libraries/Error_Handler.class.php

   1 <?php
   2 /* vim: set expandtab sw=4 ts=4 sts=4: */
   3 /**
   4  * Holds class PMA_Error_Handler
   5  *
   6  * @package phpMyAdmin
   7  */
   8
   9 /**
  10  *
  11  */
  12 require_once './libraries/Error.class.php';
  13
  14 /**
  15  * handling errors
  16  *
  17  * @package phpMyAdmin
  18  */
  19 class PMA_Error_Handler
  20 {
  21     /**
  22      * holds errors to be displayed or reported later ...
  23      *
  24      * @var array of PMA_Error
  25      */
  26     protected $_errors = array();
  27
  28     /**
  29      * Constructor - set PHP error handler
  30      *
  31      * @uses    set_error_handler()
  32      */
  33     public function __construct()
  34     {
  35         set_error_handler(array($this, 'handleError'));
  36     }
  37
  38     /**
  39      * Destructor
  40      *
  41      * stores errors in session
  42      *
  43      * @uses    $_SESSION['errors']
  44      * @uses    array_merge()
  45      * @uses    PMA_Error_Handler::$_errors
  46      * @uses    PMA_Error::isDisplayed()
  47      */
  48     public function __destruct()
  49     {
  50         if (isset($_SESSION)) {
  51             if (! isset($_SESSION['errors'])) {
  52                 $_SESSION['errors'] = array();
  53             }
  54
  55             if ($GLOBALS['cfg']['Error_Handler']['gather']) {
  56                 // remember all errors
  57                 $_SESSION['errors'] = array_merge($_SESSION['errors'], $this->_errors);
  58             } else {
  59                 // remember only not displayed errors
  60                 foreach ($this->_errors as $key => $error) {
  61                     if (($error instanceof PMA_Error) && ! $error->isDisplayed()) {
  62                         $_SESSION['errors'][$key] = $error;
  63                     }
  64                 }
  65             }
  66         }
  67     }
  68
  69     /**
  70      * returns array with all errors
  71      *
  72      * @uses    PMA_Error_Handler::$_errors as return value
  73      * @uses    PMA_Error_Handler::_checkSavedErrors()
  74      * @return array PMA_Error_Handler::$_errors
  75      */
  76     protected function getErrors()
  77     {
  78         $this->_checkSavedErrors();
  79         return $this->_errors;
  80     }
  81
  82     /**
  83      * Error handler - called when errors are triggered/occured
  84      *
  85      * The following error types cannot be handled with a user defined function:
  86      * E_ERROR, E_PARSE, E_CORE_ERROR, E_CORE_WARNING, E_COMPILE_ERROR,
  87      * E_COMPILE_WARNING,
  88      * and most of E_STRICT raised in the file where set_error_handler() is called.
  89      *
  90      * Do not use the context parameter as we want to avoid storing the
  91      * complete $GLOBALS inside $_SESSION['errors']
  92      *
  93      * @uses    E_USER_NOTICE
  94      * @uses    E_USER_WARNING
  95      * @uses    E_STRICT
  96      * @uses    E_NOTICE
  97      * @uses    E_WARNING
  98      * @uses    E_CORE_WARNING
  99      * @uses    E_COMPILE_WARNING
 100      * @uses    E_USER_ERROR
 101      * @uses    E_ERROR
 102      * @uses    E_PARSE
 103      * @uses    E_CORE_ERROR
 104      * @uses    E_COMPILE_ERROR
 105      * @uses    E_RECOVERABLE_ERROR
 106      * @uses    PMA_Error
 107      * @uses    PMA_Error_Handler::$_errors
 108      * @uses    PMA_Error_Handler::_dispFatalError()
 109      * @uses    PMA_Error::getHash()
 110      * @uses    PMA_Error::getNumber()
 111      * @param   integer $errno
 112      * @param   string  $errstr
 113      * @param   string  $errfile
 114      * @param   integer $errline
 115      */
 116     public function handleError($errno, $errstr, $errfile, $errline)
 117     {
 118         // create error object
 119         $error = new PMA_Error($errno, $errstr, $errfile, $errline);
 120
 121         // do not repeat errors
 122         $this->_errors[$error->getHash()] = $error;
 123
 124         switch ($error->getNumber()) {
 125             case E_USER_NOTICE:
 126             case E_USER_WARNING:
 127             case E_STRICT:
 128             case E_DEPRECATED:
 129             case E_NOTICE:
 130             case E_WARNING:
 131             case E_CORE_WARNING:
 132             case E_COMPILE_WARNING:
 133             case E_USER_ERROR:
 134             case E_RECOVERABLE_ERROR:
 135                 // just collect the error
 136                 // display is called from outside
 137                 break;
 138             case E_ERROR:
 139             case E_PARSE:
 140             case E_CORE_ERROR:
 141             case E_COMPILE_ERROR:
 142             default:
 143                 // FATAL error, dislay it and exit
 144                 $this->_dispFatalError($error);
 145                 exit;
 146                 break;
 147         }
 148     }
 149
 150     /**
 151      * log error to configured log facility
 152      *
 153      * @todo    finish!
 154      * @uses    PMA_Error::getMessage()
 155      * @uses    error_log()
 156      * @param   PMA_Error $error
 157      */
 158     protected function _logError($error)
 159     {
 160         return error_log($error->getMessage());
 161     }
 162
 163     /**
 164      * trigger a custom error
 165      *
 166      * @uses    trigger_error()
 167      * @param   string  $errorInfo
 168      * @param   integer $errorNumber
 169      * @param   string  $file
 170      * @param   integer $line
 171      */
 172     public function triggerError($errorInfo, $errorNumber = null, $file = null, $line = null)
 173     {
 174         // we could also extract file and line from backtrace and call handleError() directly
 175         trigger_error($errorInfo, $errorNumber);
 176     }
 177
 178     /**
 179      * display fatal error and exit
 180      *
 181      * @uses    headers_sent()
 182      * @uses    PMA_Error::display()
 183      * @uses    PMA_Error_Handler::_dispPageStart()
 184      * @uses    PMA_Error_Handler::_dispPageEnd()
 185      * @param   PMA_Error $error
 186      */
 187     protected function _dispFatalError($error)
 188     {
 189         if (! headers_sent()) {
 190             $this->_dispPageStart($error);
 191         }
 192         $error->display();
 193         $this->_dispPageEnd();
 194         exit;
 195     }
 196
 197     /**
 198      * display the whole error page with all errors
 199      *
 200      * @uses    headers_sent()
 201      * @uses    PMA_Error_Handler::dispAllErrors()
 202      * @uses    PMA_Error_Handler::_dispPageStart()
 203      * @uses    PMA_Error_Handler::_dispPageEnd()
 204      */
 205     public function dispErrorPage()
 206     {
 207         if (! headers_sent()) {
 208             $this->_dispPageStart();
 209         }
 210         $this->dispAllErrors();
 211         $this->_dispPageEnd();
 212     }
 213
 214     /**
 215      * display user errors not displayed
 216      *
 217      * @uses    PMA_Error_Handler::getErrors()
 218      * @uses    PMA_Error::isDisplayed()
 219      * @uses    PMA_Error::isUserError()
 220      * @uses    PMA_Error::display()
 221      */
 222     public function dispUserErrors()
 223     {
 224         foreach ($this->getErrors() as $error) {
 225             if ($error->isUserError() && ! $error->isDisplayed()) {
 226                 $error->display();
 227             }
 228         }
 229     }
 230
 231     /**
 232      * display HTML header
 233      *
 234      * @uses    PMA_Error::getTitle()
 235      * @param   PMA_error $error
 236      */
 237     protected function _dispPageStart($error = null)
 238     {
 239         echo '<html><head><title>';
 240         if ($error) {
 241             echo $error->getTitle();
 242         } else {
 243             echo 'phpMyAdmin error reporting page';
 244         }
 245         echo '</title></head>';
 246     }
 247
 248     /**
 249      * display HTML footer
 250      *
 251      */
 252     protected function _dispPageEnd()
 253     {
 254         echo '</body></html>';
 255     }
 256
 257     /**
 258      * display all errors regardless already displayed or user errors
 259      *
 260      * @uses    PMA_Error_Handler::getErrors()
 261      * @uses    PMA_Error::display()
 262      */
 263     public function dispAllErrors()
 264     {
 265         foreach ($this->getErrors() as $error) {
 266             $error->display();
 267         }
 268     }
 269
 270     /**
 271      * display errors not displayed
 272      *
 273      * @uses    $cfg['Error_Handler']['display']
 274      * @uses    PMA_Error_Handler::getErrors()
 275      * @uses    PMA_Error_Handler::dispUserErrors()
 276      * @uses    PMA_Error::isDisplayed()
 277      * @uses    PMA_Error::display()
 278      */
 279     public function dispErrors()
 280     {
 281         if ($GLOBALS['cfg']['Error_Handler']['display']) {
 282             foreach ($this->getErrors() as $error) {
 283                 if ($error instanceof PMA_Error) {
 284                     if (! $error->isDisplayed()) {
 285                         $error->display();
 286                     }
 287                 } else {
 288                     var_dump($error);
 289                 }
 290             }
 291         } else {
 292             $this->dispUserErrors();
 293         }
 294     }
 295
 296     /**
 297      * look in session for saved errors
 298      *
 299      * @uses    $_SESSION['errors']
 300      * @uses    PMA_Error_Handler::$_errors
 301      * @uses    array_merge()
 302      */
 303     protected function _checkSavedErrors()
 304     {
 305         if (isset($_SESSION['errors'])) {
 306
 307             // restore saved errors
 308             foreach ($_SESSION['errors'] as $hash => $error) {
 309                 if ($error instanceof PMA_Error && ! isset($this->_errors[$hash])) {
 310                     $this->_errors[$hash] = $error;
 311                 }
 312             }
 313             //$this->_errors = array_merge($_SESSION['errors'], $this->_errors);
 314
 315             // delet stored errors
 316             $_SESSION['errors'] = array();
 317             unset($_SESSION['errors']);
 318         }
 319     }
 320
 321     /**
 322      * return count of errors
 323      *
 324      * @uses    PMA_Error_Handler::getErrors()
 325      * @uses    count()
 326      * @return  integer number of errors occoured
 327      */
 328     public function countErrors()
 329     {
 330         return count($this->getErrors());
 331     }
 332
 333     /**
 334      * return count of user errors
 335      *
 336      * @uses    PMA_Error_Handler::countErrors()
 337      * @uses    PMA_Error_Handler::getErrors()
 338      * @uses    PMA_Error::isUserError()
 339      * @return  integer number of user errors occoured
 340      */
 341     public function countUserErrors()
 342     {
 343         $count = 0;
 344         if ($this->countErrors()) {
 345             foreach ($this->getErrors() as $error) {
 346                 if ($error->isUserError()) {
 347                     $count++;
 348                 }
 349             }
 350         }
 351
 352         return $count;
 353     }
 354
 355     /**
 356      * whether use errors occured or not
 357      *
 358      * @uses    PMA_Error_Handler::countUserErrors()
 359      * @return  boolean
 360      */
 361     public function hasUserErrors()
 362     {
 363         return (bool) $this->countUserErrors();
 364     }
 365
 366     /**
 367      * whether errors occured or not
 368      *
 369      * @uses    PMA_Error_Handler::countErrors()
 370      * @return  boolean
 371      */
 372     public function hasErrors()
 373     {
 374         return (bool) $this->countErrors();
 375     }
 376
 377     /**
 378      * number of errors to be displayed
 379      *
 380      * @uses    $cfg['Error_Handler']['display']
 381      * @uses    PMA_Error_Handler::countErrors()
 382      * @uses    PMA_Error_Handler::countUserErrors()
 383      * @return integer number of errors to be displayed
 384      */
 385     public function countDisplayErrors()
 386     {
 387         if ($GLOBALS['cfg']['Error_Handler']['display']) {
 388             return $this->countErrors();
 389         } else {
 390             return $this->countUserErrors();
 391         }
 392     }
 393
 394     /**
 395      * whether there are errors to display or not
 396      *
 397      * @uses    PMA_Error_Handler::countDisplayErrors()
 398      * @return boolean
 399      */
 400     public function hasDisplayErrors()
 401     {
 402         return (bool) $this->countDisplayErrors();
 403     }
 404 }
 405 ?>