class.core.php

Go to the documentation of this file.

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

class Core
{
    // Constants for various file names and versions
    const isRoot_FILE = 'root.php';
    const PATH_WIN_PLACEHOLDER = '~BEARSAMPP_WIN_PATH~';
    const PATH_LIN_PLACEHOLDER = '~BEARSAMPP_LIN_PATH~';
 
    const PHP_EXE = 'php-win.exe';
    const SETENV_EXE = 'SetEnv.exe';
    const NSSM_EXE = 'nssm.exe';
    const OPENSSL_EXE = 'openssl.exe';
    const OPENSSL_CONF = 'openssl.cfg';
    const HOSTSEDITOR_EXE = 'hEdit_x64.exe';
    const LN_EXE = 'ln.exe';
    const PWGEN_EXE = "PwTech.exe";
 
    const APP_VERSION = 'version.dat';
    const LAST_PATH = 'lastPath.dat';
    const EXEC = 'exec.dat';
    const LOADING_PID = 'loading.pid';

    public function __construct()
    {
        if ( extension_loaded( 'winbinder' ) ) {
            require_once Path::getLibsPath() . '/winbinder/winbinder.php';
        }
    }

    public function getAppVersion()
    {
        global $bearsamppLang;
 
        $filePath = Path::getResourcesPath() . '/' . self::APP_VERSION;
        if ( !is_file( $filePath ) ) {
            Log::error( sprintf( $bearsamppLang->getValue( Lang::ERROR_CONF_NOT_FOUND ), APP_TITLE, $filePath ) );
 
            return null;
        }
 
        return trim( file_get_contents( $filePath ) );
    }

    public function getLastPathContent()
    {
        return @file_get_contents( Path::getLastPath() );
    }

    public function getPreviousExec()
    {
        $file = $this->getExec();
        if (file_exists($file)) {
            return trim(file_get_contents($file));
        }
        return false;
    }

    public function getExec($aetrayPath = false)
    {
        return Path::getTmpPath( $aetrayPath ) . '/' . self::EXEC;
    }

    public function setExec($action)
    {
        file_put_contents( $this->getExec(), $action );
    }

    public function getLoadingPid($aetrayPath = false)
    {
        return Path::getResourcesPath( $aetrayPath ) . '/' . self::LOADING_PID;
    }

    public function addLoadingPid($pid)
    {
        file_put_contents( $this->getLoadingPid(), $pid . PHP_EOL, FILE_APPEND );
    }

    public function __toString()
    {
        return 'core object';
    }

    public function unzipFile($filePath, $destination, $progressCallback = null)
    {
        global $bearsamppRoot;
 
        $sevenZipPath = Path::getLibsPath() . '/7zip/7za.exe';
 
        if ( !file_exists( $sevenZipPath ) ) {
            Log::error( '7za.exe not found at: ' . $sevenZipPath );
 
            return false;
        }
 
        if ($progressCallback) {
            call_user_func($progressCallback, 'Initializing archive test...');
        }
 
        // Test the archive to determine the number of files
        if ($progressCallback) {
            call_user_func($progressCallback, 'Analyzing archive...');
        }
        $testOutput = CommandRunner::exec($sevenZipPath, ['t', $filePath, '-y', '-bsp1']);
        preg_match('/Files: (\d+)/', $testOutput !== false ? $testOutput : '', $matches);
        $numFiles = isset($matches[1]) ? (int) $matches[1] : 0;
        Log::trace('Number of files to be extracted: ' . $numFiles);
 
        if ($progressCallback) {
            call_user_func($progressCallback, 'Initializing extraction...');
        }
        // Extract the archive, streaming progress line-by-line
        $returnVar = CommandRunner::stream(
            $sevenZipPath,
            ['x', $filePath, '-y', '-bsp1', '-bb0', '-o' . $destination],
            function (string $line) use ($progressCallback) {
                Log::trace("Processing line: $line");
                if ($line === 'Everything is Ok') {
                    if ($progressCallback) {
                        Log::trace('Extraction progress: 100%');
                        call_user_func($progressCallback, 100);
                    }
                } elseif ($progressCallback && preg_match('/(?:^|\s)(\d+)%/', $line, $matches)) {
                    $currentPercentage = intval($matches[1]);
                    Log::trace("Extraction progress: $currentPercentage%");
                    call_user_func($progressCallback, $currentPercentage);
                } else {
                    Log::trace("Line did not match pattern: $line");
                }
            }
        );
 
        if ($returnVar === false) {
            Log::error('Failed to open process for: ' . $sevenZipPath);
            return ['error' => 'Failed to open process', 'numFiles' => $numFiles];
        }
 
        Log::trace('Command return value: ' . $returnVar);
 
        if ($returnVar === 0 && $progressCallback) {
            Log::trace('Extraction completed successfully. Setting progress to 100%');
            call_user_func($progressCallback, 100);
            usleep(100000); // 100 milliseconds
        }
 
        if ($returnVar === 0) {
            Log::debug('Successfully unzipped file to: ' . $destination);
            return ['success' => true, 'numFiles' => $numFiles];
        }
 
        Log::error('Failed to unzip file. Command return value: ' . $returnVar);
        return ['error' => 'Failed to unzip file', 'numFiles' => $numFiles];
    }

    public function getFileFromUrl(string $moduleUrl, string $filePath, $progressBar = false)
    {
        // Open the URL for reading
        $inputStream = @fopen( $moduleUrl, 'rb' );
        if ( $inputStream === false ) {
            Log::error( 'Error fetching content from URL: ' . $moduleUrl );
 
            return ['error' => 'Error fetching module'];
        }
 
        // Open the file for writing
        $outputStream = @fopen( $filePath, 'wb' );
        if ( $outputStream === false ) {
            Log::error( 'Error opening file for writing: ' . $filePath );
            fclose( $inputStream );
 
            return ['error' => 'Error saving module'];
        }
 
        // Read and write in chunks to avoid memory overload
        $bufferSize = 8096; // 8KB
        $chunksRead = 0;
 
        while ( !feof( $inputStream ) ) {
            $buffer = fread( $inputStream, $bufferSize );
            fwrite( $outputStream, $buffer );
            $chunksRead++;
 
            // Send progress update
            if ( $progressBar ) {
                $progress = $chunksRead;
                echo json_encode( ['progress' => $progress] ) . PHP_EOL;
 
                // Check if output buffering is active before calling ob_flush()
                if ( ob_get_length() !== false ) {
                    ob_flush();
                }
                flush();
            }
        }
 
        fclose( $inputStream );
        fclose( $outputStream );
 
        return ['success' => true];
    }
}