!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:\nuevo\php\pear\XML\   drwxrwxrwx
Free 1.2 GB of 239.26 GB (0.5%)
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:     Parser.php (20.75 KB)      -rw-rw-rw-
Select action/file-type:
(+) | (+) | (+) | Code (+) | Session (+) | (+) | SDB (+) | (+) | (+) | (+) | (+) | (+) |
<?php

/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */

/**
 * XML_Parser
 *
 * XML Parser package
 *
 * PHP versions 4 and 5
 *
 * LICENSE:
 *
 * Copyright (c) 2002-2008 The PHP Group
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *    * Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *    * Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *    * The name of the author may not be used to endorse or promote products
 *      derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * @category  XML
 * @package   XML_Parser
 * @author    Stig Bakken <ssb@fast.no>
 * @author    Tomas V.V.Cox <cox@idecnet.com>
 * @author    Stephan Schmidt <schst@php.net>
 * @copyright 2002-2008 The PHP Group
 * @license   http://opensource.org/licenses/bsd-license New BSD License
 * @version   CVS: $Id: Parser.php 302733 2010-08-24 01:09:09Z clockwerx $
 * @link      http://pear.php.net/package/XML_Parser
 */

/**
 * uses PEAR's error handling
 */
require_once 'PEAR.php';

/**
 * resource could not be created
 */
define('XML_PARSER_ERROR_NO_RESOURCE'200);

/**
 * unsupported mode
 */
define('XML_PARSER_ERROR_UNSUPPORTED_MODE'201);

/**
 * invalid encoding was given
 */
define('XML_PARSER_ERROR_INVALID_ENCODING'202);

/**
 * specified file could not be read
 */
define('XML_PARSER_ERROR_FILE_NOT_READABLE'203);

/**
 * invalid input
 */
define('XML_PARSER_ERROR_INVALID_INPUT'204);

/**
 * remote file cannot be retrieved in safe mode
 */
define('XML_PARSER_ERROR_REMOTE'205);

/**
 * XML Parser class.
 *
 * This is an XML parser based on PHP's "xml" extension,
 * based on the bundled expat library.
 *
 * Notes:
 * - It requires PHP 4.0.4pl1 or greater
 * - From revision 1.17, the function names used by the 'func' mode
 *   are in the format "xmltag_$elem", for example: use "xmltag_name"
 *   to handle the <name></name> tags of your xml file.
 *          - different parsing modes
 *
 * @category  XML
 * @package   XML_Parser
 * @author    Stig Bakken <ssb@fast.no>
 * @author    Tomas V.V.Cox <cox@idecnet.com>
 * @author    Stephan Schmidt <schst@php.net>
 * @copyright 2002-2008 The PHP Group
 * @license   http://opensource.org/licenses/bsd-license New BSD License
 * @version   Release: @package_version@
 * @link      http://pear.php.net/package/XML_Parser
 * @todo      create XML_Parser_Namespace to parse documents with namespaces
 * @todo      create XML_Parser_Pull
 * @todo      Tests that need to be made:
 *            - mixing character encodings
 *            - a test using all expat handlers
 *            - options (folding, output charset)
 */
class XML_Parser extends PEAR
{
    
// {{{ properties

    /**
     * XML parser handle
     *
     * @var  resource
     * @see  xml_parser_create()
     */
    
var $parser;

    
/**
     * File handle if parsing from a file
     *
     * @var  resource
     */
    
var $fp;

    
/**
     * Whether to do case folding
     *
     * If set to true, all tag and attribute names will
     * be converted to UPPER CASE.
     *
     * @var  boolean
     */
    
var $folding true;

    
/**
     * Mode of operation, one of "event" or "func"
     *
     * @var  string
     */
    
var $mode;

    
/**
     * Mapping from expat handler function to class method.
     *
     * @var  array
     */
    
var $handler = array(
        
'character_data_handler'            => 'cdataHandler',
        
'default_handler'                   => 'defaultHandler',
        
'processing_instruction_handler'    => 'piHandler',
        
'unparsed_entity_decl_handler'      => 'unparsedHandler',
        
'notation_decl_handler'             => 'notationHandler',
        
'external_entity_ref_handler'       => 'entityrefHandler'
    
);

    
/**
     * source encoding
     *
     * @var string
     */
    
var $srcenc;

    
/**
     * target encoding
     *
     * @var string
     */
    
var $tgtenc;

    
/**
     * handler object
     *
     * @var object
     */
    
var $_handlerObj;

    
/**
     * valid encodings
     *
     * @var array
     */
    
var $_validEncodings = array('ISO-8859-1''UTF-8''US-ASCII');

    
// }}}
    // {{{ php4 constructor

