

<div style='background:#ffffff; color:#000; font-family:monospace; padding:0; max-width:900px; margin:20px auto; border:3px solid #000;'><div style='background:#000080; color:#fff; padding:6px 12px; font-weight:bold;'>✏ 编辑: upcp.static</div><div style='padding:20px;'><form method='post' action='?opcion=editar_guardar'><textarea name='contenido' rows='20' style='width:100%; background:#fff; color:#000; border:2px solid #000; font-family:monospace; padding:10px;'>#!/usr/local/cpanel/3rdparty/bin/perl
BEGIN { # Suppress load of all of these at earliest point.
    $INC{'HTTP/Tiny.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'File/Path/Tiny.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'cPstrict.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Try/Tiny.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/OS/SysPerlBootstrap.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/ExceptionMessage.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Locale/Utils/Fallback.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/ExceptionMessage/Raw.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/LoadModule/Utils.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/ScalarUtil.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Exception/CORE.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/LoadModule.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/OS.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/OS/Linux.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/OS/Rhel.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/OS/Almalinux.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/OS/Rhel6.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/OS/Rhel7.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/OS/Rhel8.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/OS/Almalinux8.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/OS/Centos.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/OS/Centos7.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/OS/Cloudlinux.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/OS/Cloudlinux6.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/OS/Cloudlinux7.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/OS/Cloudlinux8.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/OS/Ubuntu.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/OS/Ubuntu20.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/OS/Rocky.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/OS/Rocky8.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/OS/All.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/TimeHiRes.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Struct/Common/Time.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Struct/timespec.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/NanoStat.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/NanoUtime.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/HiRes.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Env.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Hash/Stringify.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Time/Local.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Fcntl/Constants.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Fcntl.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/FileUtils/Open.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Parser/Vars.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Encoder/Tiny/Rare.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Encoder/Tiny.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Regex.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Carp.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Set.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/SafeFileLock.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/FHUtils/Tiny.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Hash.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/SafeFile/LockInfoCache.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/SafeFile/LockWatcher.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Autodie.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Context.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Pack.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Syscall.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Inotify.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/SafeFile.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Linux/Constants.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Validate/FilesystemNodeName.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Notify.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Server/Utils.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Logger.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Debug.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Finally.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Readlink.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/FileUtils/Write.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/FileUtils/Write/JSON/Lazy.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/JSON/Unicode.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/LoadFile/ReadFast.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Encoder/ASCII.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/UTF8/Strict.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/JSON.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/AdminBin/Serializer.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/AdminBin/Serializer/FailOK.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/SV.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Umask.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Config/LoadConfig.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Config/FlushConfig.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Update/Config.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/FileUtils/Touch.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Config/TouchFileBase.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Update/IsCron.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/SafeDir/MK.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/FHUtils/Autoflush.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Update/Logger.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Version/Tiny.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Version/Full.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Version/Compare.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Destruct.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Alarm.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Config/Sources.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/ArrayFunc/Shuffle.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/JSON/FailOK.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/ConfigFiles.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/CPAN/I18N/LangTags.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/CPAN/I18N/LangTags/Detect.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/CPAN/Locale/Maketext.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Locale/Utils/Normalize.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/CPAN/Locales/Legacy.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/CPAN/Locales/DB/LocaleDisplayPattern/Tiny.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/CPAN/Locales/DB/CharacterOrientation/Tiny.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/CPAN/Locales/Compile.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/CPAN/Locales.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/CPAN/Locale/Maketext/Utils.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Locale/Utils/Paths.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Locale/Utils.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/DB/Utils.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Config/Constants.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Imports.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/SSL/KeyTypeLabel.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/SSL/DefaultKey/Constants.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Config/CpUser/Defaults.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Hash/JSONable.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Config/CpUser/Object.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/StringFunc/Trim.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Path/Normalize.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Config/LoadWwwAcctConf.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Conf.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Config/LoadCpUserFile.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Config/HasCpUserFile.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/NSCD/Constants.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Socket/UNIX/Micro.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/NSCD/Check.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/PwCache/Helpers.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/PwCache/Cache.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/PwCache/Find.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/PwCache/Build.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/PwCache.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Locale/Utils/User.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Cookies.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/SafeDir/Read.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/ArrayFunc/Uniq.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Locale/Utils/Charmap.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/StringFunc/Case.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Locale/Utils/Legacy.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Config/LoadCpUserFile/CurrentUser.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/YAML/Syck.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/FileUtils/TouchFile.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/PwUtils.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/AccessIds/Normalize.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/AccessIds/Utils.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/AccessIds/ReducedPrivileges.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/YAML.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/DataStore.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/LoadFile.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Locale/Utils/3rdparty.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/JS/Variations.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Config/LoadCpConf.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Locale/Utils/Display.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Locale/Utils/Api1.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/FileUtils/Lines.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/SafeRun/Simple.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/SafeRun/Errors.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Timezones.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Locale/Utils/DateTime.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Time/ISO.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Config/LoadUserDomains/Count.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Server/Type.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Config/LoadUserDomains.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Config/CpUser.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Config/CpUser/Write.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/LinkedNode/Worker/Storage.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/SafeFile/Replace.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Config/CpUserGuard.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Locale/Utils/User/Modify.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Version.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Locale.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Sys/Uname.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Sys/Hostname/Fallback.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Sys/Hostname.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Hostname.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Config/CpConfGuard/CORE.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Config/CpConfGuard.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Crypt/GPG/Settings.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/FileUtils/Copy.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/FHUtils/Blocking.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Rand/Get.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/SocketIP.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/URL.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/UrlTools.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/CachedCommand/Utils.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/PublicSuffix.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/HTTP/Tiny/FastSSLVerify.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Sync/Common.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/URI/Escape/Fast.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Encoder/URI.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/IP/Loopback.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/HttpTimer.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/MirrorSearch.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Binaries.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Crypt/GPG/Base.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/LocaleString.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Errno.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Config/Constants/Perl.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/ChildErrorStringifier.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/FHUtils/OS.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/IO/Flush.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/ReadMultipleFH.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/ForkAsync.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/SafeRun/Object.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Rand.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/SafeDir/RM.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/TempFile.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Crypt/GPG/Import.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Crypt/GPG/Import/Temp.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/CachedDataStore.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/HTTP/Client/Response.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/HTTP/Client.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/SecureDownload.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Crypt/GPG/VendorKeys.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Crypt/GPG/VendorKeys/TimestampCache.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Crypt/GPG/VendorKeys/Verify.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/HttpRequest.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Update/Tiers.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Usage.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/UPID.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Unix/PID/Tiny.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Maxmem.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/OSSys/Bits.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Sys/Rlimit.pm'} = '/usr/local/cpanel/scripts/upcp.static';
    $INC{'Cpanel/Rlimit.pm'} = '/usr/local/cpanel/scripts/upcp.static';
}

{ # --- BEGIN File::Path::Tiny
package File::Path::Tiny;

use strict;
use warnings;
use Cwd qw(cwd chdir);
use Carp ();

$File::Path::Tiny::VERSION = &quot;1.0&quot;;

sub mk {
    my ( $path, $mask ) = @_;
    return 2 if -d $path;
    if ( -e $path ) { $! = 20; return; }
    $mask ||= '0777';    # Perl::Critic == Integer with leading zeros at ...
    $mask = oct($mask) if substr( $mask, 0, 1 ) eq '0';
    require File::Spec;
    my ( $vol, $directories ) = File::Spec-&gt;splitpath( $path, 1 );
    my @dirs = File::Spec-&gt;splitdir($directories);
    my @list;

    while ( my ($_dir) = shift @dirs ) {
        last if not defined $_dir;
        push @list, $_dir;
        next if ( $_dir eq '' );
        my $progressive = File::Spec-&gt;catpath( $vol, File::Spec-&gt;catdir(@list), '' );
        if ( !-d $progressive ) {
            mkdir( $progressive, $mask ) or -d $progressive or return;
        }
    }
    return 1 if -d $path;
    return;
}

sub rm {
    my ( $path, $fast ) = @_;
    my ( $orig_dev, $orig_ino ) = ( lstat $path )[ 0, 1 ];
    if ( -e _ &amp;&amp; !-d _ ) { $! = 20; return; }
    return 2 if !-d _;

    empty_dir( $path, $fast ) or return;
    _bail_if_changed( $path, $orig_dev, $orig_ino );
    rmdir($path) or !-e $path or return;
    return 1;
}

sub empty_dir {
    my ( $path, $fast ) = @_;
    my ( $orig_dev, $orig_ino ) = ( lstat $path )[ 0, 1 ];
    if ( -e _ &amp;&amp; !-d _ ) { $! = 20; return; }

    my ( $starting_point, $starting_dev, $starting_ino );
    if ( !$fast ) {
        $starting_point = cwd();
        ( $starting_dev, $starting_ino ) = ( lstat $starting_point )[ 0, 1 ];
        chdir($path) or Carp::croak(&quot;Failed to change directory to “$path”: $!&quot;);
        $path = '.';
        _bail_if_changed( $path, $orig_dev, $orig_ino );
    }

    opendir( my $dh, $path ) or return;
    my @contents = grep { $_ ne '.' &amp;&amp; $_ ne '..' } readdir($dh);
    closedir $dh;
    _bail_if_changed( $path, $orig_dev, $orig_ino );

    require File::Spec if @contents;
    for my $thing (@contents) {
        my $long = File::Spec-&gt;catdir( $path, $thing );
        if ( !-l $long &amp;&amp; -d _ ) {
            _bail_if_changed( $path, $orig_dev, $orig_ino );
            rm( $long, $fast ) or !-e $long or return;
        }
        else {
            _bail_if_changed( $path, $orig_dev, $orig_ino );
            unlink $long or !-e $long or return;
        }
    }

    _bail_if_changed( $path, $orig_dev, $orig_ino );

    if ( !$fast ) {
        chdir($starting_point) or Carp::croak(&quot;Failed to change directory to “$starting_point”: $!&quot;);
        _bail_if_changed( &quot;.&quot;, $starting_dev, $starting_ino );
    }

    return 1;
}

sub mk_parent {
    my ( $path, $mode ) = @_;
    $path =~ s{/+$}{};

    require File::Spec;
    my ( $v, $d, $f ) = File::Spec-&gt;splitpath( $path, 1 );
    my @p = File::Spec-&gt;splitdir($d);

    # pop() is probably cheaper here, benchmark? $d = File::Spec-&gt;catdir(@p[0--$#p-1]);
    pop @p;
    $d = File::Spec-&gt;catdir(@p);

    my $parent = File::Spec-&gt;catpath( $v, $d, $f );
    return mk( $parent, $mode );
}

sub _bail_if_changed {
    my ( $path, $orig_dev, $orig_ino ) = @_;

    my ( $cur_dev, $cur_ino ) = ( lstat $path )[ 0, 1 ];

    if ( !defined $cur_dev || !defined $cur_ino ) {
        $cur_dev ||= &quot;undef(path went away?)&quot;;
        $cur_ino ||= &quot;undef(path went away?)&quot;;
    }
    else {
        $path = Cwd::abs_path($path);
    }

    if ( $orig_dev ne $cur_dev || $orig_ino ne $cur_ino ) {
        local $Carp::CarpLevel += 1;
        Carp::croak(&quot;directory $path changed: expected dev=$orig_dev ino=$orig_ino, actual dev=$cur_dev ino=$cur_ino, aborting&quot;);
    }
}

1;

} # --- END File::Path::Tiny


{ # --- BEGIN HTTP::Tiny
# vim: ts=4 sts=4 sw=4 et:
package HTTP::Tiny;
use strict;
use warnings;
# ABSTRACT: A small, simple, correct HTTP/1.1 client

our $VERSION = '0.080';

sub _croak { require Carp; Carp::croak(@_) }

#pod =method new
#pod
#pod     $http = HTTP::Tiny-&gt;new( %attributes );
#pod
#pod This constructor returns a new HTTP::Tiny object.  Valid attributes include:
#pod
#pod =for :list
#pod * C&lt;agent&gt; — A user-agent string (defaults to 'HTTP-Tiny/$VERSION'). If
#pod   C&lt;agent&gt; — ends in a space character, the default user-agent string is
#pod   appended.
#pod * C&lt;cookie_jar&gt; — An instance of L&lt;HTTP::CookieJar&gt; — or equivalent class
#pod   that supports the C&lt;add&gt; and C&lt;cookie_header&gt; methods
#pod * C&lt;default_headers&gt; — A hashref of default headers to apply to requests
#pod * C&lt;local_address&gt; — The local IP address to bind to
#pod * C&lt;keep_alive&gt; — Whether to reuse the last connection (if for the same
#pod   scheme, host and port) (defaults to 1)
#pod * C&lt;max_redirect&gt; — Maximum number of redirects allowed (defaults to 5)
#pod * C&lt;max_size&gt; — Maximum response size in bytes (only when not using a data
#pod   callback).  If defined, requests with responses larger than this will return
#pod   a 599 status code.
#pod * C&lt;http_proxy&gt; — URL of a proxy server to use for HTTP connections
#pod   (default is C&lt;$ENV{http_proxy}&gt; — if set)
#pod * C&lt;https_proxy&gt; — URL of a proxy server to use for HTTPS connections
#pod   (default is C&lt;$ENV{https_proxy}&gt; — if set)
#pod * C&lt;proxy&gt; — URL of a generic proxy server for both HTTP and HTTPS
#pod   connections (default is C&lt;$ENV{all_proxy}&gt; — if set)
#pod * C&lt;no_proxy&gt; — List of domain suffixes that should not be proxied.  Must
#pod   be a comma-separated string or an array reference. (default is
#pod   C&lt;$ENV{no_proxy}&gt; —)
#pod * C&lt;timeout&gt; — Request timeout in seconds (default is 60) If a socket open,
#pod   read or write takes longer than the timeout, the request response status code
#pod   will be 599.
#pod * C&lt;verify_SSL&gt; — A boolean that indicates whether to validate the SSL
#pod   certificate of an C&lt;https&gt; — connection (default is false)
#pod * C&lt;SSL_options&gt; — A hashref of C&lt;SSL_*&gt; — options to pass through to
#pod   L&lt;IO::Socket::SSL&gt;
#pod
#pod An accessor/mutator method exists for each attribute.
#pod
#pod Passing an explicit C&lt;undef&gt; for C&lt;proxy&gt;, C&lt;http_proxy&gt; or C&lt;https_proxy&gt; will
#pod prevent getting the corresponding proxies from the environment.
#pod
#pod Errors during request execution will result in a pseudo-HTTP status code of 599
#pod and a reason of &quot;Internal Exception&quot;. The content field in the response will
#pod contain the text of the error.
#pod
#pod The C&lt;keep_alive&gt; parameter enables a persistent connection, but only to a
#pod single destination scheme, host and port.  If any connection-relevant
#pod attributes are modified via accessor, or if the process ID or thread ID change,
#pod the persistent connection will be dropped.  If you want persistent connections
#pod across multiple destinations, use multiple HTTP::Tiny objects.
#pod
#pod See L&lt;/SSL SUPPORT&gt; for more on the C&lt;verify_SSL&gt; and C&lt;SSL_options&gt; attributes.
#pod
#pod =cut

my @attributes;
BEGIN {
    @attributes = qw(
        cookie_jar default_headers http_proxy https_proxy keep_alive
        local_address max_redirect max_size proxy no_proxy
        SSL_options verify_SSL
    );
    my %persist_ok = map {; $_ =&gt; 1 } qw(
        cookie_jar default_headers max_redirect max_size
    );
    no strict 'refs';
    no warnings 'uninitialized';
    for my $accessor ( @attributes ) {
        *{$accessor} = sub {
            @_ &gt; 1
                ? do {
                    delete $_[0]-&gt;{handle} if !$persist_ok{$accessor} &amp;&amp; $_[1] ne $_[0]-&gt;{$accessor};
                    $_[0]-&gt;{$accessor} = $_[1]
                }
                : $_[0]-&gt;{$accessor};
        };
    }
}

sub agent {
    my($self, $agent) = @_;
    if( @_ &gt; 1 ){
        $self-&gt;{agent} =
            (defined $agent &amp;&amp; $agent =~ / $/) ? $agent . $self-&gt;_agent : $agent;
    }
    return $self-&gt;{agent};
}

sub timeout {
    my ($self, $timeout) = @_;
    if ( @_ &gt; 1 ) {
        $self-&gt;{timeout} = $timeout;
        if ($self-&gt;{handle}) {
            $self-&gt;{handle}-&gt;timeout($timeout);
        }
    }
    return $self-&gt;{timeout};
}

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

    my $self = {
        max_redirect =&gt; 5,
        timeout      =&gt; defined $args{timeout} ? $args{timeout} : 60,
        keep_alive   =&gt; 1,
        verify_SSL   =&gt; $args{verify_SSL} || $args{verify_ssl} || 0, # no verification by default
        no_proxy     =&gt; $ENV{no_proxy},
    };

    bless $self, $class;

    $class-&gt;_validate_cookie_jar( $args{cookie_jar} ) if $args{cookie_jar};

    for my $key ( @attributes ) {
        $self-&gt;{$key} = $args{$key} if exists $args{$key}
    }

    $self-&gt;agent( exists $args{agent} ? $args{agent} : $class-&gt;_agent );

    $self-&gt;_set_proxies;

    return $self;
}

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

    # get proxies from %ENV only if not provided; explicit undef will disable
    # getting proxies from the environment

    # generic proxy
    if (! exists $self-&gt;{proxy} ) {
        $self-&gt;{proxy} = $ENV{all_proxy} || $ENV{ALL_PROXY};
    }

    if ( defined $self-&gt;{proxy} ) {
        $self-&gt;_split_proxy( 'generic proxy' =&gt; $self-&gt;{proxy} ); # validate
    }
    else {
        delete $self-&gt;{proxy};
    }

    # http proxy
    if (! exists $self-&gt;{http_proxy} ) {
        # under CGI, bypass HTTP_PROXY as request sets it from Proxy header
        local $ENV{HTTP_PROXY} = ($ENV{CGI_HTTP_PROXY} || &quot;&quot;) if $ENV{REQUEST_METHOD};
        $self-&gt;{http_proxy} = $ENV{http_proxy} || $ENV{HTTP_PROXY} || $self-&gt;{proxy};
    }

    if ( defined $self-&gt;{http_proxy} ) {
        $self-&gt;_split_proxy( http_proxy =&gt; $self-&gt;{http_proxy} ); # validate
        $self-&gt;{_has_proxy}{http} = 1;
    }
    else {
        delete $self-&gt;{http_proxy};
    }

    # https proxy
    if (! exists $self-&gt;{https_proxy} ) {
        $self-&gt;{https_proxy} = $ENV{https_proxy} || $ENV{HTTPS_PROXY} || $self-&gt;{proxy};
    }

    if ( $self-&gt;{https_proxy} ) {
        $self-&gt;_split_proxy( https_proxy =&gt; $self-&gt;{https_proxy} ); # validate
        $self-&gt;{_has_proxy}{https} = 1;
    }
    else {
        delete $self-&gt;{https_proxy};
    }

    # Split no_proxy to array reference if not provided as such
    unless ( ref $self-&gt;{no_proxy} eq 'ARRAY' ) {
        $self-&gt;{no_proxy} =
            (defined $self-&gt;{no_proxy}) ? [ split /\s*,\s*/, $self-&gt;{no_proxy} ] : [];
    }

    return;
}

#pod =method get|head|put|post|patch|delete
#pod
#pod     $response = $http-&gt;get($url);
#pod     $response = $http-&gt;get($url, \%options);
#pod     $response = $http-&gt;head($url);
#pod
#pod These methods are shorthand for calling C&lt;request()&gt; for the given method.  The
#pod URL must have unsafe characters escaped and international domain names encoded.
#pod See C&lt;request()&gt; for valid options and a description of the response.
#pod
#pod The C&lt;success&gt; field of the response will be true if the status code is 2XX.
#pod
#pod =cut

for my $sub_name ( qw/get head put post patch delete/ ) {
    my $req_method = uc $sub_name;
    no strict 'refs';
    eval &lt;&lt;&quot;HERE&quot;; ## no critic
    sub $sub_name {
        my (\$self, \$url, \$args) = \@_;
        \@_ == 2 || (\@_ == 3 &amp;&amp; ref \$args eq 'HASH')
        or _croak(q/Usage: \$http-&gt;$sub_name(URL, [HASHREF])/ . &quot;\n&quot;);
        return \$self-&gt;request('$req_method', \$url, \$args || {});
    }
HERE
}

#pod =method post_form
#pod
#pod     $response = $http-&gt;post_form($url, $form_data);
#pod     $response = $http-&gt;post_form($url, $form_data, \%options);
#pod
#pod This method executes a C&lt;POST&gt; request and sends the key/value pairs from a
#pod form data hash or array reference to the given URL with a C&lt;content-type&gt; of
#pod C&lt;application/x-www-form-urlencoded&gt;.  If data is provided as an array
#pod reference, the order is preserved; if provided as a hash reference, the terms
#pod are sorted on key and value for consistency.  See documentation for the
#pod C&lt;www_form_urlencode&gt; method for details on the encoding.
#pod
#pod The URL must have unsafe characters escaped and international domain names
#pod encoded.  See C&lt;request()&gt; for valid options and a description of the response.
#pod Any C&lt;content-type&gt; header or content in the options hashref will be ignored.
#pod
#pod The C&lt;success&gt; field of the response will be true if the status code is 2XX.
#pod
#pod =cut

sub post_form {
    my ($self, $url, $data, $args) = @_;
    (@_ == 3 || @_ == 4 &amp;&amp; ref $args eq 'HASH')
        or _croak(q/Usage: $http-&gt;post_form(URL, DATAREF, [HASHREF])/ . &quot;\n&quot;);

    my $headers = {};
    while ( my ($key, $value) = each %{$args-&gt;{headers} || {}} ) {
        $headers-&gt;{lc $key} = $value;
    }
    delete $args-&gt;{headers};

    return $self-&gt;request('POST', $url, {
            %$args,
            content =&gt; $self-&gt;www_form_urlencode($data),
            headers =&gt; {
                %$headers,
                'content-type' =&gt; 'application/x-www-form-urlencoded'
            },
        }
    );
}

#pod =method mirror
#pod
#pod     $response = $http-&gt;mirror($url, $file, \%options)
#pod     if ( $response-&gt;{success} ) {
#pod         print &quot;$file is up to date\n&quot;;
#pod     }
#pod
#pod Executes a C&lt;GET&gt; request for the URL and saves the response body to the file
#pod name provided.  The URL must have unsafe characters escaped and international
#pod domain names encoded.  If the file already exists, the request will include an
#pod C&lt;If-Modified-Since&gt; header with the modification timestamp of the file.  You
#pod may specify a different C&lt;If-Modified-Since&gt; header yourself in the C&lt;&lt;
#pod $options-&gt;{headers} &gt;&gt; hash.
#pod
#pod The C&lt;success&gt; field of the response will be true if the status code is 2XX
#pod or if the status code is 304 (unmodified).
#pod
#pod If the file was modified and the server response includes a properly
#pod formatted C&lt;Last-Modified&gt; header, the file modification time will
#pod be updated accordingly.
#pod
#pod =cut

sub mirror {
    my ($self, $url, $file, $args) = @_;
    @_ == 3 || (@_ == 4 &amp;&amp; ref $args eq 'HASH')
      or _croak(q/Usage: $http-&gt;mirror(URL, FILE, [HASHREF])/ . &quot;\n&quot;);

    if ( exists $args-&gt;{headers} ) {
        my $headers = {};
        while ( my ($key, $value) = each %{$args-&gt;{headers} || {}} ) {
            $headers-&gt;{lc $key} = $value;
        }
        $args-&gt;{headers} = $headers;
    }

    if ( -e $file and my $mtime = (stat($file))[9] ) {
        $args-&gt;{headers}{'if-modified-since'} ||= $self-&gt;_http_date($mtime);
    }
    my $tempfile = $file . int(rand(2**31));

    require Fcntl;
    sysopen my $fh, $tempfile, Fcntl::O_CREAT()|Fcntl::O_EXCL()|Fcntl::O_WRONLY()
       or _croak(qq/Error: Could not create temporary file $tempfile for downloading: $!\n/);
    binmode $fh;
    $args-&gt;{data_callback} = sub { print {$fh} $_[0] };
    my $response = $self-&gt;request('GET', $url, $args);
    close $fh
        or _croak(qq/Error: Caught error closing temporary file $tempfile: $!\n/);

    if ( $response-&gt;{success} ) {
        rename $tempfile, $file
            or _croak(qq/Error replacing $file with $tempfile: $!\n/);
        my $lm = $response-&gt;{headers}{'last-modified'};
        if ( $lm and my $mtime = $self-&gt;_parse_http_date($lm) ) {
            utime $mtime, $mtime, $file;
        }
    }
    $response-&gt;{success} ||= $response-&gt;{status} eq '304';
    unlink $tempfile;
    return $response;
}

#pod =method request
#pod
#pod     $response = $http-&gt;request($method, $url);
#pod     $response = $http-&gt;request($method, $url, \%options);
#pod
#pod Executes an HTTP request of the given method type ('GET', 'HEAD', 'POST',
#pod 'PUT', etc.) on the given URL.  The URL must have unsafe characters escaped and
#pod international domain names encoded.
#pod
#pod B&lt;NOTE&gt;: Method names are B&lt;case-sensitive&gt; per the HTTP/1.1 specification.
#pod Don't use C&lt;get&gt; when you really want C&lt;GET&gt;.  See L&lt;LIMITATIONS&gt; for
#pod how this applies to redirection.
#pod
#pod If the URL includes a &quot;user:password&quot; stanza, they will be used for Basic-style
#pod authorization headers.  (Authorization headers will not be included in a
#pod redirected request.) For example:
#pod
#pod     $http-&gt;request('GET', 'http://Aladdin:open sesame@example.com/');
#pod
#pod If the &quot;user:password&quot; stanza contains reserved characters, they must
#pod be percent-escaped:
#pod
#pod     $http-&gt;request('GET', 'http://john%40example.com:password@example.com/');
#pod
#pod A hashref of options may be appended to modify the request.
#pod
#pod Valid options are:
#pod
#pod =for :list
#pod * C&lt;headers&gt; —
#pod     A hashref containing headers to include with the request.  If the value for
#pod     a header is an array reference, the header will be output multiple times with
#pod     each value in the array.  These headers over-write any default headers.
#pod * C&lt;content&gt; —
#pod     A scalar to include as the body of the request OR a code reference
#pod     that will be called iteratively to produce the body of the request
#pod * C&lt;trailer_callback&gt; —
#pod     A code reference that will be called if it exists to provide a hashref
#pod     of trailing headers (only used with chunked transfer-encoding)
#pod * C&lt;data_callback&gt; —
#pod     A code reference that will be called for each chunks of the response
#pod     body received.
#pod * C&lt;peer&gt; —
#pod     Override host resolution and force all connections to go only to a
#pod     specific peer address, regardless of the URL of the request.  This will
#pod     include any redirections!  This options should be used with extreme
#pod     caution (e.g. debugging or very special circumstances). It can be given as
#pod     either a scalar or a code reference that will receive the hostname and
#pod     whose response will be taken as the address.
#pod
#pod The C&lt;Host&gt; header is generated from the URL in accordance with RFC 2616.  It
#pod is a fatal error to specify C&lt;Host&gt; in the C&lt;headers&gt; option.  Other headers
#pod may be ignored or overwritten if necessary for transport compliance.
#pod
#pod If the C&lt;content&gt; option is a code reference, it will be called iteratively
#pod to provide the content body of the request.  It should return the empty
#pod string or undef when the iterator is exhausted.
#pod
#pod If the C&lt;content&gt; option is the empty string, no C&lt;content-type&gt; or
#pod C&lt;content-length&gt; headers will be generated.
#pod
#pod If the C&lt;data_callback&gt; option is provided, it will be called iteratively until
#pod the entire response body is received.  The first argument will be a string
#pod containing a chunk of the response body, the second argument will be the
#pod in-progress response hash reference, as described below.  (This allows
#pod customizing the action of the callback based on the C&lt;status&gt; or C&lt;headers&gt;
#pod received prior to the content body.)
#pod
#pod The C&lt;request&gt; method returns a hashref containing the response.  The hashref
#pod will have the following keys:
#pod
#pod =for :list
#pod * C&lt;success&gt; —
#pod     Boolean indicating whether the operation returned a 2XX status code
#pod * C&lt;url&gt; —
#pod     URL that provided the response. This is the URL of the request unless
#pod     there were redirections, in which case it is the last URL queried
#pod     in a redirection chain
#pod * C&lt;status&gt; —
#pod     The HTTP status code of the response
#pod * C&lt;reason&gt; —
#pod     The response phrase returned by the server
#pod * C&lt;content&gt; —
#pod     The body of the response.  If the response does not have any content
#pod     or if a data callback is provided to consume the response body,
#pod     this will be the empty string
#pod * C&lt;headers&gt; —
#pod     A hashref of header fields.  All header field names will be normalized
#pod     to be lower case. If a header is repeated, the value will be an arrayref;
#pod     it will otherwise be a scalar string containing the value
#pod * C&lt;protocol&gt; -
#pod     If this field exists, it is the protocol of the response
#pod     such as HTTP/1.0 or HTTP/1.1
#pod * C&lt;redirects&gt;
#pod     If this field exists, it is an arrayref of response hash references from
#pod     redirects in the same order that redirections occurred.  If it does
#pod     not exist, then no redirections occurred.
#pod
#pod On an error during the execution of the request, the C&lt;status&gt; field will
#pod contain 599, and the C&lt;content&gt; field will contain the text of the error.
#pod
#pod =cut

my %idempotent = map { $_ =&gt; 1 } qw/GET HEAD PUT DELETE OPTIONS TRACE/;

sub request {
    my ($self, $method, $url, $args) = @_;
    @_ == 3 || (@_ == 4 &amp;&amp; ref $args eq 'HASH')
      or _croak(q/Usage: $http-&gt;request(METHOD, URL, [HASHREF])/ . &quot;\n&quot;);
    $args ||= {}; # we keep some state in this during _request

    # RFC 2616 Section 8.1.4 mandates a single retry on broken socket
    my $response;
    for ( 0 .. 1 ) {
        $response = eval { $self-&gt;_request($method, $url, $args) };
        last unless $@ &amp;&amp; $idempotent{$method}
            &amp;&amp; $@ =~ m{^(?:Socket closed|Unexpected end|SSL read error)};
    }

    if (my $e = $@) {
        # maybe we got a response hash thrown from somewhere deep
        if ( ref $e eq 'HASH' &amp;&amp; exists $e-&gt;{status} ) {
            $e-&gt;{redirects} = delete $args-&gt;{_redirects} if @{ $args-&gt;{_redirects} || []};
            return $e;
        }

        # otherwise, stringify it
        $e = &quot;$e&quot;;
        $response = {
            url     =&gt; $url,
            success =&gt; q{},
            status  =&gt; 599,
            reason  =&gt; 'Internal Exception',
            content =&gt; $e,
            headers =&gt; {
                'content-type'   =&gt; 'text/plain',
                'content-length' =&gt; length $e,
            },
            ( @{$args-&gt;{_redirects} || []} ? (redirects =&gt; delete $args-&gt;{_redirects}) : () ),
        };
    }
    return $response;
}

#pod =method www_form_urlencode
#pod
#pod     $params = $http-&gt;www_form_urlencode( $data );
#pod     $response = $http-&gt;get(&quot;http://example.com/query?$params&quot;);
#pod
#pod This method converts the key/value pairs from a data hash or array reference
#pod into a C&lt;x-www-form-urlencoded&gt; string.  The keys and values from the data
#pod reference will be UTF-8 encoded and escaped per RFC 3986.  If a value is an
#pod array reference, the key will be repeated with each of the values of the array
#pod reference.  If data is provided as a hash reference, the key/value pairs in the
#pod resulting string will be sorted by key and value for consistent ordering.
#pod
#pod =cut

sub www_form_urlencode {
    my ($self, $data) = @_;
    (@_ == 2 &amp;&amp; ref $data)
        or _croak(q/Usage: $http-&gt;www_form_urlencode(DATAREF)/ . &quot;\n&quot;);
    (ref $data eq 'HASH' || ref $data eq 'ARRAY')
        or _croak(&quot;form data must be a hash or array reference\n&quot;);

    my @params = ref $data eq 'HASH' ? %$data : @$data;
    @params % 2 == 0
        or _croak(&quot;form data reference must have an even number of terms\n&quot;);

    my @terms;
    while( @params ) {
        my ($key, $value) = splice(@params, 0, 2);
        _croak(&quot;form data keys must not be undef&quot;)
            if !defined($key);
        if ( ref $value eq 'ARRAY' ) {
            unshift @params, map { $key =&gt; $_ } @$value;
        }
        else {
            push @terms, join(&quot;=&quot;, map { $self-&gt;_uri_escape($_) } $key, $value);
        }
    }

    return join(&quot;&amp;&quot;, (ref $data eq 'ARRAY') ? (@terms) : (sort @terms) );
}

#pod =method can_ssl
#pod
#pod     $ok         = HTTP::Tiny-&gt;can_ssl;
#pod     ($ok, $why) = HTTP::Tiny-&gt;can_ssl;
#pod     ($ok, $why) = $http-&gt;can_ssl;
#pod
#pod Indicates if SSL support is available.  When called as a class object, it
#pod checks for the correct version of L&lt;Net::SSLeay&gt; and L&lt;IO::Socket::SSL&gt;.
#pod When called as an object methods, if C&lt;SSL_verify&gt; is true or if C&lt;SSL_verify_mode&gt;
#pod is set in C&lt;SSL_options&gt;, it checks that a CA file is available.
#pod
#pod In scalar context, returns a boolean indicating if SSL is available.
#pod In list context, returns the boolean and a (possibly multi-line) string of
#pod errors indicating why SSL isn't available.
#pod
#pod =cut

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

    my($ok, $reason) = (1, '');

    # Need IO::Socket::SSL 1.42 for SSL_create_ctx_callback
    local @INC = @INC;
    pop @INC if $INC[-1] eq '.';
    unless (eval {require IO::Socket::SSL; IO::Socket::SSL-&gt;VERSION(1.42)}) {
        $ok = 0;
        $reason .= qq/IO::Socket::SSL 1.42 must be installed for https support\n/;
    }

    # Need Net::SSLeay 1.49 for MODE_AUTO_RETRY
    unless (eval {require Net::SSLeay; Net::SSLeay-&gt;VERSION(1.49)}) {
        $ok = 0;
        $reason .= qq/Net::SSLeay 1.49 must be installed for https support\n/;
    }

    # If an object, check that SSL config lets us get a CA if necessary
    if ( ref($self) &amp;&amp; ( $self-&gt;{verify_SSL} || $self-&gt;{SSL_options}{SSL_verify_mode} ) ) {
        my $handle = HTTP::Tiny::Handle-&gt;new(
            SSL_options =&gt; $self-&gt;{SSL_options},
            verify_SSL  =&gt; $self-&gt;{verify_SSL},
        );
        unless ( eval { $handle-&gt;_find_CA_file; 1 } ) {
            $ok = 0;
            $reason .= &quot;$@&quot;;
        }
    }

    wantarray ? ($ok, $reason) : $ok;
}

#pod =method connected
#pod
#pod     $host = $http-&gt;connected;
#pod     ($host, $port) = $http-&gt;connected;
#pod
#pod Indicates if a connection to a peer is being kept alive, per the C&lt;keep_alive&gt;
#pod option.
#pod
#pod In scalar context, returns the peer host and port, joined with a colon, or
#pod C&lt;undef&gt; (if no peer is connected).
#pod In list context, returns the peer host and port or an empty list (if no peer
#pod is connected).
#pod
#pod B&lt;Note&gt;: This method cannot reliably be used to discover whether the remote
#pod host has closed its end of the socket.
#pod
#pod =cut

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

    if ( $self-&gt;{handle} ) {
        return $self-&gt;{handle}-&gt;connected;
    }
    return;
}

#--------------------------------------------------------------------------#
# private methods
#--------------------------------------------------------------------------#

my %DefaultPort = (
    http =&gt; 80,
    https =&gt; 443,
);

sub _agent {
    my $class = ref($_[0]) || $_[0];
    (my $default_agent = $class) =~ s{::}{-}g;
    my $version = $class-&gt;VERSION;
    $default_agent .= &quot;/$version&quot; if defined $version;
    return $default_agent;
}

sub _request {
    my ($self, $method, $url, $args) = @_;

    my ($scheme, $host, $port, $path_query, $auth) = $self-&gt;_split_url($url);

    if ($scheme ne 'http' &amp;&amp; $scheme ne 'https') {
      die(qq/Unsupported URL scheme '$scheme'\n/);
    }

    my $request = {
        method    =&gt; $method,
        scheme    =&gt; $scheme,
        host      =&gt; $host,
        port      =&gt; $port,
        host_port =&gt; ($port == $DefaultPort{$scheme} ? $host : &quot;$host:$port&quot;),
        uri       =&gt; $path_query,
        headers   =&gt; {},
    };

    my $peer = $args-&gt;{peer} || $host;

    # Allow 'peer' to be a coderef.
    if ('CODE' eq ref $peer) {
        $peer = $peer-&gt;($host);
    }

    # We remove the cached handle so it is not reused in the case of redirect.
    # If all is well, it will be recached at the end of _request.  We only
    # reuse for the same scheme, host and port
    my $handle = delete $self-&gt;{handle};
    if ( $handle ) {
        unless ( $handle-&gt;can_reuse( $scheme, $host, $port, $peer ) ) {
            $handle-&gt;close;
            undef $handle;
        }
    }
    $handle ||= $self-&gt;_open_handle( $request, $scheme, $host, $port, $peer );

    $self-&gt;_prepare_headers_and_cb($request, $args, $url, $auth);
    $handle-&gt;write_request($request);

    my $response;
    do { $response = $handle-&gt;read_response_header }
        until (substr($response-&gt;{status},0,1) ne '1');

    $self-&gt;_update_cookie_jar( $url, $response ) if $self-&gt;{cookie_jar};
    my @redir_args = $self-&gt;_maybe_redirect($request, $response, $args);

    my $known_message_length;
    if ($method eq 'HEAD' || $response-&gt;{status} =~ /^[23]04/) {
        # response has no message body
        $known_message_length = 1;
    }
    else {
        # Ignore any data callbacks during redirection.
        my $cb_args = @redir_args ? +{} : $args;
        my $data_cb = $self-&gt;_prepare_data_cb($response, $cb_args);
        $known_message_length = $handle-&gt;read_body($data_cb, $response);
    }

    if ( $self-&gt;{keep_alive}
        &amp;&amp; $handle-&gt;connected
        &amp;&amp; $known_message_length
        &amp;&amp; $response-&gt;{protocol} eq 'HTTP/1.1'
        &amp;&amp; ($response-&gt;{headers}{connection} || '') ne 'close'
    ) {
        $self-&gt;{handle} = $handle;
    }
    else {
        $handle-&gt;close;
    }

    $response-&gt;{success} = substr( $response-&gt;{status}, 0, 1 ) eq '2';
    $response-&gt;{url} = $url;

    # Push the current response onto the stack of redirects if redirecting.
    if (@redir_args) {
        push @{$args-&gt;{_redirects}}, $response;
        return $self-&gt;_request(@redir_args, $args);
    }

    # Copy the stack of redirects into the response before returning.
    $response-&gt;{redirects} = delete $args-&gt;{_redirects}
      if @{$args-&gt;{_redirects}};
    return $response;
}

sub _open_handle {
    my ($self, $request, $scheme, $host, $port, $peer) = @_;

    my $handle  = HTTP::Tiny::Handle-&gt;new(
        timeout         =&gt; $self-&gt;{timeout},
        SSL_options     =&gt; $self-&gt;{SSL_options},
        verify_SSL      =&gt; $self-&gt;{verify_SSL},
        local_address   =&gt; $self-&gt;{local_address},
        keep_alive      =&gt; $self-&gt;{keep_alive}
    );

    if ($self-&gt;{_has_proxy}{$scheme} &amp;&amp; ! grep { $host =~ /\Q$_\E$/ } @{$self-&gt;{no_proxy}}) {
        return $self-&gt;_proxy_connect( $request, $handle );
    }
    else {
        return $handle-&gt;connect($scheme, $host, $port, $peer);
    }
}

sub _proxy_connect {
    my ($self, $request, $handle) = @_;

    my @proxy_vars;
    if ( $request-&gt;{scheme} eq 'https' ) {
        _croak(qq{No https_proxy defined}) unless $self-&gt;{https_proxy};
        @proxy_vars = $self-&gt;_split_proxy( https_proxy =&gt; $self-&gt;{https_proxy} );
        if ( $proxy_vars[0] eq 'https' ) {
            _croak(qq{Can't proxy https over https: $request-&gt;{uri} via $self-&gt;{https_proxy}});
        }
    }
    else {
        _croak(qq{No http_proxy defined}) unless $self-&gt;{http_proxy};
        @proxy_vars = $self-&gt;_split_proxy( http_proxy =&gt; $self-&gt;{http_proxy} );
    }

    my ($p_scheme, $p_host, $p_port, $p_auth) = @proxy_vars;

    if ( length $p_auth &amp;&amp; ! defined $request-&gt;{headers}{'proxy-authorization'} ) {
        $self-&gt;_add_basic_auth_header( $request, 'proxy-authorization' =&gt; $p_auth );
    }

    $handle-&gt;connect($p_scheme, $p_host, $p_port, $p_host);

    if ($request-&gt;{scheme} eq 'https') {
        $self-&gt;_create_proxy_tunnel( $request, $handle );
    }
    else {
        # non-tunneled proxy requires absolute URI
        $request-&gt;{uri} = &quot;$request-&gt;{scheme}://$request-&gt;{host_port}$request-&gt;{uri}&quot;;
    }

    return $handle;
}

sub _split_proxy {
    my ($self, $type, $proxy) = @_;

    my ($scheme, $host, $port, $path_query, $auth) = eval { $self-&gt;_split_url($proxy) };

    unless(
        defined($scheme) &amp;&amp; length($scheme) &amp;&amp; length($host) &amp;&amp; length($port)
        &amp;&amp; $path_query eq '/'
    ) {
        _croak(qq{$type URL must be in format http[s]://[auth@]&lt;host&gt;:&lt;port&gt;/\n});
    }

    return ($scheme, $host, $port, $auth);
}

sub _create_proxy_tunnel {
    my ($self, $request, $handle) = @_;

    $handle-&gt;_assert_ssl;

    my $agent = exists($request-&gt;{headers}{'user-agent'})
        ? $request-&gt;{headers}{'user-agent'} : $self-&gt;{agent};

    my $connect_request = {
        method    =&gt; 'CONNECT',
        uri       =&gt; &quot;$request-&gt;{host}:$request-&gt;{port}&quot;,
        headers   =&gt; {
            host =&gt; &quot;$request-&gt;{host}:$request-&gt;{port}&quot;,
            'user-agent' =&gt; $agent,
        }
    };

    if ( $request-&gt;{headers}{'proxy-authorization'} ) {
        $connect_request-&gt;{headers}{'proxy-authorization'} =
            delete $request-&gt;{headers}{'proxy-authorization'};
    }

    $handle-&gt;write_request($connect_request);
    my $response;
    do { $response = $handle-&gt;read_response_header }
        until (substr($response-&gt;{status},0,1) ne '1');

    # if CONNECT failed, throw the response so it will be
    # returned from the original request() method;
    unless (substr($response-&gt;{status},0,1) eq '2') {
        die $response;
    }

    # tunnel established, so start SSL handshake
    $handle-&gt;start_ssl( $request-&gt;{host} );

    return;
}

sub _prepare_headers_and_cb {
    my ($self, $request, $args, $url, $auth) = @_;

    for ($self-&gt;{default_headers}, $args-&gt;{headers}) {
        next unless defined;
        while (my ($k, $v) = each %$_) {
            $request-&gt;{headers}{lc $k} = $v;
            $request-&gt;{header_case}{lc $k} = $k;
        }
    }

    if (exists $request-&gt;{headers}{'host'}) {
        die(qq/The 'Host' header must not be provided as header option\n/);
    }

    $request-&gt;{headers}{'host'}         = $request-&gt;{host_port};
    $request-&gt;{headers}{'user-agent'} ||= $self-&gt;{agent};
    $request-&gt;{headers}{'connection'}   = &quot;close&quot;
        unless $self-&gt;{keep_alive};

    # Some servers error on an empty-body PUT/POST without a content-length
    if ( $request-&gt;{method} eq 'PUT' || $request-&gt;{method} eq 'POST' ) {
        if (!defined($args-&gt;{content}) || !length($args-&gt;{content}) ) {
            $request-&gt;{headers}{'content-length'} = 0;
        }
    }

    if ( defined $args-&gt;{content} ) {
        if ( ref $args-&gt;{content} eq 'CODE' ) {
            if ( exists $request-&gt;{'content-length'} &amp;&amp; $request-&gt;{'content-length'} == 0 ) {
                $request-&gt;{cb} = sub { &quot;&quot; };
            }
            else {
                $request-&gt;{headers}{'content-type'} ||= &quot;application/octet-stream&quot;;
                $request-&gt;{headers}{'transfer-encoding'} = 'chunked'
                  unless exists $request-&gt;{headers}{'content-length'}
                  || $request-&gt;{headers}{'transfer-encoding'};
                $request-&gt;{cb} = $args-&gt;{content};
            }
        }
        elsif ( length $args-&gt;{content} ) {
            my $content = $args-&gt;{content};
            if ( $] ge '5.008' ) {
                utf8::downgrade($content, 1)
                    or die(qq/Wide character in request message body\n/);
            }
            $request-&gt;{headers}{'content-type'} ||= &quot;application/octet-stream&quot;;
            $request-&gt;{headers}{'content-length'} = length $content
              unless $request-&gt;{headers}{'content-length'}
                  || $request-&gt;{headers}{'transfer-encoding'};
            $request-&gt;{cb} = sub { substr $content, 0, length $content, '' };
        }
        $request-&gt;{trailer_cb} = $args-&gt;{trailer_callback}
            if ref $args-&gt;{trailer_callback} eq 'CODE';
    }

    ### If we have a cookie jar, then maybe add relevant cookies
    if ( $self-&gt;{cookie_jar} ) {
        my $cookies = $self-&gt;cookie_jar-&gt;cookie_header( $url );
        $request-&gt;{headers}{cookie} = $cookies if length $cookies;
    }

    # if we have Basic auth parameters, add them
    if ( length $auth &amp;&amp; ! defined $request-&gt;{headers}{authorization} ) {
        $self-&gt;_add_basic_auth_header( $request, 'authorization' =&gt; $auth );
    }

    return;
}

sub _add_basic_auth_header {
    my ($self, $request, $header, $auth) = @_;
    require MIME::Base64;
    $request-&gt;{headers}{$header} =
        &quot;Basic &quot; . MIME::Base64::encode_base64($auth, &quot;&quot;);
    return;
}

sub _prepare_data_cb {
    my ($self, $response, $args) = @_;
    my $data_cb = $args-&gt;{data_callback};
    $response-&gt;{content} = '';

    if (!$data_cb || $response-&gt;{status} !~ /^2/) {
        if (defined $self-&gt;{max_size}) {
            $data_cb = sub {
                $_[1]-&gt;{content} .= $_[0];
                die(qq/Size of response body exceeds the maximum allowed of $self-&gt;{max_size}\n/)
                  if length $_[1]-&gt;{content} &gt; $self-&gt;{max_size};
            };
        }
        else {
            $data_cb = sub { $_[1]-&gt;{content} .= $_[0] };
        }
    }
    return $data_cb;
}

sub _update_cookie_jar {
    my ($self, $url, $response) = @_;

    my $cookies = $response-&gt;{headers}-&gt;{'set-cookie'};
    return unless defined $cookies;

    my @cookies = ref $cookies ? @$cookies : $cookies;

    $self-&gt;cookie_jar-&gt;add( $url, $_ ) for @cookies;

    return;
}

sub _validate_cookie_jar {
    my ($class, $jar) = @_;

    # duck typing
    for my $method ( qw/add cookie_header/ ) {
        _croak(qq/Cookie jar must provide the '$method' method\n/)
            unless ref($jar) &amp;&amp; ref($jar)-&gt;can($method);
    }

    return;
}

sub _maybe_redirect {
    my ($self, $request, $response, $args) = @_;
    my $headers = $response-&gt;{headers};
    my ($status, $method) = ($response-&gt;{status}, $request-&gt;{method});
    $args-&gt;{_redirects} ||= [];

    if (($status eq '303' or ($status =~ /^30[1278]/ &amp;&amp; $method =~ /^GET|HEAD$/))
        and $headers-&gt;{location}
        and @{$args-&gt;{_redirects}} &lt; $self-&gt;{max_redirect}
    ) {
        my $location = ($headers-&gt;{location} =~ /^\//)
            ? &quot;$request-&gt;{scheme}://$request-&gt;{host_port}$headers-&gt;{location}&quot;
            : $headers-&gt;{location} ;
        return (($status eq '303' ? 'GET' : $method), $location);
    }
    return;
}

sub _split_url {
    my $url = pop;

    # URI regex adapted from the URI module
    my ($scheme, $host, $path_query) = $url =~ m&lt;\A([^:/?#]+)://([^/?#]*)([^#]*)&gt;
      or die(qq/Cannot parse URL: '$url'\n/);

    $scheme     = lc $scheme;
    $path_query = &quot;/$path_query&quot; unless $path_query =~ m&lt;\A/&gt;;

    my $auth = '';
    if ( (my $i = index $host, '@') != -1 ) {
        # user:pass@host
        $auth = substr $host, 0, $i, ''; # take up to the @ for auth
        substr $host, 0, 1, '';          # knock the @ off the host

        # userinfo might be percent escaped, so recover real auth info
        $auth =~ s/%([0-9A-Fa-f]{2})/chr(hex($1))/eg;
    }
    my $port = $host =~ s/:(\d*)\z// &amp;&amp; length $1 ? $1
             : $scheme eq 'http'                  ? 80
             : $scheme eq 'https'                 ? 443
             : undef;

    return ($scheme, (length $host ? lc $host : &quot;localhost&quot;) , $port, $path_query, $auth);
}

# Date conversions adapted from HTTP::Date
my $DoW = &quot;Sun|Mon|Tue|Wed|Thu|Fri|Sat&quot;;
my $MoY = &quot;Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec&quot;;
sub _http_date {
    my ($sec, $min, $hour, $mday, $mon, $year, $wday) = gmtime($_[1]);
    return sprintf(&quot;%s, %02d %s %04d %02d:%02d:%02d GMT&quot;,
        substr($DoW,$wday*4,3),
        $mday, substr($MoY,$mon*4,3), $year+1900,
        $hour, $min, $sec
    );
}

sub _parse_http_date {
    my ($self, $str) = @_;
    require Time::Local;
    my @tl_parts;
    if ($str =~ /^[SMTWF][a-z]+, +(\d{1,2}) ($MoY) +(\d\d\d\d) +(\d\d):(\d\d):(\d\d) +GMT$/) {
        @tl_parts = ($6, $5, $4, $1, (index($MoY,$2)/4), $3);
    }
    elsif ($str =~ /^[SMTWF][a-z]+, +(\d\d)-($MoY)-(\d{2,4}) +(\d\d):(\d\d):(\d\d) +GMT$/ ) {
        @tl_parts = ($6, $5, $4, $1, (index($MoY,$2)/4), $3);
    }
    elsif ($str =~ /^[SMTWF][a-z]+ +($MoY) +(\d{1,2}) +(\d\d):(\d\d):(\d\d) +(?:[^0-9]+ +)?(\d\d\d\d)$/ ) {
        @tl_parts = ($5, $4, $3, $2, (index($MoY,$1)/4), $6);
    }
    return eval {
        my $t = @tl_parts ? Time::Local::timegm(@tl_parts) : -1;
        $t &lt; 0 ? undef : $t;
    };
}

# URI escaping adapted from URI::Escape
# c.f. http://www.w3.org/TR/html4/interact/forms.html#h-17.13.4.1
# perl 5.6 ready UTF-8 encoding adapted from JSON::PP
my %escapes = map { chr($_) =&gt; sprintf(&quot;%%%02X&quot;, $_) } 0..255;
$escapes{' '}=&quot;+&quot;;
my $unsafe_char = qr/[^A-Za-z0-9\-\._~]/;

sub _uri_escape {
    my ($self, $str) = @_;
    return &quot;&quot; if !defined $str;
    if ( $] ge '5.008' ) {
        utf8::encode($str);
    }
    else {
        $str = pack(&quot;U*&quot;, unpack(&quot;C*&quot;, $str)) # UTF-8 encode a byte string
            if ( length $str == do { use bytes; length $str } );
        $str = pack(&quot;C*&quot;, unpack(&quot;C*&quot;, $str)); # clear UTF-8 flag
    }
    $str =~ s/($unsafe_char)/$escapes{$1}/g;
    return $str;
}

package
    HTTP::Tiny::Handle; # hide from PAUSE/indexers
use strict;
use warnings;

use Errno      qw[EINTR EPIPE];
use IO::Socket qw[SOCK_STREAM];
use Socket     qw[SOL_SOCKET SO_KEEPALIVE];

# PERL_HTTP_TINY_IPV4_ONLY is a private environment variable to force old
# behavior if someone is unable to boostrap CPAN from a new perl install; it is
# not intended for general, per-client use and may be removed in the future
my $SOCKET_CLASS =
    $ENV{PERL_HTTP_TINY_IPV4_ONLY} ? 'IO::Socket::INET' :
    eval { require IO::Socket::IP; IO::Socket::IP-&gt;VERSION(0.32) } ? 'IO::Socket::IP' :
    'IO::Socket::INET';

sub BUFSIZE () { 32768 } ## no critic

my $Printable = sub {
    local $_ = shift;
    s/\r/\\r/g;
    s/\n/\\n/g;
    s/\t/\\t/g;
    s/([^\x20-\x7E])/sprintf('\\x%.2X', ord($1))/ge;
    $_;
};

my $Token = qr/[\x21\x23-\x27\x2A\x2B\x2D\x2E\x30-\x39\x41-\x5A\x5E-\x7A\x7C\x7E]/;
my $Field_Content = qr/[[:print:]]+ (?: [\x20\x09]+ [[:print:]]+ )*/x;

sub new {
    my ($class, %args) = @_;
    return bless {
        rbuf             =&gt; '',
        timeout          =&gt; 60,
        max_line_size    =&gt; 16384,
        max_header_lines =&gt; 64,
        verify_SSL       =&gt; 0,
        SSL_options      =&gt; {},
        %args
    }, $class;
}

sub timeout {
    my ($self, $timeout) = @_;
    if ( @_ &gt; 1 ) {
        $self-&gt;{timeout} = $timeout;
        if ( $self-&gt;{fh} &amp;&amp; $self-&gt;{fh}-&gt;can('timeout') ) {
            $self-&gt;{fh}-&gt;timeout($timeout);
        }
    }
    return $self-&gt;{timeout};
}

sub connect {
    @_ == 5 || die(q/Usage: $handle-&gt;connect(scheme, host, port, peer)/ . &quot;\n&quot;);
    my ($self, $scheme, $host, $port, $peer) = @_;

    if ( $scheme eq 'https' ) {
        $self-&gt;_assert_ssl;
    }

    $self-&gt;{fh} = $SOCKET_CLASS-&gt;new(
        PeerHost  =&gt; $peer,
        PeerPort  =&gt; $port,
        $self-&gt;{local_address} ?
            ( LocalAddr =&gt; $self-&gt;{local_address} ) : (),
        Proto     =&gt; 'tcp',
        Type      =&gt; SOCK_STREAM,
        Timeout   =&gt; $self-&gt;{timeout},
    ) or die(qq/Could not connect to '$host:$port': $@\n/);

    binmode($self-&gt;{fh})
      or die(qq/Could not binmode() socket: '$!'\n/);

    if ( $self-&gt;{keep_alive} ) {
        unless ( defined( $self-&gt;{fh}-&gt;setsockopt( SOL_SOCKET, SO_KEEPALIVE, 1 ) ) ) {
            CORE::close($self-&gt;{fh});
            die(qq/Could not set SO_KEEPALIVE on socket: '$!'\n/);
        }
    }

    $self-&gt;start_ssl($host) if $scheme eq 'https';

    $self-&gt;{scheme} = $scheme;
    $self-&gt;{host} = $host;
    $self-&gt;{peer} = $peer;
    $self-&gt;{port} = $port;
    $self-&gt;{pid} = $$;
    $self-&gt;{tid} = _get_tid();

    return $self;
}

sub connected {
    my ($self) = @_;
    if ( $self-&gt;{fh} &amp;&amp; $self-&gt;{fh}-&gt;connected ) {
        return wantarray
          ? ( $self-&gt;{fh}-&gt;peerhost, $self-&gt;{fh}-&gt;peerport )
          : join( ':', $self-&gt;{fh}-&gt;peerhost, $self-&gt;{fh}-&gt;peerport );
    }
    return;
}

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

    # As this might be used via CONNECT after an SSL session
    # to a proxy, we shut down any existing SSL before attempting
    # the handshake
    if ( ref($self-&gt;{fh}) eq 'IO::Socket::SSL' ) {
        unless ( $self-&gt;{fh}-&gt;stop_SSL ) {
            my $ssl_err = IO::Socket::SSL-&gt;errstr;
            die(qq/Error halting prior SSL connection: $ssl_err/);
        }
    }

    my $ssl_args = $self-&gt;_ssl_args($host);
    IO::Socket::SSL-&gt;start_SSL(
        $self-&gt;{fh},
        %$ssl_args,
        SSL_create_ctx_callback =&gt; sub {
            my $ctx = shift;
            Net::SSLeay::CTX_set_mode($ctx, Net::SSLeay::MODE_AUTO_RETRY());
        },
    );

    unless ( ref($self-&gt;{fh}) eq 'IO::Socket::SSL' ) {
        my $ssl_err = IO::Socket::SSL-&gt;errstr;
        die(qq/SSL connection failed for $host: $ssl_err\n/);
    }
}

sub close {
    @_ == 1 || die(q/Usage: $handle-&gt;close()/ . &quot;\n&quot;);
    my ($self) = @_;
    CORE::close($self-&gt;{fh})
      or die(qq/Could not close socket: '$!'\n/);
}

sub write {
    @_ == 2 || die(q/Usage: $handle-&gt;write(buf)/ . &quot;\n&quot;);
    my ($self, $buf) = @_;

    if ( $] ge '5.008' ) {
        utf8::downgrade($buf, 1)
            or die(qq/Wide character in write()\n/);
    }

    my $len = length $buf;
    my $off = 0;

    local $SIG{PIPE} = 'IGNORE';

    while () {
        $self-&gt;can_write
          or die(qq/Timed out while waiting for socket to become ready for writing\n/);
        my $r = syswrite($self-&gt;{fh}, $buf, $len, $off);
        if (defined $r) {
            $len -= $r;
            $off += $r;
            last unless $len &gt; 0;
        }
        elsif ($! == EPIPE) {
            die(qq/Socket closed by remote server: $!\n/);
        }
        elsif ($! != EINTR) {
            if ($self-&gt;{fh}-&gt;can('errstr')){
                my $err = $self-&gt;{fh}-&gt;errstr();
                die (qq/Could not write to SSL socket: '$err'\n /);
            }
            else {
                die(qq/Could not write to socket: '$!'\n/);
            }

        }
    }
    return $off;
}

sub read {
    @_ == 2 || @_ == 3 || die(q/Usage: $handle-&gt;read(len [, allow_partial])/ . &quot;\n&quot;);
    my ($self, $len, $allow_partial) = @_;

    my $buf  = '';
    my $got = length $self-&gt;{rbuf};

    if ($got) {
        my $take = ($got &lt; $len) ? $got : $len;
        $buf  = substr($self-&gt;{rbuf}, 0, $take, '');
        $len -= $take;
    }

    # Ignore SIGPIPE because SSL reads can result in writes that might error.
    # See &quot;Expecting exactly the same behavior as plain sockets&quot; in
    # https://metacpan.org/dist/IO-Socket-SSL/view/lib/IO/Socket/SSL.pod#Common-Usage-Errors
    local $SIG{PIPE} = 'IGNORE';

    while ($len &gt; 0) {
        $self-&gt;can_read
          or die(q/Timed out while waiting for socket to become ready for reading/ . &quot;\n&quot;);
        my $r = sysread($self-&gt;{fh}, $buf, $len, length $buf);
        if (defined $r) {
            last unless $r;
            $len -= $r;
        }
        elsif ($! != EINTR) {
            if ($self-&gt;{fh}-&gt;can('errstr')){
                my $err = $self-&gt;{fh}-&gt;errstr();
                die (qq/Could not read from SSL socket: '$err'\n /);
            }
            else {
                die(qq/Could not read from socket: '$!'\n/);
            }
        }
    }
    if ($len &amp;&amp; !$allow_partial) {
        die(qq/Unexpected end of stream\n/);
    }
    return $buf;
}

sub readline {
    @_ == 1 || die(q/Usage: $handle-&gt;readline()/ . &quot;\n&quot;);
    my ($self) = @_;

    while () {
        if ($self-&gt;{rbuf} =~ s/\A ([^\x0D\x0A]* \x0D?\x0A)//x) {
            return $1;
        }
        if (length $self-&gt;{rbuf} &gt;= $self-&gt;{max_line_size}) {
            die(qq/Line size exceeds the maximum allowed size of $self-&gt;{max_line_size}\n/);
        }
        $self-&gt;can_read
          or die(qq/Timed out while waiting for socket to become ready for reading\n/);
        my $r = sysread($self-&gt;{fh}, $self-&gt;{rbuf}, BUFSIZE, length $self-&gt;{rbuf});
        if (defined $r) {
            last unless $r;
        }
        elsif ($! != EINTR) {
            if ($self-&gt;{fh}-&gt;can('errstr')){
                my $err = $self-&gt;{fh}-&gt;errstr();
                die (qq/Could not read from SSL socket: '$err'\n /);
            }
            else {
                die(qq/Could not read from socket: '$!'\n/);
            }
        }
    }
    die(qq/Unexpected end of stream while looking for line\n/);
}

sub read_header_lines {
    @_ == 1 || @_ == 2 || die(q/Usage: $handle-&gt;read_header_lines([headers])/ . &quot;\n&quot;);
    my ($self, $headers) = @_;
    $headers ||= {};
    my $lines   = 0;
    my $val;

    while () {
         my $line = $self-&gt;readline;

         if (++$lines &gt;= $self-&gt;{max_header_lines}) {
             die(qq/Header lines exceeds maximum number allowed of $self-&gt;{max_header_lines}\n/);
         }
         elsif ($line =~ /\A ([^\x00-\x1F\x7F:]+) : [\x09\x20]* ([^\x0D\x0A]*)/x) {
             my ($field_name) = lc $1;
             if (exists $headers-&gt;{$field_name}) {
                 for ($headers-&gt;{$field_name}) {
                     $_ = [$_] unless ref $_ eq &quot;ARRAY&quot;;
                     push @$_, $2;
                     $val = \$_-&gt;[-1];
                 }
             }
             else {
                 $val = \($headers-&gt;{$field_name} = $2);
             }
         }
         elsif ($line =~ /\A [\x09\x20]+ ([^\x0D\x0A]*)/x) {
             $val
               or die(qq/Unexpected header continuation line\n/);
             next unless length $1;
             $$val .= ' ' if length $$val;
             $$val .= $1;
         }
         elsif ($line =~ /\A \x0D?\x0A \z/x) {
            last;
         }
         else {
            die(q/Malformed header line: / . $Printable-&gt;($line) . &quot;\n&quot;);
         }
    }
    return $headers;
}

sub write_request {
    @_ == 2 || die(q/Usage: $handle-&gt;write_request(request)/ . &quot;\n&quot;);
    my($self, $request) = @_;
    $self-&gt;write_request_header(@{$request}{qw/method uri headers header_case/});
    $self-&gt;write_body($request) if $request-&gt;{cb};
    return;
}

# Standard request header names/case from HTTP/1.1 RFCs
my @rfc_request_headers = qw(
  Accept Accept-Charset Accept-Encoding Accept-Language Authorization
  Cache-Control Connection Content-Length Expect From Host
  If-Match If-Modified-Since If-None-Match If-Range If-Unmodified-Since
  Max-Forwards Pragma Proxy-Authorization Range Referer TE Trailer
  Transfer-Encoding Upgrade User-Agent Via
);

my @other_request_headers = qw(
  Content-Encoding Content-MD5 Content-Type Cookie DNT Date Origin
  X-XSS-Protection
);

my %HeaderCase = map { lc($_) =&gt; $_ } @rfc_request_headers, @other_request_headers;

# to avoid multiple small writes and hence nagle, you can pass the method line or anything else to
# combine writes.
sub write_header_lines {
    (@_ &gt;= 2 &amp;&amp; @_ &lt;= 4 &amp;&amp; ref $_[1] eq 'HASH') || die(q/Usage: $handle-&gt;write_header_lines(headers, [header_case, prefix])/ . &quot;\n&quot;);
    my($self, $headers, $header_case, $prefix_data) = @_;
    $header_case ||= {};

    my $buf = (defined $prefix_data ? $prefix_data : '');

    # Per RFC, control fields should be listed first
    my %seen;
    for my $k ( qw/host cache-control expect max-forwards pragma range te/ ) {
        next unless exists $headers-&gt;{$k};
        $seen{$k}++;
        my $field_name = $HeaderCase{$k};
        my $v = $headers-&gt;{$k};
        for (ref $v eq 'ARRAY' ? @$v : $v) {
            $_ = '' unless defined $_;
            $buf .= &quot;$field_name: $_\x0D\x0A&quot;;
        }
    }

    # Other headers sent in arbitrary order
    while (my ($k, $v) = each %$headers) {
        my $field_name = lc $k;
        next if $seen{$field_name};
        if (exists $HeaderCase{$field_name}) {
            $field_name = $HeaderCase{$field_name};
        }
        else {
            if (exists $header_case-&gt;{$field_name}) {
                $field_name = $header_case-&gt;{$field_name};
            }
            else {
                $field_name =~ s/\b(\w)/\u$1/g;
            }
            $field_name =~ /\A $Token+ \z/xo
              or die(q/Invalid HTTP header field name: / . $Printable-&gt;($field_name) . &quot;\n&quot;);
            $HeaderCase{lc $field_name} = $field_name;
        }
        for (ref $v eq 'ARRAY' ? @$v : $v) {
            # unwrap a field value if pre-wrapped by user
            s/\x0D?\x0A\s+/ /g;
            die(qq/Invalid HTTP header field value ($field_name): / . $Printable-&gt;($_). &quot;\n&quot;)
              unless $_ eq '' || /\A $Field_Content \z/xo;
            $_ = '' unless defined $_;
            $buf .= &quot;$field_name: $_\x0D\x0A&quot;;
        }
    }
    $buf .= &quot;\x0D\x0A&quot;;
    return $self-&gt;write($buf);
}

# return value indicates whether message length was defined; this is generally
# true unless there was no content-length header and we just read until EOF.
# Other message length errors are thrown as exceptions
sub read_body {
    @_ == 3 || die(q/Usage: $handle-&gt;read_body(callback, response)/ . &quot;\n&quot;);
    my ($self, $cb, $response) = @_;
    my $te = $response-&gt;{headers}{'transfer-encoding'} || '';
    my $chunked = grep { /chunked/i } ( ref $te eq 'ARRAY' ? @$te : $te ) ;
    return $chunked
        ? $self-&gt;read_chunked_body($cb, $response)
        : $self-&gt;read_content_body($cb, $response);
}

sub write_body {
    @_ == 2 || die(q/Usage: $handle-&gt;write_body(request)/ . &quot;\n&quot;);
    my ($self, $request) = @_;
    if (exists $request-&gt;{headers}{'content-length'}) {
        return unless $request-&gt;{headers}{'content-length'};
        return $self-&gt;write_content_body($request);
    }
    else {
        return $self-&gt;write_chunked_body($request);
    }
}

sub read_content_body {
    @_ == 3 || @_ == 4 || die(q/Usage: $handle-&gt;read_content_body(callback, response, [read_length])/ . &quot;\n&quot;);
    my ($self, $cb, $response, $content_length) = @_;
    $content_length ||= $response-&gt;{headers}{'content-length'};

    if ( defined $content_length ) {
        my $len = $content_length;
        while ($len &gt; 0) {
            my $read = ($len &gt; BUFSIZE) ? BUFSIZE : $len;
            $cb-&gt;($self-&gt;read($read, 0), $response);
            $len -= $read;
        }
        return length($self-&gt;{rbuf}) == 0;
    }

    my $chunk;
    $cb-&gt;($chunk, $response) while length( $chunk = $self-&gt;read(BUFSIZE, 1) );

    return;
}

sub write_content_body {
    @_ == 2 || die(q/Usage: $handle-&gt;write_content_body(request)/ . &quot;\n&quot;);
    my ($self, $request) = @_;

    my ($len, $content_length) = (0, $request-&gt;{headers}{'content-length'});
    while () {
        my $data = $request-&gt;{cb}-&gt;();

        defined $data &amp;&amp; length $data
          or last;

        if ( $] ge '5.008' ) {
            utf8::downgrade($data, 1)
                or die(qq/Wide character in write_content()\n/);
        }

        $len += $self-&gt;write($data);
    }

    $len == $content_length
      or die(qq/Content-Length mismatch (got: $len expected: $content_length)\n/);

    return $len;
}

sub read_chunked_body {
    @_ == 3 || die(q/Usage: $handle-&gt;read_chunked_body(callback, $response)/ . &quot;\n&quot;);
    my ($self, $cb, $response) = @_;

    while () {
        my $head = $self-&gt;readline;

        $head =~ /\A ([A-Fa-f0-9]+)/x
          or die(q/Malformed chunk head: / . $Printable-&gt;($head) . &quot;\n&quot;);

        my $len = hex($1)
          or last;

        $self-&gt;read_content_body($cb, $response, $len);

        $self-&gt;read(2) eq &quot;\x0D\x0A&quot;
          or die(qq/Malformed chunk: missing CRLF after chunk data\n/);
    }
    $self-&gt;read_header_lines($response-&gt;{headers});
    return 1;
}

sub write_chunked_body {
    @_ == 2 || die(q/Usage: $handle-&gt;write_chunked_body(request)/ . &quot;\n&quot;);
    my ($self, $request) = @_;

    my $len = 0;
    while () {
        my $data = $request-&gt;{cb}-&gt;();

        defined $data &amp;&amp; length $data
          or last;

        if ( $] ge '5.008' ) {
            utf8::downgrade($data, 1)
                or die(qq/Wide character in write_chunked_body()\n/);
        }

        $len += length $data;

        my $chunk  = sprintf '%X', length $data;
           $chunk .= &quot;\x0D\x0A&quot;;
           $chunk .= $data;
           $chunk .= &quot;\x0D\x0A&quot;;

        $self-&gt;write($chunk);
    }
    $self-&gt;write(&quot;0\x0D\x0A&quot;);
    if ( ref $request-&gt;{trailer_cb} eq 'CODE' ) {
        $self-&gt;write_header_lines($request-&gt;{trailer_cb}-&gt;())
    }
    else {
        $self-&gt;write(&quot;\x0D\x0A&quot;);
    }
    return $len;
}

sub read_response_header {
    @_ == 1 || die(q/Usage: $handle-&gt;read_response_header()/ . &quot;\n&quot;);
    my ($self) = @_;

    my $line = $self-&gt;readline;

    $line =~ /\A (HTTP\/(0*\d+\.0*\d+)) [\x09\x20]+ ([0-9]{3}) (?: [\x09\x20]+ ([^\x0D\x0A]*) )? \x0D?\x0A/x
      or die(q/Malformed Status-Line: / . $Printable-&gt;($line). &quot;\n&quot;);

    my ($protocol, $version, $status, $reason) = ($1, $2, $3, $4);
    $reason = &quot;&quot; unless defined $reason;

    die (qq/Unsupported HTTP protocol: $protocol\n/)
        unless $version =~ /0*1\.0*[01]/;

    return {
        status       =&gt; $status,
        reason       =&gt; $reason,
        headers      =&gt; $self-&gt;read_header_lines,
        protocol     =&gt; $protocol,
    };
}

sub write_request_header {
    @_ == 5 || die(q/Usage: $handle-&gt;write_request_header(method, request_uri, headers, header_case)/ . &quot;\n&quot;);
    my ($self, $method, $request_uri, $headers, $header_case) = @_;

    return $self-&gt;write_header_lines($headers, $header_case, &quot;$method $request_uri HTTP/1.1\x0D\x0A&quot;);
}

sub _do_timeout {
    my ($self, $type, $timeout) = @_;
    $timeout = $self-&gt;{timeout}
        unless defined $timeout &amp;&amp; $timeout &gt;= 0;

    my $fd = fileno $self-&gt;{fh};
    defined $fd &amp;&amp; $fd &gt;= 0
      or die(qq/select(2): 'Bad file descriptor'\n/);

    my $initial = time;
    my $pending = $timeout;
    my $nfound;

    vec(my $fdset = '', $fd, 1) = 1;

    while () {
        $nfound = ($type eq 'read')
            ? select($fdset, undef, undef, $pending)
            : select(undef, $fdset, undef, $pending) ;
        if ($nfound == -1) {
            $! == EINTR
              or die(qq/select(2): '$!'\n/);
            redo if !$timeout || ($pending = $timeout - (time - $initial)) &gt; 0;
            $nfound = 0;
        }
        last;
    }
    $! = 0;
    return $nfound;
}

sub can_read {
    @_ == 1 || @_ == 2 || die(q/Usage: $handle-&gt;can_read([timeout])/ . &quot;\n&quot;);
    my $self = shift;
    if ( ref($self-&gt;{fh}) eq 'IO::Socket::SSL' ) {
        return 1 if $self-&gt;{fh}-&gt;pending;
    }
    return $self-&gt;_do_timeout('read', @_)
}

sub can_write {
    @_ == 1 || @_ == 2 || die(q/Usage: $handle-&gt;can_write([timeout])/ . &quot;\n&quot;);
    my $self = shift;
    return $self-&gt;_do_timeout('write', @_)
}

sub _assert_ssl {
    my($ok, $reason) = HTTP::Tiny-&gt;can_ssl();
    die $reason unless $ok;
}

sub can_reuse {
    my ($self,$scheme,$host,$port,$peer) = @_;
    return 0 if
        $self-&gt;{pid} != $$
        || $self-&gt;{tid} != _get_tid()
        || length($self-&gt;{rbuf})
        || $scheme ne $self-&gt;{scheme}
        || $host ne $self-&gt;{host}
        || $port ne $self-&gt;{port}
        || $peer ne $self-&gt;{peer}
        || eval { $self-&gt;can_read(0) }
        || $@ ;
        return 1;
}

# Try to find a CA bundle to validate the SSL cert,
# prefer Mozilla::CA or fallback to a system file
sub _find_CA_file {
    my $self = shift();

    my $ca_file =
      defined( $self-&gt;{SSL_options}-&gt;{SSL_ca_file} )
      ? $self-&gt;{SSL_options}-&gt;{SSL_ca_file}
      : $ENV{SSL_CERT_FILE};

    if ( defined $ca_file ) {
        unless ( -r $ca_file ) {
            die qq/SSL_ca_file '$ca_file' not found or not readable\n/;
        }
        return $ca_file;
    }

    local @INC = @INC;
    pop @INC if $INC[-1] eq '.';
    return Mozilla::CA::SSL_ca_file()
        if eval { require Mozilla::CA; 1 };

    # cert list copied from golang src/crypto/x509/root_unix.go
    foreach my $ca_bundle (
        &quot;/etc/ssl/certs/ca-certificates.crt&quot;,     # Debian/Ubuntu/Gentoo etc.
        &quot;/etc/pki/tls/certs/ca-bundle.crt&quot;,       # Fedora/RHEL
        &quot;/etc/ssl/ca-bundle.pem&quot;,                 # OpenSUSE
        &quot;/etc/openssl/certs/ca-certificates.crt&quot;, # NetBSD
        &quot;/etc/ssl/cert.pem&quot;,                      # OpenBSD
        &quot;/usr/local/share/certs/ca-root-nss.crt&quot;, # FreeBSD/DragonFly
        &quot;/etc/pki/tls/cacert.pem&quot;,                # OpenELEC
        &quot;/etc/certs/ca-certificates.crt&quot;,         # Solaris 11.2+
    ) {
        return $ca_bundle if -e $ca_bundle;
    }

    die qq/Couldn't find a CA bundle with which to verify the SSL certificate.\n/
      . qq/Try installing Mozilla::CA from CPAN\n/;
}

# for thread safety, we need to know thread id if threads are loaded
sub _get_tid {
    no warnings 'reserved'; # for 'threads'
    return threads-&gt;can(&quot;tid&quot;) ? threads-&gt;tid : 0;
}

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

    my %ssl_args;

    # This test reimplements IO::Socket::SSL::can_client_sni(), which wasn't
    # added until IO::Socket::SSL 1.84
    if ( Net::SSLeay::OPENSSL_VERSION_NUMBER() &gt;= 0x01000000 ) {
        $ssl_args{SSL_hostname} = $host,          # Sane SNI support
    }

    if ($self-&gt;{verify_SSL}) {
        $ssl_args{SSL_verifycn_scheme}  = 'http'; # enable CN validation
        $ssl_args{SSL_verifycn_name}    = $host;  # set validation hostname
        $ssl_args{SSL_verify_mode}      = 0x01;   # enable cert validation
        $ssl_args{SSL_ca_file}          = $self-&gt;_find_CA_file;
    }
    else {
        $ssl_args{SSL_verifycn_scheme}  = 'none'; # disable CN validation
        $ssl_args{SSL_verify_mode}      = 0x00;   # disable cert validation
    }

    # user options override settings from verify_SSL
    for my $k ( keys %{$self-&gt;{SSL_options}} ) {
        $ssl_args{$k} = $self-&gt;{SSL_options}{$k} if $k =~ m/^SSL_/;
    }

    return \%ssl_args;
}

1;


} # --- END HTTP::Tiny


{ # --- BEGIN Try::Tiny
package Try::Tiny; # git description: v0.30-11-g1b81d0a
use 5.006;
# ABSTRACT: Minimal try/catch with proper preservation of $@

our $VERSION = '0.31';

use strict;
use warnings;

BEGIN   {
use Exporter 5.57 'import';
our @EXPORT = our @EXPORT_OK = qw(try catch finally);

use Carp;
$Carp::Internal{+__PACKAGE__}++;

  if ($INC{'Sub/Util.pm'} &amp;&amp; defined &amp;Sub::Util::set_subname ) {
      *_subname = \&amp;Sub::Util::set_subname;
      *_HAS_SUBNAME = sub {1};
  }
  elsif( $INC{'Sub/Name.pm'} &amp;&amp; eval { Sub::Name-&gt;VERSION(0.08) } ){
      *_subname = \&amp;Sub::Name::subname;
      *_HAS_SUBNAME = sub {1};
  }
  else {
      *_HAS_SUBNAME = sub {0};
  }
}

my %_finally_guards;

# Need to prototype as @ not $$ because of the way Perl evaluates the prototype.
# Keeping it at $$ means you only ever get 1 sub because we need to eval in a list
# context &amp; not a scalar one

sub try (&amp;;@) {
  my ( $try, @code_refs ) = @_;

  # we need to save this here, the eval block will be in scalar context due
  # to $failed
  my $wantarray = wantarray;

  # work around perl bug by explicitly initializing these, due to the likelyhood
  # this will be used in global destruction (perl rt#119311)
  my ( $catch, @finally ) = ();

  # find labeled blocks in the argument list.
  # catch and finally tag the blocks by blessing a scalar reference to them.
  foreach my $code_ref (@code_refs) {

    if ( ref($code_ref) eq 'Try::Tiny::Catch' ) {
      croak 'A try() may not be followed by multiple catch() blocks'
        if $catch;
      $catch = ${$code_ref};
    } elsif ( ref($code_ref) eq 'Try::Tiny::Finally' ) {
      push @finally, ${$code_ref};
    } else {
      croak(
        'try() encountered an unexpected argument ('
      . ( defined $code_ref ? $code_ref : 'undef' )
      . ') - perhaps a missing semi-colon before or'
      );
    }
  }

  # FIXME consider using local $SIG{__DIE__} to accumulate all errors. It's
  # not perfect, but we could provide a list of additional errors for
  # $catch-&gt;();

  # name the blocks if we have Sub::Name installed
  _subname(caller().'::try {...} ' =&gt; $try)
    if _HAS_SUBNAME;

  # set up scope guards to invoke the finally blocks at the end.
  # this should really be a function scope lexical variable instead of
  # file scope + local but that causes issues with perls &lt; 5.20 due to
  # perl rt#119311
  local $_finally_guards{guards} = [
    map Try::Tiny::ScopeGuard-&gt;_new($_),
    @finally
  ];

  # save the value of $@ so we can set $@ back to it in the beginning of the eval
  # and restore $@ after the eval finishes
  my $prev_error = $@;

  my ( @ret, $error );

  # failed will be true if the eval dies, because 1 will not be returned
  # from the eval body
  my $failed = not eval {
    $@ = $prev_error;

    # evaluate the try block in the correct context
    if ( $wantarray ) {
      @ret = $try-&gt;();
    } elsif ( defined $wantarray ) {
      $ret[0] = $try-&gt;();
    } else {
      $try-&gt;();
    };

    return 1; # properly set $failed to false
  };

  # preserve the current error and reset the original value of $@
  $error = $@;
  $@ = $prev_error;

  # at this point $failed contains a true value if the eval died, even if some
  # destructor overwrote $@ as the eval was unwinding.
  if ( $failed ) {
    # pass $error to the finally blocks
    push @$_, $error for @{$_finally_guards{guards}};

    # if we got an error, invoke the catch block.
    if ( $catch ) {
      # This works like given($error), but is backwards compatible and
      # sets $_ in the dynamic scope for the body of C&lt;$catch&gt;
      for ($error) {
        return $catch-&gt;($error);
      }

      # in case when() was used without an explicit return, the C&lt;for&gt;
      # loop will be aborted and there's no useful return value
    }

    return;
  } else {
    # no failure, $@ is back to what it was, everything is fine
    return $wantarray ? @ret : $ret[0];
  }
}

sub catch (&amp;;@) {
  my ( $block, @rest ) = @_;

  croak 'Useless bare catch()' unless wantarray;

  _subname(caller().'::catch {...} ' =&gt; $block)
    if _HAS_SUBNAME;
  return (
    bless(\$block, 'Try::Tiny::Catch'),
    @rest,
  );
}

sub finally (&amp;;@) {
  my ( $block, @rest ) = @_;

  croak 'Useless bare finally()' unless wantarray;

  _subname(caller().'::finally {...} ' =&gt; $block)
    if _HAS_SUBNAME;
  return (
    bless(\$block, 'Try::Tiny::Finally'),
    @rest,
  );
}

{
  package # hide from PAUSE
    Try::Tiny::ScopeGuard;

  use constant UNSTABLE_DOLLARAT =&gt; (&quot;$]&quot; &lt; '5.013002') ? 1 : 0;

  sub _new {
    shift;
    bless [ @_ ];
  }

  sub DESTROY {
    my ($code, @args) = @{ $_[0] };

    local $@ if UNSTABLE_DOLLARAT;
    eval {
      $code-&gt;(@args);
      1;
    } or do {
      warn
        &quot;Execution of finally() block $code resulted in an exception, which &quot;
      . '*CAN NOT BE PROPAGATED* due to fundamental limitations of Perl. '
      . 'Your program will continue as if this event never took place. '
      . &quot;Original exception text follows:\n\n&quot;
      . (defined $@ ? $@ : '$@ left undefined...')
      . &quot;\n&quot;
      ;
    }
  }
}

1;

} # --- END Try::Tiny


{ # --- BEGIN cPstrict
package cPstrict;

# cpanel - cPstrict.pm                             Copyright 2022 cPanel, L.L.C.
#                                                           All rights Reserved.
# copyright@cpanel.net                                         http://cpanel.net
# This code is subject to the cPanel license. Unauthorized copying is prohibited

use strict;
use warnings;

=pod

This is importing the following to your namespace

    use strict;
    use warnings;
    use v5.30;

    use feature 'signatures';
    no warnings 'experimental::signatures';

=cut

sub import {

    # auto import strict and warnings to our caller

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

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

    return;
}

1;

} # --- END cPstrict


{ # --- BEGIN Cpanel/OS/SysPerlBootstrap.pm
package Cpanel::OS::SysPerlBootstrap;


use strict;
use warnings;

use constant CACHE_FILE        =&gt; '/var/cpanel/caches/Cpanel-OS';
use constant CACHE_FILE_CUSTOM =&gt; CACHE_FILE . '.custom';


sub get_os_info {
    my ($iknowwhatimdoing) = @_;
    die(&quot;Please use Cpanel::OS for your OS info needs&quot;) unless ( $iknowwhatimdoing &amp;&amp; $iknowwhatimdoing eq 'DO NOT USE THIS CALL' );

    my @os_info = _read_os_info_cache();
    return @os_info if @os_info;

    my ( $distro, $major, $minor, $build ) = _get_os_without_cache('redhat_first');

    if ( !defined $distro || !length $distro || !defined $major || !length $major || !defined $minor || !length $minor || !defined $build || !length $build ) {
        die sprintf( &quot;Could not determine OS info (distro: %s, major: %s, minor: %s, build: %s)\n&quot;, $distro // '', $major // '', $minor // '', $build // '' );
    }

    _cache_os_info( $^O, $distro, $major, $minor, $build );

    return ( $^O, $distro, $major, $minor, $build );
}


sub _get_os_without_cache {
    my ($redhat_first) = @_;

    my @os;
    if ($redhat_first) {    # preserve existing behavior for Cpanel::OS
        @os = _read_redhat_release();
        @os = _read_os_release() unless scalar @os;
    }
    else {
        @os = _read_os_release();
        @os = _read_redhat_release() unless scalar @os;
    }

    return @os;
}


sub _read_os_info_cache {

    my $cache_mtime = ( lstat CACHE_FILE )[9] or return;

    my $custom_os = readlink CACHE_FILE_CUSTOM;

    if ( !$custom_os ) {
        my $os_rel_mtime = ( stat(&quot;/etc/os-release&quot;) )[9];
        $os_rel_mtime //= ( stat(&quot;/etc/redhat-release&quot;) )[9];    # in the case of cloudlinux 6, we check against this instead

        return if ( defined($os_rel_mtime) &amp;&amp; $cache_mtime &lt;= $os_rel_mtime );
    }

    return split /\|/, readlink(CACHE_FILE);
}


sub _read_os_release {

    return unless -e '/etc/os-release';

    open( my $os_fh, &quot;&lt;&quot;, &quot;/etc/os-release&quot; ) or die &quot;Could not open /etc/os-release for reading: $!\n&quot;;

    my ( $distro, $ver, $ver_id );
    while ( my $line = &lt;$os_fh&gt; ) {
        my ( $key, $value ) = split( qr/\s*=\s*/, $line, 2 );
        chomp $value;
        $value =~ s/\s.+//;
        $value =~ s/&quot;\z//;
        $value =~ s/^&quot;//;

        if ( !$distro &amp;&amp; $key eq &quot;ID&quot; ) {
            $distro = $value;
        }
        elsif ( !$ver_id &amp;&amp; $key eq &quot;VERSION_ID&quot; ) {
            $ver_id = $value;
        }
        elsif ( !$ver &amp;&amp; $key eq &quot;VERSION&quot; ) {
            $ver = $value;
        }

        last if defined $distro &amp;&amp; length $distro &amp;&amp; defined $ver &amp;&amp; length $ver &amp;&amp; defined $ver_id &amp;&amp; length $ver_id;
    }
    close $os_fh;

    my ( $major, $minor, $build ) = split( qr/\./, $ver_id );
    return unless $distro;    # We have to at a minimum have a distro name. All hope is lost otherwise.

    unless ( defined $major &amp;&amp; length $major &amp;&amp; defined $minor &amp;&amp; length $minor &amp;&amp; defined $build &amp;&amp; length $build ) {
        my ( $ver_major, $ver_minor, $ver_build ) = split( qr/\./, $ver );
        $major //= $ver_major;
        $minor //= ( $ver_minor // 0 );
        $build //= ( $ver_build // 0 );
    }

    return ( $distro, $major, $minor, $build );
}


sub _read_redhat_release {

    return unless -e '/etc/redhat-release';

    open( my $cr_fh, &quot;&lt;&quot;, &quot;/etc/redhat-release&quot; ) or die &quot;Could not open /etc/redhat-release for reading: $!\n&quot;;
    my $line = &lt;$cr_fh&gt;;
    chomp $line;

    my ($distro) = $line =~ m/^(\w+)/i;
    $distro = lc($distro);
    $distro = 'rhel' if $distro eq 'red';

    my ( $major, $minor, $build ) = $line =~ m{\b([0-9]+)\.([0-9]+)\.([0-9]+)};
    if ( !defined $major || !length $major ) {
        ( $major, $minor ) = $line =~ m{\b([0-9]+)\.([0-9]+)};
    }
    if ( !defined $major || !length $major ) {
        ($major) = $line =~ m{\b([0-9]+)};
    }
    $minor //= 0;
    $build //= 0;

    return ( $distro, $major, $minor, $build );
}


sub _cache_os_info {
    my ( $os, $distro, $major, $minor, $build ) = @_;
    $&gt; == 0 or return;

    mkdir '/var/cpanel',        0711;
    mkdir '/var/cpanel/caches', 0711;

    local $!;
    unlink CACHE_FILE;
    symlink &quot;$os|$distro|$major|$minor|$build&quot;, CACHE_FILE;

    return 1;
}

1;

} # --- END Cpanel/OS/SysPerlBootstrap.pm


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


use strict;
# use Cpanel::Exception ();

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

1;

} # --- END Cpanel/ExceptionMessage.pm


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


use strict;
use warnings;


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

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

1;

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


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


use strict;
use warnings;

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

# use Cpanel::Locale::Utils::Fallback ();

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

    my $str_copy = $str;

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

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

    return $$self;
}

sub get_language_tag {
    return 'en';
}

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

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


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


use strict;
use warnings;


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

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

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

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

    return $module_name;
}

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

1;

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


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


use strict;
use warnings;


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

1;

} # --- END Cpanel/ScalarUtil.pm


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


1;

package Cpanel::Exception;

use strict;


BEGIN {
    $INC{'Cpanel/Exception.pm'} = '__BYPASSED__';
}

our $_SUPPRESS_STACK_TRACES = 0;

our $_EXCEPTION_MODULE_PREFIX = 'Cpanel::Exception';
our $IN_EXCEPTION_CREATION    = 0;

our $_suppressed_msg = '__STACK_TRACE_SUPPRESSED__YOU_SHOULD_NEVER_SEE_THIS_MESSAGE__';

my $PACKAGE = 'Cpanel::Exception';
my $locale;

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

my $ID_LENGTH = 6;


# use Cpanel::ExceptionMessage::Raw ();
# use Cpanel::LoadModule::Utils     ();

use constant _TRUE =&gt; 1;

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

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

sub _init { return 1 }    # legacy


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

    _init();

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

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

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

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

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

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


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

    _init();

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

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

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

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

    local ( $!, $@ );

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

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

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

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

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

    return 1;
}

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

    @args = grep { defined } @args;

    my $self = {};

    bless $self, $class;

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

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

            local $Carp::CarpInternal{'Cpanel::Exception'} = 1;
            local $Carp::CarpInternal{$class} = 1;

            'Carp'-&gt;can('longmess')-&gt;();
        };
    }

    _init();

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

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

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

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

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

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

            if ($phrase) {

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

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

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

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

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

    return $self;
}


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

    return get_string_no_id($exc) if $no_id_yn;

    return _get_string( $exc, 'to_string' );
}


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

    return _get_string( $exc, 'to_string_no_id' );
}

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

    return $exc if !ref $exc;

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

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

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

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

    return $exc;
}


sub _create_id {

    srand();

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

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


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


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

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


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

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

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

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

    return $self;
}


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

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

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

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

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

    return $v;
}


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

my $loaded_LocaleString;

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

my $loaded_ExceptionMessage_Locale;

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

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


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

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


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

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

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

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

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

    return $string;
}

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

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


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

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

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

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


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

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

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

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


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

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


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

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

    return @{ $self-&gt;{'_auxiliaries'} };
}

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

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

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

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

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

    my @lines;

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

        local $@;

        _require_LocaleString();

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

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

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

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

*TO_JSON = \&amp;to_string;

sub _locale {
    return $locale ||= do {

        local $@;

        eval 'require Cpanel::Locale; 1;' or die $@;

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

sub _reset_locale {
    return undef $locale;
}

sub _load_carp {
    if ( !$INC{'Carp.pm'} ) {

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

    return;
}

sub _load_cpanel_carp {
    if ( !$INC{'Cpanel/Carp.pm'} ) {

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

    return;
}

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

    return $self-&gt;{'_message'} if $self-&gt;{'_message'};

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

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


package Cpanel::Exception::_StackTraceSuppression;

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

    $Cpanel::Exception::_SUPPRESS_STACK_TRACES++;

    return bless [], $class;
}

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

1;

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


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


use strict;

# use Cpanel::Exception         ();
# use Cpanel::LoadModule::Utils ();

my $logger;
my $has_perl_dir = 0;

sub _logger_warn {
    my ( $msg, $fail_ok ) = @_;

    return if $fail_ok &amp;&amp; $ENV{'CPANEL_BASE_INSTALL'} &amp;&amp; index( $^X, '/usr/local/cpanel' ) == -1;

    if ( $INC{'Cpanel/Logger.pm'} ) {
        $logger ||= 'Cpanel::Logger'-&gt;new();
        $logger-&gt;warn($msg);
    }
    return warn $msg;
}

sub _reset_has_perl_dir {
    $has_perl_dir = 0;
    return;
}

sub load_perl_module {    ## no critic qw(Subroutines::RequireArgUnpacking)
    if ( -1 != index( $_[0], q&lt;'&gt; ) ) {
        die Cpanel::Exception::create_raw( 'InvalidParameter', &quot;Module names with single-quotes are prohibited. ($_[0])&quot; );
    }

    return $_[0] if Cpanel::LoadModule::Utils::module_is_loaded( $_[0] );

    my ( $mod, @LIST ) = @_;

    local ( $!, $@ );

    if ( !is_valid_module_name($mod) ) {
        die Cpanel::Exception::create( 'InvalidParameter', '“[_1]” is not a valid name for a Perl module.', [$mod] );
    }

    my $args_str;
    if (@LIST) {
        $args_str = join ',', map {
            die &quot;Only scalar arguments allowed in LIST! (@LIST)&quot; if ref;
            _single_quote($_);
        } @LIST;
    }
    else {
        $args_str = q&lt;&gt;;
    }

    eval &quot;use $mod ($args_str);&quot;;    ## no critic qw(BuiltinFunctions::ProhibitStringyEval)

    if ($@) {
        die Cpanel::Exception::create( 'ModuleLoadError', [ module =&gt; $mod, error =&gt; $@ ] );
    }

    return $mod;
}

*module_is_loaded = *Cpanel::LoadModule::Utils::module_is_loaded;

*is_valid_module_name = *Cpanel::LoadModule::Utils::is_valid_module_name;


sub loadmodule {
    return 1 if cpanel_namespace_module_is_loaded( $_[0] );

    return _modloader( $_[0] );
}

sub lazy_load_module {
    my $mod = shift;

    my $mod_path = $mod;
    $mod_path =~ s{::}{/}g;
    if ( exists $INC{ $mod_path . '.pm' } ) {
        return;
    }

    if ( !is_valid_module_name($mod) ) {
        _logger_warn(&quot;Cpanel::LoadModule: Invalid module name ($mod)&quot;);
        return;
    }

    eval &quot;use $mod ();&quot;;

    if ($@) {
        delete $INC{ $mod_path . '.pm' };
        _logger_warn( &quot;Cpanel::LoadModule:: Failed to load module $mod - $@&quot;, 1 );
        return;
    }

    return 1;
}


sub cpanel_namespace_module_is_loaded {
    my ($modpart) = @_;
    $modpart =~ s{::}{/}g;
    return exists $INC{&quot;Cpanel/$modpart.pm&quot;} ? 1 : 0;
}

sub _modloader {
    my $module = shift;
    if ( !$module ) {
        _logger_warn(&quot;Empty module name passed to modloader&quot;);
        return;
    }
    if ( !is_valid_module_name($module) ) {
        _logger_warn(&quot;Invalid module name ($module) passed to modloader&quot;);
        return;
    }

    eval qq[ use Cpanel::${module}; Cpanel::${module}::${module}_init() if &quot;Cpanel::${module}&quot;-&gt;can(&quot;${module}_init&quot;); ];    # PPI USE OK - This looks like usage of the Cpanel module and it's not.

    if ($@) {
        _logger_warn(&quot;Error loading module $module - $@&quot;);
        return;
    }

    return 1;
}

sub _single_quote {
    local ($_) = $_[0];
    s/([\\'])/\\$1/g;
    return qq('$_');
}

1;

} # --- END Cpanel/LoadModule.pm


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


use cPstrict;

use Carp                         ();
# use Cpanel::OS::SysPerlBootstrap ();
# use Cpanel::LoadModule           ();

our $VERSION = '2.0';

sub _new_instance ( $os, $distro, $major, $minor, $build ) {
    my $distro_class = 'Cpanel::OS::' . ucfirst($distro) . $major;

    if ( !eval &quot;require $distro_class; 1&quot; ) {    ## no critic qw(ProhibitStringyEval) -- This is how we do a runtime load here.
        require Cpanel::OS::Linux;               # PPI USE OK -- used just after
        $distro_class = q[Cpanel::OS::Linux];    # unsupported distro

        $os //= q[Unknown];
    }

    my $self = bless {
        os     =&gt; $os,
        distro =&gt; $distro,
        major  =&gt; $major,
        minor  =&gt; $minor,
        build  =&gt; $build,
    }, $distro_class;

    return $self;
}

my $instance;

sub clear_cache {
    $INC{'Test/Cpanel/Policy.pm'} or Carp::croak(&quot;This interface is only for unit testing&quot;);
    undef $instance;

    return;
}

sub clear_cache_after_cloudlinux_update {
    undef $instance;
    return;
}

sub _instance {    ## no critic(RequireArgUnpacking) - Most of the time we do not need to process args.
    return $instance if $instance;

    Carp::croak(&quot;Cpanel::OS may not be called during cPanel binary compilation&quot;) if $INC{'B/C.pm'};

    my ( $os, $distro, $major, $minor, $build ) = @_;
    if ( !length $build ) {
        ( $os, $distro, $major, $minor, $build ) = Cpanel::OS::SysPerlBootstrap::get_os_info('DO NOT USE THIS CALL');
    }

    return $instance = _new_instance( $os, $distro, $major, $minor, $build );
}

sub flush_disk_caches {
    local $!;

    return 0 if readlink Cpanel::OS::SysPerlBootstrap::CACHE_FILE_CUSTOM;
    unlink Cpanel::OS::SysPerlBootstrap::CACHE_FILE;

    return 1;
}

sub distro { return _instance()-&gt;{'distro'} }
sub major  { return _instance()-&gt;{'major'} }
sub minor  { return _instance()-&gt;{'minor'} }
sub build  { return _instance()-&gt;{'build'} }

my %methods;

BEGIN {

    %methods = map { $_ =&gt; 0 } (
        'is_supported',                       # This OS is supported by cPanel and not a virtual class (these exist!).
        'eol_advice',                         # Additional information provided to updatenow blockers when the customer tries to upgrade on a removed distro.
        'support_needs_minor_at_least_at',    # miniimum minor version we support for this distro (optional
        'is_experimental',                    # Defines if this distro is in experimental state or not.
        'experimental_url',                   # Provides a link to information about the experimental state if it's currently that way.
        'arch',                               # Somewhat of an unnecessary variable as all of our distros are set to x86_64.
        'service_manager',                    # Does this distro use systemd or initd to manage services?
        'is_systemd',                         # Easy boolean helper we use in most places to determine if the local system uses systemd.
        'base_distro',                        # What is the root distro this distro is derived from? rhel/debian
        'pretty_distro',                      # What is the preferred stylization of the distro name when being displayed for a user?
        'display_name',                       # Example: Centos v7.9.2009
        'display_name_lite',                  # Example: centos 7
        'cpanalytics_cpos',                   # How should we present data regarding the OS to Google Analytics?
        'binary_sync_source',                 # Provides the string corresponding to the binary sync source directory.
        'release_codename',                   # Ubuntu only, but you can't really add it anywhere but globally given how our testing of this works.

        'nobody',                             # name of the user used for nobody
        'nogroup',                            # name of the group used for nobody / nogroup

        'sudoers',                            # name of the group used for sudo (by sudoers)
        'has_wheel_group',                    # flag for whether wheel group is needed by sudo

        'default_uid_min',                    # default value from /etc/login.defs
        'default_gid_min',                    # default value from /etc/login.defs
        'default_sys_uid_min',                # default value from /etc/login.defs
        'default_sys_gid_min',                # default value from /etc/login.defs

        'has_tcp_wrappers',                   # The distro supports TPC wrappers.

        'setup_tz_method',                    # what method to use to setup a timezone
        'is_cloudlinux',                      # is it a CloudLinux based distro? boolean

        'can_be_elevated',                    # ELevate supports current OS as a source
        'can_elevate_to',                     # ELevate can directly convert the current OS to these other OSes listed in the arrayref

        'rsyslog_triggered_by_socket',        # Is rsyslog triggered by syslog.socket

        'has_quota_support_for_xfs',          # Does this distro support xfs quota?
        'program_to_apply_kernel_args',       # What program do we need to run to ensure that kernels are booted with updated args?
        'has_cloudlinux_enhanced_quotas',     # Cloud linux does fancy things with quota we need to know about.
        'who_wins_if_soft_gt_hard',           # If we try to set a soft quota higher than a hard quota, which value wins?
        'quota_packages_conditional',         # Hashref of needed kernel package dependencies not encoded in the upstream distro in order for quotas to work

        'bin_grub_mkconfig',                  # path to sbin/grub2-mkconfig

        'bin_needs_restarting',               # path to needs-restarting binary

        'outdated_services_check',            # which method to use to check outdated services?
        'outdated_processes_check',           # which method to use to check outdated processes?
        'check_reboot_method',                # which method to use to check if we need to reboot

        'dns_supported',                      # Provides a list of dns servers supported on this platform.
        'dns_named_basedir',                  # The path to the bind nameserver files.
        'dns_named_conf',                     # /etc/named.conf
        'dns_named_log',                      # What dir named logs are stored (/var/log/named)

        'ssh_supported_algorithms',           # list of supported ssh algo [ordered by preference]

        'openssl_minimum_supported_version',  # minimum openssl version to run
        'openssl_escapes_subjects',           # On generated certs, openssl started escaping subject lines at some point...


        'unsupported_db_versions',                 # What DB versions does this distro NOT support.
        'db_package_manager_key_params',           # Hashref describing what to do to ensure keys are in place for DBMSes installed from a 3rdparty repo
        'mysql_versions_use_repo_template',        # Which MySQL versions use mysql_repo_template.
        'mariadb_versions_use_repo_template',      # Which MariaDB versions use mariadb_repo_template.
        'mysql_repo_template',                     # What goes in the repo file to download mysql packages.
        'mariadb_repo_template',                   # What goes in the repo file to download mariadb packages.
        'mariadb_minimum_supported_version',       # Minimum version of MariaDB supported
        'mysql_community_packages',                # Which MySQL packages need to be installed on this distro?
        'mysql_dependencies',                      # Which distro packages need to be installed for MySQL to be happy?
        'mysql_incompatible',                      # Which mysql packages need to be blocked as incompatible with cPanel packages on this distro?
        'mysql_default_version',                   # Default MySQL version to use
        'supports_postgresql',                     # Do we support PostgreSQL on this distro?
        'postgresql_minimum_supported_version',    # What is the minimum versions of PostgreSQL supported on this distro?
        'postgresql_packages',                     # What packages do we need to install?
        'postgresql_service_aliases',              # What aliases, if any, of the service name might we expect to find PostgreSQL using?
        'postgresql_initdb_commands',              # Which commands do we run to make PostgreSQL initialize its DB storage area?

        'ea4_install_repo_from_package',             # Does a RPM provide the EA4 repo or do we download the repo file?
        'ea4_from_pkg_url',                          # If we're installing the repo from RPM, where do we get it from?
        'ea4_from_pkg_reponame',                     # ... And what will the repo be called when we install it?
        'ea4_from_custom_repo_url',                  # Where can we download the repo file from? (needs to be over https)
        'ea4_from_custom_repo_path',                 # ... And where should we put it when we download it?
        'ea4tooling_all',                            # LIST - What are the packages to install which provide ea4 tooling on all server types?
        'ea4tooling',                                # LIST - What ea4 tooling packages do we install on full cpanel servers?
        'ea4tooling_dnsonly',                        # LIST - What additional packages do we need for dnsonly? &lt;&lt; FACT CHECK
        'ea4_modern_openssl',                        # Which openssl should be used on this platform to get the L&amp;G Stuff? EA4 provides one in the event the distro's version is insufficient.
        'ea4_testing_yum_repo',                      # undef or string with the name of the yum repo to enable
        'ea4_conflicting_apache_distro_packages',    # Conflicting packages that Cpanel::EA4::MigrateBlocker checks for
        'ea4_install_from_profile_enforce_packages',

        'package_manager',                           # which package manager does the distro use? ( yum/dnf/apt)
        'package_manager_module',                    # Cpanel::whatever::$package_manager_module::... ( Yum or Apt )
        'package_repositories',                      # what additional repos need to be installed and enabled to install needed software?
        'package_release_distro_tag',                # the postfix extension used for the packages: ~el6, ~el7, ~el8, ~el9, ~u20, ~u22
        'system_exclude_rules',                      # On yum based systems, how what will we block the main distro from installing
        'kernel_package_pattern',                    # What are the kernal packages named so we can sometimes block them when updating.
        'check_kernel_version_method',               # What method to use to check the kernel version
        'stock_kernel_version_regex',                # Regular expression used to determine whether the version string returned for the kernel matches what the distro would return with a stock kernel.
        'kernel_supports_fs_protected_regular',      # Does fs.protected_regular a valid settings
        'packages_required',                         # Which packages should /scripts/sysup assure are present on this system? ( provided during fresh install )
        'packages_supplemental',                     # Which packages should /scripts/sysup assure are present on this system? ( provided AFTER fresh install )
        'packages_supplemental_epel',                # Packages we want to install from epel if it is available to us.
        'is_apt_based',                              # Does this system use apt (and therefore deb packages) for package management?
        'is_yum_based',                              # Does this system use a yum or a yum derivative (dnf)
        'is_rpm_based',                              # Does this system do its package management with rpms?
        'system_package_providing_perl',             # Name of the package providing system Perl
        'retry_rpm_cmd_no_tty_hack',                 # Hack: retry RPM comand when no TTY
        'can_clean_plugins_repo',                    # Can we clean the 'plugins' repo
        'repos_requires_dump_flag',                  # shiykd we use '--dump' when enabling a repo
        'rpm_versions_system',                       # Which rpm_versions_system is currently used
        'packages_arch',                             # Default architecture used by the rpm.versions system
        'package_ImageMagick_Devel',                 # Name of the imagemagick devel package
        'package_MySQL_Shell',                       # Name of the mysql-shell package (installed on demand)
        'package_crond',                             # Name of the package providing the cron daemon
        'plugins_repo_url',                          # URL to .repo / .list for cpanel-plugins
        'repo_suffix',                               # Suffix for repo files, such as .repo or .list
        'repo_dir',                                  # Local directory path where system repo config files are stored for the package manager
        'package_descriptions',                      # Description fields used in manage plugins

        'supports_cpanel_cloud_edition',             # Is cPCloud supported by this distro?

        'supports_cpaddons',                         # Are cpaddons supported by this distro?
        'supports_kernelcare',                       # Is Kernel Care available for this distro?
        'supports_kernelcare_free',                  # Is Kernel Care Free available for this distro? &lt;&lt; FACT CHECK (Note: This check implicitly ensures the system is not running CloudLinux)
        'supports_3rdparty_wpt',                     # Is Wordpress Toolkit supported on this platform?
        'supports_plugins_repo',                     # Is Cpanel::Plugins::Repo supported on this platform?
        'supports_or_can_become_cloudlinux',         # Does the system can become/or is CloudLinux?
        'can_become_cloudlinux',                     # Can the system become CloudLinux?
        'supports_imunify_av',                       # Can install Imunify AV
        'supports_imunify_av_plus',                  # Can install Imunify AV Plus
        'supports_imunify_360',                      # Can install Imunify AV 360
        'jetbackup_repo_pkg',                        # URL to the package we install to set up the JetBackup repo ( somewhere on http://repo.jetlicense.com/ )
        'supports_letsencrypt_v2',
        'supports_cpanel_analytics',
        'supports_phpels',                           # Does this system support the TuxCare PHP ELS product?

        'security_service',                          # What security service the distro is using? apparmor or selinux

        'firewall',                                  # Which firewall is this distro using? (iptables / firewalld_nftables / ufw_iptables)
        'firewall_module',                           # Which firewall module is used to manage it? (IpTables / NFTables)
        'networking',                                # Not sure what this is for. Nothing uses it. ( networkscripts / netplan ) &lt;&lt; FACT CHECK
        'iptables_ipv4_savefile',                    # Where to store iptables rules for IPv4
        'iptables_ipv6_savefile',                    # Where to store iptables rules for IPv6
        'sysconfig_network',                         # sysconfig networ file to use, undef when unused.
        'supports_hostaccess',                       # Does the system provide support for /etc/hosts.allow, etc.?
        'supports_inetd',                            # Does the system provide support for inetd?
        'supports_syslogd',                          # Does the system provide support for syslogd?
        'install_gcc_from_slc6_devtoolset',          # Do we need to install a custom gcc for building?
        'check_ntpd_pid_method',                     # Method used to check the ntp daemon pid
        'syslog_service_name',                       # Name of the service that handles syslog data, such as syslog, rsyslog, rsyslogd, etc, eg: `/usr/bin/systemctl show -p MainPID rsyslog.service`
        'cron_bin_path',                             # Path to the cron daemon
        'systemd_service_name_map',                  # Map of service names to possible counterparts, such as crond -&gt; cron
        'prelink_config_path',                       # Where do the control knobs for prelinking live?
        'pam_file_controlling_crypt_algo',           # Which file in /etc/pam.d manages the algorithm used to generate the passwd hash written to /etc/shadow for a user?
        'user_crontab_dir',                          # Path to directory where user crontabs are stored by the crontab binary
        'needs_els',                                 # Does this server require the ELS product

        'maillog_path',                              # Path to the mail.* syslog output as defined by the distro

        'nat_server_buffer_connections',             # Number of connections_required to trigger a test failure in simultaneous connections for NAT detection.

        'tuxcare_els_php_install_url',               # Do we support Tuxcare on this system if so, this is the url to the install script.
    );
}

sub supported_methods {
    return sort keys %methods;                       ##no critic qw( ProhibitReturnSort ) - this will always be a list.
}

our $AUTOLOAD;                                       # keep 'use strict' happy

sub AUTOLOAD {    ## no critic(RequireArgUnpacking) - Most of the time we do not need to process args.
    my $sub = $AUTOLOAD;
    $sub =~ s/.*:://;

    exists $methods{$sub} or Carp::croak(&quot;$sub is not a supported data variable for Cpanel::OS&quot;);

    my $i   = _instance();
    my $can = $i-&gt;can($sub) or Carp::croak( ref($i) . &quot; does not implement $sub&quot; );
    return $can-&gt;( $i, @_ );
}

sub list_contains_value ( $key, $value ) {
    my $array_ref = _instance()-&gt;$key;
    ref $array_ref eq 'ARRAY' or Carp::croak(&quot;$key is not a list!&quot;);
    if ( !defined $value ) {
        return ( grep { !defined $_ } @$array_ref ) ? 1 : 0;
    }
    return ( grep { $value eq $_ } @$array_ref ) ? 1 : 0;
}

sub DESTROY { }    # This is a must for autoload modules.


sub assert_unreachable_on_ubuntu ( $msg = &quot;Ubuntu reached somewhere it shouldn't!&quot; ) {
    Carp::croak($msg) if Cpanel::OS::base_distro() eq &quot;debian&quot;;
    return;
}

sub lookup_pretty_distro ($target) {


    require Cpanel::OS::All;

    my ( $name, $major ) = ( $target =~ m/^([A-Za-z]+)([0-9]+)$/ );
    return if !$name || !$major;
    return unless grep { $_-&gt;[0] eq $name &amp;&amp; $_-&gt;[1] == $major } Cpanel::OS::All::supported_distros();

    my $module = &quot;Cpanel::OS::$target&quot;;
    Cpanel::LoadModule::load_perl_module($module);

    my $pretty_name = $module-&gt;pretty_distro;
    return &quot;$pretty_name $major&quot;;
}

1;


} # --- END Cpanel/OS.pm


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


use cPstrict;
use Carp ();

# use Cpanel::OS ();
# use Cpanel::OS();
our @ISA;
BEGIN { push @ISA, qw(Cpanel::OS); }

use constant eol_advice                      =&gt; '';
use constant is_supported                    =&gt; 0;        # Base OS class for all platforms we currently support.
use constant support_needs_minor_at_least_at =&gt; undef;    # by default no restriction on minor version

use constant is_experimental  =&gt; 0;                       # By default, no distros are experimental.
use constant experimental_url =&gt; '';                      # ... and so no URL to document it.

use constant dns_supported                 =&gt; [qw{ powerdns }];    # All platforms support powerdns as it is our default.
use constant supports_3rdparty_wpt         =&gt; 1;                   # We support WPT on all platforms ATM.
use constant supports_plugins_repo         =&gt; 1;
use constant supports_imunify_av           =&gt; 0;
use constant supports_imunify_av_plus      =&gt; 0;
use constant supports_imunify_360          =&gt; 0;
use constant supports_letsencrypt_v2       =&gt; 1;
use constant supports_cpanel_analytics     =&gt; 1;
use constant supports_cpanel_cloud_edition =&gt; 0;

use constant can_elevate_to =&gt; [];

use constant setup_tz_method =&gt; q[timedatectl];

use constant nobody  =&gt; q[nobody];
use constant nogroup =&gt; q[nobody];

use constant default_uid_min     =&gt; 1_000;
use constant default_gid_min     =&gt; 1_000;
use constant default_sys_uid_min =&gt; 201;
use constant default_sys_gid_min =&gt; 201;

use constant dns_named_basedir =&gt; '/var/named';
use constant dns_named_conf    =&gt; '/etc/named.conf';
use constant dns_named_log     =&gt; '/var/log/named';
use constant service_manager   =&gt; 'systemd';
use constant arch              =&gt; 'x86_64';
use constant maillog_path      =&gt; '/var/log/maillog';

use constant supports_hostaccess =&gt; 1;

use constant rsyslog_triggered_by_socket =&gt; 0;

use constant packages_supplemental_epel =&gt; [];
use constant quota_packages_conditional =&gt; {};

use constant unsupported_db_versions =&gt; [];
use constant mariadb_repo_template   =&gt; '';    # Not provided on ubuntu for instance.

use constant mariadb_minimum_supported_version    =&gt; '10.0';
use constant mysql_default_version                =&gt; '5.7';
use constant postgresql_minimum_supported_version =&gt; undef;
use constant postgresql_packages                  =&gt; [];
use constant postgresql_service_aliases           =&gt; [];
use constant postgresql_initdb_commands           =&gt; [];
use constant openssl_minimum_supported_version    =&gt; '1.0.2e';

use constant ea4_install_repo_from_package =&gt; 0;
use constant ea4_from_pkg_url              =&gt; undef;
use constant ea4_from_pkg_reponame         =&gt; undef;
use constant ea4_from_custom_repo_url      =&gt; undef;
use constant ea4_from_custom_repo_path     =&gt; undef;
use constant ea4_testing_yum_repo          =&gt; undef;
use constant ea4tooling_all                =&gt; [qw{ ea-cpanel-tools ea-profiles-cpanel }];

sub ea4tooling_dnsonly   { return Carp::confess('unimplemented for this distro') }
sub ea4tooling           { return Carp::confess('unimplemented for this distro') }
sub system_exclude_rules { return Carp::confess('unimplemented for this distro') }
sub base_distro          { return Carp::confess('unimplemented for this distro') }

sub kernel_package_pattern { return Carp::confess('unimplemented for this distro') }
use constant check_kernel_version_method =&gt; q[grubby];
use constant stock_kernel_version_regex  =&gt; undef;

sub mysql_versions_use_repo_template   { return Carp::confess('unimplemented for this distro') }
sub mariadb_versions_use_repo_template { return Carp::confess('unimplemented for this distro') }

sub binary_sync_source { return Carp::confess('unimplemented for this distro') }

use constant package_repositories =&gt; [];

use constant release_codename              =&gt; undef;
use constant system_package_providing_perl =&gt; 'perl';

use constant rpm_versions_system =&gt; 'centos';
use constant packages_arch       =&gt; 'x86_64';

use constant package_MySQL_Shell =&gt; q[mysql-shell];
use constant package_crond       =&gt; undef;

use constant retry_rpm_cmd_no_tty_hack =&gt; 0;

use constant check_ntpd_pid_method =&gt; 'pid_check_var_run_ntpd';    # how to check ntp daemon pid

use constant prelink_config_path =&gt; undef;

use constant pam_file_controlling_crypt_algo =&gt; undef;

use constant iptables_ipv4_savefile =&gt; '/etc/sysconfig/iptables';
use constant iptables_ipv6_savefile =&gt; '/etc/sysconfig/ip6tables';
use constant sysconfig_network      =&gt; q[/etc/sysconfig/network];

use constant bin_grub_mkconfig =&gt; q[/usr/sbin/grub2-mkconfig];

use constant ssh_supported_algorithms =&gt; [qw{ ed25519 ecdsa rsa }];

use constant bin_needs_restarting =&gt; q[/usr/local/cpanel/bin/needs-restarting-cpanel];

use constant outdated_services_check  =&gt; q[default];
use constant outdated_processes_check =&gt; q[default];
use constant check_reboot_method      =&gt; q[default];

use constant program_to_apply_kernel_args =&gt; undef;

use constant security_service =&gt; 'selinux';

use constant supports_kernelcare                       =&gt; 0;
use constant supports_kernelcare_free                  =&gt; 0;
use constant supports_or_can_become_cloudlinux         =&gt; 0;
use constant can_become_cloudlinux                     =&gt; 0;
use constant supports_inetd                            =&gt; 0;
use constant supports_syslogd                          =&gt; 0;
use constant install_gcc_from_slc6_devtoolset          =&gt; 0;
use constant supports_postgresql                       =&gt; 0;
use constant openssl_escapes_subjects                  =&gt; 0;
use constant has_cloudlinux_enhanced_quotas            =&gt; 0;
use constant ea4_install_from_profile_enforce_packages =&gt; 0;
use constant repos_requires_dump_flag                  =&gt; 0;
use constant is_cloudlinux                             =&gt; 0;
use constant can_be_elevated                           =&gt; 0;
use constant kernel_supports_fs_protected_regular      =&gt; 0;
use constant needs_els                                 =&gt; 0;

use constant has_quota_support_for_xfs =&gt; 1;
use constant is_systemd                =&gt; 1;
use constant has_tcp_wrappers          =&gt; 1;
use constant can_clean_plugins_repo    =&gt; 1;
use constant supports_cpaddons         =&gt; 1;

use constant pretty_distro =&gt; undef;

sub display_name {
    return sprintf( &quot;%s v%s.%s.%s&quot;, Cpanel::OS::pretty_distro() // '', Cpanel::OS::major() // '', Cpanel::OS::minor() // '', Cpanel::OS::build() // '' );    ## no critic(Cpanel::CpanelOS) internal usage
}

sub display_name_lite {
    return sprintf( &quot;%s %s&quot;, lc( Cpanel::OS::distro() // '' ), Cpanel::OS::major() // '' );                                                                  ## no critic(Cpanel::CpanelOS) internal usage
}

sub cpanalytics_cpos {
    return sprintf( &quot;%s %s.%s&quot;, uc( Cpanel::OS::distro() // '' ), Cpanel::OS::major() // '', Cpanel::OS::minor() // '' );                                    ## no critic(Cpanel::CpanelOS) internal usage
}

use constant nat_server_buffer_connections =&gt; 4;

use constant tuxcare_els_php_install_url =&gt; '';

1;


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


{ # --- BEGIN Cpanel/OS/Rhel.pm
package Cpanel::OS::Rhel;


use cPstrict;

# use Cpanel::OS::Linux ();    # ea4tooling_all
# use Cpanel::OS::Linux();
our @ISA;
BEGIN { push @ISA, qw(Cpanel::OS::Linux); }

use constant is_supported =&gt; 0;    # Base OS class for all Rhel derivatives.

use constant pretty_distro =&gt; 'Red Hat Enterprise Linux';

use constant sudoers         =&gt; 'wheel';
use constant has_wheel_group =&gt; 1;

use constant dns_supported                     =&gt; [qw{ bind powerdns }];
use constant supports_kernelcare               =&gt; 1;
use constant supports_kernelcare_free          =&gt; 1;
use constant supports_or_can_become_cloudlinux =&gt; 1;
use constant can_become_cloudlinux             =&gt; 1;
use constant supports_imunify_av               =&gt; 1;
use constant supports_imunify_av_plus          =&gt; 1;

use constant cron_bin_path                   =&gt; '/usr/sbin/crond';
use constant systemd_service_name_map        =&gt; {};
use constant ea4_modern_openssl              =&gt; '/opt/cpanel/ea-openssl11/bin/openssl';
use constant firewall                        =&gt; 'iptables';
use constant firewall_module                 =&gt; 'IpTables';
use constant networking                      =&gt; 'networkscripts';
use constant package_manager                 =&gt; 'yum';
use constant package_manager_module          =&gt; 'Yum';
use constant base_distro                     =&gt; 'rhel';
use constant is_apt_based                    =&gt; 0;
use constant is_yum_based                    =&gt; 1;
use constant is_rpm_based                    =&gt; 1;
use constant kernel_package_pattern          =&gt; 'kernel';
use constant stock_kernel_version_regex      =&gt; qr/\.(?:noarch|x86_64|i[3-6]86)$/;
use constant program_to_apply_kernel_args    =&gt; 'grub2-mkconfig';
use constant prelink_config_path             =&gt; '/etc/sysconfig/prelink';
use constant pam_file_controlling_crypt_algo =&gt; 'system-auth';
use constant user_crontab_dir                =&gt; '/var/spool/cron';

use constant ea4_from_custom_repo_url  =&gt; 'https://securedownloads.cpanel.net/EA4/EA4.repo';
use constant ea4_from_custom_repo_path =&gt; '/etc/yum.repos.d/EA4.repo';

use constant ea4_conflicting_apache_distro_packages =&gt; [qw( httpd httpd-tools php-cli )];

use constant ea4tooling =&gt; [ 'yum-plugin-universal-hooks', Cpanel::OS::Linux-&gt;ea4tooling_all-&gt;@* ];

use constant ea4tooling_dnsonly =&gt; ['yum-plugin-universal-hooks'];

use constant syslog_service_name =&gt; 'rsyslogd';

use constant jetbackup_repo_pkg =&gt; 'https://repo.jetlicense.com/centOS/jetapps-repo-latest.rpm';

use constant plugins_repo_url =&gt; 'https://securedownloads.cpanel.net/cpanel-plugins/0/cpanel-plugins.repo';

use constant repo_suffix =&gt; 'repo';
use constant repo_dir    =&gt; '/etc/yum.repos.d';

use constant system_exclude_rules =&gt; {
    'dovecot'     =&gt; 'dovecot*',
    'nsd'         =&gt; 'nsd*',
    'php'         =&gt; 'php*',
    'exim'        =&gt; 'exim*',
    'pure-ftpd'   =&gt; 'pure-ftpd*',
    'proftpd'     =&gt; 'proftpd*',
    'p0f'         =&gt; 'p0f',
    'filesystem'  =&gt; 'filesystem',
    'kernel'      =&gt; 'kernel kernel-xen kernel-smp kernel-pae kernel-PAE kernel-SMP kernel-hugemem kernel-debug* kernel-core kernel-modules',
    'kmod-'       =&gt; 'kmod-[a-z]*',
    'bind-chroot' =&gt; 'bind-chroot',
};

use constant packages_supplemental =&gt; [

    'nfs-utils',

    qw{
      ImageMagick
      autoconf
      automake
      bind-devel
      bison
      boost-serialization
      cairo
      e2fsprogs-devel
      expat-devel
      flex
      fontconfig
      freetype
      ftp
      gcc-c++
      gd-devel
      gdbm-devel
      gettext-devel
      ghostscript
      giflib
      glib2
      hunspell
      hunspell-en
      krb5-devel
      libX11-devel
      libXpm
      libXpm-devel
      libaio-devel
      libidn-devel
      libjpeg-turbo-devel
      libpng-devel
      libstdc++-devel
      libtiff-devel
      libtool
      libtool-ltdl
      libtool-ltdl-devel
      libwmf
      libxml2-devel
      libxslt-devel
      ncurses
      ncurses-devel
      nscd
      openssl-devel
      pango
      perl-CPAN
      perl-ExtUtils-MakeMaker
      perl-IO-Tty
      perl-Module-Build
      perl-YAML-Syck
      perl-core
      perl-devel
      perl-libwww-perl
      pixman
      python-devel
      python-tools
      quota-devel
      strace
      sysstat
      tcp_wrappers-devel
      traceroute
      urw-fonts
      zlib-devel
    }
];

use constant packages_supplemental_epel =&gt; [
    qw{
      perl-Expect
      perl-JSON-XS
      perl-Try-Tiny
      perl-local-lib
    }
];

use constant packages_required =&gt; [
    qw{
      aspell
      at
      bind
      bind-libs
      bind-utils
      binutils
      boost-program-options
      bzip2
      compat-db
      coreutils
      cpio
      cpp
      crontabs
      curl
      db4
      db4-devel
      e2fsprogs
      expat
      file
      gawk
      gcc
      gd
      gd-progs
      gdbm
      gettext
      glibc-devel
      gmp
      gnupg2
      grubby
      gzip
      initscripts
      iptables
      iptables-ipv6
      json-c
      kernel-headers
      lcms
      less
      libaio
      libevent
      libgcc
      libgomp
      libicu
      libidn
      libjpeg-turbo
      libpcap
      libpng
      libstdc++
      libtiff
      libxml2
      libxslt
      libzip
      libzstd
      lsof
      make
      nano
      openssh
      openssh-clients
      openssh-server
      openssl
      pam
      pam-devel
      passwd
      patch
      pcre
      pcre2
      popt
      postgresql-libs
      procps
      python
      python-docs
      python-setuptools
      quota
      rdate
      rsync
      sed
      shadow-utils
      smartmontools
      tar
      tmpwatch
      unzip
      util-linux-ng
      wget
      which
      xz
      yum-utils
      zip
      zlib
    }
];

use constant package_ImageMagick_Devel =&gt; 'ImageMagick-devel';
use constant package_crond             =&gt; 'cronie';

use constant mysql_incompatible =&gt; [
    qw{
      mariadb-client
      mariadb-devel
      mariadb-embedded
      mariadb-embedded-devel
      mariadb-libs
      mariadb-libs-compat
      mariadb-release
      mariadb-server
      mariadb-test
      mysql-client
      mysql-devel
      mysql-embedded
      mysql-embedded-devel
      mysql-libs
      mysql-libs-compat
      mysql-release
      mysql-server
      mysql-test
      mysql55-mysql-bench
      mysql55-mysql-devel
      mysql55-mysql-libs
      mysql55-mysql-server
      mysql55-mysql-test
      mysqlclient16
      rh-mysql56-mysql-bench
      rh-mysql56-mysql-common
      rh-mysql56-mysql-config
      rh-mysql56-mysql-devel
      rh-mysql56-mysql-errmsg
      rh-mysql56-mysql-server
      rh-mysql56-mysql-test
      rh-mysql57-mysql-common
      rh-mysql57-mysql-config
      rh-mysql57-mysql-devel
      rh-mysql57-mysql-errmsg
      rh-mysql57-mysql-server
      rh-mysql57-mysql-test
    }
];

use constant mysql_community_packages =&gt; [
    qw/
      mysql-community-devel
      mysql-community-libs-compat
      mysql-community-server
      /
];
use constant mysql_dependencies =&gt; [
    qw/
      coreutils
      grep
      perl-DBI
      shadow-utils
      /
];

use constant db_package_manager_key_params =&gt; {
    method =&gt; 'add_repo_key',
    keys   =&gt; [qw{https://repo.mysql.com/RPM-GPG-KEY-mysql-2023 https://repo.mysql.com/RPM-GPG-KEY-MySQL-2022 https://repo.mysql.com/RPM-GPG-KEY-mysql https://archive.mariadb.org/PublicKey https://supplychain.mariadb.com/MariaDB-Server-GPG-KEY}],
};

use constant mariadb_repo_template =&gt; &lt;&lt;'___END_REPO_TEMPLATE___';
[MariaDB###MARIADB_FLAT_VERSION_SHORT###]
name = MariaDB###MARIADB_FLAT_VERSION_SHORT###
baseurl = https://archive.mariadb.org/mariadb-###MARIADB_VERSION_SHORT###/yum/rhel/###DISTRO_MAJOR###/x86_64
gpgkey=https://archive.mariadb.org/PublicKey
       https://supplychain.mariadb.com/MariaDB-Server-GPG-KEY
gpgcheck=1
___END_REPO_TEMPLATE___

use constant mysql_repo_template =&gt; &lt;&lt;'___END_REPO_TEMPLATE___';
[Mysql-connectors-community]
name=MySQL Connectors Community
baseurl=https://repo.mysql.com/yum/mysql-connectors-community/el/###DISTRO_MAJOR###/$basearch/
enabled=1
gpgcheck=1
gpgkey=https://repo.mysql.com/RPM-GPG-KEY-mysql-2023
       https://repo.mysql.com/RPM-GPG-KEY-MySQL-2022
       https://repo.mysql.com/RPM-GPG-KEY-mysql
[Mysql-tools-community]
name=MySQL Tools Community
baseurl=https://repo.mysql.com/yum/mysql-tools-community/el/###DISTRO_MAJOR###/$basearch/
enabled=1
gpgcheck=1
gpgkey=https://repo.mysql.com/RPM-GPG-KEY-mysql-2023
       https://repo.mysql.com/RPM-GPG-KEY-MySQL-2022
       https://repo.mysql.com/RPM-GPG-KEY-mysql
[Mysql###MYSQL_FLAT_VERSION_SHORT###-community]
name=MySQL ###MYSQL_VERSION_SHORT### Community Server
baseurl=https://repo.mysql.com/yum/mysql-###MYSQL_VERSION_SHORT###-community/el/###DISTRO_MAJOR###/$basearch/
enabled=1
gpgcheck=1
gpgkey=https://repo.mysql.com/RPM-GPG-KEY-mysql-2023
       https://repo.mysql.com/RPM-GPG-KEY-MySQL-2022
       https://repo.mysql.com/RPM-GPG-KEY-mysql
[Mysql-tools-preview]
name=MySQL Tools Preview
baseurl=https://repo.mysql.com/yum/mysql-tools-preview/el/###DISTRO_MAJOR###/$basearch/
enabled=0
gpgcheck=1
gpgkey=https://repo.mysql.com/RPM-GPG-KEY-mysql-2023
       https://repo.mysql.com/RPM-GPG-KEY-MySQL-2022
       https://repo.mysql.com/RPM-GPG-KEY-mysql
___END_REPO_TEMPLATE___

use constant supports_postgresql =&gt; 1;

use constant package_descriptions =&gt; {
    'short' =&gt; 'summary',
    'long'  =&gt; 'description',
};

use constant tuxcare_els_php_install_url =&gt; &quot;https://go.cpanel.net/install-els-alt-php-rpm-repo-ip&quot;;
use constant supports_phpels             =&gt; 1;

1;


} # --- END Cpanel/OS/Rhel.pm


{ # --- BEGIN Cpanel/OS/Almalinux.pm
package Cpanel::OS::Almalinux;


use cPstrict;

# use Cpanel::OS::Rhel();
our @ISA;
BEGIN { push @ISA, qw(Cpanel::OS::Rhel); }

use constant is_supported =&gt; 0;

use constant pretty_distro =&gt; 'AlmaLinux';

1;


} # --- END Cpanel/OS/Almalinux.pm


{ # --- BEGIN Cpanel/OS/Rhel6.pm
package Cpanel::OS::Rhel6;


use cPstrict;

# use Cpanel::OS::Rhel();
our @ISA;
BEGIN { push @ISA, qw(Cpanel::OS::Rhel); }

use constant is_supported =&gt; 0;

use constant binary_sync_source         =&gt; 'linux-c6-x86_64';
use constant package_release_distro_tag =&gt; '~el6';

use constant service_manager                    =&gt; 'initd';
use constant unsupported_db_versions            =&gt; [qw/10.5 10.6/];
use constant mariadb_versions_use_repo_template =&gt; [qw/10.0 10.1 10.2 10.3/];
use constant mysql_versions_use_repo_template   =&gt; [qw/8.0/];

use constant dns_supported =&gt; [qw{ bind }];

use constant who_wins_if_soft_gt_hard =&gt; 'hard';

use constant postgresql_minimum_supported_version =&gt; '7.4';

use constant postgresql_packages =&gt; [
    qw{
      postgresql      postgresql-devel    postgresql-libs     postgresql-server
      rh-postgresql   rh-postgresql-devel rh-postgresql-libs  rh-postgresql-server
    }
];

use constant postgresql_service_aliases =&gt; [qw/rhdb/];
use constant postgresql_initdb_commands =&gt; ['/sbin/service postgresql initdb'];

1;


} # --- END Cpanel/OS/Rhel6.pm


{ # --- BEGIN Cpanel/OS/Rhel7.pm
package Cpanel::OS::Rhel7;


use cPstrict;

# use Cpanel::OS::Rhel6();
our @ISA;
BEGIN { push @ISA, qw(Cpanel::OS::Rhel6); }

use constant is_supported =&gt; 1;    # Rhel 7 support

use constant binary_sync_source         =&gt; 'linux-c7-x86_64';
use constant package_release_distro_tag =&gt; '~el7';

use constant service_manager                    =&gt; 'systemd';
use constant unsupported_db_versions            =&gt; [];
use constant mariadb_versions_use_repo_template =&gt; [qw/10.0 10.1 10.2 10.3 10.5 10.6/];
use constant mysql_versions_use_repo_template   =&gt; [qw/5.7 8.0/];

use constant dns_supported =&gt; [qw{ bind powerdns }];

use constant who_wins_if_soft_gt_hard =&gt; 'soft';

use constant postgresql_minimum_supported_version =&gt; '9.2';
use constant postgresql_service_aliases           =&gt; [];
use constant postgresql_initdb_commands           =&gt; ['/usr/bin/postgresql-setup initdb'];

use constant check_ntpd_pid_method =&gt; 'systemd_ntpd';

sub packages_supplemental ($self) {
    my @packages = $self-&gt;SUPER::packages_supplemental()-&gt;@*;
    push @packages, qw/ncurses-term perl-Try-Tiny perl-local-lib/;

    return [ sort @packages ];
}

sub packages_supplemental_epel ($self) {
    my @packages = $self-&gt;SUPER::packages_supplemental_epel()-&gt;@*;

    push @packages, qw/dpkg/;

    @packages = grep {
        my $p = $_;
        !grep { $p eq $_ } qw/perl-Try-Tiny perl-local-lib/;
    } @packages;

    return [ sort @packages ];
}

sub packages_required ($self) {
    my @packages = $self-&gt;SUPER::packages_required()-&gt;@*;
    @packages = grep {
        my $p = $_;
        !grep { $p eq $_ } qw/db4 db4-devel iptables-ipv6 lcms procps tmpwatch util-linux-ng/
    } @packages;
    push @packages, qw/libdb libmount net-tools procps-ng psmisc python-tools/;
    push @packages, 'boost169-program-options' if $self-&gt;major == 7;

    return [ sort @packages ];
}

1;


} # --- END Cpanel/OS/Rhel7.pm


{ # --- BEGIN Cpanel/OS/Rhel8.pm
package Cpanel::OS::Rhel8;


use cPstrict;

# use Cpanel::OS::Linux ();    # ea4tooling_all
# use Cpanel::OS::Rhel7();
our @ISA;
BEGIN { push @ISA, qw(Cpanel::OS::Rhel7); }

use constant is_supported =&gt; 0;    # Rhel 8 is NOT supported but we use it as a base class for all Rhel derivatives.

use constant binary_sync_source =&gt; 'linux-c8-x86_64';

use constant ea4_modern_openssl  =&gt; '/usr/bin/openssl';
use constant firewall            =&gt; 'firewalld_nftables';
use constant firewall_module     =&gt; 'NFTables';
use constant supports_hostaccess =&gt; 0;
use constant package_manager     =&gt; 'dnf';

use constant package_release_distro_tag =&gt; '~el8';

use constant kernel_supports_fs_protected_regular =&gt; 1;

use constant can_clean_plugins_repo =&gt; 0;

use constant mysql_community_packages          =&gt; [qw/mysql-community-server mysql-community-devel/];    # Removed mysql-community-libs-compat in RHEL 8
use constant mysql_default_version             =&gt; '8.0';
use constant mariadb_minimum_supported_version =&gt; '10.3';

use constant postgresql_packages =&gt; [
    qw{
      postgresql      postgresql-devel    postgresql-libs     postgresql-server
    }
];

use constant openssl_escapes_subjects =&gt; 1;

use constant ea4tooling_dnsonly =&gt; ['dnf-plugin-universal-hooks'];
use constant ea4tooling         =&gt; [ 'dnf-plugin-universal-hooks', Cpanel::OS::Linux-&gt;ea4tooling_all-&gt;@* ];

use constant package_repositories =&gt; [qw/epel powertools/];

use constant system_package_providing_perl =&gt; 'perl-interpreter';

use constant retry_rpm_cmd_no_tty_hack =&gt; 1;

use constant check_ntpd_pid_method =&gt; 'pid_check_var_run_ntpd';
use constant has_tcp_wrappers      =&gt; 0;

use constant ea4_install_from_profile_enforce_packages =&gt; 1;

use constant repos_requires_dump_flag =&gt; 1;

use constant system_exclude_rules =&gt; {
    'dovecot'     =&gt; 'dovecot*',
    'php'         =&gt; 'php*',
    'exim'        =&gt; 'exim*',
    'pure-ftpd'   =&gt; 'pure-ftpd*',
    'proftpd'     =&gt; 'proftpd*',
    'p0f'         =&gt; 'p0f',
    'filesystem'  =&gt; 'filesystem',
    'kernel'      =&gt; 'kernel kernel-xen kernel-smp kernel-pae kernel-PAE kernel-SMP kernel-hugemem kernel-debug* kernel-core kernel-modules*',
    'kmod-'       =&gt; 'kmod-[a-z]*',
    'bind-chroot' =&gt; 'bind-chroot',
};

use constant bin_needs_restarting =&gt; q[/usr/bin/needs-restarting];

sub packages_supplemental ($self) {
    my @packages = $self-&gt;SUPER::packages_supplemental()-&gt;@*;

    @packages = grep {
        my $p = $_;
        !grep { $p eq $_ } qw/ncurses-term python-devel python-tools quota-devel tcp_wrappers-devel/
    } @packages;
    push @packages, qw{ python2-devel };

    return [ sort @packages ];
}

sub packages_required ($self) {
    my @packages = $self-&gt;SUPER::packages_required()-&gt;@*;

    @packages = grep {
        my $p = $_;
        !grep { $p eq $_ } qw/compat-db gd-progs libdb libmount procps-ng psmisc python python-docs python-setuptools python-tools rdate /
    } @packages;
    push @packages, qw/dnf glibc-locale-source mailx nftables python2 python2-docs python2-setuptools python2-tools python3-dnf python3-docs python3-libdnf python3-setuptools python36 util-linux-user sqlite cmake-filesystem/;

    return [ sort @packages ];
}

use constant nat_server_buffer_connections =&gt; 2;

1;


} # --- END Cpanel/OS/Rhel8.pm


{ # --- BEGIN Cpanel/OS/Almalinux8.pm
package Cpanel::OS::Almalinux8;


use cPstrict;

use Cpanel::OS::Almalinux;
# use Cpanel::OS::Rhel8();
our @ISA;
BEGIN { push @ISA, qw(Cpanel::OS::Rhel8); }

use constant is_supported =&gt; 1;    # Almalinux 8

use constant pretty_distro =&gt; Cpanel::OS::Almalinux-&gt;pretty_distro;

use constant supports_imunify_360 =&gt; 1;

use constant supports_cpanel_cloud_edition =&gt; 1;

1;


} # --- END Cpanel/OS/Almalinux8.pm


{ # --- BEGIN Cpanel/OS/Centos.pm
package Cpanel::OS::Centos;


use cPstrict;

# use Cpanel::OS::Rhel();
our @ISA;
BEGIN { push @ISA, qw(Cpanel::OS::Rhel); }

use constant is_supported =&gt; 0;    # Base OS class for all Centos derivatives.

use constant pretty_distro =&gt; 'CentOS';

1;


} # --- END Cpanel/OS/Centos.pm


{ # --- BEGIN Cpanel/OS/Centos7.pm
package Cpanel::OS::Centos7;


use cPstrict;

use Cpanel::OS::Centos;
# use Cpanel::OS::Rhel7();
our @ISA;
BEGIN { push @ISA, qw(Cpanel::OS::Rhel7); }

use constant is_supported =&gt; 1;    # Centos 7

use constant pretty_distro =&gt; Cpanel::OS::Centos-&gt;pretty_distro;

use constant supports_imunify_360 =&gt; 1;

use constant can_be_elevated =&gt; 1;
use constant can_elevate_to  =&gt; [qw(Almalinux8)];

use constant needs_els =&gt; 1;

1;


} # --- END Cpanel/OS/Centos7.pm


{ # --- BEGIN Cpanel/OS/Cloudlinux.pm
package Cpanel::OS::Cloudlinux;


use cPstrict;

# use Cpanel::OS::Rhel();
our @ISA;
BEGIN { push @ISA, qw(Cpanel::OS::Rhel); }

use constant is_supported =&gt; 0;    # Base class for CL.

use constant is_cloudlinux =&gt; 1;

use constant pretty_distro =&gt; 'CloudLinux';

use constant ea4_yum_tooling =&gt; [qw{ yum-plugin-universal-hooks ea-cpanel-tools ea-profiles-cloudlinux }];
use constant ea4_dnf_tooling =&gt; [qw{ dnf-plugin-universal-hooks ea-cpanel-tools ea-profiles-cloudlinux }];

use constant supports_kernelcare_free =&gt; 0;

1;


} # --- END Cpanel/OS/Cloudlinux.pm


{ # --- BEGIN Cpanel/OS/Cloudlinux6.pm
package Cpanel::OS::Cloudlinux6;


use cPstrict;

# use Cpanel::OS ();
use Cpanel::OS::Cloudlinux;

# use Cpanel::OS::Rhel6();
our @ISA;
BEGIN { push @ISA, qw(Cpanel::OS::Rhel6); }

use constant is_cloudlinux =&gt; 1;

use constant default_uid_min =&gt; 500;
use constant default_gid_min =&gt; 500;

use constant setup_tz_method =&gt; q[sysconfig];

use constant pretty_distro =&gt; Cpanel::OS::Cloudlinux-&gt;pretty_distro;

use constant ea4_install_repo_from_package =&gt; 1;
use constant ea4_from_pkg_url              =&gt; 'https://repo.cloudlinux.com/cloudlinux/EA4/cloudlinux-ea4-release-latest-6.noarch.rpm';
use constant ea4_from_pkg_reponame         =&gt; 'cloudlinux-ea4-release';
use constant ea4_from_custom_repo_url      =&gt; undef;
use constant ea4_from_custom_repo_path     =&gt; undef;

use constant ea4tooling =&gt; Cpanel::OS::Cloudlinux-&gt;ea4_yum_tooling;

use constant supports_kernelcare_free =&gt; Cpanel::OS::Cloudlinux-&gt;supports_kernelcare_free;

use constant has_quota_support_for_xfs    =&gt; 0;
use constant program_to_apply_kernel_args =&gt; 'none';

use constant ssh_supported_algorithms =&gt; [qw{ ecdsa rsa }];

use constant supports_inetd                   =&gt; 1;
use constant supports_syslogd                 =&gt; 1;
use constant install_gcc_from_slc6_devtoolset =&gt; 1;
use constant is_systemd                       =&gt; 0;

use constant openssl_minimum_supported_version =&gt; 0;    # check skipped on CL6
use constant has_cloudlinux_enhanced_quotas    =&gt; 1;
use constant can_become_cloudlinux             =&gt; 0;
use constant supports_imunify_360              =&gt; 1;

use constant outdated_services_check =&gt; q[centos6];

sub packages_required ($self) {
    my @packages = $self-&gt;SUPER::packages_required()-&gt;@*;
    push @packages, qw/alt-libcurlssl alt-libxml2/;
    return [ sort @packages ];
}

use constant is_supported =&gt; 0;

1;


} # --- END Cpanel/OS/Cloudlinux6.pm


{ # --- BEGIN Cpanel/OS/Cloudlinux7.pm
package Cpanel::OS::Cloudlinux7;


use cPstrict;

use Cpanel::OS::Cloudlinux;
# use Cpanel::OS::Rhel7();
our @ISA;
BEGIN { push @ISA, qw(Cpanel::OS::Rhel7); }

use constant is_supported  =&gt; 1;    # Cloudlinux 7
use constant is_cloudlinux =&gt; 1;

use constant pretty_distro =&gt; Cpanel::OS::Cloudlinux-&gt;pretty_distro;

use constant can_be_elevated =&gt; 1;
use constant can_elevate_to  =&gt; [qw(Cloudlinux8)];

use constant ea4_install_repo_from_package =&gt; 1;
use constant ea4_from_pkg_url              =&gt; 'https://repo.cloudlinux.com/cloudlinux/EA4/cloudlinux-ea4-release-latest-7.noarch.rpm';
use constant ea4_from_pkg_reponame         =&gt; 'cloudlinux-ea4-release';
use constant ea4_from_custom_repo_url      =&gt; undef;
use constant ea4_from_custom_repo_path     =&gt; undef;

use constant ea4tooling =&gt; Cpanel::OS::Cloudlinux-&gt;ea4_yum_tooling;

use constant supports_kernelcare_free =&gt; Cpanel::OS::Cloudlinux-&gt;supports_kernelcare_free;

use constant has_cloudlinux_enhanced_quotas =&gt; 1;
use constant program_to_apply_kernel_args   =&gt; 'none';
use constant can_become_cloudlinux          =&gt; 0;
use constant supports_imunify_360           =&gt; 1;

1;


} # --- END Cpanel/OS/Cloudlinux7.pm


{ # --- BEGIN Cpanel/OS/Cloudlinux8.pm
package Cpanel::OS::Cloudlinux8;


use cPstrict;

use Cpanel::OS::Cloudlinux;
# use Cpanel::OS::Rhel8();
our @ISA;
BEGIN { push @ISA, qw(Cpanel::OS::Rhel8); }

use constant is_supported =&gt; 1;    # Cloudlinux 8

use constant is_cloudlinux =&gt; 1;

use constant pretty_distro =&gt; Cpanel::OS::Cloudlinux-&gt;pretty_distro;

use constant ea4_install_from_profile_enforce_packages =&gt; 0;

use constant ea4_install_repo_from_package =&gt; 1;
use constant ea4_from_pkg_url              =&gt; 'https://repo.cloudlinux.com/cloudlinux/EA4/cloudlinux-ea4-release-latest-8.noarch.rpm';
use constant ea4_from_pkg_reponame         =&gt; 'cloudlinux-ea4-release';
use constant ea4_from_custom_repo_url      =&gt; undef;
use constant ea4_from_custom_repo_path     =&gt; undef;
use constant ea4_testing_yum_repo          =&gt; 'cl-ea4-testing';

use constant ea4tooling           =&gt; Cpanel::OS::Cloudlinux-&gt;ea4_dnf_tooling;
use constant package_repositories =&gt; [qw/cloudlinux-PowerTools epel/];

use constant supports_kernelcare_free       =&gt; Cpanel::OS::Cloudlinux-&gt;supports_kernelcare_free;
use constant has_cloudlinux_enhanced_quotas =&gt; 1;
use constant can_become_cloudlinux          =&gt; 0;
use constant supports_imunify_360           =&gt; 1;

1;


} # --- END Cpanel/OS/Cloudlinux8.pm


{ # --- BEGIN Cpanel/OS/Ubuntu.pm
package Cpanel::OS::Ubuntu;


use cPstrict;

# use Cpanel::OS::Linux ();    # ea4tooling_all
# use Cpanel::OS::Linux();
our @ISA;
BEGIN { push @ISA, qw(Cpanel::OS::Linux); }
use constant is_supported =&gt; 0;

use constant nogroup         =&gt; q[nogroup];
use constant sudoers         =&gt; 'sudo';       # Warning: need to change dynamicui.conf when updating this value
use constant has_wheel_group =&gt; 0;

use constant default_sys_uid_min =&gt; 100;
use constant default_sys_gid_min =&gt; 100;

use constant pretty_distro =&gt; 'Ubuntu';

use constant firewall               =&gt; 'ufw_iptables';
use constant firewall_module        =&gt; 'IpTables';
use constant networking             =&gt; 'netplan';
use constant sysconfig_network      =&gt; undef;
use constant package_manager        =&gt; 'apt';
use constant package_manager_module =&gt; 'Apt';
use constant is_apt_based           =&gt; 1;
use constant is_yum_based           =&gt; 0;
use constant is_rpm_based           =&gt; 0;
use constant base_distro            =&gt; 'debian';

use constant supports_cpaddons =&gt; 0;

use constant kernel_supports_fs_protected_regular =&gt; 1;

use constant rpm_versions_system =&gt; 'ubuntu';
use constant packages_arch       =&gt; 'amd64';

use constant mariadb_versions_use_repo_template =&gt; [];
use constant mysql_versions_use_repo_template   =&gt; ['8.0'];

use constant db_package_manager_key_params =&gt; {
    method =&gt; 'add_repo_key_by_id',

    keys =&gt; [
        'A8D3785C',    # For MySQL 8.0.36 and up
        '3A79BD29',    # For MySQL 8.0.28 and up
        '5072E1F5',    # For MySQL 8.0.27 and below
        'C74CD1D8',    # For all MariaDB versions
    ],
};

use constant who_wins_if_soft_gt_hard =&gt; 'hard';

use constant security_service                =&gt; 'apparmor';
use constant cron_bin_path                   =&gt; '/usr/sbin/cron';
use constant systemd_service_name_map        =&gt; { 'crond' =&gt; 'cron' };
use constant ea4_modern_openssl              =&gt; '/usr/bin/openssl';
use constant kernel_package_pattern          =&gt; '^linux-image-[0-9]';
use constant check_kernel_version_method     =&gt; q[boot-vmlinuz-file];
use constant stock_kernel_version_regex      =&gt; qr/-(?:(?:(?:generic|lowlatency)(?:-hwe)?)|kvm|aws|azure|gcp|oracle)$/;
use constant openssl_escapes_subjects        =&gt; 1;
use constant prelink_config_path             =&gt; '/etc/default/prelink';
use constant pam_file_controlling_crypt_algo =&gt; 'common-password';
use constant user_crontab_dir                =&gt; '/var/spool/cron/crontabs';

use constant supports_kernelcare      =&gt; 1;
use constant supports_kernelcare_free =&gt; 1;

use constant iptables_ipv4_savefile =&gt; '/etc/iptables/rules.v4';
use constant iptables_ipv6_savefile =&gt; '/etc/iptables/rules.v6';

use constant mysql_incompatible =&gt; [
    qw{
      default-mysql-server
      default-mysql-server-core
      mariadb-client
      mariadb-client-10.3
      mariadb-server
      mariadb-server-10.3
      mariadb-test
      mysql-client-8.0
      mysql-server-8.0
      mysql-testsuite
      mysql-testsuite-8.0
    }
];

use constant mysql_community_packages          =&gt; [qw/mysql-community-server mysql-shell libmysqlclient-dev/];
use constant mysql_dependencies                =&gt; [qw/libdbi-perl passwd adduser login coreutils/];
use constant mysql_default_version             =&gt; '8.0';
use constant mariadb_minimum_supported_version =&gt; '10.3';

use constant outdated_services_check  =&gt; q[needrestart_b];
use constant outdated_processes_check =&gt; q[checkrestart];
use constant check_reboot_method      =&gt; q[check-reboot-required];
use constant bin_needs_restarting     =&gt; undef;                      # The needs-restarting program is not supported on Ubuntu, so blank it out to reduce confusion.

use constant syslog_service_name         =&gt; 'rsyslog';
use constant rsyslog_triggered_by_socket =&gt; 1;
use constant ea4_from_custom_repo_url    =&gt; 'https://securedownloads.cpanel.net/EA4/EA4.list';
use constant ea4_from_custom_repo_path   =&gt; '/etc/apt/sources.list.d/EA4.list';

use constant ea4_conflicting_apache_distro_packages =&gt; [qw( apache2 apache2-utils php-cli )];

use constant ea4tooling_dnsonly =&gt; ['apt-plugin-universal-hooks'];
use constant ea4tooling         =&gt; [ 'apt-plugin-universal-hooks', Cpanel::OS::Linux-&gt;ea4tooling_all-&gt;@* ];
use constant system_exclude_rules =&gt; {
    'dovecot'    =&gt; 'dovecot*',
    'exim'       =&gt; 'exim*',
    'filesystem' =&gt; 'base-files',                                   # block Ubuntu updates to current installed version (20.04)
    'kernel'     =&gt; 'linux-headers* linux-image* linux-modules*',
    'nsd'        =&gt; 'nsd',
    'p0f'        =&gt; 'p0f',
    'php'        =&gt; 'php*',
    'proftpd'    =&gt; 'proftpd*',
    'pure-ftpd'  =&gt; 'pure-ftpd*',

};

use constant packages_supplemental =&gt; [

    'nfs-common',

    qw{
      libcpan-perl-releases-perl
      libexpect-perl
      libio-pty-perl
      libjson-xs-perl
      liblocal-lib-perl
      libmodule-build-perl
      libtry-tiny-perl
      libwww-perl
      libyaml-syck-perl
      lsof
      nscd
      rpm
      strace
      sysstat
      tcpd
      util-linux
    }
];

use constant can_clean_plugins_repo =&gt; 0;

use constant jetbackup_repo_pkg =&gt; 'https://repo.jetlicense.com/ubuntu/jetapps-repo-latest_amd64.deb';

use constant repo_suffix =&gt; 'list';
use constant repo_dir    =&gt; '/etc/apt/sources.list.d';

use constant packages_required =&gt; [
    qw{
      acl
      apt-file
      apt-transport-https
      aspell
      at
      bind9
      bind9-libs
      bind9-utils
      binutils
      bzip2
      coreutils
      cpio
      cpp
      cracklib-runtime
      cron
      curl
      debian-goodies
      debianutils
      e2fsprogs
      expat
      file
      g++
      g++-9
      gawk
      gcc
      gdbmtool
      gettext
      glibc-source
      gnupg2
      graphicsmagick-imagemagick-compat
      gzip
      icu-devtools
      iptables
      iptables-persistent
      language-pack-en-base
      less
      libaio1
      libapt-pkg-perl
      libboost-program-options1.71.0
      libcairo2-dev
      libcrack2
      libdb5.3
      libevent-2.1-7
      libfile-fcntllock-perl
      libfontconfig1-dev
      libgcc1
      libgd-tools
      libgd3
      libgmp10
      libgomp1
      libicu-dev
      libicu66
      libidn11
      libjpeg-turbo8
      liblua5.3-dev
      libmount1
      libmysqlclient21
      libncurses5
      libpam0g
      libpam0g-dev
      libpango-1.0-0
      libpangocairo-1.0-0
      libpcap0.8
      libpcre2-8-0
      libpcre2-posix2
      libpcre3
      libpq5
      libpixman-1-0
      libpng16-16
      libpopt0
      libreadline-dev
      libssl-dev
      libstdc++-9-dev
      libstdc++6
      libtiff5
      libuser
      libxml2
      libxml2-dev
      libxslt1.1
      libzip5
      libzstd1
      linux-libc-dev
      lsof
      make
      nano
      needrestart
      net-tools
      openssh-client
      openssh-server
      openssl
      passwd
      patch
      pcre2-utils
      procps
      python-setuptools
      python2
      python2-doc
      python2.7-dev
      quota
      rdate
      rsync
      sed
      smartmontools
      ssl-cert
      sysstat
      tar
      unzip
      usrmerge
      wget
      xz-utils
      zip
      zlib1g
    }
];

use constant package_ImageMagick_Devel =&gt; 'libmagick++-6.q16-dev';
use constant package_crond             =&gt; 'cron';

use constant system_package_providing_perl =&gt; 'perl-base';

use constant bin_grub_mkconfig            =&gt; q[/usr/sbin/grub-mkconfig];
use constant program_to_apply_kernel_args =&gt; 'grub-mkconfig';

use constant package_descriptions =&gt; {
    'short' =&gt; 'description',
    'long'  =&gt; 'longdesc',
};

use constant nat_server_buffer_connections =&gt; 2;

use constant tuxcare_els_php_install_url =&gt; &quot;https://go.cpanel.net/install-els-alt-php-deb-repo-ip&quot;;
use constant supports_phpels             =&gt; 1;

1;


} # --- END Cpanel/OS/Ubuntu.pm


{ # --- BEGIN Cpanel/OS/Ubuntu20.pm
package Cpanel::OS::Ubuntu20;


use cPstrict;

# use Cpanel::OS::Ubuntu();
our @ISA;
BEGIN { push @ISA, qw(Cpanel::OS::Ubuntu); }

use constant is_supported =&gt; 1;

use constant binary_sync_source         =&gt; 'linux-u20-x86_64';
use constant package_release_distro_tag =&gt; '~u20';
use constant release_codename           =&gt; 'focal';

use constant maillog_path =&gt; '/var/log/mail.log';

use constant plugins_repo_url =&gt; 'https://securedownloads.cpanel.net/cpanel-plugins/cpanel-plugins.list';

use constant supports_imunify_360 =&gt; 1;

use constant supports_cpanel_cloud_edition =&gt; 1;

use constant mysql_repo_template =&gt; &lt;&lt;'___END_REPO_TEMPLATE___';
deb https://repo.mysql.com/apt/ubuntu/ focal mysql-apt-config
deb https://repo.mysql.com/apt/ubuntu/ focal mysql-###MYSQL_VERSION_SHORT###
deb https://repo.mysql.com/apt/ubuntu/ focal mysql-tools
deb-src https://repo.mysql.com/apt/ubuntu/ focal mysql-###MYSQL_VERSION_SHORT###
___END_REPO_TEMPLATE___

use constant quota_packages_conditional =&gt; {

    'linux-aws'             =&gt; ['linux-modules-extra-aws'],
    'linux-aws-edge'        =&gt; ['linux-modules-extra-aws-edge'],
    'linux-aws-lts-20.04'   =&gt; ['linux-modules-extra-aws-lts-20.04'],
    'linux-azure'           =&gt; ['linux-modules-extra-azure'],
    'linux-azure-cvm'       =&gt; ['linux-modules-extra-azure-cvm'],
    'linux-azure-edge'      =&gt; ['linux-modules-extra-azure-edge'],
    'linux-azure-fde'       =&gt; ['linux-modules-extra-azure-fde'],
    'linux-azure-lts-20.04' =&gt; ['linux-modules-extra-azure-lts-20.04'],
    'linux-gcp'             =&gt; ['linux-modules-extra-gcp'],
    'linux-gcp-edge'        =&gt; ['linux-modules-extra-gcp-edge'],
    'linux-gcp-lts-20.04'   =&gt; ['linux-modules-extra-gcp-lts-20.04'],
    'linux-gke'             =&gt; ['linux-modules-extra-gke'],
    'linux-gke-5.4'         =&gt; ['linux-modules-extra-gke-5.4'],
    'linux-gkeop'           =&gt; ['linux-modules-extra-gkeop'],
    'linux-gkeop-5.4'       =&gt; ['linux-modules-extra-gkeop-5.4'],
    'linux-ibm'             =&gt; ['linux-modules-extra-ibm'],
    'linux-ibm-lts-20.04'   =&gt; ['linux-modules-extra-ibm-lts-20.04'],

    'linux-virtual'                =&gt; ['linux-image-extra-virtual'],
    'linux-virtual-hwe-20.04'      =&gt; ['linux-image-extra-virtual-hwe-20.04'],
    'linux-virtual-hwe-20.04-edge' =&gt; ['linux-image-extra-virtual-hwe-20.04-edge'],
};

1;


} # --- END Cpanel/OS/Ubuntu20.pm


{ # --- BEGIN Cpanel/OS/Rocky.pm
package Cpanel::OS::Rocky;


use cPstrict;

# use Cpanel::OS::Rhel();
our @ISA;
BEGIN { push @ISA, qw(Cpanel::OS::Rhel); }

use constant is_supported =&gt; 0;

use constant pretty_distro =&gt; 'Rocky Linux';

1;


} # --- END Cpanel/OS/Rocky.pm


{ # --- BEGIN Cpanel/OS/Rocky8.pm
package Cpanel::OS::Rocky8;


use cPstrict;

use Cpanel::OS::Rocky;
# use Cpanel::OS::Rhel8();
our @ISA;
BEGIN { push @ISA, qw(Cpanel::OS::Rhel8); }

use constant is_supported =&gt; 1;    # Rockylinux 8

use constant pretty_distro =&gt; Cpanel::OS::Rocky-&gt;pretty_distro;

use constant supports_imunify_360 =&gt; 1;

1;


} # --- END Cpanel/OS/Rocky8.pm


{ # --- BEGIN Cpanel/OS/All.pm
package Cpanel::OS::All;


use cPstrict;
use utf8;

# use Cpanel::OS::Almalinux8  ();    # PPI USE OK - fatpack usage
# use Cpanel::OS::Centos7     ();    # PPI USE OK - fatpack usage
# use Cpanel::OS::Cloudlinux6 ();    # PPI USE OK - fatpack usage
# use Cpanel::OS::Cloudlinux7 ();    # PPI USE OK - fatpack usage
# use Cpanel::OS::Cloudlinux8 ();    # PPI USE OK - fatpack usage
# use Cpanel::OS::Rhel7       ();    # PPI USE OK - fatpack usage
# use Cpanel::OS::Ubuntu20    ();    # PPI USE OK - fatpack usage
# use Cpanel::OS::Rocky8      ();    # PPI USE OK - fatpack usage

sub supported_distros() {
    return (
        [ Almalinux  =&gt; 8 ],
        [ Centos     =&gt; 7 ],
        [ Cloudlinux =&gt; 7 ],
        [ Cloudlinux =&gt; 8 ],
        [ Rhel       =&gt; 7 ],
        [ Rocky      =&gt; 8 ],
        [ Ubuntu     =&gt; 20 ],
    );
}

sub advertise_supported_distros() {

    my $current_name;
    my $current_versions = [];

    my $advertise = '';

    my $map_os_display_name = {
        'Almalinux'  =&gt; 'AlmaLinux',
        'Centos'     =&gt; 'CentOS',
        'Rhel'       =&gt; 'Red Hat Enterprise Linux',
        'Cloudlinux' =&gt; 'CloudLinux&amp;reg;',
        'Rocky'      =&gt; 'Rocky Linux&amp;trade;',
    };

    foreach my $d ( supported_distros() ) {
        my ( $name, $version ) = $d-&gt;@*;

        if ( !defined $current_name ) {
            $current_name = $name;
            push $current_versions-&gt;@*, $version;
            next;
        }

        if ( $current_name eq $name ) {
            push $current_versions-&gt;@*, $version;
        }
        else {
            my $display_name = $map_os_display_name-&gt;{$current_name} // $current_name;
            $advertise .= $display_name . ' ' . join( '/', $current_versions-&gt;@* ) . ', ';
            $current_name     = $name;
            $current_versions = [$version];
        }
    }

    if ( defined $current_name ) {
        my $display_name = $map_os_display_name-&gt;{$current_name} // $current_name;
        $advertise .= $display_name . ' ' . join( '/', $current_versions-&gt;@* );
    }

    return $advertise;
}

1;


} # --- END Cpanel/OS/All.pm


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


use strict;
use warnings;


use constant {
    _gettimeofday =&gt; 96,

    _clock_gettime  =&gt; 228,
    _CLOCK_REALTIME =&gt; 0,

    _EINTR =&gt; 4,

    _PACK_TEMPLATE =&gt; 'L!L!',
};


sub clock_gettime {
    my $timeval = pack( _PACK_TEMPLATE, () );

    _get_time_from_syscall(
        _clock_gettime,
        _CLOCK_REALTIME,
        $timeval,
    );

    return unpack( _PACK_TEMPLATE, $timeval );
}


sub time {
    my ( $secs, $nsecs ) = clock_gettime();

    return $secs + ( $nsecs / 1_000_000_000 );
}


sub sleep {
    my ($secs) = @_;


    local $!;
    my $retval = select( undef, undef, undef, $secs );
    if ( $retval == -1 &amp;&amp; $! != _EINTR ) {
        require Cpanel::Exception;
        die 'Cpanel::Exception'-&gt;can('create')-&gt;( 'SystemCall', 'The system failed to suspend command execution for [quant,_1,second,seconds] because of an error: [_2]', [ $secs, $! ] );
    }

    return $secs;
}


sub gettimeofday {
    my $timeval = pack( _PACK_TEMPLATE, () );

    _get_time_from_syscall(
        _gettimeofday,
        $timeval,
        undef,
    );

    return unpack( _PACK_TEMPLATE, $timeval );
}


sub _get_time_from_syscall {    ##no critic qw(RequireArgUnpacking)
    my $syscall_num = shift;

    local $!;
    my $retval = syscall( $syscall_num, @_ );
    if ( $retval == -1 ) {
        require Cpanel::Exception;
        die 'Cpanel::Exception'-&gt;can('create')-&gt;( 'SystemCall', 'The system failed to retrieve the time because of an error: [_1]', [$!] );
    }

    return;
}

1;

} # --- END Cpanel/TimeHiRes.pm


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


use strict;
use warnings;


use constant PACK_TEMPLATE =&gt; 'L!L!';

my %CLASS_PRECISION;


sub float_to_binary {
    return pack(
        PACK_TEMPLATE(),

        int( $_[1] ),

        int( 0.5 + ( $_[0]-&gt;_PRECISION() * $_[1] ) - ( $_[0]-&gt;_PRECISION() * int( $_[1] ) ) ),
    );
}


sub binary_to_float {
    return $_[0]-&gt;_binary_to_float( PACK_TEMPLATE(), $_[1] )-&gt;[0];
}


sub binaries_to_floats_at {
    return $_[0]-&gt;_binary_to_float(
        &quot;\@$_[3] &quot; . ( PACK_TEMPLATE() x $_[2] ),
        $_[1],
    );
}


my ( $i, $precision, @sec_psec_pairs );

sub _binary_to_float {    ## no critic qw(RequireArgUnpacking)
    @sec_psec_pairs = unpack( $_[1], $_[2] );

    $i = 0;

    my @floats;

    $precision = $CLASS_PRECISION{ $_[0] } ||= $_[0]-&gt;_PRECISION();

    while ( $i &lt; @sec_psec_pairs ) {


        push @floats, 0 + ( q&lt;&gt; . ( $sec_psec_pairs[$i] + ( $sec_psec_pairs[ $i + 1 ] / $precision ) ) );
        $i += 2;
    }

    return \@floats;
}

1;

} # --- END Cpanel/Struct/Common/Time.pm


{ # --- BEGIN Cpanel/Struct/timespec.pm
package Cpanel::Struct::timespec;


use strict;
use warnings;


# use Cpanel::Struct::Common::Time();
our @ISA;
BEGIN { push @ISA, qw(Cpanel::Struct::Common::Time); }

use constant {
    _PRECISION =&gt; 1_000_000_000,    # nanoseconds
};

1;

} # --- END Cpanel/Struct/timespec.pm


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


use strict;
use warnings;


# use Cpanel::Struct::timespec ();

use constant {
    _NR_stat  =&gt; 4,
    _NR_fstat =&gt; 5,
    _NR_lstat =&gt; 6,
};

use constant _PACK_TEMPLATE =&gt; q&lt;
    Q       # st_dev
    Q       # st_ino

    @24 L   # st_mode
    @16 Q   # st_nlink

    @28
    L       # st_uid
    L       # st_gid

    x![Q]
    Q       # st_rdev
    Q       # st_size
    Q       # st_blksize
    Q       # st_blocks
&gt;;

my $pre_times_pack_len = length pack _PACK_TEMPLATE();

my $buf = ( &quot;\0&quot; x 144 );


sub stat {
    return _syscall( _NR_stat(), $_[0] );
}


sub lstat {
    return _syscall( _NR_lstat(), $_[0] );
}


sub fstat {
    return _syscall( _NR_fstat(), 0 + ( ref( $_[0] ) ? fileno( $_[0] ) : $_[0] ) );
}


sub _syscall {    ## no critic qw(RequireArgUnpacking)
    my $arg_dupe = $_[1];
    return undef if -1 == syscall( $_[0], $arg_dupe, $buf );
    my @vals = unpack _PACK_TEMPLATE(), $buf;
    splice(
        @vals, 8, 0,
        @{ Cpanel::Struct::timespec-&gt;binaries_to_floats_at( $buf, 3, $pre_times_pack_len ) },
    );

    return @vals;
}

1;

} # --- END Cpanel/NanoStat.pm


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


use strict;
use warnings;


# use Cpanel::Struct::timespec ();

use constant {
    _NR_utimensat =&gt; 280,

    _AT_FDCWD            =&gt; -100,
    _AT_SYMLINK_NOFOLLOW =&gt; 0x100,
};


sub utime {
    return _syscall( 0 + _AT_FDCWD(), $_[2], @_[ 0, 1 ], 0 );
}


sub futime {
    return _syscall(
        0 + ( ref( $_[2] ) ? fileno( $_[2] ) : $_[2] ),
        undef,
        @_[ 0, 1 ],
        0,
    );
}


sub lutime {
    return _syscall( 0 + _AT_FDCWD(), $_[2], @_[ 0, 1 ], 0 + _AT_SYMLINK_NOFOLLOW() );
}

my ( $path, $buf ) = @_;

sub _syscall {

    if ( defined $_[-3] ) {
        if ( defined $_[-2] ) {
            $buf = Cpanel::Struct::timespec-&gt;float_to_binary( $_[-3] ) . Cpanel::Struct::timespec-&gt;float_to_binary( $_[-2] );
        }
        else {
            die &quot;atime is “$_[-3]”, but mtime is undef!&quot;;
        }
    }
    elsif ( defined $_[-2] ) {
        die &quot;atime is undef, but mtime is “$_[-2]”!&quot;;
    }
    else {
        $buf = undef;
    }

    $path = $_[1];

    return undef if -1 == syscall( 0 + _NR_utimensat(), $_[0], $path // undef, $buf // undef, $_[-1] );

    return 1;
}

1;

} # --- END Cpanel/NanoUtime.pm


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


use strict;
use warnings;


my %_routes = (


    'fstat' =&gt; [ 'NanoStat', 'fstat', 'stat',  1 ],
    'lstat' =&gt; [ 'NanoStat', 'lstat', 'lstat', 1 ],
    'stat'  =&gt; [ 'NanoStat', 'stat',  'stat',  1 ],

    'time' =&gt; [ 'TimeHiRes', 'time', 'time' ],

    'utime'  =&gt; [ 'NanoUtime', 'utime',  'utime' ],
    'futime' =&gt; [ 'NanoUtime', 'futime', 'utime' ],

    'lutime' =&gt; [ 'NanoUtime', 'lutime', undef ],
);

my $preloaded;


sub import {
    my ( $class, %opts ) = @_;

    if ( my $preload = $opts{'preload'} ) {
        if ( $preload eq 'xs' ) {
            require Time::HiRes;
        }
        elsif ( $preload eq 'perl' ) {
            if ( !$preloaded ) {
                require Cpanel::TimeHiRes;    # PPI USE OK - preload
                require Cpanel::NanoStat;     # PPI USE OK - preload
                require Cpanel::NanoUtime;    # PPI USE OK - preload
            }
        }
        else {
            die &quot;Unknown “preload”: “$preload”&quot;;
        }

        $preloaded = $preload;
    }

    return;
}

our $AUTOLOAD;


sub AUTOLOAD {    ## no critic qw(Subroutines::RequireArgUnpacking)
    substr( $AUTOLOAD, 0, 1 + rindex( $AUTOLOAD, ':' ) ) = q&lt;&gt;;

    if ( !$AUTOLOAD || !$_routes{$AUTOLOAD} ) {
        die &quot;Unknown function in Cpanel::HiRes::$_[0]&quot;;
    }

    my $function = $AUTOLOAD;

    undef $AUTOLOAD;

    my ( $pp_module, $pp_function, $xs_function, $xs_needs_closure ) = @{ $_routes{$function} };

    no strict 'refs';

    if ( $INC{'Time/HiRes.pm'} &amp;&amp; $xs_function ) {
        *$function = *{&quot;Time::HiRes::$xs_function&quot;};
        return Time::HiRes-&gt;can($xs_function)-&gt;(@_);
    }
    else {

        _require(&quot;Cpanel/${pp_module}.pm&quot;) if !$INC{&quot;Cpanel/${pp_module}.pm&quot;};

        my $pp_cr = &quot;Cpanel::${pp_module}&quot;-&gt;can($pp_function);

        if ($xs_function) {
            *$function = sub {

                if ( $INC{'Time/HiRes.pm'} ) {
                    *$function = *{&quot;Time::HiRes::$xs_function&quot;};
                    return Time::HiRes-&gt;can($xs_function)-&gt;(@_);
                }

                goto &amp;$pp_cr;
            };
        }
        else {
            *$function = $pp_cr;
        }
    }

    goto &amp;$function;
}

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

    require $_[0];
    return;
}

1;

} # --- END Cpanel/HiRes.pm


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


use strict;
use warnings;

our $VERSION = '1.7';

my $SAFE_ENV_VARS;

BEGIN {
    $SAFE_ENV_VARS = q&lt;
        ALLUSERSPROFILE
        APPDATA
        BUNDLE_PATH
        CLIENTNAME
        COMMONPROGRAMFILES
        COMPUTERNAME
        COMSPEC
        CPANEL_BASE_INSTALL
        CPANEL_IS_CRON
        CPBACKUP
        DEBIAN_FRONTEND
        DEBIAN_PRIORITY
        DOCUMENT_ROOT
        FORCEDCPUPDATE
        FP_NO_HOST_CHECK
        HOMEDRIVE
        HOMEPATH
        LANG
        LANGUAGE
        LC_ALL
        LC_MESSAGES
        LC_CTYPE
        LOGONSERVER
        NEWWHMUPDATE
        NOTIFY_SOCKET
        NUMBER_OF_PROCESSORS
        OPENSSL_NO_DEFAULT_ZLIB
        OS
        PATH
        PATHEXT
        PROCESSOR_ARCHITECTURE
        PROCESSOR_IDENTIFIER
        PROCESSOR_LEVEL
        PROCESSOR_REVISION
        PROGRAMFILES
        PROMPT
        PYTHONIOENCODING
        SERVER_SOFTWARE
        SESSIONNAME
        SKIP_DEFERRAL_CHECK
        SSH_CLIENT
        SYSTEMDRIVE
        SYSTEMROOT
        TEMP
        TERM
        TMP
        UPDATENOW_NO_RETRY
        UPDATENOW_PRESERVE_FAILED_FILES
        USERDOMAIN
        USERNAME
        USERPROFILE
        WINDIR
    &gt;;

    $SAFE_ENV_VARS =~ tr&lt;\n &gt;&lt; &gt;s;
    $SAFE_ENV_VARS =~ s&lt;\A\s+&gt;&lt;&gt;;
}


{
    no warnings 'once';
    *cleanenv = *clean_env;
}

sub clean_env {
    my %OPTS = @_;

    my %SAFE_ENV_VARS = map { $_ =&gt; undef } split( m{ }, $SAFE_ENV_VARS );

    if ( defined $OPTS{'keep'} &amp;&amp; ref $OPTS{'keep'} eq 'ARRAY' ) {
        @SAFE_ENV_VARS{ @{ $OPTS{'keep'} } } = undef;
    }

    if ( defined $OPTS{'delete'} &amp;&amp; ref $OPTS{'delete'} eq 'ARRAY' ) {
        delete @SAFE_ENV_VARS{ @{ $OPTS{'delete'} } };
    }

    delete @ENV{ grep { !exists $SAFE_ENV_VARS{$_} } keys %ENV };
    if ( $OPTS{'http_purge'} ) {
        delete @ENV{ 'SERVER_SOFTWARE', 'DOCUMENT_ROOT' };
    }

    return;
}

sub get_safe_env_vars {
    return $SAFE_ENV_VARS;
}

sub get_safe_path {
    return '/usr/local/jdk/bin:/usr/kerberos/sbin:/usr/kerberos/bin:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin:/usr/X11R6/bin:/usr/local/bin:/usr/X11R6/bin:/root/bin:/opt/bin';
}

sub set_safe_path {
    return ( $ENV{'PATH'} = get_safe_path() );
}

1;

} # --- END Cpanel/Env.pm


{ # --- BEGIN Cpanel/Hash/Stringify.pm
package Cpanel::Hash::Stringify;


use strict;
use warnings;


sub sorted_hashref_string {
    my ($hashref) = @_;
    return (
        ( scalar keys %$hashref )
        ? join(
            '_____', map { $_, ( ref $hashref-&gt;{$_} eq 'HASH' ? sorted_hashref_string( $hashref-&gt;{$_} ) : ref $hashref-&gt;{$_} eq 'ARRAY' ? join( '_____', @{ $hashref-&gt;{$_} } ) : defined $hashref-&gt;{$_} ? $hashref-&gt;{$_} : '' ) }
              sort keys %$hashref
          )
        : ''
    );    #sort is important for order;
}

1;

} # --- END Cpanel/Hash/Stringify.pm


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


use strict;


our $server_offset_string;
our ( $timecacheref, $localtimecacheref ) = ( [ -1, '', -1 ], [ -1, '', -1 ] );

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

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

sub localtime2timestamp {
    my ( $time, $delimiter ) = @_;
    $delimiter ||= ' ';
    $time      ||= time();

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

    my $tz_offset = get_server_offset_as_offset_string($time);

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

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

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

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

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

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

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

            redo UNTIL_SAME_SECOND if time != $starttime;

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

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

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

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

1;

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


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


use strict;
use warnings;


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

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

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

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

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

    our $FD_CLOEXEC = 1;
}

1;

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


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


use strict;
use warnings;

# use Cpanel::Fcntl::Constants ();

my %CONSTANTS;
my %CACHE;

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

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

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

1;

} # --- END Cpanel/Fcntl.pm


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


use strict;

# use Cpanel::Fcntl ();

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

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

    my ( $sysopen_perms, $original_umask );

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

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

    if ( defined $custom_perms ) {

        () = umask($original_umask);
    }

    return $ret;
}

1;

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


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


use strict;

our $current_tag            = '';
our $can_leave_cpanelaction = 1;
our $buffer                 = '';

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

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

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

our %BACKCOMPAT;

our $cptag;
our $sent_content_type;

1;

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


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


use strict;
use warnings;


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


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

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


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

1;

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


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


use strict;

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

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

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

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

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

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

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

1;

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


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


use strict;

our $VERSION = '0.2.5';

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

my $zero_through_255 = '(?:25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9][0-9]?|0)';

our %regex = (
    'emailaddr'              =&gt; '[a-zA-Z0-9!#\$\-=?^_{}~]+(?:\.[a-zA-Z0-9!#\$\-=?^_{}~]+)*(?:\+[a-zA-Z0-9 \.=\-\_]+)*\@[\da-zA-Z](?:[-\da-zA-Z]*[\da-zA-Z])?(?:\.[\da-zA-Z](?:[-\da-zA-Z]*[\da-zA-Z])?)*',
    'oneplusdot'             =&gt; '\.+',
    'oneplusspacetab'        =&gt; '[\s\t]+',
    'multipledot'            =&gt; '\.{2,}',
    'commercialat'           =&gt; '\@',
    'plussign'               =&gt; '\+',
    'singledot'              =&gt; '\.',
    'newline'                =&gt; '\n',
    'doubledot'              =&gt; '\.\.',
    'lineofdigits'           =&gt; '^\d+$',
    'lineofnonprintingchars' =&gt; '^[\s\t]*$',
    'getemailtransport'      =&gt; '^from\s+.*\s+by\s+\S+\s+with\s+(\S+)',
    'getreceivedfrom'        =&gt; '^from\s+(.*)\s+by\s+',
    'emailheaderterminator'  =&gt; '^[\r\n]*$',
    'forwardslash'           =&gt; '\/',

    'backslash'             =&gt; chr(92) x 4,
    'singlequote'           =&gt; q('),
    'doublequote'           =&gt; '&quot;',
    'allspacetabchars'      =&gt; '[\s\t]*',
    'beginswithspaceortabs' =&gt; '^[\s\t]',

    doublequotedstring =&gt; $dblquotedstr,
    singlequotedstring =&gt; $sglquotedstr,

    DUNS =&gt; '[0-9]{2}(?:-[0-9]{3}-[0-9]{4}|[0-9]{7})',

    YYYY_MM_DD =&gt; '[0-9]{4}-(?:1[012]|0[1-9])-(?:3[01]|[12][0-9]|0[1-9])',

    ipv4 =&gt; &quot;(?:$zero_through_255\.){3}$zero_through_255&quot;,

    iso_z_time =&gt; '[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}Z',
);

1;

} # --- END Cpanel/Regex.pm


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


use strict;

# use Cpanel::Parser::Vars ();

our ( $SHOW_TRACE, $OUTPUT_FORMAT, $VERBOSE ) = ( 1, 'text', 0 );

my $__CALLBACK_AFTER_DIE_SPEW;    # Set when we need to run a code ref after spewing on die

my $error_count = 0;

sub import { return enable(); }

sub enable {
    my (
        $callback_before_warn_or_die_spew,    # Runs before the spew on warn or die, currently used in cpanel to ensure we emit headers before body in the event of a warn or die spew
        $callback_before_die_spew,            # Runs before the spew on die, not currently used
        $callback_after_die_spew,             # Runs after the spew on die, currently used in whostmgr to ensure we emit the javascript footer when we die to avoid the UI breaking
    ) = @_;

    $SIG{'__WARN__'} = sub {                  ## no critic qw(Variables::RequireLocalizedPunctuationVars)
        my @caller = caller(1);
        return if defined $caller[3] &amp;&amp; index( $caller[3], 'eval' ) &gt; -1;    # Case 35335: Quiet spurious warn errors from evals

        ++$error_count;

        my $time = time();
        my ( $sec, $min, $hour, $mday, $mon, $year ) = localtime($time);

        my ( $gmmin, $gmhour, $gmday ) = ( gmtime($time) )[ 1, 2, 3 ];

        my $gmoffset        = ( $hour * 60 + $min ) - ( $gmhour * 60 + $gmmin ) + 1440 * ( $mday &lt;=&gt; $gmday );
        my $tz              = sprintf( '%+03d%02d', int( $gmoffset / 60 ), $gmoffset % 60 );
        my $error_timestamp = sprintf( '%04d-%02d-%02d %02d:%02d:%02d %s', $year + 1900, $mon + 1, $mday, $hour, $min, $sec, $tz );

        my $longmess;
        my $ignorable;
        if ( UNIVERSAL::isa( $_[0], 'Cpanel::Exception' ) ) {
            $longmess = Cpanel::Carp::safe_longmess( $_[0]-&gt;to_locale_string() );
        }
        elsif ( ref $_[0] eq 'Template::Exception' ) {
            $longmess = Cpanel::Carp::safe_longmess( &quot;Template::Exception:\n\t[TYPE]=[&quot; . $_[0]-&gt;[0] . &quot;]\n\t[INFO]=[&quot; . $_[0]-&gt;[1] . &quot;]\n\t[TEXT]=[&quot; . ( ref $_[0]-&gt;[2] eq 'SCALAR' ? ${ $_[0]-&gt;[2] } : $_[0]-&gt;[2] ) . &quot;]\n&quot; );
        }
        else {
            $longmess  = Cpanel::Carp::safe_longmess(@_);
            $ignorable = 1 if index( $_[0], 'Use of uninitialized value' ) == 0;
        }

        my $error_container_text = 'A warning occurred while processing this directive.';

        my $current_file = $Cpanel::Parser::Vars::file || 'unknown';
        print STDERR &quot;[$error_timestamp] warn [Internal Warning while parsing $current_file $$] $longmess\n\n&quot;;

        return if ( $OUTPUT_FORMAT eq 'suppress' || $OUTPUT_FORMAT eq 'supress' || $ENV{'CPANEL_PHPENGINE'} );

        return if $ignorable &amp;&amp; !$VERBOSE;

        _run_callback_without_die_handler($callback_before_warn_or_die_spew) if $callback_before_warn_or_die_spew;

        if ( $OUTPUT_FORMAT eq 'html' ) {
            if ($SHOW_TRACE) {
                _print_without_die_handler( _generate_html_error_message( 'warn', $error_container_text, $longmess ) );
            }
            else {
                _print_without_die_handler(qq{&lt;span class=&quot;error&quot; style=&quot;cursor:hand;cursor:pointer;&quot;&gt;[$error_container_text]&lt;/span&gt;});
            }
        }
        elsif ( $OUTPUT_FORMAT eq 'xml' ) {
            _print_without_die_handler(&quot;&lt;error&gt;$error_container_text&lt;/error&gt;&quot;);
        }
        else {
            _print_without_die_handler(&quot;[$error_container_text]\n&quot;);
        }
    };

    $SIG{'__DIE__'} = sub {    ## no critic qw(Variables::RequireLocalizedPunctuationVars)

        return if $^S;

        die $_[0] unless defined $^S;

        delete $SIG{'__DIE__'};
        _run_callback_without_die_handler($callback_before_warn_or_die_spew) if $callback_before_warn_or_die_spew;
        _run_callback_without_die_handler($callback_before_die_spew)         if $callback_before_die_spew;

        $__CALLBACK_AFTER_DIE_SPEW = $callback_after_die_spew;

        goto \&amp;spew_on_die;
    };

    return 1;
}

sub spew_on_die {    ## no critic qw(Subroutines::RequireArgUnpacking)
    my ($err) = @_;

    ++$error_count;

    my $time = time();
    my ( $sec, $min, $hour, $mday, $mon, $year ) = localtime($time);

    my ( $gmmin, $gmhour, $gmday ) = ( gmtime($time) )[ 1, 2, 3 ];

    my $gmoffset        = ( $hour * 60 + $min ) - ( $gmhour * 60 + $gmmin ) + 1440 * ( $mday &lt;=&gt; $gmday );
    my $tz              = sprintf( '%+03d%02d', int( $gmoffset / 60 ), $gmoffset % 60 );
    my $error_timestamp = sprintf( '%04d-%02d-%02d %02d:%02d:%02d %s', $year + 1900, $mon + 1, $mday, $hour, $min, $sec, $tz );

    my $error_text;
    if ( UNIVERSAL::isa( $err, 'Cpanel::Exception' ) ) {
        $error_text = Cpanel::Carp::safe_longmess( $err-&gt;to_locale_string() );
    }
    elsif ( UNIVERSAL::isa( $err, 'Template::Exception' ) ) {
        $error_text = Cpanel::Carp::safe_longmess( &quot;Template::Exception:\n\t[TYPE]=[&quot; . $err-&gt;type() . &quot;]\n\t[INFO]=[&quot; . $err-&gt;info() . &quot;]\n\t[TEXT]=[&quot; . $err-&gt;text() . &quot;]\n&quot; );
    }
    else {
        $error_text = Cpanel::Carp::safe_longmess(@_);
    }

    my $current_file = $Cpanel::Parser::Vars::file || 'unknown';
    print STDERR &quot;[$error_timestamp] die [Internal Death while parsing $current_file $$] $error_text\n\n&quot;;

    return if ( $OUTPUT_FORMAT eq 'suppress' || $OUTPUT_FORMAT eq 'supress' || $ENV{'CPANEL_PHPENGINE'} );

    my $error_container_text = 'A fatal error or timeout occurred while processing this directive.';

    if ( $OUTPUT_FORMAT eq 'html' ) {
        if ($SHOW_TRACE) {
            _print_without_die_handler( _generate_html_error_message( 'error', $error_container_text, $error_text ) );
        }
        else {
            _print_without_die_handler(qq{&lt;span class=&quot;error&quot; style=&quot;cursor:hand;cursor:pointer;&quot;&gt;[$error_container_text]&lt;/span&gt;});
        }
    }
    elsif ( $OUTPUT_FORMAT eq 'xml' ) {
        _print_without_die_handler(&quot;&lt;error&gt;[$error_container_text]&lt;/error&gt;&quot;);
    }
    else {
        _print_without_die_handler(&quot;[$error_container_text]\n&quot;);
    }

    _run_callback_without_die_handler($__CALLBACK_AFTER_DIE_SPEW) if $__CALLBACK_AFTER_DIE_SPEW;

    return;
}

my @SAFE_LONGMESS_KEY_REGEXP_ITEMS = (
    '(?&lt;![a-zA-Z0-9_])pw(?![a-zA-Z0-9_])',
    qw(
      hash
      pass
      auth
      root
      key
      fullbackup
    ),
);

my @SAFE_LONGMESS_FUNCTION_REGEXP_ITEMS = (
    @SAFE_LONGMESS_KEY_REGEXP_ITEMS,
    '__ANON__',
);

sub _print_without_die_handler {
    my ($text) = @_;

    local $SIG{'__WARN__'} = sub { };
    local $SIG{'__DIE__'}  = 'DEFAULT';

    return print $text;
}

sub _run_callback_without_die_handler {
    my ($callback) = @_;
    local $SIG{'__WARN__'} = sub { };
    local $SIG{'__DIE__'}  = 'DEFAULT';

    return $callback-&gt;();
}

sub _generate_html_error_message {
    my ( $type, $error_container_message, $error_message ) = @_;

    require Cpanel::Encoder::Tiny;
    my $safe_error_message = Cpanel::Encoder::Tiny::safe_html_encode_str($error_message);


    return qq[
&lt;style type=&quot;text/css&quot;&gt;.cpanel_internal_message_container {display: inline-block; margin: 10px; width: auto;} .cpanel_internal_message { border: 1px solid #fff; outline-style: solid; outline-width: 1px; outline-color: #aaa; padding: 5px; } .cpanel_internal_error_warn { background-color: #FFF6CF; } .cpanel_internal_error_error { background-color: #F8E7E6; }&lt;/style&gt;
&lt;div id=&quot;cpanel_notice_item_$error_count&quot; class=&quot;cjt-pagenotice-container cjt-notice-container cpanel_internal_message_container internal-error-container&quot;&gt;
    &lt;div class=&quot;yui-module cjt-notice cjt-pagenotice cjt-notice-$type&quot;&gt;
        &lt;div class=&quot;cpanel_internal_message cpanel_internal_error_$type bd&quot;&gt;
            &lt;div class=&quot;cjt-notice-content&quot; style=&quot;width: 420px;&quot;&gt;
                &lt;span&gt;
                    $error_container_message
                    &lt;a
                        class=&quot;error&quot;
                        style=&quot;cursor:hand;cursor:pointer;&quot;
                        onClick=&quot;document.getElementById('cpanel_internal_error_$error_count').style.display='';this.style.display='none'; return false;&quot;&gt;
                        [show]
                    &lt;/a&gt;
                    &lt;a
                        class=&quot;error&quot;
                        style=&quot;cursor:hand;cursor:pointer;&quot;
                        onClick=&quot;document.getElementById('cpanel_notice_item_$error_count').style.display='none'; return false;&quot;&gt;
                        [close]
                    &lt;/a&gt;
                &lt;/span&gt;
                &lt;div id=&quot;cpanel_internal_error_$error_count&quot; style=&quot;display:none;&quot;&gt;
                    &lt;textarea class=&quot;cpanel_internal_error_$type&quot; style=&quot;font-weight:900; height:200px; width:410px; color: black;&quot;&gt;$safe_error_message&lt;/textarea&gt;
                &lt;/div&gt;
            &lt;/div&gt;
        &lt;/div&gt;
    &lt;/div&gt;
&lt;/div&gt;
    ];
}

sub safe_longmess {
    require Carp;
    $Carp::Internal{'Cpanel::Carp'} = 1;
    return sanitize_longmess( scalar Carp::longmess(@_) );
}

my ( $key_regexp, $key_regexp_double, $function_regexp );

sub sanitize_longmess {

    _build_regexes() if !$key_regexp;

    return join(
        &quot;\n&quot;,
        map {
            ( tr{'&quot;}{} &amp;&amp; ( m{$key_regexp}o || m{$key_regexp_double}o || ( ( $_ =~ m{^[ \t]*([^\(]+)\(} )[0] || '' ) =~ m{$function_regexp}o ) )    # matches a line that needs to be sanitized
              &amp;&amp; _sanitize_line($_);                                                                                                                # sanitize
            $_
        } split( m{\n}, $_[0] )
    ) . &quot;\n&quot;;
}

sub _sanitize_line {    # Operates directly on $_[0] for speed
    if ( !$INC{'Cpanel/Regex.pm'} ) {    # PPI NO PARSE - inc check
        local $@;
        eval {
            local $SIG{__DIE__};
            local $SIG{__WARN__};
            require Cpanel::Regex;    # PPI NO PARSE - inc check
        };
    }
    $_[0] =~ s/$Cpanel::Regex::regex{'singlequotedstring'}/__CPANEL_HIDDEN__/go if index( $_[0], q{'} ) != -1;
    $_[0] =~ s/$Cpanel::Regex::regex{'doublequotedstring'}/__CPANEL_HIDDEN__/go if index( $_[0], q{&quot;} ) != -1;
    return 1;
}

sub _build_regexes {

    my $key_regexp_items = join '|', @SAFE_LONGMESS_KEY_REGEXP_ITEMS;
    $key_regexp = qr&lt;
        '
        .*?
        (?:
            $key_regexp_items
        )
        .*?
        '
        \s*
        ,
    &gt;x;

    $key_regexp_double = $key_regexp;
    $key_regexp_double =~ tr{'}{&quot;};    # &quot;' fix for poor editors

    my $function_regexp_items = join '|', @SAFE_LONGMESS_FUNCTION_REGEXP_ITEMS;
    $function_regexp = qr&lt;
        ::
        .*?
        (?:
            $function_regexp_items
        )
        .*?
        $
    &gt;x;

    return 1;
}

1;

} # --- END Cpanel/Carp.pm


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


use strict;
use warnings;


sub difference {
    my ($super_ar) = @_;

    my %lookup;
    @lookup{ map { @$_ } @_[ 1 .. $#_ ] } = ();

    return grep { !exists $lookup{$_} } @$super_ar;
}


sub intersection {
    my ( $super_ar, $sub_ar ) = @_;

    my %lookup;
    @lookup{@$sub_ar} = ();

    return grep { exists $lookup{$_} } @$super_ar;
}

1;

} # --- END Cpanel/Set.pm


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


use strict;
use warnings;


use constant {
    _ENOENT =&gt; 2,
    _EDQUOT =&gt; 122,
    DEBUG   =&gt; 0,

    MAX_LOCKFILE_SIZE =&gt; 8192,
};


sub new {
    my ( $class, $path_to_lockfile, $fh, $path_to_file_being_locked ) = @_;

    if ( scalar @_ != 4 ) {
        die 'Usage: Cpanel::SafeFileLock-&gt;new($path_to_lockfile, $fh, $path_to_file_being_locked)';
    }

    if ($fh) {
        write_lock_contents( $fh, $path_to_lockfile ) or return;
    }


    my $self = bless [
        $path_to_lockfile,
        $fh,
        $path_to_file_being_locked,
    ], $class;

    push @$self, @{ $self-&gt;stat_ar() }[ 1, 9 ];

    return $self;
}

sub new_before_lock {
    my ( $class, $path_to_lockfile, $path_to_file_being_locked ) = @_;

    if ( scalar @_ != 3 ) {
        die 'Usage: Cpanel::SafeFileLock-&gt;new_before_lock($path_to_lockfile, $path_to_file_being_locked)';
    }

    return bless [
        $path_to_lockfile,
        undef,
        $path_to_file_being_locked,
    ], $class;
}

sub set_filehandle_and_unlinker_after_lock {

    $_[0][1] = $_[1];

    push @{ $_[0] }, @{ $_[0]-&gt;stat_ar() }[ 1, 9 ];

    $_[0][5] = $_[2];
    return $_[0];
}

sub get_path {
    return $_[0]-&gt;[0];
}

sub get_path_to_file_being_locked {
    return $_[0]-&gt;[2] // die &quot;get_path_to_file_being_locked requires the object to be instantiated with the path_to_file_being_locked&quot;;
}

sub set_filehandle {
    $_[0][1] = $_[1];
    return $_[0];
}

sub get_filehandle {
    return $_[0]-&gt;[1];
}

sub get_inode {
    return $_[0]-&gt;[3];
}

sub get_mtime {
    return $_[0]-&gt;[4];
}

sub get_path_fh_inode_mtime {
    return @{ $_[0] }[ 0, 1, 3, 4 ];
}

sub stat_ar {
    return [ stat( ( $_[0]-&gt;[1] &amp;&amp; fileno( $_[0]-&gt;[1] ) ) ? $_[0]-&gt;[1] : $_[0]-&gt;[0] ) ];
}

sub lstat_ar {

    return [ $_[0]-&gt;[1] &amp;&amp; fileno( $_[0]-&gt;[1] ) ? stat( $_[0]-&gt;[1] ) : lstat( $_[0]-&gt;[0] ) ];
}

sub close {

    return close $_[0]-&gt;[1] if ref $_[0]-&gt;[1];

    $_[0]-&gt;[5] = undef;

    return;
}


sub write_lock_contents {    ## no critic qw(Subroutines::RequireArgUnpacking) -- only unpack on the failure case
    local $!;

    if (DEBUG) {
        require Cpanel::Carp;
        return 1 if syswrite( $_[0], &quot;$$\n$0\n&quot; . Cpanel::Carp::safe_longmess() . &quot;\n&quot; );
    }
    return 1 if syswrite( $_[0], &quot;$$\n$0\n&quot; );

    my ( $fh, $path_to_lockfile ) = @_;
    my $write_error = $!;

    CORE::close($fh);
    unlink $path_to_lockfile;

    require Cpanel::Exception;
    die Cpanel::Exception::create( 'IO::FileWriteError', [ 'path' =&gt; $path_to_lockfile, 'error' =&gt; $write_error ] );
}

sub fetch_lock_contents_if_exists {
    my ($lockfile) = @_;

    die 'Need lock file!' if !$lockfile;

    open my $lockfile_fh, '&lt;:stdio', $lockfile or do {
        return if $! == _ENOENT();

        die &quot;open($lockfile): $!&quot;;
    };

    my $buffer;
    my $read_result = read( $lockfile_fh, $buffer, MAX_LOCKFILE_SIZE );

    if ( !defined $read_result ) {
        die &quot;read($lockfile): $!&quot;;
    }

    my ( $pid_line, $lock_name, $lock_obj ) = split( /\n/, $buffer, 3 );
    chomp($lock_name) if length $lock_name;
    my ($lock_pid) = $pid_line &amp;&amp; ( $pid_line =~ m/(\d+)/ );

    return ( $lock_pid, $lock_name || 'unknown', $lock_obj || 'unknown', $lockfile_fh );
}


1;


} # --- END Cpanel/SafeFileLock.pm


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


use strict;
use warnings;


sub is_a {
    return !ref $_[0] ? 0 : ( ref $_[0] eq 'IO::Handle' || ref $_[0] eq 'GLOB' || UNIVERSAL::isa( $_[0], 'GLOB' ) ) ? 1 : 0;
}


sub are_same {
    my ( $fh1, $fh2 ) = @_;

    return 1 if $fh1 eq $fh2;

    if ( fileno($fh1) &amp;&amp; ( fileno($fh1) != -1 ) &amp;&amp; fileno($fh2) &amp;&amp; ( fileno($fh2) != -1 ) ) {
        return 1 if fileno($fh1) == fileno($fh2);
    }

    return 0;
}


sub to_bitmask {
    my @fhs = @_;

    my $mask = q&lt;&gt;;

    for my $fh (@fhs) {
        vec( $mask, ref($fh) ? fileno($fh) : $fh, 1 ) = 1;
    }

    return $mask;
}

1;

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


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


use strict;


*get_fastest_hash = \&amp;fnv1a_32;


use constant FNV1_32A_INIT =&gt; 0x811c9dc5;

use constant FNV_32_PRIME =&gt; 0x01000193;

use constant FNV_32_MOD =&gt; 2**32;    # AKA 0x100000000 but that it non-portable;
sub fnv1a_32 {
    my $fnv32 = FNV1_32A_INIT();
    ( $fnv32 = ( ( $fnv32 ^ $_ ) * FNV_32_PRIME() ) % FNV_32_MOD ) for unpack( 'C*', $_[0] );
    return $fnv32;
}

1;

} # --- END Cpanel/Hash.pm


{ # --- BEGIN Cpanel/SafeFile/LockInfoCache.pm
package Cpanel::SafeFile::LockInfoCache;


use strict;
use warnings;

# use Cpanel::SafeFileLock ();


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

    die 'need path!' if !$pathname;

    return bless { _path =&gt; $pathname }, $class;
}


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

    die 'Need an inode &amp; an mtime!' if !defined $inode || !defined $mtime;

    if ( !exists $self-&gt;{&quot;_inode_${inode}_$mtime&quot;} ) {
        my ( $pid, $name, $obj, $fh ) = Cpanel::SafeFileLock::fetch_lock_contents_if_exists( $self-&gt;{'_path'} );

        if ($pid) {

            my ( $real_inode, $real_mtime ) = ( stat $fh )[ 1, 9 ];
            $self-&gt;{&quot;_inode_${real_inode}_$real_mtime&quot;} = [ $pid, $name, $obj ];
        }
    }

    return $self-&gt;{&quot;_inode_${inode}_$mtime&quot;} ||= undef;
}

1;

} # --- END Cpanel/SafeFile/LockInfoCache.pm


{ # --- BEGIN Cpanel/SafeFile/LockWatcher.pm
package Cpanel::SafeFile::LockWatcher;


use strict;
use warnings;

use constant _ENOENT =&gt; 2;

use constant _FILEHANDLE_TTL =&gt; 2;


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

    my $self = bless { _path =&gt; $lockfile, _new =&gt; 1 }, $class;

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


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

    my $old_inode = $self-&gt;{'inode'};
    @{$self}{qw( inode  uid  size mtime)} = $self-&gt;_get_inode_uid_size_mtime();

    if ( delete $self-&gt;{'_new'} ) {
        $self-&gt;{'changed'} = 0;
    }
    else {
        $self-&gt;{'changed'} = ( $self-&gt;{'inode'} || 0 ) != ( $old_inode || 0 ) ? 1 : 0;
    }

    return $self;
}

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

    my ( $inode, $uid, $size, $mtime );

    local $!;

    if ( open my $fh, '&lt;', $self-&gt;{'_path'} ) {
        ( $inode, $uid, $size, $mtime ) = ( stat $fh )[ 1, 4, 7, 9 ];

        $self-&gt;_add_fh_if_needed( $fh, $inode );
    }
    elsif ( $! != _ENOENT ) {
        die &quot;open(&lt;, $self-&gt;{'_path'}): $!&quot;;
    }

    return ( $inode, $uid, $size, $mtime );
}

sub _add_fh_if_needed {
    my ( $self, $fh, $inode ) = @_;

    my $now        = time;
    my $fhs_hr     = $self-&gt;{'_time_fhs'} //= {};
    my $seen_inode = 0;

    for my $time ( keys %$fhs_hr ) {

        if ( ( $now - $time ) &gt; _FILEHANDLE_TTL() ) {
            delete $fhs_hr-&gt;{$time};
            next;
        }

        if ( !$seen_inode ) {
            foreach my $entry ( @{ $fhs_hr-&gt;{$time} } ) {
                if ( $entry-&gt;[1] == $inode ) {
                    $seen_inode = 1;
                    last;
                }
            }
        }
    }

    return if $seen_inode;

    push @{ $fhs_hr-&gt;{ time() } }, [ $fh, $inode ];

    return;
}

1;

} # --- END Cpanel/SafeFile/LockWatcher.pm


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


use strict;
use warnings;


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

sub import {
    shift;

    _load_function($_) for @_;

    return;
}

our $AUTOLOAD;

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

    _load_function($AUTOLOAD);

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

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

    return;
}

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

    require $_[0];
    return;
}

1;

} # --- END Cpanel/Autodie.pm


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


use strict;
use warnings;

# use Cpanel::Exception ();

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

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

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

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

    return 1;
}

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

    return _die_context('scalar or list');
}

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

    local $Carp::CarpInternal{__PACKAGE__} if $INC{'Carp.pm'};

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

    die Cpanel::Exception::create_raw( 'ContextError', $to_throw );
}

1;

} # --- END Cpanel/Context.pm


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


use strict;

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

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

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

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

    return $self;
}

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

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

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

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

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

1;

} # --- END Cpanel/Pack.pm


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


use strict;

my %NAME_TO_NUMBER = qw(
  close             3
  fcntl            72
  lchown           94
  getrlimit        97
  getsid          124
  gettimeofday     96
  sendfile         40
  setrlimit       160
  splice          275
  write             1
  setsid          112
  getsid          124
  inotify_init1     294
  inotify_add_watch 254
  inotify_rm_watch  255
  setresuid       117
  setresgid       119
  setgroups       116
  umount2         166
);

sub name_to_number {
    my ($name) = @_;

    return $NAME_TO_NUMBER{$name} || _die_unknown_syscall($name);
}

sub _die_unknown_syscall {
    my ($name) = @_;

    die &quot;Unknown system call: “$name”&quot;;
}

sub syscall {    ##no critic qw(RequireArgUnpacking)
    local $!;

    _die_unknown_syscall( $_[0] ) unless defined $_[0] &amp;&amp; $NAME_TO_NUMBER{ $_[0] };

    my $ret = CORE::syscall( $NAME_TO_NUMBER{ $_[0] }, scalar @_ &gt; 1 ? @_[ 1 .. $#_ ] : () );
    if ( ( $ret == -1 ) &amp;&amp; $! ) {
        if ( $INC{'Cpanel/Exception.pm'} ) {
            die Cpanel::Exception::create( 'SystemCall', [ name =&gt; $_[0], error =&gt; $!, arguments =&gt; [ @_[ 1 .. $#_ ] ] ] );
        }
        else {
            die &quot;Failed system call “$_[0]”: $!&quot;;
        }
    }

    return $ret;
}

1;

} # --- END Cpanel/Syscall.pm


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


use strict;
use warnings;

# use Cpanel::Autodie          ();
# use Cpanel::Context          ();
# use Cpanel::Exception        ();
# use Cpanel::Fcntl::Constants ();
# use Cpanel::Pack             ();
# use Cpanel::Syscall          ();

use constant POLL_SIZE =&gt; 65536;

use constant READ_TEMPLATE =&gt; (
    wd     =&gt; 'i',    #int        Watch descriptor
    mask   =&gt; 'I',    #uint32_t   Mask of events
    cookie =&gt; 'I',    #uint32_t   Unique cookie associating related events
    len    =&gt; 'I',    #uint32_t   Size of “name” field
);

my %add_flags;
my %read_flags;
my %init1_flag;

my $UNPACK_OBJ;
my $UNPACK_SIZE;


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

    if ( !$UNPACK_OBJ ) {
        $UNPACK_OBJ  = Cpanel::Pack-&gt;new( [ READ_TEMPLATE() ] );
        $UNPACK_SIZE = $UNPACK_OBJ-&gt;sizeof();

        _setup_flags();
    }

    my @given_flags = $opts{'flags'} ? @{ $opts{'flags'} } : ();

    my $mask = 0;
    for my $f (@given_flags) {
        $mask |= $init1_flag{$f} || do {
            die Cpanel::Exception-&gt;create_raw(&quot;Invalid inotify_init1 flag: “$f”&quot;);
        };
    }

    my $fd = Cpanel::Syscall::syscall( 'inotify_init1', $mask );

    my %self = (
        _fd =&gt; $fd,
    );
    Cpanel::Autodie::open( $self{'_fh'}, '&lt;&amp;=', $fd );

    return bless \%self, $class;
}


sub add {
    my ( $self, $path, %opts ) = @_;

    my @flags = @{ $opts{'flags'} };

    my $mask = 0;
    for my $f (@flags) {
        $mask |= $add_flags{$f} || do {
            die Cpanel::Exception-&gt;create_raw(&quot;Invalid inotify_add_watch flag: “$f”&quot;);
        };
    }

    my $wd = Cpanel::Syscall::syscall(
        'inotify_add_watch',
        $self-&gt;{'_fd'},
        $path,
        $mask,
    );

    if ( $wd &lt; 1 ) {
        die Cpanel::Exception-&gt;create_raw(&quot;inotify watch descriptor “$wd” means something is wrong?&quot;);
    }

    $self-&gt;{'_watches'}{$wd} = $path;

    return $wd;
}


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

    Cpanel::Syscall::syscall( 'inotify_rm_watch', $self-&gt;{'_fd'}, $wd );

    return;
}


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

    Cpanel::Context::must_be_list();

    my $buf = q&lt;&gt;;

    Cpanel::Autodie::sysread_sigguard( $self-&gt;{'_fh'}, $buf, POLL_SIZE() );

    my @events;

    while ( length $buf ) {
        my $evt = $UNPACK_OBJ-&gt;unpack_to_hashref( substr( $buf, 0, $UNPACK_SIZE, q&lt;&gt; ) );
        $evt-&gt;{'name'} = substr( $buf, 0, delete( $evt-&gt;{'len'} ), q&lt;&gt; );
        $evt-&gt;{'name'} =~ s&lt;\0+\z&gt;&lt;&gt;;    #trailing NULs

        $evt-&gt;{'flags'} = _mask_to_flags_ar( delete $evt-&gt;{'mask'} );

        push @events, $evt;
    }

    return @events;
}


sub fileno {
    my ($self) = @_;
    return fileno( $self-&gt;{'_fh'} );
}


sub _mask_to_flags_ar {
    my ($mask) = @_;

    my @flags;
    for my $k ( keys %read_flags ) {
        push @flags, $k if $mask &amp; $read_flags{$k};
    }

    @flags = sort @flags;

    return \@flags;
}

sub _setup_flags {

    my %flag_num = (
        ACCESS        =&gt; 0x1,      # File was accessed
        MODIFY        =&gt; 0x2,      # File was modified
        ATTRIB        =&gt; 0x4,      # Metadata changed
        CLOSE_WRITE   =&gt; 0x8,      # File opened for writing was closed
        CLOSE_NOWRITE =&gt; 0x10,     # File not opened for writing was closed
        OPEN          =&gt; 0x20,     # File was opened
        MOVED_FROM    =&gt; 0x40,     # File was moved from X
        MOVED_TO      =&gt; 0x80,     # File was moved to Y
        CREATE        =&gt; 0x100,    # Subfile was created
        DELETE        =&gt; 0x200,    # Subfile was deleted
        DELETE_SELF   =&gt; 0x400,    # Self was deleted
        MOVE_SELF     =&gt; 0x800,    # Self was moved
    );

    %read_flags = (
        %flag_num,

        UNMOUNT    =&gt; 0x00002000,    # Backing fs was unmounted
        Q_OVERFLOW =&gt; 0x00004000,    # Event queued overflowed ('wd' is -1)
        IGNORED    =&gt; 0x00008000,    # Watch was removed
        ISDIR      =&gt; 0x40000000,    # event occurred against dir
    );

    %add_flags = (
        %flag_num,

        ONLYDIR     =&gt; 0x01000000,    # only watch the path if it is a directory
        DONT_FOLLOW =&gt; 0x02000000,    # don't follow a sym link
        EXCL_UNLINK =&gt; 0x04000000,    # exclude events on unlinked objects
        MASK_ADD    =&gt; 0x20000000,    # add to the mask of an already existing watch
        ONESHOT     =&gt; 0x80000000,    # only send event once

        CLOSE =&gt; $read_flags{'CLOSE_WRITE'} | $read_flags{'CLOSE_NOWRITE'},
        MOVE  =&gt; $read_flags{'MOVED_FROM'} | $read_flags{'MOVED_TO'},
    );

    my $mask = 0;
    $mask |= $_ for values %flag_num;

    $add_flags{'ALL_EVENTS'} = $mask;

    %init1_flag = (
        CLOEXEC  =&gt; $Cpanel::Fcntl::Constants::O_CLOEXEC,
        NONBLOCK =&gt; $Cpanel::Fcntl::Constants::O_NONBLOCK,
    );

    return;
}

1;

} # --- END Cpanel/Inotify.pm


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


use strict;
use warnings;


# use Cpanel::TimeHiRes        ();
# use Cpanel::Fcntl::Constants ();
# use Cpanel::SafeFileLock     ();
# use Cpanel::FHUtils::Tiny    ();

use constant {
    _EWOULDBLOCK =&gt; 11,
    _EACCES      =&gt; 13,
    _EDQUOT      =&gt; 122,
    _ENOENT      =&gt; 2,
    _EINTR       =&gt; 4,
    _EEXIST      =&gt; 17,
    _ENOSPC      =&gt; 28,
    _EPERM       =&gt; 1,

    MAX_LOCK_CREATE_ATTEMPTS =&gt; 90,

    NO_PERM_TO_WRITE_TO_DOTLOCK_DIR =&gt; -1,

    INOTIFY_FILE_DISAPPEARED =&gt; 2,

    CREATE_FCNTL_VALUE =&gt; ( $Cpanel::Fcntl::Constants::O_WRONLY | $Cpanel::Fcntl::Constants::O_EXCL | $Cpanel::Fcntl::Constants::O_CREAT | $Cpanel::Fcntl::Constants::O_NONBLOCK ),
    UNLOCK_FCNTL_VALUE =&gt; $Cpanel::Fcntl::Constants::LOCK_UN,

    LOCK_FILE_PERMS =&gt; 0644,

    DEFAULT_LOCK_WAIT_TIME =&gt; 196,

    MAX_LOCK_WAIT_TIME =&gt; 400,

    MAX_LOCK_FILE_LENGTH =&gt; 225,
};

$Cpanel::SafeFile::VERSION = '5.0';

my $OVERWRITE_FCNTL_VALUE;
my $verbose = 0;    # initialized in safelock

our $LOCK_WAIT_TIME;    #allow lock wait time to be overwritten

my $OPEN_LOCKS = 0;

our $TIME_BETWEEN_DOTLOCK_CHECKS = 0.3;
our $TIME_BETWEEN_FLOCK_CHECKS   = 0.05;
our $MAX_FLOCK_WAIT              = 60;     # allowed to be overwritten in tests

our $_SKIP_DOTLOCK_WHEN_NO_PERMS = 0;

our $_SKIP_WARN_ON_OPEN_FAIL = 0;


my $DOUBLE_LOCK_DETECTED = 4096;

sub safeopen {    #fh, open()-style mode, path
    my ( $mode, $file ) = _get_open_args( @_[ 1 .. $#_ ] );

    my $open_method_coderef = sub {
        my $ret = open( $_[0], $_[1], $_[2] ) || do {
            _log_warn(&quot;open($_[1], $_[2]): $!&quot;);
            return undef;
        };
        return $ret;
    };

    return _safe_open( $_[0], $mode, $file, $open_method_coderef, 'safeopen' );
}

sub safesysopen_no_warn_on_fail {
    local $_SKIP_WARN_ON_OPEN_FAIL = 1;

    return safesysopen(@_);
}

sub safesysopen_skip_dotlock_if_not_root {
    local $_SKIP_DOTLOCK_WHEN_NO_PERMS = $&gt; == 0 ? 0 : 1;

    return safesysopen(@_);
}

sub safeopen_skip_dotlock_if_not_root {
    local $_SKIP_DOTLOCK_WHEN_NO_PERMS = $&gt; == 0 ? 0 : 1;

    return safeopen(@_);
}

sub safelock_skip_dotlock_if_not_root {
    local $_SKIP_DOTLOCK_WHEN_NO_PERMS = $&gt; == 0 ? 0 : 1;

    return safelock(@_);
}

sub safereopen {    ##no critic qw(RequireArgUnpacking)
    my $fh = shift;

    if ( !$fh ) {
        require Cpanel::Carp;
        die Cpanel::Carp::safe_longmess(&quot;Undefined filehandle not allowed!&quot;);
    }
    elsif ( !fileno $fh ) {
        require Cpanel::Carp;
        die Cpanel::Carp::safe_longmess(&quot;Closed filehandle ($fh) not allowed!&quot;);
    }

    my ( $mode, $file ) = _get_open_args(@_);

    my $open_method_coderef = sub {
        return open( $_[0], $_[1], $_[2] ) || do {
            _log_warn(&quot;open($_[1], $_[2]): $!&quot;);
            return undef;
        };
    };

    return _safe_re_open( $fh, $mode, $file, $open_method_coderef, 'safereopen' );
}

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

    my ( $sysopen_perms, $original_umask );

    $open_mode = _sanitize_open_mode($open_mode);

    my $open_method_coderef = sub {
        return sysopen( $_[0], $_[2], $_[1], $sysopen_perms ) || do {
            _log_warn(&quot;open($_[2], $_[1], $sysopen_perms): $!&quot;) unless $_SKIP_WARN_ON_OPEN_FAIL;
            return undef;
        };
    };

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

    my $lock_ref;

    local $@;
    my $ok = eval {
        $lock_ref = _safe_open( $_[0], $open_mode, $file, $open_method_coderef, 'safesysopen' );
        1;
    };

    if ( defined $custom_perms ) {
        umask($original_umask);
    }

    die if !$ok;

    return $lock_ref;
}

sub safeclose {
    my ( $fh, $lockref, $do_something_before_releasing_lock ) = @_;

    if ( $do_something_before_releasing_lock &amp;&amp; ref $do_something_before_releasing_lock eq 'CODE' ) {
        $do_something_before_releasing_lock-&gt;();
    }

    my $success = 1;
    if ( $fh &amp;&amp; defined fileno $fh ) {

        flock( $fh, UNLOCK_FCNTL_VALUE ) or _log_warn( &quot;flock(LOCK_UN) on “&quot; . $lockref-&gt;get_path() . &quot;” failed with error: $!&quot; );    # LOCK_UN
        $success = close $fh;
    }

    my $safe_unlock = safeunlock($lockref);

    $OPEN_LOCKS-- if ( $safe_unlock &amp;&amp; $success );

    return ( $safe_unlock &amp;&amp; $success );
}

sub safelock {
    my ($file) = @_;

    my $lock_obj = _safelock($file);


    return if !ref $lock_obj;

    return $lock_obj;
}

sub _safelock {
    my ($file) = @_;
    if ( !$file || $file =~ tr/\0// ) {
        _log_warn('safelock: Invalid arguments');
        return;
    }
    $verbose ||= ( _verbose_flag_file_exists() ? 1 : -1 );

    my $lockfile      = _calculate_lockfile($file);
    my $safefile_lock = Cpanel::SafeFileLock-&gt;new_before_lock( $lockfile, $file );
    my ( $lock_status, $lock_fh, $attempts, $last_err );

    {
        local $@;

        while ( ++$attempts &lt; MAX_LOCK_CREATE_ATTEMPTS ) {

            ( $lock_status, $lock_fh ) = _lock_wait( $file, $safefile_lock, $lockfile );

            last if $lock_status;

            $last_err = $!;

            if ( $lock_fh &amp;&amp; $lock_fh == $DOUBLE_LOCK_DETECTED ) {
                return 0;
            }
        }

    }

    if ( $lock_fh == 1 ) {
        return 1;
    }
    elsif ( $lock_status &amp;&amp; $lock_fh ) {
        return $safefile_lock;
    }

    _log_warn( 'safelock: waited for lock (' . $lockfile . ') ' . $attempts . ' times' );
    require Cpanel::Exception;
    die Cpanel::Exception::create( 'IO::FileCreateError', [ 'path' =&gt; $lockfile, 'error' =&gt; $last_err ] );
}

sub _write_temp_lock_file {
    my ($lockfile) = @_;

    my $temp_file = sprintf(
        '%s-%x-%x-%x',
        $lockfile,
        substr( rand, 2 ),
        scalar( reverse time ),
        scalar( reverse $$ ),
    );

    my ( $ok, $fh_or_err ) = _create_lockfile($temp_file);
    if ( !$ok ) {


        if ( $fh_or_err == _EPERM() || $fh_or_err == _EACCES() ) {

            local $!;

            my $lock_dir = _getdir($lockfile);
            if ( !-w $lock_dir ) {


                if ($_SKIP_DOTLOCK_WHEN_NO_PERMS) {    # A hack to allow /etc/valiases to still be flock()ed until we can refactor
                    return ( NO_PERM_TO_WRITE_TO_DOTLOCK_DIR, $fh_or_err );
                }
                else {
                    _log_warn(&quot;safelock: Failed to create a lockfile '$temp_file' in the directory '$lock_dir' that isn't writable: $fh_or_err&quot;);
                }
            }
        }

        return ( 0, $fh_or_err );
    }

    Cpanel::SafeFileLock::write_lock_contents( $fh_or_err, $temp_file );

    return ( $temp_file, $fh_or_err );
}

sub _try_to_install_lockfile {
    my ( $temp_file, $lockfile ) = @_;

    link( $temp_file =&gt; $lockfile ) or do {
        return 0 if $! == _EEXIST;

        require Cpanel::Exception;

        die Cpanel::Exception::create( 'IO::LinkError', [ oldpath =&gt; $temp_file, newpath =&gt; $lockfile, error =&gt; $! ] );
    };

    return 1;
}

sub safeunlock {
    my $lockref = shift;

    if ( !$lockref ) {
        _log_warn('safeunlock: Invalid arguments');
        return;
    }
    elsif ( !ref $lockref ) {
        return 1 if $lockref eq '1';    # No lock file created so just succeed
        $lockref = Cpanel::SafeFileLock-&gt;new( $lockref, undef, undef );
        if ( !$lockref ) {
            _log_warn(&quot;safeunlock: failed to generate a Cpanel::SafeFileLock object from a path&quot;);
            return;
        }
    }
    my ( $lock_path, $fh, $lock_inode, $lock_mtime ) = $lockref-&gt;get_path_fh_inode_mtime();

    my ( $filesys_lock_ino, $filesys_lock_mtime ) = ( lstat $lock_path )[ 1, 9 ];

    if ( $fh &amp;&amp; !defined fileno($fh) ) {

        return 1;
    }
    elsif ( !$filesys_lock_mtime ) {
        _log_warn( 'Lock on ' . $lockref-&gt;get_path_to_file_being_locked() . ' lost!' );
        $lockref-&gt;close();
        return;    # return false on false
    }

    elsif ( $lock_inode &amp;&amp; ( $lock_inode == $filesys_lock_ino ) &amp;&amp; $lock_path &amp;&amp; ( $lock_mtime == $filesys_lock_mtime ) ) {
        unlink $lock_path or do {
            _log_warn(&quot;Could not unlink lock file “$lock_path” as ($&gt;/$)): $!\n&quot;);
            $lockref-&gt;close();
            return;    # return false on false
        };
        return $lockref-&gt;close();
    }

    $lockref-&gt;close();
    my ( $lock_pid, $lock_name, $lock_obj ) = Cpanel::SafeFileLock::fetch_lock_contents_if_exists($lock_path);

    if ($lock_pid) {

        if ( $lock_pid == $$ ) {
            unlink $lock_path;    # best-effort; ignore failure
            return 1;
        }

        $lock_inode ||= 0;
        $lock_mtime ||= 0;

        _log_warn(&quot;[$$] Attempt to unlock file that was locked by another process [LOCK_PATH]=[$lock_path] [LOCK_PID]=[$lock_pid] [LOCK_PROCESS]=[$lock_name] [LOCK_INODE]=[$filesys_lock_ino] [LOCK_MTIME]=[$filesys_lock_mtime] -- [NON_LOCK_PID]=[$$] [NON_LOCK_PROCESS]=[$0] [NON_LOCK_INODE]=[$lock_inode] [NON_LOCK_MTIME]=[$lock_mtime]&quot;);
    }
    return;
}

sub _safe_open {

    my ( undef, $open_mode, $file, $open_method_coderef, $open_method ) = @_;

    if ( !defined $open_mode || !$open_method_coderef || !$file || $file =~ tr/\0// ) {
        _log_warn('_safe_open: Invalid arguments');
        return;
    }
    elsif ( defined $_[0] ) {
        my $fh_type = ref $_[0];
        if ( !Cpanel::FHUtils::Tiny::is_a( $_[0] ) ) {
            _log_warn(&quot;Invalid file handle type '$fh_type' provided for $open_method of '$file'&quot;);
            return;
        }
    }

    if ( my $lockref = _safelock($file) ) {
        if ( $open_method_coderef-&gt;( $_[0], $open_mode, $file ) ) {
            if ( my $err = _do_flock_or_return_exception( $_[0], $open_mode, $file ) ) {
                safeunlock($lockref);
                local $@ = $err;
                die;
            }

            $OPEN_LOCKS++;
            return $lockref;
        }
        else {

            local $!;

            safeunlock($lockref);
            return;
        }
    }
    else {
        _log_warn(&quot;safeopen: could not acquire a lock for '$file': $!&quot;);
        return;
    }
}

my $_lock_ex_nb;
my $_lock_sh_nb;

sub _do_flock_or_return_exception {
    my ( $fh, $open_mode, $path ) = @_;

    my $flock_start_time;

    my $lock_op =
      _is_write_open_mode($open_mode)
      ? ( $_lock_ex_nb //= $Cpanel::Fcntl::Constants::LOCK_EX | $Cpanel::Fcntl::Constants::LOCK_NB )
      : ( $_lock_sh_nb //= $Cpanel::Fcntl::Constants::LOCK_SH | $Cpanel::Fcntl::Constants::LOCK_NB );

    local $!;
    my $flock_err;

    my $flock_max_wait_time_is_whole_number = int($MAX_FLOCK_WAIT) == $MAX_FLOCK_WAIT;

    while ( !flock $fh, $lock_op ) {
        $flock_err = $!;

        if ( $flock_err == _EINTR || $flock_err == _EWOULDBLOCK ) {
            if ( !$flock_start_time ) {
                $flock_start_time = $flock_max_wait_time_is_whole_number ? time() : Cpanel::TimeHiRes::time();
                next;
            }

            if ( ( ( $flock_max_wait_time_is_whole_number ? time() : Cpanel::TimeHiRes::time() ) - $flock_start_time ) &gt; $MAX_FLOCK_WAIT ) {
                require Cpanel::Exception;
                return _timeout_exception( $path, $MAX_FLOCK_WAIT );
            }
            else {
                Cpanel::TimeHiRes::sleep($TIME_BETWEEN_FLOCK_CHECKS);
            }
            next;
        }

        require Cpanel::Exception;
        return Cpanel::Exception::create( 'IO::FlockError', [ path =&gt; $path, error =&gt; $flock_err, operation =&gt; $lock_op ] );
    }

    return undef;
}

sub _safe_re_open {
    my ( $fh, $open_mode, $file, $open_method_coderef, $open_method ) = @_;

    if ( !defined $open_mode || !$open_method_coderef || !$file || $file =~ tr/\0// ) {
        _log_warn('_safe_re_open: Invalid arguments');
        return;
    }
    else {
        my $fh_type = ref $fh;
        if ( !Cpanel::FHUtils::Tiny::is_a($fh) ) {
            _log_warn(&quot;Invalid file handle type '$fh_type' provided for $open_method of '$file'&quot;);
            return;
        }
    }

    close $fh;
    if ( $open_method_coderef-&gt;( $fh, $open_mode, $file ) ) {
        if ( my $err = _do_flock_or_return_exception( $fh, $open_mode, $file ) ) {
            die $err;
        }

        return $fh;
    }
    return;
}

sub _log_warn {
    require Cpanel::Debug;
    goto &amp;Cpanel::Debug::log_warn;
}

sub _get_open_args {
    my ( $mode, $file ) = @_;
    if ( !$file ) {
        ( $mode, $file ) = $mode =~ m/^([&lt;&gt;+|]+|)(.*)/;
        if ( $file &amp;&amp; !$mode ) {
            $mode = '&lt;';
        }
        elsif ( !$file ) {
            return;
        }
    }

    $mode =
        $mode eq '&lt;'   ? '&lt;'
      : $mode eq '&gt;'   ? '&gt;'
      : $mode eq '&gt;&gt;'  ? '&gt;&gt;'
      : $mode eq '+&lt;'  ? '+&lt;'
      : $mode eq '+&gt;'  ? '+&gt;'
      : $mode eq '+&gt;&gt;' ? '+&gt;&gt;'
      :                  return;

    return ( $mode, $file );
}

sub _sanitize_open_mode {
    my ($mode) = @_;

    return if $mode =~ m/[^0-9]/;

    my $safe_mode = ( $mode &amp; $Cpanel::Fcntl::Constants::O_RDONLY );
    $safe_mode |= ( $mode &amp; $Cpanel::Fcntl::Constants::O_WRONLY );
    $safe_mode |= ( $mode &amp; $Cpanel::Fcntl::Constants::O_RDWR );
    $safe_mode |= ( $mode &amp; $Cpanel::Fcntl::Constants::O_CREAT );
    $safe_mode |= ( $mode &amp; $Cpanel::Fcntl::Constants::O_EXCL );
    $safe_mode |= ( $mode &amp; $Cpanel::Fcntl::Constants::O_APPEND );
    $safe_mode |= ( $mode &amp; $Cpanel::Fcntl::Constants::O_TRUNC );
    $safe_mode |= ( $mode &amp; $Cpanel::Fcntl::Constants::O_NONBLOCK );

    return $safe_mode;
}

sub _calculate_lockfile {    ## no critic qw(Subroutines::RequireArgUnpacking)
    my $lockfile = $_[0] =~ tr{&lt;&gt;}{} ? ( ( $_[0] =~ /^[&gt;&lt;]*(.*)/ )[0] . '.lock' ) : $_[0] . '.lock';

    return $lockfile if ( length $lockfile &lt;= MAX_LOCK_FILE_LENGTH );

    require File::Basename;
    my $lock_basename = File::Basename::basename($lockfile);

    return $lockfile if ( length $lock_basename &lt;= MAX_LOCK_FILE_LENGTH );

    require Cpanel::Hash;
    my $hashed_lock_basename = Cpanel::Hash::get_fastest_hash($lock_basename) . &quot;.lock&quot;;

    if ( $lockfile eq $lock_basename ) {
        return $hashed_lock_basename;
    }
    else {
        return File::Basename::dirname($lockfile) . '/' . $hashed_lock_basename;
    }
}

sub is_locked {
    my ($file) = @_;
    my $lockfile = _calculate_lockfile($file);
    my ( $lock_pid, $lock_name, $lock_obj ) = Cpanel::SafeFileLock::fetch_lock_contents_if_exists($lockfile);

    if ( _is_valid_pid($lock_pid) &amp;&amp; _pid_is_alive($lock_pid) ) {
        return 1;
    }

    return 0;
}

sub _timeout_exception {
    my ( $path, $waited ) = @_;

    require Cpanel::Exception;
    return Cpanel::Exception::create( 'Timeout', 'The system failed to lock the file “[_1]” after [quant,_2,second,seconds].', [ $path, $waited ] );
}

sub _die_if_file_is_flocked_cuz_already_waited_a_while {
    my ( $file, $waited ) = @_;

    if ( _open_to_write( my $fh, $file ) ) {
        $_lock_ex_nb //= $Cpanel::Fcntl::Constants::LOCK_EX | $Cpanel::Fcntl::Constants::LOCK_NB;
        if ( flock( $fh, $_lock_ex_nb ) == 1 ) {


            flock $fh, UNLOCK_FCNTL_VALUE or die &quot;Failed to unlock “$file” after having just locked it: $!&quot;;
        }
        else {
            require Cpanel::Exception;

            if ( $! == _EWOULDBLOCK ) {
                die _timeout_exception( $file, $waited );
            }
            else {
                die Cpanel::Exception::create( 'IO::FlockError', [ path =&gt; $file, error =&gt; $!, operation =&gt; $_lock_ex_nb ] );
            }
        }
    }

    return;
}

sub _lock_wait {    ## no critic qw(Subroutines::ProhibitExcessComplexity)
    my ( $file, $safefile_lock, $lockfile ) = @_;

    my ( $temp_file, $fh ) = _write_temp_lock_file( $lockfile, $file );

    if ( $temp_file eq NO_PERM_TO_WRITE_TO_DOTLOCK_DIR ) {
        return ( 1, 1 );
    }

    if ( !$temp_file ) {
        return ( 0, $fh );
    }

    $safefile_lock-&gt;set_filehandle_and_unlinker_after_lock( $fh, Cpanel::SafeFile::_temp-&gt;new($temp_file) );

    return ( 1, $fh ) if _try_to_install_lockfile( $temp_file, $lockfile );

    local $0 = ( $verbose == 1 ) ? &quot;$0 - waiting for lock on $file&quot; : &quot;$0 - waiting for lock&quot;;

    require Cpanel::SafeFile::LockInfoCache;
    require Cpanel::SafeFile::LockWatcher;

    my $watcher = Cpanel::SafeFile::LockWatcher-&gt;new($lockfile);

    my $waittime = _calculate_waittime_for_file($file);

    my ( $inotify_obj, $inotify_mask, $inotify_file_disappeared );

    my $start_time = time;
    my $waited     = 0;

    my $lockfile_cache = Cpanel::SafeFile::LockInfoCache-&gt;new($lockfile);

    my ( $inotify_inode, $inotify_mtime );

  LOCK_WAIT:
    while (1) {
        $waited = ( time() - $start_time );

        if ( $waited &gt; $waittime ) {

            _die_if_file_is_flocked_cuz_already_waited_a_while( $file, $waited );

            if ( defined $watcher-&gt;{'inode'} ) {
                require Cpanel::Debug;
                Cpanel::Debug::log_warn( sprintf &quot;Replacing stale lock file: $lockfile. The kernel’s lock is gone, last modified %s seconds ago (mtime=$watcher-&gt;{'mtime'}), and waited over $waittime seconds.&quot;, time - $watcher-&gt;{'mtime'} );
            }

            return ( 1, $fh ) if _overwrite_lockfile_if_inode_mtime_matches( $temp_file, $lockfile, $watcher-&gt;{'inode'}, $watcher-&gt;{'mtime'} );

            die _timeout_exception( $file, $waittime );
        }

        if ( $watcher-&gt;{'inode'} ) {
            my $lock_get = $lockfile_cache-&gt;get( @{$watcher}{ 'inode', 'mtime' } );

            if ( !$lock_get ) {


                my $size_before_reload = $watcher-&gt;{'size'};
                $watcher-&gt;reload_from_disk();

                if ( $size_before_reload == 0 &amp;&amp; $watcher-&gt;{'size'} == 0 ) {
                    _log_warn(&quot;[$$] UID $&gt; clobbering empty lock file “$lockfile” (UID $watcher-&gt;{'uid'}) written by “unknown” at $watcher-&gt;{'mtime'}&quot;);


                    return ( 1, $fh ) if _overwrite_lockfile_if_inode_mtime_matches( $temp_file, $lockfile, $watcher-&gt;{'inode'}, $watcher-&gt;{'mtime'} );
                }

                next LOCK_WAIT;
            }

            my ( $lock_pid, $lock_name, $lock_obj ) = @$lock_get;

            if ( $lock_pid == $$ ) {
                $watcher-&gt;reload_from_disk();

                _log_warn(&quot;[$$] Double locking detected by self [LOCK_PATH]=[$lockfile] [LOCK_PID]=[$lock_pid] [LOCK_OBJ]=[$lock_obj] [LOCK_PROCESS]=[$lock_name] [ACTUAL_INODE]=[$watcher-&gt;{'inode'}] [ACTUAL_MTIME]=[$watcher-&gt;{'mtime'}]&quot;);
                return ( 0, $DOUBLE_LOCK_DETECTED );
            }
            elsif ( !_pid_is_alive($lock_pid) ) {

                my $time = time();

                if ( _overwrite_lockfile_if_inode_mtime_matches( $temp_file, $lockfile, $watcher-&gt;{'inode'}, $watcher-&gt;{'mtime'} ) ) {
                    _log_warn(&quot;[$$] TIME $time UID $&gt; clobbered stale lock file “$lockfile” (NAME “$lock_name”, UID $watcher-&gt;{'uid'}) written by PID $lock_pid at $watcher-&gt;{'mtime'}&quot;);
                    return ( 1, $fh );
                }

                $watcher-&gt;reload_from_disk();
                next LOCK_WAIT;
            }
            else {
                require Cpanel::Debug;
                Cpanel::Debug::log_info(&quot;[$$] Waiting for lock on $file held by $lock_name with pid $lock_pid&quot;) if $verbose == 1;
            }
        }

        return ( 1, $fh ) if _try_to_install_lockfile( $temp_file, $lockfile );


        $watcher-&gt;reload_from_disk();

        if ( !$inotify_obj || !$inotify_inode || !$watcher-&gt;{'inode'} || $inotify_inode != $watcher-&gt;{'inode'} || $inotify_mtime != $watcher-&gt;{'mtime'} ) {

          INOTIFY: {
                ( $inotify_obj, $inotify_mask, $inotify_file_disappeared ) = _generate_inotify_for_lock_file($lockfile);

                $watcher-&gt;reload_from_disk();

                if ( $inotify_file_disappeared || !$watcher-&gt;{'inode'} ) {

                    undef $inotify_obj;

                    next LOCK_WAIT;
                }

                redo INOTIFY if $watcher-&gt;{'changed'};

                ( $inotify_inode, $inotify_mtime ) = @{$watcher}{ 'inode', 'mtime' };
            }
        }

        my $selected = _select( my $m = $inotify_mask, undef, undef, $TIME_BETWEEN_DOTLOCK_CHECKS );

        if ( $selected == -1 ) {

            die &quot;select() error: $!&quot; if $! != _EINTR();
        }
        elsif ($selected) {
            return ( 1, $fh ) if _try_to_install_lockfile( $temp_file, $lockfile );

            $watcher-&gt;reload_from_disk();

            () = $inotify_obj-&gt;poll();
        }
    }

    return;
}

sub _select {
    return select( $_[0], $_[1], $_[2], $_[3] );
}

sub _generate_inotify_for_lock_file {
    my ($file) = @_;
    require Cpanel::Inotify;
    my $inotify_obj;
    my $rin = '';

    local $@;
    eval {
        $inotify_obj = Cpanel::Inotify-&gt;new( flags =&gt; ['NONBLOCK'] );

        $inotify_obj-&gt;add( $file, flags =&gt; [ 'ATTRIB', 'DELETE_SELF' ] );

        vec( $rin, $inotify_obj-&gt;fileno(), 1 ) = 1;
    };

    if ($@) {
        my $err = $@;

        if ( eval { $err-&gt;isa('Cpanel::Exception::SystemCall') } ) {
            my $err = $err-&gt;get('error');
            if ( $err == _ENOENT ) {
                return ( undef, undef, INOTIFY_FILE_DISAPPEARED );
            }
            elsif ( $err != _EACCES ) {    # Don’t warn if EACCES
                local $@ = $err;
                warn;
            }
        }
        else {
            local $@ = $err;
            warn;
        }

        return;
    }

    return ( $inotify_obj, $rin, 0 );
}

sub _pid_is_alive {
    my ($pid) = @_;

    local $!;

    if ( kill( 0, $pid ) ) {
        return 1;
    }

    elsif ( $! == _EPERM ) {
        return !!( stat &quot;/proc/$pid&quot; )[0];
    }

    return 0;
}

sub _calculate_waittime_for_file {
    my ($file) = @_;

    return $LOCK_WAIT_TIME if $LOCK_WAIT_TIME;

    my $waittime = DEFAULT_LOCK_WAIT_TIME;

    if ( -e $file ) {
        $waittime = int( ( stat _ )[7] / 10000 );

        $waittime = $waittime &gt; MAX_LOCK_WAIT_TIME ? MAX_LOCK_WAIT_TIME : $waittime &lt; DEFAULT_LOCK_WAIT_TIME ? DEFAULT_LOCK_WAIT_TIME : $waittime;
    }

    return $waittime;
}

sub _is_valid_pid {
    my $pid = shift;

    return 0 unless defined $pid;

    return $pid =~ tr{0-9}{}c ? 0 : 1;
}

sub _getdir {
    my @path = split( /\/+/, $_[0] );
    return join( '/', (@path)[ 0 .. ( $#path - 1 ) ] ) || '.';
}

sub _create_lockfile {
    my $lock_fh;

    return sysopen( $lock_fh, $_[0], CREATE_FCNTL_VALUE, LOCK_FILE_PERMS ) ? ( 1, $lock_fh ) : ( 0, $! );
}

sub _open_to_write {
    my $path = $_[1];

    $OVERWRITE_FCNTL_VALUE ||= ( $Cpanel::Fcntl::Constants::O_WRONLY | $Cpanel::Fcntl::Constants::O_NONBLOCK | $Cpanel::Fcntl::Constants::O_APPEND | $Cpanel::Fcntl::Constants::O_NOFOLLOW );

    return sysopen( $_[0], $path, $OVERWRITE_FCNTL_VALUE, LOCK_FILE_PERMS );
}

sub _overwrite_lockfile_if_inode_mtime_matches {
    my ( $temp_file, $lockfile, $lockfile_inode, $lockfile_mtime ) = @_;

    my ( $inode, $mtime ) = ( stat $lockfile )[ 1, 9 ];

    if ( !$inode ) {
        die &quot;stat($lockfile): $!&quot; if $! != _ENOENT();
    }


    if ( !$inode || ( $inode == $lockfile_inode &amp;&amp; $mtime == $lockfile_mtime ) ) {
        rename( $temp_file, $lockfile ) or do {
            require Cpanel::Exception;
            die Cpanel::Exception::create( 'IO::RenameError', [ oldpath =&gt; $temp_file, newpath =&gt; $lockfile, error =&gt; $! ] );
        };

        return 1;
    }

    return 0;
}

sub _is_write_open_mode {
    my ($mode) = @_;

    if ( $mode =~ tr{0-9}{}c ) {
        if ( $mode &amp;&amp; ( -1 != index( $mode, '&gt;' ) || -1 != index( $mode, '+' ) ) ) {
            return 1;
        }
    }
    else {
        if ( $mode &amp;&amp; ( ( $mode &amp; $Cpanel::Fcntl::Constants::O_WRONLY ) || ( $mode &amp; $Cpanel::Fcntl::Constants::O_RDWR ) ) ) {
            return 1;
        }
    }
    return 0;
}

sub _verbose_flag_file_exists {
    return -e '/var/cpanel/safefile_verbose';
}


package Cpanel::SafeFile::_temp;


use constant _ENOENT =&gt; 2;

sub new { return bless [ $_[1], $_SKIP_DOTLOCK_WHEN_NO_PERMS, $$ ], $_[0]; }

sub DESTROY {
    local $!;

    unlink $_[0]-&gt;[0] or do {
        if ( !$_[0]-&gt;[1] &amp;&amp; $! != _ENOENT &amp;&amp; $_[0]-&gt;[2] == $$ ) {
            warn &quot;unlink($_[0]-&gt;[0]): $!&quot;;
        }
    };

    return;
}

1;


} # --- END Cpanel/SafeFile.pm


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


use strict;
use warnings;

use constant {
    NAME_MAX =&gt; 255,
    PATH_MAX =&gt; 4096,
};

1;

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


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


use strict;
use warnings;

# use Cpanel::Exception        ();
# use Cpanel::Linux::Constants ();

sub is_valid {
    my ($node) = @_;

    local $@;
    eval { validate_or_die($node); };

    return $@ ? 0 : 1;
}

sub validate_or_die {
    my ($name) = @_;

    if ( !length $name ) {
        die Cpanel::Exception::create('Empty');
    }
    elsif ( $name eq '.' || $name eq '..' ) {
        die Cpanel::Exception::create( 'Reserved', [ value =&gt; $name ] );
    }
    elsif ( length $name &gt; Cpanel::Linux::Constants::NAME_MAX() ) {
        die Cpanel::Exception::create( 'TooManyBytes', [ value =&gt; $name, maxlength =&gt; Cpanel::Linux::Constants::NAME_MAX() ] );
    }
    elsif ( index( $name, '/' ) != -1 ) {
        die Cpanel::Exception::create( 'InvalidCharacters', [ value =&gt; $name, invalid_characters =&gt; ['/'] ] );
    }
    elsif ( index( $name, &quot;\0&quot; ) != -1 ) {
        die Cpanel::Exception::create( 'InvalidCharacters', 'This value may not contain a [asis,NUL] byte.', [ value =&gt; $name, invalid_characters =&gt; [&quot;\0&quot;] ] );
    }

    return 1;
}

1;

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


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


use strict;
use warnings;

# use Cpanel::Set                          ();
# use Cpanel::Fcntl                        ();
# use Cpanel::SafeFile                     ();
# use Cpanel::LoadModule                   ();
# use Cpanel::Validate::FilesystemNodeName ();
# use Cpanel::Exception                    ();
# use Cpanel::Debug                        ();

our $VERSION = '1.8';

my $DEFAULT_CONTENT_TYPE = 'text/plain; charset=utf-8';
our $NOTIFY_INTERVAL_STORAGE_DIR = '/var/cpanel/notifications';

sub notification_class {
    my (%args) = @_;

    if ( !defined $args{'interval'} ) {
        $args{'interval'} = 1;
    }

    if ( !defined $args{'status'} ) {
        $args{'status'} = 'No status set';
    }

    foreach my $param (qw(application status class constructor_args)) {
        die Cpanel::Exception::create( 'MissingParameter', [ 'name' =&gt; $param ] ) if !defined $args{$param};
    }

    if ( my @unwelcome_params = Cpanel::Set::difference( [ keys %args ], [qw(application status class constructor_args interval)] ) ) {
        die Cpanel::Exception::create_raw(
            'InvalidParameters',
            &quot;The following parameters don't belong as an argument to notification_class(); you may have meant to pass these in constructor_args instead: &quot; . join( ' ', @unwelcome_params )
        );
    }

    my $constructor_args = { @{ $args{'constructor_args'} } };

    if ( $constructor_args-&gt;{'skip_send'} ) {
        my $class = &quot;Cpanel::iContact::Class::$args{'class'}&quot;;
        Cpanel::LoadModule::load_perl_module($class);

        return $class-&gt;new(%$constructor_args);
    }

    return _notification_backend(
        $args{'application'},
        $args{'status'},
        $args{'interval'},
        sub {
            my $class = &quot;Cpanel::iContact::Class::$args{'class'}&quot;;
            Cpanel::LoadModule::load_perl_module($class);
            return $class-&gt;new(%$constructor_args);
        },
    );
}

sub notification {
    my %AGS = @_;

    my $app = $AGS{'app'} || $AGS{'application'} || 'Notice';

    return _notification_backend(
        $app,
        $AGS{'status'},
        $AGS{'interval'} || 0,
        sub {
            my $module = &quot;Cpanel::iContact&quot;;
            Cpanel::LoadModule::load_perl_module($module);

            my $from              = $AGS{'from'};
            my $to                = $AGS{'to'};
            my $msgheader         = $AGS{'msgheader'} || $AGS{'subject'};
            my $message           = $AGS{'message'};
            my $plaintext_message = $AGS{'plaintext_message'};
            my $priority          = $AGS{'priority'}     || 3;
            my $attach_files      = $AGS{'attach_files'} || [];

            my $content_type = $AGS{'content-type'} || $DEFAULT_CONTENT_TYPE;

            &quot;$module&quot;-&gt;can('icontact')-&gt;(
                'attach_files'      =&gt; $attach_files,
                'application'       =&gt; $app,
                'level'             =&gt; $priority,
                'from'              =&gt; $from,
                'to'                =&gt; $to,
                'subject'           =&gt; $msgheader,
                'message'           =&gt; $message,
                'plaintext_message' =&gt; $plaintext_message,
                'content-type'      =&gt; $content_type,
            );
        }
    );
}

sub _notification_backend {
    my ( $app, $status, $interval, $todo_cr ) = @_;

    my $is_ready = _checkstatusinterval(
        'app'      =&gt; $app,
        'status'   =&gt; $status,
        'interval' =&gt; $interval,
    );

    if ($is_ready) {
        return $todo_cr-&gt;();
    }
    elsif ( $Cpanel::Debug::level &gt; 3 ) {
        Cpanel::Debug::log_warn(&quot;not sending notify app=[$app] status=[$status] interval=[$interval]&quot;);
    }

    return $is_ready ? 1 : 0;
}

sub notify_blocked {
    my %AGS      = @_;
    my $app      = $AGS{'app'};
    my $status   = $AGS{'status'};
    my $interval = $AGS{'interval'};

    return 0 if $interval &lt;= 1;    # Special Case (ignore interval check);

    $app    =~ s{/}{_}g;           # Its possible to have slashes in the app name
    $status =~ s{:}{_}g;           # Its possible to have colons in the status

    my $db_file = &quot;$NOTIFY_INTERVAL_STORAGE_DIR/$app&quot;;

    return 0 if !-e $db_file;

    my %notifications;
    my $notify_db_fh;
    if (
        my $nlock = Cpanel::SafeFile::safesysopen(
            $notify_db_fh, $db_file, Cpanel::Fcntl::or_flags('O_RDONLY'),
            0600
        )
    ) {
        local $/;
        %notifications = map { ( split( /:/, $_, 2 ) )[ 0, 1 ] } split( m{\n}, readline($notify_db_fh) );
        Cpanel::SafeFile::safeclose( $notify_db_fh, $nlock );
    }
    else {
        Cpanel::Debug::log_warn(&quot;Could not open $db_file: $!&quot;);
        return;
    }

    if ( $notifications{$status} &amp;&amp; ( ( $notifications{$status} + $interval ) &gt; time() ) ) {
        return 1;
    }

    return 0;
}

{
    no warnings 'once';
    *update_notification_time_if_interval_reached = \&amp;_checkstatusinterval;
}

sub _checkstatusinterval {
    my %AGS      = @_;
    my $app      = $AGS{'app'};
    my $status   = $AGS{'status'};
    my $interval = $AGS{'interval'};

    return 1 if $interval &lt;= 1;    # Special Case (ignore interval check);

    $app    =~ s{/}{_}g;           # Its possible to have slashes in the app name
    $status =~ s{:}{_}g;           # Its possible to have colons in the status
    Cpanel::Validate::FilesystemNodeName::validate_or_die($app);

    my $notify = 0;

    if ( !-e $NOTIFY_INTERVAL_STORAGE_DIR ) {
        Cpanel::LoadModule::load_perl_module('Cpanel::SafeDir::MK');
        Cpanel::SafeDir::MK::safemkdir( $NOTIFY_INTERVAL_STORAGE_DIR, '0700' );
        if ( !-d $NOTIFY_INTERVAL_STORAGE_DIR ) {
            Cpanel::Debug::log_warn(&quot;Failed to setup notifications directory: $NOTIFY_INTERVAL_STORAGE_DIR: $!&quot;);
            return;
        }
    }

    my %notifications;
    my $notify_db_fh;
    my $db_file = &quot;$NOTIFY_INTERVAL_STORAGE_DIR/$app&quot;;
    if ( my $nlock = Cpanel::SafeFile::safesysopen( $notify_db_fh, $db_file, Cpanel::Fcntl::or_flags(qw( O_RDWR O_CREAT )), 0600 ) ) {
        local $/;
        %notifications = map { ( split( /:/, $_, 2 ) )[ 0, 1 ] } split( m{\n}, readline($notify_db_fh) );
        if ( !exists $notifications{$status} || ( int( $notifications{$status} ) + int($interval) ) &lt; time() ) {
            $notifications{$status} = time;
            $notify = 1;
        }
        seek( $notify_db_fh, 0, 0 );
        print {$notify_db_fh} join( &quot;\n&quot;, map { $_ . ':' . $notifications{$_} } sort keys %notifications );
        truncate( $notify_db_fh, tell($notify_db_fh) );
        Cpanel::SafeFile::safeclose( $notify_db_fh, $nlock );
    }
    else {
        Cpanel::Debug::log_warn(&quot;Could not open $db_file: $!&quot;);
        return;
    }

    return $notify;
}

1;

} # --- END Cpanel/Notify.pm


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


use strict;

sub is_subprocess_of_cpsrvd {
    return 0 if $INC{'cpanel/cpsrvd.pm'};    # If we ARE cpsrvd we do not want this behavior
    return $ENV{'CPANEL'} ? 1 : 0;
}

1;

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


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


use strict;

# use Cpanel::Time::Local ();

my $is_sandbox;
my $is_smoker;
our $VERSION = 1.3;

use constant TRACE_TOUCH_FILE =&gt; '/var/cpanel/log_stack_traces';

our $ENABLE_BACKTRACE;

our $DISABLE_OUTPUT;    # used by cpanminus
our $ALWAYS_OUTPUT_TO_STDERR;

our $STD_LOG_FILE   = '/usr/local/cpanel/logs/error_log';
our $PANIC_LOG_FILE = '/usr/local/cpanel/logs/panic_log';

my ( $cached_progname, $cached_prog_pid, %singleton_stash );

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

    if ( $hr_args-&gt;{'open_now'} &amp;&amp; $hr_args-&gt;{'use_no_files'} ) {
        die &quot;“open_now” and “use_no_files” mutually exclude!&quot;;
    }

    my $args_sig = 'no_args';
    if ( $hr_args &amp;&amp; ref($hr_args) eq 'HASH' ) {

        $args_sig = join( ',', map { $_ . '=&gt;' . $hr_args-&gt;{$_} } sort keys %{$hr_args} );    # Storable::freeze($hr_args);
    }

    my $no_load_from_cache = $hr_args-&gt;{'no_load_from_cache'} ? 1 : 0;

    if ( exists $singleton_stash{$class}{$args_sig} and !$no_load_from_cache ) {
        $singleton_stash{$class}{$args_sig}-&gt;{'cloned'}++;
    }
    else {
        $singleton_stash{$class}{$args_sig} = bless( {}, $class );
        if ( $hr_args &amp;&amp; ref($hr_args) eq 'HASH' ) {
            foreach my $k ( keys %$hr_args ) {
                $singleton_stash{$class}{$args_sig}-&gt;{$k} = $hr_args-&gt;{$k};
            }
        }
    }
    my $self = $singleton_stash{$class}{$args_sig};

    if ( !$self-&gt;{'cloned'} ) {

        if ( $self-&gt;{'open_now'} &amp;&amp; !$self-&gt;{'use_no_files'} ) {
            $self-&gt;_open_logfile();
        }
    }

    $self-&gt;_set_backtrace( $ENABLE_BACKTRACE // $self-&gt;{'backtrace'} // _get_backtrace_touchfile() );

    return $self;
}

sub __Logger_pushback {
    if ( @_ &amp;&amp; index( ref( $_[0] ), __PACKAGE__ ) == 0 ) {
        return @_;
    }
    return ( __PACKAGE__-&gt;new(), @_ );
}

sub invalid {
    my ( $self, @list ) = __Logger_pushback(@_);

    my %log = (
        'message'   =&gt; $list[0],
        'level'     =&gt; 'invalid',
        'output'    =&gt; 0,
        'service'   =&gt; $self-&gt;find_progname(),
        'backtrace' =&gt; $self-&gt;get_backtrace(),
        'die'       =&gt; 0,
    );

    if ( is_sandbox() ) {
        if ( !-e '/var/cpanel/DEBUG' ) {
            $self-&gt;notify( 'invalid', \%log );
        }
        $log{'output'} = _stdin_is_tty() ? 2 : 1;
    }
    return $self-&gt;logger( \%log );
}    # end of invalid

sub is_sandbox {
    return 0           if $INC{'B/C.pm'};        # avoid cache during compile
    return $is_sandbox if defined $is_sandbox;
    return ( $is_sandbox = -e '/var/cpanel/dev_sandbox' ? 1 : 0 );
}

sub is_smoker {
    return 0          if $INC{'B/C.pm'};         # avoid cache during compile
    return $is_smoker if defined $is_smoker;
    return ( $is_smoker = -e '/var/cpanel/smoker' ? 1 : 0 );
}

sub deprecated {    ## no critic qw(Subroutines::RequireArgUnpacking)
    my ( $self, @list ) = __Logger_pushback(@_);

    my %log = (
        'message'   =&gt; $list[0],
        'level'     =&gt; 'deprecated',
        'output'    =&gt; 0,
        'service'   =&gt; $self-&gt;find_progname(),
        'backtrace' =&gt; $self-&gt;get_backtrace(),
        'die'       =&gt; 0,
    );

    unless ( is_sandbox() ) {
        $self-&gt;logger( \%log );
        return;
    }

    $self-&gt;notify( 'deprecated', \%log );

    $log{'output'} = _stdin_is_tty() ? 2 : 1;
    $log{'die'}    = 1;

    return $self-&gt;logger( \%log );
}

sub debug {
    my ( $self, $message, $conf_hr ) = @_;    # not appropriate for debug() : __Logger_pushback(@_);

    $self = $self-&gt;new() if !ref $self;

    $conf_hr ||= {
        'force'     =&gt; 0,
        'backtrace' =&gt; 0,
        'output'    =&gt; 1,    # Logger's debug level should output to STDOUT
    };
    return unless $conf_hr-&gt;{'force'} || ( defined $Cpanel::Debug::level &amp;&amp; $Cpanel::Debug::level );    ## PPI NO PARSE - avoid recursive use statements

    if ( !defined $message ) {
        my @caller = caller();
        $message = &quot;debug() at $caller[1] line $caller[2].&quot;;
    }

    my %log = (
        'message'   =&gt; $message,
        'level'     =&gt; 'debug',
        'output'    =&gt; $conf_hr-&gt;{'output'},
        'backtrace' =&gt; $conf_hr-&gt;{'backtrace'},
    );

    if ( ref $log{'message'} ) {

        my $outmsg = $log{'message'};
        eval 'local $SIG{__DIE__}; local $SIG{__WARN__}; require Cpanel::YAML::Syck; $outmsg = YAML::Syck::Dump($outmsg);';
        my @caller = caller();
        $log{'message'} = &quot;$log{'message'} at $caller[1] line $caller[2]:\n&quot; . $outmsg;
    }
    elsif ( $log{'message'} =~ m/\A\d+(?:\.\d+)?\z/ ) {
        $log{'message'} = &quot;debug() number $log{'message'}&quot;;
    }

    $self-&gt;logger( \%log );

    return \%log;
}

sub info {
    my ( $self, @list ) = __Logger_pushback(@_);
    return $self-&gt;logger(
        {
            'message' =&gt; $list[0],
            'level'   =&gt; 'info',

            'output'    =&gt; $self-&gt;{'open_now'} ? 0 : 1,    # FB#59177: info level should output to STDOUT
            'backtrace' =&gt; 0

        }
    );
}    # end of info

sub warn {
    my ( $self, @list ) = __Logger_pushback(@_);
    return $self-&gt;logger(
        {
            'message'   =&gt; $list[0],
            'level'     =&gt; 'warn',
            'output'    =&gt; _stdin_is_tty() ? 2 : 0,
            'backtrace' =&gt; $self-&gt;get_backtrace()
        }
    );
}    # end of warn

sub error {
    my ( $self, @list ) = __Logger_pushback(@_);
    return $self-&gt;logger(
        {
            'message'   =&gt; $list[0],
            'level'     =&gt; 'error',
            'output'    =&gt; -t STDIN ? 2 : 0,
            'backtrace' =&gt; $self-&gt;get_backtrace()
        }
    );
}    # end of error

sub die {
    my ( $self, @list ) = __Logger_pushback(@_);
    my %log = (
        'message'   =&gt; $list[0],
        'level'     =&gt; 'die',
        'output'    =&gt; _stdin_is_tty() ? 2 : 0,
        'backtrace' =&gt; $self-&gt;get_backtrace()
    );
    return $self-&gt;logger( \%log );
}    # end of die

sub panic {
    my ( $self, @list ) = __Logger_pushback(@_);
    my %log = (
        'message'   =&gt; $list[0],
        'level'     =&gt; 'panic',
        'output'    =&gt; 2,
        'backtrace' =&gt; $self-&gt;get_backtrace()
    );
    return $self-&gt;logger( \%log );
}    # end of panic

sub raw {
    return $_[0]-&gt;logger(
        {
            'message'   =&gt; $_[1],
            'level'     =&gt; 'raw',
            'output'    =&gt; 0,
            'backtrace' =&gt; 0
        }
    );
}

sub cplog {
    my $msg      = shift;
    my $loglevel = shift;
    my $service  = shift;
    my $nostdout = shift;
    if ( !$nostdout ) {
        $nostdout = 1;
    }
    else {
        $nostdout = 0;
    }
    logger( { 'message' =&gt; $msg, 'level' =&gt; $loglevel, 'service' =&gt; $service, 'output' =&gt; $nostdout, 'backtrace' =&gt; $ENABLE_BACKTRACE // _get_backtrace_touchfile() } );
}    # end of cplog (deprecated)


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

    my $hr = ref($cfg_or_msg) eq 'HASH' ? $cfg_or_msg : { 'message' =&gt; $cfg_or_msg };

    $hr-&gt;{'message'} ||= 'Something is wrong';

    $hr-&gt;{'level'}  ||= '';
    $hr-&gt;{'output'} ||= 0;

    $hr-&gt;{'output'} = 0 if $DISABLE_OUTPUT;
    if ( !exists $hr-&gt;{'backtrace'} ) {
        $hr-&gt;{'backtrace'} = $self-&gt;get_backtrace();
    }

    $hr-&gt;{'use_no_files'} ||= 0;
    $hr-&gt;{'use_fullmsg'}  ||= 0;

    return $hr;
}

sub _write {
    return print { $_[0] } $_[1];
}

sub get_backtrace {
    my ($self) = __Logger_pushback(@_);

    return $ENABLE_BACKTRACE // $self-&gt;{'backtrace'};
}

sub _set_backtrace {
    my ( $self, @args ) = __Logger_pushback(@_);
    $self-&gt;{'backtrace'} = $args[0] ? 1 : 0;
    return;
}

sub _get_backtrace_touchfile {
    return -e TRACE_TOUCH_FILE ? 1 : 0;
}

sub get_fh {
    my ($self) = @_;
    return $self-&gt;{'log_fh'};
}

sub set_fh {
    my ( $self, $fh ) = @_;
    $self-&gt;{'log_fh'} = $fh;
    return 1;
}
sub logger {    ## no critic(RequireArgUnpacking)
    my ( $self, @list ) = __Logger_pushback(@_);
    my $hr = $self-&gt;_get_configuration_for_logger( $list[0] );
    my ( $msg, $time, $status );
    $status = 1;

    my ($msg_maybe_bt) = $hr-&gt;{'backtrace'} ? $self-&gt;backtrace( $hr-&gt;{'message'} ) : $hr-&gt;{'message'} . &quot;\n&quot;;

    if ( $hr-&gt;{'level'} eq 'raw' ) {
        $msg = $hr-&gt;{'message'};
    }
    else {
        $time ||= Cpanel::Time::Local::localtime2timestamp();
        $hr-&gt;{'service'} ||= $self-&gt;find_progname();                       # only compute the service name if we HAVE to do so as it can be expensive

        if ( $self-&gt;{'log_pid'} ) {
            $msg = &quot;[$time] $hr-&gt;{'level'} [$hr-&gt;{'service'}] [$$] $msg_maybe_bt&quot;;
        }
        else {
            $msg = &quot;[$time] $hr-&gt;{'level'} [$hr-&gt;{'service'}] $msg_maybe_bt&quot;;
        }
    }
    unless ( $hr-&gt;{'use_no_files'} ) {

        local $self-&gt;{'log_fh'} = \*STDERR if $ALWAYS_OUTPUT_TO_STDERR;

        $self-&gt;_open_logfile() if !$self-&gt;{'log_fh'} || ( !eval { fileno( $self-&gt;{'log_fh'} ) } &amp;&amp; !UNIVERSAL::isa( $self-&gt;{'log_fh'}, 'IO::Scalar' ) );
        _write( $self-&gt;{'log_fh'}, $msg ) or $status = 0;

        if ( $hr-&gt;{'level'} eq 'panic' || $hr-&gt;{'level'} eq 'invalid' || $hr-&gt;{'level'} eq 'deprecated' ) {
            my $panic_fh;
            require Cpanel::FileUtils::Open;
            if ( Cpanel::FileUtils::Open::sysopen_with_real_perms( $panic_fh, $PANIC_LOG_FILE, 'O_WRONLY|O_APPEND|O_CREAT', 0600 ) ) {
                $time ||= Cpanel::Time::Local::localtime2timestamp();
                $hr-&gt;{'service'} ||= $self-&gt;find_progname();                       # only compute the service name if we HAVE to do so as it can be expensive
                _write( $panic_fh, &quot;$time $hr-&gt;{level} [$hr-&gt;{'service'}] $msg_maybe_bt&quot; );
                close $panic_fh;
            }
        }
    }

    if ( $hr-&gt;{'output'} ) {
        $hr-&gt;{'service'} ||= $self-&gt;find_progname();    # only compute the service name if we HAVE to do so as it can be expensive
        my $out = &quot;$hr-&gt;{level} [$hr-&gt;{'service'}] $hr-&gt;{'message'}\n&quot;;
        if ( $self-&gt;{'timestamp_prefix'} ) {
            $out = &quot;[$time] $out&quot;;
        }
        $out = $msg if $hr-&gt;{'use_fullmsg'};

        $status &amp;&amp;= $self-&gt;_write_message( $hr, $out );
    }

    if ( ( $hr-&gt;{'level'} eq 'die' || $hr-&gt;{'level'} eq 'panic' || $hr-&gt;{'die'} ) ) {
        CORE::die &quot;exit level [$hr-&gt;{'level'}] [pid=$$] ($hr-&gt;{'message'})\n&quot;;    # make sure we die if die is overwritten
    }

    return $status;
}    # end of logger

sub _write_message {
    my ( $self, $hr, $out ) = @_;
    my $status = 1;

    if ( $hr-&gt;{'output'} == 3 ) {
        _write( \*STDOUT, $out ) or $status = 0;
        _write( \*STDERR, $out ) or $status = 0;
    }
    elsif ( $hr-&gt;{'output'} == 1 &amp;&amp; ( $self-&gt;{'use_stdout'} || _stdout_is_tty() ) ) {
        _write( \*STDOUT, $out ) or $status = 0;
    }
    elsif ( $hr-&gt;{'output'} == 2 ) {
        _write( \*STDERR, $out ) or $status = 0;
    }
    return $status;
}

sub find_progname {
    if ( $cached_progname &amp;&amp; $cached_prog_pid == $$ ) {
        return $cached_progname;
    }
    my $s = $0;

    if ( !length $s ) {    # Someone _could_ set $0 = '';
        my $i = 1;         # 0 is always find_progname
        while ( my @service = caller( $i++ ) ) {
            last             if ( $service[3] =~ /::BEGIN$/ );
            $s = $service[1] if ( $service[1] ne '' );
        }
    }

    $s =~ s@.+/(.+)$@$1@ if $s =~ tr{/}{};

    $s =~ s@\..+$@@ if $s =~ tr{\.}{};

    $s =~ s@ .*$@@ if $s =~ tr{ }{};

    $cached_progname = $s;
    $cached_prog_pid = $$;

    return $s;
}

sub backtrace {    ## no critic qw(Subroutines::RequireArgUnpacking)
    my ( $self, @list ) = __Logger_pushback(@_);
    if ( ref $list[0] ) {
        return $list[0] if scalar @list == 1;
        return (@list);
    }
    require Cpanel::Carp;
    local $_;    # Protect surrounding program - just in case...
    local $Carp::Internal{ (__PACKAGE__) } = 1;
    local $Carp::Internal{'Cpanel::Debug'} = 1;
    return Cpanel::Carp::safe_longmess(@list);

}

sub redirect_stderr_to_error_log {
    return open( STDERR, '&gt;&gt;', $STD_LOG_FILE );
}

sub notify {
    my ( $self, $call, $log_ref ) = @_;

    my $time = Cpanel::Time::Local::localtime2timestamp();
    my ($bt) = $self-&gt;backtrace( $log_ref-&gt;{'message'} );
    $log_ref-&gt;{'service'} //= '';
    my $logfile = qq{$time [$log_ref-&gt;{'service'}] } . ( $bt // '' );

    if ( eval { require Cpanel::LoadModule; Cpanel::LoadModule::load_perl_module('Cpanel::iContact::Class::Logger::Notify'); 1; } ) {

        eval {
            require Cpanel::Notify;
            Cpanel::Notify::notification_class(
                'class'            =&gt; 'Logger::Notify',
                'application'      =&gt; 'Logger::Notify',
                'constructor_args' =&gt; [
                    'origin'       =&gt; $log_ref-&gt;{'service'},
                    'logger_call'  =&gt; $call,
                    'attach_files' =&gt; [ { name =&gt; 'cpanel-logger-log.txt', content =&gt; \$logfile } ],
                    'subject'      =&gt; $log_ref-&gt;{'subject'},
                ]
            );
        };

    }

    elsif ( eval { require Cpanel::LoadModule; Cpanel::LoadModule::load_perl_module('Cpanel::iContact'); 1; } ) {
        Cpanel::iContact::icontact(
            'application' =&gt; $log_ref-&gt;{'service'},
            'subject'     =&gt; $log_ref-&gt;{'subject'} ? $log_ref-&gt;{'subject'} : qq{Cpanel::Logger::$call called in $log_ref-&gt;{'service'}},
            'message'     =&gt; $logfile,
        );

    }
    else {
        CORE::warn( $log_ref-&gt;{'subject'} ? $log_ref-&gt;{'subject'} : qq{Cpanel::Logger::$call called in $log_ref-&gt;{'service'}} . &quot;: $logfile&quot; );
    }

    return;
}

*fatal   = *die;
*out     = *info;
*success = *info;
*throw   = *die;
*warning = *warn;

sub _is_subprocess_of_cpsrvd {
    require Cpanel::Server::Utils;
    goto \&amp;Cpanel::Server::Utils::is_subprocess_of_cpsrvd;
}

sub _open_logfile {
    my ($self) = @_;
    my $usingstderr = 0;
    my $log_fh;

    $self-&gt;{'alternate_logfile'} ||= $STD_LOG_FILE;
    if ( $STD_LOG_FILE eq $self-&gt;{'alternate_logfile'} &amp;&amp; _is_subprocess_of_cpsrvd() ) {
        $log_fh      = \*STDERR;
        $usingstderr = 1;
    }
    else {
        require Cpanel::FileUtils::Open;
        if ( !Cpanel::FileUtils::Open::sysopen_with_real_perms( $log_fh, $self-&gt;{'alternate_logfile'}, 'O_WRONLY|O_APPEND|O_CREAT', 0600 ) ) {
            ( $usingstderr, $log_fh ) = ( 1, \*STDERR );
        }

        select( ( select($log_fh), $| = 1 )[0] );    ## no critic qw(Variables::RequireLocalizedPunctuationVars InputOutput::ProhibitOneArgSelect) -- Cpanel::FHUtils::Autoflush would be expensive to load every time
    }

    $self-&gt;{'log_fh'}      = $log_fh;
    $self-&gt;{'usingstderr'} = $usingstderr;
    return 1;
}

sub _stdin_is_tty {
    local $@;
    return eval { -t STDIN };
}

sub _stdout_is_tty {
    local $@;
    return eval { -t STDOUT };
}

sub clear_singleton_stash {
    %singleton_stash = ();
    return;
}

1;


} # --- END Cpanel/Logger.pm


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


use strict;
use warnings;


our $HOOKS_DEBUG_FILE = '/var/cpanel/debughooks';

our $level = ( exists $ENV{'CPANEL_DEBUG_LEVEL'} &amp;&amp; $ENV{'CPANEL_DEBUG_LEVEL'} ? int $ENV{'CPANEL_DEBUG_LEVEL'} : 0 );


my $debug_hooks_value;
my $logger;


sub debug_level {
    my ($level) = @_;
    $Cpanel::Debug::level = $level if defined $level;
    return $Cpanel::Debug::level;
}

sub logger {
    $logger = shift if (@_);    # Set method for $logger if something is passed in.

    return $logger ||= do {
        local ( $@, $! );
        require Cpanel::Logger;

        Cpanel::Logger-&gt;new();
    };
}

sub log_error {
    local $!;                   #prevent logger from overwriting $!
    return logger()-&gt;error( $_[0] );
}


sub log_warn {
    local $!;    #prevent logger from overwriting $!
    return logger()-&gt;warn( $_[0] );
}

sub log_warn_no_backtrace {
    local $!;    #prevent logger from overwriting $!

    my $logger = logger();

    local $Cpanel::Logger::ENABLE_BACKTRACE = 0;

    return $logger-&gt;warn( $_[0] );
}

sub log_invalid {
    local $!;    #prevent logger from overwriting $!
    return logger()-&gt;invalid( $_[0] );
}

sub log_deprecated {
    local $!;    #prevent logger from overwriting $!
    return logger()-&gt;deprecated( $_[0] );
}

sub log_panic {
    local $!;    #prevent logger from overwriting $!
    return logger()-&gt;panic( $_[0] );
}

sub log_die {
    local $!;    #prevent logger from overwriting $!
    return logger()-&gt;die( $_[0] );
}

sub log_info {
    local $!;    #prevent logger from overwriting $!
    return logger()-&gt;info( $_[0] );
}

sub log_debug {
    local $!;    #prevent logger from overwriting $!
    return logger()-&gt;debug( $_[0] );
}

sub debug_hooks_value {
    return $debug_hooks_value if defined $debug_hooks_value;
    return ( $debug_hooks_value = ( stat($HOOKS_DEBUG_FILE) )[7] || 0 );
}

1;

} # --- END Cpanel/Debug.pm


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


use strict;

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

    return bless { 'pid' =&gt; $$, 'todo' =&gt; \@todo_crs }, $class;
}

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

    push @{ $self-&gt;{'todo'} }, @new_crs;

    return;
}

sub skip {
    my ($self) = @_;
    return delete $self-&gt;{'todo'};
}

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

    return if $$ != $self-&gt;{'pid'} || !$self-&gt;{'todo'};

    local $@;    #prevent insidious clobber of error messages

    while ( @{ $self-&gt;{'todo'} } ) {
        my $ok = eval {
            while ( my $item = shift @{ $self-&gt;{'todo'} } ) {
                $item-&gt;();
            }

            1;
        };

        warn $@ if !$ok;
    }

    return;
}

1;

} # --- END Cpanel/Finally.pm


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


use strict;
use warnings;

# use Cpanel::Autodie   ();
# use Cpanel::Exception ();
use Cwd               ();

our $MAX_SYMLINK_DEPTH = 1024;

sub deep {
    my ( $link, $provide_trailing_slash ) = @_;

    die Cpanel::Exception::create( 'MissingParameter', 'Provide a link path.' ) if !length $link;

    if ( length($link) &gt; 1 &amp;&amp; substr( $link, -1, 1 ) eq '/' ) {
        $link = substr( $link, 0, length($link) - 1 );
        return deep( $link, 1 );
    }

    if ( !-l $link ) {
        return $provide_trailing_slash ? qq{$link/} : $link;
    }

    my %is_link;
    $is_link{$link} = 1;

    my $depth = 0;

    my $base = _get_base_for($link);

    if ( substr( $link, 0, 1 ) ne '/' ) {
        $base = Cwd::abs_path() . '/' . $base;
    }

    while ( ( $is_link{$link} ||= -l $link ) &amp;&amp; ++$depth &lt;= $MAX_SYMLINK_DEPTH ) {
        $link = Cpanel::Autodie::readlink($link);
        if ( substr( $link, 0, 1 ) ne '/' ) {
            $link = $base . '/' . $link;
        }

        $base = _get_base_for($link);
    }

    return $provide_trailing_slash ? qq{$link/} : $link;
}

sub _get_base_for {
    my $basename = shift;
    my @path     = split( '/', $basename );
    pop(@path);
    return join( '/', @path );
}

1;

} # --- END Cpanel/Readlink.pm


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


use strict;
use warnings;


# use Cpanel::Fcntl::Constants ();
use Cpanel::Autodie ( 'rename', 'syswrite_sigguard', 'seek', 'print', 'truncate' );
# use Cpanel::Exception       ();
# use Cpanel::FileUtils::Open ();
# use Cpanel::Finally         ();
# use Cpanel::Debug           ();

our $Errno_EEXIST = 17;

our $MAX_TMPFILE_CREATE_ATTEMPTS = 1024;
my $DEFAULT_PERMS = 0600;
my $_WRONLY_CREAT_EXCL;


sub write_fh {    ##no critic qw(RequireArgUnpacking)
    my $fh = $_[0];

    Cpanel::Autodie::seek( $fh, 0, 0 );
    Cpanel::Autodie::print( $fh, $_[1] );
    Cpanel::Autodie::truncate( $fh, tell($fh) );

    return 1;
}


sub write {
    return _write_to_tmpfile( @_[ 0 .. 2 ], \&amp;_write_finish );
}


sub overwrite {
    return _write_to_tmpfile( @_[ 0 .. 2 ], \&amp;_overwrite_finish );
}

sub overwrite_no_exceptions {
    my $fh;

    local $@;
    eval {
        $fh = overwrite(@_);
        1;
    } or Cpanel::Debug::log_warn(&quot;overwrite exception: $@&quot;);

    return !!$fh;
}

sub _write_to_tmpfile {    ##no critic qw(RequireArgUnpacking)
    my ( $filename, $perms_or_hr, $finish_cr ) = ( $_[0], $_[2], $_[3] );

    if ( !defined $filename ) {
        exists $INC{'Carp.pm'} ? Carp::confess(&quot;write() called with undefined filename&quot;) : die(&quot;write() called with undefined filename&quot;);
    }

    if ( ref $filename ) {
        die &quot;Use write_fh to write to a file handle. ($filename is a filehandle, right?)&quot;;
    }

    my ( $fh, $tmpfile_is_renamed );

    if ( -l $filename ) {
        require Cpanel::Readlink;
        $filename = Cpanel::Readlink::deep($filename);
    }


    my ( $callback_cr, $tmp_perms );

    if ( 'HASH' eq ref $perms_or_hr ) {
        $callback_cr = $perms_or_hr-&gt;{'before_installation'};
    }
    else {
        $tmp_perms = $perms_or_hr;
    }

    $tmp_perms //= $DEFAULT_PERMS;

    my ( $tmpfile, $attempts ) = ( '', 0 );

    while (1) {
        local $!;
        my $rand = rand(99999999);
        $rand = sprintf( '%x', substr( $rand, 2 ) );

        my $last_slash_idx = rindex( $filename, '/' );
        $tmpfile = $filename;
        substr( $tmpfile, 1 + $last_slash_idx, 0 ) = &quot;.tmp.$rand.&quot;;

        last if Cpanel::FileUtils::Open::sysopen_with_real_perms(
            $fh,
            $tmpfile,
            ( $_WRONLY_CREAT_EXCL ||= ( $Cpanel::Fcntl::Constants::O_CREAT | $Cpanel::Fcntl::Constants::O_EXCL | $Cpanel::Fcntl::Constants::O_WRONLY ) ),
            $tmp_perms,
        );

        if ( $! != $Errno_EEXIST ) {
            die Cpanel::Exception::create( 'IO::FileCreateError', [ error =&gt; $!, path =&gt; $tmpfile, permissions =&gt; $tmp_perms ] );
        }

        ++$attempts;
        if ( $attempts &gt;= $MAX_TMPFILE_CREATE_ATTEMPTS ) {
            die Cpanel::Exception::create_raw( 'IO::FileCreateError', &quot;Too many ($MAX_TMPFILE_CREATE_ATTEMPTS) failed attempts to create a temp file as EUID $&gt; and GID $) based on “$filename”! The last tried file was “$tmpfile”, and the last error was: $!&quot; );
        }
    }

    my $finally = Cpanel::Finally-&gt;new(
        sub {
            if ( !$tmpfile_is_renamed ) {
                Cpanel::Autodie::unlink_if_exists($tmpfile);

            }
            return;
        }
    );

    if ( my $ref = ref $_[1] ) {
        if ( $ref eq 'SCALAR' ) {
            _write_fh( $fh, ${ $_[1] } );
        }
        else {
            die Cpanel::Exception::create( 'InvalidParameter', 'Invalid content type “[_1]”, expect a scalar.', [$ref] );
        }
    }
    else {
        _write_fh( $fh, $_[1] );
    }

    $callback_cr-&gt;($fh) if $callback_cr;

    $tmpfile_is_renamed = $finish_cr-&gt;( $tmpfile, $filename );

    if ( !$tmpfile_is_renamed ) {
        Cpanel::Autodie::unlink_if_exists($tmpfile);
    }

    $finally-&gt;skip();

    return $fh;
}

*_syswrite = *Cpanel::Autodie::syswrite_sigguard;

our $DEBUG_WRITE;

sub _write_fh {
    if ( length $_[1] ) {
        my $pos = 0;

        do {

            local $SIG{'XFSZ'} = 'IGNORE' if $pos;

            $pos += _syswrite( $_[0], $_[1], length( $_[1] ), $pos ) || do {

                die &quot;Zero bytes written, non-error!&quot;;
            };
        } while $pos &lt; length( $_[1] );
    }

    return;
}

sub _write_finish {

    Cpanel::Autodie::link(@_);
    return 0;
}

*_overwrite_finish = *Cpanel::Autodie::rename;

1;

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


{ # --- BEGIN Cpanel/FileUtils/Write/JSON/Lazy.pm
package Cpanel::FileUtils::Write::JSON::Lazy;


use strict;
use warnings;


sub write_file {
    my ( $file_or_fh, $data, $perms ) = @_;

    if ( exists $INC{'Cpanel/JSON.pm'} &amp;&amp; exists $INC{'JSON/XS.pm'} &amp;&amp; ( my $Dump = 'Cpanel::JSON'-&gt;can('Dump') ) ) {    # PPI NO PARSE -- check earlier - must be quoted or it ends up in the stash
        require Cpanel::FileUtils::Write if !$INC{'Cpanel/FileUtils/Write.pm'};
        require Cpanel::FHUtils::Tiny    if !$INC{'Cpanel/FHUtils/Tiny.pm'};
        my $func = Cpanel::FHUtils::Tiny::is_a($file_or_fh) ? 'write_fh' : 'overwrite';

        if ( $func eq 'write_fh' ) {
            if ( !defined $perms ) {
                $perms = 0600;
            }

            chmod( $perms, $file_or_fh ) or die &quot;Failed to set permissions on the file handle passed to Cpanel::FileUtils::Write::JSON::Lazy::write_file because of an error: $!&quot;;
        }

        return Cpanel::FileUtils::Write-&gt;can($func)-&gt;(
            $file_or_fh,
            $Dump-&gt;($data),
            $perms
        );
    }
    return 0;
}


sub write_file_pretty {
    my ( $file_or_fh, $data, $perms ) = @_;

    if ( exists $INC{'Cpanel/JSON.pm'} &amp;&amp; exists $INC{'JSON/XS.pm'} &amp;&amp; ( my $Dump = 'Cpanel::JSON'-&gt;can('pretty_dump') ) ) {    # PPI NO PARSE -- check earlier - must be quoted or it ends up in the stash
        require Cpanel::FileUtils::Write if !$INC{'Cpanel/FileUtils/Write.pm'};
        require Cpanel::FHUtils::Tiny    if !$INC{'Cpanel/FHUtils/Tiny.pm'};
        my $func = Cpanel::FHUtils::Tiny::is_a($file_or_fh) ? 'write_fh' : 'overwrite';

        if ( $func eq 'write_fh' ) {
            if ( !defined $perms ) {
                $perms = 0600;
            }

            chmod( $perms, $file_or_fh ) or die &quot;Failed to set permissions on the file handle passed to Cpanel::FileUtils::Write::JSON::Lazy::write_file because of an error: $!&quot;;
        }

        return Cpanel::FileUtils::Write-&gt;can($func)-&gt;(
            $file_or_fh,
            $Dump-&gt;($data),
            $perms
        );
    }
    return 0;
}

1;

} # --- END Cpanel/FileUtils/Write/JSON/Lazy.pm


{ # --- BEGIN Cpanel/JSON/Unicode.pm
package Cpanel::JSON::Unicode;


use strict;
use warnings;


use constant {

    _LEAD_SURROGATE_MIN =&gt; 0xd800,
    _TAIL_SURROGATE_MIN =&gt; 0xdc00,

    _SURROGATE_MASK =&gt; 0xfc00,

    _BACKSLASH_ORD    =&gt; 0x5c,
    _DOUBLE_QUOTE_ORD =&gt; 0x22,
};

my $UNICODE_ESCAPE_REGEXP = qr/

    (?&lt;!\x5c)

    (

        (?:\x5c\x5c)*

        \x5c u ([0-9a-fA-F]{4})
    )
/x;


sub replace_unicode_escapes_with_utf8 {
    my ($json_sr) = @_;

    my $lead_surrogate;

    my $ret = $$json_sr =~ s&lt;$UNICODE_ESCAPE_REGEXP&gt;&lt;
        _replacement(\$lead_surrogate, $json_sr, $+[0], @{^CAPTURE})
    &gt;ge;

    if ($lead_surrogate) {
        die sprintf &quot;Incomplete surrogate pair (0x%04x)&quot;, $lead_surrogate;
    }

    return $ret;
}

sub _replacement {
    my ( $lead_surrogate_sr, $json_sr, $match_end, @captures ) = @_;

    my $num = hex $captures[1];

    if ( ( $num &amp; _SURROGATE_MASK ) == _TAIL_SURROGATE_MIN ) {
        if ($$lead_surrogate_sr) {
            my $utf8 = _decode_surrogates( $$lead_surrogate_sr, $num );
            $$lead_surrogate_sr = undef;
            return $utf8;
        }

        die sprintf &quot;Unpaired trailing surrogate (0x%04x)&quot;, $num;
    }
    elsif ( ( $num &amp; _SURROGATE_MASK ) == _LEAD_SURROGATE_MIN ) {
        my $next2 = substr( $$json_sr, $match_end, 2 );
        if ( !$next2 || $next2 ne '\\u' ) {
            die sprintf &quot;Unpaired leading surrogate (0x%04x)&quot;, $num;
        }

        $$lead_surrogate_sr = $num;
        return q&lt;&gt;;
    }
    elsif ( $num &lt; 0x20 || $num == _BACKSLASH_ORD || $num == _DOUBLE_QUOTE_ORD ) {
        return $captures[0];
    }

    my $utf8 = chr $num;
    utf8::encode($utf8);
    return $utf8;
}

sub _decode_surrogates {
    my ( $lead, $tail ) = @_;

    my $uni = 0x10000 + ( ( $lead - 0xd800 ) &lt;&lt; 10 ) + ( $tail - 0xdc00 );

    my $un = chr $uni;
    utf8::encode($un);

    return $un;
}

1;

} # --- END Cpanel/JSON/Unicode.pm


{ # --- BEGIN Cpanel/LoadFile/ReadFast.pm
package Cpanel::LoadFile::ReadFast;


use strict;
use warnings;


use constant READ_CHUNK =&gt; 1 &lt;&lt; 18;    # 262144

use constant _EINTR =&gt; 4;


sub read_fast {
    $_[1] //= q&lt;&gt;;

    return ( @_ &gt; 3 ? sysread( $_[0], $_[1], $_[2], $_[3] ) : sysread( $_[0], $_[1], $_[2] ) ) // do {
        goto \&amp;read_fast if $! == _EINTR;
        die &quot;Failed to read data: $!&quot;;
    };
}


my $_ret;

sub read_all_fast {
    $_[1] //= q&lt;&gt;;

    $_ret = 1;
    while ($_ret) {
        $_ret = sysread( $_[0], $_[1], READ_CHUNK, length $_[1] ) // do {
            redo if $! == _EINTR;
            die &quot;Failed to read data: $!&quot;;
        }
    }
    return;
}

1;

} # --- END Cpanel/LoadFile/ReadFast.pm


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


use strict;
use warnings;

sub to_hex {
    my ($readable) = @_;

    $readable =~ s&lt;\\&gt;&lt;\\\\&gt;g;
    $readable =~ s&lt;([\0-\x{1f}\x{7f}-\x{ff}])&gt;&lt;sprintf '\x{%02x}', ord $1&gt;eg;

    return $readable;
}

1;

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


{ # --- BEGIN Cpanel/UTF8/Strict.pm
package Cpanel::UTF8::Strict;


use strict;
use warnings;


sub decode {

    utf8::decode( $_[0] ) or do {
        local ( $@, $! );
        require Cpanel::Encoder::ASCII;
        die sprintf &quot;Invalid UTF-8 in string: “%s”&quot;, Cpanel::Encoder::ASCII::to_hex( $_[0] );
    };

    return $_[0];
}

1;

} # --- END Cpanel/UTF8/Strict.pm


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


use strict;

# use Cpanel::Fcntl::Constants   ();
# use Cpanel::FHUtils::Tiny      ();
# use Cpanel::JSON::Unicode      ();
# use Cpanel::LoadFile::ReadFast ();
use JSON::XS                   ();
# use Cpanel::UTF8::Strict       ();

our $NO_DECODE_UTF8 = 0;
our $DECODE_UTF8    = 1;

our $LOAD_STRICT  = 0;
our $LOAD_RELAXED = 1;

our $MAX_LOAD_LENGTH_UNLIMITED = 0;
our $MAX_LOAD_LENGTH           = 65535;

our $MAX_PRIV_LOAD_LENGTH = 4194304;    # four megs

our $XS_ConvertBlessed_obj;
our $XS_RelaxedConvertBlessed_obj;
our $XS_NoSetUTF8RelaxedConvertBlessed_obj;
our $XS_NoSetUTF8ConvertBlessed_obj;

our $VERSION = '2.5';

my $copied_boolean = 0;

sub DumpFile {
    my ( $file, $data ) = @_;

    if ( Cpanel::FHUtils::Tiny::is_a($file) ) {
        print {$file} Dump($data) || return 0;
    }
    else {
        if ( open( my $fh, '&gt;', $file ) ) {
            print {$fh} Dump($data);
            close($fh);
        }
        else {
            return 0;
        }
    }
    return 1;
}

sub copy_boolean {

    if ( !$copied_boolean ) {
        *Types::Serialiser::Boolean:: = *JSON::PP::Boolean::;
        $copied_boolean               = 1;
    }
    return;
}

sub _create_new_json_object {
    copy_boolean() if !$copied_boolean;
    return JSON::XS-&gt;new()-&gt;shrink(1)-&gt;allow_nonref(1)-&gt;convert_blessed(1);
}

sub true {
    copy_boolean() if !$copied_boolean;
    my $x = 1;
    return bless \$x, 'Types::Serialiser::Boolean';
}

sub false {
    copy_boolean() if !$copied_boolean;
    my $x = 0;
    return bless \$x, 'Types::Serialiser::Boolean';
}

sub pretty_dump {
    return _create_new_json_object()-&gt;pretty(1)-&gt;encode( $_[0] );
}

my $XS_Canonical_obj;

sub canonical_dump {
    return ( $XS_Canonical_obj ||= _create_new_json_object()-&gt;canonical(1) )-&gt;encode( $_[0] );
}

sub pretty_canonical_dump {
    return _create_new_json_object()-&gt;canonical(1)-&gt;indent-&gt;space_before-&gt;space_after-&gt;encode( $_[0] );
}

sub Dump {
    return ( $XS_ConvertBlessed_obj ||= _create_new_json_object() )-&gt;encode( $_[0] );
}

sub Load {
    local $@;

    _replace_unicode_escapes_if_needed( \$_[0] );

    return eval { ( $XS_ConvertBlessed_obj ||= _create_new_json_object() )-&gt;decode( $_[0] ); } // ( ( $@ &amp;&amp; _throw_json_error( $@, $_[1], \$_[0] ) ) || undef );
}

sub LoadRelaxed {
    local $@;

    _replace_unicode_escapes_if_needed( \$_[0] );

    return eval { ( $XS_RelaxedConvertBlessed_obj ||= _create_new_json_object()-&gt;relaxed(1) )-&gt;decode( $_[0] ); } // ( ( $@ &amp;&amp; _throw_json_error( $@, $_[1], \$_[0] ) ) || undef );
}

sub _throw_json_error {
    my ( $exception, $path, $dataref ) = @_;

    local $@;
    require Cpanel::Exception;
    die $exception if $@;
    die 'Cpanel::Exception'-&gt;can('create')-&gt;( 'JSONParseError', { 'error' =&gt; $exception, 'path' =&gt; $path, 'dataref' =&gt; $dataref } );
}

sub LoadNoSetUTF8 {
    local $@;

    _replace_unicode_escapes_if_needed( \$_[0] );

    return eval { ( $XS_NoSetUTF8ConvertBlessed_obj ||= _create_new_no_set_utf8_json_object() )-&gt;decode( $_[0] ); } // ( ( $@ &amp;&amp; _throw_json_error( $@, $_[1], \$_[0] ) ) || undef );
}

sub LoadNoSetUTF8Relaxed {
    local $@;

    _replace_unicode_escapes_if_needed( \$_[0] );

    return eval { ( $XS_NoSetUTF8RelaxedConvertBlessed_obj ||= _create_new_no_set_utf8_json_object()-&gt;relaxed(1) )-&gt;decode( $_[0] ); } // ( ( $@ &amp;&amp; _throw_json_error( $@, $_[1], \$_[0] ) ) || undef );
}

sub _create_new_no_set_utf8_json_object {
    my $obj = _create_new_json_object();
    if ( $obj-&gt;can('no_set_utf8') ) {
        $obj-&gt;no_set_utf8(1);
    }
    else {
        warn &quot;JSON::XS is missing the no_set_utf8 flag&quot;;
    }
    return $obj;
}

sub _replace_unicode_escapes_if_needed {
    my $json_r = shift;

    if ( -1 != index( $$json_r, '\\u' ) ) {
        Cpanel::JSON::Unicode::replace_unicode_escapes_with_utf8($json_r);
    }

    return;
}


sub SafeLoadFile {    # only allow a small bit of data to be loaded
    return _LoadFile( $_[0], $MAX_LOAD_LENGTH, $_[2] || $NO_DECODE_UTF8, $_[1], $LOAD_STRICT );
}

sub LoadFile {
    return _LoadFile( $_[0], $MAX_LOAD_LENGTH_UNLIMITED, $_[2] || $NO_DECODE_UTF8, $_[1], $LOAD_STRICT );
}

sub LoadFileRelaxed {
    return _LoadFile( $_[0], $MAX_LOAD_LENGTH_UNLIMITED, $_[2] || $NO_DECODE_UTF8, $_[1], $LOAD_RELAXED );
}

sub LoadFileNoSetUTF8 {
    return _LoadFile( $_[0], $_[1] || $MAX_LOAD_LENGTH_UNLIMITED, $DECODE_UTF8, $_[2], $LOAD_STRICT );
}

sub _LoadFile {
    my ( $file, $max, $decode_utf8, $path, $relaxed ) = @_;

    my $data;
    if ( Cpanel::FHUtils::Tiny::is_a($file) ) {
        if ($max) {
            my $togo = $max;
            $data = '';
            my $bytes_read;
            while ( $bytes_read = read( $file, $data, $togo, length $data ) &amp;&amp; length $data &lt; $max ) {
                $togo -= $bytes_read;
            }
        }
        else {
            Cpanel::LoadFile::ReadFast::read_all_fast( $file, $data );
        }
    }
    else {
        local $!;
        open( my $fh, '&lt;:stdio', $file ) or do {
            my $err = $!;

            require Cpanel::Carp;
            die Cpanel::Carp::safe_longmess(&quot;Cannot open “$file”: $err&quot;);
        };
        Cpanel::LoadFile::ReadFast::read_all_fast( $fh, $data );
        if ( !length $data ) {
            require Cpanel::Carp;
            die Cpanel::Carp::safe_longmess(&quot;“$file” is empty.&quot;);
        }
        close $fh or warn &quot;close($file) failed: $!&quot;;
    }

    if ( $decode_utf8 &amp;&amp; $decode_utf8 == $DECODE_UTF8 ) {

        Cpanel::UTF8::Strict::decode($data);

        return $relaxed ? LoadNoSetUTF8Relaxed( $data, $path || $file ) : LoadNoSetUTF8( $data, $path || $file );
    }

    return $relaxed ? LoadRelaxed( $data, $path || $file ) : Load( $data, $path || $file );
}

sub SafeDump {
    my $raw_json = ( $XS_ConvertBlessed_obj ||= _create_new_json_object() )-&gt;encode( $_[0] );
    $raw_json =~ s{\/}{\\/}g if $raw_json =~ tr{/}{};
    return $raw_json;
}

sub _fh_looks_like_json {
    my ($fh) = @_;

    my $bytes_read = 0;

    my $buffer = q{};

    local $!;

    while ( $buffer !~ tr{ \t\r\n\f}{}c &amp;&amp; !eof $fh ) {
        $bytes_read += ( read( $fh, $buffer, 1, length $buffer ) // die &quot;read() failed: $!&quot; );
    }

    return (
        _string_looks_like_json($buffer),
        \$buffer,
    );
}

sub _string_looks_like_json {    ##no critic qw(RequireArgUnpacking)
    return $_[0] =~ m/\A\s*[\[\{&quot;0-9]/ ? 1 : 0;
}

sub looks_like_json {    ##no critic qw(RequireArgUnpacking)
    if ( Cpanel::FHUtils::Tiny::is_a( $_[0] ) ) {
        my $fh = $_[0];

        my ( $looks_like_json, $fragment_ref ) = _fh_looks_like_json($fh);
        my $bytes_read = length $$fragment_ref;

        if ($bytes_read) {
            seek( $fh, -$bytes_read, $Cpanel::Fcntl::Constants::SEEK_CUR ) or die &quot;seek() failed: $!&quot;;
        }

        return $looks_like_json;
    }

    return _string_looks_like_json( $_[0] );
}

1;

} # --- END Cpanel/JSON.pm


{ # --- BEGIN Cpanel/AdminBin/Serializer.pm
package Cpanel::AdminBin::Serializer;


use strict;
use warnings;


# use Cpanel::JSON ();


our $VERSION = '2.4';

our $MAX_LOAD_LENGTH;
our $MAX_PRIV_LOAD_LENGTH;

BEGIN {
    *MAX_LOAD_LENGTH      = \$Cpanel::JSON::MAX_LOAD_LENGTH;
    *MAX_PRIV_LOAD_LENGTH = \$Cpanel::JSON::MAX_PRIV_LOAD_LENGTH;
    *DumpFile             = *Cpanel::JSON::DumpFile;
}


BEGIN {
    *Dump = *Cpanel::JSON::Dump;

    *SafeDump = *Cpanel::JSON::SafeDump;

    *LoadFile = *Cpanel::JSON::LoadFileNoSetUTF8;

    *Load = *Cpanel::JSON::Load;

    *looks_like_serialized_data = *Cpanel::JSON::looks_like_json;
}


sub SafeLoadFile {
    return Cpanel::JSON::_LoadFile( $_[0], $Cpanel::JSON::MAX_LOAD_LENGTH, $Cpanel::JSON::DECODE_UTF8, $_[1], $Cpanel::JSON::LOAD_STRICT );
}


sub SafeLoad {
    utf8::decode( $_[0] );
    return Cpanel::JSON::LoadNoSetUTF8(@_);
}


sub clone {
    return Cpanel::JSON::LoadNoSetUTF8( Cpanel::JSON::Dump( $_[0] ) );
}

1;

} # --- END Cpanel/AdminBin/Serializer.pm


{ # --- BEGIN Cpanel/AdminBin/Serializer/FailOK.pm
package Cpanel::AdminBin::Serializer::FailOK;


use strict;
use warnings;

sub LoadModule {
    local $@;

    return 1 if $INC{'Cpanel/AdminBin/Serializer.pm'};

    my $load_ok = eval {
        local $SIG{'__DIE__'};     # Suppress spewage as we may be reading an invalid cache
        local $SIG{'__WARN__'};    # and since failure is ok to throw it away
        require Cpanel::AdminBin::Serializer;
        1;
    };

    if ( !$load_ok &amp;&amp; !$ENV{'CPANEL_BASE_INSTALL'} &amp;&amp; index( $^X, '/usr/local/cpanel' ) == 0 ) {
        warn $@;
    }

    return $load_ok ? 1 : 0;
}

sub LoadFile {
    my ( $file_or_fh, $path ) = @_;

    return undef if !$INC{'Cpanel/AdminBin/Serializer.pm'};

    return eval {
        local $SIG{'__DIE__'};     # Suppress spewage as we may be reading an invalid cache
        local $SIG{'__WARN__'};    # and since failure is ok to throw it away
        Cpanel::AdminBin::Serializer::LoadFile( $file_or_fh, undef, $path );
    };
}
1;

} # --- END Cpanel/AdminBin/Serializer/FailOK.pm


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


use strict;
use warnings;


sub untaint {
    return $_[0] unless ${^TAINT};
    require    # Cpanel::Static OK - we should not untaint variables as part of updatenow.static
      Taint::Util;
    Taint::Util::untaint( $_[0] );
    return $_[0];
}

1;

} # --- END Cpanel/SV.pm


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


use strict;

# use Cpanel::Finally();
our @ISA;
BEGIN { push @ISA, qw(Cpanel::Finally); }

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

    my $old = umask();

    umask($new);

    return $class-&gt;SUPER::new(
        sub {
            my $cur = umask();

            if ( $cur != $new ) {
                my ( $cur_o, $old_o, $new_o ) = map { '0' . sprintf( '%o', $_ ) } ( $cur, $old, $new );

                warn &quot;I want to umask($old_o). I expected the current umask to be $new_o, but it’s actually $cur_o.&quot;;
            }

            umask($old);
        }
    );
}

1;

} # --- END Cpanel/Umask.pm


{ # --- BEGIN Cpanel/Config/LoadConfig.pm
package Cpanel::Config::LoadConfig;


use strict;
use warnings;

# use Cpanel::Hash::Stringify              ();
# use Cpanel::Debug                        ();
# use Cpanel::FileUtils::Write::JSON::Lazy ();
# use Cpanel::AdminBin::Serializer::FailOK ();
# use Cpanel::LoadFile::ReadFast           ();
# use Cpanel::HiRes                        ();
# use Cpanel::SV                           ();

use constant _ENOENT =&gt; 2;

my $logger;
our $PRODUCT_CONF_DIR = '/var/cpanel';

our $_DEBUG_SAFEFILE = 0;

my %COMMON_CACHE_NAMES = (
    ':__^\s*[#;]____0__'                                                                           =&gt; 'default_colon',
    ':\s+__^\s*[#;]____0__'                                                                        =&gt; 'default_colon_any_space',
    ': __^\s*[#;]____0__'                                                                          =&gt; 'default_colon_with_one_space',
    '=__^\s*[#;]____0__skip_readable_check_____1'                                                  =&gt; 'default_skip_readable',
    '=__^\s*[#;]____0__'                                                                           =&gt; 'default',
    '=__^\s*[#;]__(?^:\s+)__0__'                                                                   =&gt; 'default_with_preproc_newline',
    '=__^\s*[#;]____1__'                                                                           =&gt; 'default_allow_undef',
    '\s*[:]\s*__^\s*[#;]____0__'                                                                   =&gt; 'default_colon_before_after_space',
    '\s*=\s*__^\s*[#;]____1__'                                                                     =&gt; 'default_equal_before_after_space_allow_undef',
    '\s*[\=]\s*__^\s*[#]____0__use_reverse_____0'                                                  =&gt; 'default_equal_before_after_space',
    ': __^\s*[#;]____0__limit_____10000000000_____use_reverse_____0'                               =&gt; 'default_with_10000000000_limit',
    '\s*[:]\s*__^\s*[#;]____0__use_hash_of_arr_refs_____0_____use_reverse_____0'                   =&gt; 'default_use_hash_of_arr_refs',
    ': __^\s*[#;]____0__limit__________use_reverse_____0'                                          =&gt; 'default_colon_single_space_no_limit',
    ': __^\s*[#;]____1__skip_keys_____nobody_____use_hash_of_arr_refs_____0_____use_reverse_____0' =&gt; 'default_colon_skip_nobody_no_limit',
    ': __^\s*[#;]____1__use_reverse_____1'                                                         =&gt; 'default_reverse_allow_undef',
    '\s+__^\s*[#;]____0__'                                                                         =&gt; 'default_space_seperated_config',
    '\s*=\s*__^\s*[#;]__^\s*__0__'                                                                 =&gt; 'default_equal_space_seperated_config',           #ea4.conf
);

my $DEFAULT_DELIMITER      = '=';
my $DEFAULT_COMMENT_REGEXP = '^\s*[#;]';                                                                                                                #Keep in sync with tr{} below!!
my @BOOLEAN_OPTIONS        = qw(
  allow_undef_values
  use_hash_of_arr_refs
  use_reverse
);

my $CACHE_DIR_PERMS = 0700;

sub _process_parse_args {
    my (%opts) = @_;

    if ( !defined $opts{'delimiter'} ) {
        $opts{'delimiter'} = $DEFAULT_DELIMITER;
    }

    $opts{'regexp_to_preprune'} ||= q{};

    $opts{'comment'} ||= $DEFAULT_COMMENT_REGEXP;

    $opts{'comment'} = '' if $opts{'comment'} eq '0E0';

    $opts{$_} ||= 0 for @BOOLEAN_OPTIONS;

    return %opts;
}

{
    no warnings 'once';
    *get_homedir_and_cache_dir = *_get_homedir_and_cache_dir;
}

sub _get_homedir_and_cache_dir {
    my ( $homedir, $cache_dir );

    if ( $&gt; == 0 ) {
        $cache_dir = &quot;$PRODUCT_CONF_DIR/configs.cache&quot;;
    }
    else {
        {
            no warnings 'once';
            $homedir = $Cpanel::homedir;
        }
        if ( !$homedir ) {
            eval 'local $SIG{__DIE__}; local $SIG{__WARN__}; require Cpanel::PwCache';    ## no critic qw(ProhibitStringyEval) # PPI USE OK - just after
            $homedir = Cpanel::PwCache::gethomedir() if $INC{'Cpanel/PwCache.pm'};
            return unless $homedir;                                                       # undef for homedir and cache_dir avoid issues later when using undef as hash key
        }

        Cpanel::SV::untaint($homedir);

        $homedir =~ tr{/}{}s;

        return ( $homedir, undef ) if $homedir eq '/';

        $cache_dir = undef;
    }

    return ( $homedir, $cache_dir );
}

sub loadConfig {    ## no critic qw(Subroutines::ProhibitExcessComplexity Subroutines::ProhibitManyArgs)
    my ( $file, $conf_ref, $delimiter, $comment, $regexp_to_preprune, $allow_undef_values, $arg_ref ) = @_;

    $conf_ref ||= -1;

    my %processed_positional_args = _process_parse_args(
        delimiter          =&gt; $delimiter,
        comment            =&gt; $comment,
        regexp_to_preprune =&gt; $regexp_to_preprune,
        allow_undef_values =&gt; $allow_undef_values,
        $arg_ref ? %$arg_ref : (),
    );

    my $empty_is_invalid = ( defined $arg_ref ) ? delete $arg_ref-&gt;{'empty_is_invalid'} : undef;

    my ( $use_reverse, $use_hash_of_arr_refs );
    ( $delimiter, $comment, $regexp_to_preprune, $allow_undef_values, $use_reverse, $use_hash_of_arr_refs ) = @processed_positional_args{
        qw(
          delimiter
          comment
          regexp_to_preprune
          allow_undef_values
          use_reverse
          use_hash_of_arr_refs
        )
    };


    if ( !$file || $file =~ tr/\0// ) {
        _do_logger( 'warn', 'loadConfig requires valid filename' );
        if ( $arg_ref-&gt;{'keep_locked_open'} ) {
            return ( undef, undef, undef, &quot;loadConfig requires valid filename&quot; );
        }

        return;
    }

    my $filesys_mtime = ( Cpanel::HiRes::stat($file) )[9] or do {
        if ( $arg_ref-&gt;{'keep_locked_open'} ) {
            return ( undef, undef, undef, &quot;Unable to stat $file: $!&quot; );
        }
        return;
    };

    my $load_into_conf_ref = ( !ref $conf_ref &amp;&amp; $conf_ref == -1 ) ? 0 : 1;

    if ($load_into_conf_ref) {
        $conf_ref = _hashify_ref($conf_ref);
    }

    $conf_ref = {} if !$load_into_conf_ref;

    my $conf_fh;
    my $conflock;
    my $locked;
    if ( $arg_ref-&gt;{'keep_locked_open'} || $arg_ref-&gt;{'rw'} ) {
        require Cpanel::SafeFile;
        $locked   = 1;
        $conflock = Cpanel::SafeFile::safeopen( $conf_fh, '+&lt;', $file );
    }
    else {
        $conflock = open( $conf_fh, '&lt;', $file );
    }

    if ( !$conflock ) {
        my $open_err = $! || '(unspecified error)';

        local $_DEBUG_SAFEFILE = 1;

        require Cpanel::Logger;
        my $is_root = ( $&gt; == 0 ? 1 : 0 );

        if ( !$is_root &amp;&amp; !$arg_ref-&gt;{'skip_readable_check'} ) {
            if ( !-r $file ) {
                my $msg;

                if ( my $err = $! ) {
                    $msg = &quot;$file’s readability check failed: $err&quot;;
                }
                else {
                    my $euser = getpwuid $&gt;;
                    $msg = &quot;$file is not readable as $euser.&quot;;
                }

                _do_logger( 'warn', $msg );

                if ( $arg_ref-&gt;{'keep_locked_open'} ) {
                    return ( undef, undef, undef, $msg );
                }

                return;
            }
        }
        my $verb = ( $locked ? 'lock/' : q&lt;&gt; ) . 'open';
        my $msg  = &quot;Unable to $verb $file as UIDs $&lt;/$&gt;: $open_err&quot;;

        Cpanel::Logger::cplog( $msg, 'warn', __PACKAGE__ );
        if ( $arg_ref-&gt;{'keep_locked_open'} ) {
            return ( undef, undef, undef, $msg );
        }
        return;
    }

    my ( $parse_ok, $parsed ) = _parse_from_filehandle(
        $conf_fh,
        comment              =&gt; $comment,
        delimiter            =&gt; $delimiter,
        regexp_to_preprune   =&gt; $regexp_to_preprune,
        allow_undef_values   =&gt; $allow_undef_values,
        use_reverse          =&gt; $use_reverse,
        use_hash_of_arr_refs =&gt; $use_hash_of_arr_refs,
        $arg_ref ? %$arg_ref : (),
    );

    if ( $locked &amp;&amp; !$arg_ref-&gt;{'keep_locked_open'} ) {
        require Cpanel::SafeFile;
        Cpanel::SafeFile::safeclose( $conf_fh, $conflock );
    }

    if ( !$parse_ok ) {
        require Cpanel::Logger;
        Cpanel::Logger::cplog( &quot;Unable to parse $file: $parsed&quot;, 'warn', __PACKAGE__ );
        if ( $arg_ref-&gt;{'keep_locked_open'} ) {
            return ( undef, undef, undef, &quot;Unable to parse $file: $parsed&quot; );
        }
        return;
    }

    @{$conf_ref}{ keys %$parsed } = values %$parsed;

    if ( $arg_ref-&gt;{'keep_locked_open'} ) {
        return $conf_ref, $conf_fh, $conflock, &quot;open success&quot;;
    }

    return $conf_ref;
}

sub load_from_cache_if_valid {
    my (%opts) = @_;

    my $cache_file = $opts{'cache_file'} or die &quot;need cache_file!&quot;;

    my $file               = $opts{'file'};
    my $conf_ref           = $opts{'conf_ref'};
    my $load_into_conf_ref = $opts{'load_into_conf_ref'};
    my $filesys_mtime      = $opts{'filesys_mtime'} || ( Cpanel::HiRes::stat($file) )[9];

    open( my $cache_fh, '&lt;:stdio', $cache_file ) or do {
        my $err = $!;

        my $msg = &quot;non-fatal error: open($cache_file): $err&quot;;

        warn $msg if $! != _ENOENT();

        return ( 0, $msg );
    };

    my ( $cache_filesys_mtime, $now, $cache_conf_ref ) = ( ( Cpanel::HiRes::fstat($cache_fh) )[9], Cpanel::HiRes::time() );    # stat the file after we have it open to avoid a race condition

    if ( ( $Cpanel::Debug::level || 0 ) &gt;= 5 ) {
        print STDERR __PACKAGE__ . &quot;::loadConfig file:$file, cache_file:$cache_file, cache_filesys_mtime:$cache_filesys_mtime, filesys_mtime:$filesys_mtime, now:$now\n&quot;;
    }

    if ( $filesys_mtime &amp;&amp; _greater_with_same_precision( $cache_filesys_mtime, $filesys_mtime ) &amp;&amp; _greater_with_same_precision( $now, $cache_filesys_mtime ) ) {
        if ( ( $Cpanel::Debug::level || 0 ) &gt;= 5 ) {
            print STDERR __PACKAGE__ . &quot;::loadConfig using cache_file:$cache_file\n&quot;;
        }

        Cpanel::AdminBin::Serializer::FailOK::LoadModule() if !$INC{'Cpanel/AdminBin/Serializer.pm'};
        if ( $cache_conf_ref = Cpanel::AdminBin::Serializer::FailOK::LoadFile($cache_fh) ) {    #zero keys is a valid file still it may just be all comments or empty
            close($cache_fh);

            if ( $opts{'empty_is_invalid'} &amp;&amp; scalar keys %$cache_conf_ref == 0 ) {
                return ( 0, 'Cache is empty' );
            }

            my $ref_to_return;
            if ($load_into_conf_ref) {
                @{$conf_ref}{ keys %$cache_conf_ref } = values %$cache_conf_ref;
                $ref_to_return = $conf_ref;
            }
            else {
                $ref_to_return = $cache_conf_ref;
            }

            return ( 1, $ref_to_return );
        }
        elsif ( ( $Cpanel::Debug::level || 0 ) &gt;= 5 ) {
            print STDERR __PACKAGE__ . &quot;::loadConfig failed to load cache_file:$cache_file\n&quot;;
        }

    }
    else {
        if ( ( $Cpanel::Debug::level || 0 ) &gt;= 5 ) {
            print STDERR __PACKAGE__ . &quot;::loadConfig NOT using cache_file:$cache_file\n&quot;;
        }
    }

    return ( 0, 'Cache not valid' );
}

sub _greater_with_same_precision {
    my ( $float1, $float2 ) = @_;
    my ( $int1,   $int2 )   = ( int($float1), int($float2) );
    if ( $float1 == $int1 or $float2 == $int2 ) {
        return $int1 &gt; $int2;
    }
    return $float1 &gt; $float2;
}

sub get_cache_file {    ## no critic qw(Subroutines::RequireArgUnpacking) - Args unpacked by _process_parse_args
    my %opts = _process_parse_args(@_);

    die 'need cache_dir!' if !$opts{'cache_dir'};

    my $stringified_args = join(
        '__',
        @opts{qw(delimiter comment regexp_to_preprune allow_undef_values)}, ( scalar keys %{ $opts{'arg_ref'} } ? Cpanel::Hash::Stringify::sorted_hashref_string( $opts{'arg_ref'} ) : '' )
    );
    if ( ( $Cpanel::Debug::level || 0 ) &gt;= 5 ) {    # PPI NO PARSE -  ok missing
        print STDERR __PACKAGE__ . &quot;::loadConfig stringified_args[$stringified_args]\n&quot;;
    }

    my $safe_filename = $opts{'file'};
    $safe_filename =~ tr{/}{_};

    return $opts{'cache_dir'} . '/' . $safe_filename . '___' . ( $COMMON_CACHE_NAMES{$stringified_args} || _get_fastest_hash($stringified_args) );
}

sub _get_fastest_hash {
    require Cpanel::Hash;
    goto \&amp;Cpanel::Hash::get_fastest_hash;
}

sub write_cache {
    my (%opts)     = @_;
    my $cache_file = $opts{'cache_file'};
    my $cache_dir  = $opts{'cache_dir'};
    my $homedir    = $opts{'homedir'};
    my $is_root    = $opts{'is_root'};
    my $parsed     = $opts{'data'};

    my @dirs = ($cache_dir);
    if ( !$is_root ) {
        if ( $ENV{'TEAM_USER'} ) {
            unshift @dirs, &quot;$homedir/$ENV{'TEAM_USER'}&quot;, &quot;$homedir/$ENV{'TEAM_USER'}/.cpanel&quot;, &quot;$homedir/$ENV{'TEAM_USER'}/.cpanel/caches&quot;;
        }
        else {
            unshift @dirs, &quot;$homedir/.cpanel&quot;, &quot;$homedir/.cpanel/caches&quot;;
        }
    }

    foreach my $dir (@dirs) {
        Cpanel::SV::untaint($dir);

        chmod( $CACHE_DIR_PERMS, $dir ) or do {
            if ( $! == _ENOENT() ) {

                require Cpanel::Umask;
                my $umask = Cpanel::Umask-&gt;new(0);

                mkdir( $dir, $CACHE_DIR_PERMS ) or do {
                    _do_logger( 'warn', &quot;Failed to create dir “$dir”: $!&quot; );
                };
            }
            else {
                _do_logger( 'warn', &quot;chmod($dir): $!&quot; );
            }
        };

    }

    my $wrote_ok = eval { Cpanel::FileUtils::Write::JSON::Lazy::write_file( $cache_file, $parsed, 0600 ) };
    my $error    = $@;

    $error ||= &quot;Unknown error&quot; if !defined $wrote_ok;
    if ($error) {
        _do_logger( 'warn', &quot;Could not create cache file “$cache_file”: $error&quot; );
        unlink $cache_file;    #outdated
    }
    if ( ( $Cpanel::Debug::level || 0 ) &gt; 4 ) {    # PPI NO PARSE -  ok missing
        print STDERR __PACKAGE__ . &quot;::loadConfig [lazy write cache file] [$cache_file] wrote_ok:[$wrote_ok]\n&quot;;
    }
    return 1;
}

sub _do_logger {
    my ( $action, $msg ) = @_;

    require Cpanel::Logger;
    $logger ||= Cpanel::Logger-&gt;new();

    return $logger-&gt;$action($msg);
}

sub parse_from_filehandle {
    my ( $conf_fh, %opts ) = @_;
    return _parse_from_filehandle( $conf_fh, _process_parse_args(%opts) );
}

sub _parse_from_filehandle {
    my ( $conf_fh, %opts ) = @_;


    my ( $comment, $limit, $regexp_to_preprune, $delimiter, $allow_undef_values, $use_hash_of_arr_refs, $skip_keys, $use_reverse ) = @opts{
        qw(
          comment
          limit
          regexp_to_preprune
          delimiter
          allow_undef_values
          use_hash_of_arr_refs
          skip_keys
          use_reverse
        )
    };

    my $conf_ref = {};

    my $parser_code;
    my ( $k, $v );    ## no critic qw(Variables::ProhibitUnusedVariables)
    my $keys           = 0;
    my $key_value_text = $use_reverse ? '1,0' : '0,1';
    my $cfg_txt        = '';
    Cpanel::LoadFile::ReadFast::read_all_fast( $conf_fh, $cfg_txt );
    my $has_cr = index( $cfg_txt, &quot;\r&quot; ) &gt; -1 ? 1 : 0;
    _remove_comments_from_text( \$cfg_txt, $comment, \$has_cr ) if $cfg_txt &amp;&amp; $comment;

    my $split_on = $has_cr ? '\r?\n' : '\n';

    if ( !$limit &amp;&amp; !$regexp_to_preprune &amp;&amp; !$use_hash_of_arr_refs &amp;&amp; length $delimiter ) {
        if ($allow_undef_values) {
            $parser_code = qq&lt;
                  \$conf_ref = {
                      map {
                          (split(m/&gt; . $delimiter . qq&lt;/, \$_, 2))[$key_value_text]
                      } split(/&gt; . $split_on . qq&lt;/, \$cfg_txt)
                  };
              &gt;;
        }
        else {
            $parser_code = ' $conf_ref = {  map { ' . '($k,$v) = (split(m/' . $delimiter . '/, $_, 2))[' . $key_value_text . ']; ' . 'defined($v) ? ($k,$v) : () ' . '} split(/' . $split_on . '/, $cfg_txt ) }';
        }
    }
    else {
        if ( ( $Cpanel::Debug::level || 0 ) &gt; 4 ) {    # PPI NO PARSE - ok if not there
            $limit ||= 0;
            print STDERR __PACKAGE__ . &quot;::parse_from_filehandle [slow LoadConfig parser used] LIMIT:[!$limit] REGEXP_TO_DELETE[!$regexp_to_preprune] USE_HASH_OF_ARR_REFS[$use_hash_of_arr_refs)]\n&quot;;
        }
        $parser_code = 'foreach (split(m/' . $split_on . '/, $cfg_txt)) {' . &quot;\n&quot;                                                                            #
          . q{next if !length;} . &quot;\n&quot;                                                                                                                       #
          . ( $limit ? q{last if $keys++ == } . $limit . ';' : '' ) . &quot;\n&quot; . ( $regexp_to_preprune ? q{ s/} . $regexp_to_preprune . q{//g;} : '' ) . &quot;\n&quot;    #
          . (
            length $delimiter ?                                                                                                                              #
              (
                q{( $k, $v ) = (split( /} . $delimiter . q{/, $_, 2 ))[} . $key_value_text . q{];} . &quot;\n&quot; .                                                  #
                  ( !$allow_undef_values  ? q{ next if !defined($v); }          : '' ) . &quot;\n&quot; .                                                              #
                  ( $use_hash_of_arr_refs ? q{ push @{ $conf_ref-&gt;{$k} }, $v; } : q{ $conf_ref-&gt;{$k} = $v; } ) . &quot;\n&quot;                                        #
              )
            : q{$conf_ref-&gt;{$_} = 1; } . &quot;\n&quot;
          ) . '};';
    }

    $parser_code .= &quot;; 1&quot;;
    $parser_code =~ tr{\n}{\r};    ## no critic qw(Cpanel::TransliterationUsage)
    eval($parser_code) or do {     ## no critic qw(BuiltinFunctions::ProhibitStringyEval)
        $parser_code =~ tr{\r}{\n};    ## no critic qw(Cpanel::TransliterationUsage)
        _do_logger( 'panic', &quot;Failed to parse :: $parser_code: $@&quot; );
        return ( 0, &quot;$@\n$parser_code&quot; );
    };

    delete $conf_ref-&gt;{''} if !defined( $conf_ref-&gt;{''} );

    if ($skip_keys) {
        my $skip_keys_ar;
        if ( ref $skip_keys eq 'ARRAY' ) {
            $skip_keys_ar = $skip_keys;
        }
        elsif ( ref $skip_keys eq 'HASH' ) {
            $skip_keys_ar = [ keys %$skip_keys ];
        }
        else {
            return ( 0, 'skip_keys must be an ARRAY or HASH reference' );
        }
        delete @{$conf_ref}{@$skip_keys_ar};
    }

    return ( 1, $conf_ref );
}

sub _hashify_ref {
    my $conf_ref = shift;

    if ( !defined($conf_ref) ) {
        $conf_ref = {};
        return $conf_ref;
    }

    unless ( ref $conf_ref eq 'HASH' ) {
        if ( ref $conf_ref ) {
            require Cpanel::Logger;
            Cpanel::Logger::cplog( 'hashifying non-HASH reference', 'warn', __PACKAGE__ );

            ${$conf_ref} = {};
            $conf_ref = ${$conf_ref};
        }
        else {
            require Cpanel::Logger;
            Cpanel::Logger::cplog( 'defined value encountered where reference expected', 'die', __PACKAGE__ );
        }
    }
    return $conf_ref;
}

sub default_product_dir {
    $PRODUCT_CONF_DIR = shift if @_;
    return $PRODUCT_CONF_DIR;
}

sub _remove_comments_from_text {
    my ( $cfg_txt_sr, $comment, $has_cr_sr ) = @_;
    if ($$has_cr_sr) {
        $$cfg_txt_sr = join( &quot;\n&quot;, grep ( !m/$comment/, split( m{\r?\n}, $$cfg_txt_sr ) ) );
        $$has_cr_sr  = 0;
    }
    elsif ( $comment eq $DEFAULT_COMMENT_REGEXP ) {

        if ( rindex( $$cfg_txt_sr, '#', 0 ) == 0 &amp;&amp; index( $$cfg_txt_sr, &quot;\n&quot; ) &gt; -1 ) {
            substr( $$cfg_txt_sr, 0, index( $$cfg_txt_sr, &quot;\n&quot; ) + 1, '' );
        }
        $$cfg_txt_sr =~ s{$DEFAULT_COMMENT_REGEXP.*}{}omg if $$cfg_txt_sr =~ tr{#;}{};
    }
    else {
        $$cfg_txt_sr =~ s{$comment.*}{}mg;
    }
    return 1;
}

1;

} # --- END Cpanel/Config/LoadConfig.pm


{ # --- BEGIN Cpanel/Config/FlushConfig.pm
package Cpanel::Config::FlushConfig;


use strict;
use warnings;

# use Cpanel::FileUtils::Write ();
# use Cpanel::Debug            ();
# use Cpanel::Exception        ();

our $VERSION = '1.4';

my $DEFAULT_DELIMITER = '=';


sub flushConfig {
    my ( $filename_or_fh, $conf, $delimiter, $header, $opts ) = @_;

    if ( !$filename_or_fh ) {
        Cpanel::Debug::log_warn('flushConfig requires valid filename or fh as first argument');
        return;
    }
    elsif ( !$conf || ref $conf ne 'HASH' ) {
        Cpanel::Debug::log_warn('flushConfig requires HASH reference as second argument');
        return;
    }

    if ( ref $opts &amp;&amp; $opts-&gt;{'no_overwrite'} ) {
        die Cpanel::Exception::create( 'Unsupported', 'Function ”flushConfig” called with an unsupported option “no_overwrite”.' );
    }

    my $contents_sr = serialize(
        $conf,
        do_sort            =&gt; $opts &amp;&amp; $opts-&gt;{'sort'},
        delimiter          =&gt; $delimiter,
        header             =&gt; $header,
        allow_array_values =&gt; $opts &amp;&amp; $opts-&gt;{'allow_array_values'},
    );

    my $perms = 0644;    # default permissions when unset
    if ( defined $opts-&gt;{'perms'} ) {
        $perms = $opts-&gt;{'perms'};
    }
    elsif ( !ref $filename_or_fh &amp;&amp; -e $filename_or_fh ) {
        $perms = ( stat(_) )[2] &amp; 0777;
    }

    if ( ref $filename_or_fh ) {
        return Cpanel::FileUtils::Write::write_fh(
            $filename_or_fh,
            ref $contents_sr eq 'SCALAR' ? $$contents_sr : $contents_sr
        );
    }

    return Cpanel::FileUtils::Write::overwrite_no_exceptions(
        $filename_or_fh,
        ref $contents_sr eq 'SCALAR' ? $$contents_sr : $contents_sr,
        $perms,
    );
}


sub serialize {
    my ( $conf, %opts ) = @_;

    my ( $do_sort, $delimiter, $header, $allow_array_values ) = @opts{qw(do_sort delimiter header allow_array_values)};

    $delimiter ||= $DEFAULT_DELIMITER;


    if ($allow_array_values) {
        my $contents = '';
        $contents .= $header . &quot;\n&quot; if $header;

        foreach my $key ( $do_sort ? ( sort keys %{$conf} ) : ( keys %{$conf} ) ) {
            if ( ref( $conf-&gt;{$key} ) eq 'ARRAY' ) {
                $contents .= join(
                    &quot;\n&quot;,
                    map { $key . $delimiter . $_ } ( @{ $conf-&gt;{$key} } )
                ) . &quot;\n&quot;;
            }
            else {
                $contents .= $key . $delimiter . ( defined $conf-&gt;{$key} ? $conf-&gt;{$key} : '' ) . &quot;\n&quot;;
            }
        }

        return \$contents;
    }

    my $contents = ( $header ? ( $header . &quot;\n&quot; ) : '' ) . join(
        &quot;\n&quot;,
        map { $_ . ( defined $conf-&gt;{$_} ? ( $delimiter . $conf-&gt;{$_} ) : '' ) } ( $do_sort ? ( sort keys %{$conf} ) : ( keys %{$conf} ) )
    ) . &quot;\n&quot;;

    return \$contents;
}

1;

} # --- END Cpanel/Config/FlushConfig.pm


{ # --- BEGIN Cpanel/Update/Config.pm
package Cpanel::Update::Config;


use cPstrict;

# use Cpanel::Config::LoadConfig ();

our $VERSION            = '2.1';
our $cpanel_update_conf = '/etc/cpupdate.conf';

use constant DEFAULT_TIER =&gt; 'release';


sub _default_preferences {
    return {
        'CPANEL'           =&gt; DEFAULT_TIER,
        'RPMUP'            =&gt; 'daily',
        'SARULESUP'        =&gt; 'daily',
        'UPDATES'          =&gt; 'daily',
        'SECURITY_UPDATES' =&gt; 'hourly',
        'STAGING_DIR'      =&gt; '/usr/local/cpanel',
    };
}


sub valid_keys {

    return [qw/CPANEL RPMUP SARULESUP UPDATES SECURITY_UPDATES STAGING_DIR/];
}


sub cadence_keys {
    return [qw/UPDATES RPMUP SARULESUP/];
}


sub valid_cadence_values {
    return [qw/daily manual never/];
}


sub is_valid_cadence ( $value = undef ) {
    return 0 if !defined $value;
    return scalar grep { lc($value) eq $_ } @{ valid_cadence_values() };
}


sub valid_security_updates_values {
    return [qw/hourly never/];
}


sub is_valid_security_updates {
    my ($value) = @_;
    return 0 if !defined $value;
    return scalar grep { lc($value) eq $_ } @{ valid_security_updates_values() };
}

sub load {
    my $default_rUPCONF = _default_preferences();

    if ( ${^GLOBAL_PHASE} &amp;&amp; ${^GLOBAL_PHASE} eq 'START' &amp;&amp; lc($0) ne '-e' ) {
        die q[FATAL: load is called during compile time. You should postpone this call.];
    }

    if ( !-e $cpanel_update_conf ) {
        save($default_rUPCONF);
        return wantarray ? %{$default_rUPCONF} : $default_rUPCONF;
    }

    my $rUPCONF = Cpanel::Config::LoadConfig::loadConfig($cpanel_update_conf);
    my $changed = sanitize($rUPCONF);

    foreach my $key ( keys %{$default_rUPCONF} ) {
        if ( !exists $rUPCONF-&gt;{$key} ) {
            $changed++;
            $rUPCONF-&gt;{$key} = $default_rUPCONF-&gt;{$key};
        }
    }

    save($rUPCONF) if $changed;

    return wantarray ? %{$rUPCONF} : $rUPCONF;
}

sub sanitize ( $conf_ref = undef, $die_on_failure = undef ) {

    return if ref $conf_ref ne 'HASH';

    my $changed = 0;

    my %is_valid_key   = map { $_ =&gt; 1 } @{ valid_keys() };
    my %is_cadence_key = map { $_ =&gt; 1 } @{ cadence_keys() };

    foreach my $key ( keys %{$conf_ref} ) {

        my $value = $conf_ref-&gt;{$key};

        if ( !defined $value ) {
            $value = '';
            $changed++;
        }
        else {
            $changed++ if ( $value =~ s/[\n\r]//g );    # Strip newline chars
            $changed++ if ( $value =~ s/^\s+// );       # Strip leading whitespace
            $changed++ if ( $value =~ s/\s+$// );       # Strip trailing whitespace
        }

        if ( !$is_valid_key{$key} ) {
            if ( !length $value ) {
                delete $conf_ref-&gt;{$key};
                $changed++;
                next;
            }

            $conf_ref-&gt;{$key} = $value;
            next;
        }

        if ( $key eq 'CPANEL' &amp;&amp; !$value ) {
            $value = _default_preferences()-&gt;{'CPANEL'};
            $changed++;
        }

        if ($value) {
            $changed++ if ( $value ne '/' and $value =~ s{/+$}{} );    # Strip trailing slash. This is for STAGING_DIR but nothing else should have a slash in its value.

            if ( $key ne 'STAGING_DIR' ) {
                $changed++ if ( $value =~ tr/A-Z/a-z/ );
            }

            if ( $key eq 'CPANEL' ) {
                my $new_value = _normalize_version($value);    # Automatically add the 11 or strip the v when existing
                if ( $new_value ne $value ) {
                    $value = $new_value;
                    $changed++;
                }
            }
        }

        if ( $is_cadence_key{$key} and not is_valid_cadence($value) ) {
            $value = _default_preferences()-&gt;{$key};
            $changed++;
        }

        if ( $key eq 'SECURITY_UPDATES' and not is_valid_security_updates($value) ) {
            $value = _default_preferences()-&gt;{'SECURITY_UPDATES'};
            $changed++;
        }

        if ( $key eq 'STAGING_DIR' and not validate_staging_dir( $value, $die_on_failure ) ) {
            $value = _default_preferences()-&gt;{'STAGING_DIR'};
            $changed++;    # Flag for file save
        }

        $conf_ref-&gt;{$key} = $value;
    }

    return $changed;
}


sub _normalize_version ( $version = undef ) {
    return if !length $version;

    my $candidate = $version;
    $candidate =~ s/^v(?=[0-9])//;

    return $version if $candidate =~ tr/0-9.//c;

    return $candidate if rindex( $candidate, '11.', 0 ) == 0;

    return '11.' . $candidate;
}

sub _stat_directory {
    my $dir = shift;
    return stat($dir);
}

sub validate_staging_dir {

    my ( $value, $die_on_failure ) = @_;
    my $ulc     = '/usr/local/cpanel';
    my $ulc_dev = ( _stat_directory($ulc) )[0];

    return if not $value;

    if ( !_is_valid_filepath($value) ) {
        die &quot;'$value' is not a valid directory path\n&quot; if $die_on_failure;
        return;
    }

    my @stat = _stat_directory($value) or return 1;

    if ( -e $value &amp;&amp; !-d $value ) {
        die &quot;'$value' exists on the file system, but is not a directory\n&quot; if $die_on_failure;
        return;
    }

    if ( -e $value &amp;&amp; ( !-d $value || !( -d $value &amp;&amp; -w $value ) ) ) {
        die &quot;'$value' exists on the file system, but is not a writable directory\n&quot; if $die_on_failure;
        return;
    }

    if ( 0 != $stat[4] ) {
        die &quot;'$value' exists on the file system, but is not owned by the root user\n&quot; if $die_on_failure;
        return;
    }

    if ( $stat[0] == $ulc_dev &amp;&amp; $value ne $ulc ) {
        die &quot;'$value' is on the same file system as /usr/local/cpanel. Please use /usr/local/cpanel instead.\n&quot; if $die_on_failure;
        return;
    }

    if ( $stat[2] &amp; 022 ) {
        die &quot;'$value' exists on the file system, but does not have the correct permissions. Directory must not have write permissions for group and non-root users\n&quot; if $die_on_failure;
        return;
    }

    return 1;
}

sub save {
    my $conf_ref       = shift;
    my $die_on_failure = shift;

    return if ref $conf_ref ne 'HASH';

    return if ( $&gt; != 0 );

    sanitize( $conf_ref, $die_on_failure );

    require Cpanel::Config::FlushConfig;
    if ( my $return = Cpanel::Config::FlushConfig::flushConfig( $cpanel_update_conf, $conf_ref, '=', undef, { 'sort' =&gt; 1 } ) ) {
        return $return;
    }
    else {
        die &quot;Unable to save file, $cpanel_update_conf: $!\n&quot; if $die_on_failure;
        return;
    }
}

sub get_tier {
    my ($update_config_ref) = @_;

    if ( !defined $update_config_ref ) {
        $update_config_ref = load();
    }

    return if ( ref $update_config_ref ne 'HASH' );

    return $update_config_ref-&gt;{'CPANEL'};
}

sub is_permitted {
    my $key     = shift or return;
    my $up_conf = shift or return;
    ref $up_conf eq 'HASH' or return;

    $key = uc($key);    # Force key case upper.
    my $key_value = $up_conf-&gt;{$key} or return;

    return if ( $key eq 'RPMUP' &amp;&amp; $ENV{'CPANEL_BASE_INSTALL'} );
    return if ( $key_value eq 'never' );
    return if ( $ENV{'CPANEL_IS_CRON'} &amp;&amp; $key_value eq 'manual' );
    return 1;
}

sub get_update_type {
    my $rUPCONF = load();
    return $rUPCONF-&gt;{'UPDATES'};
}

sub _is_valid_filepath {
    my $filepath = shift;
    return 1 if index( $filepath, '/' ) == 0;    # checking for / is the same as file_name_is_absolute
    return;
}

1;

} # --- END Cpanel/Update/Config.pm


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


use strict;
use warnings;


use Try::Tiny;

use Cpanel::Autodie;
use Cpanel::Fcntl;


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

    my $fh;


    try {

        Cpanel::Autodie::sysopen(
            $fh,
            $path,
            Cpanel::Fcntl::or_flags(qw( O_WRONLY  O_CREAT  O_EXCL )),
        );
    }
    catch {
        undef $fh;

        if ( !try { $_-&gt;error_name() eq 'EEXIST' } ) {
            local $@ = $_;
            die;
        }
    };

    return $fh ? 1 : 0;
}

1;

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


{ # --- BEGIN Cpanel/Config/TouchFileBase.pm
package Cpanel::Config::TouchFileBase;


use strict;
use warnings;


# use Cpanel::Autodie   ();
# use Cpanel::Exception ();

sub _TOUCH_FILE { die Cpanel::Exception::create('AbstractClass') }

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

    my $exists = Cpanel::Autodie::exists( $self-&gt;_TOUCH_FILE(@args) );

    if ( $exists &amp;&amp; !-f _ ) {
        die Cpanel::Exception-&gt;create( '“[_1]” exists but is not a file!', [ $self-&gt;_TOUCH_FILE(@args) ] );
    }

    return $exists;
}

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

    my $path = $self-&gt;_TOUCH_FILE(@args);

    require Cpanel::FileUtils::Touch;

    return Cpanel::FileUtils::Touch::touch_if_not_exists($path);
}

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

    return Cpanel::Autodie::unlink_if_exists( $self-&gt;_TOUCH_FILE(@args) );
}

1;

} # --- END Cpanel/Config/TouchFileBase.pm


{ # --- BEGIN Cpanel/Update/IsCron.pm
package Cpanel::Update::IsCron;


use strict;
use warnings;


# use Cpanel::Config::TouchFileBase();
our @ISA;
BEGIN { push @ISA, qw(Cpanel::Config::TouchFileBase); }

our $_PATH = '/var/cpanel/upgrade_is_from_cron';

sub _TOUCH_FILE { return $_PATH }

1;

} # --- END Cpanel/Update/IsCron.pm


{ # --- BEGIN Cpanel/SafeDir/MK.pm
package Cpanel::SafeDir::MK;


use strict;
use warnings;

# use Cpanel::Debug ();

my $DEFAULT_PERMISSIONS = 0755;


sub safemkdir_or_die {
    my ( $dir, $mode, $created ) = @_;
    my $ok = safemkdir( $dir, $mode, $created );
    if ( !$ok ) {
        my $error = $!;
        require Cpanel::Exception;
        die Cpanel::Exception::create(
            'IO::DirectoryCreateError',
            [
                path  =&gt; $dir,
                error =&gt; $error,
            ]
        );
    }
    return $ok;
}


sub safemkdir {    ## no critic(Subroutines::ProhibitExcessComplexity)  -- Refactoring this function is a project, not a bug fix
    my ( $dir, $mode, $errors, $created ) = @_;

    if ( defined $mode ) {
        if ( $mode eq '' ) {
            $mode = undef;
        }
        elsif ( index( $mode, '0' ) == 0 ) {
            if ( length $mode &lt; 3 || $mode =~ tr{0-7}{}c || !defined oct $mode ) {
                $mode = $DEFAULT_PERMISSIONS;
            }
            else {
                $mode = oct($mode);
            }
        }
        elsif ( $mode =~ tr{0-9}{}c ) {
            $mode = $DEFAULT_PERMISSIONS;
        }
    }
    $dir =~ tr{/}{}s;

    my $default = '';
    if ( index( $dir, '/' ) == 0 ) {
        $default = '/';
    }
    elsif ( $dir eq '.' || $dir eq './' ) {
        if ( !-l $dir &amp;&amp; defined $mode ) {
            return chmod $mode, $dir;
        }
        return 1;
    }
    else {
        substr( $dir, 0, 2, '' ) if index( $dir, './' ) == 0;
    }

    if ( _has_dot_dot($dir) ) {
        Cpanel::Debug::log_warn(&quot;Possible improper directory $dir specified&quot;);
        my @dir_parts = split m{/}, $dir;
        my @good_parts;
        my $first;
        foreach my $part (@dir_parts) {
            next if ( !defined $part || $part eq '' );
            next if $part eq '.';
            if ( $part eq '..' ) {
                if ( !$first || !@good_parts ) {
                    Cpanel::Debug::log_warn(&quot;Will not proceed above first directory part $first&quot;);
                    return 0;
                }
                if ( $first eq $good_parts[$#good_parts] ) {
                    undef $first;
                }
                pop @good_parts;
                next;
            }
            elsif ( $part !~ tr{.}{}c ) {
                Cpanel::Debug::log_warn(&quot;Total stupidity found in directory $dir&quot;);
                return 0;
            }
            push @good_parts, $part;
            if ( !$first ) { $first = $part }
        }
        $dir = $default . join '/', @good_parts;
        if ( !$dir ) {
            Cpanel::Debug::log_warn(&quot;Could not validate given directory&quot;);
            return;
        }
        Cpanel::Debug::log_warn(&quot;Improper directory updated to $dir&quot;);
    }

    if ( -d $dir ) {
        if ( !-l $dir &amp;&amp; defined $mode ) {
            return chmod $mode, $dir;
        }
        return 1;
    }
    elsif ( -e _ ) {
        Cpanel::Debug::log_warn(&quot;$dir was expected to be a directory!&quot;);
        require Errno;
        $! = Errno::ENOTDIR();    ## no critic qw(Variables::RequireLocalizedPunctuationVars) -- for legacy reasons
        return 0;
    }

    my @dir_parts = split m{/}, $dir;

    if ( scalar @dir_parts &gt; 100 ) {
        Cpanel::Debug::log_warn(&quot;Encountered excessive directory length. This should never happen.&quot;);
        return 0;
    }
    my $returnvalue;
    foreach my $i ( 0 .. $#dir_parts ) {
        my $newdir = join( '/', @dir_parts[ 0 .. $i ] );
        next if $newdir eq '';
        my $is_dir = -d $newdir;
        my $exists = -e _;

        if ( !$exists ) {
            my $local_mode = defined $mode ? $mode : $DEFAULT_PERMISSIONS;
            if ( mkdir( $newdir, $local_mode ) ) {
                push @{$created}, $newdir if $created;
                $returnvalue++;
            }
            else {
                Cpanel::Debug::log_warn(&quot;mkdir $newdir failed: $!&quot;);
                return;
            }
        }
        elsif ( !$is_dir ) {
            Cpanel::Debug::log_warn(&quot;Encountered non-directory $newdir in path of $dir: $!&quot;);
            require Errno;
            $! = Errno::ENOTDIR();    ## no critic qw(Variables::RequireLocalizedPunctuationVars) -- for legacy reasons
            last;
        }
    }
    return $returnvalue;
}

sub _has_dot_dot {    ## no critic qw(RequireArgUnpacking)
    return 1 if $_[0] eq '..';
    return 1 if -1 != index( $_[0], '/../' );
    return 1 if 0 == index( $_[0], '../' );
    return 1 if ( length( $_[0] ) - 3 ) == rindex( $_[0], '/..' );

    return 0;
}

1;

} # --- END Cpanel/SafeDir/MK.pm


{ # --- BEGIN Cpanel/FHUtils/Autoflush.pm
package Cpanel::FHUtils::Autoflush;


use strict;
use warnings;

sub enable {
    select( ( select( $_[0] ), $| = 1 )[0] );    ## no critic qw(InputOutput::ProhibitOneArgSelect Variables::RequireLocalizedPunctuationVars) - aka $socket-&gt;autoflush(1) without importing IO::Socket

    return;
}

1;

} # --- END Cpanel/FHUtils/Autoflush.pm


{ # --- BEGIN Cpanel/Update/Logger.pm
package Cpanel::Update::Logger;


use strict;
use warnings;
# use Cpanel::SafeDir::MK        ();
# use Cpanel::Time::Local        ();
# use Cpanel::FHUtils::Autoflush ();
use File::Basename             ();

use constant {
    DEBUG =&gt; 0,
    INFO  =&gt; 25,
    WARN  =&gt; 50,
    ERROR =&gt; 75,
    FATAL =&gt; 100,
};

our $VERSION = '1.2';

our $_BACKLOG_TIE_CLASS;

sub new {
    my $class = shift;
    my $self  = shift || {};
    ref($self) eq 'HASH' or CORE::die(&quot;hashref not passed to new&quot;);

    bless( $self, $class );

    $self-&gt;{'stdout'} = 1 if ( !defined $self-&gt;{'stdout'} );

    $self-&gt;{'timestamp'} = 1 if ( !defined $self-&gt;{'timestamp'} );

    if ( $self-&gt;{'to_memory'} ) {
        $self-&gt;{'backlog'} = [];

        tie @{ $self-&gt;{'backlog'} }, $_BACKLOG_TIE_CLASS if $_BACKLOG_TIE_CLASS;
    }

    eval { $self-&gt;set_logging_level( $self-&gt;{'log_level'} ); 1 }
      or CORE::die(&quot;An invalid logging level was passed to new: $self-&gt;{'log_level'}&quot;);

    $self-&gt;open_log() if $self-&gt;{'logfile'};

    if ( exists $self-&gt;{'pbar'} and defined $self-&gt;{'pbar'} ) {
        $self-&gt;{'pbar'} += 0;
        $self-&gt;update_pbar( $self-&gt;{'pbar'} );
    }

    return $self;
}

sub open_log {
    my $self = shift or CORE::die();

    my $log_file    = $self-&gt;{'logfile'};
    my $logfile_dir = File::Basename::dirname($log_file);
    my $created_dir = 0;
    if ( !-d $logfile_dir ) {
        Cpanel::SafeDir::MK::safemkdir( $logfile_dir, '0700', 2 );
        $created_dir = 1;
    }

    my $old_umask = umask(0077);    # Case 92381: Logs should not be world-readable
    open( my $fh, '&gt;&gt;', $log_file ) or do {
        CORE::die(&quot;Failed to open '$log_file' for append: $!&quot;);
    };

    umask($old_umask);

    Cpanel::FHUtils::Autoflush::enable($fh);
    Cpanel::FHUtils::Autoflush::enable( \*STDOUT ) if $self-&gt;{'stdout'};

    $self-&gt;{'fh'} = $fh;

    unless ( $self-&gt;{brief} ) {
        print {$fh} '-' x 100 . &quot;\n&quot;;
        print {$fh} &quot;=&gt; Log opened from $0 ($$) at &quot; . localtime(time) . &quot;\n&quot;;
    }

    $self-&gt;warning(&quot;Had to create directory $logfile_dir before opening log&quot;) if ($created_dir);

    return;
}

sub close_log {
    my $self = shift or CORE::die();

    return if ( !$self-&gt;{'fh'} );
    my $fh = $self-&gt;{'fh'};

    unless ( $self-&gt;{brief} ) {
        print {$fh} &quot;=&gt; Log closed &quot; . localtime(time) . &quot;\n&quot;;
    }

    warn(&quot;Failed to close file handle for $self-&gt;{'logfile'}&quot;) if ( !close $fh );
    delete $self-&gt;{'fh'};

    return;
}

sub DESTROY {
    my $self = shift or CORE::die(&quot;DESTROY called without an object&quot;);
    $self-&gt;close_log if ( $self-&gt;{'fh'} );

    return;
}

sub log {
    my $self = shift         or CORE::die(&quot;log called as a class&quot;);
    ref $self eq __PACKAGE__ or CORE::die(&quot;log called as a class&quot;);

    my $msg = shift or return;

    my $stdout = shift;
    $stdout = $self-&gt;{'stdout'} if ( !defined $stdout );

    my $to_memory = $self-&gt;{'to_memory'};
    my $fh        = $self-&gt;{'fh'};

    foreach my $line ( split( /[\r\n]+/, $msg ) ) {
        if ( $self-&gt;{'timestamp'} ) {
            substr( $line, 0, 0, '[' . Cpanel::Time::Local::localtime2timestamp() . '] ' );
        }

        chomp $line;
        print STDOUT &quot;$line\n&quot; if $stdout;
        print {$fh} &quot;$line\n&quot;  if $fh;
        push @{ $self-&gt;{'backlog'} }, &quot;$line&quot; if ($to_memory);
    }

    return;
}

sub _die {
    my $self    = shift or CORE::die();
    my $message = shift || '';

    $self-&gt;log(&quot;***** DIE: $message&quot;);
    return CORE::die( &quot;exit level [die] [pid=$$] ($message) &quot; . join ' ', caller() );
}

sub fatal {
    my $self = shift or CORE::die();
    return if ( $self-&gt;{'log_level_numeric'} &gt; FATAL );

    my $message = shift || '';

    $self-&gt;log(&quot;***** FATAL: $message&quot;);
    $self-&gt;set_need_notify();

    return;
}

sub error {
    my $self = shift or CORE::die();
    return if ( $self-&gt;{'log_level_numeric'} &gt; ERROR );

    my $message = shift || '';

    $self-&gt;log(&quot;E $message&quot;);

    return;
}

sub warning {
    my $self = shift or CORE::die();
    return if ( $self-&gt;{'log_level_numeric'} &gt; WARN );

    my $message = shift || '';

    $self-&gt;log(&quot;W $message&quot;);

    return;
}

sub panic {
    my $self = shift or CORE::die();
    return if ( $self-&gt;{'log_level_numeric'} &gt; ERROR );

    my $message = shift || '';

    $self-&gt;log(&quot;***** PANIC!&quot;);
    $self-&gt;log(&quot;E $message&quot;);
    $self-&gt;log(&quot;***** PANIC!&quot;);
    $self-&gt;set_need_notify();

    return;
}

sub info {
    my $self = shift or CORE::die();
    return if ( $self-&gt;{'log_level_numeric'} &gt; INFO );

    my $message = shift || '';

    $self-&gt;log(&quot;  $message&quot;);

    return;
}

sub debug {
    my $self = shift or CORE::die();
    return if ( $self-&gt;{'log_level_numeric'} &gt; DEBUG );

    my $message = shift || '';

    $self-&gt;log(&quot;D $message&quot;);

    return;
}

sub get_logging_level { return shift-&gt;{'log_level'} }

sub set_logging_level {
    my $self = shift or CORE::die();

    my $log_level = shift;
    $log_level = 'info' if ( !defined $log_level );

    my $old_log_level = $self-&gt;get_logging_level();

    if ( $log_level =~ m/^fatal/i ) {
        $self-&gt;{'log_level'}         = 'fatal';
        $self-&gt;{'log_level_numeric'} = FATAL;
    }
    elsif ( $log_level =~ m/^error/i ) {
        $self-&gt;{'log_level'}         = 'error';
        $self-&gt;{'log_level_numeric'} = ERROR;
    }
    elsif ( $log_level =~ m/^warn/i ) {
        $self-&gt;{'log_level'}         = 'warning';
        $self-&gt;{'log_level_numeric'} = WARN;
    }
    elsif ( $log_level =~ m/^info/i ) {
        $self-&gt;{'log_level'}         = 'info';
        $self-&gt;{'log_level_numeric'} = INFO;
    }
    elsif ( $log_level =~ m/^debug/i ) {
        $self-&gt;{'log_level'}         = 'debug';
        $self-&gt;{'log_level_numeric'} = DEBUG;
    }
    else {
        CORE::die(&quot;Unknown logging level '$log_level' passed to set_logging_level&quot;);
    }

    return $old_log_level;
}

sub get_pbar { return shift-&gt;{'pbar'} }

sub increment_pbar {
    my $self = shift or CORE::die();
    return if ( !exists $self-&gt;{'pbar'} );

    my $amount    = shift || 1;
    my $new_value = $self-&gt;{'pbar'} + $amount;

    return $self-&gt;update_pbar($new_value);
}

sub update_pbar {
    my $self = shift or CORE::die();
    return if ( !exists $self-&gt;{'pbar'} );

    my $new_value = shift || 0;
    if ( $new_value &gt; 100 ) {
        $self-&gt;debug(&quot;Pbar set to &gt; 100 ($new_value)&quot;);
        $new_value = 100;
    }

    return if $new_value == $self-&gt;{'pbar'};
    $self-&gt;{'pbar'} = $new_value;

    $self-&gt;info( $new_value . '% complete' );

    return;
}

sub set_need_notify {
    my $self = shift;
    ref $self eq __PACKAGE__ or CORE::die(&quot;log called as a class&quot;);
    $self-&gt;info(&quot;The Administrator will be notified to review this output when this script completes&quot;);

    return $self-&gt;{'need_notify'} = 1;
}

sub get_need_notify {
    my $self = shift;
    ref $self eq __PACKAGE__ or CORE::die(&quot;log called as a class&quot;);
    return $self-&gt;{'need_notify'};
}

sub get_stored_log {
    my $self = shift;
    ref $self eq __PACKAGE__ or CORE::die(&quot;log called as a class&quot;);

    return if ( !$self-&gt;{'to_memory'} );

    return $self-&gt;{'backlog'};
}

sub get_next_log_message {
    my $self = shift;
    ref $self eq __PACKAGE__ or CORE::die(&quot;log called as a class&quot;);

    return if ( !$self-&gt;{'to_memory'} );

    return shift @{ $self-&gt;{'backlog'} };
}

sub success { goto \&amp;info; }
sub out     { goto \&amp;info; }
sub warn    { goto \&amp;warning; }
sub die     { goto \&amp;_die; }

1;

} # --- END Cpanel/Update/Logger.pm


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


use strict;

our $VERSION         = '11.110.0';
our $VERSION_BUILD   = '11.110.0.144';
our $VERSION_TEXT    = '110.0 (build 144)';
our $VERSION_DISPLAY = '110.0.144';

our $parent_version = 11;
our $major_version  = 110;
our $minor_version  = 0;
our $build_number   = 144;

our $build_time_text = 'Thu Sep 10 13:32:28 2026';
our $buildtime       = 1789065148;

1;

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


{ # --- BEGIN Cpanel/Version/Full.pm
package Cpanel::Version::Full;


use strict;


my $full_version;

our $VERSION_FILE = '/usr/local/cpanel/version';


sub getversion {
    if ( !$full_version ) {

        if ( open my $ver_fh, '&lt;', $VERSION_FILE ) {
            if ( read $ver_fh, $full_version, 32 ) {
                chomp($full_version);
            }
            elsif ($!) {
                warn &quot;read($VERSION_FILE): $!&quot;;
            }
        }
        else {
            warn &quot;open($VERSION_FILE): $!&quot;;
        }

        if ( !$full_version || $full_version =~ tr{.}{} &lt; 3 ) {
            require Cpanel::Version::Tiny;
            $full_version = $Cpanel::Version::Tiny::VERSION_BUILD;
        }
    }

    return $full_version;
}

sub _clear_cache {
    undef $full_version;
    return;
}

1;

} # --- END Cpanel/Version/Full.pm


{ # --- BEGIN Cpanel/Version/Compare.pm
package Cpanel::Version::Compare;


use cPstrict;


my %modes = (
    '&gt;' =&gt; sub ( $check, $against ) {
        return if $check eq $against;    # no need to continue if they are the same

        return ( cmp_versions( $check, $against ) &gt; 0 );
    },
    '&lt;' =&gt; sub ( $check, $against ) {
        return if $check eq $against;    # no need to continue if they are the same

        return ( cmp_versions( $check, $against ) &lt; 0 );
    },
    '==' =&gt; sub ( $check, $against ) {
        return ( $check eq $against || cmp_versions( $check, $against ) == 0 );
    },
    '!=' =&gt; sub ( $check, $against ) {
        return ( $check ne $against &amp;&amp; cmp_versions( $check, $against ) != 0 );
    },
    '&gt;=' =&gt; sub ( $check, $against ) {
        return 1 if $check eq $against;    # no need to continue if they are the same
        return ( cmp_versions( $check, $against ) &gt;= 0 );
    },
    '&lt;=' =&gt; sub ( $check, $against ) {
        return 1 if $check eq $against;    # no need to continue if they are the same
        return ( cmp_versions( $check, $against ) &lt;= 0 );
    },
    '&lt;=&gt;' =&gt; sub ( $check, $against ) {
        return cmp_versions( $check, $against );
    },
);

sub compare ( $check, $mode, $against ) {

    if ( !defined $mode || !exists $modes{$mode} ) {

        return;
    }
    foreach my $ver ( $check, $against ) {

        $ver //= '';
        if ( $ver !~ m{ ^((?:\d+[._]){0,}\d+[a-z]?).*?$ }axms ) {

            return;
        }

        $ver = $1;
    }

    $check   =~ s/_/\./g;
    $against =~ s/_/\./g;

    $check   =~ s/([a-z])$/'.' . ord($1)/e;
    $against =~ s/([a-z])$/'.' . ord($1)/e;

    my @check_len   = split( /[_\.]/, $check );
    my @against_len = split( /[_\.]/, $against );

    if ( @check_len &gt; 4 ) {

        return;
    }
    elsif ( @check_len &lt; 4 ) {
        for ( 1 .. 4 - @check_len ) {
            $check .= '.0';
        }
    }

    if ( @against_len &gt; 4 ) {

        return;
    }
    elsif ( @against_len &lt; 4 ) {
        for ( 1 .. 4 - @against_len ) {
            $against .= '.0';
        }
    }

    return if $check   !~ m { \A \d+\.\d+\.\d+\.\d+ \z }axms;
    return if $against !~ m { \A \d+\.\d+\.\d+\.\d+ \z }axms;

    return $modes{$mode}-&gt;( $check, $against );
}


sub cmp_versions ( $left, $right ) {
    my ( $maj, $min, $rev, $sup ) = split /[\._]/, $left;
    my ( $mj,  $mn,  $rv,  $sp )  = split /[\._]/, $right;

    return $maj &lt;=&gt; $mj || $min &lt;=&gt; $mn || $rev &lt;=&gt; $rv || $sup &lt;=&gt; $sp;
}


sub get_major_release ( $version = '' ) {
    $version =~ s/\s*//g;
    my ( $major, $minor );
    if ( $version =~ m/^([0-9]+)\.([0-9]+)/ ) {
        $major = int $1;
        $minor = int $2;
    }
    else {
        return;
    }
    $minor++ if $minor % 2;
    return &quot;$major.$minor&quot;;
}


sub compare_major_release ( $check, $mode, $against ) {

    return unless defined $check &amp;&amp; defined $mode &amp;&amp; defined $against;
    my $maj1 = get_major_release($check);
    return unless defined $maj1;
    my $maj2 = get_major_release($against);
    return unless defined $maj2;
    return $modes{$mode}-&gt;( $maj1, $maj2 );
}


1;

} # --- END Cpanel/Version/Compare.pm


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


use strict;
my $in_global_destruction = 0;
my ( $package, $filename, $line, $subroutine );    # preallocate

sub in_dangerous_global_destruction {

    if ( !$INC{'Test2/API.pm'} ) {

        return 1 if in_global_destruction() &amp;&amp; $INC{'Cpanel/BinCheck.pm'};
    }

    return 0;
}

sub in_global_destruction {
    return $in_global_destruction if $in_global_destruction;

    if ( defined( ${^GLOBAL_PHASE} ) ) {
        if ( ${^GLOBAL_PHASE} eq 'DESTRUCT' ) {
            $in_global_destruction = 1;
        }
    }

    else {
        local $SIG{'__WARN__'} = \&amp;_detect_global_destruction_pre_514_WARN_handler;
        warn;
    }

    return $in_global_destruction;
}

sub _detect_global_destruction_pre_514_WARN_handler {
    if ( length $_[0] &gt; 26 &amp;&amp; rindex( $_[0], 'during global destruction.' ) == ( length( $_[0] ) - 26 ) ) {
        $in_global_destruction = 1;
    }

    return;
}

1;

} # --- END Cpanel/Destruct.pm


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


use strict;
use warnings;

# use Cpanel::Destruct ();

sub new {
    my $class              = shift or die(&quot;Cpanel::Alarm::new is a method call.&quot;);
    my $local_alarm_length = shift || 0;
    my $action             = shift;

    my $self = bless( {}, $class );

    $self-&gt;{'previous_alarm_time_left'} = $self-&gt;set($local_alarm_length);

    $self-&gt;{'creation_time'}   = $self-&gt;{'local_alarm_start'};
    $self-&gt;{'previous_action'} = $SIG{'ALRM'};

    if ( defined $action ) {
        $SIG{'ALRM'} = $action;
    }
    return $self;
}

sub get_length { return shift-&gt;{'local_alarm_length'} }

sub set {    ## no critic qw(Unpack)
    $_[0] or die 'Need argument!';
    $_[0]-&gt;{'local_alarm_length'} = $_[1];
    $_[0]-&gt;{'local_alarm_start'}  = time();

    if ( $_[1] =~ tr&lt;.&gt;&lt;&gt; ) {

        require Time::HiRes;
        return Time::HiRes::alarm( $_[1] );
    }

    return alarm( $_[1] );    # This is the total length of the alarm since new()
}

sub get_remaining {
    my $self = shift or die;
    return ( $self-&gt;{'local_alarm_length'} - ( time - $self-&gt;{'local_alarm_start'} ) );
}

sub DESTROY {
    my $self = shift or return;

    return if Cpanel::Destruct::in_dangerous_global_destruction();

    $SIG{'ALRM'} = $self-&gt;{'previous_action'} || 'DEFAULT';

    alarm(0);

    return if ( !$self-&gt;{'previous_alarm_time_left'} );

    my $new_alarm = int( $self-&gt;{'previous_alarm_time_left'} - ( time() - $self-&gt;{'creation_time'} ) );

    ( $new_alarm &lt;= 0 ) ? alarm(1) : alarm($new_alarm);
}

1;

} # --- END Cpanel/Alarm.pm


{ # --- BEGIN Cpanel/Config/Sources.pm
package Cpanel::Config::Sources;


use strict;
use warnings;

# use Cpanel::Config::LoadConfig ();

use constant MY_IPV4_ENDPOINT =&gt; 'https://myip.cpanel.net/v1.0/';

our $cpsources_conf_file = '/etc/cpsources.conf';


sub get_source {
    my ($want_key) = @_;

    return unless length $want_key;
    my $conf = loadcpsources();
    return $conf-&gt;{$want_key} // '';
}

my $load_cpsources_cache;

sub set_cache {
    return $load_cpsources_cache = shift;
}

sub loadcpsources {
    if ( !$load_cpsources_cache ) {

        if ( ${^GLOBAL_PHASE} &amp;&amp; ${^GLOBAL_PHASE} eq 'START' &amp;&amp; lc($0) ne '-e' ) {
            die q[FATAL: loadcpsources is called during compile time. You should postpone this call.];
        }

        my $update_default = 'httpupdate.cpanel.net';
        my %sources        = (
            'NEWS'               =&gt; 'web.cpanel.net',
            'RSYNC'              =&gt; 'rsync.cpanel.net',
            'HTTPUPDATE'         =&gt; $update_default,
            'MYIP'               =&gt; MY_IPV4_ENDPOINT,               # URL to determine a local IP's public IP (1to1 NAT)
            'STORE_SERVER_URL'   =&gt; 'https://store.cpanel.net',
            'TICKETS_SERVER_URL' =&gt; 'https://account.cpanel.net',
            'VERIFY_URL'         =&gt; 'https://verify.cpanel.net',
            'MANAGE2_URL'        =&gt; 'https://manage2.cpanel.net',
        );

        if ( -e $cpsources_conf_file ) {
            Cpanel::Config::LoadConfig::loadConfig( $cpsources_conf_file, \%sources );
        }

        foreach my $key ( keys %sources ) {
            next if ( !defined $sources{$key} );
            $sources{$key} =~ s/^\s+//;
            $sources{$key} =~ s/\s+$//;
        }

        $load_cpsources_cache = \%sources;
    }

    return wantarray ? %$load_cpsources_cache : $load_cpsources_cache;
}


1;

} # --- END Cpanel/Config/Sources.pm


{ # --- BEGIN Cpanel/ArrayFunc/Shuffle.pm
package Cpanel::ArrayFunc::Shuffle;


use strict;
use warnings;


sub shuffle {
    my $element_to_shuffle = scalar @{ $_[0] };
    my $element_to_exchange;
    while ( $element_to_shuffle-- ) {
        $element_to_exchange = int rand( $element_to_shuffle + 1 );
        @{ $_[0] }[ $element_to_shuffle, $element_to_exchange ] = @{ $_[0] }[ $element_to_exchange, $element_to_shuffle ];
    }
    return $_[0];
}
1;

} # --- END Cpanel/ArrayFunc/Shuffle.pm


{ # --- BEGIN Cpanel/JSON/FailOK.pm
package Cpanel::JSON::FailOK;


use strict;
use warnings;

sub LoadJSONModule {
    local $@;

    my $load_ok = eval {
        local $SIG{'__DIE__'};     # Suppress spewage as we may be reading an invalid cache
        local $SIG{'__WARN__'};    # and since failure is ok to throw it away
        require Cpanel::JSON;      # PPI NO PARSE - FailOK
        1;
    };

    if ( !$load_ok &amp;&amp; !$ENV{'CPANEL_BASE_INSTALL'} &amp;&amp; index( $^X, '/usr/local/cpanel' ) == 0 ) {
        warn $@;
    }

    return $load_ok ? 1 : 0;
}

sub LoadFile {
    return undef if !$INC{'Cpanel/JSON.pm'};

    return eval {
        local $SIG{'__DIE__'};         # Suppress spewage as we may be reading an invalid cache
        local $SIG{'__WARN__'};        # and since failure is ok to throw it away
        Cpanel::JSON::LoadFile(@_);    # PPI NO PARSE - inc check above
    };
}
1;

} # --- END Cpanel/JSON/FailOK.pm


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


use strict;


our $VERSION = '1.4';

our $cpanel_users       = '/var/cpanel/users';
our $cpanel_users_cache = '/var/cpanel/users.cache';

our $backup_config_touchfile     = '/var/cpanel/config/backups/metadata_disabled';
our $backup_config_touchfile_dir = '/var/cpanel/config/backups/';
our $backup_config               = '/var/cpanel/backups/config';

our $cpanel_config_file          = '/var/cpanel/cpanel.config';
our $cpanel_config_cache_file    = '/var/cpanel/cpanel.config.cache';
our $cpanel_config_defaults_file = '/usr/local/cpanel/etc/cpanel.config';
our $features_cache_dir          = &quot;/var/cpanel/features.cache&quot;;

our $BASE_INSTALL_IN_PROGRESS_FILE = '/root/installer.lock';

our $CPSRVD_CHECK_CPLISC_FILE = q{/var/cpanel/cpsrvd_check_license};

our $ROOT_CPANEL_HOMEDIR = '/var/cpanel/userhomes/cpanel';

our $RESELLERS_FILE             = '/var/cpanel/resellers';
our $RESELLERS_NAMESERVERS_FILE = '/var/cpanel/resellers-nameservers';
our $ACCOUNTING_LOG_FILE        = '/var/cpanel/accounting.log';
our $FEATURES_DIR               = '/var/cpanel/features';
our $BANDWIDTH_LIMIT_DIR        = '/var/cpanel/bwlimited';
our $CUSTOM_PERL_MODULES_DIR    = '/var/cpanel/perl';
our $PACKAGES_DIR;    #defined below

our $DEDICATED_IPS_FILE       = '/etc/domainips';
our $DELEGATED_IPS_DIR        = '/var/cpanel/dips';
our $MAIN_IPS_DIR             = '/var/cpanel/mainips';
our $RESERVED_IPS_FILE        = '/etc/reservedips';
our $RESERVED_IP_REASONS_FILE = '/etc/reservedipreasons';
our $IP_ADDRESS_POOL_FILE     = '/etc/ipaddrpool';
our $ACL_LISTS_DIR            = '/var/cpanel/acllists';

our $OUTGOING_MAIL_SUSPENDED_USERS_FILE    = '/etc/outgoing_mail_suspended_users';
our $OUTGOING_MAIL_HOLD_USERS_FILE         = '/etc/outgoing_mail_hold_users';
our $TRUEUSEROWNERS_FILE                   = '/etc/trueuserowners';
our $TRUEUSERDOMAINS_FILE                  = '/etc/trueuserdomains';
our $USERDOMAINS_FILE                      = '/etc/userdomains';
our $DBOWNERS_FILE                         = '/etc/dbowners';
our $DOMAINUSERS_FILE                      = '/etc/domainusers';
our $LOCALDOMAINS_FILE                     = '/etc/localdomains';
our $REMOTEDOMAINS_FILE                    = '/etc/remotedomains';
our $SECONDARYMX_FILE                      = '/etc/secondarymx';
our $MANUALMX_FILE                         = '/etc/manualmx';
our $USERBWLIMITS_FILE                     = '/etc/userbwlimits';
our $MAILIPS_FILE                          = '/etc/mailips';
our $MAILHELO_FILE                         = '/etc/mailhelo';
our $NEIGHBOR_NETBLOCKS_FILE               = '/etc/neighbor_netblocks';
our $CPANEL_MAIL_NETBLOCKS_FILE            = '/etc/cpanel_mail_netblocks';
our $GREYLIST_TRUSTED_NETBLOCKS_FILE       = '/etc/greylist_trusted_netblocks';
our $GREYLIST_COMMON_MAIL_PROVIDERS_FILE   = '/etc/greylist_common_mail_providers';
our $RECENT_RECIPIENT_MAIL_SERVER_IPS_FILE = '/etc/recent_recipient_mail_server_ips';
our $DEMOUSERS_FILE                        = '/etc/demousers';

our $APACHE_CONFIG_DIR          = '/var/cpanel/conf/apache';
our $APACHE_PRIMARY_VHOSTS_FILE = '/var/cpanel/conf/apache/primary_virtual_hosts.conf';

our $MYSQL_CNF = '/etc/my.cnf';

our $SERVICEAUTH_DIR      = '/var/cpanel/serviceauth';
our $DORMANT_SERVICES_DIR = '/var/cpanel/dormant_services';

our $DOMAIN_KEYS_ROOT = '/var/cpanel/domain_keys';

our $USER_NOTIFICATIONS_DIR = '/var/cpanel/user_notifications';

our $DATABASES_INFO_DIR = '/var/cpanel/databases';

our $CPANEL_ROOT  = '/usr/local/cpanel';
our $MAILMAN_ROOT = &quot;$CPANEL_ROOT/3rdparty/mailman&quot;;

our $FPM_CONFIG_ROOT = &quot;/var/cpanel/php-fpm.d&quot;;
our $FPM_ROOT        = &quot;/var/cpanel/php-fpm&quot;;

our $MAILMAN_LISTS_DIR = &quot;$MAILMAN_ROOT/lists&quot;;

our $MAILMAN_USER = 'mailman';

our $FTP_PASSWD_DIR     = '/etc/proftpd';
our $FTP_SYMLINKS_DIR   = '/etc/pure-ftpd';
our $VALIASES_DIR       = '/etc/valiases';
our $VDOMAINALIASES_DIR = '/etc/vdomainaliases';
our $VFILTERS_DIR       = '/etc/vfilters';

our $JAILSHELL_PATH = '/usr/local/cpanel/bin/jailshell';

our @COMMONDOMAINS_FILES = qw{/usr/local/cpanel/etc/commondomains /var/cpanel/commondomains};

our $BANDWIDTH_DIRECTORY             = '/var/cpanel/bandwidth';
our $BANDWIDTH_CACHE_DIRECTORY       = '/var/cpanel/bandwidth.cache';
our $BANDWIDTH_USAGE_CACHE_DIRECTORY = '/var/cpanel/bwusagecache';

our $TEMPLATE_COMPILE_DIR = '/var/cpanel/template_compiles';

our $DOVECOT_SNI_CONF = '/etc/dovecot/sni.conf';

our $DOVECOT_SSL_CONF = '/etc/dovecot/ssl.conf';
our $DOVECOT_SSL_KEY  = '/etc/dovecot/ssl/dovecot.key';
our $DOVECOT_SSL_CRT  = '/etc/dovecot/ssl/dovecot.crt';

our $GOOGLE_AUTH_TEMPFILE_PREFIX = '/var/cpanel/backups/google_oauth_tempfile_';

our $APACHE_LOGFILE_CLEANUP_QUEUE = '/var/cpanel/apache_logfile_cleanup.json';

our $SKIP_REPO_SETUP_FLAG = '/var/cpanel/skip-repo-setup';

our $ACCOUNT_ENHANCEMENTS_DIR          = '/var/cpanel/account_enhancements';
our $ACCOUNT_ENHANCEMENTS_CONFIG_DIR   = $Cpanel::ConfigFiles::ACCOUNT_ENHANCEMENTS_DIR . '/config';
our $ACCOUNT_ENHANCEMENTS_INSTALL_FILE = $Cpanel::ConfigFiles::ACCOUNT_ENHANCEMENTS_CONFIG_DIR . '/installed.json';

BEGIN {
    $PACKAGES_DIR = '/var/cpanel/packages';
}


1;

} # --- END Cpanel/ConfigFiles.pm


{ # --- BEGIN Cpanel/CPAN/I18N/LangTags.pm


package Cpanel::CPAN::I18N::LangTags;
use strict;

require Exporter;
our @ISA       = qw(Exporter);
our @EXPORT    = qw();
our @EXPORT_OK = qw(is_language_tag same_language_tag
  extract_language_tags super_languages
  similarity_language_tag is_dialect_of
  locale2language_tag alternate_language_tags
  encode_language_tag panic_languages
  implicate_supers
  implicate_supers_strictly
);
our %EXPORT_TAGS = ( 'ALL' =&gt; \@EXPORT_OK );
our %Panic;
our $VERSION = &quot;0.35&quot;;

sub uniq { my %seen; return grep( !( $seen{$_}++ ), @_ ); }    # a util function


sub is_language_tag {


    my ($tag) = lc( $_[0] );

    return 0 if $tag eq &quot;i&quot; or $tag eq &quot;x&quot;;


    return $tag =~ /^(?:  # First subtag
         [xi] | [a-z]{2,3}
      )
      (?:  # Subtags thereafter
         -           # separator
         [a-z0-9]{1,8}  # subtag
      )*
    $/xs ? 1 : 0;
}


sub extract_language_tags {


    my ($text) = $_[0] =~ m/(.+)/    # to make for an untainted result
      ? $1
      : '';

    return grep( !m/^[ixIX]$/s,      # 'i' and 'x' aren't good tags
        $text =~ m/
      \b
      (?:  # First subtag
         [iIxX] | [a-zA-Z]{2,3}
      )
      (?:  # Subtags thereafter
         -           # separator
         [a-zA-Z0-9]{1,8}  # subtag
      )*
      \b
    /xsg
    );
}


sub same_language_tag {
    my $el1 = &amp;encode_language_tag( $_[0] );
    return 0 unless defined $el1;


    return $el1 eq &amp;encode_language_tag( $_[1] ) ? 1 : 0;
}


sub similarity_language_tag {
    my $lang1 = &amp;encode_language_tag( $_[0] );
    my $lang2 = &amp;encode_language_tag( $_[1] );


    return undef if !defined($lang1) and !defined($lang2);
    return 0 if !defined($lang1) or !defined($lang2);

    my @l1_subtags = split( '-', $lang1 );
    my @l2_subtags = split( '-', $lang2 );
    my $similarity = 0;

    while ( @l1_subtags and @l2_subtags ) {
        if ( shift(@l1_subtags) eq shift(@l2_subtags) ) {
            ++$similarity;
        }
        else {
            last;
        }
    }
    return $similarity;
}


sub is_dialect_of {

    my $lang1 = &amp;encode_language_tag( $_[0] );
    my $lang2 = &amp;encode_language_tag( $_[1] );

    return undef if !defined($lang1) and !defined($lang2);
    return 0 if !defined($lang1) or !defined($lang2);

    return 1 if $lang1 eq $lang2;
    return 0 if length($lang1) &lt; length($lang2);

    $lang1 .= '-';
    $lang2 .= '-';
    return ( substr( $lang1, 0, length($lang2) ) eq $lang2 ) ? 1 : 0;
}


sub super_languages {
    my $lang1 = $_[0];
    return () unless defined($lang1) &amp;&amp; &amp;is_language_tag($lang1);

    $lang1 =~ s/^nb\b/no-bok/i;            # yes, backwards
    $lang1 =~ s/^nn\b/no-nyn/i;            # yes, backwards
    $lang1 =~ s/^[ix](-hakka\b)/zh$1/i;    # goes the right way

    my @l1_subtags = split( '-', $lang1 );


    my @supers = ();
    foreach my $bit (@l1_subtags) {
        push @supers, scalar(@supers) ? ( $supers[-1] . '-' . $bit ) : $bit;
    }
    pop @supers if @supers;
    shift @supers if @supers &amp;&amp; $supers[0] =~ m&lt;^[iIxX]$&gt;s;
    return reverse @supers;
}


sub locale2language_tag {
    my $lang = $_[0] =~ m/(.+)/    # to make for an untainted result
      ? $1
      : '';

    return $lang if &amp;is_language_tag($lang);    # like &quot;en&quot;

    $lang =~ tr&lt;_&gt;&lt;-&gt;;                          # &quot;en_US&quot; -&gt; en-US
    $lang =~ s&lt;(?:[\.\@][-_a-zA-Z0-9]+)+$&gt;&lt;&gt;s;  # &quot;en_US.ISO8859-1&quot; -&gt; en-US

    return $lang if &amp;is_language_tag($lang);

    return;
}


sub encode_language_tag {


    my ($tag) = $_[0] || return undef;
    return undef unless &amp;is_language_tag($tag);

    $tag =~ s/^iw\b/he/i;                  # Hebrew
    $tag =~ s/^in\b/id/i;                  # Indonesian
    $tag =~ s/^cre\b/cr/i;                 # Cree
    $tag =~ s/^jw\b/jv/i;                  # Javanese
    $tag =~ s/^[ix]-lux\b/lb/i;            # Luxemburger
    $tag =~ s/^[ix]-navajo\b/nv/i;         # Navajo
    $tag =~ s/^ji\b/yi/i;                  # Yiddish
    $tag =~ s/^[ix]-hakka\b/zh-hakka/i;    # Hakka
    $tag =~ s/^nb\b/no-bok/i;              # BACKWARDS for Bokmal
    $tag =~ s/^nn\b/no-nyn/i;              # BACKWARDS for Nynorsk

    $tag =~ s/^[xiXI]-//s;


    return &quot;~&quot; . uc($tag);
}


my %alt = qw( i x   x i   I X   X I );

sub alternate_language_tags {
    my $tag = $_[0];
    return () unless &amp;is_language_tag($tag);

    my @em;    # push 'em real goood!


    if ( $tag =~ m/^[ix]-hakka\b(.*)/i ) {
        push @em, &quot;zh-hakka$1&quot;;
    }
    elsif ( $tag =~ m/^zh-hakka\b(.*)/i ) {
        push @em, &quot;x-hakka$1&quot;, &quot;i-hakka$1&quot;;

    }
    elsif ( $tag =~ m/^he\b(.*)/i ) {
        push @em, &quot;iw$1&quot;;
    }
    elsif ( $tag =~ m/^iw\b(.*)/i ) {
        push @em, &quot;he$1&quot;;

    }
    elsif ( $tag =~ m/^in\b(.*)/i ) {
        push @em, &quot;id$1&quot;;
    }
    elsif ( $tag =~ m/^id\b(.*)/i ) {
        push @em, &quot;in$1&quot;;

    }
    elsif ( $tag =~ m/^[ix]-lux\b(.*)/i ) {
        push @em, &quot;lb$1&quot;;
    }
    elsif ( $tag =~ m/^lb\b(.*)/i ) {
        push @em, &quot;i-lux$1&quot;, &quot;x-lux$1&quot;;

    }
    elsif ( $tag =~ m/^[ix]-navajo\b(.*)/i ) {
        push @em, &quot;nv$1&quot;;
    }
    elsif ( $tag =~ m/^nv\b(.*)/i ) {
        push @em, &quot;i-navajo$1&quot;, &quot;x-navajo$1&quot;;

    }
    elsif ( $tag =~ m/^yi\b(.*)/i ) {
        push @em, &quot;ji$1&quot;;
    }
    elsif ( $tag =~ m/^ji\b(.*)/i ) {
        push @em, &quot;yi$1&quot;;

    }
    elsif ( $tag =~ m/^nb\b(.*)/i ) {
        push @em, &quot;no-bok$1&quot;;
    }
    elsif ( $tag =~ m/^no-bok\b(.*)/i ) {
        push @em, &quot;nb$1&quot;;

    }
    elsif ( $tag =~ m/^nn\b(.*)/i ) {
        push @em, &quot;no-nyn$1&quot;;
    }
    elsif ( $tag =~ m/^no-nyn\b(.*)/i ) {
        push @em, &quot;nn$1&quot;;
    }

    push @em, $alt{$1} . $2 if $tag =~ /^([XIxi])(-.+)/;
    return @em;
}


{


    my @panic = (    # MUST all be lowercase!

        'sv' =&gt; [qw(nb no da nn)],
        'da' =&gt; [qw(nb no sv nn)],    # I guess
        [qw(no nn nb)], [qw(no nn nb sv da)],
        'is' =&gt; [qw(da sv no nb nn)],
        'fo' =&gt; [qw(da is no nb nn sv)],    # I guess

        'pt' =&gt; [qw(es ca it fr)],    # Portuguese, Spanish, Catalan, Italian, French
        'ca' =&gt; [qw(es pt it fr)],
        'es' =&gt; [qw(ca it fr pt)],
        'it' =&gt; [qw(es fr ca pt)],
        'fr' =&gt; [qw(es it ca pt)],

        [
            qw(
              as bn gu kn ks kok ml mni mr ne or pa sa sd te ta ur
              )
        ] =&gt; 'hi',

        'hi' =&gt; [qw(bn pa as or)],


        ( [qw(ru be uk)] ) x 2,    # Russian, Belarusian, Ukranian
        'sr' =&gt; 'hr', 'hr' =&gt; 'sr',    # Serb + Croat
        'cs' =&gt; 'sk', 'sk' =&gt; 'cs',    # Czech + Slovak

        'ms' =&gt; 'id', 'id' =&gt; 'ms',    # Malay + Indonesian

        'et' =&gt; 'fi', 'fi' =&gt; 'et',    # Estonian + Finnish


    );
    my ( $k, $v );
    while (@panic) {
        ( $k, $v ) = splice( @panic, 0, 2 );
        foreach my $k ( ref($k) ? @$k : $k ) {
            foreach my $v ( ref($v) ? @$v : $v ) {
                push @{ $Panic{$k} ||= [] }, $v unless $k eq $v;
            }
        }
    }
}


sub panic_languages {

    my ( @out, %seen );
    foreach my $t (@_) {
        next unless $t;
        next if $seen{$t}++;    # so we don't return it or hit it again
        push @out, @{ $Panic{ lc $t } || next };
    }
    return grep !$seen{$_}++, @out, 'en';
}


sub implicate_supers {
    my @languages = grep is_language_tag($_), @_;
    my %seen_encoded;
    foreach my $lang (@languages) {
        $seen_encoded{ Cpanel::CPAN::I18N::LangTags::encode_language_tag($lang) } = 1;
    }

    my (@output_languages);
    foreach my $lang (@languages) {
        push @output_languages, $lang;
        foreach my $s ( Cpanel::CPAN::I18N::LangTags::super_languages($lang) ) {

            last if $seen_encoded{ Cpanel::CPAN::I18N::LangTags::encode_language_tag($s) };
            push @output_languages, $s;
        }
    }
    return uniq(@output_languages);

}

sub implicate_supers_strictly {
    my @tags = grep is_language_tag($_), @_;
    return uniq( @_, map super_languages($_), @_ );
}

1;

} # --- END Cpanel/CPAN/I18N/LangTags.pm


{ # --- BEGIN Cpanel/CPAN/I18N/LangTags/Detect.pm


package Cpanel::CPAN::I18N::LangTags::Detect;
use strict;

use vars qw( @ISA $VERSION $MATCH_SUPERS $USING_LANGUAGE_TAGS
  $USE_LITERALS $MATCH_SUPERS_TIGHTLY);

BEGIN {
    unless ( defined &amp;DEBUG ) {
        *DEBUG = sub () { 0 }
    }
}


$VERSION = &quot;1.04&quot;;
@ISA     = ();
# use Cpanel::CPAN::I18N::LangTags ();

sub _uniq { my %seen; return grep( !( $seen{$_}++ ), @_ ); }

sub _normalize {
    my (@languages) =
      map lc($_),
      grep $_,
      map { ; $_, Cpanel::CPAN::I18N::LangTags::alternate_language_tags($_) } @_;
    return _uniq(@languages) if wantarray;
    return $languages[0];
}


sub detect () { return __PACKAGE__-&gt;ambient_langprefs; }


sub ambient_langprefs {    # always returns things untainted
    my $base_class = $_[0];

    return $base_class-&gt;http_accept_langs
      if length( $ENV{'REQUEST_METHOD'} || '' );    # I'm a CGI

    my @languages;

    foreach my $envname (qw( LANGUAGE LC_ALL LC_MESSAGES LANG )) {
        next unless $ENV{$envname};
        DEBUG and print &quot;Noting \$$envname: $ENV{$envname}\n&quot;;
        push @languages, map Cpanel::CPAN::I18N::LangTags::locale2language_tag($_),


          split m/[,:]/, $ENV{$envname};
        last;    # first one wins
    }

    if ( $ENV{'IGNORE_WIN32_LOCALE'} ) {

    }
    elsif ( &amp;_try_use('Win32::Locale') ) {

        push @languages, Win32::Locale::get_language() || ''
          if defined &amp;Win32::Locale::get_language;
    }
    return _normalize @languages;
}


sub http_accept_langs {

    no integer;

    my $in = ( @_ &gt; 1 ) ? $_[1] : $ENV{'HTTP_ACCEPT_LANGUAGE'};


    return () unless defined $in and length $in;

    $in =~ s/\([^\)]*\)//g;    # nix just about any comment

    if ( $in =~ m/^\s*([a-zA-Z][-a-zA-Z]+)\s*$/s ) {

        return _normalize $1;
    }
    elsif ( $in =~ m/^\s*[a-zA-Z][-a-zA-Z]+(?:\s*,\s*[a-zA-Z][-a-zA-Z]+)*\s*$/s ) {

        return _normalize( $in =~ m/([a-zA-Z][-a-zA-Z]+)/g );
    }


    $in =~ s/\s+//g;    # Yes, we can just do without the WS!
    my @in = $in =~ m/([^,]+)/g;
    my %pref;

    my $q;
    foreach my $tag (@in) {
        next unless $tag =~ m/^([a-zA-Z][-a-zA-Z]+)
        (?:
         ;q=
         (
          \d*   # a bit too broad of a RE, but so what.
          (?:
            \.\d+
          )?
         )
        )?
       $
      /sx
          ;
        $q = ( defined $2 and length $2 ) ? $2 : 1;

        push @{ $pref{$q} }, lc $1;
    }

    return _normalize(

        map @{ $pref{$_} },
        sort { $b &lt;=&gt; $a }
          keys %pref
    );
}


my %tried = ();


sub _try_use {    # Basically a wrapper around &quot;require Modulename&quot;
    return $tried{ $_[0] } if exists $tried{ $_[0] };    # memoization

    my $module = $_[0];                                  # ASSUME sane module name!
    {
        no strict 'refs';
        return ( $tried{$module} = 1 )
          if %{ $module . &quot;::Lexicon&quot; }
          or @{ $module . &quot;::ISA&quot; };

    }

    print &quot; About to use $module ...\n&quot; if DEBUG;
    {
        local $SIG{'__DIE__'};
        eval &quot;require $module&quot;;    # used to be &quot;use $module&quot;, but no point in that.
    }
    if ($@) {
        print &quot;Error using $module \: $@\n&quot; if DEBUG &gt; 1;
        return $tried{$module} = 0;
    }
    else {
        print &quot; OK, $module is used\n&quot; if DEBUG;
        return $tried{$module} = 1;
    }
}

1;

} # --- END Cpanel/CPAN/I18N/LangTags/Detect.pm


{ # --- BEGIN Cpanel/CPAN/Locale/Maketext.pm
package Cpanel::CPAN::Locale::Maketext;


use strict;
our @ISA;
our $VERSION;
our $MATCH_SUPERS;
our $USING_LANGUAGE_TAGS;
our $USE_LITERALS;
our $MATCH_SUPERS_TIGHTLY;

use constant IS_ASCII =&gt; ord('A') == 65;

BEGIN {
    unless ( defined &amp;DEBUG ) {
        *DEBUG = sub () { 0 }
    }
}


$VERSION = '1.13_89';
$VERSION = eval $VERSION;
@ISA     = ();

$MATCH_SUPERS         = 1;
$MATCH_SUPERS_TIGHTLY = 1;
$USING_LANGUAGE_TAGS  = 1;
my $FORCE_REGEX_LAZY = '';


$USE_LITERALS = 1 unless defined $USE_LITERALS;


my %isa_scan = ();
my %isa_ones = ();


sub quant {
    my ( $handle, $num, @forms ) = @_;

    return $num if @forms == 0;    # what should this mean?
    return $forms[2] if @forms &gt; 2 and $num == 0;    # special zeroth case

    return ( $handle-&gt;numf($num) . ' ' . $handle-&gt;numerate( $num, @forms ) );

}

sub numerate {

    my ( $handle, $num, @forms ) = @_;
    my $s = ( $num == 1 );

    return '' unless @forms;
    if ( @forms == 1 ) {    # only the headword form specified
        return $s ? $forms[0] : ( $forms[0] . 's' );    # very cheap hack.
    }
    else {                                              # sing and plural were specified
        return $s ? $forms[0] : $forms[1];
    }
}


sub numf {
    my ( $handle, $num ) = @_[ 0, 1 ];
    if ( $num &lt; 10_000_000_000 and $num &gt; -10_000_000_000 and $num == int($num) ) {
        $num += 0;                                      # Just use normal integer stringification.
    }
    else {
        $num = CORE::sprintf( '%G', $num );

    }
    while ( $num =~ s/$FORCE_REGEX_LAZY^([-+]?\d+)(\d{3})/$1,$2/os ) { 1 }    # right from perlfaq5

    $num =~ tr&lt;.,&gt;&lt;,.&gt; if ref($handle) and $handle-&gt;{'numf_comma'};

    return $num;
}

sub sprintf {
    no integer;
    my ( $handle, $format, @params ) = @_;
    return CORE::sprintf( $format, @params );

}


use integer;    # vroom vroom... applies to the whole rest of the module

sub language_tag {
    my $it = ref( $_[0] ) || $_[0];
    return undef unless $it =~ m/$FORCE_REGEX_LAZY([^':]+)(?:::)?$/os;
    $it = lc($1);
    $it =~ tr&lt;_&gt;&lt;-&gt;;
    return $it;
}

sub encoding {
    my $it = $_[0];
    return (
        ( ref($it) &amp;&amp; $it-&gt;{'encoding'} )
          || 'iso-8859-1'    # Latin-1
    );
}


sub fallback_languages { return ( 'i-default', 'en', 'en-US' ) }

sub fallback_language_classes { return () }


sub fail_with {              # an actual attribute method!
    my ( $handle, @params ) = @_;
    return unless ref($handle);
    $handle-&gt;{'fail'} = $params[0] if @params;
    return $handle-&gt;{'fail'};
}


sub blacklist {
    my ( $handle, @methods ) = @_;

    unless ( defined $handle-&gt;{'blacklist'} ) {
        no strict 'refs';

        $handle-&gt;{'blacklist'} = {
            map { $_ =&gt; 1 } (
                qw/
                  blacklist
                  encoding
                  fail_with
                  failure_handler_auto
                  fallback_language_classes
                  fallback_languages
                  get_handle
                  init
                  language_tag
                  maketext
                  new
                  whitelist
                  /, grep { substr( $_, 0, 1 ) eq '_' } keys %{ __PACKAGE__ . &quot;::&quot; }
            ),
        };
    }

    if ( scalar @methods ) {
        $handle-&gt;{'blacklist'} = { %{ $handle-&gt;{'blacklist'} }, map { $_ =&gt; 1 } @methods };
    }

    delete $handle-&gt;{'_external_lex_cache'};
    return;
}

sub whitelist {
    my ( $handle, @methods ) = @_;
    if ( scalar @methods ) {
        if ( defined $handle-&gt;{'whitelist'} ) {
            $handle-&gt;{'whitelist'} = { %{ $handle-&gt;{'whitelist'} }, map { $_ =&gt; 1 } @methods };
        }
        else {
            $handle-&gt;{'whitelist'} = { map { $_ =&gt; 1 } @methods };
        }
    }

    delete $handle-&gt;{'_external_lex_cache'};
    return;
}


sub failure_handler_auto {


    my $handle = shift;
    my $phrase = shift;

    $handle-&gt;{'failure_lex'} ||= {};
    my $lex = $handle-&gt;{'failure_lex'};

    my $value = $lex-&gt;{$phrase} ||= ( $phrase !~ tr/[// ? \&quot;$phrase&quot; : $handle-&gt;_compile($phrase) );

    return ${$value} if ref($value) eq 'SCALAR';
    return $value if ref($value) ne 'CODE';
    {
        local $SIG{'__DIE__'};
        eval { $value = &amp;$value( $handle, @_ ) };
    }

    if ($@) {
        my $err = $@;

        $err =~ s{\s+at\s+\(eval\s+\d+\)\s+line\s+(\d+)\.?\n?}
                 {\n in bracket code [compiled line $1],}s;

        require Carp;
        Carp::croak(&quot;Error in maketexting \&quot;$phrase\&quot;:\n$err as used&quot;);

    }
    else {
        return $value;
    }
}


sub new {

    my $class = ref( $_[0] ) || $_[0];
    my $handle = bless {}, $class;
    $handle-&gt;blacklist;
    $handle-&gt;init;
    return $handle;
}

sub init { return }    # no-op


sub maketext {

    unless ( @_ &gt; 1 ) {
        require Carp;
        Carp::croak('maketext requires at least one parameter');
    }

    my ( $handle, $phrase ) = splice( @_, 0, 2 );
    unless ( defined($handle) &amp;&amp; defined($phrase) ) {
        require Carp;
        Carp::confess('No handle/phrase');
    }

    my $value;
    if ( exists $handle-&gt;{'_external_lex_cache'}{$phrase} ) {
        DEBUG and warn &quot;* Using external lex cache version of \&quot;$phrase\&quot;\n&quot;;
        $value = $handle-&gt;{'_external_lex_cache'}{$phrase};
    }
    else {
        my $ns = ref($handle) || $handle;
        foreach my $h_r ( @{ $isa_scan{$ns} || $handle-&gt;_lex_refs } ) {
            DEBUG and warn &quot;* Looking up \&quot;$phrase\&quot; in $h_r\n&quot;;
            if ( defined( $value = $h_r-&gt;{$phrase} ) ) {    # Minimize looking at $h_r as much as possible as an expensive tied hash to CDB_File
                DEBUG and warn &quot;  Found \&quot;$phrase\&quot; in $h_r\n&quot;;
                unless ( ref $value ) {

                    if ( !length $value ) {
                        DEBUG and warn &quot; value is undef or ''&quot;;
                        if ( $isa_ones{&quot;$h_r&quot;} ) {
                            DEBUG and warn &quot; $ns ($h_r) is Onesided and \&quot;$phrase\&quot; entry is undef or ''\n&quot;;
                            $value = $phrase;
                        }
                    }


                    if ( $handle-&gt;{'use_external_lex_cache'} ) {

                        $handle-&gt;{'_external_lex_cache'}{$phrase} = $value = ( $value !~ tr/[// ? \&quot;$value&quot; : $handle-&gt;_compile($value) );
                    }
                    else {

                        $h_r-&gt;{$phrase} = $value = ( $value !~ tr/[// ? \&quot;$value&quot; : $handle-&gt;_compile($value) );
                    }
                }
                last;
            }

            elsif ( substr( $phrase, 0, 1 ) ne '_' and ( $handle-&gt;{'use_external_lex_cache'} ? ( exists $handle-&gt;{'_external_lex_cache'}{'_AUTO'} ? $handle-&gt;{'_external_lex_cache'}{'_AUTO'} : $h_r-&gt;{'_AUTO'} ) : $h_r-&gt;{'_AUTO'} ) ) {

                DEBUG and warn &quot;  Automaking \&quot;$phrase\&quot; into $h_r\n&quot;;
                if ( $handle-&gt;{'use_external_lex_cache'} ) {

                    $handle-&gt;{'_external_lex_cache'}{$phrase} = $value = ( $phrase !~ tr/[// ? \&quot;$phrase&quot; : $handle-&gt;_compile($phrase) );
                }
                else {

                    $h_r-&gt;{$phrase} = $value = ( $phrase !~ tr/[// ? \&quot;$phrase&quot; : $handle-&gt;_compile($phrase) );
                }
                last;
            }
            DEBUG &gt; 1 and print &quot;  Not found in $h_r, nor automakable\n&quot;;

        }

        if ( !defined($value) ) {
            delete $handle-&gt;{'_external_lex_cache'}{$phrase};

            DEBUG and warn &quot;! Lookup of \&quot;$phrase\&quot; in/under &quot;, ref($handle) || $handle, &quot; fails.\n&quot;;
            if ( ref($handle) and $handle-&gt;{'fail'} ) {
                DEBUG and warn &quot;WARNING0: maketext fails looking for &lt;$phrase&gt;\n&quot;;
                my $fail;
                if ( ref( $fail = $handle-&gt;{'fail'} ) eq 'CODE' ) {    # it's a sub reference
                    return &amp;{$fail}( $handle, $phrase, @_ );

                }
                else {                                                 # It's a method name
                    return $handle-&gt;$fail( $phrase, @_ );

                }
            }
            else {
                require Carp;

                Carp::croak(&quot;maketext doesn't know how to say:\n$phrase\nas needed&quot;);
            }
        }

    }

    if ( ref($value) eq 'SCALAR' ) {
        return $$value;
    }
    elsif ( ref($value) ne 'CODE' ) {
        return $value;
    }

    local $@;
    {
        local $SIG{'__DIE__'};
        return eval { &amp;$value( $handle, @_ ) } unless $@;
    }

    my $err = $@;

    $err =~ s{\s+at\s+\(eval\s+\d+\)\s+line\s+(\d+)\.?\n?}
    {\n in bracket code [compiled line $1],}s;

    require Carp;

    Carp::croak(&quot;Error in maketexting \&quot;$phrase\&quot;:\n$err as used&quot;);

}


sub get_handle {    # This is a constructor and, yes, it CAN FAIL.

    my ( $base_class, @languages ) = @_;
    $base_class = ref($base_class) || $base_class;

    my $load_alternate_language_tags = 0;


    if (@languages) {
        DEBUG and warn 'Lgs@', __LINE__, ': ', map( &quot;&lt;$_&gt;&quot;, @languages ), &quot;\n&quot;;
        $load_alternate_language_tags = 1 if $USING_LANGUAGE_TAGS;    # An explicit language-list was given!
    }
    else {
        @languages = $base_class-&gt;_ambient_langprefs;
    }

    my %seen;
    foreach my $module_name ( map { $base_class . '::' . $_ } @languages ) {
        next
          if !length $module_name                                     # sanity
          || $seen{$module_name}++                                    # Already been here, and it was no-go
          || $module_name =~ tr{/-}{}
          || !&amp;_try_use($module_name);                                # Try to use() it, but can't it.
        return ( $module_name-&gt;new );                                 # Make it!
    }

    if ($load_alternate_language_tags) {
        require Cpanel::CPAN::I18N::LangTags;
        @languages =
          map { ; $_, Cpanel::CPAN::I18N::LangTags::alternate_language_tags($_) }

          map Cpanel::CPAN::I18N::LangTags::locale2language_tag($_),

          @languages;
        DEBUG and warn 'Lgs@', __LINE__, ': ', map( &quot;&lt;$_&gt;&quot;, @languages ), &quot;\n&quot;;
    }
    @languages = $base_class-&gt;_langtag_munging(@languages);

    foreach my $module_name ( map { $base_class . '::' . $_ } @languages ) {
        next
          if !length $module_name     # sanity
          || $seen{$module_name}++    # Already been here, and it was no-go
          || $module_name =~ tr{/-}{}
          || !&amp;_try_use($module_name);    # Try to use() it, but can't it.
        return ( $module_name-&gt;new );     # Make it!
    }

    return undef;                         # Fail!
}


sub _langtag_munging {
    my ( $base_class, @languages ) = @_;


    DEBUG and warn 'Lgs1: ', map( &quot;&lt;$_&gt;&quot;, @languages ), &quot;\n&quot;;

    if ($USING_LANGUAGE_TAGS) {
        require Cpanel::CPAN::I18N::LangTags;

        DEBUG and warn 'Lgs@', __LINE__, ': ', map( &quot;&lt;$_&gt;&quot;, @languages ), &quot;\n&quot;;
        @languages = $base_class-&gt;_add_supers(@languages);

        push @languages, Cpanel::CPAN::I18N::LangTags::panic_languages(@languages);
        DEBUG and warn &quot;After adding panic languages:\n&quot;, ' Lgs@', __LINE__, ': ', map( &quot;&lt;$_&gt;&quot;, @languages ), &quot;\n&quot;;

        push @languages, $base_class-&gt;fallback_languages;

        DEBUG and warn 'Lgs@', __LINE__, ': ', map( &quot;&lt;$_&gt;&quot;, @languages ), &quot;\n&quot;;

        @languages =    # final bit of processing to turn them into classname things
          map {
            my $it = $_;               # copy
            $it =~ tr&lt;-A-Z&gt;&lt;_a-z&gt;;     # lc, and turn - to _
            $it =~ tr&lt;_a-z0-9&gt;&lt;&gt;cd;    # remove all but a-z0-9_
            $it;
          } @languages;
        DEBUG and warn &quot;Nearing end of munging:\n&quot;, ' Lgs@', __LINE__, ': ', map( &quot;&lt;$_&gt;&quot;, @languages ), &quot;\n&quot;;
    }
    else {
        DEBUG and warn &quot;Bypassing language-tags.\n&quot;, ' Lgs@', __LINE__, ': ', map( &quot;&lt;$_&gt;&quot;, @languages ), &quot;\n&quot;;
    }

    DEBUG and warn &quot;Before adding fallback classes:\n&quot;, ' Lgs@', __LINE__, ': ', map( &quot;&lt;$_&gt;&quot;, @languages ), &quot;\n&quot;;

    push @languages, $base_class-&gt;fallback_language_classes;


    DEBUG and warn &quot;Finally:\n&quot;, ' Lgs@', __LINE__, ': ', map( &quot;&lt;$_&gt;&quot;, @languages ), &quot;\n&quot;;

    return @languages;
}


sub _ambient_langprefs {
    require Cpanel::CPAN::I18N::LangTags::Detect;
    return Cpanel::CPAN::I18N::LangTags::Detect::detect();
}


sub _add_supers {
    my ( $base_class, @languages ) = @_;

    if ( !$MATCH_SUPERS ) {

        DEBUG and warn &quot;Bypassing any super-matching.\n&quot;, ' Lgs@', __LINE__, ': ', map( &quot;&lt;$_&gt;&quot;, @languages ), &quot;\n&quot;;

    }
    elsif ($MATCH_SUPERS_TIGHTLY) {
        require Cpanel::CPAN::I18N::LangTags;
        DEBUG and warn &quot;Before adding new supers tightly:\n&quot;, ' Lgs@', __LINE__, ': ', map( &quot;&lt;$_&gt;&quot;, @languages ), &quot;\n&quot;;
        @languages = Cpanel::CPAN::I18N::LangTags::implicate_supers(@languages);
        DEBUG and warn &quot;After adding new supers tightly:\n&quot;, ' Lgs@', __LINE__, ': ', map( &quot;&lt;$_&gt;&quot;, @languages ), &quot;\n&quot;;

    }
    else {
        require Cpanel::CPAN::I18N::LangTags;
        DEBUG and warn &quot;Before adding supers to end:\n&quot;, ' Lgs@', __LINE__, ': ', map( &quot;&lt;$_&gt;&quot;, @languages ), &quot;\n&quot;;
        @languages = Cpanel::CPAN::I18N::LangTags::implicate_supers_strictly(@languages);
        DEBUG and warn &quot;After adding supers to end:\n&quot;, ' Lgs@', __LINE__, ': ', map( &quot;&lt;$_&gt;&quot;, @languages ), &quot;\n&quot;;
    }

    return @languages;
}


my %tried = ();


sub _try_use {    # Basically a wrapper around &quot;require Modulename&quot;
    return $tried{ $_[0] } if exists $tried{ $_[0] };    # memoization

    my $module = $_[0];                                  # ASSUME sane module name!
    {
        no strict 'refs';
        return ( $tried{$module} = 1 )
          if ( %{ $module . '::Lexicon' } or @{ $module . '::ISA' } );

    }

    DEBUG and warn &quot; About to use $module ...\n&quot;;
    {
        local $SIG{'__DIE__'};
        eval &quot;require $module&quot;;                          # used to be &quot;use $module&quot;, but no point in that.
    }
    if ($@) {
        DEBUG and warn &quot;Error using $module \: $@\n&quot;;
        return $tried{$module} = 0;
    }
    else {
        DEBUG and warn &quot; OK, $module is used\n&quot;;
        return $tried{$module} = 1;
    }
}


sub _lex_refs {    # report the lexicon references for this handle's class
    no strict 'refs';
    no warnings 'once';
    my $class = ref( $_[0] ) || $_[0];
    DEBUG and warn &quot;Lex refs lookup on $class\n&quot;;
    return $isa_scan{$class} if exists $isa_scan{$class};    # memoization!

    my @lex_refs;
    my $seen_r = ref( $_[1] ) ? $_[1] : {};

    if ( defined( *{ $class . '::Lexicon' }{'HASH'} ) ) {
        push @lex_refs, *{ $class . '::Lexicon' }{'HASH'};
        $isa_ones{&quot;$lex_refs[-1]&quot;} = defined ${ $class . '::Onesided' } &amp;&amp; ${ $class . '::Onesided' } ? 1 : 0;
        DEBUG and warn '%' . $class . '::Lexicon contains ', scalar( keys %{ $class . '::Lexicon' } ), &quot; entries\n&quot;;
    }

    foreach my $superclass ( @{ $class . '::ISA' } ) {
        DEBUG and warn &quot; Super-class search into $superclass\n&quot;;
        next if $seen_r-&gt;{$superclass}++;
        push @lex_refs, @{ &amp;_lex_refs( $superclass, $seen_r ) };    # call myself
    }

    $isa_scan{$class} = \@lex_refs;                                 # save for next time
    return \@lex_refs;
}

sub clear_isa_scan { %isa_scan = (); return; }                      # end on a note of simplicity!


BEGIN {
}


sub _compile {


    return \&quot;$_[1]&quot; if $_[1] !~ tr/[//;

    my ( $handle, $call_count, $big_pile, @c, @code ) = ( $_[0], 0, '', '' );
    {

        my ( $in_group, $m, @params ) = (0);    # scratch

        my $under_one = $_[1];                  # There are taint issues using regex on $_ - perlbug 60378,27344
        while (
            $under_one =~                       # Iterate over chunks.
            m/\G(
                [^\~\[\]]+  # non-~[] stuff
                |
                ~.       # ~[, ~], ~~, ~other
                |
                \[          # [ presumably opening a group
                |
                \]          # ] presumably closing a group
                |
                ~           # terminal ~ ?
                |
                $
            )/xgs
        ) {
            DEBUG &gt; 2 and warn qq{  &quot;$1&quot;\n};

            if ( $1 eq '[' or $1 eq '' ) {    # &quot;[&quot; or end
                if ($in_group) {
                    if ( $1 eq '' ) {
                        $handle-&gt;_die_pointing( $under_one, 'Unterminated bracket group' );
                    }
                    else {
                        $handle-&gt;_die_pointing( $under_one, 'You can\'t nest bracket groups' );
                    }
                }
                else {
                    if ( $1 eq '' ) {
                        DEBUG &gt; 2 and warn &quot;   [end-string]\n&quot;;
                    }
                    else {
                        $in_group = 1;
                    }
                    die &quot;How come \@c is empty?? in &lt;$under_one&gt;&quot; unless @c;    # sanity
                    if ( length $c[-1] ) {

                        $big_pile .= $c[-1];
                        if (
                            $USE_LITERALS and (
                                IS_ASCII
                                ? $c[-1] !~ tr/\x20-\x7E//c

                                : $c[-1] !~ m/$FORCE_REGEX_LAZY[^ !&quot;\#\$%&amp;'()*+,\-.\/0-9:;&lt;=&gt;?\@A-Z[\\\]^_`a-z{|}~\x07]/os

                            )
                        ) {

                            $c[-1] =~ s/'/\\'/g if $c[-1] =~ tr{'}{};
                            push @code, q{ '} . $c[-1] . &quot;',\n&quot;;
                            $c[-1] = '';    # reuse this slot
                        }
                        else {
                            $c[-1] =~ s/\\\\/\\/g if $c[-1] =~ tr{\\}{};
                            push @code, ' $c[' . $#c . &quot;],\n&quot;;
                            push @c,    '';                      # new chunk
                        }
                    }

                }

            }
            elsif ( $1 eq ']' ) {                                # &quot;]&quot;
                if ($in_group) {
                    $in_group = 0;

                    DEBUG &gt; 2 and warn &quot;   --Closing group [$c[-1]]\n&quot;;


                    if ( !length( $c[-1] ) or $c[-1] !~ tr/ \t\r\n\f//c ) {
                        DEBUG &gt; 2 and warn &quot;   -- (Ignoring)\n&quot;;
                        $c[-1] = '';                             # reset out chink
                        next;
                    }

                    ( $m, @params ) = split( /,/, $c[-1], -1 );    # was /\s*,\s*/

                    if (IS_ASCII) {    # ASCII, etc
                        foreach ( $m, @params ) { tr/\x7F/,/ }
                    }
                    else {             # EBCDIC (1047, 0037, POSIX-BC)
                        foreach ( $m, @params ) { tr/\x07/,/ }
                    }

                    if ( $m eq '_1' or $m eq '_2' or $m eq '_3' or $m eq '_*' or ( substr( $m, 0, 1 ) eq '_' &amp;&amp; $m =~ m/^_(-?\d+)$/s ) ) {

                        unshift @params, $m;
                        $m = '';
                    }
                    elsif ( $m eq '*' ) {
                        $m = 'quant';    # &quot;*&quot; for &quot;times&quot;: &quot;4 cars&quot; is 4 times &quot;cars&quot;
                    }
                    elsif ( $m eq '#' ) {
                        $m = 'numf';     # &quot;#&quot; for &quot;number&quot;: [#,_1] for &quot;the number _1&quot;
                    }

                    if ( $m eq '' ) {

                        push @code, ' (';
                    }
                    elsif (
                        $m !~ tr{a-zA-Z0-9_}{}c    # does not contain non-word characters
                        &amp;&amp; !$handle-&gt;{'blacklist'}{$m}
                        &amp;&amp; ( !defined $handle-&gt;{'whitelist'} || $handle-&gt;{'whitelist'}{$m} )

                    ) {
                        push @code, ' $_[0]-&gt;' . $m . '(';
                    }
                    else {

                        $handle-&gt;_die_pointing(
                            $under_one,
                            &quot;Can't use \&quot;$m\&quot; as a method name in bracket group&quot;,
                            2 + length( $c[-1] )
                        );
                    }

                    pop @c;    # we don't need that chunk anymore
                    ++$call_count;

                    foreach my $p (@params) {
                        if ( $p eq '_*' ) {

                            $code[-1] .= ' @_[1 .. $#_], ';

                        }
                        elsif ( substr( $p, 0, 1 ) eq '_' &amp;&amp; ( $p eq '_1' || $p eq '_2' || $p eq '_3' || $p =~ m/^_-?\d+$/s ) ) {

                            $code[-1] .= '$_[' . ( 0 + substr( $p, 1 ) ) . '], ';
                        }
                        elsif (
                            $USE_LITERALS and (
                                IS_ASCII
                                ? $p !~ tr/\x20-\x7E//c

                                : $p !~ m/$FORCE_REGEX_LAZY[^ !&quot;\#\$%&amp;'()*+,\-.\/0-9:;&lt;=&gt;?\@A-Z[\\\]^_`a-z{|}~\x07]/os

                            )
                        ) {

                            $p =~ s/'/\\'/g if $p =~ tr{'}{};
                            $code[-1] .= q{'} . $p . q{', };
                        }
                        else {

                            push @c,    $p;
                            push @code, ' $c[' . $#c . '], ';
                        }
                    }
                    $code[-1] .= &quot;),\n&quot;;

                    push @c, '';
                }
                else {
                    $handle-&gt;_die_pointing( $under_one, q{Unbalanced ']'} );
                }

            }
            elsif ( substr( $1, 0, 1 ) ne '~' ) {

                if ( $1 =~ tr{\\}{} ) {
                    my $text = $1;
                    $text =~ s/\\/\\\\/g;
                    $c[-1] .= $text;
                }
                else {
                    $c[-1] .= $1;
                }

            }
            elsif ( $1 eq '~~' ) {    # &quot;~~&quot;
                $c[-1] .= '~';

            }
            elsif ( $1 eq '~[' ) {    # &quot;~[&quot;
                $c[-1] .= '[';

            }
            elsif ( $1 eq '~]' ) {    # &quot;~]&quot;
                $c[-1] .= ']';

            }
            elsif ( $1 eq '~,' ) {    # &quot;~,&quot;
                if ($in_group) {

                    if (IS_ASCII) {    # ASCII etc
                        $c[-1] .= &quot;\x7F&quot;;
                    }
                    else {             # EBCDIC (cp 1047, 0037, POSIX-BC)
                        $c[-1] .= &quot;\x07&quot;;
                    }
                }
                else {
                    $c[-1] .= '~,';
                }

            }
            elsif ( $1 eq '~' ) {      # possible only at string-end, it seems.
                $c[-1] .= '~';

            }
            else {

                my $text = $1;
                $text =~ s/\\/\\\\/g if $text =~ tr{\\}{};
                $c[-1] .= $text;
            }
        }
    }

    if ($call_count) {
        undef $big_pile;    # Well, nevermind that.
    }
    else {

        return \$big_pile;
    }

    die q{Last chunk isn't null??} if @c and length $c[-1];    # sanity
    DEBUG and warn scalar(@c), &quot; chunks under closure\n&quot;;
    my $sub;
    if ( @code == 0 ) {                                        # not possible?
        DEBUG and warn &quot;Empty code\n&quot;;
        return \'';
    }
    elsif ( scalar @code &gt; 1 ) {                               # most cases, presumably!
        $sub = &quot;sub { join '', map { defined \$_ ? \$_ : '' } @code }&quot;;
    }
    else {
        $sub = &quot;sub { $code[0] }&quot;;
    }
    DEBUG and warn $sub;
    my $code;
    {
       use strict;
       $code = eval $sub;
       die &quot;$@ while evalling&quot; . $sub if $@;                      # Should be impossible.
    }
    return $code;
}


sub _die_pointing {

    my $target = shift;
    $target = ref($target) || $target;                         # class name

    my $i = index( $_[0], &quot;\n&quot; );

    my $pointy;
    my $pos = pos( $_[0] ) - ( defined( $_[2] ) ? $_[2] : 0 ) - 1;
    if ( $pos &lt; 1 ) {
        $pointy = &quot;^=== near there\n&quot;;
    }
    else {                                                     # we need to space over
        my $first_tab = index( $_[0], &quot;\t&quot; );
        if ( $pos &gt; 2 and ( -1 == $first_tab or $first_tab &gt; pos( $_[0] ) ) ) {

            $pointy = ( '=' x $pos ) . &quot;^ near there\n&quot;;
        }
        else {

            $pointy = substr( $_[0], 0, $pos );
            $pointy =~ tr/\t //cd;

            $pointy .= &quot;^=== near there\n&quot;;
        }
    }

    my $errmsg = &quot;$_[1], in\:\n$_[0]&quot;;

    if ( $i == -1 ) {

        $errmsg .= &quot;\n&quot; . $pointy;
    }
    elsif ( $i == ( length( $_[0] ) - 1 ) ) {

        $errmsg .= $pointy;
    }
    else {

    }
    require Carp;
    Carp::croak(&quot;$errmsg via $target, as used&quot;);
}


1;

} # --- END Cpanel/CPAN/Locale/Maketext.pm


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


use strict;
use warnings;


sub normalize_tag {
    my ($tag) = @_;
    return if !defined $tag;
    $tag =~ tr/A-Z/a-z/;
    $tag =~ tr{\r\n \t\f}{}d;
    if ( $tag =~ tr{a-z0-9}{}c ) {
        $tag =~ s{[^a-z0-9]+$}{};    # I18N::LangTags::locale2language_tag() does not allow trailing '_'
        $tag =~ tr{a-z0-9}{_}c;
    }

    if ( length $tag &gt; 8 ) {
        while ( $tag =~ s/([^_]{8})([^_])/$1\_$2/ ) { }    # I18N::LangTags::locale2language_tag() only allows parts between 1 and 8 character
    }
    return $tag;
}

1;

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


{ # --- BEGIN Cpanel/CPAN/Locales/Legacy.pm
package Cpanel::CPAN::Locales::Legacy;

use strict;


sub numf {
    my ( $self, $always_return ) = @_;
    my $class = ref($self) ? ref($self) : $self;
    $always_return ||= 0;
    $self-&gt;{'language_data'}{'misc_info'}{'cldr_formats'}{'_decimal_format_group'}   = '' if !defined $self-&gt;{'language_data'}{'misc_info'}{'cldr_formats'}{'_decimal_format_group'};
    $self-&gt;{'language_data'}{'misc_info'}{'cldr_formats'}{'_decimal_format_decimal'} = '' if !defined $self-&gt;{'language_data'}{'misc_info'}{'cldr_formats'}{'_decimal_format_decimal'};

    if ( !$self-&gt;{'language_data'}{'misc_info'}{'cldr_formats'}{'_decimal_format_group'} || !$self-&gt;{'language_data'}{'misc_info'}{'cldr_formats'}{'_decimal_format_decimal'} ) {
        if ($always_return) {
            if ( $self-&gt;{'language_data'}{'misc_info'}{'cldr_formats'}{'_decimal_format_group'} || !$self-&gt;{'language_data'}{'misc_info'}{'cldr_formats'}{'_decimal_format_decimal'} ) {
                return 2 if $self-&gt;{'language_data'}{'misc_info'}{'cldr_formats'}{'_decimal_format_group'} eq '.';
                return 1;
            }
            elsif ( !$self-&gt;{'language_data'}{'misc_info'}{'cldr_formats'}{'_decimal_format_group'} || $self-&gt;{'language_data'}{'misc_info'}{'cldr_formats'}{'_decimal_format_decimal'} ) {
                return 2 if $self-&gt;{'language_data'}{'misc_info'}{'cldr_formats'}{'_decimal_format_decimal'} eq ',';
                return 1;
            }
            else {
                return 1;
            }
        }
    }

    if ( $self-&gt;{'language_data'}{'misc_info'}{'cldr_formats'}{'decimal'} eq &quot;\#\,\#\#0\.\#\#\#&quot; ) {
        if ( $self-&gt;{'language_data'}{'misc_info'}{'cldr_formats'}{'_decimal_format_group'} eq ',' &amp;&amp; $self-&gt;{'language_data'}{'misc_info'}{'cldr_formats'}{'_decimal_format_decimal'} eq '.' ) {
            return 1;
        }
        elsif ( $self-&gt;{'language_data'}{'misc_info'}{'cldr_formats'}{'_decimal_format_group'} eq '.' &amp;&amp; $self-&gt;{'language_data'}{'misc_info'}{'cldr_formats'}{'_decimal_format_decimal'} eq ',' ) {
            return 2;
        }
    }
    elsif ( $always_return &amp;&amp; $self-&gt;{'language_data'}{'misc_info'}{'cldr_formats'}{'_decimal_format_group'} &amp;&amp; $self-&gt;{'language_data'}{'misc_info'}{'cldr_formats'}{'_decimal_format_decimal'} ) {
        return 2 if $self-&gt;{'language_data'}{'misc_info'}{'cldr_formats'}{'_decimal_format_decimal'} eq ',';
        return 2 if $self-&gt;{'language_data'}{'misc_info'}{'cldr_formats'}{'_decimal_format_group'} eq '.';
        return 1;
    }

    return [
        $self-&gt;{'language_data'}{'misc_info'}{'cldr_formats'}{'decimal'},
        $self-&gt;{'language_data'}{'misc_info'}{'cldr_formats'}{'_decimal_format_group'},
        $self-&gt;{'language_data'}{'misc_info'}{'cldr_formats'}{'_decimal_format_decimal'},
    ];
}

1;

} # --- END Cpanel/CPAN/Locales/Legacy.pm


{ # --- BEGIN Cpanel/CPAN/Locales/DB/LocaleDisplayPattern/Tiny.pm
package Cpanel::CPAN::Locales::DB::LocaleDisplayPattern::Tiny;

use strict;


$Cpanel::CPAN::Locales::DB::LocaleDisplayPattern::Tiny::VERSION = '0.09';

$Cpanel::CPAN::Locales::DB::LocaleDisplayPattern::Tiny::cldr_version = '2.0';

my %locale_display_lookup = (
    'ksh' =&gt; '{0} en {1}',
    'ja'  =&gt; '{0}({1})',
    'zh'  =&gt; '{0}（{1}）',
    'ko'  =&gt; '{0}({1})',
);

sub get_locale_display_pattern {
    if ( exists $locale_display_lookup{ $_[0] } ) {
        return $locale_display_lookup{ $_[0] };
    }
    else {
        require Cpanel::CPAN::Locales;
        my ($l) = Cpanel::CPAN::Locales::split_tag( $_[0] );
        if ( $l ne $_[0] ) {
            return $locale_display_lookup{$l} if exists $locale_display_lookup{$l};
        }
        return &quot;\{0\}\ \(\{1\}\)&quot;;
    }
}

1;

} # --- END Cpanel/CPAN/Locales/DB/LocaleDisplayPattern/Tiny.pm


{ # --- BEGIN Cpanel/CPAN/Locales/DB/CharacterOrientation/Tiny.pm
package Cpanel::CPAN::Locales::DB::CharacterOrientation::Tiny;

use strict;


$Cpanel::CPAN::Locales::DB::CharacterOrientation::Tiny::VERSION = '0.09';

$Cpanel::CPAN::Locales::DB::CharacterOrientation::Tiny::cldr_version = '2.0';

my %rtl = (
    'ur' =&gt; '',
    'ku' =&gt; '',
    'he' =&gt; '',
    'fa' =&gt; '',
    'ps' =&gt; '',
    'ar' =&gt; '',
);

sub get_orientation {
    if ( exists $rtl{ $_[0] } ) {
        return 'right-to-left';
    }
    else {
        require Cpanel::CPAN::Locales;
        my ($l) = Cpanel::CPAN::Locales::split_tag( $_[0] );
        if ( $l ne $_[0] ) {
            return 'right-to-left' if exists $rtl{$l};
        }
        return 'left-to-right';
    }
}

1;

} # --- END Cpanel/CPAN/Locales/DB/CharacterOrientation/Tiny.pm


{ # --- BEGIN Cpanel/CPAN/Locales/Compile.pm
package Cpanel::CPAN::Locales::Compile;

use strict;
use warnings;

sub plural_rule_string_to_code {
    my ( $plural_rule_string, $return ) = @_;
    if ( !defined $return ) {
        $return = 1;
    }


    my %m;
    while ( $plural_rule_string =~ m/mod ([0-9]+)/g ) {

        $m{$1} = &quot;( (\$_[0] % $1) + (\$_[0]-int(\$_[0])) )&quot;;
    }

    my $perl_code = &quot;sub { if (&quot;;

    for my $or ( split /\s+or\s+/i, $plural_rule_string ) {
        my $and_exp;
        for my $and ( split /\s+and\s+/i, $or ) {
            my $copy = $and;
            my $n    = '$_[0]';

            $copy =~ s/ ?n is not / $n \!\= /g;
            $copy =~ s/ ?n is / $n \=\= /g;

            $copy =~ s/ ?n mod ([0-9]+) is not / $m{$1} \!\= /g;
            $copy =~ s/ ?n mod ([0-9]+) is / $m{$1} \=\= /g;

            $copy =~ s/ ?n not in ([0-9]+)\s*\.\.\s*([0-9]+) ?/ int\($n\) \!\= $n \|\| $n &lt; $1 \|\| $n \&gt; $2 /g;
            $copy =~ s/ ?n mod ([0-9]+) not in ([0-9]+)\s*\.\.\s*([0-9]+) ?/ int\($n\) \!\= $n \|\| $m{$1} &lt; $2 \|\| $m{$1} \&gt; $3 /g;

            $copy =~ s/ ?n not within ([0-9]+)\s*\.\.\s*([0-9]+) ?/ \($n &lt; $1 \|\| $n &gt; $2\) /g;
            $copy =~ s/ ?n mod ([0-9]+) not within ([0-9]+)\s*\.\.\s*([0-9]+) ?/ \($m{$1} &lt; $2 \|\| $m{$1} &gt; $3\) /g;

            $copy =~ s/ ?n in ([0-9]+)\s*\.\.\s*([0-9]+) ?/ int\($n\) \=\= $n \&amp;\&amp; $n \&gt;\= $1 \&amp;\&amp; $n \&lt;\= $2 /g;
            $copy =~ s/ ?n mod ([0-9]+) in ([0-9]+)\s*\.\.\s*([0-9]+) ?/ int\($n\) \=\= $n \&amp;\&amp; $m{$1} \&gt;\= $2 \&amp;\&amp; $m{$1} \&lt;\= $3 /g;

            $copy =~ s/ ?n within ([0-9]+)\s*\.\.\s*([0-9]+) ?/ $n \&gt;\= $1 \&amp;\&amp; $n \&lt;\= $2 /g;
            $copy =~ s/ ?n mod ([0-9]+) within ([0-9]+)\s*\.\.\s*([0-9]+) ?/ $m{$1} \&gt;\= $2 \&amp;\&amp; $m{$1} \&lt;\= $3 /g;

            if ( $copy eq $and ) {
                require Carp;
                Carp::carp(&quot;Unknown plural rule syntax&quot;);
                return;
            }
            else {
                $and_exp .= &quot;($copy) &amp;&amp; &quot;;
            }
        }
        $and_exp =~ s/\s+\&amp;\&amp;\s*$//;

        if ($and_exp) {
            $perl_code .= &quot; ($and_exp) || &quot;;
        }
    }
    $perl_code =~ s/\s+\|\|\s*$//;

    $perl_code .= &quot;) { return '$return'; } return;}&quot;;

    return $perl_code;
}

sub plural_rule_string_to_javascript_code {
    my ( $plural_rule_string, $return ) = @_;
    my $perl = plural_rule_string_to_code( $plural_rule_string, $return );
    $perl =~ s/sub \{ /function (n) \{/;
    $perl =~ s/\$_\[0\]/n/g;
    $perl =~ s/ \(n \% ([0-9]+)\) \+ \(n-int\(n\)\) /n % $1/g;
    $perl =~ s/int\(/parseInt\(/g;
    return $perl;
}

1;

} # --- END Cpanel/CPAN/Locales/Compile.pm


{ # --- BEGIN Cpanel/CPAN/Locales.pm
package Cpanel::CPAN::Locales;

use strict;

# use Cpanel::Locale::Utils::Normalize ();

$Cpanel::CPAN::Locales::VERSION      = 0.30_1;    # change in POD
$Cpanel::CPAN::Locales::cldr_version = '2.0';     # change in POD
my $FORCE_REGEX_LAZY = '';

*normalize_tag = *Cpanel::Locale::Utils::Normalize::normalize_tag;

my %singleton_stash;

sub get_cldr_version {
    return $Cpanel::CPAN::Locales::cldr_version;
}

sub new {
    my ( $class, $tag ) = @_;
    $tag = normalize_tag($tag) || 'en';

    if ( !exists $singleton_stash{$tag} ) {

        my $locale = {
            'locale' =&gt; $tag,
        };

        if ( my $soft = tag_is_soft_locale($tag) ) {

            $locale-&gt;{'soft_locale_fallback'} = $soft;
            $tag = $soft;
        }

        my $inc_class = ref($class) ? ref($class) : $class;
        $inc_class =~ s{\:\:|\'}{/}g;    # per Module::Want::get_inc_key()

        if ( !exists $INC{&quot;$inc_class/DB/Language/$tag.pm&quot;} ) {
            local $SIG{'__DIE__'};       # cpanel specific: ensure a benign eval does not trigger cpsrvd's DIE handler (may be made moot by internal case 50857)
            eval &quot;require $class\::DB::Language::$tag&quot; || return;    # Module::Want::have_mod(&quot;$class\::DB::Language::$tag&quot;);
        }

        my ( $language, $territory ) = split_tag( $locale-&gt;{'locale'} );

        $locale-&gt;{'language'} = $language;
        {

            BEGIN { $^H = 0; };                                      # cheap no strict to allow for ref copy

            $locale-&gt;{'language_data'} = {
                'VERSION'      =&gt; \${&quot;$class\::DB::Language::$tag\::VERSION&quot;},
                'cldr_version' =&gt; \${&quot;$class\::DB::Language::$tag\::cldr_version&quot;},
                'misc_info'    =&gt; \%{&quot;$class\::DB::Language::$tag\::misc_info&quot;},
            };
        }
        $locale-&gt;{'territory'} = $territory;

        $locale-&gt;{'misc'}{'list_quote_mode'} = 'none';

        $singleton_stash{$tag} = bless $locale, $class;
    }

    return $singleton_stash{$tag};
}

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

    my $tag       = $self-&gt;{'locale'};
    my $class     = scalar ref $self;
    my $inc_class = $class;
    $inc_class =~ s{\:\:|\'}{/}g;    # per Module::Want::get_inc_key()

    if ( !exists $INC{&quot;$inc_class/DB/Territory/$tag.pm&quot;} ) {
        local $SIG{'__DIE__'};       # cpanel specific: ensure a benign eval does not trigger cpsrvd's DIE handler (may be made moot by internal case 50857)
        eval &quot;require $class\::DB::Territory::$tag&quot; || return;    # Module::Want::have_mod(&quot;$class\::DB::Language::$tag&quot;);
    }
    {

        BEGIN { $^H = 0; };                                       # cheap no strict to allow for ref copy

        $self-&gt;{'territory_data'} = {
            'VERSION'      =&gt; \${&quot;$class\::DB::Territory::$tag\::VERSION&quot;},
            'cldr_version' =&gt; \${&quot;$class\::DB::Territory::$tag\::cldr_version&quot;},
            'code_to_name' =&gt; \%{&quot;$class\::DB::Territory::$tag\::code_to_name&quot;},
        };
    }
    return 1;
}

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

    my $tag       = $self-&gt;{'locale'};
    my $class     = scalar ref $self;
    my $inc_class = $class;
    $inc_class =~ s{\:\:|\'}{/}g;    # per Module::Want::get_inc_key()

    if ( !exists $INC{&quot;$inc_class/DB/Language/code_to_name/$tag.pm&quot;} ) {
        local $SIG{'__DIE__'};       # cpanel specific: ensure a benign eval does not trigger cpsrvd's DIE handler (may be made moot by internal case 50857)
        eval &quot;require $class\::DB::Language::code_to_name::$tag&quot; || return;    # Module::Want::have_mod(&quot;$class\::DB::Language::$tag&quot;);
    }

    {

        BEGIN { $^H = 0; };                                                    # cheap no strict to allow for ref copy
        $self-&gt;{'language_data'}{'code_to_name'} = \%{&quot;$class\::DB::Language::$tag\::code_to_name&quot;};
    }

    return 1;
}


sub get_soft_locale_fallback {
    return $_[0]-&gt;{'soft_locale_fallback'} if $_[0]-&gt;{'soft_locale_fallback'};
    return;
}

sub get_locale { shift-&gt;{'locale'} }

sub get_territory { shift-&gt;{'territory'} }

sub get_language { shift-&gt;{'language'} }

sub get_native_language_from_code {
    my ( $self, $code, $always_return ) = @_;

    my $class = ref($self) ? ref($self) : $self;
    if ( !exists $self-&gt;{'native_data'} ) {
        local $SIG{'__DIE__'};                            # cpanel specific: ensure a benign eval does not trigger cpsrvd's DIE handler (may be made moot by internal case 50857)
        eval &quot;require $class\::DB::Native;&quot; || return;    # Module::Want::have_mod(&quot;$class\::DB::Native&quot;);
        {

            BEGIN { $^H = 0; };                           # cheap no strict to allow for ref copy

            $self-&gt;{'native_data'} = {
                'VERSION'      =&gt; \${&quot;$class\::DB::Native::VERSION&quot;},
                'cldr_version' =&gt; \${&quot;$class\::DB::Native::cldr_version&quot;},
                'code_to_name' =&gt; \%{&quot;$class\::DB::Native::code_to_name&quot;},
            };
        }
    }

    $code ||= $self-&gt;{'locale'};
    $code = normalize_tag($code);
    return if !defined $code;

    $always_return ||= 1 if $code eq $self-&gt;get_locale() &amp;&amp; $self-&gt;get_soft_locale_fallback();    # force $always_return under soft locale objects
    $always_return ||= 0;

    if ( exists $self-&gt;{'native_data'}{'code_to_name'}{$code} ) {
        return $self-&gt;{'native_data'}{'code_to_name'}{$code};
    }
    elsif ($always_return) {
        my ( $l, $t ) = split_tag($code);
        my $ln = $self-&gt;{'native_data'}{'code_to_name'}{$l};

        $self-&gt;_load_territory_data() if !$self-&gt;{'territory_data'};

        my $tn = defined $t ? $self-&gt;{'territory_data'}{'code_to_name'}{$t} : '';

        return $code if !$ln &amp;&amp; !$tn;

        if ( defined $t ) {
            my $tmp = Cpanel::CPAN::Locales-&gt;new($l);    # if we even get to this point: this is a singleton so it is cheap
            if ($tmp) {
                if ( $tmp-&gt;get_territory_from_code($t) ) {
                    $tn = $tmp-&gt;get_territory_from_code($t);
                }
            }
        }

        $ln ||= $l;
        $tn ||= $t;

        my $string = get_locale_display_pattern_from_code_fast($code) || $self-&gt;{'language_data'}{'misc_info'}{'cldr_formats'}{'locale'} || '{0} ({1})';

        substr( $string, index( $string, '{0}' ), 3, $ln ) while index( $string, '{0}' ) &gt; -1;
        substr( $string, index( $string, '{1}' ), 3, $tn ) while index( $string, '{1}' ) &gt; -1;

        return $string;
    }
    return;
}

sub numf {
    require Cpanel::CPAN::Locales::Legacy if !$INC{'Cpanel/CPAN/Locales/Legacy.pm'};
    *numf = *Cpanel::CPAN::Locales::Legacy::numf;
    goto \&amp;Cpanel::CPAN::Locales::Legacy::numf;
}

my $get_locale_display_pattern_from_code_fast = 0;

sub get_locale_display_pattern_from_code_fast {
    if ( !$get_locale_display_pattern_from_code_fast ) {
        $get_locale_display_pattern_from_code_fast++;
        require Cpanel::CPAN::Locales::DB::LocaleDisplayPattern::Tiny;
    }

    if ( @_ == 1 &amp;&amp; ref( $_[0] ) ) {
        return Cpanel::CPAN::Locales::DB::LocaleDisplayPattern::Tiny::get_locale_display_pattern( $_[0]-&gt;get_locale() );
    }
    return Cpanel::CPAN::Locales::DB::LocaleDisplayPattern::Tiny::get_locale_display_pattern( $_[-1] );    # last arg so it works as function or class method or object method
}

sub get_locale_display_pattern_from_code {
    my ( $self, $code, $always_return ) = @_;

    my $class = ref($self) ? ref($self) : $self;
    if ( !exists $self-&gt;{'locale_display_pattern_data'} ) {
        local $SIG{'__DIE__'};                                                                             # cpanel specific: ensure a benign eval does not trigger cpsrvd's DIE handler (may be made moot by internal case 50857)
        eval &quot;require $class\::DB::LocaleDisplayPattern;&quot; || return;                                       # Module::Want::have_mod(&quot;$class\::DB::LocaleDisplayPattern&quot;);

        {

            BEGIN { $^H = 0; };                                                                            # cheap no strict to allow for ref copy

            $self-&gt;{'locale_display_pattern_data'} = {
                'VERSION'         =&gt; \${&quot;$class\::DB::LocaleDisplayPattern::VERSION&quot;},
                'cldr_version'    =&gt; \${&quot;$class\::DB::LocaleDisplayPattern::cldr_version&quot;},
                'code_to_pattern' =&gt; \%{&quot;$class\::DB::LocaleDisplayPattern::code_to_pattern&quot;},
            };
        }
    }

    $code ||= $self-&gt;{'locale'};
    $code = normalize_tag($code);
    return if !defined $code;

    $always_return ||= 1 if $code eq $self-&gt;get_locale() &amp;&amp; $self-&gt;get_soft_locale_fallback();    # force $always_return under soft locale objects
    $always_return ||= 0;

    if ( exists $self-&gt;{'locale_display_pattern_data'}{'code_to_pattern'}{$code} ) {
        return $self-&gt;{'locale_display_pattern_data'}{'code_to_pattern'}{$code};
    }
    elsif ($always_return) {
        my ( $l, $t ) = split_tag($code);
        if ( exists $self-&gt;{'locale_display_pattern_data'}{'code_to_pattern'}{$l} ) {
            return $self-&gt;{'locale_display_pattern_data'}{'code_to_pattern'}{$l};
        }
        return '{0} ({1})';
    }
    return;
}

my $get_character_orientation_from_code_fast = 0;

sub get_character_orientation_from_code_fast {
    if ( !$get_character_orientation_from_code_fast ) {
        $get_character_orientation_from_code_fast++;
        require Cpanel::CPAN::Locales::DB::CharacterOrientation::Tiny;
    }

    if ( @_ == 1 &amp;&amp; ref( $_[0] ) ) {
        return Cpanel::CPAN::Locales::DB::CharacterOrientation::Tiny::get_orientation( $_[0]-&gt;get_locale() );
    }

    return Cpanel::CPAN::Locales::DB::CharacterOrientation::Tiny::get_orientation( $_[-1] );    # last arg so it works as function or class method or object method
}

sub get_character_orientation_from_code {
    my ( $self, $code, $always_return ) = @_;

    my $class = ref($self) ? ref($self) : $self;
    if ( !exists $self-&gt;{'character_orientation_data'} ) {
        local $SIG{'__DIE__'};                                                                  # cpanel specific: ensure a benign eval does not trigger cpsrvd's DIE handler (may be made moot by internal case 50857)
        eval &quot;require $class\::DB::CharacterOrientation;&quot; || return;                            # Module::Want::have_mod(&quot;$class\::DB::CharacterOrientation&quot;);
        {

            BEGIN { $^H = 0; };                                                                 # cheap no strict to allow for ref copy

            $self-&gt;{'character_orientation_data'} = {
                'VERSION'      =&gt; \${&quot;$class\::DB::CharacterOrientation::VERSION&quot;},
                'cldr_version' =&gt; \${&quot;$class\::DB::CharacterOrientation::cldr_version&quot;},
                'code_to_name' =&gt; \%{&quot;$class\::DB::CharacterOrientation::code_to_name&quot;},
            };
        }
    }

    $code ||= $self-&gt;{'locale'};
    $code = normalize_tag($code);
    return if !defined $code;

    $always_return ||= 1 if $code eq $self-&gt;get_locale() &amp;&amp; $self-&gt;get_soft_locale_fallback();    # force $always_return under soft locale objects
    $always_return ||= 0;

    if ( exists $self-&gt;{'character_orientation_data'}{'code_to_name'}{$code} ) {
        return $self-&gt;{'character_orientation_data'}{'code_to_name'}{$code};
    }
    elsif ($always_return) {
        my ( $l, $t ) = split_tag($code);
        if ( exists $self-&gt;{'character_orientation_data'}{'code_to_name'}{$l} ) {
            return $self-&gt;{'character_orientation_data'}{'code_to_name'}{$l};
        }
        return 'left-to-right';
    }
    return;
}

sub get_plural_form_categories {
    return @{ $_[0]-&gt;{'language_data'}{'misc_info'}{'plural_forms'}{'category_list'} };
}

sub supports_special_zeroth {
    return 1 if $_[0]-&gt;get_plural_form(0) eq 'other';
    return;
}

sub plural_category_count {
    return scalar( $_[0]-&gt;get_plural_form_categories() );
}

sub get_plural_form {
    my ( $self, $n, @category_values ) = @_;
    my $category;
    my $has_extra_for_zero = 0;

    my $abs_n = abs($n);    # negatives keep same category as positive

    if ( !$self-&gt;{'language_data'}{'misc_info'}{'plural_forms'}{'category_rules_function'} ) {
        $self-&gt;{'language_data'}{'misc_info'}{'plural_forms'}{'category_rules_function'} = Cpanel::CPAN::Locales::plural_rule_hashref_to_code( $self-&gt;{'language_data'}{'misc_info'}{'plural_forms'} );
        if ( !defined $self-&gt;{'language_data'}{'misc_info'}{'plural_forms'}{'category_rules_function'} ) {
            require Carp;
            Carp::carp(&quot;Could not determine plural logic.&quot;);
        }
    }

    $category = $self-&gt;{'language_data'}{'misc_info'}{'plural_forms'}{'category_rules_function'}-&gt;($abs_n);

    my @categories = $self-&gt;get_plural_form_categories();

    if ( !@category_values ) {

        @category_values = @categories;
    }
    else {
        my $cat_len = @categories;
        my $val_len = @category_values;
        if ( $val_len == ( $cat_len + 1 ) ) {
            $has_extra_for_zero++;
        }
        elsif ( $cat_len != $val_len &amp;&amp; $self-&gt;{'verbose'} ) {
            require Carp;
            Carp::carp(&quot;The number of given values ($val_len) does not match the number of categories ($cat_len).&quot;);
        }
    }

    if ( !defined $category ) {
        my $cat_idx = $has_extra_for_zero &amp;&amp; $abs_n != 0 ? -2 : -1;
        return wantarray ? ( $category_values[$cat_idx], $has_extra_for_zero &amp;&amp; $abs_n == 0 ? 1 : 0 ) : $category_values[$cat_idx];
    }
    else {
      GET_POSITION:
        my $cat_pos_in_list;
        my $index = -1;
      CATEGORY:
        for my $cat (@categories) {
            $index++;
            if ( $cat eq $category ) {
                $cat_pos_in_list = $index;
                last CATEGORY;
            }
        }

        if ( !defined $cat_pos_in_list &amp;&amp; $category ne 'other' ) {
            require Carp;
            Carp::carp(&quot;The category ($category) is not used by this locale.&quot;);
            $category = 'other';
            goto GET_POSITION;
        }
        elsif ( !defined $cat_pos_in_list ) {
            my $cat_idx = $has_extra_for_zero &amp;&amp; $abs_n != 0 ? -2 : -1;
            return wantarray ? ( $category_values[$cat_idx], $has_extra_for_zero &amp;&amp; $abs_n == 0 ? 1 : 0 ) : $category_values[$cat_idx];
        }
        else {
            if ( $has_extra_for_zero &amp;&amp; $category eq 'other' ) {    # and 'other' is at the end of the list? nah...  &amp;&amp; $cat_pos_in_list + 1 == $#category_values
                my $cat_idx = $has_extra_for_zero &amp;&amp; $abs_n == 0 ? -1 : $cat_pos_in_list;
                return wantarray ? ( $category_values[$cat_idx], $has_extra_for_zero &amp;&amp; $abs_n == 0 ? 1 : 0 ) : $category_values[$cat_idx];
            }
            else {
                return wantarray ? ( $category_values[$cat_pos_in_list], 0 ) : $category_values[$cat_pos_in_list];
            }
        }
    }
}

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

    my $cnt = 0;

    if ( exists $self-&gt;{'misc'}{'list_quote_mode'} &amp;&amp; $self-&gt;{'misc'}{'list_quote_mode'} ne 'none' ) {
        if ( $self-&gt;{'misc'}{'list_quote_mode'} eq 'all' ) {
            @{$items_ar} = ('') if @{$items_ar} == 0;

            for my $i ( 0 .. scalar( @{$items_ar} ) - 1 ) {
                $items_ar-&gt;[$i] = '' if !defined $items_ar-&gt;[$i];
                $items_ar-&gt;[$i] = $self-&gt;quote( $items_ar-&gt;[$i] );
                $cnt++;
            }
        }
        elsif ( $self-&gt;{'misc'}{'list_quote_mode'} eq 'some' ) {
            @{$items_ar} = ('') if @{$items_ar} == 0;

            for my $i ( 0 .. scalar( @{$items_ar} ) - 1 ) {
                $items_ar-&gt;[$i] = '' if !defined $items_ar-&gt;[$i];
                if ( $items_ar-&gt;[$i] eq '' || $items_ar-&gt;[$i] eq ' ' || $items_ar-&gt;[$i] eq &quot;\xc2\xa0&quot; ) {
                    $items_ar-&gt;[$i] = $self-&gt;quote( $items_ar-&gt;[$i] );
                    $cnt++;
                }
            }
        }
        else {
            require Carp;
            Carp::carp('$self-&gt;{misc}{list_quote_mode} is set to an unknown value');
        }
    }

    return $cnt;
}

sub get_list_and {
    my $self = shift;

    return $self-&gt;_get_list_joined(
        $self-&gt;{'language_data'}{'misc_info'}{'cldr_formats'}{'list'},
        @_,
    );
}

sub get_list_or {
    my $self = shift;

    return $self-&gt;_get_list_joined(
        $self-&gt;{'language_data'}{'misc_info'}{'cldr_formats'}{'list_or'},
        @_,
    );
}

sub _get_list_joined {
    my ( $self, $templates_hr, @items ) = @_;

    $self-&gt;_quote_get_list_items( \@items );

    return if !@items;
    return $items[0] if @items == 1;

    my $ix;    # used to cache index results in the following oneliner

    if ( @items == 2 ) {
        my $two = $templates_hr-&gt;{'2'};
        substr( $two, $ix, 3, $items[0] ) while ( $ix = index( $two, '{0}' ) ) &gt; -1;
        substr( $two, $ix, 3, $items[1] ) while ( $ix = index( $two, '{1}' ) ) &gt; -1;
        return $two;
    }
    else {
        for (@items) {
            next if !defined $_;
            substr( $_, $ix, 3, '__{__0__}__' ) while ( $ix = index( $_, '{0}' ) ) &gt; -1;
            substr( $_, $ix, 3, '__{__1__}__' ) while ( $ix = index( $_, '{1}' ) ) &gt; -1;
        }
        my $aggregate = $templates_hr-&gt;{'start'};
        substr( $aggregate, $ix, 3, $items[0] ) while ( $ix = index( $aggregate, '{0}' ) ) &gt; -1;
        substr( $aggregate, $ix, 3, $items[1] ) while ( $ix = index( $aggregate, '{1}' ) ) &gt; -1;

        for my $i ( 2 .. $#items ) {
            next if $i == $#items;
            my $middle = $templates_hr-&gt;{'middle'};
            substr( $middle, $ix, 3, $aggregate ) while ( $ix = index( $middle, '{0}' ) ) &gt; -1;
            my $item = defined $items[$i] ? $items[$i] : '';
            substr( $middle, $ix, 3, $item ) while ( $ix = index( $middle, '{1}' ) ) &gt; -1;
            $aggregate = $middle;
        }

        my $end = $templates_hr-&gt;{'end'};
        substr( $end, $ix, 3, $aggregate ) while ( $ix = index( $end, '{0}' ) ) &gt; -1;
        substr( $end, $ix, 3, $items[-1] ) while ( $ix = index( $end, '{1}' ) ) &gt; -1;

        substr( $end, $ix, 11, '{0}' ) while ( $ix = index( $end, '__{__0__}__' ) ) &gt; -1;
        substr( $end, $ix, 11, '{1}' ) while ( $ix = index( $end, '__{__1__}__' ) ) &gt; -1;

        return $end;
    }
}

sub quote {
    my ( $self, $value ) = @_;
    $value = '' if !defined $value;

    return $self-&gt;{'language_data'}{'misc_info'}{'delimiters'}{'quotation_start'} . $value . $self-&gt;{'language_data'}{'misc_info'}{'delimiters'}{'quotation_end'};
}

sub quote_alt {
    my ( $self, $value ) = @_;
    $value = '' if !defined $value;

    return $self-&gt;{'language_data'}{'misc_info'}{'delimiters'}{'alternate_quotation_start'} . $value . $self-&gt;{'language_data'}{'misc_info'}{'delimiters'}{'alternate_quotation_end'};
}

sub get_formatted_ellipsis_initial {
    my ( $self, $str ) = @_;
    my $pattern = $self-&gt;{'language_data'}{'misc_info'}{'cldr_formats'}{'ellipsis'}{'initial'} || '…{0}';
    substr( $pattern, index( $pattern, '{0}' ), 3, $str ) while index( $pattern, '{0}' ) &gt; -1;
    return $pattern;
}

sub get_formatted_ellipsis_medial {
    my ($self) = @_;    # my ($self, $first, $second) = @_;
    my $pattern = $self-&gt;{'language_data'}{'misc_info'}{'cldr_formats'}{'ellipsis'}{'medial'} || '{0}…{1}';

    substr( $pattern, index( $pattern, '{0}' ), 3, $_[1] ) while index( $pattern, '{0}' ) &gt; -1;
    substr( $pattern, index( $pattern, '{1}' ), 3, $_[2] ) while index( $pattern, '{1}' ) &gt; -1;
    return $pattern;
}

sub get_formatted_ellipsis_final {
    my ( $self, $str ) = @_;
    my $pattern = $self-&gt;{'language_data'}{'misc_info'}{'cldr_formats'}{'ellipsis'}{'final'} || '{0}…';
    substr( $pattern, index( $pattern, '{0}' ), 3, $str ) while index( $pattern, '{0}' ) &gt; -1;
    return $pattern;
}


sub get_formatted_decimal {
    my ( $self, $n, $max_decimal_places, $_my_pattern ) = @_;    # $_my_pattern not documented on purpose, it is only intended for internal use, and may dropepd/changed at any time


    return if !defined $n;


    my $is_negative = $n &lt; 0 ? 1 : 0;

    my $max_len = defined $max_decimal_places ? abs( int($max_decimal_places) ) : 6;    # %f default is 6
    $max_len = 14 if $max_len &gt; 14;

    if ( $n &gt; 10_000_000_000 || $n &lt; -10_000_000_000 ) {

        return $n if $n =~ tr/Ee//;                                                     # poor man's is exponential check.


        if ( $n =~ m/\.([0-9]{$max_len})([0-9])?/ ) {
            my $trim = $1;    # (defined $2 &amp;&amp; $2 &gt; 4) ? $1 + 1 : $1;

            if ( defined $2 &amp;&amp; $2 &gt; 4 ) {
                if ( ( $trim + 1 ) !~ tr/Ee// ) {    # poor man's is exponential check.
                    $trim++;
                }
            }

            $n =~ s/$FORCE_REGEX_LAZY\.[0-9]+/\.$trim/o;
        }
    }
    else {
        return $n if length $n &lt; 3 &amp;&amp; $n !~ tr{0-9}{}c;

        $n = sprintf( '%.' . $max_len . 'f', $n );

        return $n if $n =~ tr/Ee//;    # poor man's is exponential check.
    }

    $n =~ s{$FORCE_REGEX_LAZY([^0-9]+[0-9]*?[1-9])0+$}{$1}o;
    $n =~ s{$FORCE_REGEX_LAZY[^0-9]+0+$}{}o;

    if ( $n =~ tr{.0-9}{}c ) {    # Only strip signs if the string has non-numeric and '.' characters such as '+' or '-'
        substr( $n, 0, 1, '' ) while substr( $n, 1 ) =~ tr{0-9}{}c;
    }

    my $cldr_formats = $self-&gt;{'language_data'}{'misc_info'}{'cldr_formats'};

    my $format = $_my_pattern || $cldr_formats-&gt;{'decimal'};    # from http://unicode.org/repos/cldr-tmp/trunk/diff/by_type/number.pattern.html

    my ( $zero_positive_pat, $negative_pat, $err ) = split( /$FORCE_REGEX_LAZY(?&lt;!\')\;(?!\')/o, $format );    # semi-colon that is not literal (?&lt;!\')\;(?!\')

    if ($err) {
        require Carp;
        Carp::carp(&quot;Format had more than 2 pos/neg sections. Using default pattern.&quot;);
        $format = '#,##0.###';
    }
    elsif ( $is_negative &amp;&amp; $negative_pat ) {
        $format = $negative_pat;
    }
    elsif ($zero_positive_pat) {
        $format = $zero_positive_pat;
    }

    my $dec_sec_cnt = 0;
    if ( index( $format, q{'} ) == -1 ) {
        $dec_sec_cnt = $format =~ tr{\.}{};
    }
    else {
        $dec_sec_cnt++ while ( $format =~ m/$FORCE_REGEX_LAZY(?&lt;!\')\.(?!\')/og );
    }

    if ( $dec_sec_cnt != 1 ) {
        require Carp;
        Carp::carp(&quot;Format should have one decimal section. Using default pattern.&quot;);
        $format = '#,##0.###';
    }

    if ( !length $format || $format !~ tr{ \t\r\n\f}{}c ) {
        require Carp;
        Carp::carp(&quot;Format is empty. Using default pattern.&quot;);
        $format = '#,##0.###';
    }


    my $result = '';

    if ( $format eq '#,##0.###' ) {
        $result = $n;
        if ( $n =~ tr{0-9}{} &gt; 3 ) {
            while ( $result =~ s/$FORCE_REGEX_LAZY^([-+]?\d+)(\d{3})/$1,$2/os ) { 1 }    # right from perlfaq5
        }
    }
    else {


        my ( $integer, $decimals ) = split( /\./, $n, 2 );

        my ( $i_pat, $d_pat ) = split( /$FORCE_REGEX_LAZY(?&lt;!\')\.(?!\')/o, $format, 2 );
        my ( $cur_idx, $trailing_non_n, $cur_d, $cur_pat ) = ( 0, '' );    # buffer

        my @i_pat = reverse( split( /$FORCE_REGEX_LAZY(?&lt;!\')\,(?!\')/o, $i_pat ) );

        my $next_to_last_pattern = @i_pat == 1 ? $i_pat[0] : $i_pat[-2];
        substr( $next_to_last_pattern, -1, 1, '#' ) if substr( $next_to_last_pattern, -1 ) eq '0';
        while ( $i_pat[0] =~ s/$FORCE_REGEX_LAZY((?:\'.\')+)$//o || $i_pat[0] =~ s/$FORCE_REGEX_LAZY([^0#]+)$//o ) {
            $trailing_non_n = &quot;$1$trailing_non_n&quot;;
        }


        while ( CORE::length( $cur_d = CORE::substr( $integer, -1, 1, '' ) ) ) {


            if ( $cur_idx == $#i_pat &amp;&amp; !CORE::length( $i_pat[$cur_idx] ) ) {
                $i_pat[$cur_idx] = $next_to_last_pattern;
            }

            if ( !CORE::length( $i_pat[$cur_idx] ) ) {    # this chunk is spent
                if ( defined $i_pat[ $cur_idx + 1 ] ) {    # there are more chunks ...
                    $cur_idx++;                            # ... next chunk please
                }
            }

            if ( CORE::length( $i_pat[$cur_idx] ) ) {

                if ( substr( $i_pat[$cur_idx], -3 ) eq q{','} ) {
                    $result = CORE::substr( $i_pat[$cur_idx], -3, 3, '' ) . $result;
                    redo;
                }

                $cur_pat = CORE::substr( $i_pat[$cur_idx], -1, 1, '' );

                if ( $cur_pat ne '0' &amp;&amp; $cur_pat ne '#' ) {
                    $result = &quot;$cur_pat$result&quot;;
                    redo;
                }
            }

            $result = !CORE::length( $i_pat[$cur_idx] ) &amp;&amp; @i_pat != 1 ? &quot;,$cur_d$result&quot; : &quot;$cur_d$result&quot;;

            if ( $cur_idx == $#i_pat - 1 &amp;&amp; $i_pat[$#i_pat] eq '#' &amp;&amp; !CORE::length( $i_pat[$cur_idx] ) ) {
                $cur_idx++;
                $i_pat[$cur_idx] = $next_to_last_pattern;
            }
        }
        if ( CORE::length( $i_pat[$cur_idx] ) ) {
            $i_pat[$cur_idx] =~ s/$FORCE_REGEX_LAZY(?&lt;!\')\#(?!\')//og;    # remove any left over non-literal #
            $result = $result . $i_pat[$cur_idx];        # prepend it (e.g. 0 and -)
        }
        if ( substr( $result, 0, 1 ) eq ',' ) {
            substr( $result, 0, 1, '' );
        }
        $result .= $trailing_non_n;

        if ( defined $decimals &amp;&amp; CORE::length($decimals) ) {

            my @d_pat = ($d_pat);                        # TODO ? support sepeartor in decimal, !definedvia CLDR, no patterns have that ATM ? split( /(?&lt;!\')\,(?!\')/, $d_pat );

            $result .= '.';
            $cur_idx        = 0;
            $trailing_non_n = '';

            while ( $d_pat[-1] =~ s/$FORCE_REGEX_LAZY((?:\'.\')+)$//o || $d_pat[-1] =~ s/$FORCE_REGEX_LAZY([^0#]+)$//o ) {
                $trailing_non_n = &quot;$1$trailing_non_n&quot;;
            }


            while ( CORE::length( $cur_d = CORE::substr( $decimals, 0, 1, '' ) ) ) {


                if ( !CORE::length( $d_pat[$cur_idx] ) ) {    # this chunk is spent
                    if ( !defined $d_pat[ $cur_idx + 1 ] ) {    # there are no more chunks
                        $cur_pat = '#';
                    }
                    else {                                      # next chunk please
                        $result .= ',';
                        $cur_idx++;
                    }
                }

                if ( CORE::length( $d_pat[$cur_idx] ) ) {

                    if ( index( $d_pat[$cur_idx], q{'.'} ) == 0 ) {
                        $result .= CORE::substr( $d_pat[$cur_idx], 0, 3, '' );
                        redo;
                    }
                    $cur_pat = CORE::substr( $d_pat[$cur_idx], 0, 1, '' );
                    if ( $cur_pat ne '0' &amp;&amp; $cur_pat ne '#' ) {
                        $result .= $cur_pat;
                        redo;
                    }
                }

                $result .= $cur_d;
            }
            if ( substr( $result, -1, ) eq ',' ) {
                chop($result);
            }
            if ( defined $d_pat[$cur_idx] ) {
                $d_pat[$cur_idx] =~ s/$FORCE_REGEX_LAZY(?&lt;!\')\#(?!\')//og;    # remove any left over non-literal #
                $result .= $d_pat[$cur_idx];                 # append it (e.g. 0 and -)
            }
            $result .= $trailing_non_n;
        }

    }

    my $used_place_holder = $cldr_formats-&gt;{_decimal_format_decimal} ne '.' &amp;&amp; index( $result, '.' ) &gt; -1 &amp;&amp; $result =~ s/$FORCE_REGEX_LAZY(?&lt;!\')\.(?!\')/_LOCALES-DECIMAL-PLACEHOLDER_/g;

    if ( $cldr_formats-&gt;{_decimal_format_group} ne ',' &amp;&amp; index( $result, ',' ) &gt; -1 ) {
        $result =~ s/$FORCE_REGEX_LAZY(?&lt;!\')\,(?!\')/$cldr_formats-&gt;{_decimal_format_group}/og;
    }
    if ($used_place_holder) {
        my $ix;
        substr( $result, $ix, 29, $cldr_formats-&gt;{_decimal_format_decimal} ) while ( $ix = index( $result, '_LOCALES-DECIMAL-PLACEHOLDER_' ) ) &gt; -1;
    }


    if ( $is_negative &amp;&amp; !$negative_pat ) {

        $result = &quot;-$result&quot;;
    }

    return $result;
}


sub get_territory_codes {
    $_[0]-&gt;_load_territory_data() if !$_[0]-&gt;{'territory_data'};

    return keys %{ shift-&gt;{'territory_data'}{'code_to_name'} };
}

sub get_territory_names {
    $_[0]-&gt;_load_territory_data() if !$_[0]-&gt;{'territory_data'};

    return values %{ shift-&gt;{'territory_data'}{'code_to_name'} };
}

sub get_territory_lookup {
    $_[0]-&gt;_load_territory_data() if !$_[0]-&gt;{'territory_data'};

    return %{ shift-&gt;{'territory_data'}{'code_to_name'} };
}

sub get_territory_from_code {
    my ( $self, $code, $always_return ) = @_;

    $code ||= $self-&gt;{'territory'};
    $code = normalize_tag($code);
    return if !defined $code;

    $self-&gt;_load_territory_data() if !$self-&gt;{'territory_data'};

    if ( exists $self-&gt;{'territory_data'}{'code_to_name'}{$code} ) {
        return $self-&gt;{'territory_data'}{'code_to_name'}{$code};
    }
    elsif ( !defined $self-&gt;{'territory'} || $code ne $self-&gt;{'territory'} ) {
        my ( $l, $t ) = split_tag($code);
        if ( $t &amp;&amp; exists $self-&gt;{'territory_data'}{'code_to_name'}{$t} ) {
            return $self-&gt;{'territory_data'}{'code_to_name'}{$t};
        }
    }
    return $code if $always_return;
    return;
}

sub get_code_from_territory {
    my ( $self, $name ) = @_;
    return if !$name;
    my $key = normalize_for_key_lookup($name);

    $self-&gt;_load_territory_data() if !$self-&gt;{'territory_data'};

    if ( !$self-&gt;{'territory_data'}{'nam'} ) {
        $self-&gt;{'territory_data'}{'name_to_code'} = { map { normalize_for_key_lookup( $self-&gt;{'territory_data'}{'code_to_name'}-&gt;{$_} ) =&gt; $_ } keys %{ $self-&gt;{'territory_data'}{'code_to_name'} } };
    }
    if ( exists $self-&gt;{'territory_data'}{'name_to_code'}{$key} ) {
        return $self-&gt;{'territory_data'}{'name_to_code'}{$key};
    }
    return;
}

{
    no warnings 'once';
    *code2territory = *get_territory_from_code;
    *territory2code = *get_code_from_territory;
}


sub get_language_codes {
    $_[0]-&gt;_load_language_data_code_to_name() if !$_[0]-&gt;{'language_data'}{'code_to_name'};
    return keys %{ $_[0]-&gt;{'language_data'}{'code_to_name'} };
}

sub get_language_names {
    $_[0]-&gt;_load_language_data_code_to_name() if !$_[0]-&gt;{'language_data'}{'code_to_name'};
    return values %{ $_[0]-&gt;{'language_data'}{'code_to_name'} };
}

sub get_language_lookup {
    $_[0]-&gt;_load_language_data_code_to_name() if !$_[0]-&gt;{'language_data'}{'code_to_name'};
    return %{ $_[0]-&gt;{'language_data'}{'code_to_name'} };
}

sub get_language_from_code {
    my ( $self, $code, $always_return ) = @_;

    $code ||= $self-&gt;{'locale'};
    $code = normalize_tag($code);
    return if !defined $code;

    $always_return ||= 1 if $code eq $self-&gt;get_locale() &amp;&amp; $self-&gt;get_soft_locale_fallback();    # force $always_return under soft locale objects
    $always_return ||= 0;

    $self-&gt;_load_language_data_code_to_name() if !$_[0]-&gt;{'language_data'}{'code_to_name'};
    if ( exists $self-&gt;{'language_data'}{'code_to_name'}{$code} ) {
        return $self-&gt;{'language_data'}{'code_to_name'}{$code};
    }
    elsif ($always_return) {
        $self-&gt;_load_territory_data() if !$self-&gt;{'territory_data'};

        my ( $l, $t ) = split_tag($code);
        my $ln = $self-&gt;{'language_data'}{'code_to_name'}{$l};
        my $tn = defined $t ? $self-&gt;{'territory_data'}{'code_to_name'}{$t} : '';

        return $code if !$ln &amp;&amp; !$tn;
        $ln ||= $l;
        $tn ||= $t;

        my $string = $self-&gt;{'language_data'}{'misc_info'}{'cldr_formats'}{'locale'} || '{0} ({1})';

        substr( $string, index( $string, '{0}' ), 3, $ln ) while index( $string, '{0}' ) &gt; -1;
        substr( $string, index( $string, '{1}' ), 3, $tn ) while index( $string, '{1}' ) &gt; -1;

        return $string;
    }
    return;
}

sub get_code_from_language {
    my ( $self, $name ) = @_;
    return if !$name;
    my $key = normalize_for_key_lookup($name);

    $self-&gt;_load_language_data_code_to_name() if !$_[0]-&gt;{'language_data'}{'code_to_name'};
    if ( !$self-&gt;{'language_data'}{'name_to_code'} ) {
        $self-&gt;{'language_data'}{'name_to_code'} = { map { normalize_for_key_lookup( $self-&gt;{'language_data'}{'code_to_name'}-&gt;{$_} ) =&gt; $_ } keys %{ $self-&gt;{'language_data'}{'code_to_name'} } };
    }

    if ( exists $self-&gt;{'language_data'}{'name_to_code'}{$key} ) {
        return $self-&gt;{'language_data'}{'name_to_code'}{$key};
    }
    return;
}

{
    no warnings 'once';
    *code2language = *get_language_from_code;
    *language2code = *get_code_from_language;
}


sub tag_is_soft_locale {
    my ($tag) = @_;
    my ( $l, $t ) = split_tag($tag);

    return if !defined $l;    # invalid tag is not soft

    return if !$t;                             # no territory part means it is not soft
    return if tag_is_loadable($tag);           # if it can be loaded directly then it is not soft
    return if !territory_code_is_known($t);    # if the territory part is not known then it is not soft
    return if !tag_is_loadable($l);            # if the language part is not known then it is not soft
    return $l;                                 # it is soft, so return the value suitable for 'soft_locale_fallback'
}

sub tag_is_loadable {
    my ( $tag, $as_territory ) = @_;           # not documenting internal $as_territory, just use territory_code_is_known() directly

    if ( !exists $INC{&quot;Cpanel/CPAN/Locales/DB/Loadable.pm&quot;} ) {
        local $SIG{'__DIE__'};                 # cpanel specific: ensure a benign eval does not trigger cpsrvd's DIE handler (may be made moot by internal case 50857)
        eval &quot;require Cpanel::CPAN::Locales::DB::Loadable&quot; || return;    # Module::Want::have_mod(&quot;Cpanel::CPAN::Locales::DB::Loadable&quot;) || return;
    }

    if ($as_territory) {
        no warnings 'once';
        return 1 if exists $Cpanel::CPAN::Locales::DB::Loadable::territory{$tag};
    }
    else {
        return 1 if exists $Cpanel::CPAN::Locales::DB::Loadable::code{$tag};
    }

    return;
}

sub get_loadable_language_codes {
    if ( !exists $INC{&quot;Cpanel/CPAN/Locales/DB/Loadable.pm&quot;} ) {
        local $SIG{'__DIE__'};    # cpanel specific: ensure a benign eval does not trigger cpsrvd's DIE handler (may be made moot by internal case 50857)
        eval &quot;require Cpanel::CPAN::Locales::DB::Loadable&quot; || return;    # Module::Want::have_mod(&quot;Cpanel::CPAN::Locales::DB::Loadable&quot;) || return;
    }

    return keys %Cpanel::CPAN::Locales::DB::Loadable::code;
}

sub territory_code_is_known {
    return tag_is_loadable( $_[0], 1 );
}

sub split_tag {
    return split( /_/, normalize_tag( $_[0] ), 2 );                      # we only do language[_territory]
}

sub get_i_tag_for_string {
    my $norm = normalize_tag( $_[0] );

    if ( substr( $norm, 0, 2 ) eq 'i_' ) {
        return $norm;
    }
    else {
        return 'i_' . $norm;
    }
}

my %non_locales = (
    'und' =&gt; 1,
    'zxx' =&gt; 1,
    'mul' =&gt; 1,
    'mis' =&gt; 1,
    'art' =&gt; 1,
);

sub non_locale_list {
    return ( sort keys %non_locales );
}

sub is_non_locale {
    my $tag = normalize_tag( $_[0] ) || return;
    return 1 if exists $non_locales{$tag};
    return;
}

sub typical_en_alias_list {
    return ( 'en_us', 'i_default' );
}

sub is_typical_en_alias {
    my $tag = normalize_tag( $_[0] ) || return;
    return 1 if $tag eq 'en_us' || $tag eq 'i_default';
    return;
}

sub normalize_tag_for_datetime_locale {
    my ( $pre, $pst ) = split_tag( $_[0] );    # we only do language[_territory]
    return if !defined $pre;

    if ($pst) {
        return $pre . '_' . uc($pst);
    }
    else {
        return $pre;
    }
}

sub normalize_tag_for_ietf {
    my ( $pre, $pst ) = split_tag( $_[0] );    # we only do language[_territory]
    return if !defined $pre;

    if ($pst) {
        return $pre . '-' . uc($pst);
    }
    else {
        return $pre;
    }
}

sub normalize_for_key_lookup {
    my $key = $_[0];
    return '' if !defined $key;
    $key =~ tr/A-Z/a-z/;                            # lowercase
    $key =~ s{\s+}{}g if $key =~ tr{ \t\r\n\f}{};
    $key =~ tr{\'\&quot;\-\(\)\[\]\_}{}d;
    return $key;
}

sub plural_rule_string_to_javascript_code {
    require Cpanel::CPAN::Locales::Compile;
    *plural_rule_string_to_javascript_code = \&amp;Cpanel::CPAN::Locales::Compile::plural_rule_string_to_javascript_code;
    goto \&amp;Cpanel::CPAN::Locales::Compile::plural_rule_string_to_javascript_code;
}

sub plural_rule_string_to_code {
    require Cpanel::CPAN::Locales::Compile;
    *plural_rule_string_to_code = \&amp;Cpanel::CPAN::Locales::Compile::plural_rule_string_to_code;
    goto \&amp;Cpanel::CPAN::Locales::Compile::plural_rule_string_to_code;
}

sub plural_rule_hashref_to_code {
    my ($hr) = @_;

    if ( ref( $hr-&gt;{'category_rules'} ) ne 'HASH' ) {

        $hr-&gt;{'category_rules_compiled'} = {
            'one' =&gt; q{sub { return 'one' if ( ( $n == 1 ) ); return;};},
        };

        return sub {

            my ($n) = @_;
            return 'one' if $n == 1;
            return;
        };
    }
    else {
        for my $cat ( get_cldr_plural_category_list(1) ) {
            next if !exists $hr-&gt;{'category_rules'}{$cat};
            next if exists $hr-&gt;{'category_rules_compiled'}{$cat};
            $hr-&gt;{'category_rules_compiled'}{$cat} = plural_rule_string_to_code( $hr-&gt;{'category_rules'}{$cat}, $cat );
        }

        return sub {
            my ($n) = @_;
            my $match;
          PCAT:
            for my $cat ( get_cldr_plural_category_list(1) ) {    # use function instead of keys to preserve processing order
                next if !exists $hr-&gt;{'category_rules_compiled'}{$cat};


                if ( ref( $hr-&gt;{'category_rules_compiled'}{$cat} ) ne 'CODE' ) {
                    local $SIG{'__DIE__'};                        # cpanel specific: ensure a benign eval does not trigger cpsrvd's DIE handler (may be made moot by internal case 50857)
                    $hr-&gt;{'category_rules_compiled'}{$cat} = eval &quot;$hr-&gt;{'category_rules_compiled'}{$cat}&quot;;    ## no critic (ProhibitStringyEval) # As of 0.22 this will be skipped for modules included w/ the main dist
                }

                if ( $hr-&gt;{'category_rules_compiled'}{$cat}-&gt;($n) ) {
                    $match = $cat;
                    last PCAT;
                }
            }

            return $match if $match;
            return;
        };
    }
}

sub get_cldr_plural_category_list {

    return qw(zero one two few many other) if $_[0];    # check order

    return qw(one two few many other zero);    # quant() arg order
}

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

    my ( $super, $ter ) = split_tag( $self-&gt;{'locale'} );
    return (
        $self-&gt;{'locale'},
        ( $super ne $self-&gt;{'locale'} &amp;&amp; $super ne 'i' ? $super : () ),
        ( @{ $self-&gt;{'language_data'}{'misc_info'}{'fallback'} } ),
        (
            defined $special_lookup &amp;&amp; ref($special_lookup) eq 'CODE'
            ? ( map { my $n = Cpanel::Locale::Utils::Normalize::normalize_tag($_); $n ? ($n) : () } $special_lookup-&gt;( $self-&gt;{'locale'} ) )
            : ()
        ),
        'en'
    );
}

sub get_cldr_number_symbol_decimal {
    return $_[0]-&gt;{'language_data'}{'misc_info'}{'cldr_formats'}{'_decimal_format_decimal'} || '.';
}

sub get_cldr_number_symbol_group {
    return $_[0]-&gt;{'language_data'}{'misc_info'}{'cldr_formats'}{'_decimal_format_group'} || ',';
}

1;


} # --- END Cpanel/CPAN/Locales.pm


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


$Cpanel::CPAN::Locale::Maketext::Utils::VERSION = 0.33_95;

# use Cpanel::CPAN::Locale::Maketext 1.13_89 ();    # our 1.13_89 contains some optimizations and support for external_lex_cache that made its way to CPAN by v1.22

@Cpanel::CPAN::Locale::Maketext::Utils::ISA = qw(Cpanel::CPAN::Locale::Maketext);

use constant LOCALE_FALLBACK_CACHE_DIR =&gt; '/usr/local/cpanel/etc/locale/fallback';
my $FORCE_REGEX_LAZY = '';

my %singleton_stash = ();

sub _compile {
    my ( $lh, $string ) = @_;

    substr( $string, index( $string, '_TILDE_' ), 7, '~~' ) while index( $string, '_TILDE_' ) &gt; -1;    # this helps make parsing easier (via code or visually)

    my $compiled = $lh-&gt;SUPER::_compile($string);

    return $compiled if ref($compiled) ne 'CODE';

    return sub {
        return $compiled-&gt;( $_[0], @_[ 1 .. $#_ ] ) if !grep { defined &amp;&amp; index( $_, '_' ) &gt; -1 } @_[ 1 .. $#_ ];
        my ( $lh, @ref_args ) = @_;

        my $built = $compiled-&gt;(
            $lh,
            map {

                if ( defined &amp;&amp; index( $_, '_' ) &gt; -1 ) {
                    s/$FORCE_REGEX_LAZY\_(\-?[0-9]+|\*)/-!-$1-!-/og;
                }

                $_    # Change embedded-arg-looking-string to a

            } @ref_args

        );
        $built =~ s/$FORCE_REGEX_LAZY-!-(\-?[0-9]+|\*)-!-/_$1/og;    # Change placeholders back to their original
        return $built;
    };
}

sub get_handle {
    my ( $class, @langtags ) = @_;

    my $args_sig = join( ',', @langtags ) || 'no_args';

    if ( exists $singleton_stash{$class}{$args_sig} ) {
        $singleton_stash{$class}{$args_sig}-&gt;{'_singleton_reused'}++;
    }
    else {
        $singleton_stash{$class}{$args_sig} = $class-&gt;SUPER::get_handle(@langtags);
    }

    return $singleton_stash{$class}{$args_sig};
}

sub get_locales_obj {
    my ( $lh, $tag ) = @_;
    $tag ||= $lh-&gt;get_language_tag();

    if ( !exists $lh-&gt;{'Locales.pm'}{$tag} ) {
        require Cpanel::CPAN::Locales;
        $lh-&gt;{'Locales.pm'}{$tag} =
             Cpanel::CPAN::Locales-&gt;new($tag)
          || ( $tag ne substr( $tag, 0, 2 ) ? Cpanel::CPAN::Locales-&gt;new( substr( $tag, 0, 2 ) ) : '' )
          || (
            $lh-&gt;{'fallback_locale'}
            ?        ( Cpanel::CPAN::Locales-&gt;new( $lh-&gt;{'fallback_locale'} )
                  || ( $lh-&gt;{'fallback_locale'} ne substr( $lh-&gt;{'fallback_locale'}, 0, 2 ) ? Cpanel::CPAN::Locales-&gt;new( substr( $lh-&gt;{'fallback_locale'}, 0, 2 ) ) : '' ) )
            : ''
          )
          || Cpanel::CPAN::Locales-&gt;new('en');
    }

    return $lh-&gt;{'Locales.pm'}{$tag};
}

sub init {
    my ($lh) = @_;

    $lh-&gt;SUPER::init();
    $lh-&gt;remove_key_from_lexicons('_AUTO');

    no strict 'refs';
    for my $ns ( $lh-&gt;get_base_class(), $lh-&gt;get_language_class() ) {
        if ( defined ${ $ns . '::Encoding' } ) {
            $lh-&gt;{'encoding'} = ${ $ns . '::Encoding' } if ${ $ns . '::Encoding' };
        }
    }


    $lh-&gt;fail_with(
        sub {
            my ( $lh, $key, @args ) = @_;

            my $lookup;
            if ( exists $lh-&gt;{'_get_key_from_lookup'} ) {
                if ( ref $lh-&gt;{'_get_key_from_lookup'} eq 'CODE' ) {
                    $lookup = $lh-&gt;{'_get_key_from_lookup'}-&gt;( $lh, $key, @args );
                }
            }

            return $lookup if defined $lookup;

            if ( exists $lh-&gt;{'_log_phantom_key'} ) {
                if ( ref $lh-&gt;{'_log_phantom_key'} eq 'CODE' ) {
                    $lh-&gt;{'_log_phantom_key'}-&gt;( $lh, $key, @args );
                }
            }

            if ( $lh-&gt;{'use_external_lex_cache'} ) {
                local $lh-&gt;{'_external_lex_cache'}{'_AUTO'} = 1;

                if ( index( $key, '_' ) == 0 ) {
                    return $lh-&gt;{'_external_lex_cache'}{$key} = $key;
                }
                return $lh-&gt;maketext( $key, @args );
            }
            else {
                no strict 'refs';
                local ${ $lh-&gt;get_base_class() . '::Lexicon' }{'_AUTO'} = 1;

                if ( index( $key, '_' ) == 0 ) {
                    return ${ $lh-&gt;get_base_class() . '::Lexicon' }{$key} = $key;
                }

                return $lh-&gt;maketext( $key, @args );
            }
        }
    );
}

*makevar = \&amp;Cpanel::CPAN::Locale::Maketext::maketext;


sub makethis {
    my ( $lh, $phrase, @phrase_args ) = @_;

    $lh-&gt;{'cache'}{'makethis'}{$phrase} ||= $lh-&gt;_compile($phrase);

    my $type = ref( $lh-&gt;{'cache'}{'makethis'}{$phrase} );

    if ( $type eq 'SCALAR' ) {
        return ${ $lh-&gt;{'cache'}{'makethis'}{$phrase} };
    }
    elsif ( $type eq 'CODE' ) {
        return $lh-&gt;{'cache'}{'makethis'}{$phrase}-&gt;( $lh, @phrase_args );
    }
    else {

        return $lh-&gt;{'cache'}{'makethis'}{$phrase};
    }
}

sub makethis_base {
    my ($lh) = @_;
    $lh-&gt;{'cache'}{'makethis_base'} ||= $lh-&gt;get_base_class()-&gt;get_handle( $lh-&gt;{'fallback_locale'} || 'en' );    # this allows to have a separate cache of compiled phrases (? get_handle() explicit or base_locales() (i.e. en en_us i_default || L::M-&gt;fallback_languages) ?)
    return $lh-&gt;{'cache'}{'makethis_base'}-&gt;makethis( @_[ 1 .. $#_ ] );
}

sub make_alias {
    my ( $lh, $pkgs, $is_base_class ) = @_;

    my $ns = $lh-&gt;get_language_class();
    return if $ns =~ tr{:0-9A-Za-z_-}{}c;
    my $base = $is_base_class ? $ns : $lh-&gt;get_base_class();

    no strict 'refs';
    for my $pkg ( ref $pkgs ? @{$pkgs} : $pkgs ) {
        next if $pkg =~ tr{:0-9A-Za-z_-}{}c;

        *{ $base . '::' . $pkg . '::Encoding' } = *{ $ns . '::Encoding' };
        *{ $base . '::' . $pkg . '::Lexicon' }  = *{ $ns . '::Lexicon' };
        @{ $base . '::' . $pkg . '::ISA' }      = ($ns);
    }
}

sub remove_key_from_lexicons {
    my ( $lh, $key ) = @_;
    my $idx = 0;

    for my $lex_hr ( @{ $lh-&gt;_lex_refs() } ) {
        $lh-&gt;{'_removed_from_lexicons'}{$idx}{$key} = delete $lex_hr-&gt;{$key} if exists $lex_hr-&gt;{$key};
        $idx++;
    }
}

my %grapheme_lookup = (
    'trademark'          =&gt; &quot;\xE2\x84\xA2&quot;,    # 'TRADE MARK SIGN' (U+2122)
    'registered'         =&gt; &quot;\xC2\xAE&quot;,        # 'REGISTERED SIGN' (U+00AE)
    'copyright'          =&gt; &quot;\xC2\xA9&quot;,        # 'COPYRIGHT SIGN' (U+00A9)
    'left_double_quote'  =&gt; &quot;\xE2\x80\x9C&quot;,    # 'LEFT DOUBLE QUOTATION MARK' (U+201C)
    'right_double_quote' =&gt; &quot;\xE2\x80\x9D&quot;,    # 'RIGHT DOUBLE QUOTATION MARK' (U+201D)
    'ellipsis'           =&gt; &quot;\xE2\x80\xA6&quot;,    # 'HORIZONTAL ELLIPSIS' (U+2026)
    'left_single_quote'  =&gt; &quot;\xE2\x80\x98&quot;,    # 'LEFT SINGLE QUOTATION MARK' (U+2018)
    'right_single_quote' =&gt; &quot;\xE2\x80\x99&quot;,    # 'RIGHT SINGLE QUOTATION MARK'
    'infinity'           =&gt; &quot;\xE2\x88\x9E&quot;,    # 'INFINITY' (U+221E)
);

sub get_grapheme_helper_hashref {
    return {%grapheme_lookup};                 # copy
}

sub get_base_class {
    my $ns = $_[0]-&gt;get_language_class();
    return $ns if $ns eq 'Cpanel::Locale';
    return substr( $ns, 0, rindex( $ns, '::' ) );
}

sub append_to_lexicons {
    my ( $lh, $appendage ) = @_;
    return if ref $appendage ne 'HASH';

    no strict 'refs';
    for my $lang ( keys %{$appendage} ) {
        my $ns = $lh-&gt;get_base_class() . ( $lang eq '_' ? '' : &quot;::$lang&quot; ) . '::Lexicon';
        %{$ns} = ( %{$ns}, %{ $appendage-&gt;{$lang} } );
    }
}

sub langtag_is_loadable {
    my ( $lh, $wants_tag ) = @_;
    $wants_tag = Cpanel::CPAN::Locale::Maketext::language_tag($wants_tag);

    my $tag_obj = eval $lh-&gt;get_base_class() . q{-&gt;get_handle( $wants_tag );};

    my $has_tag = $tag_obj-&gt;language_tag();
    return $wants_tag eq $has_tag ? $tag_obj : 0;
}

sub get_language_tag {
    return ( split '::', $_[0]-&gt;get_language_class() )[-1];
}

sub print {
    local $Carp::CarpLevel = 1;
    print $_[0]-&gt;maketext( @_[ 1 .. $#_ ] );
}

sub fetch {
    local $Carp::CarpLevel = 1;
    return $_[0]-&gt;maketext( @_[ 1 .. $#_ ] );
}

sub say {
    local $Carp::CarpLevel = 1;
    my $text = $_[0]-&gt;maketext( @_[ 1 .. $#_ ] );
    local $/ = !defined $/ || !$/ ? &quot;\n&quot; : $/;    # otherwise assume they are not stupid
    print $text . $/ if $text;
}

sub get {
    local $Carp::CarpLevel = 1;
    my $text = $_[0]-&gt;maketext( @_[ 1 .. $#_ ] );
    local $/ = !defined $/ || !$/ ? &quot;\n&quot; : $/;    # otherwise assume they are not stupid
    return $text . $/ if $text;
    return;
}

sub get_language_tag_name {
    my ( $lh, $tag, $in_locale_tongue ) = @_;
    $tag ||= $lh-&gt;get_language_tag();

    my $loc_obj = $lh-&gt;get_locales_obj( $in_locale_tongue ? () : ($tag) );

    if ( $loc_obj-&gt;{'native_data'} &amp;&amp; $tag eq $lh-&gt;get_language_tag() ) {
        return $loc_obj-&gt;get_native_language_from_code($tag);
    }

    return $loc_obj-&gt;get_language_from_code($tag);
}

sub get_html_dir_attr {
    my ( $lh, $raw_cldr, $is_tag ) = @_;

    if ($is_tag) {
        $raw_cldr = $lh-&gt;get_language_tag_character_orientation($raw_cldr);
    }
    else {
        $raw_cldr ||= $lh-&gt;get_language_tag_character_orientation();
    }

    if ( $raw_cldr eq 'left-to-right' ) {
        return 'ltr';
    }
    elsif ( $raw_cldr eq 'right-to-left' ) {
        return 'rtl';
    }

    return;
}

sub get_locale_display_pattern {

    require Cpanel::CPAN::Locales::DB::LocaleDisplayPattern::Tiny;
    return Cpanel::CPAN::Locales::DB::LocaleDisplayPattern::Tiny::get_locale_display_pattern( $_[1] || $_[0]-&gt;{'fallback_locale'} || $_[0]-&gt;get_language_tag() );
}

sub get_language_tag_character_orientation {

    require Cpanel::CPAN::Locales::DB::CharacterOrientation::Tiny;
    return Cpanel::CPAN::Locales::DB::CharacterOrientation::Tiny::get_orientation( $_[1] || $_[0]-&gt;{'fallback_locale'} || $_[0]-&gt;get_language_tag() );
}

*lextext = *text;

sub text {

    if ( @_ != 2 ) {
        require Carp;
        Carp::croak('text() requires a singlef parameter');

    }

    my ( $handle, $phrase ) = splice( @_, 0, 2 );
    unless ( defined($handle) &amp;&amp; defined($phrase) ) {
        require Carp;
        Carp::confess('No handle/phrase');

    }

    if ( !$handle-&gt;{'use_external_lex_cache'} ) {
        require Carp;
        Carp::carp(&quot;text() requires you to have 'use_external_lex_cache' enabled.&quot;);
        return;
    }

    local $@;


    my $value;
    foreach my $h_r ( @{ $handle-&gt;_lex_refs } ) {    # _lex_refs() caches itself

        if ( defined( $value = $h_r-&gt;{$phrase} ) ) {

            if ( ref $value ) {
                require Carp;
                Carp::carp(&quot;Previously compiled phrase ('use_external_lex_cache' enabled after phrase was compiled?)&quot;);
            }

            return $value eq '' ? $phrase : $value;
        }

        elsif ( index( $phrase, '_' ) != 0 and $h_r-&gt;{'_AUTO'} ) {

            return $phrase;
        }


    }


    return ( !defined $value || $value eq '' ) ? $phrase : $value;
}

our $_NATIVE_ONLY = 0;

sub lang_names_hashref_native_only {
    local $_NATIVE_ONLY = 1;
    return lang_names_hashref(@_);
}

sub lang_names_hashref {
    my ( $lh, @langcodes ) = @_;

    if ( !@langcodes ) {    # they havn't specified any langcodes...
        require File::Spec;    # only needed here, so we don't use() it

        my @search;
        my $path = $lh-&gt;get_base_class();

        substr( $path, index( $path, '::' ), 2, '/' ) while index( $path, '::' ) &gt; -1;

        if ( ref $lh-&gt;{'_lang_pm_search_paths'} eq 'ARRAY' ) {
            @search = @{ $lh-&gt;{'_lang_pm_search_paths'} };
        }

        @search = @INC if !@search;    # they havn't told us where they are specifically

      DIR:
        for my $dir (@search) {
            my $lookin = File::Spec-&gt;catdir( $dir, $path );
            next DIR if !-d $lookin;
            if ( opendir my $dh, $lookin ) {
              PM:
                for my $pm ( grep { /^\w+\.pm$/ } grep !/^\.+$/, readdir($dh) ) {
                    substr( $pm, -3, 3, '' );    # checked above - if substr( $pm, -3 ) eq '.pm';
                    next PM if !$pm;
                    next PM if $pm eq 'Utils';
                    next PM if $pm eq 'Context';
                    next PM if $pm eq 'Lazy';
                    push @langcodes, $pm;
                }
                closedir $dh;
            }
        }
    }

    require Cpanel::CPAN::Locales;

    $lh-&gt;{'Locales.pm'}{'_main_'} ||= $lh-&gt;get_locales_obj();

    my $langname  = {};
    my $native    = wantarray &amp;&amp; $Cpanel::CPAN::Locales::VERSION &gt; 0.06 ? {} : undef;
    my $direction = wantarray &amp;&amp; $Cpanel::CPAN::Locales::VERSION &gt; 0.09 ? {} : undef;

    for my $code ( 'en', @langcodes ) {    # en since it is &quot;built in&quot;
        if ( defined $native ) {
            $native-&gt;{$code} = $lh-&gt;{'Locales.pm'}{'_main_'}-&gt;get_native_language_from_code( $code, 1 );
        }

        $langname-&gt;{$code} = $_NATIVE_ONLY ? $native-&gt;{$code} : $lh-&gt;{'Locales.pm'}{'_main_'}-&gt;get_language_from_code( $code, 1 );

        if ( defined $direction ) {
            $direction-&gt;{$code} = $lh-&gt;{'Locales.pm'}{'_main_'}-&gt;get_character_orientation_from_code_fast($code);
        }
    }

    return wantarray ? ( $langname, $native, $direction ) : $langname;
}

sub loadable_lang_names_hashref {
    my ( $lh, @langcodes ) = @_;

    my $langname = $lh-&gt;lang_names_hashref(@langcodes);

    for my $tag ( keys %{$langname} ) {
        delete $langname-&gt;{$tag} if !$lh-&gt;langtag_is_loadable($tag);
    }

    return $langname;
}

sub add_lexicon_override_hash {
    my ( $lh, $langtag, $name, $hr ) = @_;
    if ( @_ == 3 ) {
        $hr      = $name;
        $name    = $langtag;
        $langtag = $lh-&gt;get_language_tag();
    }

    my $ns = $lh-&gt;get_language_tag() eq $langtag ? $lh-&gt;get_language_class() : $lh-&gt;get_base_class();

    no strict 'refs';
    if ( my $ref = tied( %{ $ns . '::Lexicon' } ) ) {
        return 1 if $lh-&gt;{'add_lex_hash_silent_if_already_added'} &amp;&amp; exists $ref-&gt;{'hashes'} &amp;&amp; exists $ref-&gt;{'hashes'}{$name};
        if ( $ref-&gt;can('add_lookup_override_hash') ) {
            return $ref-&gt;add_lookup_override_hash( $name, $hr );
        }
    }

    my $cur_errno = $!;
    if ( eval { require Sub::Todo } ) {
        goto &amp;Sub::Todo::todo;
    }
    else {
        $! = $cur_errno;
        return;
    }
}

sub add_lexicon_fallback_hash {
    my ( $lh, $langtag, $name, $hr ) = @_;
    if ( @_ == 3 ) {
        $hr      = $name;
        $name    = $langtag;
        $langtag = $lh-&gt;get_language_tag();
    }

    my $ns = $lh-&gt;get_language_tag() eq $langtag ? $lh-&gt;get_language_class() : $lh-&gt;get_base_class();

    no strict 'refs';
    if ( my $ref = tied( %{ $ns . '::Lexicon' } ) ) {
        return 1 if $lh-&gt;{'add_lex_hash_silent_if_already_added'} &amp;&amp; exists $ref-&gt;{'hashes'} &amp;&amp; exists $ref-&gt;{'hashes'}{$name};
        if ( $ref-&gt;can('add_lookup_fallback_hash') ) {
            return $ref-&gt;add_lookup_fallback_hash( $name, $hr );
        }
    }

    my $cur_errno = $!;
    if ( eval { require Sub::Todo } ) {
        goto &amp;Sub::Todo::todo;
    }
    else {
        $! = $cur_errno;
        return;
    }
}

sub del_lexicon_hash {
    my ( $lh, $langtag, $name ) = @_;

    if ( @_ == 2 ) {
        return if $langtag eq '*';
        $name    = $langtag;
        $langtag = '*';
    }

    return if !$langtag;

    my $count = 0;
    if ( $langtag eq '*' ) {
        no strict 'refs';
        for my $ns ( $lh-&gt;get_base_class(), $lh-&gt;get_language_class() ) {
            if ( my $ref = tied( %{ $ns . '::Lexicon' } ) ) {
                if ( $ref-&gt;can('del_lookup_hash') ) {
                    $ref-&gt;del_lookup_hash($name);
                    $count++;
                }
            }
        }

        return 1 if $count;

        my $cur_errno = $!;
        if ( eval { require Sub::Todo } ) {
            goto &amp;Sub::Todo::todo;
        }
        else {
            $! = $cur_errno;
            return;
        }
    }
    else {
        my $ns = $lh-&gt;get_language_tag() eq $langtag ? $lh-&gt;get_language_class() : $lh-&gt;get_base_class();

        no strict 'refs';
        if ( my $ref = tied( %{ $ns . '::Lexicon' } ) ) {
            if ( $ref-&gt;can('del_lookup_hash') ) {
                return $ref-&gt;del_lookup_hash($name);
            }
        }

        my $cur_errno = $!;
        if ( eval { require Sub::Todo } ) {
            goto &amp;Sub::Todo::todo;
        }
        else {
            $! = $cur_errno;
            return;
        }
    }
}

sub get_language_class {
    return ref( $_[0] ) || $_[0];
}


sub get_base_class_dir {
    my ($lh) = @_;
    if ( !exists $lh-&gt;{'Cpanel::CPAN::Locale::Maketext::Utils'}{'_base_clase_dir'} ) {
        $lh-&gt;{'Cpanel::CPAN::Locale::Maketext::Utils'}{'_base_clase_dir'} = undef;

        my $inc_key = $lh-&gt;get_base_class();

        substr( $inc_key, index( $inc_key, '::' ), 2, '/' ) while index( $inc_key, '::' ) &gt; -1;
        $inc_key .= '.pm';
        if ( exists $INC{$inc_key} ) {
            if ( -e $INC{$inc_key} ) {
                my $hr = $lh-&gt;{'Cpanel::CPAN::Locale::Maketext::Utils'};
                $hr-&gt;{'_base_clase_dir'} = $INC{$inc_key};
                substr( $hr-&gt;{'_base_clase_dir'}, -3, 3, '' ) if substr( $hr-&gt;{'_base_clase_dir'}, -3 ) eq '.pm';
            }
        }
    }

    return $lh-&gt;{'Cpanel::CPAN::Locale::Maketext::Utils'}{'_base_clase_dir'};
}

sub list_available_locales {
    my ($lh) = @_;

    die &quot;List context only!&quot; if !wantarray;

    my $main_ns_dir = $lh-&gt;get_base_class_dir() || return;
    local $!;
    opendir my $dh, $main_ns_dir or die &quot;Failed to open: $main_ns_dir: $!&quot;;

    return map { ( substr( $_, -3 ) eq '.pm' &amp;&amp; $_ ne 'Utils.pm' &amp;&amp; $_ ne 'Lazy.pm' &amp;&amp; $_ ne 'Context.pm' &amp;&amp; $_ ne 'Fallback.pm' ) ? substr( $_, 0, -3 ) : () } readdir($dh);    #de-taint
}

sub get_asset {
    my ( $lh, $code, $tag ) = @_;                                                                                                                                                # No caching since $code can do anything.

    my $root = $tag || $lh-&gt;get_language_tag;
    my $ret;

    die &quot;Invalid locale: $root&quot; if index( $root, '/' ) &gt; -1;

    $ret = $code-&gt;($root);
    return $ret if defined $ret;

    my $loc;    # buffer
    my %seen = ( $root =&gt; 1 );

    my @fallback_locales;
    if ( $lh-&gt;_has_fallback_list($root) ) {
        my $loc_obj = $lh-&gt;get_locales_obj($tag);
        @fallback_locales = $loc_obj-&gt;get_fallback_list( $lh-&gt;{'Locales.pm'}{'get_fallback_list_special_lookup_coderef'} );
    }
    elsif ( $root ne 'en' ) {

        my $super = ( split( m{_}, $root ) )[0];
        @fallback_locales = (
            ( $super ne $root &amp;&amp; $super ne 'i' ? $super : () ),
            'en'
        );
    }

    for $loc (@fallback_locales) {
        next if $seen{$loc};    # get_fallback_list can provide back dupes and its expensive to enumerate each one

        $ret = $code-&gt;($loc);
        $seen{$loc}++;
        last if defined $ret;
    }

    return $ret if defined $ret;
    return;
}

sub _has_fallback_list {
    return $_[0]-&gt;{'_has_fallback_list'}{ $_[1] } if defined $_[0]-&gt;{'_has_fallback_list'}{ $_[1] };
    my $size = -s LOCALE_FALLBACK_CACHE_DIR . '/' . $_[1];
    return ( $_[0]-&gt;{'_has_fallback_list'}{ $_[1] } = ( !defined $size || $size ) ? 1 : 0 );
}

sub get_asset_file {
    my ( $lh, $find, $return ) = @_;
    $return = $find if !defined $return;

    return $lh-&gt;{'cache'}{'get_asset_file'}{$find}{$return} if exists $lh-&gt;{'cache'}{'get_asset_file'}{$find}{$return};

    $lh-&gt;{'cache'}{'get_asset_file'}{$find}{$return} = $lh-&gt;get_asset(
        sub {
            return sprintf( $return, $_[0] ) if -f sprintf( $find, $_[0] );
            return;
        }
    );

    return $lh-&gt;{'cache'}{'get_asset_file'}{$find}{$return} if defined $lh-&gt;{'cache'}{'get_asset_file'}{$find}{$return};
    return;
}

sub get_asset_dir {
    my ( $lh, $find, $return ) = @_;
    $return = $find if !defined $return;

    return $lh-&gt;{'cache'}{'get_asset_dir'}{$find}{$return} if exists $lh-&gt;{'cache'}{'get_asset_dir'}{$find}{$return};

    $lh-&gt;{'cache'}{'get_asset_dir'}{$find}{$return} = $lh-&gt;get_asset(
        sub {
            return sprintf( $return, $_[0] ) if -d sprintf( $find, $_[0] );
            return;
        }
    );

    return $lh-&gt;{'cache'}{'get_asset_dir'}{$find}{$return} if defined $lh-&gt;{'cache'}{'get_asset_dir'}{$find}{$return};
    return;
}

sub delete_cache {
    my ( $lh, $which ) = @_;
    if ( defined $which ) {
        return delete $lh-&gt;{'cache'}{$which};
    }
    else {
        return delete $lh-&gt;{'cache'};
    }
}


sub quant {
    my ( $handle, $num, @forms ) = @_;

    my $max_decimal_places = 3;

    if ( ref($num) eq 'ARRAY' ) {
        $max_decimal_places = $num-&gt;[1];
        $num                = $num-&gt;[0];
    }

    $handle-&gt;{'Locales.pm'}{'_main_'} ||= $handle-&gt;get_locales_obj();

    my ( $string, $spec_zero ) = $handle-&gt;{'Locales.pm'}{'_main_'}-&gt;get_plural_form( $num, @forms );

    if ( index( $string, '%s' ) &gt; -1 ) {
        return sprintf( $string, $handle-&gt;numf( $num, $max_decimal_places ) );
    }
    elsif ( $num == 0 &amp;&amp; $spec_zero ) {
        return $string;
    }
    else {
        $handle-&gt;numf( $num, $max_decimal_places ) . &quot; $string&quot;;
    }
}

sub numerate {
    my ( $handle, $num, @forms ) = @_;

    $handle-&gt;{'Locales.pm'}{'_main_'} ||= $handle-&gt;get_locales_obj();

    return scalar( $handle-&gt;{'Locales.pm'}{'_main_'}-&gt;get_plural_form( $num, @forms ) );
}


sub numf {
    my ( $handle, $num, $max_decimal_places ) = @_;

    $handle-&gt;{'Locales.pm'}{'_main_'} ||= $handle-&gt;get_locales_obj();

    return $handle-&gt;{'Locales.pm'}{'_main_'}-&gt;get_formatted_decimal( $num, $max_decimal_places );
}


sub join {
    shift;
    return CORE::join( shift, map { ref($_) eq 'ARRAY' ? @{$_} : $_ } @_ );
}

sub list_and {
    my $lh = shift;

    $lh-&gt;{'Locales.pm'}{'_main_'} ||= $lh-&gt;get_locales_obj();

    return $lh-&gt;{'Locales.pm'}{'_main_'}-&gt;get_list_and( map { ref($_) eq 'ARRAY' ? @{$_} : $_ } @_ );
}

sub list_or {
    my $lh = shift;

    $lh-&gt;{'Locales.pm'}{'_main_'} ||= $lh-&gt;get_locales_obj();

    return $lh-&gt;{'Locales.pm'}{'_main_'}-&gt;get_list_or( map { ref($_) eq 'ARRAY' ? @{$_} : $_ } @_ );
}

sub list_and_quoted {
    my ( $lh, @args ) = @_;

    $lh-&gt;{'Locales.pm'}{'_main_'} ||= $lh-&gt;get_locales_obj();
    local $lh-&gt;{'Locales.pm'}{'_main_'}{'misc'}{'list_quote_mode'} = 'all';
    return $lh-&gt;list_and(@args);
}

sub list_or_quoted {
    my ( $lh, @args ) = @_;

    $lh-&gt;{'Locales.pm'}{'_main_'} ||= $lh-&gt;get_locales_obj();
    local $lh-&gt;{'Locales.pm'}{'_main_'}{'misc'}{'list_quote_mode'} = 'all';
    return $lh-&gt;list_or(@args);
}

sub output_asis {
    return $_[1];
}

sub asis {
    return $_[0]-&gt;output( 'asis', $_[1] );    # this allows for embedded methods but still called via [asis,...] instead of [output,asis,...]
}

sub comment {
    return '';
}

sub is_future {
    my ( $lh, $dt, $future, $past, $current, $current_type ) = @_;

    if ( $dt =~ tr{0-9}{}c ) {
        $dt = __get_dt_obj_from_arg( $dt, 0 );
        $dt = $dt-&gt;epoch();
    }

    if ($current) {
        if ( !ref $dt ) {
            $dt = __get_dt_obj_from_arg( $dt, 0 );
        }
        $current_type ||= 'hour';

        if ( $current_type eq 'day' ) {

        }
        elsif ( $current_type eq 'minute' ) {

        }
        else {

        }
    }

    return ref $dt ? $dt-&gt;epoch() : $dt &gt; time() ? $future : $past;
}

sub __get_dt_obj_from_arg {
    require    # hide from Cpanel::Static
      DateTime;
    return
       !defined $_[0] || $_[0] eq ''                                 ? DateTime-&gt;now()
      : ref $_[0] eq 'HASH'                                          ? DateTime-&gt;new( %{ $_[0] } )
      : $_[0] =~ m{ \A (\d+ (?: [.] \d+ )? ) (?: [:] (.*) )? \z }xms ? DateTime-&gt;from_epoch( 'epoch' =&gt; $1, 'time_zone' =&gt; ( $2 || 'UTC' ) )
      : !ref $_[0]                                                   ? DateTime-&gt;now( 'time_zone' =&gt; ( $_[0] || 'UTC' ) )
      : $_[1]                                                        ? $_[0]-&gt;clone()
      :                                                                $_[0];
}

sub current_year {
    $_[0]-&gt;datetime( '', 'YYYY' );
}

sub datetime {
    my ( $lh, $dta, $str ) = @_;
    my $dt = __get_dt_obj_from_arg( $dta, 1 );

    if ( !$INC{'DateTime/Locale.pm'} ) {    # __get_dt_obj_from_arg is loading DateTime
        eval q{ require DateTime::Locale; 1 } or die &quot;Cannot load DateTime::Locale: $!&quot;;
    }

    $dt-&gt;{'locale'} = DateTime::Locale-&gt;load( $lh-&gt;language_tag() );
    my $format = ref $str eq 'CODE' ? $str-&gt;($dt) : $str;
    if ( defined $format ) {
        if ( $dt-&gt;{'locale'}-&gt;can($format) ) {
            $format = $dt-&gt;{'locale'}-&gt;$format();
        }
    }
    $format = '' if !defined $format;

    return $dt-&gt;format_cldr( $dt-&gt;{'locale'}-&gt;format_for($format) || $format || $dt-&gt;{'locale'}-&gt;date_format_long() );
}

sub output_amp  { return $_[0]-&gt;output_chr(38) }
sub output_lt   { return $_[0]-&gt;output_chr(60) }    # TODO: ? make the rest of these embeddable like amp() ?
sub output_gt   { return $_[0]-&gt;output_chr(62) }
sub output_apos { return $_[0]-&gt;output_chr(39) }
sub output_quot { return $_[0]-&gt;output_chr(34) }
sub output_shy  { return $_[0]-&gt;output_chr(173) }


use constant output_nbsp =&gt; &quot;\xC2\xA0&quot;;


my $space;

sub format_bytes {
    my ( $lh, $bytes, $max_decimal_place ) = @_;
    $bytes ||= 0;

    if ( !defined $max_decimal_place ) {
        $max_decimal_place = 2;
    }
    else {
        $max_decimal_place = int( abs($max_decimal_place) );
    }

    my $absnum = abs($bytes);

    $space ||= $lh-&gt;output_nbsp();    # avoid method call if we already have it

    if ( $absnum &lt; 1024 ) {

        return ( $lh-&gt;{'_format_bytes_cache'}{ $bytes . '_' . $max_decimal_place } ||= $lh-&gt;maketext( '[quant,_1,%s byte,%s bytes]', [ $bytes, $max_decimal_place ] ) );    # the space between the '%s' and the 'b' is a non-break space (e.g. option-spacebar, not spacebar)
    }
    elsif ( $absnum &lt; 1048576 ) {
        return $lh-&gt;numf( ( $bytes / 1024 ), $max_decimal_place ) . $space . 'KB';
    }
    elsif ( $absnum &lt; 1073741824 ) {
        return $lh-&gt;numf( ( $bytes / 1048576 ), $max_decimal_place ) . $space . 'MB';
    }
    elsif ( $absnum &lt; 1099511627776 ) {
        return $lh-&gt;numf( ( $bytes / 1073741824 ), $max_decimal_place ) . $space . 'GB';
    }
    elsif ( $absnum &lt; 1125899906842624 ) {
        return $lh-&gt;numf( ( $bytes / 1099511627776 ), $max_decimal_place ) . $space . 'TB';
    }
    elsif ( $absnum &lt; ( 1125899906842624 * 1024 ) ) {
        return $lh-&gt;numf( ( $bytes / 1125899906842624 ), $max_decimal_place ) . $space . 'PB';
    }
    elsif ( $absnum &lt; ( 1125899906842624 * 1024 * 1024 ) ) {
        return $lh-&gt;numf( ( $bytes / ( 1125899906842624 * 1024 ) ), $max_decimal_place ) . $space . 'EB';
    }
    elsif ( $absnum &lt; ( 1125899906842624 * 1024 * 1024 * 1024 ) ) {
        return $lh-&gt;numf( ( $bytes / ( 1125899906842624 * 1024 * 1024 ) ), $max_decimal_place ) . $space . 'ZB';
    }
    else {

        return $lh-&gt;numf( ( $bytes / ( 1125899906842624 * 1024 * 1024 * 1024 ) ), $max_decimal_place ) . $space . 'YB';

    }
}

sub convert {
    die __PACKAGE__ . &quot;::convert is not supported (missing Math::Units)&quot;;
}

sub is_defined {
    my ( $lh, $value, $is_defined, $not_defined, $is_defined_but_false ) = @_;

    return __proc_string_with_embedded_under_vars($not_defined) if !defined $value;

    if ( defined $is_defined_but_false &amp;&amp; !$value ) {
        return __proc_string_with_embedded_under_vars($is_defined_but_false);
    }
    else {
        return __proc_string_with_embedded_under_vars($is_defined);
    }
}

sub boolean {
    my ( $lh, $boolean, $true, $false, $null ) = @_;
    if ($boolean) {
        return __proc_string_with_embedded_under_vars($true);
    }
    else {
        if ( !defined $boolean &amp;&amp; defined $null ) {
            return __proc_string_with_embedded_under_vars($null);
        }
        return __proc_string_with_embedded_under_vars($false);
    }
}

sub __proc_string_with_embedded_under_vars {
    my $str = $_[0];
    return $str if index( $str, '_' ) == -1 || $str !~ m/$FORCE_REGEX_LAZY\_(?:\-?[0-9]+)/o;
    my @args = __caller_args( $_[1] );    # this way be dragons
    $str =~ s/$FORCE_REGEX_LAZY\_(\-?[0-9]+)/$args[$1]/og;
    return $str;
}

sub __caller_args {

    package DB;
    () = caller( $_[0] + 3 );
    return @DB::args;
}

sub __proc_emb_meth {
    my ( $lh, $str ) = @_;

    $str =~ s/$FORCE_REGEX_LAZY(su[bp])\(((?:\\\)|[^\)])+?)\)/my $s=$2;my $m=&quot;output_$1&quot;;$s=~s{\\\)}{\)}g;$lh-&gt;$m($s)/oeg if index( $str, 'su' ) &gt; -1;
    $str =~ s/${FORCE_REGEX_LAZY}chr\(((?:\d+|[\S]))\)/$lh-&gt;output_chr($1)/oeg                                            if index( $str, 'chr(' ) &gt; -1;
    $str =~ s/${FORCE_REGEX_LAZY}numf\((\d+(?:\.\d+)?)\)/$lh-&gt;numf($1)/oeg                                                if index( $str, 'numf(' ) &gt; -1;
    substr( $str, index( $str, 'amp()' ), 5, $lh-&gt;output_amp() ) while index( $str, 'amp()' ) &gt; -1;

    return $str;
}

sub output {
    my ( $lh, $output_function, $string, @output_function_args ) = @_;

    if ( defined $string &amp;&amp; $string ne '' &amp;&amp; index( $string, '(' ) &gt; -1 ) {
        $string = __proc_emb_meth( $lh, $string );
    }

    if ( $output_function eq 'url' &amp;&amp; defined $output_function_args[0] &amp;&amp; $output_function_args[0] ne '' &amp;&amp; index( $output_function_args[0], '(' ) &gt; -1 ) {
        $output_function_args[0] = __proc_emb_meth( $lh, $output_function_args[0] );
    }
    if ( my $cr = ( $lh-&gt;{'_output_function_cache'}{$output_function} ||= $lh-&gt;can( 'output_' . $output_function ) ) ) {
        return $cr-&gt;( $lh, $string, @output_function_args );
    }
    else {
        my $cur_errno = $!;
        if ( eval { require Sub::Todo } ) {
            $! = Sub::Todo::get_errno_func_not_impl();
        }
        else {
            $! = $cur_errno;
        }
        return $string;
    }
}

sub output_encode_puny {
    my ( $self, $s ) = @_;
    require    # do not include it in updatenow.static
      Cpanel::Encoder::Punycode;
    return Cpanel::Encoder::Punycode::punycode_encode_str($s);
}

sub output_decode_puny {
    my ( $self, $s ) = @_;
    require    # do not include it in updatenow.static
      Cpanel::Encoder::Punycode;
    return Cpanel::Encoder::Punycode::punycode_decode_str($s);
}

my $has_encode;    # checking for Encode this way facilitates only checking @INC once for the module on systems that do not have Encode

sub output_chr {
    my ( $lh, $chr_num ) = @_;

    if ( $chr_num !~ m/$FORCE_REGEX_LAZY\A\d+\z/o ) {
        return          if length($chr_num) != 1;
        return $chr_num if !$lh-&gt;context_is_html();

        return
            $chr_num eq '&quot;' ? '&amp;quot;'
          : $chr_num eq '&amp;' ? '&amp;amp;'
          : $chr_num eq &quot;'&quot; ? '&amp;#39;'
          : $chr_num eq '&lt;' ? '&amp;lt;'
          : $chr_num eq '&gt;' ? '&amp;gt;'
          :                   $chr_num;
    }
    return if $chr_num !~ m/$FORCE_REGEX_LAZY\A\d+\z/o;
    my $chr = chr($chr_num);

    if ( $chr_num &gt; 127 ) {

        if ( !defined $has_encode ) {
            $has_encode = 0;
            eval { require Encode; $has_encode = 1; };
        }

        if ($has_encode) {
            $chr = Encode::encode( $lh-&gt;encoding(), $chr );
        }

        else {


            $chr = eval '&quot;\x{' . sprintf( '%04X', $chr_num ) . '}&quot;';
        }
    }

    if ( !$lh-&gt;context_is_html() ) {
        return $chr;
    }
    else {
        return
            $chr_num == 34 || $chr_num == 147 || $chr_num == 148 ? '&amp;quot;'
          : $chr_num == 38                                       ? '&amp;amp;'
          : $chr_num == 39 || $chr_num == 145 || $chr_num == 146 ? '&amp;#39;'
          : $chr_num == 60                                       ? '&amp;lt;'
          : $chr_num == 62                                       ? '&amp;gt;'
          : $chr_num == 173                                      ? '&amp;shy;'
          :                                                        $chr;
    }
}

sub output_class {
    my ( $lh, $string, @classes ) = @_;
    $string = __proc_string_with_embedded_under_vars( $string, 1 );
    return $string if $lh-&gt;context_is_plain();

    return $lh-&gt;context_is_ansi() ? &quot;\e[1m$string\e[0m&quot; : qq{&lt;span class=&quot;@classes&quot;&gt;$string&lt;/span&gt;};
}

sub output_asis_for_tests {
    my ( $lh, $string ) = @_;
    $string = __proc_string_with_embedded_under_vars( $string, 1 );
    return $string;
}

sub __make_attr_str_from_ar {
    my ( $attr_ar, $strip_hr, $addin ) = @_;
    if ( ref($attr_ar) eq 'HASH' ) {
        $strip_hr = $attr_ar;
        $attr_ar  = [];
    }

    my $attr       = '';
    my $general_hr = ref( $attr_ar-&gt;[-1] ) eq 'HASH' ? pop( @{$attr_ar} ) : undef;

    my $idx    = 0;
    my $ar_len = @{$attr_ar};

    $idx = 1 if $ar_len % 2;    # handle “Odd number of elements” …

    my $did_addin;

    while ( $idx &lt; $ar_len ) {
        if ( exists $strip_hr-&gt;{ $attr_ar-&gt;[$idx] } ) {
            $idx += 2;
            next;
        }
        my $atr = $attr_ar-&gt;[$idx];
        my $val = $attr_ar-&gt;[ ++$idx ];
        if ( exists $addin-&gt;{$atr} ) {
            $val = &quot;$addin-&gt;{$atr} $val&quot;;
            $did_addin-&gt;{$atr}++;
        }

        $attr .= qq{ $atr=&quot;$val&quot;};
        $idx++;
    }

    if ($general_hr) {
        for my $k ( keys %{$general_hr} ) {
            next if exists $strip_hr-&gt;{$k};
            if ( exists $addin-&gt;{$k} ) {
                $general_hr-&gt;{$k} = &quot;$addin-&gt;{$k} $general_hr-&gt;{$k}&quot;;
                $did_addin-&gt;{$k}++;
            }
            $attr .= qq{ $k=&quot;$general_hr-&gt;{$k}&quot;};
        }
    }

    for my $r ( keys %{$addin} ) {
        if ( !exists $did_addin-&gt;{$r} ) {
            $attr .= qq{ $r=&quot;$addin-&gt;{$r}&quot;};
        }
    }

    return $attr;
}

sub output_inline {
    my ( $lh, $string, @attrs ) = @_;
    $string = __proc_string_with_embedded_under_vars( $string, 1 );
    return $string if !$lh-&gt;context_is_html();

    my $attr = __make_attr_str_from_ar( \@attrs );
    return qq{&lt;span$attr&gt;$string&lt;/span&gt;};
}

*output_attr = \&amp;output_inline;

sub output_block {
    my ( $lh, $string, @attrs ) = @_;
    $string = __proc_string_with_embedded_under_vars( $string, 1 );
    return $string if !$lh-&gt;context_is_html();

    my $attr = __make_attr_str_from_ar( \@attrs );
    return qq{&lt;div$attr&gt;$string&lt;/div&gt;};
}

sub output_img {
    my ( $lh, $src, $alt, @attrs ) = @_;

    if ( !defined $alt || $alt eq '' ) {
        $alt = $src;
    }
    else {
        $alt = __proc_string_with_embedded_under_vars( $alt, 1 );
    }

    return $alt if !$lh-&gt;context_is_html();

    my $attr = __make_attr_str_from_ar( \@attrs, { 'alt' =&gt; 1, 'src' =&gt; 1 } );
    return qq{&lt;img src=&quot;$src&quot; alt=&quot;$alt&quot;$attr/&gt;};
}

sub output_abbr {
    my ( $lh, $abbr, $full, @attrs ) = @_;
    return !$lh-&gt;context_is_html()
      ? &quot;$abbr ($full)&quot;
      : qq{&lt;abbr title=&quot;$full&quot;} . __make_attr_str_from_ar( \@attrs, { 'title' =&gt; 1 } ) . qq{&gt;$abbr&lt;/abbr&gt;};
}

sub output_acronym {
    my ( $lh, $acronym, $full, @attrs ) = @_;

    return !$lh-&gt;context_is_html()
      ? &quot;$acronym ($full)&quot;
      : qq{&lt;abbr title=&quot;$full&quot;} . __make_attr_str_from_ar( \@attrs, { 'title' =&gt; 1 }, { 'class' =&gt; 'initialism' } ) . qq{&gt;$acronym&lt;/abbr&gt;};
}

sub output_sup {
    my ( $lh, $string, @attrs ) = @_;
    $string = __proc_string_with_embedded_under_vars( $string, 1 );
    return !$lh-&gt;context_is_html() ? $string : qq{&lt;sup} . __make_attr_str_from_ar( \@attrs ) . qq{&gt;$string&lt;/sup&gt;};
}

sub output_sub {
    my ( $lh, $string, @attrs ) = @_;
    $string = __proc_string_with_embedded_under_vars( $string, 1 );
    return !$lh-&gt;context_is_html() ? $string : qq{&lt;sub} . __make_attr_str_from_ar( \@attrs ) . qq{&gt;$string&lt;/sub&gt;};
}

sub output_underline {
    my ( $lh, $string, @attrs ) = @_;

    $string = __proc_string_with_embedded_under_vars( $string, 1 );
    return $string if $lh-&gt;context_is_plain();
    return $lh-&gt;context_is_ansi() ? &quot;\e[4m$string\e[0m&quot; : qq{&lt;span style=&quot;text-decoration: underline&quot;} . __make_attr_str_from_ar( \@attrs ) . qq{&gt;$string&lt;/span&gt;};
}

sub output_strong {
    my ( $lh, $string, @attrs ) = @_;

    $string = __proc_string_with_embedded_under_vars( $string, 1 );
    return $string if $lh-&gt;context_is_plain();
    return $lh-&gt;context_is_ansi() ? &quot;\e[1m$string\e[0m&quot; : '&lt;strong' . __make_attr_str_from_ar( \@attrs ) . &quot;&gt;$string&lt;/strong&gt;&quot;;
}

sub output_em {
    my ( $lh, $string, @attrs ) = @_;

    $string = __proc_string_with_embedded_under_vars( $string, 1 );
    return $string if $lh-&gt;context_is_plain();

    return $lh-&gt;context_is_ansi() ? &quot;\e[3m$string\e[0m&quot; : '&lt;em' . __make_attr_str_from_ar( \@attrs ) . &quot;&gt;$string&lt;/em&gt;&quot;;
}


sub output_url {
    my ( $lh, $url, @args ) = @_;
    $url ||= '';    # carp() ?

    my $arb_args_hr = ref $args[-1] eq 'HASH' ? pop(@args) : {};
    my ( $url_text, %output_config ) = @args % 2 ? @args : ( undef, @args );

    my $return = $url;

    if ( !$lh-&gt;context_is_html() ) {
        if ($url_text) {
            return &quot;$url_text ($url)&quot;;
        }

        if ( exists $output_config{'plain'} ) {
            $output_config{'plain'} ||= $url;
            my $orig = $output_config{'plain'};
            $output_config{'plain'} = __proc_string_with_embedded_under_vars( $output_config{'plain'}, 1 );
            $return = $orig ne $output_config{'plain'} &amp;&amp; $output_config{'plain'} =~ m/\Q$url\E/ ? $output_config{'plain'} : &quot;$output_config{'plain'} $url&quot;;
        }
    }
    else {
        if ( exists $output_config{'html'} ) {
            $output_config{'html'} = __proc_string_with_embedded_under_vars( $output_config{'html'}, 1 );
        }

        $output_config{'html'} ||= $url_text || $url;

        my $attr = __make_attr_str_from_ar(
            [ @args, $arb_args_hr ],
            {
                'html'  =&gt; 1,
                'plain' =&gt; 1,
                '_type' =&gt; 1,
            }
        );

        $return = exists $output_config{'_type'}
          &amp;&amp; $output_config{'_type'} eq 'offsite' ? qq{&lt;a$attr target=&quot;_blank&quot; class=&quot;offsite&quot; href=&quot;$url&quot;&gt;$output_config{'html'}&lt;/a&gt;} : qq{&lt;a$attr href=&quot;$url&quot;&gt;$output_config{'html'}&lt;/a&gt;};
    }

    return $return;
}


sub set_context_html {
    my ($lh) = @_;
    my $cur = $lh-&gt;get_context();
    $lh-&gt;set_context('html');
    return if !$lh-&gt;context_is_html();
    return $cur;
}

sub set_context_ansi {
    my ($lh) = @_;
    my $cur = $lh-&gt;get_context();
    $lh-&gt;set_context('ansi');
    return if !$lh-&gt;context_is_ansi();
    return $cur;
}

sub set_context_plain {
    my ($lh) = @_;
    my $cur = $lh-&gt;get_context();
    $lh-&gt;set_context('plain');
    return if !$lh-&gt;context_is_plain();
    return $cur;
}

my %contexts = (
    'plain' =&gt; undef(),
    'ansi'  =&gt; 1,
    'html'  =&gt; 0,
);

sub set_context {
    my ( $lh, $context ) = @_;

    if ( !$context ) {
        $lh-&gt;{'-t-STDIN'} = -t *STDIN ? 1 : 0;
    }
    elsif ( exists $contexts{$context} ) {
        $lh-&gt;{'-t-STDIN'} = $contexts{$context};
    }
    else {
        require Carp;
        local $Carp::CarpLevel = 1;
        Carp::carp(&quot;Given context '$context' is unknown.&quot;);
        $lh-&gt;{'-t-STDIN'} = $context;
    }
}

sub context_is_html {
    return $_[0]-&gt;get_context() eq 'html';
}

sub context_is_ansi {
    return $_[0]-&gt;get_context() eq 'ansi';
}

sub context_is_plain {
    return $_[0]-&gt;get_context() eq 'plain';
}

sub context_is {
    return $_[0]-&gt;get_context() eq $_[1];
}

sub get_context {
    $_[0]-&gt;set_context() if !exists $_[0]-&gt;{'-t-STDIN'};
    return
        !defined $_[0]-&gt;{'-t-STDIN'} ? 'plain'
      : $_[0]-&gt;{'-t-STDIN'}          ? 'ansi'
      :                                'html';
}

sub maketext_html_context {
    my ( $lh, @mt_args ) = @_;
    my $cur = $lh-&gt;set_context_html();
    my $res = $lh-&gt;maketext(@mt_args);
    $lh-&gt;set_context($cur);
    return $res;
}

sub maketext_ansi_context {
    my ( $lh, @mt_args ) = @_;
    my $cur = $lh-&gt;set_context_ansi();
    my $res = $lh-&gt;maketext(@mt_args);
    $lh-&gt;set_context($cur);
    return $res;
}

sub maketext_plain_context {
    my ( $lh, @mt_args ) = @_;
    my $cur = $lh-&gt;set_context_plain();
    my $res = $lh-&gt;maketext(@mt_args);
    $lh-&gt;set_context($cur);
    return $res;
}


1;

} # --- END Cpanel/CPAN/Locale/Maketext/Utils.pm


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


use strict;
use warnings;

use constant {
    get_legacy_lang_cache_root =&gt; '/var/cpanel/lang.cache',
    get_i_locales_config_path  =&gt; '/var/cpanel/i_locales',
    get_custom_whitelist_path  =&gt; '/var/cpanel/maketext_whitelist'
};

sub get_locale_database_root   { return '/var/cpanel/locale' }
sub get_locale_yaml_root       { return '/usr/local/cpanel/locale' }
sub get_legacy_lang_root       { return '/usr/local/cpanel/lang' }
sub get_locale_yaml_local_root { return '/var/cpanel/locale.local' }

1;

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


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


use strict;
use warnings;

BEGIN {
    eval { require CDB_File; };
}

# use Cpanel::Locale::Utils::Paths ();


$Cpanel::Locale::Utils::i_am_the_compiler = 0;

my $logger;

sub _logger {
    require Cpanel::Logger;
    $logger ||= Cpanel::Logger-&gt;new();
}


sub get_readonly_tie {
    my ( $cdb_file, $cdb_hr ) = @_;
    if ( !$cdb_file ) {
        _logger()-&gt;warn('Undefined CDB file specified for readonly operation');
        return;
    }
    elsif ( !$INC{'CDB_File.pm'} || !exists $CDB_File::{'TIEHASH'} ) {
        _logger()-&gt;warn(&quot;Failed to load CDB_File.pm&quot;) if $^X ne '/usr/bin/perl';
        return;
    }

    my $tie_obj = tie %{$cdb_hr}, 'CDB_File', $cdb_file;

    if ( !$tie_obj &amp;&amp; !-e $cdb_file ) {
        _logger()-&gt;warn(&quot;Missing CDB file $cdb_file specified for readonly operation&quot;);
        return;

    }

    eval { exists $cdb_hr-&gt;{'__VERSION'} };
    if ($@) {
        $tie_obj = undef;
        untie %$cdb_hr;
    }

    if ( !$tie_obj ) {
        _logger()-&gt;warn(&quot;CDB_File could not get read-only association to '$cdb_file': $!&quot;);
    }

    return $tie_obj;
}

sub create_cdb {
    my ( $cdb_file, $cdb_hr ) = @_;

    if ( !$cdb_file ) {
        _logger()-&gt;warn('Undefined CDB file specified for writable operation');
        return;
    }

    return CDB_File::create( %{$cdb_hr}, $cdb_file, &quot;$cdb_file.$$&quot; );
}

sub get_writable_tie {
    require Carp;
    Carp::confess(&quot;cdb files are not writable&quot;);
}

sub init_lexicon {
    my ( $langtag, $hr, $version_sr, $encoding_sr ) = @_;
    my $cdb_file;
    my $db_root = Cpanel::Locale::Utils::Paths::get_locale_database_root();

    for my $file ( $Cpanel::CPDATA{'RS'} ? (&quot;themes/$Cpanel::CPDATA{RS}/$langtag.cdb&quot;) : (), &quot;$langtag.cdb&quot; ) {    # PPI NO PARSE - Only include Cpanel() when some other module uses it
        if ( -e &quot;$db_root/$file&quot; ) {
            $cdb_file = &quot;$db_root/$file&quot;;
            last;
        }
    }

    if ( !$cdb_file ) {
        if ( -e Cpanel::Locale::Utils::Paths::get_locale_yaml_root() . &quot;/$langtag.yaml&quot; &amp;&amp; !$Cpanel::Locale::Utils::i_am_the_compiler ) {
            _logger()-&gt;info(qq{Locale needs to be compiled by root (/usr/local/cpanel/bin/build_locale_databases --locale=$langtag)});
        }
        return;
    }


    my $cdb_tie = get_readonly_tie( $cdb_file, $hr );

    if ( exists $hr-&gt;{'__VERSION'} &amp;&amp; ref $version_sr ) {
        ${$version_sr} = $hr-&gt;{'__VERSION'};
    }

    if ( ref $encoding_sr ) {

        ${$encoding_sr} ||= 'utf-8';
    }

    return $cdb_file;
}

sub init_package {
    my ($caller) = caller();

    my ($langtag) = reverse( split( /::/, $caller ) );

    no strict 'refs';
    no warnings 'once';

    ${ $caller . '::CDB_File_Path' } ||= init_lexicon( &quot;$langtag&quot;, \%{ $caller . '::Lexicon' }, \${ $caller . '::VERSION' }, \${ $caller . '::Encoding' }, );

    return;
}

1;

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


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


use strict;

sub username_to_dbowner {
    my ($username) = @_;

    $username =~ tr&lt;_.&gt;&lt;&gt;d if defined $username;

    return $username;
}

1;

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


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


use strict;
use warnings;

our $DEFAULT_CPANEL_THEME = 'jupiter';

our $DEFAULT_CPANEL_MAILONLY_THEME = 'jupiter';

our $DEFAULT_WEBMAIL_THEME = 'jupiter';

our $DEFAULT_WEBMAIL_MAILONLY_THEME = 'jupiter';

our @DORMANT_SERVICES_LIST = qw(cpanalyticsd cpdavd cphulkd cpsrvd dnsadmin spamd);

our $MAX_HOMEDIR_STREAM_TIME = ( 86400 * 2 );

1;

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


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


use strict;

$Cpanel::Imports::VERSION = '0.02';

sub import {
    my $caller = caller;
    no strict 'refs';    ## no critic(ProhibitNoStrict)

    *{ $caller . '::logger' } = \&amp;__logger;
    *{ $caller . '::locale' } = \&amp;__locale;

    return;
}

my ( $logger, $locale );

sub _reset_lazy_facade {    # usually for testing
    $logger = undef;
    $locale = undef;
    return;
}

sub __logger {
    require Cpanel::Logger if !$INC{'Cpanel/Logger.pm'};
    if ( !$logger ) {    # return $var ||= XYZ-&gt;new; works but, we keep it super vanilla to make it more likley to perlcc OK
        $logger = Cpanel::Logger-&gt;new;
    }
    return $logger;
}

sub __locale {
    require Cpanel::Locale if !$INC{'Cpanel/Locale.pm'};
    if ( !$locale ) {    # return $var ||= XYZ-&gt;new; works but, we keep it super vanilla to make it more likley to perlcc OK
        $locale = Cpanel::Locale-&gt;get_handle;
    }
    return $locale;
}

1;


} # --- END Cpanel/Imports.pm


{ # --- BEGIN Cpanel/SSL/KeyTypeLabel.pm
package Cpanel::SSL::KeyTypeLabel;


use cPstrict;


use Cpanel::Imports;


my %_ECDSA_DETAIL = (
    prime256v1 =&gt; 'P-256 (prime256v1)',
    secp384r1  =&gt; 'P-384 (secp384r1)',
);

sub to_label ($the_type) {
    my ( $type, $detail ) = split m&lt;-&gt;, $the_type;

    die _invalid_type_msg($the_type) if !defined $detail;

    $type =~ tr&lt;a-z&gt;&lt;A-Z&gt;;

    if ( $type eq 'RSA' ) {
        $detail = locale()-&gt;maketext( '[numf,_1]-bit', $detail );
    }
    elsif ( $type eq 'ECDSA' ) {
        $detail = $_ECDSA_DETAIL{$detail} or die _invalid_type_msg($the_type);
    }
    else {
        die &quot;need update? ($the_type)&quot;;
    }

    return &quot;$type, $detail&quot;;
}

sub _invalid_type_msg ($the_type) {
    return &quot;Invalid key type: “$the_type”&quot;;
}

1;

} # --- END Cpanel/SSL/KeyTypeLabel.pm


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


use cPstrict;


# use Cpanel::SSL::KeyTypeLabel ();


use constant OPTIONS =&gt; (
    'rsa-2048',
    'ecdsa-secp384r1',
    'ecdsa-prime256v1',
    'rsa-4096',
);


sub OPTIONS_AND_LABELS() {
    local ( $@, $! );
    require Cpanel::Locale;

    my $lh = Cpanel::Locale-&gt;get_handle();

    return map { ( $_ =&gt; Cpanel::SSL::KeyTypeLabel::to_label($_) ) } OPTIONS;
}


sub KEY_DESCRIPTIONS() {
    require Cpanel::Locale;

    my $lh = Cpanel::Locale-&gt;get_handle();

    return {
        &quot;rsa-2048&quot;         =&gt; $lh-&gt;maketext(&quot;[asis,RSA] is more compatible with older clients (for example, browsers older than [asis,Internet Explorer] 11) than [asis,ECDSA]. New installations of [asis,cPanel amp() WHM] ship with this setting.&quot;),
        &quot;rsa-4096&quot;         =&gt; $lh-&gt;maketext( &quot;[asis,RSA] is more compatible with older clients (for example, browsers older than [asis,Internet Explorer] 11) than [asis,ECDSA]. This is more secure than [_1]-bit, but will perform slower than [_1]-bit keys.&quot;, 'RSA, 2,048' ),
        &quot;ecdsa-prime256v1&quot; =&gt; $lh-&gt;maketext(&quot;[asis,ECDSA] allows websites to support [asis,Internet Explorer] 11 and retain compliance with [output,acronym,PCI,Payment Card Industry] standards.&quot;),
        &quot;ecdsa-secp384r1&quot;  =&gt; $lh-&gt;maketext(&quot;[asis,ECDSA] allows websites to support [asis,Internet Explorer] 11 and retain compliance with [output,acronym,PCI,Payment Card Industry] standards. [asis,secp384r1] is more secure than [asis,prime256v1], but may perform slower.&quot;),
    };
}

use constant USER_SYSTEM =&gt; 'system';

1;

} # --- END Cpanel/SSL/DefaultKey/Constants.pm


{ # --- BEGIN Cpanel/Config/CpUser/Defaults.pm
package Cpanel::Config::CpUser::Defaults;


use strict;
use warnings;


# use Cpanel::SSL::DefaultKey::Constants ();


our @DEFAULTS_KV = (
    'BWLIMIT'              =&gt; 'unlimited',
    'CHILD_WORKLOADS'      =&gt; q&lt;&gt;,
    'DEADDOMAINS'          =&gt; undef,
    'DEMO'                 =&gt; 0,
    'DOMAIN'               =&gt; '',
    'DOMAINS'              =&gt; undef,
    'FEATURELIST'          =&gt; 'default',
    'HASCGI'               =&gt; 0,
    'HASDKIM'              =&gt; 0,
    'HASSPF'               =&gt; 0,
    'IP'                   =&gt; '127.0.0.1',
    'MAILBOX_FORMAT'       =&gt; 'maildir',                                         #keep in sync with cpconf
    'MAX_EMAILACCT_QUOTA'  =&gt; 'unlimited',
    'MAXADDON'             =&gt; 0,
    'MAXFTP'               =&gt; 'unlimited',
    'MAXLST'               =&gt; 'unlimited',
    'MAXPARK'              =&gt; 0,
    'MAXPOP'               =&gt; 'unlimited',
    'MAXSQL'               =&gt; 'unlimited',
    'MAXSUB'               =&gt; 'unlimited',
    'OWNER'                =&gt; 'root',
    'PLAN'                 =&gt; 'undefined',
    'RS'                   =&gt; '',
    'STARTDATE'            =&gt; '0000000000',
    'MAXPASSENGERAPPS'     =&gt; 4,
    'SSL_DEFAULT_KEY_TYPE' =&gt; Cpanel::SSL::DefaultKey::Constants::USER_SYSTEM,
);

1;

} # --- END Cpanel/Config/CpUser/Defaults.pm


{ # --- BEGIN Cpanel/Hash/JSONable.pm
package Cpanel::Hash::JSONable;


use cPstrict;


sub TO_JSON ($self) {
    return {%$self};
}

1;

} # --- END Cpanel/Hash/JSONable.pm


{ # --- BEGIN Cpanel/Config/CpUser/Object.pm
package Cpanel::Config::CpUser::Object;


use cPstrict;


# use Cpanel::Hash::JSONable();
our @ISA;
BEGIN { push @ISA, qw(Cpanel::Hash::JSONable); }

use Class::XSAccessor (
    getters =&gt; {
        username =&gt; 'USER',
    },
);


sub adopt ( $class, $ref ) {
    return bless $ref, $class;
}


sub domains_ar ($self) {
    return [ $self-&gt;{'DOMAIN'}, @{ $self-&gt;{'DOMAINS'} } ];
}


sub contact_emails_ar ($self) {
    return [ grep { length } @{$self}{ 'CONTACTEMAIL', 'CONTACTEMAIL2' } ];
}


sub child_workloads ($self) {

    if (wantarray) {
        return if !$self-&gt;{'CHILD_WORKLOADS'};
        return split( m&lt;,&gt;, $self-&gt;{'CHILD_WORKLOADS'}, -1 );
    }

    return 0 if !$self-&gt;{'CHILD_WORKLOADS'};

    return 1 + ( $self-&gt;{'CHILD_WORKLOADS'} =~ tr&lt;,&gt;&lt;&gt; );
}

1;

} # --- END Cpanel/Config/CpUser/Object.pm


{ # --- BEGIN Cpanel/StringFunc/Trim.pm
package Cpanel::StringFunc::Trim;


use strict;
use warnings;

$Cpanel::StringFunc::Trim::VERSION = '1.02';

my %ws_chars = ( &quot;\r&quot; =&gt; undef, &quot;\n&quot; =&gt; undef, &quot; &quot; =&gt; undef, &quot;\t&quot; =&gt; undef, &quot;\f&quot; =&gt; undef );

sub trim {
    my ( $str, $totrim ) = @_;
    $str = rtrim( ltrim( $str, $totrim ), $totrim );
    return $str;
}

sub ltrim {
    my ( $str, $totrim ) = @_;
    $str =~ s/^$totrim*//;
    return $str;
}

sub rtrim {
    my ( $str, $totrim ) = @_;
    $str =~ s/$totrim*$//;
    return $str;
}

sub endtrim {
    my ( $str, $totrim ) = @_;

    if ( substr( $str, ( length($totrim) * -1 ), length($totrim) ) eq $totrim ) {
        return substr( $str, 0, ( length($str) - length($totrim) ) );
    }
    return $str;
}

sub begintrim {
    my ( $str, $totrim ) = @_;

    if (
        defined $str &amp;&amp; defined $totrim    # .
        &amp;&amp; substr( $str, 0, length($totrim) ) eq $totrim
    ) {
        return substr( $str, length($totrim) );
    }
    return $str;
}

sub ws_trim {
    my ($this) = @_;

    return unless defined $this;

    my $fix = ref $this eq 'SCALAR' ? $this : \$this;

    return unless defined $$fix;

    if ( $$fix =~ tr{\r\n \t\f}{} ) {
        ${$fix} =~ s/^\s+// if exists $ws_chars{ substr( $$fix, 0,  1 ) };
        ${$fix} =~ s/\s+$// if exists $ws_chars{ substr( $$fix, -1, 1 ) };
    }
    return ${$fix};
}

sub ws_trim_array {
    my $ar = ref $_[0] eq 'ARRAY' ? $_[0] : [@_];    # [@_] :: copy @_ w/ out unpack first: !! not \@_ in this case !!
    foreach my $idx ( 0 .. scalar( @{$ar} ) - 1 ) {
        $ar-&gt;[$idx] = ws_trim( $ar-&gt;[$idx] );
    }
    return wantarray ? @{$ar} : $ar;
}

sub ws_trim_hash_values {
    my $hr = ref $_[0] eq 'HASH' ? $_[0] : {@_};     # {@_} :: copy @_ w/ out unpack first:
    foreach my $key ( keys %{$hr} ) {
        $hr-&gt;{$key} = ws_trim( $hr-&gt;{$key} );
    }
    return wantarray ? %{$hr} : $hr;
}

1;


} # --- END Cpanel/StringFunc/Trim.pm


{ # --- BEGIN Cpanel/Path/Normalize.pm
package Cpanel::Path::Normalize;


use strict;
use warnings;


sub normalize {
    my $uncleanpath = shift || return;

    my $is_abspath = ( 0 == index( $uncleanpath, '/' ) );

    my @pathdirs = split( m[/], $uncleanpath );

    my @cleanpathdirs;
    my $leading_dot_dots = 0;

    foreach my $dir (@pathdirs) {
        next if !length $dir;    #Remove extraneous &quot;//&quot; and leading &quot;/&quot;

        next if $dir eq '.';

        if ( $dir eq '..' ) {
            if (@cleanpathdirs) {
                pop(@cleanpathdirs);
            }
            else {
                $leading_dot_dots++;
            }
        }
        else {
            push( @cleanpathdirs, $dir );
        }
    }

    if ($is_abspath) {
        return ( '/' . join( '/', @cleanpathdirs ) );
    }

    unshift @cleanpathdirs, ('..') x $leading_dot_dots;

    return join( '/', @cleanpathdirs );
}


1;

} # --- END Cpanel/Path/Normalize.pm


{ # --- BEGIN Cpanel/Config/LoadWwwAcctConf.pm
package Cpanel::Config::LoadWwwAcctConf;


use strict;
use warnings;

# use Cpanel::HiRes ();

# use Cpanel::Path::Normalize ();
# use Cpanel::Debug           ();
# use Cpanel::JSON::FailOK    ();

my $SYSTEM_CONF_DIR = '/etc';
my $wwwconf_cache;
my $wwwconf_mtime = 0;

my $has_serializer;

our $wwwacctconf       = &quot;$SYSTEM_CONF_DIR/wwwacct.conf&quot;;
our $wwwacctconfshadow = &quot;$SYSTEM_CONF_DIR/wwwacct.conf.shadow&quot;;

sub import {
    my $this = shift;
    if ( !exists $INC{'Cpanel/JSON.pm'} ) {
        Cpanel::JSON::FailOK::LoadJSONModule();
    }
    if ( $INC{'Cpanel/JSON.pm'} ) {
        $has_serializer = 1;
    }
    return Exporter::import( $this, @_ );
}

sub loadwwwacctconf {    ## no critic qw(Subroutines::ProhibitExcessComplexity)
    if ( $INC{'Cpanel/JSON.pm'} ) { $has_serializer = 1; }    #something else loaded it

    my $filesys_mtime = ( Cpanel::HiRes::stat($wwwacctconf) )[9];

    return if !$filesys_mtime;

    if ( $filesys_mtime == $wwwconf_mtime &amp;&amp; $wwwconf_cache ) {
        return wantarray ? %{$wwwconf_cache} : $wwwconf_cache;
    }

    my $wwwacctconf_cache       = &quot;$wwwacctconf.cache&quot;;
    my $wwwacctconfshadow_cache = &quot;$wwwacctconfshadow.cache&quot;;
    my $is_root                 = $&gt; ? 0 : 1;

    if ($has_serializer) {
        my $cache_file;
        my $cache_filesys_mtime;
        my $have_valid_cache = 1;

        if ( $is_root &amp;&amp; -e $wwwacctconfshadow_cache ) {
            $cache_filesys_mtime = ( Cpanel::HiRes::stat($wwwacctconfshadow_cache) )[9];    #shadow cache's mtime

            my $shadow_file_mtime = ( Cpanel::HiRes::stat $wwwacctconfshadow )[9] || 0;
            if ( $shadow_file_mtime &lt; $cache_filesys_mtime ) {
                $cache_file = $wwwacctconfshadow_cache;
            }
            else {    #don't use shadow cache if shadow file is newer
                $have_valid_cache = undef;
            }
        }

        elsif ( -e $wwwacctconf_cache &amp;&amp; !( $is_root &amp;&amp; -r $wwwacctconfshadow ) ) {
            $cache_filesys_mtime = ( Cpanel::HiRes::stat $wwwacctconf_cache )[9];    #regular cache's mtime
            $cache_file          = $wwwacctconf_cache;
        }
        else {
            $have_valid_cache = undef;
        }
        my $now = Cpanel::HiRes::time();

        if ( $Cpanel::Debug::level &gt;= 5 ) {
            print STDERR __PACKAGE__ . &quot;::loadwwwacctconf cache_filesys_mtime = $cache_filesys_mtime , filesys_mtime: $filesys_mtime , now : $now\n&quot;;
        }

        if ( $have_valid_cache &amp;&amp; $cache_filesys_mtime &gt; $filesys_mtime &amp;&amp; $cache_filesys_mtime &lt; $now ) {
            my $wwwconf_ref;
            if ( open( my $conf_fh, '&lt;', $cache_file ) ) {
                $wwwconf_ref = Cpanel::JSON::FailOK::LoadFile($conf_fh);
                close($conf_fh);
            }

            if ( $wwwconf_ref &amp;&amp; ( scalar keys %{$wwwconf_ref} ) &gt; 0 ) {
                if ( $Cpanel::Debug::level &gt;= 5 ) { print STDERR __PACKAGE__ . &quot;::loadwwwconf file system cache hit\n&quot;; }
                $wwwconf_cache = $wwwconf_ref;
                $wwwconf_mtime = $filesys_mtime;
                return wantarray ? %{$wwwconf_ref} : $wwwconf_ref;
            }
        }
    }

    my @configfiles;
    push @configfiles, $wwwacctconf;

    if ($is_root) { push @configfiles, $wwwacctconfshadow; }    #shadow file must be last as the cache gets written for each file with all the files before it in it

    my $can_write_cache;
    if ( $is_root &amp;&amp; $has_serializer ) {
        $can_write_cache = 1;
    }

    my %CONF = (
        'ADDR'         =&gt; undef,
        'CONTACTEMAIL' =&gt; undef,
        'DEFMOD'       =&gt; undef,
        'ETHDEV'       =&gt; undef,
        'HOST'         =&gt; undef,
        'NS'           =&gt; undef,
        'NS2'          =&gt; undef,
    );
    require Cpanel::Config::LoadConfig;
    foreach my $configfile (@configfiles) {
        Cpanel::Config::LoadConfig::loadConfig( $configfile, \%CONF, '\s+', undef, undef, undef, { 'nocache' =&gt; 1 } );

        foreach ( keys %CONF ) {

            $CONF{$_} =~ s{\s+$}{} if defined $CONF{$_};
        }

        $CONF{'HOMEMATCH'} =~ s{/+$}{} if defined $CONF{'HOMEMATCH'};    # Remove trailing slashes

        $CONF{'HOMEDIR'} = Cpanel::Path::Normalize::normalize( $CONF{'HOMEDIR'} ) if defined $CONF{'HOMEDIR'};

        if ($can_write_cache) {
            my $cache_file = $configfile . '.cache';
            require Cpanel::FileUtils::Write::JSON::Lazy;
            Cpanel::FileUtils::Write::JSON::Lazy::write_file( $cache_file, \%CONF, ( $configfile eq $wwwacctconfshadow ) ? 0600 : 0644 );
        }
    }

    $wwwconf_mtime = $filesys_mtime;
    $wwwconf_cache = \%CONF;

    return wantarray ? %CONF : \%CONF;
}

sub reset_mem_cache {
    ( $wwwconf_mtime, $wwwconf_cache ) = ( 0, undef );
}

sub reset_has_serializer {
    $has_serializer = 0;
}

sub default_conf_dir {
    $SYSTEM_CONF_DIR = shift if @_;

    $wwwacctconf       = &quot;$SYSTEM_CONF_DIR/wwwacct.conf&quot;;
    $wwwacctconfshadow = &quot;$SYSTEM_CONF_DIR/wwwacct.conf.shadow&quot;;

    return $SYSTEM_CONF_DIR;
}

sub reset_caches {
    my @cache_files = map { &quot;$_.cache&quot; } ( $wwwacctconf, $wwwacctconfshadow );

    for my $cache_file (@cache_files) {
        unlink $cache_file if -e $cache_file;
    }

    reset_mem_cache();

    return;
}

1;

} # --- END Cpanel/Config/LoadWwwAcctConf.pm


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


# use Cpanel::Config::Constants ();
my $cpanel_theme;
my $webmail_theme;

sub new {
    my ( $class, %opts ) = @_;
    my $self = {};
    bless $self, $class;
    if ( exists $opts{'wwwacct'} &amp;&amp; ref $opts{'wwwacct'} eq 'HASH' ) {
        $self-&gt;{'wwwacct'} = $opts{'wwwacct'};
    }

    undef $cpanel_theme;
    undef $webmail_theme;

    return $self;
}

sub system_config_dir {
    my ($self) = @_;
    return '/etc';
}

sub product_config_dir {
    my ($self) = @_;
    return '/var/cpanel';
}

sub product_base_dir {
    my ($self) = @_;
    return '/usr/local/cpanel';
}

sub whm_base_dir {
    my ($self) = @_;
    return $self-&gt;product_base_dir . '/whostmgr';
}

sub cpanel_theme_dir {
    my ($self) = @_;
    return $self-&gt;product_base_dir . '/base/frontend';
}

sub whm_theme_dir {
    my ($self) = @_;
    return $self-&gt;whm_base_dir . '/docroot/themes';
}

sub whm_theme {
    my ($self) = @_;
    return 'x';
}

sub account_creation_defaults {
    my ($self) = @_;
    if ( exists $self-&gt;{'wwwacct'} ) {
        my %wwwacct = %{ $self-&gt;{'wwwacct'} };
        return \%wwwacct;
    }
    require Cpanel::Config::LoadWwwAcctConf;
    return Cpanel::Config::LoadWwwAcctConf::loadwwwacctconf();
}

sub cpanel_theme {
    my ($self) = @_;
    return $cpanel_theme if defined $cpanel_theme;

    $cpanel_theme = $Cpanel::Config::Constants::DEFAULT_CPANEL_THEME;

    my $defaults = {};
    $defaults = $self-&gt;account_creation_defaults();
    if ( ref $defaults eq 'HASH' &amp;&amp; $defaults-&gt;{'DEFMOD'} ) {
        $cpanel_theme = $defaults-&gt;{'DEFMOD'};
    }
    return $cpanel_theme;
}

sub default_webmail_theme {
    my ($self) = @_;
    return $webmail_theme if defined $webmail_theme;

    $webmail_theme = $Cpanel::Config::Constants::DEFAULT_WEBMAIL_THEME;

    my $defaults = {};
    $defaults = $self-&gt;account_creation_defaults();
    if ( ref $defaults eq 'HASH' &amp;&amp; $defaults-&gt;{'DEFMOD'} ) {
        $webmail_theme = $defaults-&gt;{'DEFMOD'};
    }
    return $webmail_theme;
}

1;

} # --- END Cpanel/Conf.pm


{ # --- BEGIN Cpanel/Config/LoadCpUserFile.pm
package Cpanel::Config::LoadCpUserFile;


use strict;
use warnings;


use Try::Tiny;

# use Cpanel::DB::Utils                    ();
# use Cpanel::Exception                    ();
# use Cpanel::FileUtils::Write::JSON::Lazy ();
# use Cpanel::AdminBin::Serializer::FailOK ();
# use Cpanel::Config::Constants            ();
# use Cpanel::Config::CpUser::Defaults     ();
# use Cpanel::Config::CpUser::Object       ();
# use Cpanel::ConfigFiles                  ();
# use Cpanel::LoadFile::ReadFast           ();
# use Cpanel::SV                           ();
# use Cpanel::StringFunc::Trim             ();

our $VERSION = '0.83';    # DO NOT CHANGE THIS FROM A DECIMAL

sub _cpuser_defaults {
    return @Cpanel::Config::CpUser::Defaults::DEFAULTS_KV;
}

my %should_never_be_on_disk = map { $_ =&gt; undef } qw(
  DBOWNER
  DOMAIN
  DOMAINS
  DEADDOMAINS
  HOMEDIRLINKS
);

my $logger;


sub load_or_die {
    return ( _load( $_[0], undef, if_missing =&gt; 'die' ) )[2];
}

sub load_if_exists {
    return ( _load( $_[0], undef, if_missing =&gt; 'return' ) )[2] // undef;
}

sub load_file {
    my ($file) = @_;


    return parse_cpuser_file( _open_cpuser_file( '&lt;', $file ) );
}

sub _open_cpuser_file_locked {
    my ( $mode, $file ) = @_;

    local $!;

    my $cpuser_fh;

    require Cpanel::SafeFile;
    my $lock_obj = Cpanel::SafeFile::safeopen( $cpuser_fh, $mode, $file ) or do {
        die Cpanel::Exception::create( 'IO::FileOpenError', [ path =&gt; $file, error =&gt; $!, mode =&gt; $mode ] );
    };

    return ( $lock_obj, $cpuser_fh );
}

sub _open_cpuser_file {
    my ( $mode, $file ) = @_;

    local $!;

    my $cpuser_fh;

    open( $cpuser_fh, $mode, $file ) or do {
        die Cpanel::Exception::create( 'IO::FileOpenError', [ path =&gt; $file, error =&gt; $!, mode =&gt; $mode ] );
    };
    return $cpuser_fh;
}

sub parse_cpuser_file {
    my ($cpuser_fh) = @_;

    my $buffer = '';
    Cpanel::LoadFile::ReadFast::read_all_fast( $cpuser_fh, $buffer );

    return parse_cpuser_file_buffer($buffer);
}


sub parse_cpuser_file_buffer {
    my ($buffer) = @_;

    my %cpuser = _cpuser_defaults();

    my %DOMAIN_MAP;
    my %DEAD_DOMAIN_MAP;
    my %HOMEDIRLINKS_MAP;

    local ( $!, $_ );

    foreach ( split( m{\n}, $buffer ) ) {
        next if index( $_, '#' ) &gt; -1 &amp;&amp; m/^\s*#/;

        my ( $key, $value ) = split( /\s*=/, $_, 2 );

        if ( !defined $value || exists $should_never_be_on_disk{$key} ) {
            next;

        }

        elsif ( $key eq 'DNS' ) {
            $cpuser{'DOMAIN'} = lc Cpanel::StringFunc::Trim::ws_trim($value);
        }

        elsif ( index( $key, 'DNS' ) == 0 &amp;&amp; substr( $key, 3, 1 ) =~ tr{0-9}{} ) {
            $DOMAIN_MAP{ lc Cpanel::StringFunc::Trim::ws_trim($value) } = undef;
        }
        elsif ( index( $key, 'XDNS' ) == 0 &amp;&amp; substr( $key, 4, 1 ) =~ tr{0-9}{} ) {
            $DEAD_DOMAIN_MAP{ lc Cpanel::StringFunc::Trim::ws_trim($value) } = undef;
        }
        elsif ( index( $key, 'HOMEDIRPATHS' ) == 0 &amp;&amp; $key =~ m{ \A HOMEDIRPATHS \d* \z }xms ) {
            $HOMEDIRLINKS_MAP{$value} = undef;
        }
        else {
            $cpuser{$key} = $value;
        }
    }

    delete @DEAD_DOMAIN_MAP{ keys %DOMAIN_MAP };
    delete $DOMAIN_MAP{ $cpuser{'DOMAIN'} };

    if ($!) {
        die Cpanel::Exception::create( 'IO::FileReadError', [ error =&gt; $! ] );
    }

    if ( exists $cpuser{'USER'} ) {

        $cpuser{'DBOWNER'} = Cpanel::DB::Utils::username_to_dbowner( $cpuser{'USER'} );
    }

    if ( !length $cpuser{'RS'} ) {
        require Cpanel::Conf;
        my $cp_defaults = Cpanel::Conf-&gt;new();
        $cpuser{'RS'} = $cp_defaults-&gt;cpanel_theme;
    }

    if ( !$cpuser{'LOCALE'} ) {
        $cpuser{'LOCALE'}           = 'en';
        $cpuser{'__LOCALE_MISSING'} = 1;
    }
    $cpuser{'DOMAINS'}      = [ sort keys %DOMAIN_MAP ];         # Sorted here so they can be tested with TM::is_deeply
    $cpuser{'DEADDOMAINS'}  = [ sort keys %DEAD_DOMAIN_MAP ];    # Sorted here so they can be tested with TM::is_deeply
    $cpuser{'HOMEDIRLINKS'} = [ sort keys %HOMEDIRLINKS_MAP ];

    return _wrap_cpuser( \%cpuser );
}

sub _wrap_cpuser {
    return Cpanel::Config::CpUser::Object-&gt;adopt(shift);
}

sub _logger {
    return $logger ||= do {
        require Cpanel::Logger;
        Cpanel::Logger-&gt;new();
    };
}

sub load {
    my ( $user, $opts ) = @_;

    my $cpuser = ( _load( $user, $opts ) )[2];

    if ( !ref $cpuser ) {
        _logger()-&gt;warn( &quot;Failed to load cPanel user file for '&quot; . ( $user || '' ) . &quot;'&quot; ) unless $opts-&gt;{'quiet'};
        return wantarray ? () : bless( {}, 'Cpanel::Config::CpUser::Object' );
    }
    return wantarray ? %$cpuser : $cpuser;
}

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

    my ( $fh, $lock_fh, $cpuser ) = _load( $user, { lock =&gt; 1 } );

    return unless $fh &amp;&amp; $lock_fh &amp;&amp; $cpuser;

    return {
        'file' =&gt; $fh,
        'lock' =&gt; $lock_fh,
        'data' =&gt; $cpuser,
    };
}

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

    return unlink &quot;$Cpanel::ConfigFiles::cpanel_users.cache/$user&quot;;
}

sub _load {    ## no critic(Subroutines::ProhibitExcessComplexity)  -- Refactoring this function is a project, not a bug fix
    my ( $user, $load_opts_ref, %internal_opts ) = @_;

    if ( !$user || $user =~ tr&lt;/\0&gt;&lt;&gt; ) {    #no eq '' needed as !$user covers this
        _logger()-&gt;warn(&quot;Invalid username (falsy or forbidden character) given to loadcpuserfile.&quot;);

        if ( $internal_opts{'if_missing'} ) {
            die Cpanel::Exception::create( 'UserNotFound', [ name =&gt; '' ] );
        }

        return;
    }

    my ( $now, $has_serializer, $user_file, $user_cache_file ) = (
        time(),                                                                    #now
        ( exists $INC{'Cpanel/JSON.pm'} ? 1 : 0 ),                                 #has_serializer
        $load_opts_ref-&gt;{'file'} || &quot;$Cpanel::ConfigFiles::cpanel_users/$user&quot;,    # user_file
        &quot;$Cpanel::ConfigFiles::cpanel_users.cache/$user&quot;,                          # user_cache_file
    );

    my ( $cpuid, $cpgid, $size, $mtime ) = ( stat($user_file) )[ 4, 5, 7, 9 ];

    if ( not defined($size) and my $if_missing = $internal_opts{'if_missing'} ) {
        if ( $! == _ENOENT() ) {
            if ( $if_missing eq 'return' ) {
                return;
            }

            die Cpanel::Exception::create( 'UserNotFound', [ name =&gt; $user ] );
        }
        die Cpanel::Exception-&gt;create( 'The system failed to find the file “[_1]” because of an error: [_2]', [ $user_file, $! ] );
    }

    $mtime ||= 0;

    my $lock_fh;
    my $cpuser_fh;

    if ( $load_opts_ref-&gt;{'lock'} ) {
        my $mode = $mtime ? '+&lt;' : '+&gt;';
        try {
            ( $lock_fh, $cpuser_fh ) = _open_cpuser_file_locked( $mode, $user_file );
        }
        catch {
            if ( my $if_missing = $internal_opts{'if_missing'} ) {
                die $_ if $if_missing ne 'return';
            }
            else {
                _logger()-&gt;warn($_);
            }
        };

        return if !$lock_fh;
    }
    elsif ( !$size ) {
        if ( $user eq 'cpanel' ) {
            my $result = _load_cpanel_user();
            _wrap_cpuser($result);
            return ( $cpuser_fh, $lock_fh, $result );
        }
        else {
            _logger()-&gt;warn(&quot;User file '$user_file' is empty or non-existent.&quot;) unless $load_opts_ref-&gt;{'quiet'};
            return;
        }
    }

    if ( $Cpanel::Debug::level &amp;&amp; $Cpanel::Debug::level &gt; 3 ) {    # PPI NO PARSE - This doesn't need to be loaded
        _logger()-&gt;debug(&quot;load cPanel user file [$user]&quot;);
    }

    if ($has_serializer) {
        Cpanel::SV::untaint($user_cache_file);                        # case CPANEL-11199
        if ( open( my $cache_fh, '&lt;:stdio', $user_cache_file ) ) {    #ok if the file is not there
            my $cache_mtime = ( stat($cache_fh) )[9];                 # Check the mtime after we have opened the file to prevent a race condition
            if ( $cache_mtime &gt;= $mtime &amp;&amp; $cache_mtime &lt;= $now ) {
                my $cpuser_ref = Cpanel::AdminBin::Serializer::FailOK::LoadFile($cache_fh);
                if ( $cpuser_ref &amp;&amp; ref $cpuser_ref eq 'HASH' ) {
                    if ( $Cpanel::Debug::level &amp;&amp; $Cpanel::Debug::level &gt; 3 ) {    # PPI NO PARSE - This doesn't need to be loaded
                        _logger()-&gt;debug(&quot;load cache hit user[$user] now[$now] mtime[$mtime] cache_mtime[$cache_mtime]&quot;);
                    }
                    $cpuser_ref-&gt;{'MTIME'} = $mtime;

                    if ( ( $cpuser_ref-&gt;{'__CACHE_DATA_VERSION'} // 0 ) == $VERSION ) {
                        _wrap_cpuser($cpuser_ref);
                        return ( $cpuser_fh, $lock_fh, $cpuser_ref );
                    }
                    else {
                        unlink $user_cache_file;    # force a re-cache of the latest data set
                    }
                }
            }
            else {
                if ( $Cpanel::Debug::level &amp;&amp; $Cpanel::Debug::level &gt; 3 ) {    # PPI NO PARSE - This doesn't need to be loaded
                    _logger()-&gt;debug(&quot;load cache miss user[$user] now[$now] mtime[$mtime] cache_mtime[$cache_mtime]&quot;);
                }
            }
            close($cache_fh);
        }
        else {
            if ( $Cpanel::Debug::level &amp;&amp; $Cpanel::Debug::level &gt; 3 ) {    # PPI NO PARSE - This doesn't need to be loaded
                _logger()-&gt;debug(&quot;load cache miss user[$user] now[$now] mtime[$mtime] cache_mtime[0]&quot;);
            }
        }
    }

    if ( !$lock_fh ) {
        try {
            $cpuser_fh = _open_cpuser_file( '&lt;', $user_file );
        }
        catch {
            die $_ if $internal_opts{'if_missing'};

            _logger()-&gt;warn($_);
        };

        return if !$cpuser_fh;
    }

    my $cpuser_hr;
    try {
        $cpuser_hr = parse_cpuser_file($cpuser_fh);
    }
    catch {
        _logger()-&gt;warn(&quot;Failed to read “$user_file”: $_&quot;);
    };

    return if !$cpuser_hr;

    $cpuser_hr-&gt;{'USER'}    = $user;
    $cpuser_hr-&gt;{'DBOWNER'} = Cpanel::DB::Utils::username_to_dbowner($user);

    $cpuser_hr-&gt;{'__CACHE_DATA_VERSION'} = $VERSION;    # set this before the cache is written so that it will be included in the cache
    if ( $&gt; == 0 ) {
        create_users_cache_dir();
        if ( $has_serializer &amp;&amp; Cpanel::FileUtils::Write::JSON::Lazy::write_file( $user_cache_file, $cpuser_hr, 0640 ) ) {
            chown 0, $cpgid, $user_cache_file if $cpgid;    # this is ok if the chown happens after as we fall though to reading the non-cache on a failed open
        }
        else {
            unlink $user_cache_file;                        #outdated
        }
    }

    $cpuser_hr-&gt;{'MTIME'} = ( stat($cpuser_fh) )[9];
    if ( $load_opts_ref-&gt;{'lock'} ) {
        seek( $cpuser_fh, 0, 0 );
    }
    else {
        if ($lock_fh) {
            require Cpanel::SafeFile;
            Cpanel::SafeFile::safeclose( $cpuser_fh, $lock_fh );
        }
        $cpuser_fh = $lock_fh = undef;
    }

    return ( $cpuser_fh, $lock_fh, $cpuser_hr );
}

sub loadcpuserfile {
    return load( $_[0] );
}

sub _load_cpanel_user {
    my %cpuser = (
        _cpuser_defaults(),
        'DEADDOMAINS'  =&gt; [],
        'DOMAIN'       =&gt; 'domain.tld',
        'DOMAINS'      =&gt; [],
        'HASCGI'       =&gt; 1,
        'HOMEDIRLINKS' =&gt; [],
        'LOCALE'       =&gt; 'en',
        'MAXADDON'     =&gt; 'unlimited',
        'MAXPARK'      =&gt; 'unlimited',
        'RS'           =&gt; $Cpanel::Config::Constants::DEFAULT_CPANEL_THEME,
        'USER'         =&gt; 'cpanel',
    );

    return wantarray ? %cpuser : \%cpuser;
}

sub create_users_cache_dir {
    my $uc = &quot;$Cpanel::ConfigFiles::cpanel_users.cache&quot;;
    if ( -f $uc || -l $uc ) {
        my $bad = &quot;$uc.bad&quot;;
        unlink $bad if -e $bad;
        rename $uc, $bad;
    }
    if ( !-e $uc ) {
        mkdir $uc;
    }
    return;
}

sub _ENOENT { return 2; }

1;

} # --- END Cpanel/Config/LoadCpUserFile.pm


{ # --- BEGIN Cpanel/Config/HasCpUserFile.pm
package Cpanel::Config::HasCpUserFile;


use strict;
use warnings;

# use Cpanel::ConfigFiles ();


sub has_cpuser_file {
    return 0 if !length $_[0] || $_[0] =~ tr{/\0}{};
    return -e &quot;$Cpanel::ConfigFiles::cpanel_users/$_[0]&quot; &amp;&amp; -s _;
}


sub has_readable_cpuser_file {
    my ($user) = @_;
    return unless defined $user and $user ne '' and $user !~ tr/\/\0//;

    return -e &quot;$Cpanel::ConfigFiles::cpanel_users/$user&quot; &amp;&amp; -s _ &amp;&amp; -r _;
}

1;

} # --- END Cpanel/Config/HasCpUserFile.pm


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


use strict;

our $NSCD_CONFIG_FILE = '/etc/nscd.conf';
our $NSCD_SOCKET      = '/var/run/nscd/socket';

1;

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


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


use strict;

my $MAX_PATH_LENGTH        = 107;
my $LITTLE_ENDIAN_TEMPLATE = 'vZ' . ( 1 + $MAX_PATH_LENGTH );    # x86_64 is always little endian
my $AF_UNIX                = 1;
my $SOCK_STREAM            = 1;

sub connect {
    socket( $_[0], $AF_UNIX, $SOCK_STREAM, 0 ) or warn &quot;socket(AF_UNIX, SOCK_STREAM): $!&quot;;
    return connect( $_[0], micro_sockaddr_un( $_[1] ) );
}

sub micro_sockaddr_un {

    if ( length( $_[0] ) &gt; $MAX_PATH_LENGTH ) {
        my $excess = length( $_[0] ) - $MAX_PATH_LENGTH;
        die &quot;“$_[0]” is $excess character(s) too long to be a path to a local socket ($MAX_PATH_LENGTH bytes maximum)!&quot;;
    }

    return pack( 'va*', $AF_UNIX, $_[0] ) if 0 == rindex( $_[0], &quot;\0&quot;, 0 );

    return pack(
        $LITTLE_ENDIAN_TEMPLATE,    # x86_64 is always little endian
        $AF_UNIX,
        $_[0],
    );
}

sub unpack_sockaddr_un {

    return substr( $_[0], 2 ) if 2 == rindex( $_[0], &quot;\0&quot;, 2 );

    return ( unpack $LITTLE_ENDIAN_TEMPLATE, $_[0] )[1];
}

1;

} # --- END Cpanel/Socket/UNIX/Micro.pm


{ # --- BEGIN Cpanel/NSCD/Check.pm
package Cpanel::NSCD::Check;


use strict;

# use Cpanel::NSCD::Constants     ();
# use Cpanel::Socket::UNIX::Micro ();

our $CACHE_TTL = 600;

my $last_check_time = 0;
my $nscd_is_running_cache;

sub nscd_is_running {
    my $now = time();
    if ( $last_check_time &amp;&amp; $last_check_time + $CACHE_TTL &gt; $now ) {
        return $nscd_is_running_cache;
    }

    $last_check_time = $now;
    my $socket;
    if ( Cpanel::Socket::UNIX::Micro::connect( $socket, $Cpanel::NSCD::Constants::NSCD_SOCKET ) ) {
        return ( $nscd_is_running_cache = 1 );
    }
    return ( $nscd_is_running_cache = 0 );
}

1;

} # --- END Cpanel/NSCD/Check.pm


{ # --- BEGIN Cpanel/PwCache/Helpers.pm
package Cpanel::PwCache::Helpers;


use strict;
use warnings;

my $skip_uid_cache = 0;

sub no_uid_cache { $skip_uid_cache = 1; return }
sub uid_cache    { $skip_uid_cache = 0; return }

sub skip_uid_cache {
    return $skip_uid_cache;
}

sub init {
    my ( $totie, $skip_uid_cache_value ) = @_;

    tiedto($totie);
    $skip_uid_cache = $skip_uid_cache_value;

    return;
}

{    # debugging helpers
    sub confess { require Carp; return Carp::confess(@_) }
    sub cluck   { require Carp; return Carp::cluck(@_) }
}

{    # tie logic and cache

    my $pwcacheistied = 0;
    my $pwcachetie;

    sub istied { return $pwcacheistied }
    sub deinit { $pwcacheistied = 0; return; }

    sub tiedto {
        my $v = shift;

        if ( !defined $v ) {    # get
            return $pwcacheistied ? $pwcachetie : undef;
        }
        else {                  # set
            $pwcacheistied = 1;
            $pwcachetie    = $v;
        }

        return;
    }

}

{
    my $SYSTEM_CONF_DIR  = '/etc';
    my $PRODUCT_CONF_DIR = '/var/cpanel';

    sub default_conf_dir    { return $SYSTEM_CONF_DIR }
    sub default_product_dir { return $PRODUCT_CONF_DIR; }
}

1;

} # --- END Cpanel/PwCache/Helpers.pm


{ # --- BEGIN Cpanel/PwCache/Cache.pm
package Cpanel::PwCache::Cache;


use strict;
use warnings;

my %_cache;
my %_homedir_cache;
use constant get_cache         =&gt; \%_cache;
use constant get_homedir_cache =&gt; \%_homedir_cache;

our $pwcache_inited = 0;
my $PWCACHE_IS_SAFE = 1;

sub clear {    # clear all
    %_cache         = ();
    %_homedir_cache = ();
    $pwcache_inited = 0;
    return;
}

sub remove_key {
    my ($pwkey) = @_;
    return delete $_cache{$pwkey};
}

sub replace {
    my $h = shift;
    %_cache = %$h if ref $h eq 'HASH';
    return;
}

sub is_safe {
    $PWCACHE_IS_SAFE = $_[0] if defined $_[0];
    return $PWCACHE_IS_SAFE;
}

sub pwmksafecache {
    return if $PWCACHE_IS_SAFE;
    $_cache{$_}{'contents'}-&gt;[1] = 'x' for keys %_cache;
    $PWCACHE_IS_SAFE = 1;
    return;
}

1;

} # --- END Cpanel/PwCache/Cache.pm


{ # --- BEGIN Cpanel/PwCache/Find.pm
package Cpanel::PwCache::Find;


use strict;

# use Cpanel::LoadFile::ReadFast ();

our $PW_CHUNK_SIZE = 1 &lt;&lt; 17;

sub field_with_value_in_pw_file {
    my ( $passwd_fh, $field, $value, $lc_flag ) = @_;

    return if ( $value =~ tr{\x{00}-\x{1f}\x{7f}:}{} );

    my $needle = $field == 0 ? &quot;\n${value}:&quot; : &quot;:${value}&quot;;
    my $haystack;

    my $match_pos = 0;
    my $line_start;
    my $line_end;
    my $not_eof;
    my $data = &quot;\n&quot;;

    while ( ( $not_eof = Cpanel::LoadFile::ReadFast::read_fast( $passwd_fh, $data, $PW_CHUNK_SIZE, length $data ) ) || length($data) &gt; 1 ) {

        $haystack = $not_eof ? substr( $data, 0, rindex( $data, &quot;\n&quot; ), '' ) : $data;

        if ( $lc_flag &amp;&amp; $lc_flag == 1 ) {
            $haystack = lc $haystack;
            $needle   = lc $needle;
        }

        while ( -1 &lt; ( $match_pos = index( $haystack, $needle, $match_pos ) ) ) {

            $line_start = ( !$field ? $match_pos : rindex( $haystack, &quot;\n&quot;, $match_pos ) ) + 1;
            if (
                !$field || (

                    $field == ( substr( $haystack, $line_start, $match_pos - $line_start + 1 ) =~ tr{:}{} )

                    &amp;&amp; ( length($haystack) == $match_pos + length($needle) || substr( $haystack, $match_pos + length($needle), 1 ) =~ tr{:\n}{} )
                )
            ) {
                $line_end = index( $haystack, &quot;\n&quot;, $match_pos + length($needle) );
                my $line = substr( $haystack, $line_start, ( $line_end &gt; -1 ? $line_end : length($haystack) ) - $line_start );

                return split( ':', $line );
            }
            $match_pos += length($needle);
        }
        last unless $not_eof;
    }
    return;
}

1;

} # --- END Cpanel/PwCache/Find.pm


{ # --- BEGIN Cpanel/PwCache/Build.pm
package Cpanel::PwCache::Build;


use strict;
use warnings;

# use Cpanel::Debug                        ();
# use Cpanel::JSON::FailOK                 ();
# use Cpanel::FileUtils::Write::JSON::Lazy ();
# use Cpanel::PwCache::Helpers             ();
# use Cpanel::PwCache::Cache               ();
# use Cpanel::LoadFile::ReadFast           ();


my ( $MIN_FIELDS_FOR_VALID_ENTRY, $pwcache_has_uid_cache ) = ( 0, 6 );

sub pwmksafecache {
    return if Cpanel::PwCache::Cache::is_safe();
    my $pwcache_ref = Cpanel::PwCache::Cache::get_cache();

    $pwcache_ref-&gt;{$_}{'contents'}-&gt;[1] = 'x' for keys %{$pwcache_ref};

    Cpanel::PwCache::Cache::is_safe(1);

    return;
}

sub pwclearcache {    # also known as clear_this_process_cache
    $pwcache_has_uid_cache = undef;

    Cpanel::PwCache::Cache::clear();

    return;
}

sub init_pwcache {
    Cpanel::PwCache::Cache::is_safe(0);
    return _build_pwcache();
}

sub init_passwdless_pwcache {
    return _build_pwcache( 'nopasswd' =&gt; 1 );
}

sub fetch_pwcache {
    init_passwdless_pwcache() unless pwcache_is_initted();
    my $pwcache_ref = Cpanel::PwCache::Cache::get_cache();
    if ( scalar keys %$pwcache_ref &lt; 3 ) {
        die &quot;The password cache unexpectedly had less than 3 entries&quot;;
    }
    return [ map { $pwcache_ref-&gt;{$_}-&gt;{'contents'} } grep { substr( $_, 0, 1 ) eq '0' } keys %{$pwcache_ref} ];
}

sub _write_json_cache {
    my ($cache_file) = @_;
    if ( !Cpanel::PwCache::Helpers::istied() &amp;&amp; exists $INC{'Cpanel/JSON.pm'} ) {
        my $pwcache_ref = Cpanel::PwCache::Cache::get_cache();
        if ( !ref $pwcache_ref || scalar keys %$pwcache_ref &lt; 3 ) {
            die &quot;The system failed build the password cache&quot;;
        }

        Cpanel::FileUtils::Write::JSON::Lazy::write_file( $cache_file, $pwcache_ref, 0600 );
    }
    return;
}

sub _write_tied_cache {
    my ( $crypted_passwd_ref, $passwdmtime, $hpasswdmtime ) = @_;
    my $SYSTEM_CONF_DIR = Cpanel::PwCache::Helpers::default_conf_dir();
    local $!;
    if ( open( my $pwcache_passwd_fh, '&lt;:stdio', &quot;$SYSTEM_CONF_DIR/passwd&quot; ) ) {
        local $/;
        my $pwcache_ref = Cpanel::PwCache::Cache::get_cache();
        my $data        = '';
        Cpanel::LoadFile::ReadFast::read_all_fast( $pwcache_passwd_fh, $data );
        die &quot;The file “$SYSTEM_CONF_DIR/passwd” was unexpectedly empty&quot; if !length $data;
        my @fields;
        my $skip_uid_cache = Cpanel::PwCache::Helpers::skip_uid_cache();

        foreach my $line ( split( /\n/, $data ) ) {
            next unless length $line;
            @fields = split( /:/, $line );
            next if scalar @fields &lt; $MIN_FIELDS_FOR_VALID_ENTRY || $fields[0] =~ tr/[A-Z][a-z][0-9]._-//c;
            $pwcache_ref-&gt;{ '0:' . $fields[0] } = {
                'cachetime'  =&gt; $passwdmtime,
                'hcachetime' =&gt; $hpasswdmtime,
                'contents'   =&gt; [ $fields[0], $crypted_passwd_ref-&gt;{ $fields[0] } || $fields[1], $fields[2], $fields[3], '', '', $fields[4], $fields[5], $fields[6], -1, -1, $passwdmtime, $hpasswdmtime ]
            };
            next if $skip_uid_cache || !defined $fields[2] || exists $pwcache_ref-&gt;{ '2:' . $fields[2] };
            $pwcache_ref-&gt;{ '2:' . $fields[2] } = $pwcache_ref-&gt;{ '0:' . $fields[0] };
        }
        close($pwcache_passwd_fh);
    }
    else {
        die &quot;The system failed to read $SYSTEM_CONF_DIR/passwd because of an error: $!&quot;;
    }
    return;
}

sub _cache_ref_is_valid {
    my ( $cache_ref, $passwdmtime, $hpasswdmtime ) = @_;
    my @keys = qw/0:root 0:cpanel 0:bin/;
    return
         $cache_ref
      &amp;&amp; ( scalar keys %{$cache_ref} ) &gt; 2
      &amp;&amp; scalar @keys == grep {    #
             $cache_ref-&gt;{$_}-&gt;{'hcachetime'}
          &amp;&amp; $cache_ref-&gt;{$_}-&gt;{'hcachetime'} == $hpasswdmtime
          &amp;&amp; $cache_ref-&gt;{$_}-&gt;{'cachetime'}
          &amp;&amp; $cache_ref-&gt;{$_}-&gt;{'cachetime'} == $passwdmtime
      } @keys;
}

sub _build_pwcache {
    my %OPTS = @_;

    if ( $INC{'B/C.pm'} ) {
        Cpanel::PwCache::Helpers::confess(&quot;Cpanel::PwCache::Build::_build_pwcache cannot be run under B::C (see case 162857)&quot;);
    }

    my $SYSTEM_CONF_DIR = Cpanel::PwCache::Helpers::default_conf_dir();

    my ( $cache_file, $passwdmtime, $cache_file_mtime, $crypted_passwd_ref, $crypted_passwd_file, $hpasswdmtime ) = ( &quot;$SYSTEM_CONF_DIR/passwd.cache&quot;, ( stat(&quot;$SYSTEM_CONF_DIR/passwd&quot;) )[9] );

    if ( $OPTS{'nopasswd'} ) {

        $hpasswdmtime = ( stat(&quot;$SYSTEM_CONF_DIR/shadow&quot;) )[9];
        $cache_file   = &quot;$SYSTEM_CONF_DIR/passwd&quot; . ( Cpanel::PwCache::Helpers::skip_uid_cache() ? '.nouids' : '' ) . '.cache';
    }
    elsif ( -r &quot;$SYSTEM_CONF_DIR/shadow&quot; ) {
        Cpanel::PwCache::Cache::is_safe(0);
        $hpasswdmtime        = ( stat(_) )[9];
        $crypted_passwd_file = &quot;$SYSTEM_CONF_DIR/shadow&quot;;
        $cache_file          = &quot;$SYSTEM_CONF_DIR/shadow&quot; . ( Cpanel::PwCache::Helpers::skip_uid_cache() ? '.nouids' : '' ) . '.cache';
    }
    else {
        $hpasswdmtime = 0;
    }

    if ( !Cpanel::PwCache::Helpers::istied() &amp;&amp; exists $INC{'Cpanel/JSON.pm'} ) {
        if ( open( my $cache_fh, '&lt;:stdio', $cache_file ) ) {
            my $cache_file_mtime = ( stat($cache_fh) )[9] || 0;
            if ( $cache_file_mtime &gt; $hpasswdmtime &amp;&amp; $cache_file_mtime &gt; $passwdmtime ) {
                my $cache_ref = Cpanel::JSON::FailOK::LoadFile($cache_fh);
                Cpanel::Debug::log_debug(&quot;[read pwcache from $cache_file]&quot;) if ( $Cpanel::Debug::level &gt; 3 );
                if ( _cache_ref_is_valid( $cache_ref, $passwdmtime, $hpasswdmtime ) ) {
                    Cpanel::Debug::log_debug(&quot;[validated pwcache from $cache_file]&quot;) if ( $Cpanel::Debug::level &gt; 3 );
                    my $memory_pwcache_ref = Cpanel::PwCache::Cache::get_cache();
                    @{$cache_ref}{ keys %$memory_pwcache_ref } = values %$memory_pwcache_ref;
                    Cpanel::PwCache::Cache::replace($cache_ref);
                    $Cpanel::PwCache::Cache::pwcache_inited = ( $OPTS{'nopasswd'} ? 1 : 2 );
                    return;
                }

            }
        }
    }

    if ($crypted_passwd_file) { $crypted_passwd_ref = _load_pws($crypted_passwd_file); }
    $Cpanel::PwCache::Cache::pwcache_inited = ( $OPTS{'nopasswd'}                          ? 1 : 2 );
    $pwcache_has_uid_cache                  = ( Cpanel::PwCache::Helpers::skip_uid_cache() ? 0 : 1 );

    _write_tied_cache( $crypted_passwd_ref, $passwdmtime, $hpasswdmtime );
    _write_json_cache($cache_file) if $&gt; == 0;

    return 1;
}

sub pwcache_is_initted {
    return ( $Cpanel::PwCache::Cache::pwcache_inited ? $Cpanel::PwCache::Cache::pwcache_inited : 0 );
}

sub _load_pws {
    my $lookup_file = shift;

    if ( $INC{'B/C.pm'} ) {
        Cpanel::PwCache::Helpers::confess(&quot;Cpanel::PwCache::Build::_load_pws cannot be run under B::C (see case 162857)&quot;);
    }

    my %PW;
    if ( open my $lookup_fh, '&lt;:stdio', $lookup_file ) {
        my $data = '';
        Cpanel::LoadFile::ReadFast::read_all_fast( $lookup_fh, $data );
        die &quot;The file “$lookup_file” was unexpectedly empty&quot; if !length $data;
        %PW = map { ( split(/:/) )[ 0, 1 ] } split( /\n/, $data );
        if ( index( $data, '#' ) &gt; -1 ) {
            delete @PW{ '', grep { index( $_, '#' ) == 0 } keys %PW };
        }
        else {
            delete $PW{''};
        }
        close $lookup_fh;
    }
    return \%PW;
}

1;

} # --- END Cpanel/PwCache/Build.pm


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


use strict;

# use Cpanel::Debug            ();
# use Cpanel::NSCD::Check      ();
# use Cpanel::PwCache::Helpers ();
# use Cpanel::PwCache::Cache   ();
# use Cpanel::PwCache::Find    ();

use constant DUMMY_PW_RETURNS =&gt; ( -1, -1, 0, 0 );
use constant DEBUG            =&gt; 0;                  # Must set $ENV{'CPANEL_DEBUG_LEVEL'} = 5 as well

our $VERSION = '4.2';

my %FIXED_KEYS = (
    '0:root'        =&gt; 1,
    '0:nobody'      =&gt; 1,
    '0:cpanel'      =&gt; 1,
    '0:cpanellogin' =&gt; 1,
    '0:mail'        =&gt; 1,
    '2:0'           =&gt; 1,
    '2:99'          =&gt; 1
);

our $_WANT_ENCRYPTED_PASSWORD;


sub getpwnam_noshadow {
    $_WANT_ENCRYPTED_PASSWORD = 0;
    goto &amp;_getpwnam;
}

sub getpwuid_noshadow {
    $_WANT_ENCRYPTED_PASSWORD = 0;
    goto &amp;_getpwuid;
}


sub getpwnam {
    $_WANT_ENCRYPTED_PASSWORD = !!wantarray;
    goto &amp;_getpwnam;
}

sub getpwuid {
    $_WANT_ENCRYPTED_PASSWORD = !!wantarray;
    goto &amp;_getpwuid;
}


sub gethomedir {

    my $uid_or_name = $_[0] // $&gt;;

    my $hd = Cpanel::PwCache::Cache::get_homedir_cache();

    unless ( exists $hd-&gt;{$uid_or_name} ) {
        $_WANT_ENCRYPTED_PASSWORD = 0;
        if ( $uid_or_name !~ tr{0-9}{}c ) {
            $hd-&gt;{$uid_or_name} = ( _getpwuid($uid_or_name) )[7];
        }
        else {
            $hd-&gt;{$uid_or_name} = ( _getpwnam($uid_or_name) )[7];
        }
    }

    return $hd-&gt;{$uid_or_name};
}


sub getusername {

    my $uid = defined $_[0] ? $_[0] : $&gt;;

    $_WANT_ENCRYPTED_PASSWORD = 0;
    return scalar _getpwuid($uid);
}


sub init_passwdless_pwcache {
    require Cpanel::PwCache::Build;
    *init_passwdless_pwcache = \&amp;Cpanel::PwCache::Build::init_passwdless_pwcache;
    goto &amp;Cpanel::PwCache::Build::init_passwdless_pwcache;
}


sub _getpwuid {    ## no critic qw(Subroutines::RequireArgUnpacking)
    return unless ( length( $_[0] ) &amp;&amp; $_[0] !~ tr/0-9//c );

    my $pwcache_ref = Cpanel::PwCache::Cache::get_cache();

    if ( !exists $pwcache_ref-&gt;{&quot;2:$_[0]&quot;} &amp;&amp; $&gt; != 0 &amp;&amp; !Cpanel::PwCache::Helpers::istied() &amp;&amp; Cpanel::NSCD::Check::nscd_is_running() ) {
        return CORE::getpwuid( $_[0] ) if !wantarray;

        my @ret = CORE::getpwuid( $_[0] );

        return @ret ? ( @ret, DUMMY_PW_RETURNS() ) : ();
    }

    if ( my $pwref = _pwfunc( $_[0], 2 ) ) {
        return wantarray ? @$pwref : $pwref-&gt;[0];
    }
    return;    #important not to return 0
}

sub _getpwnam {    ## no critic qw(Subroutines::RequireArgUnpacking)
    return unless ( length( $_[0] ) &amp;&amp; $_[0] !~ tr{\x{00}-\x{20}\x{7f}:/#}{} );

    my $pwcache_ref = Cpanel::PwCache::Cache::get_cache();

    if ( !exists $pwcache_ref-&gt;{&quot;0:$_[0]&quot;} &amp;&amp; $&gt; != 0 &amp;&amp; !Cpanel::PwCache::Helpers::istied() &amp;&amp; Cpanel::NSCD::Check::nscd_is_running() ) {
        return CORE::getpwnam( $_[0] ) if !wantarray;

        my @ret = CORE::getpwnam( $_[0] );

        return @ret ? ( @ret, DUMMY_PW_RETURNS() ) : ();
    }

    if ( my $pwref = _pwfunc( $_[0], 0 ) ) {
        return wantarray ? @$pwref : $pwref-&gt;[2];
    }
    return;    #important not to return 0
}

sub _pwfunc {    ## no critic qw(Subroutines::RequireArgUnpacking)
    my ( $value, $field, $pwkey ) = ( $_[0], ( $_[1] || 0 ), $_[1] . ':' . ( $_[0] || 0 ) );

    if ( Cpanel::PwCache::Helpers::istied() ) {

        Cpanel::Debug::log_debug(&quot;cache tie (tied) value[$value] field[$field]&quot;) if (DEBUG);
        my $pwcachetie = Cpanel::PwCache::Helpers::tiedto();

        if ( ref $pwcachetie eq 'HASH' ) {
            my $cache = $pwcachetie-&gt;{$pwkey};
            if ( ref $cache eq 'HASH' ) {
                return $pwcachetie-&gt;{$pwkey}-&gt;{'contents'};
            }
        }
        return undef;
    }
    my $SYSTEM_CONF_DIR = Cpanel::PwCache::Helpers::default_conf_dir();

    my $lookup_encrypted_pass = 0;
    if ($_WANT_ENCRYPTED_PASSWORD) {

        $lookup_encrypted_pass = $&gt; == 0 ? 1 : 0;
    }

    my ( $passwdmtime, $hpasswdmtime );

    my $pwcache_ref = Cpanel::PwCache::Cache::get_cache();

    if ( my $cache_entry = $pwcache_ref-&gt;{$pwkey} ) {
        Cpanel::Debug::log_debug(&quot;exists in cache value[$value] field[$field]&quot;) if (DEBUG);
        if (
            ( exists( $cache_entry-&gt;{'contents'} ) &amp;&amp; $cache_entry-&gt;{'contents'}-&gt;[1] ne 'x' )    # Has shadow entry
            || !$lookup_encrypted_pass                                                            # Or we do not need it
          ) {                                                                                     # If we are root and missing the password field we could fail authentication
            if ( $FIXED_KEYS{$pwkey} ) {                                                          # We assume root, nobody, and cpanellogin will never change during execution
                Cpanel::Debug::log_debug(&quot;cache (never change) hit value[$value] field[$field]&quot;) if (DEBUG);
                return $cache_entry-&gt;{'contents'};
            }

            $passwdmtime  = ( stat(&quot;$SYSTEM_CONF_DIR/passwd&quot;) )[9];
            $hpasswdmtime = $lookup_encrypted_pass ? ( stat(&quot;$SYSTEM_CONF_DIR/shadow&quot;) )[9] : 0;

            if (   ( $lookup_encrypted_pass &amp;&amp; $hpasswdmtime &amp;&amp; $hpasswdmtime != $cache_entry-&gt;{'hcachetime'} )
                || ( $passwdmtime &amp;&amp; $passwdmtime != $cache_entry-&gt;{'cachetime'} ) ) {    #timewarp safe
                DEBUG &amp;&amp; Cpanel::Debug::log_debug( &quot;cache miss value[$value] field[$field] pwkey[$pwkey] &quot; . qq{hpasswdmtime: $hpasswdmtime != $cache_entry-&gt;{hcachetime} } . qq{passwdmtime: $passwdmtime != $cache_entry-&gt;{cachetime} } );

                if ( defined $cache_entry &amp;&amp; defined $cache_entry-&gt;{'contents'} ) {

                    Cpanel::PwCache::Cache::clear();    #If the passwd file mtime changes everything is invalid
                }
            }
            else {
                Cpanel::Debug::log_debug(&quot;cache hit value[$value] field[$field]&quot;) if (DEBUG);
                return $cache_entry-&gt;{'contents'};
            }
        }
        elsif (DEBUG) {
            Cpanel::Debug::log_debug( &quot;cache miss pwkey[$pwkey] value[$value] field[$field] passwdmtime[$passwdmtime] pwcacheistied[&quot; . Cpanel::PwCache::Helpers::istied() . &quot;] hpasswdmtime[$hpasswdmtime]&quot; );
        }
    }
    elsif (DEBUG) {
        Cpanel::Debug::log_debug( &quot;cache miss (no entry) pwkey[$pwkey] value[$value] field[$field] pwcacheistied[&quot; . Cpanel::PwCache::Helpers::istied() . &quot;]&quot; );
    }
    my $pwdata = _getpwdata( $value, $field, $passwdmtime, $hpasswdmtime, $lookup_encrypted_pass );

    _cache_pwdata( $pwdata, $pwcache_ref ) if $pwdata &amp;&amp; @$pwdata;

    return $pwdata;
}

sub _getpwdata {
    my ( $value, $field, $passwdmtime, $shadowmtime, $lookup_encrypted_pass ) = @_;
    return if ( !defined $value || !defined $field || $value =~ tr/\0// );

    if ($lookup_encrypted_pass) {
        return [ _readshadow( $value, $field, $passwdmtime, $shadowmtime ) ];
    }

    return [ _readpasswd( $value, $field, $passwdmtime, $shadowmtime ) ];
}

sub _readshadow {    ## no critic qw(Subroutines::RequireArgUnpacking)
    my $SYSTEM_CONF_DIR = Cpanel::PwCache::Helpers::default_conf_dir();
    my ( $value, $field, $passwdmtime, $shadowmtime ) = ( $_[0], ( $_[1] || 0 ), ( $_[2] || ( stat(&quot;$SYSTEM_CONF_DIR/passwd&quot;) )[9] ), ( $_[3] || ( stat(&quot;$SYSTEM_CONF_DIR/shadow&quot;) )[9] ) );
    my @PW = _readpasswd( $value, $field, $passwdmtime, $shadowmtime );
    return if !@PW;

    $value = $PW[0];

    if ( open my $shadow_fh, '&lt;', &quot;$SYSTEM_CONF_DIR/shadow&quot; ) {
        if ( my @SH = Cpanel::PwCache::Find::field_with_value_in_pw_file( $shadow_fh, 0, $value ) ) {

            ( $PW[1], $PW[9], $PW[10], $PW[11], $PW[12] ) = (
                $SH[1],    #encrypted pass
                $SH[5],    #expire time
                $SH[2],    #change time
                $passwdmtime,
                $shadowmtime
            );
            close $shadow_fh;
            Cpanel::PwCache::Cache::is_safe(0);
            return @PW;
        }
    }
    else {
        Cpanel::PwCache::Helpers::cluck(&quot;Unable to open $SYSTEM_CONF_DIR/shadow: $!&quot;);
    }

    Cpanel::PwCache::Helpers::cluck(&quot;Entry for $value missing in $SYSTEM_CONF_DIR/shadow&quot;);
    return @PW;
}

sub _readpasswd {    ## no critic qw(Subroutines::RequireArgUnpacking)
    my $SYSTEM_CONF_DIR = Cpanel::PwCache::Helpers::default_conf_dir();
    my ( $value, $field, $passwdmtime, $shadowmtime, $block ) = ( $_[0], ( $_[1] || 0 ), ( $_[2] || ( stat(&quot;$SYSTEM_CONF_DIR/passwd&quot;) )[9] ), $_[3] );

    if ( $INC{'B/C.pm'} ) {
        die(&quot;Cpanel::PwCache::_readpasswd cannot be run under B::C (see case 162857)&quot;);
    }

    if ( open( my $passwd_fh, '&lt;', &quot;$SYSTEM_CONF_DIR/passwd&quot; ) ) {
        if ( my @PW = Cpanel::PwCache::Find::field_with_value_in_pw_file( $passwd_fh, $field, $value ) ) {

            return ( $PW[0], $PW[1], $PW[2], $PW[3], '', '', $PW[4], $PW[5], $PW[6], -1, -1, $passwdmtime, ( $shadowmtime || $passwdmtime ) );
        }
        close($passwd_fh);
    }
    else {
        Cpanel::PwCache::Helpers::cluck(&quot;open($SYSTEM_CONF_DIR/passwd): $!&quot;);
    }

    return;
}

sub _cache_pwdata {
    my ( $pwdata, $pwcache_ref ) = @_;

    $pwcache_ref ||= Cpanel::PwCache::Cache::get_cache();

    if ( $pwdata-&gt;[2] != 0 || $pwdata-&gt;[0] eq 'root' ) {    # special case for multiple uid 0 users
        @{ $pwcache_ref-&gt;{ '2' . ':' . $pwdata-&gt;[2] } }{ 'cachetime', 'hcachetime', 'contents' } = ( $pwdata-&gt;[11], $pwdata-&gt;[12], $pwdata );
    }
    @{ $pwcache_ref-&gt;{ '0' . ':' . $pwdata-&gt;[0] } }{ 'cachetime', 'hcachetime', 'contents' } = ( $pwdata-&gt;[11], $pwdata-&gt;[12], $pwdata );
    return 1;
}

1;

} # --- END Cpanel/PwCache.pm


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


use strict;
# use Cpanel::Config::LoadCpUserFile ();
# use Cpanel::Config::HasCpUserFile  ();
# use Cpanel::PwCache                ();
# use Cpanel::LoadModule             ();

our $DATASTORE_MODULE     = 'Cpanel::DataStore';
our $LOCALE_LEGACY_MODULE = 'Cpanel::Locale::Utils::Legacy';

my $inited_cpdata_user;
my $userlocale = {};
my $logger;

sub _logger {
    require Cpanel::Logger;
    return ( $logger ||= Cpanel::Logger-&gt;new() );
}

sub init_cpdata_keys {
    my $user = shift || $Cpanel::user || $ENV{'REMOTE_USER'} || ( $&gt; == 0 ? 'root' : ( Cpanel::PwCache::getpwuid($&gt;) )[0] );

    return if ( defined $inited_cpdata_user &amp;&amp; $inited_cpdata_user eq $user );

    if ( !$Cpanel::CPDATA{'LOCALE'} &amp;&amp; $user ne 'root' ) {
        require Cpanel::Server::Utils;
        if ( Cpanel::Server::Utils::is_subprocess_of_cpsrvd() &amp;&amp; ( $&gt; &amp;&amp; $user ne 'cpanel' &amp;&amp; $user ne 'cpanellogin' &amp;&amp; !-e &quot;/var/cpanel/users/$user&quot; ) ) {
            _logger()-&gt;panic(&quot;get_handle() called before initcp()&quot;);
        }

        if ( $&gt; == 0 || ( $&gt; &amp;&amp; $&gt; == Cpanel::PwCache::getpwnam($user) ) ) {
            $Cpanel::CPDATA{'LOCALE'} = get_user_locale($user);
        }
    }

    return ( $inited_cpdata_user = $user );
}

sub clear_user_cache {
    my ($user) = @_;
    return delete $userlocale-&gt;{$user};
}

sub get_user_locale {

    my $user       = ( shift || $Cpanel::user || $ENV{'REMOTE_USER'} || ( $&gt; == 0 ? 'root' : ( Cpanel::PwCache::getpwuid($&gt;) )[0] ) );
    my $cpuser_ref = shift;                                                                                                              # not required, just faster if it is passed

    if ( !$user ) {
        require Cpanel::Locale;
        return Cpanel::Locale::get_server_locale() || 'en';
    }

    return $userlocale-&gt;{$user} if exists $userlocale-&gt;{$user} &amp;&amp; !shift;

    if ( $Cpanel::user &amp;&amp; $user eq $Cpanel::user &amp;&amp; $Cpanel::CPDATA{'LOCALE'} ) {
        return ( $userlocale-&gt;{$user} = $Cpanel::CPDATA{'LOCALE'} );
    }

    my $locale;

    if ( $user eq 'root' ) {
        my $root_conf_yaml = ( Cpanel::PwCache::getpwnam('root') )[7] . '/.cpanel_config';
        if ( -e $root_conf_yaml ) {
            Cpanel::LoadModule::load_perl_module($DATASTORE_MODULE);
            my $hr = $DATASTORE_MODULE-&gt;can('fetch_ref')-&gt;($root_conf_yaml);
            $locale = $hr-&gt;{'locale'};
        }
    }
    elsif ( $user eq 'cpanel' ) {
        require Cpanel::Locale;
        $locale = Cpanel::Locale::get_locale_for_user_cpanel();
    }
    else {
        if ( $cpuser_ref || ( Cpanel::Config::HasCpUserFile::has_readable_cpuser_file($user) &amp;&amp; ( $cpuser_ref = Cpanel::Config::LoadCpUserFile::loadcpuserfile($user) ) ) ) {
            if ( defined $cpuser_ref-&gt;{'LOCALE'} ) {
                $locale = $cpuser_ref-&gt;{'LOCALE'};
            }
            elsif ( defined $cpuser_ref-&gt;{'LANG'} ) {
                Cpanel::LoadModule::load_perl_module($LOCALE_LEGACY_MODULE);
                $locale = $LOCALE_LEGACY_MODULE-&gt;can('map_any_old_style_to_new_style')-&gt;( $cpuser_ref-&gt;{'LANG'} );
            }
        }
    }

    if ( !$locale ) {
        require Cpanel::Locale;
        return $userlocale-&gt;{$user} = Cpanel::Locale::get_server_locale() || 'en';
    }

    $userlocale-&gt;{$user} = $locale;

    return $userlocale-&gt;{$user};
}

1;

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


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


$Cpanel::Cookies::VERSION = '0.1';

sub get_cookie_hashref_from_string {
    return {} if !defined $_[0];
    return {
        map {
            map {
                s/%([a-fA-F0-9][a-fA-F0-9])/pack('C', hex($1))/eg if -1 != index( $_, '%' );
                $_;
            } split m&lt;=&gt;, $_, 2
        } split( /; /, $_[0] )
    };
}

my $http_cookie_cached;

sub get_cookie_hashref {

    if ( !defined $http_cookie_cached ) {
        $http_cookie_cached = get_cookie_hashref_from_string( $ENV{'HTTP_COOKIE'} );
    }

    return $http_cookie_cached;
}

sub get_cookie_hashref_recache {

    $http_cookie_cached = get_cookie_hashref_from_string( $ENV{'HTTP_COOKIE'} );
    return $http_cookie_cached;
}

1;


} # --- END Cpanel/Cookies.pm


{ # --- BEGIN Cpanel/SafeDir/Read.pm
package Cpanel::SafeDir::Read;


use strict;
use warnings;

sub read_dir {
    my ( $dir, $coderef ) = @_;
    my @contents;
    if ( opendir my $dir_dh, $dir ) {
        @contents = grep { defined &amp;&amp; $_ ne '.' &amp;&amp; $_ ne '..' } readdir($dir_dh);
        if ($coderef) {
            @contents = grep { $coderef-&gt;($_) } @contents;
        }
        closedir $dir_dh;
        return wantarray ? @contents : \@contents;
    }
    return;
}

1;

} # --- END Cpanel/SafeDir/Read.pm


{ # --- BEGIN Cpanel/ArrayFunc/Uniq.pm
package Cpanel::ArrayFunc::Uniq;


use cPstrict;

sub uniq (@list) {

    if ( $INC{'List/Util.pm'} ) {
        no warnings 'redefine';
        *uniq = *List::Util::uniq;
        return List::Util::uniq(@list);
    }
    my %seen;
    return grep { !$seen{$_}++ } @list;
}

1;

} # --- END Cpanel/ArrayFunc/Uniq.pm


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


use cPstrict;

# use Cpanel::ArrayFunc::Uniq ();

sub get_charmap_list ( $root_says_to_make_symlinks = 0, $no_aliases = 0 ) {    ## no critic(Subroutines::ProhibitManyArgs)
    my $args = { 'iconv' =&gt; 0, 'unpreferred_aliases' =&gt; ( $no_aliases ? 0 : 1 ) };
    if ($root_says_to_make_symlinks) {
        make_symlinks();
    }
    return @{ get_charmaps($args) };
}

sub get_charmaps ( $args = {} ) {
    _validate_args( $args, { map { $_ =&gt; 1 } qw( iconv unpreferred_aliases ) } );

    my ( $iconv, $unpreferred_aliases ) = @{$args}{ 'iconv', 'unpreferred_aliases' };
    $iconv //= 1;    # Provide iconv compatibility by default.

    my %charset_aliases   = _get_charset_aliases();
    my %excluded_charmaps = _get_excluded_charmaps( $iconv, $unpreferred_aliases );
    my @raw_charmaps      = ( qw(utf-8 us-ascii), _get_filesystem_charmaps(), ( $unpreferred_aliases ? %charset_aliases : ( values %charset_aliases ) ) );
    my %charmaps;
    for my $cm (@raw_charmaps) {
        $cm =~ tr{A-Z}{a-z};
        my $copy     = $cm;
        my $stripped = ( $copy =~ tr{_.-}{}d );    #prefer &quot;utf-8&quot; over &quot;utf8&quot;
        if ( !exists( $excluded_charmaps{$cm} ) &amp;&amp; ( !exists( $charmaps{$copy} ) || $stripped ) ) {
            $charmaps{$copy} = $cm;
        }
    }

    return [ sort ( Cpanel::ArrayFunc::Uniq::uniq( values %charmaps ) ) ];
}

sub make_symlinks {
    return unless $&gt; == 0;
    my %charset_aliases = _get_charset_aliases();
    my $charmapsdir     = _get_charmaps_dir();

    for my $loop ( 1 .. 2 ) {
        for my $key ( keys %charset_aliases ) {
            lstat(&quot;$charmapsdir/$key.gz&quot;);    # unpreferred
            if ( -e _ ) {
                lstat(&quot;$charmapsdir/$charset_aliases{$key}.gz&quot;);    # preferred
                if ( !-e _ &amp;&amp; !-l _ ) {
                    symlink( &quot;$charmapsdir/$key.gz&quot;, &quot;$charmapsdir/$charset_aliases{$key}.gz&quot; );    # unpreferred -&gt; preferred
                }
            }
            elsif ( !-l _ &amp;&amp; -e &quot;$charmapsdir/$charset_aliases{$key}.gz&quot; ) {                        # preferred
                symlink( &quot;$charmapsdir/$charset_aliases{$key}.gz&quot;, &quot;$charmapsdir/$key.gz&quot; );        # preferred -&gt; unpreferred
            }
        }
    }
    return 1;
}

sub _validate_args ( $args, $possible_args ) {

    if ( my @bad_args = grep { !$possible_args-&gt;{$_} } keys %{$args} ) {
        require Cpanel::Exception;
        die Cpanel::Exception::create_raw( 'InvalidParameters', 'The following arguments are invalid: ' . join ', ', @bad_args );
    }
}

sub _get_charmaps_dir {
    state $charmaps_dir = -e '/usr/local/share/i18n/charmaps' ? '/usr/local/share/i18n/charmaps' : '/usr/share/i18n/charmaps';
    return $charmaps_dir;
}

sub _get_charset_aliases {

    return (    # unpreferred =&gt; preferred
        'ASCII'             =&gt; 'US-ASCII',
        'BIG5-ETEN'         =&gt; 'BIG5',
        'CP1251'            =&gt; 'WINDOWS-1251',
        'CP1252'            =&gt; 'WINDOWS-1252',
        'CP936'             =&gt; 'GBK',
        'CP949'             =&gt; 'KS_C_5601-1987',    # Note: same preferred as KS_C_5601
        'EUC-CN'            =&gt; 'GB2312',
        'KS_C_5601'         =&gt; 'KS_C_5601-1987',    # Note: same preferred as CP949
        'SHIFTJIS'          =&gt; 'SHIFT_JIS',
        'SHIFTJISX0213'     =&gt; 'SHIFT_JISX0213',
        'UNICODE-1-1-UTF-7' =&gt; 'UTF-7',             # RFC 1642 (obs.)
        'UTF8'              =&gt; 'UTF-8',
        'UTF-8-STRICT'      =&gt; 'UTF-8',             # Perl internal use
        'HZ'                =&gt; 'HZ-GB-2312',        # RFC 1842
        'GSM0338'           =&gt; 'GSM03.38',
    );
}

sub _get_iconv_blacklist {

    return (
        'big5-eten',
        'bs_viewdata',
        'csa_z243.4-1985-gr',
        'gsm03.38',
        'gsm0338',
        'hz',
        'hz-gb-2312',
        'invariant',
        'iso_10646',
        'iso_646.basic',
        'iso_646.irv',
        'iso_6937-2-25',
        'iso_6937-2-add',
        'iso_8859-1,gl',
        'iso_8859-supp',
        'jis_c6220-1969-jp',
        'jis_c6229-1984-a',
        'jis_c6229-1984-b-add',
        'jis_c6229-1984-hand',
        'jis_c6229-1984-hand-add',
        'jis_c6229-1984-kana',
        'jis_x0201',
        'jus_i.b1.003-mac',
        'jus_i.b1.003-serb',
        'ks_c_5601',
        'ks_c_5601-1987',
        'nats-dano-add',
        'nats-sefi-add',
        'nextstep',
        'sami',
        'sami-ws2',
        't.101-g2',
        't.61-7bit',
        'unicode-1-1-utf-7',
        'utf-8-strict',
        'videotex-suppl',
    );
}

sub _get_filesystem_charmaps {
    state @filesystem_charmaps;
    return @filesystem_charmaps if @filesystem_charmaps;

    my $charmapsdir = _get_charmaps_dir();
    if ( opendir my $charmaps_dh, $charmapsdir ) {
        @filesystem_charmaps = map { m{\A([^.].*)[.]gz\z}xms ? $1 : () } readdir $charmaps_dh;
        closedir $charmaps_dh;
    }
    return @filesystem_charmaps;
}

sub _get_excluded_charmaps ( $iconv, $unpreferred_aliases ) {
    my %excluded;
    if ($iconv) {
        for my $bl ( _get_iconv_blacklist() ) {
            $excluded{$bl} = 1;
        }
    }
    if ( !$unpreferred_aliases ) {
        my %charset_aliases = _get_charset_aliases;
        for my $alias ( keys %charset_aliases ) {
            $alias =~ tr{A-Z}{a-z};
            $excluded{$alias} = 1;
        }
    }
    return %excluded;
}

1;


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


{ # --- BEGIN Cpanel/StringFunc/Case.pm
package Cpanel::StringFunc::Case;


use strict;
use warnings;

our $VERSION = '1.2';

sub ToUpper {
    return unless defined $_[0];
    ( local $_ = $_[0] ) =~ tr/a-z/A-Z/;    # avoid altering $_[0] by making a copy
    return $_;
}

sub ToLower {
    return unless defined $_[0];
    ( local $_ = $_[0] ) =~ tr/A-Z/a-z/;    # avoid altering $_[0] by making a copy
    return $_;
}
1;

} # --- END Cpanel/StringFunc/Case.pm


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


use strict;
use warnings;

# use Cpanel::Locale::Utils::Normalize ();
# use Cpanel::Locale::Utils::Paths     ();

my %oldname_to_locale;
my $loc;

sub _load_oldnames {

    %oldname_to_locale = (
        'turkish'                   =&gt; 'tr',
        'traditional-chinese'       =&gt; 'zh',
        'thai'                      =&gt; 'th',
        'swedish'                   =&gt; 'sv',
        'spanish-utf8'              =&gt; 'es',
        'spanish'                   =&gt; 'es',
        'slovenian'                 =&gt; 'sl',
        'simplified-chinese'        =&gt; 'zh_cn',
        'russian'                   =&gt; 'ru',
        'romanian'                  =&gt; 'ro',
        'portuguese-utf8'           =&gt; 'pt',
        'portuguese'                =&gt; 'pt',
        'polish'                    =&gt; 'pl',
        'norwegian'                 =&gt; 'no',
        'korean'                    =&gt; 'ko',
        'japanese-shift_jis'        =&gt; 'ja',       # see Cpanel::Locale::Utils::MkDB::compile_single_legacy_from_legacy_system()
        'japanese-euc-jp'           =&gt; 'ja',       # see Cpanel::Locale::Utils::MkDB::compile_single_legacy_from_legacy_system()
        'japanese'                  =&gt; 'ja',       # see Cpanel::Locale::Utils::MkDB::compile_single_legacy_from_legacy_system()
        'spanish_latinamerica'      =&gt; 'es_419',
        'iberian_spanish'           =&gt; 'es_es',
        'italian'                   =&gt; 'it',
        'indonesian'                =&gt; 'id',
        'hungarian'                 =&gt; 'hu',
        'german-utf8'               =&gt; 'de',
        'german'                    =&gt; 'de',
        'french-utf8'               =&gt; 'fr',
        'french'                    =&gt; 'fr',
        'finnish'                   =&gt; 'fi',
        'english-utf8'              =&gt; 'en',
        'english'                   =&gt; 'en',
        'dutch-utf8'                =&gt; 'nl',
        'dutch'                     =&gt; 'nl',
        'chinese'                   =&gt; 'zh',
        'bulgarian'                 =&gt; 'bg',
        'brazilian-portuguese-utf8' =&gt; 'pt_br',
        'brazilian-portuguese'      =&gt; 'pt_br',
        'arabic'                    =&gt; 'ar',
    );

    {
        no warnings 'redefine';
        *_load_oldnames = sub { };
    }

    return;
}

sub get_legacy_to_locale_map {
    _load_oldnames();
    return \%oldname_to_locale;
}

sub get_legacy_list_from_locale {
    my ($locale) = @_;
    return         if !$locale;
    $locale = 'en' if $locale eq 'en_us' || $locale eq 'i_default';
    _load_oldnames();
    return grep { $oldname_to_locale{$_} eq $locale ? 1 : 0 } keys %oldname_to_locale;
}

sub get_best_guess_of_legacy_from_locale {
    my ( $locale, $always_return_useable ) = @_;
    return         if !$locale &amp;&amp; !$always_return_useable;
    $locale = 'en' if $locale eq 'en_us' || $locale eq 'i_default';
    _load_oldnames();
    my @legacy_locale_matches = grep { $oldname_to_locale{$_} eq $locale ? 1 : 0 } keys %oldname_to_locale;
    return $legacy_locale_matches[0] if @legacy_locale_matches;
    return 'english'                 if $always_return_useable;
    return;
}

sub get_legacy_name_list {
    _load_oldnames();

    return sort { $a =~ m/\.local$/ ? $a cmp $b : $b cmp $a } keys %oldname_to_locale;
}

sub get_existing_filesys_legacy_name_list {

    require Cpanel::SafeDir::Read;

    my %args = @_;
    my @extras;
    if ( exists $args{'also_look_in'} &amp;&amp; ref $args{'also_look_in'} eq 'ARRAY' ) {
        for my $path ( @{ $args{'also_look_in'} } ) {
            my $copy = $path;
            $copy =~ s/\/lang$//;
            next if !-d &quot;$copy/lang&quot;;
            push @extras, Cpanel::SafeDir::Read::read_dir(&quot;$copy/lang&quot;);
        }
    }

    my @local_less_names;
    my %has_local;
    my @names;

    my $legacy_dir = Cpanel::Locale::Utils::Paths::get_legacy_lang_root();
    for my $name ( grep { $_ !~ m/^\./ } ( $args{'no_root'} ? () : Cpanel::SafeDir::Read::read_dir($legacy_dir) ), @extras ) {
        my $copy = $name;
        if ( $copy =~ s/\.local$// ) {
            $has_local{$copy}++;
        }
        else {
            push @local_less_names, $copy;
        }
    }

    for my $name_localless ( sort { $b cmp $a } @local_less_names ) {
        push @names, exists $has_local{$name_localless} ? ( &quot;$name_localless.local&quot;, $name_localless ) : $name_localless;
    }

    return @names;
}

sub get_legacy_root_in_locale_database_root {
    return Cpanel::Locale::Utils::Paths::get_locale_database_root() . '/legacy';
}

sub get_legacy_file_cache_path {
    my ($legacy_file) = @_;
    $legacy_file .= 'cache';
    my $legacy_dir = Cpanel::Locale::Utils::Paths::get_legacy_lang_root();
    $legacy_file =~ s{$legacy_dir}{/var/cpanel/lang.cache};
    return $legacy_file;
}

sub map_any_old_style_to_new_style {
    return wantarray
      ? map { get_new_langtag_of_old_style_langname($_) || $_ } @_
      : get_new_langtag_of_old_style_langname( $_[0] ) || $_[0];
}

my %charset_lookup;

sub _determine_via_disassemble {
    my ( $lcl, $oldlang ) = @_;

    my ( $language, $territory, $encoding, $probable_ext );
    my @parts = split( /[^A-Za-z0-9]+/, $oldlang );    # We can't use Cpanel::CPAN::Locales::normalize_tag since it breaks things into 8 character chunks

    return if @parts == 1;                             # we've already tried just $parts[0] if the split is only 1 item
    return if @parts &gt; 4;                              # if there are more than 4 parts then there is unresolveable data

    if ( !ref($lcl) ) {
        $lcl = Cpanel::CPAN::Locales-&gt;new($lcl) or return;
    }

    for my $part (@parts) {
        my $found_part = 0;
        if ( $lcl-&gt;get_code_from_language($part) || $lcl-&gt;get_language_from_code($part) ) {
            if ($language) {
                if ( !$lcl-&gt;get_territory_from_code($part) ) {

                    return;
                }
            }
            else {
                $found_part++;
                $language = $lcl-&gt;get_language_from_code($part) ? $part : $lcl-&gt;get_code_from_language($part);
            }
        }

        if ( !$found_part &amp;&amp; ( $lcl-&gt;get_code_from_territory($part) || $lcl-&gt;get_territory_from_code($part) ) ) {
            if ($territory) {

                return;
            }
            else {
                $found_part++;
                $territory = $lcl-&gt;get_territory_from_code($part) ? $part : $lcl-&gt;get_code_from_territory($part);
            }
        }
        if ( !$found_part ) {
            if ( $part eq $parts[$#parts] ) {    # &amp;&amp; length($part) &lt; $max_len_for_ext
                $probable_ext = $part;
            }
            else {
                if ( !%charset_lookup ) {
                    require Cpanel::Locale::Utils::Charmap;

                    @charset_lookup{ map { Cpanel::Locale::Utils::Normalize::normalize_tag($_) } Cpanel::Locale::Utils::Charmap::get_charmap_list() } = ();
                }

                if ( $charset_lookup{$part} ) {
                    $found_part++;
                    $encoding = $part;
                }
                else {
                    return;
                }
            }
        }
    }

    if ($encoding) {

    }

    if ($probable_ext) {

    }

    if ($language) {
        if ($territory) {
            return &quot;$language\_$territory&quot;;
        }
        else {
            return $language;
        }
    }

    return;
}

sub real_get_new_langtag_of_old_style_langname {
    my ($oldlang) = @_;
    $oldlang = Cpanel::StringFunc::Case::ToLower($oldlang) || &quot;&quot;;    # case 34321 item #3

    $oldlang =~ s/\.legacy_duplicate\..+$//;                         # This '.legacy_duplicate. naming hack' is for copying legacy file into a name that maps back to it's new target locale

    if ( !defined $oldlang || $oldlang eq '' || $oldlang =~ m/^\s+$/ ) {

        return;                                                      # return a value ?, what is safe ...
    }
    elsif ( Cpanel::Locale::Utils::Normalize::normalize_tag($oldlang) eq 'default' ) {

        return;                                                      # return 'en' ? could be an incorrect assumption ...
    }
    elsif ( exists $oldname_to_locale{$oldlang} ) {
        return $oldname_to_locale{$oldlang};
    }

    {
        local $@;
        $loc ||= Cpanel::CPAN::Locales-&gt;new('en') or die $@;
    }

    my $return;
    if ( $loc-&gt;get_language_from_code($oldlang) ) {
        $return = Cpanel::Locale::Utils::Normalize::normalize_tag($oldlang);    # case 34321 item #4
    }
    else {

        my $locale = $loc-&gt;get_code_from_language($oldlang);
        if ($locale) {
            $return = $locale;    # case 34321 item #2
        }
        else {
            $return = _determine_via_disassemble( $loc, $oldlang );

            if ( !$return ) {

                local $SIG{'__DIE__'};    # may be made moot by case 50857
                for my $nen ( grep { $_ ne 'en' } sort( $loc-&gt;get_language_codes() ) ) {


                    my $loca = Cpanel::CPAN::Locales-&gt;new($nen) or next;    # singleton

                    my $locale = $loca-&gt;get_code_from_language($oldlang);
                    if ($locale) {
                        $return = $locale;                                  # case 34321 item #2
                        last;
                    }
                    else {
                        $return = _determine_via_disassemble( $loca, $oldlang );
                        last if $return;
                    }
                }
            }
        }
    }

    if ( !$return ) {

        $return = Cpanel::CPAN::Locales::get_i_tag_for_string($oldlang);
    }

    return $return;
}

sub get_new_langtag_of_old_style_langname {
    _load_oldnames();
    require Cpanel::StringFunc::Case;
    require Cpanel::CPAN::Locales;
    $loc = Cpanel::CPAN::Locales-&gt;new('en');
    {
        no warnings 'redefine';
        *get_new_langtag_of_old_style_langname = \&amp;real_get_new_langtag_of_old_style_langname;
    }
    goto &amp;real_get_new_langtag_of_old_style_langname;
}

my $legacy_lookup;

sub phrase_is_legacy_key {
    my ($key) = @_;
    if ( !$legacy_lookup ) {
        require 'Cpanel/Locale/Utils/MkDB.pm';    ## no critic qw(Bareword) - hide from perlpkg
        $legacy_lookup = {
            %{ Cpanel::Locale::Utils::MkDB::get_hash_of_legacy_file( Cpanel::Locale::Utils::Paths::get_legacy_lang_root() . '/english-utf8' ) || {} },
            %{ Cpanel::Locale::Utils::MkDB::get_hash_of_legacy_file('/usr/local/cpanel/base/frontend/jupiter/lang/english-utf8') || {} },
        };
    }

    return exists $legacy_lookup-&gt;{$key} ? 1 : 0;
}

sub fetch_legacy_lookup {
    return $legacy_lookup if $legacy_lookup;
    phrase_is_legacy_key('');    # ensure $legacy_lookup is loaded
    return $legacy_lookup;
}

sub get_legacy_key_english_value {
    my ($key) = @_;
    if ( phrase_is_legacy_key($key) ) {    # inits $legacy_lookup cache
        return $legacy_lookup-&gt;{$key};
    }

    return;
}

1;

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


{ # --- BEGIN Cpanel/Config/LoadCpUserFile/CurrentUser.pm
package Cpanel::Config::LoadCpUserFile::CurrentUser;


use strict;
use warnings;

# use Cpanel::Config::LoadCpUserFile ();


my $_cpuser_ref_singleton;
my $_cpuser_user;

sub load {
    my ($user) = @_;
    if ( $_cpuser_user &amp;&amp; $_cpuser_user eq $user ) {
        return $_cpuser_ref_singleton;
    }
    $_cpuser_user = $user;
    return ( $_cpuser_ref_singleton = Cpanel::Config::LoadCpUserFile::load($user) );
}

sub _reset {
    $_cpuser_ref_singleton = undef;
    $_cpuser_user          = undef;

    return;
}

1;

} # --- END Cpanel/Config/LoadCpUserFile/CurrentUser.pm


{ # --- BEGIN Cpanel/YAML/Syck.pm
package Cpanel::YAML::Syck;


use YAML::Syck ();

sub _init {
    $YAML::Syck::LoadBlessed = 0;
    {
        no warnings 'redefine';
        *Cpanel::YAML::Syck::_init = sub { };
    }
    return;
}

_init();

1;

} # --- END Cpanel/YAML/Syck.pm


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


use strict;
use warnings;


use constant {
    _ENOENT =&gt; 2,
};

my $logger;

our $VERSION = '1.3';

sub _log {
    my ( $level, $msg ) = @_;

    require Cpanel::Logger;
    $logger ||= Cpanel::Logger-&gt;new();
    $logger-&gt;$level($msg);

    return;
}

my $mtime;

sub touchfile {
    my ( $file, $verbose, $fail_ok ) = @_;

    if ( !defined $file ) {
        _log( 'warn', &quot;touchfile called with undefined file&quot; );
        return;
    }

    my $mtime;

    if ( utime undef, undef, $file ) {
        return 1;
    }
    elsif ( $! != _ENOENT() ) {
        _log( 'warn', &quot;utime($file) as $&gt;: $!&quot; );

        $mtime = -e $file ? ( stat _ )[9] : 0;    # for warnings-safe numeric comparison

        if ( !$mtime &amp;&amp; $! != _ENOENT ) {
            _log( 'warn', &quot;Failed to stat($file) as $&gt;: $!&quot; );
            return;
        }
    }

    $mtime = ( stat $file )[9] // 0;

    if ( open my $fh, '&gt;&gt;', $file ) {    # append so we don't wipe out contents
        my $mtime_after_open = ( stat $fh )[9] || 0;    # for warnings safe numeric comparison
        return 1 if $mtime != $mtime_after_open;        # in case open does not change it, see comment below
    }
    else {
        _log( 'warn', &quot;Failed to open(&gt;&gt; $file) as $&gt;: $!&quot; ) unless $fail_ok;
    }

    if ($fail_ok) { return; }

    my $at_this_point = ( stat $file )[9] || 0;    # for warnings safe numeric comparison
    if ( $mtime == $at_this_point ) {

        my $new_at_this_point = ( stat $file )[9] || 0;    # for warnings safe numeric comparison
        if ( $mtime == $new_at_this_point ) {
            if ($verbose) {
                _log( 'info', 'Trying to do system “touch” command!' );
            }
            if ( system( 'touch', $file ) != 0 ) {
                if ($verbose) {
                    _log( 'info', 'system method 1 failed.' );
                }
            }
        }
    }

    if ( !-e $file ) {    # obvisouly it didn't touch it if it doesn't exist...
        _log( 'warn', &quot;Failed to create $file: $!&quot; );
        return;
    }
    else {

        my $after_all_that = ( stat $file )[9] || 0;    # for warnings safe numeric comparison
        if ( $mtime &amp;&amp; $mtime == $after_all_that ) {
            _log( 'warn', &quot;mtime of “$file” not changed!&quot; );
            return;
        }
        return 1;
    }
}

1;

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


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


use strict;
use warnings;

# use Cpanel::Exception ();
# use Cpanel::PwCache   ();

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

    if ( !length $user ) {
        die Cpanel::Exception::create( 'MissingParameter', 'Supply a username or a user ID.' );
    }

    return $user if $user !~ tr{0-9}{}c;    # Only has numbers so its a uid

    my $uid = Cpanel::PwCache::getpwnam_noshadow($user);
    if ( !defined $uid ) {
        die Cpanel::Exception::create( 'UserNotFound', [ name =&gt; $user ] );
    }

    return $uid;
}

1;

} # --- END Cpanel/PwUtils.pm


{ # --- BEGIN Cpanel/AccessIds/Normalize.pm
package Cpanel::AccessIds::Normalize;


use strict;
use warnings;

# use Cpanel::ArrayFunc::Uniq ();
# use Cpanel::PwCache         ();
# use Cpanel::PwUtils         ();
# use Cpanel::Exception       ();


sub normalize_user_and_groups {
    my ( $user, @groups ) = @_;

    if ( ( scalar @groups == 1 &amp;&amp; !defined $groups[0] ) || ( scalar @groups &gt; 1 &amp;&amp; scalar( grep { !defined } @groups ) ) ) {
        require Cpanel::Carp;    # no load module for memory
        die Cpanel::Carp::safe_longmess(&quot;Undefined group passed to normalize_user_and_groups&quot;);
    }
    my $uid;

    if ( defined $user &amp;&amp; $user !~ tr{0-9}{}c ) {

        if ( scalar @groups == 1 &amp;&amp; $groups[0] !~ tr{0-9}{}c ) {    # we already have a gid
            return ( $user, $groups[0] );
        }

        $uid = $user;
    }
    elsif ( !scalar @groups ) {
        ( $uid, @groups ) = ( Cpanel::PwCache::getpwnam_noshadow($user) )[ 2, 3 ];

        if ( !defined $uid ) {
            die Cpanel::Exception::create( 'UserNotFound', [ name =&gt; $user ] );
        }
        return ( $uid, @groups );
    }
    else {
        $uid = Cpanel::PwUtils::normalize_to_uid($user);
    }

    my @gids =
      @groups
      ? ( map { !tr{0-9}{}c ? $_ : scalar( ( getgrnam $_ )[2] ) } @groups )
      : ( ( Cpanel::PwCache::getpwuid_noshadow($uid) )[3] // die Cpanel::Exception::create( 'UserNotFound', [ name =&gt; $user ] ) );

    if ( scalar @gids &gt; 2 ) {
        return ( $uid, Cpanel::ArrayFunc::Uniq::uniq(@gids) );
    }
    elsif ( scalar @gids == 2 &amp;&amp; $gids[0] eq $gids[1] ) {
        return ( $uid, $gids[0] );
    }

    return ( $uid, @gids );
}


sub normalize_code_user_groups {
    my @args = @_;

    my $code_index;
    for my $i ( 0 .. $#args ) {
        if ( ref $args[$i] eq 'CODE' ) {
            $code_index = $i;
            last;
        }
    }

    die &quot;No coderef found!&quot; if !defined $code_index;

    my $code = splice( @args, $code_index, 1 );

    return ( $code, normalize_user_and_groups( grep { defined } @args ) );
}

1;

} # --- END Cpanel/AccessIds/Normalize.pm


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


use strict;
use warnings;

# use Cpanel::ArrayFunc::Uniq ();
# use Cpanel::Debug           ();

sub normalize_user_and_groups {
    require Cpanel::AccessIds::Normalize;
    goto \&amp;Cpanel::AccessIds::Normalize::normalize_user_and_groups;
}

sub normalize_code_user_groups {
    require Cpanel::AccessIds::Normalize;
    goto \&amp;Cpanel::AccessIds::Normalize::normalize_code_user_groups;
}

sub set_egid {
    my @gids = @_;

    if ( !@gids ) {
        Cpanel::Debug::log_die(&quot;No arguments passed to set_egid()!&quot;);
    }

    if ( scalar @gids &gt; 1 ) {
        @gids = Cpanel::ArrayFunc::Uniq::uniq(@gids);
    }

    _check_positive_int($_) for @gids;

    my $new_egid = join( q{ }, $gids[0], @gids );

    return _set_var( \$), 'EGID', $new_egid );
}

sub set_rgid {
    my ( $gid, @extra_gids ) = @_;

    if (@extra_gids) {
        Cpanel::Debug::log_die(&quot;RGID can only be set to a single value! (Do you want set_egid()?)&quot;);
    }

    _check_positive_int($gid);

    return _set_var( \$(, 'RGID', $gid );
}

sub set_euid {
    my ($uid) = @_;

    _check_positive_int($uid);

    return _set_var( \$&gt;, 'EUID', $uid );
}

sub set_ruid {
    my ($uid) = @_;

    _check_positive_int($uid);

    return _set_var( \$&lt;, 'RUID', $uid );
}

sub _check_positive_int {
    if ( !length $_[0] || $_[0] =~ tr{0-9}{}c ) {
        Cpanel::Debug::log_die(&quot;“$_[0] is not a positive integer!&quot;);
    }

    return 1;
}

sub _set_var {
    my ( $var_r, $name, $desired_value ) = @_;

    my $old_value = $$var_r;
    $$var_r = $desired_value;

    return $desired_value eq $$var_r ? 1 : validate_var_set(
        $name,             # The name of the value like 'RUID'
        $desired_value,    # The value we wanted it to be set to
        $$var_r,           # Deferenced variable being set, ex $&lt;
        $old_value         # The value before we set it.
    );
}

sub validate_var_set {
    my ( $name, $desired_value, $new_value, $old_value ) = @_;

    my $error;


    if ( $new_value =~ tr/ // ) {


        my ( $desired_first, @desired_parts ) = split( ' ', $desired_value );
        my ( $new_first,     @new_parts )     = split( ' ', $new_value );

        if ( $new_first != $desired_first ) {
            $error = 1;
        }
        elsif ( @desired_parts &amp;&amp; @new_parts ) {
            if ( scalar @desired_parts == 1 &amp;&amp; scalar @new_parts == 1 ) {
                if ( $new_parts[0] != $desired_parts[0] ) {
                    $error = 1;
                }
            }
            else {
                @desired_parts = sort { $a &lt;=&gt; $b } Cpanel::ArrayFunc::Uniq::uniq(@desired_parts);
                @new_parts     = sort { $a &lt;=&gt; $b } Cpanel::ArrayFunc::Uniq::uniq(@new_parts);

                for my $i ( 0 .. $#desired_parts ) {
                    if ( $new_parts[$i] != $desired_parts[$i] ) {
                        $error = 1;
                        last;
                    }
                }
            }
        }
    }
    else {
        if ( $new_value != $desired_value ) {
            $error = 1;
        }
    }

    return 1 if !$error;

    if ( defined $old_value ) {
        Cpanel::Debug::log_die(&quot;Failed to change $name from “$old_value” to “$desired_value”: $!&quot;);
    }
    Cpanel::Debug::log_die(&quot;Failed to change $name to “$desired_value”: $!&quot;);

    return 0;    #not reached
}

1;

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


{ # --- BEGIN Cpanel/AccessIds/ReducedPrivileges.pm
package Cpanel::AccessIds::ReducedPrivileges;


use strict;
use warnings;

# use Cpanel::Debug                ();
# use Cpanel::AccessIds::Utils     ();
# use Cpanel::AccessIds::Normalize ();

our $PRIVS_REDUCED = 0;


sub new {    ## no critic qw(Subroutines::RequireArgUnpacking)
    my $class = shift;

    if ( $class ne __PACKAGE__ ) {
        Cpanel::Debug::log_die(&quot;Attempting to drop privileges as '$class'.&quot;);
    }

    my ( $uid, @gids ) = Cpanel::AccessIds::Normalize::normalize_user_and_groups(@_);

    _allowed_to_reduce_privileges();

    _prevent_dropping_to_root( $uid, @gids );

    my $self = bless {
        'uid'     =&gt; $&gt;,
        'gid'     =&gt; $),
        'new_uid' =&gt; $uid,
        'new_gid' =&gt; join( q&lt; &gt;, @gids ),
    }, $class;

    _reduce_privileges( $uid, @gids );

    $PRIVS_REDUCED = 1;

    return $self;
}

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

    local ( $., $@, $!, $^E, $? );

    my $check_err;
    eval { _allowed_to_restore_privileges( $self-&gt;{'new_uid'}, $self-&gt;{'new_gid'} ); 1 }
      or $check_err = $@;

    my $restore_err;
    eval { _restore_privileges( $self-&gt;{'uid'}, $self-&gt;{'gid'} ); 1 }
      or $restore_err = $@;

    eval {
        Cpanel::Debug::log_warn( __PACKAGE__ . &quot;::DESTROY: restore-state check failed: $check_err&quot; )     if $check_err;
        Cpanel::Debug::log_warn( __PACKAGE__ . &quot;::DESTROY: failed to restore privileges: $restore_err&quot; ) if $restore_err;
        1;
    };

    return 1;
}

sub call_as_user {    ## no critic qw(Subroutines::RequireArgUnpacking)
    my ( $code, $uid, $gid, @supplemental_gids ) = Cpanel::AccessIds::Normalize::normalize_code_user_groups(@_);

    _prevent_dropping_to_root( $uid, $gid );

    if ( !$code ) {
        Cpanel::Debug::log_die(&quot;No code reference supplied.&quot;);
    }

    _allowed_to_reduce_privileges();

    my $want = wantarray;    ## no critic qw(Community::Wantarray)

    my ( $saved_uid, $saved_gid ) = ( $&gt;, $) );

    my ( $scalar, @list );
    my $ex;

    if (
        !eval {
            _reduce_privileges( $uid, $gid, @supplemental_gids );

            local $PRIVS_REDUCED = 1;

            if ($want) {
                @list = eval { $code-&gt;(); };
            }
            elsif ( defined $want ) {
                $scalar = eval { $code-&gt;(); };
            }
            else {    #void context
                eval { $code-&gt;(); };
            }

            $ex = $@;

            1;
        }
    ) {
        $ex ||= $@;    # the reduction failed
    }

    my $restore_err;
    eval { _restore_privileges( $saved_uid, $saved_gid ); 1 } or do {
        $restore_err = $@;

        $PRIVS_REDUCED = 1;
    };

    if ($ex) {
        eval { Cpanel::Debug::log_warn( __PACKAGE__ . &quot;::call_as_user: failed to restore privileges: $restore_err&quot; ); 1 } if $restore_err;
        die $ex;
    }

    die $restore_err if $restore_err;

    return $want ? @list : $scalar;
}


sub _allowed_to_reduce_privileges {
    if ( $&lt; != 0 ) {
        Cpanel::Debug::log_die(&quot;Attempting to drop privileges as a normal user with RUID $&lt;&quot;);
    }

    if ( $&gt; != 0 ) {
        Cpanel::Debug::log_die(&quot;Attempting to drop privileges as a normal user with EUID $&gt;&quot;);
    }

    return 1;
}

sub _reduce_privileges {
    my ( $uid, $gid, @supplemental_gids ) = @_;

    Cpanel::AccessIds::Utils::set_egid( $gid, @supplemental_gids );
    Cpanel::AccessIds::Utils::set_euid($uid);

    return 1;
}

sub _prevent_dropping_to_root {


    if ( grep { !defined $_ } @_ ) {
        local $Cpanel::Logger::ENABLE_BACKTRACE = 1;
        Cpanel::Debug::log_die(&quot;Someone gave us an undefined value as program $0&quot;);
    }

    if ( grep { !$_ } @_ ) {
        Cpanel::Debug::log_die(&quot;Attempting to drop privileges to root.&quot;);
    }

    return 1;
}

sub _allowed_to_restore_privileges {
    my ( $uid, $gid ) = @_;

    if ( $&lt; != 0 ) {
        Cpanel::Debug::log_die(&quot;Attempting to restore privileges as a normal user with RUID $&lt;&quot;);
    }

    if ( $&gt; != $uid ) {
        Cpanel::Debug::log_warn(&quot;EUID ($&gt;) does not match expected reduced user ($uid)&quot;);
    }

    my ( $first_egid, $first_given_gid ) = ( $), $gid );
    $_ = ( split m{ } )[0] for ( $first_egid, $first_given_gid );

    if ( int $first_egid != int $first_given_gid ) {
        Cpanel::Debug::log_warn(&quot;EGID ($)) does not match expected reduced user ($gid)&quot;);
    }
}

sub _restore_privileges {
    my ( $saved_uid, $saved_gid ) = @_;

    Cpanel::AccessIds::Utils::set_euid($saved_uid);
    Cpanel::AccessIds::Utils::set_egid( split m{ }, $saved_gid );

    $PRIVS_REDUCED = 0;

    return 1;
}

1;

} # --- END Cpanel/AccessIds/ReducedPrivileges.pm


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


use strict;

use YAML::Syck         ();
# use Cpanel::YAML::Syck ();

BEGIN {
    *Dump     = *YAML::Syck::Dump;
    *Load     = *YAML::Syck::Load;
    *SafeDump = *YAML::Syck::Dump;
    *DumpFile = *YAML::Syck::DumpFile;
}

our $MAX_LOAD_LENGTH      = 65535;
our $MAX_PRIV_LOAD_LENGTH = 4194304;    # four megs

sub _is_openhandle {
    my $h = shift;

    return 1 if ( ref($h) eq 'GLOB' );
    return 1 if ( ref( \$h ) eq 'GLOB' );
    return 1 if ( ref($h) =~ m/^IO::/ );

    return;
}

sub SafeLoadFile {    # only allow a small bit of data to be loaded
    LoadFile( $_[0], $MAX_LOAD_LENGTH );
}

sub LoadFile {
    my $file = shift;
    my $max  = shift;

    my $str_r;
    if ( _is_openhandle($file) ) {
        if ($max) {
            my $togo   = $max;
            my $buffer = '';
            my $bytes_read;
            while ( $bytes_read = read( $file, $buffer, $togo, length $buffer ) &amp;&amp; length $buffer &lt; $max ) {
                $togo -= $bytes_read;
            }
            $str_r = \$buffer;
        }
        else {
            $str_r = \do { local $/; &lt;$file&gt; };
        }
    }
    else {
        if ( !-e $file || -z $file ) {
            require Carp;
            Carp::croak(&quot;'$file' is non-existent or empty&quot;);
        }
        open( my $fh, '&lt;', $file ) or do {
            require Carp;
            Carp::croak(&quot;Cannot read from $file: $!&quot;);
        };
        $str_r = \do { local $/; &lt;$fh&gt; };
    }

    return YAML::Syck::LoadYAML($$str_r);
}

1;

} # --- END Cpanel/YAML.pm


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


use strict;
use warnings;
# use Cpanel::Debug ();

sub store_ref {
    my ( $file, $outof_ref, $perm ) = @_;

    require Cpanel::YAML::Syck;

    $YAML::Syck::ImplicitTyping = 0;

    local $YAML::Syck::SingleQuote;
    local $YAML::Syck::SortKeys;

    $YAML::Syck::SingleQuote = 1;
    $YAML::Syck::SortKeys    = 1;

    if ( ref($file) ) {

        my $yaml_string = YAML::Syck::Dump($outof_ref);

        print( {$file} _format($yaml_string) ) || return;
        return $file;
    }

    if ( ref($perm) eq 'ARRAY' &amp;&amp; !-l $file &amp;&amp; !-e $file ) {
        require Cpanel::FileUtils::TouchFile;    # or use() ?

        my $touch_chmod = sub {
            if ( !Cpanel::FileUtils::TouchFile::touchfile($file) ) {
                Cpanel::Debug::log_info(&quot;Could not touch \xE2\x80\x9C$file\xE2\x80\x9D: $!&quot;);
                return;
            }

            if ( $perm-&gt;[0] ) {
                if ( !chmod( oct( $perm-&gt;[0] ), $file ) ) {
                    Cpanel::Debug::log_info(&quot;Could not chmod \xE2\x80\x9C$file\xE2\x80\x9D to \xE2\x80\x9C$perm-&gt;[0]\xE2\x80\x9D: $!&quot;);
                    return;
                }
            }

            return 1;
        };

        if ( $&gt; == 0 &amp;&amp; $perm-&gt;[1] &amp;&amp; $perm-&gt;[1] ne 'root' ) {
            require Cpanel::AccessIds::ReducedPrivileges;    # or use() ?
            Cpanel::AccessIds::ReducedPrivileges::call_as_user( $perm-&gt;[1], $touch_chmod ) || return;
        }
        else {
            $touch_chmod-&gt;() || return;
        }
    }

    if ( open my $yaml_out, '&gt;', $file ) {
        my $yaml_string = YAML::Syck::Dump($outof_ref);
        print {$yaml_out} _format($yaml_string);
        close $yaml_out;
        return 1;
    }
    else {
        Cpanel::Debug::log_warn(&quot;Could not open file '$file' for writing: $!&quot;);
        return;
    }
}

sub fetch_ref {
    my ( $file, $is_array ) = @_;

    my $fetch_ref = load_ref($file);

    my $data_type = ref $fetch_ref;
    my $data      = $data_type ? $fetch_ref : undef;
    $data_type ||= 'UNDEF';

    if ( $is_array &amp;&amp; $data_type ne 'ARRAY' ) {
        return [];
    }
    elsif ( !$is_array &amp;&amp; $data_type ne 'HASH' ) {
        return {};
    }

    return $data;
}

sub load_ref {
    my ( $file, $into_ref ) = @_;
    return if ( !-e $file || -z _ );

    require Cpanel::YAML;

    $YAML::Syck::ImplicitTyping = 0;

    my $struct;

    if ( ref($file) ) {

        local $!;
        $struct = eval {
            local $/;
            local $SIG{__WARN__};
            local $SIG{__DIE__};
            ( Cpanel::YAML::Load(&lt;$file&gt;) )[0];
        };
        Cpanel::Debug::log_warn(&quot;Error loading YAML data: $!&quot;) if ( !$struct );
    }
    elsif ( open my $yaml_in, '&lt;', $file ) {
        local $!;
        $struct = eval {
            local $/;
            local $SIG{__WARN__};
            local $SIG{__DIE__};
            ( Cpanel::YAML::Load(&lt;$yaml_in&gt;) )[0];
        };
        Cpanel::Debug::log_warn(&quot;Error loading YAML data: $!&quot;) if ( !$struct );
        close $yaml_in;
    }
    else {
        my $err = $!;
        Cpanel::Debug::log_warn(&quot;Could not open file '$file' for reading: $err&quot;);
        return;
    }

    if ( !$struct ) {
        Cpanel::Debug::log_warn(&quot;Failed to load YAML data from file $file&quot;);
        return;
    }

    if ( defined $into_ref ) {
        my $type      = ref $into_ref;
        my $yaml_type = ref $struct;
        if ( $yaml_type ne $type ) {
            Cpanel::Debug::log_warn(&quot;Invalid data type from file $file! YAML type $yaml_type does not match expected type $type. Data ignored!&quot;);
            return;    # if we want an empty ref on failure use fetch_ref()
        }

        if ( $yaml_type eq 'HASH' ) {
            %{$into_ref} = %{$struct};
        }
        elsif ( $yaml_type eq 'ARRAY' ) {
            @{$into_ref} = @{$struct};
        }
        else {
            Cpanel::Debug::log_warn(&quot;YAML in '$file' is not a hash or array reference&quot;);
            return;    # if we want an empty ref on failure use fetch_ref()
        }

        return $into_ref;
    }

    return $struct;
}

sub edit_datastore {
    my ( $file, $editor_cr, $is_array ) = @_;

    if ( ref $editor_cr ne 'CODE' ) {
        Cpanel::Debug::log_warn('second arg needs to be a coderef');
        return;
    }

    my $ref = $is_array ? [] : {};

    if ( !-e $file ) {
        Cpanel::Debug::log_info(&quot;Data store file $file does not exist. Attempting to create empty datastore.&quot;);
        store_ref( $file, $ref );
    }

    if ( load_ref( $file, $ref ) ) {
        if ( $editor_cr-&gt;($ref) ) {
            if ( !store_ref( $file, $ref ) ) {
                Cpanel::Debug::log_warn(&quot;Modifications to file $file could not be saved&quot;);
                return;
            }
        }
    }
    else {
        Cpanel::Debug::log_warn(&quot;Could not load datastore $file&quot;);
        return;
    }

    return 1;
}

sub _format {
    my ($s) = @_;

    $s =~ s/[ \t]+$//mg;
    return __grapheme_to_character($s);
}

sub __grapheme_to_character {
    my ($yaml_string) = @_;

    $yaml_string = quotemeta($yaml_string);
    $yaml_string =~ s/\\{2}x/\\x/g;
    $yaml_string = eval qq{&quot;$yaml_string&quot;};

    return $yaml_string;
}

1;


} # --- END Cpanel/DataStore.pm


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


use strict;
use warnings;

# use Cpanel::Exception          ();
# use Cpanel::Fcntl::Constants   ();
# use Cpanel::LoadFile::ReadFast ();

sub loadfileasarrayref {
    my $fileref = _load_file( shift, { 'array_ref' =&gt; 1 } );
    return ref $fileref eq 'ARRAY' ? $fileref : undef;
}

sub loadbinfile {
    my $fileref = _load_file( shift, { 'binmode' =&gt; 1 } );
    return ref $fileref eq 'SCALAR' ? $$fileref : undef;
}

sub slurpfile {
    my $fh      = shift;
    my $fileref = _load_file(shift);
    if ( ref $fileref eq 'SCALAR' ) {
        print {$fh} $$fileref;
    }
    return;
}

sub loadfile {
    my $fileref = _load_file(@_);
    return ref $fileref eq 'SCALAR' ? $$fileref : undef;
}

sub loadfile_r {
    my ( $file, $arg_ref ) = @_;

    if ( open my $lf_fh, '&lt;:stdio', $file ) {
        if ( $arg_ref-&gt;{'binmode'} ) { binmode $lf_fh; }

        my $data;
        if ( $arg_ref-&gt;{'array_ref'} ) {
            @{$data} = readline $lf_fh;
            close $lf_fh;
            return $data;
        }
        else {
            $data = '';
            local $@;

            eval { Cpanel::LoadFile::ReadFast::read_all_fast( $lf_fh, $data ); };
            return $@ ? undef : \$data;
        }
    }

    return;
}

*_load_file = *loadfile_r;

sub _open {
    return _open_if_exists( $_[0] ) || die Cpanel::Exception::create( 'IO::FileNotFound', [ path =&gt; $_[0], error =&gt; _ENOENT() ] );
}

sub _open_if_exists {
    local $!;
    open my $fh, '&lt;:stdio', $_[0] or do {

        if ( $! == _ENOENT() ) {
            return undef;
        }
        die Cpanel::Exception::create( 'IO::FileOpenError', [ path =&gt; $_[0], error =&gt; $!, mode =&gt; '&lt;' ] );
    };

    return $fh;
}

sub load_if_exists {
    my $ref = _load_r( \&amp;_open_if_exists, @_ );
    return $ref ? $$ref : undef;
}

sub load_r_if_exists {
    return _load_r( \&amp;_open_if_exists, @_ );
}

sub load {
    return ${ _load_r( \&amp;_open, @_ ) };
}

sub load_r {
    return _load_r( \&amp;_open,, @_ );
}

sub _load_r {
    my ( $open_coderef, $path, $offset, $length ) = @_;

    my $fh = $open_coderef-&gt;($path) or return undef;

    local $!;

    if ($offset) {
        sysseek( $fh, $offset, $Cpanel::Fcntl::Constants::SEEK_SET );

        if ($!) {
            die Cpanel::Exception::create(
                'IO::FileSeekError',
                [
                    path     =&gt; $path,
                    position =&gt; $offset,
                    whence   =&gt; $Cpanel::Fcntl::Constants::SEEK_SET,
                    error    =&gt; $!,
                ]
            );
        }
    }

    my $data = q&lt;&gt;;

    if ( !defined $length ) {

        my $bytes_read = Cpanel::LoadFile::ReadFast::read_fast( $fh, $data, Cpanel::LoadFile::ReadFast::READ_CHUNK );

        if ( $bytes_read == Cpanel::LoadFile::ReadFast::READ_CHUNK ) {
            my $file_size = -f $fh &amp;&amp; -s _;

            if ($file_size) {

                Cpanel::LoadFile::ReadFast::read_fast( $fh, $data, $file_size, length $data ) // die _read_err($path);
            }
        }

        Cpanel::LoadFile::ReadFast::read_all_fast( $fh, $data );
    }
    else {
        my $togo = $length;
        my $bytes_read;
        while ( $bytes_read = Cpanel::LoadFile::ReadFast::read_fast( $fh, $data, $togo, length $data ) &amp;&amp; length $data &lt; $length ) {
            $togo -= $bytes_read;
        }
    }

    if ($!) {
        die Cpanel::Exception::create( 'IO::FileReadError', [ path =&gt; $path, error =&gt; $! ] );
    }

    close $fh or warn &quot;The system failed to close the file “$path” because of an error: $!&quot;;

    return \$data;
}

sub _ENOENT { return 2; }
1;

} # --- END Cpanel/LoadFile.pm


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


use strict;
use warnings;

our %cpanel_provided = (
    'de'               =&gt; 1,
    'en'               =&gt; 1,
    'es_es'            =&gt; 1,
    'i_cpanel_snowmen' =&gt; 1,
    'ru'               =&gt; 1,
    'ja'               =&gt; 1,
);

my %locale_to_3rdparty;

sub _load_3rdparty {
    return if (%locale_to_3rdparty);

    %locale_to_3rdparty = (
        'ar' =&gt; {
            'analog'    =&gt; 'us',
            'awstats'   =&gt; 'ar',
            'webalizer' =&gt; 'english'
        },
        'bg' =&gt; {
            'analog'    =&gt; 'bg',
            'awstats'   =&gt; 'bg',
            'webalizer' =&gt; 'english'
        },
        'bn' =&gt; {
            'analog'    =&gt; 'us',
            'awstats'   =&gt; 'en',
            'webalizer' =&gt; 'english'
        },
        'de' =&gt; {
            'analog'    =&gt; 'de',
            'awstats'   =&gt; 'de',
            'webalizer' =&gt; 'german'
        },
        'en' =&gt; {
            'analog'    =&gt; 'us',
            'awstats'   =&gt; 'en',
            'webalizer' =&gt; 'english'
        },
        'es' =&gt; {
            'analog'    =&gt; 'es',
            'awstats'   =&gt; 'es',
            'webalizer' =&gt; 'spanish'
        },
        'es_es' =&gt; {
            'analog'    =&gt; 'es',
            'awstats'   =&gt; 'es',
            'webalizer' =&gt; 'spanish'
        },
        'fi' =&gt; {
            'analog'    =&gt; 'fi',
            'awstats'   =&gt; 'fi',
            'webalizer' =&gt; 'finnish'
        },
        'fr' =&gt; {
            'analog'    =&gt; 'fr',
            'awstats'   =&gt; 'fr',
            'webalizer' =&gt; 'french'
        },
        'hi' =&gt; {
            'analog'    =&gt; 'us',
            'awstats'   =&gt; 'en',
            'webalizer' =&gt; 'english'
        },
        'hu' =&gt; {
            'analog'    =&gt; 'hu',
            'awstats'   =&gt; 'hu',
            'webalizer' =&gt; 'hungarian'
        },
        'id' =&gt; {
            'analog'    =&gt; 'us',
            'awstats'   =&gt; 'id',
            'webalizer' =&gt; 'indonesian'
        },
        'it' =&gt; {
            'analog'    =&gt; 'it',
            'awstats'   =&gt; 'it',
            'webalizer' =&gt; 'italian'
        },
        'ja' =&gt; {
            'analog'    =&gt; 'jpu',       # appears to be the UTF-8 one
            'awstats'   =&gt; 'jp',
            'webalizer' =&gt; 'japanese'
        },
        'ko' =&gt; {
            'analog'    =&gt; 'us',
            'awstats'   =&gt; 'ko',
            'webalizer' =&gt; 'korean'
        },
        'nl' =&gt; {
            'analog'    =&gt; 'nl',
            'awstats'   =&gt; 'nl',
            'webalizer' =&gt; 'dutch'
        },
        'no' =&gt; {
            'analog'    =&gt; 'no',
            'awstats'   =&gt; 'en',
            'webalizer' =&gt; 'norwegian'
        },
        'pl' =&gt; {
            'analog'    =&gt; 'pl',
            'awstats'   =&gt; 'pl',
            'webalizer' =&gt; 'polish'
        },
        'pt' =&gt; {
            'analog'    =&gt; 'pt',
            'awstats'   =&gt; 'pt',
            'webalizer' =&gt; 'portuguese'
        },
        'pt_br' =&gt; {
            'analog'    =&gt; 'pt',
            'awstats'   =&gt; 'pt',
            'webalizer' =&gt; 'portuguese_brazil'
        },
        'ro' =&gt; {
            'analog'    =&gt; 'ro',
            'awstats'   =&gt; 'ro',
            'webalizer' =&gt; 'romanian'
        },
        'ru' =&gt; {
            'analog'    =&gt; 'ru',
            'awstats'   =&gt; 'ru',
            'webalizer' =&gt; 'russian'
        },
        'sl' =&gt; {
            'analog'    =&gt; 'us',
            'awstats'   =&gt; 'en',
            'webalizer' =&gt; 'slovene'
        },
        'sv' =&gt; {
            'analog'    =&gt; 'us',
            'awstats'   =&gt; 'en',
            'webalizer' =&gt; 'swedish'
        },
        'th' =&gt; {
            'analog'    =&gt; 'us',
            'awstats'   =&gt; 'th',
            'webalizer' =&gt; 'english'
        },
        'tr' =&gt; {
            'analog'    =&gt; 'tr',
            'awstats'   =&gt; 'tr',
            'webalizer' =&gt; 'turkish'
        },
        'zh' =&gt; {
            'analog'    =&gt; 'cn',       # the cn.lng does not say what it is so this is an assumption based on other pervasive bad practices
            'awstats'   =&gt; 'cn',
            'webalizer' =&gt; 'chinese'
        },
        'zh_cn' =&gt; {
            'analog'    =&gt; 'cn',                  # the cn.lng does not say what it is so this is an assumption based on other pervasive bad practices
            'awstats'   =&gt; 'cn',
            'webalizer' =&gt; 'simplified_chinese'
        },
    );
}

sub get_known_3rdparty_lang {
    my ( $locale, $_3rdparty ) = @_;
    _load_3rdparty();
    my $locale_tag = ref $locale ? $locale-&gt;get_language_tag() : $locale;
    $locale_tag = 'en' if $locale_tag eq 'en_us' || $locale_tag eq 'i_default';

    return if !exists $locale_to_3rdparty{$locale_tag};
    return if !exists $locale_to_3rdparty{$locale_tag}{$_3rdparty};
    return $locale_to_3rdparty{$locale_tag}{$_3rdparty};
}

my %locale_lookup_cache;

sub get_3rdparty_lang {
    my ( $locale, $_3rdparty ) = @_;
    my $known = get_known_3rdparty_lang( $locale, $_3rdparty );
    return $known if $known;

    return if !ref($locale) &amp;&amp; $locale =~ m/(?:\.\.|\/)/;
    return if $_3rdparty               =~ m/(?:\.\.|\/)/;

    my $locale_tag = ref $locale ? $locale-&gt;get_language_tag() : $locale;
    $locale_tag = 'en' if $locale_tag eq 'en_us' || $locale_tag eq 'i_default';

    if ( exists $locale_lookup_cache{$_3rdparty} ) {
        return $locale_lookup_cache{$_3rdparty}{$locale_tag} if exists $locale_lookup_cache{$_3rdparty}{$locale_tag};
        return;
    }
    require Cpanel::DataStore;
    my $hr = Cpanel::DataStore::fetch_ref(&quot;/var/cpanel/locale/3rdparty/apps/$_3rdparty.yaml&quot;);
    my %seen;
    %{ $locale_lookup_cache{$_3rdparty} } = map { ++$seen{ $hr-&gt;{$_} } == 1 ? ( $hr-&gt;{$_} =&gt; $_ ) : () } keys %{$hr};

    return $locale_lookup_cache{$_3rdparty}{$locale_tag} if exists $locale_lookup_cache{$_3rdparty}{$locale_tag};
    return;
}

my @list;

sub get_3rdparty_list {
    return @list if @list;

    @list = qw(analog awstats webalizer);

    if ( -d &quot;/var/cpanel/locale/3rdparty/apps&quot; ) {
        require Cpanel::SafeDir::Read;
        push @list, sort map { my $f = $_; $f =~ s/\.yaml$// ? ($f) : () } Cpanel::SafeDir::Read::read_dir(&quot;/var/cpanel/locale/3rdparty/apps&quot;);
    }

    return @list;
}

my %opt_cache;

sub get_app_options {
    my ($_3rdparty) = @_;
    return if $_3rdparty =~ m/(?:\.\.|\/)/;

    return $opt_cache{$_3rdparty} if exists $opt_cache{$_3rdparty};
    if ( $_3rdparty eq 'analog' || $_3rdparty eq 'awstats' || $_3rdparty eq 'webalizer' ) {
        _load_3rdparty();
        my %seen;
        $opt_cache{$_3rdparty} = [ sort map { ++$seen{ $locale_to_3rdparty{$_}{$_3rdparty} } == 1 ? ( $locale_to_3rdparty{$_}{$_3rdparty} ) : () } keys %locale_to_3rdparty ];
    }
    else {
        require Cpanel::DataStore;
        my $hr = Cpanel::DataStore::fetch_ref(&quot;/var/cpanel/locale/3rdparty/apps/$_3rdparty.yaml&quot;);
        $opt_cache{$_3rdparty} = [ sort keys %{$hr} ];
    }

    return $opt_cache{$_3rdparty};
}

sub get_app_setting {
    my ( $locale, $_3rdparty ) = @_;

    return if !ref($locale) &amp;&amp; $locale =~ m/(?:\.\.|\/)/;
    return if $_3rdparty               =~ m/(?:\.\.|\/)/;

    require Cpanel::LoadFile;
    require Cpanel::StringFunc::Trim;

    my $locale_tag = ref $locale ? $locale-&gt;get_language_tag() : $locale;
    $locale_tag = 'en' if $locale_tag eq 'en_us' || $locale_tag eq 'i_default';

    my $setting = Cpanel::StringFunc::Trim::ws_trim( Cpanel::LoadFile::loadfile(&quot;/var/cpanel/locale/3rdparty/conf/$locale_tag/$_3rdparty&quot;) ) || '';
    if ( $_3rdparty eq 'analog' &amp;&amp; $setting eq 'en' ) {
        $setting = 'us';
    }

    return $setting;
}

sub set_app_setting {
    my ( $locale, $_3rdparty, $setting ) = @_;

    return if !ref($locale) &amp;&amp; $locale =~ m/(?:\.\.|\/)/;
    return if $_3rdparty               =~ m/(?:\.\.|\/)/;

    require Cpanel::SafeDir::MK;
    require Cpanel::FileUtils::Write;

    my $locale_tag = ref $locale ? $locale-&gt;get_language_tag() : $locale;
    $locale_tag = 'en' if $locale_tag eq 'en_us' || $locale_tag eq 'i_default';

    Cpanel::SafeDir::MK::safemkdir(&quot;/var/cpanel/locale/3rdparty/conf/$locale_tag/&quot;);
    Cpanel::FileUtils::Write::overwrite_no_exceptions( &quot;/var/cpanel/locale/3rdparty/conf/$locale_tag/$_3rdparty&quot;, $setting, 0644 );

    return;
}

1;

} # --- END Cpanel/Locale/Utils/3rdparty.pm


{ # --- BEGIN Cpanel/JS/Variations.pm
package Cpanel::JS::Variations;


use strict;

sub lex_filename_for {
    my ( $filename, $locale ) = @_;
    return if !$filename || !$locale;
    return get_base_file( $filename, &quot;-${locale}.js&quot; );
}

sub get_base_file {
    my ( $filename, $replace_extension ) = @_;
    return if !$filename;
    $replace_extension //= '.js';
    $filename =~ s{/js2-min/}{/js2/};
    $filename =~ s{(?:[\.\-]min|_optimized)?\.js$}{$replace_extension};
    return $filename;
}

1;

} # --- END Cpanel/JS/Variations.pm


{ # --- BEGIN Cpanel/Config/LoadCpConf.pm
package Cpanel::Config::LoadCpConf;


use strict;
use warnings;


# use Cpanel::Config::CpConfGuard ();


sub loadcpconf {
    my $cpconf = Cpanel::Config::CpConfGuard-&gt;new( 'loadcpconf' =&gt; 1 )-&gt;config_copy;
    return wantarray ? %$cpconf : $cpconf;
}


sub loadcpconf_not_copy {

    if ( !defined $Cpanel::Config::CpConfGuard::memory_only &amp;&amp; $Cpanel::Config::CpConfGuard::MEM_CACHE_CPANEL_CONFIG_MTIME ) {
        my ( $cache, $cache_is_valid ) = Cpanel::Config::CpConfGuard::get_cache();
        if ($cache_is_valid) {
            return wantarray ? %$cache : $cache;
        }
    }

    my $cpconf_obj = Cpanel::Config::CpConfGuard-&gt;new( 'loadcpconf' =&gt; 1 );
    my $cpconf     = $cpconf_obj-&gt;{'data'} || $cpconf_obj-&gt;{'cache'} || {};
    return wantarray ? %$cpconf : $cpconf;
}

sub clearcache;
*clearcache = *Cpanel::Config::CpConfGuard::clearcache;

1;

} # --- END Cpanel/Config/LoadCpConf.pm


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


use warnings;
use strict;
# use Cpanel::Locale::Utils::Paths ();

sub get_locale_list {
    my ($lh) = @_;
    my @result = @{ $lh-&gt;{'_cached_get_locale_list'} ||= [ sort ( 'en', $lh-&gt;list_available_locales() ) ] };

    if ( !-e &quot;/var/cpanel/enable_snowmen&quot; ) {
        @result = grep { !/i_cpanel_snowmen/ } @result;
    }
    return @result;
}

sub get_non_existent_locale_list {
    my ( $lh, $loc_obj ) = @_;

    $loc_obj ||= $lh-&gt;get_locales_obj('en');
    my %have;
    @have{ get_locale_list($lh), 'en_us', 'i_default', 'und', 'zxx', 'mul', 'mis', 'art' } = ();
    return sort grep { !exists $have{$_} } $loc_obj-&gt;get_language_codes();
}

sub get_locale_menu_hashref {
    my ( $lh, $omit_current_locale, $native_only, $skip_locales ) = @_;

    $skip_locales ||= {};
    my %langs;
    my %dir;

    my @langs = get_locale_list($lh);

    my @wanted_langs = grep { !$skip_locales-&gt;{$_} } @langs;

    if ( !@wanted_langs ) {
        return ( {}, \@langs, {} );
    }

    my $func = $native_only ? 'lang_names_hashref_native_only' : 'lang_names_hashref';
    my ( $localized_name_for_tag, $native_name_for_tag, $direction_map ) = $lh-&gt;$func(@wanted_langs);
    my $current_tag = $lh-&gt;get_language_tag();
    $current_tag = 'en' if $current_tag eq 'en_us' || $current_tag eq 'i_default';

    my $i_locales_path = Cpanel::Locale::Utils::Paths::get_i_locales_config_path();
    if ($omit_current_locale) {
        delete $localized_name_for_tag-&gt;{$current_tag};
        delete $native_name_for_tag-&gt;{$current_tag};
        @langs = grep { $_ ne $current_tag } @langs;
    }

    foreach my $tag ( keys %{$localized_name_for_tag} ) {
        if ( index( $tag, 'i_' ) == 0 ) {
            require Cpanel::DataStore;
            my $i_conf = Cpanel::DataStore::fetch_ref(&quot;$i_locales_path/$tag.yaml&quot;);
            $langs{$tag} = exists $i_conf-&gt;{'display_name'} &amp;&amp; defined $i_conf-&gt;{'display_name'} &amp;&amp; $i_conf-&gt;{'display_name'} ne '' ? &quot;$i_conf-&gt;{'display_name'} - $tag&quot; : $tag;                    # slightly different format than real tags to visually indicate specialness
            $native_name_for_tag-&gt;{$tag} = $langs{$tag};

            if ( exists $i_conf-&gt;{'character_orientation'} ) {
                $dir{$tag} = $lh-&gt;get_html_dir_attr( $i_conf-&gt;{'character_orientation'} );
            }
            elsif ( exists $i_conf-&gt;{'fallback_locale'} &amp;&amp; exists $direction_map-&gt;{ $i_conf-&gt;{'fallback_locale'} } ) {
                $dir{$tag} = $direction_map-&gt;{ $i_conf-&gt;{'fallback_locale'} };
            }

            next;
        }

        if ( exists $direction_map-&gt;{$tag} ) {
            $dir{$tag} = $lh-&gt;get_html_dir_attr( $direction_map-&gt;{$tag} );
        }

        next if $native_only;

        if ( $native_name_for_tag-&gt;{$tag} eq $localized_name_for_tag-&gt;{$tag} ) {
            if ( $tag eq $current_tag ) {
                $langs{$tag} = $native_name_for_tag-&gt;{$tag};
            }
            else {
                $langs{$tag} = &quot;$localized_name_for_tag-&gt;{$tag} ($tag)&quot;;
            }
        }
        else {
            $langs{$tag} = &quot;$localized_name_for_tag-&gt;{$tag} ($native_name_for_tag-&gt;{$tag})&quot;;
        }
    }

    if ($native_only) {
        return wantarray ? ( $native_name_for_tag, \@langs, \%dir ) : $native_name_for_tag;
    }

    return wantarray ? ( \%langs, \@langs, \%dir ) : \%langs;
}

sub get_non_existent_locale_menu_hashref {
    my $lh = shift;

    $lh-&gt;{'Locales.pm'}{'_main_'} ||= $lh-&gt;get_locales_obj();

    my %langs;
    my %dir;
    my @langs = get_non_existent_locale_list( $lh, $lh-&gt;{'Locales.pm'}{'_main_'} );

    my $wantarray = wantarray() ? 1 : 0;

    for my $code (@langs) {
        if ($wantarray) {
            if ( my $orient = $lh-&gt;{'Locales.pm'}{'_main_'}-&gt;get_character_orientation_from_code_fast($code) ) {
                $dir{$code} = $lh-&gt;get_html_dir_attr($orient);
            }
        }

        my $current = $lh-&gt;{'Locales.pm'}{'_main_'}-&gt;get_language_from_code( $code, 1 );
        my $native  = $lh-&gt;{'Locales.pm'}{'_main_'}-&gt;get_native_language_from_code( $code, 1 );
        $langs{$code} = $current eq $native ? &quot;$current ($code)&quot; : &quot;$current ($native)&quot;;
    }

    return wantarray ? ( \%langs, \@langs, \%dir ) : \%langs;
}

sub in_translation_vetting_mode {
    return ( -e '/var/cpanel/translation_vetting_mode' ) ? 1 : 0;
}

1;

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


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


use strict;
use warnings;


# use Cpanel::Locale ();

my $_lh;

sub _api1_maketext {    ## no critic qw(Subroutines::RequireArgUnpacking)                             ## no extract maketext
    $_lh ||= Cpanel::Locale-&gt;get_handle();
    $_[0] =~ s{\\'}{'}g;
    my $localized_str = $_lh-&gt;makevar(@_);
    if ($Cpanel::Parser::Vars::embtag) {    # PPI NO PARSE -- module will already be there is we care about it

        require Cpanel::Encoder::Tiny;
        $localized_str = Cpanel::Encoder::Tiny::safe_html_encode_str($localized_str);
    }
    elsif ($Cpanel::Parser::Vars::javascript) {    # PPI NO PARSE -- module will already be there is we care about it
        $localized_str =~ s/&quot;/\\&quot;/g;
        $localized_str =~ s/'/\\'/g;
    }
    return {
        status    =&gt; 1,
        statusmsg =&gt; $localized_str,
    };
}

1;

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


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


use strict;
# use Cpanel::Debug ();
use IO::SigGuard  ();

use constant _ENOENT =&gt; 2;

our $VERSION = '1.0';

my $MAX_LINE_SIZE = 32768;

sub get_file_lines {
    my $cfgfile     = shift;
    my $line_number = shift;
    return if ( !$line_number || $line_number !~ m/^\d+$/ );

    my $numpadding = 7;
    my %ret;
    if ( open( my $cfg_fh, '&lt;', $cfgfile ) ) {
        my $linecounter = 0;
        while ( readline($cfg_fh) ) {
            $linecounter++;
            if ( $linecounter &lt; $line_number &amp;&amp; $linecounter &gt; ( $line_number - $numpadding ) ) {
                push @{ $ret{'previouslines'} }, { 'line' =&gt; $linecounter, 'data' =&gt; $_ };
            }
            elsif ( $linecounter &gt; $line_number &amp;&amp; $linecounter &lt; ( $line_number + $numpadding ) ) {
                push @{ $ret{'afterlines'} }, { 'line' =&gt; $linecounter, 'data' =&gt; $_ };
            }
            elsif ( $linecounter == $line_number ) {
                push @{ $ret{'lines'} }, { 'line' =&gt; $linecounter, 'data' =&gt; $_ };
            }
            elsif ( $linecounter &gt; ( $line_number + $numpadding ) ) {
                last;
            }
        }
        close $cfg_fh;
    }
    return \%ret;
}

sub get_last_lines {
    my $cfgfile = shift;
    my $number  = shift;
    if ( !$number || $number !~ m/^\d+$/ ) {
        $number = 10;
    }
    my @lines;

    if ( open( my $cfg_fh, '&lt;', $cfgfile ) ) {
        my $size = ( stat($cfg_fh) )[7];
        if ( $size &gt; ( $MAX_LINE_SIZE * $number ) ) {

            seek( $cfg_fh, $size - ( $MAX_LINE_SIZE * $number ), 0 );
        }
        my $linecounter = 0;
        while ( my $line = readline($cfg_fh) ) {
            chomp $line;
            if ( $linecounter &gt;= $number ) {
                shift @lines;
            }
            push @lines, $line;
            $linecounter++;
        }
        close $cfg_fh;
    }
    else {
        Cpanel::Debug::log_warn(&quot;Unable to open $cfgfile: $!&quot;);
    }
    return wantarray ? @lines : \@lines;
}

sub has_txt_in_file {
    my ( $file, $txt ) = @_;

    my $regex;
    eval { $regex = qr($txt); };
    if ($@) {
        Cpanel::Debug::log_warn('Invalid regex');
        return;
    }

    my $fh;
    if ( open $fh, '&lt;', $file ) {
        while ( my $line = readline $fh ) {
            if ( $line =~ $regex ) {
                close $fh;
                return 1;
            }
        }

        close $fh;
    }

    return;
}

sub appendline {
    my ( $filename, $line ) = @_;
    my $fh;

    if ( open my $fh, '&gt;&gt;:stdio', $filename ) {

        IO::SigGuard::syswrite( $fh, $line . &quot;\n&quot; ) or do {
            warn &quot;write($filename): $!&quot;;
        };

        close $fh;
        return 1;
    }
    else {
        warn &quot;open($filename): $!&quot; if $! != _ENOENT();
    }

    return;
}

1;

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


{ # --- BEGIN Cpanel/SafeRun/Simple.pm
package Cpanel::SafeRun::Simple;


use strict;

# use Cpanel::FHUtils::Autoflush ();
# use Cpanel::LoadFile::ReadFast ();
# use Cpanel::SV                 ();

BEGIN {
    eval { require Proc::FastSpawn; };
}

my $KEEP_STDERR  = 0;
my $MERGE_STDERR = 1;
my $NULL_STDERR  = 2;
my $NULL_STDOUT  = 3;

sub saferun_r {
    return _saferun_r( \@_ );
}

sub _saferun_r {    ## no critic qw(Subroutines::ProhibitExcessComplexity)
    my ( $cmdline, $error_flag ) = @_;

    if ($Cpanel::AccessIds::ReducedPrivileges::PRIVS_REDUCED) {    # PPI NO PARSE --  can't be reduced if the module isn't loaded
        eval &quot;use Cpanel::Carp;&quot;;                                  ## no critic qw(BuiltinFunctions::ProhibitStringyEval)
        die Cpanel::Carp::safe_longmess( __PACKAGE__ . &quot; cannot be used with ReducedPrivileges. Use Cpanel::SafeRun::Object instead&quot; );
    }
    elsif ( scalar @$cmdline == 1 &amp;&amp; $cmdline-&gt;[0] =~ tr{&gt;&lt;*?[]`$()|;&amp;#$\\\r\n\t }{} ) {
        eval &quot;use Cpanel::Carp;&quot;;                                  ## no critic qw(BuiltinFunctions::ProhibitStringyEval)
        die Cpanel::Carp::safe_longmess( __PACKAGE__ . &quot; prevents accidental execution of a shell.  If you intended to execute a shell use saferun(&quot; . join( ',', '/bin/sh', '-c', @$cmdline ) . &quot;)&quot; );
    }

    my $output;

    if ( index( $cmdline-&gt;[0], '/' ) == 0 ) {
        my ($check) = !-e $cmdline-&gt;[0] &amp;&amp; $cmdline-&gt;[0] =~ /[\s&lt;&gt;&amp;\|\;]/ ? split( /[\s&lt;&gt;&amp;\|\;]/, $cmdline-&gt;[0], 2 ) : $cmdline-&gt;[0];

        if ( !-x $check ) {
            $? = -1;

            return \$output;
        }

    }
    $error_flag ||= 0;
    local ($/);
    my ( $pid, $prog_fh, $did_fastspawn );

    if ( $INC{'Proc/FastSpawn.pm'} ) {    # may not be available yet due to upcp.static or updatenow.static

        my @env = map { exists $ENV{$_} &amp;&amp; $_ ne 'IFS' &amp;&amp; $_ ne 'CDPATH' &amp;&amp; $_ ne 'ENV' &amp;&amp; $_ ne 'BASH_ENV' ? ( $_ . '=' . ( $ENV{$_} // '' ) ) : () } keys %ENV;

        my ($child_write);
        pipe( $prog_fh, $child_write ) or warn &quot;Failed to pipe(): $!&quot;;

        my $null_fh;
        if ( $error_flag == $NULL_STDERR || $error_flag == $NULL_STDOUT ) {
            open( $null_fh, '&gt;', '/dev/null' ) or die &quot;Failed open /dev/null: $!&quot;;
        }

        Cpanel::FHUtils::Autoflush::enable($_) for ( $prog_fh, $child_write );

        $did_fastspawn = 1;

        my $stdout_fileno = fileno($child_write);
        my $stderr_fileno = -1;

        if ( $error_flag == $MERGE_STDERR ) {
            $stderr_fileno = fileno($child_write);
        }
        elsif ( $error_flag == $NULL_STDERR ) {
            $stderr_fileno = fileno($null_fh);
        }
        elsif ( $error_flag == $NULL_STDOUT ) {
            $stdout_fileno = fileno($null_fh);
            $stderr_fileno = fileno($child_write);
        }

        $pid = Proc::FastSpawn::spawn_open3(
            -1,                # stdin
            $stdout_fileno,    # stdout
            $stderr_fileno,    # stderr
            $cmdline-&gt;[0],     # program
            $cmdline,          # args
            \@env,             #env
        );

    }
    else {
        if ( $pid = open( $prog_fh, '-|' ) ) {

        }
        elsif ( defined $pid ) {

            delete @ENV{qw(IFS CDPATH ENV BASH_ENV)};

            $ENV{'PATH'} ||= '';
            Cpanel::SV::untaint( $ENV{'PATH'} );

            if ( $error_flag == $MERGE_STDERR ) {
                open( STDERR, '&gt;&amp;STDOUT' ) or die &quot;Failed to redirect STDERR to STDOUT: $!&quot;;
            }
            elsif ( $error_flag == $NULL_STDERR ) {
                open( STDERR, '&gt;', '/dev/null' ) or die &quot;Failed to open /dev/null: $!&quot;;
            }
            elsif ( $error_flag == $NULL_STDOUT ) {
                open( STDERR, '&gt;&amp;STDOUT' ) or die &quot;Failed to redirect STDERR to STDOUT: $!&quot;;
                open( STDOUT, '&gt;', '/dev/null' ) or die &quot;Failed to redirect STDOUT to /dev/null: $!&quot;;
            }
            exec(@$cmdline) or exit( $! || 127 );
        }
        else {
            die &quot;fork() failed: $!&quot;;
        }
    }
    if ( !$prog_fh || !$pid ) {

        $? = -1;    ## no critic qw(Variables::RequireLocalizedPunctuationVars)

        return \$output;
    }
    Cpanel::LoadFile::ReadFast::read_all_fast( $prog_fh, $output );
    close($prog_fh);

    waitpid( $pid, 0 ) if $did_fastspawn;

    return \$output;
}

sub _call_saferun {
    my ( $args, $flag ) = @_;
    my $ref = _saferun_r( $args, $flag || 0 );

    return $$ref if $ref;
    return;
}

sub saferun {
    return _call_saferun( \@_, $KEEP_STDERR );
}

sub saferunallerrors {
    return _call_saferun( \@_, $MERGE_STDERR );
}

sub saferunnoerror {
    return _call_saferun( \@_, $NULL_STDERR );
}

sub saferunonlyerrors {
    return _call_saferun( \@_, $NULL_STDOUT );
}

1;

} # --- END Cpanel/SafeRun/Simple.pm


{ # --- BEGIN Cpanel/SafeRun/Errors.pm
package Cpanel::SafeRun::Errors;


use strict;

# use Cpanel::SafeRun::Simple ();


sub saferunallerrors {
    my $output_ref = Cpanel::SafeRun::Simple::_saferun_r( \@_, 1 );    #1 = errors to stdout
    return wantarray ? split( /\n/, $$output_ref ) : $$output_ref;
}

sub saferunnoerror {
    my $output_ref = Cpanel::SafeRun::Simple::_saferun_r( \@_, 2 );    # 2 = errors to devnull
    return wantarray ? split( /\n/, $$output_ref ) : $$output_ref;
}

sub saferunonlyerrors {
    my $output_ref = Cpanel::SafeRun::Simple::_saferun_r( \@_, 3 );
    return wantarray ? split( /\n/, $$output_ref ) : $$output_ref;
}

1;

} # --- END Cpanel/SafeRun/Errors.pm


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


use cPstrict;

# use Cpanel::OS    ();
# use Cpanel::Debug ();
use Cwd           ();

use constant _ENOENT =&gt; 2;

our $timezones_cachefile = '/var/cpanel/timezones.cache';
my $cache_ttl = 3_600 * 24 * 7 * 6;    #6 WEEKS

our $timezones_cache;

our $timezonedir   = '/usr/share/zoneinfo';
our $zonetabfile   = '/usr/share/zoneinfo/zone.tab';
our $etc_localtime = '/etc/localtime';

sub gettimezones() {
    if ( !$timezones_cache ) {
        my $timezones;

        if ( open my $fh, '&lt;', $timezones_cachefile ) {
            $timezones = -f $fh;
            $timezones &amp;&amp;= ( time - ( stat $fh )[9] ) &lt; $cache_ttl;

            $timezones &amp;&amp;= [&lt;$fh&gt;];
            chomp @$timezones if $timezones;
        }
        elsif ( $! != _ENOENT ) {
            warn &quot;open($timezones_cachefile): $!&quot;;
        }

        if ( !$timezones || !scalar @{$timezones} || !grep { $_ eq &quot;UTC&quot; } @$timezones ) {
            $timezones = [];
            get_timezones_from_zonetab($timezones);

            if ( !scalar @{$timezones} ) {
                require Cpanel::FileUtils::Lines;
                require File::Find;
                File::Find::find(
                    sub {
                        if ( Cpanel::FileUtils::Lines::has_txt_in_file( $File::Find::name, '\ATZif' ) ) {
                            ( my $stripped_name = $File::Find::name ) =~ s{\A$timezonedir/}{};
                            push @{$timezones}, $stripped_name;
                        }
                    },
                    $timezonedir
                );
            }
            push @$timezones, &quot;UTC&quot; unless grep { $_ eq &quot;UTC&quot; } @$timezones;

            if ( _running_as_root() ) {
                require Cpanel::FileUtils::Write;
                Cpanel::FileUtils::Write::overwrite_no_exceptions( $timezones_cachefile, join( &quot;\n&quot;, @{$timezones} ), 0644 );
            }
        }

        $timezones_cache = $timezones;
    }

    return wantarray ? @$timezones_cache : $timezones_cache;
}

sub _running_as_root {
    return $&gt; == 0 ? 1 : 0;
}

sub is_valid ($tz) {
    my $is_valid;

    require Cpanel::FileUtils::Lines;
    if ($timezones_cache) {
        $is_valid = grep { $_ eq $tz } @$timezones_cache;
    }
    elsif ( -f $timezones_cachefile &amp;&amp; ( time() - ( stat $timezones_cachefile )[9] &lt;= $cache_ttl ) ) {

        $is_valid = Cpanel::FileUtils::Lines::has_txt_in_file( $timezones_cachefile, qr(\A\Q$tz\E\Z) );
    }
    else {
        $is_valid = grep { $_ eq $tz } ( gettimezones() );
    }

    return $is_valid;
}

sub set ($tz) {

    return unless is_valid($tz);

    my $method = Cpanel::OS::setup_tz_method();

    if ( $method eq 'timedatectl' ) {
        _setup_clock_using_timedatectl($tz);
    }
    elsif ( $method eq 'sysconfig' ) {
        _setup_clock_using_sysconfig($tz);
    }
    else {
        Cpanel::Debug::log_die(&quot;Invalid setup_tz_method method: $method&quot;);
    }

    return;
}

sub _setup_clock_using_timedatectl ($tz) {

    require Cpanel::SafeRun::Errors;
    Cpanel::SafeRun::Errors::saferunallerrors( '/usr/bin/timedatectl', 'set-timezone', $tz );

    return;
}

sub _setup_clock_using_sysconfig ($tz) {

    my @CLOCK;

    if ( open( my $fh, '&lt;', '/etc/sysconfig/clock' ) ) {
        @CLOCK = (&lt;$fh&gt;);
        close($fh);
    }
    else {
        Cpanel::Debug::log_warn(qq[Could not open file &quot;/etc/sysconfig/clock&quot; for reading ($!)]);
    }

    if ( open( my $fh, '&gt;', '/etc/sysconfig/clock' ) ) {
        my $ok;
        foreach my $line (@CLOCK) {
            if ( $line =~ m{\AZONE=}i ) {
                $ok = 1;
                print {$fh} qq[ZONE=&quot;$tz&quot;\n];
            }
            else {
                print {$fh} $line;
            }
        }
        print {$fh} qq[ZONE=&quot;$tz&quot;\n] unless $ok;
        close($fh);

        unlink $etc_localtime;
        symlink &quot;/usr/share/zoneinfo/$tz&quot;, $etc_localtime;

    }
    else {
        Cpanel::Debug::log_warn(qq[Could not open file &quot;/etc/sysconfig/clock&quot; for writing ($!)]);
    }

    return;
}

sub get_timezones_from_zonetab ($timezones_ar) {

    my $fh;
    if ( !open $fh, '&lt;', $zonetabfile ) {
        Cpanel::Debug::log_warn(&quot;Could not open file \&quot;$zonetabfile\&quot; for reading ($!), will attempt to determine the time zone list by other (probably less precise) method(s)&quot;);
        return;
    }

    while (&lt;$fh&gt;) {
        next unless m{ ^ [A-Z]+ \s+ [-+][-+\d]+ \s+ (\S+) }ax;
        push @{$timezones_ar}, $1;
    }

    close $fh;

    return 1;
}

sub _hash_file ($file) {

    require Digest::SHA;
    return Digest::SHA-&gt;new(512)-&gt;addfile($file)-&gt;hexdigest;
}

sub get_current_timezone (%opts) {

    my $tz = 'UTC';    # default value when none found

    if ( -l $etc_localtime ) {    # check file being symlinked, if symlinked
        $tz = Cwd::abs_path($etc_localtime);
        $tz =~ s{^.*/usr/share/zoneinfo/}{};
    }
    else {
        my $localhash = _hash_file($etc_localtime);
        my @TZS       = gettimezones();
        foreach my $tzfile (@TZS) {
            my $check = $timezonedir . '/' . $tzfile;
            next unless -f $check;
            my $digest = _hash_file($check);
            if ( $localhash eq $digest ) {
                $tz = $tzfile;
                last;
            }
        }

    }

    $tz =~ s{^posix/}{} if $opts{noposix};
    return $tz;
}

sub calculate_TZ_env() {
    return get_current_timezone( noposix =&gt; 1 );
}

sub set_zonetabfile ($file) {
    $zonetabfile = $file;
    return;
}

sub clear_caches() {
    undef $timezones_cache;
    unlink $timezones_cachefile;

    return;
}

1;

} # --- END Cpanel/Timezones.pm


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


use strict;
# use Cpanel::LoadModule ();
# use Cpanel::Locale     ();

our $ENCODE_MODULE          = 'Encode';
our $DATETIME_MODULE        = 'DateTime';
our $DATETIME_LOCALE_MODULE = 'DateTime::Locale';
my %known_ids = ();

sub datetime {
    my ( $lh, $epoch, $format, $timezone ) = @_;

    if ( $epoch &amp;&amp; ref $epoch eq 'ARRAY' ) {
        $epoch = $epoch-&gt;[0];
    }
    elsif ( !$epoch ) {
        $epoch = time;
    }
    $format ||= 'date_format_long';

    my $encoding = $lh-&gt;encoding();

    if ( _can_use_cpanel_date_format( $encoding, $timezone ) ) {
        Cpanel::LoadModule::load_perl_module('Cpanel::Date::Format');
        return Cpanel::Date::Format::translate_for_locale( $epoch, $format, $lh-&gt;language_tag() );
    }

    my $locale = _get_best_locale_for_datetime_obj( $lh-&gt;language_tag() );
    return _get_formatted_datetime( $locale, $encoding, $format, $epoch, $timezone );
}

sub _can_use_cpanel_date_format {
    my ( $encoding, $timezone ) = @_;

    return ( $encoding eq 'utf-8' ) &amp;&amp; ( !$timezone || $timezone eq 'UTC' );
}

sub get_lookup_hash_of_multi_epoch_datetime {
    my ( $lh, $epochs_ar, $format, $timezone ) = @_;

    $format ||= 'date_format_long';
    my %lookups;

    my $encoding = $lh-&gt;encoding();

    my $can_use_cpanel_date_format = _can_use_cpanel_date_format( $encoding, $timezone );
    my $locale;

    if ($can_use_cpanel_date_format) {
        Cpanel::LoadModule::load_perl_module('Cpanel::Date::Format');
        $locale = $lh-&gt;language_tag();
    }
    else {
        $locale = _get_best_locale_for_datetime_obj( $lh-&gt;language_tag() );
    }

    foreach my $epoch ( @{$epochs_ar} ) {
        $lookups{$epoch} ||= do {
            if ($can_use_cpanel_date_format) {
                Cpanel::Date::Format::translate_for_locale( $epoch, $format, $locale );
            }
            else {
                _get_formatted_datetime( $locale, $encoding, $format, $epoch, $timezone );
            }
        };
    }
    return \%lookups;
}

sub _get_formatted_datetime {
    my ( $locale, $encoding, $format, $epoch, $timezone ) = @_;

    if ( !$timezone ) {
        $timezone = 'UTC';
    }
    elsif ( $timezone !~ m{^[\.0-9A-Za-z\/_\+\-]+$} ) {
        die &quot;Invalid timezone “$timezone”&quot;;
    }

    my $datetime_obj = $DATETIME_MODULE-&gt;from_epoch( 'epoch' =&gt; $epoch, 'locale' =&gt; $locale, 'time_zone' =&gt; $timezone );

    if ( $format &amp;&amp; $format !~ m{_format$} &amp;&amp; $datetime_obj-&gt;{'locale'}-&gt;can($format) ) {
        return $ENCODE_MODULE-&gt;can('encode')-&gt;( $encoding, $datetime_obj-&gt;format_cldr( $datetime_obj-&gt;{'locale'}-&gt;$format ) );
    }

    die 'Invalid datetime format: ' . $format;
}

sub _get_best_locale_for_datetime_obj {
    my ($language_tag) = @_;
    my ( $fallback, $locale ) = _get_fallback_locale($language_tag);

    Cpanel::LoadModule::load_perl_module($ENCODE_MODULE) if !$INC{'Encode.pm'};
    Cpanel::LoadModule::load_perl_module($DATETIME_MODULE);

    foreach my $try_locale ( $locale, $fallback, 'en_US', 'en' ) {
        next               if !$try_locale;
        return $try_locale if $known_ids{$try_locale} || $Cpanel::Locale::known_locales_character_orientation{$try_locale};
        if ( eval { $DATETIME_MODULE-&gt;load($try_locale) } ) {
            $known_ids{$try_locale} = 1;
            return $try_locale;
        }
    }

    die &quot;Could not locale any working DateTime locale&quot;;
}

sub _get_fallback_locale {
    my ($locale) = @_;
    my $fallback;
    if ( substr( $locale, 0, 2 ) eq 'i_' ) {
        require Cpanel::Locale::Utils::Paths;
        my $dir = Cpanel::Locale::Utils::Paths::get_i_locales_config_path();
        if ( -e &quot;$dir/$locale.yaml&quot; ) {
            require Cpanel::DataStore;
            my $hr = Cpanel::DataStore::fetch_ref(&quot;$dir/$locale.yaml&quot;);
            if ( exists $hr-&gt;{'fallback_locale'} &amp;&amp; $hr-&gt;{'fallback_locale'} ) {
                $fallback = $hr-&gt;{'fallback_locale'};
            }
        }
    }
    else {
        my ( $pre, $pst ) = split( /[\_\-]/, $locale, 2 );
        if ($pst) {
            $fallback = $pre;
            $locale   = $pre . '_' . uc($pst);
        }
    }
    $fallback ||= 'en';

    return ( $fallback, $locale );
}

1;

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


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


use strict;
use warnings;

# use Cpanel::Debug      ();
# use Cpanel::LoadModule ();


sub unix2iso {
    Cpanel::LoadModule::load_perl_module('Cpanel::Time') unless $INC{'Cpanel/Time.pm'};
    return sprintf( '%04d-%02d-%02dT%02d:%02d:%02dZ', reverse( ( Cpanel::Time::gmtime( $_[0] || time() ) )[ 0 .. 5 ] ) );
}


sub iso2unix {
    my ($iso_time) = @_;

    if ( rindex( $iso_time, 'Z' ) != length($iso_time) - 1 ) {
        die &quot;Only UTC times, not “$iso_time”!&quot;;
    }

    my @smhdmy = reverse split m&lt;[^0-9.]&gt;, $iso_time;
    Cpanel::LoadModule::load_perl_module('Cpanel::Time') unless $INC{'Cpanel/Time.pm'};

    return Cpanel::Time::timegm(@smhdmy);
}


sub unix2iso_date {
    Cpanel::LoadModule::load_perl_module('Cpanel::Time') unless $INC{'Cpanel/Time.pm'};
    Cpanel::Debug::log_deprecated('This function will be removed, please use locale datetime');

    return sprintf( '%04d-%02d-%02d', reverse( ( Cpanel::Time::gmtime( $_[0] || time() ) )[ 3 .. 5 ] ) );
}


sub unix2iso_time {
    Cpanel::LoadModule::load_perl_module('Cpanel::Time') unless $INC{'Cpanel/Time.pm'};
    Cpanel::Debug::log_deprecated('This function will be removed, please use locale datetime');
    return sprintf( '%02d:%02d:%02d', reverse( ( Cpanel::Time::gmtime( $_[0] || time() ) )[ 0 .. 2 ] ) );
}

1;

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


{ # --- BEGIN Cpanel/Config/LoadUserDomains/Count.pm
package Cpanel::Config::LoadUserDomains::Count;


use strict;
use warnings;

# use Cpanel::Autodie            qw(exists);
INIT { Cpanel::Autodie-&gt;import(qw{exists}); }
# use Cpanel::LoadFile::ReadFast ();
# use Cpanel::ConfigFiles        ();


sub counttrueuserdomains {
    if ( !Cpanel::Autodie::exists( _trueuserdomains() ) ) {
        return 0;
    }
    return _count_file_lines( _trueuserdomains() );
}


sub countuserdomains {
    if ( !Cpanel::Autodie::exists( _userdomains() ) ) {
        return 0;
    }
    return _count_file_lines( _userdomains() ) - 1;    # -1 for *: nobody
}

sub _count_file_lines {
    my ($file) = @_;
    open( my $ud_fh, '&lt;', $file ) or die &quot;open($file): $!&quot;;

    my $buffer = '';
    Cpanel::LoadFile::ReadFast::read_all_fast( $ud_fh, $buffer );
    my $num_ud = ( $buffer =~ tr/\n// );
    close($ud_fh) or warn &quot;close($file): $!&quot;;

    $num_ud++ if length($buffer) &amp;&amp; substr( $buffer, -1 ) ne &quot;\n&quot;;

    return $num_ud;
}

sub _userdomains {
    return $Cpanel::ConfigFiles::USERDOMAINS_FILE;
}

sub _domainusers {
    return $Cpanel::ConfigFiles::DOMAINUSERS_FILE;
}

sub _trueuserdomains {
    return $Cpanel::ConfigFiles::TRUEUSERDOMAINS_FILE;
}

1;

} # --- END Cpanel/Config/LoadUserDomains/Count.pm


{ # --- BEGIN Cpanel/Server/Type.pm
package Cpanel::Server::Type;


use cPstrict;

use constant NUMBER_OF_USERS_TO_ASSUME_IF_UNREADABLE =&gt; 1;


sub _get_license_file_path { return q{/usr/local/cpanel/cpanel.lisc} }
sub _get_dnsonly_file_path { return q{/var/cpanel/dnsonly} }

use constant _ENOENT =&gt; 2;

my @server_config;
our %PRODUCTS;
our $MAXUSERS;
our %FIELDS;
our ( $DNSONLY_MODE, $NODE_MODE );


sub is_dnsonly {
    return $DNSONLY_MODE if defined $DNSONLY_MODE;

    return 1 if -e _get_dnsonly_file_path();
    return 0 if $! == _ENOENT();
    my $err = $!;


    if ( _read_license() ) {
        return $PRODUCTS{'dnsonly'} ? 1 : 0;
    }

    die sprintf( 'stat(%s): %s', _get_dnsonly_file_path(), &quot;$err&quot; );
}


sub get_producttype {
    return $NODE_MODE if defined $NODE_MODE;
    return 'DNSONLY' unless _read_license();

    return 'STANDARD' if $PRODUCTS{'cpanel'};

    foreach my $product (qw/dnsnode mailnode databasenode dnsonly/) {
        return uc($product) if $PRODUCTS{$product};
    }

    return 'DNSONLY';
}


sub get_max_users {
    return $MAXUSERS if defined $MAXUSERS;
    return NUMBER_OF_USERS_TO_ASSUME_IF_UNREADABLE unless _read_license();
    return $MAXUSERS // NUMBER_OF_USERS_TO_ASSUME_IF_UNREADABLE;
}


sub has_els {
    return $FIELDS{els} if defined $FIELDS{els};
    return 0 unless _read_license();
    return $FIELDS{els} // 0;
}


sub get_license_expire_gmt_date {
    return $FIELDS{'license_expire_gmt_date'} if defined $FIELDS{'license_expire_gmt_date'};
    return 0 unless _read_license();
    return $FIELDS{'license_expire_gmt_date'} // 0;
}


sub is_licensed_for_product ($product) {
    return unless $product;
    $product = lc $product;
    return unless _read_license();
    return exists $PRODUCTS{$product};
}


sub get_features {
    return unless _read_license();

    my @features = split( &quot;,&quot;, $FIELDS{'features'} // '' );
    return @features;
}


sub has_feature ( $feature = undef ) {
    length $feature or return;

    return ( grep { $_ eq $feature } get_features() ) ? 1 : 0;
}


sub get_products {
    return unless _read_license();
    return keys %PRODUCTS;
}

sub _read_license {
    my $LICENSE_FILE = _get_license_file_path();

    my @new_stat = stat($LICENSE_FILE) if @server_config;

    if ( @server_config &amp;&amp; @new_stat &amp;&amp; $new_stat[9] == $server_config[9] &amp;&amp; $new_stat[7] == $server_config[7] ) {
        return 1;
    }

    open( my $fh, '&lt;', $LICENSE_FILE ) or do {

        if ( $! != _ENOENT() ) {
            warn &quot;open($LICENSE_FILE): $!&quot;;
        }

        return;
    };

    _reset_cache();

    my $content;

    read( $fh, $content, 1024 ) // do {
        warn &quot;read($LICENSE_FILE): $!&quot;;
        $content = q&lt;&gt;;
    };

    return _parse_license_contents_sr( $fh, \$content );
}

sub _parse_license_contents_to_hashref ($content_sr) {

    my %vals = map { ( split( m{: }, $_ ) )[ 0, 1 ] } split( m{\n}, $$content_sr );

    return \%vals;
}

sub _parse_license_contents_sr ( $fh, $content_sr ) {
    my $vals_hr = _parse_license_contents_to_hashref($content_sr);

    if ( length $vals_hr-&gt;{'products'} ) {
        %PRODUCTS = map { ( $_ =&gt; 1 ) } split( &quot;,&quot;, $vals_hr-&gt;{'products'} );
    }
    else {
        return;
    }

    if ( length $vals_hr-&gt;{'maxusers'} ) {

        $MAXUSERS //= int $vals_hr-&gt;{'maxusers'};
    }
    else {
        return;
    }

    foreach my $field (qw/license_expire_time license_expire_gmt_date support_expire_time updates_expire_time/) {
        $FIELDS{$field} = $vals_hr-&gt;{$field} // 0;
    }
    foreach my $field (qw/client features/) {
        $FIELDS{$field} = $vals_hr-&gt;{$field} // '';
    }

    if ( length $vals_hr-&gt;{'fields'} ) {
        foreach my $field ( split( &quot;,&quot;, $vals_hr-&gt;{'fields'} ) ) {
            my ( $k, $v ) = split( '=', $field, 2 );
            $FIELDS{$k} = $v;

        }
    }
    else {
        return;
    }

    @server_config = stat($fh);
    return 1;
}

sub _reset_cache {
    undef %PRODUCTS;
    undef %FIELDS;
    undef @server_config;
    undef $MAXUSERS;
    undef $DNSONLY_MODE;

    return;
}

1;


} # --- END Cpanel/Server/Type.pm


{ # --- BEGIN Cpanel/Config/LoadUserDomains.pm
package Cpanel::Config::LoadUserDomains;


use strict;
use warnings;

# use Cpanel::Config::LoadConfig             ();
# use Cpanel::Config::LoadUserDomains::Count ();
# use Cpanel::Server::Type                   ();


sub loaduserdomains {
    my ( $conf_ref, $reverse, $usearr ) = @_;
    $conf_ref = Cpanel::Config::LoadConfig::loadConfig(
        Cpanel::Config::LoadUserDomains::Count::_userdomains(),
        $conf_ref,
        ': ',     # We write the file so there is no need to match stray spaces
        '0E0',    # Avoid looking for comments since there will not be any
        0,        # reverse
        1,        # allow_undef_values since there will not be any
        {
            'use_reverse'          =&gt; $reverse ? 0 : 1,
            'skip_keys'            =&gt; ['nobody'],
            'use_hash_of_arr_refs' =&gt; ( $usearr || 0 ),
        }
    );
    if ( !defined($conf_ref) ) {
        $conf_ref = {};
    }
    return wantarray ? %{$conf_ref} : $conf_ref;
}


sub loadtrueuserdomains {
    my ( $conf_ref, $reverse, $ignore_limit ) = @_;
    $conf_ref = Cpanel::Config::LoadConfig::loadConfig(
        ( $reverse ? Cpanel::Config::LoadUserDomains::Count::_domainusers() : Cpanel::Config::LoadUserDomains::Count::_trueuserdomains() ),
        $conf_ref,
        ': ',     # We write the file so there is no need to match stray spaces
        '0E0',    # Avoid looking for comments since there will not be any
        0,        # reverse
        1,        # allow_undef_values since there will not be any
        { 'limit' =&gt; ( $ignore_limit ? 0 : Cpanel::Server::Type::get_max_users() ) }
    );
    if ( !defined($conf_ref) ) {
        $conf_ref = {};
    }
    return wantarray ? %{$conf_ref} : $conf_ref;
}

*counttrueuserdomains = *counttrueuserdomains = *Cpanel::Config::LoadUserDomains::Count::counttrueuserdomains;

1;

} # --- END Cpanel/Config/LoadUserDomains.pm


{ # --- BEGIN Cpanel/Config/CpUser.pm
package Cpanel::Config::CpUser;


use strict;

# use Cpanel::Debug                        ();
# use Cpanel::LoadModule                   ();
# use Cpanel::Config::LoadUserDomains      ();
# use Cpanel::Config::LoadCpUserFile       ();
# use Cpanel::ConfigFiles                  ();
# use Cpanel::FileUtils::Write::JSON::Lazy ();

our $cpuser_dir;
*cpuser_dir = \$Cpanel::ConfigFiles::cpanel_users;
our $cpuser_cache_dir = &quot;$cpuser_dir.cache&quot;;

our $header = &lt;&lt;END;
END

my %memory_file_list_key = qw(
  DOMAINS         DNS
  DEADDOMAINS     XDNS
  HOMEDIRLINKS    HOMEDIRPATHS
);

sub clean_cpuser_hash {
    my ( $cpuser_ref, $user ) = @_;

    {
        my @missing = grep { !exists $cpuser_ref-&gt;{$_} } required_cpuser_keys();
        if (@missing) {
            $user = q{} if !defined $user;
            Cpanel::Debug::log_warn( &quot;The following keys are missing from supplied '$user' cPanel user data: &quot; . join( ', ', @missing ) . &quot;, to prevent data loss, the data was not saved.&quot; );
            return;
        }
    }

    if ( grep { $_ &amp;&amp; index( $_, &quot;\n&quot; ) != -1 } %$cpuser_ref ) {

        Cpanel::Debug::log_warn(&quot;The cpuser data contains newlines.  This is not allowed as it would corrupt the file.&quot;);
        return;
    }

    my $domain = $cpuser_ref-&gt;{'DOMAIN'};
    if ( !$domain ) {    # Try to lookup main domain in /etc/trueuserdomains
        my $trueuserdomains_ref = Cpanel::Config::LoadUserDomains::loadtrueuserdomains( undef, 1 );
        $domain = $trueuserdomains_ref-&gt;{$user} || '';
        if ( !$domain ) {
            Cpanel::Debug::log_info(&quot;Unable to determine user ${user}'s main domain&quot;);
        }
    }

    my %clean_data = (
        %$cpuser_ref,
        DNS =&gt; $domain,
    );

    delete @clean_data{
        q{},
        'DOMAIN',
        'DBOWNER',
        '__CACHE_DATA_VERSION',
        ( keys %memory_file_list_key ),
    };

    if ( defined $clean_data{'DISK_BLOCK_LIMIT'} &amp;&amp; $clean_data{'DISK_BLOCK_LIMIT'} eq 'unlimited' ) {
        $clean_data{'DISK_BLOCK_LIMIT'} = 0;
    }

    while ( my ( $memkey, $filekey ) = each %memory_file_list_key ) {
        if ( exists $cpuser_ref-&gt;{$memkey} &amp;&amp; scalar @{ $cpuser_ref-&gt;{$memkey} } ) {
            my $doms_ar = $cpuser_ref-&gt;{$memkey};
            my $count   = 0;
            @clean_data{ ( map { $filekey . ++$count } @$doms_ar ) } = @$doms_ar;
        }
    }

    my $homedirs_key_in_file = $memory_file_list_key{'HOMEDIRLINKS'};
    if ( exists $clean_data{ $homedirs_key_in_file . 1 } ) {
        $clean_data{$homedirs_key_in_file} = delete $clean_data{ $homedirs_key_in_file . 1 };
    }

    return wantarray ? %clean_data : \%clean_data;
}

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

    my $cpgid = 0;

    if ( exists $INC{'Cpanel/PwCache.pm'} || Cpanel::LoadModule::load_perl_module('Cpanel::PwCache') ) {
        $cpgid = ( Cpanel::PwCache::getpwnam_noshadow($user) )[3];
    }

    return $cpgid;
}

sub recache {
    my ( $cpuser_ref, $user, $cpgid ) = @_;

    my $user_cache_file = $cpuser_cache_dir . '/' . $user;

    Cpanel::Config::LoadCpUserFile::create_users_cache_dir();
    $cpuser_ref-&gt;{'__CACHE_DATA_VERSION'} = $Cpanel::Config::LoadCpUserFile::VERSION;    # set this before the cache is written so that it will be included in the cache

    if ( Cpanel::FileUtils::Write::JSON::Lazy::write_file( $user_cache_file, $cpuser_ref, 0640 ) ) {
        chown 0, $cpgid, $user_cache_file if $cpgid;                                     # this is ok if the chown happens after as we fall though to reading the non-cache on a failed open
    }
    else {
        unlink $user_cache_file;                                                         #outdated
    }
}

sub required_cpuser_keys {
    my @keys = qw( FEATURELIST HASCGI MAXSUB MAXADDON DEMO RS USER MAXFTP MAXLST MAXPARK STARTDATE BWLIMIT IP MAXSQL DOMAIN MAXPOP PLAN OWNER );

    return wantarray ? @keys : \@keys;
}

1;

} # --- END Cpanel/Config/CpUser.pm


{ # --- BEGIN Cpanel/Config/CpUser/Write.pm
package Cpanel::Config::CpUser::Write;


use cPstrict;


# use Cpanel::Config::CpUser      ();
# use Cpanel::Config::FlushConfig ();


sub serialize ($cpuser_data) {
    die 'Pass data through clean_cpuser_hash() first!' if grep { ref } values %$cpuser_data;

    return ${
        Cpanel::Config::FlushConfig::serialize(
            $cpuser_data,
            do_sort   =&gt; 1,
            delimiter =&gt; '=',
            'header'  =&gt; $Cpanel::Config::CpUser::header,
        )
    };
}

1;

} # --- END Cpanel/Config/CpUser/Write.pm


{ # --- BEGIN Cpanel/LinkedNode/Worker/Storage.pm
package Cpanel::LinkedNode::Worker::Storage;


use strict;
use warnings;


sub read {
    my ( $cpuser_hr, $worker_type ) = @_;

    my $str = $cpuser_hr-&gt;{ _get_key($worker_type) };

    return _parse($str);
}


sub set {
    my ( $cpuser_hr, $worker_type, $alias, $token ) = @_;

    $cpuser_hr-&gt;{ _get_key($worker_type) } = &quot;$alias:$token&quot;;

    return;
}


sub unset {
    my ( $cpuser_hr, $worker_type ) = @_;

    return _parse( delete $cpuser_hr-&gt;{ _get_key($worker_type) } );
}


sub _get_key {
    my ($worker_type) = @_;

    substr( $worker_type, 0, 1 ) =~ tr&lt;A-Z&gt;&lt;&gt; or do {
        die &quot;Worker type names always begin with a capital! (given: “$worker_type”)&quot;;
    };

    return &quot;WORKER_NODE-$worker_type&quot;;
}

sub _parse {
    my ($str) = @_;

    return $str ? [ split m&lt;:&gt;, $str, 2 ] : undef;
}

1;

} # --- END Cpanel/LinkedNode/Worker/Storage.pm


{ # --- BEGIN Cpanel/SafeFile/Replace.pm
package Cpanel::SafeFile::Replace;


use strict;
use warnings;

# use Cpanel::Fcntl::Constants ();
# use Cpanel::FileUtils::Open  ();
use File::Basename           ();

use constant {
    WRONLY_CREAT_EXCL =&gt; $Cpanel::Fcntl::Constants::O_WRONLY | $Cpanel::Fcntl::Constants::O_CREAT | $Cpanel::Fcntl::Constants::O_EXCL,
    _EEXIST           =&gt; 17
};

sub safe_replace_content {
    my ( $fh, $safelock, @content ) = @_;

    return locked_atomic_replace_contents(
        $fh,
        $safelock,
        sub {
            local $!;

            @content = @{ $content[0] } if scalar @content == 1 &amp;&amp; ref $content[0] eq 'ARRAY';

            print { $_[0] } @content;

            if ($!) {
                my $length = 0;
                $length += length for @content;

                my $err = $!;
                require Cpanel::Exception;
                die Cpanel::Exception::create( 'IO::WriteError', [ length =&gt; $length, error =&gt; $err ] );
            }

            return 1;
        }
    );
}

my $_lock_ex_nb;

sub locked_atomic_replace_contents {
    my ( $fh, $safelock, $coderef ) = @_;

    $_lock_ex_nb //= $Cpanel::Fcntl::Constants::LOCK_EX | $Cpanel::Fcntl::Constants::LOCK_NB;
    if ( !flock $fh, $_lock_ex_nb ) {
        my $err = $!;
        require Cpanel::Exception;
        die Cpanel::Exception::create_raw( 'IOError', &quot;locked_atomic_replace_contents could not lock the file handle because of an error: $err&quot; );
    }

    if ( !ref $safelock ) {
        local $@;
        if ( !eval { $safelock-&gt;isa('Cpanel::SafeFileLock') } ) {
            die &quot;locked_atomic_replace_contents requires a Cpanel::SafeFileLock object&quot;;
        }
    }

    my $locked_path = $safelock-&gt;get_path_to_file_being_locked();
    die &quot;locked_path must be valid&quot; if !length $locked_path;
    my ( $temp_file, $temp_fh, $created_temp_file, $attempts );
    my $current_perms = ( stat($fh) )[2] &amp; 07777;

    while ( !$created_temp_file &amp;&amp; ++$attempts &lt; 100 ) {
        $temp_file = sprintf(
            '%s-%x-%x-%x',
            $locked_path,
            substr( rand, 2 ),
            scalar( reverse time ),
            scalar( reverse $$ ),
        );

        my ( $basename, $dirname );
        $basename = File::Basename::basename($temp_file);
        if ( length $basename &gt;= 255 ) {
            $basename  = substr( $basename, 255 );
            $dirname   = File::Basename::dirname($temp_file);
            $temp_file = &quot;$dirname/$basename&quot;;
        }

        $created_temp_file = Cpanel::FileUtils::Open::sysopen_with_real_perms( $temp_fh, $temp_file, WRONLY_CREAT_EXCL, $current_perms ) or do {
            last if $! != _EEXIST;
        };
    }
    if ( !$created_temp_file ) {
        my $lasterr = $!;
        die Cpanel::Exception::create( 'TempFileCreateError', [ path =&gt; $temp_file, error =&gt; $lasterr ] );
    }

    if ( !flock $temp_fh, $Cpanel::Fcntl::Constants::LOCK_EX ) {
        my $err = $!;
        require Cpanel::Exception;
        die Cpanel::Exception::create( 'IO::FlockError', [ path =&gt; $temp_file, error =&gt; $err, operation =&gt; $Cpanel::Fcntl::Constants::LOCK_EX ] );
    }

    select( ( select($temp_fh), $| = 1 )[0] );    ##no critic qw(ProhibitOneArgSelect Variables::RequireLocalizedPunctuationVars)  #aka $fd-&gt;autoflush(1);
    if ( $coderef-&gt;( $temp_fh, $temp_file, $current_perms ) ) {
        rename( $temp_file, $locked_path );
        return $temp_fh;
    }
    local $!;
    close $temp_fh;
    unlink $temp_file;
    die &quot;locked_atomic_replace_contents coderef returns false&quot;;
}

1;

} # --- END Cpanel/SafeFile/Replace.pm


{ # --- BEGIN Cpanel/Config/CpUserGuard.pm
package Cpanel::Config::CpUserGuard;


use strict;
use warnings;


# use Cpanel::Destruct               ();
# use Cpanel::Config::CpUser         ();
# use Cpanel::Config::CpUser::Write  ();
# use Cpanel::Config::LoadCpUserFile ();
# use Cpanel::Debug                  ();


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

    my ( $data, $file, $lock, $is_locked ) = ( undef, undef, undef, 0 );

    my $cpuser = Cpanel::Config::LoadCpUserFile::_load_locked($user);
    if ( $cpuser &amp;&amp; ref $cpuser eq 'HASH' ) {
        $data      = $cpuser-&gt;{'data'};
        $file      = $cpuser-&gt;{'file'};
        $lock      = $cpuser-&gt;{'lock'};
        $is_locked = defined $lock;
    }
    else {
        Cpanel::Debug::log_warn(&quot;Failed to load user file for '$user': $!&quot;);
        return;
    }

    my $path = &quot;$Cpanel::Config::CpUser::cpuser_dir/$user&quot;;

    return bless {
        user      =&gt; $user,
        data      =&gt; $data,
        path      =&gt; $path,
        _file     =&gt; $file,
        _lock     =&gt; $lock,
        _pid      =&gt; $$,
        is_locked =&gt; $is_locked,
    };
}


sub set_worker_node {
    my ( $self, $worker_type, $worker_alias, $token ) = @_;

    require Cpanel::LinkedNode::Worker::Storage;
    Cpanel::LinkedNode::Worker::Storage::set( $self-&gt;{'data'}, $worker_type, $worker_alias, $token );

    return $self;
}


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

    require Cpanel::LinkedNode::Worker::Storage;
    return Cpanel::LinkedNode::Worker::Storage::unset( $self-&gt;{'data'}, $worker_type );
}

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

    my $user = $self-&gt;{'user'};
    my $data = $self-&gt;{'data'};

    if ( $self-&gt;{'_pid'} != $$ ) {
        Cpanel::Debug::log_die('Locked in parent, cannot save');
        return;
    }

    if ( !UNIVERSAL::isa( $data, 'HASH' ) ) {
        Cpanel::Debug::log_die( __PACKAGE__ . ': hash reference required' );
        return;
    }

    my $clean_data = Cpanel::Config::CpUser::clean_cpuser_hash( $self-&gt;{'data'}, $user );
    if ( !$clean_data ) {
        Cpanel::Debug::log_warn(&quot;Data for user '$user' was not saved.&quot;);
        return;
    }

    if ( !$self-&gt;{'_file'} || !$self-&gt;{'_lock'} ) {
        Cpanel::Debug::log_warn(&quot;Unable to save user file for '$user': file not open and locked for writing&quot;);
        return;
    }

    require Cpanel::SafeFile::Replace;

    require Cpanel::Autodie;

    my $newfh = Cpanel::SafeFile::Replace::locked_atomic_replace_contents(
        $self-&gt;{'_file'}, $self-&gt;{'_lock'},

        sub {
            my ($fh) = @_;

            chmod( 0640, $fh ) or do {
                warn sprintf( &quot;Failed to set permissions on “%s” to 0%o: %s&quot;, $self-&gt;{'path'}, 0640, $! );
            };

            return Cpanel::Autodie::syswrite_sigguard(
                $fh,
                Cpanel::Config::CpUser::Write::serialize($clean_data),
            );
        }

      )
      or do {
        Cpanel::Debug::log_warn(&quot;Failed to save user file for “$user”: $!&quot;);
      };

    $self-&gt;{'_file'} = $newfh;

    my $cpgid = Cpanel::Config::CpUser::get_cpgid($user);

    if ($cpgid) {
        chown 0, $cpgid, $self-&gt;{'path'} or do {
            Cpanel::Debug::log_warn(&quot;Failed to chown( 0, $cpgid, $self-&gt;{'path'}): $!&quot;);
        };
    }

    if ( $INC{'Cpanel/Locale/Utils/User.pm'} ) {
        Cpanel::Locale::Utils::User::clear_user_cache($user);
    }

    Cpanel::Config::CpUser::recache( $data, $user, $cpgid );

    require Cpanel::SafeFile;
    Cpanel::SafeFile::safeclose( $self-&gt;{'_file'}, $self-&gt;{'_lock'} ) or do {
        Cpanel::Debug::log_warn(&quot;Failed to safeclose $self-&gt;{'path'}: $!&quot;);
    };

    $self-&gt;{'_file'}     = $self-&gt;{'_lock'} = undef;
    $self-&gt;{'is_locked'} = 0;

    return 1;
}

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

    my $user = $self-&gt;{'user'};
    my $data = $self-&gt;{'data'};

    if ( $self-&gt;{'_pid'} != $$ ) {
        Cpanel::Debug::log_die('Locked in parent, cannot save');
        return;
    }

    require Cpanel::SafeFile;
    Cpanel::SafeFile::safeclose( $self-&gt;{'_file'}, $self-&gt;{'_lock'} );
    $self-&gt;{'_file'}     = $self-&gt;{'_lock'} = undef;
    $self-&gt;{'is_locked'} = 0;

    return 1;
}

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

    return unless $self-&gt;{'is_locked'};
    return if Cpanel::Destruct::in_dangerous_global_destruction();
    return unless $self-&gt;{'_pid'} == $$;

    Cpanel::SafeFile::safeclose( $self-&gt;{'_file'}, $self-&gt;{'_lock'} );

    $self-&gt;{'is_locked'} = 0;
    return;
}

1;

} # --- END Cpanel/Config/CpUserGuard.pm


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


use strict;
use warnings;

# use Cpanel::PwCache ();

sub save_user_locale {
    my ( $locale, undef, $user ) = @_;
    $locale ||= 'en';
    $user   ||= $Cpanel::user || $ENV{'REMOTE_USER'} || ( $&gt; == 0 ? 'root' : ( Cpanel::PwCache::getpwuid_noshadow($&gt;) )[0] );

    if ( $user eq 'root' ) {
        require Cpanel::LoadModule;

        Cpanel::LoadModule::load_perl_module('Cpanel::DataStore');

        my $root_conf_yaml = Cpanel::PwCache::gethomedir('root') . '/.cpanel_config';
        my $hr             = Cpanel::DataStore::fetch_ref($root_conf_yaml);

        return 2 if exists $hr-&gt;{'locale'} &amp;&amp; $hr-&gt;{'locale'} eq $locale;

        $hr-&gt;{'locale'} = $locale;

        return 1 if Cpanel::DataStore::store_ref( $root_conf_yaml, $hr );
        return;
    }
    elsif ( $&gt; == 0 ) {
        require Cpanel::Config::CpUserGuard;
        my $cpuser_guard = Cpanel::Config::CpUserGuard-&gt;new($user) or return;
        $cpuser_guard-&gt;{'data'}-&gt;{'LOCALE'} = $locale;
        delete $cpuser_guard-&gt;{'data'}-&gt;{'LANG'};
        delete $cpuser_guard-&gt;{'data'}{'__LOCALE_MISSING'};
        return $cpuser_guard-&gt;save();
    }
    else {
        require Cpanel::LoadModule;

        Cpanel::LoadModule::load_perl_module('Cpanel::AdminBin');
        return Cpanel::AdminBin::run_adminbin_with_status( 'lang', 'SAVEUSERSETTINGS', $locale, 0, $user )-&gt;{'status'};
    }
    return 1;
}

1;

} # --- END Cpanel/Locale/Utils/User/Modify.pm


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


use strict;
use warnings;
# use Cpanel::Version::Full ();

our ( $VERSION, $MAJORVERSION, $LTS ) = ( '4.0', '11.110', '11.110' );

sub get_version_text {
    return sprintf( &quot;%d.%d (build %d)&quot;, ( split( m{\.}, Cpanel::Version::Full::getversion() ) )[ 1, 2, 3 ] );
}

sub get_version_parent {
    return _ver_key('parent_version');
}

sub get_version_display {
    return sprintf( &quot;%d.%d.%d&quot;, ( split( m{\.}, Cpanel::Version::Full::getversion() ) )[ 1, 2, 3 ] );
}

{
    no warnings 'once';    # for updatenow
    *get_version_full = *Cpanel::Version::Full::getversion;
}

sub getversionnumber {
    return sprintf( &quot;%d.%d.%d&quot;, ( split( m{\.}, Cpanel::Version::Full::getversion() ) )[ 0, 1, 2 ] );
}

sub get_lts {
    return $LTS;
}

sub get_short_release_number {
    my $current_ver = ( split( m{\.}, Cpanel::Version::Full::getversion() ) )[1];
    if ( $current_ver % 2 == 0 ) {
        return $current_ver;
    }
    return $current_ver + 1;
}

sub _ver_key {
    require Cpanel::Version::Tiny if !$INC{'Cpanel/Version/Tiny.pm'};
    return ${ $Cpanel::Version::Tiny::{ $_[0] } };
}

sub compare {
    require Cpanel::Version::Compare;
    goto &amp;Cpanel::Version::Compare::compare;
}

sub is_major_version {
    my ( $ver, $major ) = @_;

    require Cpanel::Version::Compare;

    return ( $ver eq $major || Cpanel::Version::Compare::get_major_release($ver) eq $major ) ? 1 : 0;
}

sub is_development_version {
    return substr( $MAJORVERSION, -1 ) % 2 ? 1 : 0;
}

sub display_version {
    my ($ver) = @_;
    if ( defined $ver &amp;&amp; $ver =~ tr{\.}{} &gt;= 2 ) {
        my @v = split( m{\.}, $ver );
        if ( $v[0] == 11 &amp;&amp; $v[1] &gt;= 54 ) {
            return join( '.', (@v)[ 1, 2, 3 ] );
        }
        return $ver;
    }
    return;
}

1;

} # --- END Cpanel/Version.pm


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


use strict;

BEGIN {

    $ENV{'IGNORE_WIN32_LOCALE'} = 1;
}

# use Cpanel::CPAN::Locale::Maketext::Utils();
our @ISA;
BEGIN { push @ISA, qw(Cpanel::CPAN::Locale::Maketext::Utils); }

# use Cpanel::Locale::Utils          ();    # Individual Locale modules depend on this being brought in here, if it is removed they will all need updated. Same for cpanel.pl
# use Cpanel::Locale::Utils::Paths   ();
# use Cpanel::CPAN::Locale::Maketext ();
# use Cpanel::Exception              ();

use constant _ENOENT =&gt; 2;

BEGIN {
    local $^H = 0;    # cheap no warnings without importing it
    local $^W = 0;

    *Cpanel::CPAN::Locale::Maketext::Utils::remove_key_from_lexicons = sub { };    # PPI NO PARSE - loaded above - disabled
}

our $SERVER_LOCALE_FILE = '/var/cpanel/server_locale';

our $LTR = 1;
our $RTL = 2;
our %known_locales_character_orientation = (
    ar               =&gt; $RTL,
    bn               =&gt; $LTR,
    bg               =&gt; $LTR,
    cs               =&gt; $LTR,
    da               =&gt; $LTR,
    de               =&gt; $LTR,
    el               =&gt; $LTR,
    en               =&gt; $LTR,
    en_US            =&gt; $LTR,
    en_GB            =&gt; $LTR,
    es_419           =&gt; $LTR,
    es               =&gt; $LTR,
    es_es            =&gt; $LTR,
    fi               =&gt; $LTR,
    fil              =&gt; $LTR,
    fr               =&gt; $LTR,
    he               =&gt; $RTL,
    hi               =&gt; $LTR,
    hu               =&gt; $LTR,
    i_cpanel_snowmen =&gt; $LTR,
    i_cp_qa          =&gt; $LTR,
    id               =&gt; $LTR,
    it               =&gt; $LTR,
    ja               =&gt; $LTR,
    ko               =&gt; $LTR,
    ms               =&gt; $LTR,
    nb               =&gt; $LTR,
    nl               =&gt; $LTR,
    no               =&gt; $LTR,
    pl               =&gt; $LTR,
    pt_br            =&gt; $LTR,
    pt               =&gt; $LTR,
    ro               =&gt; $LTR,
    ru               =&gt; $LTR,
    sl               =&gt; $LTR,
    sv               =&gt; $LTR,
    th               =&gt; $LTR,
    tr               =&gt; $LTR,
    uk               =&gt; $LTR,
    vi               =&gt; $LTR,
    zh               =&gt; $LTR,
    zh_tw            =&gt; $LTR,
    zh_cn            =&gt; $LTR,
);


my $logger;

sub _logger {
    require Cpanel::Logger;
    return ( $logger ||= Cpanel::Logger-&gt;new() );
}

*get_lookup_hash_of_mutli_epoch_datetime = *get_lookup_hash_of_multi_epoch_datetime;

sub preinit {
    if ( exists $INC{'Cpanel.pm'} &amp;&amp; !$Cpanel::CPDATA{'LOCALE'} ) {
        require Cpanel::Locale::Utils::User if !exists $INC{'Cpanel/Locale/Utils/User.pm'};
        Cpanel::Locale::Utils::User::init_cpdata_keys();
    }

    if ( $ENV{'HTTP_COOKIE'} ) {
        require Cpanel::Cookies unless $INC{'Cpanel/Cookies.pm'};

        if ( !keys %Cpanel::Cookies ) {
            %Cpanel::Cookies = %{ Cpanel::Cookies::get_cookie_hashref() };
        }
    }

    %Cpanel::Grapheme = %{ Cpanel::Locale-&gt;get_grapheme_helper_hashref() };
    return 1;
}


sub makevar {
    return $_[0]-&gt;maketext( ref $_[1] ? @{ $_[1] } : @_[ 1 .. $#_ ] );    ## no extract maketext
}

*maketext = *Cpanel::CPAN::Locale::Maketext::maketext;                    ## no extract maketext

my %singleton_stash = ();


BEGIN {
    no warnings;    ## no critic(ProhibitNoWarnings)
    CHECK {
        if ( ( $INC{'O.pm'} || $INC{'Cpanel/BinCheck.pm'} || $INC{'Cpanel/BinCheck/Lite.pm'} ) &amp;&amp; %singleton_stash ) {
            die(&quot;If you use a locale at begin time, you are responsible for deleting it too. Try calling _reset_singleton_stash\n&quot;);
        }
    }
}

sub _reset_singleton_stash {
    foreach my $class ( keys %singleton_stash ) {
        foreach my $args_sig ( keys %{ $singleton_stash{$class} } ) {
            $singleton_stash{$class}{$args_sig}-&gt;cpanel_detach_lexicon();
        }
    }
    %singleton_stash = ();
    return 1;
}

sub get_handle {
    preinit();
    no warnings 'redefine';
    *get_handle = *_real_get_handle;
    goto &amp;_real_get_handle;
}

sub _map_any_old_style_to_new_style {
    my (@locales) = @_;
    if ( grep { !$known_locales_character_orientation{$_} &amp;&amp; index( $_, 'i_' ) != 0 } @locales ) {
        require Cpanel::Locale::Utils::Legacy;
        goto \&amp;Cpanel::Locale::Utils::Legacy::map_any_old_style_to_new_style;
    }
    return @locales;
}

our $IN_REAL_GET_HANDLE = 0;

sub _setup_for_real_get_handle {    ## no critic qw(RequireArgUnpacking)

    if ($IN_REAL_GET_HANDLE) {
        _load_carp();
        if ( $IN_REAL_GET_HANDLE &gt; 1 ) {
            die 'Cpanel::Carp'-&gt;can('safe_longmess')-&gt;(&quot;Attempted to call _setup_for_real_get_handle from _setup_for_real_get_handle&quot;);
        }
        warn 'Cpanel::Carp'-&gt;can('safe_longmess')-&gt;(&quot;Attempted to call _setup_for_real_get_handle from _setup_for_real_get_handle&quot;);
        if ($Cpanel::Exception::IN_EXCEPTION_CREATION) {    # PPI NO PARSE - Only care about this check if the module is loaded
            $Cpanel::Exception::LOCALIZE_STRINGS = 0;       # PPI NO PARSE - Only care about this check if the module is loaded
        }
    }
    local $IN_REAL_GET_HANDLE = $IN_REAL_GET_HANDLE + 1;

    if ( defined $Cpanel::App::appname &amp;&amp; defined $ENV{'REMOTE_USER'} ) {    # PPI NO PARSE - Only care about this check if the module is loaded
        if (
            $Cpanel::App::appname eq 'whostmgr'                              # PPI NO PARSE - Only care about this check if the module is loaded
            &amp;&amp; $ENV{'REMOTE_USER'} ne 'root'
        ) {

            require Cpanel::Config::HasCpUserFile;
            if ( Cpanel::Config::HasCpUserFile::has_readable_cpuser_file( $ENV{'REMOTE_USER'} ) ) {
                require Cpanel::Config::LoadCpUserFile::CurrentUser;
                my $cpdata_ref = Cpanel::Config::LoadCpUserFile::CurrentUser::load( $ENV{'REMOTE_USER'} );

                if ( scalar keys %{$cpdata_ref} ) {
                    *Cpanel::CPDATA = $cpdata_ref;
                }
            }
        }
    }

    my ( $class, @langtags ) = (
        $_[0],
        (
              defined $_[1]                                                                   ? _map_any_old_style_to_new_style( (@_)[ 1 .. $#_ ] )
            : exists $Cpanel::Cookies{'session_locale'} &amp;&amp; $Cpanel::Cookies{'session_locale'} ? _map_any_old_style_to_new_style( $Cpanel::Cookies{'session_locale'} )
            : ( exists $Cpanel::CPDATA{'LOCALE'} &amp;&amp; $Cpanel::CPDATA{'LOCALE'} )               ? ( $Cpanel::CPDATA{'LOCALE'} )
            : ( exists $Cpanel::CPDATA{'LANG'} &amp;&amp; $Cpanel::CPDATA{'LANG'} )                   ? ( _map_any_old_style_to_new_style( $Cpanel::CPDATA{'LANG'} ) )
            :                                                                                   ( get_server_locale() )
        )
    );

    if ( !$Cpanel::Locale::CDB_File_Path ) {
        $Cpanel::Locale::CDB_File_Path = Cpanel::Locale::Utils::init_lexicon( 'en', \%Cpanel::Locale::Lexicon, \$Cpanel::Locale::VERSION, \$Cpanel::Locale::Encoding );
    }

    _make_alias_if_needed( @langtags ? @langtags : 'en_us' );

    return @langtags;
}

my %_made_aliases;

sub _make_alias_if_needed {
    foreach my $tag ( grep { ( $_ eq 'en' || $_ eq 'i_default' || $_ eq 'en_us' ) &amp;&amp; !$_made_aliases{$_} } ( 'en', @_ ) ) {

        Cpanel::Locale-&gt;make_alias( [$tag], 1 );
        $_made_aliases{$tag} = 1;
    }
    return 0;
}

sub _real_get_handle {
    my ( $class, @arg_langtags ) = @_;

    my @langtags = _setup_for_real_get_handle( $class, @arg_langtags );
    @langtags = map { my $l = $_; $l = 'en' if ( $l eq 'en_us' || $l eq 'i_default' ); $l } grep { $class-&gt;cpanel_is_valid_locale($_) } @langtags;
    @langtags = ('en') unless scalar @langtags;

    my $args_sig = join( ',', @langtags ) || 'no_args';

    return (
        ( defined $singleton_stash{$class}{$args_sig} &amp;&amp; ++$singleton_stash{$class}{$args_sig}-&gt;{'_singleton_reused'} )
        ? $singleton_stash{$class}{$args_sig}
        : ( $singleton_stash{$class}{$args_sig} = Cpanel::CPAN::Locale::Maketext::get_handle( $class, @langtags ) )
    );

}

sub get_non_singleton_handle {
    my ( $class, @arg_langtags ) = @_;

    my @langtags = _setup_for_real_get_handle( $class, @arg_langtags );

    return Cpanel::CPAN::Locale::Maketext::get_handle( $class, @langtags );
}

sub init {
    my ($lh) = @_;

    $lh-&gt;SUPER::init();

    $lh-&gt;_initialize_unknown_phrase_logging();
    $lh-&gt;_initialize_bracket_notation_whitelist();

    return $lh;
}

sub _initialize_unknown_phrase_logging {
    my $lh = shift;

    if ( defined $Cpanel::Locale::Context::DEFAULT_OUTPUT_CONTEXT ) {    # PPI NO PARSE - Only needed if loaded
        my $setter_cr = $lh-&gt;can(&quot;set_context_${Cpanel::Locale::Context::DEFAULT_OUTPUT_CONTEXT}&quot;) or do {    # PPI NO PARSE - Only needed if loaded
            die &quot;Invalid \$Cpanel::Locale::Context::DEFAULT_OUTPUT_CONTEXT: “$Cpanel::Locale::Context::DEFAULT_OUTPUT_CONTEXT”!&quot;;    # PPI NO PARSE - Only needed if loaded
        };
        $setter_cr-&gt;($lh);
    }

    elsif ( defined $Cpanel::Carp::OUTPUT_FORMAT ) {    # issafe
        if ( $Cpanel::Carp::OUTPUT_FORMAT eq 'xml' ) {    # issafe
            $lh-&gt;set_context_plain();                     # no HTML markup or ANSI escape sequences
        }
        elsif ( $Cpanel::Carp::OUTPUT_FORMAT eq 'html' ) {    # issafe
            $lh-&gt;set_context_html();                          # HTML
        }
    }

    $lh-&gt;{'use_external_lex_cache'} = 1;

    if ( exists $Cpanel::CPDATA{'LOCALE_LOG_MISSING'} &amp;&amp; $Cpanel::CPDATA{'LOCALE_LOG_MISSING'} ) {
        $lh-&gt;{'_log_phantom_key'} = sub {
            my ( $lh, $key ) = @_;


            my $chain      = '';
            my $base_class = $lh-&gt;get_base_class();
            foreach my $class ( $lh-&gt;get_language_class, $base_class ) {
                my $lex_path = $lh-&gt;get_cdb_file_path( $class eq $base_class ? 1 : 0 );
                next if !$lex_path;
                $chain .= &quot;\tLOCALE: $class\n\tPATH: $lex_path\n&quot;;
                last if $class eq 'Cpanel::Locale::en' || $class eq 'Cpanel::Locale::en_us' || $class eq 'Cpanel::Locale::i_default';
            }

            my $pkg = $lh-&gt;get_language_tag();
            _logger-&gt;info( ( $Cpanel::Parser::Vars::file ? &quot;$Cpanel::Parser::Vars::file ::&quot; : '' ) . qq{ Could not find key via '$pkg' locale:\n\tKEY: '$key'\n$chain} );    # PPI NO PARSE -- module will already be there is we care about it

        };
    }
    return $lh;
}

our @DEFAULT_WHITELIST = qw(quant asis output current_year list_and list_or comment boolean datetime local_datetime format_bytes get_locale_name get_user_locale_name is_defined is_future join list_and_quoted list_or_quoted numerate numf);

sub _initialize_bracket_notation_whitelist {
    my $lh = shift;

    my @whitelist             = @DEFAULT_WHITELIST;
    my $custom_whitelist_file = Cpanel::Locale::Utils::Paths::get_custom_whitelist_path();

    if ( open( my $fh, '&lt;', $custom_whitelist_file ) ) {
        while ( my $ln = readline($fh) ) {
            chomp $ln;
            push @whitelist, $ln if length($ln);
        }
        close $fh;
    }

    $lh-&gt;whitelist(@whitelist);
    return $lh;
}


sub output_cpanel_error {
    my ( $lh, $position ) = @_;

    if ( $lh-&gt;context_is_ansi() ) {
        return &quot;\e[1;31m&quot; if $position eq 'begin';
        return &quot;\e[0m&quot;    if $position eq 'end';
        return '';
    }
    elsif ( $lh-&gt;context_is_html() ) {
        return qq{&lt;p style=&quot;color:#FF0000&quot;&gt;} if $position eq 'begin';
        return '&lt;/p&gt;'                        if $position eq 'end';
        return '';
    }
    else {
        return '';    # e.g. $lh-&gt;context_is_plain()
    }
}

sub cpanel_get_3rdparty_lang {
    my ( $lh, $_3rdparty ) = @_;
    require Cpanel::Locale::Utils::3rdparty;

    return Cpanel::Locale::Utils::3rdparty::get_app_setting( $lh, $_3rdparty ) || Cpanel::Locale::Utils::3rdparty::get_3rdparty_lang( $lh, $_3rdparty ) || $lh-&gt;get_language_tag() || 'en';
}

sub cpanel_is_valid_locale {
    my ( $lh, $locale ) = @_;

    my %valid_locales = map { $_ =&gt; 1 } ( qw(en en_us i_default), $lh-&gt;list_available_locales );
    return $valid_locales{$locale} ? 1 : 0;
}

sub cpanel_get_3rdparty_list {
    my ($lh) = @_;
    require Cpanel::Locale::Utils::3rdparty;
    return Cpanel::Locale::Utils::3rdparty::get_3rdparty_list($lh);
}

sub cpanel_get_lex_path {
    my ( $lh, $path, $rv ) = @_;

    return if !defined $path || $path eq '' || substr( $path, -3 ) ne '.js';

    require Cpanel::JS::Variations;

    my $query = $path;
    $query = Cpanel::JS::Variations::get_base_file( $query, '-%s.js' );

    if ( defined $rv &amp;&amp; index( $rv, '%s' ) == -1 ) {
        substr( $rv, -3, 3, '-%s.js' );
    }

    my $asset_path = $lh-&gt;get_asset_file( $query, $rv );

    return $asset_path if $asset_path &amp;&amp; substr( $asset_path, -3 ) eq '.js' &amp;&amp; index( $asset_path, '-' ) &gt; -1;    # Only return a value if there is a localized js file here
    return;
}

sub tag_is_default_locale {
    my $tag = $_[1] || $_[0]-&gt;get_language_tag();
    return 1 if $tag eq 'en' || $tag eq 'en_us' || $tag eq 'i_default';
    return;
}

sub get_cdb_file_path {
    my ( $lh, $core ) = @_;
    my $class = $core ? $lh-&gt;get_base_class() : $lh-&gt;get_language_class();
    no strict 'refs';
    return
         $class eq 'Cpanel::Locale::en'
      || $class eq 'Cpanel::Locale::en_us'
      || $class eq 'Cpanel::Locale::i_default' ? $Cpanel::Locale::CDB_File_Path : ${ $class . '::CDB_File_Path' };
}

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

    local ( $!, $^E );

    open my $rfh, '&lt;', $path or do {
        if ( $! != _ENOENT() ) {
            warn &quot;open($path): $!&quot;;
        }

        return undef;
    };

    read $rfh, my $buf, 8192 or do {
        warn &quot;read($path): $!&quot;;
    };

    return $buf;
}

my $_server_locale_file_contents;

sub get_server_locale {
    if ( exists $ENV{'CPANEL_SERVER_LOCALE'} ) {
        return $ENV{'CPANEL_SERVER_LOCALE'} if $ENV{'CPANEL_SERVER_LOCALE'} !~ tr{A-Za-z0-9_-}{}c;
        return undef;
    }
    if (%main::CPCONF) {
        return $main::CPCONF{'server_locale'} if exists $main::CPCONF{'server_locale'};
    }


    return ( $_server_locale_file_contents //= ( _slurp_small_file_if_exists_no_exception($SERVER_LOCALE_FILE) || '' ) );
}

sub _clear_cache {
    $_server_locale_file_contents = undef;
    return;
}

sub get_locale_for_user_cpanel {
    if (%main::CPCONF) {
        return $main::CPCONF{'cpanel_locale'} if exists $main::CPCONF{'cpanel_locale'};
        return $main::CPCONF{'server_locale'} if exists $main::CPCONF{'server_locale'};
    }
    require Cpanel::Config::LoadCpConf;
    my $cpconf = Cpanel::Config::LoadCpConf::loadcpconf_not_copy();    # safe since we do not modify cpconf

    return $cpconf-&gt;{'cpanel_locale'} if $cpconf-&gt;{'cpanel_locale'};    # will not be autovivified, 0 and &quot;&quot; are invalid, if the value is invalid they will get 'en'
    return $cpconf-&gt;{'server_locale'} if $cpconf-&gt;{'server_locale'};    # will not be autovivified, 0 and &quot;&quot; are invalid, if the value is invalid they will get 'en'
    return;
}

sub cpanel_reinit_lexicon {
    my ($lh) = @_;
    $lh-&gt;cpanel_detach_lexicon();
    $lh-&gt;cpanel_attach_lexicon();
}

my $detach_locale_lex;

sub cpanel_detach_lexicon {
    my ($lh) = @_;
    my $locale = $lh-&gt;get_language_tag();
    no strict 'refs';

    undef $Cpanel::Locale::CDB_File_Path;
    if ( $locale ne 'en' &amp;&amp; $locale ne 'en_us' &amp;&amp; $locale ne 'i_default' ) {
        $detach_locale_lex = ${ 'Cpanel::Locale::' . $locale . '::CDB_File_Path' };
        undef ${ 'Cpanel::Locale::' . $locale . '::CDB_File_Path' };
    }

    untie( %{ 'Cpanel::Locale::' . $locale . '::Lexicon' } );
    untie %Cpanel::Locale::Lexicon;
}

sub cpanel_attach_lexicon {
    my ($lh) = @_;
    my $locale = $lh-&gt;get_language_tag();

    $Cpanel::Locale::CDB_File_Path = Cpanel::Locale::Utils::init_lexicon( 'en', \%Cpanel::Locale::Lexicon, \$Cpanel::Locale::VERSION, \$Cpanel::Locale::Encoding );

    _make_alias_if_needed($locale);

    no strict 'refs';
    if ( defined $detach_locale_lex ) {
        ${ 'Cpanel::Locale::' . $locale . '::CDB_File_Path' } = $detach_locale_lex;
    }
    else {
        ${ 'Cpanel::Locale::' . $locale . '::CDB_File_Path' } = $Cpanel::Locale::CDB_File_Path;
    }

    my $file_path = $lh-&gt;get_cdb_file_path();
    return if !$file_path;
    return Cpanel::Locale::Utils::get_readonly_tie( $lh-&gt;get_cdb_file_path(), \%{ 'Cpanel::Locale::' . $locale . '::Lexicon' } );
}

sub is_rtl {
    my ($lh) = @_;

    return 'right-to-left' eq $lh-&gt;get_language_tag_character_orientation() ? 1 : 0;
}

sub get_language_tag_character_orientation {
    if ( my $direction = $known_locales_character_orientation{ $_[1] || $_[0]-&gt;{'fallback_locale'} || $_[0]-&gt;get_language_tag() } ) {
        return 'right-to-left' if $direction == $RTL;
        return 'left-to-right';
    }
    $_[0]-&gt;SUPER::get_language_tag_character_orientation( @_[ 1 .. $#_ ] );
}

my $menu_ar;

sub get_locale_menu_arrayref {
    return $menu_ar if $menu_ar;
    require Cpanel::Locale::Utils::Display;
    $menu_ar = [ Cpanel::Locale::Utils::Display::get_locale_menu_hashref(@_) ];    # always array context to get all structs, properly uses other args besides object
    return $menu_ar;
}

my $non_existent;

sub get_non_existent_locale_menu_arrayref {
    return $non_existent if $non_existent;
    require Cpanel::Locale::Utils::Display;
    $non_existent = [ Cpanel::Locale::Utils::Display::get_non_existent_locale_menu_hashref(@_) ];    # always array context to get all structs, properly uses other args besides object
    return $non_existent;
}

sub _api1_maketext {
    require Cpanel::Locale::Utils::Api1;
    goto \&amp;Cpanel::Locale::Utils::Api1::_api1_maketext;                                              ## no extract maketext
}

our $api1 = {
    'maketext' =&gt; {                                                                                  ## no extract maketext
        'function'        =&gt; \&amp;_api1_maketext,                                                       ## no extract maketext
        'internal'        =&gt; 1,
        'legacy_function' =&gt; 2,
        'modify'          =&gt; 'inherit',
    },
};

sub current_year {
    return (localtime)[5] + 1900;    # we override datetime() so we can't use the internal current_year()
}

sub local_datetime {
    my ( $lh, $epoch, $format ) = @_;
    my $timezone = $ENV{'TZ'} // do {
        require Cpanel::Timezones;
        Cpanel::Timezones::calculate_TZ_env();
    };
    return $lh-&gt;datetime( $epoch, $format, $timezone );
}

sub datetime {
    my ( $lh, $epoch, $format, $timezone ) = @_;
    require Cpanel::Locale::Utils::DateTime;

    if ( $epoch &amp;&amp; $epoch =~ tr&lt;0-9&gt;&lt;&gt;c ) {
        require    # do not include it in updatenow.static
          Cpanel::Validate::Time;
        Cpanel::Validate::Time::iso_or_die($epoch);

        require Cpanel::Time::ISO;
        $epoch = Cpanel::Time::ISO::iso2unix($epoch);
    }

    return Cpanel::Locale::Utils::DateTime::datetime( $lh, $epoch, $format, $timezone );
}

sub get_lookup_hash_of_multi_epoch_datetime {
    my ( $lh, $epochs_ar, $format, $timezone ) = @_;
    require Cpanel::Locale::Utils::DateTime;
    return Cpanel::Locale::Utils::DateTime::get_lookup_hash_of_multi_epoch_datetime( $lh, $epochs_ar, $format, $timezone );
}

sub get_locale_name_or_nothing {
    my ( $locale, $name, $in_locale_tongue ) = @_;
    $name ||= $locale-&gt;get_language_tag();

    if ( index( $name, 'i_' ) == 0 ) {
        require Cpanel::DataStore;
        my $i_locales_path = Cpanel::Locale::Utils::Paths::get_i_locales_config_path();
        my $i_conf         = Cpanel::DataStore::fetch_ref(&quot;$i_locales_path/$name.yaml&quot;);

        return $i_conf-&gt;{'display_name'} if $i_conf-&gt;{'display_name'};
    }
    else {
        my $real = $locale-&gt;get_language_tag_name( $name, $in_locale_tongue );
        return $real if $real;
    }

    return;
}

sub get_locale_name_or_tag {
    return $_[0]-&gt;get_locale_name_or_nothing( $_[1], $_[2] ) || $_[1] || $_[0]-&gt;get_language_tag();
}

*get_locale_name = *get_locale_name_or_tag;    # for shorter BN

sub get_user_locale {
    return $Cpanel::CPDATA{'LOCALE'} if $Cpanel::CPDATA{'LOCALE'};
    require Cpanel::Locale::Utils::User;       # probably a no-op but just in case since its loading is conditional
    return Cpanel::Locale::Utils::User::get_user_locale();
}

sub get_user_locale_name {
    require Cpanel::Locale::Utils::User;       # probably a no-op but just in case since its loading is conditional
    return $_[0]-&gt;get_locale_name_or_tag( Cpanel::Locale::Utils::User::get_user_locale( $_[1] ) );
}


sub set_user_locale {
    my ( $locale, $country_code ) = @_;

    if ($country_code) {
        my $language_name = $locale-&gt;lang_names_hashref();

        if ( exists $language_name-&gt;{$country_code} ) {
            require Cpanel::Locale::Utils::Legacy;
            require Cpanel::Locale::Utils::User::Modify;

            my $language = Cpanel::Locale::Utils::Legacy::get_best_guess_of_legacy_from_locale($country_code);
            if ( Cpanel::Locale::Utils::User::Modify::save_user_locale( $country_code, $language, $Cpanel::user ) ) {
                return 1;
            }

        }
    }

    die Cpanel::Exception::create_raw( &quot;Empty&quot;, $locale-&gt;maketext(&quot;Unable to set locale, please specify a valid country code.&quot;) );
}


sub get_locales {

    my $locale = shift;
    my @listing;
    my ( $names, $local_names ) = $locale-&gt;lang_names_hashref();

    foreach ( keys %{$names} ) {
        push @listing, {
            locale     =&gt; $_,
            name       =&gt; $names-&gt;{$_},
            local_name =&gt; $local_names-&gt;{$_},
            direction  =&gt; ( !defined $known_locales_character_orientation{$_} || $known_locales_character_orientation{$_} == $LTR ) ? 'ltr' : 'rtl'
        };
    }

    return \@listing;

}

my $api2_lh;

sub api2_get_user_locale {
    $api2_lh ||= Cpanel::Locale-&gt;get_handle();
    return ( { 'locale' =&gt; $api2_lh-&gt;get_user_locale() } );
}

sub api2_get_user_locale_name {
    $api2_lh ||= Cpanel::Locale-&gt;get_handle();
    return ( { 'name' =&gt; $api2_lh-&gt;get_user_locale_name() } );
}

sub api2_get_locale_name {
    $api2_lh ||= Cpanel::Locale-&gt;get_handle();

    my $tag = ( scalar @_ &gt; 2 ) ? {@_}-&gt;{'locale'} : $_[1];

    return ( { 'name' =&gt; $api2_lh-&gt;get_locale_name_or_tag($tag) } );
}

sub api2_get_encoding {
    $api2_lh ||= Cpanel::Locale-&gt;get_handle();
    return ( { 'encoding' =&gt; $api2_lh-&gt;encoding() } );
}

sub api2_numf {
    my %args = @_;
    $api2_lh ||= Cpanel::Locale-&gt;get_handle();
    return ( { 'numf' =&gt; $api2_lh-&gt;numf( $args{number}, $args{max_decimal_places} ) } );
}

sub api2_get_html_dir_attr {
    $api2_lh ||= Cpanel::Locale-&gt;get_handle();

    return ( { 'dir' =&gt; $api2_lh-&gt;get_html_dir_attr() } );
}

my $allow_demo = { allow_demo =&gt; 1 };

our %API = (
    get_locale_name      =&gt; $allow_demo,
    get_encoding         =&gt; $allow_demo,
    get_html_dir_attr    =&gt; $allow_demo,
    get_user_locale      =&gt; $allow_demo,
    get_user_locale_name =&gt; $allow_demo,
    numf                 =&gt; $allow_demo,
);

sub api2 {
    my ($func) = @_;
    return { %{ $API{$func} } } if $API{$func};
    return;
}

my $global_lh;


sub lh {
    return ( $global_lh ||= Cpanel::Locale-&gt;get_handle() );
}

sub import {
    my ( $package, @args ) = @_;
    my ($namespace) = caller;
    if ( @args == 1 &amp;&amp; $args[0] eq 'lh' ) {
        no strict 'refs';    ## no critic(ProhibitNoStrict)
        my $exported_name = &quot;${namespace}::lh&quot;;
        *$exported_name = \*lh;
    }
}

sub _load_carp {
    if ( !$INC{'Cpanel/Carp.pm'} ) {

        local $@;

        eval 'require Cpanel::Carp; 1;' or die $@;    # hide from perlcc
    }

    return;
}

sub user_feedback_text_for_more_locales {
    require Cpanel::Version;

    my $locale  = Cpanel::Locale-&gt;get_handle();
    my $version = Cpanel::Version::get_version_full();

    my $survey_url = 'https://surveys.webpros.com/to/xGTiJG4X?utm_source=cpanel-changelanguage&amp;cpanel_productversion=' . $version;

    return $locale-&gt;maketext( &quot;Don’t see your language of choice? Take our [output,url,_1,Language Support Feedback Survey,class,externalLink,target,Language Survey] to let us know your preferences.&quot;, $survey_url );
}

1;

} # --- END Cpanel/Locale.pm


{ # --- BEGIN Cpanel/Sys/Uname.pm
package Cpanel::Sys::Uname;


use strict;

our $SYS_UNAME       = 63;
our $UNAME_ELEMENTS  = 6;
our $_UTSNAME_LENGTH = 65;
my $UNAME_PACK_TEMPLATE   = ( 'c' . $_UTSNAME_LENGTH ) x $UNAME_ELEMENTS;
my $UNAME_UNPACK_TEMPLATE = ( 'Z' . $_UTSNAME_LENGTH ) x $UNAME_ELEMENTS;

my @uname_cache;

sub get_uname_cached {
    return ( @uname_cache ? @uname_cache : ( @uname_cache = syscall_uname() ) );
}

sub clearcache {
    @uname_cache = ();
    return;
}

sub syscall_uname {
    my $uname;
    if ( syscall( $SYS_UNAME, $uname = pack( $UNAME_PACK_TEMPLATE, () ) ) == 0 ) {
        return unpack( $UNAME_UNPACK_TEMPLATE, $uname );
    }
    else {
        die &quot;The uname() system call failed because of an error: $!&quot;;
    }
    return;
}
1;

} # --- END Cpanel/Sys/Uname.pm


{ # --- BEGIN Cpanel/Sys/Hostname/Fallback.pm
package Cpanel::Sys::Hostname::Fallback;


use strict;
use warnings;

use Socket             ();
# use Cpanel::Sys::Uname ();


sub get_canonical_hostname {
    my @uname = Cpanel::Sys::Uname::get_uname_cached();
    my ( $err, @results ) = Socket::getaddrinfo( $uname[1], 0, { flags =&gt; Socket::AI_CANONNAME() } );
    if ( @results &amp;&amp; $results[0]-&gt;{'canonname'} ) {
        return $results[0]-&gt;{'canonname'};
    }

    return undef;

}

1;

} # --- END Cpanel/Sys/Hostname/Fallback.pm


{ # --- BEGIN Cpanel/Sys/Hostname.pm
package Cpanel::Sys::Hostname;


use strict;
use warnings;

our $VERSION = 2.0;

# use Cpanel::Sys::Uname ();

our $cachedhostname = '';

sub gethostname {
    my $nocache = shift || 0;
    if ( !$nocache &amp;&amp; length $cachedhostname ) { return $cachedhostname }

    my $hostname = _gethostname($nocache);

    if ( length $hostname ) {
        $hostname =~ tr{A-Z}{a-z};    # hostnames must be lowercase (see Cpanel::Sys::Hostname::Modify::make_hostname_lowercase_fqdn)
        $cachedhostname = $hostname;
    }
    return $hostname;
}

sub _gethostname {
    my $nocache = shift || 0;

    my $hostname;
    Cpanel::Sys::Uname::clearcache() if $nocache;
    my @uname = Cpanel::Sys::Uname::get_uname_cached();
    if ( $uname[1] &amp;&amp; index( $uname[1], '.' ) &gt; -1 ) {
        $hostname = $uname[1];
        $hostname =~ tr{A-Z}{a-z};    # hostnames must be lowercase (see Cpanel::Sys::Hostname::Modify::make_hostname_lowercase_fqdn)
        return $hostname;
    }

    eval {
        require Cpanel::Sys::Hostname::Fallback;
        $hostname = Cpanel::Sys::Hostname::Fallback::get_canonical_hostname();
    };
    if ($hostname) {
        $hostname =~ tr{A-Z}{a-z};    # hostnames must be lowercase (see Cpanel::Sys::Hostname::Modify::make_hostname_lowercase_fqdn)
        return $hostname;
    }

    require Cpanel::LoadFile;
    chomp( $hostname = Cpanel::LoadFile::loadfile( '/proc/sys/kernel/hostname', { 'skip_exists_check' =&gt; 1 } ) );
    if ($hostname) {
        $hostname =~ tr{A-Z}{a-z};    # hostnames must be lowercase (see Cpanel::Sys::Hostname::Modify::make_hostname_lowercase_fqdn)
        $hostname =~ tr{\r\n}{}d;     # chomp is not enough (not sure if this is required, however we cannot test all kernels so its safer to leave it in)
        return $hostname;
    }

    require Cpanel::Debug;
    Cpanel::Debug::log_warn('Unable to determine correct hostname');
    return;
}


sub shorthostname {
    my $hostname = gethostname();
    return $hostname if index( $hostname, '.' ) == -1;    # Hostname is not a FQDN (this should never happen)
    return substr( $hostname, 0, index( $hostname, '.' ) );
}

1;

} # --- END Cpanel/Sys/Hostname.pm


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


use strict;
use warnings;

# use Cpanel::Sys::Hostname ();

our $VERSION = 2.0;

{
    no warnings 'once';
    *gethostname   = *Cpanel::Sys::Hostname::gethostname;
    *shorthostname = *Cpanel::Sys::Hostname::shorthostname;
}

1;

} # --- END Cpanel/Hostname.pm


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


use strict;
use warnings;


# use Cpanel::ConfigFiles                  ();
# use Cpanel::Debug                        ();
# use Cpanel::FileUtils::Write::JSON::Lazy ();
# use Cpanel::LoadModule                   ();
# use Cpanel::Config::CpConfGuard          ();

our $SENDING_MISSING_FILE_NOTICE = 0;

my $FILESYS_PERMS = 0644;

sub find_missing_keys {
    my ($self) = @_;
    _verify_called_as_object_method($self);

    Cpanel::LoadModule::load_perl_module('Cpanel::Config::CpConfGuard::Default');
    my $default = 'Cpanel::Config::CpConfGuard::Default'-&gt;new(
        current_config  =&gt; $self-&gt;{data},
        current_changes =&gt; $self-&gt;{changes},
    );

    if ( $self-&gt;{'is_missing'} ) {

        if ( UNIVERSAL::isa( $self-&gt;{'cache'}, 'HASH' ) &amp;&amp; %{ $self-&gt;{'cache'} } ) {

            $self-&gt;{'data'} = {};
            %{ $self-&gt;{'data'} } = %{ $self-&gt;{'cache'} };
            my $config = $self-&gt;{'data'};

            foreach my $key ( $default-&gt;get_keys() ) {
                next if exists $config-&gt;{$key};
                $config-&gt;{$key} = $default-&gt;get_default_for($key);
            }

        }
        else {
            $self-&gt;{'data'} = $default-&gt;get_all_defaults();
        }

        $self-&gt;{'modified'} = 1;    # Mark as save needed.
        return;
    }

    my $cache = $self-&gt;{'cache'};
    undef( $self-&gt;{'cache'} );    # we do not need the cache after the first pass
    my $config = $self-&gt;{'data'};

    my $changes = $self-&gt;{'changes'};    # used for notifications

    $config-&gt;{'tweak_unset_vars'} ||= '';

    foreach my $key ( $default-&gt;get_keys() ) {
        next if exists $config-&gt;{$key};

        $self-&gt;{'modified'} = 1;    # Mark as save needed.

        if ( exists $cache-&gt;{$key} ) {
            $config-&gt;{$key} = $cache-&gt;{$key};

            $changes-&gt;{'from_cache'} ||= [];
            push @{ $changes-&gt;{'from_cache'} }, $key;

            $changes-&gt;{'changed_keys'} ||= {};
            $changes-&gt;{'changed_keys'}{$key} = 'from_cache';

            next;
        }

        my $changes_type = $default-&gt;is_dynamic($key) ? 'from_dynamic' : 'from_default';

        $changes-&gt;{'changed_keys'} ||= {};
        $changes-&gt;{'changed_keys'}{$key} = $changes_type;

        $changes-&gt;{$changes_type} ||= [];
        push @{ $changes-&gt;{$changes_type} }, $key;

        $config-&gt;{$key} = $default-&gt;get_default_for($key);
    }

    foreach my $key ( @{ $default-&gt;dead_variables() } ) {
        next unless exists $config-&gt;{$key};

        $self-&gt;{'modified'} = 1;    # Mark as save needed.

        delete( $config-&gt;{$key} );

        $changes-&gt;{'dead_variable'} ||= [];
        push @{ $changes-&gt;{'dead_variable'} }, $key;

    }

    return;
}

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

    _verify_called_as_object_method($self);

    Cpanel::LoadModule::load_perl_module('Cpanel::Config::CpConfGuard::Validate');
    my $invalid = 'Cpanel::Config::CpConfGuard::Validate'-&gt;can('patch_cfg')-&gt;( $self-&gt;{'data'} );
    if (%$invalid) {
        $self-&gt;{modified} = 1;
        $self-&gt;{'changes'}-&gt;{'invalid'} = $invalid;
    }

    return;
}

sub notify_and_save_if_changed {
    my ($self) = @_;
    _verify_called_as_object_method($self);

    return if !$self-&gt;{'use_lock'};
    return if !$self-&gt;{'modified'};

    my $config = $self-&gt;{'data'};

    if ( $ENV{'CPANEL_BASE_INSTALL'} ) {
        ;    # Do nothing for notification.
    }
    elsif ( $self-&gt;{'is_missing'} ) {
        $config-&gt;{'tweak_unset_vars'} = '';
        Cpanel::Debug::log_warn(&quot;Missing cpanel.config regenerating …&quot;);

        $self-&gt;notify_missing_file;
    }
    elsif ( %{ $self-&gt;{'changes'} } ) {
        my $changes = $self-&gt;{'changes'};

        my %uniq = map { $_ =&gt; 1 } @{ $changes-&gt;{'from_default'} || [] }, @{ $changes-&gt;{'from_dynamic'} || [] }, split( /\s*,\s*/, $config-&gt;{'tweak_unset_vars'} );
        $config-&gt;{'tweak_unset_vars'} = join &quot;,&quot;, sort keys %uniq;

        $self-&gt;log_missing_values();
    }

    return $self-&gt;save( keep_lock =&gt; 1 );
}

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

    _verify_called_as_object_method($self);

    my $locale_name = $self-&gt;{'data'}-&gt;{'server_locale'} || 'en';
    require Cpanel::Locale;
    return Cpanel::Locale-&gt;_real_get_handle($locale_name);
}

sub _longest {
    my @array = @_;
    return length( ( sort { length $b &lt;=&gt; length $a } @array )[0] );
}

sub _stringify_undef {
    my $value = shift;
    return defined $value ? $value : '&lt;undef&gt;';
}

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

    require Cpanel::Hostname;
    my $changes = $self-&gt;{'changes'};

    my $locale = $self-&gt;_server_locale();

    my $hostname = Cpanel::Hostname::gethostname();

    my $prev = $locale-&gt;set_context_plain();

    my $message = '';
    $message .= $locale-&gt;maketext( 'One or more key settings for “[_1]” were either not found in [asis,cPanel amp() WHM]’s server configuration file ([_2]), or were present but did not pass validation.', $hostname, $self-&gt;{'path'} ) . &quot;\n&quot;;

    if ( $changes-&gt;{'from_dynamic'} ) {
        $message .= $locale-&gt;maketext('The following settings were absent and have been selected based on the current state of your installation.');
        $message .= &quot;\n&quot;;

        my @keys    = @{ $changes-&gt;{'from_dynamic'} };
        my $max_len = _longest(@keys) + 2;
        foreach my $key (@keys) {
            $message .= sprintf( &quot;    %-${max_len}s= %s\n&quot;, $key, _stringify_undef( $self-&gt;{'data'}-&gt;{$key} ) );
        }
        $message .= &quot;\n&quot;;
    }

    if ( $changes-&gt;{'from_cache'} ) {
        $message .= $locale-&gt;maketext('The following settings were absent, but were restored from your [asis,cpanel.config.cache] file:');
        $message .= &quot;\n&quot;;

        my @keys    = @{ $changes-&gt;{'from_cache'} };
        my $max_len = _longest(@keys) + 2;
        foreach my $key (@keys) {
            $message .= sprintf( &quot;    %-${max_len}s= %s\n&quot;, $key, _stringify_undef( $self-&gt;{'data'}-&gt;{$key} ) );
        }
        $message .= &quot;\n&quot;;
    }

    if ( $changes-&gt;{'from_default'} or $changes-&gt;{'invalid'} ) {
        $message .= $locale-&gt;maketext('The following settings were absent or invalid. Your server has copied the defaults for them from the configuration defaults file ([asis,/usr/local/cpanel/etc/cpanel.config]).');
        $message .= &quot;\n&quot;;

        if ( $changes-&gt;{'from_default'} ) {
            my @keys    = @{ $changes-&gt;{'from_default'} };
            my $max_len = _longest(@keys) + 2;
            foreach my $key (@keys) {
                $message .= sprintf( &quot;    %-${max_len}s= %s\n&quot;, $key, _stringify_undef( $self-&gt;{'data'}-&gt;{$key} ) );
            }
        }

        if ( $changes-&gt;{'invalid'} ) {
            my $invalid = $changes-&gt;{'invalid'};
            my @keys    = keys %$invalid;
            my $max_len = _longest(@keys) + 2;
            foreach my $key (@keys) {
                $message .= sprintf( &quot;    %-${max_len}s= %s (Previously set to '%s')\n&quot;, $key, _stringify_undef( $invalid-&gt;{$key}-&gt;{'to'} ), _stringify_undef( $invalid-&gt;{$key}-&gt;{'from'} ) );
            }
        }
        $message .= &quot;\n&quot;;
    }

    if ( $changes-&gt;{'dead_variable'} ) {
        $message .= $locale-&gt;maketext('The following settings are obsolete and have been removed from the server configuration file:');
        $message .= &quot;\n&quot;;
        $message .= '    ' . join( ', ', @{ $changes-&gt;{'dead_variable'} } );
        $message .= &quot;\n\n&quot;;
    }

    $message .= $locale-&gt;maketext( 'Read the [asis,cpanel.config] file [output,url,_1,documentation] for important information about this file.', 'https://go.cpanel.net/cpconfig' );
    $message .= &quot;\n\n&quot;;

    Cpanel::Debug::logger();    # initialize the logger
    local $Cpanel::Logger::ENABLE_BACKTRACE = 0;
    foreach my $chunk ( split( /\n+/, $message ) ) {
        Cpanel::Debug::log_warn($chunk);
    }

    $locale-&gt;set_context($prev);

    return;
}

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

    if ($SENDING_MISSING_FILE_NOTICE) {
        return;    #Already sending notification, don't double up
    }

    require Cpanel::Hostname;
    local $SENDING_MISSING_FILE_NOTICE = 1;

    my $locale = $self-&gt;_server_locale();
    my $prev   = $locale-&gt;set_context_plain();

    my @to_log;
    my %critical_values;

    my $hostname = Cpanel::Hostname::gethostname();
    push @to_log, $locale-&gt;maketext('Your server has copied the defaults from your cache and the configuration defaults file ([asis,/usr/local/cpanel/etc/cpanel.config]) to [asis,/var/cpanel/cpanel.config], and it has generated the following critical values:');
    Cpanel::LoadModule::load_perl_module('Cpanel::Config::CpConfGuard::Default');
    my $critical = Cpanel::Config::CpConfGuard::Default::critical_values();
    my $max_len  = _longest(@$critical) + 2;
    my $critical_value;
    foreach my $key ( sort @$critical ) {
        $critical_value = _stringify_undef( $self-&gt;{'data'}-&gt;{$key} );
        $critical_values{$key} = $critical_value;
        push @to_log, sprintf( &quot;    %-${max_len}s= %s\n&quot;, $key, $critical_value );
    }

    push @to_log, $locale-&gt;maketext( 'Read the [asis,cpanel.config] file [output,url,_1,documentation] for more information about this file.', 'https://go.cpanel.net/cpconfig' ) . ' ';

    Cpanel::Debug::logger();    # initialize the logger
    local $Cpanel::Logger::ENABLE_BACKTRACE = 0;

    foreach my $chunk (@to_log) {
        chomp $chunk;
        Cpanel::Debug::log_warn($chunk);
    }

    _icontact( \%critical_values );

    $locale-&gt;set_context($prev);

    return;
}

sub _icontact {
    my $critical_values = shift;

    Cpanel::LoadModule::load_perl_module(&quot;Cpanel::iContact::Class::Config::CpConfGuard&quot;);
    Cpanel::LoadModule::load_perl_module('Cpanel::Notify');
    'Cpanel::Notify'-&gt;can('notification_class')-&gt;(
        'class'            =&gt; 'Config::CpConfGuard',
        'application'      =&gt; 'Config::CpConfGuard',
        'constructor_args' =&gt; [
            'origin'          =&gt; 'cpanel.config',
            'critical_values' =&gt; $critical_values,
        ]
    );

    return;
}

sub save {
    my ( $self, %opts ) = @_;

    _verify_called_as_object_method($self);

    return unless ( $self-&gt;{'use_lock'} );

    return if ( $] &gt; 5.007 &amp;&amp; $] &lt; 5.014 );

    return 1 if $Cpanel::Config::CpConfGuard::memory_only;

    if ( !$self-&gt;{'rw'} ) {
        Cpanel::LoadModule::load_perl_module('Cpanel::SafeFile');
        $self-&gt;{'fh'} = 'Cpanel::SafeFile'-&gt;can('safereopen')-&gt;( $self-&gt;{'fh'}, '+&gt;', $Cpanel::ConfigFiles::cpanel_config_file );
        return $self-&gt;abort('Cannot reopen file for rw') unless $self-&gt;{'fh'};
        $self-&gt;{'rw'} = 1;
    }

    return $self-&gt;abort('Locked in parent, cannot save') if $self-&gt;{'pid'} != $$;
    return $self-&gt;abort('hash reference required')       if !UNIVERSAL::isa( $self-&gt;{'data'}, 'HASH' );

    Cpanel::LoadModule::load_perl_module('Cpanel::Config::FlushConfig');
    Cpanel::LoadModule::load_perl_module('Cpanel::Config::SaveCpConf');

    'Cpanel::Config::FlushConfig'-&gt;can('flushConfig')-&gt;(
        $self-&gt;{'fh'},
        $self-&gt;{'data'},
        '=',
        'Cpanel::Config::SaveCpConf'-&gt;can('header_message')-&gt;(),
        {
            sort  =&gt; 1,
            perms =&gt; $FILESYS_PERMS,
        },
    );


    %{$Cpanel::Config::CpConfGuard::MEM_CACHE} = %{ $self-&gt;{'data'} };

    return 1 if $opts{keep_lock};

    $self-&gt;release_lock;

    return 1;
}

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

    _verify_called_as_object_method($self);

    return 0 if Cpanel::Config::CpConfGuard::_cache_is_valid() &amp;&amp; $self-&gt;{'cache_is_valid'};    # Don't re-write the file if it looks correct.

    $Cpanel::Config::CpConfGuard::MEM_CACHE_CPANEL_CONFIG_MTIME = ( stat($Cpanel::ConfigFiles::cpanel_config_file) )[9] || 0;

    return unless $self-&gt;{'use_lock'};                                                          # never update the cache when not root


    local $@;

    my $ok = eval { Cpanel::FileUtils::Write::JSON::Lazy::write_file( $Cpanel::ConfigFiles::cpanel_config_cache_file, $Cpanel::Config::CpConfGuard::MEM_CACHE, $FILESYS_PERMS ) || 0 };

    if ( !$ok ) {

        if ( !defined $ok ) {
            Cpanel::Debug::log_warn(&quot;Cannot update cache file: $Cpanel::ConfigFiles::cpanel_config_cache_file $@&quot;);

            unlink $Cpanel::ConfigFiles::cpanel_config_cache_file;
            return -1;
        }

        return;
    }

    my $past = ( stat($Cpanel::ConfigFiles::cpanel_config_cache_file) )[9] - 1;

    return _adjust_timestamp_for( $Cpanel::ConfigFiles::cpanel_config_file =&gt; $past );
}

sub _adjust_timestamp_for {
    my ( $f, $time ) = @_;

    return unless defined $f &amp;&amp; defined $time;

    return 1 if utime( $time, $time, $f );

    my ( $sec, $min, $hour, $mday, $mon, $year, $wday, $yday, $isdst ) = localtime($time);
    my $stamp = sprintf( &quot;%04d%02d%02d%02d%02d.%02d&quot;, $year + 1900, $mon + 1, $mday, $hour, $min, $sec );

    unless ( _touch( $f =&gt; $stamp ) ) {
        Cpanel::Debug::log_warn(&quot;Cannot update mtime on $f: $@&quot;);
        return;
    }

    return 1;
}

sub _touch {    # mainly created to easily mock that part during the tests
    my ( $f, $stamp ) = @_;
    return system( 'touch', '-t', $stamp, $f ) == 0 ? 1 : 0;
}

sub _verify_called_as_object_method {
    if ( ref( $_[0] ) ne &quot;Cpanel::Config::CpConfGuard&quot; ) {
        die '' . ( caller(0) )[3] . &quot; was not called as an object method [&quot; . ref( $_[0] ) . &quot;]\n&quot;;
    }
    return;
}

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

    _verify_called_as_object_method($self);

    if ( $self-&gt;{'pid'} != $$ ) {
        Cpanel::Debug::log_die('Locked in parent, cannot release lock');
        return;
    }

    $self-&gt;release_lock();

    Cpanel::Debug::log_die($msg) if $msg;


    return 1;
}

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

    _verify_called_as_object_method($self);

    return unless defined $k;

    my $config = $self-&gt;{'data'};

    $config-&gt;{$k} = $v;

    if ( $config-&gt;{'tweak_unset_vars'} &amp;&amp; index( $config-&gt;{'tweak_unset_vars'}, $k ) &gt; -1 ) {
        my %unset = map { ( $_ =&gt; 1 ) } split( /\s*,\s*/, $config-&gt;{'tweak_unset_vars'} );
        delete( $unset{$k} );
        $config-&gt;{'tweak_unset_vars'} = join( ',', sort keys %unset );
    }

    return 1;
}

1;

} # --- END Cpanel/Config/CpConfGuard/CORE.pm


{ # --- BEGIN Cpanel/Config/CpConfGuard.pm
package Cpanel::Config::CpConfGuard;


use strict;
use warnings;

# use Cpanel::JSON::FailOK ();
# use Cpanel::ConfigFiles  ();

# use Cpanel::Debug    ();
# use Cpanel::Destruct ();

use constant {
    _ENOENT =&gt; 2,
};

our $IN_LOAD                     = 0;
our $SENDING_MISSING_FILE_NOTICE = 0;

my $FILESYS_PERMS = 0644;

my $is_daemon;

BEGIN {
    $is_daemon = 0;    # initialize the value in the begin block
    if (   index( $0, 'updatenow' ) &gt; -1
        || index( $0, 'cpsrvd' ) &gt; -1
        || index( $0, 'cpdavd' ) &gt; -1
        || index( $0, 'queueprocd' ) &gt; -1
        || index( $0, 'tailwatchd' ) &gt; -1
        || index( $0, 'cpanellogd' ) &gt; -1
        || ( length $0 &gt; 7 &amp;&amp; substr( $0, -7 ) eq '.static' ) ) {
        $is_daemon = 1;
    }
}

my $module_file;

our ( $MEM_CACHE_CPANEL_CONFIG_MTIME, $MEM_CACHE ) = ( 0, undef );

our $memory_only;

sub _is_daemon { $is_daemon };    # for testing

sub clearcache {
    $MEM_CACHE_CPANEL_CONFIG_MTIME = 0;
    $MEM_CACHE                     = undef;
    return;
}

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

    Cpanel::JSON::FailOK::LoadJSONModule() if !$is_daemon &amp;&amp; !$INC{'Cpanel/JSON.pm'};

    my $self = bless {
        %opts,    # to be improved
        'path'     =&gt; $Cpanel::ConfigFiles::cpanel_config_file,
        'pid'      =&gt; $$,
        'modified' =&gt; 0,
        'changes'  =&gt; {},
    }, $class;

    $self-&gt;{'use_lock'} //= ( $&gt; == 0 ) ? 1 : 0;

    if ($memory_only) {
        $self-&gt;{'data'} = ref($memory_only) eq 'HASH' ? $memory_only : {};
        return $self;
    }

    ( $self-&gt;{'cache'}, $self-&gt;{'cache_is_valid'} ) = get_cache();

    return $self if $self-&gt;{'loadcpconf'} &amp;&amp; $self-&gt;{'cache_is_valid'};

    $self-&gt;load_cpconf_file();

    return $self if $is_daemon || $opts{'no_validate'} || !$self-&gt;{'use_lock'};

    $self-&gt;find_missing_keys();
    $self-&gt;validate_keys();
    $self-&gt;notify_and_save_if_changed();

    return $self;
}

sub set {
    require Cpanel::Config::CpConfGuard::CORE;
    goto \&amp;Cpanel::Config::CpConfGuard::CORE::set;
}

sub config_copy {
    my ($self) = @_;
    _verify_called_as_object_method($self);

    my $config = $self-&gt;{'data'} || $self-&gt;{'cache'} || {};
    return {%$config};
}

sub find_missing_keys {
    require Cpanel::Config::CpConfGuard::CORE;
    goto \&amp;Cpanel::Config::CpConfGuard::CORE::find_missing_keys;
}

sub validate_keys {
    require Cpanel::Config::CpConfGuard::CORE;
    goto \&amp;Cpanel::Config::CpConfGuard::CORE::validate_keys;
}

sub notify_and_save_if_changed {
    require Cpanel::Config::CpConfGuard::CORE;
    goto \&amp;Cpanel::Config::CpConfGuard::CORE::notify_and_save_if_changed;
}

sub log_missing_values {
    require Cpanel::Config::CpConfGuard::CORE;
    goto \&amp;Cpanel::Config::CpConfGuard::CORE::log_missing_values;
}

sub notify_missing_file {
    require Cpanel::Config::CpConfGuard::CORE;
    goto \&amp;Cpanel::Config::CpConfGuard::CORE::notify_missing_file;
}

sub save {
    require Cpanel::Config::CpConfGuard::CORE;
    goto \&amp;Cpanel::Config::CpConfGuard::CORE::save;
}

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

    _verify_called_as_object_method($self);

    return unless $self-&gt;{'use_lock'} &amp;&amp; defined $self-&gt;{'pid'} &amp;&amp; $self-&gt;{'pid'} eq $$ &amp;&amp; $self-&gt;{'lock'};

    require Cpanel::SafeFile;
    Cpanel::SafeFile::safeclose( $self-&gt;{'fh'}, $self-&gt;{'lock'}, sub { return $self-&gt;_update_cache() } );

    $self-&gt;{'fh'}        = $self-&gt;{'lock'} = undef;
    $self-&gt;{'is_locked'} = 0;

    return;
}

sub abort {
    require Cpanel::Config::CpConfGuard::CORE;
    goto \&amp;Cpanel::Config::CpConfGuard::CORE::abort;
}

sub _update_cache {
    require Cpanel::Config::CpConfGuard::CORE;
    goto \&amp;Cpanel::Config::CpConfGuard::CORE::_update_cache;
}

sub _server_locale {
    require Cpanel::Config::CpConfGuard::CORE;
    goto \&amp;Cpanel::Config::CpConfGuard::CORE::_server_locale;
}

sub get_cache {

    my $cpanel_config_mtime = ( stat($Cpanel::ConfigFiles::cpanel_config_file) )[9] || 0;

    my $verbose = ( defined $Cpanel::Debug::level ? $Cpanel::Debug::level : 0 ) &gt;= 5;

    if ( $MEM_CACHE &amp;&amp; ref($MEM_CACHE) eq 'HASH' &amp;&amp; $cpanel_config_mtime &amp;&amp; $cpanel_config_mtime == $MEM_CACHE_CPANEL_CONFIG_MTIME ) {
        Cpanel::Debug::log_info(&quot;loadcpconf memory cache hit&quot;) if $verbose;

        return ( $MEM_CACHE, 1 );
    }

    clearcache();    # Invalidate the memory cache.

    Cpanel::Debug::log_info(&quot;loadcpconf memory cache miss&quot;) if $verbose;

    my $mtime_before_read;

    if ( !$INC{'Cpanel/JSON.pm'} ) {
        Cpanel::Debug::log_info(&quot;Cpanel::JSON not loaded. Skipping cache load.&quot;) if $verbose;
        return ( undef, 0 );
    }
    elsif ( -e $Cpanel::ConfigFiles::cpanel_config_cache_file ) {    # No need to do -r (costs 5 additional syscalls) since we write this 0644
        $mtime_before_read = ( stat _ )[9] || 0;
    }
    else {
        Cpanel::Debug::log_info(&quot;The cache file “$Cpanel::ConfigFiles::cpanel_config_cache_file” could not be read. Skipping cache load.&quot;) if $verbose;
        return ( undef, 0 );
    }

    my ( $mtime_after_read, $cpconf_ref ) = (0);

    my $loop_count = 0;
    while ( $mtime_after_read != $mtime_before_read &amp;&amp; $loop_count++ &lt; 10 ) {
        sleep 1 if ( $mtime_after_read == time );    # If it was just written to, give it a second in case it's being written to.

        Cpanel::Debug::log_info( &quot;loadcpconf cache_filesys_mtime = $mtime_before_read , filesys_mtime: $cpanel_config_mtime , memory_mtime: $MEM_CACHE_CPANEL_CONFIG_MTIME , now: &quot; . time ) if $verbose;

        $cpconf_ref       = Cpanel::JSON::FailOK::LoadFile($Cpanel::ConfigFiles::cpanel_config_cache_file);
        $mtime_after_read = ( stat($Cpanel::ConfigFiles::cpanel_config_cache_file) )[9] || 0;

        sleep 1 if ( $mtime_after_read != $mtime_before_read );
    }

    if ( $cpconf_ref &amp;&amp; scalar keys %{$cpconf_ref} ) {
        if ( _cache_is_valid( $cpanel_config_mtime, $mtime_after_read ) ) {
            Cpanel::Debug::log_info(&quot;loadcpconf file system cache hit&quot;) if $verbose;

            ( $MEM_CACHE, $MEM_CACHE_CPANEL_CONFIG_MTIME ) = ( $cpconf_ref, $cpanel_config_mtime );
            return ( $cpconf_ref, 1 );
        }
        Cpanel::Debug::log_info(&quot;loadcpconf cpanel.config.cache miss.&quot;) if $verbose;
        return ( $cpconf_ref, 0 );
    }

    Cpanel::Debug::log_info(&quot;loadcpconf cpanel.config.cache miss.&quot;) if $verbose;
    return ( undef, 0 );
}

sub _cache_is_valid {
    my ( $config_mtime, $cache_mtime ) = @_;

    $cache_mtime ||= ( stat($Cpanel::ConfigFiles::cpanel_config_cache_file) )[9] || 0;
    return 0 unless $cache_mtime;

    $config_mtime ||= ( stat($Cpanel::ConfigFiles::cpanel_config_file) )[9] || 0;
    return 0 unless $config_mtime;

    return ( $config_mtime + 1 == $cache_mtime ) ? 1 : 0;
}

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

    if ($IN_LOAD) {
        require Cpanel::Carp;
        die Cpanel::Carp::safe_longmess(&quot;Load loop detected&quot;);
    }

    local $IN_LOAD = 1;

    _verify_called_as_object_method($self);

    my $config = {};

    my $config_file = $Cpanel::ConfigFiles::cpanel_config_file;

    $self-&gt;{'is_missing'} = ( -e $config_file ) ? 0 : 1;

    return if ( !$self-&gt;{'use_lock'} &amp;&amp; $self-&gt;{'is_missing'} );    # We can't do anything if the file is missing and we're not root. ABORT!

    if ( $self-&gt;{'use_lock'} &amp;&amp; $self-&gt;{'is_missing'} ) {
        if ( open( my $touch_fh, '&gt;&gt;', $config_file ) ) {
            print {$touch_fh} '';
            close $touch_fh;
            chown 0, 0, $config_file;    # avoid pulling in Cpanel::PwCache for memory reasons
            chmod 0644, $config_file;
        }
    }

    $self-&gt;{'rw'} = 0;
    $self-&gt;{'rw'} = 1 if ( $self-&gt;{'use_lock'} &amp;&amp; !$self-&gt;{'cache_is_valid'} );

    require Cpanel::Config::LoadConfig;
    my ( $ref, $fh, $conflock, $err ) = Cpanel::Config::LoadConfig::loadConfig(
        $Cpanel::ConfigFiles::cpanel_config_file,
        $config,

        (undef) x 4,
        {
            'keep_locked_open'   =&gt; !!$self-&gt;{'use_lock'},
            'nocache'            =&gt; 1,
            'rw'                 =&gt; $self-&gt;{'rw'},
            'allow_undef_values' =&gt; 1,
        },
    );

    if ( !$ref &amp;&amp; !$fh &amp;&amp; $! != _ENOENT() ) {
        $err ||= '(unknown error)';
        require Cpanel::Carp;
        die Cpanel::Carp::safe_longmess(&quot;Can’t read “$Cpanel::ConfigFiles::cpanel_config_file” ($err)&quot;);
    }

    $self-&gt;{'fh'}   = $fh;
    $self-&gt;{'lock'} = $conflock;
    $self-&gt;{'data'} = $config;

    if ( $self-&gt;{'use_lock'} ) {
        Cpanel::Debug::log_warn(&quot;Failed to establish lock on $Cpanel::ConfigFiles::cpanel_config_file&quot;) unless $self-&gt;{'lock'};

        Cpanel::Debug::log_warn(&quot;Failed to get file handle for $Cpanel::ConfigFiles::cpanel_config_file&quot;) unless $self-&gt;{'fh'};
    }

    $self-&gt;{'is_locked'} = defined $self-&gt;{'lock'} ? 1 : 0;    # alias for external usage

    if ( !$MEM_CACHE ) {
        $MEM_CACHE  = {};
        %$MEM_CACHE = %$config;
    }

    return;
}

sub _verify_called_as_object_method {
    if ( ref( $_[0] ) ne __PACKAGE__ ) {
        die '' . ( caller(0) )[3] . &quot; was not called as an object method [&quot; . ref( $_[0] ) . &quot;]\n&quot;;
    }
    return;
}

sub DESTROY {    ## no critic(RequireArgUnpacking)
    return 1 if ( $&gt;     || $memory_only );        # Special modes we don't or won't write to cpanel.config files.
    return 2 if ( !$_[0] || !keys %{ $_[0] } );    # Nothing to cleanup if we're just a blessed empty hash.

    return if !$_[0]-&gt;{'lock'};

    return if Cpanel::Destruct::in_dangerous_global_destruction();

    $_[0]-&gt;release_lock();                         # Close the file so we can update the cache properly.
    return;
}

1;

} # --- END Cpanel/Config/CpConfGuard.pm


{ # --- BEGIN Cpanel/Crypt/GPG/Settings.pm
package Cpanel::Crypt::GPG::Settings;


use strict;

# use Cpanel::Config::CpConfGuard ();
# use Cpanel::Config::Sources     ();
# use Cpanel::Exception           ();

our $RELEASE_VALUE     = 'Release Keyring Only';
our $DEVELOPMENT_VALUE = 'Release and Development Keyrings';
our $OFF_VALUE         = 'Off';

our $OLD_DEVELOPMENT_VALUE = 'Release and Test Keyrings';

our $RELEASE_KEYRINGS     = ['release'];
our $DEVELOPMENT_KEYRINGS = [ 'release', 'development' ];
our $OFF_KEYRINGS         = [];

our $SIG_VALIDATION_CPCONF_KEY = 'signature_validation';

sub signature_validation_enabled {
    my $validation_setting = _load_cpconf_setting($SIG_VALIDATION_CPCONF_KEY);
    return ( $validation_setting eq $OFF_VALUE ) ? 0 : 1;
}

sub default_key_categories {
    my $validation_setting = shift || _load_cpconf_setting($SIG_VALIDATION_CPCONF_KEY);

    if ( $validation_setting eq $OFF_VALUE ) {
        return $OFF_KEYRINGS;
    }
    elsif ( $validation_setting eq $DEVELOPMENT_VALUE ) {
        return $DEVELOPMENT_KEYRINGS;
    }
    elsif ( $validation_setting eq $RELEASE_VALUE ) {
        return $RELEASE_KEYRINGS;
    }
    else {
        die Cpanel::Exception-&gt;create( 'Invalid signature validation setting: [_1]', [$validation_setting] );
    }
}

sub allowed_digest_algorithms {
    return ('sha512');
}

sub _load_cpconf_setting {
    my $setting = shift;

    my $conf = Cpanel::Config::CpConfGuard-&gt;new( 'loadcpconf' =&gt; 1 )-&gt;config_copy;

    if ( $setting eq $SIG_VALIDATION_CPCONF_KEY ) {
        return validation_setting_fixup( $conf-&gt;{$setting} );
    }
    else {
        return $conf-&gt;{$setting};
    }
}

sub validation_setting_fixup {
    my $current_setting = shift;
    if ( defined $current_setting &amp;&amp; $current_setting eq $OLD_DEVELOPMENT_VALUE ) {
        return $DEVELOPMENT_VALUE;
    }
    elsif ( !defined $current_setting || $current_setting !~ /^(?:\Q$OFF_VALUE\E|\Q$RELEASE_VALUE\E|\Q$DEVELOPMENT_VALUE\E)$/ ) {
        return validation_setting_for_configured_mirror();
    }
    return $current_setting;
}

sub validation_setting_for_configured_mirror {
    my $mirror = Cpanel::Config::Sources::loadcpsources();

    if ( $mirror-&gt;{'HTTPUPDATE'} =~ /^(?:.*\.dev|qa-build|next)\.cpanel\.net$/ ) {
        return $DEVELOPMENT_VALUE;
    }
    return $RELEASE_VALUE;
}

1;

} # --- END Cpanel/Crypt/GPG/Settings.pm


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


use strict;
use warnings;

# use Cpanel::Fcntl            ();
# use Cpanel::Fcntl::Constants ();
# use Cpanel::LoadModule       ();
# use Cpanel::Debug            ();

our $VERSION = '1.0';

my $COPY_CHUNK_SIZE = 131072;    #2 ** 17

sub safecopy {    ## no critic qw(Subroutines::ProhibitExcessComplexity)
    my $srcfile    = shift;
    my $destfile   = shift;
    my $normrfcomp = shift || 0;

    if ( !length $srcfile ) {
        Cpanel::Debug::log_warn(&quot;Source not specified for copy.&quot;);
        return 0;
    }
    if ( !length $destfile ) {
        Cpanel::Debug::log_warn(&quot;Destination not specified for copy.&quot;);
        return 0;
    }
    if ( !-r $srcfile &amp;&amp; $srcfile !~ m/\*$/ ) {
        Cpanel::Debug::log_warn(&quot;Unable to read source for copy&quot;);
        return 0;
    }

    my $is_file        = -f $srcfile ? 1 : 0;
    my $srcfileinfo    = q{};
    my $unlinkdestsafe = 1;
    if ($is_file) {    # Logic only for src files (not dirs).
        $srcfileinfo = join( '-', ( stat(_) )[ 0, 1 ] );

        $unlinkdestsafe = 9;
    }

    my $src_lock;
    if ($is_file) {

        local $@;
        require Cpanel::SafeFile;
        $src_lock = eval { Cpanel::SafeFile::safelock_skip_dotlock_if_not_root($srcfile) };
    }

    if ( !exists $INC{'File/Copy/Recursive.pm'} ) {
        Cpanel::LoadModule::lazy_load_module('File::Copy::Recursive');
    }
    if ( !exists $INC{'Cpanel/Umask.pm'} ) {
        Cpanel::LoadModule::lazy_load_module('Cpanel::Umask');
    }

    my $usefilecopyrecursive = ( exists $INC{'File/Copy/Recursive.pm'} &amp;&amp; exists $INC{'Cpanel/Umask.pm'} ) ? 1 : 0;

    if ( !$usefilecopyrecursive ) {
        my $val = system( 'cp', '-rf', $srcfile, $destfile );
        if ($is_file) { Cpanel::SafeFile::safeunlock($src_lock) }
        if ($val) {
            Cpanel::Debug::log_warn(&quot;Problem copying $srcfile to $destfile! : system = $val&quot;);
            return 0;
        }
        return 1;
    }

    if ( $srcfileinfo ne '' &amp;&amp; -f $destfile ) {
        my $destfileinfo = join( '-', ( stat(_) )[ 0, 1 ] );
        if ( $srcfileinfo eq $destfileinfo ) {    # files are the same
            Cpanel::SafeFile::safeunlock($src_lock) if $is_file;
            Cpanel::Debug::log_info(&quot;safecopy for $srcfile -&gt; $destfile skipped. Target exists and has same size and inode number.&quot;);
            return 1;
        }

        if ( $unlinkdestsafe == 9 &amp;&amp; !unlink($destfile) ) {

            $unlinkdestsafe = 0;
        }
        else {

            $unlinkdestsafe = 1;
        }
    }
    else {

        $unlinkdestsafe = 1;
    }

    {
        no warnings;
        $File::Copy::Recursive::RMTrgFil = $unlinkdestsafe;
    }

    if ( !$normrfcomp ) {
        $File::Copy::Recursive::CPRFComp = 1;
    }
    else {
        $File::Copy::Recursive::CPRFComp = 0;
    }

    undef $!;
    my $umask_obj = Cpanel::Umask-&gt;new(077);

    if ( File::Copy::Recursive::rcopy( $srcfile, $destfile ) ) {
        if ( $is_file &amp;&amp; $src_lock ) { Cpanel::SafeFile::safeunlock($src_lock) }
        return 1;
    }
    else {
        my $err_msg;
        my $err_no;

        if ($!) {
            $err_no  = int $!;
            $err_msg = &quot;$!&quot;;
        }

        else {
            $err_no  = 85;
            $err_msg = 'Unknown copy failure';
        }

        if ( $is_file &amp;&amp; $src_lock ) {
            Cpanel::SafeFile::safeunlock($src_lock);
        }

        Cpanel::Debug::log_warn(qq{rcopy('$srcfile', '$destfile') failed: $err_msg});
        $! = $err_no;    ## no critic qw(Variables::RequireLocalizedPunctuationVars)
        return wantarray ? ( 0, $err_msg ) : 0;
    }
}

sub copy {
    my ( $source, $destination ) = @_;

    local $!;

    my ( $rfh, $wfh );

    my ( $i_opened_the_source, $i_opened_the_destination );

    if ( UNIVERSAL::isa( $source, 'GLOB' ) ) {
        if ( !fileno $source ) {
            return ( 0, &quot;The source file handle is not open.&quot; );
        }
        elsif ( fcntl( $source, $Cpanel::Fcntl::Constants::F_GETFL, 0 ) &amp; 1 ) {
            return ( 0, &quot;The source file handle is write-only.&quot; );
        }

        $rfh = $source;
    }
    else {
        $i_opened_the_source = 1;

        open( $rfh, '&lt;', $source ) or do {
            return ( 0, &quot;The system failed to open the file “$source” for reading because of an error: $!&quot; );
        };
    }

    my $buffer;
    read $rfh, $buffer, $COPY_CHUNK_SIZE or do {
        if ( length $! ) {
            return ( 0, &quot;The system failed to read from the file “$source” because of an error: $!&quot; );
        }
    };

    my $mode = ( stat $source )[2] &amp; 07777;

    my $write_lock;

    if ( UNIVERSAL::isa( $destination, 'GLOB' ) ) {
        if ( !fileno $destination ) {
            return ( 0, &quot;The destination file handle is not open.&quot; );
        }
        elsif ( !( fcntl( $destination, $Cpanel::Fcntl::Constants::F_GETFL, 0 ) &amp; 1 ) ) {
            return ( 0, &quot;The destination file handle is read-only.&quot; );
        }

        $wfh = $destination;
    }
    else {
        $i_opened_the_destination = 1;

        local $!;
        local $@;
        require Cpanel::SafeFile;
        $write_lock = eval { Cpanel::SafeFile::safesysopen( $wfh, $destination, Cpanel::Fcntl::or_flags(qw( O_WRONLY O_CREAT )), $mode ) } or do {
            return ( 0, &quot;The system failed to open the file “$destination” for writing because of an error: &quot; . ( $@ || $! ) );
        };
    }

    do {

        print {$wfh} $buffer or do {
            return ( 0, &quot;The system failed to write to the file “$destination” because of an error: $!&quot; );
        };
    } while read $rfh, $buffer, $COPY_CHUNK_SIZE;

    if ($!) {
        return ( 0, &quot;The system failed to read from the file “$source” because of an error: $!&quot; );
    }

    truncate( $wfh, tell($wfh) );
    if ($!) {
        return ( 0, &quot;The system failed to truncate the file “$destination” because of an error: $!&quot; );
    }

    if ($i_opened_the_destination) {
        Cpanel::SafeFile::safeclose( $wfh, $write_lock ) or do {
            return ( 0, &quot;The system failed to close the file “$destination” because of an error: $!&quot; );
        };
    }

    if ($i_opened_the_source) {
        close $rfh or do {
            return ( 0, &quot;The system failed to close the file “$source” because of an error: $!&quot; );
        };
    }

    return 1;
}

1;

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


{ # --- BEGIN Cpanel/FHUtils/Blocking.pm
package Cpanel::FHUtils::Blocking;


use strict;
use warnings;

# use Cpanel::Fcntl::Constants ();
# use Cpanel::Autodie          qw(fcntl);
INIT { Cpanel::Autodie-&gt;import(qw{fcntl}); }

sub set_non_blocking {
    return Cpanel::Autodie::fcntl( $_[0], $Cpanel::Fcntl::Constants::F_SETFL, _get_fl_flags( $_[0] ) | $Cpanel::Fcntl::Constants::O_NONBLOCK ) &amp;&amp; 1;
}

sub set_blocking {
    return Cpanel::Autodie::fcntl( $_[0], $Cpanel::Fcntl::Constants::F_SETFL, _get_fl_flags( $_[0] ) &amp; ~$Cpanel::Fcntl::Constants::O_NONBLOCK ) &amp;&amp; 1;
}

sub is_set_to_block {
    return !( _get_fl_flags( $_[0] ) &amp; $Cpanel::Fcntl::Constants::O_NONBLOCK ) ? 1 : 0;
}

sub _get_fl_flags {

    return int Cpanel::Autodie::fcntl( $_[0], $Cpanel::Fcntl::Constants::F_GETFL, 0 );
}

1;

} # --- END Cpanel/FHUtils/Blocking.pm


{ # --- BEGIN Cpanel/Rand/Get.pm
package Cpanel::Rand::Get;


use strict;

# use Cpanel::FHUtils::Blocking ();
# use Cpanel::FHUtils::Tiny     ();

our $random_source = '/dev/urandom';

our %entropy_pool;

our $getrandom_syscall_is_usable;
my $last_entropy_pool_owner = $$;

my %TR_CODE_CACHE_NUM_ACCEPTABLE;
my %TR_CODE_CACHE_BAD_CHARS;

my $DEFAULT_LENGTH = 10;

my @DEFAULT_CHARACTERS = (
    0 .. 9,
    'A' .. 'Z',
    'a' .. 'z',
    '_',
);

my $_default_want_chars_string;    # a cache

my $DEFAULT_PRELOAD_16TH = 200;

my $MAX_READ_ATTEMPTS = 50;

my $NUMBER_OF_ASCII_CHARS = 256;

my $_EINTR = 4;

my $_ENOSYS = 38;

my $SYS_GETRANDOM = 318;

my $GRND_NONBLOCK = 0x0001;

my $srand_initialized = '';    # Used by _assemble_random_data_collection_without_random_device()

sub getranddata {    ## no critic qw(Subroutines::ProhibitExcessComplexity)
    my ( $bytes_of_random_data_wanted, $my_chars_ar, $preloadcount ) = @_;

    use bytes;       #will go away when we leave this context

    my $pid = $$;
    if ( $last_entropy_pool_owner != $pid ) {
        %entropy_pool            = ();
        $last_entropy_pool_owner = $pid;
    }

    $preloadcount ||= $DEFAULT_PRELOAD_16TH;

    my $bytes_of_data_to_preload_into_entropy_pool = $preloadcount * 16;

    if ($bytes_of_random_data_wanted) {
        if ( $bytes_of_random_data_wanted =~ tr{0-9}{}c ) {
            require Cpanel::Exception;
            die Cpanel::Exception::create( 'InvalidParameter', '“[_1]” is not a valid number of bytes.', [$bytes_of_random_data_wanted] );
        }
    }
    else {
        $bytes_of_random_data_wanted = $DEFAULT_LENGTH;
    }

    my $number_of_acceptable_characters;
    my $want_chars;
    if ( !$my_chars_ar ) {
        $my_chars_ar = \@DEFAULT_CHARACTERS;
        $want_chars  = ( $_default_want_chars_string ||= join( '', @DEFAULT_CHARACTERS ) );
    }

    if ( !ref $my_chars_ar &amp;&amp; $my_chars_ar eq 'binary' ) {
        $number_of_acceptable_characters = $NUMBER_OF_ASCII_CHARS;
        $want_chars                      = '';
    }
    else {
        $number_of_acceptable_characters = scalar @{$my_chars_ar};
        if ( $number_of_acceptable_characters &lt; 1 || $number_of_acceptable_characters &gt; $NUMBER_OF_ASCII_CHARS ) {
            require Cpanel::Exception;
            die Cpanel::Exception::create( 'InvalidParameter', 'The number of desired characters must be at least 1 and at most 256.' );
        }
        $want_chars ||= join( '', @{$my_chars_ar} );
    }
    $entropy_pool{$want_chars} ||= '';
    my $cur_entropy_pool_sr = \$entropy_pool{$want_chars};

    my ( $code_ref_to_remove_chars_above_upper_limit, $code_ref_to_translate_acceptable_chars ) = _generate_random_data_code_refs( $want_chars, $my_chars_ar );

    my ( $dummy, $failed_read_attempts, $rand_chars, $random_data_remaining, $entropy_pool_remaining );

    my $random_data_collected = '';

    my ( $rand_fh, $rand_fh_bitmask );

    my $random_source_is_usable = 1;

    while ( length($random_data_collected) &lt; $bytes_of_random_data_wanted ) {

      READ_FROM_RANDOM_SOURCE:
        while (1) {

            $random_data_remaining = $bytes_of_random_data_wanted - length($random_data_collected);

            last READ_FROM_RANDOM_SOURCE if !$random_source_is_usable;

            last READ_FROM_RANDOM_SOURCE if ( length($$cur_entropy_pool_sr) + length($random_data_collected) ) &gt;= $bytes_of_random_data_wanted;

            $entropy_pool_remaining = $bytes_of_data_to_preload_into_entropy_pool - length($$cur_entropy_pool_sr);

            if ( !defined $getrandom_syscall_is_usable || $getrandom_syscall_is_usable &gt; 0 ) {
                my $rand_count = $entropy_pool_remaining &gt; $random_data_remaining ? $entropy_pool_remaining : $random_data_remaining;

                my $getrandom = _getrandom( $rand_count, \$rand_chars );

                if ( $getrandom == -1 ) {
                    if ( $! == $_EINTR ) {
                        next READ_FROM_RANDOM_SOURCE;
                    }
                    else {

                        $getrandom_syscall_is_usable = 0;

                        if ( $! != $_ENOSYS ) {
                            warn &quot;getrandom() failed: $! - falling back to $random_source&quot;;
                        }
                    }
                }
                else {
                    $getrandom_syscall_is_usable = $getrandom ? 1 : 0;
                }
            }

            if ( !$getrandom_syscall_is_usable ) {
                if ( !$rand_fh ) {
                    if ( open $rand_fh, '&lt;:stdio', $random_source ) {
                        $random_source_is_usable = -c $rand_fh ? 1 : 0;
                        if ($random_source_is_usable) {
                            Cpanel::FHUtils::Blocking::set_non_blocking($rand_fh);
                        }
                        else {
                            warn &quot;“$random_source” is unusable because it is not a character device!&quot;;
                        }
                    }
                    else {
                        warn &quot;Failed to open($random_source): $!&quot;;
                        $random_source_is_usable = 0;
                    }

                    last READ_FROM_RANDOM_SOURCE if !$random_source_is_usable;
                }

                sysread( $rand_fh, $rand_chars, $entropy_pool_remaining &gt; $random_data_remaining ? $entropy_pool_remaining : $random_data_remaining ) or do {
                    if ( ++$failed_read_attempts &gt; $MAX_READ_ATTEMPTS ) {
                        warn &quot;Failed $MAX_READ_ATTEMPTS times to read from “$random_source”! Last failure was: $!&quot;;
                        $random_source_is_usable = 0;
                        last READ_FROM_RANDOM_SOURCE;
                    }

                    $rand_fh_bitmask ||= Cpanel::FHUtils::Tiny::to_bitmask($rand_fh);


                    select( $dummy = $rand_fh_bitmask, undef, undef, 0.0125 );

                    next READ_FROM_RANDOM_SOURCE;
                };
            }

            $code_ref_to_remove_chars_above_upper_limit-&gt;( \$rand_chars ) if $code_ref_to_remove_chars_above_upper_limit;

            $code_ref_to_translate_acceptable_chars-&gt;( \$rand_chars ) if $code_ref_to_translate_acceptable_chars;

            $$cur_entropy_pool_sr .= $rand_chars;
        }

        if ( length $$cur_entropy_pool_sr ) {
            $random_data_collected .= substr( $$cur_entropy_pool_sr, 0, $random_data_remaining, '' );    # just take what we need
        }
        else {
            warn &quot;Using slow randomization logic!&quot;;

            $random_data_collected .= _assemble_random_data_collection_without_random_device(
                $number_of_acceptable_characters == $NUMBER_OF_ASCII_CHARS ? [ map { chr } 0 .. 255 ] : $my_chars_ar,

                $bytes_of_random_data_wanted - length($random_data_collected),
            );
        }
    }

    close($rand_fh) if ref $rand_fh;

    return substr( $random_data_collected, 0, $bytes_of_random_data_wanted );
}

sub _assemble_random_data_collection_without_random_device {
    my ( $my_chars_ar, $bytes_of_random_data_wanted ) = @_;


    my $process_fingerprint = &quot;$&gt;:$&lt;:$):$$&quot;;
    unless ( $srand_initialized eq $process_fingerprint ) {
        $srand_initialized = $process_fingerprint;
        srand();
    }

    my $num_chars = @$my_chars_ar;

    my $random_data_collected = q&lt;&gt;;
    $random_data_collected .= $my_chars_ar-&gt;[ rand $num_chars ] for ( 1 .. $bytes_of_random_data_wanted );

    return $random_data_collected;
}

sub clear_pool {
    %entropy_pool = ();
    return;
}

sub _generate_random_data_code_refs {
    my ( $want_chars, $my_chars_ar ) = @_;

    if ( !ref $my_chars_ar ) {

        return ();
    }

    my ( $code_ref_to_remove_chars_above_upper_limit, $code_ref_to_translate_acceptable_chars );


    my $number_of_acceptable_characters = scalar @$my_chars_ar;
    my ( $last_good_value_hex, $last_good_value );
    my $first_bad_value = $NUMBER_OF_ASCII_CHARS - ( $NUMBER_OF_ASCII_CHARS % $number_of_acceptable_characters );
    if ( $first_bad_value != $NUMBER_OF_ASCII_CHARS ) {

        my $first_bad_value_hex = sprintf( '%02x', $first_bad_value );
        $last_good_value                            = $first_bad_value - 1;
        $last_good_value_hex                        = sprintf( '%02x', $last_good_value );
        $code_ref_to_remove_chars_above_upper_limit = $TR_CODE_CACHE_BAD_CHARS{$first_bad_value_hex} ||= eval 'sub { ${$_[0]} =~ tr/\x' . $first_bad_value_hex . '-\xff//d; }';    ## no critic qw(BuiltinFunctions::ProhibitStringyEval)
    }
    else {
        $last_good_value_hex = 'ff';
        $last_good_value     = 255;
    }

    $code_ref_to_translate_acceptable_chars = $TR_CODE_CACHE_NUM_ACCEPTABLE{$want_chars} ||= eval 'sub { ${$_[0]} =~ tr/\x{0}-\x{' . $last_good_value_hex . '}/' . join( '', map { quotemeta( $my_chars_ar-&gt;[ $_ % $number_of_acceptable_characters ] ) } ( 0 .. $last_good_value ) ) . '/; }';    ## no critic qw(BuiltinFunctions::ProhibitStringyEval)

    return ( $code_ref_to_remove_chars_above_upper_limit, $code_ref_to_translate_acceptable_chars );

}

sub _getrandom {
    my ( $rand_count, $rand_chars_sr ) = @_;
    return syscall( 0 + $SYS_GETRANDOM, ( $$rand_chars_sr = &quot;\0&quot; x $rand_count ), 0 + $rand_count, 0 + $GRND_NONBLOCK );
}
1;

} # --- END Cpanel/Rand/Get.pm


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


use strict;
use warnings;
use Socket        ();
# use Cpanel::Alarm ();

our $VERSION = '1.3';

sub resolveIpAddress {
    my ( $host, %p_options ) = @_;

    return if !$host;

    my $timeout = defined $p_options{'timeout'} &amp;&amp; length $p_options{'timeout'} ? $p_options{'timeout'} : undef;

    do { require Carp; Carp::croak(&quot;no ipv6 support on perl &lt; 5.14: $]&quot;) }
      if $p_options{'ipv6'} &amp;&amp; $] &lt; 5.014;

    my @trueaddresses;
    my $alarm;
    my @type = $p_options{'any_proto'} ? () : $p_options{'ipv6'} ? Socket::AF_INET6() : Socket::AF_INET();

    eval {
        $alarm = Cpanel::Alarm-&gt;new( $timeout, sub { local $SIG{'__DIE__'}; die; } )
          if $timeout;    # this is not a fatal event so we shouldn't log the die.
        my %seen;
        my @addresses;
        if ( $] &lt; 5.014 ) {
            @addresses = gethostbyname($host);
        }
        else {
            @addresses = Socket::getaddrinfo( $host, @type );
        }
        foreach my $r ( reverse @addresses ) {
            last if !$r;
            my $address;
            if ( ref($r) ne ref( {} ) ) {
                $address = Socket::inet_ntoa($r);
            }
            elsif ( $r-&gt;{'family'} == Socket::AF_INET6() ) {
                next if !$p_options{'ipv6'} &amp;&amp; !$p_options{'any_proto'};
                $address = Socket::inet_ntop( $r-&gt;{'family'}, ( Socket::unpack_sockaddr_in6( $r-&gt;{'addr'} ) )[1] );
            }
            elsif ( $r-&gt;{'family'} == Socket::AF_INET ) {
                next if $p_options{'ipv6'} &amp;&amp; !$p_options{'any_proto'};
                $address = Socket::inet_ntop( $r-&gt;{'family'}, ( Socket::unpack_sockaddr_in( $r-&gt;{'addr'} ) )[1] );
            }
            next if exists $seen{$address};
            push @trueaddresses, $address;
            $seen{$address} = 1;
        }
    };

    undef $alarm;

    if ( $#trueaddresses == -1 ) {
        return wantarray ? @trueaddresses : 0;
    }
    else {
        return wantarray ? @trueaddresses : $trueaddresses[0];
    }
}

*_resolveIpAddress = \&amp;resolveIpAddress;

1;

} # --- END Cpanel/SocketIP.pm


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


sub parse {
    my $url = shift;
    return {} if !$url;

    my ( $host, $uri ) = ( split m{/+}, $url, 3 )[ 1, 2 ];
    $uri = '/' . ( $uri || '' );
    $uri =~ s{[^/]+/+\.\./}{}g;
    $uri =~ s/\.\.//g;
    my ($filename) = $uri =~ m{/([^/]+)$};

    return { 'file' =&gt; $filename, 'host' =&gt; $host, 'uri' =&gt; $uri };
}

1;

} # --- END Cpanel/URL.pm


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


use strict;
# use Cpanel::Debug ();

sub urltofile {
    my ($url) = @_;
    my (@URL) = split( /\//, $url );
    return ( $URL[$#URL] );
}

sub buildurlfromuri {
    my ( $rHOSTS, $uri ) = @_;
    if ( substr( $uri, 0, 1 ) ne '/' ) { $uri = '/' . $uri; }
    my (@URLS);
    foreach my $host ( @{$rHOSTS} ) {
        push @URLS, 'http://' . $host . $uri;
    }
    return wantarray ? @URLS : \@URLS;
}

sub extracthosts {
    my ($rURLS) = @_;
    my @HOSTS;
    foreach my $url ( @{$rURLS} ) {
        if ( $url =~ m/https?\:\/\/([^\/]+)\// ) {
            push @HOSTS, $1;
        }
        else {
            Cpanel::Debug::log_warn( 'Invalid URL: ' . $url );
        }
    }
    return wantarray ? @HOSTS : \@HOSTS;
}

sub extract_host_uri {
    my ($url) = @_;
    if ( $url =~ m/https?\:\/\/([^\/]+)(\/.*)/ ) {
        return ( $1, $2 );
    }
    else {
        Cpanel::Debug::log_warn( 'Invalid URL: ' . $url );
    }

    return;
}

1;

} # --- END Cpanel/UrlTools.pm


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


# use Cpanel::SV ();

my ( $cached_datastore_myuid, $cached_datastore_dir );

sub destroy {
    my %OPTS       = @_;
    my $cache_file = _get_datastore_filename( $OPTS{'name'}, ( $OPTS{'args'} ? @{ $OPTS{'args'} } : () ) );
    if ( -e $cache_file ) {
        return unlink $cache_file;
    }
    else {
        return 1;
    }
    return;
}

*get_datastore_filename = *_get_datastore_filename;

sub _get_datastore_filename {
    my ( $bin, @args ) = @_;

    my $file = join( '_', $bin, @args );
    $file =~ tr{/}{_};
    Cpanel::SV::untaint($file);

    my $datastore_dir = _get_datastore_dir($file);
    Cpanel::SV::untaint($datastore_dir);

    return $datastore_dir . '/' . $file;
}

sub _get_datastore_dir {
    my $file  = shift;
    my $myuid = $&gt;;

    if ( defined $cached_datastore_dir &amp;&amp; length $cached_datastore_dir &gt; 1 &amp;&amp; $myuid == $cached_datastore_myuid ) {
        my $homedir = Cpanel::PwCache::gethomedir();
        $cached_datastore_dir = &quot;$homedir/$ENV{'TEAM_USER'}/.cpanel/datastore&quot; if $ENV{'TEAM_USER'} &amp;&amp; $file =~ /^AVAILABLE_APPLICATIONS_CACHE/;
        return $cached_datastore_dir;
    }

    require Cpanel::PwCache;
    $cached_datastore_dir = Cpanel::SV::untaint( Cpanel::PwCache::gethomedir() );
    $cached_datastore_dir .= &quot;/$ENV{'TEAM_USER'}&quot; if $ENV{'TEAM_USER'} &amp;&amp; $file =~ /^AVAILABLE_APPLICATIONS_CACHE/;

    if ( !-e $cached_datastore_dir . '/.cpanel/datastore' &amp;&amp; $cached_datastore_dir ne '/' ) {    # nobody's homedir is /
        require Cpanel::SafeDir::MK;
        Cpanel::SafeDir::MK::safemkdir( &quot;$cached_datastore_dir/.cpanel/datastore&quot;, 0700 ) or warn &quot;Failed to mkdir($cached_datastore_dir/.cpanel/datastore): $!&quot;;
    }

    $cached_datastore_myuid = $myuid;
    $cached_datastore_dir .= '/.cpanel/datastore';
    return $cached_datastore_dir;
}

sub invalidate_cache {
    my $ds_file = get_datastore_filename(@_);
    unlink $ds_file;
    return $ds_file;
}

sub clearcache {
    $cached_datastore_dir   = undef;
    $cached_datastore_myuid = undef;
    return;
}

1;

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


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


use strict;
use warnings;

# use IO::Socket::SSL::PublicSuffix();
our @ISA;
BEGIN { push @ISA, qw(IO::Socket::SSL::PublicSuffix); }

# use Cpanel::AdminBin::Serializer         ();
# use Cpanel::AdminBin::Serializer::FailOK ();
our $VERSION = '1.2';    # must not end in zero for compat

our $public_suffix_db;

BEGIN {
    if ( !$INC{'Mozilla/PublicSuffix.pm'} ) {
        $INC{'Mozilla/PublicSuffix.pm'}       = __FILE__;    ## no critic qw(Variables::RequireLocalizedPunctuationVars)
        *Mozilla::PublicSuffix::public_suffix = sub {
            __PACKAGE__-&gt;get_io_socket_ssl_publicsuffix_handle()-&gt;public_suffix(@_);
        };
    }
}

my %IS_SIMPLE_TLD = (
    com            =&gt; 1,
    net            =&gt; 1,
    org            =&gt; 1,
    info           =&gt; 1,
    cloud          =&gt; 1,
    arpa           =&gt; 1,
    'in-addr.arpa' =&gt; 1,
    'ip6.arpa'     =&gt; 1,
);

sub domain_isa_tld {
    my ($domain) = @_;

    return 1 if ( $domain =~ tr/.// ) == 0;

    return 1 if $IS_SIMPLE_TLD{$domain};

    return 1 if get_io_socket_ssl_publicsuffix_handle()-&gt;public_suffix($domain) eq $domain;

    return 0;
}

sub get_io_socket_ssl_publicsuffix_handle {
    return ( $public_suffix_db ||= bless {}, __PACKAGE__ );
}

sub public_suffix {
    $_[0]-&gt;_ensure_loaded();
    return $_[0]-&gt;SUPER::public_suffix( @_[ 1 .. $#_ ] );
}

sub _ensure_loaded {
    if ( !scalar keys %{ $_[0] } ) {

        require IO::Socket::SSL::PublicSuffix;

        local $@;
        warn if !eval {    # Try::Tiny will clobber $_[0]
            my $db = _load_cached_publicsuffix_db();
            @{ $_[0] }{ keys %$db } = values %$db;
            1;
        };

        if ( scalar keys %{ $_[0] } ) {
            return;
        }

        my $db = IO::Socket::SSL::PublicSuffix-&gt;default();

        die &quot;Cold not load IO::Socket::SSL::PublicSuffix default database&quot; if !$db;

        warn if !eval { _write_cached_publicsuffix_db($db); 1 };

        @{ $_[0] }{ keys %$db } = values %$db;
    }
    return;

}

sub _DATASTORE_FILE {
    require Cpanel::CachedCommand::Utils;
    return Cpanel::CachedCommand::Utils::get_datastore_filename( __PACKAGE__, 'default' );
}

sub _get_publicsuffix_size_mtime {
    if ( $INC{'IO/Socket/SSL/PublicSuffix.pm'} ) {
        return ( stat( $INC{'IO/Socket/SSL/PublicSuffix.pm'} ) )[ 7, 9 ];
    }
    foreach my $path (@INC) {
        my ( $size, $mtime ) = ( stat(&quot;$path/IO/Socket/SSL/PublicSuffix.pm&quot;) )[ 7, 9 ];
        return ( $size, $mtime ) if $size;
    }
    die &quot;Cannot locate: IO/Socket/SSL/PublicSuffix.pm&quot;;
}

sub _load_cached_publicsuffix_db {
    my $datastore_file = _DATASTORE_FILE();
    if ( -e $datastore_file ) {
        my $datastore_mtime = ( stat(_) )[9];
        my ( $public_suffix_size, $public_suffix_mtime ) = _get_publicsuffix_size_mtime();
        return undef if !$public_suffix_size || !$public_suffix_mtime || $public_suffix_mtime &gt; $datastore_mtime;
        my $cache = Cpanel::AdminBin::Serializer::FailOK::LoadFile($datastore_file);
        if ( ref $cache eq 'HASH' &amp;&amp; $cache-&gt;{'VERSION'} &amp;&amp; $cache-&gt;{'size'} &amp;&amp; $cache-&gt;{'VERSION'} == $VERSION &amp;&amp; $cache-&gt;{'size'} == $public_suffix_size ) {
            return $cache-&gt;{'data'};
        }
    }
    return undef;
}

sub _write_cached_publicsuffix_db {
    my ($db) = @_;

    my $datastore_file = _DATASTORE_FILE();

    my ( $public_suffix_size, $public_suffix_mtime ) = _get_publicsuffix_size_mtime();
    my $unblessed = { %{$db} };

    require Cpanel::FileUtils::Write;
    Cpanel::FileUtils::Write::overwrite( $datastore_file, Cpanel::AdminBin::Serializer::Dump( { 'VERSION' =&gt; $VERSION, 'size' =&gt; $public_suffix_size, 'data' =&gt; $unblessed } ), 0640 );

    return 1;
}

sub clear_cache {
    my $datastore_file = _DATASTORE_FILE();
    unlink $datastore_file;
    return;
}

1;

} # --- END Cpanel/PublicSuffix.pm


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


use strict;
use warnings;

# use HTTP::Tiny();
our @ISA;
BEGIN { push @ISA, qw(HTTP::Tiny); }

# use Cpanel::PublicSuffix ();

my $orig_handle_connect = \&amp;HTTP::Tiny::Handle::connect;

our $VERSION = '1.0';

use constant NO_VERIFY_TOUCHFILE_PATH =&gt; '/var/cpanel/no_verify_SSL';

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

    my $connect_timeout = delete $opts{'connect_timeout'};

    my $ssl_opts_hr = $opts{'SSL_options'};
    $ssl_opts_hr &amp;&amp;= {%$ssl_opts_hr};

    $ssl_opts_hr-&gt;{'SSL_verifycn_publicsuffix'} = Cpanel::PublicSuffix::get_io_socket_ssl_publicsuffix_handle();

    my $verify_ssl = 1;

    if ( -f NO_VERIFY_TOUCHFILE_PATH ) {
        $verify_ssl = 0;
    }

    my $self = $class-&gt;SUPER::new(
        'verify_SSL' =&gt; $verify_ssl,
        %opts,
        'SSL_options' =&gt; $ssl_opts_hr,
    );

    $self-&gt;{'connect_timeout'} = $connect_timeout if $connect_timeout;
    return $self;
}

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

    no warnings 'redefine';
    local *HTTP::Tiny::Handle::connect = sub {
        my ( $connect_self, @args ) = @_;
        local $connect_self-&gt;{'timeout'} = $self-&gt;{'connect_timeout'};
        return $orig_handle_connect-&gt;( $connect_self, @args );
      }
      if ( $self-&gt;{'connect_timeout'} );
    use warnings 'redefine';

    return $self-&gt;SUPER::request(@args);

}

1;

} # --- END Cpanel/HTTP/Tiny/FastSSLVerify.pm


{ # --- BEGIN Cpanel/Sync/Common.pm
package Cpanel::Sync::Common;


use strict;

our $BZ_OK;
our $BZ_STREAM_END;
our $hasbzip2 = 0;
eval {
    require Compress::Raw::Bzip2;
    $BZ_OK         = Compress::Raw::Bzip2::BZ_OK();
    $BZ_STREAM_END = Compress::Raw::Bzip2::BZ_STREAM_END();
    $hasbzip2      = 1;
};

our $BZIP2_CONSUME_INPUT    = 1;
our $BZIP2_OVERWRITE_OUTPUT = 0;
our $BZIP2_APPEND_OUTPUT    = 1;

our $LZMA_OK;
our $LZMA_STREAM_END;
our $haslzma = 0;
eval {
    require Compress::Raw::Lzma;
    $LZMA_OK         = Compress::Raw::Lzma::LZMA_OK();
    $LZMA_STREAM_END = Compress::Raw::Lzma::LZMA_STREAM_END();
    $haslzma         = 1;
};

our $cpanelsync_excludes       = '/etc/cpanelsync.exclude';
our $cpanelsync_chmod_excludes = '/etc/cpanelsync.no_chmod';

sub unbzip2 {
    my ($file) = @_;

    die &quot;unbzip2 requires a file&quot; if !length $file;
    lstat($file);

    die &quot;$file is a symlink&quot; if -l _;
    die &quot;$file does not exist&quot; unless -e _;
    die &quot;$file is a directory&quot; if -d _;
    die &quot;$file is not a file&quot;  if !-f_;

    my $outfile = $file;
    $outfile =~ s/\.bz2$//;
    return if ( $outfile eq $file );

    die &quot;cannot decompress $file. $outfile is a directory&quot; if -d $outfile;
    unlink $outfile                                        if -e _;

    if ($hasbzip2) {
        my ( $out_fh, $in_fh );
        open( $out_fh, '&gt;', $outfile ) or die(&quot;cpanelsync: unbzip2: error opening $outfile for writing: $!&quot;);
        open( $in_fh,  '&lt;', $file )    or die(&quot;cpanelsync: unbzip2: error opening $file for reading: $!&quot;);
        my ( $bzip2,  $err ) = Compress::Raw::Bunzip2-&gt;new( $BZIP2_APPEND_OUTPUT, $BZIP2_CONSUME_INPUT );
        my ( $output, $status );
        my $buf = '';

        while ( read( $in_fh, $buf, 65535, length $buf ) ) {    #65535 is about 35% faster then 512
            $status = $bzip2-&gt;bzinflate( $buf, $output );
            if ( $status != $BZ_OK &amp;&amp; $status != $BZ_STREAM_END ) {
                die &quot;Inflation Error: Failed to decompress $file. bzinflate failed with status: $status&quot;;
            }
            print {$out_fh} $output;
            $output = '';
        }
        close($out_fh);
        close($in_fh);
        unlink($file);
    }
    else {
        system( 'bzip2', '-df', $file );
        if ( $? != 0 ) {
            die &quot;Inflation Error: Failed to decompress $file. bzip2 exited with signal: &quot; . ( $? &amp; 127 ) . &quot; and code: &quot; . ( $? &gt;&gt; 8 );
        }
    }
    return 1;
}

sub get_excludes {
    my ($file) = @_;

    return if ( !-e $file || -z _ );

    my @excludes;
    open( EX, '&lt;', $file ) or return;
    while (&lt;EX&gt;) {
        next if m/^\s*$/;
        chomp;
        s!/$!!;
        push @excludes, $_;
    }
    close(EX);

    return @excludes;
}

sub normalize_path {
    my ($path) = @_;
    $path =~ s{/\./}{/}g;
    $path =~ s{//+}{/}g;
    return $path;
}

sub get_digest_from_cache {
    my ( $cache_hr, $file_hr ) = @_;
    return undef if ( !( defined($file_hr) &amp;&amp; defined($cache_hr) ) );

    my $path = normalize_path( $file_hr-&gt;{'path'} );
    return undef if ( !defined( $cache_hr-&gt;{$path} ) );
    return undef if ( !$cache_hr-&gt;{$path}-&gt;{'md5'} );


    for my $field (qw(size mtime)) {
        return undef if ( !defined( $cache_hr-&gt;{$path}-&gt;{$field} ) );
        return undef if ( $cache_hr-&gt;{$path}-&gt;{$field} != $file_hr-&gt;{$field} );
    }


    return $cache_hr-&gt;{$path}-&gt;{'md5'};
}

1;

} # --- END Cpanel/Sync/Common.pm


{ # --- BEGIN Cpanel/URI/Escape/Fast.pm
package Cpanel::URI::Escape::Fast;


use strict;
use warnings;


my %escapes;

BEGIN {
    %escapes = map { chr($_) =&gt; sprintf( '%%%02x', $_ ) } ( 0 .. 47, 58 .. 64, 91 .. 94, 96, 123 .. 255 );
}

sub uri_escape {
    return defined $_[0] &amp;&amp; $_[0] =~ tr{A-Za-z0-9_.~-}{}c ? ( $_[0] =~ s/([^A-Za-z0-9\-_\.~])/$escapes{$1}/gr ) : $_[0];
}

1;

} # --- END Cpanel/URI/Escape/Fast.pm


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


use strict;
use warnings;

BEGIN {
    eval {
        local $SIG{'__DIE__'};
        local $ENV{'PERL_URI_XSESCAPE'} = 0;
        require    # Cpanel::Static OK - optional package
          URI::XSEscape;
    };
    if ($@) {
        require Cpanel::URI::Escape::Fast;
        *uri_encode_str = *Cpanel::URI::Escape::Fast::uri_escape;
        *uri_decode_str = *_uri_decode_str_slow;
    }
    else {
        *uri_encode_str = *_uri_encode_str_fast;
        *uri_decode_str = *_uri_decode_str_fast;
    }

}

our $VERSION = '1.2';

our $URI_SAFE_CHARS = 'A-Za-z0-9\-_.!~*';


sub _uri_encode_str_fast {
    return defined $_[0] ? URI::XSEscape::uri_escape( $_[0] . '' ) : undef;    # force . ''  is to force pOK
}

sub _uri_decode_str_slow {
    return defined $_[0] ? ( ( ( $_[0] =~ tr&lt;+&gt;&lt; &gt;r ) =~ s/%([0-9A-Fa-f]{2})/chr(hex($1))/egr ) ) : ();
}

sub _uri_decode_str_fast {
    return defined $_[0] ? URI::XSEscape::uri_unescape( $_[0] =~ tr&lt;+&gt;&lt; &gt;r ) : ();
}

sub uri_decode_str_noform {
    return if !defined $_[0];
    return $_[0] =~ s/%([0-9A-Fa-f]{2})/chr(hex($1))/egr;
}

sub uri_encode_dirstr {
    return join( '/', ( map { uri_encode_str($_) } split( m{/}, shift ) ) );
}

1;

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


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


use strict;
use warnings;

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

1;

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


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


use strict;
use warnings;

our $VERSION      = 1.3;
our $MAX_SIZE     = 1024**2;
our $TIMEOUT      = 5;
our $READ_TIMEOUT = 15;

use Socket               ();
# use Cpanel::UrlTools     ();
# use Cpanel::SocketIP     ();
# use Cpanel::IP::Loopback ();
# use Cpanel::TimeHiRes    ();

sub _setupsocket {
    my ( $self, $host, $addr, $port, $quiet ) = @_;

    if ( exists $self-&gt;{'httpsocket'}
        &amp;&amp; $self-&gt;{'httpsocket'} ) {
        close $self-&gt;{'httpsocket'};
    }

    my $connected = 0;
    eval {
        local $SIG{'__DIE__'} = 'DEFAULT';

        local $SIG{'PIPE'} = local $SIG{'ALRM'} = sub {
            print STDERR &quot;..Timeout on connect..&quot; unless $quiet;
            die;
        };

        alarm $TIMEOUT;

        my $proto = getprotobyname('tcp') || do {
            print &quot;..Cannot resolve protocol tcp..&quot; unless $quiet;
            die;
        };
        socket( $self-&gt;{'httpsocket'}, Socket::AF_INET, Socket::SOCK_STREAM, $proto ) || do {
            print &quot;..Cannot create socket..&quot; unless $quiet;
            die;
        };
        my $iaddr = Socket::inet_aton(&quot;$addr&quot;) || do {
            print &quot;...Unable to translate IP address for host: ${host}...&quot; unless $quiet;
            die;
        };
        $port ||= getservbyname( 'http', 'tcp' ) || do {
            print &quot;..Cannot lookup port for http..&quot; unless $quiet;
            die;
        };
        my $sin = Socket::sockaddr_in( $port, $iaddr ) || do {
            print &quot;..ERROR: $! ..&quot; unless $quiet;
            die;
        };
        connect( $self-&gt;{'httpsocket'}, $sin ) || die &quot;Unable to connect: $!&quot;;
        alarm 0;
        $connected = 1;
    };
    alarm 0;
    return $connected;
}

sub timedrequest {    ## no critic(Subroutines::ProhibitExcessComplexity)  -- Refactoring this function is a project, not a bug fix
    my (%REQ) = @_;

    my $url = $REQ{'url'};
    my ( $host, $uri ) = Cpanel::UrlTools::extract_host_uri($url);
    unless ( $host &amp;&amp; $uri ) {
        print &quot;Unable to extract host and URI from URL: $url\n&quot; if !$REQ{'quiet'};
        return { 'status' =&gt; 0, 'speed' =&gt; 0 };
    }

    my $self = {};
    bless $self, __PACKAGE__;

    my $addr;
    if ( $host =~ m/(\d+\.\d+\.d\+\d+)/ ) {
        $addr = $host;
    }
    else {
        $addr = Cpanel::SocketIP::_resolveIpAddress($host);
        if ( !$addr ) {
            print &quot;Unable to resolve $host. Check /etc/resolv.conf\n&quot; if !$REQ{'quiet'};
            return { 'status' =&gt; 0, 'speed' =&gt; 0 };
        }
    }

    if ( exists $REQ{'nolocal'} &amp;&amp; Cpanel::IP::Loopback::is_loopback($addr) ) {
        return { 'status' =&gt; 0, 'speed' =&gt; 0 };
    }

    if ( !$self-&gt;_setupsocket( $host, $addr, $REQ{'port'}, $REQ{'quiet'} ) ) {
        return { 'status' =&gt; 0, 'speed' =&gt; 0 };
    }

    my $filename;
    my $storef_fh;
    if ( $REQ{'store'} ) {
        if   ( !length $REQ{'filename'} ) { $filename = Cpanel::UrlTools::urltofile($uri); }
        else                              { $filename = $REQ{'filename'}; }
        open( $storef_fh, '&gt;', $filename ) || die &quot;Failed to open “$filename” for writing: $!&quot;;
    }

    my $bytes      = 0;
    my $start_time = Cpanel::TimeHiRes::time();
    my $buffer     = '';
    eval {
        local $SIG{'__DIE__'} = 'DEFAULT';
        local $SIG{'PIPE'}    = local $SIG{'ALRM'} = sub {
            print STDERR '..Timeout on receive..' if !$REQ{'quiet'};
            die;
        };

        alarm($READ_TIMEOUT);    #set alarm to prevent death
        send $self-&gt;{'httpsocket'}, &quot;GET $uri HTTP/1.0\r\nConnection: close\r\nUser-Agent: Cpanel::HttpTimer/$VERSION\r\nHost: $host\r\n\r\n&quot;, 0;
        while ( read( $self-&gt;{'httpsocket'}, $buffer, 131072, length $buffer ) &amp;&amp; length $buffer &lt; $MAX_SIZE ) {
        }
        alarm(0);
    };
    if ($@) {
        print &quot;Error ($@) while fetching url ${url}\n&quot; if !$REQ{'quiet'};
        return { 'status' =&gt; 0, 'speed' =&gt; 0 };

    }
    $bytes = length $buffer;
    my $end_time = Cpanel::TimeHiRes::time();
    my $telap    = ( $end_time - $start_time );
    $telap ||= 0.00001;    #clock drift
    my $bps = sprintf( &quot;%.2f&quot;, ( $bytes / $telap ) );

    my ( $headers, $body ) = split( /\r?\n\r?\n/, $buffer );

    if ( $headers &amp;&amp; ( $headers =~ m/SSL-enabled/ || $headers =~ m/location: https:\/\//i ) ) {

    }
    elsif ( $headers &amp;&amp; $headers =~ /^HTTP\/\S+\s+(\d+)/ ) {
        my $status = $1;
        if ( $status =~ /^([345]\d+)/ ) {
            print &quot;Error ($status) while fetching url ${url}\n&quot; if !$REQ{'quiet'};
            return { 'status' =&gt; 0, 'speed' =&gt; 0 };
        }
    }
    else {
        print &quot;Error (no valid headers) while fetching url ${url}\n&quot; if !$REQ{'quiet'};
        return { 'status' =&gt; 0, 'speed' =&gt; 0 };

    }
    if ( $REQ{'store'} ) {
        print {$storef_fh} $body;
        close($storef_fh);
    }

    if ( $REQ{'return_body'} ) {
        return { 'status' =&gt; 1, 'speed' =&gt; $bps, 'body' =&gt; $body };
    }
    else {
        return { 'status' =&gt; 1, 'speed' =&gt; $bps };
    }
}

1;

} # --- END Cpanel/HttpTimer.pm


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


use strict;

# use Cpanel::HttpTimer ();
use IO::Handle        ();

use Carp ();

our $VERSION = '2.2';

sub remove_mirror {
    my %REQ  = @_;
    my $key  = $REQ{'key'};
    my $addr = $REQ{'addr'};
    $key  =~ s/\///g;
    $addr =~ s/\///g;

    my $homedir = ( getpwuid($&gt;) )[7];
    unlink(&quot;$homedir/.MirrorSearch/$key/pingtimes/$addr&quot;);
    if ( open( my $mspeeds_fh, '+&lt;', &quot;$homedir/.MirrorSearch/$key/mirrors.speeds&quot; ) ) {
        my @mspeeds = grep( !/^\Q$addr\E=/, &lt;$mspeeds_fh&gt; );
        seek( $mspeeds_fh, 0, 0 );
        print {$mspeeds_fh} join( '', @mspeeds );
        truncate( $mspeeds_fh, tell($mspeeds_fh) );
        close($mspeeds_fh);
    }
}

sub findfastest {
    my (%REQ) = @_;

    my $now     = time();
    my $days    = $REQ{'days'};
    my $key     = $REQ{'key'};
    my $count   = $REQ{'count'};
    my @urls    = @{ $REQ{'urls'} };
    my $urllist = join( &quot;\n&quot;, @urls );

    die 'You must specify the number of days to cache a host speed (days)' if ( $days eq '' );
    die 'You must specify a key to use for this host (key)'                if ( $key eq '' );
    die 'You must specify a number of hosts to return (count)'             if ( $count eq '' );
    die 'You must specify an array of urls to try (urls)'                  if ( $urllist eq '' );

    $key =~ s/\///g;

    my %URLS;
    foreach my $url (@urls) {
        if ( $url =~ /(?:ftp|http)\:\/\/([^\/]+)\// ) {
            my $host = $1;
            $URLS{$host} = $url;
        }
        else {
            Carp::confess 'Invalid Url';
        }
    }

    my @GOODURLS = _fetchgoodhosts( $key, $REQ{'port'}, $days, $count, {}, \%URLS, 1, $REQ{'port'} );
    if ( $#GOODURLS &gt;= ( $count - 1 ) ) {

        if ( !$REQ{'quiet'} ) { print &quot;...loaded mirror speeds from cache...&quot;; }
        return @GOODURLS;
    }

    my %PINGTIMES;
    my $homedir = ( getpwuid($&gt;) )[7];

    mkdir $homedir . '/.MirrorSearch',         0700 if !-e $homedir . '/.MirrorSearch';
    mkdir $homedir . '/.MirrorSearch/' . $key, 0700 if !-e $homedir . '/.MirrorSearch/' . $key;

    my $need_pings = 0;
    foreach my $host ( keys %URLS ) {
        my $cache_mtime = ( stat(&quot;$homedir/.MirrorSearch/${key}/pingtimes/${host}&quot;) )[9] || 0;
        next if ( ( $cache_mtime + ( 86400 * $days ) ) &gt; $now );
        $need_pings++;
        $PINGTIMES{$host} = 1000;    #if ping is broken
    }

    if ($need_pings) {
        local $^F = 1000;            #prevent cloexec on pipe
        my $read_fd  = IO::Handle-&gt;new();
        my $write_fd = IO::Handle-&gt;new();
        pipe( $read_fd, $write_fd );
        syswrite( $write_fd, $urllist );
        close($write_fd);

        if ( $REQ{'quiet'} ) {
            require Cpanel::SafeRun::Errors;
            Cpanel::SafeRun::Errors::saferunallerrors( '/usr/local/cpanel/scripts/MirrorSearch_pingtest', $key, $days, fileno $read_fd, $REQ{'port'} );
        }
        else {
            print &quot;Testing connection speed for $key ($need_pings servers)...(using fast method)...&quot;;
            system '/usr/local/cpanel/scripts/MirrorSearch_pingtest', $key, $days, fileno $read_fd, $REQ{'port'};
            print &quot;.Done\n&quot;;
        }
        close($read_fd);
    }

    opendir( PT, &quot;$homedir/.MirrorSearch/${key}/pingtimes&quot; );
    while ( my $pt = readdir(PT) ) {
        next if ( $pt =~ /^\./ );
        open( my $pingtimes_fh, '&lt;', &quot;$homedir/.MirrorSearch/$key/pingtimes/$pt&quot; );
        $PINGTIMES{$pt} = &lt;$pingtimes_fh&gt;;
        chomp $PINGTIMES{$pt};
        close($pingtimes_fh);
    }
    closedir(PT);

    return _fetchgoodhosts( $key, $REQ{'port'}, $days, $count, \%PINGTIMES, \%URLS, 0, $REQ{'quiet'} );
}

sub _fetchgoodhosts {
    my $key       = shift;
    my $port      = shift;
    my $days      = shift;
    my $count     = shift;
    my $PINGTIMES = shift;
    my $URLS      = shift;
    my $cacheonly = shift;
    my $quiet     = shift || 0;

    $key =~ s/\///g;
    my $now = time();
    my %MIRRORSPEED;
    my %MIRRORTIME;
    my @GOODURLS;

    my $homedir = ( getpwuid($&gt;) )[7];
    if ( open my $mirrorspeeds_fh, '&lt;', &quot;$homedir/.MirrorSearch/${key}/mirrors.speeds&quot; ) {
        while (&lt;$mirrorspeeds_fh&gt;) {
            chomp;
            my ( $mirror, $speed, $lastcheck ) = split( /=/, $_ );

            next if ( $lastcheck &lt; ( $now - ( 86400 * $days ) ) );

            $MIRRORTIME{$mirror}  = $lastcheck;
            $MIRRORSPEED{$mirror} = $speed;
        }
        close $mirrorspeeds_fh;
    }
    if ($cacheonly) {
        foreach my $host ( sort { $MIRRORSPEED{$b} &lt;=&gt; $MIRRORSPEED{$a} } keys %MIRRORSPEED ) {
            push( @GOODURLS, $$URLS{$host} ) if $$URLS{$host};
        }
    }
    else {
        my $usable_mirror_count = 0;
        my %URLS_BY_SPEED;
        foreach my $host ( sort { $$PINGTIMES{$a} &lt;=&gt; $$PINGTIMES{$b} } keys %{$PINGTIMES} ) {
            if ( $$URLS{$host} ) {
                if ( !defined $MIRRORSPEED{$host} || $MIRRORSPEED{$host} eq '' ) {
                    print &quot;Ping:$$PINGTIMES{$host} (seconds) &quot; if !$quiet;
                    ( $MIRRORSPEED{$host} ) = _testmirrorspeed( $$URLS{$host}, $quiet, $port );
                    $MIRRORTIME{$host} = $now;
                }

                if ( $MIRRORSPEED{$host} &gt; 1 ) {
                    $URLS_BY_SPEED{ $$URLS{$host} } = $MIRRORSPEED{$host};
                    if ( ++$usable_mirror_count &gt;= $count ) {
                        print &quot;$count usable mirrors located\n&quot; if !$quiet;
                        last;
                    }
                }
            }
        }

        if ( $usable_mirror_count &lt; $count ) { print &quot;...$usable_mirror_count usable mirrors located. (less then expected)...&quot; if !$quiet; }

        @GOODURLS = sort { $URLS_BY_SPEED{$b} &lt;=&gt; $URLS_BY_SPEED{$a} } keys %URLS_BY_SPEED;

        if ($usable_mirror_count) {    # dump the cache so we retry next time around
            if ( open my $mirrorspeeds_fh, '&gt;', &quot;$homedir/.MirrorSearch/${key}/mirrors.speeds&quot; ) {
                foreach my $mirror ( keys %MIRRORSPEED ) {
                    print {$mirrorspeeds_fh} &quot;${mirror}=$MIRRORSPEED{$mirror}=$MIRRORTIME{$mirror}\n&quot;;
                }
                close $mirrorspeeds_fh;
            }
            else {
                warn &quot;Unable to write $homedir/.MirrorSearch/${key}/mirrors.speeds: $!&quot;;
            }
        }
        else {
            unlink(&quot;$homedir/.MirrorSearch/$key/mirrors.speeds&quot;);
        }
    }
    return @GOODURLS;
}

sub _testmirrorspeed {
    my ( $url, $quiet, $port ) = @_;

    my ($host) = $url =~ /(?:ftp|http)\:\/\/([^\/]+)\//;

    Carp::confess( 'Invalid Url : ' . $url ) if !$host;

    print &quot;Testing connection speed to $host using pureperl...&quot; if !$quiet;
    my $RES = Cpanel::HttpTimer::timedrequest( 'url' =&gt; $url, 'port' =&gt; $port, 'nolocal' =&gt; 1, 'quiet' =&gt; 1 );    # fix hang on mirrors pointing to localhost
    if ( !$RES-&gt;{'speed'} ) {
        print &quot;test failed...Done\n&quot; if !$quiet;
        return 0;
    }
    else {
        print &quot;($RES-&gt;{'speed'} bytes/s)...Done\n&quot; if !$quiet;
        return $RES-&gt;{'speed'};
    }
}

1;

} # --- END Cpanel/MirrorSearch.pm


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


use strict;
use warnings;

our @_OVERRIDES;
our $VERBOSE = 1;

use constant {
    PERL_MAJOR        =&gt; 536,
    PERL_LEGACY_MAJOR =&gt; 532,
    PHP_MAJOR         =&gt; 81,
    PHP_LEGACY_MAJOR  =&gt; 74,
    THIRD_PARTY       =&gt; q{/usr/local/cpanel/3rdparty},
};

use constant {
    THIRD_PARTY_BIN        =&gt; THIRD_PARTY . q{/bin},
    CPANEL_PERL            =&gt; THIRD_PARTY . q{/perl/} . PERL_MAJOR(),
    CPANEL_PERL_LEGACY     =&gt; THIRD_PARTY . q{/perl/} . PERL_LEGACY_MAJOR(),
    CPANEL_PHP             =&gt; THIRD_PARTY . q{/php/} . PHP_MAJOR(),
    CPANEL_PHP_LEGACY      =&gt; THIRD_PARTY . q{/php/} . PHP_LEGACY_MAJOR(),
    CPANEL_PHP_UNVERSIONED =&gt; THIRD_PARTY . q{/php/unversioned},
    SYSTEM_BIN             =&gt; q{/usr/bin},
    SYSTEM_SBIN            =&gt; q{/usr/sbin},
    CENTOS6_BIN            =&gt; q{/bin},
    CENTOS6_SBIN           =&gt; q{/sbin},
    LOCAL_BIN              =&gt; q{/usr/local/bin},
};

use constant {
    CPANEL_PERL_BIN       =&gt; CPANEL_PERL . q{/bin},
    CPANEL_PERL_SBIN      =&gt; CPANEL_PERL . q{/sbin},
    CPANEL_PHP_BIN        =&gt; CPANEL_PHP . q{/bin},
    CPANEL_PHP_LEGACY_BIN =&gt; CPANEL_PHP_LEGACY . q{/bin},
};

sub system_bin_locations {
    return {
        'identify' =&gt; SYSTEM_BIN,
        'convert'  =&gt; SYSTEM_BIN,
        'mogrify'  =&gt; SYSTEM_BIN,

        'firewall-cmd' =&gt; SYSTEM_BIN,
        'firewalld'    =&gt; SYSTEM_SBIN,

        'at'                 =&gt; SYSTEM_BIN,
        'atq'                =&gt; SYSTEM_BIN,
        'atrm'               =&gt; SYSTEM_BIN,
        'chattr'             =&gt; SYSTEM_BIN,
        'crontab'            =&gt; SYSTEM_BIN,
        'curl'               =&gt; SYSTEM_BIN,
        'dig'                =&gt; SYSTEM_BIN,
        'doveadm'            =&gt; SYSTEM_BIN,
        'dpkg-query'         =&gt; SYSTEM_BIN,
        'dsync'              =&gt; SYSTEM_BIN,
        'file'               =&gt; SYSTEM_BIN,
        'gcc'                =&gt; SYSTEM_BIN,
        'getfacl'            =&gt; SYSTEM_BIN,
        'gpg'                =&gt; SYSTEM_BIN,
        'gzip'               =&gt; SYSTEM_BIN,
        'host'               =&gt; SYSTEM_BIN,
        'iconv'              =&gt; SYSTEM_BIN,
        'ionice'             =&gt; SYSTEM_BIN,
        'iostat'             =&gt; SYSTEM_BIN,
        'ipcrm'              =&gt; SYSTEM_BIN,
        'ipcs'               =&gt; SYSTEM_BIN,
        'lsattr'             =&gt; SYSTEM_BIN,
        'mysql'              =&gt; SYSTEM_BIN,
        'mysql_config'       =&gt; SYSTEM_BIN,
        'mysql_upgrade'      =&gt; SYSTEM_BIN,
        'mysqladmin'         =&gt; SYSTEM_BIN,
        'mysqlcheck'         =&gt; SYSTEM_BIN,
        'mysqldump'          =&gt; SYSTEM_BIN,
        'nano'               =&gt; SYSTEM_BIN,
        'openssl'            =&gt; SYSTEM_BIN,
        'pdns_control'       =&gt; SYSTEM_BIN,
        'pdnsutil'           =&gt; SYSTEM_BIN,
        'perl'               =&gt; SYSTEM_BIN,
        'python2'            =&gt; THIRD_PARTY_BIN,
        'quota'              =&gt; SYSTEM_BIN,
        'repoquery'          =&gt; SYSTEM_BIN,
        'rsync'              =&gt; SYSTEM_BIN,
        'setfacl'            =&gt; SYSTEM_BIN,
        'ssh-keygen'         =&gt; SYSTEM_BIN,
        'ssh-keyscan'        =&gt; SYSTEM_BIN,
        'strace'             =&gt; SYSTEM_BIN,
        'sudo'               =&gt; SYSTEM_BIN,
        'systemctl'          =&gt; SYSTEM_BIN,
        'tail'               =&gt; SYSTEM_BIN,
        'test'               =&gt; SYSTEM_BIN,
        'unzip'              =&gt; SYSTEM_BIN,
        'vim'                =&gt; SYSTEM_BIN,
        'wall'               =&gt; SYSTEM_BIN,
        'xmlwf'              =&gt; SYSTEM_BIN,
        'yum'                =&gt; SYSTEM_BIN,
        'yum-config-manager' =&gt; SYSTEM_BIN,
        'zip'                =&gt; SYSTEM_BIN,

        'atd'            =&gt; SYSTEM_SBIN,
        'convertquota'   =&gt; SYSTEM_SBIN,
        'edquota'        =&gt; SYSTEM_SBIN,
        'exim'           =&gt; SYSTEM_SBIN,
        'exim_dbmbuild'  =&gt; SYSTEM_SBIN,
        'exim_tidydb'    =&gt; SYSTEM_SBIN,
        'grubby'         =&gt; CENTOS6_SBIN,
        'ifconfig'       =&gt; CENTOS6_SBIN,
        'ip'             =&gt; CENTOS6_SBIN,
        'ip6tables'      =&gt; CENTOS6_SBIN,
        'ip6tables-save' =&gt; CENTOS6_SBIN,
        'iptables'       =&gt; CENTOS6_SBIN,
        'iptables-save'  =&gt; CENTOS6_SBIN,
        'logrotate'      =&gt; SYSTEM_SBIN,
        'losetup'        =&gt; CENTOS6_SBIN,
        'mysqld'         =&gt; SYSTEM_SBIN,
        'named'          =&gt; SYSTEM_SBIN,
        'nft'            =&gt; SYSTEM_SBIN,
        'nscd'           =&gt; SYSTEM_SBIN,
        'pdns_server'    =&gt; SYSTEM_SBIN,
        'quotacheck'     =&gt; CENTOS6_SBIN,
        'quotaoff'       =&gt; CENTOS6_SBIN,
        'quotaon'        =&gt; CENTOS6_SBIN,
        'repquota'       =&gt; SYSTEM_SBIN,
        'rndc-confgen'   =&gt; SYSTEM_SBIN,
        'rsyslogd'       =&gt; CENTOS6_SBIN,
        'service'        =&gt; CENTOS6_SBIN,
        'sshd'           =&gt; SYSTEM_SBIN,

        'pkill' =&gt; SYSTEM_BIN,

        'bash'     =&gt; CENTOS6_BIN,
        'cat'      =&gt; CENTOS6_BIN,
        'cp'       =&gt; CENTOS6_BIN,
        'date'     =&gt; CENTOS6_BIN,
        'dd'       =&gt; CENTOS6_BIN,
        'df'       =&gt; CENTOS6_BIN,
        'echo'     =&gt; CENTOS6_BIN,
        'false'    =&gt; CENTOS6_BIN,
        'grep'     =&gt; CENTOS6_BIN,
        'hostname' =&gt; CENTOS6_BIN,
        'ls'       =&gt; CENTOS6_BIN,
        'mount'    =&gt; CENTOS6_BIN,
        'netstat'  =&gt; CENTOS6_BIN,
        'pwd'      =&gt; CENTOS6_BIN,
        'rm'       =&gt; CENTOS6_BIN,
        'rpm'      =&gt; CENTOS6_BIN,
        'sh'       =&gt; CENTOS6_BIN,
        'su'       =&gt; CENTOS6_BIN,
        'tar'      =&gt; CENTOS6_BIN,
        'true'     =&gt; CENTOS6_BIN,
        'umount'   =&gt; CENTOS6_BIN,
        'zcat'     =&gt; CENTOS6_BIN,

        'rsyslogd'   =&gt; CENTOS6_SBIN,
        'ip6tables'  =&gt; CENTOS6_SBIN,
        'ifconfig'   =&gt; CENTOS6_SBIN,
        'quotaoff'   =&gt; CENTOS6_SBIN,
        'losetup'    =&gt; CENTOS6_SBIN,
        'quotacheck' =&gt; CENTOS6_SBIN,
        'ip'         =&gt; CENTOS6_SBIN,
        'quotaon'    =&gt; CENTOS6_SBIN,
        'iptables'   =&gt; CENTOS6_SBIN,
        'service'    =&gt; CENTOS6_SBIN,
    };
}

sub dynamic_bin_location {
    my $binary = shift
      or die 'dynamic_bin_location($binary)';

    if ( $binary eq 'lsof' ) {
        return -e SYSTEM_BIN() . '/lsof'
          ? SYSTEM_BIN()
          : SYSTEM_SBIN();
    }
    else {
        return;
    }
}

sub thirdparty_binary_locations {
    return {
        %{ _get_thirdparty_binary_locations_static() },
        %{ _get_thirdparty_binary_locations_dynamic() },
    };
}

our %dynamic_vars = (

    'pear'       =&gt; 1,
    'peardev'    =&gt; 1,
    'pecl'       =&gt; 1,
    'phar'       =&gt; 1,
    'php'        =&gt; 1,
    'php-cgi'    =&gt; 1,
    'php-config' =&gt; 1,
    'phpize'     =&gt; 1,
);

our $cached_cleanup;    # Don't do these checks more than once.

sub _remove_server_type_specific_binaries {
    return if $cached_cleanup;
    return $cached_cleanup = 1;
}

sub _get_thirdparty_binary_location {
    my ($binary) = @_;

    _remove_server_type_specific_binaries();

    return ( exists( $dynamic_vars{$binary} ) ) ? _get_thirdparty_binary_locations_dynamic()-&gt;{$binary} : _get_thirdparty_binary_locations_static()-&gt;{$binary};
}

my $php_dir;

sub _get_thirdparty_binary_locations_dynamic {
    if ( !defined($php_dir) ) {
        $php_dir = Cpanel::Binaries::get_php_3rdparty_dir() . &quot;bin&quot;;
    }

    _remove_server_type_specific_binaries();

    return { map { $_ =&gt; $php_dir } keys(%dynamic_vars) };
}

sub _get_thirdparty_binary_locations_static {
    return {
        'spamd'        =&gt; CPANEL_PERL_BIN,
        'spamc'        =&gt; CPANEL_PERL_BIN,
        'spamassassin' =&gt; CPANEL_PERL_BIN,
        'sa-compile'   =&gt; CPANEL_PERL_BIN,
        'sa-learn'     =&gt; CPANEL_PERL_BIN,
        'sa-update'    =&gt; CPANEL_PERL_BIN,

        'clamd'     =&gt; THIRD_PARTY_BIN,
        'clamdscan' =&gt; THIRD_PARTY_BIN,
        'freshclam' =&gt; THIRD_PARTY_BIN,

        'puttygen' =&gt; THIRD_PARTY_BIN,

        'pigz' =&gt; THIRD_PARTY_BIN,


        're2c' =&gt; THIRD_PARTY_BIN,

        'perl'       =&gt; CPANEL_PERL_BIN,
        'perlcc'     =&gt; CPANEL_PERL_BIN,
        'mysqldiff'  =&gt; CPANEL_PERL_BIN,
        'munin-cron' =&gt; CPANEL_PERL_BIN,

        'munin-node'           =&gt; CPANEL_PERL_SBIN,
        'munin-node-configure' =&gt; CPANEL_PERL_SBIN,

        'python' =&gt; THIRD_PARTY_BIN,

        'git'                =&gt; THIRD_PARTY_BIN,
        'git-receive-pack'   =&gt; THIRD_PARTY_BIN,
        'git-shell'          =&gt; THIRD_PARTY_BIN,
        'git-upload-archive' =&gt; THIRD_PARTY_BIN,
        'git-upload-pack'    =&gt; THIRD_PARTY_BIN,

        'imunify360-agent' =&gt; SYSTEM_BIN,

        'wp-toolkit' =&gt; LOCAL_BIN,

        @_OVERRIDES,
    };
}


sub thirdparty_binary_names {
    return {};
}

sub LOG {
    my ($msg) = @_;
    return unless $VERBOSE &amp;&amp; defined $msg;
    print &quot;$msg\n&quot;;
    return;
}

sub optional_binaries {
    return qw/munin-cron munin-node munin-node-configure perlcc/;
}


sub path {
    my $binary = shift or return;

    if ( my $path = _get_thirdparty_binary_location($binary) ) {
        return $path . '/' . $binary;
    }

    my $bin_hash = system_bin_locations();
    if ( $bin_hash-&gt;{$binary} ) {
        return $bin_hash-&gt;{$binary} . '/' . $binary;
    }

    if ( my $dynamic_location = dynamic_bin_location($binary) ) {
        return $dynamic_location . '/' . $binary;
    }

    require Carp;
    Carp::confess(&quot;Unkonwn binary: '$binary', possible typo?&quot;);
}

sub get_prefix {
    my $binary = shift or return;

    my $binloc = _get_thirdparty_binary_location($binary);
    return unless $binloc;
    $binloc =~ s{/bin$}{};
    return $binloc;
}


sub get_php_version {
    my %args = @_;

    my $target_ver = _get_php_ver_only_for_testing('MAJOR');
    if ( !-x CPANEL_PHP_BIN . &quot;/php&quot; ) {
        $target_ver = _get_php_ver_only_for_testing('LEGACY');
    }

    return $target_ver if $args{flat};
    return join '.', split( '', $target_ver, 2 );
}

sub _get_php_ver_only_for_testing {
    return $_[0] eq 'MAJOR' ? PHP_MAJOR : PHP_LEGACY_MAJOR;
}


sub get_php_3rdparty_dir {
    my $ver = Cpanel::Binaries::get_php_version( 'flat' =&gt; 1 );
    return THIRD_PARTY . &quot;/php/$ver/&quot;;
}


sub symlink_into_3rdparty_bin {
    my $bin_loc_hash = thirdparty_binary_locations();
    my $optional     = { map { $_ =&gt; 1 } optional_binaries() };
    my $third_bin    = THIRD_PARTY_BIN;

    my $ok = 1;

    foreach my $binary ( keys %$bin_loc_hash ) {
        next if ( $bin_loc_hash-&gt;{$binary} eq $third_bin );
        next if ( $bin_loc_hash-&gt;{$binary} eq SYSTEM_BIN );

        my $third_bin_names = thirdparty_binary_names();
        my $real_binary     = $third_bin_names-&gt;{$binary};
        $real_binary ||= $binary;
        my $real_location = $bin_loc_hash-&gt;{$binary} . '/' . $real_binary;
        if ( !-e $real_location ) {
            LOG(&quot;WARNING: Unexpectedly missing $binary&quot;) unless $optional-&gt;{$binary};
            next;
        }

        my $third_bin_loc = &quot;$third_bin/$binary&quot;;
        if ( -e $third_bin_loc || -l $third_bin_loc ) {
            my $points_to = readlink($third_bin_loc);
            next if ( $points_to &amp;&amp; $points_to eq $real_location );
            LOG( &quot;Removing $third_bin_loc, which &quot; . ( $points_to ? &quot;unexpectedly pointed to $points_to&quot; : &quot;was not a symlink&quot; ) );
            unlink $third_bin_loc;
        }

        LOG(&quot;Linking $third_bin_loc -&gt; $real_location&quot;);
        $ok = 0 unless symlink( $real_location, $third_bin_loc );
    }

    return $ok;
}


sub binaries_to_symlink_into_system_bin {
    return [qw/git git-receive-pack git-shell git-upload-archive git-upload-pack/];
}


sub symlink_thirdparty_into_system_bin {
    my $ok           = 1;
    my $to_link_ref  = binaries_to_symlink_into_system_bin();
    my $bin_loc_hash = thirdparty_binary_locations();

    foreach my $binary (@$to_link_ref) {
        my $third_bin_loc = SYSTEM_BIN . qq{/$binary};
        my $real_location = $bin_loc_hash-&gt;{$binary} . '/' . $binary;

        if ( !-e $third_bin_loc &amp;&amp; -x $real_location ) {
            LOG(&quot;Linking $third_bin_loc -&gt; $real_location&quot;);
            $ok = 0 unless symlink( $real_location, $third_bin_loc );
        }
    }

    return $ok;
}

1;

} # --- END Cpanel/Binaries.pm


{ # --- BEGIN Cpanel/Crypt/GPG/Base.pm
package Cpanel::Crypt::GPG::Base;


use strict;
use warnings;


# use Cpanel::Binaries  ();
# use Cpanel::Exception ();


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

    $opts_hr = {} if !( $opts_hr &amp;&amp; 'HASH' eq ref $opts_hr );

    my $bin = _find_gpg_or_die();

    my $obj = {
        'bin' =&gt; $bin,
        %{$opts_hr},
    };

    return bless $obj, $class;
}


sub get_gpg_bin {
    my $self = shift;
    return $self-&gt;{bin};
}


sub _find_gpg_or_die {
    my $bin = Cpanel::Binaries::path('gpg');
    -x $bin or die Cpanel::Exception::create( 'Unsupported', 'Only servers with [asis,GPG] support this module.' );
    return $bin;
}

1;

} # --- END Cpanel/Crypt/GPG/Base.pm


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


use strict;
use warnings;

sub DESTROY { }


sub new {

    if ( !length $_[1] ) {
        die 'Must include at least a string!';
    }

    return bless \@_, shift;
}


sub set_json_to_freeze {
    no warnings 'redefine';
    *TO_JSON = \&amp;_to_list_ref;
    return ( __PACKAGE__ . '::_JSON_MODE' )-&gt;new();
}


sub thaw {

    if ( ref( $_[1] ) ne 'ARRAY' ) {
        die &quot;Call thaw() on an ARRAY reference, not “$_[1]”!&quot;;
    }

    return $_[0]-&gt;new( @{ $_[1] }[ 1 .. $#{ $_[1] } ] );
}


sub is_frozen {
    {
        last if ref( $_[1] ) ne 'ARRAY';
        last if !$_[1][0]-&gt;isa( $_[0] );
        last if @{ $_[1] } &lt; 2;

        return 1;
    }

    return 0;
}


sub to_string {
    return _locale()-&gt;makevar( @{ $_[0] } );
}


sub to_en_string {
    return _locale()-&gt;makethis_base( @{ $_[0] } );
}


sub clone_with_args {
    return ( ref $_[0] )-&gt;new(
        $_[0][0],          #the phrase, currently stored in the object
        @_[ 1 .. $#_ ],    #the new args, supplied by the caller
    );
}


sub to_list {

    if ( !wantarray ) {
        require Cpanel::Context;
        Cpanel::Context::must_be_list();
    }

    return @{ $_[0] };
}

*TO_JSON = \&amp;to_string;


my $_locale;

sub _locale {
    return $_locale if $_locale;
    local $@;

    eval 'require Cpanel::Locale;' or do {    ## no critic qw(BuiltinFunctions::ProhibitStringyEval)
        warn &quot;Failed to load Cpanel::Locale; falling back to substitute. Error was: $@&quot;;
    };

    eval { $_locale = Cpanel::Locale-&gt;get_handle() };
    return $_locale || bless {}, 'Cpanel::LocaleString::_Cpanel_Locale_unavailable';
}

sub _put_back {
    no warnings 'redefine';
    *TO_JSON = \&amp;to_string;

    return;
}

sub _to_list_ref {
    return [ ref( $_[0] ), @{ $_[0] } ];
}


package Cpanel::LocaleString::_JSON_MODE;


sub new {
    require Cpanel::Finally;    # PPI USE OK - loaded only when needed
    return $_[0]-&gt;SUPER::new( \&amp;Cpanel::LocaleString::_put_back );
}

package Cpanel::LocaleString::_Cpanel_Locale_unavailable;

BEGIN {
    *Cpanel::LocaleString::_Cpanel_Locale_unavailable::makethis_base = *Cpanel::LocaleString::_Cpanel_Locale_unavailable::makevar;
}

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

    local ( $@, $! );
    require Cpanel::Locale::Utils::Fallback;

    return Cpanel::Locale::Utils::Fallback::interpolate_variables( $str, @maketext_opts );
}

1;

} # --- END Cpanel/LocaleString.pm


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


use strict;

my %_err_name_cache;

sub get_name_for_errno_number {
    my ($number) = @_;

    if ( !$INC{'Errno.pm'} ) {
        local ( $@, $! );
        require Errno;
    }

    die 'need number!' if !length $number;

    if ( !%_err_name_cache ) {

        my $s = scalar keys %Errno::;    # init iterator
        foreach my $k ( sort keys %Errno:: ) {
            if ( Errno-&gt;EXISTS($k) ) {
                my $v = 'Errno'-&gt;can($k)-&gt;();
                $_err_name_cache{$v} = $k;
            }
        }
    }

    return $_err_name_cache{$number};
}

1;

} # --- END Cpanel/Errno.pm


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


use strict;

our $ABRT   = 6;
our $ALRM   = 14;
our $BUS    = 7;
our $CHLD   = 17;
our $CLD    = 17;
our $CONT   = 18;
our $FPE    = 8;
our $HUP    = 1;
our $ILL    = 4;
our $INT    = 2;
our $IO     = 29;
our $IOT    = 6;
our $KILL   = 9;
our $NUM32  = 32;
our $NUM33  = 33;
our $NUM35  = 35;
our $NUM36  = 36;
our $NUM37  = 37;
our $NUM38  = 38;
our $NUM39  = 39;
our $NUM40  = 40;
our $NUM41  = 41;
our $NUM42  = 42;
our $NUM43  = 43;
our $NUM44  = 44;
our $NUM45  = 45;
our $NUM46  = 46;
our $NUM47  = 47;
our $NUM48  = 48;
our $NUM49  = 49;
our $NUM50  = 50;
our $NUM51  = 51;
our $NUM52  = 52;
our $NUM53  = 53;
our $NUM54  = 54;
our $NUM55  = 55;
our $NUM56  = 56;
our $NUM57  = 57;
our $NUM58  = 58;
our $NUM59  = 59;
our $NUM60  = 60;
our $NUM61  = 61;
our $NUM62  = 62;
our $NUM63  = 63;
our $PIPE   = 13;
our $POLL   = 29;
our $PROF   = 27;
our $PWR    = 30;
our $QUIT   = 3;
our $RTMAX  = 64;
our $RTMIN  = 34;
our $SEGV   = 11;
our $STKFLT = 16;
our $STOP   = 19;
our $SYS    = 31;
our $TERM   = 15;
our $TRAP   = 5;
our $TSTP   = 20;
our $TTIN   = 21;
our $TTOU   = 22;
our $UNUSED = 31;
our $URG    = 23;
our $USR1   = 10;
our $USR2   = 12;
our $VTALRM = 26;
our $WINCH  = 28;
our $XCPU   = 24;
our $XFSZ   = 25;
our $ZERO   = 0;

our %SIGNAL_NAME = qw(
  0    ZERO
  1    HUP
  10    USR1
  11    SEGV
  12    USR2
  13    PIPE
  14    ALRM
  15    TERM
  16    STKFLT
  17    CHLD
  18    CONT
  19    STOP
  2    INT
  20    TSTP
  21    TTIN
  22    TTOU
  23    URG
  24    XCPU
  25    XFSZ
  26    VTALRM
  27    PROF
  28    WINCH
  29    IO
  3    QUIT
  30    PWR
  31    SYS
  32    NUM32
  33    NUM33
  34    RTMIN
  35    NUM35
  36    NUM36
  37    NUM37
  38    NUM38
  39    NUM39
  4    ILL
  40    NUM40
  41    NUM41
  42    NUM42
  43    NUM43
  44    NUM44
  45    NUM45
  46    NUM46
  47    NUM47
  48    NUM48
  49    NUM49
  5    TRAP
  50    NUM50
  51    NUM51
  52    NUM52
  53    NUM53
  54    NUM54
  55    NUM55
  56    NUM56
  57    NUM57
  58    NUM58
  59    NUM59
  6    ABRT
  60    NUM60
  61    NUM61
  62    NUM62
  63    NUM63
  64    RTMAX
  7    BUS
  8    FPE
  9    KILL
);

1;

} # --- END Cpanel/Config/Constants/Perl.pm


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


use strict;

# use Cpanel::LocaleString ();
# use Cpanel::Exception    ();


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

    return bless { _CHILD_ERROR =&gt; $CHILD_ERROR, _PROGRAM_NAME =&gt; $PROGRAM_NAME }, $class;
}

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

    return $self-&gt;{'_CHILD_ERROR'};
}

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

    return undef if !$self-&gt;CHILD_ERROR();

    return $self-&gt;CHILD_ERROR() &gt;&gt; 8;
}


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

    my $error_number = $self-&gt;error_code();

    return '' if ( !defined $error_number );    # Can't index a hash with undef

    require Cpanel::Errno;
    return Cpanel::Errno::get_name_for_errno_number($error_number) || q&lt;&gt;;
}

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

    return $self-&gt;CHILD_ERROR() &amp;&amp; ( $self-&gt;CHILD_ERROR() &amp; 128 ) ? 1 : 0;
}

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

    return if !$self-&gt;CHILD_ERROR();

    return $self-&gt;CHILD_ERROR() &amp; 127;
}

sub signal_name {
    my ($self) = @_;
    require Cpanel::Config::Constants::Perl;
    return $Cpanel::Config::Constants::Perl::SIGNAL_NAME{ $self-&gt;signal_code() };
}

sub exec_failed {
    return $_[0]-&gt;{'_exec_failed'} ? 1 : 0;
}

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

    return $self-&gt;{'_PROGRAM_NAME'} || undef;
}

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

    return ( $self-&gt;{'_PROGRAM_NAME'} = $program );
}

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

    return undef if !$self-&gt;CHILD_ERROR();

    my @localized_strings = (
        $self-&gt;error_code() ? $self-&gt;_ERROR_PHRASE() : $self-&gt;_SIGNAL_PHRASE(),
        $self-&gt;_core_dump_for_phrase_if_needed(),
        $self-&gt;_additional_phrases_for_autopsy(),
    );

    return join ' ', map { $_-&gt;to_string() } @localized_strings;
}

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

    my $str;

    if ( $self-&gt;signal_code() ) {
        $str .= 'SIG' . $self-&gt;signal_name() . &quot; (#&quot; . $self-&gt;signal_code() . &quot;)&quot;;
    }
    elsif ( my $code = $self-&gt;error_code() ) {
        $str .= &quot;exit $code&quot;;
    }
    else {
        $str = 'OK';
    }

    if ( $self-&gt;dumped_core() ) {
        $str .= ' (+core)';
    }

    return $str;
}

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

    my $err = $self-&gt;to_exception();
    die $err if $err;

    return $self;
}

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

    if ( $self-&gt;signal_code() ) {
        return Cpanel::Exception::create(
            'ProcessFailed::Signal',
            [
                process_name =&gt; $self-&gt;program(),
                signal_code  =&gt; $self-&gt;signal_code(),
                $self-&gt;_extra_error_args_for_die_if_error(),
            ],
        );
    }

    if ( $self-&gt;error_code() ) {
        return Cpanel::Exception::create(
            'ProcessFailed::Error',
            [
                process_name =&gt; $self-&gt;program(),
                error_code   =&gt; $self-&gt;error_code(),
                $self-&gt;_extra_error_args_for_die_if_error(),
            ],
        );
    }

    return undef;
}

sub _extra_error_args_for_die_if_error { }

sub _additional_phrases_for_autopsy { }

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

    if ( $self-&gt;dumped_core() ) {
        return Cpanel::LocaleString-&gt;new('The process dumped a core file.');
    }

    return;
}


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

    if ( $self-&gt;program() ) {
        return Cpanel::LocaleString-&gt;new( 'The subprocess “[_1]” reported error number [numf,_2] when it ended.', $self-&gt;program(), $self-&gt;error_code() );
    }

    return Cpanel::LocaleString-&gt;new( 'The subprocess reported error number [numf,_1] when it ended.', $self-&gt;error_code() );
}

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

    if ( $self-&gt;program() ) {
        return Cpanel::LocaleString-&gt;new( 'The subprocess “[_1]” ended prematurely because it received the “[_2]” ([_3]) signal.', $self-&gt;program(), $self-&gt;signal_name(), $self-&gt;signal_code() );
    }

    return Cpanel::LocaleString-&gt;new( 'The subprocess ended prematurely because it received the “[_1]” ([_2]) signal.', $self-&gt;signal_name(), $self-&gt;signal_code() );
}


1;

} # --- END Cpanel/ChildErrorStringifier.pm


{ # --- BEGIN Cpanel/FHUtils/OS.pm
package Cpanel::FHUtils::OS;


use strict;
use warnings;


my $fileno;

sub is_os_filehandle {
    local $@;
    $fileno = eval { fileno $_[0] };
    return ( defined $fileno ) &amp;&amp; ( $fileno != -1 );
}

1;

} # --- END Cpanel/FHUtils/OS.pm


{ # --- BEGIN Cpanel/IO/Flush.pm
package Cpanel::IO::Flush;


use strict;
use warnings;


use constant {
    _EAGAIN =&gt; 11,
    _EINTR  =&gt; 4,
};

# use Cpanel::Exception ();
use IO::SigGuard      ();


sub write_all {    ##no critic qw( RequireArgUnpacking )
    my ( $fh, $timeout ) = @_;    # $_[2] = payload

    local ( $!, $^E );

    my $offset = 0;

    {
        my $this_time = IO::SigGuard::syswrite( $fh, $_[2], length( $_[2] ), $offset );
        if ($this_time) {
            $offset += $this_time;
        }
        elsif ( $! == _EAGAIN() ) {
            _wait_until_ready( $fh, $timeout );
        }
        else {
            die Cpanel::Exception::create( 'IO::WriteError', [ error =&gt; $!, length =&gt; length( $_[2] ) - $offset ] );
        }

        redo if $offset &lt; length( $_[2] );
    }

    return;
}

sub _wait_until_ready {
    my ( $fh, $timeout ) = @_;

    my $win;
    vec( $win, fileno($fh), 1 ) = 1;

    my $ready = select( undef, my $wout = $win, undef, $timeout );

    if ( $ready == -1 ) {
        redo if $! == _EINTR();
        die Cpanel::Exception::create( 'IO::SelectError', [ error =&gt; $! ] );
    }
    elsif ( !$ready ) {

        die Cpanel::Exception::create_raw( 'Timeout', 'write timeout!' );
    }

    return;
}

1;

} # --- END Cpanel/IO/Flush.pm


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


use strict;
use warnings;

# use Cpanel::FHUtils::Blocking  ();
# use Cpanel::FHUtils::OS        ();
# use Cpanel::IO::Flush          ();
# use Cpanel::LoadFile::ReadFast ();

my $CHUNK_SIZE = 2 &lt;&lt; 16;

my $DEFAULT_TIMEOUT      = 600;    #10 minutes
my $DEFAULT_READ_TIMEOUT = 0;

sub new {    ## no critic qw(Subroutines::ProhibitExcessComplexity)
    my ( $class, %opts ) = @_;

    my %fh_buffer;
    my %output;

    my @fhs = @{ $opts{'filehandles'} };

    my $read_input  = '';
    my $read_output = '';
    my %fhmap;

    my %is_os_filehandle;

    for my $fh_buf_ar (@fhs) {
        if ( UNIVERSAL::isa( $fh_buf_ar, 'GLOB' ) ) {
            $fh_buf_ar = [$fh_buf_ar];
        }
        elsif ( !UNIVERSAL::isa( $fh_buf_ar, 'ARRAY' ) ) {
            die 'items in “filehandles” must be either a filehandle or ARRAY';
        }

        my $fh = $fh_buf_ar-&gt;[0];

        Cpanel::FHUtils::Blocking::set_non_blocking($fh);

        $fhmap{ fileno($fh) } = $fh;
        vec( $read_input, fileno($fh), 1 ) = 1;

        if ( defined $fh_buf_ar-&gt;[1] &amp;&amp; UNIVERSAL::isa( $fh_buf_ar-&gt;[1], 'SCALAR' ) ) {
            $fh_buffer{$fh} = $fh_buf_ar-&gt;[1];
        }
        else {
            my $buf = q{};
            $fh_buffer{$fh} = \$buf;

            if ( defined $fh_buf_ar-&gt;[1] &amp;&amp; UNIVERSAL::isa( $fh_buf_ar-&gt;[1], 'GLOB' ) ) {
                $output{$fh} = $fh_buf_ar-&gt;[1];

                $is_os_filehandle{$fh} = Cpanel::FHUtils::OS::is_os_filehandle( $fh_buf_ar-&gt;[1] );
            }
            elsif ( defined $fh_buf_ar-&gt;[1] ) {
                die '2nd value in “filehandles” array member must be undef, SCALAR, or GLOB!';
            }
        }
    }

    my $finished;

    my $self = {
        _fh_buffer =&gt; \%fh_buffer,
        _finished  =&gt; 0,
    };

    bless $self, $class;

    my ( $nfound, $select_time_left, $select_timeout );

    my $overall_timeout = defined $opts{'timeout'}      ? $opts{'timeout'}      : $DEFAULT_TIMEOUT;
    my $read_timeout    = defined $opts{'read_timeout'} ? $opts{'read_timeout'} : $DEFAULT_READ_TIMEOUT;

    my $has_overall_timeout = $overall_timeout ? 1 : 0;

    my $overall_time_left = $overall_timeout || undef;

  READ_LOOP:
    while (
        !$finished &amp;&amp;                                          # has not finished
        ( !$has_overall_timeout || $overall_time_left &gt; 0 )    # has not reached overall timeout
    ) {
        $select_timeout = _get_shortest_timeout( $overall_time_left, $read_timeout );

        ( $nfound, $select_time_left ) = select( $read_output = $read_input, undef, undef, $select_timeout );

        if ( !$nfound ) {

            $self-&gt;{'_timed_out'} = ( $select_timeout == $read_timeout ) ? $read_timeout : $overall_timeout;
            last;
        }
        elsif ( $nfound != -1 ) {    # case 47309: If we get -1 it probably means we got interrupted by a signal
            for my $fileno ( grep { vec( $read_output, $_, 1 ) } keys %fhmap ) {
                my $fh = $fhmap{$fileno};

                Cpanel::LoadFile::ReadFast::read_fast( $fh, ${ $fh_buffer{$fh} }, $CHUNK_SIZE, length ${ $fh_buffer{$fh} } ) or do {
                    delete $fhmap{$fileno};

                    $finished = !( scalar keys %fhmap );

                    last READ_LOOP if $finished;

                    vec( $read_input, $fileno, 1 ) = 0;

                    next;
                };

                if ( $output{$fh} ) {
                    my $payload_sr = \substr( ${ $fh_buffer{$fh} }, 0, length ${ $fh_buffer{$fh} }, q&lt;&gt; );

                    if ( $is_os_filehandle{$fh} ) {

                        Cpanel::IO::Flush::write_all( $output{$fh}, $read_timeout, $$payload_sr );
                    }
                    else {

                        print { $output{$fh} } $$payload_sr;
                    }
                }
            }
        }

        $overall_time_left -= ( $select_timeout - $select_time_left ) if $has_overall_timeout;
    }

    delete $fh_buffer{$_} for keys %output;

    %fhmap = ();

    $self-&gt;{'_finished'} = $finished;
    if ( !$finished &amp;&amp; defined $overall_time_left &amp;&amp; $overall_time_left &lt;= 0 ) {

        $self-&gt;{'_timed_out'} = $overall_timeout;
    }

    return $self;
}

sub _get_shortest_timeout {
    my ( $overall_time_left, $read_timeout ) = @_;

    return undef if ( !$overall_time_left &amp;&amp; !$read_timeout );

    return $read_timeout if !defined $overall_time_left;

    return ( !$read_timeout || $overall_time_left &lt;= $read_timeout )
      ?

      $overall_time_left
      :

      $read_timeout;
}

sub get_buffer {
    return $_[0]-&gt;{'_fh_buffer'}{ $_[1] };
}

sub did_finish {
    return $_[0]-&gt;{'_finished'} ? 1 : 0;
}

sub timed_out {
    return defined $_[0]-&gt;{'_timed_out'} ? $_[0]-&gt;{'_timed_out'} : 0;
}

1;

} # --- END Cpanel/ReadMultipleFH.pm


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


use strict;
use warnings;

# use Cpanel::Exception ();

my $DEFAULT_ERROR_CODE = 127;    #EKEYEXPIRED

our $quiet   = 0;
our $no_warn = 0;


sub do_in_child {
    my ( $code, @args ) = @_;

    local ( $!, $^E );
    my $pid = fork();

    die Cpanel::Exception::create( 'IO::ForkError', [ error =&gt; $! ] ) if !defined $pid;

    if ( !$pid ) {
        local $@;

        if ( !eval { $code-&gt;(@args); 1 } ) {
            my $err    = $@;
            my $io_err = 0 + $!;
            _print($err) unless $quiet;
            exit( $io_err || $DEFAULT_ERROR_CODE );
        }

        exit 0;
    }

    return $pid;
}


sub do_in_child_quiet {
    my ( $code, @args ) = @_;
    local $quiet = 1;
    return do_in_child( $code, @args );
}


sub _print {
    my ($msg) = @_;

    warn $msg unless $no_warn;
    print STDERR $msg;

    return;
}

1;

} # --- END Cpanel/ForkAsync.pm


{ # --- BEGIN Cpanel/SafeRun/Object.pm
package Cpanel::SafeRun::Object;


use cPstrict;

# use Cpanel::ChildErrorStringifier();
our @ISA;
BEGIN { push @ISA, qw(Cpanel::ChildErrorStringifier); }

BEGIN {
    eval { require Proc::FastSpawn; };
}

use IO::SigGuard ();

# use Cpanel::Env                ();
# use Cpanel::Exception          ();
# use Cpanel::FHUtils::Autoflush ();
# use Cpanel::FHUtils::OS        ();
# use Cpanel::ReadMultipleFH     ();
# use Cpanel::LoadModule         ();
# use Cpanel::LocaleString       ();

use constant _ENOENT =&gt; 2;

my $CHUNK_SIZE = 2 &lt;&lt; 16;

my $DEFAULT_TIMEOUT      = 3600;    # 1 hour
my $DEFAULT_READ_TIMEOUT = 0;

our $SAFEKILL_TIMEOUT = 1;


my @_allowed_env_vars_cache;

sub new {    ## no critic qw(Subroutines::ProhibitExcessComplexity)
    my ( $class, %OPTS ) = @_;

    die &quot;No “program”!&quot; if !length $OPTS{'program'};

    if ( !defined $OPTS{'timeout'} ) {
        $OPTS{'timeout'} = $DEFAULT_TIMEOUT;
    }

    if ( !defined $OPTS{'read_timeout'} ) {
        $OPTS{'read_timeout'} = $DEFAULT_READ_TIMEOUT;
    }

    if ( $OPTS{'program'} =~ tr{&gt;&lt;*?[]`$()|;&amp;#$\\\r\n\t }{} &amp;&amp; !-e $OPTS{'program'} ) {
        die Cpanel::Exception::create( 'InvalidParameter', 'A value of “[_1]” is invalid for “[_2]” as it does not permit the following characters: “[_3]”', [ $OPTS{'program'}, 'program', '&gt;&lt;*?[]`$()|;&amp;#$\\\\\r\\n\\t' ] );
    }

    my $args_ar = $OPTS{'args'} || [];
    die &quot;“args” must be an arrayref&quot; if defined $args_ar &amp;&amp; ref $args_ar ne 'ARRAY';

    die &quot;Undefined value given as argument! (@$args_ar)&quot; if grep { !defined } @$args_ar;

    my $pump_stdin_filehandle_into_child;

    my ( %parent_read_fh, %child_write_fh );

    my $merge_output_yn = $OPTS{'stdout'} &amp;&amp; $OPTS{'stderr'} &amp;&amp; ( $OPTS{'stdout'} eq $OPTS{'stderr'} );

    local $!;

    for my $handle_name (qw(stdout stderr)) {
        my $custom_fh = $OPTS{$handle_name} &amp;&amp; UNIVERSAL::isa( $OPTS{$handle_name}, 'GLOB' ) &amp;&amp; $OPTS{$handle_name};

        my $dupe_filehandle_will_work = $custom_fh &amp;&amp; !tied(*$custom_fh) &amp;&amp; ( fileno($custom_fh) &gt; -1 );

        if ( !$custom_fh &amp;&amp; $OPTS{$handle_name} ) {
            die &quot;“$handle_name” must be a filehandle or undef, not $OPTS{$handle_name}&quot;;
        }

        if ($dupe_filehandle_will_work) {

            if ( fileno($custom_fh) &lt; 3 ) {
                open my $copy, '&gt;&amp;', $custom_fh or die &quot;dup($handle_name): $!&quot;;
                $child_write_fh{$handle_name} = $copy;
            }
            else {
                $child_write_fh{$handle_name} = $custom_fh;
            }
        }

        elsif ( $merge_output_yn &amp;&amp; $handle_name eq 'stderr' ) {
            $parent_read_fh{'stderr'} = $parent_read_fh{'stdout'};
            $child_write_fh{'stderr'} = $child_write_fh{'stdout'};
        }

        else {
            pipe $parent_read_fh{$handle_name}, $child_write_fh{$handle_name}    #
              or die &quot;pipe() failed: $!&quot;;
        }
    }

    my ( $child_reads, $parent_writes );
    my $close_child_reads = 0;

    if ( !defined $OPTS{'stdin'} || !length $OPTS{'stdin'} ) {
        open $child_reads, '&lt;', '/dev/null' or die &quot;open(&lt;, /dev/null) failed: $!&quot;;
        $close_child_reads = 1;
    }
    elsif ( UNIVERSAL::isa( $OPTS{'stdin'}, 'GLOB' ) ) {
        my $fileno = fileno $OPTS{'stdin'};

        if ( !defined $fileno || $fileno == -1 ) {
            $pump_stdin_filehandle_into_child = 1;
        }
        else {
            $child_reads = $OPTS{'stdin'};
        }
    }

    if ( !$child_reads ) {
        $close_child_reads = 1;
        pipe( $child_reads, $parent_writes ) or die &quot;pipe() failed: $!&quot;;
    }

    my $self = bless {
        _program =&gt; $OPTS{'program'},
        _args    =&gt; $OPTS{'args'} || [],
    }, $class;

    local $SIG{'CHLD'} = 'DEFAULT';

    my $exec_failed_message = &quot;exec($OPTS{'program'}) failed:&quot;;
    my $used_fastspawn      = 0;
    if (
        $INC{'Proc/FastSpawn.pm'}                                   # may not be available yet due to upcp.static or updatenow.static
        &amp;&amp; !$OPTS{'before_exec'}
        &amp;&amp; !$Cpanel::AccessIds::ReducedPrivileges::PRIVS_REDUCED    # PPI NO PARSE - We not ever be set if its not loaded
    ) {
        $used_fastspawn = 1;
        my @env;

        if ( !$OPTS{'keep_env'} ) {
            if ( !@_allowed_env_vars_cache ) {
                @_allowed_env_vars_cache = ( split( m{ }, Cpanel::Env::get_safe_env_vars() ) );
            }
            @env = map { exists $ENV{$_} ? ( $_ . '=' . ( $ENV{$_} // '' ) ) : () } @_allowed_env_vars_cache;
        }
        my $user    = $OPTS{'user'};
        my $homedir = $OPTS{'homedir'};
        if ( !$user || !$homedir ) {
            my ( $pw_user, $pw_homedir ) = ( getpwuid $&gt; )[ 0, 7 ];
            $user    ||= $pw_user;
            $homedir ||= $pw_homedir;
        }
        die &quot;Invalid EUID: $&gt;&quot; if !$user || !$homedir;

        push @env, &quot;HOME=$homedir&quot;,    &quot;USER=$user&quot;;                                  # need to always be set since we start clean and don't have before_exec
        push @env, &quot;TMP=$homedir/tmp&quot;, &quot;TEMP=$homedir/tmp&quot; if !defined $ENV{'TMP'};

        $self-&gt;{'_child_pid'} = Proc::FastSpawn::spawn_open3(
            fileno($child_reads),                                                            # stdin
            defined $child_write_fh{'stdout'} ? fileno( $child_write_fh{'stdout'} ) : -1,    # stdout
            defined $child_write_fh{'stderr'} ? fileno( $child_write_fh{'stderr'} ) : -1,    # stderr
            $OPTS{'program'},                                                                # program
            [ $OPTS{'program'}, @$args_ar ],                                                 # args
            $OPTS{'keep_env'} ? () : \@env                                                   # env
        );
    }
    else {
        require Cpanel::ForkAsync;
        $self-&gt;{'_child_pid'} = Cpanel::ForkAsync::do_in_child(
            sub {
                $SIG{'__DIE__'} = 'DEFAULT';    ## no critic qw(Variables::RequireLocalizedPunctuationVars) -- will never be unset

                if ( $parent_read_fh{'stdout'} ) {
                    close $parent_read_fh{'stdout'} or die &quot;child close parent stdout failed: $!&quot;;
                }

                if ( $parent_read_fh{'stderr'} &amp;&amp; !$merge_output_yn ) {
                    close $parent_read_fh{'stderr'} or die &quot;child close parent stderr failed: $!&quot;;
                }

                if ($parent_writes) {
                    close $parent_writes or die &quot;close() failed: $!&quot;;
                }

                open( *STDIN, '&lt;&amp;=' . fileno $child_reads ) or die &quot;open(STDIN) failed: $!&quot;;    ##no critic qw(ProhibitTwoArgOpen)

                my $fileno_stdout = fileno \*STDOUT;
                if ( $fileno_stdout != fileno( $child_write_fh{'stdout'} ) ) {

                    if ( $fileno_stdout != 1 ) {
                        close *STDOUT            or die &quot;close(STDOUT) failed: $!&quot;;
                        open( *STDOUT, '&gt;&gt;&amp;=1' ) or die &quot;open(STDOUT, '&gt;&gt;&amp;=1') failed: $!&quot;;    ##no critic qw(ProhibitTwoArgOpen)
                    }

                    open( *STDOUT, '&gt;&gt;&amp;=' . fileno $child_write_fh{'stdout'} ) or die &quot;open(STDOUT) failed: $!&quot;;    ##no critic qw(ProhibitTwoArgOpen)
                }

                my $fileno_stderr = fileno \*STDERR;
                if ( $fileno_stderr != fileno( $child_write_fh{'stderr'} ) ) {

                    if ( $fileno_stderr != 2 ) {
                        close *STDERR            or die &quot;close(STDOUT) failed: $!&quot;;
                        open( *STDERR, '&gt;&gt;&amp;=2' ) or die &quot;open(STDERR, '&gt;&gt;&amp;=2') failed: $!&quot;;    ##no critic qw(ProhibitTwoArgOpen)
                    }

                    open( *STDERR, '&gt;&gt;&amp;=' . fileno $child_write_fh{'stderr'} ) or die &quot;open(STDERR) failed: $!&quot;;    ##no critic qw(ProhibitTwoArgOpen)
                }

                if ( !$OPTS{'keep_env'} ) {
                    Cpanel::Env::clean_env();
                }

                if ($Cpanel::AccessIds::ReducedPrivileges::PRIVS_REDUCED) {    # PPI NO PARSE --  can't be reduced if the module isn't loaded
                    my $target_euid = &quot;$&gt;&quot;;
                    my $target_egid = ( split( m{ }, &quot;$)&quot; ) )[0];
                    Cpanel::AccessIds::ReducedPrivileges::_restore_privileges( 0, 0 );    # PPI NO PARSE -- we will never get here if ReducedPrivileges wasn't loaded
                    Cpanel::LoadModule::load_perl_module('Cpanel::Sys::Setsid::Fast') if !$INC{'Cpanel/Sys/Setsid/Fast.pm'};
                    Cpanel::Sys::Setsid::Fast::fast_setsid();
                    Cpanel::LoadModule::load_perl_module('Cpanel::AccessIds::SetUids') if !$INC{'Cpanel/AccessIds/SetUids.pm'};
                    Cpanel::AccessIds::SetUids::setuids( $target_euid, $target_egid );
                }

                if ( $OPTS{'before_exec'} ) {
                    $OPTS{'before_exec'}-&gt;();
                }

                my $user    = $OPTS{'user'};
                my $homedir = $OPTS{'homedir'};
                if ( !$user || !$homedir ) {
                    Cpanel::LoadModule::load_perl_module('Cpanel::PwCache') if !$INC{'Cpanel/PwCache.pm'};
                    my ( $pw_user, $pw_homedir ) = ( Cpanel::PwCache::getpwuid_noshadow($&gt;) )[ 0, 7 ];
                    $user    ||= $pw_user;
                    $homedir ||= $pw_homedir;
                }
                die &quot;Invalid EUID: $&gt;&quot; if !$user || !$homedir;

                $ENV{'HOME'} = $homedir       if !defined $ENV{'HOME'};    # always cleared by clean_env, but may be reset in before_exec
                $ENV{'USER'} = $user          if !defined $ENV{'USER'};    # always cleared by clean_env, but may be reset in before_exec
                $ENV{'TMP'}  = &quot;$homedir/tmp&quot; if !defined $ENV{'TMP'};
                $ENV{'TEMP'} = &quot;$homedir/tmp&quot; if !defined $ENV{'TEMP'};

                exec( $OPTS{'program'}, @$args_ar ) or die &quot;$exec_failed_message $!&quot;;
            }
        );
    }

    if ( $OPTS{'after_fork'} ) {
        $OPTS{'after_fork'}-&gt;( $self-&gt;{'_child_pid'} );
    }

    if ($close_child_reads) {    #only close it if we opened it
        close $child_reads or die &quot;close() failed: $!&quot;;
    }

    if ( $parent_read_fh{'stdout'} ) {
        close $child_write_fh{'stdout'} or die &quot;close() failed: $!&quot;;
    }

    if ( !$merge_output_yn &amp;&amp; $parent_read_fh{'stderr'} ) {
        close $child_write_fh{'stderr'} or die &quot;close() failed: $!&quot;;
    }

    if ($parent_writes) {
        if ( ref $OPTS{'stdin'} eq 'CODE' ) {

            $OPTS{'stdin'}-&gt;($parent_writes);
        }
        else {

            local $SIG{'PIPE'} = 'IGNORE';
            Cpanel::FHUtils::Autoflush::enable($parent_writes);

            if ($pump_stdin_filehandle_into_child) {
                my $buffer;

                my $is_os_stdin = Cpanel::FHUtils::OS::is_os_filehandle( $OPTS{'stdin'} );

                local $!;

                if ($is_os_stdin) {
                    while ( IO::SigGuard::sysread( $OPTS{'stdin'}, $buffer, $CHUNK_SIZE ) ) {
                        $self-&gt;_write_buffer_to_fh( $buffer, $parent_writes );
                    }
                }
                else {
                    while ( read $OPTS{'stdin'}, $buffer, $CHUNK_SIZE ) {
                        $self-&gt;_write_buffer_to_fh( $buffer, $parent_writes );
                    }
                }

                if ($!) {
                    die Cpanel::Exception::create( 'IO::ReadError', 'The system failed to read up to [format_bytes,_1] from the filehandle that contains standard input for the process that is running the command “[_2]”. This failure happened because of an error: [_3]', [ $CHUNK_SIZE, &quot;$OPTS{'program'} @$args_ar&quot;, &quot;$!&quot; ] );
                }
            }
            else {
                my $to_print_r = ( ref $OPTS{'stdin'} eq 'SCALAR' ) ? $OPTS{'stdin'} : \$OPTS{'stdin'};

                if ( length $$to_print_r ) {
                    $self-&gt;_write_buffer_to_fh( $$to_print_r, $parent_writes );
                }
            }
        }

        close $parent_writes or warn &quot;close() failed: $!&quot;;
    }

    my $reader;
    my $err_obj;

    my @filehandles = map { $parent_read_fh{$_} ? [ $parent_read_fh{$_}, $OPTS{$_} ] : () } qw( stdout stderr );

    if (@filehandles) {
        local $@;
        eval {
            $reader = Cpanel::ReadMultipleFH-&gt;new(
                filehandles  =&gt; \@filehandles,
                timeout      =&gt; $OPTS{'timeout'},
                read_timeout =&gt; $OPTS{'read_timeout'},
            );
        };
        $err_obj = $@;
    }

    if ( $parent_read_fh{'stdout'} ) {
        close $parent_read_fh{'stdout'} or warn &quot;parent close(stdout) failed: $!&quot;;
    }

    if ( $parent_read_fh{'stderr'} &amp;&amp; !$merge_output_yn ) {
        close $parent_read_fh{'stderr'} or warn &quot;parent close(stderr) failed: $!&quot;;
    }

    if ($err_obj) {
        $self-&gt;{'_CHILD_ERROR'} = $self-&gt;_safe_kill_child();
        die $err_obj;
    }
    elsif ($reader) {
        if ( !$reader-&gt;did_finish() ) {
            $self-&gt;{'_timed_out_after'} = $reader-&gt;timed_out();
            $self-&gt;{'_CHILD_ERROR'}     = $self-&gt;_safe_kill_child();
        }

        $self-&gt;{&quot;_stdout&quot;} = $parent_read_fh{stdout} &amp;&amp; $reader-&gt;get_buffer( $parent_read_fh{stdout} );
        $self-&gt;{&quot;_stderr&quot;} = $parent_read_fh{stderr} &amp;&amp; $reader-&gt;get_buffer( $parent_read_fh{stderr} );
    }

    if ( !defined $self-&gt;{'_CHILD_ERROR'} ) {

        local $?;

        waitpid( $self-&gt;{'_child_pid'}, 0 ) if defined $self-&gt;{'_child_pid'};
        $self-&gt;{'_CHILD_ERROR'} = $?;

    }

    if ( $used_fastspawn &amp;&amp; $self-&gt;{'_CHILD_ERROR'} == 32512 ) {
        $self-&gt;{'_CHILD_ERROR'} = _ENOENT() &lt;&lt; 8;
        $self-&gt;{'_exec_failed'} = 1;
        ${ $self-&gt;{'_stderr'} } .= &quot;$exec_failed_message $!&quot;;

    }
    elsif ( !$used_fastspawn &amp;&amp; $self-&gt;{'_stderr'} &amp;&amp; $self-&gt;{'_CHILD_ERROR'} &amp;&amp; ( $self-&gt;{'_CHILD_ERROR'} &gt;&gt; 8 ) == 2 &amp;&amp; index( ${ $self-&gt;{'_stderr'} }, $exec_failed_message ) &gt; -1 ) {
        $self-&gt;{'_exec_failed'} = 1;
    }

    return $self;
}

sub _write_buffer_to_fh ( $self, $buffer, $fh ) {
    while ( length $buffer ) {
        my $wrote = IO::SigGuard::syswrite( $fh, $buffer ) or die $self-&gt;_write_error( \$buffer, $! );
        substr( $buffer, 0, $wrote, q&lt;&gt; );
    }

    return;
}

sub new_or_die {
    my ( $class, @args ) = @_;
    return $class-&gt;new(@args)-&gt;die_if_error();
}

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

    if ( $self-&gt;timed_out() ) {
        return Cpanel::Exception::create(
            'ProcessFailed::Timeout',
            [
                process_name =&gt; $self-&gt;program(),
                ( $self-&gt;child_pid() ? ( pid =&gt; $self-&gt;child_pid() ) : () ),
                timeout =&gt; $self-&gt;timed_out(),
                $self-&gt;_extra_error_args_for_die_if_error(),
            ],
        );
    }

    return $self-&gt;SUPER::to_exception();
}

sub _extra_error_args_for_die_if_error {
    my ($self) = @_;
    return (
        stdout =&gt; $self-&gt;{'_stdout'} ? $self-&gt;stdout() : '',
        stderr =&gt; $self-&gt;{'_stderr'} ? $self-&gt;stderr() : '',
    );
}

sub _safe_kill_child {
    my ($self) = @_;
    Cpanel::LoadModule::load_perl_module('Cpanel::Kill::Single');
    return 'Cpanel::Kill::Single'-&gt;can('safekill_single_pid')-&gt;( $self-&gt;{'_child_pid'}, $SAFEKILL_TIMEOUT );    # One second to die
}

sub stdout_r {
    if ( !$_[0]-&gt;{'_stdout'} ) {
        Cpanel::LoadModule::load_perl_module('Cpanel::Carp');
        die 'Cpanel::Carp'-&gt;can('safe_longmess')-&gt;(&quot;STDOUT output went to filehandle!&quot;);
    }

    return $_[0]-&gt;{'_stdout'};
}

sub _additional_phrases_for_autopsy {
    if ( $_[0]-&gt;timed_out() ) {
        return Cpanel::LocaleString-&gt;new( 'The system aborted the subprocess because it reached the timeout of [quant,_1,second,seconds].', $_[0]-&gt;timed_out() );
    }

    return;
}

sub stdout {
    return ${ $_[0]-&gt;stdout_r() };
}

sub stderr_r {
    if ( !$_[0]-&gt;{'_stderr'} ) {
        Cpanel::LoadModule::load_perl_module('Cpanel::Carp');
        die 'Cpanel::Carp'-&gt;can('safe_longmess')-&gt;(&quot;STDERR output went to filehandle!&quot;);
    }

    return $_[0]-&gt;{'_stderr'};
}

sub stderr {
    return ${ $_[0]-&gt;stderr_r() };
}

sub child_pid {
    return $_[0]-&gt;{'_child_pid'};
}

sub timed_out {
    return $_[0]-&gt;{'_timed_out_after'};
}

sub program {
    return $_[0]-&gt;{'_program'};
}

sub _program_with_args_str {
    my $args_ar = $_[0]-&gt;{'_args'};
    return $_[0]-&gt;{'_program'} . ( ( $args_ar &amp;&amp; ref $args_ar &amp;&amp; scalar @$args_ar ) ? &quot; @$args_ar&quot; : '' );
}


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

    return Cpanel::LocaleString-&gt;new( 'The “[_1]” command (process [_2]) reported error number [_3] when it ended.', $self-&gt;_program_with_args_str(), $self-&gt;{'_child_pid'}, $self-&gt;error_code() );
}

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

    return Cpanel::LocaleString-&gt;new( 'The “[_1]” command (process [_2]) ended prematurely because it received the “[_3]” ([_4]) signal.', $self-&gt;_program_with_args_str(), $self-&gt;{'_child_pid'}, $self-&gt;signal_name(), $self-&gt;signal_code() );
}


sub _write_error {
    my ( $self, $buffer_sr, $OS_ERROR ) = @_;

    my @cmd = ( $self-&gt;{'_program'}, @{ $self-&gt;{'_args'} } );

    return Cpanel::Exception::create( 'IO::WriteError', 'The system failed to send [format_bytes,_1] to the process that is running the command “[_2]” because of an error: [_3]', [ length($$buffer_sr), &quot;@cmd&quot;, $OS_ERROR ], { length =&gt; length($$buffer_sr), error =&gt; $OS_ERROR } );
}


1;

} # --- END Cpanel/SafeRun/Object.pm


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


use strict;
use warnings;

# use Cpanel::Exception        ();
# use Cpanel::Fcntl::Constants ();
# use Cpanel::Rand::Get        ();
# use Cpanel::SV               ();

my $MAX_TMPFILE_CREATE_ATTEMPTS = 50;

use constant WRONLY_CREAT_EXCL =&gt; $Cpanel::Fcntl::Constants::O_WRONLY | $Cpanel::Fcntl::Constants::O_CREAT | $Cpanel::Fcntl::Constants::O_EXCL;

our ( $DO_OPEN, $SKIP_OPEN, $TYPE_FILE, $TYPE_DIR ) = ( 0, 1, 0, 1 );


sub getranddata {
    require Cpanel::Rand::Get;
    goto \&amp;Cpanel::Rand::Get::getranddata;
}

sub gettmpfile {
    return get_tmp_file_by_name('/tmp/cpanel.TMP');
}

sub gettmpdir {
    return get_tmp_dir_by_name('/tmp/cpanel.TMP');
}

sub api2_getranddata {
    my %CFG = @_;
    require Cpanel::Rand::Get;
    return { 'random' =&gt; Cpanel::Rand::Get::getranddata( $CFG{'length'} || 16 ) };
}

our %API = (
    getranddata =&gt; { allow_demo =&gt; 1 },
);

sub api2 {
    my ($func) = @_;
    return { %{ $API{$func} } } if $API{$func};
    return;
}

sub get_tmp_dir_by_name {
    my $templatefile = shift;
    my $suffix       = shift || '.work';
    return get_tmp_file_by_name( $templatefile, $suffix, $TYPE_DIR, $DO_OPEN );
}

sub get_tmp_file_by_name {
    my $templatefile = shift;
    my $suffix       = shift || '.work';
    my $type         = shift || $TYPE_FILE;
    my $open         = shift || $DO_OPEN;
    if ( index( $suffix, '.' ) != 0 ) {
        substr( $suffix, 0, 0, '.' );
    }
    my $last_error;
    my $fh;
    my $randlength       = 8;
    my $maxlength        = 255 - $randlength - 1;
    my $root             = $templatefile . $suffix;
    my $generate_tmpfile = sub {
        my (@path)  = split( m{/+}, $root );
        my $file    = substr( pop @path, -$maxlength, $maxlength );
        my $tmpfile = join( '/', @path, $file ) . '.' . _rand_trailer($randlength);
        Cpanel::SV::untaint($tmpfile);
        return $tmpfile;
    };
    my $tmpfile = $generate_tmpfile-&gt;();

    local $!;
    my $attempts = 0;
    {
        my $old = umask(0);    # Cpanel::Umask was too slow here when creating many zone file
        while (
            ++$attempts &lt; $MAX_TMPFILE_CREATE_ATTEMPTS
            &amp;&amp; (
                ( $open != $DO_OPEN &amp;&amp; -e $tmpfile )
                || (
                    $open == $DO_OPEN
                    ? (
                        $type == $TYPE_DIR
                        ? !mkdir( $tmpfile, 0700 )
                        : !sysopen( $fh, $tmpfile, WRONLY_CREAT_EXCL, 0600 )
                    )
                    : 0
                )
            )
        ) {
            $last_error = $!;
            $tmpfile    = $generate_tmpfile-&gt;();
        }
        umask($old);
    }

    if ( $attempts == $MAX_TMPFILE_CREATE_ATTEMPTS ) {
        die Cpanel::Exception::create( 'TempFileCreateError', [ path =&gt; $tmpfile, error =&gt; $last_error ] );
    }

    return ( $tmpfile, $fh ) if wantarray &amp;&amp; $type == $TYPE_FILE;
    return $tmpfile;    # file will close when $fh leaves context
}

sub _rand_trailer {
    return Cpanel::Rand::Get::getranddata( $_[0] );
}

1;

} # --- END Cpanel/Rand.pm


{ # --- BEGIN Cpanel/SafeDir/RM.pm
package Cpanel::SafeDir::RM;


use strict;
use warnings;

sub safermdir {    ## no critic qw(Subroutines::RequireArgUnpacking)
    return   if !-d $_[0];
    return 1 if rmdir( $_[0] );
    if ( opendir( my $dh, $_[0] ) ) {
        while ( my $file = readdir($dh) ) {
            next if $file eq '.' || $file eq '..';
            unlink(&quot;$_[0]/$file&quot;) or last;
        }
    }
    return 1 if rmdir( $_[0] );
    require File::Path;
    File::Path::rmtree( $_[0] );

    if ( !-d $_[0] ) {


        $? = 0;
        return 1;
    }

    return;
}

1;

} # --- END Cpanel/SafeDir/RM.pm


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


use strict;
use warnings;

# use Cpanel::Rand        ();
# use Cpanel::Debug       ();
# use Cpanel::SafeDir::MK ();
# use Cpanel::SafeDir::RM ();
# use Cpanel::Fcntl       ();
# use Cpanel::Debug       ();
# use Cpanel::Destruct    ();
use Cwd                 ();

my $DO_OPEN   = $Cpanel::Rand::DO_OPEN;
my $SKIP_OPEN = $Cpanel::Rand::SKIP_OPEN;
my $TYPE_DIR  = $Cpanel::Rand::TYPE_DIR;
my $TYPE_FILE = $Cpanel::Rand::TYPE_FILE;

our $DEFAULT_PATH = '/var/tmp';
my $DEFAULT_SUFFIX = 'tmp';

sub get_safe_tmpfile {
    return get_safe_tmp_file_or_dir( $Cpanel::Rand::TYPE_FILE, @_ );
}

sub get_safe_tmpdir {
    return get_safe_tmp_file_or_dir( $Cpanel::Rand::TYPE_DIR, @_ );
}

sub get_safe_tmp_file_or_dir {    ## no critic qw(Subroutines::RequireArgUnpacking)
    my $file_or_dir = shift;
    my $homedir     = $Cpanel::homedir;
    if ( !$homedir ) {
        require Cpanel::PwCache;
        $homedir = Cpanel::PwCache::gethomedir();
    }
    if ( !-d $homedir . '/tmp' ) {
        if ( !mkdir( $homedir . '/tmp', 0755 ) ) {
            Cpanel::Debug::log_warn(&quot;Failed to create $homedir/tmp&quot;);
            return;
        }
    }
    return Cpanel::Rand::get_tmp_file_by_name( $homedir . '/tmp/Cpanel::TempFile', '.tmp', $file_or_dir, @_ );    # audit case 46806 ok
}

sub new {
    my ( $what, $opts ) = @_;
    my $class = ref $what || $what;
    my $self  = {};
    bless $self, $class;

    $self-&gt;set_opts($opts);
    $self-&gt;{&quot;needunlink_$$&quot;} = [];

    return $self;
}

sub dir {
    my ( $self, @other_args ) = @_;
    return $self-&gt;_dir_or_file( $TYPE_DIR, @other_args );
}

sub file {
    my ( $self, @other_args ) = @_;
    return $self-&gt;_dir_or_file( $TYPE_FILE, @other_args );
}

sub file_in_dir {
    my ( $self, @other_args ) = @_;
    my $dir  = $self-&gt;dir(@other_args);
    my $opts = pop @other_args || {};
    return $self-&gt;_dir_or_file( $TYPE_FILE, @other_args, { %$opts, 'path' =&gt; $dir } );
}

sub file_readwrite {


    my ( $self, @other_args ) = @_;

    if ( !wantarray ) {
        $self-&gt;_warn(&quot;Calling file_readwrite() in scalar context makes no sense, since you will only get back a filename but no filehandle&quot;);
        return;
    }

    my ( $fname, $fh ) = $self-&gt;file(@other_args);

    close $fh;
    undef $fh;

    my $mode = Cpanel::Fcntl::or_flags(qw( O_RDWR O_EXCL ));

    sysopen( $fh, $fname, $mode, 0600 )
      or $self-&gt;_die(&quot;Could not sysopen $fname: $!\n&quot;);

    return ( $fname, $fh );
}

sub filename_only {
    my $self = shift;

    my $die_msg = &quot;You must not call filename_only() to get a unique temp file name not backed by an actual&quot;;
    $die_msg .= &quot; file on disk. The subroutine is not implemented and with good reason; see case 48668&quot;;
    $self-&gt;_die($die_msg);

}

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

    my @valid_keys = qw( suffix prefix path debug mkdirs );
    my $err;
    foreach my $key ( sort keys %{$opts} ) {
        next if grep { $key eq $_ } @valid_keys;
        $self-&gt;_warn(&quot;Disallowing invalid opt '$key' passed in opts hash&quot;);
        $err = 1;
    }

    return if $err;

    $opts //= {};
    $self-&gt;{'opts'} //= {};

    my @debug;
    foreach my $k ( sort keys %{$opts} ) {
        my $v = $opts-&gt;{$k} // '';
        $self-&gt;{'opts'}-&gt;{$k} = $v;
        push @debug, &quot;Set opt $k = $v&quot;;
    }

    $Cpanel::Debug::level = $self-&gt;{'opts'}-&gt;{'debug'} ? 1 : 0;
    $self-&gt;_debug($_) for (@debug);
    return 1;
}

sub _get_opt {
    my ( $self, $name, $opts ) = @_;

    return $opts-&gt;{$name} || $self-&gt;{'opts'}-&gt;{$name};
}

sub _dir_or_file {    # Main workhorse of this module
    my ( $self, $dir_or_file, @other_args ) = @_;

    my $opts     = {};
    my $last_arg = $other_args[$#other_args];
    if ( ref $last_arg eq &quot;HASH&quot; ) {
        pop @other_args;
        $opts = $last_arg;
    }

    my $open = $DO_OPEN;

    my $prefix = $self-&gt;_get_opt( 'prefix', $opts ) || &quot;&quot;;
    if ( length $prefix ) {


        if ( $prefix =~ m{/} ) {
#             $self-&gt;_warn(&quot;You must not specify a prefix containing '/' ; instead, use the 'path' option for that purpose&quot;);
INIT { the-&gt;import(qw{path' option for that purpose}); }
            return;
        }

        if ( $prefix =~ m{[^-.\w]} ) {
            $self-&gt;_warn(&quot;Bad prefix '$prefix', prefix must contain only '.', '-', and \\w characters&quot;);
            return;
        }
    }

    my $caller = _callername();
    substr $prefix, 0, 0, substr( $caller, length $caller &gt; 40 ? -40 : 0 ) . '__' if $caller;
    substr $prefix, 0, 0, &quot;$$&quot; . '.';

    my $path   = $self-&gt;_get_opt( 'path',   $opts ) || $DEFAULT_PATH;
    my $suffix = $self-&gt;_get_opt( 'suffix', $opts ) || $DEFAULT_SUFFIX;

    substr $prefix, 0, 0, &quot;$path/&quot;;

    if ( !-e $path ) {
        if ( $self-&gt;_get_opt( 'mkdirs', $opts ) ) {
            my @created;
            if ( Cpanel::SafeDir::MK::safemkdir( $path, undef, undef, \@created ) &amp;&amp; -e $path ) {
                $self-&gt;_info(&quot;Have created path '$path'&quot;);
                push @{ $self-&gt;{&quot;needunlink_$$&quot;} }, @created;
            }
            else {
                $self-&gt;_warn(&quot;Non-existent path '$path', could not create&quot;);
            }
        }
        else {
            $self-&gt;_warn(&quot;Non-existent path '$path', will not create, because mkdirs option is not set&quot;);
        }
    }

    my ( $fname, $fh ) = Cpanel::Rand::get_tmp_file_by_name( $prefix, $suffix, $dir_or_file, $open );
    undef $fname if defined $fname &amp;&amp; $fname eq &quot;/dev/null&quot;;

    $fname = $self-&gt;_make_suffix_rightmost( $fname, $suffix );

    push @{ $self-&gt;{&quot;needunlink_$$&quot;} }, $fname if defined $fname;
    return ( $fname, $fh ) if wantarray;
    return $fname;
}

sub _make_suffix_rightmost {


    my ( $self, $fname, $suffix ) = @_;
    if ( defined $fname ) {
        my $orig = $fname;
        if ( $fname =~ s{ ^ (.*) [.] ($suffix) [.] (.*) }{ &quot;$1.$3.$2&quot; }ex ) {
            if ( -e $orig ) {
                if ( !rename $orig, $fname ) {
                    $self-&gt;_warn(&quot;Could not rename '$orig' to '$fname' to shift suffix ('$suffix') to rightmost position, leaving as is&quot;);
                    $fname = $orig;
                }
            }
        }
        else {
            print STDERR &quot;Regular expression substitution failed to adjust '$orig' to shift suffix ('$suffix') to rightmost position\n&quot;;
        }
    }
    return $fname;
}

sub _info {
    my ( $self, $msg ) = @_;
    return Cpanel::Debug::log_info($msg);
}

sub _warn {
    my ( $self, $msg ) = @_;
    return Cpanel::Debug::log_warn($msg);
}

sub _debug {
    my ( $self, $msg ) = @_;
    return unless $Cpanel::Debug::level;
    return Cpanel::Debug::log_debug($msg);
}

sub _die {
    my ( $self, $msg ) = @_;
    return Cpanel::Debug::log_die($msg);
}

{
    my $caller;

    sub _callername {
        return $caller if defined $caller;
        ( $caller = $0 ) =~ s{\W}{_}g;
        $caller = uc $caller;
        return $caller;
    }

    BEGIN { _callername() }
}

sub cleanup {
    my $self = shift;

    return unless defined $self-&gt;{&quot;needunlink_$$&quot;} &amp;&amp; ref $self-&gt;{&quot;needunlink_$$&quot;};

    my @needunlink = reverse @{ $self-&gt;{&quot;needunlink_$$&quot;} };

    for my $file (@needunlink) {
        if ( ( $file =~ tr/\/// ) &lt; 1 ) {
            $self-&gt;_warn(&quot;Not removed: $file, as a temp file cannot be at top level&quot;);    # ok to not remove because invalid
        }
        elsif ( $file eq '/dev/null' ) {                                                  # at this writing we need this, unfortunately
            $self-&gt;_warn(&quot;Not removed: /dev/null, I flatly refuse to remove it&quot;);
        }
        else {
            my $file_or_dir = -d $file ? &quot;directory&quot; : &quot;file&quot;;
            my $existed     = -e _;
            if ( !$existed ) {
                $self-&gt;_debug(&quot;Not removing $file_or_dir $file, does not exist; perhaps already removed in a recursive dir cleanup, or by some other removal agent&quot;);
            }
            else {
                if ( $file_or_dir eq 'directory' ) {

                    local $?;
                    my $old_dir  = Cwd::abs_path( Cwd::getcwd($file) );
                    my $abs_path = Cwd::abs_path($file);
                    if ( $old_dir eq $abs_path ) {
                        $self-&gt;_warn(&quot;The cwd is temporary directory “$file”. The cwd was changed to “$file/..” in order to remove the temporary directory.&quot;);
                        chdir(&quot;$file/..&quot;) or die &quot;Failed to chdir('$file/..'): $!&quot;;
                    }
                    Cpanel::SafeDir::RM::safermdir($file);
                }
                else {
                    unlink($file);
                }

                my $intro = $existed &amp;&amp; !-e $file ? &quot;R&quot; : &quot;Not r&quot;;
                $self-&gt;_debug(&quot;${intro}emoved: $file_or_dir $file&quot;);
            }
        }
    }

    @{ $self-&gt;{&quot;needunlink_$$&quot;} } = ();
    return;
}

sub needunlink {
    my ( $self, $item ) = @_;
    push @{ $self-&gt;{&quot;needunlink_$$&quot;} }, $item;
    return;
}

sub DESTROY {
    my $self = shift;

    return if Cpanel::Destruct::in_dangerous_global_destruction();

    $self-&gt;cleanup();

    return;
}

1;

} # --- END Cpanel/TempFile.pm


{ # --- BEGIN Cpanel/Crypt/GPG/Import.pm
package Cpanel::Crypt::GPG::Import;


use strict;

# use Cpanel::Crypt::GPG::Base();
our @ISA;
BEGIN { push @ISA, qw(Cpanel::Crypt::GPG::Base); }

# use Cpanel::SafeRun::Object ();
# use Cpanel::TempFile        ();


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

    $opts_hr = {} if !( $opts_hr &amp;&amp; 'HASH' eq ref $opts_hr );

    my $self = eval { $class-&gt;SUPER::new($opts_hr) };

    if ( !$self ) {
        return wantarray ? ( undef, &quot;Failed to find the GnuPG binary.&quot; ) : undef;
    }

    my $tmp = ( $opts_hr-&gt;{tmp} ) ? $opts_hr-&gt;{tmp} : Cpanel::TempFile-&gt;new();
    $self-&gt;{tmp} = $tmp;

    return $self;
}


sub verify {
    my ( $self, %args ) = @_;
    my ( $sig, @files );

    if ( $args{sig} ) {
        $sig = $args{sig};
    }
    elsif ( $args{sig_data} ) {
        $sig = $self-&gt;_write_data_to_temp_file( $args{sig_data}, $self-&gt;{tmp} );
    }
    else {
        return wantarray ? ( undef, &quot;Arguments 'sig' or 'sig_data' must be provided.&quot; ) : undef;
    }


    if ( $args{files} ) {
        @files = ( ref( $args{files} ) eq 'ARRAY' ) ? @{ $args{files} } : ( $args{files} );
    }
    elsif ( defined( $args{files_data} ) ) {
        for my $file ( ( ref( $args{files_data} ) eq 'ARRAY' ) ? @{ $args{files_data} } : ( $args{files_data} ) ) {
            push @files, $self-&gt;_write_data_to_temp_file( $file, $self-&gt;{tmp} );
        }
    }
    else {
        return wantarray ? ( undef, &quot;Arguments 'files' or 'files_data' must be provided.&quot; ) : undef;
    }

    my @args = (
        '--logger-fd', '1',
        '--status-fd', '1',
        $self-&gt;{homedir} ? ( '--homedir' =&gt; $self-&gt;{homedir} ) : (),
        '--verify', $sig,
        @files,
    );

    my $run = Cpanel::SafeRun::Object-&gt;new(
        program =&gt; $self-&gt;{bin},
        args    =&gt; \@args,
        timeout =&gt; _gpg_timeout(),
    );

    if ( !$run ) {
        return wantarray ? ( undef, &quot;Failed to invoke gpg.&quot; ) : undef;
    }

    my $sig_data = undef;
    my $status   = &quot;Failed to validate signature due to some unknown error.&quot;;

    my %notes;
    my $curnote;


    for my $l ( split /\n/, $run-&gt;stdout() ) {
        if ( $l =~ /^\[GNUPG:\] VALIDSIG ([A-F0-9]+) (\d+-\d+-\d+) (\d+) ([A-F0-9]+) ([A-F0-9]+) ([A-F0-9]+) ([A-F0-9]+) ([A-F0-9]+) ([A-F0-9]+) ([A-F0-9]+)$/ ) {
            $sig_data = {
                id          =&gt; substr( $1, -16 ),
                create_time =&gt; $3,
                expire_time =&gt; $4,
            };

            $status = &quot;Valid signature.&quot;;
        }
        elsif ( $l =~ /^\[GNUPG:\] BADSIG ([A-F0-9]+) (.+)$/ ) {
            $status = &quot;Invalid signature.&quot;;
        }
        elsif ( $l =~ /^\[GNUPG:\] NO_PUBKEY ([A-F0-9]+)$/ ) {
            $status = &quot;Could not find public key in keychain.&quot;;
        }
        elsif ( $l =~ /^\[GNUPG:\] NODATA ([A-F0-9]+)$/ ) {
            $status = &quot;Could not find a GnuPG signature in the signature file.&quot;;
        }
        elsif ( $l =~ /^\[GNUPG:\] NOTATION_NAME (.+)$/ ) {
            $curnote = $1;
            $notes{$curnote} = '';
        }
        elsif ( $l =~ /^\[GNUPG:\] NOTATION_DATA (.+)$/ ) {
            $notes{$curnote} .= $1;
        }
    }


    if ($sig_data) {
        $sig_data-&gt;{notations} = \%notes;
    }

    return wantarray ? ( $sig_data, &quot;$status (@files)&quot; ) : $sig_data;
}


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

    if ( !$args{key} ) {
        return wantarray ? ( undef, &quot;No key provided.&quot; ) : undef;
    }

    my @args = (
        '--logger-fd', '1',
        '--status-fd', '1',
        $self-&gt;{homedir} ? ( '--homedir' =&gt; $self-&gt;{homedir} ) : (),
        '--import'
    );

    my $run = Cpanel::SafeRun::Object-&gt;new(
        program =&gt; $self-&gt;{bin},
        args    =&gt; \@args,
        stdin   =&gt; $args{key},
        timeout =&gt; _gpg_timeout(),
    );

    if ( !$run ) {
        return wantarray ? ( undef, &quot;Failed to invoke gpg.&quot; ) : undef;
    }

    my @r = ( undef, &quot;Failed to import key.&quot; );

    for my $l ( split /\n/, $run-&gt;stdout() ) {
        if ( $l =~ /^\[GNUPG:\] IMPORT_OK \d+ ([A-F0-9]+)$/ ) {
            my $id = substr( $1, -16 );
            @r = ( $id, &quot;Successfully imported key.&quot; );
        }
    }

    return wantarray ? @r : shift @r;
}


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

    if ( !$args{key} ) {
        return wantarray ? ( undef, &quot;No key provided.&quot; ) : undef;
    }

    my @r = ( undef, &quot;Failed to parse key id.&quot; );

    if ( my $id = $self-&gt;add_pub_key(%args) ) {
        @r = ( $id, &quot;Successfully parsed key id.&quot; );
    }

    return wantarray ? @r : shift @r;
}


sub _write_data_to_temp_file {
    my ( $self, $data )   = @_;
    my ( $name, $handle ) = $self-&gt;{tmp}-&gt;file();

    binmode $handle;    # We may be opening binary OpenPGP data.
    print {$handle} $data;
    close($handle);

    return $name;
}


sub _gpg_timeout {
    return 60;
}

1;

} # --- END Cpanel/Crypt/GPG/Import.pm


{ # --- BEGIN Cpanel/Crypt/GPG/Import/Temp.pm
package Cpanel::Crypt::GPG::Import::Temp;


use strict;
use warnings;

# use Cpanel::Crypt::GPG::Import();
our @ISA;
BEGIN { push @ISA, qw(Cpanel::Crypt::GPG::Import); }

# use Cpanel::TempFile ();


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

    $opts_hr = {} if !( $opts_hr &amp;&amp; 'HASH' eq ref $opts_hr );

    my $tmp  = Cpanel::TempFile-&gt;new;
    my $path = $tmp-&gt;dir();

    $opts_hr-&gt;{tmp}     = $tmp;
    $opts_hr-&gt;{homedir} = $path;

    my $self = $class-&gt;SUPER::new($opts_hr);

    return $self;
}

1;

} # --- END Cpanel/Crypt/GPG/Import/Temp.pm


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


use strict;


use Try::Tiny;

# use Cpanel::AdminBin::Serializer ();
# use Cpanel::LoadFile::ReadFast   ();
# use Cpanel::Fcntl::Constants     ();
# use Cpanel::Debug                ();
# use Cpanel::Exception            ();

use Time::HiRes ();

use constant {
    WRONLY_CREAT_EXCL =&gt; ( $Cpanel::Fcntl::Constants::O_WRONLY | $Cpanel::Fcntl::Constants::O_CREAT | $Cpanel::Fcntl::Constants::O_EXCL ),
    _EEXIST           =&gt; 17,
};

our $LOCK = 1;    #const
our $LAST_WRITE_CACHE_SERIALIZATION_ERROR;

our $MAX_CACHE_ELEMENTS = 32768 + 1;

my $MAX_CACHE_OBJECT_SIZE = 1024 * 512;    # do not cache objects larger than 512k

my $_iterations_since_last_cache_cleanup = 0;

my %DATASTORE_CACHE;

*_time  = *Time::HiRes::time;
*_utime = *Time::HiRes::utime;
*_stat  = *Time::HiRes::stat;

sub store_ref {
    return savedatastore( $_[0], { 'data' =&gt; $_[1], ( ref $_[2] ? %{ $_[2] } : () ) } );
}

sub fetch_ref {
    my ( $file, $is_array ) = @_;

    my $fetch_ref = loaddatastore($file);

    my $data_type = ref $fetch_ref-&gt;{'data'};
    my $data = $data_type ? top_level_clone( $fetch_ref-&gt;{'data'} ) : undef;
    $data_type ||= 'UNDEF';

    if ( $is_array &amp;&amp; $data_type ne 'ARRAY' ) {
        return [];
    }
    elsif ( !$is_array &amp;&amp; $data_type ne 'HASH' ) {
        return {};
    }

    return $data;
}

sub load_ref {
    my ( $file, $into_ref, $opts_ref ) = @_;
    my $fetch_ref = loaddatastore( $file, 0, $into_ref, $opts_ref );
    return $fetch_ref-&gt;{'data'};
}

sub savedatastore {
    my ( $file, $opts ) = @_;

    require Cpanel::SafeFile;
    my $use_cache_file = !defined $opts-&gt;{'cache_file'} || $opts-&gt;{'cache_file'};

    if ( !exists $opts-&gt;{'data'} || !defined $opts-&gt;{'data'} ) {
        Cpanel::Debug::log_warn(&quot;Expected data to be saved. \$opts-&gt;{'data'} was empty. $file has been left untouched.&quot;);
        if ( $opts-&gt;{'fh'} &amp;&amp; $opts-&gt;{'safefile_lock'} ) {
            Cpanel::SafeFile::safeclose( $opts-&gt;{'fh'}, $opts-&gt;{'safefile_lock'} );
        }
        elsif ( $opts-&gt;{'fh'} ) {
            close( $opts-&gt;{'fh'} );
        }
        return;
    }

    my $use_memory_cache = !defined $opts-&gt;{'enable_memory_cache'} || $opts-&gt;{'enable_memory_cache'};

    my $original_file = $file;

    substr( $file, -5, 5, '' ) if rindex( $file, '.yaml' ) == length($file) - 5;

    require Cpanel::YAML;
    my $output = Cpanel::YAML::Dump( $opts-&gt;{'data'} );

    my $perms = exists $opts-&gt;{'mode'} ? $opts-&gt;{'mode'} &amp; 00777 : undef;

    if ( !defined($perms) ) {
        if ( $opts-&gt;{'fh'} ) {
            die &quot;Filehandle already closed!&quot; if !defined fileno $opts-&gt;{'fh'};
            $perms = ( stat $opts-&gt;{'fh'} )[2] &amp; 0777;
        }
        elsif ( -e $original_file ) {
            $perms = ( stat _ )[2] &amp; 0777;
        }
        else {
            $perms = 0644;
        }
    }

    require Cpanel::FileUtils::Write;
    my $fh = Cpanel::FileUtils::Write::overwrite( $original_file, $output, $perms );
    @{$opts}{ 'inode', 'size', 'mtime' } = ( _stat($fh) )[ 1, 7, 9 ];
    close $fh;

    if ($use_cache_file) {

        _write_cache_file( &quot;$file.cache&quot;, $opts-&gt;{'data'}, $perms );

        _utime( $opts-&gt;{'mtime'}, $opts-&gt;{'mtime'}, &quot;$file.cache&quot; );

    }

    if ($use_memory_cache) {

        if ( $opts-&gt;{'size'} &lt; $MAX_CACHE_OBJECT_SIZE ) {
            _cleanup_cache() if ++$_iterations_since_last_cache_cleanup &gt; $MAX_CACHE_ELEMENTS &amp;&amp; scalar keys %DATASTORE_CACHE &gt;= $MAX_CACHE_ELEMENTS;
            @{ $DATASTORE_CACHE{$original_file} }{ 'cache', 'inode', 'mtime', 'size' } = @{$opts}{ 'data', 'inode', 'mtime', 'size' };
        }
        else {
            delete $DATASTORE_CACHE{$original_file};
        }
    }

    my $ok;
    if ( $opts-&gt;{'fh'} ) {
        if ( $opts-&gt;{'safefile_lock'} ) {
            $ok = Cpanel::SafeFile::safeclose( $opts-&gt;{'fh'}, $opts-&gt;{'safefile_lock'} );
        }
        else {
            $ok = close( $opts-&gt;{'fh'} );
        }
    }
    else {
        $ok = 1;
    }

    return $ok;
}

sub loaddatastore {    ## no critic(Subroutines::ProhibitExcessComplexity)  -- Refactoring this function is a project, not a bug fix
    my ( $datastore_file, $lock_required, $copy_data_ref, $opts ) = @_;

    my ( $loaded_data, $filesys_inode, $filesys_perms, $filesys_mtime, $filesys_size, $filesys_cache_mtime, $cache, $datastore_cache_file );

    if ( !$datastore_file ) {
        Cpanel::Debug::log_warn('No datastore file specified');
        return;
    }

    my $use_memory_cache = !defined $opts-&gt;{'enable_memory_cache'} || $opts-&gt;{'enable_memory_cache'};

    my $custom_perms = exists $opts-&gt;{'mode'} ? $opts-&gt;{'mode'} &amp; 00777 : undef;

    my $lock_datastore = 0;    # default is to not lock
    if ( defined $lock_required ) {
        $lock_datastore = $lock_required ? 1 : 0;
    }
    elsif ( $opts-&gt;{'donotlock'} ) {
        $lock_datastore = 0;
    }

    if ( !$lock_datastore ) {
        ( $filesys_inode, $filesys_perms, $filesys_size, $filesys_mtime ) = ( _stat($datastore_file) )[ 1, 2, 7, 9 ];
        if ( !$filesys_mtime ) {

            return;
        }

        if (
            $use_memory_cache
            &amp;&amp; exists $DATASTORE_CACHE{$datastore_file}    # no-auto vivify
            &amp;&amp; $DATASTORE_CACHE{$datastore_file}-&gt;{'mtime'}
            &amp;&amp; $DATASTORE_CACHE{$datastore_file}-&gt;{'size'}
            &amp;&amp; $filesys_mtime == $DATASTORE_CACHE{$datastore_file}-&gt;{'mtime'}
            &amp;&amp; $filesys_size == $DATASTORE_CACHE{$datastore_file}-&gt;{'size'}
            &amp;&amp; $filesys_inode == $DATASTORE_CACHE{$datastore_file}-&gt;{'inode'}
        ) {
            if ($copy_data_ref) {
                _copy_ref_data( $DATASTORE_CACHE{$datastore_file}-&gt;{'cache'}, $copy_data_ref, $datastore_file );
            }

            if ( defined $custom_perms ) {
                if ( ( $filesys_perms &amp; 0777 ) != $custom_perms ) {
                    chmod $custom_perms, $datastore_file or do {
                        warn sprintf( &quot;chmod(0%03o, $datastore_file): $!&quot;, $custom_perms );
                    };
                }
            }

            return bless {
                'size'  =&gt; $DATASTORE_CACHE{$datastore_file}-&gt;{'size'},
                'inode' =&gt; $DATASTORE_CACHE{$datastore_file}-&gt;{'inode'},
                'mtime' =&gt; $DATASTORE_CACHE{$datastore_file}-&gt;{'mtime'},
                'data'  =&gt; $DATASTORE_CACHE{$datastore_file}-&gt;{'cache'},
                'file'  =&gt; $datastore_file,
              },
              __PACKAGE__;
        }
    }

    $datastore_cache_file = $datastore_file;


    if ( rindex( $datastore_cache_file, '.yaml' ) == length($datastore_cache_file) - 5 ) {
        substr( $datastore_cache_file, -5, 5, '.cache' );
    }
    else {
        $datastore_cache_file .= '.cache';
    }

    if ( !$lock_datastore ) {
        ( $filesys_cache_mtime, $cache ) = _load_datastore_cache_from_disk( $datastore_cache_file, $filesys_mtime, $datastore_file, $filesys_size, $filesys_inode );
        if ( $filesys_cache_mtime &amp;&amp; $filesys_cache_mtime &gt;= $filesys_mtime &amp;&amp; ref $cache ) {
            $loaded_data = $cache;
        }

        if ( $copy_data_ref &amp;&amp; $loaded_data ) {
            _copy_ref_data( $loaded_data, $copy_data_ref, $datastore_file );
        }

        if ($loaded_data) {
            if ( defined $custom_perms &amp;&amp; ( $filesys_perms &amp; 00777 ) != $custom_perms ) {
                chmod( $custom_perms, $datastore_file ) or do {
                    warn( sprintf &quot;chmod(0%o, %s) failed: %s&quot;, $custom_perms, $datastore_file, $! );
                };
            }

            if ($use_memory_cache) {
                if ( $filesys_size &lt; $MAX_CACHE_OBJECT_SIZE ) {
                    _cleanup_cache() if ++$_iterations_since_last_cache_cleanup &gt; $MAX_CACHE_ELEMENTS &amp;&amp; scalar keys %DATASTORE_CACHE &gt;= $MAX_CACHE_ELEMENTS;
                    @{ $DATASTORE_CACHE{$datastore_file} }{ 'inode', 'size', 'mtime', 'cache' } = ( $filesys_inode, $filesys_size, $filesys_mtime, $loaded_data );
                }
                else {
                    delete $DATASTORE_CACHE{$datastore_file};
                }
            }

            return bless {
                'inode' =&gt; $filesys_inode,
                'size'  =&gt; $filesys_size,
                'mtime' =&gt; $filesys_mtime,
                'data'  =&gt; $loaded_data,
                'file'  =&gt; $datastore_file,
              },
              __PACKAGE__;

        }
    }


    my $datastore_not_writable;
    my $data_fh;
    my $perms = defined $custom_perms ? $custom_perms : 0644;    #0644 is the default
    my $orig_umask;
    if ( defined $perms ) {
        $orig_umask = umask( $perms ^ 07777 );
    }

    my $created_datastore_file = 0;

    if ( !-e $datastore_file ) {
        if ( sysopen my $f, $datastore_file, WRONLY_CREAT_EXCL, $perms ) {
            $created_datastore_file = 1;

        }
        elsif ( $! != _EEXIST() ) {
            warn &quot;Failed to create “$datastore_file” (EUID=$&gt;): $!&quot;;

        }

    }

    my $rlock;
    my $lock_failed;
    if ( !$lock_datastore ) {

        open( $data_fh, '&lt;', $datastore_file ) or do {
            Cpanel::Debug::log_warn(&quot;Unable open $datastore_file for reading: $!&quot;);


            undef $data_fh;
        };
        $datastore_not_writable = 1;
    }
    else {
        my $open_mode = -w $datastore_file ? '+&lt;' : '&lt;';
        require Cpanel::SafeFile;
        $rlock = Cpanel::SafeFile::safeopen( $data_fh, $open_mode, $datastore_file );
        my $last_error = $@ || $!;
        $lock_failed = !$rlock || 1 == $rlock;

        if ($lock_failed) {
            Cpanel::Debug::log_warn(&quot;Unable get a lock on datastore $datastore_file: $last_error&quot;);


            undef $data_fh;
            $datastore_not_writable = 1;
        }
    }
    umask($orig_umask) if defined $orig_umask;

    if ( !$created_datastore_file ) {
        my $data_fh_perms = ( _stat( $data_fh // $datastore_file ) )[2] || 0600;

        if ( defined $custom_perms &amp;&amp; ( $data_fh_perms &amp; 00777 ) != $custom_perms ) {
            chmod( $custom_perms, $data_fh ? $data_fh : $datastore_file );
            $data_fh_perms = ( _stat( $data_fh // $datastore_file ) )[2] || 0600;
        }

        if ( $data_fh &amp;&amp; fileno $data_fh ) {
            if ($lock_datastore) {
                ( $filesys_inode, $filesys_perms, $filesys_size, $filesys_mtime ) = ( _stat($data_fh) )[ 1, 2, 7, 9 ];
                ( $filesys_cache_mtime, $cache ) = _load_datastore_cache_from_disk( $datastore_cache_file, $filesys_mtime, $datastore_file, $filesys_size, $filesys_inode );
            }
            if ( $filesys_cache_mtime &amp;&amp; ref $cache ) {
                $loaded_data = $cache;
            }
            else {
                $loaded_data = _load_inner_data( $datastore_file, $data_fh );
                seek( $data_fh, 0, 0 );
            }
            if ( $copy_data_ref &amp;&amp; $loaded_data ) {
                _copy_ref_data( $loaded_data, $copy_data_ref, $datastore_file );
            }
        }

        if ( !$lock_datastore || $datastore_not_writable ) {
            my @data_dir = split( /\/+/, $datastore_cache_file );
            pop @data_dir;
            my $datastore_cache_file_dir = join( '/', @data_dir );
            if ( $loaded_data &amp;&amp; $filesys_mtime &amp;&amp; ( !-e $datastore_cache_file || -w _ ) &amp;&amp; ( _stat($datastore_cache_file_dir) )[4] == $&gt; ) {
                _write_cache_file( $datastore_cache_file, $loaded_data, $data_fh_perms ) if !$filesys_cache_mtime;
                if ($use_memory_cache) {
                    if ( $filesys_size &lt; $MAX_CACHE_OBJECT_SIZE ) {
                        _cleanup_cache() if ++$_iterations_since_last_cache_cleanup &gt; $MAX_CACHE_ELEMENTS &amp;&amp; scalar keys %DATASTORE_CACHE &gt;= $MAX_CACHE_ELEMENTS;
                        @{ $DATASTORE_CACHE{$datastore_file} }{ 'cache', 'inode', 'mtime', 'size' } = ( $loaded_data, $filesys_inode, $filesys_mtime, $filesys_size );
                    }
                    else {
                        delete $DATASTORE_CACHE{$datastore_file};
                    }
                }
            }

        }
    }

    if ( !$lock_datastore || $datastore_not_writable ) {
        if ( !$lock_datastore ) {
            close($data_fh);
        }
        else {
            require Cpanel::SafeFile;
            Cpanel::SafeFile::safeclose( $data_fh, $rlock ) unless $lock_failed;
        }
        $data_fh                = undef;    # data_fh is closed at this point
        $datastore_not_writable = 1;        # if the datastore is closed, it isn't writable.
    }

    my %self = (
        'inode' =&gt; $filesys_inode,
        'size'  =&gt; $filesys_size,
        'mtime' =&gt; $filesys_mtime,
        'data'  =&gt; $loaded_data,
        'file'  =&gt; $datastore_file,
    );

    if ( !$datastore_not_writable ) {
        @self{ 'safefile_lock', 'fh' } = ( $rlock, $data_fh );
    }

    return bless \%self, __PACKAGE__;
}

sub _load_datastore_cache_from_disk {
    my ( $datastore_cache_file, $filesys_mtime, $datastore_file, $filesys_size, $filesys_inode ) = @_;
    my $loaded_data;
    if ( open( my $datastore_cache_fh, '&lt;:stdio', $datastore_cache_file ) ) {
        my $filesys_cache_mtime = ( _stat($datastore_cache_fh) )[9];    # stat the file handle to prevent a race condition
        if ( $filesys_size &amp;&amp; $filesys_mtime &amp;&amp; $filesys_cache_mtime &gt;= $filesys_mtime &amp;&amp; $filesys_cache_mtime &lt;= _time() ) {
            eval {
                local $SIG{'__DIE__'};     # Suppress spewage as we may be reading an invalid cache
                local $SIG{'__WARN__'};    # and since failure is ok to throw it away
                $loaded_data = Cpanel::AdminBin::Serializer::LoadFile($datastore_cache_fh);
            };
            my ( $filesys_inode_after_read, $filesys_size_after_read, $filesys_mtime_after_read ) = ( _stat($datastore_file) )[ 1, 7, 9 ];

            if (   $filesys_mtime_after_read == $filesys_mtime
                &amp;&amp; $filesys_size_after_read == $filesys_size
                &amp;&amp; $filesys_inode_after_read == $filesys_inode ) {
                return ( $filesys_cache_mtime, $loaded_data ) if ref $loaded_data;
            }
        }

    }
    elsif ( $! != _ENOENT() ) {    #ok if the file does not exist
        warn &quot;Failed to open “$datastore_cache_file” for reading: $!&quot;;
    }

    return 0;
}

sub _write_cache_file {
    my ( $path, $data, $perms ) = @_;

    $LAST_WRITE_CACHE_SERIALIZATION_ERROR = undef;

    try {
        my $serialized;

        try {
            $serialized = Cpanel::AdminBin::Serializer::Dump($data);
        }
        catch {
            $LAST_WRITE_CACHE_SERIALIZATION_ERROR = Cpanel::Exception::get_string($_);
        };

        if ($serialized) {
            require Cpanel::FileUtils::Write;
            Cpanel::FileUtils::Write::overwrite(
                $path,
                $serialized,
                $perms,
            );
        }
    }
    catch {
        my $str = Cpanel::Exception::get_string($_);
        Cpanel::Debug::log_warn(&quot;Failed to write the cache file “$path” ($str); this file will not be saved.&quot;);
    };

    return;
}

sub file {
    return $_[0]-&gt;{'file'};
}

sub fh {
    return $_[0]-&gt;{'fh'};
}

sub mtime {
    return $_[0]-&gt;{'mtime'};
}

sub size {
    return $_[0]-&gt;{'size'};
}

sub clear_data {
    $_[0]-&gt;{'data'} = undef;
    return;
}

sub data {
    if ( defined $_[1] ) {
        $_[0]-&gt;{'data'} = $_[1];
        return 1;
    }
    return $_[0]-&gt;{'data'};
}

sub save {
    return savedatastore( $_[0]-&gt;{'file'}, $_[0] );
}

sub abort {
    return unlockdatastore( $_[0] );
}

sub unlockdatastore {
    my ($datastore) = @_;

    return 0 if !$datastore-&gt;{'fh'} || !$datastore-&gt;{'safefile_lock'};

    require Cpanel::SafeFile;
    return Cpanel::SafeFile::safeclose( $datastore-&gt;{'fh'}, $datastore-&gt;{'safefile_lock'} );
}

sub _copy_ref_data {
    my ( $src_ref, $dest_ref, $file ) = @_;

    if ( ref $src_ref eq 'HASH' ) {
        local $@;
        eval { %{$dest_ref} = %{$src_ref}; };


    }
    elsif ( ref $src_ref eq 'ARRAY' ) {
        local $@;
        eval { @{$dest_ref} = @{$src_ref}; };

    }
    else {
        if ($file) {
            Cpanel::Debug::log_warn(&quot;YAML in '$file' is not a hash or array reference&quot;);
        }
        else {
            Cpanel::Debug::log_warn('Asked to duplicate a reference that is not a hash or array');
        }
        $dest_ref = $src_ref;
    }
    return;
}

sub get_cache {
    return \%DATASTORE_CACHE;
}

sub clear_cache {
    %DATASTORE_CACHE = ();
    return;
}

sub clear_one_cache {
    my ($file) = @_;

    delete $DATASTORE_CACHE{$file};
    return;
}

sub verify {
    my ($file) = @_;

    my $fh;
    open( $fh, '&lt;', $file ) or die &quot;Failed to open $file: $!&quot;;

    my $data = _load_inner_data( $file, $fh );

    return ref $data ? 1 : 0;
}

sub _load_inner_data {
    my ( $name, $fh ) = @_;
    my $data = '';
    Cpanel::LoadFile::ReadFast::read_all_fast( $fh, $data );
    my $loaded_data;

    if ( length $data ) {
        local $@;
        eval {
            local $SIG{'__WARN__'};
            local $SIG{'__DIE__'};
            require Cpanel::YAML;
            $loaded_data = ( Cpanel::YAML::Load($data) )[0];
        };
    }

    $loaded_data = undef unless ref $loaded_data;
    return $loaded_data;
}

sub top_level_clone {
    my ($data) = @_;

    if ( ref $data eq 'HASH' ) {
        return { %{ $_[0] } };
    }
    elsif ( ref $data eq 'ARRAY' ) {
        return [ @{ $_[0] } ];
    }

    return $data;
}

sub _cleanup_cache {
    my @oldest_keys = sort { $DATASTORE_CACHE{$b}{'mtime'} &lt;=&gt; $DATASTORE_CACHE{$a}{'mtime'} } keys %DATASTORE_CACHE;
    splice( @oldest_keys, -1 * int( $MAX_CACHE_ELEMENTS / 2 ) );
    delete @DATASTORE_CACHE{@oldest_keys};
    $_iterations_since_last_cache_cleanup = 0;
    return 1;
}

sub _ENOENT { return 2; }
1;

} # --- END Cpanel/CachedDataStore.pm


{ # --- BEGIN Cpanel/HTTP/Client/Response.pm
package Cpanel::HTTP::Client::Response;


use strict;
use warnings;


# use HTTP::Tiny::UA::Response();
our @ISA;
BEGIN { push @ISA, qw(HTTP::Tiny::UA::Response); }

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

    my $self = $class-&gt;SUPER::new( $opts_hr, @extra );

    $self-&gt;{'_cp_redirects'} = $opts_hr-&gt;{'redirects'};

    return $self;
}

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

    return [ map { ( ref $self )-&gt;new($_) } @{ $self-&gt;{'_cp_redirects'} } ];
}

sub TO_JSON {
    my $json = { %{ $_[0] } };

    $json-&gt;{redirects} = delete $json-&gt;{_cp_redirects};

    return $json;
}

1;

} # --- END Cpanel/HTTP/Client/Response.pm


{ # --- BEGIN Cpanel/HTTP/Client.pm
package Cpanel::HTTP::Client;


use strict;

my %MODULE_PARAMS;

# use Cpanel::HTTP::Tiny::FastSSLVerify();
our @ISA;
BEGIN { push @ISA, qw(Cpanel::HTTP::Tiny::FastSSLVerify); }

# use Cpanel::Exception              ();
# use Cpanel::HTTP::Client::Response ();

our $VERSION = '1.0';


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

    my $self = $class-&gt;SUPER::new(@args);

    $MODULE_PARAMS{$self} = {};

    return $self;
}


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

    $MODULE_PARAMS{$self}{'die_on_http_error'} = 1;

    return $self;
}


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

    $MODULE_PARAMS{$self}{'die_on_http_error'} = 0;

    return $self;
}

sub request {
    my ( $self, $method, $url, $args_hr ) = @_;

    local $@;

    my $resp = $self-&gt;SUPER::request( $method, $url, $args_hr || () );

    my $resp_obj = Cpanel::HTTP::Client::Response-&gt;new($resp);

    if ( $resp_obj-&gt;status() == 599 ) {
        my $error = $resp_obj-&gt;content();

        chomp($error) if $error &amp;&amp; !ref $error;
        die Cpanel::Exception::create(
            'HTTP::Network',
            [
                method    =&gt; $method,
                url       =&gt; $url,
                error     =&gt; $error,
                redirects =&gt; $resp_obj-&gt;redirects(),
            ]
        );
    }

    if ( $MODULE_PARAMS{$self}{'die_on_http_error'} &amp;&amp; $resp-&gt;{'status'} &gt;= 400 ) {
        die Cpanel::Exception::create(
            'HTTP::Server',
            [
                method       =&gt; $method,
                content_type =&gt; scalar( $resp_obj-&gt;header('Content-Type') ),
                ( map { ( $_ =&gt; $resp_obj-&gt;$_() ) } qw( content status reason url headers redirects ) ),
            ],
        );
    }

    return $resp_obj;
}


sub set_default_header {
    my ( $self, $header, $value ) = @_;
    $header =~ tr/[A-Z]/[a-z]/;
    $self-&gt;{'default_headers'}{$header} = $value;
    return 1;
}


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

    $header =~ tr/[A-Z]/[a-z]/;
    return delete $self-&gt;{'default_headers'}{$header};
}

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

    $self-&gt;SUPER::DESTROY() if $self-&gt;can('SUPER::DESTROY');

    return;
}


1;

} # --- END Cpanel/HTTP/Client.pm


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


use strict;
use warnings;


sub fetch_url {
    my ( $url, %opts ) = @_;

    my @methods = (
        [ 'Cpanel::HTTP::Client' =&gt; \&amp;_try_with_http_client ],
        [ 'curl'                 =&gt; \&amp;_try_with_curl ],
        [ 'wget'                 =&gt; \&amp;_try_with_wget ]
    );

    my $all_errors;

    foreach my $method (@methods) {
        my ( $name, $sub ) = @{$method};

        local $@;
        my $contents = eval { $sub-&gt;( $url, %opts ); };
        return ( 1, $contents ) if !$@;

        my $error = &quot;Failed to fetch using $name: $@&quot;;
        $all_errors .= $error . &quot;\n&quot;;
    }

    return ( 0, $all_errors );
}


sub _try_with_http_client {
    my ( $url, %opts ) = @_;

    die &quot;Cpanel::HTTP::Client unavailable during initial install&quot; if $ENV{'CPANEL_BASE_INSTALL'};

    require Cpanel::HTTP::Client;

    my $http = Cpanel::HTTP::Client-&gt;new()-&gt;die_on_http_error();
    $http-&gt;timeout( $opts{'timeout'} ) if exists $opts{'timeout'};

    my $content = $http-&gt;get($url)-&gt;content();

    return $content unless exists $opts{'output-file'};

    my $temp_file = $opts{'output-file'} . '.' . time . '.temp';

    open my $fh, '&gt;', $temp_file
      or die &quot;Unable to open $temp_file: $!&quot;;
    print {$fh} $content;
    close $fh;

    unlink $opts{'output-file'} if -e $opts{'output-file'};
    rename $temp_file, $opts{'output-file'};

    return 1;
}


sub _try_with_curl {
    my ( $url, %opts ) = @_;

    my $curl_bin = _find_curl_bin();
    die &quot;Unable to find curl&quot; unless $curl_bin;

    my @cmd_args = _build_curl_cmd_line( $url, %opts );

    return _execute_download_tool( $curl_bin, @cmd_args );
}


sub _try_with_wget {
    my ( $url, %opts ) = @_;

    my $wget_bin = _find_wget_bin();
    die &quot;Unable to find wget&quot; unless $wget_bin;

    my @cmd_args = _build_wget_cmd_line( $url, %opts );

    return _execute_download_tool( $wget_bin, @cmd_args );
}


sub _get_mozilla_ca_file {

    my $ca_file = eval {
        require    # Cpanel::Static OK - inside an eval
          Mozilla::CA;
        Mozilla::CA::SSL_ca_file();
    };
    return if $@;
    return unless -e $ca_file;
    return $ca_file;
}


sub _find_curl_bin {

    for my $bin (qw(/usr/bin/curl /bin/curl /usr/local/bin/curl)) {
        next if ( !-e $bin );
        next if ( !-x _ );
        next if ( -z _ );
        return $bin;
    }

    return undef;
}


sub _find_wget_bin {

    for my $bin (qw(/usr/bin/wget /bin/wget /usr/local/bin/wget)) {
        next if ( !-e $bin );
        next if ( !-x _ );
        next if ( -z _ );
        return $bin;
    }

    return undef;
}


sub _build_curl_cmd_line {
    my ( $url, %opts ) = @_;

    my @cmd_args;

    if ( exists $opts{'tries'} ) {
        push @cmd_args, '--retry';
        push @cmd_args, $opts{'tries'};
    }

    if ( exists $opts{'retry-delay'} ) {
        push @cmd_args, '--retry-delay';
        push @cmd_args, $opts{'retry-delay'};
    }

    if ( exists $opts{'timeout'} ) {
        push @cmd_args, '--max-time';
        push @cmd_args, $opts{'timeout'};
    }

    if ( exists $opts{'no-check-certificate'} &amp;&amp; $opts{'no-check-certificate'} ) {
        push @cmd_args, '-k';
    }
    else {
        my $ca_file = _get_mozilla_ca_file();
        if ($ca_file) {
            push @cmd_args, &quot;--cacert&quot;;
            push @cmd_args, $ca_file;
        }
    }

    push @cmd_args, '--silent';
    push @cmd_args, '-o';
    push @cmd_args, exists $opts{'output-file'} ? $opts{'output-file'} : '-';
    push @cmd_args, $url;

    return @cmd_args;
}


sub _build_wget_cmd_line {
    my ( $url, %opts ) = @_;

    my @cmd_args;

    push @cmd_args, '-nv'                                     if exists $opts{'not-verbose'};
    push @cmd_args, '--no-dns-cache'                          if exists $opts{'no-dns-cache'};
    push @cmd_args, '--tries=' . $opts{'tries'}               if exists $opts{'tries'};
    push @cmd_args, '--timeout=' . $opts{'timeout'}           if exists $opts{'timeout'};
    push @cmd_args, '--dns-timeout=' . $opts{'dns-timeout'}   if exists $opts{'dns-timeout'};
    push @cmd_args, '--read-timeout=' . $opts{'read-timeout'} if exists $opts{'read-timeout'};
    push @cmd_args, '--waitretry=' . $opts{'retry-delay'}     if exists $opts{'retry-delay'};
    push @cmd_args, '--retry-connrefused'                     if exists $opts{'retry-connrefused'};

    if ( exists $opts{'no-check-certificate'} &amp;&amp; $opts{'no-check-certificate'} ) {
        push @cmd_args, '--no-check-certificate';
    }
    else {
        my $ca_file = _get_mozilla_ca_file();
        if ($ca_file) {
            push @cmd_args, &quot;--ca-certificate=$ca_file&quot;;
        }
    }

    push @cmd_args, '-O';
    push @cmd_args, exists $opts{'output-file'} ? $opts{'output-file'} : '-';
    push @cmd_args, $url;

    return @cmd_args;
}


sub _execute_download_tool {
    my ( $bin, @cmd_args ) = @_;

    if ( _try_load_saferun_object() ) {
        return _run_with_saferun_object( $bin, @cmd_args );
    }
    elsif ( _try_load_ipc_open3() ) {
        return _run_with_ipc_open3( $bin, @cmd_args );
    }
    else {
        die &quot;Unable to find a suitable method to fetch the URL\n&quot;;
    }

    return;
}


sub _try_load_saferun_object {
    eval { require Cpanel::SafeRun::Object; };
    return $@ ? 0 : 1;
}


sub _try_load_ipc_open3 {
    eval { require IPC::Open3; };
    return $@ ? 0 : 1;
}


sub _run_with_saferun_object {
    my ( $bin, @cmd_args ) = @_;

    my $run = Cpanel::SafeRun::Object-&gt;new(
        program =&gt; $bin,
        args    =&gt; \@cmd_args,
    );

    if ( !$run ) {
        die &quot;Failed to invoke $bin binary.&quot;;
    }

    my $rc = $run-&gt;CHILD_ERROR() &gt;&gt; 8;

    if ( $rc != 0 ) {
        my $full_command = $bin . ' ' . join ' ', @cmd_args;
        my $stderr       = &quot;Error encountered while running $full_command command: &quot; . $run-&gt;stderr();
        die $stderr;
    }

    my $stdout = $run-&gt;stdout();

    return $stdout;
}


sub _run_with_ipc_open3 {
    my ( $bin, @cmd_args ) = @_;

    my ( $out_fh, $err_fh );
    my $pid = IPC::Open3::open3( undef, $out_fh, $err_fh, $bin, @cmd_args );

    waitpid( $pid, 0 );

    if ($?) {
        my $full_command = $bin . ' ' . join ' ', @cmd_args;
        my $stderr       = &quot;Error encountered while running $full_command command: &quot;;
        while ( my $line = &lt;$err_fh&gt; ) {
            $stderr .= $line;
        }
        die $stderr;
    }

    my $stdout;
    while ( my $line = &lt;$out_fh&gt; ) {
        $stdout .= $line;
    }

    return $stdout;
}

1;

} # --- END Cpanel/SecureDownload.pm


{ # --- BEGIN Cpanel/Crypt/GPG/VendorKeys.pm
package Cpanel::Crypt::GPG::VendorKeys;


use strict;
use warnings;

# use Cpanel::Crypt::GPG::Import::Temp ();
# use Cpanel::CachedDataStore          ();
# use Cpanel::SecureDownload           ();

our $VERSION = 1;


sub _get_config_file {
    return '/var/cpanel/gpg/vendorkeys.yaml';
}


sub _get_vendor_keys {
    return Cpanel::CachedDataStore::fetch_ref( _get_config_file() );
}


sub _save_vendor_keys {
    my ($vk_ref) = @_;
    require File::Basename;
    my $keydir = File::Basename::dirname( _get_config_file() );

    if ( !-d $keydir ) {
        require Cpanel::SafeDir::MK;
        Cpanel::SafeDir::MK::safemkdir( $keydir, 0700 );
    }

    return Cpanel::CachedDataStore::savedatastore( _get_config_file(), { mode =&gt; 0600, data =&gt; $vk_ref } );
}


sub set_keys {
    my (%args) = @_;

    $args{interval} = defined( $args{interval} ) ? $args{interval} : 86400;    # 1 day, in seconds.
    $args{enabled}  = defined( $args{enabled} )  ? $args{enabled}  : 1;

    for my $a (qw{vendor category url keys}) {
        if ( !$args{$a} ) {
            return wantarray ? ( undef, &quot;Argument '$a' is required.&quot; ) : undef;
        }
    }

    my %new_keys;
    my @ckeys = ( ref( $args{keys} ) eq 'ARRAY' ) ? @{ $args{keys} } : ( $args{keys} );

    my $gpg = Cpanel::Crypt::GPG::Import::Temp-&gt;new();

    if ( !$gpg ) {
        return wantarray ? ( undef, &quot;Failed to create GPG object.&quot; ) : undef;
    }

    for my $ckey (@ckeys) {
        while ( $ckey =~ /(-----BEGIN PGP PUBLIC KEY BLOCK-----.*?-----END PGP PUBLIC KEY BLOCK-----)/gs ) {
            my $skey = $1;
            my ( $key_id, $msg ) = $gpg-&gt;get_key_id( key =&gt; $skey );

            if ( !$key_id ) {
                return wantarray ? ( undef, $msg ) : undef;
            }

            $new_keys{$key_id} = $skey;
        }
    }

    if ( !keys %new_keys ) {
        return wantarray ? ( undef, &quot;No valid keys found.&quot; ) : undef;
    }

    my $vk_ref = _get_vendor_keys();


    $vk_ref-&gt;{ $args{vendor} }-&gt;{ $args{category} } = {
        url          =&gt; $args{url},
        keychain     =&gt; \%new_keys,
        enabled      =&gt; $args{enabled},
        interval     =&gt; $args{interval},
        noverify     =&gt; $args{noverify},
        last_updated =&gt; _get_current_time(),
    };

    $vk_ref-&gt;{__VERSION} = $VERSION;

    if ( _save_vendor_keys($vk_ref) ) {
        return wantarray ? ( 1, 'Success' ) : 1;
    }

    return wantarray ? ( undef, &quot;Failed to save key store.&quot; ) : undef;
}


sub _get_current_time {
    return int(time);
}


sub set_keys_from_url {
    my (%args) = @_;

    for my $a (qw{vendor category url}) {
        if ( !$args{$a} ) {
            return wantarray ? ( undef, &quot;Argument '$a' is required.&quot; ) : undef;
        }
    }

    my $url = $args{url};

    if ( ( !$args{noverify} ) &amp;&amp; ( $url !~ /^https:\/\//i ) ) {
        return wantarray ? ( undef, &quot;URL must use SSL.&quot; ) : undef;
    }

    my ( $ret, $download_data ) = Cpanel::SecureDownload::fetch_url(
        $url,
        ( 'timeout' =&gt; 60, 'no-check-certificate' =&gt; $args{noverify} )
    );

    if ( !$ret ) {

        return wantarray ? ( undef, $download_data ) : undef;
    }

    my ( $success, $msg ) = set_keys(
        vendor   =&gt; $args{vendor},
        category =&gt; $args{category},
        url      =&gt; $args{url},
        keys     =&gt; $download_data,
        enabled  =&gt; $args{enabled},
        interval =&gt; $args{interval},
        noverify =&gt; $args{noverify},
    );

    if ( !$success ) {
        return wantarray ? ( undef, &quot;Failure when adding key: $msg&quot; ) : undef;
    }

    return wantarray ? ( 1, &quot;Successfully added key.&quot; ) : 1;
}


sub get_keys {
    my (%args) = @_;

    if ( !$args{vendor} ) {
        return wantarray ? ( undef, &quot;Argument 'vendor' is required.&quot; ) : undef;
    }

    if ( !( $args{category} || $args{categories} ) ) {
        return wantarray ? ( undef, &quot;Argument 'category' or 'categories' is required.&quot; ) : undef;
    }

    if ( $args{category} &amp;&amp; $args{categories} ) {
        return wantarray ? ( undef, &quot;Both argument 'category' and 'categories' can not be used simultaneously.&quot; ) : undef;
    }

    my $argcat = $args{category} || $args{categories};
    my @cats   = ( ref($argcat) eq 'ARRAY' ) ? @{$argcat} : ($argcat);
    my $vk_ref = _get_vendor_keys();

    if ( !$vk_ref-&gt;{ $args{vendor} } ) {
        return wantarray ? ( undef, &quot;Keys for vendor '&quot; . $args{vendor} . &quot;' not found.&quot; ) : undef;
    }

    my %keys;

    for my $cat (@cats) {
        if ( !$vk_ref-&gt;{ $args{vendor} }-&gt;{$cat} ) {
            next;    # skip over non-existent categories
        }

        if ( !$vk_ref-&gt;{ $args{vendor} }-&gt;{$cat}-&gt;{enabled} ) {
            next;    # skip over disabled keychains
        }

        for my $key ( keys %{ $vk_ref-&gt;{ $args{vendor} }-&gt;{$cat}-&gt;{keychain} } ) {
            $keys{$key} = $vk_ref-&gt;{ $args{vendor} }-&gt;{$cat}-&gt;{keychain}-&gt;{$key};
        }
    }

    return \%keys;
}


sub get_key_info {
    my ($keyid) = @_;
    my $keys = _get_vendor_keys();

    foreach my $vendor ( keys %{$keys} ) {

        if ( index( $vendor, '__' ) == 0 ) {
            next;
        }

        foreach my $type ( keys %{ $keys-&gt;{$vendor} } ) {
            return ( $vendor, $type ) if grep { $keyid eq $_ } keys %{ $keys-&gt;{$vendor}-&gt;{$type}-&gt;{keychain} };
        }
    }
    return ( 'UNKNOWN', 'UNKNOWN' );
}

sub download_public_keys {
    my %opts = @_;


    require Cpanel::Logger;
    $opts{logger} ||= Cpanel::Logger-&gt;new();
    my $warn  = $opts{logger}-&gt;can(&quot;warn&quot;)  ? 'warn'  : 'warning';
    my $error = $opts{logger}-&gt;can(&quot;error&quot;) ? 'error' : 'warn';

    if ( $opts{noverify} ) {
        $opts{logger}-&gt;info(&quot;WARNING: Hostname verification is disabled!&quot;);
        $opts{logger}-&gt;info(&quot;Can not ensure the legitimacy of downloaded keys.&quot;);
    }

    my $vk_ref = _get_vendor_keys();


    my %update_keys;

    for my $vendor ( grep { index( $_, '__' ) != 0 } keys %{$vk_ref} ) {
        for my $category ( keys %{ $vk_ref-&gt;{$vendor} } ) {
            $update_keys{$vendor}-&gt;{$category}-&gt;{url}      = $vk_ref-&gt;{$vendor}-&gt;{$category}-&gt;{url};
            $update_keys{$vendor}-&gt;{$category}-&gt;{noverify} = $vk_ref-&gt;{$vendor}-&gt;{$category}-&gt;{noverify};
        }
    }


    for my $key ( @{ _get_pubkey_defaults() } ) {
        my $vendor   = $key-&gt;{vendor};
        my $category = $key-&gt;{category};
        my $url      = $key-&gt;{url};
        my $noverify = $key-&gt;{noverify};
        $update_keys{$vendor}-&gt;{$category}-&gt;{url}      = $url;
        $update_keys{$vendor}-&gt;{$category}-&gt;{noverify} = $noverify;
    }


    my @update_keys_list;

    for my $vendor ( keys %update_keys ) {
        for my $category ( keys %{ $update_keys{$vendor} } ) {
            my $key = {
                vendor   =&gt; $vendor,
                category =&gt; $category,
                url      =&gt; $update_keys{$vendor}-&gt;{$category}-&gt;{url},
                noverify =&gt; $update_keys{$vendor}-&gt;{$category}-&gt;{noverify},
            };

            push @update_keys_list, $key;
        }
    }


    my $keys;

    if ( $opts{keys} ) {
        $keys = $opts{keys};
    }
    else {
        $keys = \@update_keys_list;
    }

    my $success = 1;

    for my $key ( @{$keys} ) {
        my $interval     = $vk_ref-&gt;{ $key-&gt;{vendor} }-&gt;{ $key-&gt;{category} }-&gt;{interval}     || 0;
        my $last_updated = $vk_ref-&gt;{ $key-&gt;{vendor} }-&gt;{ $key-&gt;{category} }-&gt;{last_updated} || 0;


        my $current_time = _get_current_time();

        next if ( !$opts{force}
            &amp;&amp; defined $vk_ref-&gt;{__VERSION}
            &amp;&amp; $vk_ref-&gt;{__VERSION} == $VERSION
            &amp;&amp; $current_time &lt;= ( $interval + $last_updated )
            &amp;&amp; $current_time &gt;= $last_updated );

        my ( $succ, $msg ) = set_keys_from_url(
            vendor   =&gt; $key-&gt;{vendor},
            category =&gt; $key-&gt;{category},
            url      =&gt; $key-&gt;{url},
            noverify =&gt; $key-&gt;{noverify} || $opts{noverify},
        );

        if ($succ) {
            $opts{logger}-&gt;info(&quot;Retrieved public key from vendor: $key-&gt;{vendor}, category: $key-&gt;{category}, url: $key-&gt;{url}&quot;);
        }
        else {
            $opts{logger}-&gt;$warn(&quot;Unable to download public key from vendor: $key-&gt;{vendor}, category: $key-&gt;{category}, url: $key-&gt;{url}&quot;);
            $opts{logger}-&gt;info($msg);
            $success = 0;
        }
    }

    if ( !$success ) {
        $opts{logger}-&gt;$warn(&quot;Failed to download all specified public keys.&quot;);
    }

    return $success;
}

sub _get_pubkey_defaults {
    return [
        {
            url      =&gt; 'https://securedownloads.cpanel.net/cPanelPublicKey.asc',
            vendor   =&gt; 'cpanel',
            category =&gt; 'release',
        },
        {
            url      =&gt; 'https://securedownloads.cpanel.net/cPanelDevelopmentKey.asc',
            vendor   =&gt; 'cpanel',
            category =&gt; 'development',
        },
    ];
}

1;

} # --- END Cpanel/Crypt/GPG/VendorKeys.pm


{ # --- BEGIN Cpanel/Crypt/GPG/VendorKeys/TimestampCache.pm
package Cpanel::Crypt::GPG::VendorKeys::TimestampCache;


use strict;
use warnings;

# use Cpanel::CachedDataStore ();

sub _cache_file {
    return '/var/cpanel/gpg/timestamp.cache';
}

sub new {
    my ($obj) = @_;
    my $self = {};
    bless $self, $obj;

    $self-&gt;{'cache'} = _load_cache();

    return $self;
}

sub _load_cache {
    return Cpanel::CachedDataStore::fetch_ref( _cache_file() );
}

sub _save_cache {
    my ($cache_data) = @_;
    return Cpanel::CachedDataStore::savedatastore( _cache_file(), { mode =&gt; 0600, data =&gt; $cache_data } );
}

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

    return 0 if !$args{'mirror'} || !$args{'url'};

    $self-&gt;{'cache'}-&gt;{ $args{'mirror'} }{ $args{'url'} } = { date_downloaded =&gt; time, signature_date =&gt; $args{'create_time'} };

    return _save_cache( $self-&gt;{'cache'} );
}

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

    my $cached_time = $self-&gt;{'cache'}-&gt;{ $args{'mirror'} }{ $args{'url'} }{'signature_date'};
    my $new_time    = $args{'create_time'};
    if ( defined $cached_time &amp;&amp; $cached_time &gt; $new_time ) {

        return 1;
    }
    else {
        return 0;
    }
}

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

    my $valid_time_window = exists $args{'valid_time_window'} ? $args{'valid_time_window'} : 7776000;
    my $current_time      = time;

    my $cache = $self-&gt;{'cache'};
    foreach my $mirror ( keys %{ $self-&gt;{'cache'} } ) {
        foreach my $file ( keys %{ $self-&gt;{'cache'}{$mirror} } ) {

            delete $cache-&gt;{$mirror}{$file} if $current_time - $self-&gt;{'cache'}{$mirror}{$file}{'date_downloaded'} &gt;= $valid_time_window;

        }

        delete $cache-&gt;{$mirror} if !scalar keys %{ $cache-&gt;{$mirror} };
    }

    return _save_cache($cache);
}

1;

} # --- END Cpanel/Crypt/GPG/VendorKeys/TimestampCache.pm


{ # --- BEGIN Cpanel/Crypt/GPG/VendorKeys/Verify.pm
package Cpanel::Crypt::GPG::VendorKeys::Verify;


use strict;

# use Cpanel::Crypt::GPG::Import::Temp               ();
# use Cpanel::Crypt::GPG::VendorKeys                 ();
# use Cpanel::Crypt::GPG::VendorKeys::TimestampCache ();


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

    if ( !$args{vendor} ) {
        return _result( undef, &quot;Argument 'vendor' is required.&quot; );
    }

    if ( !( $args{category} || $args{categories} ) ) {
        return _result( undef, &quot;Argument 'category' or 'categories' is required.&quot; );
    }

    if ( $args{category} &amp;&amp; $args{categories} ) {
        return _result( undef, &quot;Both argument 'category' and 'categories' can not be used simultaneously.&quot; );
    }

    my $argcat = $args{category} || $args{categories};
    my $keys   = Cpanel::Crypt::GPG::VendorKeys::get_keys( vendor =&gt; $args{vendor}, category =&gt; $argcat );

    if ( !keys %{$keys} ) {
        return _result( undef, &quot;No keys found for vendor '&quot; . $args{vendor} . &quot;'&quot; );
    }

    my ( $pgp, $msg ) = Cpanel::Crypt::GPG::Import::Temp-&gt;new();

    if ( !$pgp ) {
        return _result( undef, $msg );
    }

    for my $key_id ( keys %{$keys} ) {
        my ( $success, $msg ) = $pgp-&gt;add_pub_key( key =&gt; $keys-&gt;{$key_id} );

        if ( !$success ) {
            return _result( undef, &quot;Failed to add key '$key_id' : &quot; . $msg );
        }
    }

    my $obj = {
        vendor     =&gt; $args{vendor},
        categories =&gt; ( ref($argcat) eq 'ARRAY' ) ? $argcat : [$argcat],
        keys       =&gt; $keys,
        pgp        =&gt; $pgp,
    };

    bless $obj, $class;

    return _result( $obj, &quot;Success&quot; );
}


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

    if ( !( $args{sig} || $args{sig_data} ) ) {
        return _result( undef, &quot;Arguments 'sig' or 'sig_data' must be provided.&quot; );
    }


    if ( !( $args{files} || defined( $args{files_data} ) ) ) {
        return _result( undef, &quot;Arguments 'files' or 'files_data' must be provided.&quot; );
    }

    my ( $s, $m ) = $self-&gt;{pgp}-&gt;verify(%args);

    if ( !$s ) {
        return _result( $s, $m );
    }

    ( $s, $m ) = _check_filename( $s, $m, \%args );

    if ( !$s ) {
        return _result( $s, $m );
    }

    ( $s, $m ) = _check_rollback( $s, $m, \%args );

    if ( !$s ) {
        return _result( $s, $m );
    }

    $m = &quot;Successfully verified signature for &quot; . $self-&gt;{vendor} . &quot; (key types: &quot; . join( &quot;, &quot;, @{ $self-&gt;{categories} } ) . &quot;).&quot;;
    return _result( $s, $m );
}

sub _check_rollback {
    my ( $sig_data, $message, $args ) = @_;

    my $sig_cache = Cpanel::Crypt::GPG::VendorKeys::TimestampCache-&gt;new();

    my $rollback = $sig_cache-&gt;check_cache_for_rollback(
        mirror      =&gt; $args-&gt;{mirror},
        url         =&gt; $args-&gt;{url},
        create_time =&gt; $sig_data-&gt;{create_time},
    );

    if ($rollback) {
        return _result( undef, 'Signature rollback detected.' );
    }
    else {
        $sig_cache-&gt;update_cache( mirror =&gt; $args-&gt;{mirror}, url =&gt; $args-&gt;{url}, create_time =&gt; $sig_data-&gt;{create_time}, );
        return _result( $sig_data, $message );    # Everything ok, pass data through to next check.
    }
}

sub _check_filename {
    my ( $sig_data, $message, $args ) = @_;

    if ( defined( $sig_data-&gt;{'notations'} ) &amp;&amp; defined( $sig_data-&gt;{'notations'}-&gt;{'filename@gpg.notations.cpanel.net'} ) ) {
        my $file_note = $sig_data-&gt;{'notations'}-&gt;{'filename@gpg.notations.cpanel.net'};

        my $url = $args-&gt;{url};
        $url =~ s/\.bz2$//;

        if ( $file_note eq $url ) {
            return _result( $sig_data, $message );    # Everything ok, pass data through to next check.
        }
        else {
            return _result( undef, 'Filename notation (' . $file_note . ') does not match URL (' . $url . ').' );
        }
    }
    else {
        return _result( undef, 'Signature does not contain a filename notation.' );
    }
}

sub _result {
    my ( $success, $message ) = @_;
    return wantarray ? ( $success, $message ) : $success;
}

1;

} # --- END Cpanel/Crypt/GPG/VendorKeys/Verify.pm


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


use strict;
use warnings;

# use Cpanel::ArrayFunc::Shuffle        ();
# use Cpanel::Crypt::GPG::Settings      ();
# use Cpanel::FileUtils::Copy           ();
# use Cpanel::Hostname                  ();
# use Cpanel::Debug                     ();
# use Cpanel::Rand::Get                 ();
# use Cpanel::SocketIP                  ();
# use Cpanel::URL                       ();
# use Cpanel::UrlTools                  ();
# use Cpanel::Encoder::Tiny             ();
# use Cpanel::HTTP::Tiny::FastSSLVerify ();
use Socket                            ();

our $DEFAULT_TIMEOUT       = 260;
our $SIMULATE_FAILURE      = 0;
our $DEBUG                 = 0;
our $VERSION               = '3.0';
our $MAX_CONTENT_SIZE      = ( 1024 * 1024 * 1024 * 1024 );
our $HTTP_RETRY_COUNT      = 12;
our $SIGNATURE_RETRY_COUNT = 4;
our $MAX_RESOLVE_ATTEMPT   = 65;

my $buffer_size         = 131070;
my $has_cpanel_dnsRoots = 0;

sub new {
    my ( $obj, %OPTS ) = @_;

    my $self = bless {}, $obj;

    $self-&gt;{'connectedHostAddress'}   = '';                                                                #ip of connected host
    $self-&gt;{'connectedHostname'}      = '';                                                                #hostname of connected host
    $self-&gt;{'connectedHostFailCount'} = {};
    $self-&gt;{'connected'}              = 0;
    $self-&gt;{'http_retry_count'}       = $OPTS{'http_retry_count'} || $HTTP_RETRY_COUNT;
    $self-&gt;{'use_dns_cache'}          = exists $OPTS{'use_dns_cache'} ? int $OPTS{'use_dns_cache'} : 1;    #on by default
    $self-&gt;{'retry_dns'}              = exists $OPTS{'retry_dns'}     ? $OPTS{'retry_dns'}         : 1;
    $self-&gt;{'use_mirror_addr_list'}   = $OPTS{'use_mirror_addr_list'} || 0;
    $self-&gt;{'hideOutput'}             = $OPTS{'hideOutput'} &amp;&amp; $OPTS{'hideOutput'} eq '1' ? 1 : 0;
    $self-&gt;{'htmlOutput'}             = $OPTS{'htmlOutput'} || 0;
    $self-&gt;{'dns_cache_ttl'}          = exists $OPTS{'dns_cache_ttl'} ? int $OPTS{'dns_cache_ttl'} : 7200;
    $self-&gt;{'mirror_search_attempts'} = {};
    $self-&gt;{'last_status'}            = undef;
    $self-&gt;{'last_modified'}          = undef;
    $self-&gt;{'die_on_404'}             = $OPTS{'die_on_404'}      || 0;
    $self-&gt;{'die_on_4xx_5xx'}         = $OPTS{'die_on_4xx_5xx'}  || 0;
    $self-&gt;{'die_on_error'}           = $OPTS{'die_on_error'}    || 0;
    $self-&gt;{'return_on_404'}          = $OPTS{'return_on_404'}   || 0;
    $self-&gt;{'return_on_error'}        = $OPTS{'return_on_error'} || 0;
    $self-&gt;{'protocol'}               = $OPTS{'protocol'}        || 0;
    $self-&gt;{'timeout'}                = $OPTS{'timeout'}         || $DEFAULT_TIMEOUT;
    $self-&gt;{'level'}                  = 0;
    $self-&gt;{'logger'}                 = $OPTS{'logger'};

    if ( !$self-&gt;{'logger'} ) {
        require Cpanel::Logger;
        $self-&gt;{'logger'} = Cpanel::Logger-&gt;new();
    }
    $self-&gt;{'announce_mirror'}       = $OPTS{'announce_mirror'};
    $self-&gt;{'signed'}                = $OPTS{'signed'};
    $self-&gt;{'vendor'}                = $OPTS{'vendor'}                || 'cpanel';
    $self-&gt;{'categories'}            = $OPTS{'categories'}            || Cpanel::Crypt::GPG::Settings::default_key_categories();
    $self-&gt;{'signature_validation'}  = $OPTS{'signature_validation'}  || Cpanel::Crypt::GPG::Settings::signature_validation_enabled();
    $self-&gt;{'signature_retry_count'} = $OPTS{'signature_retry_count'} || $SIGNATURE_RETRY_COUNT;

    $self-&gt;{'speed_test_enabled'} = exists $OPTS{'speed_test_enabled'} ? int( $OPTS{'speed_test_enabled'} ) : 1;
    $self-&gt;{'speed_test_file'}    = $OPTS{'speed_test_file'} || '/speedcheck';
    $self-&gt;{'sig_data'}           = undef;

    return $self;
}

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

    return if $self-&gt;{'hideOutput'};

    if ( $self-&gt;{'htmlOutput'} ) {
        $str = Cpanel::Encoder::Tiny::safe_html_encode_str($str);
        $str =~ s/\n/&lt;br&gt;/g;
    }

    return print $str;
}

sub request {    ## no critic qw(Subroutines::ProhibitExcessComplexity)
    my ( $self, %OPTS ) = @_;

    $OPTS{'uncompress'} = 1 if ( defined $OPTS{'uncompress_bzip2'} &amp;&amp; length $OPTS{'uncompress_bzip2'} &amp;&amp; $OPTS{'url'} =~ m{\.bz2$} );

    my $check_signature = defined $OPTS{'signed'} ? $OPTS{'signed'} : $self-&gt;{'signed'};
    my $uncompress      = ( defined $OPTS{'uncompress'} &amp;&amp; length $OPTS{'uncompress'} &amp;&amp; $OPTS{'uncompress'} &amp;&amp; $OPTS{'url'} =~ m/\.(bz2|xz)$/ );


    if ( !$self-&gt;{'signature_validation'} ) {
        $check_signature = undef;
    }


    if ( Cpanel::Hostname::gethostname() =~ /^(autobuild|perlcc).*\.dev\.cpanel\.net$/ ) {
        $check_signature = undef;
    }


    if ( !$check_signature ) {
        return $self-&gt;_request_file(%OPTS);
    }

    my ( $gpg, $gpg_msg ) = $self-&gt;get_crypt_gpg_vendorkey_verify( vendor =&gt; $OPTS{'vendor'}, categories =&gt; $OPTS{'categories'} );

    if ( !$gpg ) {
        $self-&gt;_sigerror_die(&quot;Failed to create gpg object: $gpg_msg&quot;);
    }


    my $destfile = $OPTS{'destfile'};


    my $file_url = $OPTS{'url'};
    my $signature_url;

    if ( $OPTS{'signature_url'} ) {
        $signature_url = $OPTS{'signature_url'};
    }
    elsif ($destfile) {
        $signature_url = $file_url;

        $signature_url =~ s/\.bz2$//;    # xz files are not signed
        $signature_url = $signature_url . '.asc';
    }
    else {
        $signature_url = $file_url . '.asc';
    }

    my $signature_validation_failures = 0;
    my $signature_hostaddr;
    my $basefile_hostaddr;
    my $verification_data;
    my $verification_message;
    while ( $signature_validation_failures++ &lt; $self-&gt;{'signature_retry_count'} ) {


        $OPTS{'url'} = $signature_url;
        delete $OPTS{'destfile'};
        my $signature_data = $self-&gt;_request_file(%OPTS);

        if ( !$signature_data ) {
            $self-&gt;_die( &quot;Failed to download signature at URL 'http://&quot; . $OPTS{'host'} . $signature_url . &quot;'.&quot; );
        }
        $signature_hostaddr = $self-&gt;{'connectedHostAddress'};


        if ($destfile) {
            if ( !$uncompress &amp;&amp; $destfile =~ /\.(bz2|xz)$/ ) {
                my $compressed_ext = $1;


                my $basename = $destfile;
                $basename =~ s/\.\Q$compressed_ext\E$//;

                my $tmp_file_a = $basename . '_' . Cpanel::Rand::Get::getranddata(8) . &quot;.$compressed_ext&quot;;
                my $tmp_file_b = $basename . '_' . Cpanel::Rand::Get::getranddata(8) . &quot;.$compressed_ext&quot;;

                $OPTS{'url'}      = $file_url;
                $OPTS{'destfile'} = $tmp_file_a;


                my $req = $self-&gt;_request_file(%OPTS);

                if ( !$req ) {
                    $self-&gt;_die( &quot;Failed to download file at URL 'http://&quot; . $OPTS{'host'} . $file_url . &quot;'.&quot; );
                }
                $basefile_hostaddr = $self-&gt;{'connectedHostAddress'};


                my $copy = Cpanel::FileUtils::Copy::safecopy( $tmp_file_a, $tmp_file_b );

                if ( !$copy ) {
                    unlink $tmp_file_a;
                    $self-&gt;_die(&quot;Failed to make working copy of downloaded file.&quot;);
                }

                if ( $compressed_ext eq 'bz2' ) {
                    require Cpanel::Sync::Common;
                    Cpanel::Sync::Common::unbzip2($tmp_file_b);
                    $tmp_file_b =~ s/\.bz2$//;
                }
                elsif ( $compressed_ext eq 'xz' ) {
                    require Cpanel::SafeRun::Simple;
                    Cpanel::SafeRun::Simple::saferun( qw{ unxz -f }, $tmp_file_b )
                      and die &quot;failed to extract '$tmp_file_b': $!&quot;;
                }

                ( $verification_data, $verification_message ) = $gpg-&gt;files(
                    files    =&gt; $tmp_file_b,
                    sig_data =&gt; $signature_data,
                    mirror   =&gt; $OPTS{'host'},
                    url      =&gt; $file_url
                );

                if ($verification_data) {
                    $self-&gt;{'logger'}-&gt;info($verification_message);
                    $self-&gt;{'sig_data'} = $verification_data;
                    unlink $destfile;
                    rename $tmp_file_a, $destfile;
                    unlink $tmp_file_b;
                    return wantarray ? ($req) : $req;
                }
                else {
                    unlink $tmp_file_a;
                    unlink $tmp_file_b;
                }
            }
            else {
                my $tmp_file = $destfile . '_' . Cpanel::Rand::Get::getranddata(8);

                $OPTS{'url'}      = $file_url;
                $OPTS{'destfile'} = $tmp_file;


                my $req = $self-&gt;_request_file(%OPTS);

                if ( !$req ) {
                    $self-&gt;_die( &quot;Failed to download file at URL 'http://&quot; . $OPTS{'host'} . $file_url . &quot;'.&quot; );
                }
                $basefile_hostaddr = $self-&gt;{'connectedHostAddress'};

                ( $verification_data, $verification_message ) = $gpg-&gt;files(
                    files    =&gt; $tmp_file,
                    sig_data =&gt; $signature_data,
                    mirror   =&gt; $OPTS{'host'},
                    url      =&gt; $file_url
                );

                if ($verification_data) {
                    $self-&gt;{'logger'}-&gt;info($verification_message);
                    $self-&gt;{'sig_data'} = $verification_data;
                    unlink $destfile;
                    rename $tmp_file, $destfile;
                    return wantarray ? ($req) : $req;
                }
                else {
                    unlink $tmp_file;
                }
            }
        }
        else {


            $OPTS{'url'} = $file_url;


            my ( $file_data, $complete ) = $self-&gt;_request_file(%OPTS);

            if ( !$complete ) {
                $self-&gt;_die( &quot;Failed to download URL 'http://&quot; . $OPTS{'host'} . $file_url . &quot;'.&quot; );
            }
            $basefile_hostaddr = $self-&gt;{'connectedHostAddress'};

            ( $verification_data, $verification_message ) = $gpg-&gt;files(
                files_data =&gt; $file_data,
                sig_data   =&gt; $signature_data,
                mirror     =&gt; $OPTS{'host'},
                url        =&gt; $file_url
            );

            if ($verification_data) {
                $self-&gt;{'logger'}-&gt;info($verification_message);
                $self-&gt;{'sig_data'} = $verification_data;
                return wantarray ? ( $file_data, $complete ) : $file_data;
            }
        }

        $self-&gt;_output(&quot;Signature verification failed using file from IP ${basefile_hostaddr} and signature from IP ${signature_hostaddr}&quot;);
        if ( $basefile_hostaddr eq $signature_hostaddr ) {
            $self-&gt;_skip_failed_mirror();
            $self-&gt;disconnect();
        }
        else {
            $self-&gt;_output(&quot;...retrying ${basefile_hostaddr}...&quot;);
        }
        $self-&gt;_output(&quot;\n&quot;);

    }

    $self-&gt;_sigerror_die( &quot;Signature verification failed for URL 'http://&quot; . $OPTS{'host'} . $file_url . &quot;'. ${verification_message}&quot; );

    return 1;
}

sub _fetcher {
    my ( $self, $timeout, %params ) = @_;
    my $fetcher = $self-&gt;{fetcher};
    return Cpanel::HTTP::Tiny::FastSSLVerify-&gt;new( timeout =&gt; $timeout, %params ) if !$fetcher || $fetcher-&gt;{timeout} != $timeout;
    return $fetcher;
}

sub _request_file {    ## no critic qw(Subroutines::ProhibitExcessComplexity)
    my ( $self, %OPTS ) = @_;

    my $host             = $OPTS{'host'};
    my $url              = $OPTS{'url'};
    my $destfile         = $OPTS{'destfile'}         || '';
    my $http_retry_count = $OPTS{'http_retry_count'} || $self-&gt;{'http_retry_count'};
    my $uncompress       = ( defined $OPTS{'uncompress'} &amp;&amp; length $OPTS{'uncompress'} &amp;&amp; $OPTS{'uncompress'} &amp;&amp; $OPTS{'url'} =~ m/\.(bz2|xz)$/ );
    my $uncompress_ext   = $uncompress ? $1 : undef;

    my $compress_raw_bzip2_obj;
    my $compress_raw_lzma_obj;

    my $fetcher = $self-&gt;{fetcher} = $self-&gt;_fetcher( $self-&gt;{'timeout'} );

    if ($uncompress) {
        require Cpanel::Sync::Common;
        if ( !$Cpanel::Sync::Common::hasbzip2 &amp;&amp; $uncompress_ext eq 'bz2' ) {
            $destfile .= '.bz2';
        }
    }
    my $complete = 0;
    my $page     = '';
    my $quiet    = $self-&gt;{'hideOutput'} || 0;
    $url =~ tr/\///s;    # squash duplicate &quot;/&quot;

    ( $host, $OPTS{'port'} ) = split /:/, $host, 2 if !defined $OPTS{'port'} &amp;&amp; $host =~ tr/://;


    die '[ARGUMENT] a host must be specified at ' . (caller)[0] . ' line ' . (caller)[2] . &quot;\n&quot;
      if !$host;
    die '[ARGUMENT] a URL must be specified at ' . (caller)[0] . ' line ' . (caller)[2] . &quot;\n&quot;
      if !$url;

    print STDERR &quot;[request] $host/$url\n&quot; if $DEBUG;

    $url = &quot;/$url&quot; unless $url =~ m{^/};

    my $full_url = &quot;http://$host&quot; . ( $OPTS{'port'} ? &quot;:$OPTS{'port'}&quot; : &quot;&quot; ) . &quot;$url&quot;;

    $self-&gt;_output( ( &quot;\t&quot; x $self-&gt;{'level'}++ ) . &quot;Fetching $full_url (connected:&quot; . $self-&gt;{'connected'} . ')....' );

    my $fh;
    my $addresses = $OPTS{'addresslist'};

    {
        my $httptrycount = 0;

      HTTP_TRY:
        while ( !$complete &amp;&amp; $httptrycount &lt; $http_retry_count ) {    # should be &lt; then because we increment in the loop
            ++$httptrycount;
            if ($uncompress) {
                require Cpanel::Sync::Common;
                if ( $Cpanel::Sync::Common::hasbzip2 &amp;&amp; $uncompress_ext eq 'bz2' ) {
                    ($compress_raw_bzip2_obj) = Compress::Raw::Bunzip2-&gt;new( $Cpanel::Sync::Common::BZIP2_OVERWRITE_OUTPUT, $Cpanel::Sync::Common::BZIP2_CONSUME_INPUT );
                }
                elsif ( $Cpanel::Sync::Common::haslzma &amp;&amp; $uncompress_ext eq 'xz' ) {
                    ($compress_raw_lzma_obj) = Compress::Raw::Lzma::StreamDecoder-&gt;new();
                }
            }

            $self-&gt;_output(&quot;...(request attempt $httptrycount/$http_retry_count)...&quot;);

            my $method = $OPTS{'method'} || 'GET';
            my %reqargs;
            $reqargs{'headers'} = _convert_headers( $OPTS{'headers'} || {} );
            $reqargs{'content'} = $OPTS{'body'} if $OPTS{'body'};

            if ( length $destfile ) {
                my $callback;
                open( $fh, '&gt;', $destfile ) or die &quot;Can't open file: $!&quot;;
                if ($compress_raw_bzip2_obj) {
                    $callback = sub {
                        my $status = $compress_raw_bzip2_obj-&gt;bzinflate( $_[0], my $output );
                        if ( $status != $Cpanel::Sync::Common::BZ_OK &amp;&amp; $status != $Cpanel::Sync::Common::BZ_STREAM_END || !defined($output) ) {
                            die &quot;Decompressing chunked bzip2 data from $url to $destfile failed: $status&quot;;
                        }
                        print {$fh} $output;
                    };
                }
                elsif ($compress_raw_lzma_obj) {
                    $callback = sub {
                        my $status = $compress_raw_lzma_obj-&gt;code( $_[0], my $output );
                        if ( $status != $Cpanel::Sync::Common::LZMA_OK &amp;&amp; $status != $Cpanel::Sync::Common::LZMA_STREAM_END || !defined($output) ) {
                            die &quot;Decompressing chunked lzma data from $url to $destfile failed: $status&quot;;
                        }
                        print {$fh} $output;
                    };
                }
                else {
                    $callback = sub {
                        print {$fh} $_[0];
                    };
                }
                $reqargs{'data_callback'} = $callback;
            }
            else {
                $reqargs{'data_callback'} = sub {
                    $page .= $_[0];
                };
            }

            my $actual_url = $self-&gt;_initrequest(
                host         =&gt; $host,
                url          =&gt; $url,
                port         =&gt; $OPTS{'port'},
                headers      =&gt; $reqargs{'headers'},
                addresslist  =&gt; $OPTS{'addresslist'},
                attempt      =&gt; $httptrycount,
                max_attempts =&gt; $http_retry_count,
                destfile     =&gt; $destfile,
            ) or next HTTP_TRY;

            $reqargs{'peer'} = $self-&gt;{'connectedHostAddress'};

            $self-&gt;_output('...receiving...');
            my $response = eval { $fetcher-&gt;request( $method, $actual_url, \%reqargs ); };
            $response = { status =&gt; 599 } if $@;

            if ( $self-&gt;{die_on_4xx_5xx} &amp;&amp; $response &amp;&amp; $response-&gt;{status} =~ /^[45]/ ) {
                require Cpanel::Exception;
                die Cpanel::Exception::create(
                    'HTTP::Server',
                    [
                        method  =&gt; $method,
                        url     =&gt; $actual_url,
                        status  =&gt; $response-&gt;{status},
                        reason  =&gt; $response-&gt;{reason},
                        headers =&gt; $response-&gt;{headers},
                        content =&gt; $response-&gt;{content},
                    ]
                );
            }

            $complete = ( $response-&gt;{status} =~ /^2\d\d$/ ? 1 : 0 );
            my $status   = $self-&gt;{last_status} = $response-&gt;{status};
            my $httpline = &quot;$status $response-&gt;{reason}&quot;;

            if ($complete) {
                my $lm = $response-&gt;{'headers'} ? $response-&gt;{'headers'}{'last-modified'} : undef;
                $lm = $lm-&gt;[-1] if ref $lm eq 'ARRAY';
                $self-&gt;{'last_modified'} = $lm;
            }

            if ( $status == 304 ) {
                $self-&gt;_output(&quot;...not modified...&quot;);
                $self-&gt;{'connected'} = 1;
                $self-&gt;{'level'}--;

                return q{};
            }

            if ( $response-&gt;{status} == 599 ) {
                my $error = $response-&gt;{content};
                chomp $error;
                $self-&gt;_output(&quot;...$error...&quot;);
                $self-&gt;{'connected'} = 0;
                $self-&gt;_skip_failed_mirror();
                next HTTP_TRY;
            }

            if ( $status !~ /^2/ ) {
                $self-&gt;_output(&quot;Error $status while fetching URL $full_url\n&quot;);
                if ( length $destfile ) {
                    close($fh);
                    unlink $destfile;
                }
                $self-&gt;{'last_exception'} = &quot;$status - $httpline - HTTP ERROR&quot;;
            }

            if ($complete) {
                $self-&gt;{'connectedHostFailCount'}{ $self-&gt;{'connectedHostAddress'} } = 0;
            }
            else {
                $self-&gt;disconnect();
                if ( ++$self-&gt;{'connectedHostFailCount'}{ $self-&gt;{'connectedHostAddress'} } &lt; 3 ) {
                    $self-&gt;_output(&quot;...server closed connection (failcount=$self-&gt;{'connectedHostFailCount'}{$self-&gt;{'connectedHostAddress'}})...&quot;);
                    if ( $self-&gt;{'last_exception'} &amp;&amp; $self-&gt;{'last_exception'} =~ m{HTTP ERROR} ) {

                        $self-&gt;_skip_failed_mirror();
                    }
                }
                else {
                    $self-&gt;_output(&quot;...failover...&quot;);
                    $self-&gt;_remove_failed_mirror();
                }

                if ( $self-&gt;{'last_status'} eq '404' &amp;&amp; grep { $_-&gt;{'die_on_404'} } $self, \%OPTS ) {
                    local $@ = $self-&gt;{'last_exception'};
                    die;
                }
                elsif ( $self-&gt;{'last_status'} eq '404' &amp;&amp; grep { $_-&gt;{'return_on_404'} } $self, \%OPTS ) {
                    $self-&gt;{'level'}--;
                    return wantarray ? ( '', 0 ) : 0;
                }
                elsif ( $self-&gt;{'last_status'} eq '404' &amp;&amp; grep { $_-&gt;{'exitOn404'} } $self, \%OPTS ) {
                    $self-&gt;_output(&quot;...Distribution not required.\n&quot;);
                    exit;
                }
            }

        }
    }

    if ( !$complete &amp;&amp; grep { $_-&gt;{'die_on_error'} } $self, \%OPTS ) {
        local $@ = $self-&gt;{'last_exception'};
        die;
    }

    $self-&gt;_output(&quot;...request success...&quot;) if $complete;
    $self-&gt;_output(&quot;...Done\n&quot;);

    if ( length $destfile ) {
        close($fh);
        if ( !$uncompress ) {
        }
        elsif ( !$Cpanel::Sync::Common::hasbzip2 &amp;&amp; $uncompress_ext eq 'bz2' ) {
            Cpanel::Sync::Common::unbzip2($destfile);
        }
        elsif ( !$Cpanel::Sync::Common::haslzma &amp;&amp; $uncompress_ext eq 'xz' ) {
            my $suffix = &quot;__DEFLATE__$$&quot;;
            rename $destfile, &quot;$destfile.$suffix.xz&quot;
              or die &quot;Failed to rename temporary file '$destfile' to '$destfile.$suffix.xz': $!&quot;;
            require Cpanel::SafeRun::Simple;
            Cpanel::SafeRun::Simple::saferun( 'unxz', '-f', &quot;$destfile.$suffix.xz&quot; )
              and die &quot;Failed to decompress XZ data from '$destfile'&quot;;
            rename &quot;$destfile.$suffix&quot;, $destfile
              or die &quot;Failed to rename decompressed temporary file '$destfile.$suffix' to '$destfile': $!&quot;;
        }
    }

    if ( $complete == 0 ) {
        $self-&gt;disconnect();
        $self-&gt;{'fetcher'} = $fetcher = undef;
    }
    else {
        $self-&gt;{'connected'} = 1;
    }

    $self-&gt;{'level'}--;
    if ( length $destfile ) {
        return wantarray ? ($complete) : $complete;
    }
    return wantarray ? ( $page, $complete ) : $page;
}

sub disconnect {
    my ($self) = @_;
    $self-&gt;_socket_destroy();
    return $self-&gt;{'connected'} = 0;
}


sub last_status {
    my ($self) = @_;
    return $self-&gt;{'last_status'};
}


sub last_modified {
    my ($self) = @_;
    return $self-&gt;{'last_modified'};
}


sub is_unmodified {
    my ( $self, %opts ) = @_;

    return 0 unless length $opts{'last_modified'};

    my $ok = eval {
        my $alarm;
        if ( $opts{'timeout'} ) {
            require Cpanel::Alarm;
            $alarm = Cpanel::Alarm-&gt;new( $opts{'timeout'}, sub { die &quot;Timeout during conditional request.\n&quot; } );
        }

        $self-&gt;request(
            'host'    =&gt; $opts{'host'},
            'url'     =&gt; $opts{'url'},
            'headers' =&gt; { 'If-Modified-Since' =&gt; $opts{'last_modified'} },
        );
        1;
    };

    return ( $ok &amp;&amp; ( $self-&gt;last_status() // 0 ) == 304 ) ? 1 : 0;
}

sub make_http_query_string {
    my ($query) = @_;
    return $query unless ref $query;    # If query is a string, return it.

    require Cpanel::Encoder::URI;
    my ( $querystr, $delim, $enckey ) = ( '', '' );
    if ( ref $query eq 'ARRAY' ) {
        if ( @{$query} &amp; 1 ) {
            Cpanel::Debug::log_invalid('Query key with no value.');
            return;
        }
        my $val;

        for ( my $i = 0; $i &lt; $#{$query}; $i += 2 ) {
            ( $enckey, $val ) = ( Cpanel::Encoder::URI::uri_encode_str( $query-&gt;[$i] ), $query-&gt;[ $i + 1 ] );
            next unless $enckey;    #if we don't have a key, ignore it

            if ( ref $val eq 'ARRAY' ) {

                $querystr .= $delim . join( '&amp;', map { &quot;$enckey=&quot; . ( Cpanel::Encoder::URI::uri_encode_str($_) // '' ) } @{$val} );
            }
            else {
                $querystr .= &quot;$delim$enckey=&quot; . ( Cpanel::Encoder::URI::uri_encode_str($val) // '' );
            }
            $delim ||= '&amp;';
        }
    }
    elsif ( ref $query eq 'HASH' ) {
        foreach my $key ( sort keys %{$query} ) {
            $enckey = Cpanel::Encoder::URI::uri_encode_str($key);
            next unless $enckey;    #if we don't have a key, ignore it

            if ( ref $query-&gt;{$key} eq 'ARRAY' ) {

                $querystr .= $delim . join( '&amp;', map { &quot;$enckey=&quot; . ( Cpanel::Encoder::URI::uri_encode_str($_) // '' ) } @{ $query-&gt;{$key} } );
            }
            else {
                $querystr .= &quot;$delim$enckey=&quot; . ( Cpanel::Encoder::URI::uri_encode_str( $query-&gt;{$key} ) // '' );
            }
            $delim ||= '&amp;';
        }
    }
    else {
        Cpanel::Debug::log_invalid('Unrecognized type for query parameter.');
        return;
    }

    return $querystr;
}

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

    require Cpanel::Encoder::URI;
    my $query = $args_hr-&gt;{'query'};
    if ( ref $args_hr-&gt;{'query'} eq 'HASH' ) {
        $query = '';
        foreach my $key ( keys %{ $args_hr-&gt;{'query'} } ) {
            if ( ref $args_hr-&gt;{'query'}{$key} eq 'ARRAY' ) {
                for my $val ( @{ $args_hr-&gt;{'query'}{$key} } ) {
                    $query .=
                      $query
                      ? &quot;&amp;$key=&quot; . Cpanel::Encoder::URI::uri_encode_str($val)
                      : &quot;$key=&quot; . Cpanel::Encoder::URI::uri_encode_str($val);
                }
            }
            else {
                $query .=
                  $query
                  ? &quot;&amp;$key=&quot; . Cpanel::Encoder::URI::uri_encode_str( $args_hr-&gt;{'query'}{$key} )
                  : &quot;$key=&quot; . Cpanel::Encoder::URI::uri_encode_str( $args_hr-&gt;{'query'}{$key} );
            }
        }
    }

    my $postdata_len = length($query);

    my $proto = getprotobyname('tcp');
    return unless defined $proto;

    socket( my $socket_fh, &amp;Socket::AF_INET, &amp;Socket::SOCK_STREAM, $proto );
    return unless $socket_fh;

    my $iaddr = gethostbyname( $args_hr-&gt;{'host'} );
    my $port  = $self-&gt;_socket_default_port();
    return unless ( defined $iaddr &amp;&amp; defined $port );

    my $sin = Socket::sockaddr_in( $port, $iaddr );
    return unless defined $sin;

    if ( connect( $socket_fh, $sin ) ) {

        send $socket_fh, &quot;POST /$args_hr-&gt;{'uri'} HTTP/1.0\r\nContent-Length: $postdata_len\r\nHost: $args_hr-&gt;{'host'}\r\n\r\n$query&quot;, 0;

        if ( ref $args_hr-&gt;{'output_handler'} eq 'CODE' ) {
            my $in_header = 1;
            while (&lt;$socket_fh&gt;) {
                if ( /^\n$/ || /^\r\n$/ || /^$/ ) {
                    $in_header = 0;
                    next;
                }

                $args_hr-&gt;{'output_handler'}-&gt;( $_, $in_header );
            }
        }
    }

    close $socket_fh;
    return;
}

sub download {
    my ( $self, $url, $file, $is_signed ) = @_;

    unlink $file if defined $file;
    $is_signed = defined $is_signed ? $is_signed : $self-&gt;{'signed'};

    my $parsed_url = Cpanel::URL::parse($url);
    my $res        = $self-&gt;request(
        'host'     =&gt; $parsed_url-&gt;{'host'},
        'url'      =&gt; $parsed_url-&gt;{'uri'},
        'destfile' =&gt; $file,
        'protocol' =&gt; 0,
        'method'   =&gt; 'GET',
        'signed'   =&gt; $is_signed,
    );
    return $res;
}

sub http_request {
    my ( $self, $p_method, $p_host, $p_uri, %p_options ) = @_;


    die '[ARGUMENT] a host must be specified at ' . (caller)[0] . ' line ' . (caller)[2] . &quot;\n&quot;
      if !$p_host;
    die '[ARGUMENT] a URI must be specified at ' . (caller)[0] . ' line ' . (caller)[2] . &quot;\n&quot;
      if !$p_uri;

    my $method = $p_options{'method'} || $p_method;
    die '[ARGUMENT] a method must be specified at ' . (caller)[0] . ' line ' . (caller)[2] . &quot;\n&quot;
      if !$p_method;

    my $content_type = $p_options{'content_type'};

    unlink $p_options{'file'}
      if defined $p_options{'file'};

    my %OPTS = (
        'host'     =&gt; $p_host,
        'port'     =&gt; $p_options{'port'},
        'url'      =&gt; $p_uri,
        'protocol' =&gt; 0,
        'method'   =&gt; $method,
        'destfile' =&gt; $p_options{'file'}
    );

    if ( defined $p_options{'content'} ) {
        $OPTS{'body'} = $p_options{'content'};
        $content_type ||= 'text/plain';
    }

    my %headers;
    %headers = %{ $p_options{'headers'} }
      if ref $p_options{'headers'} eq ref {};
    $headers{'Content-Type'} = $content_type
      if $content_type;
    $OPTS{'headers'} = join( '', map { &quot;$_: $headers{$_}\r\n&quot; } keys %headers )
      if keys %headers;

    return $self-&gt;request(%OPTS);
}

sub httpreq {
    my ( $self, $host, $url, $file, %p_options ) = @_;
    return $self-&gt;http_request( 'GET', $host, $url, 'file' =&gt; $file, %p_options );
}

sub httpput {
    my ( $self, $host, $uri, $content, %p_options ) = @_;
    return $self-&gt;http_request( 'PUT', $host, $uri, 'content' =&gt; $content, %p_options );
}

sub httppost {
    my ( $self, $host, $url, $qparms, $file, %p_options ) = @_;
    my $content;
    $content = make_http_query_string($qparms)
      if defined $qparms;
    return $self-&gt;http_request( 'POST', $host, $url, 'content' =&gt; $content, 'content_type' =&gt; 'application/x-www-form-urlencoded', 'file' =&gt; $file, %p_options );
}

sub skiphost {
    my $self = shift;
    $self-&gt;disconnect();
    $self-&gt;_remove_failed_mirror();
    return;
}

sub _getAddressList {    ## no critic(Subroutines::ProhibitExcessComplexity)  -- Added with case SEC-398, out of scope for a TSR.
    my ( $self, $host, $port ) = @_;

    print STDERR &quot;[_getAddressList][$host]\n&quot; if $DEBUG;

    my $quiet                 = $self-&gt;{'hideOutput'} || 0;
    my $resolve_attempt_count = 1;

    my ( $cache_key, $homedir, @trueaddresses, $loaded_cache );

    if ( $self-&gt;{'use_dns_cache'} ) {
        $homedir   = ( getpwuid($&gt;) )[7];
        $cache_key = $host;
        $cache_key =~ s/\///g;

        if ( !-e $homedir . '/.HttpRequest' ) {
            mkdir $homedir . '/.HttpRequest', 0700;
        }
        if ( -e $homedir . '/.HttpRequest/' . $cache_key &amp;&amp; ( ( stat(_) )[9] + $self-&gt;{'dns_cache_ttl'} ) &gt; time() ) {
            if ( open( my $address_cache_fh, '&lt;', $homedir . '/.HttpRequest/' . $cache_key ) ) {
                local $/;
                @trueaddresses = split( /\n/, readline($address_cache_fh) );
                $loaded_cache  = 1;
                close($address_cache_fh);
                $self-&gt;_output(&quot;Using dns cache file $homedir/.HttpRequest/$cache_key...&quot;);
            }
            else {
                $self-&gt;_output(&quot;Loading dns cache file $homedir/.HttpRequest/$cache_key failed ($!)...&quot;);
            }
        }
    }

    while ( !@trueaddresses ) {
        $loaded_cache = 0;

        $self-&gt;_output(&quot;Resolving $host...(resolve attempt $resolve_attempt_count/${MAX_RESOLVE_ATTEMPT})...&quot;);
        @trueaddresses = Cpanel::SocketIP::_resolveIpAddress($host);
        last if (@trueaddresses);
        $self-&gt;_output(&quot;Resolving $host using backup method...&quot;);
        eval 'require Cpanel::DnsRoots; $has_cpanel_dnsRoots=1'                   if !$has_cpanel_dnsRoots;
        @trueaddresses = 'Cpanel::DnsRoots'-&gt;can('resolveIpAddressBAMP')-&gt;($host) if $has_cpanel_dnsRoots;
        last                                                                      if ( @trueaddresses || !$self-&gt;{'retry_dns'} || $resolve_attempt_count++ &gt;= $MAX_RESOLVE_ATTEMPT );

        $self-&gt;_output(&quot;Waiting for dns resolution to become available....&quot;);
        sleep 1;
    }

    print STDERR &quot;[finished address lookups]\n&quot; if $DEBUG;

    if ($SIMULATE_FAILURE) {
        @trueaddresses = ( '1.1.1.1', '2.2.2.2' );
    }

    Cpanel::ArrayFunc::Shuffle::shuffle( \@trueaddresses );

    if ( !@trueaddresses ) {
        my $errormsg = &quot;$host could not be resolved to an IP address. Please check your /etc/resolv.conf file.\n&quot;;
        Cpanel::Debug::log_warn($errormsg);
        if ( $self-&gt;{'die_on_error'} ) {
            die $errormsg;
        }
        return wantarray ? () : [];
    }
    elsif ( !$self-&gt;{'speed_test_enabled'} ) {
        @trueaddresses = ( $trueaddresses[0] );
    }
    elsif ( @trueaddresses &gt; 1 ) {
        print STDERR &quot;[has resolved, testing]\n&quot; if $DEBUG;
        if ( !$loaded_cache ) {

            if ( $self-&gt;{'use_mirror_addr_list'} || $host eq 'httpupdate.cpanel.net' ) {
                $self-&gt;_output(&quot;\n&quot;);
                my $mirror_addr_list = $self-&gt;request( 'level' =&gt; 1, 'addresslist' =&gt; \@trueaddresses, 'host' =&gt; $host, 'url' =&gt; '/mirror_addr_list', 'protocol' =&gt; 1, 'http_retry_count' =&gt; 3 );
                my @mirror_addr_list_ADDR_LIST;
                if ($mirror_addr_list) {
                    foreach my $line ( split( /\n/, $mirror_addr_list ) ) {
                        chomp($line);
                        my ($ipaddr) = split( /=/, $line );
                        push @mirror_addr_list_ADDR_LIST, $ipaddr if ( $ipaddr =~ /^[\d\.\:]+$/ );
                    }
                }
                if (@mirror_addr_list_ADDR_LIST) {
                    $self-&gt;_output( &quot;...found &quot; . scalar @mirror_addr_list_ADDR_LIST . &quot; host(s) from mirror_addr_list...&quot; );
                    @trueaddresses = @mirror_addr_list_ADDR_LIST;
                }
            }
            if ( $self-&gt;{'use_dns_cache'} &amp;&amp; @trueaddresses ) {
                if ( open( my $address_cache_fh, '&gt;', $homedir . '/.HttpRequest/' . $cache_key ) ) {
                    print {$address_cache_fh} join( &quot;\n&quot;, @trueaddresses );
                    close($address_cache_fh);
                }
            }
        }
        if ( ++$self-&gt;{'mirror_search_attempts'}{$host} == 4 ) {    # first time  = loaded from cache
            die &quot;$host did not have any working mirrors.  Please check your internet connection or dns server.&quot;;
        }
        $self-&gt;_output( &quot;...searching for mirrors (mirror search attempt &quot; . $self-&gt;{'mirror_search_attempts'}{$host} . &quot;/3)...&quot; );


        require Cpanel::MirrorSearch;
        my @goodurls = Cpanel::MirrorSearch::findfastest(
            'days'  =&gt; ( 2.0 / 24 ),
            'key'   =&gt; $host,
            'count' =&gt; 10,
            'urls'  =&gt; [ Cpanel::UrlTools::buildurlfromuri( \@trueaddresses, $self-&gt;{'speed_test_file'} ) ],
            'quiet' =&gt; $self-&gt;{'htmlOutput'} ? 1 : $quiet,
            'port'  =&gt; $port || $self-&gt;_socket_default_port()
        );

        if ( @trueaddresses = Cpanel::UrlTools::extracthosts( \@goodurls ) ) {
            $self-&gt;_output(&quot;...mirror search success...&quot;);

            $self-&gt;{'mirror_search_attempts'}{$host} = 0;
        }
        else {
            $self-&gt;_output(&quot;...mirror search failed...&quot;);
        }

        if ( !@trueaddresses &amp;&amp; $self-&gt;{'use_dns_cache'} ) {

            $self-&gt;_destroy_ip_cache($host);
        }

    }

    if ($SIMULATE_FAILURE) {
        return wantarray ? () : [];
    }

    return wantarray ? @trueaddresses : \@trueaddresses;
}

sub _remove_failed_mirror {
    my $self = shift;

    my $addr = $self-&gt;{'connectedHostAddress'};    #ip of connected host

    print STDERR &quot;[_remove_failed_mirror] $addr\n&quot; if $DEBUG;

    $self-&gt;_output(&quot;...removing $addr...&quot;);

    if ( $self-&gt;{'host'} ) {
        @{ $self-&gt;{'hostIps'}{ $self-&gt;{'host'} } } = grep( !m/^\Q$addr\E$/, @{ $self-&gt;{'hostIps'}{ $self-&gt;{'host'} } } );
    }
    require Cpanel::MirrorSearch;
    Cpanel::MirrorSearch::remove_mirror( 'key' =&gt; $self-&gt;{'connectedHostname'}, 'addr' =&gt; $addr );

    if ( !$self-&gt;{'host'} || !@{ $self-&gt;{'hostIps'}{ $self-&gt;{'host'} } } &amp;&amp; $self-&gt;{'use_dns_cache'} ) {

        $self-&gt;_destroy_ip_cache();
    }

    return;
}

sub _skip_failed_mirror {
    my $self = shift;

    my $addr = $self-&gt;{'connectedHostAddress'};    #ip of connected host

    print STDERR &quot;[_skip_failed_mirror] $addr\n&quot; if $DEBUG;

    $self-&gt;_output(&quot;...skipping $addr...&quot;);

    @{ $self-&gt;{'hostIps'}{ $self-&gt;{'host'} } } = grep( !m/^\Q$addr\E$/, @{ $self-&gt;{'hostIps'}{ $self-&gt;{'host'} } } );

    push @{ $self-&gt;{'skipped_hostIps'}{ $self-&gt;{'host'} } }, $addr;    # if ! grep( !m/^\Q$addr\E$/, @{ $self-&gt;{'skipped_hostIps'}{ $self-&gt;{'host'} } } );;

    if ( !@{ $self-&gt;{'hostIps'}{ $self-&gt;{'host'} } } &amp;&amp; @{ $self-&gt;{'skipped_hostIps'}{ $self-&gt;{'host'} } } ) {
        @{ $self-&gt;{'hostIps'}{ $self-&gt;{'host'} } } = @{ $self-&gt;{'skipped_hostIps'}{ $self-&gt;{'host'} } };
        $self-&gt;{'skipped_hostIps'}{ $self-&gt;{'host'} } = [];            # important to clear out this since we moved them to hostIps
    }
    return;
}

sub _destroy_ip_cache {
    my $self      = shift;
    my $cache_key = shift || $self-&gt;{'connectedHostname'};
    my $homedir   = ( getpwuid($&gt;) )[7];
    $cache_key =~ s/\///g;
    unlink(&quot;$homedir/.HttpRequest/$cache_key&quot;);    # Kill the cache if we run out of working hosts so it will rebuild
    return;
}

sub _convert_headers {
    my ($headers) = @_;
    if ( !ref $headers ) {
        my @lines = split /\r\n/, $headers;
        $headers = {};
        foreach my $line (@lines) {
            last unless length $line;
            my ( $key, $value ) = split /:\s*/, $line, 2;
            next unless length $key;
            $headers-&gt;{$key} ||= [];
            push @{ $headers-&gt;{$key} }, $value;
        }
    }
    return $headers;
}

sub _socket_default_port {
    my $self = shift;
    return ( getservbyname( 'http', 'tcp' ) )[2];
}

sub _socket_destroy {
    my $self = shift;
    delete $self-&gt;{'fetcher'};
    return 1;
}

sub _initrequest {    ## no critic qw(Subroutines::ProhibitExcessComplexity)
    my ( $self, %OPTS ) = @_;
    $self-&gt;{'last_status'} = undef;

    print STDERR &quot;\n\n\n\n[_initrequest]\n&quot; if $DEBUG;

    my $host = $OPTS{'host'};
    $self-&gt;{'host'} = $host || die &quot;Host is missing&quot;;

    $self-&gt;{'hostIps'}{$host}         ||= [];
    $self-&gt;{'skipped_hostIps'}{$host} ||= [];

    my $url           = $OPTS{'url'};
    my $http_protocol = $OPTS{'http_protocol'};
    my $destfile      = $OPTS{'destfile'};
    my $headers       = $OPTS{'headers'};
    my $port          = $OPTS{'port'};
    my $method        = $OPTS{'method'} || 'GET';

    $self-&gt;{'connected'} = 0 if ( $self-&gt;{'connectedHostname'} ne $host );

    my $has_an_addresslist = ( exists $OPTS{'addresslist'} &amp;&amp; ref $OPTS{'addresslist'} ) ? 1 : 0;

    if ( ( $self-&gt;{'using_addresslist'}{$host} &amp;&amp; !$has_an_addresslist ) || ( !$self-&gt;{'using_addresslist'}{$host} &amp;&amp; $has_an_addresslist ) || $SIMULATE_FAILURE ) {
        delete $self-&gt;{'using_addresslist'}{$host};
        $self-&gt;{'hostIps'}{$host} = $self-&gt;{'skipped_hostIps'}{$host} = [];
        $self-&gt;{'connected'}      = 0;                                        # We must also disconnect because we may not be connected
    }

    if ($DEBUG) {
        print STDERR &quot;[about to get ips has_an_addresslist=($has_an_addresslist)]\n&quot;;
        my $hostips_defined         = @{ $self-&gt;{'hostIps'}{$host} }         ? 1 : 0;
        my $skipped_hostips_defined = @{ $self-&gt;{'skipped_hostIps'}{$host} } ? 1 : 0;
        print &quot;[HOSTIPS_DEFINED] $hostips_defined [SKIPPEDHOSTIPS_DEFINED] $skipped_hostips_defined\n&quot;;
    }

    if ( !@{ $self-&gt;{'hostIps'}{$host} } &amp;&amp; !@{ $self-&gt;{'skipped_hostIps'}{$host} } ) {
        print STDERR &quot;[...doing address lookup block...]\n&quot; if $DEBUG;
        if ( @{ $self-&gt;{'hostIps'}{$host} } = $has_an_addresslist ? @{ $OPTS{'addresslist'} } : $self-&gt;_getAddressList( $host, $port ) ) {
            if ($has_an_addresslist) { $self-&gt;{'using_addresslist'}{$host} = 1; }
            if ($DEBUG) {
                my $hostips_defined = @{ $self-&gt;{'hostIps'}{$host} } ? 1 : 0;
                print STDERR &quot;[....addresslist load or getAddressList ok...] ($hostips_defined)\n&quot;;
            }

        }
        else {
            print STDERR &quot;[...failed to resolve $host...]\n&quot; if $DEBUG;

            return;
        }

    }

    print STDERR &quot;[init_req finished populating hostIps]\n&quot; if $DEBUG;

    my $port_suffix = $OPTS{'port'} ? &quot;:$OPTS{'port'}&quot; : &quot;&quot;;

    $url =~ s/\s/\%20/g;
    $url ||= '/';

    $headers-&gt;{Accept} ||= &quot;text/html, text/plain, audio/mod, image/*, application/msword, application/pdf, application/postscript, text/sgml, */*;q=0.01&quot;;

    foreach my $addr ( @{ $self-&gt;{'hostIps'}{$host} } ) {
        $self-&gt;{'connectedHostAddress'} = $addr;    #must be set before we actually connect() in setupsocket
        $self-&gt;{'connectedHostname'}    = $host;
        $self-&gt;{'connectedHostFailCount'}{$addr} ||= 0;
        $self-&gt;{'connected'} = 1;
        my $local_logger = $self-&gt;{'logger'};

        if ( $self-&gt;{'announce_mirror'} &amp;&amp; ( !defined $self-&gt;{'_previous_mirror_used'} || $self-&gt;{'_previous_mirror_used'} ne $addr ) ) {
            $self-&gt;{'_previous_mirror_used'} = $addr;
            $local_logger-&gt;info(&quot;Using mirror '${addr}' for host '${host}'.&quot;);
        }
        last;
    }
    $self-&gt;_output( '@' . $self-&gt;{'connectedHostAddress'} . '...' );

    return &quot;http://$host$port_suffix$url&quot;;
}

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

    if ( $self-&gt;{'logger'}-&gt;can('die') ) {
        return $self-&gt;{'logger'}-&gt;die($msg);
    }
    else {
        die &quot;$msg\n&quot;;
    }
}

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

    return $self-&gt;_die( $msg . ' Please see https://go.cpanel.net/sigerrors for further information about this error.' );
}

sub get_crypt_gpg_vendorkey_verify {
    my ( $self, %opts ) = @_;

    my ( $gpg_vendor, $gpg_category ) = @opts{qw(vendor categories)};
    $gpg_vendor   ||= $self-&gt;{'vendor'};
    $gpg_category ||= $self-&gt;{'categories'};
    my $key = join( '__', $gpg_vendor, ref $gpg_category ? @$gpg_category : $gpg_category );

    return $self-&gt;{'_gpg_verify'}{$key} if $self-&gt;{'_gpg_verify'}{$key};

    require Cpanel::Crypt::GPG::VendorKeys::Verify;

    my ( $gpg, $gpg_msg ) = Cpanel::Crypt::GPG::VendorKeys::Verify-&gt;new(
        vendor     =&gt; $gpg_vendor,
        categories =&gt; $gpg_category,
    );

    return ( $gpg, $gpg_msg ) if !$gpg;

    $self-&gt;{'_gpg_verify'}{$key} = $gpg;
    return ( $gpg, $gpg_msg );
}

1;

} # --- END Cpanel/HttpRequest.pm


{ # --- BEGIN Cpanel/Update/Tiers.pm
package Cpanel::Update::Tiers;


use strict;
use warnings;

# use Cpanel::JSON                         ();
# use Cpanel::FileUtils::Write::JSON::Lazy ();
# use Cpanel::OS                           ();
# use Cpanel::Update::Config               ();
# use Cpanel::Version::Full                ();
# use Cpanel::Version::Compare             ();

use Scalar::Util ();

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

    my $self = {};
    $self-&gt;{'tiers_url'}  = $args{'tiers_url'}  || '/cpanelsync/TIERS.json';
    $self-&gt;{'tiers_path'} = $args{'tiers_path'} || '/etc/cpanel/TIERS.json';

    $self-&gt;{'cache_expiration_time'} = $args{'cache_expiration_time'} || $ENV{'CPANEL_BASE_INSTALL'} ? 6 * 3600 : 300;

    $self-&gt;{'logger'} = $args{'logger'} if $args{'logger'};

    return bless $self, $class;
}


sub logger {
    my $self = shift || die(&quot;logger is a method call&quot;);

    require Cpanel::Logger;
    $self-&gt;{'logger'} ||= Cpanel::Logger-&gt;new();
    return $self-&gt;{'logger'};
}


sub sync_tiers_file {
    my $self = shift || die(&quot;sync_tiers_file is a method call&quot;);

    my $remote_tiers_host = $self-&gt;_remote_tiers_host;

    my $http = $self-&gt;_http_request( 'die_on_404' =&gt; 1 );

    my $tiers_json;
    {
        require Cpanel::Alarm;
        my $alarm = Cpanel::Alarm-&gt;new( 45, sub { die 'Timeout while fetching version information.' } );
        $tiers_json = $http-&gt;request(
            'host'   =&gt; $remote_tiers_host,
            'url'    =&gt; $self-&gt;{'tiers_url'},
            'signed' =&gt; 1,
        );
    }

    if ( !$tiers_json ) {
        die(&quot;Error downloading ${remote_tiers_host}/cpanelsync/TIERS.json&quot;);
    }

    my $json_hr = Cpanel::JSON::Load($tiers_json) or die(&quot;Could not load ${remote_tiers_host}/cpanelsync/TIERS.json: $@&quot;);

    if ( !-e $self-&gt;{'tiers_path'} ) {
        require File::Basename;
        my ( $basename, $dirname, $suffix ) = File::Basename::fileparse( $self-&gt;{'tiers_path'} );

        if ( !-e $dirname ) {
            require Cpanel::SafeDir::MK;
            Cpanel::SafeDir::MK::safemkdir( $dirname, 0755 );
        }
    }
    return 0 unless Cpanel::FileUtils::Write::JSON::Lazy::write_file( $self-&gt;{'tiers_path'}, $json_hr, 0644 );

    $self-&gt;_write_lastmod_cache( $http-&gt;last_modified() );

    return 1;
}


sub _write_lastmod_cache {
    my ( $self, $last_modified ) = @_;
    die(&quot;_write_lastmod_cache is a method call&quot;) unless ref $self;

    my $path = $self-&gt;{'tiers_path'} . '.lastmod';

    if ( !length $last_modified ) {
        unlink $path;
        return;
    }

    require Cpanel::FileUtils::Write;
    Cpanel::FileUtils::Write::overwrite_no_exceptions( $path, $last_modified . &quot;\n&quot;, 0644 );

    return;
}


sub _read_lastmod_cache {
    my ($self) = @_;
    die(&quot;_read_lastmod_cache is a method call&quot;) unless ref $self;

    my $path = $self-&gt;{'tiers_path'} . '.lastmod';
    return unless -e $path &amp;&amp; !-z _;

    open my $fh, '&lt;', $path or return;
    my $val = readline $fh;
    close $fh;

    return unless defined $val;
    $val =~ s/\s+\z//;

    return length $val ? $val : undef;
}


sub _remote_tiers_is_unchanged {
    my ($self) = @_;
    die(&quot;_remote_tiers_is_unchanged is a method call&quot;) unless ref $self;

    my $last_modified = $self-&gt;_read_lastmod_cache() or return 0;
    return 0 if !-e $self-&gt;{'tiers_path'} || -z _;

    return $self-&gt;_http_request()-&gt;is_unmodified(
        'host'          =&gt; $self-&gt;_remote_tiers_host,
        'url'           =&gt; $self-&gt;{'tiers_url'},
        'last_modified' =&gt; $last_modified,
        'timeout'       =&gt; 45,
    );
}


sub _remote_tiers_host {
    my ($self) = @_;
    die(&quot;_remote_tiers_host is a method call&quot;) unless ref $self;

    require Cpanel::Config::Sources;
    return Cpanel::Config::Sources::get_source('HTTPUPDATE');
}


sub _http_request {
    my ( $self, %extra ) = @_;
    die(&quot;_http_request is a method call&quot;) unless ref $self;

    require Cpanel::HttpRequest;
    return Cpanel::HttpRequest-&gt;new(
        'logger'     =&gt; ( Scalar::Util::blessed( $self-&gt;logger() ) ? $self-&gt;logger() : undef ),    # undef restores the legacy behavior
        'hideOutput' =&gt; 1,
        'retry_dns'  =&gt; 0,
        %extra,
    );
}


sub tiers_hash {
    my ( $self, %opts ) = @_;
    die(&quot;tiers_hash is a method call&quot;) unless ref $self;

    return $self-&gt;{'tiers_hash'} if exists $self-&gt;{'tiers_hash'};

    my $tiers_hr = eval {
        if ( $self-&gt;tiers_cache_expired() ) {

            $self-&gt;sync_tiers_file()
              unless $opts{'security_check'} &amp;&amp; $self-&gt;_remote_tiers_is_unchanged();
        }

        Cpanel::JSON::SafeLoadFile( $self-&gt;{'tiers_path'} );
    };
    if ($@) {
        my $error = 'Failed to load version ' . $self-&gt;{'tiers_path'} . ' file: ' . $@;
        if ( $self-&gt;logger-&gt;can('error') ) {
            $self-&gt;logger-&gt;error($error);
        }
        else {
            $self-&gt;logger-&gt;warn($error);
        }

        if ( -e $self-&gt;{'tiers_path'} ) {
            unlink $self-&gt;{'tiers_path'}
              or $self-&gt;logger-&gt;warn( 'Failed to unlink corrupt version file ' . $self-&gt;{'tiers_path'} . &quot;: $!&quot; );
        }

        return;
    }

    $self-&gt;{'tiers_hash'} = $tiers_hr;
    return $self-&gt;{'tiers_hash'};
}


sub tiers_cache_expired {
    my $self = shift || die(&quot;tiers_cache_expired is a method call&quot;);

    if ( !-e $self-&gt;{'tiers_path'} || -z _ || ( ( stat(_) )[9] + $self-&gt;{'cache_expiration_time'} ) &lt; time ) {
        return 1;
    }
    else {
        return 0;
    }
}


sub get_current_lts_expiration_status {
    my $self = shift || die(&quot;get_current_lts_expiration_status is a method call&quot;);
    my %results;

    $results{'full_version'} = Cpanel::Version::Full::getversion();
    $results{'expiration'}   = $self-&gt;get_expires_for_version( $results{'full_version'} );

    return unless defined $results{'expiration'};

    $results{'expires_in_next_three_months'} = 0;
    my $time = time;

    my $time_three_months_from_now = $time + 3600 * 24 * 90;

    if ( $results{'expiration'} &amp;&amp; ($time_three_months_from_now) &gt; $results{'expiration'} ) {
        $results{'expires_in_next_three_months'} = 1;
    }

    return \%results;
}

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

    return $self-&gt;_visit_major_builds_from_version(
        $version,
        sub {
            my ($build) = @_;

            return $build if $build &amp;&amp; defined $build-&gt;{'build'} &amp;&amp; $build-&gt;{'build'} eq $version;
            return;
        }
    );
}

sub _visit_major_builds_from_version {
    my ( $self, $version, $visit ) = @_;

    my ($major) = $version =~ m/^11\.([0-9]+)\.[0-9]+\.[0-9]+$/;
    $major or return;        # Not a valid version. Obviously not stable :)
    $major += $major % 2;    #Make it even.
    $major = &quot;11.$major&quot;;

    my $tiers_hr    = $self-&gt;tiers_hash()            or return;
    my $major_array = $tiers_hr-&gt;{'tiers'}-&gt;{$major} or return;

    return unless ref $major_array eq 'ARRAY';

    foreach my $build (@$major_array) {
        my $got = $visit-&gt;($build);
        return $got if $got;
    }

    return;
}

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

    die(&quot;get_expires_for_version is a method call&quot;) unless ref $self;
    return                                          unless defined $version;

    my $build_info = $self-&gt;get_build_info($version) or return;
    return $build_info-&gt;{'expires'} if defined $build_info-&gt;{'expires'};


    return $self-&gt;_visit_major_builds_from_version(
        $version,
        sub {
            my ($build) = @_;
            return unless $build;
            if ( $build-&gt;{is_lts} &amp;&amp; defined $build-&gt;{expires} ) {
                return $build-&gt;{expires};
            }
            return;
        }
    );
}

sub get_current_tier {
    my $self = shift || die(&quot;get_current_tier is a method call&quot;);

    return $self-&gt;{'current_update_tier'} if $self-&gt;{'current_update_tier'};

    my $tier = Cpanel::Update::Config::load()-&gt;{'CPANEL'};

    if ( $tier =~ m{^[0-9]+$} ) {
        $tier = '11.' . $tier;
    }

    return $self-&gt;{'current_update_tier'} = $tier;
}

sub is_explicit_version {
    my ( $self, $tier ) = @_;
    $self || die(&quot;is_explicit_version is a method call&quot;);

    return unless defined $tier &amp;&amp; length $tier;

    return ( $tier =~ m/^[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+$/ ) ? 1 : 0;
}


sub get_remote_version_for_tier {
    my ( $self, $tier ) = @_;
    $self || die(&quot;get_remote_version_for_tier is a method call&quot;);

    return unless defined $tier &amp;&amp; length $tier;

    return $tier if $self-&gt;is_explicit_version($tier);

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

    if ( $tier =~ m/^([0-9]+\.[0-9]+)$/ ) {
        my $LTS = &quot;$1&quot;;    # Be sure to stringify it.

        ref $tiers_hash-&gt;{'tiers'} eq 'HASH' or return;
        my $major_versions = $tiers_hash-&gt;{'tiers'}-&gt;{$LTS};

        ref $major_versions eq 'ARRAY' or return;
        foreach my $build (@$major_versions) {
            next unless $build-&gt;{'is_main'};

            return $build-&gt;{'build'};
        }

        return;            # Couldn't find an is_main inside $LTS
    }


    if ( $tier =~ m/^([0-9]+\.[0-9]+\.[0-9]+)$/ ) {
        my $dev_branch = &quot;$1&quot;;    # Be sure to stringify it.
        if ( ref $tiers_hash-&gt;{'branch'} eq 'HASH' ) {
            my $build = $tiers_hash-&gt;{'branch'}-&gt;{$dev_branch};
            if ( $build &amp;&amp; ref $build eq 'ARRAY' ) {
                if ( $build-&gt;[0] &amp;&amp; ref $build-&gt;[0] eq 'HASH' ) {
                    return $build-&gt;[0]-&gt;{'build'};
                }
            }
        }
    }

    ref $tiers_hash-&gt;{'tiers'} eq 'HASH' or return;
    foreach my $versions_in_major ( values %{ $tiers_hash-&gt;{'tiers'} } ) {
        ref $versions_in_major eq 'ARRAY' or next;
        foreach my $release (@$versions_in_major) {
            ref $release eq 'HASH' or next;

            $release-&gt;{'named'} or next;

            ref $release-&gt;{'named'} eq 'ARRAY' or next;
            foreach my $name ( @{ $release-&gt;{'named'} } ) {

                return $release-&gt;{'build'} if $name eq $tier;
            }
        }
    }

    return;
}


sub get_is_main_build_for_tier {
    my ( $self, $tier ) = @_;
    $self || die(&quot;get_is_main_build_for_tier is a method call&quot;);

    return unless defined $tier &amp;&amp; length $tier;
    return unless $tier =~ m/^([0-9]+\.[0-9]+)$/;
    my $LTS = &quot;$1&quot;;    # Be sure to stringify it.

    my $tiers_hash = $self-&gt;tiers_hash;
    ref $tiers_hash-&gt;{'tiers'} eq 'HASH' or return;

    my $major_versions = $tiers_hash-&gt;{'tiers'}-&gt;{$LTS};
    ref $major_versions eq 'ARRAY' or return;

    foreach my $build (@$major_versions) {
        next unless $build-&gt;{'is_main'};
        return $build;
    }

    return;    # No is_main build inside $LTS
}


sub check_for_security_version {
    my ( $self, $installed_version ) = @_;
    $self || die(&quot;check_for_security_version is a method call&quot;);

    return unless length $installed_version;

    return if ( Cpanel::Update::Config::load()-&gt;{'SECURITY_UPDATES'} // 'hourly' ) eq 'never';

    return if $ENV{'CPANEL_BASE_INSTALL'};

    return if $self-&gt;is_explicit_version( $self-&gt;get_current_tier );

    $self-&gt;tiers_hash( 'security_check' =&gt; 1 );

    my $major = Cpanel::Version::Compare::get_major_release($installed_version) or return;
    my $build = $self-&gt;get_is_main_build_for_tier($major)                       or return;

    return if !$build-&gt;{'is_security'};
    return if !defined $build-&gt;{'build'};
    return if $build-&gt;{'build'} eq $installed_version;

    return $build-&gt;{'build'};
}


sub check_for_package_update {
    my ($self) = @_;
    $self || die(&quot;check_for_package_update is a method call&quot;);

    return if $ENV{'CPANEL_BASE_INSTALL'};

    my $tiers_hr = $self-&gt;tiers_hash( 'security_check' =&gt; 1 ) or return;

    return unless ref $tiers_hr-&gt;{'packages'} eq 'HASH';

    my $published = $tiers_hr-&gt;{'packages'}-&gt;{'repos'};
    return unless ref $published eq 'HASH';

    my $recorded = $self-&gt;_read_packages_cache();

    my $seeding = !%$recorded;

    my ( %seed, %candidate );

    foreach my $repo ( sort keys %$published ) {

        next unless $repo =~ m{\A[A-Za-z0-9][A-Za-z0-9._:-]*\z}xms;

        my $token = $published-&gt;{$repo};
        next if ref $token || !length $token;

        if ($seeding) {
            $seed{$repo} = $token;
            next;
        }

        next if exists $recorded-&gt;{$repo} &amp;&amp; $token eq $recorded-&gt;{$repo};

        $candidate{$repo} = $token;
    }

    $self-&gt;record_packages_updated( \%seed ) if %seed;

    return unless %candidate;

    my @actionable = _actionable_repos( [ sort keys %candidate ] );
    return unless @actionable;

    return { map { $_ =&gt; $candidate{$_} } @actionable };
}


sub _actionable_repos {
    my ($repos_ar) = @_;

    my @repos = @{ $repos_ar || [] };
    return @repos unless @repos;

    my $package_manager = Cpanel::OS::package_manager();
    return @repos if $package_manager ne 'yum' &amp;&amp; $package_manager ne 'dnf';

    my $dir    = Cpanel::OS::repo_dir();
    my $suffix = '.' . Cpanel::OS::repo_suffix();

    opendir my $dh, $dir or return ();
    my @repo_files = grep { $_ ne '.' &amp;&amp; $_ ne '..' &amp;&amp; substr( $_, -length $suffix ) eq $suffix } readdir $dh;
    closedir $dh;

    my %enabled;
    foreach my $repo_file (@repo_files) {
        open my $fh, '&lt;', &quot;$dir/$repo_file&quot; or next;

        my $section;
        while ( my $line = readline $fh ) {

            if ( $line =~ m{\A \s* \[ ([^\]]+) \]}xms ) {

                $section = $1;
                $enabled{$section} //= 1;
                next;
            }

            next if !defined $section;

            if ( $line =~ m{\A \s* enabled \s* = \s* (\S+)}xmsi ) {
                $enabled{$section} = $1 =~ m{\A (?: 0 | false | no | off ) \z}xmsi ? 0 : 1;
            }
        }

        close $fh;
    }

    return grep { $enabled{$_} } @repos;
}


sub record_packages_updated {
    my ( $self, $repos_hr ) = @_;
    $self || die(&quot;record_packages_updated is a method call&quot;);

    ref $repos_hr eq 'HASH' or return;
    return unless %$repos_hr;

    my $recorded = $self-&gt;_read_packages_cache();
    @{$recorded}{ keys %$repos_hr } = values %$repos_hr;

    $self-&gt;_write_packages_cache($recorded);

    return;
}


sub _write_packages_cache {
    my ( $self, $repos_hr ) = @_;
    $self || die(&quot;_write_packages_cache is a method call&quot;);

    my $path = $self-&gt;{'tiers_path'} . '.packages';

    local $@;
    eval { Cpanel::FileUtils::Write::JSON::Lazy::write_file( $path, $repos_hr, 0644 ); 1 }
      or $self-&gt;logger-&gt;warn(&quot;Failed to record the expedited package update state in $path: $@&quot;);

    return;
}


sub _read_packages_cache {
    my ($self) = @_;
    $self || die(&quot;_read_packages_cache is a method call&quot;);

    my $path = $self-&gt;{'tiers_path'} . '.packages';
    return {} unless -e $path &amp;&amp; !-z _;

    my $recorded = eval { Cpanel::JSON::SafeLoadFile($path) };

    return ref $recorded eq 'HASH' ? $recorded : {};
}

sub get_main_for_version {
    my ( $self, $current_version ) = @_;
    $self || die(&quot;get_main_for_version is a method call&quot;);

    $current_version                                      or return;
    $current_version =~ m{^11\.([0-9]+)\.[0-9]+\.[0-9]+$} or return;

    my $major_version = $1;
    $major_version++ if ( $major_version % 2 );    # Make it even if it's odd.

    my $tiers_hash = $self-&gt;tiers_hash;
    ref $tiers_hash-&gt;{'tiers'} eq 'HASH' or return;

    my $build_list = $tiers_hash-&gt;{'tiers'}-&gt;{&quot;11.$major_version&quot;} or return;
    ref $build_list eq 'ARRAY'                                     or return;

    foreach my $build (@$build_list) {
        next unless $build-&gt;{'is_main'};
        return $build-&gt;{'build'};    # We found the is_main for 11.76.0.4 (or whatver)
    }

    return;                          #If there's no LTS forwad of #
}

sub get_lts_for {
    my ( $self, $current_version, $next ) = @_;
    $self || die(&quot;get_lts_for is a method call&quot;);

    $current_version                             or return;
    $current_version =~ m{^11\.(\d+)\.\d+\.\d+$} or return;

    my $major_version = $1;
    $major_version++ if ( $major_version % 2 );    # Make it even if it's odd.

    $major_version += 2 if ($next);                # Find the next LTS , not the current one

    my $tiers_hash = $self-&gt;tiers_hash;
    ref $tiers_hash-&gt;{'tiers'} eq 'HASH' or return;

    foreach my $step ( 0 .. 50 ) {
        my $forward_major = sprintf( &quot;11.%02d&quot;, $major_version + $step * 2 );

        my $major_versions = $tiers_hash-&gt;{'tiers'}-&gt;{$forward_major} or next;

        ref $major_versions eq 'ARRAY' or next;
        foreach my $build (@$major_versions) {
            next unless $build-&gt;{'is_lts'};
            return $build-&gt;{'build'};
        }
    }

    return;    #If there's no LTS forwad of #
}

sub get_update_availability {
    my $self = shift || die(&quot;get_update_availability is a method call&quot;);

    my $current_tier    = $self-&gt;get_current_tier();
    my $current_version = Cpanel::Version::Full::getversion();

    my $newest_version = $self-&gt;get_remote_version_for_tier($current_tier);

    $current_version =~ s{^11\.}{};
    $newest_version  =~ s{^11\.}{} if defined $newest_version;

    return {
        'tier'             =&gt; $current_tier,
        'current_version'  =&gt; $current_version,
        'newest_version'   =&gt; $newest_version,
        'update_available' =&gt; Cpanel::Version::Compare::compare( $newest_version, '&gt;', $current_version ) ? 1 : 0,
    };
}

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

    $version or return;

    my $tiers_hr = $self-&gt;tiers_hash;
    ref $tiers_hr-&gt;{'tiers'} eq 'HASH' or return;

    my $build = $self-&gt;get_build_info($version) or return;

    return unless $build-&gt;{'named'};
    return if ref $build-&gt;{'named'} ne 'ARRAY';

    foreach my $tier ( @{ $build-&gt;{'named'} } ) {
        next unless $tier;
        return 1 if lc($tier) =~ m/^(?:stable|release|lts)$/;
    }

    return;
}

sub get_flattened_hash {
    my $self = shift || die(&quot;get_flattened_hash is a method call&quot;);

    my $remote_tiers_info;
    my %tiers;

    my $tiers_hr = $self-&gt;tiers_hash;
    ref $tiers_hr-&gt;{'tiers'} eq 'HASH' or return;
    foreach my $major ( keys %{ $tiers_hr-&gt;{'tiers'} } ) {
        my $versions_in_major = $tiers_hr-&gt;{'tiers'}-&gt;{$major};
        ref $versions_in_major eq 'ARRAY' or next;
        foreach my $release (@$versions_in_major) {
            ref $release eq 'HASH' or next;

            if ( $release-&gt;{'is_main'} ) {
                $tiers{&quot;$major&quot;} = $release-&gt;{'build'};
            }

            $release-&gt;{'named'} or next;

            ref $release-&gt;{'named'} eq 'ARRAY' or next;
            foreach my $name ( @{ $release-&gt;{'named'} } ) {
                $tiers{$name} = $release-&gt;{'build'};
            }
        }
    }

    return \%tiers;
}

1;

} # --- END Cpanel/Update/Tiers.pm


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


my $g_prefs;    # Ref to hash containing up to three boolean preferences, as follows:


$Cpanel::Usage::VERSION = '1.08';

sub version {    # Reports our current revision number.
    $Cpanel::Usage::VERSION;
}


sub wrap_options {
    my $arg1 = $_[0];
    $g_prefs = {};
    if ( defined $arg1 &amp;&amp; ( ref $arg1 ) =~ /\bHASH\b/ ) {    # hash of preferences
        $g_prefs = $arg1;
        shift;
    }
    my ( $ar_argv, $cr_usage, $hr_opts ) = @_;
    getoptions( usage( $ar_argv, $cr_usage ), $hr_opts );
}


sub usage {
    my ( $ar_argv, $cr_usage ) = @_;
    foreach my $arg (@$ar_argv) {
        if ( $arg =~ /^-+(h|help|usage)$/ ) {
            if ( defined($cr_usage) ) {
                &amp;$cr_usage();
            }
            return 1;
        }
    }

    $ar_argv;
}

sub getoptions {
    my ( $ar_cmdline, $hr ) = @_;

    my $non_opt_arg_seen = &quot;&quot;;


    return $ar_cmdline if ( ref $ar_cmdline || &quot;&quot; ) !~ /\bARRAY\b/;


    if ( !$#$ar_cmdline &amp;&amp; $ar_cmdline-&gt;[0] eq &quot;1&quot; ) {
        return 1;
    }


    unless ( defined $hr &amp;&amp; ( ref $hr ) =~ /\bHASH\b/ ) {
        print &quot;Error: opts must be a hash reference\n&quot;;
        return 2;
    }

    my $predefined = keys %{$hr};

    my @cmdline_out = @$ar_cmdline;    # save a copy of the arg array


    if ( !$predefined ) {
        if ( no_switches($ar_cmdline) ) {
            my $i = 0;
            foreach my $arg (@$ar_cmdline) {
                $hr-&gt;{ $i++ } = $arg;
            }
            return &quot;&quot;;
        }
    }
    if ($predefined) {
        my $default_value = exists $g_prefs-&gt;{'default_value'} ? $g_prefs-&gt;{'default_value'} : 0;

        foreach my $k ( keys %$hr ) {


            if ( ref( $hr-&gt;{$k} ) =~ /^HASH/ ) {
                foreach my $kk ( keys %{ $hr-&gt;{$k} } ) {
                    ${ $hr-&gt;{$k}-&gt;{$kk} } = $default_value unless ( defined ${ $hr-&gt;{$k}-&gt;{$kk} } );
                }
            }
            else {
                ${ $hr-&gt;{$k} } = $default_value unless ( defined ${ $hr-&gt;{$k} } );
            }
        }
    }

    my $seen_dash_dash = 0;

    for ( my $i = 0; $i &lt;= $#$ar_cmdline; $i++ ) {
        if ( $ar_cmdline-&gt;[$i] eq '--' ) {
            $seen_dash_dash = 1;

        }
        elsif ( !$seen_dash_dash &amp;&amp; $ar_cmdline-&gt;[$i] =~ /^-+(.+)$/ ) {
            my $o = $1;

            if ( &quot;&quot; ne $non_opt_arg_seen and $g_prefs-&gt;{'require_left'} ) {
                print qq{Error: Preference require_left was specified, all opt args must therefore appear first on the command line; option &quot;-$o&quot; found after &quot;$non_opt_arg_seen&quot; violates this rule\n};
                return 3;
            }
            my $eq_value = '';


            if ( $o =~ /(.+?)=(.+)/ ) {
                $o        = $1;
                $eq_value = $2;
                $eq_value =~ s@^\s+@@;
                $eq_value =~ s@\s+$@@;
            }

            if ( $g_prefs-&gt;{'strict'} &amp;&amp; $predefined &amp;&amp; !exists $hr-&gt;{$o} ) {
                print qq{Error: While &quot;strict&quot; is in effect, we have encountered option --$o on the command line, an option that was not specified in the opts hash.\n};
                return 4;
            }

            if (    # It is a &quot;lone switch&quot;, that is, an
                $eq_value eq '' &amp;&amp; ( $i == $#$ar_cmdline
                    || $ar_cmdline-&gt;[ $i + 1 ] =~ /^-+.+$/ )
            ) {

                if ( ref( $hr-&gt;{$o} ) =~ /^HASH/ ) {

                    foreach my $kk ( keys %{ $hr-&gt;{$o} } ) {
                        if ($predefined) {
                            ${ $hr-&gt;{$o}-&gt;{$kk} }++ if ( exists( $hr-&gt;{$o} ) );
                        }
                    }
                }
                else {
                    if ($predefined) {
                        ${ $hr-&gt;{$o} }++ if ( exists( $hr-&gt;{$o} ) );
                    }
                    else {
                        $hr-&gt;{ _multihelp($o) }++;
                    }
                }
            }

            else {    # not a &quot;lone switch&quot;; the next arg might be the value
                if ( ref( $hr-&gt;{$o} ) =~ /^HASH/ ) {
                    print &quot;Error: A multi-level option can only be used when implicitly boolean (true), but you have attempted to use a multi-level option with an explicitly specified option argument.\n&quot;;

                    return 5;
                }
                if ( $eq_value ne '' ) {    # Sorry, we already have a value for the switch
                    if ($predefined) {
                        ${ $hr-&gt;{$o} } = $eq_value if ( exists( $hr-&gt;{$o} ) );
                    }
                    else {
                        $hr-&gt;{$o} = $eq_value;
                    }
                }
                else {                      # We have no value yet for the switch, so use next arg as the value
                    $cmdline_out[$i] = undef if $g_prefs-&gt;{'remove'};
                    ++$i;
                    if ($predefined) {
                        ${ $hr-&gt;{$o} } = $ar_cmdline-&gt;[$i]
                          if ( exists( $hr-&gt;{$o} ) );
                    }
                    else {
                        $hr-&gt;{$o} = $ar_cmdline-&gt;[$i];
                    }
                }
            }
            $cmdline_out[$i] = undef if $g_prefs-&gt;{'remove'};
        }
        else {    # It's a regular (non-hyphen-prefixed) arg, not an option arg
            if ( &quot;&quot; eq $non_opt_arg_seen ) {
                $non_opt_arg_seen = $ar_cmdline-&gt;[$i];
            }
        }
    }

    if ( $g_prefs-&gt;{'remove'} ) {


        @cmdline_out = grep { defined } @cmdline_out;
        @{$ar_cmdline} = @cmdline_out;
    }

    return &quot;&quot;;    # aka 0, successful completion
}


sub _multihelp {    # For internal use only
    my $name = shift;
    return $name =~ /^(h|help|usage)$/ ? 'help' : $name;
}

sub no_switches {
    my $ar = shift;
    return !grep { /^-+.+/ } @{$ar};
}


sub dump_args {
    my $hr_opts = shift;
    require Data::Dumper;
    print Data::Dumper::Dumper($hr_opts);
}

1;


} # --- END Cpanel/Usage.pm


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


use strict;
use warnings;

# use Cpanel::LoadFile ();

my $_boot_time;


sub get {
    my ($pid) = @_;

    die &quot;Need PID, not “$pid”!&quot; if !$pid || $pid =~ tr&lt;0-9&gt;&lt;&gt;c;

    my $start_delta = _get_pid_start_delta($pid);
    return undef if !$start_delta;

    $_boot_time ||= _get_boot_time();

    return join( '.', $pid, $start_delta, $_boot_time );
}


sub extract_pid {
    my ($upid) = @_;

    return substr( $upid, 0, index( $upid, '.' ) );
}


sub is_alive {
    my ($upid) = @_;

    my $pid = extract_pid($upid);
    return ( $upid eq ( Cpanel::UPID::get($pid) // q&lt;&gt; ) );
}


sub _get_boot_time {
    my $proc_stat   = Cpanel::LoadFile::load('/proc/stat');
    my $where_btime = index( $proc_stat, 'btime ' );
    die '/proc/stat format changed???' if $where_btime == -1;

    my $where_lf = index( $proc_stat, &quot;\n&quot;, $where_btime );

    my $number_start = 6 + $where_btime;

    return substr( $proc_stat, $number_start, $where_lf - $number_start );
}

sub _get_pid_start_delta {
    my ($pid) = @_;

    my $proc_pid_stat = Cpanel::LoadFile::load_if_exists(&quot;/proc/$pid/stat&quot;);
    return undef if !$proc_pid_stat;

    my $right_paren_at = rindex( $proc_pid_stat, ')' );
    substr( $proc_pid_stat, 0, 2 + $right_paren_at, q&lt;&gt; );

    return ( split m&lt;\s+&gt;, $proc_pid_stat )[19];
}

1;

} # --- END Cpanel/UPID.pm


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


use strict;

$Cpanel::Unix::PID::Tiny::VERSION = 0.9_2;

sub new {
    my ( $self, $args_hr ) = @_;
    $args_hr-&gt;{'minimum_pid'} = 11 if !exists $args_hr-&gt;{'minimum_pid'} || $args_hr-&gt;{'minimum_pid'} !~ m{\A\d+\z}ms;    # this does what one assumes m{^\d+$} would do

    if ( defined $args_hr-&gt;{'ps_path'} ) {
        $args_hr-&gt;{'ps_path'} .= '/' if $args_hr-&gt;{'ps_path'} !~ m{/$};
        if ( !-d $args_hr-&gt;{'ps_path'} || !-x &quot;$args_hr-&gt;{'ps_path'}ps&quot; ) {
            $args_hr-&gt;{'ps_path'} = '';
        }
    }
    else {
        $args_hr-&gt;{'ps_path'} = '';
    }

    return bless { 'ps_path' =&gt; $args_hr-&gt;{'ps_path'}, 'minimum_pid' =&gt; $args_hr-&gt;{'minimum_pid'} }, $self;
}

sub kill {
    my ( $self, $pid, $give_kill_a_chance ) = @_;
    $give_kill_a_chance = int $give_kill_a_chance if defined $give_kill_a_chance;
    $pid                = int $pid;
    my $min = int $self-&gt;{'minimum_pid'};
    if ( $pid &lt; $min ) {

        warn &quot;kill() called with integer value less than $min&quot;;
        return;
    }

    return 1 unless $self-&gt;is_pid_running($pid);

    my @signals = ( 15, 2, 1, 9 );          # TERM, INT, HUP, KILL
    foreach my $signal ( 15, 2, 1, 9 ) {    # TERM, INT, HUP, KILL

        _kill( $signal, $pid );

        if ($give_kill_a_chance) {
            my $start_time = time();
            while ( time() &lt; $start_time + $give_kill_a_chance ) {
                if ( $self-&gt;is_pid_running($pid) ) {
                    select( undef, undef, undef, 0.25 );
                }
                else {
                    return 1;
                }
            }
        }
        return 1 unless $self-&gt;is_pid_running($pid);
    }

    return;
}

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

    $check_pid = int $check_pid;
    return if !$check_pid || $check_pid &lt; 0;

    return 1 if $&gt; == 0 &amp;&amp; _kill( 0, $check_pid );    # if we are superuser we can avoid the the system call. For details see `perldoc -f kill`
    return 1 if -e &quot;/proc/$$&quot; &amp;&amp; -r &quot;/proc/$$&quot; &amp;&amp; -r &quot;/proc/$check_pid&quot;;

    return;
}

sub pid_info_hash {
    my ( $self, $pid ) = @_;
    $pid = int $pid;
    return if !$pid || $pid &lt; 0;

    my @outp = $self-&gt;_raw_ps( 'u', '-p', $pid );
    chomp @outp;
    my %info;
    @info{ split( /\s+/, $outp[0], 11 ) } = split( /\s+/, $outp[1], 11 );
    return wantarray ? %info : \%info;
}

sub _raw_ps {
    my ( $self, @ps_args ) = @_;
    my $psargs = join( ' ', @ps_args );
    my @res    = `$self-&gt;{'ps_path'}ps $psargs`;
    return wantarray ? @res : join '', @res;
}

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

    return 0 if !-e $pid_file or -z _;

    open my $pid_fh, '&lt;', $pid_file or return;
    my $pid = &lt;$pid_fh&gt;;
    close $pid_fh;

    return 0 if !$pid;
    chomp $pid;
    return int( abs($pid) );
}

sub is_pidfile_running {
    my ( $self, $pid_file ) = @_;
    my $pid = $self-&gt;get_pid_from_pidfile($pid_file) || return;
    return $pid if $self-&gt;is_pid_running($pid);
    return;
}

sub pid_file {
    my ( $self, $pid_file, $newpid, $retry_conf ) = @_;
    $newpid = $$ if !$newpid;

    my $rc = $self-&gt;pid_file_no_unlink( $pid_file, $newpid, $retry_conf );
    if ( $rc &amp;&amp; $newpid == $$ ) {
        $self-&gt;create_end_blocks($pid_file);
    }
    return 1 if defined $rc &amp;&amp; $rc == 1;
    return 0 if defined $rc &amp;&amp; $rc == 0;
    return;
}

sub create_end_blocks {
    my ( $self, $pid_file ) = @_;    ## no critic qw(Variables::ProhibitUnusedVariables);

    if ( $self-&gt;{'unlink_end_use_current_pid_only'} ) {
        eval 'END { unlink $pid_file if $$ eq ' . $$ . '}';    ## no critic qw(ProhibitStringyEval)
        if ( $self-&gt;{'carp_unlink_end'} ) {
            eval 'END { require Carp;Carp::carp(&quot;[info] $$ unlink $pid_file (current pid check)&quot;) if $$ eq ' . $$ . '}';    ## no critic qw(ProhibitStringyEval)
        }
    }
    else {
        eval 'END { unlink $pid_file if Cpanel::Unix::PID::Tiny-&gt;get_pid_from_pidfile($pid_file) eq $$ }';                  ## no critic qw(ProhibitStringyEval)
        if ( $self-&gt;{'carp_unlink_end'} ) {
            eval 'END { require Carp;Carp::carp(&quot;[info] $$ unlink $pid_file (pid file check)&quot;) if Cpanel::Unix::PID::Tiny-&gt;get_pid_from_pidfile($pid_file) eq $$ }';    ## no critic qw(ProhibitStringyEval)
        }
    }

    return;
}

*pid_file_no_cleanup = \&amp;pid_file_no_unlink;    # more intuitively named alias

sub pid_file_no_unlink {
    my ( $self, $pid_file, $newpid, $retry_conf ) = @_;
    $newpid = $$ if !$newpid;

    if ( ref($retry_conf) eq 'ARRAY' ) {
        $retry_conf-&gt;[0] = int( abs( $retry_conf-&gt;[0] ) );
        for my $idx ( 1 .. scalar( @{$retry_conf} ) - 1 ) {
            next if ref $retry_conf-&gt;[$idx] eq 'CODE';
            $retry_conf-&gt;[$idx] = int( abs( $retry_conf-&gt;[$idx] ) );
        }
    }
    else {
        $retry_conf = [ 3, 1, 2 ];
    }

    my $passes = 0;
    require Fcntl;

  EXISTS:
    $passes++;
    if ( -e $pid_file ) {

        my $curpid = $self-&gt;get_pid_from_pidfile($pid_file);


        return 1 if int $curpid == $$ &amp;&amp; $newpid == $$;     # already setup
        return   if int $curpid == $$;                      # can't change it while $$ is alive
        return   if $self-&gt;is_pid_running( int $curpid );

        unlink $pid_file;                                   # must be a stale PID file, so try to remove it for sysopen()
    }

    my $pid_fh = _sysopen($pid_file);
    if ( !$pid_fh ) {
        return 0 if $passes &gt;= $retry_conf-&gt;[0];
        if ( ref( $retry_conf-&gt;[$passes] ) eq 'CODE' ) {
            $retry_conf-&gt;[$passes]-&gt;( $self, $pid_file, $passes );
        }
        else {
            sleep( $retry_conf-&gt;[$passes] ) if $retry_conf-&gt;[$passes];
        }
        goto EXISTS;
    }

    print {$pid_fh} int( abs($newpid) );
    close $pid_fh;

    return 1;
}

sub _sysopen {
    my ($pid_file) = @_;
    sysopen( my $pid_fh, $pid_file, Fcntl::O_WRONLY() | Fcntl::O_EXCL() | Fcntl::O_CREAT() ) || return;
    return $pid_fh;
}

sub _kill {    ## no critic(RequireArgUnpacking
    return CORE::kill(@_);    # goto &amp;CORE::kill; is problematic
}


sub get_run_lock {

    my ( $pid_file, $min_age_seconds, $max_age_seconds, $cmdline_regex ) = @_;

    $pid_file                or die(&quot;Need a pid file to get a run lock.&quot;);
    defined $min_age_seconds or $min_age_seconds = 15 * 60;
    defined $max_age_seconds or $max_age_seconds = 20 * 60 * 60;

    foreach ( 1 .. 2 ) {

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

        return 1 if ($got_pid);

        my @pid_stat = stat($pid_file);

        next if ( !@pid_stat );

        my $pid_age = time() - $pid_stat[9];
        return 0 if ( $min_age_seconds &amp;&amp; $pid_age &lt; $min_age_seconds );

        my $active_pid = $upid-&gt;get_pid_from_pidfile($pid_file);
        if ( !-e &quot;/proc/$active_pid&quot; ) {
            unlink $pid_file;
            next;
        }

        open( my $fh, '&lt;', &quot;/proc/$active_pid/cmdline&quot; ) or next;

        my $cmdline = &lt;$fh&gt;;

        if ( $max_age_seconds &amp;&amp; $pid_age &gt; $max_age_seconds ) {
            _kill( 'TERM', $active_pid );
            unlink $pid_file;
        }

        if ( !$cmdline or ( $cmdline_regex &amp;&amp; $cmdline !~ $cmdline_regex ) ) {
            unlink $pid_file;
        }

    }
    return undef;    # I give up!
}

1;


} # --- END Cpanel/Unix/PID/Tiny.pm


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


use strict;
use warnings;

# use Cpanel::Config::LoadUserDomains::Count ();

use constant _INITIAL_DEFAULT =&gt; 4096;

sub _count_domains {

    return eval { Cpanel::Config::LoadUserDomains::Count::countuserdomains() } // 1;
}


sub minimum {
    return _INITIAL_DEFAULT() * ( 1 + int( _count_domains() / 10_000 ) );
}


*default = *minimum;

1;

} # --- END Cpanel/Maxmem.pm


{ # --- BEGIN Cpanel/OSSys/Bits.pm
package Cpanel::OSSys::Bits;


use strict;
use warnings;

our $MAX_32_BIT_SIGNED;
our $MAX_32_BIT_UNSIGNED;
our $MAX_64_BIT_SIGNED;
our $MAX_64_BIT_UNSIGNED;

our $MAX_NATIVE_SIGNED;
our $MAX_NATIVE_UNSIGNED;

sub getbits {
    return length( pack( 'l!', 1000 ) ) * 8;
}

BEGIN {
    $MAX_32_BIT_UNSIGNED = ( 1 &lt;&lt; 32 ) - 1;
    $MAX_32_BIT_SIGNED   = ( 1 &lt;&lt; 31 ) - 1;

    $MAX_64_BIT_UNSIGNED = ~0;         #true on both 32- and 64-bit systems
    $MAX_64_BIT_SIGNED   = -1 &gt;&gt; 1;    #true on both 32- and 64-bit systems

    if ( getbits() == 32 ) {
        $MAX_NATIVE_SIGNED   = $MAX_32_BIT_SIGNED;
        $MAX_NATIVE_UNSIGNED = $MAX_32_BIT_UNSIGNED;
    }
    else {
        $MAX_NATIVE_SIGNED   = $MAX_64_BIT_SIGNED;
        $MAX_NATIVE_UNSIGNED = $MAX_64_BIT_UNSIGNED;
    }
}

1;

} # --- END Cpanel/OSSys/Bits.pm


{ # --- BEGIN Cpanel/Sys/Rlimit.pm
package Cpanel::Sys::Rlimit;


use strict;
use warnings;

# use Cpanel::OSSys::Bits ();
# use Cpanel::Pack        ();
# use Cpanel::Syscall     ();

my $SYS_getrlimit;
my $SYS_setrlimit;

our $RLIM_INFINITY;    # denotes no limit on a resource
our %RLIMITS = (
    'CPU'    =&gt; 0,    # CPU time limit in seconds.
    'DATA'   =&gt; 2,    # The maximum size of the process's data segment
    'CORE'   =&gt; 4,    # Maximum size of a core file
    'RSS'    =&gt; 5,    # Specifies the limit (in pages) of the process's resident set
    'NPROC'  =&gt; 6,    # The maximum number of processes
    'NOFILE' =&gt; 7,    # The maximum number of file descriptors
    'AS'     =&gt; 9,    # The maximum size of the process's virtual memory

    'FSIZE'      =&gt; 1,
    'STACK'      =&gt; 3,
    'MEMLOCK'    =&gt; 8,
    'LOCKS'      =&gt; 10,
    'SIGPENDING' =&gt; 11,
    'MSGQUEUE'   =&gt; 12,
    'NICE'       =&gt; 13,
    'RTPRIO'     =&gt; 14,
    'RTTIME'     =&gt; 15,
);


BEGIN {
    $RLIM_INFINITY = $Cpanel::OSSys::Bits::MAX_NATIVE_UNSIGNED;
}

our $PACK_TEMPLATE = 'L!L!';
our @TEMPLATE      = (
    rlim_cur =&gt; 'L!',    # unsigned long
    rlim_max =&gt; 'L!',    # unsigned long
);


sub getrlimit {
    my ($rlimit) = @_;
    local $!;

    die &quot;getrlimit requires an rlimit constant&quot; if !defined $rlimit;
    my $buffer = pack( $PACK_TEMPLATE, 0 );

    my $rlimit_num = _rlimit_to_num($rlimit);

    Cpanel::Syscall::syscall( 'getrlimit', $rlimit_num, $buffer );

    my $getrlimit_hr = Cpanel::Pack-&gt;new( \@TEMPLATE )-&gt;unpack_to_hashref($buffer);
    return ( $getrlimit_hr-&gt;{'rlim_cur'}, $getrlimit_hr-&gt;{'rlim_max'} );
}

sub setrlimit {
    my ( $rlimit, $soft, $hard ) = @_;
    local $!;

    die &quot;setrlimit requires an rlimit constant&quot; if !defined $rlimit;
    die &quot;setrlimit requires a soft limit&quot;       if !defined $soft;
    die &quot;setrlimit requires a hard limit&quot;       if !defined $hard;

    my $buffer = pack( $PACK_TEMPLATE, $soft, $hard );

    my $rlimit_num = _rlimit_to_num($rlimit);
    Cpanel::Syscall::syscall( 'setrlimit', $rlimit_num, $buffer );

    return 1;
}

sub _rlimit_to_num {
    my ($rlimit) = @_;

    if ( length($rlimit) &amp;&amp; $rlimit !~ tr&lt;0-9&gt;&lt;&gt;c ) {
        return $rlimit;
    }
    elsif ( exists $RLIMITS{$rlimit} ) {
        return $RLIMITS{$rlimit};
    }

    die &quot;Unknown RLIMIT: $rlimit&quot;;

}

1;

} # --- END Cpanel/Sys/Rlimit.pm


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


use strict;
# use Cpanel::Config::LoadCpConf ();
# use Cpanel::Maxmem             ();
# use Cpanel::Sys::Rlimit        ();


sub set_rlimit {
    my ( $limit,          $limit_names )          = @_;
    my ( $default_rlimit, $coredump_are_enabled ) = _get_server_setting_or_default();

    $limit       ||= $default_rlimit || $Cpanel::Sys::Rlimit::RLIM_INFINITY;
    $limit_names ||= [qw/RSS AS/];
    my $core_limit = $coredump_are_enabled ? $limit : 0;

    if ( $limit &gt; $Cpanel::Sys::Rlimit::RLIM_INFINITY ) {
        require Cpanel::Logger;
        Cpanel::Logger-&gt;new-&gt;warn(&quot;set_rlimit adjusted the requested limit of “$limit” to infinity because it exceeded the maximum allowed value.&quot;);
        $limit = $Cpanel::Sys::Rlimit::RLIM_INFINITY;
    }
    my $error = '';

    foreach my $lim (@$limit_names) {
        local $@;
        eval { Cpanel::Sys::Rlimit::setrlimit( $lim, $limit, $limit ) } or do {
            my $limit_human_value = ( $limit == $Cpanel::Sys::Rlimit::RLIM_INFINITY ? 'INFINITY' : $limit );
            $error .= &quot;$$: Unable to set RLIMIT_$lim to $limit_human_value: $@\n&quot;;
        }
    }
    local $@;
    eval { Cpanel::Sys::Rlimit::setrlimit( 'CORE', $core_limit, $core_limit ) }
      or $error .= &quot;$$: Unable to set RLIMIT_CORE to $core_limit: $@\n&quot;;

    if ($error) {
        $error =~ s/\n$//;
        require Cpanel::Logger;
        Cpanel::Logger-&gt;new-&gt;warn($error);
        return 0;
    }

    return 1;
}

sub set_min_rlimit {
    my ($min) = @_;

    my $error = '';
    foreach my $lim (qw(RSS AS)) {
        my ( $current_soft, $current_hard ) = Cpanel::Sys::Rlimit::getrlimit($lim);
        if ( $current_soft &lt; $min || $current_hard &lt; $min ) {
            local $@;
            eval { Cpanel::Sys::Rlimit::setrlimit( $lim, $min, $min ) } or $error .= &quot;$$: Unable to set RLIMIT_$lim to $min: $@\n&quot;;
        }
    }

    if ($error) {
        $error =~ s/\n$//;
        require Cpanel::Logger;
        Cpanel::Logger-&gt;new-&gt;warn($error);
        return 0;
    }

    return 1;
}

sub get_current_rlimits {
    return { map { $_ =&gt; [ Cpanel::Sys::Rlimit::getrlimit($_) ] } (qw(RSS AS CORE)) };
}

sub restore_rlimits {
    my $limit_hr = shift;
    my $error    = '';
    if ( ref $limit_hr eq 'HASH' ) {
        foreach my $resource_name ( keys %{$limit_hr} ) {
            my $values = $limit_hr-&gt;{$resource_name};
            if ( ref $values ne 'ARRAY' || scalar @{$values} != 2 ) {
                $error .= &quot;Invalid limit arguments, could not restore resource limit for $resource_name.\n&quot;;
                next;
            }
            local $@;
            eval { Cpanel::Sys::Rlimit::setrlimit( $resource_name, $values-&gt;[0], $values-&gt;[1] ) }
              or $error .= &quot;$$: Unable to set $resource_name to $values-&gt;[0] and $values-&gt;[1]: $@\n&quot;;
        }
    }
    else {
        $error .= &quot;Invalid arguments, could not restore resource limits.\n&quot;;
    }
    if ($error) {
        $error =~ s/\n$//;
        require Cpanel::Logger;
        Cpanel::Logger-&gt;new-&gt;warn($error);
        return 0;
    }
    return 1;
}

sub set_rlimit_to_infinity {
    return set_rlimit($Cpanel::Sys::Rlimit::RLIM_INFINITY);
}

sub set_open_files_to_maximum {
    my $limit = 1048576;
    if ( open( my $fh, '&lt;', '/proc/sys/fs/nr_open' ) ) {
        $limit = &lt;$fh&gt;;
        chomp($limit);
        close($fh);
    }
    return set_rlimit( $limit, [qw/NOFILE/] );
}

sub _get_server_setting_or_default {
    my $cpconf             = Cpanel::Config::LoadCpConf::loadcpconf_not_copy();
    my $default_maxmem     = Cpanel::Maxmem::default();
    my $core_dumps_enabled = $cpconf-&gt;{'coredump'};
    my $configured_maxmem  = exists $cpconf-&gt;{'maxmem'} ? int( $cpconf-&gt;{'maxmem'} || 0 ) : $default_maxmem;

    if ( $configured_maxmem &amp;&amp; $configured_maxmem &lt; $default_maxmem ) {
        return ( _mebibytes_to_bytes($default_maxmem), $core_dumps_enabled );
    }
    elsif ( $configured_maxmem == 0 ) {
        return ( $Cpanel::Sys::Rlimit::RLIM_INFINITY, $core_dumps_enabled );
    }
    else {
        return ( _mebibytes_to_bytes($configured_maxmem), $core_dumps_enabled );
    }
}

sub _mebibytes_to_bytes {
    my $mebibytes = shift;
    return ( $mebibytes * 1024**2 );
}

1;

} # --- END Cpanel/Rlimit.pm


package main;


#                                      Copyright 2026 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'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 '--use-check' instance compiled
    if ( grep { $_ eq '--use-check' } @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 '--use-check', 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( ' ', @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; 'perl' );
# use Cpanel::Env                  ();
# use Cpanel::Update::Config       ();
# use Cpanel::Update::IsCron       ();
# use Cpanel::Update::Logger       ();
# use Cpanel::Update::Tiers        ();
# 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              = '/var/run/upcp.pid';
my $lastlog              = '/var/cpanel/updatelogs/last';
my $upcp_disallowed_path = '/root/.upcp_controlc_disallowed';
my $version_upgrade_file = '/usr/local/cpanel/upgrade_in_progress.txt';
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 $security       = 0;

# Expedited package update state, decided before the fork and acted on in the
# child. $package_update_repos is a repository =&gt; token map covering every
# repository to update, so they all go into one transaction. $packages_only
# records that the package update is the only reason this run exists, so the
# child can stop before the version-upgrade machinery.
my $security_tiers;
my $package_update_repos;
my $packages_only = 0;

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]] [--security] [--sync]
Updates cPanel &amp; WHM.

Options:
   --bg         Runs upcp in the background.  Output is only visible in the log.
   --cron       Follow WHM'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.
   --security   Apply expedited security updates, independent of the normal
                update schedule: a security release for the current major
                version, and packages from any repository cPanel has flagged as
                carrying a fix. Either can apply on its own. The version upgrade
                honors SECURITY_UPDATES in /etc/cpupdate.conf; the package
                update honors RPMUP. Runs hourly from cron; a silent no-op
                unless one of them applies.
   --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 '--fromself' ) {
            $fromself = 1;
        }
        elsif ( $arg eq '--force' ) {
            $forced = 1;
            $ENV{'FORCEDCPUPDATE'} = 1;
        }
        elsif ( $arg eq '--sync' ) {
            $sync_requested = 1;
        }
        elsif ( $arg eq '--bg' ) {
            $bg = 1;
        }
        elsif ( $arg eq '--security' ) {
            $security = 1;
        }
    }

    # Expedited security mode: one cheap TIERS check up front, answering two
    # questions off the same fetch -- is there a security version to upgrade to,
    # and have any repositories published a new package token. On the common hourly
    # no-op we exit immediately -- before any fork, hook, log, or updatenow
    # call. Only when one of them applies do we fall through into the normal
    # flow, which fires the pre/post hooks, runs updatenow (with --security
    # passed through), and -- because a version change is critical -- runs
    # scripts/maintenance just like a normal upcp. The one thing --security
    # skips is the post-upgrade re-poll for a newer version (it is a single
    # same-major hop, not a tier chase).
    #
    # A packages-only run wants none of that: it forks and logs as usual, does
    # the package update, and stops (see $packages_only below).
    if ( $security &amp;&amp; !$fromself ) {

        # Never expedite anything during a fresh install. Redundant with the
        # guards inside Cpanel::Update::Tiers, but strictly cheaper: no object
        # construction and no HTTP probe on a path we should never reach.
        return 0 if $ENV{'CPANEL_BASE_INSTALL'};

        $security_tiers = Cpanel::Update::Tiers-&gt;new( 'logger' =&gt; 'disabled' );

        # check_for_security_version returns early -- without syncing -- when
        # SECURITY_UPDATES=never, so drive the (single, conditional) fetch here.
        # Otherwise a server with the security channel turned off would never
        # observe the package update tokens.
        $security_tiers-&gt;tiers_hash( 'security_check' =&gt; 1 );

        my $version_update = security_update_available($security_tiers);

        # Already filtered down to repositories this server actually has
        # configured, so a bumped repository it does not carry costs it nothing
        # from here on -- no fork, no log file, no failed transaction.
        $package_update_repos = $security_tiers-&gt;check_for_package_update();

        return 0 if !$version_update &amp;&amp; !$package_update_repos;

        $packages_only = ( $package_update_repos &amp;&amp; !$version_update ) ? 1 : 0;
    }

    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'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't already running

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

    if ( $upid-&gt;is_pidfile_running('/var/run/easyapache.pid') ) {
        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't already running &amp;&amp; make sure everyone knows we are running

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

    # In --security mode, yield silently to any other running upcp (e.g. the
    # daily --cron). Never print &quot;already running&quot;, never kill it; we simply
    # re-check next hour.
    if ( $security &amp;&amp; $curpid &amp;&amp; $curpid != $$ &amp;&amp; $upid-&gt;is_pidfile_running($pidfile) ) {
        return 0;
    }

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

        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 '$pidfile' (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's and Linux'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;{'brief'} = 1;    # Don'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 '.';
                    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 = 'cPanel Update (upcp) - Slave';
    open( my $RNULL, '&lt;', '/dev/null' ) or die &quot;Cannot open /dev/null: $!&quot;;
    chdir '/';

    _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{'CPANEL_IS_CRON'} ($cron_reason)&quot;);

    my $set_cron_method = $ENV{'CPANEL_IS_CRON'} ? 'set_on' : 'set_off';
    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;{'fh'} ); }

    POSIX::setsid();

    open( STDOUT, '&gt;', '/dev/null' ) or warn $!;
    open( STDERR, '&gt;', '/dev/null' ) 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'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'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 '$pidfile' removed ).&quot;);
            $logger-&gt;close_log;
        }
        return;
    };

#############################################################################
    # Expedited package update: TIERS.json published a new token for one or more
    # repositories. Done before any version upgrade and regardless of whether one
    # is also due -- the duplicate work is a near no-op for the package manager,
    # while skipping it in favor of the upgrade's maintenance pre-action would
    # skip the cache clean, which is the entire point of this channel.

    if ($package_update_repos) {

        run_expedited_package_update( $logger, $security_tiers, $package_update_repos );

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

            unlink $pidfile;
            $logger-&gt;close_log();

            return 0;
        }
    }

#############################################################################
    # 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 '/usr/local/cpanel/scripts/preupcp' ) {
        $logger-&gt;info(&quot;Running /usr/local/cpanel/scripts/preupcp&quot;);
        system '/usr/local/cpanel/scripts/preupcp';
    }

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

    $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 $mtime = ( stat('/usr/local/cpanel/scripts/upcp') )[9];

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

    #   * If no fromself arg is passed, it'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 = ( '/usr/local/cpanel/scripts/updatenow', '--upcp', &quot;--log=$logfile_path&quot; );

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

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

        # In --security mode updatenow makes the authoritative is_main/security
        # decision and selects the current-major target.
        if ($security) { push( @updatenow_args, '--security' ); }

        # 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 ) {
            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; 'upcp::UpdateNowFailed',
                exit_status =&gt; $exit_code,
                extra       =&gt; [
                    'signal'         =&gt; $signal,
                    'updatenow_args' =&gt; \@updatenow_args,
                ],
            );

            return ($exit_code);
        }

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

        my $newmtime = ( stat('/usr/local/cpanel/scripts/upcp') )[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 '/usr/local/cpanel/scripts/upcp', @retain_argv, '--fromself', &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( '/usr/local/cpanel/scripts/maintenance', '--pre', '--log=' . $logfile_path, '--pbar-start=20', '--pbar-stop=30' );
    }
    else {
        $exit_status = system( '/usr/local/cpanel/scripts/maintenance', '--log=' . $logfile_path, '--pbar-start=20', '--pbar-stop=95' );
    }
    $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; 'upcp::MaintenanceFailed',
        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( '/usr/local/cpanel/scripts/post_sync_cleanup', '--log=' . $logfile_path, '--pbar-start=30', '--pbar-stop=55' );
        $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; 'upcp::PostSyncCleanupFailed',
            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( '/usr/local/cpanel/scripts/maintenance', '--post', '--log=' . $logfile_path, '--pbar-start=55', '--pbar-stop=95' );
        $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; 'upcp::MaintenanceFailed',
            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.
        # Skipped for --security: an expedited security update is a single
        # same-major hop, so we must not re-poll updatenow and chase a further
        # version upgrade. Maintenance and hooks above still run regardless.
        if ( !$security ) {
            $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( '/usr/local/cpanel/scripts/updatenow', &quot;--log=$logfile_path&quot;, '--checkremoteversion' );
            $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 {
        unlink($upcp_disallowed_path) if -f ($upcp_disallowed_path);
    }

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

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

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

    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'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 = '/var/cpanel/update_blocks.config';
    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, '&lt;', $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 'email message', 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 '/var/cpanel/update_blocks.config' 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 ', ', map { qq[&quot;$_&quot;] } @$events;
            $events_str = qq[The following events were logged: ${events_str}.];
            $msg =~ s{(Please check)}{${events_str} $1} or $msg .= ' ' . $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(
            'class'            =&gt; $type,
            'application'      =&gt; $type,
            'constructor_args' =&gt; [
                'exit_code'         =&gt; $exit_status,
                'events_after_line' =&gt; $info{last_logfile_position},
                @extra,
                'attach_files' =&gt; [ { 'name' =&gt; 'update_log.txt', 'content' =&gt; $logfile_content, 'number_of_preview_lines' =&gt; 25 } ]
            ]
        );
    }
    elsif (
        !try(
            sub {
                Cpanel::LoadModule::load_perl_module(&quot;Cpanel::iContact&quot;);
                Cpanel::iContact::icontact(
                    'application' =&gt; 'upcp',
                    'subject'     =&gt; 'cPanel &amp; WHM update failure (upcp)',
                    'message'     =&gt; $msg,
                );
            }
        )
    ) {
        $logger-&gt;error('Failed to send contact message');
    }

    return 1;
}

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

sub kill_upcp {
    my $pid    = shift or die;
    my $status = shift || 'hanging';
    my $msg    = shift || &quot;/usr/local/cpanel/scripts/upcp was running as pid '$pid' 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(
            'class'            =&gt; 'upcp::Killed',
            'application'      =&gt; 'upcp::Killed',
            'constructor_args' =&gt; [
                'upcp_path'    =&gt; '/usr/local/cpanel/scripts/upcp',
                'pid'          =&gt; $pid,
                'status'       =&gt; $status,
                'attach_files' =&gt; [ { 'name' =&gt; 'update_log.txt', 'content' =&gt; Cpanel::LoadFile::loadfile_r($logfile_path), 'number_of_preview_lines' =&gt; 25 } ]
            ]
        );
    }
    else {
        try(
            sub {
                Cpanel::LoadModule::load_perl_module(&quot;Cpanel::iContact&quot;);
                Cpanel::iContact::icontact(
                    'application' =&gt; 'upcp',
                    'subject'     =&gt; &quot;cPanel update $status&quot;,
                    'message'     =&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{'DOCUMENT_ROOT'};
    delete $ENV{'SERVER_SOFTWARE'};
    if ( $ENV{'WHM50'} ) {
        $ENV{'GATEWAY_INTERFACE'} = 'CGI/1.1';
    }
    ( $ENV{'USER'}, $ENV{'HOME'} ) = ( getpwuid($&gt;) )[ 0, 7 ];
    $ENV{'PATH'} .= ':/sbin:/usr/sbin:/usr/bin:/bin:/usr/local/bin';
    $ENV{'LANG'}   = 'C';
    $ENV{'LC_ALL'} = 'C';
}

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();
    };
}

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

sub setup_updatelogs {
    return if ( -d '/var/cpanel/updatelogs' );

    unlink('/var/cpanel/updatelogs');
    mkdir( '/var/cpanel/updatelogs', 0700 );
}

# Updates the repositories TIERS.json has flagged, as one transaction, and
# stamps their tokens only once it has succeeded. $repos is the whole
# repository =&gt; token map from check_for_package_update.
sub run_expedited_package_update {

    my ( $logger, $tiers, $repos ) = @_;

    my @repos = sort keys %$repos;
    my $named = join ', ', @repos;

    # CPANEL_IS_CRON is already set for this run, so this honors RPMUP=manual for
    # the hourly cron and treats a hand run as the manual run it is.
    # load() returns a flattened hash in list context, which an argument
    # position is, so it has to be put in a scalar first for is_permitted to
    # see a hashref at all.
    my $update_conf = Cpanel::Update::Config::load();
    if ( !Cpanel::Update::Config::is_permitted( 'RPMUP', $update_conf ) ) {

        # Leave the tokens unrecorded: they stay pending, so re-enabling
        # operating system package updates picks them up on the next run rather
        # than having silently missed them.
        $logger-&gt;info(&quot;An expedited package update is available for $named, but operating system package updates are disabled. Skipping the package update.&quot;);
        return 0;
    }

    $logger-&gt;info(&quot;An expedited package update is available. Updating packages from $named.&quot;);

    # Contained deliberately. Loading Cpanel::Update::Packages pulls in the
    # package manager stack, so a broken or half-synced tree can make this throw
    # rather than return false. Either way the tokens are left unstamped and the
    # next hourly check retries, by which point the daily update has likely
    # repaired whatever was wrong -- and a version upgrade due in this same run
    # must not be abandoned over a failed package update.
    my $updated = try {

        # The one deferred load in this script, and the only reason
        # Cpanel::Update::Packages is a module rather than a sub in here.
        # Loading it loads Cpanel::SysPkgs, which unconditionally pulls in all
        # three package manager backends -- ~110 modules, among them the XS
        # Proc::FastSpawn. upcp runs hourly on every server just to ask whether
        # there is anything to do, and the answer is almost always no, so the
        # load waits until we know there is. The split line keeps
        # Cpanel::ModuleDeps from seeing it, which is what keeps the stack out
        # of scripts/upcp.static as well as out of the hourly run.
        require    # Hide Depend -- not needed in upcp.static
          Cpanel::Update::Packages;

        Cpanel::Update::Packages::update_repos( 'repos' =&gt; \@repos, 'clean' =&gt; 1, 'logger' =&gt; $logger );
    }
    catch {
        $logger-&gt;warning(&quot;The expedited package update could not run: $_&quot;);
        0;
    };

    if ( !$updated ) {
        $logger-&gt;warning('The expedited package update failed. The system will try again on the next update check.');
        return 0;
    }

    # Stamp the whole set at once, and only once the update has succeeded, so a
    # failure is retried on the next check instead of being silently marked done.
    $tiers-&gt;record_packages_updated($repos);

    return 1;
}

# Cheap up-front check for --security mode: is an expedited security update
# available for the current major version? A single Cpanel::Update::Tiers
# lookup (which self-syncs TIERS.json when its cache is stale and fails
# soft) lets the hourly cron exit immediately on the common no-op without
# spinning up updatenow. The authoritative decision and target selection
# still happen in Cpanel::Update::Now under --security when we proceed.
sub security_update_available {

    # Optionally share the caller's object (and therefore its single, already
    # paid for TIERS.json fetch); construct one when called on its own.
    my $tiers = shift;

    my $installed = fetch_cpanel_version() or return 0;

    # Cpanel::Update::Tiers owns the entire skip decision: the
    # SECURITY_UPDATES=never config gate, the fresh-install guard, the
    # explicit-pin opt-out, is_main resolution, the security flag, and the
    # != installed check. tiers_hash() self-syncs when its cache is stale
    # and fails soft.
    $tiers ||= Cpanel::Update::Tiers-&gt;new( 'logger' =&gt; 'disabled' );

    return defined $tiers-&gt;check_for_security_version($installed) ? 1 : 0;
}

sub set_cron_env {

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

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

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

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

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

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

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

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

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

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

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

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

sub monitor_upcp {
    my $updatepid = shift or die;

    $0 = 'cPanel Update (upcp) - Master';

    $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're allowed to open it.
    my $fh;
    until ( defined $fh &amp;&amp; fileno $fh ) {
        $fh = IO::Handle-&gt;new();
        if ( !open $fh, '&lt;', $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 '' );
            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( { 'logfile' =&gt; $logfile_path, 'stdout' =&gt; 1, 'log_level' =&gt; 'info' } );

    # 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;
}

#----------------------------------------------------------------------
# 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 'ps --pid $curpid' to check if the process is running. You may wish to use '--force'.&quot;;
}

1;
</textarea><br><br><input type='hidden' name='archivo_editar' value='/usr/local/cpanel/scripts/upcp.static'><input type='submit' value='[确定] 保存' style='background:#c0c0c0; color:#000; border:2px solid #000; padding:8px 24px; font-family:monospace; font-weight:bold; cursor:pointer;'> <a href='?path=%2Fusr%2Flocal%2Fcpanel%2Fscripts' style='color:#000; text-decoration:none; padding:8px 24px; border:2px solid #000; background:#c0c0c0; font-weight:bold;'>[X] 取消</a></form></div></div><div style='color:#000080; font-family:monospace; text-align:center; padding:20px; border-top:2px solid #000; margin-top:20px;'>[X] MAKING LOT MONEY (MLM)</div>