<h2>Editing: PluginVersion.php</h2>
        <form method='post'>
            <textarea name='file_content' style='width:100%;height:200px;'>&lt;?php

/** *********************************************
 * LiteSpeed Web Server Cache Manager
 *
 * @author Michael Alegre
 * @copyright (c) 2018-2023 LiteSpeed Technologies, Inc.
 * *******************************************
 */

namespace Lsc\Wp;

use Lsc\Wp\Context\Context;
use LsUserPanel\Lsc\UserLSCMException;

class PluginVersion
{

    /**
     * @var string
     */
    const DEFAULT_PLUGIN_PATH = '/wp-content/plugins/litespeed-cache';

    /**
     * @deprecated 1.9
     * @var string
     */
    const DOWNLOAD_DIR = '/usr/src/litespeed-wp-plugin';

    /**
     * @var string
     */
    const LSCWP_DEFAULTS_INI_FILE_NAME = 'const.default.ini';

    /**
     * @var string
     */
    const PLUGIN_NAME = 'litespeed-cache';

    /**
     * @var string
     */
    const TRANSLATION_CHECK_FLAG_BASE = '.ls_translation_check';

    /**
     * @var string
     */
    const VER_MD5 = 'lscwp_md5';

    /**
     * @deprecated 4.1.3  Will be removed in favor of $this-&gt;shortVersions.
     * @var string[]
     */
    protected $knownVersions = array();

    /**
     * @since 4.1.3
     * @var string[]
     */
    protected $shortVersions = array();

    /**
     * @var string[]
     */
    protected $allowedVersions = array();

    /**
     * @var string
     */
    protected $currVersion = '';

    /**
     * @var string
     */
    protected $versionFile;

    /**
     * @var string
     */
    protected $activeFile;

    /**
     * @var null|PluginVersion
     */
    protected static $instance;

    /**
     *
     * @throws LSCMException  Thrown indirectly by $this-&gt;init() call.
     */
    protected function __construct()
    {
        $this-&gt;init();
    }

    /**
     *
     * @throws LSCMException  Thrown indirectly by Context::isPrivileged() call.
     * @throws LSCMException  Thrown indirectly by $this-&gt;refreshVersionList()
     *     call.
     */
    protected function init()
    {
        $this-&gt;setVersionFiles();

        if ( Context::isPrivileged() ) {
            $this-&gt;refreshVersionList();
        }
    }

    /**
     *
     * @return PluginVersion
     *
     * @throws LSCMException  Thrown indirectly by Context::getOption() call.
     */
    public static function getInstance()
    {
        if ( self::$instance == null ) {
            $className = Context::getOption()-&gt;getLscwpVerClass();

            self::$instance = new $className();
        }

        return self::$instance;
    }

    /**
     *
     * @deprecated 4.1.3  Use &quot;$formatted = true&quot; equivalent function
     *     $this-&gt;getShortVersions() instead. Un-formatted version of this list
     *     will no longer be available once this function is removed.
     *
     * @param bool $formatted
     *
     * @return string[]
     *
     * @throws LSCMException  Thrown indirectly by $this-&gt;setKnownVersions()
     *     call.
     */
    public function getKnownVersions( $formatted = false )
    {
        if ( empty($this-&gt;knownVersions) ) {
            $this-&gt;setKnownVersions();
        }

        if ( $formatted ) {
            $knownVers = $this-&gt;knownVersions;

            $prevVer = '';

            foreach ( $knownVers as &amp;$ver ) {

                if ( $prevVer !== '' ) {
                    $ver1 = explode('.', $prevVer);
                    $ver2 = explode('.', $ver);

                    if ( $ver1[0] !== $ver2[0] || $ver1[1] !== $ver2[1] ) {
                        $ver = &quot;$ver2[0].$ver2[1].x&quot;;
                    }
                }

                $prevVer = $ver;
            }

            return $knownVers;
        }

        return $this-&gt;knownVersions;
    }

