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

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

namespace Lsc\Wp\Context;

use Lsc\Wp\LSCMException;
use Lsc\Wp\Logger;

/**
 * Context is a singleton
 */
class Context
{

    const LOCAL_PLUGIN_DIR = '/usr/src/litespeed-wp-plugin';

    /**
     * @var int
     */
    protected $isRoot;

    /**
     * @var ContextOption
     */
    protected $options;

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

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

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

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

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

    /**
     *
     * @param ContextOption  $contextOption
     */
    protected function __construct( ContextOption $contextOption )
    {
        $this-&gt;options = $contextOption;

        $this-&gt;init();
    }

    protected function init()
    {
        $this-&gt;dataDir        =
            realpath(__DIR__ . '/../../../..') . '/admin/lscdata';
        $this-&gt;dataFile       = &quot;$this-&gt;dataDir/lscm.data&quot;;
        $this-&gt;customDataFile = &quot;$this-&gt;dataDir/lscm.data.cust&quot;;
        $this-&gt;isRoot         = $this-&gt;options-&gt;isRoot();
    }

    /**
     *
     * @since 1.9
     *
     * @return void
     *
     * @throws LSCMException  Thrown indirectly by Logger::debug() call.
     * @throws LSCMException  Thrown indirectly by Logger::debug() call.
     * @throws LSCMException  Thrown indirectly by Logger::notice() call.
     * @throws LSCMException  Thrown indirectly by Logger::notice() call.
     * @throws LSCMException  Thrown indirectly by Logger::debug() call.
     */
    protected function checkLocalPluginDirInCageFS()
    {
        $mpFile        = '/etc/cagefs/cagefs.mp';
        $mountFile     = '/proc/mounts';
        $cagefsCtlFile = '/usr/sbin/cagefsctl';

        if (
                !file_exists($mpFile)
                ||
                !file_exists($cagefsCtlFile)
                ||
                !is_executable($cagefsCtlFile)
        ) {
            return;
        }

        Logger::debug('Detected cagefs.mp file.');

        $localPluginDir = self::LOCAL_PLUGIN_DIR;

        $pattern      = &quot;=^((?!deleted).)*$localPluginDir((?!deleted).)*$=m&quot;;
        $result       = preg_grep($pattern, file($mountFile));
        $procMountSet = !empty($result);

        if ( !$procMountSet ) {
            Logger::debug(&quot;Data dir not set in $mountFile.&quot;);

            $pattern     = &quot;=^.*$localPluginDir.*$=m&quot;;
            $result      = preg_grep($pattern, file($mpFile));
            $setInMpFile = !empty($result);

            if ( !$setInMpFile ) {
                file_put_contents(
                    $mpFile,
                    &quot;\n$localPluginDir&quot;,
                    FILE_APPEND
                );

                Logger::notice('Added data dir to cagefs.mp.');
            }

            exec(&quot;$cagefsCtlFile --remount-all&quot;);

            Logger::notice('Remounted CageFS.');
        }
        else {
            Logger::debug('Data dir already added to CageFS.');
        }
    }

    /**
     *
     * @throws LSCMException  Thrown when unable to create data dir.
     */
    protected function createDataDir()
    {
        if ( !file_exists($this-&gt;dataDir) &amp;&amp; !mkdir($this-&gt;dataDir, 0755) ) {
            throw new LSCMException(
                &quot;Fail to create data directory $this-&gt;dataDir.&quot;,
                LSCMException::E_PERMISSION
            );
        }
    }

    /**
     *
     * @since 1.9
     *
     * @throws LSCMException  Thrown when unable to create local plugin dir.
     */
    protected function createLocalPluginDir()
    {
        if (
                !file_exists(Context::LOCAL_PLUGIN_DIR)
                &amp;&amp;
                !mkdir(Context::LOCAL_PLUGIN_DIR, 0755)
        ) {
            throw new LSCMException(
                &quot;Fail to create local plugin directory &quot;
                    . Context::LOCAL_PLUGIN_DIR . '.',
                LSCMException::E_PERMISSION
            );
        }
    }

    /**
     *
     * @return ContextOption
     *
     * @throws LSCMException  Thrown indirectly by self::me() call.
     */
    public static function getOption()
    {
        return self::me(true)-&gt;options;
    }

    /**
     *
     * @since 1.9.1  Added optional parameter $loggerObj.
     *
     * @param ContextOption $contextOption
     * @param object        $loggerObj      Object implementing all public
     *     Logger class functions.
     *
     * @throws LSCMException  Thrown when Context is already initialized.
     * @throws LSCMException  Thrown indirectly by Logger::setInstance() call.
     * @throws LSCMException  Thrown indirectly by
     *     self::$instance-&gt;createDataDir() call.
     * @throws LSCMException  Thrown indirectly by
     *     self::$instance-&gt;createLocalPluginDir() call.
     * @throws LSCMException  Thrown indirectly by
     *     self::$instance-&gt;checkLocalPluginDirInCageFS() call.
     */
    public static function initialize(
        ContextOption $contextOption,
                      $loggerObj = null
    )
    {
        if ( self::$instance != null ) {
            /**
             * Do not allow, must initialize first.
             */
            throw new LSCMException(
                'Context cannot be initialized twice.',
                LSCMException::E_PROGRAM
            );
        }

        self::$instance = new self($contextOption);

        if ( $loggerObj != null ) {
            Logger::setInstance($loggerObj);
        }
        else {
            $loggerClass = $contextOption-&gt;getLoggerClass();
            $loggerClass::Initialize($contextOption);
        }

        if ( self::$instance-&gt;isRoot == ContextOption::IS_ROOT ) {
            self::$instance-&gt;createDataDir();
            self::$instance-&gt;createLocalPluginDir();
            self::$instance-&gt;checkLocalPluginDirInCageFS();
        }
    }

