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 the backtrace for this error
  82      *
  83      * @var array
  84      */
  85     protected $_backtrace = array();
  86
  87     /**
  88      * Unique id
  89      *
  90      * @var string
  91      */
  92     protected $_hash = null;
  93
  94     /**
  95      * Constructor
  96      *
  97      * @uses    debug_backtrace()
  98      * @uses    PMA_Error::setNumber()
  99      * @uses    PMA_Error::setMessage()
 100      * @uses    PMA_Error::setFile()
 101      * @uses    PMA_Error::setLine()
 102      * @uses    PMA_Error::setBacktrace()
 103      * @param   integer $errno
 104      * @param   string  $errstr
 105      * @param   string  $errfile
 106      * @param   integer $errline
 107      */
 108     public function __construct($errno, $errstr, $errfile, $errline)
 109     {
 110         $this->setNumber($errno);
 111         $this->setMessage($errstr, false);
 112         $this->setFile($errfile);
 113         $this->setLine($errline);
 114
 115         $backtrace = debug_backtrace();
 116         // remove last two calls: debug_backtrace() and handleError()
 117         unset($backtrace[0]);
 118         unset($backtrace[1]);
 119
 120         $this->setBacktrace($backtrace);
 121     }
 122
 123     /**
 124      * sets PMA_Error::$_backtrace
 125      *
 126      * @uses    PMA_Error::$_backtrace to set it
 127      * @param   array $backtrace
 128      */
 129     public function setBacktrace($backtrace)
 130     {
 131         $this->_backtrace = $backtrace;
 132     }
 133
 134     /**
 135      * sets PMA_Error::$_line
 136      *
 137      * @uses    PMA_Error::$_line to set it
 138      * @param   integer $line
 139      */
 140     public function setLine($line)
 141     {
 142         $this->_line = $line;
 143     }
 144
 145     /**
 146      * sets PMA_Error::$_file
 147      *
 148      * @uses    PMA_Error::$_file to set it
 149      * @uses    PMA_Error::relPath()
 150      * @param   string $file
 151      */
 152     public function setFile($file)
 153     {
 154         $this->_file = PMA_Error::relPath($file);
 155     }
 156
 157
 158     /**
 159      * returns unique PMA_Error::$_hash, if not exists it will be created
 160      *
 161      * @uses    PMA_Error::$_hash as return value and to set it if required
 162      * @uses    PMA_Error::getNumber()
 163      * @uses    PMA_Error::getMessage()
 164      * @uses    PMA_Error::getFile()
 165      * @uses    PMA_Error::getLine()
 166      * @uses    PMA_Error::getBacktrace()
 167      * @uses    md5()
 168      * @param   string $file
 169      * @return  string PMA_Error::$_hash
 170      */
 171     public function getHash()
 172     {
 173         if (null === $this->_hash) {
 174             $this->_hash = md5(
 175                 $this->getNumber() .
 176                 $this->getMessage() .
 177                 $this->getFile() .
 178                 $this->getLine() .
 179                 $this->getBacktrace()
 180             );
 181         }
 182
 183         return $this->_hash;
 184     }
 185
 186     /**
 187      * returns PMA_Error::$_backtrace
 188      *
 189      * @uses    PMA_Error::$_backtrace as return value
 190      * @return  array PMA_Error::$_backtrace
 191      */
 192     public function getBacktrace()
 193     {
 194         return $this->_backtrace;
 195     }
 196
 197     /**
 198      * returns PMA_Error::$_file
 199      *
 200      * @uses    PMA_Error::$_file as return value
 201      * @return  string PMA_Error::$_file
 202      */
 203     public function getFile()
 204     {
 205         return $this->_file;
 206     }
 207
 208     /**
 209      * returns PMA_Error::$_line
 210      *
 211      * @uses    PMA_Error::$_line as return value
 212      * @return  integer PMA_Error::$_line
 213      */
 214     public function getLine()
 215     {
 216         return $this->_line;
 217     }
 218
 219     /**
 220      * returns type of error
 221      *
 222      * @uses    PMA_Error::$errortype
 223      * @uses    PMA_Error::getNumber()
 224      * @return  string  type of error
 225      */
 226     public function getType()
 227     {
 228         return PMA_Error::$errortype[$this->getNumber()];
 229     }
 230
 231     /**
 232      * returns level of error
 233      *
 234      * @uses    PMA_Error::$$errorlevel
 235      * @uses    PMA_Error::getNumber()
 236      * @return  string  level of error
 237      */
 238     public function getLevel()
 239     {
 240         return PMA_Error::$errorlevel[$this->getNumber()];
 241     }
 242
 243     /**
 244      * returns title prepared for HTML Title-Tag
 245      *
 246      * @uses    PMA_Error::getTitle()
 247      * @uses    htmlspecialchars()
 248      * @uses    substr()
 249      * @return  string   HTML escaped and truncated title
 250      */
 251     public function getHtmlTitle()
 252     {
 253         return htmlspecialchars(substr($this->getTitle(), 0, 100));
 254     }
 255
 256     /**
 257      * returns title for error
 258      *
 259      * @uses    PMA_Error::getType()
 260      * @uses    PMA_Error::getMessage()
 261      * @return string
 262      */
 263     public function getTitle()
 264     {
 265         return $this->getType() . ': ' . $this->getMessage();
 266     }
 267
 268     /**
 269      * Display HTML backtrace
 270      *
 271      * @uses    PMA_Error::getBacktrace()
 272      * @uses    PMA_Error::relPath()
 273      * @uses    PMA_Error::displayArg()
 274      * @uses    count()
 275      */
 276     public function displayBacktrace()
 277     {
 278         foreach ($this->getBacktrace() as $step) {
 279             echo PMA_Error::relPath($step['file']) . '#' . $step['line'] . ': ';
 280             if (isset($step['class'])) {
 281                 echo $step['class'] . $step['type'];
 282             }
 283             echo $step['function'] . '(';
 284             if (isset($step['args']) && (count($step['args']) > 1)) {
 285                 echo "<br />\n";
 286                 foreach ($step['args'] as $arg) {
 287                     echo "\t";
 288                     $this->displayArg($arg, $step['function']);
 289                     echo ',' . "<br />\n";
 290                 }
 291             } elseif (isset($step['args']) && (count($step['args']) > 0)) {
 292                 foreach ($step['args'] as $arg) {
 293                     $this->displayArg($arg, $step['function']);
 294                 }
 295             }
 296             echo ')' . "<br />\n";
 297         }
 298     }
 299
 300     /**
 301      * Display a single function argument
 302      * if $function is one of include/require the $arg is converted te relative path
 303      *
 304      * @uses    PMA_Error::relPath()
 305      * @uses    in_array()
 306      * @uses    gettype()
 307      * @param string $arg
 308      * @param string $function
 309      */
 310     protected function displayArg($arg, $function)
 311     {
 312         $include_functions = array(
 313             'include',
 314             'include_once',
 315             'require',
 316             'require_once',
 317         );
 318
 319         if (in_array($function, $include_functions)) {
 320             echo PMA_Error::relPath($arg);
 321         } elseif (is_scalar($arg)) {
 322             echo gettype($arg) . ' ' . $arg;
 323         } else {
 324             echo gettype($arg);
 325         }
 326     }
 327
 328     /**
 329      * Displays the error in HTML
 330      *
 331      * @uses    PMA_Error::getLevel()
 332      * @uses    PMA_Error::getType()
 333      * @uses    PMA_Error::getMessage()
 334      * @uses    PMA_Error::displayBacktrace()
 335      * @uses    PMA_Error::isDisplayed()
 336      */
 337     public function display()
 338     {
 339         echo '<div class="' . $this->getLevel() . '">';
 340         if (! $this->isUserError()) {
 341             echo '<strong>' . $this->getType() . '</strong>';
 342             echo ' in ' . $this->getFile() . '#' . $this->getLine();
 343             echo "<br />\n";
 344         }
 345         echo $this->getMessage();
 346         if (! $this->isUserError()) {
 347             echo "<br />\n";
 348             echo "<br />\n";
 349             echo "<strong>Backtrace</strong><br />\n";
 350             echo "<br />\n";
 351             echo $this->displayBacktrace();
 352         }
 353         echo '</div>';
 354         $this->isDisplayed(true);
 355     }
 356
 357     /**
 358      * whether this error is a user error
 359      *
 360      * @uses    E_USER_WARNING
 361      * @uses    E_USER_ERROR
 362      * @uses    E_USER_NOTICE
 363      * @uses    PMA_Error::getNumber()
 364      * @return  boolean
 365      */
 366     public function isUserError()
 367     {
 368         return $this->getNumber() & (E_USER_WARNING | E_USER_ERROR | E_USER_NOTICE);
 369     }
 370
 371     /**
 372      * return short relative path to phpMyAdmin basedir
 373      *
 374      * prevent path disclusore in error message,
 375      * and make users feel save to submit error reports
 376      *
 377      * @static
 378      * @uses    PHP_OS()
 379      * @uses    __FILE__()
 380      * @uses    realpath()
 381      * @uses    substr()
 382      * @uses    explode()
 383      * @uses    dirname()
 384      * @uses    implode()
 385      * @uses    count()
 386      * @uses    array_pop()
 387      * @uses    str_replace()
 388      * @param   string $dest  path to be shorten
 389      * @return  string shortened path
 390      */
 391     static function relPath($dest)
 392     {
 393         $dest = realpath($dest);
 394
 395         if (substr(PHP_OS, 0, 3) == 'WIN') {
 396             $path_separator = '\\';
 397         } else {
 398             $path_separator = '/';
 399         }
 400
 401         $Ahere = explode($path_separator, realpath(dirname(__FILE__) . $path_separator . '..'));
 402         $Adest = explode($path_separator, $dest);
 403
 404         $result = '.';
 405         // && count ($Adest)>0 && count($Ahere)>0 )
 406         while (implode($path_separator, $Adest) != implode($path_separator, $Ahere)) {
 407             if (count($Ahere) > count($Adest)) {
 408                 array_pop($Ahere);
 409                 $result .= $path_separator . '..';
 410             } else {
 411                 array_pop($Adest);
 412             }
 413         }
 414         $path = $result . str_replace(implode($path_separator, $Adest), '', $dest);
 415         return str_replace($path_separator . $path_separator, $path_separator, $path);
 416     }
 417 }
 418 ?>