Common: SErrorManager.php5 Source File

00001 <?php
00002 
00020 abstract class SErrorManager {
00021     private static $ERRORS = array();
00022     private static $WARNINGS = array();
00023     private static $DEBUG = array();
00024 
00025     private static $ERROR_REDIRECT = array();
00026     private static $WARNING_REDIRECT = array();
00027     private static $DEBUG_REDIRECT = array();
00028 
00029     private static $SHUTDOWN_FUNCS = array();
00030 
00031     private static $MESSAGE_ID = 0;
00032 
00033     private static $NO_FAILSAFE_NEEDED = false;
00034 
00035     private static $EMAIL = false;
00036     private static $EMAIL_ON = array(
00037         'fatal' => false,
00038         'error' => false,
00039         'warning' => false,
00040         'debug' => false);
00041 
00042 
00043     // this prevents the class from being instantiated or overridden
00051     private function __construct() {}
00052 
00060     public static function initialize() {
00061         if(SConfig::getOption('common.DISPLAY_PHP_ERRORS'))
00062             set_error_handler(array('SErrorManager', 'php_error_handler'));
00063         else
00064             set_error_handler(array('SErrorManager', 'php_error_handler'), E_ERROR | E_USER_ERROR);
00065         register_shutdown_function(array('SErrorManager', 'failsafe_show_errors'));
00066     }
00067 
00076     public function registerShutdownFunction($cb) {
00077         if(is_array($cb) && !method_exists($cb[0], $cb[1])) {
00078             self::setError('Will not register non-existent method');
00079             return false;
00080         }
00081 
00082         if(is_string($cb) && !function_exists($cb)) {
00083             self::setError('Will not register non-existent function');
00084             return false;
00085         }
00086 
00087         if(!is_string($cb) && !is_array($cb)) {
00088             self::setError('Invalid callback');
00089             return false;
00090         }
00091 
00092         array_push(self::$SHUTDOWN_FUNCS, $cb);
00093         return true;
00094     }
00095 
00104     public static function setEnablePHPErrors($enablePHP) {
00105         restore_error_handler();
00106         if($enablePHP)
00107             set_error_handler(array('SErrorManager', 'php_error_handler'));
00108         else
00109             set_error_handler(array('SErrorManager', 'php_error_handler'), E_ERROR | E_USER_ERROR);
00110     }
00111 
00112     // if $email is false, emailing is disabled
00125     public function setEmail($email, $onFatal = true, $onError = false, $onWarning = false, $onDebug = false) {
00126         self::$EMAIL = $email;
00127 
00128         self::$EMAIL_ON['fatal'] = $onFatal;
00129         self::$EMAIL_ON['error'] = $onError;
00130         self::$EMAIL_ON['warning'] = $onWarning;
00131         self::$EMAIL_ON['debug'] = $onDebug;
00132     }
00133 
00144     public static function getLastError($all = false) {
00145         if(count(self::$ERRORS) == 0) {
00146             if($all)
00147                 return null;
00148             else
00149                 return false;
00150         }
00151         else {
00152             if($all)
00153                 return self::$ERRORS[count(self::$ERRORS) - 1][0];
00154             else
00155                 return self::$ERRORS[count(self::$ERRORS) - 1];
00156         }
00157     }
00158 
00169     public static function getLastWarning($all = false) {
00170         if(count(self::$WARNINGS) == 0) {
00171             if($all)
00172                 return null;
00173             else
00174                 return false;
00175         }
00176         else {
00177             if($all)
00178                 return self::$WARNINGS[count(self::$WARNINGS) - 1][0];
00179             else
00180                 return self::$WARNINGS[count(self::$WARNINGS) - 1];
00181         }
00182     }
00183 
00195     public static function setError($msg, $forUser = false) {
00196         $bt = debug_backtrace();
00197         if(count(self::$ERROR_REDIRECT) > 0) {
00198             switch(self::$ERROR_REDIRECT[count(self::$ERROR_REDIRECT) - 1]) {
00199                 case 'error':
00200                     array_push(self::$ERRORS, array($msg, $bt, 1, self::$MESSAGE_ID++));
00201                     break;
00202                 case 'warning':
00203                     array_push(self::$WARNINGS, array($msg, $bt, 1, self::$MESSAGE_ID++));
00204                     break;
00205                 case 'debug':
00206                     array_push(self::$DEBUG, array($msg, $bt, 1, self::$MESSAGE_ID++));
00207                     break;
00208             }
00209         }
00210         else
00211             array_push(self::$ERRORS, array($msg, $bt, 1, self::$MESSAGE_ID++));
00212         if($forUser) {
00213             if(isset($GLOBALS['SWAT'])) {
00214                 $usr = $GLOBALS['SWAT']->getGlobalUser();
00215                 if($usr != null) {
00216                     $usr->setFlash($msg);
00217                     return;
00218                 }
00219             }
00220             // XXX: we really should have a standard way of finding out the PRM name
00221             $GLOBALS['prm']->flash($msg);
00222         }
00223     }
00224 
00230     public static function setUserError($msg) {
00231         self::sobj_setError($msg, true, 2);
00232     }
00233 
00241     public static function setWarning($msg) {
00242         $bt = debug_backtrace();
00243         if(count(self::$WARNING_REDIRECT) > 0) {
00244             switch(self::$WARNING_REDIRECT[count(self::$WARNING_REDIRECT) - 1]) {
00245                 case 'error':
00246                     array_push(self::$ERRORS, array($msg, $bt, 1, self::$MESSAGE_ID++));
00247                     break;
00248                 case 'warning':
00249                     array_push(self::$WARNINGS, array($msg, $bt, 1, self::$MESSAGE_ID++));
00250                     break;
00251                 case 'debug':
00252                     array_push(self::$DEBUG, array($msg, $bt, 1, self::$MESSAGE_ID++));
00253                     break;
00254             }
00255         }
00256         else
00257             array_push(self::$WARNINGS, array($msg, $bt, 1, self::$MESSAGE_ID++));
00258     }
00259 
00267     public static function setDebug($msg) {
00268         $bt = debug_backtrace();
00269         if(count(self::$DEBUG_REDIRECT) > 0) {
00270             switch(self::$DEBUG_REDIRECT[count(self::$DEBUG_REDIRECT) - 1]) {
00271                 case 'error':
00272                     array_push(self::$ERRORS, array($msg, $bt, 1, self::$MESSAGE_ID++));
00273                     break;
00274                 case 'warning':
00275                     array_push(self::$WARNINGS, array($msg, $bt, 1, self::$MESSAGE_ID++));
00276                     break;
00277                 case 'debug':
00278                     array_push(self::$DEBUG, array($msg, $bt, 1, self::$MESSAGE_ID++));
00279                     break;
00280             }
00281         }
00282         else
00283             array_push(self::$DEBUG, array($msg, $bt, 1, self::$MESSAGE_ID++));
00284     }
00285 
00291     public static function clearErrors() {
00292         self::$ERRORS = array();
00293     }
00294 
00300     public static function clearWarnings() {
00301         self::$WARNINGS = array();
00302     }
00303 
00309     public static function clearDebug() {
00310         self::$DEBUG = array();
00311     }
00312 
00324     public static function getAllErrors($all = false) {
00325         if($all)
00326             return self::$ERRORS;
00327         $errors = array();
00328         foreach(self::$ERRORS as $e)
00329             array_push($errors, $e[0]);
00330         return $errors;
00331     }
00332 
00344     public static function getAllWarnings($all = false) {
00345         if($all)
00346             return self::$WARNINGS;
00347         $warnings = array();
00348         foreach(self::$WARNINGS as $w)
00349             array_push($warnings, $w[0]);
00350         return $warnings;
00351     }
00352 
00364     public static function getAllDebug($all = false) {
00365         if($all)
00366             return self::$DEBUG;
00367         $debug = array();
00368         foreach(self::$DEBUG as $w)
00369             array_push($debug, $w[0]);
00370         return $debug;
00371     }
00372 
00383     public static function restoreErrors($errors) {
00384         self::$ERRORS = $errors;
00385     }
00386 
00397     public static function restoreWarnings($warnings) {
00398         self::$WARNINGS = $warnings;
00399     }
00400 
00411     public static function restoreDebug($debug) {
00412         self::$DEBUG = $debug;
00413     }
00414 
00424     public static function redirectPush($type, $redir) {
00425         $type = strtolower($type);
00426         $redir = strtolower($redir);
00427 
00428         if($type != 'error' && $type != 'warning' && $type != 'debug'
00429             && $redir != 'error' && $redir != 'warning' && $redir != 'debug' && $redir != 'devnull') {
00430             $msg = 'Invalid error manager redirect!';
00431             $bt = debug_backtrace();
00432             array_push(self::$ERRORS, array($msg, $bt, 0));
00433             return false;
00434         }
00435 
00436         switch($type) {
00437             case 'error':
00438                 array_push(self::$ERROR_REDIRECT, $redir);
00439                 break;
00440             case 'warning':
00441                 array_push(self::$WARNING_REDIRECT, $redir);
00442                 break;
00443             case 'debug':
00444                 array_push(self::$DEBUG_REDIRECT, $redir);
00445                 break;
00446         }
00447 
00448         return true;
00449     }
00450 
00459     public static function redirectPop($type) {
00460         $type = strtolower($type);
00461 
00462         if($type != 'error' && $type != 'warning' && $type != 'debug') {
00463             $msg = 'Invalid error manager queue for redirect popping!';
00464             $bt = debug_backtrace();
00465             array_push(self::$ERRORS, array($msg, $bt, 0));
00466             return false;
00467         }
00468 
00469         switch($type) {
00470             case 'error':
00471                 if(count(self::$ERROR_REDIRECT) > 0)
00472                     return array_pop(self::$ERROR_REDIRECT);
00473                 break;
00474             case 'warning':
00475                 if(count(self::$WARNING_REDIRECT) > 0)
00476                     return array_pop(self::$WARNING_REDIRECT);
00477                 break;
00478             case 'debug':
00479                 if(count(self::$DEBUG_REDIRECT) > 0)
00480                     return array_pop(self::$DEBUG_REDIRECT);
00481                 break;
00482         }
00483 
00484         $msg = 'Redirect stack is empty!';
00485         $bt = debug_backtrace();
00486         array_push(self::$ERRORS, array($msg, $bt, 0));
00487         return false;
00488     }
00489 
00500     public static function sobj_setError($msg, $forUser, $ignoreHowMany = 1) {
00501         $bt = debug_backtrace();
00502         if(count(self::$ERROR_REDIRECT) > 0) {
00503             switch(self::$ERROR_REDIRECT[count(self::$ERROR_REDIRECT) - 1]) {
00504                 case 'error':
00505                     array_push(self::$ERRORS, array($msg, $bt, $ignoreHowMany, self::$MESSAGE_ID++));
00506                     break;
00507                 case 'warning':
00508                     array_push(self::$WARNINGS, array($msg, $bt, $ignoreHowMany, self::$MESSAGE_ID++));
00509                     break;
00510                 case 'debug':
00511                     array_push(self::$DEBUG, array($msg, $bt, $ignoreHowMany, self::$MESSAGE_ID++));
00512                     break;
00513             }
00514         }
00515         else
00516             array_push(self::$ERRORS, array($msg, $bt, $ignoreHowMany, self::$MESSAGE_ID++));
00517         if($forUser) {
00518             if(isset($GLOBALS['SWAT'])) {
00519                 $usr = $GLOBALS['SWAT']->getGlobalUser();
00520                 if($usr != null) {
00521                     $usr->setFlash($msg);
00522                     return;
00523                 }
00524             }
00525             // XXX: we really should have a standard way of finding out the PRM name
00526             $GLOBALS['prm']->flash($msg);
00527         }
00528     }
00529 
00539     public static function sobj_setWarning($msg, $ignoreHowMany = 1) {
00540         $bt = debug_backtrace();
00541         if(count(self::$WARNING_REDIRECT) > 0) {
00542             switch(self::$WARNING_REDIRECT[count(self::$WARNING_REDIRECT) - 1]) {
00543                 case 'error':
00544                     array_push(self::$ERRORS, array($msg, $bt, $ignoreHowMany, self::$MESSAGE_ID++));
00545                     break;
00546                 case 'warning':
00547                     array_push(self::$WARNINGS, array($msg, $bt, $ignoreHowMany, self::$MESSAGE_ID++));
00548                     break;
00549                 case 'debug':
00550                     array_push(self::$DEBUG, array($msg, $bt, $ignoreHowMany, self::$MESSAGE_ID++));
00551                     break;
00552             }
00553         }
00554         else
00555             array_push(self::$WARNINGS, array($msg, $bt, $ignoreHowMany, self::$MESSAGE_ID++));
00556     }
00557 
00567     public static function sobj_setDebug($msg, $ignoreHowMany = 1) {
00568         $bt = debug_backtrace();
00569         if(count(self::$DEBUG_REDIRECT) > 0) {
00570             switch(self::$DEBUG_REDIRECT[count(self::$DEBUG_REDIRECT) - 1]) {
00571                 case 'error':
00572                     array_push(self::$ERRORS, array($msg, $bt, $ignoreHowMany, self::$MESSAGE_ID++));
00573                     break;
00574                 case 'warning':
00575                     array_push(self::$WARNINGS, array($msg, $bt, $ignoreHowMany, self::$MESSAGE_ID++));
00576                     break;
00577                 case 'debug':
00578                     array_push(self::$DEBUG, array($msg, $bt, $ignoreHowMany, self::$MESSAGE_ID++));
00579                     break;
00580             }
00581         }
00582         else
00583             array_push(self::$DEBUG, array($msg, $bt, $ignoreHowMany, self::$MESSAGE_ID++));
00584     }
00585 
00598     public static function php_error_handler($errno, $errstr, $errfile, $errline, $errcontext) {
00599         if(($errno & E_USER_ERROR)
00600             && !SConfig::getOption('common.DISPLAY_PHP_ERRORS')) {
00601             SConfig::setOption('common.DISPLAY_ERRORS', true);
00602             SConfig::setOption('common.DISPLAY_WARNINGS', true);
00603             self::failsafe_show_errors();
00604             self::$NO_FAILSAFE_NEEDED = true;
00605             return false;
00606         }
00607         $noMessage = true;
00608         if($errno & E_STRICT)
00609             return true;
00610         if(SConfig::getOption('common.DISPLAY_ERRORS')) {
00611             if(!($errno & (E_ERROR | E_CORE_ERROR | E_COMPILE_ERROR | E_USER_ERROR | E_STRICT)))
00612                 $noMessage = false;
00613         }
00614         if(SConfig::getOption('common.DISPLAY_WARNINGS')) {
00615             if(!($errno & (E_WARNING | E_CORE_WARNING | E_COMPILE_WARNING | E_USER_WARNING | E_NOTICE | E_USER_NOTICE)))
00616                 $noMessage = false;
00617         }
00618         if(!$noMessage)
00619             self::sobj_setError("<span style=\"background:orange\">[PHP ERROR] <b>$errstr</b>"
00620                 . " in <tt>$errfile</tt> on line <b>$errline</b></span>", false, 2);
00621         return true;
00622     }
00623 
00631     public static function failsafe_show_errors() {
00632         if(count(self::$SHUTDOWN_FUNCS) > 0) {
00633             foreach(self::$SHUTDOWN_FUNCS as $cb) {
00634                 $cb();
00635             }
00636         }
00637 
00638         if(self::$NO_FAILSAFE_NEEDED)
00639             return;
00640         $collect = "";
00641         $err = '';
00642         $warn = '';
00643         $dbg = '';
00644         if(count(self::$ERRORS) > 0 && SConfig::getOption('common.DISPLAY_ERRORS')) {
00645             $err = "<h1>Errors</h1><ul>\n";
00646             foreach(self::$ERRORS as $error) {
00647                 $msg = $error[0];
00648                 $bt = $error[1];
00649                 $ignore = $error[2];
00650                 $html = self::generateBacktraceHTML($bt, $place, $ignore);
00651                 $err .= "<li><b>In <u>$place</u></b>: " . self::formatMessageArray($msg)
00652                     . " $html</li>\n";
00653             }
00654             $err .= "</ul>";
00655         }
00656         if(count(self::$WARNINGS) > 0 && SConfig::getOption('common.DISPLAY_WARNINGS')) {
00657             $warn .= "<h1>Warnings</h1><ul>\n";
00658             foreach(self::$WARNINGS as $warning) {
00659                 $msg = $warning[0];
00660                 $bt = $warning[1];
00661                 $ignore = $warning[2];
00662                 $html = self::generateBacktraceHTML($bt, $place, $ignore);
00663                 $warn .= "<li><b>In <u>$place</u></b>: " . self::formatMessageArray($msg)
00664                     . " $html</li>\n";
00665             }
00666             $warn .= "</ul>";
00667         }
00668         if(count(self::$DEBUG) > 0 && (SConfig::getOption('common.DISPLAY_DEBUG'))) {
00669             $dbg .= "<h1>Debug Messages</h1><ul>\n";
00670             foreach(self::$DEBUG as $warning) {
00671                 $msg = $warning[0];
00672                 $bt = $warning[1];
00673                 $ignore = $warning[2];
00674                 $html = self::generateBacktraceHTML($bt, $place, $ignore);
00675                 $dbg .= "<li><b>In <u>$place</u></b>: " . self::formatMessageArray($msg)
00676                     . " $html</li>\n";
00677             }
00678             $dbg .= "</ul>";
00679         }
00680         print $err . $warn . $dbg;
00681 
00682         if(self::$EMAIL) {
00683             $email = '';
00684 
00685             if(self::$EMAIL_ON['error'])
00686                 $email .= $err;
00687             if(self::$EMAIL_ON['warning'])
00688                 $email .= $warn;
00689             if(self::$EMAIL_ON['debug'])
00690                 $email .= $dbg;
00691 
00692             if($email != '') {
00693                 $time = date("D, M j, Y g:i:s a");
00694                 $userInfo = '';
00695                 if(isset($GLOBALS['SWAT']) && $GLOBALS['SWAT'] != null && $GLOBALS['SWAT'] instanceof SWAT) {
00696                     $guser = $GLOBALS['SWAT']->getGlobalUser();
00697                     if($guser != null && $guser instanceof SGlobalUser) {
00698                         $ldap = $guser->getAuthModule('ldap');
00699                         if($ldap != null && $ldap instanceof SLdapAuthModule) {
00700                             $uinfo = $ldap->getUserFromUid($ldap->getUID());
00701                             $userInfo = "<b>User</b>: $uinfo[firstName] $uinfo[lastName] ($uinfo[userName]:"
00702                                 . $ldap->getUID() . ')<br />';
00703                         }
00704                     }
00705                 }
00706                 $requestVars = print_r($_REQUEST, true);
00707                 $serverInfo = print_r($_SERVER, true);
00708                 $httpHeaders = print_r(apache_request_headers(), true);
00709                 $email = <<<END_HTML
00710 <html>
00711     <head>
00712         <title>Errors from $time</title>
00713     </head>
00714     <body>
00715         <h1>Error Report</h1>
00716         <b>Time</b>: $time<br />
00717         <b>Page</b>: $_SERVER[SERVER_NAME]$_SERVER[REQUEST_URI]<br />
00718         $userInfo
00719         <b>Request Variables</b>: <tt><pre>$requestVars</pre></tt>
00720         <b>Server Info</b>: <tt><pre>$serverInfo</pre></tt>
00721         <b>HTTP Headers</b>: <tt><pre>$serverInfo</pre></tt>
00722         $email
00723     </body>
00724 </html>
00725 END_HTML;
00726                 $headers = <<<END_HEADERS
00727 MIME-Version: 1.0
00728 Content-Type: text/html
00729 From: SErrorManager <noreply@example.org>
00730 END_HEADERS;
00731                 mail(self::$EMAIL, "Error Report at $time on $_SERVER[REQUEST_URI]", $email, $headers);
00732             }
00733         }
00734     }
00735 
00746     private static function generateBacktraceHTML($bt, &$place, $ignoreHowMany) {
00747         $collect = "<table style=\"border-collapse: collapse\" "
00748             . "class=\"backtrace\"><tr><th>Function</th><th>Line</th>"
00749             . "<th>File</th></tr>";
00750         if(!ctype_digit((string) $ignoreHowMany)) {
00751             print "[INTERNAL ERROR]: somebody didn't set the ignore level!<br />";
00752             $ignoreHowMany = 1;
00753         }
00754         $ignoreHowMany--;
00755         if($ignoreHowMany < 0)
00756             $ignoreHowMany = 0;
00757         for($i = $ignoreHowMany; $i < count($bt); $i++) {
00758             $fn = $bt[$i];
00759             if(isset($fn['file']))
00760                 $file = $fn['file'];
00761             else
00762                 $file = '???';
00763             if(isset($fn['line']))
00764                 $line = $fn['line'];
00765             else
00766                 $line = '???';
00767             if($i < count($bt) - 1) {
00768                 if(!isset($bt[$i+1]['class']))
00769                     $fnName = $bt[$i+1]['function'] . "()";
00770                 else
00771                     $fnName = $bt[$i+1]['class']."::".$bt[$i+1]['function']
00772                                 . "()";
00773             }
00774             else {
00775                 $fnName = "&lt;global&gt;";
00776             }
00777             if($i == $ignoreHowMany)
00778                 $place = $fnName;
00779 
00780             $collect .= "<tr><td class=\"bt_cell\">$fnName</td><td class=\"bt_cell\">$line</td><td class=\"bt_cell\">$file</td>"
00781                 . "</tr>\n";
00782         }
00783         $collect .= "</table>\n";
00784         return $collect;
00785     }
00786 
00800     private static function formatMessage($typecnt, $bt, $place, $msg, $cls, $id) {
00801         if (is_array($msg)) { $msg = self::formatMessageArray($msg); }
00802         $output = "<b class=\"bt_clicker\" onclick=\"toggleBacktrace('$typecnt')\">"
00803             . "($id) $place:</b> $msg <div id=\"$typecnt\" class=\"bt_container\">"
00804             . "<div class=\"bt_title\">Debug Backtrace</div>$bt</div>";
00805         return $output;
00806     }
00807 
00816     private static function formatMessageArray($msg) {
00817         if (!is_array($msg)) return $msg;
00818         $output = "";
00819         foreach ($msg as $m) {
00820             if (is_array($m)){
00821                 $output .= self::formatMessageArray($m);
00822             } else {
00823                 $output .= $m;
00824             }
00825         }
00826         return $output;
00827     }
00828 
00836     public static function prm_printMessages() {
00837         self::$NO_FAILSAFE_NEEDED = true;
00838         $output = "";
00839         $dbg = "";
00840         $warn = "";
00841         $err = "";
00842 
00843         if(SConfig::getOption('common.DISPLAY_DEBUG')) {
00844             if(count(self::$DEBUG) > 0) {
00845                 $dbg .= '<div class="bt_debugOuter">'
00846                     . "<h3>Debug Messages:</h3><ul>\n";
00847                 foreach(self::$DEBUG as $i => $msgInfo) {
00848                     $place = "";
00849                     $bt = self::generateBacktraceHTML($msgInfo[1], $place, $msgInfo[2]);
00850                     $dbg .= '<li>' . self::formatMessage('dbg_' . $i,
00851                         $bt, $place, $msgInfo[0],
00852                         "backtraceDebug", $msgInfo[3]) . "</li>\n";
00853                 }
00854                 $dbg .= "</ul><div style=\"clear:both\"></div></div>\n";
00855             }
00856         }
00857         if(SConfig::getOption('common.DISPLAY_WARNINGS')) {
00858             if(count(self::$WARNINGS) > 0) {
00859                 $warn .= '<div class="bt_warningOuter">'
00860                     . "<h3>Warnings:</h3><ul>\n";
00861                 foreach(self::$WARNINGS as $i => $msgInfo) {
00862                     $place = "";
00863                     $bt = self::generateBacktraceHTML($msgInfo[1], $place, $msgInfo[2]);
00864                     $warn .= '<li>' . self::formatMessage('warn_' . $i,
00865                         $bt, $place, $msgInfo[0], "backtraceWarning", $msgInfo[3])
00866                                                 . "</li>\n";
00867                 }
00868                 $warn .= "</ul><div style=\"clear:both\"></div></div>\n";
00869             }
00870         }
00871         if(SConfig::getOption('common.DISPLAY_ERRORS')) {
00872             if(count(self::$ERRORS) > 0) {
00873                 $err .= '<div class="bt_errorOuter">'
00874                     . "<h3>Errors:</h3><ul>\n";
00875                 foreach(self::$ERRORS as $i => $msgInfo) {
00876                     $place = "";
00877                     $bt = self::generateBacktraceHTML($msgInfo[1], $place, $msgInfo[2]);
00878                     $err .= '<li>' . self::formatMessage('err_' . $i,
00879                         $bt, $place, $msgInfo[0], "backtraceError", $msgInfo[3])
00880                                                 . "</li>\n";
00881                 }
00882                 $err .= "</ul><div style=\"clear:both\"></div></div>\n";
00883             }
00884         }
00885 
00886         if(self::$EMAIL) {
00887             $email = '';
00888 
00889             if(self::$EMAIL_ON['error'])
00890                 $email .= $err;
00891             if(self::$EMAIL_ON['warning'])
00892                 $email .= $warn;
00893             if(self::$EMAIL_ON['debug'])
00894                 $email .= $dbg;
00895 
00896             if($email != '') {
00897                 $time = date("D, M j, Y g:i:s a");
00898                 $userInfo = '';
00899                 if(isset($GLOBALS['SWAT']) && $GLOBALS['SWAT'] != null && $GLOBALS['SWAT'] instanceof SWAT) {
00900                     $guser = $GLOBALS['SWAT']->getGlobalUser();
00901                     if($guser != null && $guser instanceof SGlobalUser) {
00902                         $ldap = $guser->getAuthModule('ldap');
00903                         if($ldap != null && $ldap instanceof SLdapAuthModule) {
00904                             $uinfo = $ldap->getUserFromUid($ldap->getUID());
00905                             $userInfo = "<b>User</b>: $uinfo[firstName] $uinfo[lastName] ($uinfo[userName]:"
00906                                 . $ldap->getUID() . ')<br />';
00907                         }
00908                     }
00909                 }
00910                 $requestVars = print_r($_REQUEST, true);
00911                 $serverInfo = print_r($_SERVER, true);
00912                 $httpHeaders = print_r(apache_request_headers(), true);
00913                 $email = <<<END_HTML
00914 <html>
00915     <head>
00916         <title>Errors from $time</title>
00917     </head>
00918     <body>
00919         <h1>Error Report</h1>
00920         <b>Time</b>: $time<br />
00921         <b>Page</b>: $_SERVER[SERVER_NAME]$_SERVER[REQUEST_URI]<br />
00922         $userInfo
00923         <b>Request Variables</b>: <tt><pre>$requestVars</pre></tt>
00924         <b>Server Info</b>: <tt><pre>$serverInfo</pre></tt>
00925         <b>HTTP Headers</b>: <tt><pre>$httpHeaders</pre></tt>
00926         $email
00927     </body>
00928 </html>
00929 END_HTML;
00930 
00931                 $headers = <<<END_HEADERS
00932 MIME-Version: 1.0
00933 Content-Type: text/html
00934 From: SErrorManager <noreply@example.org>
00935 END_HEADERS;
00936                 mail(self::$EMAIL, "Error Report at $time on $_SERVER[REQUEST_URI]", $email, $headers);
00937             }
00938         }
00939 
00940         return $err . $warn . $dbg;
00941     }
00942 }
00943 
00944 ?>