Util Class Reference

Static Public Member Functions
static	changePath ($filesToScan, $rootPath=null)
static	checkInternetState ()
static	cleanArgv ($name, $type='text')
static	cleanGetVar ($name, $type='text')
static	cleanPostVar ($name, $type='text')
static	clearFileScanCache ()
static	clearFolder ($path, $exclude=array())
static	clearFolders ($paths, $exclude=array())
static	clearLoadingText ()
static	clearPathFormatCache ()
static	contains ($string, $search)
static	cp1252ToUtf8 ($data)
static	decryptFile ()
static	deleteFolder ($path)
static	disableLaunchStartup ()
static	enableLaunchStartup ()
static	endWith ($string, $search)
static	findRepos ($initPath, $startPath, $checkFile, $maxDepth=1)
static	flushLogBuffer ()
static	formatUnixPath ($path)
static	formatWindowsPath ($path)
static	generateSecureBytes ($length=32)
static	generateSecureToken ($length=32)
static	getApiJson ($url)
static	getAppBinsRegKey ($fromRegistry=true)
static	getAppPathRegKey ()
static	getChangelogUrl ($utmSource=true)
static	getCurlHttpHeaders ($url)
static	getFileScanCacheDuration ()
static	getFileScanStats ()
static	getFilesToScan ($path=null, $useCache=true, $forceRefresh=false)
static	getFolderList ($path)
static	getFopenHttpHeaders ($url)
static	getGithubRawUrl ($file)
static	getGithubUrl ($part=null)
static	getGithubUserUrl ($part=null)
static	getHeaders ($host, $port, $ssl=false)
static	getHttpHeaders ($pingUrl)
static	getLatestVersion ($url)
static	getLogBufferSize ()
static	getLogStats ()
static	getMicrotime ()
static	getNssmEnvPaths ()
static	getPathFormatCacheSize ()
static	getPathFormatStats ()
static	getPowerShellPath ()
static	getProcessorRegKey ()
static	getRemoteFilesize ($url, $humanFileSize=true)
static	getStartupLnkPath ()
static	getSysPathRegKey ()
static	getVersionList ($path)
static	getWebsiteUrl ($path='', $fragment='', $utmSource=true)
static	getWebsiteUrlNoUtm ($path='', $fragment='')
static	humanFileSize ($size, $unit='')
static	imgToBase64 ($path)
static	installService ($bin, $port, $syntaxCheckCmd, $showWindow=false)
static	is32BitsOs ()
static	isAlphanumeric ($string)
static	isLaunchStartup ()
static	isPortInUse ($port)
static	isValidDomainName ($domainName)
static	isValidIp ($ip)
static	isValidPort ($port)
static	logDebug ($data, $file=null)
static	logError ($data, $file=null)
static	logInfo ($data, $file=null)
static	logInitClass ($classInstance)
static	logReloadClass ($classInstance)
static	logSeparator ()
static	logTrace ($data, $file=null)
static	logWarning ($data, $file=null)
static	openFileContent ($caption, $content)
static	random ($length=32, $withNumeric=true)
static	removeService ($service, $name)
static	replaceDefine ($path, $var, $value)
static	replaceInFile ($path, $replaceList)
static	sanitizeOutput ($output)
static	sanitizePath ($path)
static	sanitizePID ($pid)
static	sanitizePort ($port)
static	sanitizeServiceName ($serviceName)
static	setAppBinsRegKey ($value)
static	setAppPathRegKey ($value)
static	setFileScanCacheDuration ($seconds)
static	setLogBufferSize ($size)
static	setSysPathRegKey ($value)
static	setupCurlHeaderWithToken ()
static	startLoading ()
static	startService ($bin, $syntaxCheckCmd, $showWindow=false)
static	startWith ($string, $search)
static	stopLoading ()
static	updateLoadingText ($text)
static	utf8ToCp1252 ($data)

Data Fields
const	LOG_DEBUG = 'DEBUG'
const	LOG_ERROR = 'ERROR'
const	LOG_INFO = 'INFO'
const	LOG_TRACE = 'TRACE'
const	LOG_WARNING = 'WARNING'

Static Private Member Functions
static	findFile ($startPath, $findFile)
static	findFiles ($startPath, $includes=array(''), $recursive=true)
static	generateCacheHMAC ($data, $cacheKey)
static	getCacheIntegrityKey ()
static	getFileScanCache ($cacheKey)
static	getPathsToScan ()
static	log ($data, $type, $file=null)
static	setFileScanCache ($cacheKey, $data)
static	verifyCacheIntegrity ($fileContents, $cacheKey)

Static Private Attributes
static	$cacheIntegrityKey = null
static	$fileScanCache = null
static	$fileScanCacheDuration = 3600
static	$fileScanStats
static	$logBuffer = []
static	$logBufferSize = 50
static	$logStats
static	$pathFormatCache = []
static	$pathFormatCacheMaxSize = 500
static	$pathFormatStats
static	$shutdownRegistered = false

Detailed Description

Utility class providing a wide range of static methods for various purposes including:

• Cleaning and retrieving command line, GET, and POST variables based on type specifications.
• String manipulation methods to check if strings contain, start with, or end with specified substrings.
• File and directory management functions for deleting, clearing, or finding files and directories.
• Logging functionalities tailored for different levels of verbosity (ERROR, WARNING, INFO, DEBUG, TRACE).
• System utilities for handling registry operations, managing environment variables, and executing system commands.
• Network utilities to validate IPs, domains, and manage HTTP requests.
• Helper functions for encoding, decoding, and file operations.

This class is designed to be used as a helper or utility class where methods are accessed statically. This means you do not need to instantiate it to use the methods, but can simply call them using the Util::methodName() syntax.

Usage Example:

$cleanedData = Util::cleanGetVar('data', 'text');
Util::logError('An error occurred');
$isAvailable = Util::isValidIp('192.168.1.1');

Each method is self-contained and provides specific functionality, making this class a central point for common utility operations needed across a PHP application, especially in environments like web servers or command-line interfaces.

Definition at line 34 of file class.util.php.

Member Function Documentation

changePath()

changePath ( $filesToScan, $rootPath = null )

static

Replaces old path references with new path references in the specified files.

Parameters

array	$filesToScan	Array of file paths to scan and modify.
string | null	$rootPath	The new root path to replace the old one. If null, uses a default root path.

Returns

array Returns an array with the count of occurrences changed and the count of files changed.

Definition at line 1999 of file class.util.php.

    {
        global $bearsamppRoot, $bearsamppCore;
 
        $result = array(
            'countChangedOcc'   => 0,
            'countChangedFiles' => 0
        );
 
        $rootPath           = $rootPath != null ? $rootPath : $bearsamppRoot->getRootPath();
        $unixOldPath        = self::formatUnixPath($bearsamppCore->getLastPathContent());
        $windowsOldPath     = self::formatWindowsPath($bearsamppCore->getLastPathContent());
        $unixCurrentPath    = self::formatUnixPath($rootPath);
        $windowsCurrentPath = self::formatWindowsPath($rootPath);
 
        foreach ($filesToScan as $fileToScan) {
            $tmpCountChangedOcc = 0;
            $fileContentOr      = file_get_contents($fileToScan);
            $fileContent        = $fileContentOr;
 
            // old path
            preg_match('#' . $unixOldPath . '#i', $fileContent, $unixMatches);
            if (!empty($unixMatches)) {
                $fileContent        = str_replace($unixOldPath, $unixCurrentPath, $fileContent, $countChanged);
                $tmpCountChangedOcc += $countChanged;
            }
            preg_match('#' . str_replace('\\', '\\\\', $windowsOldPath) . '#i', $fileContent, $windowsMatches);
            if (!empty($windowsMatches)) {
                $fileContent        = str_replace($windowsOldPath, $windowsCurrentPath, $fileContent, $countChanged);
                $tmpCountChangedOcc += $countChanged;
            }
 
            // placeholders
            preg_match('#' . Core::PATH_LIN_PLACEHOLDER . '#i', $fileContent, $unixMatches);
            if (!empty($unixMatches)) {
                $fileContent        = str_replace(Core::PATH_LIN_PLACEHOLDER, $unixCurrentPath, $fileContent, $countChanged);
                $tmpCountChangedOcc += $countChanged;
            }
            preg_match('#' . Core::PATH_WIN_PLACEHOLDER . '#i', $fileContent, $windowsMatches);
            if (!empty($windowsMatches)) {
                $fileContent        = str_replace(Core::PATH_WIN_PLACEHOLDER, $windowsCurrentPath, $fileContent, $countChanged);
                $tmpCountChangedOcc += $countChanged;
            }
 
            if ($fileContentOr != $fileContent) {
                $result['countChangedOcc']   += $tmpCountChangedOcc;
                $result['countChangedFiles'] += 1;
                file_put_contents($fileToScan, $fileContent);
            }
        }
 
        self::logDebug('changePath() completed: ' . $result['countChangedFiles'] . ' files changed, ' . $result['countChangedOcc'] . ' total occurrences');
 
        return $result;
    }

References $bearsamppCore, $bearsamppRoot, $result, formatUnixPath(), formatWindowsPath(), logDebug(), Core\PATH_LIN_PLACEHOLDER, and Core\PATH_WIN_PLACEHOLDER.

Referenced by ActionStartup\changePath(), BinPostgresql\initData(), and ActionSwitchVersion\processWindow().

checkInternetState()

checkInternetState ( )

static

Checks the current state of the internet connection.

This method attempts to reach a well-known website (e.g., www.google.com) to determine the state of the internet connection. It returns true if the connection is successful, otherwise it returns false.

Returns

bool True if the internet connection is active, false otherwise.

Definition at line 2810 of file class.util.php.

    {
        $connected = @fsockopen('www.google.com', 80);
        if ($connected) {
            fclose($connected);
 
            return true; // Internet connection is active
        } else {
            return false; // Internet connection is not active
        }
    }

Referenced by QuickPick\getQuickpickMenu(), and QuickPick\installModule().

cleanArgv()

cleanArgv ( $name, $type = 'text' )

static

Cleans and returns a specific command line argument based on the type specified.

Parameters

string	$name	The index of the argument in the $_SERVER['argv'] array.
string	$type	The type of the argument to return: 'text', 'numeric', 'boolean', or 'array'.

Returns

mixed Returns the cleaned argument based on the type or false if the argument is not set.

Definition at line 133 of file class.util.php.

    {
        if (isset($_SERVER['argv'])) {
            if ($type == 'text') {
                return (isset($_SERVER['argv'][$name]) && !empty($_SERVER['argv'][$name])) ? trim($_SERVER['argv'][$name]) : '';
            } elseif ($type == 'numeric') {
                return (isset($_SERVER['argv'][$name]) && is_numeric($_SERVER['argv'][$name])) ? intval($_SERVER['argv'][$name]) : '';
            } elseif ($type == 'boolean') {
                return (isset($_SERVER['argv'][$name])) ? true : false;
            } elseif ($type == 'array') {
                return (isset($_SERVER['argv'][$name]) && is_array($_SERVER['argv'][$name])) ? $_SERVER['argv'][$name] : array();
            }
        }
 
        return false;
    }

Referenced by Action\process().

cleanGetVar()

cleanGetVar ( $name, $type = 'text' )

static

Cleans and returns a specific $_GET variable based on the type specified.

Parameters

string	$name	The name of the $_GET variable.
string	$type	The type of the variable to return: 'text', 'numeric', 'boolean', or 'array'.

Returns

mixed Returns the cleaned $_GET variable based on the type or false if the variable is not set.

Definition at line 158 of file class.util.php.

    {
        if (is_string($name)) {
            if ($type == 'text') {
                $value = (isset($_GET[$name]) && !empty($_GET[$name])) ? stripslashes($_GET[$name]) : '';
                // Additional sanitization: remove null bytes and control characters
                return filter_var($value, FILTER_SANITIZE_FULL_SPECIAL_CHARS);
            } elseif ($type == 'numeric') {
                return (isset($_GET[$name]) && is_numeric($_GET[$name])) ? intval($_GET[$name]) : '';
            } elseif ($type == 'boolean') {
                return (isset($_GET[$name])) ? true : false;
            } elseif ($type == 'array') {
                return (isset($_GET[$name]) && is_array($_GET[$name])) ? $_GET[$name] : array();
            }
        }
 
        return false;
    }

Referenced by Homepage\__construct().

cleanPostVar()

cleanPostVar ( $name, $type = 'text' )

static

Cleans and returns a specific $_POST variable based on the type specified.

Parameters

string	$name	The name of the $_POST variable.
string	$type	The type of the variable to return: 'text', 'number', 'float', 'boolean', 'array', or 'content'.

Returns

mixed Returns the cleaned $_POST variable based on the type or false if the variable is not set.

Definition at line 185 of file class.util.php.

    {
        if (is_string($name)) {
            if ($type == 'text') {
                return (isset($_POST[$name]) && !empty($_POST[$name])) ? stripslashes(trim($_POST[$name])) : '';
            } elseif ($type == 'number') {
                return (isset($_POST[$name]) && is_numeric($_POST[$name])) ? intval($_POST[$name]) : '';
            } elseif ($type == 'float') {
                return (isset($_POST[$name]) && is_numeric($_POST[$name])) ? floatval($_POST[$name]) : '';
            } elseif ($type == 'boolean') {
                return (isset($_POST[$name])) ? true : false;
            } elseif ($type == 'array') {
                return (isset($_POST[$name]) && is_array($_POST[$name])) ? $_POST[$name] : array();
            } elseif ($type == 'content') {
                return (isset($_POST[$name]) && !empty($_POST[$name])) ? trim($_POST[$name]) : '';
            }
        }
 
        return false;
    }

clearFileScanCache()

clearFileScanCache ( )

static

Clears all file scan caches.

Returns

void

Definition at line 1710 of file class.util.php.

    {
        global $bearsamppRoot;
 
        // Clear memory cache
        self::$fileScanCache = null;
 
        // Clear file caches
        if (isset($bearsamppRoot)) {
            $tmpPath = $bearsamppRoot->getTmpPath();
            $cacheFiles = glob($tmpPath . '/filescan_cache_*.dat');
 
            if ($cacheFiles !== false) {
                foreach ($cacheFiles as $cacheFile) {
                    @unlink($cacheFile);
                }
                self::logInfo('Cleared ' . count($cacheFiles) . ' file scan cache files');
            }
        }
 
        // Reset stats
        self::$fileScanStats = [
            'hits' => 0,
            'misses' => 0,
            'invalidations' => 0
        ];
    }

References $bearsamppRoot, and logInfo().

clearFolder()

clearFolder ( $path, $exclude = array() )

static

Recursively clears all files and directories within a specified directory, excluding specified items.

Parameters

string	$path	The path of the directory to clear.
array	$exclude	An array of filenames to exclude from deletion.

Returns

array|null Returns an array with the operation status and count of files deleted, or null if the directory cannot be opened.

