wp-includes/IXR/class-IXR-message.php

   1 <?php
   2
   3 /**
   4  * IXR_MESSAGE
   5  *
   6  * @package IXR
   7  * @since 1.5.0
   8  *
   9  */
  10 class IXR_Message
  11 {
  12     var $message;
  13     var $messageType;  // methodCall / methodResponse / fault
  14     var $faultCode;
  15     var $faultString;
  16     var $methodName;
  17     var $params;
  18
  19     // Current variable stacks
  20     var $_arraystructs = array();   // The stack used to keep track of the current array/struct
  21     var $_arraystructstypes = array(); // Stack keeping track of if things are structs or array
  22     var $_currentStructName = array();  // A stack as well
  23     var $_param;
  24     var $_value;
  25     var $_currentTag;
  26     var $_currentTagContents;
  27     // The XML parser
  28     var $_parser;
  29
  30         /**
  31          * PHP5 constructor.
  32          */
  33     function __construct( $message )
  34     {
  35         $this->message =& $message;
  36     }
  37
  38         /**
  39          * PHP4 constructor.
  40          */
  41         public function IXR_Message( $message ) {
  42                 self::__construct( $message );
  43         }
  44
  45     function parse()
  46     {
  47         if ( ! function_exists( 'xml_parser_create' ) ) {
  48             trigger_error( __( "PHP's XML extension is not available. Please contact your hosting provider to enable PHP's XML extension." ) );
  49             return false;
  50         }
  51
  52         // first remove the XML declaration
  53         // merged from WP #10698 - this method avoids the RAM usage of preg_replace on very large messages
  54         $header = preg_replace( '/<\?xml.*?\?'.'>/s', '', substr( $this->message, 0, 100 ), 1 );
  55         $this->message = trim( substr_replace( $this->message, $header, 0, 100 ) );
  56         if ( '' == $this->message ) {
  57             return false;
  58         }
  59
  60         // Then remove the DOCTYPE
  61         $header = preg_replace( '/^<!DOCTYPE[^>]*+>/i', '', substr( $this->message, 0, 200 ), 1 );
  62         $this->message = trim( substr_replace( $this->message, $header, 0, 200 ) );
  63         if ( '' == $this->message ) {
  64             return false;
  65         }
  66
  67         // Check that the root tag is valid
  68         $root_tag = substr( $this->message, 0, strcspn( substr( $this->message, 0, 20 ), "> \t\r\n" ) );
  69         if ( '<!DOCTYPE' === strtoupper( $root_tag ) ) {
  70             return false;
  71         }
  72         if ( ! in_array( $root_tag, array( '<methodCall', '<methodResponse', '<fault' ) ) ) {
  73             return false;
  74         }
  75
  76         // Bail if there are too many elements to parse
  77         $element_limit = 30000;
  78         if ( function_exists( 'apply_filters' ) ) {
  79             /**
  80              * Filters the number of elements to parse in an XML-RPC response.
  81              *
  82              * @since 4.0.0
  83              *
  84              * @param int $element_limit Default elements limit.
  85              */
  86             $element_limit = apply_filters( 'xmlrpc_element_limit', $element_limit );
  87         }
  88         if ( $element_limit && 2 * $element_limit < substr_count( $this->message, '<' ) ) {
  89             return false;
  90         }
  91
  92         $this->_parser = xml_parser_create();
  93         // Set XML parser to take the case of tags in to account
  94         xml_parser_set_option($this->_parser, XML_OPTION_CASE_FOLDING, false);
  95         // Set XML parser callback functions
  96         xml_set_object($this->_parser, $this);
  97         xml_set_element_handler($this->_parser, 'tag_open', 'tag_close');
  98         xml_set_character_data_handler($this->_parser, 'cdata');
  99
 100         // 256Kb, parse in chunks to avoid the RAM usage on very large messages
 101         $chunk_size = 262144;
 102
 103         /**
 104          * Filters the chunk size that can be used to parse an XML-RPC reponse message.
 105          *
 106          * @since 4.4.0
 107          *
 108          * @param int $chunk_size Chunk size to parse in bytes.
 109          */
 110         $chunk_size = apply_filters( 'xmlrpc_chunk_parsing_size', $chunk_size );
 111
 112         $final = false;
 113         do {
 114             if (strlen($this->message) <= $chunk_size) {
 115                 $final = true;
 116             }
 117             $part = substr($this->message, 0, $chunk_size);
 118             $this->message = substr($this->message, $chunk_size);
 119             if (!xml_parse($this->_parser, $part, $final)) {
 120                 return false;
 121             }
 122             if ($final) {
 123                 break;
 124             }
 125         } while (true);
 126         xml_parser_free($this->_parser);
 127
 128         // Grab the error messages, if any
 129         if ($this->messageType == 'fault') {
 130             $this->faultCode = $this->params[0]['faultCode'];
 131             $this->faultString = $this->params[0]['faultString'];
 132         }
 133         return true;
 134     }
 135
 136     function tag_open($parser, $tag, $attr)
 137     {
 138         $this->_currentTagContents = '';
 139         $this->currentTag = $tag;
 140         switch($tag) {
 141             case 'methodCall':
 142             case 'methodResponse':
 143             case 'fault':
 144                 $this->messageType = $tag;
 145                 break;
 146                 /* Deal with stacks of arrays and structs */
 147             case 'data':    // data is to all intents and puposes more interesting than array
 148                 $this->_arraystructstypes[] = 'array';
 149                 $this->_arraystructs[] = array();
 150                 break;
 151             case 'struct':
 152                 $this->_arraystructstypes[] = 'struct';
 153                 $this->_arraystructs[] = array();
 154                 break;
 155         }
 156     }
 157
 158     function cdata($parser, $cdata)
 159     {
 160         $this->_currentTagContents .= $cdata;
 161     }
 162
 163     function tag_close($parser, $tag)
 164     {
 165         $valueFlag = false;
 166         switch($tag) {
 167             case 'int':
 168             case 'i4':
 169                 $value = (int)trim($this->_currentTagContents);
 170                 $valueFlag = true;
 171                 break;
 172             case 'double':
 173                 $value = (double)trim($this->_currentTagContents);
 174                 $valueFlag = true;
 175                 break;
 176             case 'string':
 177                 $value = (string)trim($this->_currentTagContents);
 178                 $valueFlag = true;
 179                 break;
 180             case 'dateTime.iso8601':
 181                 $value = new IXR_Date(trim($this->_currentTagContents));
 182                 $valueFlag = true;
 183                 break;
 184             case 'value':
 185                 // "If no type is indicated, the type is string."
 186                 if (trim($this->_currentTagContents) != '') {
 187                     $value = (string)$this->_currentTagContents;
 188                     $valueFlag = true;
 189                 }
 190                 break;
 191             case 'boolean':
 192                 $value = (boolean)trim($this->_currentTagContents);
 193                 $valueFlag = true;
 194                 break;
 195             case 'base64':
 196                 $value = base64_decode($this->_currentTagContents);
 197                 $valueFlag = true;
 198                 break;
 199                 /* Deal with stacks of arrays and structs */
 200             case 'data':
 201             case 'struct':
 202                 $value = array_pop($this->_arraystructs);
 203                 array_pop($this->_arraystructstypes);
 204                 $valueFlag = true;
 205                 break;
 206             case 'member':
 207                 array_pop($this->_currentStructName);
 208                 break;
 209             case 'name':
 210                 $this->_currentStructName[] = trim($this->_currentTagContents);
 211                 break;
 212             case 'methodName':
 213                 $this->methodName = trim($this->_currentTagContents);
 214                 break;
 215         }
 216
 217         if ($valueFlag) {
 218             if (count($this->_arraystructs) > 0) {
 219                 // Add value to struct or array
 220                 if ($this->_arraystructstypes[count($this->_arraystructstypes)-1] == 'struct') {
 221                     // Add to struct
 222                     $this->_arraystructs[count($this->_arraystructs)-1][$this->_currentStructName[count($this->_currentStructName)-1]] = $value;
 223                 } else {
 224                     // Add to array
 225                     $this->_arraystructs[count($this->_arraystructs)-1][] = $value;
 226                 }
 227             } else {
 228                 // Just add as a parameter
 229                 $this->params[] = $value;
 230             }
 231         }
 232         $this->_currentTagContents = '';
 233     }
 234 }