    /**
     * Checks if the current instance is lacking the expected level of
     * permissions.
     *
     * @deprecated 1.17.8
     *
     * @return bool
     *
     * @noinspection SpellCheckingInspection
     * @noinspection PhpUnused
     */
    protected function hasInsufficentPermissions()
    {
        return $this-&gt;hasInsufficientPermissions();
    }

    /**
     * Checks if the current instance is lacking the expected level of
     * permissions.
     *
     * @since 1.17.8
     *
     * @return bool
     */
    protected function hasInsufficientPermissions()
    {
        return (
            self::$instance-&gt;isRoot
                &lt;
                self::$instance-&gt;options-&gt;getExpectedPermissions()
        );
    }

    /**
     *
     * @param bool $checkPerms
     *
     * @return Context
     *
     * @throws LSCMException  Thrown when Context is not initialized.
     * @throws LSCMException  Thrown when required permissions not met.
     */
    protected static function me( $checkPerms = false )
    {
        if ( self::$instance == null ) {
            /**
             * Do not allow, must initialize first.
             */
            throw new LSCMException(
                'Uninitialized context.',
                LSCMException::E_NON_FATAL
            );
        }

        if ( $checkPerms &amp;&amp; self::$instance-&gt;hasInsufficientPermissions() ) {
            throw new LSCMException(
                'Access denied: Insufficient permissions.',
                LSCMException::E_NON_FATAL
            );
        }

        return self::$instance;
    }

    /**
     *
     * @return string
     *
     * @throws LSCMException  Thrown indirectly by self::me() call.
     */
    public static function getLSCMDataDir()
    {
        return self::me()-&gt;dataDir;
    }


    /**
     * Deprecated 06/19/19. Shift to using getLSCMDataFiles() instead.
     *
     * @deprecated
     *
     * @return string
     *
     * @throws LSCMException  Thrown indirectly by self::getLSCMDataFiles()
     *     call.
     */
    public static function getLSCMDataFile()
    {
        $dataFiles = self::getLSCMDataFiles();

        return $dataFiles['dataFile'];
    }

    /**
     *
     * @return string[]
     *
     * @throws LSCMException  Re-thrown when self::me() calls throw an
     *     exception.
     * @throws LSCMException  Thrown indirectly by Logger::debug() call.
     */
    public static function getLSCMDataFiles()
    {
        try {
            $dataFile     = self::me(true)-&gt;dataFile;
            $custDataFile = self::me(true)-&gt;customDataFile;
        }
        catch ( LSCMException $e ) {
            $msg = &quot;{$e-&gt;getMessage()} Could not get data file paths.&quot;;
            Logger::debug($msg);

            throw new LSCMException($msg);
        }

        return array(
            'dataFile'     =&gt; $dataFile,
            'custDataFile' =&gt; $custDataFile
        );
    }

    /**
     *
     * @return int
     *
     * @throws LSCMException  Thrown indirectly by self::me() call.
     */
    public static function isRoot()
    {
        return self::me()-&gt;isRoot;
    }

    /**
     *
     * @return bool
     *
     * @throws LSCMException  Thrown indirectly by self::me() call.
     */
    public static function isPrivileged()
    {
        return (self::me()-&gt;isRoot &gt; ContextOption::IS_NOT_ROOT);
    }

    /**
     *
     * @return int
     *
     * @throws LSCMException  Thrown indirectly by self::me() call.
     */
    public static function getScanDepth()
    {
        return self::me()-&gt;options-&gt;getScanDepth();
    }

    /**
     *
     * @return int
     *
     * @throws LSCMException Thrown indirectly by self::me() call.
     */
    public static function getActionTimeout()
    {
        $timeout = self::me()-&gt;options-&gt;getBatchTimeout();

        if ( $timeout &gt; 1 ) {
            return time() + $timeout;
        }

        /**
         * No timeout.
         */
        return 0;
    }

    /**
     *
     * @return string
     *
     * @throws LSCMException  Thrown indirectly by self::me() call.
     */
    public static function getFlagFileContent()
    {
        $m = self::me();

        if ( $m-&gt;flagContent == null ) {
            $m-&gt;flagContent = &lt;&lt;&lt;CONTENT
This file was created by LiteSpeed Web Cache Manager

When this file exists, your LiteSpeed Cache plugin for WordPress will NOT be affected
by Mass Enable/Disable operations performed through LiteSpeed Web Cache Manager.

Please DO NOT ATTEMPT to remove this file unless you understand the above.

CONTENT;
        }

        return $m-&gt;flagContent;
    }

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