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 method avoids the RAM usage of preg_replace on very large messages
 162                 $header = preg_replace( '/<\?xml.*?\?'.'>/', '', substr( $this->message, 0, 100 ), 1 );
 163                 $this->message = substr_replace($this->message, $header, 0, 100);
 164         if (trim($this->message) == '') {
 165             return false;
 166                 }
 167         $this->_parser = xml_parser_create();
 168         // Set XML parser to take the case of tags in to account
 169         xml_parser_set_option($this->_parser, XML_OPTION_CASE_FOLDING, false);
 170         // Set XML parser callback functions
 171         xml_set_object($this->_parser, $this);
 172         xml_set_element_handler($this->_parser, 'tag_open', 'tag_close');
 173                 xml_set_character_data_handler($this->_parser, 'cdata');
 174                 $chunk_size = 262144; // 256Kb, parse in chunks to avoid the RAM usage on very large messages
 175                 do {
 176                         if ( strlen($this->message) <= $chunk_size )
 177                                 $final=true;
 178                         $part = substr( $this->message, 0, $chunk_size );
 179                         $this->message = substr( $this->message, $chunk_size );
 180                         if ( !xml_parse( $this->_parser, $part, $final ) )
 181                                 return false;
 182                         if ( $final )
 183                                 break;
 184                 } while ( true );
 185                 xml_parser_free($this->_parser);
 186         // Grab the error messages, if any
 187         if ($this->messageType == 'fault') {
 188             $this->faultCode = $this->params[0]['faultCode'];
 189             $this->faultString = $this->params[0]['faultString'];
 190                 }
 191         return true;
 192     }
 193     function tag_open($parser, $tag, $attr) {
 194         $this->_currentTagContents = '';
 195         $this->currentTag = $tag;
 196         switch($tag) {
 197             case 'methodCall':
 198             case 'methodResponse':
 199             case 'fault':
 200                 $this->messageType = $tag;
 201                 break;
 202             /* Deal with stacks of arrays and structs */
 203             case 'data':    // data is to all intents and puposes more interesting than array
 204                 $this->_arraystructstypes[] = 'array';
 205                 $this->_arraystructs[] = array();
 206                 break;
 207             case 'struct':
 208                 $this->_arraystructstypes[] = 'struct';
 209                 $this->_arraystructs[] = array();
 210                 break;
 211         }
 212     }
 213     function cdata($parser, $cdata) {
 214         $this->_currentTagContents .= $cdata;
 215     }
 216     function tag_close($parser, $tag) {
 217         $valueFlag = false;
 218         switch($tag) {
 219             case 'int':
 220             case 'i4':
 221                 $value = (int) trim($this->_currentTagContents);
 222                 $valueFlag = true;
 223                 break;
 224             case 'double':
 225                 $value = (double) trim($this->_currentTagContents);
 226                 $valueFlag = true;
 227                 break;
 228             case 'string':
 229                 $value = $this->_currentTagContents;
 230                 $valueFlag = true;
 231                 break;
 232             case 'dateTime.iso8601':
 233                 $value = new IXR_Date(trim($this->_currentTagContents));
 234                 // $value = $iso->getTimestamp();
 235                 $valueFlag = true;
 236                 break;
 237             case 'value':
 238                 // "If no type is indicated, the type is string."
 239                 if (trim($this->_currentTagContents) != '') {
 240                     $value = (string)$this->_currentTagContents;
 241                     $valueFlag = true;
 242                 }
 243                 break;
 244             case 'boolean':
 245                 $value = (boolean) trim($this->_currentTagContents);
 246                 $valueFlag = true;
 247                 break;
 248             case 'base64':
 249                 $value = base64_decode( trim( $this->_currentTagContents ) );
 250                 $valueFlag = true;
 251                 break;
 252             /* Deal with stacks of arrays and structs */
 253             case 'data':
 254             case 'struct':
 255                 $value = array_pop($this->_arraystructs);
 256                 array_pop($this->_arraystructstypes);
 257                 $valueFlag = true;
 258                 break;
 259             case 'member':
 260                 array_pop($this->_currentStructName);
 261                 break;
 262             case 'name':
 263                 $this->_currentStructName[] = trim($this->_currentTagContents);
 264                 break;
 265             case 'methodName':
 266                 $this->methodName = trim($this->_currentTagContents);
 267                 break;
 268         }
 269         if ($valueFlag) {
 270             if (count($this->_arraystructs) > 0) {
 271                 // Add value to struct or array
 272                 if ($this->_arraystructstypes[count($this->_arraystructstypes)-1] == 'struct') {
 273                     // Add to struct
 274                     $this->_arraystructs[count($this->_arraystructs)-1][$this->_currentStructName[count($this->_currentStructName)-1]] = $value;
 275                 } else {
 276                     // Add to array
 277                     $this->_arraystructs[count($this->_arraystructs)-1][] = $value;
 278                 }
 279             } else {
 280                 // Just add as a paramater
 281                 $this->params[] = $value;
 282             }
 283         }
 284         $this->_currentTagContents = '';
 285     }
 286 }
 287
 288 /**
 289  * IXR_Server
 290  *
 291  * @package IXR
 292  * @since 1.5
 293  */
 294 class IXR_Server {
 295     var $data;
 296     var $callbacks = array();
 297     var $message;
 298     var $capabilities;
 299     function IXR_Server($callbacks = false, $data = false) {
 300         $this->setCapabilities();
 301         if ($callbacks) {
 302             $this->callbacks = $callbacks;
 303         }
 304         $this->setCallbacks();
 305         $this->serve($data);
 306     }
 307     function serve($data = false) {
 308         if (!$data) {
 309             global $HTTP_RAW_POST_DATA;
 310             if (!$HTTP_RAW_POST_DATA) {
 311                header( 'Content-Type: text/plain' );
 312                die('XML-RPC server accepts POST requests only.');
 313             }
 314             $data = &$HTTP_RAW_POST_DATA;
 315         }
 316         $this->message = new IXR_Message($data);
 317         if (!$this->message->parse()) {
 318             $this->error(-32700, 'parse error. not well formed');
 319         }
 320         if ($this->message->messageType != 'methodCall') {
 321             $this->error(-32600, 'server error. invalid xml-rpc. not conforming to spec. Request must be a methodCall');
 322         }
 323         $result = $this->call($this->message->methodName, $this->message->params);
 324         // Is the result an error?
 325         if (is_a($result, 'IXR_Error')) {
 326             $this->error($result);
 327         }
 328         // Encode the result
 329         $r = new IXR_Value($result);
 330         $resultxml = $r->getXml();
 331         // Create the XML
 332         $xml = <<<EOD
 333 <methodResponse>
 334   <params>
 335     <param>
 336       <value>
 337         $resultxml
 338       </value>
 339     </param>
 340   </params>
 341 </methodResponse>
 342
 343 EOD;
 344         // Send it
 345         $this->output($xml);
 346     }
 347     function call($methodname, $args) {
 348         if (!$this->hasMethod($methodname)) {
 349             return new IXR_Error(-32601, 'server error. requested method '.
 350                 $methodname.' does not exist.');
 351         }
 352         $method = $this->callbacks[$methodname];
 353         // Perform the callback and send the response
 354         if (count($args) == 1) {
 355             // If only one paramater just send that instead of the whole array
 356             $args = $args[0];
 357         }
 358         // Are we dealing with a function or a method?
 359         if (substr($method, 0, 5) == 'this:') {
 360             // It's a class method - check it exists
 361             $method = substr($method, 5);
 362             if (!method_exists($this, $method)) {
 363                 return new IXR_Error(-32601, 'server error. requested class method "'.
 364                     $method.'" does not exist.');
 365             }
 366             // Call the method
 367             $result = $this->$method($args);
 368         } else {
 369             // It's a function - does it exist?
 370             if (is_array($method)) {
 371                 if (!method_exists($method[0], $method[1])) {
 372                     return new IXR_Error(-32601, 'server error. requested object method "'.
 373                         $method[1].'" does not exist.');
 374                 }
 375             } else if (!function_exists($method)) {
 376                 return new IXR_Error(-32601, 'server error. requested function "'.
 377                     $method.'" does not exist.');
 378             }
 379             // Call the function
 380             $result = call_user_func($method, $args);
 381         }
 382         return $result;
 383     }
 384
 385     function error($error, $message = false) {
 386         // Accepts either an error object or an error code and message
 387         if ($message && !is_object($error)) {
 388             $error = new IXR_Error($error, $message);
 389         }
 390         $this->output($error->getXml());
 391     }
 392     function output($xml) {
 393         $xml = '<?xml version="1.0"?>'."\n".$xml;
 394         $length = strlen($xml);
 395         header('Connection: close');
 396         header('Content-Length: '.$length);
 397         header('Content-Type: text/xml');
 398         header('Date: '.date('r'));
 399         echo $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($args) {
 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($args) {
 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 /**
 460  * IXR_Request
 461  *
 462  * @package IXR
 463  * @since 1.5
 464  */
 465 class IXR_Request {
 466     var $method;
 467     var $args;
 468     var $xml;
 469     function IXR_Request($method, $args) {
 470         $this->method = $method;
 471         $this->args = $args;
 472         $this->xml = <<<EOD
 473 <?xml version="1.0"?>
 474 <methodCall>
 475 <methodName>{$this->method}</methodName>
 476 <params>
 477
 478 EOD;
 479         foreach ($this->args as $arg) {
 480             $this->xml .= '<param><value>';
 481             $v = new IXR_Value($arg);
 482             $this->xml .= $v->getXml();
 483             $this->xml .= "</value></param>\n";
 484         }
 485         $this->xml .= '</params></methodCall>';
 486     }
 487     function getLength() {
 488         return strlen($this->xml);
 489     }
 490     function getXml() {
 491         return $this->xml;
 492     }
 493 }
 494
 495 /**
 496  * IXR_Client
 497  *
 498  * @package IXR
 499  * @since 1.5
 500  */
 501 class IXR_Client {
 502     var $server;
 503     var $port;
 504     var $path;
 505     var $useragent;
 506         var $headers;
 507     var $response;
 508     var $message = false;
 509     var $debug = false;
 510     var $timeout;
 511     // Storage place for an error message
 512     var $error = false;
 513     function IXR_Client($server, $path = false, $port = 80, $timeout = false) {
 514         if (!$path) {
 515             // Assume we have been given a URL instead
 516             $bits = parse_url($server);
 517             $this->server = $bits['host'];
 518             $this->port = isset($bits['port']) ? $bits['port'] : 80;
 519             $this->path = isset($bits['path']) ? $bits['path'] : '/';
 520             // Make absolutely sure we have a path
 521             if (!$this->path) {
 522                 $this->path = '/';
 523             }
 524         } else {
 525             $this->server = $server;
 526             $this->path = $path;
 527             $this->port = $port;
 528         }
 529         $this->useragent = 'The Incutio XML-RPC PHP Library';
 530         $this->timeout = $timeout;
 531     }
 532     function query() {
 533         $args = func_get_args();
 534         $method = array_shift($args);
 535         $request = new IXR_Request($method, $args);
 536         $length = $request->getLength();
 537         $xml = $request->getXml();
 538         $r = "\r\n";
 539         $request  = "POST {$this->path} HTTP/1.0$r";
 540
 541                 $this->headers['Host']                  = $this->server;
 542                 $this->headers['Content-Type']  = 'text/xml';
 543                 $this->headers['User-Agent']    = $this->useragent;
 544                 $this->headers['Content-Length']= $length;
 545
 546                 foreach( $this->headers as $header => $value ) {
 547                         $request .= "{$header}: {$value}{$r}";
 548                 }
 549                 $request .= $r;
 550
 551         $request .= $xml;
 552         // Now send the request
 553         if ($this->debug) {
 554             echo '<pre class="ixr_request">'.htmlspecialchars($request)."\n</pre>\n\n";
 555         }
 556         if ($this->timeout) {
 557             $fp = @fsockopen($this->server, $this->port, $errno, $errstr, $this->timeout);
 558         } else {
 559             $fp = @fsockopen($this->server, $this->port, $errno, $errstr);
 560         }
 561         if (!$fp) {
 562             $this->error = new IXR_Error(-32300, "transport error - could not open socket: $errno $errstr");
 563             return false;
 564         }
 565         fputs($fp, $request);
 566         $contents = '';
 567         $debug_contents = '';
 568         $gotFirstLine = false;
 569         $gettingHeaders = true;
 570         while (!feof($fp)) {
 571             $line = fgets($fp, 4096);
 572             if (!$gotFirstLine) {
 573                 // Check line for '200'
 574                 if (strstr($line, '200') === false) {
 575                     $this->error = new IXR_Error(-32301, 'transport error - HTTP status code was not 200');
 576                     return false;
 577                 }
 578                 $gotFirstLine = true;
 579             }
 580             if (trim($line) == '') {
 581                 $gettingHeaders = false;
 582             }
 583             if (!$gettingHeaders) {
 584                 $contents .= trim($line);
 585             }
 586             if ($this->debug) {
 587                 $debug_contents .= $line;
 588             }
 589         }
 590         if ($this->debug) {
 591             echo '<pre class="ixr_response">'.htmlspecialchars($debug_contents)."\n</pre>\n\n";
 592         }
 593         // Now parse what we've got back
 594         $this->message = new IXR_Message($contents);
 595         if (!$this->message->parse()) {
 596             // XML error
 597             $this->error = new IXR_Error(-32700, 'parse error. not well formed');
 598             return false;
 599         }
 600         // Is the message a fault?
 601         if ($this->message->messageType == 'fault') {
 602             $this->error = new IXR_Error($this->message->faultCode, $this->message->faultString);
 603             return false;
 604         }
 605         // Message must be OK
 606         return true;
 607     }
 608     function getResponse() {
 609         // methodResponses can only have one param - return that
 610         return $this->message->params[0];
 611     }
 612     function isError() {
 613         return (is_object($this->error));
 614     }
 615     function getErrorCode() {
 616         return $this->error->code;
 617     }
 618     function getErrorMessage() {
 619         return $this->error->message;
 620     }
 621 }
 622
 623 /**
 624  * IXR_Error
 625  *
 626  * @package IXR
 627  * @since 1.5
 628  */
 629 class IXR_Error {
 630     var $code;
 631     var $message;
 632     function IXR_Error($code, $message) {
 633         $this->code = $code;
 634         // WP adds htmlspecialchars(). See #5666
 635         $this->message = htmlspecialchars($message);
 636     }
 637     function getXml() {
 638         $xml = <<<EOD
 639 <methodResponse>
 640   <fault>
 641     <value>
 642       <struct>
 643         <member>
 644           <name>faultCode</name>
 645           <value><int>{$this->code}</int></value>
 646         </member>
 647         <member>
 648           <name>faultString</name>
 649           <value><string>{$this->message}</string></value>
 650         </member>
 651       </struct>
 652     </value>
 653   </fault>
 654 </methodResponse>
 655
 656 EOD;
 657         return $xml;
 658     }
 659 }
 660
 661 /**
 662  * IXR_Date
 663  *
 664  * @package IXR
 665  * @since 1.5
 666  */
 667 class IXR_Date {
 668     var $year;
 669     var $month;
 670     var $day;
 671     var $hour;
 672     var $minute;
 673     var $second;
 674     var $timezone;
 675     function IXR_Date($time) {
 676         // $time can be a PHP timestamp or an ISO one
 677         if (is_numeric($time)) {
 678             $this->parseTimestamp($time);
 679         } else {
 680             $this->parseIso($time);
 681         }
 682     }
 683     function parseTimestamp($timestamp) {
 684         $this->year = date('Y', $timestamp);
 685         $this->month = date('m', $timestamp);
 686         $this->day = date('d', $timestamp);
 687         $this->hour = date('H', $timestamp);
 688         $this->minute = date('i', $timestamp);
 689         $this->second = date('s', $timestamp);
 690         // WP adds timezone. See #2036
 691         $this->timezone = '';
 692     }
 693     function parseIso($iso) {
 694         $this->year = substr($iso, 0, 4);
 695         $this->month = substr($iso, 4, 2);
 696         $this->day = substr($iso, 6, 2);
 697         $this->hour = substr($iso, 9, 2);
 698         $this->minute = substr($iso, 12, 2);
 699         $this->second = substr($iso, 15, 2);
 700         // WP adds timezone. See #2036
 701         $this->timezone = substr($iso, 17);
 702     }
 703     function getIso() {
 704         // WP adds timezone. See #2036
 705         return $this->year.$this->month.$this->day.'T'.$this->hour.':'.$this->minute.':'.$this->second.$this->timezone;
 706     }
 707     function getXml() {
 708         return '<dateTime.iso8601>'.$this->getIso().'</dateTime.iso8601>';
 709     }
 710     function getTimestamp() {
 711         return mktime($this->hour, $this->minute, $this->second, $this->month, $this->day, $this->year);
 712     }
 713 }
 714
 715 /**
 716  * IXR_Base64
 717  *
 718  * @package IXR
 719  * @since 1.5
 720  */
 721 class IXR_Base64 {
 722     var $data;
 723     function IXR_Base64($data) {
 724         $this->data = $data;
 725     }
 726     function getXml() {
 727         return '<base64>'.base64_encode($this->data).'</base64>';
 728     }
 729 }
 730
 731 /**
 732  * IXR_IntrospectionServer
 733  *
 734  * @package IXR
 735  * @since 1.5
 736  */
 737 class IXR_IntrospectionServer extends IXR_Server {
 738     var $signatures;
 739     var $help;
 740     function IXR_IntrospectionServer() {
 741         $this->setCallbacks();
 742         $this->setCapabilities();
 743         $this->capabilities['introspection'] = array(
 744             'specUrl' => 'http://xmlrpc.usefulinc.com/doc/reserved.html',
 745             'specVersion' => 1
 746         );
 747         $this->addCallback(
 748             'system.methodSignature',
 749             'this:methodSignature',
 750             array('array', 'string'),
 751             'Returns an array describing the return type and required parameters of a method'
 752         );
 753         $this->addCallback(
 754             'system.getCapabilities',
 755             'this:getCapabilities',
 756             array('struct'),
 757             'Returns a struct describing the XML-RPC specifications supported by this server'
 758         );
 759         $this->addCallback(
 760             'system.listMethods',
 761             'this:listMethods',
 762             array('array'),
 763             'Returns an array of available methods on this server'
 764         );
 765         $this->addCallback(
 766             'system.methodHelp',
 767             'this:methodHelp',
 768             array('string', 'string'),
 769             'Returns a documentation string for the specified method'
 770         );
 771     }
 772     function addCallback($method, $callback, $args, $help) {
 773         $this->callbacks[$method] = $callback;
 774         $this->signatures[$method] = $args;
 775         $this->help[$method] = $help;
 776     }
 777     function call($methodname, $args) {
 778         // Make sure it's in an array
 779         if ($args && !is_array($args)) {
 780             $args = array($args);
 781         }
 782         // Over-rides default call method, adds signature check
 783         if (!$this->hasMethod($methodname)) {
 784             return new IXR_Error(-32601, 'server error. requested method "'.$this->message->methodName.'" not specified.');
 785         }
 786         $method = $this->callbacks[$methodname];
 787         $signature = $this->signatures[$methodname];
 788         $returnType = array_shift($signature);
 789         // Check the number of arguments
 790         if (count($args) != count($signature)) {
 791             return new IXR_Error(-32602, 'server error. wrong number of method parameters');
 792         }
 793         // Check the argument types
 794         $ok = true;
 795         $argsbackup = $args;
 796         for ($i = 0, $j = count($args); $i < $j; $i++) {
 797             $arg = array_shift($args);
 798             $type = array_shift($signature);
 799             switch ($type) {
 800                 case 'int':
 801                 case 'i4':
 802                     if (is_array($arg) || !is_int($arg)) {
 803                         $ok = false;
 804                     }
 805                     break;
 806                 case 'base64':
 807                 case 'string':
 808                     if (!is_string($arg)) {
 809                         $ok = false;
 810                     }
 811                     break;
 812                 case 'boolean':
 813                     if ($arg !== false && $arg !== true) {
 814                         $ok = false;
 815                     }
 816                     break;
 817                 case 'float':
 818                 case 'double':
 819                     if (!is_float($arg)) {
 820                         $ok = false;
 821                     }
 822                     break;
 823                 case 'date':
 824                 case 'dateTime.iso8601':
 825                     if (!is_a($arg, 'IXR_Date')) {
 826                         $ok = false;
 827                     }
 828                     break;
 829             }
 830             if (!$ok) {
 831                 return new IXR_Error(-32602, 'server error. invalid method parameters');
 832             }
 833         }
 834         // It passed the test - run the "real" method call
 835         return parent::call($methodname, $argsbackup);
 836     }
 837     function methodSignature($method) {
 838         if (!$this->hasMethod($method)) {
 839             return new IXR_Error(-32601, 'server error. requested method "'.$method.'" not specified.');
 840         }
 841         // We should be returning an array of types
 842         $types = $this->signatures[$method];
 843         $return = array();
 844         foreach ($types as $type) {
 845             switch ($type) {
 846                 case 'string':
 847                     $return[] = 'string';
 848                     break;
 849                 case 'int':
 850                 case 'i4':
 851                     $return[] = 42;
 852                     break;
 853                 case 'double':
 854                     $return[] = 3.1415;
 855                     break;
 856                 case 'dateTime.iso8601':
 857                     $return[] = new IXR_Date(time());
 858                     break;
 859                 case 'boolean':
 860                     $return[] = true;
 861                     break;
 862                 case 'base64':
 863                     $return[] = new IXR_Base64('base64');
 864                     break;
 865                 case 'array':
 866                     $return[] = array('array');
 867                     break;
 868                 case 'struct':
 869                     $return[] = array('struct' => 'struct');
 870                     break;
 871             }
 872         }
 873         return $return;
 874     }
 875     function methodHelp($method) {
 876         return $this->help[$method];
 877     }
 878 }
 879
 880 /**
 881  * IXR_ClientMulticall
 882  *
 883  * @package IXR
 884  * @since 1.5
 885  */
 886 class IXR_ClientMulticall extends IXR_Client {
 887     var $calls = array();
 888     function IXR_ClientMulticall($server, $path = false, $port = 80) {
 889         parent::IXR_Client($server, $path, $port);
 890         $this->useragent = 'The Incutio XML-RPC PHP Library (multicall client)';
 891     }
 892     function addCall() {
 893         $args = func_get_args();
 894         $methodName = array_shift($args);
 895         $struct = array(
 896             'methodName' => $methodName,
 897             'params' => $args
 898         );
 899         $this->calls[] = $struct;
 900     }
 901     function query() {
 902         // Prepare multicall, then call the parent::query() method
 903         return parent::query('system.multicall', $this->calls);
 904     }
 905 }
 906
 907 ?>