Definition at line 500 of file class.util.php.

    {
        $result             = array();
        $result['return']   = true;
        $result['nb_files'] = 0;
 
        $handle = @opendir($path);
        if (!$handle) {
            return null;
        }
 
        while (false !== ($file = readdir($handle))) {
            if ($file == '.' || $file == '..' || in_array($file, $exclude)) {
                continue;
            }
            if (is_dir($path . '/' . $file)) {
                $r = self::clearFolder($path . '/' . $file);
                if (!$r) {
                    $result['return'] = false;
 
                    return $result;
                }
            } else {
                $r = @unlink($path . '/' . $file);
                if ($r) {
                    $result['nb_files']++;
                } else {
                    $result['return'] = false;
 
                    return $result;
                }
            }
        }
 
        closedir($handle);
 
        return $result;
    }

References $result, and clearFolder().

Referenced by ActionClearFolders\__construct(), ActionStartup\cleanTmpFolders(), clearFolder(), and clearFolders().

clearFolders()

clearFolders ( $paths, $exclude = array() )

static

Recursively deletes files from a specified directory while excluding certain files.

Parameters

string	$path	The path to the directory to clear.
array	$exclude	An array of filenames to exclude from deletion.

Returns

array Returns an array with the status of the operation and the number of files deleted.

Definition at line 482 of file class.util.php.

    {
        $result = array();
        foreach ($paths as $path) {
            $result[$path] = self::clearFolder($path, $exclude);
        }
 
        return $result;
    }

References $result, and clearFolder().

clearLoadingText()

clearLoadingText ( )

static

Clears the loading status file

Definition at line 1452 of file class.util.php.

    {
        global $bearsamppCore;
 
        $statusFile = $bearsamppCore->getTmpPath() . '/loading_status.txt';
        if (file_exists($statusFile)) {
            @unlink($statusFile);
        }
    }

References $bearsamppCore.

Referenced by stopLoading().

clearPathFormatCache()

clearPathFormatCache ( )

static

Clears the path format cache. Useful when paths change or for testing purposes.

Returns

void

Definition at line 1336 of file class.util.php.

    {
        self::$pathFormatCache = [];
        self::$pathFormatStats = [
            'unix_hits' => 0,
            'unix_misses' => 0,
            'windows_hits' => 0,
            'windows_misses' => 0
        ];
    }

contains()

contains ( $string, $search )

static

Checks if a string contains a specified substring.

Parameters

string	$string	The string to search in.
string	$search	The substring to search for.

Returns

bool Returns true if the substring is found in the string, otherwise false.

Definition at line 350 of file class.util.php.

    {
        if (!empty($string) && !empty($search)) {
            $result = stripos($string, $search);
            if ($result !== false) {
                return true;
            } else {
                return false;
            }
        } else {
            return false;
        }
    }

References $result.

Referenced by BinMailpit\checkPort(), BinXlight\checkPort(), BinMariadb\getCmdLineOutput(), BinMysql\getCmdLineOutput(), is32BitsOs(), and Win32Ps\killBins().

cp1252ToUtf8()

cp1252ToUtf8 ( $data )

static

Converts Windows-1252 encoded data to UTF-8 encoding.

Parameters

string

$data

The Windows-1252 encoded data.

Returns

string Returns the data encoded in UTF-8.

Definition at line 1391 of file class.util.php.

    {
        return iconv('WINDOWS-1252', 'UTF-8//IGNORE', $data);
    }

decryptFile()

decryptFile ( )

static

Decrypts a file encrypted with a specified method and returns the content.

Returns

string|false Decrypted content or false on failure.

Definition at line 2733 of file class.util.php.

    {
        global $bearsamppCore, $bearsamppConfig;
 
        $stringfile = $bearsamppCore->getResourcesPath() . '/string.dat';
        $encryptedFile = $bearsamppCore->getResourcesPath() . '/github.dat';
        $method        = 'AES-256-CBC'; // The same encryption method used
 
        // Get key string
        $stringPhrase = @file_get_contents($stringfile);
        if ($stringPhrase === false) {
            Util::logDebug("Failed to read the file at path: {$stringfile}");
 
            return false;
        }
 
        $stringKey = convert_uudecode($stringPhrase);
 
        // Read the encrypted data from the file
        $encryptedData = file_get_contents($encryptedFile);
        if ($encryptedData === false) {
            Util::logDebug("Failed to read the file at path: {$encryptedFile}");
 
            return false;
        }
 
        // Decode the base64 encoded data
        $data = base64_decode($encryptedData);
        if ($data === false) {
            Util::logDebug("Failed to decode the data from path: {$encryptedFile}");
 
            return false;
        }
 
        // Extract the IV which was prepended to the encrypted data
        $ivLength  = openssl_cipher_iv_length($method);
        $iv        = substr($data, 0, $ivLength);
        $encrypted = substr($data, $ivLength);
 
        // Decrypt the data
        $decrypted = openssl_decrypt($encrypted, $method, $stringKey, 0, $iv);
        if ($decrypted === false) {
            Util::logDebug("Decryption failed for data from path: {$encryptedFile}");
 
            return false;
        }
 
        return $decrypted;
    }

References $bearsamppConfig, $bearsamppCore, and logDebug().

Referenced by setupCurlHeaderWithToken().

deleteFolder()

deleteFolder ( $path )

static

Recursively deletes a directory and all its contents.

Parameters

string

$path

The path of the directory to delete.

Definition at line 544 of file class.util.php.

    {
        if (is_dir($path)) {
            if (substr($path, strlen($path) - 1, 1) != '/') {
                $path .= '/';
            }
            $files = glob($path . '*', GLOB_MARK);
            foreach ($files as $file) {
                if (is_dir($file)) {
                    self::deleteFolder($file);
                } else {
                    unlink($file);
                }
            }
            rmdir($path);
        }
    }

References deleteFolder().

Referenced by deleteFolder(), and ActionStartup\rotationLogs().

disableLaunchStartup()

disableLaunchStartup ( )

static

Disables launching the application at startup by removing the shortcut from the startup folder.

Returns

bool True on success, false on failure.

Definition at line 915 of file class.util.php.

    {
        $startupLnkPath = self::getStartupLnkPath();
 
        // Check if file exists before attempting to delete
        if (file_exists($startupLnkPath)) {
            return @unlink($startupLnkPath);
        }
 
        // Return true if the file doesn't exist (already disabled)
        return true;
    }

References getStartupLnkPath().

Referenced by ActionLaunchStartup\__construct(), and ActionStartup\checkLaunchStartup().

enableLaunchStartup()

enableLaunchStartup ( )

static

Enables launching the application at startup by creating a shortcut in the startup folder.

Returns

bool True on success, false on failure.

Definition at line 905 of file class.util.php.

    {
        return Vbs::createShortcut(self::getStartupLnkPath());
    }

References Vbs\createShortcut().

Referenced by ActionLaunchStartup\__construct(), and ActionStartup\checkLaunchStartup().

endWith()

endWith ( $string, $search )

static

Checks if a string ends with a specified substring.

This method trims the right side whitespace of the input string before checking if it ends with the specified search substring.

Parameters

string	$string	The string to check.
string	$search	The substring to look for at the end of the string.

Returns

bool Returns true if the string ends with the search substring, otherwise false.

Definition at line 395 of file class.util.php.

    {
        $length = strlen($search);
        $start  = $length * -1;
 
        return (substr($string, $start) === $search);
    }

Referenced by Batch\exec(), BinApache\getAlias(), BinPhp\getExtensionsFromFolder(), LangProc\getList(), TplAppLogs\getMenuLogs(), BinApache\getModulesFromFolder(), Batch\getProcessUsingPort(), and BinApache\getVhosts().

findFile()

findFile ( $startPath, $findFile )

staticprivate

Recursively searches for a file starting from a specified directory.

Parameters

string	$startPath	The directory path to start the search.
string	$findFile	The filename to search for.

Returns

string|false Returns the path to the file if found, or false if not found.

Definition at line 570 of file class.util.php.

    {
        $result = false;
 
        $handle = @opendir($startPath);
        if (!$handle) {
            return false;
        }
 
        while (false !== ($file = readdir($handle))) {
            if ($file == '.' || $file == '..') {
                continue;
            }
            if (is_dir($startPath . '/' . $file)) {
                $result = self::findFile($startPath . '/' . $file, $findFile);
                if ($result !== false) {
                    break;
                }
            } elseif ($file == $findFile) {
                $result = self::formatUnixPath($startPath . '/' . $file);
                break;
            }
        }
 
        closedir($handle);
 
        return $result;
    }

References $result, findFile(), and formatUnixPath().

Referenced by findFile(), and getPowerShellPath().

findFiles()

findFiles ( $startPath, $includes = array(''), $recursive = true )

staticprivate

Recursively finds files in a directory that match a set of inclusion patterns.

Parameters

string	$startPath	The directory path to start the search from.
array	$includes	An array of file patterns to include in the search. Patterns starting with '!' are excluded.
bool	$recursive	Determines whether the search should be recursive.

Returns

array An array of files that match the inclusion patterns.

Definition at line 1952 of file class.util.php.

    {
        $result = array();
 
        $handle = @opendir($startPath);
        if (!$handle) {
            return $result;
        }
 
        while (false !== ($file = readdir($handle))) {
            if ($file == '.' || $file == '..') {
                continue;
            }
            if (is_dir($startPath . '/' . $file) && $recursive) {
                $tmpResults = self::findFiles($startPath . '/' . $file, $includes);
                foreach ($tmpResults as $tmpResult) {
                    $result[] = $tmpResult;
                }
            } elseif (is_file($startPath . '/' . $file)) {
                foreach ($includes as $include) {
                    if (self::startWith($include, '!')) {
                        $include = ltrim($include, '!');
                        if (self::startWith($file, '.') && !self::endWith($file, $include)) {
                            $result[] = self::formatUnixPath($startPath . '/' . $file);
                        } elseif ($file != $include) {
                            $result[] = self::formatUnixPath($startPath . '/' . $file);
                        }
                    } elseif (self::endWith($file, $include) || $file == $include || empty($include)) {
                        $result[] = self::formatUnixPath($startPath . '/' . $file);
                    }
                }
            }
        }
 
        closedir($handle);
 
        return $result;
    }

References $result, findFiles(), and formatUnixPath().

Referenced by findFiles(), and getFilesToScan().

findRepos()

findRepos ( $initPath, $startPath, $checkFile, $maxDepth = 1 )

static

Recursively searches for repositories starting from a given path up to a specified depth.

Parameters

string	$initPath	The initial path from where the search begins.
string	$startPath	The current path from where to search.
string	$checkFile	The file name to check for in the directory to consider it a repository.
int	$maxDepth	The maximum depth of directories to search into.

Returns

array Returns an array of paths that contain the specified file.

Definition at line 1204 of file class.util.php.

    {
        $depth  = substr_count(str_replace($initPath, '', $startPath), '/');
        $result = array();
 
        $handle = @opendir($startPath);
        if (!$handle) {
            return $result;
        }
 
        while (false !== ($file = readdir($handle))) {
            if ($file == '.' || $file == '..') {
                continue;
            }
            if (is_dir($startPath . '/' . $file) && ($initPath == $startPath || $depth <= $maxDepth)) {
                $tmpResults = self::findRepos($initPath, $startPath . '/' . $file, $checkFile, $maxDepth);
                foreach ($tmpResults as $tmpResult) {
                    $result[] = $tmpResult;
                }
            } elseif (is_file($startPath . '/' . $checkFile) && !in_array($startPath, $result)) {
                $result[] = self::formatUnixPath($startPath);
            }
        }
 
        closedir($handle);
 
        return $result;
    }

References $result, findRepos(), and formatUnixPath().

Referenced by ToolGit\findRepos(), and findRepos().

flushLogBuffer()

flushLogBuffer ( )

static

Flushes the log buffer to disk. Groups log entries by file to minimize file operations.

Returns

void

Definition at line 997 of file class.util.php.

    {
        if (empty(self::$logBuffer)) {
            return;
        }
 
        global $bearsamppCore;
 
        // Group logs by file
        $logsByFile = [];
        foreach (self::$logBuffer as $log) {
            if (!isset($logsByFile[$log['file']])) {
                $logsByFile[$log['file']] = [];
            }
            $logsByFile[$log['file']][] = $log;
        }
 
        // Write all logs at once per file
        foreach ($logsByFile as $file => $logs) {
            $content = '';
            foreach ($logs as $log) {
                $content .= '[' . date('Y-m-d H:i:s', $log['time']) . '] # ' .
                           APP_TITLE . ' ' . $bearsamppCore->getAppVersion() . ' # ' .
                           $log['type'] . ': ' . $log['data'] . PHP_EOL;
            }
 
            // Use LOCK_EX to prevent race conditions
            @file_put_contents($file, $content, FILE_APPEND | LOCK_EX);
            self::$logStats['writes']++;
        }
 
        self::$logStats['flushed'] += count(self::$logBuffer);
        self::$logBuffer = [];
    }

References $bearsamppCore, and APP_TITLE.

Referenced by log().

formatUnixPath()

formatUnixPath ( $path )

static

Converts a Windows-style path to a Unix-style path with caching. Unix-style paths use forward slashes (/) as separators.

Performance optimization: Caches results to avoid redundant string replacements for frequently used paths (e.g., root paths, bin paths).

Parameters

string

$path

The Windows-style path to convert.

Returns

string Returns the converted Unix-style path.

Definition at line 1287 of file class.util.php.

    {
        // Return early for empty strings
        if (empty($path)) {
            return $path;
        }
 
        // Check cache first
        $cacheKey = 'u_' . $path;
        if (isset(self::$pathFormatCache[$cacheKey])) {
            self::$pathFormatStats['unix_hits']++;
            return self::$pathFormatCache[$cacheKey];
        }
 
        self::$pathFormatStats['unix_misses']++;
 
        // Perform the conversion
        $result = str_replace('\\', '/', $path);
 
        // Store in cache if under size limit
        if (count(self::$pathFormatCache) < self::$pathFormatCacheMaxSize) {
            self::$pathFormatCache[$cacheKey] = $result;
        } else {
            // Cache is full - implement LRU by removing first 10% of entries
            $removeCount = (int)(self::$pathFormatCacheMaxSize * 0.1);
            self::$pathFormatCache = array_slice(self::$pathFormatCache, $removeCount, null, true);
            self::$pathFormatCache[$cacheKey] = $result;
        }
 
        return $result;
    }

References $result.

Referenced by changePath(), ActionQuit\checkForOrphanedProcesses(), Root\errorHandler(), Win32Ps\findByPath(), findFile(), findFiles(), findRepos(), BinApache\getAliasContent(), getNssmEnvPaths(), Vbs\getSpecialPath(), BinApache\getVhostContent(), Win32Ps\killBins(), ActionStartup\killOldInstances(), ActionGenSslCertificate\processWindow(), ActionStartup\processWindow(), and ToolGit\reload().

formatWindowsPath()

formatWindowsPath ( $path )

static

Converts a Unix-style path to a Windows-style path with caching. This is a Windows application, so paths use backslashes () as separators.

