FM / classes

/usr/share/phpmyadmin/libraries/classes/

/usr/share/phpmyadmin/libraries/classes

Name	Size	Mode	Actions
Charsets/	-	0755	rm
Command/	-	0755	rm
Config/	-	0755	rm
Controllers/	-	0755	rm
Database/	-	0755	rm
Dbal/	-	0755	rm
Display/	-	0755	rm
Engines/	-	0755	rm
Exceptions/	-	0755	rm
Export/	-	0755	rm
Gis/	-	0755	rm
Html/	-	0755	rm
Import/	-	0755	rm
Navigation/	-	0755	rm
Plugins/	-	0755	rm
Properties/	-	0755	rm
Providers/	-	0755	rm
Query/	-	0755	rm
Server/	-	0755	rm
Setup/	-	0755	rm
Table/	-	0755	rm
Twig/	-	0755	rm
Utils/	-	0755	rm
Advisor.php	12517	0644	edit dl rm
Bookmark.php	10944	0644	edit dl rm
BrowseForeigners.php	11083	0644	edit dl rm
Charsets.php	7267	0644	edit dl rm
CheckUserPrivileges.php	12230	0644	edit dl rm
Config.php	46456	0644	edit dl rm
Console.php	3460	0644	edit dl rm
Core.php	43344	0644	edit dl rm
CreateAddField.php	17993	0644	edit dl rm
DatabaseInterface.php	76802	0644	edit dl rm
DbTableExists.php	3287	0644	edit dl rm
Encoding.php	8715	0644	edit dl rm
Error.php	14304	0644	edit dl rm
ErrorHandler.php	17557	0644	edit dl rm
ErrorReport.php	9364	0644	edit dl rm
Export.php	47351	0644	edit dl rm
File.php	21786	0644	edit dl rm
FileListing.php	2923	0644	edit dl rm
Font.php	5718	0644	edit dl rm
Footer.php	10794	0644	edit dl rm
Git.php	18381	0644	edit dl rm
Header.php	21967	0644	edit dl rm
Import.php	58840	0644	edit dl rm
Index.php	15428	0644	edit dl rm
IndexColumn.php	4331	0644	edit dl rm
InsertEdit.php	133309	0644	edit dl rm
InternalRelations.php	17730	0644	edit dl rm
IpAllowDeny.php	9997	0644	edit dl rm
Language.php	4568	0644	edit dl rm
LanguageManager.php	24532	0644	edit dl rm
Linter.php	5374	0644	edit dl rm
ListAbstract.php	1814	0644	edit dl rm
ListDatabase.php	4402	0644	edit dl rm
Logging.php	2781	0644	edit dl rm
Menu.php	21812	0644	edit dl rm
Message.php	19547	0644	edit dl rm
Mime.php	916	0644	edit dl rm
Normalization.php	42475	0644	edit dl rm
OpenDocument.php	8617	0644	edit dl rm
Operations.php	38748	0644	edit dl rm
OutputBuffering.php	4074	0644	edit dl rm
ParseAnalyze.php	2429	0644	edit dl rm
Partition.php	7340	0644	edit dl rm
Pdf.php	4449	0644	edit dl rm
Plugins.php	25783	0644	edit dl rm
Profiling.php	2317	0644	edit dl rm
RecentFavoriteTable.php	12297	0644	edit dl rm
Relation.php	79247	0644	edit dl rm
RelationCleanup.php	15051	0644	edit dl rm
Replication.php	4843	0644	edit dl rm
ReplicationGui.php	22038	0644	edit dl rm
ReplicationInfo.php	4943	0644	edit dl rm
Response.php	16864	0644	edit dl rm
Routing.php	5845	0644	edit dl rm
Sanitize.php	12418	0644	edit dl rm
SavedSearches.php	12221	0644	edit dl rm
Scripts.php	3726	0644	edit dl rm
Session.php	8198	0644	edit dl rm
Sql.php	68272	0644	edit dl rm
SqlQueryForm.php	7286	0644	edit dl rm
StorageEngine.php	12828	0644	edit dl rm
SubPartition.php	3398	0644	edit dl rm
SystemDatabase.php	3748	0644	edit dl rm
Table.php	97961	0644	edit dl rm
TablePartitionDefinition.php	6664	0644	edit dl rm
Template.php	3962	0644	edit dl rm
Theme.php	8969	0644	edit dl rm
ThemeManager.php	9815	0644	edit dl rm
Tracker.php	30497	0644	edit dl rm
Tracking.php	38141	0644	edit dl rm
Transformations.php	16685	0644	edit dl rm
TwoFactor.php	6968	0644	edit dl rm
Types.php	25805	0644	edit dl rm
Url.php	8973	0644	edit dl rm
UserPassword.php	7284	0644	edit dl rm
UserPreferences.php	8657	0644	edit dl rm
Util.php	104768	0644	edit dl rm
Version.php	533	0644	edit dl rm
VersionInformation.php	7319	0644	edit dl rm
ZipExtension.php	11017	0644	edit dl rm

