includes/Exception.php

   1 <?php
   2 /**
   3  * Exception class and handler.
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  18  * http://www.gnu.org/copyleft/gpl.html
  19  *
  20  * @file
  21  */
  22
  23 /**
  24  * @defgroup Exception Exception
  25  */
  26
  27 /**
  28  * MediaWiki exception
  29  *
  30  * @ingroup Exception
  31  */
  32 class MWException extends Exception {
  33
  34         /**
  35          * Should the exception use $wgOut to output the error?
  36          *
  37          * @return bool
  38          */
  39         function useOutputPage() {
  40                 return $this->useMessageCache() &&
  41                         !empty( $GLOBALS['wgFullyInitialised'] ) &&
  42                         !empty( $GLOBALS['wgOut'] ) &&
  43                         !empty( $GLOBALS['wgTitle'] );
  44         }
  45
  46         /**
  47          * Can the extension use the Message class/wfMessage to get i18n-ed messages?
  48          *
  49          * @return bool
  50          */
  51         function useMessageCache() {
  52                 global $wgLang;
  53
  54                 foreach ( $this->getTrace() as $frame ) {
  55                         if ( isset( $frame['class'] ) && $frame['class'] === 'LocalisationCache' ) {
  56                                 return false;
  57                         }
  58                 }
  59
  60                 return $wgLang instanceof Language;
  61         }
  62
  63         /**
  64          * Run hook to allow extensions to modify the text of the exception
  65          *
  66          * @param string $name class name of the exception
  67          * @param array $args arguments to pass to the callback functions
  68          * @return string|null string to output or null if any hook has been called
  69          */
  70         function runHooks( $name, $args = array() ) {
  71                 global $wgExceptionHooks;
  72
  73                 if ( !isset( $wgExceptionHooks ) || !is_array( $wgExceptionHooks ) ) {
  74                         return null; // Just silently ignore
  75                 }
  76
  77                 if ( !array_key_exists( $name, $wgExceptionHooks ) || !is_array( $wgExceptionHooks[$name] ) ) {
  78                         return null;
  79                 }
  80
  81                 $hooks = $wgExceptionHooks[$name];
  82                 $callargs = array_merge( array( $this ), $args );
  83
  84                 foreach ( $hooks as $hook ) {
  85                         if ( is_string( $hook ) || ( is_array( $hook ) && count( $hook ) >= 2 && is_string( $hook[0] ) ) ) { // 'function' or array( 'class', hook' )
  86                                 $result = call_user_func_array( $hook, $callargs );
  87                         } else {
  88                                 $result = null;
  89                         }
  90
  91                         if ( is_string( $result ) ) {
  92                                 return $result;
  93                         }
  94                 }
  95                 return null;
  96         }
  97
  98         /**
  99          * Get a message from i18n
 100          *
 101          * @param string $key message name
 102          * @param string $fallback default message if the message cache can't be
 103          *                  called by the exception
 104          * The function also has other parameters that are arguments for the message
 105          * @return string message with arguments replaced
 106          */
 107         function msg( $key, $fallback /*[, params...] */ ) {
 108                 $args = array_slice( func_get_args(), 2 );
 109
 110                 if ( $this->useMessageCache() ) {
 111                         return wfMessage( $key, $args )->plain();
 112                 } else {
 113                         return wfMsgReplaceArgs( $fallback, $args );
 114                 }
 115         }
 116
 117         /**
 118          * If $wgShowExceptionDetails is true, return a HTML message with a
 119          * backtrace to the error, otherwise show a message to ask to set it to true
 120          * to show that information.
 121          *
 122          * @return string html to output
 123          */
 124         function getHTML() {
 125                 global $wgShowExceptionDetails;
 126
 127                 if ( $wgShowExceptionDetails ) {
 128                         return '<p>' . nl2br( htmlspecialchars( $this->getMessage() ) ) .
 129                                 '</p><p>Backtrace:</p><p>' . nl2br( htmlspecialchars( MWExceptionHandler::formatRedactedTrace( $this ) ) ) .
 130                                 "</p>\n";
 131                 } else {
 132                         return "<div class=\"errorbox\">" .
 133                                 '[' . MWExceptionHandler::getLogId( $this ) . '] ' .
 134                                 gmdate( 'Y-m-d H:i:s' ) .
 135                                 ": Fatal exception of type " . get_class( $this ) . "</div>\n" .
 136                                 "<!-- Set \$wgShowExceptionDetails = true; " .
 137                                 "at the bottom of LocalSettings.php to show detailed " .
 138                                 "debugging information. -->";
 139                 }
 140         }
 141
 142         /**
 143          * Get the text to display when reporting the error on the command line.
 144          * If $wgShowExceptionDetails is true, return a text message with a
 145          * backtrace to the error.
 146          *
 147          * @return string
 148          */
 149         function getText() {
 150                 global $wgShowExceptionDetails;
 151
 152                 if ( $wgShowExceptionDetails ) {
 153                         return $this->getMessage() .
 154                                 "\nBacktrace:\n" . MWExceptionHandler::formatRedactedTrace( $this ) . "\n";
 155                 } else {
 156                         return "Set \$wgShowExceptionDetails = true; " .
 157                                 "in LocalSettings.php to show detailed debugging information.\n";
 158                 }
 159         }
 160
 161         /**
 162          * Return the title of the page when reporting this error in a HTTP response.
 163          *
 164          * @return string
 165          */
 166         function getPageTitle() {
 167                 global $wgSitename;
 168                 return $this->msg( 'pagetitle', "$1 - $wgSitename", $this->msg( 'internalerror', 'Internal error' ) );
 169         }
 170
 171         /**
 172          * Get a the ID for this error.
 173          *
 174          * @since 1.20
 175          * @deprecated since 1.22 Use MWExceptionHandler::getLogId instead.
 176          * @return string
 177          */
 178         function getLogId() {
 179                 wfDeprecated( __METHOD__, '1.22' );
 180                 return MWExceptionHandler::getLogId( $this );
 181         }
 182
 183         /**
 184          * Return the requested URL and point to file and line number from which the
 185          * exception occurred
 186          *
 187          * @since 1.8
 188          * @deprecated since 1.22 Use MWExceptionHandler::getLogMessage instead.
 189          * @return string
 190          */
 191         function getLogMessage() {
 192                 wfDeprecated( __METHOD__, '1.22' );
 193                 return MWExceptionHandler::getLogMessage( $this );
 194         }
 195
 196         /**
 197          * Output the exception report using HTML.
 198          */
 199         function reportHTML() {
 200                 global $wgOut;
 201                 if ( $this->useOutputPage() ) {
 202                         $wgOut->prepareErrorPage( $this->getPageTitle() );
 203
 204                         $hookResult = $this->runHooks( get_class( $this ) );
 205                         if ( $hookResult ) {
 206                                 $wgOut->addHTML( $hookResult );
 207                         } else {
 208                                 $wgOut->addHTML( $this->getHTML() );
 209                         }
 210
 211                         $wgOut->output();
 212                 } else {
 213                         header( 'Content-Type: text/html; charset=utf-8' );
 214                         echo "<!DOCTYPE html>\n" .
 215                                 '<html><head>' .
 216                                 '<title>' . htmlspecialchars( $this->getPageTitle() ) . '</title>' .
 217                                 '<style>body { font-family: sans-serif; margin: 0; padding: 0.5em 2em; }</style>' .
 218                                 "</head><body>\n";
 219
 220                         $hookResult = $this->runHooks( get_class( $this ) . 'Raw' );
 221                         if ( $hookResult ) {
 222                                 echo $hookResult;
 223                         } else {
 224                                 echo $this->getHTML();
 225                         }
 226
 227                         echo "</body></html>\n";
 228                 }
 229         }
 230
 231         /**
 232          * Output a report about the exception and takes care of formatting.
 233          * It will be either HTML or plain text based on isCommandLine().
 234          */
 235         function report() {
 236                 global $wgMimeType;
 237
 238                 MWExceptionHandler::logException( $this );
 239
 240                 if ( defined( 'MW_API' ) ) {
 241                         // Unhandled API exception, we can't be sure that format printer is alive
 242                         header( 'MediaWiki-API-Error: internal_api_error_' . get_class( $this ) );
 243                         wfHttpError( 500, 'Internal Server Error', $this->getText() );
 244                 } elseif ( self::isCommandLine() ) {
 245                         MWExceptionHandler::printError( $this->getText() );
 246                 } else {
 247                         header( 'HTTP/1.1 500 MediaWiki exception' );
 248                         header( 'Status: 500 MediaWiki exception', true );
 249                         header( "Content-Type: $wgMimeType; charset=utf-8", true );
 250
 251                         $this->reportHTML();
 252                 }
 253         }
 254
 255         /**
 256          * Check whether we are in command line mode or not to report the exception
 257          * in the correct format.
 258          *
 259          * @return bool
 260          */
 261         static function isCommandLine() {
 262                 return !empty( $GLOBALS['wgCommandLineMode'] );
 263         }
 264 }
 265
 266 /**
 267  * Exception class which takes an HTML error message, and does not
 268  * produce a backtrace. Replacement for OutputPage::fatalError().
 269  *
 270  * @since 1.7
 271  * @ingroup Exception
 272  */
 273 class FatalError extends MWException {
 274
 275         /**
 276          * @return string
 277          */
 278         function getHTML() {
 279                 return $this->getMessage();
 280         }
 281
 282         /**
 283          * @return string
 284          */
 285         function getText() {
 286                 return $this->getMessage();
 287         }
 288 }
 289
 290 /**
 291  * An error page which can definitely be safely rendered using the OutputPage.
 292  *
 293  * @since 1.7
 294  * @ingroup Exception
 295  */
 296 class ErrorPageError extends MWException {
 297         public $title, $msg, $params;
 298
 299         /**
 300          * Note: these arguments are keys into wfMessage(), not text!
 301          *
 302          * @param string|Message $title Message key (string) for page title, or a Message object
 303          * @param string|Message $msg Message key (string) for error text, or a Message object
 304          * @param array $params with parameters to wfMessage()
 305          */
 306         function __construct( $title, $msg, $params = null ) {
 307                 $this->title = $title;
 308                 $this->msg = $msg;
 309                 $this->params = $params;
 310
 311                 // Bug 44111: Messages in the log files should be in English and not
 312                 // customized by the local wiki. So get the default English version for
 313                 // passing to the parent constructor. Our overridden report() below
 314                 // makes sure that the page shown to the user is not forced to English.
 315                 if ( $msg instanceof Message ) {
 316                         $enMsg = clone( $msg );
 317                 } else {
 318                         $enMsg = wfMessage( $msg, $params );
 319                 }
 320                 $enMsg->inLanguage( 'en' )->useDatabase( false );
 321                 parent::__construct( $enMsg->text() );
 322         }
 323
 324         function report() {
 325                 global $wgOut;
 326
 327                 $wgOut->showErrorPage( $this->title, $this->msg, $this->params );
 328                 $wgOut->output();
 329         }
 330 }
 331
 332 /**
 333  * Show an error page on a badtitle.
 334  * Similar to ErrorPage, but emit a 400 HTTP error code to let mobile
 335  * browser it is not really a valid content.
 336  *
 337  * @since 1.19
 338  * @ingroup Exception
 339  */
 340 class BadTitleError extends ErrorPageError {
 341         /**
 342          * @param string|Message $msg A message key (default: 'badtitletext')
 343          * @param array $params parameter to wfMessage()
 344          */
 345         function __construct( $msg = 'badtitletext', $params = null ) {
 346                 parent::__construct( 'badtitle', $msg, $params );
 347         }
 348
 349         /**
 350          * Just like ErrorPageError::report() but additionally set
 351          * a 400 HTTP status code (bug 33646).
 352          */
 353         function report() {
 354                 global $wgOut;
 355
 356                 // bug 33646: a badtitle error page need to return an error code
 357                 // to let mobile browser now that it is not a normal page.
 358                 $wgOut->setStatusCode( 400 );
 359                 parent::report();
 360         }
 361
 362 }
 363
 364 /**
 365  * Show an error when a user tries to do something they do not have the necessary
 366  * permissions for.
 367  *
 368  * @since 1.18
 369  * @ingroup Exception
 370  */
 371 class PermissionsError extends ErrorPageError {
 372         public $permission, $errors;
 373
 374         function __construct( $permission, $errors = array() ) {
 375                 global $wgLang;
 376
 377                 $this->permission = $permission;
 378
 379                 if ( !count( $errors ) ) {
 380                         $groups = array_map(
 381                                 array( 'User', 'makeGroupLinkWiki' ),
 382                                 User::getGroupsWithPermission( $this->permission )
 383                         );
 384
 385                         if ( $groups ) {
 386                                 $errors[] = array( 'badaccess-groups', $wgLang->commaList( $groups ), count( $groups ) );
 387                         } else {
 388                                 $errors[] = array( 'badaccess-group0' );
 389                         }
 390                 }
 391
 392                 $this->errors = $errors;
 393         }
 394
 395         function report() {
 396                 global $wgOut;
 397
 398                 $wgOut->showPermissionsErrorPage( $this->errors, $this->permission );
 399                 $wgOut->output();
 400         }
 401 }
 402
 403 /**
 404  * Show an error when the wiki is locked/read-only and the user tries to do
 405  * something that requires write access.
 406  *
 407  * @since 1.18
 408  * @ingroup Exception
 409  */
 410 class ReadOnlyError extends ErrorPageError {
 411         public function __construct() {
 412                 parent::__construct(
 413                         'readonly',
 414                         'readonlytext',
 415                         wfReadOnlyReason()
 416                 );
 417         }
 418 }
 419
 420 /**
 421  * Show an error when the user hits a rate limit.
 422  *
 423  * @since 1.18
 424  * @ingroup Exception
 425  */
 426 class ThrottledError extends ErrorPageError {
 427         public function __construct() {
 428                 parent::__construct(
 429                         'actionthrottled',
 430                         'actionthrottledtext'
 431                 );
 432         }
 433
 434         public function report() {
 435                 global $wgOut;
 436                 $wgOut->setStatusCode( 503 );
 437                 parent::report();
 438         }
 439 }
 440
 441 /**
 442  * Show an error when the user tries to do something whilst blocked.
 443  *
 444  * @since 1.18
 445  * @ingroup Exception
 446  */
 447 class UserBlockedError extends ErrorPageError {
 448         public function __construct( Block $block ) {
 449                 // @todo FIXME: Implement a more proper way to get context here.
 450                 $params = $block->getPermissionsError( RequestContext::getMain() );
 451                 parent::__construct( 'blockedtitle', array_shift( $params ), $params );
 452         }
 453 }
 454
 455 /**
 456  * Shows a generic "user is not logged in" error page.
 457  *
 458  * This is essentially an ErrorPageError exception which by default uses the
 459  * 'exception-nologin' as a title and 'exception-nologin-text' for the message.
 460  * @see bug 37627
 461  * @since 1.20
 462  *
 463  * @par Example:
 464  * @code
 465  * if( $user->isAnon() ) {
 466  *      throw new UserNotLoggedIn();
 467  * }
 468  * @endcode
 469  *
 470  * Note the parameter order differs from ErrorPageError, this allows you to
 471  * simply specify a reason without overriding the default title.
 472  *
 473  * @par Example:
 474  * @code
 475  * if( $user->isAnon() ) {
 476  *      throw new UserNotLoggedIn( 'action-require-loggedin' );
 477  * }
 478  * @endcode
 479  *
 480  * @ingroup Exception
 481  */
 482 class UserNotLoggedIn extends ErrorPageError {
 483
 484         /**
 485          * @param $reasonMsg A message key containing the reason for the error.
 486          *        Optional, default: 'exception-nologin-text'
 487          * @param $titleMsg A message key to set the page title.
 488          *        Optional, default: 'exception-nologin'
 489          * @param $params Parameters to wfMessage().
 490          *        Optional, default: null
 491          */
 492         public function __construct(
 493                 $reasonMsg = 'exception-nologin-text',
 494                 $titleMsg = 'exception-nologin',
 495                 $params = null
 496         ) {
 497                 parent::__construct( $titleMsg, $reasonMsg, $params );
 498         }
 499 }
 500
 501 /**
 502  * Show an error that looks like an HTTP server error.
 503  * Replacement for wfHttpError().
 504  *
 505  * @since 1.19
 506  * @ingroup Exception
 507  */
 508 class HttpError extends MWException {
 509         private $httpCode, $header, $content;
 510
 511         /**
 512          * Constructor
 513          *
 514          * @param $httpCode Integer: HTTP status code to send to the client
 515          * @param string|Message $content content of the message
 516          * @param string|Message $header content of the header (\<title\> and \<h1\>)
 517          */
 518         public function __construct( $httpCode, $content, $header = null ) {
 519                 parent::__construct( $content );
 520                 $this->httpCode = (int)$httpCode;
 521                 $this->header = $header;
 522                 $this->content = $content;
 523         }
 524
 525         /**
 526          * Returns the HTTP status code supplied to the constructor.
 527          *
 528          * @return int
 529          */
 530         public function getStatusCode() {
 531                 return $this->httpCode;
 532         }
 533
 534         /**
 535          * Report the HTTP error.
 536          * Sends the appropriate HTTP status code and outputs an
 537          * HTML page with an error message.
 538          */
 539         public function report() {
 540                 $httpMessage = HttpStatus::getMessage( $this->httpCode );
 541
 542                 header( "Status: {$this->httpCode} {$httpMessage}", true, $this->httpCode );
 543                 header( 'Content-type: text/html; charset=utf-8' );
 544
 545                 print $this->getHTML();
 546         }
 547
 548         /**
 549          * Returns HTML for reporting the HTTP error.
 550          * This will be a minimal but complete HTML document.
 551          *
 552          * @return string HTML
 553          */
 554         public function getHTML() {
 555                 if ( $this->header === null ) {
 556                         $header = HttpStatus::getMessage( $this->httpCode );
 557                 } elseif ( $this->header instanceof Message ) {
 558                         $header = $this->header->escaped();
 559                 } else {
 560                         $header = htmlspecialchars( $this->header );
 561                 }
 562
 563                 if ( $this->content instanceof Message ) {
 564                         $content = $this->content->escaped();
 565                 } else {
 566                         $content = htmlspecialchars( $this->content );
 567                 }
 568
 569                 return "<!DOCTYPE html>\n" .
 570                         "<html><head><title>$header</title></head>\n" .
 571                         "<body><h1>$header</h1><p>$content</p></body></html>\n";
 572         }
 573 }
 574
 575 /**
 576  * Handler class for MWExceptions
 577  * @ingroup Exception
 578  */
 579 class MWExceptionHandler {
 580         /**
 581          * Install an exception handler for MediaWiki exception types.
 582          */
 583         public static function installHandler() {
 584                 set_exception_handler( array( 'MWExceptionHandler', 'handle' ) );
 585         }
 586
 587         /**
 588          * Report an exception to the user
 589          */
 590         protected static function report( Exception $e ) {
 591                 global $wgShowExceptionDetails;
 592
 593                 $cmdLine = MWException::isCommandLine();
 594
 595                 if ( $e instanceof MWException ) {
 596                         try {
 597                                 // Try and show the exception prettily, with the normal skin infrastructure
 598                                 $e->report();
 599                         } catch ( Exception $e2 ) {
 600                                 // Exception occurred from within exception handler
 601                                 // Show a simpler error message for the original exception,
 602                                 // don't try to invoke report()
 603                                 $message = "MediaWiki internal error.\n\n";
 604
 605                                 if ( $wgShowExceptionDetails ) {
 606                                         $message .= 'Original exception: ' . self::formatRedactedTrace( $e ) . "\n\n" .
 607                                                 'Exception caught inside exception handler: ' . $e2->__toString();
 608                                 } else {
 609                                         $message .= "Exception caught inside exception handler.\n\n" .
 610                                                 "Set \$wgShowExceptionDetails = true; at the bottom of LocalSettings.php " .
 611                                                 "to show detailed debugging information.";
 612                                 }
 613
 614                                 $message .= "\n";
 615
 616                                 if ( $cmdLine ) {
 617                                         self::printError( $message );
 618                                 } else {
 619                                         echo nl2br( htmlspecialchars( $message ) ) . "\n";
 620                                 }
 621                         }
 622                 } else {
 623                         $message = "Unexpected non-MediaWiki exception encountered, of type \"" . get_class( $e ) . "\"";
 624
 625                         if ( $wgShowExceptionDetails ) {
 626                                 $message .= "\nexception '" . get_class( $e ) . "' in " . $e->getFile() . ":" . $e->getLine() . "\nStack trace:\n" . self::formatRedactedTrace( $e ) . "\n";
 627                         }
 628
 629                         if ( $cmdLine ) {
 630                                 self::printError( $message );
 631                         } else {
 632                                 echo nl2br( htmlspecialchars( $message ) ) . "\n";
 633                         }
 634                 }
 635         }
 636
 637         /**
 638          * Print a message, if possible to STDERR.
 639          * Use this in command line mode only (see isCommandLine)
 640          *
 641          * @param string $message Failure text
 642          */
 643         public static function printError( $message ) {
 644                 # NOTE: STDERR may not be available, especially if php-cgi is used from the command line (bug #15602).
 645                 #      Try to produce meaningful output anyway. Using echo may corrupt output to STDOUT though.
 646                 if ( defined( 'STDERR' ) ) {
 647                         fwrite( STDERR, $message );
 648                 } else {
 649                         echo $message;
 650                 }
 651         }
 652
 653         /**
 654          * Exception handler which simulates the appropriate catch() handling:
 655          *
 656          *   try {
 657          *       ...
 658          *   } catch ( MWException $e ) {
 659          *       $e->report();
 660          *   } catch ( Exception $e ) {
 661          *       echo $e->__toString();
 662          *   }
 663          */
 664         public static function handle( $e ) {
 665                 global $wgFullyInitialised;
 666
 667                 self::report( $e );
 668
 669                 // Final cleanup
 670                 if ( $wgFullyInitialised ) {
 671                         try {
 672                                 // uses $wgRequest, hence the $wgFullyInitialised condition
 673                                 wfLogProfilingData();
 674                         } catch ( Exception $e ) {
 675                         }
 676                 }
 677
 678                 // Exit value should be nonzero for the benefit of shell jobs
 679                 exit( 1 );
 680         }
 681
 682         /**
 683          * Get the stack trace from the exception as a string, redacting certain function arguments in the process
 684          * @param Exception $e The exception
 685          * @return string The stack trace as a string
 686          */
 687         public static function formatRedactedTrace( Exception $e ) {
 688                 global $wgRedactedFunctionArguments;
 689                 $finalExceptionText = '';
 690
 691                 // Unique value to indicate redacted parameters
 692                 $redacted = new stdClass();
 693
 694                 foreach ( $e->getTrace() as $i => $call ) {
 695                         $checkFor = array();
 696                         if ( isset( $call['class'] ) ) {
 697                                 $checkFor[] = $call['class'] . '::' . $call['function'];
 698                                 foreach ( class_parents( $call['class'] ) as $parent ) {
 699                                         $checkFor[] = $parent . '::' . $call['function'];
 700                                 }
 701                         } else {
 702                                 $checkFor[] = $call['function'];
 703                         }
 704
 705                         foreach ( $checkFor as $check ) {
 706                                 if ( isset( $wgRedactedFunctionArguments[$check] ) ) {
 707                                         foreach ( (array)$wgRedactedFunctionArguments[$check] as $argNo ) {
 708                                                 $call['args'][$argNo] = $redacted;
 709                                         }
 710                                 }
 711                         }
 712
 713                         if ( isset( $call['file'] ) && isset( $call['line'] ) ) {
 714                                 $finalExceptionText .= "#{$i} {$call['file']}({$call['line']}): ";
 715                         } else {
 716                                 // 'file' and 'line' are unset for calls via call_user_func (bug 55634)
 717                                 // This matches behaviour of Exception::getTraceAsString to instead
 718                                 // display "[internal function]".
 719                                 $finalExceptionText .= "#{$i} [internal function]: ";
 720                         }
 721
 722                         if ( isset( $call['class'] ) ) {
 723                                 $finalExceptionText .= $call['class'] . $call['type'] . $call['function'];
 724                         } else {
 725                                 $finalExceptionText .= $call['function'];
 726                         }
 727                         $args = array();
 728                         if ( isset( $call['args'] ) ) {
 729                                 foreach ( $call['args'] as $arg ) {
 730                                         if ( $arg === $redacted ) {
 731                                                 $args[] = 'REDACTED';
 732                                         } elseif ( is_object( $arg ) ) {
 733                                                 $args[] = 'Object(' . get_class( $arg ) . ')';
 734                                         } elseif( is_array( $arg ) ) {
 735                                                 $args[] = 'Array';
 736                                         } else {
 737                                                 $args[] = var_export( $arg, true );
 738                                         }
 739                                 }
 740                         }
 741                         $finalExceptionText .=  '(' . implode( ', ', $args ) . ")\n";
 742                 }
 743                 return $finalExceptionText . '#' . ( $i + 1 ) . ' {main}';
 744         }
 745
 746
 747         /**
 748          * Get the ID for this error.
 749          *
 750          * The ID is saved so that one can match the one output to the user (when
 751          * $wgShowExceptionDetails is set to false), to the entry in the debug log.
 752          *
 753          * @since 1.22
 754          * @param Exception $e
 755          * @return string
 756          */
 757         public static function getLogId( Exception $e ) {
 758                 if ( !isset( $e->_mwLogId ) ) {
 759                         $e->_mwLogId = wfRandomString( 8 );
 760                 }
 761                 return $e->_mwLogId;
 762         }
 763
 764         /**
 765          * Return the requested URL and point to file and line number from which the
 766          * exception occurred.
 767          *
 768          * @since 1.22
 769          * @param Exception $e
 770          * @return string
 771          */
 772         public static function getLogMessage( Exception $e ) {
 773                 global $wgRequest;
 774
 775                 $id = self::getLogId( $e );
 776                 $file = $e->getFile();
 777                 $line = $e->getLine();
 778                 $message = $e->getMessage();
 779
 780                 if ( isset( $wgRequest ) && !$wgRequest instanceof FauxRequest ) {
 781                         $url = $wgRequest->getRequestURL();
 782                         if ( !$url ) {
 783                                 $url = '[no URL]';
 784                         }
 785                 } else {
 786                         $url = '[no req]';
 787                 }
 788
 789                 return "[$id] $url   Exception from line $line of $file: $message";
 790         }
 791
 792         /**
 793          * Log an exception to the exception log (if enabled).
 794          *
 795          * This method must not assume the exception is an MWException,
 796          * it is also used to handle PHP errors or errors from other libraries.
 797          *
 798          * @since 1.22
 799          * @param Exception $e
 800          */
 801         public static function logException( Exception $e ) {
 802                 global $wgLogExceptionBacktrace;
 803
 804                 $log = self::getLogMessage( $e );
 805                 if ( $log ) {
 806                         if ( $wgLogExceptionBacktrace ) {
 807                                 wfDebugLog( 'exception', $log . "\n" . self::formatRedactedTrace( $e ) . "\n" );
 808                         } else {
 809                                 wfDebugLog( 'exception', $log );
 810                         }
 811                 }
 812         }
 813
 814 }