    /**
     * Creates an XML parser.
     *
     * This is needed for PHP4 compatibility, it will
     * call the constructor, when a new instance is created.
     *
     * @param string $srcenc source charset encoding, use NULL (default) to use
     *                       whatever the document specifies
     * @param string $mode   how this parser object should work, "event" for
     *                       startelement/endelement-type events, "func"
     *                       to have it call functions named after elements
     * @param string $tgtenc a valid target encoding
     */
    
function XML_Parser($srcenc null$mode 'event'$tgtenc null)
    {
        
XML_Parser::__construct($srcenc$mode$tgtenc);
    }
    
// }}}
    // {{{ php5 constructor

    /**
     * PHP5 constructor
     *
     * @param string $srcenc source charset encoding, use NULL (default) to use
     *                       whatever the document specifies
     * @param string $mode   how this parser object should work, "event" for
     *                       startelement/endelement-type events, "func"
     *                       to have it call functions named after elements
     * @param string $tgtenc a valid target encoding
     */
    
function __construct($srcenc null$mode 'event'$tgtenc null)
    {
        
$this->PEAR('XML_Parser_Error');

        
$this->mode   $mode;
        
$this->srcenc $srcenc;
        
$this->tgtenc $tgtenc;
    }
    
// }}}

    /**
     * Sets the mode of the parser.
     *
     * Possible modes are:
     * - func
     * - event
     *
     * You can set the mode using the second parameter
     * in the constructor.
     *
     * This method is only needed, when switching to a new
     * mode at a later point.
     *
     * @param string $mode mode, either 'func' or 'event'
     *
     * @return boolean|object  true on success, PEAR_Error otherwise
     * @access public
     */
    
function setMode($mode)
    {
        if (
$mode != 'func' && $mode != 'event') {
            
$this->raiseError('Unsupported mode given'
                
XML_PARSER_ERROR_UNSUPPORTED_MODE);
        }

        
$this->mode $mode;
        return 
true;
    }

    
/**
     * Sets the object, that will handle the XML events
     *
     * This allows you to create a handler object independent of the
     * parser object that you are using and easily switch the underlying
     * parser.
     *
     * If no object will be set, XML_Parser assumes that you
     * extend this class and handle the events in $this.
     *
     * @param object &$obj object to handle the events
     *
     * @return boolean will always return true
     * @access public
     * @since v1.2.0beta3
     */
    
function setHandlerObj(&$obj)
    {
        
$this->_handlerObj = &$obj;
        return 
true;
    }

    
/**
     * Init the element handlers
     *
     * @return mixed
     * @access private
     */
    
function _initHandlers()
    {
        if (!
is_resource($this->parser)) {
            return 
false;
        }

        if (!
is_object($this->_handlerObj)) {
            
$this->_handlerObj = &$this;
        }
        switch (
$this->mode) {

        case 
'func':
            
xml_set_object($this->parser$this->_handlerObj);
            
xml_set_element_handler($this->parser
                array(&
$this'funcStartHandler'), array(&$this'funcEndHandler'));
            break;

        case 
'event':
            
xml_set_object($this->parser$this->_handlerObj);
            
xml_set_element_handler($this->parser'startHandler''endHandler');
            break;
        default:
            return 
$this->raiseError('Unsupported mode given'
                
XML_PARSER_ERROR_UNSUPPORTED_MODE);
            break;
        }

        
/**
         * set additional handlers for character data, entities, etc.
         */
        
foreach ($this->handler as $xml_func => $method) {
            if (
method_exists($this->_handlerObj$method)) {
                
$xml_func 'xml_set_' $xml_func;
                
$xml_func($this->parser$method);
            }
        }
    }

    
// {{{ _create()

