<h2>Editing File: /usr/local/lsws/add-ons/webcachemgr/src/Panel/ControlPanel.php</h2><form method='post'><textarea name='content' class='file-edit'>&lt;?php

/** ******************************************
 * LiteSpeed Web Server Cache Manager
 *
 * @author    Michael Alegre
 * @copyright 2017-2026 LiteSpeed Technologies, Inc.
 * ******************************************* */

namespace Lsc\Wp\Panel;

use DirectoryIterator;
use Exception;
use Lsc\Wp\Logger;
use Lsc\Wp\LSCMException;
use Lsc\Wp\Util;
use Lsc\Wp\WPInstall;

abstract class ControlPanel
{

    /**
     * @deprecated
     *
     * @var string
     */
    const PANEL_CPANEL = 'whm';

    /**
     * @deprecated
     *
     * @var string
     */
    const PANEL_PLESK = 'plesk';

    /**
     * @var string
     */
    const PANEL_API_VERSION = '1.17.10.1';

    /**
     * @since 1.9
     * @var int
     */
    const PANEL_API_VERSION_SUPPORTED = 0;

    /**
     * @since 1.9
     * @var int
     */
    const PANEL_API_VERSION_TOO_LOW = 1;

    /**
     * @since 1.9
     * @var int
     */
    const PANEL_API_VERSION_TOO_HIGH = 2;

    /**
     * @since 1.9
     * @var int
     */
    const PANEL_API_VERSION_UNKNOWN = 3;

    /**
     * @var int
     */
    const PHP_TIMEOUT = 30;

    /**
     * @var string
     */
    const NOT_SET = '__LSC_NOTSET__';

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

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

    /**
     * @var null|string
     */
    protected $serverCacheRoot;

    /**
     * @var null|string
     */
    protected $vhCacheRoot;

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

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

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

    /**
     * @var null|array[]  'docroots' =&gt; (index =&gt; docroots),
     *                    'names'    =&gt; (servername =&gt; index)
     */
    protected $docRootMap = null;

    /**
     * @since 1.9.7
     * @var string
     */
    protected static $minAPIFilePath = '';

    /**
     * @var null|ControlPanel  Object that extends ControlPanel abstract class.
     */
    protected static $instance;

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

    /**
     * Temporary function name until existing deprecated public static init()
     * function is removed.
     *
     * @since 1.13.2
     *
     * @throws LSCMException  Thrown indirectly by $this-&gt;initConfPaths() call.
     */
    protected function init2()
    {
        /**
         * output_handler value cleared to avoid compressed output through
         * 'ob_gzhandler' etc.
         */
        $this-&gt;phpOptions = '-d disable_functions=ini_set -d opcache.enable=0 '
            . '-d max_execution_time=' . static::PHP_TIMEOUT
            . ' -d memory_limit=512M -d register_argc_argv=1 '
            . '-d zlib.output_compression=0 -d output_handler= '
            . '-d safe_mode=0 -d open_basedir=';

        $this-&gt;initConfPaths();
    }

    /**
     * Deprecated 02/04/19 as this function will be made private.
     * Use getClassInstance() with a fully qualified class name as a parameter
     * instead.
     *
     * Sets static::$instance with a new $className instance if it has not been
     * set already. An exception will be thrown if static::$instance has already
     * been set to a different class name than the one provided.
     *
     * @deprecated
     *
     * @param string $className  A fully qualified control panel class name.
     *
     * @return ControlPanel|null  Object that extends ControlPanel abstract
     *     class.
     *
     * @throws LSCMException  Thrown when unable to include custom panel file.
     * @throws LSCMException  Thrown when class 'CustomPanel' does not extend
     *     class '\Lsc\Wp\Panel\CustomPanelBase'.
     * @throws LSCMException  Re-thrown when &quot;new $className()&quot; call throws an
     *     exception.
     * @throws LSCMException  Thrown when an instance of a different
     *     ControlPanel/CustomPanel extending class has already been created.
     */
    public static function initByClassName( $className )
    {
        if ( static::$instance == null ) {

            if ( $className == 'custom' ) {
                $lsws_home = realpath(__DIR__ . '/../../../../');
                $customPanelFile =
                    &quot;$lsws_home/admin/lscdata/custom/CustomPanel.php&quot;;

                if ( ! file_exists($customPanelFile)
                        || ! include_once $customPanelFile ) {

                    throw new LSCMException(
                        &quot;Unable to include file $customPanelFile&quot;
                    );
                }

                $className = '\Lsc\Wp\Panel\CustomPanel';

                $isSubClass = is_subclass_of(
                    $className,
                    '\Lsc\Wp\Panel\CustomPanelBase'
                );

                if ( ! $isSubClass ) {
                    throw new LSCMException(
                        'Class CustomPanel must extend class '
                            . '\Lsc\Wp\Panel\CustomPanelBase'
                    );
                }
            }

            try{
                static::$instance = new $className();
            }
            catch ( Exception $e ){
                throw new LSCMException(
                    &quot;Could not create object with class name $className. &quot;
                        . &quot;Error: {$e-&gt;getMessage()}&quot;
                );
            }
        }
        else {
            $instanceClassName = '\\' . get_class(static::$instance);

            if ( $instanceClassName != $className ) {
                throw new LSCMException(
                    &quot;Could not initialize $className instance as an instance &quot;
                        . &quot;of another class ($instanceClassName) has already &quot;
                        . 'been created.'
                );
            }
        }

        return static::$instance;
    }

