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