class.util.php

Go to the documentation of this file.

<?php
/*
 *
 *  * Copyright (c) 2022-2025 Bearsampp
 *  * License: GNU General Public License version 3 or later; see LICENSE.txt
 *  * Website: https://bearsampp.com
 *  * Github: https://github.com/Bearsampp
 *
 */

class Util
{
    const LOG_ERROR = 'ERROR';
    const LOG_WARNING = 'WARNING';
    const LOG_INFO = 'INFO';
    const LOG_DEBUG = 'DEBUG';
    const LOG_TRACE = 'TRACE';

    private static $logBuffer = [];

    private static $logBufferSize = 50;

    private static $shutdownRegistered = false;

    private static $logStats = [
        'buffered' => 0,
        'flushed' => 0,
        'writes' => 0
    ];

    private static $fileScanCache = null;

    private static $fileScanCacheDuration = 3600;

    private static $fileScanStats = [
        'hits' => 0,
        'misses' => 0,
        'invalidations' => 0
    ];

    private static $cacheIntegrityKey = null;

    private static $pathFormatCache = [];

    private static $pathFormatCacheMaxSize = 500;

    private static $pathFormatStats = [
        'unix_hits' => 0,
        'unix_misses' => 0,
        'windows_hits' => 0,
        'windows_misses' => 0
    ];

    public static function cleanArgv($name, $type = 'text')
    {
        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;
    }

    public static function cleanGetVar($name, $type = 'text')
    {
        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;
    }

    public static function cleanPostVar($name, $type = 'text')
    {
        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;
    }

    public static function sanitizePID($pid)
    {
        // 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;
    }

    public static function sanitizePort($port)
    {
        $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;
    }

    public static function sanitizeServiceName($serviceName)
    {
        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;
    }

    public static function sanitizePath($path)
    {
        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;
    }

    public static function sanitizeOutput($output)
    {
        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');
    }

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

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

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

    public static function random($length = 32, $withNumeric = true)
    {
        $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;
    }

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

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

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

    public static function clearFolder($path, $exclude = array())
    {
        $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;
    }