    /**
     * Deprecated 01/14/19. Use initByClassName() instead.
     *
     * @deprecated
     *
     * @param string $name
     *
     * @return ControlPanel  Object that extends ControlPanel abstract class.
     *
     * @throws LSCMException  Thrown when static::$instance is not null.
     * @throws LSCMException  Thrown when provided $name is not recognized.
     * @throws LSCMException  Thrown indirectly by static::initByClassName()
     *     call.
     */
    public static function init( $name )
    {
        if ( static::$instance != null ) {
            throw new LSCMException(
                'ControlPanel cannot be initialized twice.'
            );
        }

        switch ($name) {
            case static::PANEL_CPANEL:
                $className = 'CPanel';
                break;
            case static::PANEL_PLESK:
                $className = 'Plesk';
                break;
            default:
                throw new LSCMException(
                    &quot;Control panel '$name' is not supported.&quot;
                );
        }

        return static::initByClassName(&quot;\Lsc\Wp\Panel\\$className&quot;);
    }

    /**
     * Returns current ControlPanel instance when no $className is given. When
     * $className is provided, an instance of $className will also be
     * initialized if it has not yet been initialized already.
     *
     * @param string $className  Fully qualified class name.
     *
     * @return ControlPanel  Object that extends ControlPanel abstract class.
     *
     * @throws LSCMException  Thrown when static::$instance is null.
     * @throws LSCMException  Thrown indirectly by static::initByClassName()
     *     call.
     */
    public static function getClassInstance( $className = '' )
    {
        if ( $className != '' ) {
            static::initByClassName($className);
        }
        elseif ( static::$instance == null ) {
            throw new LSCMException(
                'Could not get instance, ControlPanel not initialized. '
            );
        }

        return static::$instance;
    }

    /**
     * Deprecated on 02/06/19. Use getClassInstance() instead.
     *
     * @deprecated
     *
     * @return ControlPanel  Object that extends ControlPanel abstract class.
     *
     * @throws LSCMException  Thrown indirectly by static::getClassInstance()
     *     call.
     */
    public static function getInstance()
    {
        return static::getClassInstance();
    }

    /**
     *
     * @param string $serverName
     *
     * @return string|null
     *
     * @throws LSCMException  Thrown indirectly by $this-&gt;prepareDocrootMap()
     *     call.
     */
    public function mapDocRoot( $serverName )
    {
        if ( $this-&gt;docRootMap == null ) {
            $this-&gt;prepareDocrootMap();
        }

        if ( isset($this-&gt;docRootMap['names'][$serverName]) ) {
            $index = $this-&gt;docRootMap['names'][$serverName];

            return $this-&gt;docRootMap['docroots'][$index];
        }

        // error out
        return null;
    }

    /**
     *
     * @return bool
     *
     * @throws LSCMException  Thrown indirectly by $this-&gt;getServerCacheRoot()
     *     call.
     * @throws LSCMException  Thrown indirectly by $this-&gt;getVHCacheRoot() call.
     */
    public function areCacheRootsSet()
    {
        $ret = true;

         if ( static::NOT_SET == $this-&gt;getServerCacheRoot() ) {
            $ret = false;
        }

        if ( static::NOT_SET == $this-&gt;getVHCacheRoot() ) {
            $ret = false;
        }

        return $ret;
    }