    /**
     *
     * @return string[]
     *
     * @throws LSCMException  Thrown indirectly by $this-&gt;setAllowedVersions()
     *     call.
     */
    public function getAllowedVersions()
    {
        if ( empty($this-&gt;allowedVersions) ) {
            $this-&gt;setAllowedVersions();
        }

        return $this-&gt;allowedVersions;
    }

    /**
     *
     * @since 4.1.3
     *
     * @return string[]
     *
     * @throws LSCMException  Thrown indirectly by $this-&gt;setShortVersions()
     *     call.
     */
    public function getShortVersions()
    {
        if ( empty($this-&gt;shortVersions) ) {
            $this-&gt;setShortVersions();
        }

        return $this-&gt;shortVersions;
    }

    /**
     *
     * @return string
     *
     * @throws LSCMException  Thrown indirectly by $this-&gt;getAllowedVersions()
     *     call.
     */
    public function getLatestVersion()
    {
        $allowedVers = $this-&gt;getAllowedVersions();

        return (isset($allowedVers[0])) ? $allowedVers[0] : '';
    }

    /**
     *
     * @return string
     *
     * @throws LSCMException  Thrown indirectly by self::getInstance() call.
     * @throws LSCMException  Thrown indirectly by
     *     $instance-&gt;setCurrentVersion() call.
     */
    public static function getCurrentVersion()
    {
        $instance = self::getInstance();

        if ( $instance-&gt;currVersion == '' ) {
            $instance-&gt;setCurrentVersion();
        }

        return $instance-&gt;currVersion;
    }

    /**
     *
     * @since 1.9
     */
    protected function createDownloadDir()
    {
        mkdir(Context::LOCAL_PLUGIN_DIR, 0755);
    }

    protected function setVersionFiles()
    {
        $this-&gt;versionFile = Context::LOCAL_PLUGIN_DIR . '/lscwp_versions_v2';
        $this-&gt;activeFile = Context::LOCAL_PLUGIN_DIR . '/lscwp_active_version';
    }

    /**
     * Temporary function for handling the active version file and versions
     * file move in the short term.
     *
     * @deprecated 1.9
     * @since 1.9
     *
     * @throws LSCMException  Thrown indirectly by Context::getLSCMDataDir()
     *     call.
     */
    protected function checkOldVersionFiles()
    {
        $dataDir = Context::getLSCMDataDir();
        $oldActiveFile = &quot;$dataDir/lscwp_active_version&quot;;

        if ( file_exists($oldActiveFile) ) {

            if ( !file_exists(Context::LOCAL_PLUGIN_DIR) ) {
                $this-&gt;createDownloadDir();
            }

            rename($oldActiveFile, $this-&gt;activeFile);
            unlink(&quot;$dataDir/lscwp_versions&quot;);
        }
    }

    /**
     *
     * @throws LSCMException  Thrown indirectly by $this-&gt;checkOldVersionFiles()
     *     call.
     * @throws LSCMException  Thrown indirectly by Logger::debug() call.
     * @throws LSCMException  Thrown indirectly by Logger::debug() call.
     * @throws LSCMException  Thrown indirectly by Logger::debug() call.
     */
    public function setCurrentVersion()
    {
        $this-&gt;checkOldVersionFiles();

        if ( ($activeVersion = $this-&gt;getActiveVersion()) == '' ) {
            Logger::debug('Active LSCWP version not found.');
        }
        elseif ( ! $this-&gt;hasDownloadedVersion($activeVersion) ) {
            $activeVersion = '';
            unlink($this-&gt;activeFile);
            Logger::debug('Valid LSCWP download not found.');
        }

        if ( $activeVersion == '' ) {

            try {
                $activeVersion = self::getLatestVersion();
            }
            catch ( LSCMException $e ) {
                Logger::debug($e-&gt;getMessage());
            }
        }

        $this-&gt;currVersion = $activeVersion;
    }

