inc/IXR_Library.php

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