Performance optimization: Caches results to avoid redundant string replacements for frequently used paths (e.g., root paths, bin paths).

Parameters

string

$path

The Unix-style path to convert.

Returns

string Returns the converted Windows-style path.

Definition at line 1244 of file class.util.php.

    {
        // Return early for empty strings
        if (empty($path)) {
            return $path;
        }
 
        // Check cache first
        $cacheKey = 'w_' . $path;
        if (isset(self::$pathFormatCache[$cacheKey])) {
            self::$pathFormatStats['windows_hits']++;
            return self::$pathFormatCache[$cacheKey];
        }
 
        self::$pathFormatStats['windows_misses']++;
 
        // Perform the conversion
        $result = str_replace('/', '\\', $path);
 
        // Store in cache if under size limit
        if (count(self::$pathFormatCache) < self::$pathFormatCacheMaxSize) {
            self::$pathFormatCache[$cacheKey] = $result;
        } else {
            // Cache is full - implement LRU by removing first 10% of entries
            $removeCount = (int)(self::$pathFormatCacheMaxSize * 0.1);
            self::$pathFormatCache = array_slice(self::$pathFormatCache, $removeCount, null, true);
            self::$pathFormatCache[$cacheKey] = $result;
        }
 
        return $result;
    }

References $result.

Referenced by ActionGenSslCertificate\__construct(), changePath(), ActionStartup\checkPathRegKey(), ActionAddVhost\createFormFields(), ActionEditAlias\createFormFields(), ActionEditVhost\createFormFields(), Batch\createSymlink(), Module\createSymlink(), getAppBinsRegKey(), ToolPowerShell\getShell(), Batch\getTmpFile(), BinMariadb\initData(), Batch\installPostgresqlService(), openFileContent(), Batch\refreshEnvVars(), Batch\removeSymlink(), Nssm\setBinPath(), Win32Service\setBinPath(), Nssm\setEnvironmentExtra(), and Batch\uninstallPostgresqlService().

generateCacheHMAC()

generateCacheHMAC ( $data, $cacheKey )

staticprivate

Generates HMAC for cache data integrity verification.

Parameters

array	$data	The data to generate HMAC for
string	$cacheKey	The cache key

Returns

string The HMAC hash

Definition at line 1676 of file class.util.php.

    {
        $key = self::getCacheIntegrityKey();
        $message = serialize($data) . $cacheKey;
        return hash_hmac('sha256', $message, $key);
    }

References getCacheIntegrityKey().

Referenced by setFileScanCache(), and verifyCacheIntegrity().

generateSecureBytes()

generateSecureBytes ( $length = 32 )

static

Generates a cryptographically secure random bytes string. Useful for encryption keys, initialization vectors, etc.

Parameters

int

$length

The length in bytes.

Returns

string Returns raw binary random bytes.

Exceptions

Exception

If an appropriate source of randomness cannot be found.

Definition at line 464 of file class.util.php.

    {
        try {
            return random_bytes($length);
        } catch (Exception $e) {
            self::logError('Failed to generate secure bytes: ' . $e->getMessage());
            throw $e;
        }
    }

References logError().

generateSecureToken()

generateSecureToken ( $length = 32 )

static

Generates a cryptographically secure random token as a hexadecimal string. This is ideal for security tokens, session IDs, CSRF tokens, etc.

Parameters

int

$length

The length in bytes (output will be double this in hex characters).

Returns

string Returns a hexadecimal string of cryptographically secure random bytes.

Exceptions

Exception

If an appropriate source of randomness cannot be found.

Definition at line 445 of file class.util.php.

    {
        try {
            return bin2hex(random_bytes($length));
        } catch (Exception $e) {
            self::logError('Failed to generate secure token: ' . $e->getMessage());
            throw $e;
        }
    }

References logError().

getApiJson()

getApiJson ( $url )

static

Sends a GET request to the specified URL and returns the response.

Parameters

string

$url

The URL to send the GET request to.

Returns

string The trimmed response data from the URL.

Definition at line 2355 of file class.util.php.

    {
        $header = self::setupCurlHeaderWithToken();
 
        $ch = curl_init();
        curl_setopt($ch, CURLOPT_SSLVERSION, CURL_SSLVERSION_TLSv1_2);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($ch, CURLOPT_VERBOSE, true);
        curl_setopt($ch, CURLOPT_URL, $url);
        curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
        curl_setopt($ch, CURLOPT_HTTPHEADER, $header);
        $data = curl_exec($ch);
        if (curl_errno($ch)) {
            Util::logError('CURL Error: ' . curl_error($ch));
        }
 
        // curl_close() is deprecated in PHP 8.5+ as it has no effect since PHP 8.0
        // The resource is automatically closed when it goes out of scope
        if (PHP_VERSION_ID < 80500) {
            curl_close($ch);
        }
 
        return trim($data);
    }

References logError(), and setupCurlHeaderWithToken().

Referenced by getLatestVersion().

getAppBinsRegKey()

getAppBinsRegKey ( $fromRegistry = true )

static

Definition at line 718 of file class.util.php.

    {
        global $bearsamppRegistry;
 
        if ($fromRegistry) {
            $value = $bearsamppRegistry->getValue(
                Registry::HKEY_LOCAL_MACHINE,
                Registry::ENV_KEY,
                Registry::APP_BINS_REG_ENTRY
            );
            self::logDebug('App reg key from registry: ' . $value);
        } else {
            global $bearsamppBins, $bearsamppTools;
            $value = '';
            if ($bearsamppBins->getApache()->isEnable()) {
                $value .= $bearsamppBins->getApache()->getSymlinkPath() . '/bin;';
            }
            if ($bearsamppBins->getPhp()->isEnable()) {
                $value .= $bearsamppBins->getPhp()->getSymlinkPath() . ';';
                $value .= $bearsamppBins->getPhp()->getSymlinkPath() . '/pear;';
                $value .= $bearsamppBins->getPhp()->getSymlinkPath() . '/deps;';
                $value .= $bearsamppBins->getPhp()->getSymlinkPath() . '/imagick;';
            }
            if ($bearsamppBins->getNodejs()->isEnable()) {
                $value .= $bearsamppBins->getNodejs()->getSymlinkPath() . ';';
            }
            if ($bearsamppTools->getComposer()->isEnable()) {
                $value .= $bearsamppTools->getComposer()->getSymlinkPath() . ';';
                $value .= $bearsamppTools->getComposer()->getSymlinkPath() . '/vendor/bin;';
            }
            if ($bearsamppTools->getGhostscript()->isEnable()) {
                $value .= $bearsamppTools->getGhostscript()->getSymlinkPath() . '/bin;';
            }
            if ($bearsamppTools->getGit()->isEnable()) {
                $value .= $bearsamppTools->getGit()->getSymlinkPath() . '/bin;';
            }
            if ($bearsamppTools->getNgrok()->isEnable()) {
                $value .= $bearsamppTools->getNgrok()->getSymlinkPath() . ';';
            }
            if ($bearsamppTools->getPerl()->isEnable()) {
                $value .= $bearsamppTools->getPerl()->getSymlinkPath() . '/perl/site/bin;';
                $value .= $bearsamppTools->getPerl()->getSymlinkPath() . '/perl/bin;';
                $value .= $bearsamppTools->getPerl()->getSymlinkPath() . '/c/bin;';
            }
            if ($bearsamppTools->getPython()->isEnable()) {
                $value .= $bearsamppTools->getPython()->getSymlinkPath() . '/bin;';
            }
            if ($bearsamppTools->getRuby()->isEnable()) {
                $value .= $bearsamppTools->getRuby()->getSymlinkPath() . '/bin;';
            }
            $value = self::formatWindowsPath($value);
            self::logDebug('Generated app bins reg key: ' . $value);
        }
 
        return $value;
    }

References $bearsamppBins, Registry\APP_BINS_REG_ENTRY, Registry\ENV_KEY, formatWindowsPath(), Registry\HKEY_LOCAL_MACHINE, and logDebug().

Referenced by ActionStartup\checkBinsRegKey(), Win32Service\create(), and ActionSwitchVersion\processWindow().

getAppPathRegKey()

getAppPathRegKey ( )

static

Retrieves the application path from the registry.

Returns

mixed The value of the application path registry key or false on error.

Definition at line 799 of file class.util.php.

    {
        global $bearsamppRegistry;
 
        return $bearsamppRegistry->getValue(
            Registry::HKEY_LOCAL_MACHINE,
            Registry::ENV_KEY,
            Registry::APP_PATH_REG_ENTRY
        );
    }

References Registry\APP_PATH_REG_ENTRY, Registry\ENV_KEY, and Registry\HKEY_LOCAL_MACHINE.

Referenced by ActionStartup\checkPathRegKey().

getCacheIntegrityKey()

getCacheIntegrityKey ( )

staticprivate

Generates or retrieves the cache integrity key. This key is unique per session to prevent cross-session cache tampering.

Returns

string The cache integrity key

Definition at line 1629 of file class.util.php.

    {
        if (self::$cacheIntegrityKey === null) {
            global $bearsamppRoot;
 
            // Try to load existing key from session file
            if (isset($bearsamppRoot)) {
                $keyFile = $bearsamppRoot->getTmpPath() . '/cache_integrity.key';
 
                if (file_exists($keyFile)) {
                    $key = @file_get_contents($keyFile);
                    if ($key !== false && strlen($key) === 64) {
                        self::$cacheIntegrityKey = $key;
                        return self::$cacheIntegrityKey;
                    }
                }
 
                // Generate new key if none exists or invalid
                try {
                    self::$cacheIntegrityKey = bin2hex(random_bytes(32));
                    @file_put_contents($keyFile, self::$cacheIntegrityKey, LOCK_EX);
                } catch (Exception $e) {
                    self::logError('Failed to generate cache integrity key: ' . $e->getMessage());
                    // Fallback to a less secure but functional key
                    self::$cacheIntegrityKey = hash('sha256', uniqid('bearsampp_cache_', true));
                }
            } else {
                // Fallback if bearsamppRoot not available
                try {
                    self::$cacheIntegrityKey = bin2hex(random_bytes(32));
                } catch (Exception $e) {
                    self::$cacheIntegrityKey = hash('sha256', uniqid('bearsampp_cache_', true));
                }
            }
        }
 
        return self::$cacheIntegrityKey;
    }

References $bearsamppRoot, and logError().

Referenced by generateCacheHMAC().

getChangelogUrl()

getChangelogUrl ( $utmSource = true )

static

Constructs the URL to the changelog page, optionally including UTM parameters.

Parameters

bool

$utmSource

Whether to include UTM source parameters.

Returns

string The URL to the changelog page.

Definition at line 2135 of file class.util.php.

    {
        return self::getWebsiteUrl('doc/changelog', null, $utmSource);
    }

References getWebsiteUrl().

getCurlHttpHeaders()

getCurlHttpHeaders ( $url )

static

Retrieves HTTP headers from a given URL using cURL.

This method initializes a cURL session, sets various options to fetch headers including disabling SSL peer verification, and executes the request. It logs the raw response for debugging purposes and parses the headers from the response.

Parameters

string

$url

The URL from which to fetch the headers.

Returns

array An array of headers if successful, otherwise an empty array.

Definition at line 2273 of file class.util.php.

    {
        $result = array();
 
        $ch = curl_init();
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($ch, CURLOPT_VERBOSE, true);
        curl_setopt($ch, CURLOPT_HEADER, true);
        curl_setopt($ch, CURLOPT_URL, $url);
        curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
 
        $response = @curl_exec($ch);
        if (empty($response)) {
            return $result;
        }
 
        self::logTrace('getCurlHttpHeaders:' . $response);
        $responseHeaders = explode("\r\n\r\n", $response, 2);
        if (!isset($responseHeaders[0]) || empty($responseHeaders[0])) {
            return $result;
        }
 
        return explode("\n", $responseHeaders[0]);
    }

References $response, $result, and logTrace().

Referenced by getHttpHeaders().

getFileScanCache()

getFileScanCache ( $cacheKey )

staticprivate

Gets cached file scan results if valid. Includes integrity verification to prevent cache tampering.

Parameters

string

$cacheKey

The cache key to retrieve.

Returns

array|false Returns cached results or false if cache is invalid/missing.

Definition at line 1523 of file class.util.php.

    {
        global $bearsamppRoot;
 
        // Check if we have in-memory cache first
        if (self::$fileScanCache !== null && isset(self::$fileScanCache[$cacheKey])) {
            $cache = self::$fileScanCache[$cacheKey];
 
            // Check if cache is still valid
            if (time() - $cache['timestamp'] < self::$fileScanCacheDuration) {
                return $cache['data'];
            } else {
                self::$fileScanStats['invalidations']++;
                unset(self::$fileScanCache[$cacheKey]);
            }
        }
 
        // Try to load from file cache
        if (!isset($bearsamppRoot)) {
            return false;
        }
 
        $cacheFile = $bearsamppRoot->getTmpPath() . '/filescan_cache_' . $cacheKey . '.dat';
 
        if (file_exists($cacheFile)) {
            $fileContents = @file_get_contents($cacheFile);
 
            if ($fileContents === false) {
                return false;
            }
 
            // Verify file integrity before unserializing
            if (!self::verifyCacheIntegrity($fileContents, $cacheKey)) {
                self::logWarning('File scan cache integrity check failed for key: ' . $cacheKey . '. Possible tampering detected.');
                @unlink($cacheFile);
                return false;
            }
 
            $cacheData = @unserialize($fileContents);
 
            if ($cacheData !== false && isset($cacheData['timestamp']) && isset($cacheData['data']) && isset($cacheData['hmac'])) {
                // Check if file cache is still valid
                if (time() - $cacheData['timestamp'] < self::$fileScanCacheDuration) {
                    // Store in memory cache for faster subsequent access
                    if (self::$fileScanCache === null) {
                        self::$fileScanCache = [];
                    }
                    self::$fileScanCache[$cacheKey] = $cacheData;
 
                    return $cacheData['data'];
                } else {
                    // Cache expired, delete file
                    self::$fileScanStats['invalidations']++;
                    @unlink($cacheFile);
                }
            } else {
                // Invalid cache structure, delete file
                self::logWarning('Invalid cache structure detected for key: ' . $cacheKey);
                @unlink($cacheFile);
            }
        }
 
        return false;
    }

References $bearsamppRoot, and logWarning().

Referenced by getFilesToScan().

getFileScanCacheDuration()

getFileScanCacheDuration ( )

static

Gets the current file scan cache duration.

Returns

int Cache duration in seconds

Definition at line 1768 of file class.util.php.

    {
        return self::$fileScanCacheDuration;
    }

getFileScanStats()

getFileScanStats ( )

static

Gets file scan cache statistics.

Returns

array Array containing hits, misses, and invalidations counts

Definition at line 1743 of file class.util.php.

    {
        return self::$fileScanStats;
    }

getFilesToScan()

getFilesToScan ( $path = null, $useCache = true, $forceRefresh = false )