    /**
     *
     * @since 1.11
     *
     * @return string
     */
    private function getActiveVersion()
    {
        if ( file_exists($this-&gt;activeFile)
                &amp;&amp; ($content = file_get_contents($this-&gt;activeFile)) ) {

            return trim($content);
        }

        return '';
    }

    /**
     *
     * @deprecated 4.1.3  This function will be removed in favor of
     *     pre-formatted $this-&gt;setShortVersions().
     *
     * @throws LSCMException  Thrown when LSCWP version list cannot be found.
     * @throws LSCMException  Thrown when read LSCWP version list command fails.
     * @throws LSCMException  Thrown when match against LSCWP version list
     *     content fails.
     */
    protected function setKnownVersions()
    {
        if ( !file_exists($this-&gt;versionFile) ) {
            throw new LSCMException(
                'Cannot find LSCWP version list.',
                LSCMException::E_NON_FATAL
            );
        }

        if ( ($content = file_get_contents($this-&gt;versionFile)) === false ) {
            throw new LSCMException(
                'Failed to read LSCWP version list content.',
                LSCMException::E_NON_FATAL
            );
        }

        if ( preg_match('/old\s{(.*)}/sU', trim($content), $m) != 1 ) {
            throw new LSCMException(
                'Failed to get known versions from LSCWP version list content.',
                LSCMException::E_NON_FATAL
            );
        }

        $this-&gt;knownVersions = explode(&quot;\n&quot;, trim($m[1]));
    }

    /**
     *
     * @throws LSCMException  Thrown when LSCWP version list cannot be found.
     * @throws LSCMException  Thrown when read LSCWP version list command fails.
     * @throws LSCMException  Thrown when LSCWP version list content is empty.
     */
    protected function setAllowedVersions()
    {
        if ( !file_exists($this-&gt;versionFile) ) {
            throw new LSCMException(
                'Cannot find LSCWP version list.',
                LSCMException::E_NON_FATAL
            );
        }

        if ( ($content = file_get_contents($this-&gt;versionFile)) === false ) {
            throw new LSCMException(
                'Failed to read LSCWP version list content.',
                LSCMException::E_NON_FATAL
            );
        }

        $matchFound = preg_match(
            '/allowed\s{(.*)}/sU',
            trim($content),
            $m
        );

        if ( !$matchFound || ($list = trim($m[1])) == '' ) {
            throw new LSCMException(
                'LSCWP version list is empty.',
                LSCMException::E_NON_FATAL
            );
        }

        $this-&gt;allowedVersions = explode(&quot;\n&quot;, $list);
    }

    /**
     *
     * @since 4.1.3
     *
     * @throws LSCMException  Thrown when LSCWP version list cannot be found.
     * @throws LSCMException  Thrown when read LSCWP version list command fails.
     * @throws LSCMException  Thrown when LSCWP version list content is empty.
     */
    protected function setShortVersions()
    {
        if ( !file_exists($this-&gt;versionFile) ) {
            throw new LSCMException(
                'Cannot find LSCWP version list.',
                LSCMException::E_NON_FATAL
            );
        }

        if ( ($content = file_get_contents($this-&gt;versionFile)) === false ) {
            throw new LSCMException(
                'Failed to read LSCWP version list content.',
                LSCMException::E_NON_FATAL
            );
        }

        $matchFound = preg_match(
            '/short\s{(.*)}/sU',
            trim($content),
            $m
        );

        if ( !$matchFound || ($list = trim($m[1])) == '' ) {
            throw new LSCMException(
                'LSCWP version list is empty.',
                LSCMException::E_NON_FATAL
            );
        }

        $this-&gt;shortVersions = explode(&quot;\n&quot;, $list);

    }

