golden hour

/home/godaofbq/cellsonic-usa.com/wp-content/plugins/litespeed-cache/src

File/Folder	Size	Actions
activation.cls.php	17.62 KB
admin-display.cls.php	48.76 KB
admin-settings.cls.php	12.77 KB
admin.cls.php	6.13 KB
api.cls.php	10.44 KB
avatar.cls.php	9.25 KB
base.cls.php	37.66 KB
cdn	-
cdn.cls.php	17.76 KB
cloud-auth-callback.trait.php	10.43 KB
cloud-auth-ip.trait.php	4.33 KB
cloud-auth.trait.php	9.38 KB
cloud-misc.trait.php	10.32 KB
cloud-node.trait.php	5.95 KB
cloud-queue-svc.cls.php	9.33 KB
cloud-request.trait.php	19.68 KB
cloud.cls.php	7.32 KB
conf.cls.php	19.53 KB
control.cls.php	24.35 KB
core.cls.php	21.53 KB
crawler-map.cls.php	22.3 KB
crawler.cls.php	44 KB
css.cls.php	7.26 KB
data.cls.php	22.2 KB
data.upgrade.func.php	6.41 KB
data_structure	-
db-optm.cls.php	15.35 KB
debug2.cls.php	18.4 KB
doc.cls.php	5.45 KB
error.cls.php	7.35 KB
esi.cls.php	31.37 KB
file.cls.php	13.75 KB
guest.cls.php	2.75 KB
gui.cls.php	35.09 KB
health.cls.php	4.66 KB
htaccess.cls.php	29.81 KB
img-optm-manage.trait.php	31.25 KB
img-optm-pull.trait.php	22.1 KB
img-optm-send.trait.php	20.77 KB
img-optm.cls.php	5.25 KB
import.cls.php	4.29 KB
import.preset.cls.php	5.5 KB
lang.cls.php	17.02 KB
localization.cls.php	4.03 KB
media.cls.php	44.06 KB
metabox.cls.php	5.29 KB
object-cache-wp.cls.php	18.82 KB
object-cache.cls.php	21.82 KB
object.lib.php	13.85 KB
optimax.cls.php	8.94 KB
optimize.cls.php	38.74 KB
optimizer.cls.php	12.71 KB
placeholder.cls.php	17.64 KB
purge.cls.php	35.48 KB
report.cls.php	7.53 KB
rest.cls.php	7.95 KB
root.cls.php	14.29 KB
router.cls.php	20.86 KB
str.cls.php	3.08 KB
tag.cls.php	9.26 KB
task.cls.php	8.98 KB
tool.cls.php	4.58 KB
ucss.cls.php	7.34 KB
utility.cls.php	27.11 KB
vary.cls.php	21.33 KB
vpi.cls.php	4.25 KB

Edit: file.cls.php

<?php
// phpcs:ignoreFile

/**
 * LiteSpeed File Operator Library Class
 * Append/Replace content to a file
 *
 * @since 1.1.0
 */

namespace LiteSpeed;

defined('WPINC') || exit();