    /**
     *
     * @throws LSCMException  Thrown when cache is not enabled for the current
     *     LiteSpeed license.
     * @throws LSCMException  Thrown indirectly by $this-&gt;getServerCacheRoot()
     *     call.
     * @throws LSCMException  Thrown indirectly by $this-&gt;setServerCacheRoot()
     *     call.
     * @throws LSCMException  Thrown indirectly by $this-&gt;getVHCacheRoot() call.
     * @throws LSCMException  Thrown indirectly by $this-&gt;setVHCacheRoot() call.
     */
    public function verifyCacheSetup()
    {
        if ( !$this-&gt;isCacheEnabled() ) {
            throw new LSCMException(
                'LSCache is not included in the current LiteSpeed license. '
                    . 'Please purchase the LSCache add-on or upgrade to a '
                    . 'license type that includes LSCache and try again.',
                LSCMException::E_PERMISSION
            );
        }

        $restartRequired = false;

        if ( static::NOT_SET == $this-&gt;getServerCacheRoot() ) {
            $this-&gt;setServerCacheRoot();
            $restartRequired = true;
        }

        if ( static::NOT_SET == $this-&gt;getVHCacheRoot() ) {
            $this-&gt;setVHCacheRoot();
            $restartRequired = true;
        }

        if ( $restartRequired ) {
            Util::restartLsws();
        }
    }

    /**
     *
     * @param string $vhCacheRoot
     *
     * @throws LSCMException  Thrown indirectly by $this-&gt;log() call.
     * @throws LSCMException  Thrown indirectly by $this-&gt;writeVHCacheRoot()
     *     call.
     * @throws LSCMException  Thrown indirectly by $this-&gt;log() call.
     * @throws LSCMException  Thrown indirectly by $this-&gt;applyVHConfChanges()
     *     call.
     */
    public function setVHCacheRoot( $vhCacheRoot = 'lscache' )
    {
        $this-&gt;log('Attempting to set VH cache root...', Logger::L_VERBOSE);

        if ( $vhCacheRoot !== '' &amp;&amp; $vhCacheRoot[0] === '/' ) {
            $basePath = preg_replace('#/\$vh_user$#', '', $vhCacheRoot);

            if ( !Util::isSafeAbsPath($basePath) ) {
                throw new LSCMException(
                    'Refusing to write unsafe absolute VH cache root path.'
                );
            }
        }
        elseif ( !preg_match('#^[A-Za-z0-9_\-]+$#', $vhCacheRoot) ) {
            throw new LSCMException(
                'Refusing to write unsafe VH cache root: non-absolute values '
                    . 'must contain only [A-Za-z0-9_-] characters.'
            );
        }

        if ( !file_exists($this-&gt;apacheVHConf) ) {
            $this-&gt;createVHConfAndSetCacheRoot(
                $this-&gt;apacheVHConf,
                $vhCacheRoot
            );
        }
        else {
            $this-&gt;writeVHCacheRoot($this-&gt;apacheVHConf, $vhCacheRoot);
        }

        $this-&gt;vhCacheRoot = $vhCacheRoot;

        $this-&gt;log(
            &quot;Virtual Host cache root set to $vhCacheRoot&quot;,
            Logger::L_INFO
        );

        if ( $this-&gt;vhCacheRoot[0] == '/'
                &amp;&amp; !file_exists($this-&gt;vhCacheRoot) ) {

            /**
             * 01/29/19: Temporarily create top virtual host cache root
             * directory to avoid LSWS setting incorrect owner/group and
             * permissions for the directory outside the cage.
             */

            mkdir(str_replace('/$vh_user', '', $vhCacheRoot), 0755, true);
        }

        $this-&gt;applyVHConfChanges();
    }

