vendor/incutio/IXR_Library.inc.php

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