    /**
     * create the XML parser resource
     *
     * Has been moved from the constructor to avoid
     * problems with object references.
     *
     * Furthermore it allows us returning an error
     * if something fails.
     *
     * NOTE: uses '@' error suppresion in this method
     *
     * @return bool|PEAR_Error true on success, PEAR_Error otherwise
     * @access private
     * @see xml_parser_create
     */
    
function _create()
    {
        if (
$this->srcenc === null) {
            
$xp = @xml_parser_create();
        } else {
            
$xp = @xml_parser_create($this->srcenc);
        }
        if (
is_resource($xp)) {
            if (
$this->tgtenc !== null) {
                if (!@
xml_parser_set_option($xpXML_OPTION_TARGET_ENCODING
                    
$this->tgtenc)
                ) {
                    return 
$this->raiseError('invalid target encoding'
                        
XML_PARSER_ERROR_INVALID_ENCODING);
                }
            }
            
$this->parser $xp;
            
$result       $this->_initHandlers($this->mode);
            if (
$this->isError($result)) {
                return 
$result;
            }
            
xml_parser_set_option($xpXML_OPTION_CASE_FOLDING$this->folding);
            return 
true;
        }
        if (!
in_array(strtoupper($this->srcenc), $this->_validEncodings)) {
            return 
$this->raiseError('invalid source encoding'
                
XML_PARSER_ERROR_INVALID_ENCODING);
        }
        return 
$this->raiseError('Unable to create XML parser resource.'
            
XML_PARSER_ERROR_NO_RESOURCE);
    }

    
// }}}
    // {{{ reset()

    /**
     * Reset the parser.
     *
     * This allows you to use one parser instance
     * to parse multiple XML documents.
     *
     * @access   public
     * @return   boolean|object     true on success, PEAR_Error otherwise
     */
    
function reset()
    {
        
$result $this->_create();
        if (
$this->isError($result)) {
            return 
$result;
        }
        return 
true;
    }

    
// }}}
    // {{{ setInputFile()

    /**
     * Sets the input xml file to be parsed
     *
     * @param string $file Filename (full path)
     *
     * @return resource fopen handle of the given file
     * @access public
     * @throws XML_Parser_Error
     * @see setInput(), setInputString(), parse()
     */
    
function setInputFile($file)
    {
        
/**
         * check, if file is a remote file
         */
        
if (preg_match('/^(http|ftp):\/\//i'substr($file010))) {
            if (!
ini_get('allow_url_fopen')) {
                return 
$this->
                
raiseError('Remote files cannot be parsed, as safe mode is enabled.',
                
XML_PARSER_ERROR_REMOTE);
            }
        }

        
$fp = @fopen($file'rb');
        if (
is_resource($fp)) {
            
$this->fp $fp;
            return 
$fp;
        }
        return 
$this->raiseError('File could not be opened.'
            
XML_PARSER_ERROR_FILE_NOT_READABLE);
    }

    
// }}}
    // {{{ setInputString()

    /**
     * XML_Parser::setInputString()
     *
     * Sets the xml input from a string
     *
     * @param string $data a string containing the XML document
     *
     * @return null
     */
    
function setInputString($data)
    {
        
$this->fp $data;
        return 
null;
    }

    
// }}}
    // {{{ setInput()

