lib/ErrorManager.php

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