static

Retrieves a list of files to scan from specified paths or default paths. Implements caching to avoid repeated expensive file system scans.

Parameters

string | null	$path	Optional. The path to start scanning from. If null, uses default paths.
bool	$useCache	Whether to use cached results (default: true).
bool	$forceRefresh	Force refresh the cache even if valid (default: false).

Returns

array Returns an array of files found during the scan.

Definition at line 1472 of file class.util.php.

    {
        // Generate cache key based on path parameter
        $cacheKey = md5(serialize($path));
 
        // Try to get from cache if enabled and not forcing refresh
        if ($useCache && !$forceRefresh) {
            $cachedResult = self::getFileScanCache($cacheKey);
            if ($cachedResult !== false) {
                self::$fileScanStats['hits']++;
                self::logDebug('File scan cache HIT (saved expensive scan operation)');
                return $cachedResult;
            }
        }
 
        self::$fileScanStats['misses']++;
        self::logDebug('File scan cache MISS (performing full scan)');
 
        // Perform the actual scan
        $startTime = self::getMicrotime();
        $result      = array();
        $pathsToScan = !empty($path) ? $path : self::getPathsToScan();
 
        foreach ($pathsToScan as $pathToScan) {
            $pathStartTime = self::getMicrotime();
            $findFiles = self::findFiles($pathToScan['path'], $pathToScan['includes'], $pathToScan['recursive']);
            foreach ($findFiles as $findFile) {
                $result[] = $findFile;
            }
            self::logDebug($pathToScan['path'] . ' scanned in ' . round(self::getMicrotime() - $pathStartTime, 3) . 's');
        }
 
        $totalTime = round(self::getMicrotime() - $startTime, 3);
        self::logInfo('Full file scan completed in ' . $totalTime . 's (' . count($result) . ' files found)');
 
        // Store in cache if enabled
        if ($useCache) {
            self::setFileScanCache($cacheKey, $result);
        }
 
        return $result;
    }

References $result, findFiles(), getFileScanCache(), getMicrotime(), getPathsToScan(), logDebug(), logInfo(), and setFileScanCache().

Referenced by BinPostgresql\initData(), ActionSwitchVersion\processWindow(), and ActionStartup\scanFolders().

getFolderList()

getFolderList ( $path )

static

Retrieves a list of folders from a specified directory, excluding certain directories.

Parameters

string

$path

The directory path from which to list folders.

Returns

array|bool An array of folder names, or false if the directory cannot be opened.

Definition at line 2648 of file class.util.php.

    {
        $result = array();
 
        $handle = @opendir($path);
        if (!$handle) {
            return false;
        }
 
        while (false !== ($file = readdir($handle))) {
            $filePath = $path . '/' . $file;
            if ($file != '.' && $file != '..' && is_dir($filePath) && $file != 'current') {
                $result[] = $file;
            }
        }
 
        closedir($handle);
 
        return $result;
    }

References $result.

Referenced by ActionSwitchVersion\__construct(), and getPathsToScan().

getFopenHttpHeaders()

getFopenHttpHeaders ( $url )

static

Retrieves HTTP headers from a given URL using the fopen function.

This method creates a stream context to disable SSL peer and peer name verification, which allows self-signed certificates. It attempts to open the URL and read the HTTP response headers.

Parameters

string

$url

The URL from which to fetch the headers.

Returns

array An array of headers if successful, otherwise an empty array.

Definition at line 2240 of file class.util.php.

    {
        $result = array();
 
        $context = stream_context_create(array(
            'ssl' => array(
                'verify_peer'       => false,
                'verify_peer_name'  => false,
                'allow_self_signed' => true,
            )
        ));
 
        $fp = @fopen($url, 'r', false, $context);
        if ($fp) {
            $meta   = stream_get_meta_data($fp);
            $result = isset($meta['wrapper_data']) ? $meta['wrapper_data'] : $result;
            fclose($fp);
        }
 
        return $result;
    }

References $result.

Referenced by getHttpHeaders().

getGithubRawUrl()

getGithubRawUrl ( $file )

static

Constructs a URL for raw content from a GitHub repository.

Parameters

string

$file

The file path to append to the base URL.

Returns

string The full URL to the raw content on GitHub.

Definition at line 2634 of file class.util.php.

    {
        $file = !empty($file) ? '/' . $file : null;
 
        return 'https://raw.githubusercontent.com/' . APP_GITHUB_USER . '/' . APP_GITHUB_REPO . '/main' . $file;
    }

References APP_GITHUB_REPO, and APP_GITHUB_USER.

getGithubUrl()

getGithubUrl ( $part = null )

static

Constructs a GitHub repository URL with an optional path.

Parameters

string | null

$part

Optional path to append to the URL.

Returns

string The full GitHub repository URL.

Definition at line 2620 of file class.util.php.

    {
        $part = !empty($part) ? '/' . $part : null;
 
        return self::getGithubUserUrl(APP_GITHUB_REPO . $part);
    }

References APP_GITHUB_REPO, and getGithubUserUrl().

getGithubUserUrl()

getGithubUserUrl ( $part = null )

static

Constructs a GitHub user URL with an optional path.

Parameters

string | null

$part

Optional path to append to the URL.

Returns

string The full GitHub user URL.

Definition at line 2606 of file class.util.php.

    {
        $part = !empty($part) ? '/' . $part : null;
 
        return 'https://github.com/' . APP_GITHUB_USER . $part;
    }

References APP_GITHUB_USER.

Referenced by ActionAbout\__construct(), getGithubUrl(), and ActionAbout\processWindow().

getHeaders()

getHeaders ( $host, $port, $ssl = false )

static

Retrieves the initial response line from a specified host and port using a socket connection.

This method optionally uses SSL and creates a stream context similar to getFopenHttpHeaders. It attempts to connect to the host and port, reads the first line of the response, and parses it. Detailed debug information is logged for each header line received.

Parameters

string	$host	The host name or IP address to connect to.
int	$port	The port number to connect to.
bool	$ssl	Whether to use SSL (defaults to false).

Returns

array An array containing the first line of the response, split into parts, or an empty array if unsuccessful.

Definition at line 2311 of file class.util.php.

    {
        $result  = array();
        $context = stream_context_create(array(
            'ssl' => array(
                'verify_peer'       => false,
                'verify_peer_name'  => false,
                'allow_self_signed' => true,
            )
        ));
 
        $fp = @stream_socket_client(($ssl ? 'ssl://' : '') . $host . ':' . $port, $errno, $errstr, 5, STREAM_CLIENT_CONNECT, $context);
        if ($fp) {
            $out    = fgets($fp);
            $result = explode(PHP_EOL, $out);
            @fclose($fp);
        }
 
        if (!empty($result)) {
            $rebuildResult = array();
            foreach ($result as $row) {
                $row = trim($row);
                if (!empty($row)) {
                    $rebuildResult[] = $row;
                }
            }
            $result = $rebuildResult;
 
            self::logDebug('getHeaders:');
            foreach ($result as $header) {
                self::logDebug('-> ' . $header);
            }
        }
 
        return $result;
    }

References $port, $result, and logDebug().

Referenced by BinMailpit\checkPort(), and BinXlight\checkPort().

getHttpHeaders()

getHttpHeaders ( $pingUrl )

static

Retrieves HTTP headers from a given URL using either cURL or fopen, depending on availability.

Parameters

string

$pingUrl

The URL to ping for headers.

Returns

array An array of HTTP headers.

Definition at line 2202 of file class.util.php.

    {
        if (function_exists('curl_version')) {
            $result = self::getCurlHttpHeaders($pingUrl);
        } else {
            $result = self::getFopenHttpHeaders($pingUrl);
        }
 
        if (!empty($result)) {
            $rebuildResult = array();
            foreach ($result as $row) {
                $row = trim($row);
                if (!empty($row)) {
                    $rebuildResult[] = $row;
                }
            }
            $result = $rebuildResult;
 
            self::logDebug('getHttpHeaders:');
            foreach ($result as $header) {
                self::logDebug('-> ' . $header);
            }
        }
 
        return $result;
    }

References $result, getCurlHttpHeaders(), getFopenHttpHeaders(), and logDebug().

Referenced by BinApache\checkPort().

getLatestVersion()

getLatestVersion ( $url )

static

Fetches the latest version information from a given url.

Parameters

string

$url

The URL to fetch version information from.

Returns

array|null Returns an array with 'version' and 'url' if successful, null otherwise.

Definition at line 2062 of file class.util.php.

    {
        $result = self::getApiJson($url);
        if (empty($result)) {
            self::logError('Cannot retrieve latest github info for: ' . $result . ' RESULT');
 
            return null;
        }
 
        $resultArray = json_decode($result, true);
        if (isset($resultArray['tag_name']) && isset($resultArray['assets'][0]['browser_download_url'])) {
            $tagName     = $resultArray['tag_name'];
            $downloadUrl = $resultArray['assets'][0]['browser_download_url'];
            $name        = $resultArray['name'];
            self::logDebug('Latest version tag name: ' . $tagName);
            self::logDebug('Download URL: ' . $downloadUrl);
            self::logDebug('Name: ' . $name);
 
            return ['version' => $tagName, 'html_url' => $downloadUrl, 'name' => $name];
        } else {
            self::logError('Tag name, download URL, or name not found in the response: ' . $result);
 
            return null;
        }
    }

References $result, getApiJson(), logDebug(), and logError().

Referenced by ActionCheckVersion\__construct(), and ActionCheckVersion\processWindow().

getLogBufferSize()

getLogBufferSize ( )

static

Gets the current log buffer size.

Returns

int The current buffer size

Definition at line 1062 of file class.util.php.

    {
        return self::$logBufferSize;
    }

getLogStats()

getLogStats ( )

static

Gets the current log buffer statistics. Useful for monitoring and debugging log buffer effectiveness.

Returns

array Array containing buffered, flushed, and writes counts

Definition at line 1038 of file class.util.php.

    {
        return self::$logStats;
    }

getMicrotime()

getMicrotime ( )

static

Gets the current Unix timestamp with microseconds.

Returns

float Returns the current Unix timestamp combined with microseconds.

Definition at line 711 of file class.util.php.

    {
        list($usec, $sec) = explode(' ', microtime());
 
        return ((float)$usec + (float)$sec);
    }

Referenced by ActionStartup\__construct(), getFilesToScan(), ActionStartup\installServicesSequential(), ActionStartup\prepareService(), ActionStartup\processWindow(), and ActionStartup\scanFolders().

getNssmEnvPaths()

getNssmEnvPaths ( )

static

Retrieves and formats environment paths from a data file. Paths are verified to be directories and formatted to Unix style. Warnings are logged for paths that do not exist.

Returns

string A semicolon-separated string of formatted environment paths. @global object $bearsamppRoot Global object containing root path methods.

Definition at line 2677 of file class.util.php.

    {
        global $bearsamppRoot;
 
        $result           = '';
        $nssmEnvPathsFile = $bearsamppRoot->getRootPath() . '/nssmEnvPaths.dat';
 
        if (is_file($nssmEnvPathsFile)) {
            $paths = explode(PHP_EOL, file_get_contents($nssmEnvPathsFile));
            foreach ($paths as $path) {
                $path = trim($path);
                if (stripos($path, ':') === false) {
                    $path = $bearsamppRoot->getRootPath() . '/' . $path;
                }
                if (is_dir($path)) {
                    $result .= self::formatUnixPath($path) . ';';
                } else {
                    self::logWarning('Path not found in nssmEnvPaths.dat: ' . $path);
                }
            }
        }
 
        return $result;
    }

References $bearsamppRoot, $result, formatUnixPath(), and logWarning().

Referenced by Win32Service\create().

getPathFormatCacheSize()

getPathFormatCacheSize ( )

static

Gets the current size of the path format cache.

Returns

int Number of cached path conversions

Definition at line 1352 of file class.util.php.

    {
        return count(self::$pathFormatCache);
    }

getPathFormatStats()

getPathFormatStats ( )

static

Gets path format cache statistics. Useful for monitoring cache effectiveness and tuning cache size.

Returns

array Array containing unix_hits, unix_misses, windows_hits, windows_misses

Definition at line 1325 of file class.util.php.

    {
        return self::$pathFormatStats;
    }

getPathsToScan()

getPathsToScan ( )

staticprivate

Retrieves a list of directories and file types to scan within the BEARSAMPP environment.

This method compiles an array of paths from various components of the BEARSAMPP stack, including Apache, PHP, MySQL, MariaDB, PostgreSQL, Node.js, Composer, PowerShell, Python and Ruby. Each path entry includes the directory path, file types to include in the scan, and whether the scan should be recursive.

The method uses global variables to access the root paths of each component. It then dynamically fetches specific subdirectories using the getFolderList method (which is assumed to be defined elsewhere in this class or in the global scope) and constructs an array of path specifications.

Each path specification is an associative array with the following keys:

• 'path': The full directory path to scan.
• 'includes': An array of file extensions or filenames to include in the scan.
• 'recursive': A boolean indicating whether the scan should include subdirectories.

The method is designed to be used for setting up scans of configuration files and other important files within the BEARSAMPP environment, possibly for purposes like configuration management, backup, or security auditing.

Returns

array An array of associative arrays, each containing 'path', 'includes', and 'recursive' keys.

