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