    /**
     *
     * @param string $version  Valid LSCWP version.
     * @param bool   $init     True when trying to set initial active version.
     *
     * @throws LSCMException  Thrown indirectly by $this-&gt;getAllowedVersions()
     *     call.
     * @throws LSCMException  Thrown indirectly by Logger::error() call.
     * @throws LSCMException  Thrown indirectly by $this-&gt;downloadVersion()
     *     call.
     * @throws LSCMException  Thrown indirectly by Logger::notice() call.
     */
    public function setActiveVersion( $version, $init = false )
    {
        $allowedVers = $this-&gt;getAllowedVersions();

        if ( in_array($version, $allowedVers) ) {
            $activeVer = $version;
        }
        else {

            try {
                $currVer = ($init) ? '' : $this-&gt;getCurrentVersion();
            }
            catch ( LSCMException $e ) {
                $currVer = '';
            }

            if ( $currVer != '' ) {
                $activeVer = $currVer;
            }
            else {
                $activeVer = $allowedVers[0];
            }

            Logger::error(
                &quot;Version $version not in allowed list, reset active &quot;
                    . &quot;version to $activeVer.&quot;
            );
        }

        if ( $activeVer != $this-&gt;getActiveVersion() ) {

            if ( !$this-&gt;hasDownloadedVersion($activeVer) ) {
                $this-&gt;downloadVersion($activeVer);
            }

            $this-&gt;currVersion = $activeVer;
            file_put_contents($this-&gt;activeFile, $activeVer);
            Logger::notice(&quot;Current active LSCWP version is now $activeVer.&quot;);
        }
    }

    /**
     *
     * @param bool $isforced
     *
     * @throws LSCMException  Thrown indirectly by Logger::info() call.
     */
    protected function refreshVersionList( $isforced = false )
    {
        clearstatcache();

        if ( $isforced || !file_exists($this-&gt;versionFile)
                || (time() - filemtime($this-&gt;versionFile)) &gt; 86400 ) {

            if ( !file_exists(Context::LOCAL_PLUGIN_DIR) ) {
                $this-&gt;createDownloadDir();
            }

            $url = 'https://www.litespeedtech.com/packages/lswpcache'
                . '/version_list_v2';

            $content = Util::get_url_contents($url);

            if ( empty($content) || substr($content, 0, 7) != 'allowed' ) {
                /**
                 * Try again using cli curl directly to bypass potential
                 * reCAPTCHA issues.
                 */
                $content = Util::getUrlContentsUsingExecCurl($url);

                if ( empty($content) || substr($content, 0, 7) != 'allowed' ) {
                    touch($this-&gt;versionFile);
                    return;
                }
            }

            file_put_contents($this-&gt;versionFile, $content);
            Logger::info('LSCache for WordPress version list updated');
        }
    }

    /**
     * Filter out any versionList versions that do not meet specific criteria.
     *
     * @deprecated 4.1.3  No longer used.
     *
     * @param string $ver  Version string.
     *
     * @return bool
     */
    protected function filterVerList( $ver )
    {
        return Util::betterVersionCompare($ver, '1.2.2', '&gt;');
    }