Definition at line 1797 of file class.util.php.

    {
        global $bearsamppRoot, $bearsamppCore, $bearsamppBins, $bearsamppApps, $bearsamppTools;
        $paths = array();
 
        // Alias
        $paths[] = array(
            'path'      => $bearsamppRoot->getAliasPath(),
            'includes'  => array(''),
            'recursive' => false
        );
 
        // Vhosts
        $paths[] = array(
            'path'      => $bearsamppRoot->getVhostsPath(),
            'includes'  => array(''),
            'recursive' => false
        );
 
        // OpenSSL
        $paths[] = array(
            'path'      => $bearsamppCore->getOpenSslPath(),
            'includes'  => array('openssl.cfg'),
            'recursive' => false
        );
 
        // Homepage
        $paths[] = array(
            'path'      => $bearsamppCore->getResourcesPath() . '/homepage',
            'includes'  => array('alias.conf'),
            'recursive' => false
        );
 
        // Apache
        $folderList = self::getFolderList($bearsamppBins->getApache()->getRootPath());
        foreach ($folderList as $folder) {
            $paths[] = array(
                'path'      => $bearsamppBins->getApache()->getRootPath() . '/' . $folder,
                'includes'  => array('.ini', '.conf'),
                'recursive' => true
            );
        }
 
        // PHP
        $folderList = self::getFolderList($bearsamppBins->getPhp()->getRootPath());
        foreach ($folderList as $folder) {
            $paths[] = array(
                'path'      => $bearsamppBins->getPhp()->getRootPath() . '/' . $folder,
                'includes'  => array('.php', '.bat', '.ini', '.reg', '.inc'),
                'recursive' => true
            );
        }
 
        // MySQL
        $folderList = self::getFolderList($bearsamppBins->getMysql()->getRootPath());
        foreach ($folderList as $folder) {
            $paths[] = array(
                'path'      => $bearsamppBins->getMysql()->getRootPath() . '/' . $folder,
                'includes'  => array('my.ini'),
                'recursive' => false
            );
        }
 
        // MariaDB
        $folderList = self::getFolderList($bearsamppBins->getMariadb()->getRootPath());
        foreach ($folderList as $folder) {
            $paths[] = array(
                'path'      => $bearsamppBins->getMariadb()->getRootPath() . '/' . $folder,
                'includes'  => array('my.ini'),
                'recursive' => false
            );
        }
 
        // PostgreSQL
        $folderList = self::getFolderList($bearsamppBins->getPostgresql()->getRootPath());
        foreach ($folderList as $folder) {
            $paths[] = array(
                'path'      => $bearsamppBins->getPostgresql()->getRootPath() . '/' . $folder,
                'includes'  => array( '.conf', '.bat', '.ber'),
                'recursive' => true
            );
        }
 
        // Node.js
        $folderList = self::getFolderList($bearsamppBins->getNodejs()->getRootPath());
        foreach ($folderList as $folder) {
            $paths[] = array(
                'path'      => $bearsamppBins->getNodejs()->getRootPath() . '/' . $folder . '/etc',
                'includes'  => array('npmrc'),
                'recursive' => true
            );
            $paths[] = array(
                'path'      => $bearsamppBins->getNodejs()->getRootPath() . '/' . $folder . '/node_modules/npm',
                'includes'  => array('npmrc'),
                'recursive' => false
            );
        }
 
        // Composer
        $folderList = self::getFolderList($bearsamppTools->getComposer()->getRootPath());
        foreach ($folderList as $folder) {
            $paths[] = array(
                'path'      => $bearsamppTools->getComposer()->getRootPath() . '/' . $folder,
                'includes'  => array('giscus.json'),
                'recursive' => false
            );
        }
 
        // PowerShell
        $folderList = self::getFolderList($bearsamppTools->getPowerShell()->getRootPath());
        foreach ($folderList as $folder) {
            $paths[] = array(
                'path'      => $bearsamppTools->getPowerShell()->getRootPath() . '/' . $folder,
                'includes'  => array('console.xml', '.ini', '.btm'),
                'recursive' => true
            );
        }
 
        // Python
        $folderList = self::getFolderList($bearsamppTools->getPython()->getRootPath());
        foreach ($folderList as $folder) {
            $paths[] = array(
                'path'      => $bearsamppTools->getPython()->getRootPath() . '/' . $folder . '/bin',
                'includes'  => array('.bat'),
                'recursive' => false
            );
            $paths[] = array(
                'path'      => $bearsamppTools->getPython()->getRootPath() . '/' . $folder . '/settings',
                'includes'  => array('winpython.ini'),
                'recursive' => false
            );
        }
 
        // Ruby
        $folderList = self::getFolderList($bearsamppTools->getRuby()->getRootPath());
        foreach ($folderList as $folder) {
            $paths[] = array(
                'path'      => $bearsamppTools->getRuby()->getRootPath() . '/' . $folder . '/bin',
                'includes'  => array('!.dll', '!.exe'),
                'recursive' => false
            );
        }
 
        return $paths;
    }

References $bearsamppBins, $bearsamppCore, $bearsamppRoot, and getFolderList().

Referenced by getFilesToScan().

getPowerShellPath()

getPowerShellPath ( )

static

Finds the path to the PowerShell executable in the Windows System32 directory.

Returns

string|false Returns the path to powershell.exe if found, otherwise false.

Definition at line 1185 of file class.util.php.

    {
        if (is_dir('C:\Windows\System32\WindowsPowerShell')) {
            return self::findFile('C:\Windows\System32\WindowsPowerShell', 'powershell.exe');
        }
 
        return false;
    }

References findFile().

Referenced by TplPowerShell\getTabPowerShellSection().

getProcessorRegKey()

getProcessorRegKey ( )

static

Retrieves the processor identifier from the registry.

Returns

mixed The value of the processor identifier registry key or false on error.

Definition at line 869 of file class.util.php.

    {
        global $bearsamppRegistry;
 
        return $bearsamppRegistry->getValue(
            Registry::HKEY_LOCAL_MACHINE,
            Registry::PROCESSOR_REG_SUBKEY,
            Registry::PROCESSOR_REG_ENTRY
        );
    }

References Registry\HKEY_LOCAL_MACHINE, Registry\PROCESSOR_REG_ENTRY, and Registry\PROCESSOR_REG_SUBKEY.

Referenced by is32BitsOs().

getRemoteFilesize()

getRemoteFilesize ( $url, $humanFileSize = true )

static

Retrieves the file size of a remote file.

Parameters

string	$url	The URL of the remote file.
bool	$humanFileSize	Whether to return the size in a human-readable format.

Returns

mixed The file size, either in bytes or as a formatted string.

Definition at line 2148 of file class.util.php.

    {
        $size = 0;
 
        $data = get_headers($url, true);
        if (isset($data['Content-Length'])) {
            $size = intval($data['Content-Length']);
        }
 
        return $humanFileSize ? self::humanFileSize($size) : $size;
    }

References humanFileSize().

getStartupLnkPath()

getStartupLnkPath ( )

static

Retrieves the path for the startup link file.

Returns

string The full path to the startup link file.

Definition at line 885 of file class.util.php.

    {
        return Vbs::getStartupPath(APP_TITLE . '.lnk');
    }

References APP_TITLE, and Vbs\getStartupPath().

Referenced by disableLaunchStartup().

getSysPathRegKey()

getSysPathRegKey ( )

static

Retrieves the system path from the registry.

Returns

mixed The value of the system path registry key or false on error.

Definition at line 834 of file class.util.php.

    {
        global $bearsamppRegistry;
 
        return $bearsamppRegistry->getValue(
            Registry::HKEY_LOCAL_MACHINE,
            Registry::ENV_KEY,
            Registry::SYSPATH_REG_ENTRY
        );
    }

References Registry\ENV_KEY, Registry\HKEY_LOCAL_MACHINE, and Registry\SYSPATH_REG_ENTRY.

Referenced by ActionStartup\checkSystemPathRegKey().

getVersionList()

getVersionList ( $path )

static

Retrieves a list of version directories within a specified path.

Parameters

string

$path

The path to search for version directories.

Returns

array|false Returns a sorted array of version names, or false if the directory cannot be opened.

Definition at line 684 of file class.util.php.

    {
        $result = array();
 
        $handle = @opendir($path);
        if (!$handle) {
            return false;
        }
 
        while (false !== ($file = readdir($handle))) {
            $filePath = $path . '/' . $file;
            if ($file != '.' && $file != '..' && is_dir($filePath) && $file != 'current') {
                $result[] = str_replace(basename($path), '', $file);
            }
        }
 
        closedir($handle);
        natcasesort($result);
 
        return $result;
    }

References $result.

Referenced by Module\getVersionList().

getWebsiteUrl()

getWebsiteUrl ( $path = '', $fragment = '', $utmSource = true )

static

Constructs a complete website URL with optional path, fragment, and UTM source parameters.

Parameters

string	$path	Optional path to append to the base URL.
string	$fragment	Optional fragment to append to the URL.
bool	$utmSource	Whether to include UTM source parameters.

Returns

string The constructed URL.

Definition at line 2110 of file class.util.php.

    {
        global $bearsamppCore;
 
        $url = APP_WEBSITE;
        if (!empty($path)) {
            $url .= '/' . ltrim($path, '/');
        }
        if ($utmSource) {
            $url = rtrim($url, '/') . '/?utm_source=bearsampp-' . $bearsamppCore->getAppVersion();
        }
        if (!empty($fragment)) {
            $url .= $fragment;
        }
 
        return $url;
    }

References $bearsamppCore, and APP_WEBSITE.

Referenced by getChangelogUrl(), TplAppApache\getMenuApache(), TplAppMailpit\getMenuMailpit(), TplAppMariadb\getMenuMariadb(), TplAppMemcached\getMenuMemcached(), TplAppMysql\getMenuMysql(), TplAppNodejs\getMenuNodejs(), TplAppPhp\getMenuPhp(), TplAppPostgresql\getMenuPostgresql(), TplAppXlight\getMenuXlight(), QuickPick\getQuickpickMenu(), TplApp\getSectionMenuRight(), getWebsiteUrlNoUtm(), and ActionAbout\processWindow().

getWebsiteUrlNoUtm()

getWebsiteUrlNoUtm ( $path = '', $fragment = '' )

static

Constructs a website URL without UTM parameters.

Parameters

string	$path	Optional path to append to the base URL.
string	$fragment	Optional fragment to append to the URL.

Returns

string The constructed URL without UTM parameters.

Definition at line 2096 of file class.util.php.

    {
        return self::getWebsiteUrl($path, $fragment, false);
    }

References getWebsiteUrl().

Referenced by ActionAbout\__construct().

humanFileSize()

humanFileSize ( $size, $unit = '' )

static

Converts a file size in bytes to a human-readable format.

Parameters

int	$size	The file size in bytes.
string	$unit	The unit to convert to ('GB', 'MB', 'KB', or ''). If empty, auto-selects the unit.

Returns

string The formatted file size.

Definition at line 2168 of file class.util.php.

    {
        if ((!$unit && $size >= 1 << 30) || $unit == 'GB') {
            return number_format($size / (1 << 30), 2) . 'GB';
        }
        if ((!$unit && $size >= 1 << 20) || $unit == 'MB') {
            return number_format($size / (1 << 20), 2) . 'MB';
        }
        if ((!$unit && $size >= 1 << 10) || $unit == 'KB') {
            return number_format($size / (1 << 10), 2) . 'KB';
        }
 
        return number_format($size) . ' bytes';
    }

Referenced by getRemoteFilesize().

imgToBase64()

imgToBase64 ( $path )

static

Converts an image file to a base64 encoded string.

Parameters

string

$path

The path to the image file.

Returns

string Returns the base64 encoded string of the image.

Definition at line 1364 of file class.util.php.

    {
        $type = pathinfo($path, PATHINFO_EXTENSION);
        $data = file_get_contents($path);
 
        return 'data:image/' . $type . ';base64,' . base64_encode($data);
    }

installService()

installService ( $bin, $port, $syntaxCheckCmd, $showWindow = false )

static

Attempts to install and start a service on a specific port, with optional syntax checking and user notifications.

Parameters

object	$bin	An object containing the binary information and methods related to the service.
int	$port	The port number on which the service should run.
string	$syntaxCheckCmd	The command to execute for syntax checking of the service configuration.
bool	$showWindow	Optional. Whether to show message boxes for information, warnings, and errors. Defaults to false.

Returns

bool Returns true if the service is successfully installed and started, false otherwise.

Definition at line 2449 of file class.util.php.

    {
        global $bearsamppLang, $bearsamppWinbinder;
 
        if (method_exists($bin, 'initData')) {
            $bin->initData();
        }
 
        $name     = $bin->getName();
        $service  = $bin->getService();
        $boxTitle = sprintf($bearsamppLang->getValue(Lang::INSTALL_SERVICE_TITLE), $name);
 
        $isPortInUse = self::isPortInUse($port);
        if ($isPortInUse === false) {
            if (!$service->isInstalled()) {
                $service->create();
                if ($service->start()) {
                    self::logInfo(sprintf('%s service successfully installed. (name: %s ; port: %s)', $name, $service->getName(), $port));
                    if ($showWindow) {
                        $bearsamppWinbinder->messageBoxInfo(
                            sprintf($bearsamppLang->getValue(Lang::SERVICE_INSTALLED), $name, $service->getName(), $port),
                            $boxTitle
                        );
                    }
 
                    return true;
                } else {
                    $serviceError    = sprintf($bearsamppLang->getValue(Lang::SERVICE_INSTALL_ERROR), $name);
                    $serviceErrorLog = sprintf('Error during the installation of %s service', $name);
                    if (!empty($syntaxCheckCmd)) {
                        $cmdSyntaxCheck = $bin->getCmdLineOutput($syntaxCheckCmd);
                        if (!$cmdSyntaxCheck['syntaxOk']) {
                            $serviceError    .= PHP_EOL . sprintf($bearsamppLang->getValue(Lang::STARTUP_SERVICE_SYNTAX_ERROR), $cmdSyntaxCheck['content']);
                            $serviceErrorLog .= sprintf(' (conf errors detected : %s)', $cmdSyntaxCheck['content']);
                        }
                    }
                    self::logError($serviceErrorLog);
                    if ($showWindow) {
                        $bearsamppWinbinder->messageBoxError($serviceError, $boxTitle);
                    }
                }
            } else {
                self::logWarning(sprintf('%s service already installed', $name));
                if ($showWindow) {
                    $bearsamppWinbinder->messageBoxWarning(
                        sprintf($bearsamppLang->getValue(Lang::SERVICE_ALREADY_INSTALLED), $name),
                        $boxTitle
                    );
                }
 
                return true;
            }
        } elseif ($service->isRunning()) {
            self::logWarning(sprintf('%s service already installed and running', $name));
            if ($showWindow) {
                $bearsamppWinbinder->messageBoxWarning(
                    sprintf($bearsamppLang->getValue(Lang::SERVICE_ALREADY_INSTALLED), $name),
                    $boxTitle
                );
            }
 
            return true;
        } else {
            self::logError(sprintf('Port %s is used by an other application : %s', $port, $isPortInUse));
            if ($showWindow) {
                $bearsamppWinbinder->messageBoxError(
                    sprintf($bearsamppLang->getValue(Lang::PORT_NOT_USED_BY), $port, $isPortInUse),
                    $boxTitle
                );
            }
        }
 
        return false;
    }

References $bearsamppLang, $port, Lang\INSTALL_SERVICE_TITLE, isPortInUse(), logError(), logInfo(), logWarning(), Lang\PORT_NOT_USED_BY, Lang\SERVICE_ALREADY_INSTALLED, Lang\SERVICE_INSTALL_ERROR, Lang\SERVICE_INSTALLED, and Lang\STARTUP_SERVICE_SYNTAX_ERROR.

Referenced by ActionService\install(), BinApache\setEnable(), BinMailpit\setEnable(), BinMariadb\setEnable(), BinMemcached\setEnable(), BinMysql\setEnable(), BinPostgresql\setEnable(), and BinXlight\setEnable().

is32BitsOs()

is32BitsOs ( )

static

Checks if the operating system is 32-bit.

Returns

bool True if the OS is 32-bit, false otherwise.

Definition at line 2188 of file class.util.php.

    {
        $processor = self::getProcessorRegKey();
 
        return self::contains($processor, 'x86');
    }

References contains(), and getProcessorRegKey().

isAlphanumeric()

isAlphanumeric ( $string )

static

Checks if a string is alphanumeric.

Parameters

string

$string

The string to check.

Returns

bool Returns true if the string is alphanumeric, false otherwise.

