libraries/Error.class.php

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