class File {

const MARKER = 'LiteSpeed Operator';

/**
	 * Marker name embedded in the seeded .htaccess. Bump the suffix when the rule template changes so ensure_static_protection() re-seeds outdated copies on existing sites.
	 *
	 * @since 7.9
	 */
	const STATIC_DIR_HTACCESS_MARKER = 'LSCACHE_STATIC_PROTECT_V2';

/**
	 * Build the whitelist .htaccess content for LITESPEED_STATIC_DIR
	 * Anything not explicitly allowed returns 403.
	 * Lazy-gen folders (avatar/localres) hand missing requests off to WP's index.php directly
	 *
	 * @since 7.9
	 *
	 * @return string Full .htaccess body.
	 */
	public static function build_static_dir_htaccess() {
		$home_path = parse_url(home_url('/'), PHP_URL_PATH);
		if (!is_string($home_path) || '' === $home_path) {
			$home_path = '/';
		}
		$wp_index = rtrim($home_path, '/') . '/index.php';
		$marker   = self::STATIC_DIR_HTACCESS_MARKER;

return <<<HTACCESS
# BEGIN {$marker}
# DO NOT EDIT — auto-generated by LiteSpeed Cache.
# Whitelist: only listed root files and folders are publicly readable.

Options -Indexes

<IfModule mod_rewrite.c>
    RewriteEngine On

# Block dotfiles (.litespeed_conf.dat, .htaccess, etc.) anywhere in the tree
    RewriteRule (^|/)\.[^/]+$ - [F,L]

# Whitelisted root-level public files
    RewriteRule ^robots\.txt$ - [L]

# Lazy-gen folders: serve existing files directly
    RewriteCond %{REQUEST_FILENAME} -f
    RewriteRule ^(avatar|localres)(/|$) - [L]

# Lazy-gen folders: missing file → hand off to WP index.php for on-the-fly generation
    RewriteCond %{REQUEST_FILENAME} !-f
    RewriteRule ^(avatar|localres)/.+ {$wp_index} [L]

# Default deny
    RewriteRule .* - [F,L]
</IfModule>
# END {$marker}
HTACCESS;
	}

/**
	 * Seed .htaccess + robots.txt into LITESPEED_STATIC_DIR if missing or outdated.
	 *
	 * Re-seeds whenever the on-disk body differs from the freshly built template — covers template
	 * bumps, hand edits that drop critical rules, partial writes, and home_url() changes that would
	 * otherwise leave a stale rewrite target in the file.
	 *
	 * @since 7.9
	 */
	public static function ensure_static_protection() {
		if (!is_dir(LITESPEED_STATIC_DIR)) {
			return;
		}
		$htaccess_path = LITESPEED_STATIC_DIR . '/.htaccess';
		$content       = self::build_static_dir_htaccess();

if (is_file($htaccess_path)) {
			$existing = @file_get_contents($htaccess_path);
			if (false !== $existing && $existing === $content) {
				return;
			}
		}

$bytes = @file_put_contents($htaccess_path, $content, LOCK_EX);

$robots_path = LITESPEED_STATIC_DIR . '/robots.txt';
		if (!is_file($robots_path)) {
			@file_put_contents($robots_path, "User-agent: *\nDisallow: /\n", LOCK_EX);
		}

$banner = sprintf(
			/* translators: %s: full path to the .htaccess file LiteSpeed Cache failed to create. */
			__('LiteSpeed Cache could not create %s. Sensitive files (configuration backups, debug logs) under this folder may be publicly accessible. Fix the directory permissions to restore protection.', 'litespeed-cache'),
			'<code>' . esc_html($htaccess_path) . '</code>'
		);
		if ($bytes === strlen($content)) {
			Admin_Display::dismiss_pin_by_content($banner, Admin_Display::NOTICE_RED, true);
		} else {
			Admin_Display::error($banner, false, true);
		}
	}

/**
	 * Detect if an URL is 404
	 *
	 * @since  3.3
	 */
	public static function is_404( $url ) {
		$response = wp_safe_remote_get($url);
		$code     = wp_remote_retrieve_response_code($response);
		if ($code == 404) {
			return true;
		}

return false;
	}

/**
	 *  Delete folder
	 *
	 * @since 2.1
	 */
	public static function rrmdir( $dir ) {
		$files = array_diff(scandir($dir), array( '.', '..' ));

foreach ($files as $file) {
			is_dir("$dir/$file") ? self::rrmdir("$dir/$file") : unlink("$dir/$file");
		}

return rmdir($dir);
	}

public static function count_lines( $filename ) {
		if (!file_exists($filename)) {
			return 0;
		}

$file = new \SplFileObject($filename);
		$file->seek(PHP_INT_MAX);
		return $file->key() + 1;
	}

/**
	 * Read data from file
	 *
	 * @since 1.1.0
	 * @param string $filename
	 * @param int    $start_line
	 * @param int    $lines
	 */
	public static function read( $filename, $start_line = null, $lines = null ) {
		if (!file_exists($filename)) {
			return '';
		}

if (!is_readable($filename)) {
			return false;
		}

if ($start_line !== null) {
			$res  = array();
			$file = new \SplFileObject($filename);
			$file->seek($start_line);

if ($lines === null) {
				while (!$file->eof()) {
					$res[] = rtrim($file->current(), "\n");
					$file->next();
				}
			} else {
				for ($i = 0; $i < $lines; $i++) {
					if ($file->eof()) {
						break;
					}
					$res[] = rtrim($file->current(), "\n");
					$file->next();
				}
			}

unset($file);
			return $res;
		}

$content = file_get_contents($filename);

$content = self::remove_zero_space($content);

return $content;
	}

/**
	 * Append data to file
	 *
	 * @since 1.1.5
	 * @access public
	 * @param string  $filename
	 * @param string  $data
	 * @param boolean $mkdir
	 * @param boolean $silence Used to avoid WP's functions are used
	 */
	public static function append( $filename, $data, $mkdir = false, $silence = true ) {
		return self::save($filename, $data, $mkdir, true, $silence);
	}

/**
	 * Save data to file
	 *
	 * @since 1.1.0
	 * @param string  $filename
	 * @param string  $data
	 * @param boolean $mkdir
	 * @param boolean $append If the content needs to be appended
	 * @param boolean $silence Used to avoid WP's functions are used
	 */
	public static function save( $filename, $data, $mkdir = false, $append = false, $silence = true ) {
		if (is_null($filename)) {
			return $silence ? false : __('Filename is empty!', 'litespeed-cache');
		}

$error  = false;
		$folder = dirname($filename);

// mkdir if folder does not exist
		if (!file_exists($folder)) {
			if (!$mkdir) {
				return $silence ? false : sprintf(__('Folder does not exist: %s', 'litespeed-cache'), $folder);
			}

set_error_handler('litespeed_exception_handler');

try {
				mkdir($folder, 0755, true);
			} catch (\ErrorException $ex) {
				return $silence ? false : sprintf(__('Can not create folder: %1$s. Error: %2$s', 'litespeed-cache'), $folder, $ex->getMessage());
			}

restore_error_handler();
		}

if (strpos($filename, LITESPEED_STATIC_DIR . '/') === 0) {
			self::ensure_static_protection();
		}

if (!file_exists($filename)) {
			if (!is_writable($folder)) {
				return $silence ? false : sprintf(__('Folder is not writable: %s.', 'litespeed-cache'), $folder);
			}
			set_error_handler('litespeed_exception_handler');
			try {
				touch($filename);
			} catch (\ErrorException $ex) {
				return $silence ? false : sprintf(__('File %s is not writable.', 'litespeed-cache'), $filename);
			}
			restore_error_handler();
		} elseif (!is_writable($filename)) {
			return $silence ? false : sprintf(__('File %s is not writable.', 'litespeed-cache'), $filename);
		}

$data = self::remove_zero_space($data);

$ret = file_put_contents($filename, $data, $append ? FILE_APPEND : LOCK_EX);
		if ($ret === false) {
			return $silence ? false : sprintf(__('Failed to write to %s.', 'litespeed-cache'), $filename);
		}

return true;
	}

/**
	 * Remove Unicode zero-width space <200b><200c>
	 *
	 * @since 2.1.2
	 * @since 2.9 changed to public
	 */
	public static function remove_zero_space( $content ) {
		if (is_array($content)) {
			$content = array_map(__CLASS__ . '::remove_zero_space', $content);
			return $content;
		}

// Remove UTF-8 BOM if present
		if (substr($content, 0, 3) === "\xEF\xBB\xBF") {
			$content = substr($content, 3);
		}

$content = str_replace("\xe2\x80\x8b", '', $content);
		$content = str_replace("\xe2\x80\x8c", '', $content);
		$content = str_replace("\xe2\x80\x8d", '', $content);

return $content;
	}

/**
	 * Appends an array of strings into a file (.htaccess ), placing it between
	 * BEGIN and END markers.
	 *
	 * Replaces existing marked info. Retains surrounding
	 * data. Creates file if none exists.
	 *
	 * @param string             $filename  Filename to alter.
	 * @param string             $marker    The marker to alter.
	 * @param array|string|false $insertion The new content to insert.
	 * @param bool               $prepend Prepend insertion if not exist.
	 * @return bool True on write success, false on failure.
	 */
	public static function insert_with_markers( $filename, $insertion = false, $marker = false, $prepend = false ) {
		if (!$marker) {
			$marker = self::MARKER;
		}

if (!$insertion) {
			$insertion = array();
		}

return self::_insert_with_markers($filename, $marker, $insertion, $prepend); // todo: capture exceptions
	}

/**
	 * Return wrapped block data with marker
	 *
	 * @param string $insertion
	 * @param string $marker
	 * @return string The block data
	 */
	public static function wrap_marker_data( $insertion, $marker = false ) {
		if (!$marker) {
			$marker = self::MARKER;
		}
		$start_marker = "# BEGIN {$marker}";
		$end_marker   = "# END {$marker}";

$new_data = implode("\n", array_merge(array( $start_marker ), $insertion, array( $end_marker )));
		return $new_data;
	}

/**
	 * Touch block data from file, return with marker
	 *
	 * @param string $filename
	 * @param string $marker
	 * @return string The current block data
	 */
	public static function touch_marker_data( $filename, $marker = false ) {
		if (!$marker) {
			$marker = self::MARKER;
		}

$result = self::_extract_from_markers($filename, $marker);

if (!$result) {
			return false;
		}

$start_marker = "# BEGIN {$marker}";
		$end_marker   = "# END {$marker}";
		$new_data     = implode("\n", array_merge(array( $start_marker ), $result, array( $end_marker )));
		return $new_data;
	}

/**
	 * Extracts strings from between the BEGIN and END markers in the .htaccess file.
	 *
	 * @param string $filename
	 * @param string $marker
	 * @return array An array of strings from a file (.htaccess ) from between BEGIN and END markers.
	 */
	public static function extract_from_markers( $filename, $marker = false ) {
		if (!$marker) {
			$marker = self::MARKER;
		}
		return self::_extract_from_markers($filename, $marker);
	}

/**
	 * Extracts strings from between the BEGIN and END markers in the .htaccess file.
	 *
	 * @param string $filename
	 * @param string $marker
	 * @return array An array of strings from a file (.htaccess ) from between BEGIN and END markers.
	 */
	private static function _extract_from_markers( $filename, $marker ) {
		$result = array();

if (!file_exists($filename)) {
			return $result;
		}

if ($markerdata = explode("\n", implode('', file($filename)))) {
			$state = false;
			foreach ($markerdata as $markerline) {
				if (strpos($markerline, '# END ' . $marker) !== false) {
					$state = false;
				}
				if ($state) {
					$result[] = $markerline;
				}
				if (strpos($markerline, '# BEGIN ' . $marker) !== false) {
					$state = true;
				}
			}
		}

return array_map('trim', $result);
	}

/**
	 * Inserts an array of strings into a file (.htaccess ), placing it between BEGIN and END markers.
	 *
	 * Replaces existing marked info. Retains surrounding data. Creates file if none exists.
	 *
	 * NOTE: will throw error if failed
	 *
	 * @since 3.0-
	 * @since  3.0 Throw errors if failed
	 * @access private
	 */
	private static function _insert_with_markers( $filename, $marker, $insertion, $prepend = false ) {
		if (!file_exists($filename)) {
			if (!is_writable(dirname($filename))) {
				Error::t('W', dirname($filename));
			}

set_error_handler('litespeed_exception_handler');
			try {
				touch($filename);
			} catch (\ErrorException $ex) {
				Error::t('W', $filename);
			}
			restore_error_handler();
		} elseif (!is_writable($filename)) {
			Error::t('W', $filename);
		}

if (!is_array($insertion)) {
			$insertion = explode("\n", $insertion);
		}

$start_marker = "# BEGIN {$marker}";
		$end_marker   = "# END {$marker}";

$fp = fopen($filename, 'r+');
		if (!$fp) {
			Error::t('W', $filename);
		}

// Attempt to get a lock. If the filesystem supports locking, this will block until the lock is acquired.
		flock($fp, LOCK_EX);

$lines = array();
		while (!feof($fp)) {
			$lines[] = rtrim(fgets($fp), "\r\n");
		}

// Split out the existing file into the preceding lines, and those that appear after the marker
		$pre_lines    = $post_lines = $existing_lines = array();
		$found_marker = $found_end_marker = false;
		foreach ($lines as $line) {
			if (!$found_marker && false !== strpos($line, $start_marker)) {
				$found_marker = true;
				continue;
			} elseif (!$found_end_marker && false !== strpos($line, $end_marker)) {
				$found_end_marker = true;
				continue;
			}

if (!$found_marker) {
				$pre_lines[] = $line;
			} elseif ($found_marker && $found_end_marker) {
				$post_lines[] = $line;
			} else {
				$existing_lines[] = $line;
			}
		}

// Check to see if there was a change
		if ($existing_lines === $insertion) {
			flock($fp, LOCK_UN);
			fclose($fp);

return true;
		}

// Check if need to prepend data if not exist
		if ($prepend && !$post_lines) {
			// Generate the new file data
			$new_file_data = implode("\n", array_merge(array( $start_marker ), $insertion, array( $end_marker ), $pre_lines));
		} else {
			// Generate the new file data
			$new_file_data = implode("\n", array_merge($pre_lines, array( $start_marker ), $insertion, array( $end_marker ), $post_lines));
		}

// Write to the start of the file, and truncate it to that length
		fseek($fp, 0);
		$bytes = fwrite($fp, $new_file_data);
		if ($bytes) {
			ftruncate($fp, ftell($fp));
		}
		fflush($fp);
		flock($fp, LOCK_UN);
		fclose($fp);

return (bool) $bytes;
	}
}