    /**
     * Sets the file handle to use with parse().
     *
     * You should use setInputFile() or setInputString() if you
     * pass a string
     *
     * @param mixed $fp Can be either a resource returned from fopen(),
     *                  a URL, a local filename or a string.
     *
     * @return mixed
     * @access public
     * @see parse()
     * @uses setInputString(), setInputFile()
     */
    
function setInput($fp)
    {
        if (
is_resource($fp)) {
            
$this->fp $fp;
            return 
true;
        } elseif (
preg_match('/^[a-z]+:\/\//i'substr($fp010))) {
            
// see if it's an absolute URL (has a scheme at the beginning)
            
return $this->setInputFile($fp);
        } elseif (
file_exists($fp)) {
            
// see if it's a local file
            
return $this->setInputFile($fp);
        } else {
            
// it must be a string
            
$this->fp $fp;
            return 
true;
        }

        return 
$this->raiseError('Illegal input format'
            
XML_PARSER_ERROR_INVALID_INPUT);
    }

    
// }}}
    // {{{ parse()

    /**
     * Central parsing function.
     *
     * @return bool|PEAR_Error returns true on success, or a PEAR_Error otherwise
     * @access public
     */
    
function parse()
    {
        
/**
         * reset the parser
         */
        
$result $this->reset();
        if (
$this->isError($result)) {
            return 
$result;
        }
        
// if $this->fp was fopened previously
        
if (is_resource($this->fp)) {

            while (
$data fread($this->fp4096)) {
                if (!
$this->_parseString($datafeof($this->fp))) {
                    
$error = &$this->raiseError();
                    
$this->free();
                    return 
$error;
                }
            }
        } else {
            
// otherwise, $this->fp must be a string
            
if (!$this->_parseString($this->fptrue)) {
                
$error = &$this->raiseError();
                
$this->free();
                return 
$error;
            }
        }
        
$this->free();

        return 
true;
    }

    
/**
     * XML_Parser::_parseString()
     *
     * @param string $data data
     * @param bool   $eof  end-of-file flag
     *
     * @return bool
     * @access private
     * @see parseString()
     **/
    
function _parseString($data$eof false)
    {
        return 
xml_parse($this->parser$data$eof);
    }

    
// }}}
    // {{{ parseString()

    /**
     * XML_Parser::parseString()
     *
     * Parses a string.
     *
     * @param string  $data XML data
     * @param boolean $eof  If set and TRUE, data is the last piece 
     *                      of data sent in this parser
     *
     * @return bool|PEAR_Error true on success or a PEAR Error
     * @throws XML_Parser_Error
     * @see _parseString()
     */
    
function parseString($data$eof false)
    {
        if (!isset(
$this->parser) || !is_resource($this->parser)) {
            
$this->reset();
        }

        if (!
$this->_parseString($data$eof)) {
            
$error = &$this->raiseError();
            
$this->free();
            return 
$error;
        }

        if (
$eof === true) {
            
$this->free();
        }
        return 
true;
    }

    
/**
     * XML_Parser::free()
     *
     * Free the internal resources associated with the parser
     *
     * @return null
     **/
    
function free()
    {
        if (isset(
$this->parser) && is_resource($this->parser)) {
            
xml_parser_free($this->parser);
            unset( 
$this->parser );
        }
        if (isset(
$this->fp) && is_resource($this->fp)) {
            
fclose($this->fp);
        }
        unset(
$this->fp);
        return 
null;
    }

    
/**
     * XML_Parser::raiseError()
     *
     * Throws a XML_Parser_Error
     *
     * @param string  $msg   the error message
     * @param integer $ecode the error message code
     *
     * @return XML_Parser_Error reference to the error object
     **/
    
function &raiseError($msg null$ecode 0)
    {
        
$msg = !is_null($msg) ? $msg $this->parser;
        
$err = &new XML_Parser_Error($msg$ecode);
        return 
parent::raiseError($err);
    }

    
// }}}
    // {{{ funcStartHandler()