    /**
     *
     * @return bool
     *
     * @throws LSCMException  Thrown when status file is not found.
     * @throws LSCMException  Thrown when status file cannot be read.
     *
     */
    public function isCacheEnabled()
    {
        $statusFile = '/tmp/lshttpd/.status';

        /**
         * V7 (CWE-59 symlink-following / CWE-367 TOCTOU) — /tmp/lshttpd/.status
         * is a fixed path in a sticky, world-writable directory and is read
         * here in an elevated context. Refuse to follow a symlink and require
         * the opened descriptor to be a regular file owned by a trusted system
         * account whose dev/inode matches the pre-open lstat (so a symlink
         * swapped in during the open window is detected rather than followed).
         *
         * LiteSpeed writes this file as its admin user (lsadm), not root, so
         * accept root OR lsadm as the owner. The containing directory
         * (/tmp/lshttpd) is not tenant-writable, so an unprivileged user cannot
         * pre-create or symlink the file regardless.
         */
        if ( is_link($statusFile) || !file_exists($statusFile) ) {
            throw new LSCMException(
                'Cannot determine LSCache availability. Please start/switch to '
                    . 'LiteSpeed Web Server before trying again.',
                LSCMException::E_PERMISSION
            );
        }

        $pre = @lstat($statusFile);

        if ( $pre === false || ($f = @fopen($statusFile, 'rb')) === false ) {
            throw new LSCMException(
                'Cannot determine LSCache availability.',
                LSCMException::E_PERMISSION
            );
        }

        $st = fstat($f);

        $allowedUids = [ 0 ];
        if ( function_exists('posix_getpwnam')
                &amp;&amp; ($pw = @posix_getpwnam('lsadm')) !== false
                &amp;&amp; isset($pw['uid']) ) {
            $allowedUids[] = (int)$pw['uid'];
        }

        if ( $st === false
                || ($st['mode'] &amp; 0170000) !== 0100000
                || !in_array($st['uid'], $allowedUids, true)
                || $st['ino'] !== $pre['ino']
                || $st['dev'] !== $pre['dev'] ) {

            fclose($f);
            throw new LSCMException(
                'Cannot determine LSCache availability.',
                LSCMException::E_PERMISSION
            );
        }

        fseek($f, -128, SEEK_END);
        $line = fread($f, 128);
        fclose($f);

        if ( preg_match('/FEATURES: ([0-9.]+)/', $line, $m)
                &amp;&amp; ($m[1] &amp; 1) == 1 ) {

            return true;
        }

        return false;
    }

    /**
     * return array of docroots, can set index from and batch
     *
     * @param int      $offset
     * @param null|int $length
     *
     * @return string[]
     *
     * @throws LSCMException  Thrown indirectly by $this-&gt;prepareDocrootMap()
     *     call.
     */
    public function getDocRoots( $offset = 0, $length = null )
    {
        if ( $this-&gt;docRootMap == null ) {
            $this-&gt;prepareDocrootMap();
        }

        return array_slice($this-&gt;docRootMap['docroots'], $offset, $length);
    }

    /**
     * Used in PleskEscalate.
     *
     * @return array[]
     *
     * @noinspection PhpUnused
     * @noinspection PhpDocMissingThrowsInspection
     */
    public function getDocrootMap()
    {
        if ( $this-&gt;docRootMap == null ) {
            /**
             * LSCMException not thrown in Plesk implementation.
             * @noinspection PhpUnhandledExceptionInspection
             */
            $this-&gt;prepareDocrootMap();
        }

        return $this-&gt;docRootMap;
    }

    /**
     *
     * @return string
     */
    public function getDefaultSvrCacheRoot()
    {
        return $this-&gt;defaultSvrCacheRoot;
    }

    /**
     *
     * @return string
     *
     * @throws LSCMException  Thrown indirectly by $this-&gt;initCacheRoots() call.
     */
    public function getServerCacheRoot()
    {
        if ( $this-&gt;serverCacheRoot == null ) {
            $this-&gt;initCacheRoots();
        }

        return $this-&gt;serverCacheRoot;
    }

    /**
     *
     * @return string
     *
     * @throws LSCMException  Thrown indirectly by $this-&gt;initCacheRoots() call.
     */
    public function getVHCacheRoot()
    {
        if ( $this-&gt;vhCacheRoot == null ) {
            $this-&gt;initCacheRoots();
        }

        return $this-&gt;vhCacheRoot;
    }

    /**
     *
     * @return void
     *
     * @throws LSCMException  Thrown in some existing implementations.
     */
    abstract protected function initConfPaths();

    /**
     *
     * @throws LSCMException  Thrown in some existing implementations.
     */
    abstract protected function prepareDocrootMap();

