!C99Shell v. 2.5 [PHP 8 Update] [24.05.2025]!

Software: Apache/2.4.41 (Ubuntu). PHP/8.0.30 

uname -a: Linux apirnd 5.4.0-204-generic #224-Ubuntu SMP Thu Dec 5 13:38:28 UTC 2024 x86_64 

uid=33(www-data) gid=33(www-data) groups=33(www-data) 

Safe-mode: OFF (not secure)

/uploads/script/vendor/composer/composer/src/Composer/   drwxr-xr-x
Free 13.24 GB of 57.97 GB (22.84%)
Home    Back    Forward    UPDIR    Refresh    Search    Buffer    Encoder    Tools    Proc.    FTP brute    Sec.    SQL    PHP-code    Update    Self remove    Logout    


Viewing file:     Compiler.php (10.52 KB)      -rw-r--r--
Select action/file-type:
(+) | (+) | (+) | Code (+) | Session (+) | (+) | SDB (+) | (+) | (+) | (+) | (+) | (+) |
<?php

/*
 * This file is part of Composer.
 *
 * (c) Nils Adermann <naderman@naderman.de>
 *     Jordi Boggiano <j.boggiano@seld.be>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Composer;

use 
Composer\Json\JsonFile;
use 
Composer\CaBundle\CaBundle;
use 
Symfony\Component\Finder\Finder;
use 
Symfony\Component\Process\Process;
use 
Seld\PharUtils\Timestamps;
use 
Seld\PharUtils\Linter;

/**
 * The Compiler class compiles composer into a phar
 *
 * @author Fabien Potencier <fabien@symfony.com>
 * @author Jordi Boggiano <j.boggiano@seld.be>
 */
