1: <?php
  2: /**
  3:  * Horde_ErrorHandler: simple error_handler implementation for
  4:  * handling PHP errors, generating backtraces for them, etc.
  5:  *
  6:  * @TODO Split dump() off into a Horde_Log backend, and make this more
  7:  * general-purpose. Also make it configurable whether or not to honor
  8:  * suppression of errors with @.
  9:  *
 10:  * @category Horde
 11:  * @package  Core
 12:  */
 13: class Horde_ErrorHandler
 14: {
 15:     /**
 16:      * Mapping of error codes to error code names.
 17:      *
 18:      * @var array
 19:      */
 20:     public static $errorTypes = array(
 21:         1 => 'ERROR',
 22:         2 => 'WARNING',
 23:         4 => 'PARSE',
 24:         8 => 'NOTICE',
 25:         16 => 'CORE_ERROR',
 26:         32 => 'CORE_WARNING',
 27:         64 => 'COMPILE_ERROR',
 28:         128 => 'COMPILE_WARNING',
 29:         256 => 'USER_ERROR',
 30:         512 => 'USER_WARNING',
 31:         1024 => 'USER_NOTICE',
 32:         2047 => 'ALL',
 33:         2048 => 'STRICT',
 34:         4096 => 'RECOVERABLE_ERROR',
 35:     );
 36: 
 37:     /**
 38:      * error_reporting mask
 39:      *
 40:      * @var integer
 41:      */
 42:     protected static $_mask = E_ALL;
 43: 
 44:     /**
 45:      * Array of errors that have been caught.
 46:      *
 47:      * @var array
 48:      */
 49:     protected static $_errors = array();
 50: 
 51:     /**
 52:      * Configurable function to run on shutdown.
 53:      *
 54:      * @var callable
 55:      */
 56:     protected static $_shutdownFunc;
 57: 
 58:     /**
 59:      * Set the error handler and shutdown functions.
 60:      *
 61:      * @param TODO
 62:      */
 63:     public static function register($shutdownFunc = null)
 64:     {
 65:         set_error_handler(array(__CLASS__, 'handleError'));
 66: 
 67:         if (is_null($shutdownFunc)) {
 68:             $shutdownFunc = array(__CLASS__, 'dump');
 69:         }
 70: 
 71:         self::$_shutdownFunc = $shutdownFunc;
 72:     }
 73: 
 74:     /**
 75:      * Call the shutdown func, passing in accumulated errors.
 76:      */
 77:     public function __destruct()
 78:     {
 79:         if (self::$_errors) {
 80:             call_user_func(self::$_shutdownFunc, self::$_errors);
 81:         }
 82:     }
 83: 
 84:     /**
 85:      * Process and handle/store an error.
 86:      *
 87:      * @param integer $errno    TODO
 88:      * @param string $errstr    TODO
 89:      * @param string $errfile   TODO
 90:      * @param integer $errline  TODO
 91:      */
 92:     public static function handleError($errno, $errstr, $errfile, $errline)
 93:     {
 94:         // Was the error suppressed?
 95:         if (!error_reporting()) {
 96:             // @TODO
 97:             // ...
 98:         }
 99: 
100:         // Check the mask.
101:         if ($errno & self::$_mask) {
102:             self::$_errors[] = array(
103:                 'no' => $errno,
104:                 'str' => self::_cleanErrorString($errstr),
105:                 'file' => $errfile,
106:                 'line' => $errline,
107:                 'trace' => self::_errorBacktrace(),
108:             );
109:         }
110:     }
111: 
112:     /**
113:      * Include the context of the error in the debug
114:      * information. Takes more (and could be much more) memory.
115:      *
116:      * @param integer $errno    TODO
117:      * @param string $errstr    TODO
118:      * @param string $errfile   TODO
119:      * @param integer $errline  TODO
120:      * @param TODO $errcontext  TODO
121:      */
122:     public static function handleErrorWithContext($errno, $errstr, $errfile,
123:                                                   $errline, $errcontext)
124:     {
125:         self::$_errors[] = array(
126:             'no' => $errno,
127:             'str' => self::_cleanErrorString($errstr),
128:             'file' => $errfile,
129:             'line' => $errline,
130:             'context' => $errcontext,
131:             'trace' => self::_errorBacktrace(),
132:         );
133:     }
134: 
135:     /**
136:      * Remove function documentation links from an error string.
137:      *
138:      * @param string $errstr  TODO
139:      *
140:      * @return string  TODO
141:      */
142:     protected static function _cleanErrorString($errstr)
143:     {
144:         return preg_replace("%\s\[<a href='function\.[\d\w-_]+'>function\.[\d\w-_]+</a>\]%", '', $errstr);
145:     }
146: 
147:     /**
148:      * Generate an exception-like backtrace from the debug_backtrace()
149:      * function for errors.
150:      *
151:      * @return array  TODO
152:      */
153:     protected static function _errorBacktrace()
154:     {
155:         // Skip two levels of backtrace
156:         $skip = 2;
157: 
158:         $backtrace = debug_backtrace();
159:         $trace = array();
160:         for ($i = $skip, $i_max = count($backtrace); $i < $i_max; $i++) {
161:             $frame = $backtrace[$i];
162:             $trace[$i - $skip] = array(
163:                 'file' => isset($frame['file']) ? $frame['file'] : null,
164:                 'line' => isset($frame['line']) ? $frame['line'] : null,
165:                 'function' => isset($frame['function']) ? $frame['function'] : null,
166:                 'class' => isset($frame['class']) ? $frame['class'] : null,
167:                 'type' => isset($frame['type']) ? $frame['type'] : null,
168:                 'args' => isset($frame['args']) ? $frame['args'] : null,
169:             );
170:         }
171: 
172:         return $trace;
173:     }
174: 
175:     /**
176:      * On text/html pages, if the user is an administrator, show all
177:      * errors that occurred during the request.
178:      *
179:      * @param array $errors  Accumulated errors.
180:      */
181:     public static function dump($errors)
182:     {
183:         if (!$GLOBALS['registry']->isAdmin()) {
184:             return;
185:         }
186: 
187:         $dump = false;
188:         foreach (headers_list() as $header) {
189:             if (strpos($header, 'Content-type: text/html') !== false) {
190:                 $dump = true;
191:                 break;
192:             }
193:         }
194: 
195:         if ($dump) {
196:             foreach ($errors as $error) {
197:                 echo '<p>' . htmlspecialchars($error['file']) . ':' . htmlspecialchars($error['line']) . ': ' . htmlspecialchars($error['str']) . '</p>';
198:             }
199:         }
200:     }
201: 
202: }
203: