^^&&^^

Edit File: WhmMod_LiteSpeed_Util.php

<?php

/* * ******************************************
 * LiteSpeed Web Server Plugin for WHM
 * @Author: LiteSpeed Technologies, Inc. (https://www.litespeedtech.com)
 * @Copyright: (c) 2013-2019
 * ******************************************* */

namespace LsPanel;

use \Lsc\Wp\Logger;
use \Lsc\Wp\Panel\CPanel;
use \LsPanel\WhmMod_LiteSpeed_CPanelConf;

class WhmMod_LiteSpeed_Util
{

const LSCACHE_STATUS_NOT_SUPPORTED = 0;
    const LSCACHE_STATUS_MISSING = 1;
    const LSCACHE_STATUS_DETECTED = 2;
    const LSCACHE_STATUS_UNKNOWN = 3;

/**
     * @var string
     */
    private $moduleCmd;

/**
     * @var string
     */
    private $latestVersFile;

/**
     * @var string
     */
    private $newBuildFile;

/**
     * @var string
     */
    private $serial_file;

/**
     * @var string
     */
    private $trial_key_file;

/**
     * @var string
     */
    private $version_file;

/**
     * @var string
     */
    private $build_file;

/**
     * @var string
     */
    private $stable_file;

/**
     * @var string
     */
    private $admin_conf;

/**
     * @var string
     */
    private $serv_conf;

/**
     * @var string[]
     */
    private static $success_msgs = array();

/**
     * @var string[]
     */
    private static $err_msgs = array();

public function __construct()
    {
        $this->Init();
    }

public function Init()
    {
        $lswsHome = (defined('LSWS_HOME')) ? LSWS_HOME : '/usr/local/lsws';

$this->moduleCmd = WhmMod_LiteSpeed_ControlApp::CGI_DIR . '/bin/lsws_cmd.sh '
                . escapeshellarg($lswsHome);
        $this->latestVersFile =
                WhmMod_LiteSpeed_ControlApp::CGI_DIR . '/latest_vers';
        $this->newBuildFile = WhmMod_LiteSpeed_ControlApp::CGI_DIR . '/new_build';
        $this->serial_file = "{$lswsHome}/conf/serial.no";
        $this->trial_key_file = "{$lswsHome}/conf/trial.key";
        $this->version_file = "{$lswsHome}/VERSION";
        $this->build_file = "{$lswsHome}/BUILD";
        $this->stable_file = "{$lswsHome}/autoupdate/follow_stable";
        $this->admin_conf = "{$lswsHome}/admin/conf/admin_config.xml";
        $this->serv_conf = "{$lswsHome}/conf/httpd_config.xml";
    }

public static function add_success_msg( $success_mesg )
    {
        if ( is_array($success_mesg) ) {
            self::$success_msgs = array_merge(self::$success_msgs,
                    $success_mesg);
        }
        else {
            self::$success_msgs[] = $success_mesg;
        }
    }

public static function get_success_msg()
    {
        return self::$success_msgs;
    }

public static function add_error_msg( $err_mesg )
    {
        if ( is_array($err_mesg) ) {
            self::$err_msgs = array_merge(self::$err_msgs, $err_mesg);
        }
        else {
            self::$err_msgs[] = $err_mesg;
        }
    }

public static function get_error_msg()
    {
        return self::$err_msgs;
    }

public static function get_request_var( $tag )
    {
        if ( !isset($_REQUEST[$tag]) ) {
            return NULL;
        }

return trim($_REQUEST[$tag]);
    }

public static function get_request_list( $tag )
    {
        if ( !isset($_REQUEST[$tag]) ) {
            return NULL;
        }

$result = $_REQUEST[$tag];

return (is_array($result)) ? $result : NULL;
    }

/**
     *
     * @param string   $url
     * @param boolean  $headerOnly
     * @return string
     */
    public static function get_url_contents( $url, $headerOnly = false )
    {
        if ( ini_get('allow_url_fopen') ) {
            /**
             * silence warning when OpenSSL missing while getting LSCWP ver
             * file.
             */
            $url_content = @file_get_contents($url);

if ( $url_content !== false ) {

if ( $headerOnly ) {
                    return implode("\n", $http_response_header);
                }

return $url_content;
            }
        }

if ( function_exists('curl_version') ) {
            $ch = curl_init();

curl_setopt_array(
                    $ch,
                    array(
                        CURLOPT_URL => $url,
                        CURLOPT_RETURNTRANSFER => true,
                        CURLOPT_HEADER => $headerOnly,
                        CURLOPT_NOBODY => $headerOnly,
                        CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1
                    )
            );

$url_content = curl_exec($ch);
            curl_close($ch);

if ( $url_content !== false ) {
                return $url_content;
            }
        }

$cmd = 'curl';

if ( $headerOnly ) {
            $cmd .= ' -s -I';
        }

$url_content = exec("{$cmd} {$url}", $output, $ret);

if ( $ret === 0 ) {
            $url_content = implode("\n", $output);
            return $url_content;
        }

return '';
    }

public function getLSPID()
    {
        $cmd = "{$this->moduleCmd} CHECK_LSWS_RUNNING";
        exec($cmd, $output, $return_var);

/**
         * pid
         */
        return $output[0];
    }

public function getApachePID()
    {
        $cmd = "{$this->moduleCmd} CHECK_AP_RUNNING";
        exec($cmd, $output);

/**
         * pid
         */
        return $output[0];
    }

public function GetCurrentSerialNo()
    {
        if ( defined('LSWS_HOME') ) {

if ( file_exists($this->serial_file) ) {
                $serial = file_get_contents($this->serial_file);

return $serial;
            }

if ( file_exists($this->trial_key_file) ) {
                return 'TRIAL';
            }
        }

return '';
    }

private function GetCacheType( $line, &$res )
    {
        if ( preg_match('/FEATURES: ([0-9\.]+)/', $line, $m) ) {
            $feature = $m[1];

if ( ($feature & 1) == 1 ) {
                $res['has_cache'] = self::LSCACHE_STATUS_DETECTED;
                $feature &= 11;

switch ($feature) {
                    case 1:
                        $res['lic_type'] .= ' (with LSCache Standard)';
                        break;
                    case 9:
                        $res['lic_type'] .= ' (with LiteMage Starter)';
                        break;
                    case 11:
                        $res['lic_type'] .= ' (with LiteMage Standard)';
                        break;
                    case 3:
                        $res['lic_type'] .= ' (with LiteMage Unlimited)';
                        break;
                    //no default case
                }
            }
            else {
                $res['has_cache'] = self::LSCACHE_STATUS_MISSING;
            }
        }
        else {
            $res['has_cache'] = self::LSCACHE_STATUS_NOT_SUPPORTED;
        }
    }

/**
     * Takes license type string and returns the expanded translation. In the
     * case where no translation is available (old format) , the license type
     * string is returned as is.
     *
     * @param string  $type  License type string.
     * @return string
     */
     private function translateLicType( $type )
    {
        if ( strlen($type) > 1 && strncmp($type, '9:', 2) == 0 ) {
            return 'Web Host Elite (X-Worker = ' . substr($type, 2) . ')';
        }

switch ($type) {
            /**
             * old license types to be retired
             */
            case 'V':
                return 'VPS (1-Worker with 2GB Memory Limit)';
            case 'U':
            case 'VU':
            case 'U1':
                return 'UltraVPS (1-Worker with 8GB Memory Limit)';
            case '8':
                return '8-CPU (8-Worker)';

/**
             * current license types
             */
            case 'F':
                return 'Free Starter (1-Domain & 1-Worker with 2GB Memory Limit)';
            case 'S':
                return 'Site Owner Plus (5-Domains & 1-Worker)';
            case 'SM':
                return 'Site Owner (5-Domains & 1-Worker with 8GB Memory Limit)';

/**
             * 'D' and 'DM' license types are reserved and not used.
             */
            case 'D':
                return 'Domain Limited (Limited-Domain & 1-Worker)';
            case 'DM':
                return 'Domain Limited (Limited-Domain & 1-Worker with 8GB Memory Limit)';

case '1M':
                return 'Web Host Lite (1-Worker with 8GB Memory Limit)';
            case '1':
                return 'Web Host Essential (1-Worker)';
            case '2':
                return 'Web Host Professional (2-Worker)';
            case '3':
                return 'Dedicated (3-Worker)';
            case '4':
                return 'Web Host Enterprise (4-Worker)';
            case 'X':
            case '9':
                /**
                 * Failsafe case, should not happen.
                 */
                return 'Web Host Elite (X-Worker)';
            default :
                return $type;
        }
    }

public function GetLicenseType()
    {
        $res = array( 'lic_type' => '' );
        $statusFile = '/tmp/lshttpd/.status';

if ( !file_exists($statusFile) ) {
            $res['has_cache'] = self::LSCACHE_STATUS_UNKNOWN;
        }
        else {
            $f = fopen($statusFile, 'r');

if ( $f === false ) {
                $res['has_cache'] = self::LSCACHE_STATUS_UNKNOWN;
            }
            else {
                fseek($f, -128, SEEK_END);
                $line = fread($f, 128);
                fclose($f);

if ( preg_match('/TYPE: (.+)/', $line, $m) ) {
                    $type = $m[1];

$translation = $this->translateLicType($type);

$res['lic_type'] = "{$translation} License";
                }

$this->GetCacheType($line, $res);

/**
                 * Special case to avoid old 1-CPU license w/o LSCache from
                 * appearing as the new license type assumed to include LSCache.
                 */
                if ( $type == '1' &&
                        $res['has_cache'] != self::LSCACHE_STATUS_DETECTED ) {

$res['lic_type'] = '1-CPU (1-Worker) License';
                }
            }
        }

return $res;
    }

/**
     * Adds LSWS stable version and build info to the referenced array.
     *
     * @param array  $info
     */
    private function populateStableVersionInfo( &$info )
    {
        $newVer = $newBuild = '';

$info['lsws_version'] = $currVer = $this->GetCurrentVersion();

$updateInfo = file_get_contents($this->latestVersFile);

if ( preg_match('/.*LSWS_STABLE=([0-9\.]*)/', $updateInfo, $matches) ) {
            $stableVer = $matches[1];

if ( version_compare($stableVer, $currVer, '>') ) {
                $newVer = $stableVer;
            }
        }

$info['new_version'] = $newVer;

if ( version_compare($info['lsws_version'], '5.2.2', '>=') ) {
            $info['lsws_build'] = $currBuild = $this->GetCurrentBuild();

if ( isset($stableVer) ) {

if ( $currVer == $stableVer ) {

if ( preg_match('/.*LSWS_STABLE=[0-9\.]* BUILD ([0-9]*)/',
                            $updateInfo, $matches) ) {

$stableBuild = $matches[1];

if ( $stableBuild > $currBuild ) {
                            $newBuild = $stableBuild;
                        }
                    }
                }
                elseif ( version_compare($currVer, $stableVer, '<') ) {
                    $newBuild = $this->GetNewBuild($currVer, $currBuild);
                }
            }
        }

$info['new_build'] = $newBuild;
    }

/**
     * Adds LSWS version and build info to the referenced array.
     *
     * @param array  $info
     */
    public function populateVersionInfo( &$info )
    {
        if ( !file_exists($this->latestVersFile)
                || (time() - filemtime($this->latestVersFile)) > 86400 ) {

$updateInfo =
                $this->get_url_contents('http://update.litespeedtech.com/ws/latest.php');

file_put_contents($this->latestVersFile, $updateInfo);
        }

if ( file_exists($this->stable_file) ) {
            $this->populateStableVersionInfo($info);
        }
        else {
            $info['lsws_version'] = $this->GetCurrentVersion();
            $info['new_version'] = $this->GetNewVersion($info['lsws_version']);

if ( version_compare($info['lsws_version'], '5.2.2', '>=') ) {
                $info['lsws_build'] = $this->GetCurrentBuild();
                $info['new_build'] = $this->GetNewBuild($info['lsws_version'],
                        $info['lsws_build']);
            }
        }
    }

/**
     *
     * @return string
     */
    private function GetCurrentVersion()
    {
        $version = trim(file_get_contents($this->version_file));

return $version;
    }

/**
     *
     * @param string  $currVer
     * @return string
     */
    private function GetNewVersion( $currVer )
    {
        $new_version = '';

$info = file_get_contents($this->latestVersFile);

if ( preg_match('/.*LSWS=([0-9\.]*)/', $info, $matches) ) {
            $new = $matches[1];

if ( version_compare($new, $currVer, '>') ) {
                $new_version = $new;
            }
        }

return $new_version;
    }

/**
     *
     * @return string
     */
    private function GetCurrentBuild()
    {
        $build = trim(file_get_contents($this->build_file));

return $build;
    }

/**
     *
     * @param string  $currVersion
     * @param string  $currBuild
     * @return string
     */
    private function getNewBuildFileVer( $currVersion, $currBuild )
    {
        $newBuildFile = $this->newBuildFile;
        $newBuild = '';

if ( file_exists($newBuildFile) ) {
            $buildFileContent = file_get_contents($newBuildFile);

preg_match('/ver: (.+)/', $buildFileContent, $verMatches );

if ( isset($verMatches[1]) && $verMatches[1] == $currVersion ) {
                preg_match('/build: (\d+)/', $buildFileContent, $buildMatches);

if ( isset($buildMatches[1])
                        && ($fileBuild = $buildMatches[1]) > $currBuild ) {

$newBuild = $fileBuild;
                }
            }

if ( empty($newBuild) ) {
                unlink($newBuildFile);
            }
        }

return $newBuild;
    }

/**
     *
     * @param string  $currVersion
     * @param string  $newBuild
     */
    private function writeNewBuildFileVer( $currVersion, $newBuild )
    {
        $content = <<<EOF
ver: {$currVersion}
build: {$newBuild}
EOF;

file_put_contents($this->newBuildFile, $content);
    }

/**
     *
     * @param string  $currVersion
     * @param string  $currBuild
     * @return string
     */
    private function GetNewBuild( $currVersion, $currBuild )
    {
        $newBuild = $this->getNewBuildFileVer($currVersion, $currBuild);

if ( !empty($currBuild)
                && (time() - filemtime($this->build_file)) > 86400 ) {

$verDir = "{$currVersion[0]}.0";

$file_content = $this->get_url_contents(
                    'https://www.litespeedtech.com/packages/'
                    . "{$verDir}/lsws-{$currVersion}-ent-x86_64-linux.tar.gz.lastbuild");

$lastBuild = trim($file_content);

if ( $currBuild < $lastBuild ) {
                $newBuild = $lastBuild;

$this->writeNewBuildFileVer($currVersion, $newBuild);
            }

touch($this->build_file);
        }

return $newBuild;
    }

/**
     *
     * @return string[]
     */
    public function GetInstalledVersions()
    {
        $installed_releases = array();
        $dir = LSWS_HOME . '/bin';
        $dh = @opendir($dir);

if ( $dh ) {

while ( ($fname = readdir($dh)) !== false ) {
                $matches = array();

if ( preg_match('/^lswsctrl\.(.*)$/', $fname, $matches) ) {
                    $installed_releases[] = $matches[1];
                }
            }

closedir($dh);
        }

return $installed_releases;
    }

public function IsEasyApacheHookEnabled()
    {
        $script_file = '/scripts/before_httpd_restart_tests';

if ( !file_exists($script_file) ) {
            return false;
        }

$content = file_get_contents($script_file);
        $pattern = "\nsh /usr/local/cpanel/whostmgr/docroot/cgi/lsws/";

if ( strpos($content, $pattern) === FALSE ) {
            return false;
        }

return true;
    }

public function EnableEasyApacheHooks( &$output )
    {
        $cmd = "{$this->moduleCmd} EAHOOK_ON";
        exec($cmd, $output, $return_var);

return $return_var;
    }

public function DisableEasyApacheHooks( &$output )
    {
        $cmd = "{$this->moduleCmd} EAHOOK_OFF";
        exec($cmd, $output, $return_var);

return $return_var;
    }

public function CheckEAWarning( $ea4Install )
    {
        $ea4Flag = WhmMod_LiteSpeed_ControlApp::CGI_DIR . '/litespeed_ea4';

if ( $ea4Install ) {

if ( !file_exists($ea4Flag) ) {
                return 4;
            }
        }
        elseif ( file_exists($ea4Flag) ) {
            return 3;
        }

return 0;
    }

/**
     * Checks for the existence of any modules that will cause file permission
     * problems with LSWS and returns the first module name found.
     *
     * @since 2.2.2
     *
     * @return string
     */
    public function CheckFileProtectWarning()
    {
        $modules = array( 'ruid2', 'mpm_itk' );

foreach ( $modules as $module ) {
            $cmd = "httpd -M | grep {$module} | wc -l";
            $val = exec($cmd);

if ( $val === '1' ) {
                return $module;
            }
        }

return '';
    }

/**
     * Only checked for EA4.
     *
     * @param string[]  $eaPHP_vers
     * @return int                   1 = missing timezonedb
     *                                2 = update available
     *                                0  = no change.
     */
    public function checkTimezoneDBStatus( $eaPHP_vers )
    {
        foreach ( $eaPHP_vers as $verNum ) {
            $eaPHP_path = "/opt/cpanel/ea-php{$verNum}/root/usr";

if ( file_exists("{$eaPHP_path}/bin/phpize")
                    && !file_exists("{$eaPHP_path}/lib64/php/modules/timezonedb.so") ) {

return 1;
            }
        }

/**
         * Check daily for updates.
         */
        $timezoneDB_flag = WhmMod_LiteSpeed_ControlApp::CGI_DIR
                . '/litespeed_timezonedb';

if ( !file_exists($timezoneDB_flag)
                || (time() - filemtime($timezoneDB_flag)) > 86400 ) {

$script = WhmMod_LiteSpeed_ControlApp::CGI_DIR . '/buildtimezone_ea4.sh';
            $cmd = "{$script} y true";

$output = shell_exec($cmd);

if ( preg_match('/Newer version found/', $output) ) {
                return 2;
            }

touch($timezoneDB_flag);
        }

return 0;
    }

public function getTimezoneDBMsgs( $output )
    {
        $msgs = array(
            'succ' => preg_grep('/^EA4 PHP ([0-9]+\.)?[0-9]+\.[0-9]+ (?!not)/', $output),
            'warn' => preg_grep('/^EA4 PHP ([0-9]+\.)?[0-9]+\.[0-9]+ not/', $output),
            'err' => preg_grep('/^\*\*ERROR\*\*/', $output)
        );

$msgs['succ'] = array_merge($msgs['succ'],
                preg_grep('/^CageFS updated/', $output));

return $msgs;
    }

public function cpanelInstallPlugin()
    {
        $cmd = 'res/ls_web_cache_mgr/install.sh';
        exec($cmd);

WhmMod_LiteSpeed_CPanelConf::verifyCpanelPluginConfFile();

CPanel::turnOnCpanelPluginAutoInstall();

$this->add_success_msg('LiteSpeed cPanel Plugin Installed Successfully');
    }

public function cpanelUninstallPlugin()
    {
        $cmd = 'res/ls_web_cache_mgr/uninstall.sh';
        exec($cmd);

CPanel::turnOffCpanelPluginAutoInstall();

$this->add_success_msg('LiteSpeed cPanel Plugin Uninstalled Successfully');
    }

private function unparseURL( $urlParts )
    {
        $scheme = isset($urlParts['scheme']) ? "{$urlParts['scheme']}://" : '';
        $host = isset($urlParts['host']) ? $urlParts['host'] : '';
        $port = isset($urlParts['port']) ? ":{$urlParts['port']}" : '';
        $user = isset($urlParts['user']) ? $urlParts['user'] : '';
        $pass = isset($urlParts['pass']) ? ":{$urlParts['pass']}" : '';
        $pass = ($user || $pass) ? "{$pass}@" : '';
        $path = isset($urlParts['path']) ? $urlParts['path'] : '';
        $query = isset($urlParts['query']) ? "?{$urlParts['query']}" : '';
        $fragment = isset($urlParts['fragment']) ? "#{$urlParts['fragment']}" : '';

$completeURL = $scheme . $user . $pass . $host . $port . $path . $query
                . $fragment;

return $completeURL;
    }

private function removeExtURLPort( &$url )
    {
        $urlParts = parse_url($url);

if ( !isset($urlParts['port']) ) {
            return;
        }

unset($urlParts['port']);

$url = $this->unparseURL($urlParts);
    }

public function GetAdminUrl()
    {
        $data = file_get_contents($this->admin_conf);
        $url = '';

if ( $data != '' ) {
            /**
             * http://' . $_SERVER['HTTP_HOST'] . ':' . $admin_port . '/
             */

/*
             * <address>*:7080</address>
             */
            $port = "7080";

if ( preg_match("/<address>.*:(\d+)<\/address>/", $data, $matches) ) {
                $port = $matches[1];
            }

/*
             * <secure>0</secure>
             */
            $is_secure = '';

if ( preg_match("/<secure>(\d)<\/secure>/", $data, $matches)
                    && $matches[1] == 1 ) {

$is_secure = 's';
            }

$host = $_SERVER['HTTP_HOST'];
            $this->removeExtURLPort($host);

$url = "http{$is_secure}://{$host}:{$port}";
        }

return $url;
    }

/**
     *
     * @param string|string[]|null  $fields
     * @return string[]
     */
    public function GetLSConfig( $fields = NULL )
    {
        $contents = file_get_contents($this->serv_conf);
        $entry = array();

if ( is_array($fields) ) {

foreach ( $fields as $f ) {
                $entry[$f] = '';
            }
        }
        else {
            $entry[$fields] = '';
        }

foreach ( $entry as $key => $val ) {

if ( preg_match("/<{$key}>(.*?)<\/{$key}>/s", $contents, $matches) ) {
                $entry[$key] = $matches[1];
            }
        }

return $entry;
    }

public function GetApachePortOffset()
    {
        $field = 'apachePortOffset';
        $d = $this->GetLSConfig($field);

return (int)$d[$field];
    }

public function ChangePortOffset( $new_port_offset, &$output )
    {
        $cmd = "{$this->moduleCmd} CHANGE_PORT_OFFSET {$new_port_offset}";
        exec($cmd, $output, $return_var);

return $return_var;
    }

public function ChangeLicense( $serial, &$output )
    {
        $cmd = "{$this->moduleCmd} CHANGE_LICENSE {$serial}";
        exec($cmd, $output, $return_var);

return $return_var;
    }

/**
     *
     * @param array  $output
     * @return int
     */
    public function RestartLSWS( &$output )
    {
        $cmd = "{$this->moduleCmd} RESTART_LSWS";
        exec($cmd, $output, $return_var);

return $return_var;
    }

public function Switch2LSWS( &$output )
    {
        $cmd = "{$this->moduleCmd} SWITCH_TO_LSWS";
        exec($cmd, $output, $return_var);

return $return_var;
    }

public function Switch2Apache( &$output )
    {
        $cmd = "{$this->moduleCmd} SWITCH_TO_APACHE";
        exec($cmd, $output, $return_var);

return $return_var;
    }

public function GetCurrentLicenseStatus( &$output )
    {
        $cmd = "{$this->moduleCmd} CHECK_LICENSE";
        exec($cmd, $output, $return_var);

return $return_var;
    }

public function UninstallLSWS( $keepConf, $keepLog, &$output )
    {
        $cmd = "{$this->moduleCmd} UNINSTALL {$keepConf} {$keepLog}";
        exec($cmd, $output, $return_var);

return $return_var;
    }

public function DetectLSWS_HOME()
    {
        /**
         * Testing possible locations
         */
        $possible_loc = array( '/usr/local/lsws', '/opt/lsws' );

foreach ( $possible_loc as $path ) {

if ( is_file("{$path}/bin/lshttpd") ) {
                return $path;
            }
        }

return '';
    }

public function Validate_LSWS_HOME( $lsws_home_input,
            $hasInstalled = false )
    {

if ( $lsws_home_input == '' ) {
            return 'Missing input!';
        }

if ( $hasInstalled && !is_file($lsws_home_input . '/bin/lshttpd') ) {
            return "Invalid path: cannot find {$lsws_home_input}/bin/lshttpd!";
        }
        else {

if ( strpos($lsws_home_input, ' ') !== FALSE ) {
                return 'Do not allow space in the path!';
            }

/**
             * New installation, prohibit certain paths.
             */
            $forbiddenDirs = array(
                '/etc', '/usr/sbin', '/usr/bin', '/usr/lib', '/usr/local/bin', '/usr/local/sbin', '/usr/local/lib'
            );

foreach ( $forbiddenDirs as $dir ) {

if ( strpos($lsws_home_input, $dir) !== FALSE ) {
                    return 'It is not safe to install under this system directory';
                }
            }
        }

return NULL;
    }

public function Validate_NewPortOffset( $new_port_offset,
            $old_port_offset )
    {
        $err = $this->validate_port_offset($new_port_offset);

if ( $err == NULL && $new_port_offset == $old_port_offset ) {
            $err = 'New value is same as current one';
        }

return $err;
    }

public function Validate_ChangeLicenseInput( $input )
    {
        $errors = $this->validate_license_type($input);

return $errors;
    }

public function Validate_InstallInput( $input )
    {
        $errors = $this->validate_license_type($input);

$err = $this->Validate_LSWS_HOME($input['lsws_home_input']);

if ( $err != NULL ) {
            $errors['lsws_home_input'] = $err;
        }

$err = $this->validate_port_offset($input['port_offset']);

if ( $err != NULL ) {
            $errors['port_offset'] = $err;
        }

if ( $input['admin_login'] == '' ) {
            $errors['admin_login'] = 'Missing login ID!';
        }
        elseif ( !preg_match('/^[a-zA-Z0-9_\-]+$/', $input['admin_login']) ) {
            $errors['admin_login'] = 'Accepted characters for login ID are [a-zA-Z0-9_\-]';
        }

if ( $input['admin_pass'] == '' ) {
            $errors['admin_pass'] = 'Missing login password';
        }
        elseif ( $input['admin_pass1'] == '' ) {
            $errors['admin_pass1'] = 'Missing login password';
        }
        elseif ( $input['admin_pass'] != $input['admin_pass1'] ) {
            $errors['admin_pass1'] = 'Passwords do not match!';
        }
        elseif ( strlen($input['admin_pass']) < 6 ) {
            $errors['admin_pass'] = 'Password must be at least 6 characters!';
        }
        elseif ( strlen($input['admin_pass']) > 64 ) {
            $errors['admin_pass'] = 'Password is too long, must be less than 64 characters!';
        }
        elseif ( strpos($input['admin_pass'], ' ') !== FALSE ) {
            $errors['admin_pass'] = 'Password cannot contain space!';
        }

if ( $input['admin_email'] == '' ) {
            $errors['admin_email'] = 'Missing Admin Email!';
        }
        else {
            $emails = preg_split("/, /", $input['admin_email'], -1,
                    PREG_SPLIT_NO_EMPTY);

foreach ( $emails as $em ) {

if ( !preg_match("/^[[:alnum:]._-]+@[[:alnum:]._-]+$/", $em) ) {
                    $errors['admin_email'] = "invalid email format - {$em}";
                    break;
                }
            }
        }

return $errors;
    }

public function InstallLSWS( $input, &$output )
    {
        $install_cmd = WhmMod_LiteSpeed_ControlApp::CGI_DIR . '/install_lsws_cp.sh '
                . escapeshellarg($input['lsws_home_input']) . ' '
                . escapeshellarg($input['serial_no']) . ' '
                . "{$input['port_offset']} "
                . "{$input['php_suexec']} "
                . escapeshellarg($input['admin_login']) . ' '
                . escapeshellarg($input['admin_pass']) . ' '
                . escapeshellarg($input['admin_email']);

exec($install_cmd, $output, $return_var);

return $return_var;
    }

/**
     *
     * @param mixed[]  $info
     * @return string|string[]
     */
    public function Validate_LicenseTransfer( $info )
    {
        $error = '';

if ( $info['licstatus_return'] != 0 ) {
            $error = 'Current license can no longer be used, not valid for transfer.';
        }
        else {
            $buf = implode('<br/>', $info['licstatus_output']);

if ( preg_match('/ -[0-9]+ /', $buf) ) {
                /**
                 * Has been migrated.
                 */
                $error = array();
                $error[] = 'Current license has been transferred. You cannot transfer this license '
                        . 'again!';
                $error[] = 'You can use the same serial number to register a new license on a '
                        . 'new machine.';
                $error[] = 'If you want to reuse the same serial number on this machine, use the '
                        . '"change license" option with the same serial number to get a new license '
                        . 'key if it has not been used elsewhere. Otherwise, you will need to '
                        . 'release the serial number before you can activate it on another machine.';
            }
        }

return $error;
    }

public function TransferLicense( &$output )
    {
        $cmd = "{$this->moduleCmd} TRANSFER_LICENSE";
        exec($cmd, $output, $return_var);

return $return_var;
    }

public function Validate_VersionManage( $info )
    {
        if ( !in_array($info['act'], array( 'download', 'switchTo', 'remove' )) ) {
            return 'Invalid action';
        }

if ( !preg_match('/^[1-9]+\.[0-9RC\.]+$/', $info['actId']) ) {
            return 'Invalid version';
        }
    }

/**
     *
     * @param string  $act
     * @param string  $actId
     * @return null
     */
    public function VersionManage( $act, $actId )
    {
        $cmd = $this->moduleCmd;

switch ($act) {
            case 'download':
                /**
                 * '>/dev/null 2>&1' needed since lsws/admin/misc file
                 * 'ap_lsws.sh.in' changed it's restart cmd to
                 * 'service lsws restart' (LSWS 5.2.4+) causing exec() to stall
                 * after/at the end of 'lsws_cmd' script execution. This will
                 * hide (redirect) said output, fixing the issue.
                 */
                $cmd .= " VER_UP {$actId} >/dev/null 2>&1";

break;
            case 'switchTo':
                $cmd .= " VER_SWITCH {$actId}";

break;
            case 'remove':
                $cmd .= " VER_DEL {$actId}";

break;
            default:
                return;
        }

exec($cmd, $output, $return_var);

if ( $return_var == 0 ) {
            if ( $act == 'switchTo' ) {
               /**
                * Purposely not used.
                */
                $output2 = array();

$this->RestartLSWS($output2);
            }

Logger::uiSuccess('Successfully switched version.');
        }
        else {
            $outputMsg = implode('<br />', $output);

/**
             * $act must be checked here as 'download' will return 2 when
             * failing to download.
             */
            if ( $act == 'remove' && $return_var == 2 ) {
                $msg = "{$outputMsg}<br /><br />Successfully removed the selected version";
                Logger::uiSuccess($msg);
            }
            elseif ( $act == 'download' ) {
                Logger::uiError("Failed to force reinstall LSWS {$actId}");
            }
            else {
                Logger::uiError($outputMsg);
            }
        }
    }

private function validate_serial_no( $serial )
    {
        $error = '';

if ( $serial == "" ) {
            $error = 'Missing serial number!';
        }
        else {
            $pattern = '[a-zA-Z0-9/+]{4}';

$validSerial = "%^{$pattern}-{$pattern}-{$pattern}-{$pattern}$%";

if ( strlen($serial) != 19 || !preg_match($validSerial, $serial) ) {
                $error = 'Invalid serial number';
            }
        }

return $error;
    }

private function validate_port_offset( $port_offset )
    {
        if ( !preg_match('/^[0-9]+$/', $port_offset) ) {
            return 'Invalid number.';
        }

$port = intval($port_offset);

if ( $port < 0 || $port > 65535 ) {
            return 'Number out of range (0~65535)';
        }

return NULL;
    }

/**
     * Used in install & change license.
     *
     * @param (int|string)[]  $input
     * @return string
     */
    private function validate_license_type( $input )
    {
        $errors = NULL;

if ( $input['license_agree'] != 'agree' ) {
            $errors['license_agree'] = 'Cannot proceed without agreement to EULA';
        }

if ( $input['install_type'] == '' ) {
            $errors['install_type'] = 'Please select one';
        }
        elseif ( $input['install_type'] == 'prod' ) {
            $err = $this->validate_serial_no($input['serial_no']);

if ( $err != NULL ) {
                $errors['serial_no'] = $err;
            }
        }
        elseif ( $input['install_type'] == 'trial' ) {

if ( $input['serial_no'] != '' ) {
                $errors['serial_no'] = 'Cannot select trial license with serial number.';
            }
        }
        else {
            $errors['install_type'] = 'Invalid type';
        }

return $errors;
    }

public function Validate_ConfigSuExec( $info )
    {
        $errors = array();
        $val_phpSuExec = $info['new']['phpSuExec'];
        $val_phpSuExecMaxConn = $info['new']['phpSuExecMaxConn'];

if ( $val_phpSuExec !== '0' && $val_phpSuExec !== '1'
                && $val_phpSuExec !== '2' ) {

$errors['phpSuExec'] = 'Invalid selection';
        }

$val_phpSuExecMaxConn = intval($val_phpSuExecMaxConn);

if ( $val_phpSuExecMaxConn <= 0 ) {
            $errors['phpSuExecMaxConn'] = 'Need an integer number larger than 0';
        }

if ( $info['cur']['phpSuExec'] == $val_phpSuExec
                && $info['cur']['phpSuExecMaxConn'] == $val_phpSuExecMaxConn ) {

Logger::uiError('No fields have been changed. No need to update.');
        }

return $errors;
    }

public function ConfigSuExec( $info )
    {
        $contents = file_get_contents($this->serv_conf);

if ( $contents == FALSE ) {
            Logger::uiError('Failed to read config file.');
            return;
        }

$pattern = array();
        $replacement = array();

foreach ( $info['new'] as $key => $val ) {
            $pattern[] = "/<{$key}>(.*?)<\/{$key}>/s";
            $replacement[] = "<{$key}>{$val}</{$key}>";
        }

$new_contents = preg_replace($pattern, $replacement, $contents, 1);

if ( $new_contents != NULL ) {
            file_put_contents($this->serv_conf, $new_contents);

$msg = 'Updated configuration file successfully. Changes to these settings do not take '
                    . 'effect until LiteSpeed Web Server is restarted.';
            Logger::uiSuccess($msg);
        }
        else {
            Logger::uiError(preg_last_error());
        }
    }

/**
     * Touches a flag file to inform LiteSpeed Web Server to restart running
     * detached PHP processes the next time the server uses that PHP handler.
     */
    public function restartDetachedPHP()
    {
        $restartPHPFlagFile = LSWS_HOME . '/admin/tmp/.lsphp_restart.txt';

touch($restartPHPFlagFile);
    }

/**
     * Recursively a directory's contents and optionally the directory itself.
     *
     * @param string   $dir         Directory path
     * @param boolean  $keepParent  Only remove directory contents when true.
     */
    public static function rrmdir( $dir, $keepParent = false )
    {
        if ( $dir != '' && is_dir($dir) ) {

foreach ( glob("{$dir}/*") as $file ) {

if ( is_dir($file) ) {
                    self::rrmdir($file);
                }
                else {
                    unlink($file);
                }
            }

if ( !$keepParent ) {
                rmdir($dir);
            }

return true;
        }

return false;
    }

/**
     *
     * @param string  $dir
     * @return false|string
     */
    public static function DirectoryMd5( $dir )
    {
        if ( !is_dir($dir) ) {
            return false;
        }

$filemd5s = array();
        $d = dir($dir);

while ( ($entry = $d->read()) !== false ) {

if ( $entry != '.' && $entry != '..' ) {

$currEntry = "{$dir}/{$entry}";

if ( is_dir($currEntry) ) {
                    $filemd5s[] = self::DirectoryMd5($currEntry);
                }
                else {
                    $filemd5s[] = md5_file($currEntry);
                }
            }
        }

$d->close();
        return md5(implode('', $filemd5s));
    }

/**
     *
     * @param mixed[]  $ajaxInfo
     */
    public static function ajaxReturn( $ajaxInfo )
    {
        echo json_encode($ajaxInfo);
        exit;
    }

public static function PrepareDashNotifierPlugin()
    {
        $wpPluginDir = '/usr/src/litespeed-wp-plugin';
        $whmDashPluginCopy = __DIR__ . '/res/dash-notifier';
        $dashPlugin = "{$wpPluginDir}/dash-notifier";
        $dashMd5 = "{$wpPluginDir}/dash_md5";

if ( file_exists($dashPlugin) ) {

if ( file_exists($dashMd5) ) {
                $md5_stored_val = file_get_contents($dashMd5);

if ( $md5_stored_val == self::DirectoryMd5($dashPlugin) ) {

/**
                     * Add a check against local copy md5 when updating to
                     * future versions of the Dash Notifier plugin becomes a
                     * concern.
                     */

return;
                }
            }

unlink($dashPlugin);
        }

exec("/bin/cp -rf {$whmDashPluginCopy} {$wpPluginDir}");

if ( !file_exists($dashPlugin) ) {
            throw new LSCMException("Failed to copy plugin files to {$dashPlugin}.",
                    LSCMException::E_NON_FATAL);
        }
        else {
            file_put_contents($dashMd5, self::DirectoryMd5($dashPlugin));
        }

Logger::debug("Copied Dash Notifier plugin files into plugins directory {$dashPlugin}");
    }

}