libraries/Error.class.php

   1 <?php
   2 /* vim: set expandtab sw=4 ts=4 sts=4: */
   3 /**
   4  * Holds class PMA_Error
   5  *
   6  * @package PhpMyAdmin
   7  */
   8
   9 /**
  10  * base class
  11  */
  12 require_once './libraries/Message.class.php';
  13
  14 /**
  15  * a single error
  16  *
  17  * @package PhpMyAdmin
  18  */
  19 class PMA_Error extends PMA_Message
  20 {
  21     /**
  22      * Error types
  23      *
  24      * @var array
  25      */
  26     static public $errortype = array (
  27         E_ERROR              => 'Error',
  28         E_WARNING            => 'Warning',
  29         E_PARSE              => 'Parsing Error',
  30         E_NOTICE             => 'Notice',
  31         E_CORE_ERROR         => 'Core Error',
  32         E_CORE_WARNING       => 'Core Warning',
  33         E_COMPILE_ERROR      => 'Compile Error',
  34         E_COMPILE_WARNING    => 'Compile Warning',
  35         E_USER_ERROR         => 'User Error',
  36         E_USER_WARNING       => 'User Warning',
  37         E_USER_NOTICE        => 'User Notice',
  38         E_STRICT             => 'Runtime Notice',
  39         E_DEPRECATED         => 'Deprecation Notice',
  40         E_RECOVERABLE_ERROR  => 'Catchable Fatal Error',
  41     );
  42
  43     /**
  44      * Error levels
  45      *
  46      * @var array
  47      */
  48     static public $errorlevel = array (
  49         E_ERROR              => 'error',
  50         E_WARNING            => 'error',
  51         E_PARSE              => 'error',
  52         E_NOTICE             => 'notice',
  53         E_CORE_ERROR         => 'error',
  54         E_CORE_WARNING       => 'error',
  55         E_COMPILE_ERROR      => 'error',
  56         E_COMPILE_WARNING    => 'error',
  57         E_USER_ERROR         => 'error',
  58         E_USER_WARNING       => 'error',
  59         E_USER_NOTICE        => 'notice',
  60         E_STRICT             => 'notice',
  61         E_DEPRECATED         => 'notice',
  62         E_RECOVERABLE_ERROR  => 'error',
  63     );
  64
  65     /**
  66      * The file in which the error occured
  67      *
  68      * @var string
  69      */
  70     protected $_file = '';
  71
  72     /**
  73      * The line in which the error occured
  74      *
  75      * @var integer
  76      */
  77     protected $_line = 0;
  78
  79     /**
  80      * Holds the backtrace for this error
  81      *
  82      * @var array
  83      */
  84     protected $_backtrace = array();
  85
  86     /**
  87      * Unique id
  88      *
  89      * @var string
  90      */
  91     protected $_hash = null;
  92
  93     /**
  94      * Constructor
  95      *
  96      * @param integer $errno
  97      * @param string  $errstr
  98      * @param string  $errfile
  99      * @param integer $errline
 100      */
 101     public function __construct($errno, $errstr, $errfile, $errline)
 102     {
 103         $this->setNumber($errno);
 104         $this->setMessage($errstr, false);
 105         $this->setFile($errfile);
 106         $this->setLine($errline);
 107
 108         $backtrace = debug_backtrace();
 109         // remove last two calls: debug_backtrace() and handleError()
 110         unset($backtrace[0]);
 111         unset($backtrace[1]);
 112
 113         $this->setBacktrace($backtrace);
 114     }
 115
 116     /**
 117      * sets PMA_Error::$_backtrace
 118      *
 119      * @param array $backtrace
 120      */
 121     public function setBacktrace($backtrace)
 122     {
 123         $this->_backtrace = $backtrace;
 124     }
 125
 126     /**
 127      * sets PMA_Error::$_line
 128      *
 129      * @param integer $line
 130      */
 131     public function setLine($line)
 132     {
 133         $this->_line = $line;
 134     }
 135
 136     /**
 137      * sets PMA_Error::$_file
 138      *
 139      * @param string $file
 140      */
 141     public function setFile($file)
 142     {
 143         $this->_file = PMA_Error::relPath($file);
 144     }
 145
 146
 147     /**
 148      * returns unique PMA_Error::$_hash, if not exists it will be created
 149      *
 150      * @param string $file
 151      * @return  string PMA_Error::$_hash
 152      */
 153     public function getHash()
 154     {
 155         if (null === $this->_hash) {
 156             $this->_hash = md5(
 157                 $this->getNumber() .
 158                 $this->getMessage() .
 159                 $this->getFile() .
 160                 $this->getLine() .
 161                 serialize($this->getBacktrace())
 162             );
 163         }
 164
 165         return $this->_hash;
 166     }
 167
 168     /**
 169      * returns PMA_Error::$_backtrace
 170      *
 171      * @return  array PMA_Error::$_backtrace
 172      */
 173     public function getBacktrace()
 174     {
 175         return $this->_backtrace;
 176     }
 177
 178     /**
 179      * returns PMA_Error::$_file
 180      *
 181      * @return  string PMA_Error::$_file
 182      */
 183     public function getFile()
 184     {
 185         return $this->_file;
 186     }
 187
 188     /**
 189      * returns PMA_Error::$_line
 190      *
 191      * @return  integer PMA_Error::$_line
 192      */
 193     public function getLine()
 194     {
 195         return $this->_line;
 196     }
 197
 198     /**
 199      * returns type of error
 200      *
 201      * @return  string  type of error
 202      */
 203     public function getType()
 204     {
 205         return PMA_Error::$errortype[$this->getNumber()];
 206     }
 207
 208     /**
 209      * returns level of error
 210      *
 211      * @return  string  level of error
 212      */
 213     public function getLevel()
 214     {
 215         return PMA_Error::$errorlevel[$this->getNumber()];
 216     }
 217
 218     /**
 219      * returns title prepared for HTML Title-Tag
 220      *
 221      * @return  string   HTML escaped and truncated title
 222      */
 223     public function getHtmlTitle()
 224     {
 225         return htmlspecialchars(substr($this->getTitle(), 0, 100));
 226     }
 227
 228     /**
 229      * returns title for error
 230      *
 231      * @return string
 232      */
 233     public function getTitle()
 234     {
 235         return $this->getType() . ': ' . $this->getMessage();
 236     }
 237
 238     /**
 239      * Display HTML backtrace
 240      *
 241      */
 242     public function displayBacktrace()
 243     {
 244         foreach ($this->getBacktrace() as $step) {
 245             echo PMA_Error::relPath($step['file']) . '#' . $step['line'] . ': ';
 246             if (isset($step['class'])) {
 247                 echo $step['class'] . $step['type'];
 248             }
 249             echo $step['function'] . '(';
 250             if (isset($step['args']) && (count($step['args']) > 1)) {
 251                 echo "<br />\n";
 252                 foreach ($step['args'] as $arg) {
 253                     echo "\t";
 254                     $this->displayArg($arg, $step['function']);
 255                     echo ',' . "<br />\n";
 256                 }
 257             } elseif (isset($step['args']) && (count($step['args']) > 0)) {
 258                 foreach ($step['args'] as $arg) {
 259                     $this->displayArg($arg, $step['function']);
 260                 }
 261             }
 262             echo ')' . "<br />\n";
 263         }
 264     }
 265
 266     /**
 267      * Display a single function argument
 268      * if $function is one of include/require the $arg is converted te relative path
 269      *
 270      * @param string $arg
 271      * @param string $function
 272      */
 273     protected function displayArg($arg, $function)
 274     {
 275         $include_functions = array(
 276             'include',
 277             'include_once',
 278             'require',
 279             'require_once',
 280         );
 281
 282         if (in_array($function, $include_functions)) {
 283             echo PMA_Error::relPath($arg);
 284         } elseif (is_scalar($arg)) {
 285             echo gettype($arg) . ' ' . htmlspecialchars($arg);
 286         } else {
 287             echo gettype($arg);
 288         }
 289     }
 290
 291     /**
 292      * Displays the error in HTML
 293      *
 294      */
 295     public function display()
 296     {
 297         echo '<div class="' . $this->getLevel() . '">';
 298         if (! $this->isUserError()) {
 299             echo '<strong>' . $this->getType() . '</strong>';
 300             echo ' in ' . $this->getFile() . '#' . $this->getLine();
 301             echo "<br />\n";
 302         }
 303         echo $this->getMessage();
 304         if (! $this->isUserError()) {
 305             echo "<br />\n";
 306             echo "<br />\n";
 307             echo "<strong>Backtrace</strong><br />\n";
 308             echo "<br />\n";
 309             echo $this->displayBacktrace();
 310         }
 311         echo '</div>';
 312         $this->isDisplayed(true);
 313     }
 314
 315     /**
 316      * whether this error is a user error
 317      *
 318      * @return  boolean
 319      */
 320     public function isUserError()
 321     {
 322         return $this->getNumber() & (E_USER_WARNING | E_USER_ERROR | E_USER_NOTICE);
 323     }
 324
 325     /**
 326      * return short relative path to phpMyAdmin basedir
 327      *
 328      * prevent path disclusore in error message,
 329      * and make users feel save to submit error reports
 330      *
 331      * @static
 332      * @param string $dest  path to be shorten
 333      * @return  string shortened path
 334      */
 335     static function relPath($dest)
 336     {
 337         $dest = realpath($dest);
 338
 339         if (substr(PHP_OS, 0, 3) == 'WIN') {
 340             $path_separator = '\\';
 341         } else {
 342             $path_separator = '/';
 343         }
 344
 345         $Ahere = explode($path_separator, realpath(dirname(__FILE__) . $path_separator . '..'));
 346         $Adest = explode($path_separator, $dest);
 347
 348         $result = '.';
 349         // && count ($Adest)>0 && count($Ahere)>0 )
 350         while (implode($path_separator, $Adest) != implode($path_separator, $Ahere)) {
 351             if (count($Ahere) > count($Adest)) {
 352                 array_pop($Ahere);
 353                 $result .= $path_separator . '..';
 354             } else {
 355                 array_pop($Adest);
 356             }
 357         }
 358         $path = $result . str_replace(implode($path_separator, $Adest), '', $dest);
 359         return str_replace($path_separator . $path_separator, $path_separator, $path);
 360     }
 361 }
 362 ?>