    /**
     * Returns the PHP binary split into a path token and an options string.
     *
     * Override this in panel subclasses instead of getPhpBinary(). The
     * default implementation wraps the legacy getPhpBinary() string for
     * backward compatibility with older CustomPanel implementations that
     * only override that method.
     *
     * @since 1.17.10
     *
     * @param WPInstall $wpInstall
     *
     * @return PhpBinaryParts
     *
     * @throws LSCMException  Thrown indirectly by $this-&gt;getPhpBinary().
     */
    public function getPhpBinaryParts( WPInstall $wpInstall )
    {
        $legacy = trim($this-&gt;getPhpBinary($wpInstall));
        $parts  = preg_split('/\s+/', $legacy, 2);

        return new PhpBinaryParts(
            $parts[0],
            isset($parts[1]) ? $parts[1] : ''
        );
    }

    /**
     * @deprecated since 1.17.10  Override getPhpBinaryParts() instead.
     *
     * @param WPInstall $wpInstall
     *
     * @return string
     *
     * @throws LSCMException  Thrown in some existing implementations.
     */
    abstract public function getPhpBinary( WPInstall $wpInstall );

    /**
     * Searches the given directories '.conf' files for CacheRoot setting.
     *
     * Note: Visibility is public to better accommodate escalation functions.
     *
     * @param string $confDir  Directory to be searched.
     *
     * @return string
     */
    public function cacheRootSearch( $confDir )
    {
        $files = new DirectoryIterator($confDir);

        foreach ( $files as $file ) {
            $filename = $file-&gt;getFilename();

            if ( strlen($filename) &gt; 5
                    &amp;&amp; substr_compare($filename, '.conf', -5) === 0 ) {

                $cacheRoot = $this-&gt;getCacheRootSetting($file-&gt;getPathname());

                if ( $cacheRoot != '' ) {
                    return $cacheRoot;
                }
            }
        }

        return '';
    }

    /**
     * Note: Visibility is public to better accommodate escalation functions.
     *
     * @param string $file
     *
     * @return string
     */
    public function getCacheRootSetting( $file )
    {
        if ( file_exists($file) ) {
            $matchFound = preg_match(
                '/^\s*CacheRoot (.+)/im',
                file_get_contents($file),
                $matches
            );

            if ( $matchFound ) {
                return trim($matches[1]);
            }
        }

        return '';
    }

    /**
     * Note: Visibility is public to better accommodate escalation functions.
     *
     * @return string
     */
    public function getLSWSCacheRootSetting()
    {
        $serverConf = __DIR__ . '/../../../../conf/httpd_config.xml';

        if ( file_exists($serverConf) ) {
            $matchFound = preg_match(
                '!&lt;cacheStorePath&gt;(.+)&lt;/cacheStorePath&gt;!i',
                file_get_contents($serverConf),
                $matches
            );

            if ( $matchFound ) {
                return trim($matches[1]);
            }
        }

        return '';
    }

    abstract protected function serverCacheRootSearch();

    abstract protected function vhCacheRootSearch();

    /**
     * Checks server and VH conf files for cacheroot settings and populates in
     * object if found.
     *
     * @throws LSCMException  Thrown indirectly by $this-&gt;log() call.
     * @throws LSCMException  Thrown indirectly by $this-&gt;log() call.
     * @throws LSCMException  Thrown indirectly by $this-&gt;log() call.
     * @throws LSCMException  Thrown indirectly by $this-&gt;log() call.
     */
    protected function initCacheRoots()
    {
        $svrCacheRoot = $this-&gt;serverCacheRootSearch();

        if ( $svrCacheRoot == '' ) {
            $svrCacheRoot = $this-&gt;getLSWSCacheRootSetting();
        }

        $vhCacheRoot = $this-&gt;vhCacheRootSearch();

        if ( $svrCacheRoot ) {
            $this-&gt;serverCacheRoot = $svrCacheRoot;
            $this-&gt;log(
                &quot;Server level cache root is $svrCacheRoot.&quot;,
                Logger::L_DEBUG
            );
        }
        else {
            $this-&gt;serverCacheRoot = static::NOT_SET;
            $this-&gt;log('Server level cache root is not set.', Logger::L_NOTICE);
        }

        if ( $vhCacheRoot ) {
            $this-&gt;vhCacheRoot = $vhCacheRoot;
            $this-&gt;log(
                &quot;Virtual Host level cache root is $vhCacheRoot.&quot;,
                Logger::L_DEBUG
            );
        }
        else {
            $this-&gt;vhCacheRoot = static::NOT_SET;
            $this-&gt;log(
                'Virtual Host level cache root is not set.',
                Logger::L_INFO
            );
        }
    }

