1 <?php

     2 /**

     3  * IXR - The Incutio XML-RPC Library

     4  *

     5  * Copyright (c) 2010, Incutio Ltd.

     6  * All rights reserved.

     7  *

     8  * Redistribution and use in source and binary forms, with or without

     9  * modification, are permitted provided that the following conditions are met:

    10  *

    11  *  - Redistributions of source code must retain the above copyright notice,

    12  *    this list of conditions and the following disclaimer.

    13  *  - Redistributions in binary form must reproduce the above copyright

    14  *    notice, this list of conditions and the following disclaimer in the

    15  *    documentation and/or other materials provided with the distribution.

    16  *  - Neither the name of Incutio Ltd. nor the names of its contributors

    17  *    may be used to endorse or promote products derived from this software

    18  *    without specific prior written permission.

    19  *

    20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS

    21  * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,

    22  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

    23  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR

    24  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

    25  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

    26  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

    27  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

    28  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

    29  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE

    30  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

    31  *

    32  * @package IXR

    33  * @since 1.5

    34  *

    35  * @copyright  Incutio Ltd 2010 (http://www.incutio.com)

    36  * @version    1.7.4 7th September 2010

    37  * @author     Simon Willison

    38  * @link       http://scripts.incutio.com/xmlrpc/ Site/manual

    39  * @license    http://www.opensource.org/licenses/bsd-license.php BSD

    40  */

    41 

    42 /**

    43  * IXR_Value

    44  *

    45  * @package IXR

    46  * @since 1.5

    47  */

    48 class IXR_Value {

    49     var $data;

    50     var $type;

    51 

    52     function IXR_Value($data, $type = false)

    53     {

    54         $this->data = $data;

    55         if (!$type) {

    56             $type = $this->calculateType();

    57         }

    58         $this->type = $type;

    59         if ($type == 'struct') {

    60             // Turn all the values in the array in to new IXR_Value objects

    61             foreach ($this->data as $key => $value) {

    62                 $this->data[$key] = new IXR_Value($value);

    63             }

    64         }

    65         if ($type == 'array') {

    66             for ($i = 0, $j = count($this->data); $i < $j; $i++) {

    67                 $this->data[$i] = new IXR_Value($this->data[$i]);

    68             }

    69         }

    70     }

    71 

    72     function calculateType()

    73     {

    74         if ($this->data === true || $this->data === false) {

    75             return 'boolean';

    76         }

    77         if (is_integer($this->data)) {

    78             return 'int';

    79         }

    80         if (is_double($this->data)) {

    81             return 'double';

    82         }

    83 

    84         // Deal with IXR object types base64 and date

    85         if (is_object($this->data) && is_a($this->data, 'IXR_Date')) {

    86             return 'date';

    87         }

    88         if (is_object($this->data) && is_a($this->data, 'IXR_Base64')) {

    89             return 'base64';

    90         }

    91 

    92         // If it is a normal PHP object convert it in to a struct

    93         if (is_object($this->data)) {

    94             $this->data = get_object_vars($this->data);

    95             return 'struct';

    96         }

    97         if (!is_array($this->data)) {

    98             return 'string';

    99         }

   100 

   101         // We have an array - is it an array or a struct?

   102         if ($this->isStruct($this->data)) {

   103             return 'struct';

   104         } else {

   105             return 'array';

   106         }

   107     }

   108 

   109     function getXml()

   110     {

   111         // Return XML for this value

   112         switch ($this->type) {

   113             case 'boolean':

   114                 return '<boolean>'.(($this->data) ? '1' : '0').'</boolean>';

   115                 break;

   116             case 'int':

   117                 return '<int>'.$this->data.'</int>';

   118                 break;

   119             case 'double':

   120                 return '<double>'.$this->data.'</double>';

   121                 break;

   122             case 'string':

   123                 return '<string>'.htmlspecialchars($this->data).'</string>';

   124                 break;

   125             case 'array':

   126                 $return = '<array><data>'."\n";

   127                 foreach ($this->data as $item) {

   128                     $return .= '  <value>'.$item->getXml()."</value>\n";

   129                 }

   130                 $return .= '</data></array>';

   131                 return $return;

   132                 break;

   133             case 'struct':

   134                 $return = '<struct>'."\n";

   135                 foreach ($this->data as $name => $value) {

   136 					$name = htmlspecialchars($name);

   137                     $return .= "  <member><name>$name</name><value>";

   138                     $return .= $value->getXml()."</value></member>\n";

   139                 }

   140                 $return .= '</struct>';

   141                 return $return;

   142                 break;

   143             case 'date':

   144             case 'base64':

   145                 return $this->data->getXml();

   146                 break;

   147         }

   148         return false;

   149     }

   150 

   151     /**

   152      * Checks whether or not the supplied array is a struct or not

   153      *

   154      * @param unknown_type $array

   155      * @return boolean

   156      */

   157     function isStruct($array)

   158     {

   159         $expected = 0;

   160         foreach ($array as $key => $value) {

   161             if ((string)$key != (string)$expected) {

   162                 return true;

   163             }

   164             $expected++;

   165         }

   166         return false;

   167     }

   168 }

   169 

   170 /**

   171  * IXR_MESSAGE

   172  *

   173  * @package IXR

   174  * @since 1.5

   175  *

   176  */

   177 class IXR_Message

   178 {

   179     var $message;

   180     var $messageType;  // methodCall / methodResponse / fault

   181     var $faultCode;

   182     var $faultString;

   183     var $methodName;

   184     var $params;

   185 

   186     // Current variable stacks

   187     var $_arraystructs = array();   // The stack used to keep track of the current array/struct

   188     var $_arraystructstypes = array(); // Stack keeping track of if things are structs or array

   189     var $_currentStructName = array();  // A stack as well

   190     var $_param;

   191     var $_value;

   192     var $_currentTag;

   193     var $_currentTagContents;

   194     // The XML parser

   195     var $_parser;

   196 

   197     function IXR_Message($message)

   198     {

   199         $this->message =& $message;

   200     }

   201 

   202     function parse()

   203     {

   204         // first remove the XML declaration

   205         // merged from WP #10698 - this method avoids the RAM usage of preg_replace on very large messages

   206         $header = preg_replace( '/<\?xml.*?\?'.'>/', '', substr($this->message, 0, 100), 1);

   207         $this->message = substr_replace($this->message, $header, 0, 100);

   208         if (trim($this->message) == '') {

   209             return false;

   210         }

   211         $this->_parser = xml_parser_create();

   212         // Set XML parser to take the case of tags in to account

   213         xml_parser_set_option($this->_parser, XML_OPTION_CASE_FOLDING, false);

   214         // Set XML parser callback functions

   215         xml_set_object($this->_parser, $this);

   216         xml_set_element_handler($this->_parser, 'tag_open', 'tag_close');

   217         xml_set_character_data_handler($this->_parser, 'cdata');

   218         $chunk_size = 262144; // 256Kb, parse in chunks to avoid the RAM usage on very large messages

   219         $final = false;

   220         do {

   221             if (strlen($this->message) <= $chunk_size) {

   222                 $final = true;

   223             }

   224             $part = substr($this->message, 0, $chunk_size);

   225             $this->message = substr($this->message, $chunk_size);

   226             if (!xml_parse($this->_parser, $part, $final)) {

   227                 return false;

   228             }

   229             if ($final) {

   230                 break;

   231             }

   232         } while (true);

   233         xml_parser_free($this->_parser);

   234 

   235         // Grab the error messages, if any

   236         if ($this->messageType == 'fault') {

   237             $this->faultCode = $this->params[0]['faultCode'];

   238             $this->faultString = $this->params[0]['faultString'];

   239         }

   240         return true;

   241     }

   242 

   243     function tag_open($parser, $tag, $attr)

   244     {

   245         $this->_currentTagContents = '';

   246         $this->currentTag = $tag;

   247         switch($tag) {

   248             case 'methodCall':

   249             case 'methodResponse':

   250             case 'fault':

   251                 $this->messageType = $tag;

   252                 break;

   253                 /* Deal with stacks of arrays and structs */

   254             case 'data':    // data is to all intents and puposes more interesting than array

   255                 $this->_arraystructstypes[] = 'array';

   256                 $this->_arraystructs[] = array();

   257                 break;

   258             case 'struct':

   259                 $this->_arraystructstypes[] = 'struct';

   260                 $this->_arraystructs[] = array();

   261                 break;

   262         }

   263     }

   264 

   265     function cdata($parser, $cdata)

   266     {

   267         $this->_currentTagContents .= $cdata;

   268     }

   269 

   270     function tag_close($parser, $tag)

   271     {

   272         $valueFlag = false;

   273         switch($tag) {

   274             case 'int':

   275             case 'i4':

   276                 $value = (int)trim($this->_currentTagContents);

   277                 $valueFlag = true;

   278                 break;

   279             case 'double':

   280                 $value = (double)trim($this->_currentTagContents);

   281                 $valueFlag = true;

   282                 break;

   283             case 'string':

   284                 $value = (string)trim($this->_currentTagContents);

   285                 $valueFlag = true;

   286                 break;

   287             case 'dateTime.iso8601':

   288                 $value = new IXR_Date(trim($this->_currentTagContents));

   289                 $valueFlag = true;

   290                 break;

   291             case 'value':

   292                 // "If no type is indicated, the type is string."

   293                 if (trim($this->_currentTagContents) != '') {

   294                     $value = (string)$this->_currentTagContents;

   295                     $valueFlag = true;

   296                 }

   297                 break;

   298             case 'boolean':

   299                 $value = (boolean)trim($this->_currentTagContents);

   300                 $valueFlag = true;

   301                 break;

   302             case 'base64':

   303                 $value = base64_decode($this->_currentTagContents);

   304                 $valueFlag = true;

   305                 break;

   306                 /* Deal with stacks of arrays and structs */

   307             case 'data':

   308             case 'struct':

   309                 $value = array_pop($this->_arraystructs);

   310                 array_pop($this->_arraystructstypes);

   311                 $valueFlag = true;

   312                 break;

   313             case 'member':

   314                 array_pop($this->_currentStructName);

   315                 break;

   316             case 'name':

   317                 $this->_currentStructName[] = trim($this->_currentTagContents);

   318                 break;

   319             case 'methodName':

   320                 $this->methodName = trim($this->_currentTagContents);

   321                 break;

   322         }

   323 

   324         if ($valueFlag) {

   325             if (count($this->_arraystructs) > 0) {

   326                 // Add value to struct or array

   327                 if ($this->_arraystructstypes[count($this->_arraystructstypes)-1] == 'struct') {

   328                     // Add to struct

   329                     $this->_arraystructs[count($this->_arraystructs)-1][$this->_currentStructName[count($this->_currentStructName)-1]] = $value;

   330                 } else {

   331                     // Add to array

   332                     $this->_arraystructs[count($this->_arraystructs)-1][] = $value;

   333                 }

   334             } else {

   335                 // Just add as a paramater

   336                 $this->params[] = $value;

   337             }

   338         }

   339         $this->_currentTagContents = '';

   340     }

   341 }

   342 

   343 /**

   344  * IXR_Server

   345  *

   346  * @package IXR

   347  * @since 1.5

   348  */

   349 class IXR_Server

   350 {

   351     var $data;

   352     var $callbacks = array();

   353     var $message;

   354     var $capabilities;

   355 

   356     function IXR_Server($callbacks = false, $data = false, $wait = false)

   357     {

   358         $this->setCapabilities();

   359         if ($callbacks) {

   360             $this->callbacks = $callbacks;

   361         }

   362         $this->setCallbacks();

   363         if (!$wait) {

   364             $this->serve($data);

   365         }

   366     }

   367 

   368     function serve($data = false)

   369     {

   370         if (!$data) {

   371             if (isset($_SERVER['REQUEST_METHOD']) && $_SERVER['REQUEST_METHOD'] !== 'POST') {

   372             	header('Content-Type: text/plain'); // merged from WP #9093

   373                 die('XML-RPC server accepts POST requests only.');

   374             }

   375 

   376             global $HTTP_RAW_POST_DATA;

   377             if (empty($HTTP_RAW_POST_DATA)) {

   378                 // workaround for a bug in PHP 5.2.2 - http://bugs.php.net/bug.php?id=41293

   379                 $data = file_get_contents('php://input');

   380             } else {

   381                 $data =& $HTTP_RAW_POST_DATA;

   382             }

   383         }

   384         $this->message = new IXR_Message($data);

   385         if (!$this->message->parse()) {

   386             $this->error(-32700, 'parse error. not well formed');

   387         }

   388         if ($this->message->messageType != 'methodCall') {

   389             $this->error(-32600, 'server error. invalid xml-rpc. not conforming to spec. Request must be a methodCall');

   390         }

   391         $result = $this->call($this->message->methodName, $this->message->params);

   392 

   393         // Is the result an error?

   394         if (is_a($result, 'IXR_Error')) {

   395             $this->error($result);

   396         }

   397 

   398         // Encode the result

   399         $r = new IXR_Value($result);

   400         $resultxml = $r->getXml();

   401 

   402         // Create the XML

   403         $xml = <<<EOD

   404 <methodResponse>

   405   <params>

   406     <param>

   407       <value>

   408       $resultxml

   409       </value>

   410     </param>

   411   </params>

   412 </methodResponse>

   413 

   414 EOD;

   415       // Send it

   416       $this->output($xml);

   417     }

   418 

   419     function call($methodname, $args)

   420     {

   421         if (!$this->hasMethod($methodname)) {

   422             return new IXR_Error(-32601, 'server error. requested method '.$methodname.' does not exist.');

   423         }

   424         $method = $this->callbacks[$methodname];

   425 

   426         // Perform the callback and send the response

   427         if (count($args) == 1) {

   428             // If only one paramater just send that instead of the whole array

   429             $args = $args[0];

   430         }

   431 

   432         // Are we dealing with a function or a method?

   433         if (is_string($method) && substr($method, 0, 5) == 'this:') {

   434             // It's a class method - check it exists

   435             $method = substr($method, 5);

   436             if (!method_exists($this, $method)) {

   437                 return new IXR_Error(-32601, 'server error. requested class method "'.$method.'" does not exist.');

   438             }

   439 

   440             //Call the method

   441             $result = $this->$method($args);

   442         } else {

   443             // It's a function - does it exist?

   444             if (is_array($method)) {

   445                 if (!is_callable(array($method[0], $method[1]))) {

   446                     return new IXR_Error(-32601, 'server error. requested object method "'.$method[1].'" does not exist.');

   447                 }

   448             } else if (!function_exists($method)) {

   449                 return new IXR_Error(-32601, 'server error. requested function "'.$method.'" does not exist.');

   450             }

   451 

   452             // Call the function

   453             $result = call_user_func($method, $args);

   454         }

   455         return $result;

   456     }

   457 

   458     function error($error, $message = false)

   459     {

   460         // Accepts either an error object or an error code and message

   461         if ($message && !is_object($error)) {

   462             $error = new IXR_Error($error, $message);

   463         }

   464         $this->output($error->getXml());

   465     }

   466 

   467     function output($xml)

   468     {

   469         $charset = function_exists('get_option') ? get_option('blog_charset') : '';

   470         if ($charset)

   471             $xml = '<?xml version="1.0" encoding="'.$charset.'"?>'."\n".$xml;

   472         else

   473             $xml = '<?xml version="1.0"?>'."\n".$xml;

   474         $length = strlen($xml);

   475         header('Connection: close');

   476         header('Content-Length: '.$length);

   477         if ($charset)

   478             header('Content-Type: text/xml; charset='.$charset);

   479         else

   480             header('Content-Type: text/xml');

   481         header('Date: '.date('r'));

   482         echo $xml;

   483         exit;

   484     }

   485 

   486     function hasMethod($method)

   487     {

   488         return in_array($method, array_keys($this->callbacks));

   489     }

   490 

   491     function setCapabilities()

   492     {

   493         // Initialises capabilities array

   494         $this->capabilities = array(

   495             'xmlrpc' => array(

   496                 'specUrl' => 'http://www.xmlrpc.com/spec',

   497                 'specVersion' => 1

   498         ),

   499             'faults_interop' => array(

   500                 'specUrl' => 'http://xmlrpc-epi.sourceforge.net/specs/rfc.fault_codes.php',

   501                 'specVersion' => 20010516

   502         ),

   503             'system.multicall' => array(

   504                 'specUrl' => 'http://www.xmlrpc.com/discuss/msgReader$1208',

   505                 'specVersion' => 1

   506         ),

   507         );

   508     }

   509 

   510     function getCapabilities($args)

   511     {

   512         return $this->capabilities;

   513     }

   514 

   515     function setCallbacks()

   516     {

   517         $this->callbacks['system.getCapabilities'] = 'this:getCapabilities';

   518         $this->callbacks['system.listMethods'] = 'this:listMethods';

   519         $this->callbacks['system.multicall'] = 'this:multiCall';

   520     }

   521 

   522     function listMethods($args)

   523     {

   524         // Returns a list of methods - uses array_reverse to ensure user defined

   525         // methods are listed before server defined methods

   526         return array_reverse(array_keys($this->callbacks));

   527     }

   528 

   529     function multiCall($methodcalls)

   530     {

   531         // See http://www.xmlrpc.com/discuss/msgReader$1208

   532         $return = array();

   533         foreach ($methodcalls as $call) {

   534             $method = $call['methodName'];

   535             $params = $call['params'];

   536             if ($method == 'system.multicall') {

   537                 $result = new IXR_Error(-32600, 'Recursive calls to system.multicall are forbidden');

   538             } else {

   539                 $result = $this->call($method, $params);

   540             }

   541             if (is_a($result, 'IXR_Error')) {

   542                 $return[] = array(

   543                     'faultCode' => $result->code,

   544                     'faultString' => $result->message

   545                 );

   546             } else {

   547                 $return[] = array($result);

   548             }

   549         }

   550         return $return;

   551     }

   552 }

   553 

   554 /**

   555  * IXR_Request

   556  *

   557  * @package IXR

   558  * @since 1.5

   559  */

   560 class IXR_Request

   561 {

   562     var $method;

   563     var $args;

   564     var $xml;

   565 

   566     function IXR_Request($method, $args)

   567     {

   568         $this->method = $method;

   569         $this->args = $args;

   570         $this->xml = <<<EOD

   571 <?xml version="1.0"?>

   572 <methodCall>

   573 <methodName>{$this->method}</methodName>

   574 <params>

   575 

   576 EOD;

   577         foreach ($this->args as $arg) {

   578             $this->xml .= '<param><value>';

   579             $v = new IXR_Value($arg);

   580             $this->xml .= $v->getXml();

   581             $this->xml .= "</value></param>\n";

   582         }

   583         $this->xml .= '</params></methodCall>';

   584     }

   585 

   586     function getLength()

   587     {

   588         return strlen($this->xml);

   589     }

   590 

   591     function getXml()

   592     {

   593         return $this->xml;

   594     }

   595 }

   596 

   597 /**

   598  * IXR_Client

   599  *

   600  * @package IXR

   601  * @since 1.5

   602  *

   603  */

   604 class IXR_Client

   605 {

   606     var $server;

   607     var $port;

   608     var $path;

   609     var $useragent;

   610     var $response;

   611     var $message = false;

   612     var $debug = false;

   613     var $timeout;

   614     var $headers = array();

   615 

   616     // Storage place for an error message

   617     var $error = false;

   618 

   619     function IXR_Client($server, $path = false, $port = 80, $timeout = 15)

   620     {

   621         if (!$path) {

   622             // Assume we have been given a URL instead

   623             $bits = parse_url($server);

   624             $this->server = $bits['host'];

   625             $this->port = isset($bits['port']) ? $bits['port'] : 80;

   626             $this->path = isset($bits['path']) ? $bits['path'] : '/';

   627 

   628             // Make absolutely sure we have a path

   629             if (!$this->path) {

   630                 $this->path = '/';

   631             }

   632         } else {

   633             $this->server = $server;

   634             $this->path = $path;

   635             $this->port = $port;

   636         }

   637         $this->useragent = 'The Incutio XML-RPC PHP Library';

   638         $this->timeout = $timeout;

   639     }

   640 

   641     function query()

   642     {

   643         $args = func_get_args();

   644         $method = array_shift($args);

   645         $request = new IXR_Request($method, $args);

   646         $length = $request->getLength();

   647         $xml = $request->getXml();

   648         $r = "\r\n";

   649         $request  = "POST {$this->path} HTTP/1.0$r";

   650 

   651         // Merged from WP #8145 - allow custom headers

   652         $this->headers['Host']          = $this->server;

   653         $this->headers['Content-Type']  = 'text/xml';

   654         $this->headers['User-Agent']    = $this->useragent;

   655         $this->headers['Content-Length']= $length;

   656 

   657         foreach( $this->headers as $header => $value ) {

   658             $request .= "{$header}: {$value}{$r}";

   659         }

   660         $request .= $r;

   661 

   662         $request .= $xml;

   663 

   664         // Now send the request

   665         if ($this->debug) {

   666             echo '<pre class="ixr_request">'.htmlspecialchars($request)."\n</pre>\n\n";

   667         }

   668 

   669         if ($this->timeout) {

   670             $fp = @fsockopen($this->server, $this->port, $errno, $errstr, $this->timeout);

   671         } else {

   672             $fp = @fsockopen($this->server, $this->port, $errno, $errstr);

   673         }

   674         if (!$fp) {

   675             $this->error = new IXR_Error(-32300, 'transport error - could not open socket');

   676             return false;

   677         }

   678         fputs($fp, $request);

   679         $contents = '';

   680         $debugContents = '';

   681         $gotFirstLine = false;

   682         $gettingHeaders = true;

   683         while (!feof($fp)) {

   684             $line = fgets($fp, 4096);

   685             if (!$gotFirstLine) {

   686                 // Check line for '200'

   687                 if (strstr($line, '200') === false) {

   688                     $this->error = new IXR_Error(-32300, 'transport error - HTTP status code was not 200');

   689                     return false;

   690                 }

   691                 $gotFirstLine = true;

   692             }

   693             if (trim($line) == '') {

   694                 $gettingHeaders = false;

   695             }

   696             if (!$gettingHeaders) {

   697             	// merged from WP #12559 - remove trim

   698                 $contents .= $line;

   699             }

   700             if ($this->debug) {

   701             	$debugContents .= $line;

   702             }

   703         }

   704         if ($this->debug) {

   705             echo '<pre class="ixr_response">'.htmlspecialchars($debugContents)."\n</pre>\n\n";

   706         }

   707 

   708         // Now parse what we've got back

   709         $this->message = new IXR_Message($contents);

   710         if (!$this->message->parse()) {

   711             // XML error

   712             $this->error = new IXR_Error(-32700, 'parse error. not well formed');

   713             return false;

   714         }

   715 

   716         // Is the message a fault?

   717         if ($this->message->messageType == 'fault') {

   718             $this->error = new IXR_Error($this->message->faultCode, $this->message->faultString);

   719             return false;

   720         }

   721 

   722         // Message must be OK

   723         return true;

   724     }

   725 

   726     function getResponse()

   727     {

   728         // methodResponses can only have one param - return that

   729         return $this->message->params[0];

   730     }

   731 

   732     function isError()

   733     {

   734         return (is_object($this->error));

   735     }

   736 

   737     function getErrorCode()

   738     {

   739         return $this->error->code;

   740     }

   741 

   742     function getErrorMessage()

   743     {

   744         return $this->error->message;

   745     }

   746 }

   747 

   748 

   749 /**

   750  * IXR_Error

   751  *

   752  * @package IXR

   753  * @since 1.5

   754  */

   755 class IXR_Error

   756 {

   757     var $code;

   758     var $message;

   759 

   760     function IXR_Error($code, $message)

   761     {

   762         $this->code = $code;

   763         $this->message = htmlspecialchars($message);

   764     }

   765 

   766     function getXml()

   767     {

   768         $xml = <<<EOD

   769 <methodResponse>

   770   <fault>

   771     <value>

   772       <struct>

   773         <member>

   774           <name>faultCode</name>

   775           <value><int>{$this->code}</int></value>

   776         </member>

   777         <member>

   778           <name>faultString</name>

   779           <value><string>{$this->message}</string></value>

   780         </member>

   781       </struct>

   782     </value>

   783   </fault>

   784 </methodResponse>

   785 

   786 EOD;

   787         return $xml;

   788     }

   789 }

   790 

   791 /**

   792  * IXR_Date

   793  *

   794  * @package IXR

   795  * @since 1.5

   796  */

   797 class IXR_Date {

   798     var $year;

   799     var $month;

   800     var $day;

   801     var $hour;

   802     var $minute;

   803     var $second;

   804     var $timezone;

   805 

   806     function IXR_Date($time)

   807     {

   808         // $time can be a PHP timestamp or an ISO one

   809         if (is_numeric($time)) {

   810             $this->parseTimestamp($time);

   811         } else {

   812             $this->parseIso($time);

   813         }

   814     }

   815 

   816     function parseTimestamp($timestamp)

   817     {

   818         $this->year = date('Y', $timestamp);

   819         $this->month = date('m', $timestamp);

   820         $this->day = date('d', $timestamp);

   821         $this->hour = date('H', $timestamp);

   822         $this->minute = date('i', $timestamp);

   823         $this->second = date('s', $timestamp);

   824         $this->timezone = '';

   825     }

   826 

   827     function parseIso($iso)

   828     {

   829         $this->year = substr($iso, 0, 4);

   830         $this->month = substr($iso, 4, 2);

   831         $this->day = substr($iso, 6, 2);

   832         $this->hour = substr($iso, 9, 2);

   833         $this->minute = substr($iso, 12, 2);

   834         $this->second = substr($iso, 15, 2);

   835         $this->timezone = substr($iso, 17);

   836     }

   837 

   838     function getIso()

   839     {

   840         return $this->year.$this->month.$this->day.'T'.$this->hour.':'.$this->minute.':'.$this->second.$this->timezone;

   841     }

   842 

   843     function getXml()

   844     {

   845         return '<dateTime.iso8601>'.$this->getIso().'</dateTime.iso8601>';

   846     }

   847 

   848     function getTimestamp()

   849     {

   850         return mktime($this->hour, $this->minute, $this->second, $this->month, $this->day, $this->year);

   851     }

   852 }

   853 

   854 /**

   855  * IXR_Base64

   856  *

   857  * @package IXR

   858  * @since 1.5

   859  */

   860 class IXR_Base64

   861 {

   862     var $data;

   863 

   864     function IXR_Base64($data)

   865     {

   866         $this->data = $data;

   867     }

   868 

   869     function getXml()

   870     {

   871         return '<base64>'.base64_encode($this->data).'</base64>';

   872     }

   873 }

   874 

   875 /**

   876  * IXR_IntrospectionServer

   877  *

   878  * @package IXR

   879  * @since 1.5

   880  */

   881 class IXR_IntrospectionServer extends IXR_Server

   882 {

   883     var $signatures;

   884     var $help;

   885 

   886     function IXR_IntrospectionServer()

   887     {

   888         $this->setCallbacks();

   889         $this->setCapabilities();

   890         $this->capabilities['introspection'] = array(

   891             'specUrl' => 'http://xmlrpc.usefulinc.com/doc/reserved.html',

   892             'specVersion' => 1

   893         );

   894         $this->addCallback(

   895             'system.methodSignature',

   896             'this:methodSignature',

   897             array('array', 'string'),

   898             'Returns an array describing the return type and required parameters of a method'

   899         );

   900         $this->addCallback(

   901             'system.getCapabilities',

   902             'this:getCapabilities',

   903             array('struct'),

   904             'Returns a struct describing the XML-RPC specifications supported by this server'

   905         );

   906         $this->addCallback(

   907             'system.listMethods',

   908             'this:listMethods',

   909             array('array'),

   910             'Returns an array of available methods on this server'

   911         );

   912         $this->addCallback(

   913             'system.methodHelp',

   914             'this:methodHelp',

   915             array('string', 'string'),

   916             'Returns a documentation string for the specified method'

   917         );

   918     }

   919 

   920     function addCallback($method, $callback, $args, $help)

   921     {

   922         $this->callbacks[$method] = $callback;

   923         $this->signatures[$method] = $args;

   924         $this->help[$method] = $help;

   925     }

   926 

   927     function call($methodname, $args)

   928     {

   929         // Make sure it's in an array

   930         if ($args && !is_array($args)) {

   931             $args = array($args);

   932         }

   933 

   934         // Over-rides default call method, adds signature check

   935         if (!$this->hasMethod($methodname)) {

   936             return new IXR_Error(-32601, 'server error. requested method "'.$this->message->methodName.'" not specified.');

   937         }

   938         $method = $this->callbacks[$methodname];

   939         $signature = $this->signatures[$methodname];

   940         $returnType = array_shift($signature);

   941 

   942         // Check the number of arguments

   943         if (count($args) != count($signature)) {

   944             return new IXR_Error(-32602, 'server error. wrong number of method parameters');

   945         }

   946 

   947         // Check the argument types

   948         $ok = true;

   949         $argsbackup = $args;

   950         for ($i = 0, $j = count($args); $i < $j; $i++) {

   951             $arg = array_shift($args);

   952             $type = array_shift($signature);

   953             switch ($type) {

   954                 case 'int':

   955                 case 'i4':

   956                     if (is_array($arg) || !is_int($arg)) {

   957                         $ok = false;

   958                     }

   959                     break;

   960                 case 'base64':

   961                 case 'string':

   962                     if (!is_string($arg)) {

   963                         $ok = false;

   964                     }

   965                     break;

   966                 case 'boolean':

   967                     if ($arg !== false && $arg !== true) {

   968                         $ok = false;

   969                     }

   970                     break;

   971                 case 'float':

   972                 case 'double':

   973                     if (!is_float($arg)) {

   974                         $ok = false;

   975                     }

   976                     break;

   977                 case 'date':

   978                 case 'dateTime.iso8601':

   979                     if (!is_a($arg, 'IXR_Date')) {

   980                         $ok = false;

   981                     }

   982                     break;

   983             }

   984             if (!$ok) {

   985                 return new IXR_Error(-32602, 'server error. invalid method parameters');

   986             }

   987         }

   988         // It passed the test - run the "real" method call

   989         return parent::call($methodname, $argsbackup);

   990     }

   991 

   992     function methodSignature($method)

   993     {

   994         if (!$this->hasMethod($method)) {

   995             return new IXR_Error(-32601, 'server error. requested method "'.$method.'" not specified.');

   996         }

   997         // We should be returning an array of types

   998         $types = $this->signatures[$method];

   999         $return = array();

  1000         foreach ($types as $type) {

  1001             switch ($type) {

  1002                 case 'string':

  1003                     $return[] = 'string';

  1004                     break;

  1005                 case 'int':

  1006                 case 'i4':

  1007                     $return[] = 42;

  1008                     break;

  1009                 case 'double':

  1010                     $return[] = 3.1415;

  1011                     break;

  1012                 case 'dateTime.iso8601':

  1013                     $return[] = new IXR_Date(time());

  1014                     break;

  1015                 case 'boolean':

  1016                     $return[] = true;

  1017                     break;

  1018                 case 'base64':

  1019                     $return[] = new IXR_Base64('base64');

  1020                     break;

  1021                 case 'array':

  1022                     $return[] = array('array');

  1023                     break;

  1024                 case 'struct':

  1025                     $return[] = array('struct' => 'struct');

  1026                     break;

  1027             }

  1028         }

  1029         return $return;

  1030     }

  1031 

  1032     function methodHelp($method)

  1033     {

  1034         return $this->help[$method];

  1035     }

  1036 }

  1037 

  1038 /**

  1039  * IXR_ClientMulticall

  1040  *

  1041  * @package IXR

  1042  * @since 1.5

  1043  */

  1044 class IXR_ClientMulticall extends IXR_Client

  1045 {

  1046     var $calls = array();

  1047 

  1048     function IXR_ClientMulticall($server, $path = false, $port = 80)

  1049     {

  1050         parent::IXR_Client($server, $path, $port);

  1051         $this->useragent = 'The Incutio XML-RPC PHP Library (multicall client)';

  1052     }

  1053 

  1054     function addCall()

  1055     {

  1056         $args = func_get_args();

  1057         $methodName = array_shift($args);

  1058         $struct = array(

  1059             'methodName' => $methodName,

  1060             'params' => $args

  1061         );

  1062         $this->calls[] = $struct;

  1063     }

  1064 

  1065     function query()

  1066     {

  1067         // Prepare multicall, then call the parent::query() method

  1068         return parent::query('system.multicall', $this->calls);

  1069     }

  1070 }