wp-includes/class-IXR.php

   1 <?php
   2 /**
   3  * IXR - The Inutio XML-RPC Library
   4  *
   5  * @package IXR
   6  * @since 1.5
   7  *
   8  * @copyright Incutio Ltd 2002-2005
   9  * @version 1.7 (beta) 23rd May 2005
  10  * @author Simon Willison
  11  * @link http://scripts.incutio.com/xmlrpc/ Site
  12  * @link http://scripts.incutio.com/xmlrpc/manual.php Manual
  13  * @license BSD License http://www.opensource.org/licenses/bsd-license.php
  14  */
  15
  16 /**
  17  * IXR_Value
  18  *
  19  * @package IXR
  20  * @since 1.5
  21  */
  22 class IXR_Value {
  23     var $data;
  24     var $type;
  25
  26     function IXR_Value ($data, $type = false) {
  27         $this->data = $data;
  28         if (!$type) {
  29             $type = $this->calculateType();
  30         }
  31         $this->type = $type;
  32         if ($type == 'struct') {
  33             /* Turn all the values in the array in to new IXR_Value objects */
  34             foreach ($this->data as $key => $value) {
  35                 $this->data[$key] = new IXR_Value($value);
  36             }
  37         }
  38         if ($type == 'array') {
  39             for ($i = 0, $j = count($this->data); $i < $j; $i++) {
  40                 $this->data[$i] = new IXR_Value($this->data[$i]);
  41             }
  42         }
  43     }
  44
  45     function calculateType() {
  46         if ($this->data === true || $this->data === false) {
  47             return 'boolean';
  48         }
  49         if (is_integer($this->data)) {
  50             return 'int';
  51         }
  52         if (is_double($this->data)) {
  53             return 'double';
  54         }
  55         // Deal with IXR object types base64 and date
  56         if (is_object($this->data) && is_a($this->data, 'IXR_Date')) {
  57             return 'date';
  58         }
  59         if (is_object($this->data) && is_a($this->data, 'IXR_Base64')) {
  60             return 'base64';
  61         }
  62         // If it is a normal PHP object convert it in to a struct
  63         if (is_object($this->data)) {
  64
  65             $this->data = get_object_vars($this->data);
  66             return 'struct';
  67         }
  68         if (!is_array($this->data)) {
  69             return 'string';
  70         }
  71         /* We have an array - is it an array or a struct ? */
  72         if ($this->isStruct($this->data)) {
  73             return 'struct';
  74         } else {
  75             return 'array';
  76         }
  77     }
  78
  79     function getXml() {
  80         /* Return XML for this value */
  81         switch ($this->type) {
  82             case 'boolean':
  83                 return '<boolean>'.(($this->data) ? '1' : '0').'</boolean>';
  84                 break;
  85             case 'int':
  86                 return '<int>'.$this->data.'</int>';
  87                 break;
  88             case 'double':
  89                 return '<double>'.$this->data.'</double>';
  90                 break;
  91             case 'string':
  92                 return '<string>'.htmlspecialchars($this->data).'</string>';
  93                 break;
  94             case 'array':
  95                 $return = '<array><data>'."\n";
  96                 foreach ($this->data as $item) {
  97                     $return .= '  <value>'.$item->getXml()."</value>\n";
  98                 }
  99                 $return .= '</data></array>';
 100                 return $return;
 101                 break;
 102             case 'struct':
 103                 $return = '<struct>'."\n";
 104                 foreach ($this->data as $name => $value) {
 105                                         $name = htmlspecialchars($name);
 106                     $return .= "  <member><name>$name</name><value>";
 107                     $return .= $value->getXml()."</value></member>\n";
 108                 }
 109                 $return .= '</struct>';
 110                 return $return;
 111                 break;
 112             case 'date':
 113             case 'base64':
 114                 return $this->data->getXml();
 115                 break;
 116         }
 117         return false;
 118     }
 119
 120     function isStruct($array) {
 121         /* Nasty function to check if an array is a struct or not */
 122         $expected = 0;
 123         foreach ($array as $key => $value) {
 124             if ((string)$key != (string)$expected) {
 125                 return true;
 126             }
 127             $expected++;
 128         }
 129         return false;
 130     }
 131 }
 132
 133 /**
 134  * IXR_Message
 135  *
 136  * @package IXR
 137  * @since 1.5
 138  */
 139 class IXR_Message {
 140     var $message;
 141     var $messageType;  // methodCall / methodResponse / fault
 142     var $faultCode;
 143     var $faultString;
 144     var $methodName;
 145     var $params;
 146     // Current variable stacks
 147     var $_arraystructs = array();   // The stack used to keep track of the current array/struct
 148     var $_arraystructstypes = array(); // Stack keeping track of if things are structs or array
 149     var $_currentStructName = array();  // A stack as well
 150     var $_param;
 151     var $_value;
 152     var $_currentTag;
 153     var $_currentTagContents;
 154     // The XML parser
 155     var $_parser;
 156     function IXR_Message ($message) {
 157         $this->message = $message;
 158     }
 159     function parse() {
 160         // first remove the XML declaration
 161         $this->message = preg_replace('/<\?xml(.*)?\?'.'>/', '', $this->message);
 162         if (trim($this->message) == '') {
 163             return false;
 164         }
 165         $this->_parser = xml_parser_create();
 166         // Set XML parser to take the case of tags in to account
 167         xml_parser_set_option($this->_parser, XML_OPTION_CASE_FOLDING, false);
 168         // Set XML parser callback functions
 169         xml_set_object($this->_parser, $this);
 170         xml_set_element_handler($this->_parser, 'tag_open', 'tag_close');
 171         xml_set_character_data_handler($this->_parser, 'cdata');
 172         if (!xml_parse($this->_parser, $this->message)) {
 173             /* die(sprintf('XML error: %s at line %d',
 174                 xml_error_string(xml_get_error_code($this->_parser)),
 175                 xml_get_current_line_number($this->_parser))); */
 176             return false;
 177         }
 178         xml_parser_free($this->_parser);
 179         // Grab the error messages, if any
 180         if ($this->messageType == 'fault') {
 181             $this->faultCode = $this->params[0]['faultCode'];
 182             $this->faultString = $this->params[0]['faultString'];
 183         }
 184         return true;
 185     }
 186     function tag_open($parser, $tag, $attr) {
 187         $this->_currentTagContents = '';
 188         $this->currentTag = $tag;
 189         switch($tag) {
 190             case 'methodCall':
 191             case 'methodResponse':
 192             case 'fault':
 193                 $this->messageType = $tag;
 194                 break;
 195             /* Deal with stacks of arrays and structs */
 196             case 'data':    // data is to all intents and puposes more interesting than array
 197                 $this->_arraystructstypes[] = 'array';
 198                 $this->_arraystructs[] = array();
 199                 break;
 200             case 'struct':
 201                 $this->_arraystructstypes[] = 'struct';
 202                 $this->_arraystructs[] = array();
 203                 break;
 204         }
 205     }
 206     function cdata($parser, $cdata) {
 207         $this->_currentTagContents .= $cdata;
 208     }
 209     function tag_close($parser, $tag) {
 210         $valueFlag = false;
 211         switch($tag) {
 212             case 'int':
 213             case 'i4':
 214                 $value = (int) trim($this->_currentTagContents);
 215                 $valueFlag = true;
 216                 break;
 217             case 'double':
 218                 $value = (double) trim($this->_currentTagContents);
 219                 $valueFlag = true;
 220                 break;
 221             case 'string':
 222                 $value = $this->_currentTagContents;
 223                 $valueFlag = true;
 224                 break;
 225             case 'dateTime.iso8601':
 226                 $value = new IXR_Date(trim($this->_currentTagContents));
 227                 // $value = $iso->getTimestamp();
 228                 $valueFlag = true;
 229                 break;
 230             case 'value':
 231                 // "If no type is indicated, the type is string."
 232                 if (trim($this->_currentTagContents) != '') {
 233                     $value = (string)$this->_currentTagContents;
 234                     $valueFlag = true;
 235                 }
 236                 break;
 237             case 'boolean':
 238                 $value = (boolean) trim($this->_currentTagContents);
 239                 $valueFlag = true;
 240                 break;
 241             case 'base64':
 242                 $value = base64_decode( trim( $this->_currentTagContents ) );
 243                 $valueFlag = true;
 244                 break;
 245             /* Deal with stacks of arrays and structs */
 246             case 'data':
 247             case 'struct':
 248                 $value = array_pop($this->_arraystructs);
 249                 array_pop($this->_arraystructstypes);
 250                 $valueFlag = true;
 251                 break;
 252             case 'member':
 253                 array_pop($this->_currentStructName);
 254                 break;
 255             case 'name':
 256                 $this->_currentStructName[] = trim($this->_currentTagContents);
 257                 break;
 258             case 'methodName':
 259                 $this->methodName = trim($this->_currentTagContents);
 260                 break;
 261         }
 262         if ($valueFlag) {
 263             if (count($this->_arraystructs) > 0) {
 264                 // Add value to struct or array
 265                 if ($this->_arraystructstypes[count($this->_arraystructstypes)-1] == 'struct') {
 266                     // Add to struct
 267                     $this->_arraystructs[count($this->_arraystructs)-1][$this->_currentStructName[count($this->_currentStructName)-1]] = $value;
 268                 } else {
 269                     // Add to array
 270                     $this->_arraystructs[count($this->_arraystructs)-1][] = $value;
 271                 }
 272             } else {
 273                 // Just add as a paramater
 274                 $this->params[] = $value;
 275             }
 276         }
 277         $this->_currentTagContents = '';
 278     }
 279 }
 280
 281 /**
 282  * IXR_Server
 283  *
 284  * @package IXR
 285  * @since 1.5
 286  */
 287 class IXR_Server {
 288     var $data;
 289     var $callbacks = array();
 290     var $message;
 291     var $capabilities;
 292     function IXR_Server($callbacks = false, $data = false) {
 293         $this->setCapabilities();
 294         if ($callbacks) {
 295             $this->callbacks = $callbacks;
 296         }
 297         $this->setCallbacks();
 298         $this->serve($data);
 299     }
 300     function serve($data = false) {
 301         if (!$data) {
 302             global $HTTP_RAW_POST_DATA;
 303             if (!$HTTP_RAW_POST_DATA) {
 304                die('XML-RPC server accepts POST requests only.');
 305             }
 306             $data = $HTTP_RAW_POST_DATA;
 307         }
 308         $this->message = new IXR_Message($data);
 309         if (!$this->message->parse()) {
 310             $this->error(-32700, 'parse error. not well formed');
 311         }
 312         if ($this->message->messageType != 'methodCall') {
 313             $this->error(-32600, 'server error. invalid xml-rpc. not conforming to spec. Request must be a methodCall');
 314         }
 315         $result = $this->call($this->message->methodName, $this->message->params);
 316         // Is the result an error?
 317         if (is_a($result, 'IXR_Error')) {
 318             $this->error($result);
 319         }
 320         // Encode the result
 321         $r = new IXR_Value($result);
 322         $resultxml = $r->getXml();
 323         // Create the XML
 324         $xml = <<<EOD
 325 <methodResponse>
 326   <params>
 327     <param>
 328       <value>
 329         $resultxml
 330       </value>
 331     </param>
 332   </params>
 333 </methodResponse>
 334
 335 EOD;
 336         // Send it
 337         $this->output($xml);
 338     }
 339     function call($methodname, $args) {
 340         if (!$this->hasMethod($methodname)) {
 341             return new IXR_Error(-32601, 'server error. requested method '.
 342                 $methodname.' does not exist.');
 343         }
 344         $method = $this->callbacks[$methodname];
 345         // Perform the callback and send the response
 346         if (count($args) == 1) {
 347             // If only one paramater just send that instead of the whole array
 348             $args = $args[0];
 349         }
 350         // Are we dealing with a function or a method?
 351         if (substr($method, 0, 5) == 'this:') {
 352             // It's a class method - check it exists
 353             $method = substr($method, 5);
 354             if (!method_exists($this, $method)) {
 355                 return new IXR_Error(-32601, 'server error. requested class method "'.
 356                     $method.'" does not exist.');
 357             }
 358             // Call the method
 359             $result = $this->$method($args);
 360         } else {
 361             // It's a function - does it exist?
 362             if (is_array($method)) {
 363                 if (!method_exists($method[0], $method[1])) {
 364                     return new IXR_Error(-32601, 'server error. requested object method "'.
 365                         $method[1].'" does not exist.');
 366                 }
 367             } else if (!function_exists($method)) {
 368                 return new IXR_Error(-32601, 'server error. requested function "'.
 369                     $method.'" does not exist.');
 370             }
 371             // Call the function
 372             $result = call_user_func($method, $args);
 373         }
 374         return $result;
 375     }
 376
 377     function error($error, $message = false) {
 378         // Accepts either an error object or an error code and message
 379         if ($message && !is_object($error)) {
 380             $error = new IXR_Error($error, $message);
 381         }
 382         $this->output($error->getXml());
 383     }
 384     function output($xml) {
 385         $xml = '<?xml version="1.0"?>'."\n".$xml;
 386         $length = strlen($xml);
 387         header('Connection: close');
 388         header('Content-Length: '.$length);
 389         header('Content-Type: text/xml');
 390         header('Date: '.date('r'));
 391         echo $xml;
 392         exit;
 393     }
 394     function hasMethod($method) {
 395         return in_array($method, array_keys($this->callbacks));
 396     }
 397     function setCapabilities() {
 398         // Initialises capabilities array
 399         $this->capabilities = array(
 400             'xmlrpc' => array(
 401                 'specUrl' => 'http://www.xmlrpc.com/spec',
 402                 'specVersion' => 1
 403             ),
 404             'faults_interop' => array(
 405                 'specUrl' => 'http://xmlrpc-epi.sourceforge.net/specs/rfc.fault_codes.php',
 406                 'specVersion' => 20010516
 407             ),
 408             'system.multicall' => array(
 409                 'specUrl' => 'http://www.xmlrpc.com/discuss/msgReader$1208',
 410                 'specVersion' => 1
 411             ),
 412         );
 413     }
 414     function getCapabilities($args) {
 415         return $this->capabilities;
 416     }
 417     function setCallbacks() {
 418         $this->callbacks['system.getCapabilities'] = 'this:getCapabilities';
 419         $this->callbacks['system.listMethods'] = 'this:listMethods';
 420         $this->callbacks['system.multicall'] = 'this:multiCall';
 421     }
 422     function listMethods($args) {
 423         // Returns a list of methods - uses array_reverse to ensure user defined
 424         // methods are listed before server defined methods
 425         return array_reverse(array_keys($this->callbacks));
 426     }
 427     function multiCall($methodcalls) {
 428         // See http://www.xmlrpc.com/discuss/msgReader$1208
 429         $return = array();
 430         foreach ($methodcalls as $call) {
 431             $method = $call['methodName'];
 432             $params = $call['params'];
 433             if ($method == 'system.multicall') {
 434                 $result = new IXR_Error(-32600, 'Recursive calls to system.multicall are forbidden');
 435             } else {
 436                 $result = $this->call($method, $params);
 437             }
 438             if (is_a($result, 'IXR_Error')) {
 439                 $return[] = array(
 440                     'faultCode' => $result->code,
 441                     'faultString' => $result->message
 442                 );
 443             } else {
 444                 $return[] = array($result);
 445             }
 446         }
 447         return $return;
 448     }
 449 }
 450
 451 /**
 452  * IXR_Request
 453  *
 454  * @package IXR
 455  * @since 1.5
 456  */
 457 class IXR_Request {
 458     var $method;
 459     var $args;
 460     var $xml;
 461     function IXR_Request($method, $args) {
 462         $this->method = $method;
 463         $this->args = $args;
 464         $this->xml = <<<EOD
 465 <?xml version="1.0"?>
 466 <methodCall>
 467 <methodName>{$this->method}</methodName>
 468 <params>
 469
 470 EOD;
 471         foreach ($this->args as $arg) {
 472             $this->xml .= '<param><value>';
 473             $v = new IXR_Value($arg);
 474             $this->xml .= $v->getXml();
 475             $this->xml .= "</value></param>\n";
 476         }
 477         $this->xml .= '</params></methodCall>';
 478     }
 479     function getLength() {
 480         return strlen($this->xml);
 481     }
 482     function getXml() {
 483         return $this->xml;
 484     }
 485 }
 486
 487 /**
 488  * IXR_Client
 489  *
 490  * @package IXR
 491  * @since 1.5
 492  */
 493 class IXR_Client {
 494     var $server;
 495     var $port;
 496     var $path;
 497     var $useragent;
 498     var $response;
 499     var $message = false;
 500     var $debug = false;
 501     var $timeout;
 502     // Storage place for an error message
 503     var $error = false;
 504     function IXR_Client($server, $path = false, $port = 80, $timeout = false) {
 505         if (!$path) {
 506             // Assume we have been given a URL instead
 507             $bits = parse_url($server);
 508             $this->server = $bits['host'];
 509             $this->port = isset($bits['port']) ? $bits['port'] : 80;
 510             $this->path = isset($bits['path']) ? $bits['path'] : '/';
 511             // Make absolutely sure we have a path
 512             if (!$this->path) {
 513                 $this->path = '/';
 514             }
 515         } else {
 516             $this->server = $server;
 517             $this->path = $path;
 518             $this->port = $port;
 519         }
 520         $this->useragent = 'The Incutio XML-RPC PHP Library';
 521         $this->timeout = $timeout;
 522     }
 523     function query() {
 524         $args = func_get_args();
 525         $method = array_shift($args);
 526         $request = new IXR_Request($method, $args);
 527         $length = $request->getLength();
 528         $xml = $request->getXml();
 529         $r = "\r\n";
 530         $request  = "POST {$this->path} HTTP/1.0$r";
 531         $request .= "Host: {$this->server}$r";
 532         $request .= "Content-Type: text/xml$r";
 533         $request .= "User-Agent: {$this->useragent}$r";
 534         $request .= "Content-length: {$length}$r$r";
 535         $request .= $xml;
 536         // Now send the request
 537         if ($this->debug) {
 538             echo '<pre>'.htmlspecialchars($request)."\n</pre>\n\n";
 539         }
 540         if ($this->timeout) {
 541             $fp = @fsockopen($this->server, $this->port, $errno, $errstr, $this->timeout);
 542         } else {
 543             $fp = @fsockopen($this->server, $this->port, $errno, $errstr);
 544         }
 545         if (!$fp) {
 546             $this->error = new IXR_Error(-32300, "transport error - could not open socket: $errno $errstr");
 547             return false;
 548         }
 549         fputs($fp, $request);
 550         $contents = '';
 551         $gotFirstLine = false;
 552         $gettingHeaders = true;
 553         while (!feof($fp)) {
 554             $line = fgets($fp, 4096);
 555             if (!$gotFirstLine) {
 556                 // Check line for '200'
 557                 if (strstr($line, '200') === false) {
 558                     $this->error = new IXR_Error(-32300, 'transport error - HTTP status code was not 200');
 559                     return false;
 560                 }
 561                 $gotFirstLine = true;
 562             }
 563             if (trim($line) == '') {
 564                 $gettingHeaders = false;
 565             }
 566             if (!$gettingHeaders) {
 567                 $contents .= trim($line);
 568             }
 569         }
 570         if ($this->debug) {
 571             echo '<pre>'.htmlspecialchars($contents)."\n</pre>\n\n";
 572         }
 573         // Now parse what we've got back
 574         $this->message = new IXR_Message($contents);
 575         if (!$this->message->parse()) {
 576             // XML error
 577             $this->error = new IXR_Error(-32700, 'parse error. not well formed');
 578             return false;
 579         }
 580         // Is the message a fault?
 581         if ($this->message->messageType == 'fault') {
 582             $this->error = new IXR_Error($this->message->faultCode, $this->message->faultString);
 583             return false;
 584         }
 585         // Message must be OK
 586         return true;
 587     }
 588     function getResponse() {
 589         // methodResponses can only have one param - return that
 590         return $this->message->params[0];
 591     }
 592     function isError() {
 593         return (is_object($this->error));
 594     }
 595     function getErrorCode() {
 596         return $this->error->code;
 597     }
 598     function getErrorMessage() {
 599         return $this->error->message;
 600     }
 601 }
 602
 603 /**
 604  * IXR_Error
 605  *
 606  * @package IXR
 607  * @since 1.5
 608  */
 609 class IXR_Error {
 610     var $code;
 611     var $message;
 612     function IXR_Error($code, $message) {
 613         $this->code = $code;
 614         // WP adds htmlspecialchars(). See #5666
 615         $this->message = htmlspecialchars($message);
 616     }
 617     function getXml() {
 618         $xml = <<<EOD
 619 <methodResponse>
 620   <fault>
 621     <value>
 622       <struct>
 623         <member>
 624           <name>faultCode</name>
 625           <value><int>{$this->code}</int></value>
 626         </member>
 627         <member>
 628           <name>faultString</name>
 629           <value><string>{$this->message}</string></value>
 630         </member>
 631       </struct>
 632     </value>
 633   </fault>
 634 </methodResponse>
 635
 636 EOD;
 637         return $xml;
 638     }
 639 }
 640
 641 /**
 642  * IXR_Date
 643  *
 644  * @package IXR
 645  * @since 1.5
 646  */
 647 class IXR_Date {
 648     var $year;
 649     var $month;
 650     var $day;
 651     var $hour;
 652     var $minute;
 653     var $second;
 654     var $timezone;
 655     function IXR_Date($time) {
 656         // $time can be a PHP timestamp or an ISO one
 657         if (is_numeric($time)) {
 658             $this->parseTimestamp($time);
 659         } else {
 660             $this->parseIso($time);
 661         }
 662     }
 663     function parseTimestamp($timestamp) {
 664         $this->year = date('Y', $timestamp);
 665         $this->month = date('m', $timestamp);
 666         $this->day = date('d', $timestamp);
 667         $this->hour = date('H', $timestamp);
 668         $this->minute = date('i', $timestamp);
 669         $this->second = date('s', $timestamp);
 670         // WP adds timezone. See #2036
 671         $this->timezone = '';
 672     }
 673     function parseIso($iso) {
 674         $this->year = substr($iso, 0, 4);
 675         $this->month = substr($iso, 4, 2);
 676         $this->day = substr($iso, 6, 2);
 677         $this->hour = substr($iso, 9, 2);
 678         $this->minute = substr($iso, 12, 2);
 679         $this->second = substr($iso, 15, 2);
 680         // WP adds timezone. See #2036
 681         $this->timezone = substr($iso, 17);
 682     }
 683     function getIso() {
 684         // WP adds timezone. See #2036
 685         return $this->year.$this->month.$this->day.'T'.$this->hour.':'.$this->minute.':'.$this->second.$this->timezone;
 686     }
 687     function getXml() {
 688         return '<dateTime.iso8601>'.$this->getIso().'</dateTime.iso8601>';
 689     }
 690     function getTimestamp() {
 691         return mktime($this->hour, $this->minute, $this->second, $this->month, $this->day, $this->year);
 692     }
 693 }
 694
 695 /**
 696  * IXR_Base64
 697  *
 698  * @package IXR
 699  * @since 1.5
 700  */
 701 class IXR_Base64 {
 702     var $data;
 703     function IXR_Base64($data) {
 704         $this->data = $data;
 705     }
 706     function getXml() {
 707         return '<base64>'.base64_encode($this->data).'</base64>';
 708     }
 709 }
 710
 711 /**
 712  * IXR_IntrospectionServer
 713  *
 714  * @package IXR
 715  * @since 1.5
 716  */
 717 class IXR_IntrospectionServer extends IXR_Server {
 718     var $signatures;
 719     var $help;
 720     function IXR_IntrospectionServer() {
 721         $this->setCallbacks();
 722         $this->setCapabilities();
 723         $this->capabilities['introspection'] = array(
 724             'specUrl' => 'http://xmlrpc.usefulinc.com/doc/reserved.html',
 725             'specVersion' => 1
 726         );
 727         $this->addCallback(
 728             'system.methodSignature',
 729             'this:methodSignature',
 730             array('array', 'string'),
 731             'Returns an array describing the return type and required parameters of a method'
 732         );
 733         $this->addCallback(
 734             'system.getCapabilities',
 735             'this:getCapabilities',
 736             array('struct'),
 737             'Returns a struct describing the XML-RPC specifications supported by this server'
 738         );
 739         $this->addCallback(
 740             'system.listMethods',
 741             'this:listMethods',
 742             array('array'),
 743             'Returns an array of available methods on this server'
 744         );
 745         $this->addCallback(
 746             'system.methodHelp',
 747             'this:methodHelp',
 748             array('string', 'string'),
 749             'Returns a documentation string for the specified method'
 750         );
 751     }
 752     function addCallback($method, $callback, $args, $help) {
 753         $this->callbacks[$method] = $callback;
 754         $this->signatures[$method] = $args;
 755         $this->help[$method] = $help;
 756     }
 757     function call($methodname, $args) {
 758         // Make sure it's in an array
 759         if ($args && !is_array($args)) {
 760             $args = array($args);
 761         }
 762         // Over-rides default call method, adds signature check
 763         if (!$this->hasMethod($methodname)) {
 764             return new IXR_Error(-32601, 'server error. requested method "'.$this->message->methodName.'" not specified.');
 765         }
 766         $method = $this->callbacks[$methodname];
 767         $signature = $this->signatures[$methodname];
 768         $returnType = array_shift($signature);
 769         // Check the number of arguments
 770         if (count($args) != count($signature)) {
 771             return new IXR_Error(-32602, 'server error. wrong number of method parameters');
 772         }
 773         // Check the argument types
 774         $ok = true;
 775         $argsbackup = $args;
 776         for ($i = 0, $j = count($args); $i < $j; $i++) {
 777             $arg = array_shift($args);
 778             $type = array_shift($signature);
 779             switch ($type) {
 780                 case 'int':
 781                 case 'i4':
 782                     if (is_array($arg) || !is_int($arg)) {
 783                         $ok = false;
 784                     }
 785                     break;
 786                 case 'base64':
 787                 case 'string':
 788                     if (!is_string($arg)) {
 789                         $ok = false;
 790                     }
 791                     break;
 792                 case 'boolean':
 793                     if ($arg !== false && $arg !== true) {
 794                         $ok = false;
 795                     }
 796                     break;
 797                 case 'float':
 798                 case 'double':
 799                     if (!is_float($arg)) {
 800                         $ok = false;
 801                     }
 802                     break;
 803                 case 'date':
 804                 case 'dateTime.iso8601':
 805                     if (!is_a($arg, 'IXR_Date')) {
 806                         $ok = false;
 807                     }
 808                     break;
 809             }
 810             if (!$ok) {
 811                 return new IXR_Error(-32602, 'server error. invalid method parameters');
 812             }
 813         }
 814         // It passed the test - run the "real" method call
 815         return parent::call($methodname, $argsbackup);
 816     }
 817     function methodSignature($method) {
 818         if (!$this->hasMethod($method)) {
 819             return new IXR_Error(-32601, 'server error. requested method "'.$method.'" not specified.');
 820         }
 821         // We should be returning an array of types
 822         $types = $this->signatures[$method];
 823         $return = array();
 824         foreach ($types as $type) {
 825             switch ($type) {
 826                 case 'string':
 827                     $return[] = 'string';
 828                     break;
 829                 case 'int':
 830                 case 'i4':
 831                     $return[] = 42;
 832                     break;
 833                 case 'double':
 834                     $return[] = 3.1415;
 835                     break;
 836                 case 'dateTime.iso8601':
 837                     $return[] = new IXR_Date(time());
 838                     break;
 839                 case 'boolean':
 840                     $return[] = true;
 841                     break;
 842                 case 'base64':
 843                     $return[] = new IXR_Base64('base64');
 844                     break;
 845                 case 'array':
 846                     $return[] = array('array');
 847                     break;
 848                 case 'struct':
 849                     $return[] = array('struct' => 'struct');
 850                     break;
 851             }
 852         }
 853         return $return;
 854     }
 855     function methodHelp($method) {
 856         return $this->help[$method];
 857     }
 858 }
 859
 860 /**
 861  * IXR_ClientMulticall
 862  *
 863  * @package IXR
 864  * @since 1.5
 865  */
 866 class IXR_ClientMulticall extends IXR_Client {
 867     var $calls = array();
 868     function IXR_ClientMulticall($server, $path = false, $port = 80) {
 869         parent::IXR_Client($server, $path, $port);
 870         $this->useragent = 'The Incutio XML-RPC PHP Library (multicall client)';
 871     }
 872     function addCall() {
 873         $args = func_get_args();
 874         $methodName = array_shift($args);
 875         $struct = array(
 876             'methodName' => $methodName,
 877             'params' => $args
 878         );
 879         $this->calls[] = $struct;
 880     }
 881     function query() {
 882         // Prepare multicall, then call the parent::query() method
 883         return parent::query('system.multicall', $this->calls);
 884     }
 885 }
 886
 887 ?>