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