Definition at line 2434 of file class.util.php.

    {
        return ctype_alnum($string);
    }

isLaunchStartup()

isLaunchStartup ( )

static

Checks if the application is set to launch at startup.

Returns

bool True if the startup link exists, false otherwise.

Definition at line 895 of file class.util.php.

    {
        return file_exists(self::getStartupLnkPath());
    }

Referenced by ActionReload\__construct(), and TplAppLaunchStartup\process().

isPortInUse()

isPortInUse ( $port )

static

Checks if a specific port is in use.

Parameters

int

$port

The port number to check

Returns

mixed False if the port is not in use, otherwise returns the process using the port

Definition at line 2387 of file class.util.php.

    {
        // Set localIP statically
        $localIP = '127.0.0.1';
 
        // Save current error reporting level
        $errorReporting = error_reporting();
 
        // Disable error reporting temporarily
        error_reporting(0);
 
        $connection = @fsockopen($localIP, $port);
 
        // Restore original error reporting level
        error_reporting($errorReporting);
 
        if (is_resource($connection)) {
            fclose($connection);
            $process = Batch::getProcessUsingPort($port);
 
            return $process != null ? $process : 'N/A';
        }
 
        return false;
    }

References $port, and Batch\getProcessUsingPort().

Referenced by BinApache\changePort(), BinMailpit\changePort(), BinMariadb\changePort(), BinMemcached\changePort(), BinMysql\changePort(), BinPostgresql\changePort(), BinXlight\changePort(), BinPostgresql\handleNonPostgresUsage(), installService(), and ActionStartup\prepareService().

isValidDomainName()

isValidDomainName ( $domainName )

static

Validates a domain name based on specific criteria.

Parameters

string

$domainName

The domain name to validate.

Returns

bool Returns true if the domain name is valid, false otherwise.

Definition at line 2420 of file class.util.php.

    {
        return preg_match('/^([a-z\d](-*[a-z\d])*)(\.([a-z\d](-*[a-z\d])*))*$/i', $domainName)
            && preg_match('/^.{1,253}$/', $domainName)
            && preg_match('/^[^\.]{1,63}(\.[^\.]{1,63})*$/', $domainName);
    }

Referenced by ActionAddVhost\validateInput(), and ActionEditVhost\validateInput().

isValidIp()

isValidIp ( $ip )

static

Validates an IP address.

Parameters

string

$ip

The IP address to validate.

Returns

bool Returns true if the IP address is valid, otherwise false.

Definition at line 606 of file class.util.php.

    {
        return filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_IPV4)
            || filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_IPV6);
    }

isValidPort()

isValidPort ( $port )

static

Validates a port number.

Parameters

int

$port

The port number to validate.

Returns

bool Returns true if the port number is valid and within the range of 1 to 65535, otherwise false.

Definition at line 619 of file class.util.php.

    {
        return is_numeric($port) && ($port > 0 && $port <= 65535);
    }

References $port.

Referenced by BinApache\changePort(), BinMailpit\changePort(), BinMariadb\changePort(), BinMemcached\changePort(), BinMysql\changePort(), BinPostgresql\changePort(), BinXlight\changePort(), BinApache\checkPort(), BinMailpit\checkPort(), BinMariadb\checkPort(), BinMemcached\checkPort(), BinMysql\checkPort(), BinPostgresql\checkPort(), and BinXlight\checkPort().

log()

log ( $data, $type, $file = null )

staticprivate

Logs a message to a specified file or default log file based on the log type. Implements buffering to reduce file I/O operations and improve performance.

Parameters

string	$data	The message to log.
string	$type	The type of log message: 'ERROR', 'WARNING', 'INFO', 'DEBUG', or 'TRACE'.
string | null	$file	The file path to write the log message to. If null, uses default log file based on type.

Definition at line 936 of file class.util.php.

    {
        global $bearsamppRoot, $bearsamppCore, $bearsamppConfig;
 
        // Safety check: if globals aren't initialized, use error_log as fallback
        if (!isset($bearsamppRoot) || !isset($bearsamppCore) || !isset($bearsamppConfig)) {
            error_log('[' . $type . '] ' . $data);
            return;
        }
 
        // Register shutdown handler on first log call
        if (!self::$shutdownRegistered) {
            register_shutdown_function([__CLASS__, 'flushLogBuffer']);
            self::$shutdownRegistered = true;
        }
 
        $file = $file == null ? ($type == self::LOG_ERROR ? $bearsamppRoot->getErrorLogFilePath() : $bearsamppRoot->getLogFilePath()) : $file;
        if (!$bearsamppRoot->isRoot()) {
            $file = $bearsamppRoot->getHomepageLogFilePath();
        }
 
        $verbose                         = array();
        $verbose[Config::VERBOSE_SIMPLE] = $type == self::LOG_ERROR || $type == self::LOG_WARNING;
        $verbose[Config::VERBOSE_REPORT] = $verbose[Config::VERBOSE_SIMPLE] || $type == self::LOG_INFO;
        $verbose[Config::VERBOSE_DEBUG]  = $verbose[Config::VERBOSE_REPORT] || $type == self::LOG_DEBUG;
        $verbose[Config::VERBOSE_TRACE]  = $verbose[Config::VERBOSE_DEBUG] || $type == self::LOG_TRACE;
 
        $writeLog = false;
        if ($bearsamppConfig->getLogsVerbose() == Config::VERBOSE_SIMPLE && $verbose[Config::VERBOSE_SIMPLE]) {
            $writeLog = true;
        } elseif ($bearsamppConfig->getLogsVerbose() == Config::VERBOSE_REPORT && $verbose[Config::VERBOSE_REPORT]) {
            $writeLog = true;
        } elseif ($bearsamppConfig->getLogsVerbose() == Config::VERBOSE_DEBUG && $verbose[Config::VERBOSE_DEBUG]) {
            $writeLog = true;
        } elseif ($bearsamppConfig->getLogsVerbose() == Config::VERBOSE_TRACE && $verbose[Config::VERBOSE_TRACE]) {
            $writeLog = true;
        }
 
        if ($writeLog) {
            // Add to buffer instead of writing immediately
            self::$logBuffer[] = [
                'file' => $file,
                'data' => $data,
                'type' => $type,
                'time' => time()
            ];
            self::$logStats['buffered']++;
 
            // Flush if buffer is full or if it's an error (errors should be written immediately)
            if (count(self::$logBuffer) >= self::$logBufferSize || $type == self::LOG_ERROR) {
                self::flushLogBuffer();
            }
        }
    }

References $bearsamppConfig, $bearsamppCore, $bearsamppRoot, flushLogBuffer(), Config\VERBOSE_DEBUG, Config\VERBOSE_REPORT, Config\VERBOSE_SIMPLE, and Config\VERBOSE_TRACE.

Referenced by logDebug(), logError(), logInfo(), logTrace(), and logWarning().

logDebug()

logDebug ( $data, $file = null )

static

Logs debug information. This function is a wrapper around the generic log function for debug-level messages.

Parameters

mixed	$data	The data to log.
string | null	$file	Optional. The file path to log to. If not provided, a default path is used.

Definition at line 1119 of file class.util.php.

    {
        self::log($data, self::LOG_DEBUG, $file);
    }

References log().

Referenced by ActionQuit\__construct(), Action\call(), changePath(), BinApache\changePort(), BinMailpit\changePort(), BinMariadb\changePort(), BinMemcached\changePort(), BinMysql\changePort(), BinPostgresql\changePort(), BinXlight\changePort(), QuickPick\checkDownloadId(), ActionQuit\checkForOrphanedProcesses(), BinApache\checkPort(), BinMailpit\checkPort(), BinMariadb\checkPort(), BinMemcached\checkPort(), BinMysql\checkPort(), BinPostgresql\checkPort(), BinXlight\checkPort(), Csrf\cleanupExpiredTokens(), ActionQuit\cleanupTemporaryFiles(), decryptFile(), Symlinks\deleteCurrentSymlinks(), QuickPick\fetchAndUnzipModule(), Csrf\generateToken(), getAppBinsRegKey(), getFilesToScan(), getHeaders(), getHttpHeaders(), getLatestVersion(), QuickPick\getModuleUrl(), QuickPick\getVersions(), BinPostgresql\handleNonPostgresUsage(), Win32Service\infos(), QuickPick\installModule(), Vbs\killProc(), QuickPick\logHeaders(), ActionQuit\performQuickCleanupVerification(), Action\process(), ActionQuit\processWindow(), QuickPick\rebuildQuickpickJson(), BinApache\refreshAlias(), BinApache\refreshConf(), BinApache\refreshVhosts(), QuickPick\regenerateMenuSafe(), ActionStartup\scanFolders(), BinApache\setEnable(), BinMailpit\setEnable(), BinMariadb\setEnable(), BinMemcached\setEnable(), BinMysql\setEnable(), BinNodejs\setEnable(), BinPhp\setEnable(), BinPostgresql\setEnable(), BinXlight\setEnable(), setFileScanCache(), setFileScanCacheDuration(), Win32Service\start(), BinApache\switchVersion(), BinMailpit\switchVersion(), BinMariadb\switchVersion(), BinMemcached\switchVersion(), BinMysql\switchVersion(), BinNodejs\switchVersion(), BinPhp\switchVersion(), BinPostgresql\switchVersion(), BinXlight\switchVersion(), Core\unzipFile(), AppPhpmyadmin\updateConfig(), AppPhppgadmin\updateConfig(), BinApache\updateConfig(), BinMailpit\updateConfig(), BinMariadb\updateConfig(), BinMemcached\updateConfig(), BinMysql\updateConfig(), BinNodejs\updateConfig(), BinPhp\updateConfig(), BinPostgresql\updateConfig(), BinXlight\updateConfig(), Module\updateConfig(), ToolGit\updateConfig(), QuickPick\updateModuleConfig(), Csrf\validateToken(), ActionQuit\verifyServicesStoppedAndCleanup(), ActionStartup\writeLog(), Batch\writeLog(), Nssm\writeLog(), Registry\writeLog(), Vbs\writeLog(), Win32Service\writeLog(), and WinBinder\writeLog().

logError()

logError ( $data, $file = null )

static

Logs error messages. This function is a wrapper around the generic log function for error-level messages.

Parameters

mixed	$data	The data to log.
string | null	$file	Optional. The file path to log to. If not provided, a default path is used.

Definition at line 1155 of file class.util.php.

    {
        self::log($data, self::LOG_ERROR, $file);
    }

References log().

Referenced by ActionLoading\__construct(), BinApache\changePort(), BinMailpit\changePort(), BinMariadb\changePort(), BinMemcached\changePort(), BinMysql\changePort(), BinPostgresql\changePort(), BinXlight\changePort(), QuickPick\checkDownloadId(), ActionQuit\checkForOrphanedProcesses(), BinApache\checkPort(), BinMailpit\checkPort(), BinMariadb\checkPort(), BinMemcached\checkPort(), BinMysql\checkPort(), BinPostgresql\checkPort(), BinXlight\checkPort(), ActionQuit\cleanupTemporaryFiles(), Vbs\createShortcut(), Module\createSymlink(), Symlinks\deleteCurrentSymlinks(), QuickPick\fetchAndUnzipModule(), generateSecureBytes(), generateSecureToken(), Csrf\generateToken(), getApiJson(), Core\getAppVersion(), getCacheIntegrityKey(), Core\getFileFromUrl(), getLatestVersion(), QuickPick\getModuleUrl(), QuickPick\getQuickpickJson(), QuickPick\getVersions(), Splash\init(), BinMariadb\initData(), QuickPick\installModule(), installService(), ActionCheckVersion\processWindow(), random(), AppPhpmyadmin\reload(), AppPhppgadmin\reload(), BinApache\reload(), BinMailpit\reload(), BinMariadb\reload(), BinMemcached\reload(), BinMysql\reload(), BinNodejs\reload(), BinPhp\reload(), BinPostgresql\reload(), BinXlight\reload(), ToolBruno\reload(), ToolComposer\reload(), ToolGhostscript\reload(), ToolGit\reload(), ToolNgrok\reload(), ToolPerl\reload(), ToolPowerShell\reload(), ToolPython\reload(), ToolRuby\reload(), removeService(), Win32Service\start(), startService(), TplAppReload\triggerReload(), Core\unzipFile(), AppPhpmyadmin\updateConfig(), AppPhppgadmin\updateConfig(), BinApache\updateConfig(), BinMailpit\updateConfig(), BinMariadb\updateConfig(), BinMemcached\updateConfig(), BinMysql\updateConfig(), BinNodejs\updateConfig(), BinPhp\updateConfig(), BinPostgresql\updateConfig(), BinXlight\updateConfig(), QuickPick\updateModuleConfig(), ActionQuit\verifyServicesStoppedAndCleanup(), ActionQuit\verifySymlinksRemoved(), and Nssm\writeLogError().

logInfo()

logInfo ( $data, $file = null )

static

Logs informational messages. This function is a wrapper around the generic log function for informational messages.

Parameters

mixed	$data	The data to log.
string | null	$file	Optional. The file path to log to. If not provided, a default path is used.

Definition at line 1131 of file class.util.php.

    {
        self::log($data, self::LOG_INFO, $file);
    }

References log().

Referenced by ActionQuit\__construct(), ActionQuit\checkForOrphanedProcesses(), ActionQuit\cleanupTemporaryFiles(), clearFileScanCache(), Batch\exitApp(), getFilesToScan(), installService(), ActionQuit\performQuickCleanupVerification(), ActionQuit\processWindow(), AppPhpmyadmin\reload(), AppPhppgadmin\reload(), Apps\reload(), BinApache\reload(), BinMailpit\reload(), BinMariadb\reload(), BinMemcached\reload(), BinMysql\reload(), BinNodejs\reload(), BinPhp\reload(), BinPostgresql\reload(), Bins\reload(), BinXlight\reload(), ToolBruno\reload(), ToolComposer\reload(), ToolGhostscript\reload(), ToolGit\reload(), ToolNgrok\reload(), ToolPerl\reload(), ToolPowerShell\reload(), ToolPython\reload(), ToolRuby\reload(), removeService(), BinApache\setEnable(), BinMailpit\setEnable(), BinMariadb\setEnable(), BinMemcached\setEnable(), BinMysql\setEnable(), BinNodejs\setEnable(), BinPhp\setEnable(), BinPostgresql\setEnable(), BinXlight\setEnable(), Win32Service\start(), Apps\update(), Bins\update(), Tools\update(), QuickPick\updateModuleConfig(), ActionQuit\verifyServicesStoppedAndCleanup(), ActionQuit\verifySymlinksRemoved(), and Nssm\writeLogInfo().

logInitClass()

logInitClass ( $classInstance )

static

Logs the initialization of a class instance.

Parameters

object

$classInstance

The instance of the class to log.

Definition at line 1165 of file class.util.php.

    {
        self::logTrace('Init ' . get_class($classInstance));
    }

References logTrace().