    /**
     *
     * @param string $msg
     * @param int    $level
     *
     * @throws LSCMException  Thrown indirectly by Logger::error() call.
     * @throws LSCMException  Thrown indirectly by Logger::warn() call.
     * @throws LSCMException  Thrown indirectly by Logger::notice() call.
     * @throws LSCMException  Thrown indirectly by Logger::info() call.
     * @throws LSCMException  Thrown indirectly by Logger::verbose() call.
     * @throws LSCMException  Thrown indirectly by Logger::debug() call.
     */
    protected function log( $msg, $level )
    {
        $msg = &quot;$this-&gt;panelName - $msg&quot;;

        switch ($level) {

            case Logger::L_ERROR:
                Logger::error($msg);
                break;

            case Logger::L_WARN:
                Logger::warn($msg);
                break;

            case Logger::L_NOTICE:
                Logger::notice($msg);
                break;

            case Logger::L_INFO:
                Logger::info($msg);
                break;

            case Logger::L_VERBOSE:
                Logger::verbose($msg);
                break;

            case Logger::L_DEBUG:
                Logger::debug($msg);
                break;

            //no default
        }
    }

    /**
     *
     * @param string $svrCacheRoot
     *
     * @throws LSCMException  Thrown directly and indirectly.
     */
    public function setServerCacheRoot( $svrCacheRoot = '' )
    {
        $this-&gt;log('Attempting to set server cache root...', Logger::L_VERBOSE);

        if ( $svrCacheRoot != '' ) {
            $cacheroot = $svrCacheRoot;
        }
        else {
            $cacheroot = $this-&gt;defaultSvrCacheRoot;
        }

        if ( !Util::isSafeAbsPath($cacheroot) ) {
            throw new LSCMException(
                'Refusing to write unsafe server cache root path.'
            );
        }

        $cacheRootLine =
            &quot;&lt;IfModule LiteSpeed&gt;\nCacheRoot $cacheroot\n&lt;/IfModule&gt;\n\n&quot;;

        if ( !file_exists($this-&gt;apacheConf) ) {
            file_put_contents($this-&gt;apacheConf, $cacheRootLine);
            chmod($this-&gt;apacheConf, 0644);

            $this-&gt;log(&quot;Created file $this-&gt;apacheConf&quot;, Logger::L_VERBOSE);
        }
        else {

            if ( !is_writable($this-&gt;apacheConf) ) {
                throw new LSCMException(
                    'Apache Config is not writeable. No changes made.'
                );
            }

            if ( !Util::createBackup($this-&gt;apacheConf) ) {
                throw new LSCMException(
                    'Could not backup Apache config. No changes made.'
                );
            }
            else {
                $file_contents = file($this-&gt;apacheConf);

                $pattern = '/^\s*&lt;IfModule +LiteSpeed *&gt;/im';

                if ( preg_grep($pattern, $file_contents) ) {

                    if ( preg_grep('/^\s*CacheRoot +/im', $file_contents) ) {
                        $file_contents = preg_replace(
                            '/^\s*CacheRoot +.+/im',
                            &quot;CacheRoot $cacheroot&quot;,
                            $file_contents
                        );
                    }
                    else {
                        $file_contents = preg_replace(
                            '/^\s*&lt;IfModule +LiteSpeed *&gt;/im',
                            &quot;&lt;IfModule LiteSpeed&gt;\nCacheRoot $cacheroot&quot;,
                            $file_contents
                        );
                    }
                }
                else {
                    array_unshift($file_contents, $cacheRootLine);
                }

                file_put_contents($this-&gt;apacheConf, $file_contents);
            }
        }

        $this-&gt;serverCacheRoot = $cacheroot;

        $this-&gt;log(&quot;Server level cache root set to $cacheroot&quot;, Logger::L_INFO);

        if ( file_exists($cacheroot) ) {
            exec('/bin/rm -rf ' . escapeshellarg($cacheroot));

            $this-&gt;log(
                'Server level cache root directory removed for proper '
                    . 'permission.',
                Logger::L_DEBUG
            );
        }
    }

