!C99Shell v. 1.0 pre-release build #13!

Software: Apache. PHP/5.5.15 

uname -a: Windows NT SVR-DMZ 6.1 build 7600 (Windows Server 2008 R2 Enterprise Edition) i586 

SYSTEM 

Safe-mode: OFF (not secure)

E:\xampp\xampp\phpMyAdmin\libraries\   drwxrwxrwx
Free 1.16 GB of 239.26 GB (0.48%)
Detected drives: [ a ] [ c ] [ d ] [ e ] [ f ]
Home    Back    Forward    UPDIR    Refresh    Search    Buffer    Encoder    Tools    Proc.    FTP brute    Sec.    SQL    PHP-code    Update    Feedback    Self remove    Logout    


Viewing file:     Error_Handler.class.php (10.41 KB)      -rw-rw-rw-
Select action/file-type:
(+) | (+) | (+) | Code (+) | Session (+) | (+) | SDB (+) | (+) | (+) | (+) | (+) | (+) |
<?php
/* vim: set expandtab sw=4 ts=4 sts=4: */
/**
 * Holds class PMA_Error_Handler
 *
 * @version $Id: Error_Handler.class.php 12298 2009-03-22 12:25:17Z lem9 $
 * @package phpMyAdmin
 */

/**
 *
 */
require_once './libraries/Error.class.php';

/**
 * handling errors
 *
 * @package phpMyAdmin
 */