Referenced by AppPhpmyadmin\__construct(), AppPhppgadmin\__construct(), BinApache\__construct(), BinMailpit\__construct(), BinMariadb\__construct(), BinMemcached\__construct(), BinMysql\__construct(), BinNodejs\__construct(), BinPhp\__construct(), BinPostgresql\__construct(), Bins\__construct(), BinXlight\__construct(), Homepage\__construct(), Nssm\__construct(), Registry\__construct(), Splash\__construct(), ToolBruno\__construct(), ToolComposer\__construct(), ToolGhostscript\__construct(), ToolGit\__construct(), ToolNgrok\__construct(), ToolPerl\__construct(), ToolPowerShell\__construct(), ToolPython\__construct(), ToolRuby\__construct(), Win32Service\__construct(), and WinBinder\__construct().

logReloadClass()

logReloadClass ( $classInstance )

static

Logs the reloading of a class instance.

Parameters

object

$classInstance

The instance of the class to log.

Definition at line 1175 of file class.util.php.

    {
        self::logTrace('Reload ' . get_class($classInstance));
    }

References logTrace().

Referenced by AppPhpmyadmin\reload(), AppPhppgadmin\reload(), BinApache\reload(), BinMailpit\reload(), BinMariadb\reload(), BinMemcached\reload(), BinMysql\reload(), BinNodejs\reload(), BinPhp\reload(), BinPostgresql\reload(), BinXlight\reload(), ToolBruno\reload(), ToolComposer\reload(), ToolGhostscript\reload(), ToolGit\reload(), ToolNgrok\reload(), ToolPerl\reload(), ToolPowerShell\reload(), ToolPython\reload(), and ToolRuby\reload().

logSeparator()

logSeparator ( )

static

Appends a separator line to multiple log files if they do not already end with it. This function ensures that each log file ends with a clear separator for better readability.

@global object $bearsamppRoot An object that provides paths to various log files.

Definition at line 1073 of file class.util.php.

    {
        global $bearsamppRoot;
 
        $logs = array(
            $bearsamppRoot->getLogFilePath(),
            $bearsamppRoot->getErrorLogFilePath(),
            $bearsamppRoot->getServicesLogFilePath(),
            $bearsamppRoot->getRegistryLogFilePath(),
            $bearsamppRoot->getStartupLogFilePath(),
            $bearsamppRoot->getBatchLogFilePath(),
            $bearsamppRoot->getVbsLogFilePath(),
            $bearsamppRoot->getWinbinderLogFilePath(),
        );
 
        $separator = '========================================================================================' . PHP_EOL;
        foreach ($logs as $log) {
            if (!file_exists($log)) {
                continue; // Skip to the next iteration if the file does not exist
            }
            $logContent = @file_get_contents($log);
            if ($logContent !== false && !self::endWith($logContent, $separator)) {
                file_put_contents($log, $separator, FILE_APPEND);
            }
        }
    }

References $bearsamppRoot.

Referenced by Root\register().

logTrace()

logTrace ( $data, $file = null )

static

Logs trace information. This function is a wrapper around the generic log function for trace-level messages.

Parameters

mixed	$data	The data to log.
string | null	$file	Optional. The file path to log to. If not provided, a default path is used.

Definition at line 1107 of file class.util.php.

    {
        self::log($data, self::LOG_TRACE, $file);
    }

References log().

Referenced by ActionExec\__construct(), ActionLoading\__construct(), ActionManualRestart\__construct(), ActionRebuildini\__construct(), Win32Service\callWin32Service(), BinMysql\changeRootPassword(), ActionLoading\checkAllServicesStarted(), ActionStartup\checkApacheServiceWithTimeout(), ActionStartup\checkMySQLServiceWithTimeout(), BinMysql\checkPort(), BinMysql\checkRootPassword(), Win32Service\create(), OpenSsl\createCrt(), Win32Service\delete(), Win32Service\fastServiceCheck(), getCurlHttpHeaders(), Win32Service\infos(), BinMariadb\initData(), BinMysql\initData(), ActionStartup\installServices(), ActionStartup\installServicesSequential(), Win32Service\isInstalled(), Win32Service\isPaused(), Win32Service\isPending(), Win32Service\isRunning(), Win32Service\isStopped(), logInitClass(), logReloadClass(), ActionStartup\prepareService(), ActionLoading\processLoading(), ActionStartup\processWindow(), ActionSwitchVersion\processWindow(), BinMailpit\rebuildConf(), BinApache\refreshAlias(), BinApache\refreshConf(), BinApache\refreshVhosts(), Config\replaceAll(), replaceInFile(), ActionStartup\rotationLogs(), ActionStartup\scanFolders(), BinPhp\setVersion(), startLoading(), Win32Service\status(), Win32Service\stop(), ActionQuit\terminatePhpProcesses(), TplAppReload\triggerReload(), Core\unzipFile(), BinPhp\updateConfig(), and ActionSwitchVersion\updateConfigVersion().

logWarning()

logWarning ( $data, $file = null )

static

Logs warning messages. This function is a wrapper around the generic log function for warning-level messages.

Parameters

mixed	$data	The data to log.
string | null	$file	Optional. The file path to log to. If not provided, a default path is used.

Definition at line 1143 of file class.util.php.

    {
        self::log($data, self::LOG_WARNING, $file);
    }

References log().

Referenced by ActionQuit\checkForOrphanedProcesses(), ActionQuit\cleanupTemporaryFiles(), getFileScanCache(), getNssmEnvPaths(), Batch\initializeMariadb(), Batch\initializeMysql(), Batch\initializePostgresql(), installService(), ActionQuit\performQuickCleanupVerification(), ActionQuit\processWindow(), QuickPick\regenerateMenuSafe(), ToolGit\reload(), removeService(), sanitizePath(), sanitizePID(), sanitizePort(), sanitizeServiceName(), Csrf\validateRequest(), Csrf\validateToken(), ActionQuit\verifyServicesStoppedAndCleanup(), and ActionQuit\verifySymlinksRemoved().

openFileContent()

openFileContent ( $caption, $content )

static

Opens a file with a given caption and content in the default text editor. The file is created in a temporary directory with a unique name.

Parameters

string	$caption	The filename to use when saving the content.
string	$content	The content to write to the file.

@global object $bearsamppRoot Global object to access temporary path. @global object $bearsamppConfig Global configuration object. @global object $bearsamppWinbinder Global object to execute external programs.

Definition at line 2713 of file class.util.php.

    {
        global $bearsamppRoot, $bearsamppConfig, $bearsamppWinbinder;
 
        $folderPath = $bearsamppRoot->getTmpPath() . '/openFileContent-' . self::random();
        if (!is_dir($folderPath)) {
            mkdir($folderPath, 0777, true);
        }
 
        $filepath = self::formatWindowsPath($folderPath . '/' . $caption);
        file_put_contents($filepath, $content);
 
        $bearsamppWinbinder->exec($bearsamppConfig->getNotepad(), '"' . $filepath . '"');
    }

References $bearsamppConfig, $bearsamppRoot, formatWindowsPath(), and random().

Referenced by ActionDebugBase\__construct().

random()

random ( $length = 32, $withNumeric = true )

static

Generates a cryptographically secure random string of specified length and character set.

Parameters

int	$length	The length of the random string to generate.
bool	$withNumeric	Whether to include numeric characters in the random string.

Returns

string Returns the generated random string.

Exceptions

Exception

If an appropriate source of randomness cannot be found.

Definition at line 412 of file class.util.php.

    {
        $characters = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
        if ($withNumeric) {
            $characters .= '0123456789';
        }
 
        $charactersLength = strlen($characters);
        $randomString = '';
 
        try {
            for ($i = 0; $i < $length; $i++) {
                // Use cryptographically secure random_int() instead of rand()
                $randomIndex = random_int(0, $charactersLength - 1);
                $randomString .= $characters[$randomIndex];
            }
        } catch (Exception $e) {
            self::logError('Failed to generate cryptographically secure random string: ' . $e->getMessage());
            throw $e;
        }
 
        return $randomString;
    }

References logError().

Referenced by OpenSsl\createCrt(), Batch\getTmpFile(), and openFileContent().

removeService()

removeService ( $service, $name )

static

Removes a service if it is installed.

Parameters

Win32Service	$service	The service object to be removed.
string	$name	The name of the service.

Returns

bool Returns true if the service is successfully removed, false otherwise.

Definition at line 2532 of file class.util.php.

    {
        if (!($service instanceof Win32Service)) {
            self::logError('$service not an instance of Win32Service');
 
            return false;
        }
 
        if ($service->isInstalled()) {
            if ($service->delete()) {
                self::logInfo(sprintf('%s service successfully removed', $name));
 
                return true;
            } else {
                self::logError(sprintf('Error during the uninstallation of %s service', $name));
 
                return false;
            }
        } else {
            self::logWarning(sprintf('%s service does not exist', $name));
        }
 
        return true;
    }

References logError(), logInfo(), and logWarning().

Referenced by ActionService\remove(), BinApache\setEnable(), BinMailpit\setEnable(), BinMariadb\setEnable(), BinMemcached\setEnable(), BinMysql\setEnable(), BinPostgresql\setEnable(), and BinXlight\setEnable().

replaceDefine()

replaceDefine ( $path, $var, $value )

static

Replaces a defined constant in a file with a new value.

Parameters

string	$path	The file path where the constant is defined.
string	$var	The name of the constant.
mixed	$value	The new value for the constant.

Definition at line 631 of file class.util.php.

    {
        self::replaceInFile($path, array(
            '/^define\‍((.*?)' . $var . '(.*?),/' => 'define(\'' . $var . '\', ' . (is_int($value) ? $value : '\'' . $value . '\'') . ');'
        ));
    }

References replaceInFile().

replaceInFile()

replaceInFile ( $path, $replaceList )

static

Performs replacements in a file based on a list of regular expression patterns.

Parameters

string	$path	The path to the file where replacements are to be made.
array	$replaceList	An associative array where keys are regex patterns and values are replacement strings.

Definition at line 644 of file class.util.php.

    {
        if (file_exists($path)) {
            $lines = file($path);
            $fp    = fopen($path, 'w');
            foreach ($lines as $nb => $line) {
                $replaceDone = false;
                foreach ($replaceList as $regex => $replace) {
                    if (preg_match($regex, $line, $matches)) {
                        $countParams = preg_match_all('/{{(\d+)}}/', $replace, $paramsMatches);
                        if ($countParams > 0 && $countParams <= count($matches)) {
                            foreach ($paramsMatches[1] as $paramsMatch) {
                                $replace = str_replace('{{' . $paramsMatch . '}}', $matches[$paramsMatch], $replace);
                            }
                        }
                        self::logTrace('Replace in file ' . $path . ' :');
                        self::logTrace('## line_num: ' . trim($nb));
                        self::logTrace('## old: ' . trim($line));
                        self::logTrace('## new: ' . trim($replace));
                        fwrite($fp, $replace . PHP_EOL);
 
                        $replaceDone = true;
                        break;
                    }
                }
                if (!$replaceDone) {
                    fwrite($fp, $line);
                }
            }
            fclose($fp);
        }
    }

References logTrace().

Referenced by BinPostgresql\rebuildConf(), Homepage\refreshCommonsJsContent(), replaceDefine(), ToolGit\setScanStartup(), AppPhpmyadmin\updateConfig(), AppPhppgadmin\updateConfig(), BinApache\updateConfig(), BinMariadb\updateConfig(), BinMysql\updateConfig(), BinPhp\updateConfig(), and BinPostgresql\updateConfig().

sanitizeOutput()

sanitizeOutput ( $output )

static

Sanitizes output for display to prevent XSS attacks. Escapes HTML special characters.

Parameters

string

$output

The output to sanitize

Returns

string Returns the sanitized output safe for HTML display

Definition at line 329 of file class.util.php.

    {
        if (!is_string($output)) {
            return '';
        }
 
        // Remove null bytes
        $output = str_replace("\0", '', $output);
 
        // Escape HTML special characters
        return htmlspecialchars($output, ENT_QUOTES | ENT_HTML5, 'UTF-8');
    }

sanitizePath()

sanitizePath ( $path )

static

Sanitizes a file path by removing null bytes and checking for path traversal attempts. This is a basic sanitization - paths should still be validated before use.

Parameters

string

$path

The path to sanitize

Returns

string|false Returns the sanitized path, or false if dangerous patterns detected

Definition at line 299 of file class.util.php.

    {
        if (!is_string($path) || empty($path)) {
            return false;
        }
 
        // Remove null bytes
        $sanitized = str_replace("\0", '', $path);
 
        // Check for path traversal attempts (but allow environment variables)
        $pathWithoutEnvVars = preg_replace('/%[^%]+%/', '', $sanitized);
        if (strpos($pathWithoutEnvVars, '..') !== false) {
            self::logWarning('Path traversal attempt detected: ' . $path);
            return false;
        }
 
        // Remove dangerous characters that could be used for command injection
        // But preserve valid path characters including : for drive letters and ; for PATH
        $sanitized = preg_replace('/[<>"|?*\x00-\x1F]/', '', $sanitized);
 
        return $sanitized;
    }

References logWarning().

sanitizePID()

sanitizePID ( $pid )

static

Sanitizes a process ID (PID) by removing all non-numeric characters. This prevents command injection through PID parameters.

Parameters

mixed

$pid

The PID to sanitize

Returns

int|false Returns the sanitized PID as integer, or false if invalid

Definition at line 213 of file class.util.php.

    {
        // Remove all non-numeric characters
        $sanitized = preg_replace('/[^0-9]/', '', (string)$pid);
 
        if (empty($sanitized)) {
            self::logWarning('Invalid PID provided: ' . var_export($pid, true));
            return false;
        }
 
        $pidInt = (int)$sanitized;
 
        // Validate range (PIDs are positive integers)
        if ($pidInt <= 0 || $pidInt > 2147483647) {
            self::logWarning('PID out of valid range: ' . $pidInt);
            return false;
        }
 
        return $pidInt;
    }

References logWarning().

Referenced by Batch\findExeByPid().

sanitizePort()

sanitizePort ( $port )

static

Sanitizes a port number by ensuring it's a valid integer in the correct range. This prevents command injection through port parameters.

Parameters

mixed

$port

The port to sanitize

Returns

int|false Returns the sanitized port as integer, or false if invalid

Definition at line 241 of file class.util.php.

    {
        $portStr = trim((string)$port);
 
        // Require strictly digits to avoid silently changing meaning
        if ($portStr === '' || !preg_match('/^\d+$/', $portStr)) {
            self::logWarning('Invalid port provided: ' . var_export($port, true));
            return false;
        }
 
        $portInt = (int)$portStr;
 
        // Validate range (1-65535)
        if ($portInt < 1 || $portInt > 65535) {
            self::logWarning('Port out of valid range: ' . $portInt);
            return false;
        }
 
        return $portInt;
    }

References $port, and logWarning().

Referenced by Batch\getProcessUsingPort().

sanitizeServiceName()

sanitizeServiceName ( $serviceName )

static