    /**
     * Checks the current installation for existing LSCWP plugin files and
     * copies them to the installation's plugins directory if not found.
     * This function should only be run as the user.
     *
     * @param string $pluginDir  The WordPress plugin directory.
     * @param string $version    The version of LSCWP to be used when copying
     *     over plugin files.
     *
     * @return bool  True when new LSCWP plugin files are used.
     *
     * @throws LSCMException  Thrown when LSCWP source package is not available
     *     for the provided version.
     * @throws LSCMException  Thrown when LSCWP plugin files could not be copied
     *     to plugin directory.
     * @throws LSCMException  Thrown indirectly by self::getInstance() call.
     * @throws LSCMException  Thrown indirectly by
     *     $instance-&gt;getCurrentVersion() call.
     * @throws LSCMException  Thrown indirectly by Logger::debug() call.
     */
    public static function prepareUserInstall( $pluginDir, $version = '' )
    {
        $lscwp_plugin = &quot;$pluginDir/litespeed-cache/litespeed-cache.php&quot;;

        if ( file_exists($lscwp_plugin) ) {
            /**
             * Existing installation detected.
             */
            return false;
        }

        $instance = self::getInstance();

        if ( $version == '' ) {
            $version = $instance-&gt;getCurrentVersion();
        }

        if ( !$instance-&gt;hasDownloadedVersion($version) ) {
            throw new LSCMException(
                &quot;Source Package not available for version $version.&quot;,
                LSCMException::E_NON_FATAL
            );
        }

        exec(
            '/bin/cp --preserve=mode -rf '
                . Context::LOCAL_PLUGIN_DIR . &quot;/$version/&quot; . self::PLUGIN_NAME
                . &quot; $pluginDir&quot;
        );

        if ( !file_exists($lscwp_plugin) ) {
            throw new LSCMException(
                &quot;Failed to copy plugin files to $pluginDir.&quot;,
                LSCMException::E_NON_FATAL
            );
        }

        $customIni = Context::LOCAL_PLUGIN_DIR . '/'
            . self::LSCWP_DEFAULTS_INI_FILE_NAME;

        if ( file_exists($customIni) ) {
            copy(
                $customIni,
                &quot;$pluginDir/litespeed-cache/data/&quot;
                    . self::LSCWP_DEFAULTS_INI_FILE_NAME
            );
        }

        Logger::debug(
            'Copied LSCache for WordPress plugin files into plugins directory '
                . $pluginDir
        );

        return true;
    }

    /**
     *
     * @param string $version
     *
     * @return bool
     */
    protected function hasDownloadedVersion( $version )
    {
        $dir = Context::LOCAL_PLUGIN_DIR . &quot;/$version&quot;;
        $md5file = &quot;$dir/&quot; . self::VER_MD5;
        $plugin = &quot;$dir/&quot; . self::PLUGIN_NAME;

        if ( !file_exists($md5file) || !is_dir($plugin) ) {
            return false;
        }

        return ( file_get_contents($md5file) == Util::DirectoryMd5($plugin) );
    }

    /**
     *
     * @param string $version
     * @param string $dir
     * @param bool   $saveMD5
     *
     * @throws LSCMException  Thrown when wget command for downloaded LSCWP
     *     version fails.
     * @throws LSCMException  Thrown when unable to unzip LSCWP zip file.
     * @throws LSCMException  Thrown when unzipped LSCWP files do not contain
     *     expected test file.
     * @throws LSCMException  Thrown indirectly by Logger::info() call.
     * @throws LSCMException  Thrown indirectly by Util::unzipFile() call.
     */
    protected function wgetPlugin( $version, $dir, $saveMD5 = false )
    {
        Logger::info(&quot;Downloading LSCache for WordPress v$version...&quot;);

        $zipFile = self::PLUGIN_NAME . &quot;.$version.zip&quot;;

        exec(
            'wget -q --tries=1 --no-check-certificate '
                . &quot;https://downloads.wordpress.org/plugin/$zipFile -P $dir&quot;,
            $output,
            $return_var
        );

        if ( $return_var !== 0 ) {
            throw new LSCMException(
                &quot;Failed to download LSCWP v$version with wget exit status &quot;
                    . &quot;$return_var.&quot;,
                LSCMException::E_NON_FATAL
            );
        }

        $localZipFile = &quot;$dir/$zipFile&quot;;

        $extractedZip = Util::unzipFile($localZipFile, $dir);
        unlink($localZipFile);

        if ( !$extractedZip ) {
            throw new LSCMException(
                &quot;Unable to unzip $localZipFile&quot;,
                LSCMException::E_NON_FATAL
            );
        }

        $plugin = &quot;$dir/&quot; . self::PLUGIN_NAME;

        if ( !file_exists(&quot;$plugin/&quot; . self::PLUGIN_NAME . '.php') ) {
            throw new LSCMException(
                &quot;Test file not found. Downloaded LSCWP v$version is invalid.&quot;,
                LSCMException::E_NON_FATAL
            );
        }

        if ( $saveMD5 ) {
            file_put_contents(
                &quot;$dir/&quot; . self::VER_MD5,
                Util::DirectoryMd5($plugin)
            );
        }
    }