class PMA_Error_Handler
{
    
/**
     * holds errors to be displayed or reported later ...
     *
     * @var array of PMA_Error
     */
    
protected $_errors = array();

    
/**
     * Constructor - set PHP error handler
     *
     * @uses    set_error_handler()
     */
    
public function __construct()
    {
        
set_error_handler(array($this'handleError'));
    }

    
/**
     * Destructor
     *
     * stores errors in session
     *
     * @uses    $_SESSION['errors']
     * @uses    array_merge()
     * @uses    PMA_Error_Handler::$_errors
     * @uses    PMA_Error::isDisplayed()
     */
    
public function __destruct()
    {
        if (isset(
$_SESSION)) {
            if (! isset(
$_SESSION['errors'])) {
                
$_SESSION['errors'] = array();
            }

            if (
$GLOBALS['cfg']['Error_Handler']['gather']) {
                
// remember all errors
                
$_SESSION['errors'] = array_merge($_SESSION['errors'], $this->_errors);
            } else {
                
// remember only not displayed errors
                
foreach ($this->_errors as $key => $error) {
                    if ((
$error instanceof PMA_Error) && ! $error->isDisplayed()) {
                        
$_SESSION['errors'][$key] = $error;
                    }
                }
            }
        }
    }

    
/**
     * returns array with all errors
     *
     * @uses    PMA_Error_Handler::$_errors as return value
     * @uses    PMA_Error_Handler::_checkSavedErrors()
     * @return array PMA_Error_Handler::$_errors
     */
    
protected function getErrors()
    {
        
$this->_checkSavedErrors();
        return 
$this->_errors;
    }

    
/**
     * Error handler - called when errors are triggered/occured
     *
     * The following error types cannot be handled with a user defined function:
     * E_ERROR, E_PARSE, E_CORE_ERROR, E_CORE_WARNING, E_COMPILE_ERROR,
     * E_COMPILE_WARNING,
     * and most of E_STRICT raised in the file where set_error_handler() is called.
     *
     * @uses    E_USER_NOTICE
     * @uses    E_USER_WARNING
     * @uses    E_STRICT
     * @uses    E_NOTICE
     * @uses    E_WARNING
     * @uses    E_CORE_WARNING
     * @uses    E_COMPILE_WARNING
     * @uses    E_USER_ERROR
     * @uses    E_ERROR
     * @uses    E_PARSE
     * @uses    E_CORE_ERROR
     * @uses    E_COMPILE_ERROR
     * @uses    E_RECOVERABLE_ERROR
     * @uses    PMA_Error
     * @uses    PMA_Error_Handler::$_errors
     * @uses    PMA_Error_Handler::_dispFatalError()
     * @uses    PMA_Error::getHash()
     * @uses    PMA_Error::getNumber()
     * @param   integer $errno
     * @param   string  $errstr
     * @param   string  $errfile
     * @param   integer $errline
     * @param   array   $errcontext
     */
    
public function handleError($errno$errstr$errfile$errline$errcontext)
    {
        
// create error object
        
$error = new PMA_Error($errno$errstr$errfile$errline$errcontext);

        
// do not repeat errors
        
$this->_errors[$error->getHash()] = $error;

        switch (
$error->getNumber()) {
            case 
E_USER_NOTICE:
            case 
E_USER_WARNING:
            case 
E_STRICT:
            case 
E_DEPRECATED:
            case 
E_NOTICE:
            case 
E_WARNING:
            case 
E_CORE_WARNING:
            case 
E_COMPILE_WARNING:
            case 
E_USER_ERROR:
            case 
E_RECOVERABLE_ERROR:
                
// just collect the error
                // display is called from outside
                
break;
            case 
E_ERROR:
            case 
E_PARSE:
            case 
E_CORE_ERROR:
            case 
E_COMPILE_ERROR:
            default:
                
// FATAL error, dislay it and exit
                
$this->_dispFatalError($error);
                exit;
                break;
        }
    }

    
/**
     * log error to configured log facility
     *
     * @todo    finish!
     * @uses    PMA_Error::getMessage()
     * @uses    error_log()
     * @param   PMA_Error $error
     */
    
protected function _logError($error)
    {
        return 
error_log($error->getMessage());
    }

    
/**
     * trigger a custom error
     *
     * @uses    trigger_error()
     * @param   string  $errorInfo
     * @param   integer $errorNumber
     * @param   string  $file
     * @param   integer $line
     */
    
public function triggerError($errorInfo$errorNumber null$file null$line null)
    {
        
// we could also extract file and line from backtrace and call handleError() directly
        
trigger_error($errorInfo$errorNumber);
    }

    
/**
     * display fatal error and exit
     *
     * @uses    headers_sent()
     * @uses    PMA_Error::display()
     * @uses    PMA_Error_Handler::_dispPageStart()
     * @uses    PMA_Error_Handler::_dispPageEnd()
     * @param   PMA_Error $error
     */
    
protected function _dispFatalError($error)
    {
        if (! 
headers_sent()) {
            
$this->_dispPageStart($error);
        }
        
$error->display();
        
$this->_dispPageEnd();
        exit;
    }

    
/**
     * display the whole error page with all errors
     *
     * @uses    headers_sent()
     * @uses    PMA_Error_Handler::dispAllErrors()
     * @uses    PMA_Error_Handler::_dispPageStart()
     * @uses    PMA_Error_Handler::_dispPageEnd()
     */
    
public function dispErrorPage()
    {
        if (! 
headers_sent()) {
            
$this->_dispPageStart();
        }
        
$this->dispAllErrors();
        
$this->_dispPageEnd();
    }

    
/**
     * display user errors not displayed
     *
     * @uses    PMA_Error_Handler::getErrors()
     * @uses    PMA_Error::isDisplayed()
     * @uses    PMA_Error::isUserError()
     * @uses    PMA_Error::display()
     */
    
public function dispUserErrors()
    {
        foreach (
$this->getErrors() as $error) {
            if (
$error->isUserError() && ! $error->isDisplayed()) {
                
$error->display();
            }
        }
    }

    
/**
     * display HTML header
     *
     * @uses    PMA_Error::getTitle()
     * @param   PMA_error $error
     */
    
protected function _dispPageStart($error null)
    {
        echo 
'<html><head><title>';
        if (
$error) {
            echo 
$error->getTitle();
        } else {
            echo 
'phpMyAdmin error reporting page';
        }
        echo 
'</title></head>';
    }

    
/**
     * display HTML footer
     *
     */
    
protected function _dispPageEnd()
    {
        echo 
'</body></html>';
    }

    
/**
     * display all errors regardless already displayed or user errors
     *
     * @uses    PMA_Error_Handler::getErrors()
     * @uses    PMA_Error::display()
     */
    
public function dispAllErrors()
    {
        foreach (
$this->getErrors() as $error) {
            
$error->display();
        }
    }

    
/**
     * display errors not displayed
     *
     * @uses    $cfg['Error_Handler']['display']
     * @uses    PMA_Error_Handler::getErrors()
     * @uses    PMA_Error_Handler::dispUserErrors()
     * @uses    PMA_Error::isDisplayed()
     * @uses    PMA_Error::display()
     */
    
public function dispErrors()
    {
        if (
$GLOBALS['cfg']['Error_Handler']['display']) {
            foreach (
$this->getErrors() as $error) {
                if (
$error instanceof PMA_Error) {
                    if (! 
$error->isDisplayed()) {
                        
$error->display();
                    }
                } else {
                    
var_dump($error);
                }
            }
        } else {
            
$this->dispUserErrors();
        }
    }

    
/**
     * look in session for saved errors
     *
     * @uses    $_SESSION['errors']
     * @uses    PMA_Error_Handler::$_errors
     * @uses    array_merge()
     */
    
protected function _checkSavedErrors()
    {
        if (isset(
$_SESSION['errors'])) {

            
// restore saved errors
            
foreach ($_SESSION['errors'] as $hash => $error) {
                if (
$error instanceof PMA_Error && ! isset($this->_errors[$hash])) {
                    
$this->_errors[$hash] = $error;
                }
            }
            
//$this->_errors = array_merge($_SESSION['errors'], $this->_errors);

            // delet stored errors
            
$_SESSION['errors'] = array();
            unset(
$_SESSION['errors']);
        }
    }

    
/**
     * return count of errors
     *
     * @uses    PMA_Error_Handler::getErrors()
     * @uses    count()
     * @return  integer number of errors occoured
     */
    
public function countErrors()
    {
        return 
count($this->getErrors());
    }

    
/**
     * return count of user errors
     *
     * @uses    PMA_Error_Handler::countErrors()
     * @uses    PMA_Error_Handler::getErrors()
     * @uses    PMA_Error::isUserError()
     * @return  integer number of user errors occoured
     */
    
public function countUserErrors()
    {
        
$count 0;
        if (
$this->countErrors()) {
            foreach (
$this->getErrors() as $error) {
                if (
$error->isUserError()) {
                    
$count++;
                }
            }
        }

        return 
$count;
    }

    
/**
     * whether use errors occured or not
     *
     * @uses    PMA_Error_Handler::countUserErrors()
     * @return  boolean
     */
    
public function hasUserErrors()
    {
        return (bool) 
$this->countUserErrors();
    }

    
/**
     * whether errors occured or not
     *
     * @uses    PMA_Error_Handler::countErrors()
     * @return  boolean
     */
    
public function hasErrors()
    {
        return (bool) 
$this->countErrors();
    }

    
/**
     * number of errors to be displayed
     *
     * @uses    $cfg['Error_Handler']['display']
     * @uses    PMA_Error_Handler::countErrors()
     * @uses    PMA_Error_Handler::countUserErrors()
     * @return integer number of errors to be displayed
     */
    
public function countDisplayErrors()
    {
        if (
$GLOBALS['cfg']['Error_Handler']['display']) {
            return 
$this->countErrors();
        } else {
            return 
$this->countUserErrors();
        }
    }

    
/**
     * whether there are errors to display or not
     *
     * @uses    PMA_Error_Handler::countDisplayErrors()
     * @return boolean
     */
    
public function hasDisplayErrors()
    {
        return (bool) 
$this->countDisplayErrors();
    }
}
?>

:: Command execute ::

Enter:
 
Select:
 

:: Search ::
  - regexp 

:: Upload ::
 
[ ok ]

:: Make Dir ::
 
[ ok ]
:: Make File ::
 
[ ok ]

:: Go Dir ::
 
:: Go File ::
 

--[ c99shell v. 1.0 pre-release build #13 powered by Captain Crunch Security Team | http://ccteam.ru | Generation time: 0.0156 ]--