Sanitizes a service name by removing dangerous characters. Allows only alphanumeric characters, underscores, and hyphens.

Parameters

string

$serviceName

The service name to sanitize

Returns

string|false Returns the sanitized service name, or false if invalid

Definition at line 269 of file class.util.php.

    {
        if (!is_string($serviceName) || empty($serviceName)) {
            self::logWarning('Invalid service name: not a string or empty');
            return false;
        }
 
        // Remove all characters except alphanumeric, underscore, and hyphen
        $sanitized = preg_replace('/[^a-zA-Z0-9_-]/', '', $serviceName);
 
        if (empty($sanitized)) {
            self::logWarning('Service name became empty after sanitization: ' . $serviceName);
            return false;
        }
 
        // Limit length to 256 characters (Windows service name limit)
        if (strlen($sanitized) > 256) {
            $sanitized = substr($sanitized, 0, 256);
        }
 
        return $sanitized;
    }

References logWarning().

Referenced by Batch\setServiceDescription(), Batch\setServiceDisplayName(), and Batch\setServiceStartType().

setAppBinsRegKey()

setAppBinsRegKey ( $value )

static

Retrieves or generates the application binaries registry key.

Parameters

bool

$fromRegistry

Determines whether to retrieve the key from the registry or generate it.

Returns

string Returns the application binaries registry key.

Definition at line 782 of file class.util.php.

    {
        global $bearsamppRegistry;
 
        return $bearsamppRegistry->setStringValue(
            Registry::HKEY_LOCAL_MACHINE,
            Registry::ENV_KEY,
            Registry::APP_BINS_REG_ENTRY,
            $value
        );
    }

References Registry\APP_BINS_REG_ENTRY, Registry\ENV_KEY, and Registry\HKEY_LOCAL_MACHINE.

Referenced by ActionStartup\checkBinsRegKey(), and ActionSwitchVersion\processWindow().

setAppPathRegKey()

setAppPathRegKey ( $value )

static

Sets the application path in the registry.

Parameters

string

$value

The new value for the application path.

Returns

bool True on success, false on failure.

Definition at line 817 of file class.util.php.

    {
        global $bearsamppRegistry;
 
        return $bearsamppRegistry->setStringValue(
            Registry::HKEY_LOCAL_MACHINE,
            Registry::ENV_KEY,
            Registry::APP_PATH_REG_ENTRY,
            $value
        );
    }

References Registry\APP_PATH_REG_ENTRY, Registry\ENV_KEY, and Registry\HKEY_LOCAL_MACHINE.

Referenced by ActionStartup\checkPathRegKey().

setFileScanCache()

setFileScanCache ( $cacheKey, $data )

staticprivate

Stores file scan results in cache with integrity protection.

Parameters

string	$cacheKey	The cache key to store under.
array	$data	The scan results to cache.

Returns

void

Definition at line 1596 of file class.util.php.

    {
        global $bearsamppRoot;
 
        // Generate HMAC for integrity verification
        $hmac = self::generateCacheHMAC($data, $cacheKey);
 
        $cacheData = [
            'timestamp' => time(),
            'data' => $data,
            'hmac' => $hmac
        ];
 
        // Store in memory cache
        if (self::$fileScanCache === null) {
            self::$fileScanCache = [];
        }
        self::$fileScanCache[$cacheKey] = $cacheData;
 
        // Store in file cache
        if (isset($bearsamppRoot)) {
            $cacheFile = $bearsamppRoot->getTmpPath() . '/filescan_cache_' . $cacheKey . '.dat';
            @file_put_contents($cacheFile, serialize($cacheData), LOCK_EX);
            self::logDebug('File scan results cached to: ' . $cacheFile);
        }
    }

References $bearsamppRoot, generateCacheHMAC(), and logDebug().

Referenced by getFilesToScan().

setFileScanCacheDuration()

setFileScanCacheDuration ( $seconds )

static

Sets the file scan cache duration.

Parameters

int

$seconds

Cache duration in seconds (default: 3600 = 1 hour).

Returns

void

Definition at line 1755 of file class.util.php.

    {
        if ($seconds > 0 && $seconds <= 86400) { // Max 24 hours
            self::$fileScanCacheDuration = $seconds;
            self::logDebug('File scan cache duration set to ' . $seconds . ' seconds');
        }
    }

References logDebug().

setLogBufferSize()

setLogBufferSize ( $size )

static

Sets the log buffer size. Allows dynamic adjustment of buffer size based on application needs.

Parameters

int

$size

The new buffer size

Returns

void

Definition at line 1050 of file class.util.php.

    {
        if ($size > 0 && $size <= 1000) {
            self::$logBufferSize = $size;
        }
    }

setSysPathRegKey()

setSysPathRegKey ( $value )

static

Sets the system path in the registry.

Parameters

string

$value

The new value for the system path.

Returns

bool True on success, false on failure.

Definition at line 852 of file class.util.php.

    {
        global $bearsamppRegistry;
 
        return $bearsamppRegistry->setExpandStringValue(
            Registry::HKEY_LOCAL_MACHINE,
            Registry::ENV_KEY,
            Registry::SYSPATH_REG_ENTRY,
            $value
        );
    }

References Registry\ENV_KEY, Registry\HKEY_LOCAL_MACHINE, and Registry\SYSPATH_REG_ENTRY.

Referenced by ActionStartup\checkSystemPathRegKey().

setupCurlHeaderWithToken()

setupCurlHeaderWithToken ( )

static

Sets up a cURL header array using a decrypted GitHub Personal Access Token.

Returns

array The header array for cURL with authorization and other necessary details.

Definition at line 2788 of file class.util.php.

    {
        // Usage
        global $bearsamppCore, $bearsamppConfig;
        $Token = self::decryptFile();
 
        return [
            'Accept: application/vnd.github+json',
            'Authorization: Token ' . $Token,
            'User-Agent: ' . APP_GITHUB_USERAGENT,
            'X-GitHub-Api-Version: 2022-11-28'
        ];
    }

References $bearsamppConfig, $bearsamppCore, APP_GITHUB_USERAGENT, and decryptFile().

Referenced by getApiJson().

startLoading()

startLoading ( )

static

Initiates a loading process using external components.

Definition at line 1399 of file class.util.php.

    {
        global $bearsamppCore, $bearsamppWinbinder;
 
        self::logTrace('startLoading() called');
        self::logTrace('PHP executable: ' . $bearsamppCore->getPhpExe());
        self::logTrace('Root file: ' . Core::isRoot_FILE);
        self::logTrace('Action: ' . Action::LOADING);
 
        $command = Core::isRoot_FILE . ' ' . Action::LOADING;
        self::logTrace('Executing command: ' . $bearsamppCore->getPhpExe() . ' ' . $command);
 
        $result = $bearsamppWinbinder->exec($bearsamppCore->getPhpExe(), $command);
        self::logTrace('exec() returned: ' . var_export($result, true));
 
        self::logTrace('startLoading() completed');
    }

References $bearsamppCore, $result, Core\isRoot_FILE, Action\LOADING, and logTrace().

Referenced by ActionCheckVersion\__construct(), ActionEnable\__construct(), ActionLaunchStartup\__construct(), ActionManualRestart\__construct(), ActionRefreshRepos\__construct(), ActionReload\__construct(), ActionService\__construct(), ActionSwitchOnline\__construct(), and ActionStartup\processWindow().

startService()

startService ( $bin, $syntaxCheckCmd, $showWindow = false )

static

Attempts to start a service and performs a syntax check if required.

Parameters

object	$bin	An object containing service details.
string	$syntaxCheckCmd	Command to check syntax errors.
bool	$showWindow	Whether to show error messages in a window.

Returns

bool Returns true if the service starts successfully, false otherwise.

Definition at line 2566 of file class.util.php.

    {
        global $bearsamppLang, $bearsamppWinbinder;
 
        if (method_exists($bin, 'initData')) {
            $bin->initData();
        }
 
        $name     = $bin->getName();
        $service  = $bin->getService();
        $boxTitle = sprintf($bearsamppLang->getValue(Lang::START_SERVICE_TITLE), $name);
 
        if (!$service->start()) {
            $serviceError    = sprintf($bearsamppLang->getValue(Lang::START_SERVICE_ERROR), $name);
            $serviceErrorLog = sprintf('Error while starting the %s service', $name);
            if (!empty($syntaxCheckCmd)) {
                $cmdSyntaxCheck = $bin->getCmdLineOutput($syntaxCheckCmd);
                if (!$cmdSyntaxCheck['syntaxOk']) {
                    $serviceError    .= PHP_EOL . sprintf($bearsamppLang->getValue(Lang::STARTUP_SERVICE_SYNTAX_ERROR), $cmdSyntaxCheck['content']);
                    $serviceErrorLog .= sprintf(' (conf errors detected : %s)', $cmdSyntaxCheck['content']);
                }
            }
            self::logError($serviceErrorLog);
            if ($showWindow) {
                $bearsamppWinbinder->messageBoxError($serviceError, $boxTitle);
            }
 
            return false;
        }
 
        return true;
    }

References $bearsamppLang, logError(), Lang\START_SERVICE_ERROR, Lang\START_SERVICE_TITLE, and Lang\STARTUP_SERVICE_SYNTAX_ERROR.

Referenced by BinPhp\setEnable(), ActionService\start(), and ServiceHelper\startService().

startWith()

startWith ( $string, $search )

static

Checks if a string starts with a specified substring.

Parameters

string	$string	The string to check.
string	$search	The substring to look for at the start of the string.

Returns

bool Returns true if the string starts with the search substring, otherwise false.

Definition at line 372 of file class.util.php.

    {
        // Return false if string is NULL or empty
        if ($string === null || $string === '') {
            return false;
        }
 
        $length = strlen($search);
 
        return (substr($string, 0, $length) === $search);
    }

Referenced by BinApache\checkPort(), BinMariadb\checkPort(), BinMysql\checkPort(), BinApache\getModulesFromConf(), BinApache\getModulesFromFolder(), BinApache\getOfflineContent(), BinApache\getOnlineContent(), Batch\getOsInfo(), Batch\getPearVersion(), Batch\getProcessUsingPort(), Registry\getValue(), BinApache\getVhostsUrl(), Win32Ps\killBins(), Autoloader\resolveClassPath(), and Registry\setValue().

stopLoading()

stopLoading ( )

static

Stops a previously started loading process and cleans up related resources.

Definition at line 1420 of file class.util.php.

    {
        global $bearsamppCore;
        if (file_exists($bearsamppCore->getLoadingPid())) {
            $pids = file($bearsamppCore->getLoadingPid());
            foreach ($pids as $pid) {
                Win32Ps::kill($pid);
            }
            @unlink($bearsamppCore->getLoadingPid());
        }
 
        // Clean up status file
        self::clearLoadingText();
    }

References $bearsamppCore, clearLoadingText(), and Win32Ps\kill().

Referenced by ActionManualRestart\__construct(), ActionService\__construct(), ActionCheckVersion\showVersionOkMessageBox(), and ActionCheckVersion\showVersionUpdateWindow().

updateLoadingText()

updateLoadingText ( $text )

static

Updates the loading screen text (if loading screen is active) This allows dynamic updates to show which service is being processed

Parameters

string

$text

The text to display on the loading screen

Definition at line 1441 of file class.util.php.

    {
        global $bearsamppCore;
 
        $statusFile = $bearsamppCore->getTmpPath() . '/loading_status.txt';
        file_put_contents($statusFile, json_encode(['text' => $text]));
    }

References $bearsamppCore.

Referenced by ActionService\restart(), ActionService\start(), and ActionService\stop().

utf8ToCp1252()

utf8ToCp1252 ( $data )

static

Converts UTF-8 encoded data to Windows-1252 encoding.

Parameters

string

$data

The UTF-8 encoded data.

Returns

string Returns the data encoded in Windows-1252.

Definition at line 1379 of file class.util.php.

    {
        return iconv('UTF-8', 'WINDOWS-1252//IGNORE', $data);
    }

Referenced by ActionReload\__construct().

verifyCacheIntegrity()

verifyCacheIntegrity ( $fileContents, $cacheKey )

staticprivate

Verifies cache file integrity using HMAC.

Parameters

string	$fileContents	The serialized cache file contents
string	$cacheKey	The cache key

Returns

bool True if integrity check passes, false otherwise

Definition at line 1691 of file class.util.php.

    {
        $cacheData = @unserialize($fileContents);
 
        if ($cacheData === false || !isset($cacheData['hmac']) || !isset($cacheData['data'])) {
            return false;
        }
 
        $expectedHmac = self::generateCacheHMAC($cacheData['data'], $cacheKey);
 
        // Use hash_equals to prevent timing attacks
        return hash_equals($expectedHmac, $cacheData['hmac']);
    }

References generateCacheHMAC().

Field Documentation

$cacheIntegrityKey

$cacheIntegrityKey = null

staticprivate

Definition at line 100 of file class.util.php.

$fileScanCache

$fileScanCache = null

staticprivate

Definition at line 77 of file class.util.php.

$fileScanCacheDuration

$fileScanCacheDuration = 3600

staticprivate

Definition at line 83 of file class.util.php.

$fileScanStats

$fileScanStats

staticprivate

Initial value:

                              = [
    'hits' => 0,
    'misses' => 0,
    'invalidations' => 0
]

Definition at line 89 of file class.util.php.

$logBuffer

$logBuffer = []

staticprivate

Definition at line 49 of file class.util.php.

$logBufferSize

$logBufferSize = 50

staticprivate

Definition at line 55 of file class.util.php.

$logStats

$logStats

staticprivate

Initial value:

                         = [
    'buffered' => 0,
    'flushed' => 0,
    'writes' => 0
]

Definition at line 67 of file class.util.php.

$pathFormatCache

$pathFormatCache = []

staticprivate

Definition at line 106 of file class.util.php.

$pathFormatCacheMaxSize

$pathFormatCacheMaxSize = 500

staticprivate

Definition at line 112 of file class.util.php.

$pathFormatStats

$pathFormatStats

staticprivate

Initial value:

                                = [
    'unix_hits' => 0,
    'unix_misses' => 0,
    'windows_hits' => 0,
    'windows_misses' => 0
]

Definition at line 118 of file class.util.php.

$shutdownRegistered

$shutdownRegistered = false

staticprivate

Definition at line 61 of file class.util.php.

LOG_DEBUG

const LOG_DEBUG = 'DEBUG'

Definition at line 42 of file class.util.php.

LOG_ERROR

const LOG_ERROR = 'ERROR'

This code snippet defines constants for logging levels.

Definition at line 39 of file class.util.php.

LOG_INFO

const LOG_INFO = 'INFO'

Definition at line 41 of file class.util.php.

LOG_TRACE

const LOG_TRACE = 'TRACE'

Definition at line 43 of file class.util.php.

LOG_WARNING

const LOG_WARNING = 'WARNING'

Definition at line 40 of file class.util.php.

---

The documentation for this class was generated from the following file:

• E:/Bearsampp-development/sandbox/core/classes/class.util.php