class Compiler
{
    private 
$version;
    private 
$branchAliasVersion '';
    private 
$versionDate;

    
/**
     * Compiles composer into a single phar file
     *
     * @param  string            $pharFile The full path to the file to create
     * @throws \RuntimeException
     */
    
public function compile($pharFile 'composer.phar')
    {
        if (
file_exists($pharFile)) {
            
unlink($pharFile);
        }

        
$process = new Process('git log --pretty="%H" -n1 HEAD'__DIR__);
        if (
$process->run() != 0) {
            throw new 
\RuntimeException('Can\'t run git log. You must ensure to run compile from composer git repository clone and that git binary is available.');
        }
        
$this->version trim($process->getOutput());

        
$process = new Process('git log -n1 --pretty=%ci HEAD'__DIR__);
        if (
$process->run() != 0) {
            throw new 
\RuntimeException('Can\'t run git log. You must ensure to run compile from composer git repository clone and that git binary is available.');
        }

        
$this->versionDate = new \DateTime(trim($process->getOutput()));
        
$this->versionDate->setTimezone(new \DateTimeZone('UTC'));

        
$process = new Process('git describe --tags --exact-match HEAD');
        if (
$process->run() == 0) {
            
$this->version trim($process->getOutput());
        } else {
            
// get branch-alias defined in composer.json for dev-master (if any)
            
$localConfig __DIR__.'/../../composer.json';
            
$file = new JsonFile($localConfig);
            
$localConfig $file->read();
            if (isset(
$localConfig['extra']['branch-alias']['dev-master'])) {
                
$this->branchAliasVersion $localConfig['extra']['branch-alias']['dev-master'];
            }
        }

        
$phar = new \Phar($pharFile0'composer.phar');
        
$phar->setSignatureAlgorithm(\Phar::SHA1);

        
$phar->startBuffering();

        
$finderSort = function ($a$b) {
            return 
strcmp(strtr($a->getRealPath(), '\\''/'), strtr($b->getRealPath(), '\\''/'));
        };

        
// Add Composer sources
        
$finder = new Finder();
        
$finder->files()
            ->
ignoreVCS(true)
            ->
name('*.php')
            ->
notName('Compiler.php')
            ->
notName('ClassLoader.php')
            ->
in(__DIR__.'/..')
            ->
sort($finderSort)
        ;
        foreach (
$finder as $file) {
            
$this->addFile($phar$file);
        }
        
// Add ClassLoader separately to make sure it retains the docblocks as it will get copied into projects
        
$this->addFile($phar, new \SplFileInfo(__DIR__ '/Autoload/ClassLoader.php'), false);

        
// Add Composer resources
        
$finder = new Finder();
        
$finder->files()
            ->
in(__DIR__.'/../../res')
            ->
sort($finderSort)
        ;
        foreach (
$finder as $file) {
            
$this->addFile($phar$filefalse);
        }

        
// Add vendor files
        
$finder = new Finder();
        
$finder->files()
            ->
ignoreVCS(true)
            ->
notPath('/\/(composer\.(json|lock)|[A-Z]+\.md|\.gitignore|appveyor.yml|phpunit\.xml\.dist|phpstan\.neon\.dist|phpstan-config\.neon)$/')
            ->
notPath('/bin\/(jsonlint|validate-json|simple-phpunit)(\.bat)?$/')
            ->
notPath('symfony/debug/Resources/ext/')
            ->
notPath('justinrainbow/json-schema/demo/')
            ->
notPath('justinrainbow/json-schema/dist/')
            ->
notPath('composer/installed.json')
            ->
notPath('composer/LICENSE')
            ->
exclude('Tests')
            ->
exclude('tests')
            ->
exclude('docs')
            ->
in(__DIR__.'/../../vendor/')
            ->
sort($finderSort)
        ;

        
$extraFiles = array(
            
realpath(__DIR__ '/../../vendor/composer/spdx-licenses/res/spdx-exceptions.json'),
            
realpath(__DIR__ '/../../vendor/composer/spdx-licenses/res/spdx-licenses.json'),
            
realpath(CaBundle::getBundledCaBundlePath()),
            
realpath(__DIR__ '/../../vendor/symfony/console/Resources/bin/hiddeninput.exe'),
            
realpath(__DIR__ '/../../vendor/symfony/polyfill-mbstring/Resources/mb_convert_variables.php8'),
        );
        
$unexpectedFiles = array();

        foreach (
$finder as $file) {
            if (
in_array(realpath($file), $extraFilestrue)) {
                unset(
$extraFiles[array_search(realpath($file), $extraFilestrue)]);
            } elseif (!
preg_match('{(/LICENSE|\.php)$}'$file)) {
                
$unexpectedFiles[] = (string) $file;
            }

            if (
preg_match('{\.php[\d.]*$}'$file)) {
                
$this->addFile($phar$file);
            } else {
                
$this->addFile($phar$filefalse);
            }
        }

        if (
$extraFiles) {
            throw new 
\RuntimeException('These files were expected but not added to the phar, they might be excluded or gone from the source package:'.PHP_EOL.implode(PHP_EOL$extraFiles));
        }
        if (
$unexpectedFiles) {
            throw new 
\RuntimeException('These files were unexpectedly added to the phar, make sure they are excluded or listed in $extraFiles:'.PHP_EOL.implode(PHP_EOL$unexpectedFiles));
        }

        
// Add bin/composer
        
$this->addComposerBin($phar);

        
// Stubs
        
$phar->setStub($this->getStub());

        
$phar->stopBuffering();

        
// disabled for interoperability with systems without gzip ext
        // $phar->compressFiles(\Phar::GZ);

        
$this->addFile($phar, new \SplFileInfo(__DIR__.'/../../LICENSE'), false);

        unset(
$phar);

        
// re-sign the phar with reproducible timestamp / signature
        
$util = new Timestamps($pharFile);
        
$util->updateTimestamps($this->versionDate);
        
$util->save($pharFile\Phar::SHA1);

        
Linter::lint($pharFile);
    }

    
/**
     * @param  \SplFileInfo $file
     * @return string
     */
    
private function getRelativeFilePath($file)
    {
        
$realPath $file->getRealPath();
        
$pathPrefix dirname(dirname(__DIR__)).DIRECTORY_SEPARATOR;

        
$pos strpos($realPath$pathPrefix);
        
$relativePath = ($pos !== false) ? substr_replace($realPath''$posstrlen($pathPrefix)) : $realPath;

        return 
strtr($relativePath'\\''/');
    }