    /**
     *
     * @param array  $file_contents
     * @param string $vhCacheRoot
     *
     * @return array
     */
    abstract protected function addVHCacheRootSection(
        array $file_contents,
              $vhCacheRoot = 'lscache'
    );

    /**
     *
     * @param string $vhConf
     *
     * @throws LSCMException  Thrown when virtual host conf file is not
     *     writeable.
     * @throws LSCMException  Thrown when a backup of the virtual host conf file
     *     could not be made.
     * @throws LSCMException  Thrown when &quot;write to virtual host conf file&quot; call
     *     fails.
     * @throws LSCMException  Thrown indirectly by $this-&gt;log() call.
     */
    public function writeVHCacheRoot( $vhConf, $vhCacheRoot = 'lscache' )
    {
        if ( !is_writable($vhConf) ) {
            throw new LSCMException(
                &quot;Could not write to VH config $vhConf. No changes made.&quot;,
                LSCMException::E_PERMISSION
            );
        }
        if ( !Util::createBackup($vhConf) ) {
            throw new LSCMException(
                &quot;Could not backup Virtual Host config file $vhConf. No &quot;
                    . 'changes made.',
                LSCMException::E_PERMISSION
            );
        }

        $file_contents = file($vhConf);

        if ( preg_grep('/^\s*&lt;IfModule +LiteSpeed *&gt;/im', $file_contents) ) {

            if ( preg_grep('/^\s*CacheRoot +/im', $file_contents) ) {
                $modified_contents = preg_replace(
                    '/^\s*CacheRoot +.+/im',
                    &quot;CacheRoot $vhCacheRoot&quot;,
                    $file_contents
                );
            }
            else {
                $modified_contents = preg_replace(
                    '/^\s*&lt;IfModule +LiteSpeed *&gt;/im',
                    &quot;&lt;IfModule LiteSpeed&gt;\nCacheRoot $vhCacheRoot&quot;,
                    $file_contents
                );
            }
        }
        else {
            $modified_contents =
                $this-&gt;addVHCacheRootSection($file_contents, $vhCacheRoot);
        }

        if ( file_put_contents($vhConf, $modified_contents) === false ) {
            throw new LSCMException(
                &quot;Failed to write to file $vhConf.&quot;,
                LSCMException::E_PERMISSION
            );
        }

        $this-&gt;log(&quot;Updated file $vhConf.&quot;, Logger::L_DEBUG);
    }

    /**
     * Note: Visibility is public to better accommodate escalation functions.
     *
     * @param string $vhConf
     * @param string $vhCacheRoot
     */
    abstract public function createVHConfAndSetCacheRoot(
        $vhConf,
        $vhCacheRoot = 'lscache'
    );

    /**
     * Note: Visibility is public to better accommodate escalation functions.
     *
     * @throws LSCMException  Thrown by some implementations.
     */
    abstract public function applyVHConfChanges();

    /**
     *
     * @since 1.9.7
     */
    protected static function setMinAPIFilePath()
    {
        static::$minAPIFilePath = realpath(__DIR__ . '/../..') . '/MIN_VER';
    }

    /**
     *
     * @since 1.9.7
     *
     * @return string
     */
    protected static function getMinAPIFilePath()
    {
        if ( static::$minAPIFilePath == '' ) {
            static::setMinAPIFilePath();
        }

        return static::$minAPIFilePath;
    }

    /**
     *
     * @since 1.9.7
     * @since 1.12  Changed visibility from protected to public.
     */
    public static function populateMinAPIVerFile()
    {
        $minVerFile = static::getMinAPIFilePath();

        $content = Util::get_url_contents(
            'https://www.litespeed.sh/sub/shared/MIN_VER'
        );

        if ( !empty($content) ) {
            file_put_contents($minVerFile, $content);
        }
        else {
            touch($minVerFile);
        }
    }

    /**
     *
     * @since 1.9.7
     *
     * @return string
     */
    protected static function getMinAPIVer()
    {
        $minVerFile = static::getMinAPIFilePath();

        clearstatcache();

        if ( !file_exists($minVerFile)
                || (time() - filemtime($minVerFile)) &gt; 86400 ) {

            static::populateMinAPIVerFile();
        }

        if ( ($content = file_get_contents($minVerFile)) !== false ) {
            return trim($content);
        }

        return '';
    }