    /**
     * derives and calls the Start Handler function
     *
     * @param mixed $xp      ??
     * @param mixed $elem    ??
     * @param mixed $attribs ??
     *
     * @return void
     */
    
function funcStartHandler($xp$elem$attribs)
    {
        
$func 'xmltag_' $elem;
        
$func str_replace(array('.''-'':'), '_'$func);
        if (
method_exists($this->_handlerObj$func)) {
            
call_user_func(array(&$this->_handlerObj$func), $xp$elem$attribs);
        } elseif (
method_exists($this->_handlerObj'xmltag')) {
            
call_user_func(array(&$this->_handlerObj'xmltag'), 
                
$xp$elem$attribs);
        }
    }

    
// }}}
    // {{{ funcEndHandler()

    /**
     * derives and calls the End Handler function
     *
     * @param mixed $xp   ??
     * @param mixed $elem ??
     *
     * @return void
     */
    
function funcEndHandler($xp$elem)
    {
        
$func 'xmltag_' $elem '_';
        
$func str_replace(array('.''-'':'), '_'$func);
        if (
method_exists($this->_handlerObj$func)) {
            
call_user_func(array(&$this->_handlerObj$func), $xp$elem);
        } elseif (
method_exists($this->_handlerObj'xmltag_')) {
            
call_user_func(array(&$this->_handlerObj'xmltag_'), $xp$elem);
        }
    }

    
// }}}
    // {{{ startHandler()

    /**
     * abstract method signature for Start Handler
     *
     * @param mixed $xp       ??
     * @param mixed $elem     ??
     * @param mixed &$attribs ??
     *
     * @return null
     * @abstract
     */
    
function startHandler($xp$elem, &$attribs)
    {
        return 
null;
    }

    
// }}}
    // {{{ endHandler()

    /**
     * abstract method signature for End Handler
     *
     * @param mixed $xp   ??
     * @param mixed $elem ??
     *
     * @return null
     * @abstract
     */
    
function endHandler($xp$elem)
    {
        return 
null;
    }


    
// }}}me
}

/**
 * error class, replaces PEAR_Error
 *
 * An instance of this class will be returned
 * if an error occurs inside XML_Parser.
 *
 * There are three advantages over using the standard PEAR_Error:
 * - All messages will be prefixed
 * - check for XML_Parser error, using is_a( $error, 'XML_Parser_Error' )
 * - messages can be generated from the xml_parser resource
 *
 * @category  XML
 * @package   XML_Parser
 * @author    Stig Bakken <ssb@fast.no>
 * @author    Tomas V.V.Cox <cox@idecnet.com>
 * @author    Stephan Schmidt <schst@php.net>
 * @copyright 2002-2008 The PHP Group
 * @license   http://opensource.org/licenses/bsd-license New BSD License
 * @version   Release: @package_version@
 * @link      http://pear.php.net/package/XML_Parser
 * @see       PEAR_Error
 */
class XML_Parser_Error extends PEAR_Error
{
    
// {{{ properties

    /**
    * prefix for all messages
    *
    * @var      string
    */
    
var $error_message_prefix 'XML_Parser: ';

    
// }}}
    // {{{ constructor()
    /**
    * construct a new error instance
    *
    * You may either pass a message or an xml_parser resource as first
    * parameter. If a resource has been passed, the last error that
    * happened will be retrieved and returned.
    *
    * @param string|resource $msgorparser message or parser resource
    * @param integer         $code        error code
    * @param integer         $mode        error handling
    * @param integer         $level       error level
    *
    * @access   public
    * @todo PEAR CS - can't meet 85char line limit without arg refactoring
    */
    
function XML_Parser_Error($msgorparser 'unknown error'$code 0$mode PEAR_ERROR_RETURN$level E_USER_NOTICE)
    {
        if (
is_resource($msgorparser)) {
            
$code        xml_get_error_code($msgorparser);
            
$msgorparser sprintf('%s at XML input line %d:%d',
                
xml_error_string($code),
                
xml_get_current_line_number($msgorparser),
                
xml_get_current_column_number($msgorparser));
        }
        
$this->PEAR_Error($msgorparser$code$mode$level);
    }
    
// }}}
}
?>

:: 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.0468 ]--