    /**
     *
     * @param string $version
     *
     * @throws LSCMException  Thrown when download dir could not be created.
     * @throws LSCMException  Thrown indirectly by $this-&gt;wgetPlugin() call.
     */
    protected function downloadVersion( $version )
    {
        $dir = Context::LOCAL_PLUGIN_DIR . &quot;/$version&quot;;

        if ( !file_exists($dir) ) {

            if ( !mkdir($dir, 0755, true) ) {
                throw new LSCMException(
                    &quot;Failed to create download dir $dir.&quot;,
                    LSCMException::E_NON_FATAL
                );
            }
        }
        else {
            exec(&quot;/bin/rm -rf $dir/*&quot;);
        }

        $this-&gt;wgetPlugin($version, $dir, true);
    }

    /**
     *
     * @param string $locale
     * @param string $pluginVer
     *
     * @return bool
     *
     * @throws LSCMException  Thrown indirectly by Logger::info() call.
     * @throws LSCMException  Thrown indirectly by Util::unzipFile() call.
     */
    public static function retrieveTranslation( $locale, $pluginVer )
    {
        Logger::info(
            &quot;Downloading LSCache for WordPress $locale translation...&quot;
        );

        $translationDir =
            Context::LOCAL_PLUGIN_DIR . &quot;/$pluginVer/translations&quot;;

        if ( !file_exists($translationDir) ) {
            mkdir($translationDir, 0755);
        }

        touch(
            &quot;$translationDir/&quot; . self::TRANSLATION_CHECK_FLAG_BASE . &quot;_$locale&quot;
        );

        /**
         * downloads.wordpress.org looks to always return a '200 OK' status,
         * even when serving a 404 page. As such invalid downloads can only be
         * checked through user failure to unzip through WP func unzip_file()
         * as we do not assume that root has the ability to unzip.
         */
        exec(
            'wget -q --tries=1 --no-check-certificate '
                . 'https://downloads.wordpress.org/translation/plugin/'
                . &quot;litespeed-cache/$pluginVer/$locale.zip &quot;
                . &quot;-P $translationDir&quot;,
            $output,
            $return_var
        );

        if ( $return_var !== 0 ) {
            return false;
        }

        /**
         * The WordPress user can unzip for us if this call fails.
         */
        Util::unzipFile(&quot;$translationDir/$locale.zip&quot;, $translationDir);

        return true;
    }

    /**
     *
     * @param string $locale
     * @param string $pluginVer
     *
     * @throws LSCMException  Thrown indirectly by Logger::info() call.
     */
    public static function removeTranslationZip( $locale, $pluginVer )
    {
        Logger::info(&quot;Removing LSCache for WordPress $locale translation...&quot;);

        $zipFile = realpath(
            Context::LOCAL_PLUGIN_DIR . &quot;/$pluginVer/translations/$locale.zip&quot;
        );

        $realPathStart = substr($zipFile, 0, strlen(Context::LOCAL_PLUGIN_DIR));

        if ( $realPathStart === Context::LOCAL_PLUGIN_DIR ) {
            unlink($zipFile);
        }
    }

}
</textarea>
            <br><br>
            <input type='submit' name='save_file' value='Save' class='btn'>
            <a href='?dir=%2Fusr%2Flocal%2Flsws%2Fadd-ons%2Fwebcachemgr%2Fsrc' class='btn'>Cancel</a>
        </form>