    /**
     *
     * @since 1.9.7
     *
     * @return bool
     */
    public static function meetsMinAPIVerRequirement()
    {
        $minAPIVer = static::getMinAPIVer();

        if ( $minAPIVer == ''
                || Util::betterVersionCompare(static::PANEL_API_VERSION, $minAPIVer, '&lt;') ) {

            return false;
        }

        return true;
    }

    /**
     *
     * @since 1.9
     *
     * @param string $panelAPIVer  Shared code API version used by the panel
     *     plugin.
     *
     * @return int
     */
    public static function checkPanelAPICompatibility( $panelAPIVer )
    {
        $supportedAPIVers = array(
            '1.17.10.1',
            '1.17.10',
            '1.17.9',
            '1.17.8',
            '1.17.7',
            '1.17.6',
            '1.17.5',
            '1.17.4.2',
            '1.17.4.1',
            '1.17.4',
            '1.17.3',
            '1.17.2',
            '1.17.1.1',
            '1.17.1',
            '1.17.0.5',
            '1.17.0.4',
            '1.17.0.3',
            '1.17.0.2',
            '1.17.0.1',
            '1.17',
            '1.16.1',
            '1.16.0.2',
            '1.16.0.1',
            '1.16',
            '1.15.0.1',
            '1.15',
            '1.14.5',
            '1.14.4.1',
            '1.14.4',
            '1.14.3.2',
            '1.14.3.1',
            '1.14.3',
            '1.14.2',
            '1.14.1.2',
            '1.14.1.1',
            '1.14.1',
            '1.14.0.3',
            '1.14.0.2',
            '1.14.0.1',
            '1.14',
            '1.13.13.1',
            '1.13.13',
            '1.13.12',
            '1.13.11.1',
            '1.13.11',
            '1.13.10.2',
            '1.13.10.1',
            '1.13.10',
            '1.13.9',
            '1.13.8',
            '1.13.7.1',
            '1.13.7',
            '1.13.6',
            '1.13.5.2',
            '1.13.5.1',
            '1.13.5',
            '1.13.4.4',
            '1.13.4.3',
            '1.13.4.2',
            '1.13.4.1',
            '1.13.4',
            '1.13.3.1',
            '1.13.3',
            '1.13.2.2',
            '1.13.2.1',
            '1.13.2',
            '1.13.1',
            '1.13.0.3',
            '1.13.0.2',
            '1.13.0.1',
            '1.13',
            '1.12',
            '1.11',
            '1.10',
            '1.9.8',
            '1.9.7',
            '1.9.6.1',
            '1.9.6',
            '1.9.5',
            '1.9.4',
            '1.9.3',
            '1.9.2',
            '1.9.1',
            '1.9',
            '1.8',
            '1.7',
            '1.6.1',
            '1.6',
            '1.5',
            '1.4',
            '1.3',
            '1.2',
            '1.1',
            '1.0'
        );

        if ( Util::betterVersionCompare($panelAPIVer, $supportedAPIVers[0], '&gt;') ) {
            return static::PANEL_API_VERSION_TOO_HIGH;
        }
        elseif ( Util::betterVersionCompare($panelAPIVer, end($supportedAPIVers), '&lt;') ) {
            return static::PANEL_API_VERSION_TOO_LOW;
        }
        elseif ( ! in_array($panelAPIVer, $supportedAPIVers) ) {
            return static::PANEL_API_VERSION_UNKNOWN;
        }
        else {
            return static::PANEL_API_VERSION_SUPPORTED;
        }
    }

    /**
     *
     * @deprecated 1.9  Use checkPanelAPICompatibility() instead.
     *
     * @param string $panelAPIVer  Shared code API version used by the panel
     *     plugin.
     *
     * @return bool
     */
    public static function isPanelAPICompatible( $panelAPIVer )
    {
        $apiCompatStatus = static::checkPanelAPICompatibility($panelAPIVer);

        if ( $apiCompatStatus != static::PANEL_API_VERSION_SUPPORTED ) {
            return false;
        }

        return true;
    }

}
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Flocal%2Flsws%2Fadd-ons%2Fwebcachemgr%2Fsrc%2FPanel'>Back to Directory</a>