    private function 
addFile($phar$file$strip true)
    {
        
$path $this->getRelativeFilePath($file);
        
$content file_get_contents($file);
        if (
$strip) {
            
$content $this->stripWhitespace($content);
        } elseif (
'LICENSE' === basename($file)) {
            
$content "\n".$content."\n";
        }

        if (
$path === 'src/Composer/Composer.php') {
            
$content strtr(
                
$content,
                array(
                    
'@package_version@' => $this->version,
                    
'@package_branch_alias_version@' => $this->branchAliasVersion,
                    
'@release_date@' => $this->versionDate->format('Y-m-d H:i:s'),
                )
            );
            
$content preg_replace('{SOURCE_VERSION = \'[^\']+\';}''SOURCE_VERSION = \'\';'$content);
        }

        
$phar->addFromString($path$content);
    }

    private function 
addComposerBin($phar)
    {
        
$content file_get_contents(__DIR__.'/../../bin/composer');
        
$content preg_replace('{^#!/usr/bin/env php\s*}'''$content);
        
$phar->addFromString('bin/composer'$content);
    }

    
/**
     * Removes whitespace from a PHP source string while preserving line numbers.
     *
     * @param  string $source A PHP string
     * @return string The PHP string with the whitespace removed
     */
    
private function stripWhitespace($source)
    {
        if (!
function_exists('token_get_all')) {
            return 
$source;
        }

        
$output '';
        foreach (
token_get_all($source) as $token) {
            if (
is_string($token)) {
                
$output .= $token;
            } elseif (
in_array($token[0], array(T_COMMENTT_DOC_COMMENT))) {
                
$output .= str_repeat("\n"substr_count($token[1], "\n"));
            } elseif (
T_WHITESPACE === $token[0]) {
                
// reduce wide spaces
                
$whitespace preg_replace('{[ \t]+}'' '$token[1]);
                
// normalize newlines to \n
                
$whitespace preg_replace('{(?:\r\n|\r|\n)}'"\n"$whitespace);
                
// trim leading spaces
                
$whitespace preg_replace('{\n +}'"\n"$whitespace);
                
$output .= $whitespace;
            } else {
                
$output .= $token[1];
            }
        }

        return 
$output;
    }

    private function 
getStub()
    {
        
$stub = <<<'EOF'
#!/usr/bin/env php
<?php
/*
 * This file is part of Composer.
 *
 * (c) Nils Adermann <naderman@naderman.de>
 *     Jordi Boggiano <j.boggiano@seld.be>
 *
 * For the full copyright and license information, please view
 * the license that is located at the bottom of this file.
 */

// Avoid APC causing random fatal errors per https://github.com/composer/composer/issues/264
if (extension_loaded('apc') && filter_var(ini_get('apc.enable_cli'), FILTER_VALIDATE_BOOLEAN) && filter_var(ini_get('apc.cache_by_default'), FILTER_VALIDATE_BOOLEAN)) {
    if (version_compare(phpversion('apc'), '3.0.12', '>=')) {
        ini_set('apc.cache_by_default', 0);
    } else {
        fwrite(STDERR, 'Warning: APC <= 3.0.12 may cause fatal errors when running composer commands.'.PHP_EOL);
        fwrite(STDERR, 'Update APC, or set apc.enable_cli or apc.cache_by_default to 0 in your php.ini.'.PHP_EOL);
    }
}

Phar::mapPhar('composer.phar');

EOF;

        
// add warning once the phar is older than 60 days
        
if (preg_match('{^[a-f0-9]+$}'$this->version)) {
            
$warningTime $this->versionDate->format('U') + 60 86400;
            
$stub .= "define('COMPOSER_DEV_WARNING_TIME', $warningTime);\n";
        }

        return 
$stub . <<<'EOF'
require 'phar://composer.phar/bin/composer';

__HALT_COMPILER();
EOF;
    }
}

:: Command execute ::

Enter:
 
Select:
 

:: Search ::
  - regexp 

:: Upload ::
 
[ Read-Only ]

:: Make Dir ::
 
[ Read-Only ]
:: Make File ::
 
[ Read-Only ]

:: Go Dir ::
 
:: Go File ::
 

--[ c99shell v. 2.5 [PHP 8 Update] [24.05.2025] | Generation time: 0.0074 ]--