    public static function deleteFolder($path)
    {
        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);
        }
    }

    private static function findFile($startPath, $findFile)
    {
        $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;
    }

    public static function isValidIp($ip)
    {
        return filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_IPV4)
            || filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_IPV6);
    }

    public static function isValidPort($port)
    {
        return is_numeric($port) && ($port > 0 && $port <= 65535);
    }

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

    public static function replaceInFile($path, $replaceList)
    {
        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);
        }
    }

    public static function getVersionList($path)
    {
        $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;
    }

    public static function getMicrotime()
    {
        list($usec, $sec) = explode(' ', microtime());
 
        return ((float)$usec + (float)$sec);
    }
 
    public static function getAppBinsRegKey($fromRegistry = true)
    {
        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;
    }

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

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

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

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

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

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

    public static function getStartupLnkPath()
    {
        return Vbs::getStartupPath(APP_TITLE . '.lnk');
    }

    public static function isLaunchStartup()
    {
        return file_exists(self::getStartupLnkPath());
    }

    public static function enableLaunchStartup()
    {
        return Vbs::createShortcut(self::getStartupLnkPath());
    }

    public static function disableLaunchStartup()
    {
        $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;
    }

    private static function log($data, $type, $file = null)
    {
        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();
            }
        }
    }

    public static function flushLogBuffer()
    {
        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 = [];
    }

    public static function getLogStats()
    {
        return self::$logStats;
    }

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

    public static function getLogBufferSize()
    {
        return self::$logBufferSize;
    }

    public static function logSeparator()
    {
        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);
            }
        }
    }

    public static function logTrace($data, $file = null)
    {
        self::log($data, self::LOG_TRACE, $file);
    }

    public static function logDebug($data, $file = null)
    {
        self::log($data, self::LOG_DEBUG, $file);
    }

    public static function logInfo($data, $file = null)
    {
        self::log($data, self::LOG_INFO, $file);
    }

    public static function logWarning($data, $file = null)
    {
        self::log($data, self::LOG_WARNING, $file);
    }

    public static function logError($data, $file = null)
    {
        self::log($data, self::LOG_ERROR, $file);
    }

    public static function logInitClass($classInstance)
    {
        self::logTrace('Init ' . get_class($classInstance));
    }

    public static function logReloadClass($classInstance)
    {
        self::logTrace('Reload ' . get_class($classInstance));
    }

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

    public static function findRepos($initPath, $startPath, $checkFile, $maxDepth = 1)
    {
        $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;
    }

    public static function formatWindowsPath($path)
    {
        // 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;
    }

    public static function formatUnixPath($path)
    {
        // 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;
    }

    public static function getPathFormatStats()
    {
        return self::$pathFormatStats;
    }

    public static function clearPathFormatCache()
    {
        self::$pathFormatCache = [];
        self::$pathFormatStats = [
            'unix_hits' => 0,
            'unix_misses' => 0,
            'windows_hits' => 0,
            'windows_misses' => 0
        ];
    }

    public static function getPathFormatCacheSize()
    {
        return count(self::$pathFormatCache);
    }

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

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

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

    public static function startLoading()
    {
        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');
    }

    public static function stopLoading()
    {
        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();
    }

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

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

    public static function getFilesToScan($path = null, $useCache = true, $forceRefresh = false)
    {
        // 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;
    }

    private static function getFileScanCache($cacheKey)
    {
        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;
    }

    private static function setFileScanCache($cacheKey, $data)
    {
        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);
        }
    }

    private static function getCacheIntegrityKey()
    {
        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;
    }

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

    private static function verifyCacheIntegrity($fileContents, $cacheKey)
    {
        $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']);
    }

    public static function clearFileScanCache()
    {
        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
        ];
    }

    public static function getFileScanStats()
    {
        return self::$fileScanStats;
    }

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

    public static function getFileScanCacheDuration()
    {
        return self::$fileScanCacheDuration;
    }

    private static function getPathsToScan()
    {
        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;
    }

    private static function findFiles($startPath, $includes = array(''), $recursive = true)
    {
        $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;
    }

    public static function changePath($filesToScan, $rootPath = null)
    {
        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;
    }

    public static function getLatestVersion($url)
    {
        $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;
        }
    }

    public static function getWebsiteUrlNoUtm($path = '', $fragment = '')
    {
        return self::getWebsiteUrl($path, $fragment, false);
    }

    public static function getWebsiteUrl($path = '', $fragment = '', $utmSource = true)
    {
        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;
    }

    public static function getChangelogUrl($utmSource = true)
    {
        return self::getWebsiteUrl('doc/changelog', null, $utmSource);
    }

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

    public static function humanFileSize($size, $unit = '')
    {
        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';
    }

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

    public static function getHttpHeaders($pingUrl)
    {
        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;
    }

    public static function getFopenHttpHeaders($url)
    {
        $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;
    }

    public static function getCurlHttpHeaders($url)
    {
        $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]);
    }

    public static function getHeaders($host, $port, $ssl = false)
    {
        $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;
    }

    public static function getApiJson($url)
    {
        $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);
    }

    public static function isPortInUse($port)
    {
        // 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;
    }

    public static function isValidDomainName($domainName)
    {
        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);
    }

    public static function isAlphanumeric($string)
    {
        return ctype_alnum($string);
    }

    public static function installService($bin, $port, $syntaxCheckCmd, $showWindow = false)
    {
        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;
    }

    public static function removeService($service, $name)
    {
        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;
    }

    public static function startService($bin, $syntaxCheckCmd, $showWindow = false)
    {
        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;
    }

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

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

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

    public static function getFolderList($path)
    {
        $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;
    }

    public static function getNssmEnvPaths()
    {
        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;
    }

    public static function openFileContent($caption, $content)
    {
        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 . '"');
    }

    public static function decryptFile()
    {
        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;
    }

    public static function setupCurlHeaderWithToken()
    {
        // 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'
        ];
    }

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