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      * Do not use the context parameter as we want to avoid storing the
  92      * complete $GLOBALS inside $_SESSION['errors']
  93      *
  94      * @uses    E_USER_NOTICE
  95      * @uses    E_USER_WARNING
  96      * @uses    E_STRICT
  97      * @uses    E_NOTICE
  98      * @uses    E_WARNING
  99      * @uses    E_CORE_WARNING
 100      * @uses    E_COMPILE_WARNING
 101      * @uses    E_USER_ERROR
 102      * @uses    E_ERROR
 103      * @uses    E_PARSE
 104      * @uses    E_CORE_ERROR
 105      * @uses    E_COMPILE_ERROR
 106      * @uses    E_RECOVERABLE_ERROR
 107      * @uses    PMA_Error
 108      * @uses    PMA_Error_Handler::$_errors
 109      * @uses    PMA_Error_Handler::_dispFatalError()
 110      * @uses    PMA_Error::getHash()
 111      * @uses    PMA_Error::getNumber()
 112      * @param   integer $errno
 113      * @param   string  $errstr
 114      * @param   string  $errfile
 115      * @param   integer $errline
 116      */
 117     public function handleError($errno, $errstr, $errfile, $errline)
 118     {
 119         // create error object
 120         $error = new PMA_Error($errno, $errstr, $errfile, $errline);
 121
 122         // do not repeat errors
 123         $this->_errors[$error->getHash()] = $error;
 124
 125         switch ($error->getNumber()) {
 126             case E_USER_NOTICE:
 127             case E_USER_WARNING:
 128             case E_STRICT:
 129             case E_DEPRECATED:
 130             case E_NOTICE:
 131             case E_WARNING:
 132             case E_CORE_WARNING:
 133             case E_COMPILE_WARNING:
 134             case E_USER_ERROR:
 135             case E_RECOVERABLE_ERROR:
 136                 // just collect the error
 137                 // display is called from outside
 138                 break;
 139             case E_ERROR:
 140             case E_PARSE:
 141             case E_CORE_ERROR:
 142             case E_COMPILE_ERROR:
 143             default:
 144                 // FATAL error, dislay it and exit
 145                 $this->_dispFatalError($error);
 146                 exit;
 147                 break;
 148         }
 149     }
 150
 151     /**
 152      * log error to configured log facility
 153      *
 154      * @todo    finish!
 155      * @uses    PMA_Error::getMessage()
 156      * @uses    error_log()
 157      * @param   PMA_Error $error
 158      */
 159     protected function _logError($error)
 160     {
 161         return error_log($error->getMessage());
 162     }
 163
 164     /**
 165      * trigger a custom error
 166      *
 167      * @uses    trigger_error()
 168      * @param   string  $errorInfo
 169      * @param   integer $errorNumber
 170      * @param   string  $file
 171      * @param   integer $line
 172      */
 173     public function triggerError($errorInfo, $errorNumber = null, $file = null, $line = null)
 174     {
 175         // we could also extract file and line from backtrace and call handleError() directly
 176         trigger_error($errorInfo, $errorNumber);
 177     }
 178
 179     /**
 180      * display fatal error and exit
 181      *
 182      * @uses    headers_sent()
 183      * @uses    PMA_Error::display()
 184      * @uses    PMA_Error_Handler::_dispPageStart()
 185      * @uses    PMA_Error_Handler::_dispPageEnd()
 186      * @param   PMA_Error $error
 187      */
 188     protected function _dispFatalError($error)
 189     {
 190         if (! headers_sent()) {
 191             $this->_dispPageStart($error);
 192         }
 193         $error->display();
 194         $this->_dispPageEnd();
 195         exit;
 196     }
 197
 198     /**
 199      * display the whole error page with all errors
 200      *
 201      * @uses    headers_sent()
 202      * @uses    PMA_Error_Handler::dispAllErrors()
 203      * @uses    PMA_Error_Handler::_dispPageStart()
 204      * @uses    PMA_Error_Handler::_dispPageEnd()
 205      */
 206     public function dispErrorPage()
 207     {
 208         if (! headers_sent()) {
 209             $this->_dispPageStart();
 210         }
 211         $this->dispAllErrors();
 212         $this->_dispPageEnd();
 213     }
 214
 215     /**
 216      * display user errors not displayed
 217      *
 218      * @uses    PMA_Error_Handler::getErrors()
 219      * @uses    PMA_Error::isDisplayed()
 220      * @uses    PMA_Error::isUserError()
 221      * @uses    PMA_Error::display()
 222      */
 223     public function dispUserErrors()
 224     {
 225         foreach ($this->getErrors() as $error) {
 226             if ($error->isUserError() && ! $error->isDisplayed()) {
 227                 $error->display();
 228             }
 229         }
 230     }
 231
 232     /**
 233      * display HTML header
 234      *
 235      * @uses    PMA_Error::getTitle()
 236      * @param   PMA_error $error
 237      */
 238     protected function _dispPageStart($error = null)
 239     {
 240         echo '<html><head><title>';
 241         if ($error) {
 242             echo $error->getTitle();
 243         } else {
 244             echo 'phpMyAdmin error reporting page';
 245         }
 246         echo '</title></head>';
 247     }
 248
 249     /**
 250      * display HTML footer
 251      *
 252      */
 253     protected function _dispPageEnd()
 254     {
 255         echo '</body></html>';
 256     }
 257
 258     /**
 259      * display all errors regardless already displayed or user errors
 260      *
 261      * @uses    PMA_Error_Handler::getErrors()
 262      * @uses    PMA_Error::display()
 263      */
 264     public function dispAllErrors()
 265     {
 266         foreach ($this->getErrors() as $error) {
 267             $error->display();
 268         }
 269     }
 270
 271     /**
 272      * display errors not displayed
 273      *
 274      * @uses    $cfg['Error_Handler']['display']
 275      * @uses    PMA_Error_Handler::getErrors()
 276      * @uses    PMA_Error_Handler::dispUserErrors()
 277      * @uses    PMA_Error::isDisplayed()
 278      * @uses    PMA_Error::display()
 279      */
 280     public function dispErrors()
 281     {
 282         if ($GLOBALS['cfg']['Error_Handler']['display']) {
 283             foreach ($this->getErrors() as $error) {
 284                 if ($error instanceof PMA_Error) {
 285                     if (! $error->isDisplayed()) {
 286                         $error->display();
 287                     }
 288                 } else {
 289                     var_dump($error);
 290                 }
 291             }
 292         } else {
 293             $this->dispUserErrors();
 294         }
 295     }
 296
 297     /**
 298      * look in session for saved errors
 299      *
 300      * @uses    $_SESSION['errors']
 301      * @uses    PMA_Error_Handler::$_errors
 302      * @uses    array_merge()
 303      */
 304     protected function _checkSavedErrors()
 305     {
 306         if (isset($_SESSION['errors'])) {
 307
 308             // restore saved errors
 309             foreach ($_SESSION['errors'] as $hash => $error) {
 310                 if ($error instanceof PMA_Error && ! isset($this->_errors[$hash])) {
 311                     $this->_errors[$hash] = $error;
 312                 }
 313             }
 314             //$this->_errors = array_merge($_SESSION['errors'], $this->_errors);
 315
 316             // delet stored errors
 317             $_SESSION['errors'] = array();
 318             unset($_SESSION['errors']);
 319         }
 320     }
 321
 322     /**
 323      * return count of errors
 324      *
 325      * @uses    PMA_Error_Handler::getErrors()
 326      * @uses    count()
 327      * @return  integer number of errors occoured
 328      */
 329     public function countErrors()
 330     {
 331         return count($this->getErrors());
 332     }
 333
 334     /**
 335      * return count of user errors
 336      *
 337      * @uses    PMA_Error_Handler::countErrors()
 338      * @uses    PMA_Error_Handler::getErrors()
 339      * @uses    PMA_Error::isUserError()
 340      * @return  integer number of user errors occoured
 341      */
 342     public function countUserErrors()
 343     {
 344         $count = 0;
 345         if ($this->countErrors()) {
 346             foreach ($this->getErrors() as $error) {
 347                 if ($error->isUserError()) {
 348                     $count++;
 349                 }
 350             }
 351         }
 352
 353         return $count;
 354     }
 355
 356     /**
 357      * whether use errors occured or not
 358      *
 359      * @uses    PMA_Error_Handler::countUserErrors()
 360      * @return  boolean
 361      */
 362     public function hasUserErrors()
 363     {
 364         return (bool) $this->countUserErrors();
 365     }
 366
 367     /**
 368      * whether errors occured or not
 369      *
 370      * @uses    PMA_Error_Handler::countErrors()
 371      * @return  boolean
 372      */
 373     public function hasErrors()
 374     {
 375         return (bool) $this->countErrors();
 376     }
 377
 378     /**
 379      * number of errors to be displayed
 380      *
 381      * @uses    $cfg['Error_Handler']['display']
 382      * @uses    PMA_Error_Handler::countErrors()
 383      * @uses    PMA_Error_Handler::countUserErrors()
 384      * @return integer number of errors to be displayed
 385      */
 386     public function countDisplayErrors()
 387     {
 388         if ($GLOBALS['cfg']['Error_Handler']['display']) {
 389             return $this->countErrors();
 390         } else {
 391             return $this->countUserErrors();
 392         }
 393     }
 394
 395     /**
 396      * whether there are errors to display or not
 397      *
 398      * @uses    PMA_Error_Handler::countDisplayErrors()
 399      * @return boolean
 400      */
 401     public function hasDisplayErrors()
 402     {
 403         return (bool) $this->countDisplayErrors();
 404     }
 405 }
 406 ?>