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
{
    private static $fileScanCache = null;

    private static $fileScanCacheDuration = 3600;

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

    private static $cacheIntegrityKey = null;

    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 = UtilPath::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 isAdmin()
    {
        // Only applicable on Windows
        if (strtoupper(substr(PHP_OS, 0, 3)) !== 'WIN') {
            // On non-Windows systems, check if running as root
            if (function_exists('posix_geteuid')) {
                return posix_geteuid() === 0;
            }
            // If we can't determine on non-Windows, assume true to avoid blocking
            return true;
        }
 
        // Method 1: Try using shell_exec with 'net session' command
        // This command only succeeds when run with admin privileges
        $output = CommandRunner::shellExec('net session 2>&1');
        if ($output !== null) {
            // Check for access denied errors
            if (stripos($output, 'Access is denied') !== false ||
                stripos($output, 'System error 5') !== false ||
                stripos($output, 'Zugriff verweigert') !== false) { // German
                // Explicitly denied - not admin
                return false;
            }
 
            // If we got output without errors, we likely have admin rights
            if (stripos($output, 'There are no entries') !== false ||
                stripos($output, 'These workstations') !== false ||
                preg_match('/\\\\\\\\/', $output)) {
                return true;
            }
        }
 
        // Method 2: Check using whoami command (Windows Vista and later)
        $output = CommandRunner::shellExec('whoami /groups 2>&1');
        if ($output !== null && !empty($output)) {
            // Look for the Administrators group or High Mandatory Level
            if (stripos($output, 'S-1-16-12288') !== false || // High Mandatory Level
                stripos($output, 'S-1-5-32-544') !== false) {  // Administrators group
                return true;
            }
 
            // If we got output but no admin indicators, we're not admin
            if (stripos($output, 'S-1-16-8192') !== false) { // Medium Mandatory Level (not admin)
                return false;
            }
        }
 
        // Method 3: Try to write to a system directory
        // This is a fallback method that checks if we can write to Windows directory
        $testFile = getenv('SystemRoot') . '\\Temp\\bearsampp_admin_test_' . uniqid() . '.tmp';
        $result = @file_put_contents($testFile, 'test');
        if ($result !== false) {
            @unlink($testFile);
            return true;
        }
 
        // If all methods fail or indicate no admin, return false
        return false;
    }

    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);
                            }
                        }
                        Log::trace('Replace in file ' . $path . ' :');
                        Log::trace('## line_num: ' . trim($nb));
                        Log::trace('## old: ' . trim($line));
                        Log::trace('## 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;
        }
 
        $prefix = basename($path);
 
        while (false !== ($file = readdir($handle))) {
            $filePath = $path . '/' . $file;
            if ($file != '.' && $file != '..' && is_dir($filePath) && $file != 'current') {
                if (strpos($file, $prefix) === 0) {
                    $version = substr($file, strlen($prefix));
                } else {
                    $version = $file;
                }
                $result[] = $version;
            }
        }
 
        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
            );
            Log::debug('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 = UtilPath::formatWindowsPath($value);
            Log::debug('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()
    {
        $startupPath = Win32Native::getSpecialFolderPath('Startup');
        return $startupPath ? $startupPath . '/' . APP_TITLE . '.lnk' : false;
    }

    public static function isLaunchStartup()
    {
        $lnk = self::getStartupLnkPath();
        return $lnk ? file_exists($lnk) : false;
    }

    public static function enableLaunchStartup()
    {
        global $bearsamppRoot, $bearsamppCore;
 
        $shortcutPath = self::getStartupLnkPath();
        if (!$shortcutPath) {
            return false;
        }
 
        $targetPath = $bearsamppRoot->getExeFilePath();
        $workingDir = $bearsamppRoot->getRootPath();
        $description = APP_TITLE . ' ' . $bearsamppCore->getAppVersion();
        $iconPath = $bearsamppCore->getIconsPath() . '/app.ico';
 
        return Win32Native::createShortcut($shortcutPath, $targetPath, $workingDir, $description, $iconPath);
    }

    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;
    }

    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[] = UtilPath::formatUnixPath($startPath);
            }
        }
 
        closedir($handle);
 
        return $result;
    }

    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 convertEncoding($data, $direction = 'to_cp1252')
    {
        if ($direction === 'to_utf8') {
            return self::cp1252ToUtf8($data);
        } else {
            return self::utf8ToCp1252($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;
 
        Log::trace('startLoading() called');
        Log::trace('PHP executable: ' . $bearsamppCore->getPhpExe());
        Log::trace('Root file: ' . Core::isRoot_FILE);
        Log::trace('Action: ' . Action::LOADING);
 
        $command = Core::isRoot_FILE . ' ' . Action::LOADING;
        Log::trace('Executing command: ' . $bearsamppCore->getPhpExe() . ' ' . $command);
 
        $result = $bearsamppWinbinder->exec($bearsamppCore->getPhpExe(), $command);
        Log::trace('exec() returned: ' . var_export($result, true));
 
        Log::trace('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']++;
                Log::debug('File scan cache HIT (saved expensive scan operation)');
                return $cachedResult;
            }
        }
 
        self::$fileScanStats['misses']++;
        Log::debug('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;
            }
            Log::debug($pathToScan['path'] . ' scanned in ' . round(self::getMicrotime() - $pathStartTime, 3) . 's');
        }
 
        $totalTime = round(self::getMicrotime() - $startTime, 3);
        Log::info('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)) {
                Log::warning('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
                Log::warning('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);
            Log::debug('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) {
                    Log::error('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);
                }
                Log::info('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;
            Log::debug('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
            );
            // Also scan data directory for my.ini (created during initialization)
            $dataPath = $bearsamppBins->getMariadb()->getRootPath() . '/' . $folder . '/data';
            if (is_dir($dataPath)) {
                $paths[] = array(
                    'path'      => $dataPath,
                    '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 (UtilString::startWith($include, '!')) {
                        $include = ltrim($include, '!');
                        if (UtilString::startWith($file, '.') && !UtilString::endWith($file, $include)) {
                            $result[] = UtilPath::formatUnixPath($startPath . '/' . $file);
                        } elseif ($file != $include) {
                            $result[] = UtilPath::formatUnixPath($startPath . '/' . $file);
                        }
                    } elseif (UtilString::endWith($file, $include) || $file == $include || empty($include)) {
                        $result[] = UtilPath::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        = UtilPath::formatUnixPath($bearsamppCore->getLastPathContent());
        $windowsOldPath     = UtilPath::formatWindowsPath($bearsamppCore->getLastPathContent());
        $unixCurrentPath    = UtilPath::formatUnixPath($rootPath);
        $windowsCurrentPath = UtilPath::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);
            }
        }
 
        Log::debug('changePath() completed: ' . $result['countChangedFiles'] . ' files changed, ' . $result['countChangedOcc'] . ' total occurrences');
 
        return $result;
    }

    public static function getLatestVersion($url)
    {
        $responseData = self::getApiJson($url);
 
        if (empty($responseData)) {
            Log::error('Cannot retrieve latest github info: empty result or error');
            return null;
        }
 
        // Now decode the JSON string
        $resultArray = json_decode($responseData, 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'];
            Log::debug('Latest version tag name: ' . $tagName);
            Log::debug('Download URL: ' . $downloadUrl);
            Log::debug('Name: ' . $name);
 
            return ['version' => $tagName, 'html_url' => $downloadUrl, 'name' => $name];
        } else {
            Log::error('Tag name, download URL, or name not found in the response');
            return null;
        }
    }

    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 getWebsiteUrlNoUtm($path = '', $fragment = '')
    {
        return self::getWebsiteUrl($path, $fragment, false);
    }

    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 UtilString::contains($processor, 'x86');
    }

    public static function getHeaders($host, $port, $ssl = false)
    {
        $result  = array();
        $context = stream_context_create(array(
            'ssl' => array(
                'verify_peer'       => true,
                'verify_peer_name'  => true,
                'allow_self_signed' => false,
            )
        ));
 
        $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;
 
            Log::debug('getHeaders:');
            foreach ($result as $header) {
                Log::debug('-> ' . $header);
            }
        }
 
        return $result;
    }

    public static function getApiJson($url)
    {
        $result = HttpClient::getApiJson($url);
 
        if (isset($result['error'])) {
            return null;
        }
 
        return isset($result['data']) ? $result['data'] : null;
    }

    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)
    {
        // This will return the string if valid, or FALSE if not.
        // It checks syntax rules (RFC 1034/1035) but doesn't check if the domain is "real."
        $isValidSyntax = filter_var($domainName, FILTER_VALIDATE_DOMAIN, FILTER_FLAG_HOSTNAME);
 
        return $isValidSyntax;
    }

    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()) {
                    Log::info(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']);
                        }
                    }
                    Log::error($serviceErrorLog);
                    if ($showWindow) {
                        $bearsamppWinbinder->messageBoxError($serviceError, $boxTitle);
                    }
                }
            } else {
                Log::warning(sprintf('%s service already installed', $name));
                if ($showWindow) {
                    $bearsamppWinbinder->messageBoxWarning(
                        sprintf($bearsamppLang->getValue(Lang::SERVICE_ALREADY_INSTALLED), $name),
                        $boxTitle
                    );
                }
 
                return true;
            }
        } elseif ($service->isRunning()) {
            Log::warning(sprintf('%s service already installed and running', $name));
            if ($showWindow) {
                $bearsamppWinbinder->messageBoxWarning(
                    sprintf($bearsamppLang->getValue(Lang::SERVICE_ALREADY_INSTALLED), $name),
                    $boxTitle
                );
            }
 
            return true;
        } else {
            Log::error(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)) {
            Log::error('$service not an instance of Win32Service');
 
            return false;
        }
 
        if ($service->isInstalled()) {
            if ($service->delete()) {
                Log::info(sprintf('%s service successfully removed', $name));
 
                return true;
            } else {
                Log::error(sprintf('Error during the uninstallation of %s service', $name));
 
                return false;
            }
        } else {
            Log::warning(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']);
                }
            }
            Log::error($serviceErrorLog);
            if ($showWindow) {
                $bearsamppWinbinder->messageBoxError($serviceError, $boxTitle);
            }
 
            return false;
        }
 
        return true;
    }

    public static function getGithubUrl($type = 'user', $user = APP_GITHUB_USER, $repo = null, $branch = null, $path = null) {
        if (empty($user) || !is_string($user)) {
            return false;
        }
 
        // Encode as URL path segment (not query encoding)
        $user = rawurlencode($user);
 
        switch ($type) {
            case 'user':
                return "https://github.com/{$user}";
 
            case 'repo':
                if (empty($repo) || !is_string($repo)) {
                    return false;
                }
                $repo = rawurlencode($repo);
                return "https://github.com/{$user}/{$repo}";
 
            case 'raw':
                if (empty($repo) || empty($branch) || empty($path) || !is_string($repo) || !is_string($branch) || !is_string($path)) {
                    return false;
                }
                $repo = rawurlencode($repo);
                $branch = rawurlencode($branch);
 
                $path = ltrim($path, '/');
                $segments = array_map('rawurlencode', explode('/', $path));
                $pathEncoded = implode('/', $segments);
 
                return "https://raw.githubusercontent.com/{$user}/{$repo}/{$branch}/{$pathEncoded}";
 
            default:
                return false;
        }
    }

    public static function getGithubUserUrl()
    {
        return self::getGithubUrl('user', APP_GITHUB_USER);
    }

    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);
        natcasesort($result);
 
        return $result;
    }

    public static function openFileContent($caption, $content)
    {
        global $bearsamppCore, $bearsamppConfig;
 
        $tmpFile = $bearsamppCore->getTmpPath() . '/' . $caption . '.txt';
        file_put_contents($tmpFile, $content);
 
        // Open the file with the configured editor from bearsampp.conf
        $editor = $bearsamppConfig->getNotepad();
        $bearsamppCore->getWinbinder()->exec($editor, '"' . $tmpFile . '"');
    }
}