lib/ErrorManager.php

   1 <?php // $Id$
   2
   3 if (isset($GLOBALS['ErrorManager'])) return;
   4
   5 // php5: ignore E_STRICT (var warnings)
   6 /*
   7 if (defined('E_STRICT')
   8     and (E_ALL & E_STRICT)
   9     and (error_reporting() & E_STRICT)) {
  10     echo " errormgr: error_reporting=", error_reporting();
  11     echo "\nplease fix that in your php.ini!";
  12     error_reporting(E_ALL & ~E_STRICT);
  13 }
  14 */
  15 define ('EM_FATAL_ERRORS', E_ERROR | E_PARSE | E_CORE_ERROR | E_COMPILE_ERROR | E_USER_ERROR | ~2048 & ((check_php_version(5,3)) ? ~E_DEPRECATED : ~0));
  16 define ('EM_WARNING_ERRORS',
  17     E_WARNING | E_CORE_WARNING | E_COMPILE_WARNING | E_USER_WARNING | ((check_php_version(5,3)) ? E_DEPRECATED : 0));
  18 define ('EM_NOTICE_ERRORS', E_NOTICE | E_USER_NOTICE);
  19
  20 /* It is recommended to leave assertions on.
  21    You can simply comment the two lines below to leave them on.
  22    Only where absolute speed is necessary you might want to turn
  23    them off.
  24 */
  25 //also turn it on if phpwiki_version notes no release
  26 if (defined('DEBUG') and DEBUG)
  27     assert_options (ASSERT_ACTIVE, 1);
  28 else
  29     assert_options (ASSERT_ACTIVE, 0);
  30 assert_options (ASSERT_CALLBACK, 'wiki_assert_handler');
  31
  32 function wiki_assert_handler ($file, $line, $code) {
  33     ErrorManager_errorHandler( $code, sprintf("<br />%s:%s: %s: Assertion failed <br />", $file, $line, $code), $file, $line);
  34 }
  35
  36 /**
  37  * A class which allows custom handling of PHP errors.
  38  *
  39  * This is a singleton class. There should only be one instance
  40  * of it --- you can access the one instance via $GLOBALS['ErrorManager'].
  41  *
  42  * FIXME: more docs.
  43  */
  44 class ErrorManager
  45 {
  46     /**
  47      * Constructor.
  48      *
  49      * As this is a singleton class, you should never call this.
  50      * @access private
  51      */
  52     function ErrorManager() {
  53         $this->_handlers = array();
  54         $this->_fatal_handler = false;
  55         $this->_postpone_mask = 0;
  56         $this->_postponed_errors = array();
  57
  58         set_error_handler('ErrorManager_errorHandler');
  59     }
  60
  61     /**
  62      * Get mask indicating which errors are currently being postponed.
  63      * @access public
  64      * @return int The current postponed error mask.
  65      */
  66     function getPostponedErrorMask() {
  67         return $this->_postpone_mask;
  68     }
  69
  70     /**
  71      * Set mask indicating which errors to postpone.
  72      *
  73      * The default value of the postpone mask is zero (no errors postponed.)
  74      *
  75      * When you set this mask, any queue errors which do not match the new
  76      * mask are reported.
  77      *
  78      * @access public
  79      * @param $newmask int The new value for the mask.
  80      */
  81     function setPostponedErrorMask($newmask) {
  82         $this->_postpone_mask = $newmask;
  83         if (function_exists('PrintXML'))
  84             PrintXML($this->_flush_errors($newmask));
  85         else
  86             echo($this->_flush_errors($newmask));
  87
  88     }
  89
  90     /**
  91      * Report any queued error messages.
  92      * @access public
  93      */
  94     function flushPostponedErrors() {
  95         if (function_exists('PrintXML'))
  96             PrintXML($this->_flush_errors());
  97         else
  98             echo $this->_flush_errors();
  99     }
 100
 101     /**
 102      * Get rid of all pending error messages in case of all non-html
 103      * - pdf or image - output.
 104      * @access public
 105      */
 106     function destroyPostponedErrors () {
 107         $this->_postponed_errors = array();
 108     }
 109
 110     /**
 111      * Get postponed errors, formatted as HTML.
 112      *
 113      * This also flushes the postponed error queue.
 114      *
 115      * @return object HTML describing any queued errors (or false, if none).
 116      */
 117     function getPostponedErrorsAsHTML() {
 118         $flushed = $this->_flush_errors();
 119         if (!$flushed)
 120             return false;
 121         if ($flushed->isEmpty())
 122             return false;
 123         // format it with the worst class (error, warning, notice)
 124         $worst_err = $flushed->_content[0];
 125         foreach ($flushed->_content as $err) {
 126             if ($err and isa($err, 'PhpError') and $err->errno > $worst_err->errno) {
 127                 $worst_err = $err;
 128             }
 129         }
 130         if ($worst_err->isNotice())
 131             return $flushed;
 132         $class = $worst_err->getHtmlClass();
 133         $html = HTML::div(array('class' => $class),
 134                           HTML::div(array('class' => 'errors'),
 135                                    "PHP " . $worst_err->getDescription()));
 136         $html->pushContent($flushed);
 137         return $html;
 138     }
 139
 140     /**
 141      * Push a custom error handler on the handler stack.
 142      *
 143      * Sometimes one is performing an operation where one expects
 144      * certain errors or warnings. In this case, one might not want
 145      * these errors reported in the normal manner. Installing a custom
 146      * error handler via this method allows one to intercept such
 147      * errors.
 148      *
 149      * An error handler installed via this method should be either a
 150      * function or an object method taking one argument: a PhpError
 151      * object.
 152      *
 153      * The error handler should return either:
 154      * <dl>
 155      * <dt> False <dd> If it has not handled the error. In this case,
 156      *                 error processing will proceed as if the handler
 157      *                 had never been called: the error will be passed
 158      *                 to the next handler in the stack, or the
 159      *                 default handler, if there are no more handlers
 160      *                 in the stack.
 161      *
 162      * <dt> True <dd> If the handler has handled the error. If the
 163      *                error was a non-fatal one, no further processing
 164      *                will be done. If it was a fatal error, the
 165      *                ErrorManager will still terminate the PHP
 166      *                process (see setFatalHandler.)
 167      *
 168      * <dt> A PhpError object <dd> The error is not considered
 169      *                             handled, and will be passed on to
 170      *                             the next handler(s) in the stack
 171      *                             (or the default handler). The
 172      *                             returned PhpError need not be the
 173      *                             same as the one passed to the
 174      *                             handler. This allows the handler to
 175      *                             "adjust" the error message.
 176      * </dl>
 177      * @access public
 178      * @param $handler WikiCallback  Handler to call.
 179      */
 180     function pushErrorHandler($handler) {
 181         array_unshift($this->_handlers, $handler);
 182     }
 183
 184     /**
 185      * Pop an error handler off the handler stack.
 186      * @access public
 187      */
 188     function popErrorHandler() {
 189         return array_shift($this->_handlers);
 190     }
 191
 192     /**
 193      * Set a termination handler.
 194      *
 195      * This handler will be called upon fatal errors. The handler
 196      * gets passed one argument: a PhpError object describing the
 197      * fatal error.
 198      *
 199      * @access public
 200      * @param $handler WikiCallback  Callback to call on fatal errors.
 201      */
 202     function setFatalHandler($handler) {
 203         $this->_fatal_handler = $handler;
 204     }
 205
 206     /**
 207      * Handle an error.
 208      *
 209      * The error is passed through any registered error handlers, and
 210      * then either reported or postponed.
 211      *
 212      * @access public
 213      * @param $error object A PhpError object.
 214      */
 215     function handleError($error) {
 216         static $in_handler;
 217
 218         if (!empty($in_handler)) {
 219             $msg = $error->_getDetail();
 220             $msg->unshiftContent(HTML::h2(fmt("%s: error while handling error:",
 221                                               "ErrorManager")));
 222             $msg->printXML();
 223             return;
 224         }
 225
 226         // template which flushed the pending errors already handled,
 227         // so display now all errors directly.
 228         if (!empty($GLOBALS['request']->_finishing)) {
 229             $this->_postpone_mask = 0;
 230     }
 231
 232         $in_handler = true;
 233
 234         foreach ($this->_handlers as $handler) {
 235             if (!$handler) continue;
 236             $result = $handler->call($error);
 237             if (!$result) {
 238                 continue;       // Handler did not handle error.
 239             }
 240             elseif (is_object($result)) {
 241                 // handler filtered the result. Still should pass to
 242                 // the rest of the chain.
 243                 if ($error->isFatal()) {
 244                     // Don't let handlers make fatal errors non-fatal.
 245                     $result->errno = $error->errno;
 246                 }
 247                 $error = $result;
 248             }
 249             else {
 250                 // Handler handled error.
 251                 if (!$error->isFatal()) {
 252                     $in_handler = false;
 253                     return;
 254                 }
 255                 break;
 256             }
 257         }
 258
 259         // Error was either fatal, or was not handled by a handler.
 260         // Handle it ourself.
 261         if ($error->isFatal()) {
 262             $this->_noCacheHeaders();
 263             echo "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
 264             echo "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\"\n";
 265         echo "\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n";
 266             echo "<html>\n";
 267             echo "<head>\n";
 268             echo "<meta http-equiv=\"Content-Type\" content=\"text/html; charset=UTF-8\" />\n";
 269             echo "<title>Fatal Error</title>\n";
 270             echo "<link rel=\"stylesheet\" type=\"text/css\" href=\"themes/default/phpwiki.css\" />\n";
 271             echo "</head>\n";
 272             echo "<body>\n";
 273             echo "<div style=\"font-weight:bold; color:red\">Fatal Error:</div>\n";
 274
 275             if (defined('DEBUG') and (DEBUG & _DEBUG_TRACE)) {
 276                 echo "error_reporting=",error_reporting(),"\n<br />";
 277                 $error->printSimpleTrace(debug_backtrace());
 278             }
 279         $this->_die($error);
 280         }
 281         else if (($error->errno & error_reporting()) != 0) {
 282             if  (($error->errno & $this->_postpone_mask) != 0) {
 283                 if ((function_exists('isa') and isa($error, 'PhpErrorOnce'))
 284                     or (!function_exists('isa') and
 285                     (
 286                      // stdlib independent isa()
 287                      (strtolower(get_class($error)) == 'phperroronce')
 288                      or (is_subclass_of($error, 'PhpErrorOnce'))))) {
 289                     $error->removeDoublettes($this->_postponed_errors);
 290                     if ( $error->_count < 2 )
 291                         $this->_postponed_errors[] = $error;
 292                 } else {
 293                     $this->_postponed_errors[] = $error;
 294                 }
 295             }
 296             else {
 297                 //echo "postponed errors: ";
 298                 $this->_noCacheHeaders();
 299                 if (defined('DEBUG') and (DEBUG & _DEBUG_TRACE)) {
 300                     echo "error_reporting=",error_reporting(),"\n";
 301                     $error->printSimpleTrace(debug_backtrace());
 302                 }
 303                 $error->printXML();
 304             }
 305         }
 306         $in_handler = false;
 307     }
 308
 309     function warning($msg, $errno = E_USER_NOTICE) {
 310         $this->handleError(new PhpWikiError($errno, $msg, '?', '?'));
 311     }
 312
 313     /**
 314      * @access private
 315      */
 316     function _die($error) {
 317         global $WikiTheme;
 318         //echo "\n\n<html><body>";
 319         $error->printXML();
 320         PrintXML($this->_flush_errors());
 321         if ($this->_fatal_handler)
 322             $this->_fatal_handler->call($error);
 323     if (!$WikiTheme->DUMP_MODE)
 324         exit -1;
 325     }
 326
 327     /**
 328      * @access private
 329      */
 330     function _flush_errors($keep_mask = 0) {
 331         $errors = &$this->_postponed_errors;
 332         if (empty($errors)) return '';
 333         $flushed = HTML();
 334         for ($i=0; $i<count($errors); $i++) {
 335             $error =& $errors[$i];
 336             if (!is_object($error)) {
 337                 continue;
 338             }
 339             if (($error->errno & $keep_mask) != 0)
 340                 continue;
 341             unset($errors[$i]);
 342             $flushed->pushContent($error);
 343         }
 344         return $flushed;
 345     }
 346
 347     function _noCacheHeaders() {
 348         global $request;
 349         static $already = false;
 350
 351         if (isset($request) and isset($request->_validators)) {
 352             $request->_validators->_tag = false;
 353             $request->_validators->_mtime = false;
 354         }
 355         if ($already) return;
 356
 357         // FIXME: Howto announce that to Request->cacheControl()?
 358         if (!headers_sent()) {
 359             header( "Cache-control: no-cache" );
 360             header( "Pragma: nocache" );
 361         }
 362         $already = true;
 363     }
 364 }
 365
 366 /**
 367  * Global error handler for class ErrorManager.
 368  *
 369  * This is necessary since PHP's set_error_handler() does not allow
 370  * one to set an object method as a handler.
 371  *
 372  * @access private
 373  */
 374 function ErrorManager_errorHandler($errno, $errstr, $errfile, $errline)
 375 {
 376     if (!isset($GLOBALS['ErrorManager'])) {
 377       $GLOBALS['ErrorManager'] = new ErrorManager;
 378     }
 379
 380     if (defined('DEBUG') and DEBUG) {
 381         $error = new PhpError($errno, $errstr, $errfile, $errline);
 382     } else {
 383         $error = new PhpErrorOnce($errno, $errstr, $errfile, $errline);
 384     }
 385     $GLOBALS['ErrorManager']->handleError($error);
 386 }
 387
 388 /**
 389  * A class representing a PHP error report.
 390  *
 391  * @see The PHP documentation for set_error_handler at
 392  *      http://php.net/manual/en/function.set-error-handler.php .
 393  */
 394 class PhpError {
 395     /**
 396      * The PHP errno
 397      */
 398     //var $errno;
 399
 400     /**
 401      * The PHP error message.
 402      */
 403     //var $errstr;
 404
 405     /**
 406      * The source file where the error occurred.
 407      */
 408     //var $errfile;
 409
 410     /**
 411      * The line number (in $this->errfile) where the error occured.
 412      */
 413     //var $errline;
 414
 415     /**
 416      * Construct a new PhpError.
 417      * @param $errno   int
 418      * @param $errstr  string
 419      * @param $errfile string
 420      * @param $errline int
 421      */
 422     function PhpError($errno, $errstr, $errfile, $errline) {
 423         $this->errno   = $errno;
 424         $this->errstr  = $errstr;
 425         $this->errfile = $errfile;
 426         $this->errline = $errline;
 427     }
 428
 429     /**
 430      * Determine whether this is a fatal error.
 431      * @return boolean True if this is a fatal error.
 432      */
 433     function isFatal() {
 434         return ($this->errno & (2048|EM_WARNING_ERRORS|EM_NOTICE_ERRORS)) == 0;
 435     }
 436
 437     /**
 438      * Determine whether this is a warning level error.
 439      * @return boolean
 440      */
 441     function isWarning() {
 442         return ($this->errno & EM_WARNING_ERRORS) != 0;
 443     }
 444
 445     /**
 446      * Determine whether this is a notice level error.
 447      * @return boolean
 448      */
 449     function isNotice() {
 450         return ($this->errno & EM_NOTICE_ERRORS) != 0;
 451     }
 452     function getHtmlClass() {
 453         if ($this->isNotice()) {
 454             return 'hint';
 455         } elseif ($this->isWarning()) {
 456             return 'warning';
 457         } else {
 458             return 'errors';
 459         }
 460     }
 461
 462     function getDescription() {
 463         if ($this->isNotice()) {
 464             return 'Notice';
 465         } elseif ($this->isWarning()) {
 466             return 'Warning';
 467         } else {
 468             return 'Error';
 469         }
 470     }
 471
 472     /**
 473      * Get a printable, HTML, message detailing this error.
 474      * @return object The detailed error message.
 475      */
 476     function _getDetail() {
 477         $dir = defined('PHPWIKI_DIR') ? PHPWIKI_DIR : substr(dirname(__FILE__),0,-4);
 478         if (substr(PHP_OS,0,3) == 'WIN') {
 479            $dir = str_replace('/','\\',$dir);
 480            $this->errfile = str_replace('/','\\',$this->errfile);
 481            $dir .= "\\";
 482         } else
 483            $dir .= '/';
 484         $errfile = preg_replace('|^' . preg_quote($dir) . '|', '', $this->errfile);
 485         $lines = explode("\n", $this->errstr);
 486         if (DEBUG & _DEBUG_VERBOSE) {
 487           $msg = sprintf("%s:%d %s[%d]: %s",
 488                          $errfile, $this->errline,
 489                          $this->getDescription(), $this->errno,
 490                          array_shift($lines));
 491         }/* elseif (! $this->isFatal()) {
 492           $msg = sprintf("%s:%d %s: \"%s\"",
 493                          $errfile, $this->errline,
 494                          $this->getDescription(),
 495                          array_shift($lines));
 496         }*/ else {
 497           $msg = sprintf("%s:%d %s: \"%s\"",
 498                          $errfile, $this->errline,
 499                          $this->getDescription(),
 500                          array_shift($lines));
 501         }
 502
 503         $html = HTML::div(array('class' => $this->getHtmlClass()), HTML::p($msg));
 504         // The class is now used for the div container.
 505         // $html = HTML::div(HTML::p($msg));
 506         if ($lines) {
 507             $list = HTML::ul();
 508             foreach ($lines as $line)
 509                 $list->pushContent(HTML::li($line));
 510             $html->pushContent($list);
 511         }
 512
 513         return $html;
 514     }
 515
 516     /**
 517      * Print an HTMLified version of this error.
 518      * @see asXML()
 519      */
 520     function printXML() {
 521         PrintXML($this->_getDetail());
 522     }
 523
 524     /**
 525      * Return an HTMLified version of this error.
 526      */
 527     function asXML() {
 528         return AsXML($this->_getDetail());
 529     }
 530
 531     /**
 532      * Return a plain-text version of this error.
 533      */
 534     function asString() {
 535         return AsString($this->_getDetail());
 536     }
 537
 538     function printSimpleTrace($bt) {
 539         global $HTTP_SERVER_VARS;
 540         $nl = isset($HTTP_SERVER_VARS['REQUEST_METHOD']) ? "<br />" : "\n";
 541         echo $nl."Traceback:".$nl;
 542         foreach ($bt as $i => $elem) {
 543             if (!array_key_exists('file', $elem)) {
 544                 continue;
 545             }
 546             print "  " . $elem['file'] . ':' . $elem['line'] . $nl;
 547         }
 548         flush();
 549     }
 550 }
 551
 552 /**
 553  * A class representing a PhpWiki warning.
 554  *
 555  * This is essentially the same as a PhpError, except that the
 556  * error message is quieter: no source line, etc...
 557  */
 558 class PhpWikiError extends PhpError {
 559     /**
 560      * Construct a new PhpError.
 561      * @param $errno   int
 562      * @param $errstr  string
 563      */
 564     function PhpWikiError($errno, $errstr, $errfile, $errline) {
 565         $this->PhpError($errno, $errstr, $errfile, $errline);
 566     }
 567
 568     function _getDetail() {
 569         return HTML::div(array('class' => $this->getHtmlClass()),
 570                          HTML::p($this->getDescription() . ": $this->errstr"));
 571     }
 572 }
 573
 574 /**
 575  * A class representing a Php warning, printed only the first time.
 576  *
 577  * Similar to PhpError, except only the first same error message is printed,
 578  * with number of occurences.
 579  */
 580 class PhpErrorOnce extends PhpError {
 581
 582     function PhpErrorOnce($errno, $errstr, $errfile, $errline) {
 583         $this->_count = 1;
 584         $this->PhpError($errno, $errstr, $errfile, $errline);
 585     }
 586
 587     function _sameError($error) {
 588         if (!$error) return false;
 589         return ($this->errno == $error->errno and
 590                 $this->errfile == $error->errfile and
 591                 $this->errline == $error->errline);
 592     }
 593
 594     // count similar handlers, increase _count and remove the rest
 595     function removeDoublettes(&$errors) {
 596         for ($i=0; $i < count($errors); $i++) {
 597             if (!isset($errors[$i])) continue;
 598             if ($this->_sameError($errors[$i])) {
 599                 $errors[$i]->_count++;
 600                 $this->_count++;
 601                 if ($i) unset($errors[$i]);
 602             }
 603         }
 604         return $this->_count;
 605     }
 606
 607     function _getDetail($count=0) {
 608         if (!$count) $count = $this->_count;
 609     $dir = defined('PHPWIKI_DIR') ? PHPWIKI_DIR : substr(dirname(__FILE__),0,-4);
 610         if (substr(PHP_OS,0,3) == 'WIN') {
 611            $dir = str_replace('/','\\',$dir);
 612            $this->errfile = str_replace('/','\\',$this->errfile);
 613            $dir .= "\\";
 614         } else
 615            $dir .= '/';
 616         $errfile = preg_replace('|^' . preg_quote($dir) . '|', '', $this->errfile);
 617         if (is_string($this->errstr))
 618             $lines = explode("\n", $this->errstr);
 619     elseif (is_object($this->errstr))
 620             $lines = array($this->errstr->asXML());
 621         $errtype = (DEBUG & _DEBUG_VERBOSE) ? sprintf("%s[%d]", $this->getDescription(), $this->errno)
 622                                             : sprintf("%s", $this->getDescription());
 623         if ((DEBUG & _DEBUG_VERBOSE) or $this->isFatal()) {
 624         $msg = sprintf("%s:%d %s: %s %s",
 625                        $errfile, $this->errline,
 626                        $errtype,
 627                        array_shift($lines),
 628                        $count > 1 ? sprintf(" (...repeated %d times)",$count) : ""
 629                        );
 630     } else {
 631           $msg = sprintf("%s: \"%s\" %s",
 632              $errtype,
 633              array_shift($lines),
 634              $count > 1 ? sprintf(" (...repeated %d times)",$count) : "");
 635     }
 636         $html = HTML::div(array('class' => $this->getHtmlClass()),
 637                           HTML::p($msg));
 638         if ($lines) {
 639             $list = HTML::ul();
 640             foreach ($lines as $line)
 641                 $list->pushContent(HTML::li($line));
 642             $html->pushContent($list);
 643         }
 644
 645         return $html;
 646     }
 647 }
 648
 649 if (check_php_version(5,2)) {
 650     require_once(dirname(__FILE__).'/HtmlElement5.php');
 651 } else {
 652     require_once(dirname(__FILE__).'/HtmlElement.php');
 653 }
 654
 655 if (!isset($GLOBALS['ErrorManager'])) {
 656     $GLOBALS['ErrorManager'] = new ErrorManager;
 657 }
 658
 659 // Local Variables:
 660 // mode: php
 661 // tab-width: 8
 662 // c-basic-offset: 4
 663 // c-hanging-comment-ender-p: nil
 664 // indent-tabs-mode: nil
 665 // End:
 666 ?>