Edit: /usr/share/phpmyadmin/libraries/classes/ErrorHandler.php (17557B)

<?php

declare(strict_types=1);

namespace PhpMyAdmin;

use const E_COMPILE_ERROR;
use const E_COMPILE_WARNING;
use const E_CORE_ERROR;
use const E_CORE_WARNING;
use const E_DEPRECATED;
use const E_ERROR;
use const E_NOTICE;
use const E_PARSE;
use const E_RECOVERABLE_ERROR;
use const E_STRICT;
use const E_USER_DEPRECATED;
use const E_USER_ERROR;
use const E_USER_NOTICE;
use const E_USER_WARNING;
use const E_WARNING;
use function array_splice;
use function count;
use function defined;
use function error_reporting;
use function headers_sent;
use function htmlspecialchars;
use function set_error_handler;
use function trigger_error;
use const PHP_VERSION_ID;

/**
 * handling errors
 */
class ErrorHandler
{
    /**
     * holds errors to be displayed or reported later ...
     *
     * @var Error[]
     */
    protected $errors = [];

/**
     * Hide location of errors
     *
     * @var bool
     */
    protected $hideLocation = false;

/**
     * Initial error reporting state
     *
     * @var int
     */
    protected $errorReporting = 0;

public function __construct()
    {
        /**
         * Do not set ourselves as error handler in case of testsuite.
         *
         * This behavior is not tested there and breaks other tests as they
         * rely on PHPUnit doing it's own error handling which we break here.
         */
        if (! defined('TESTSUITE')) {
            set_error_handler([$this, 'handleError']);
        }
        if (! Util::isErrorReportingAvailable()) {
            return;
        }

$this->errorReporting = error_reporting();
    }

/**
     * Destructor
     *
     * stores errors in session
     */
    public function __destruct()
    {
        if (! isset($_SESSION['errors'])) {
            $_SESSION['errors'] = [];
        }

// remember only not displayed errors
        foreach ($this->errors as $key => $error) {
            /**
             * We don't want to store all errors here as it would
             * explode user session.
             */
            if (count($_SESSION['errors']) >= 10) {
                $error = new Error(
                    0,
                    __('Too many error messages, some are not displayed.'),
                    __FILE__,
                    __LINE__
                );
                $_SESSION['errors'][$error->getHash()] = $error;
                break;
            }

if ((! ($error instanceof Error))
                || $error->isDisplayed()
            ) {
                continue;
            }

$_SESSION['errors'][$key] = $error;
        }
    }

/**
     * Toggles location hiding
     *
     * @param bool $hide Whether to hide
     */
    public function setHideLocation(bool $hide): void
    {
        $this->hideLocation = $hide;
    }

/**
     * returns array with all errors
     *
     * @param bool $check Whether to check for session errors
     *
     * @return Error[]
     */
    public function getErrors(bool $check = true): array
    {
        if ($check) {
            $this->checkSavedErrors();
        }

return $this->errors;
    }

/**
     * returns the errors occurred in the current run only.
     * Does not include the errors saved in the SESSION
     *
     * @return Error[]
     */
    public function getCurrentErrors(): array
    {
        return $this->errors;
    }

/**
     * Pops recent errors from the storage
     *
     * @param int $count Old error count
     *
     * @return Error[]
     */
    public function sliceErrors(int $count): array
    {
        $errors = $this->getErrors(false);
        $this->errors = array_splice($errors, 0, $count);

return array_splice($errors, $count);
    }

/**
     * Error handler - called when errors are triggered/occurred
     *
     * This calls the addError() function, escaping the error string
     * Ignores the errors wherever Error Control Operator (@) is used.
     *
     * @param int    $errno   error number
     * @param string $errstr  error string
     * @param string $errfile error file
     * @param int    $errline error line
     */
    public function handleError(
        int $errno,
        string $errstr,
        string $errfile,
        int $errline
    ): void {
        if (Util::isErrorReportingAvailable()) {
            /**
            * Check if Error Control Operator (@) was used, but still show
            * user errors even in this case.
            * See: https://github.com/phpmyadmin/phpmyadmin/issues/16729
            */
            $isSilenced = ! (error_reporting() & $errno);
            if (PHP_VERSION_ID < 80000) {
                $isSilenced = error_reporting() == 0;
            }
            if ($isSilenced &&
                $this->errorReporting != 0 &&
                ($errno & (E_USER_WARNING | E_USER_ERROR | E_USER_NOTICE | E_USER_DEPRECATED)) == 0
            ) {
                return;
            }
        } else {
            if (($errno & (E_USER_WARNING | E_USER_ERROR | E_USER_NOTICE | E_USER_DEPRECATED)) == 0) {
                return;
            }
        }

$this->addError($errstr, $errno, $errfile, $errline, true);
    }

/**
     * Add an error; can also be called directly (with or without escaping)
     *
     * The following error types cannot be handled with a user defined function:
     * E_ERROR, E_PARSE, E_CORE_ERROR, E_CORE_WARNING, E_COMPILE_ERROR,
     * E_COMPILE_WARNING,
     * and most of E_STRICT raised in the file where set_error_handler() is called.
     *
     * Do not use the context parameter as we want to avoid storing the
     * complete $GLOBALS inside $_SESSION['errors']
     *
     * @param string $errstr  error string
     * @param int    $errno   error number
     * @param string $errfile error file
     * @param int    $errline error line
     * @param bool   $escape  whether to escape the error string
     */
    public function addError(
        string $errstr,
        int $errno,
        string $errfile,
        int $errline,
        bool $escape = true
    ): void {
        if ($escape) {
            $errstr = htmlspecialchars($errstr);
        }
        // create error object
        $error = new Error(
            $errno,
            $errstr,
            $errfile,
            $errline
        );
        $error->setHideLocation($this->hideLocation);

// do not repeat errors
        $this->errors[$error->getHash()] = $error;

switch ($error->getNumber()) {
            case E_STRICT:
            case E_DEPRECATED:
            case E_NOTICE:
            case E_WARNING:
            case E_CORE_WARNING:
            case E_COMPILE_WARNING:
            case E_RECOVERABLE_ERROR:
                /* Avoid rendering BB code in PHP errors */
                $error->setBBCode(false);
                break;
            case E_USER_NOTICE:
            case E_USER_WARNING:
            case E_USER_ERROR:
            case E_USER_DEPRECATED:
                // just collect the error
                // display is called from outside
                break;
            case E_ERROR:
            case E_PARSE:
            case E_CORE_ERROR:
            case E_COMPILE_ERROR:
            default:
                // FATAL error, display it and exit
                $this->dispFatalError($error);
                exit;
        }
    }

/**
     * trigger a custom error
     *
     * @param string $errorInfo   error message
     * @param int    $errorNumber error number
     */
    public function triggerError(string $errorInfo, ?int $errorNumber = null): void
    {
        // we could also extract file and line from backtrace
        // and call handleError() directly
        trigger_error($errorInfo, $errorNumber);
    }

/**
     * display fatal error and exit
     *
     * @param Error $error the error
     */
    protected function dispFatalError(Error $error): void
    {
        if (! headers_sent()) {
            $this->dispPageStart($error);
        }
        echo $error->getDisplay();
        $this->dispPageEnd();
        exit;
    }

/**
     * Displays user errors not displayed
     */
    public function dispUserErrors(): void
    {
        echo $this->getDispUserErrors();
    }

/**
     * Renders user errors not displayed
     */
    public function getDispUserErrors(): string
    {
        $retval = '';
        foreach ($this->getErrors() as $error) {
            if (! $error->isUserError() || $error->isDisplayed()) {
                continue;
            }

$retval .= $error->getDisplay();
        }

return $retval;
    }

/**
     * display HTML header
     *
     * @param Error $error the error
     */
    protected function dispPageStart(?Error $error = null): void
    {
        Response::getInstance()->disable();
        echo '<html><head><title>';
        if ($error) {
            echo $error->getTitle();
        } else {
            echo 'phpMyAdmin error reporting page';
        }
        echo '</title></head>';
    }

/**
     * display HTML footer
     */
    protected function dispPageEnd(): void
    {
        echo '</body></html>';
    }

/**
     * renders errors not displayed
     */
    public function getDispErrors(): string
    {
        $retval = '';
        // display errors if SendErrorReports is set to 'ask'.
        if ($GLOBALS['cfg']['SendErrorReports'] !== 'never') {
            foreach ($this->getErrors() as $error) {
                if ($error->isDisplayed()) {
                    continue;
                }

$retval .= $error->getDisplay();
            }
        } else {
            $retval .= $this->getDispUserErrors();
        }
        // if preference is not 'never' and
        // there are 'actual' errors to be reported
        if ($GLOBALS['cfg']['SendErrorReports'] !== 'never'
            && $this->countErrors() !=  $this->countUserErrors()
        ) {
            // add report button.
            $retval .= '<form method="post" action="' . Url::getFromRoute('/error-report')
                    . '" id="pma_report_errors_form"';
            if ($GLOBALS['cfg']['SendErrorReports'] === 'always') {
                // in case of 'always', generate 'invisible' form.
                $retval .= ' class="hide"';
            }
            $retval .=  '>';
            $retval .= Url::getHiddenFields([
                'exception_type' => 'php',
                'send_error_report' => '1',
                'server' => $GLOBALS['server'],
            ]);
            $retval .= '<input type="submit" value="'
                    . __('Report')
                    . '" id="pma_report_errors" class="btn btn-primary floatright">'
                    . '<input type="checkbox" name="always_send"'
                    . ' id="always_send_checkbox" value="true">'
                    . '<label for="always_send_checkbox">'
                    . __('Automatically send report next time')
                    . '</label>';

if ($GLOBALS['cfg']['SendErrorReports'] === 'ask') {
                // add ignore buttons
                $retval .= '<input type="submit" value="'
                        . __('Ignore')
                        . '" id="pma_ignore_errors_bottom" class="btn btn-secondary floatright">';
            }
            $retval .= '<input type="submit" value="'
                    . __('Ignore All')
                    . '" id="pma_ignore_all_errors_bottom" class="btn btn-secondary floatright">';
            $retval .= '</form>';
        }

return $retval;
    }

/**
     * look in session for saved errors
     */
    protected function checkSavedErrors(): void
    {
        if (! isset($_SESSION['errors'])) {
            return;
        }

// restore saved errors
        foreach ($_SESSION['errors'] as $hash => $error) {
            if (! ($error instanceof Error) || isset($this->errors[$hash])) {
                continue;
            }

$this->errors[$hash] = $error;
        }

// delete stored errors
        $_SESSION['errors'] = [];
        unset($_SESSION['errors']);
    }

/**
     * return count of errors
     *
     * @param bool $check Whether to check for session errors
     *
     * @return int number of errors occurred
     */
    public function countErrors(bool $check = true): int
    {
        return count($this->getErrors($check));
    }

/**
     * return count of user errors
     *
     * @return int number of user errors occurred
     */
    public function countUserErrors(): int
    {
        $count = 0;
        if ($this->countErrors()) {
            foreach ($this->getErrors() as $error) {
                if (! $error->isUserError()) {
                    continue;
                }

$count++;
            }
        }

return $count;
    }

/**
     * whether use errors occurred or not
     */
    public function hasUserErrors(): bool
    {
        return (bool) $this->countUserErrors();
    }

/**
     * whether errors occurred or not
     */
    public function hasErrors(): bool
    {
        return (bool) $this->countErrors();
    }

/**
     * number of errors to be displayed
     *
     * @return int number of errors to be displayed
     */
    public function countDisplayErrors(): int
    {
        if ($GLOBALS['cfg']['SendErrorReports'] !== 'never') {
            return $this->countErrors();
        }

return $this->countUserErrors();
    }

/**
     * whether there are errors to display or not
     */
    public function hasDisplayErrors(): bool
    {
        return (bool) $this->countDisplayErrors();
    }

/**
     * Deletes previously stored errors in SESSION.
     * Saves current errors in session as previous errors.
     * Required to save current errors in case  'ask'
     */
    public function savePreviousErrors(): void
    {
        unset($_SESSION['prev_errors']);
        $_SESSION['prev_errors'] = $GLOBALS['error_handler']->getCurrentErrors();
    }

/**
     * Function to check if there are any errors to be prompted.
     * Needed because user warnings raised are
     *      also collected by global error handler.
     * This distinguishes between the actual errors
     *      and user errors raised to warn user.
     *
     * @return bool true if there are errors to be "prompted", false otherwise
     */
    public function hasErrorsForPrompt(): bool
    {
        return $GLOBALS['cfg']['SendErrorReports'] !== 'never'
            && $this->countErrors() !=  $this->countUserErrors();
    }

/**
     * Function to report all the collected php errors.
     * Must be called at the end of each script
     *      by the $GLOBALS['error_handler'] only.
     */
    public function reportErrors(): void
    {
        // if there're no actual errors,
        if (! $this->hasErrors()
            || $this->countErrors() ==  $this->countUserErrors()
        ) {
            // then simply return.
            return;
        }
        // Delete all the prev_errors in session & store new prev_errors in session
        $this->savePreviousErrors();
        $response = Response::getInstance();
        $jsCode = '';
        if ($GLOBALS['cfg']['SendErrorReports'] === 'always') {
            if ($response->isAjax()) {
                // set flag for automatic report submission.
                $response->addJSON('sendErrorAlways', '1');
            } else {
                // send the error reports asynchronously & without asking user
                $jsCode .= '$("#pma_report_errors_form").submit();'
                        . 'Functions.ajaxShowMessage(
                            Messages.phpErrorsBeingSubmitted, false
                        );';
                // js code to appropriate focusing,
                $jsCode .= '$("html, body").animate({
                                scrollTop:$(document).height()
                            }, "slow");';
            }
        } elseif ($GLOBALS['cfg']['SendErrorReports'] === 'ask') {
            //ask user whether to submit errors or not.
            if (! $response->isAjax()) {
                // js code to show appropriate msgs, event binding & focusing.
                $jsCode = 'Functions.ajaxShowMessage(Messages.phpErrorsFound);'
                        . '$("#pma_ignore_errors_popup").on("click", function() {
                            Functions.ignorePhpErrors()
                        });'
                        . '$("#pma_ignore_all_errors_popup").on("click",
                            function() {
                                Functions.ignorePhpErrors(false)
                            });'
                        . '$("#pma_ignore_errors_bottom").on("click", function(e) {
                            e.preventDefault();
                            Functions.ignorePhpErrors()
                        });'
                        . '$("#pma_ignore_all_errors_bottom").on("click",
                            function(e) {
                                e.preventDefault();
                                Functions.ignorePhpErrors(false)
                            });'
                        . '$("html, body").animate({
                            scrollTop:$(document).height()
                        }, "slow");';
            }
        }
        // The errors are already sent from the response.
        // Just focus on errors division upon load event.
        $response->getFooter()->getScripts()->addCode($jsCode);
    }
}

cmd: