1 <?php

     2 /**

     3  * IXR - The Inutio XML-RPC Library

     4  *

     5  * @package IXR

     6  * @since 1.5

     7  *

     8  * @copyright Incutio Ltd 2002-2005

     9  * @version 1.7 (beta) 23rd May 2005

    10  * @author Simon Willison

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

    12  * @link http://scripts.incutio.com/xmlrpc/manual.php Manual

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

    14  */

    15 

    16 /**

    17  * IXR_Value

    18  *

    19  * @package IXR

    20  * @since 1.5

    21  */

    22 class IXR_Value {

    23     var $data;

    24     var $type;

    25 

    26     function IXR_Value ($data, $type = false) {

    27         $this->data = $data;

    28         if (!$type) {

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

    30         }

    31         $this->type = $type;

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

    33             /* Turn all the values in the array in to new IXR_Value objects */

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

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

    36             }

    37         }

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

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

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

    41             }

    42         }

    43     }

    44 

    45     function calculateType() {

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

    47             return 'boolean';

    48         }

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

    50             return 'int';

    51         }

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

    53             return 'double';

    54         }

    55         // Deal with IXR object types base64 and date

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

    57             return 'date';

    58         }

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

    60             return 'base64';

    61         }

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

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

    64 

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

    66             return 'struct';

    67         }

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

    69             return 'string';

    70         }

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

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

    73             return 'struct';

    74         } else {

    75             return 'array';

    76         }

    77     }

    78 

    79     function getXml() {

    80         /* Return XML for this value */

    81         switch ($this->type) {

    82             case 'boolean':

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

    84                 break;

    85             case 'int':

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

    87                 break;

    88             case 'double':

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

    90                 break;

    91             case 'string':

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

    93                 break;

    94             case 'array':

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

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

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

    98                 }

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

   100                 return $return;

   101                 break;

   102             case 'struct':

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

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

   105 					$name = htmlspecialchars($name);

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

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

   108                 }

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

   110                 return $return;

   111                 break;

   112             case 'date':

   113             case 'base64':

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

   115                 break;

   116         }

   117         return false;

   118     }

   119 

   120     function isStruct($array) {

   121         /* Nasty function to check if an array is a struct or not */

   122         $expected = 0;

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

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

   125                 return true;

   126             }

   127             $expected++;

   128         }

   129         return false;

   130     }

   131 }

   132 

   133 /**

   134  * IXR_Message

   135  *

   136  * @package IXR

   137  * @since 1.5

   138  */

   139 class IXR_Message {

   140     var $message;

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

   142     var $faultCode;

   143     var $faultString;

   144     var $methodName;

   145     var $params;

   146     // Current variable stacks

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

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

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

   150     var $_param;

   151     var $_value;

   152     var $_currentTag;

   153     var $_currentTagContents;

   154     // The XML parser

   155     var $_parser;

   156     function IXR_Message ($message) {

   157         $this->message = $message;

   158     }

   159     function parse() {

   160         // first remove the XML declaration

   161         $this->message = preg_replace('/<\?xml.*?\?'.'>/', '', $this->message);

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

   163             return false;

   164         }

   165         $this->_parser = xml_parser_create();

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

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

   168         // Set XML parser callback functions

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

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

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

   172         if (!xml_parse($this->_parser, $this->message)) {

   173             /* die(sprintf('XML error: %s at line %d',

   174                 xml_error_string(xml_get_error_code($this->_parser)),

   175                 xml_get_current_line_number($this->_parser))); */

   176             return false;

   177         }

   178         xml_parser_free($this->_parser);

   179         // Grab the error messages, if any

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

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

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

   183         }

   184         return true;

   185     }

   186     function tag_open($parser, $tag, $attr) {

   187         $this->_currentTagContents = '';

   188         $this->currentTag = $tag;

   189         switch($tag) {

   190             case 'methodCall':

   191             case 'methodResponse':

   192             case 'fault':

   193                 $this->messageType = $tag;

   194                 break;

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

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

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

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

   199                 break;

   200             case 'struct':

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

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

   203                 break;

   204         }

   205     }

   206     function cdata($parser, $cdata) {

   207         $this->_currentTagContents .= $cdata;

   208     }

   209     function tag_close($parser, $tag) {

   210         $valueFlag = false;

   211         switch($tag) {

   212             case 'int':

   213             case 'i4':

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

   215                 $valueFlag = true;

   216                 break;

   217             case 'double':

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

   219                 $valueFlag = true;

   220                 break;

   221             case 'string':

   222                 $value = $this->_currentTagContents;

   223                 $valueFlag = true;

   224                 break;

   225             case 'dateTime.iso8601':

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

   227                 // $value = $iso->getTimestamp();

   228                 $valueFlag = true;

   229                 break;

   230             case 'value':

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

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

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

   234                     $valueFlag = true;

   235                 }

   236                 break;

   237             case 'boolean':

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

   239                 $valueFlag = true;

   240                 break;

   241             case 'base64':

   242                 $value = base64_decode( trim( $this->_currentTagContents ) );

   243                 $valueFlag = true;

   244                 break;

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

   246             case 'data':

   247             case 'struct':

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

   249                 array_pop($this->_arraystructstypes);

   250                 $valueFlag = true;

   251                 break;

   252             case 'member':

   253                 array_pop($this->_currentStructName);

   254                 break;

   255             case 'name':

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

   257                 break;

   258             case 'methodName':

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

   260                 break;

   261         }

   262         if ($valueFlag) {

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

   264                 // Add value to struct or array

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

   266                     // Add to struct

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

   268                 } else {

   269                     // Add to array

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

   271                 }

   272             } else {

   273                 // Just add as a paramater

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

   275             }

   276         }

   277         $this->_currentTagContents = '';

   278     }

   279 }

   280 

   281 /**

   282  * IXR_Server

   283  *

   284  * @package IXR

   285  * @since 1.5

   286  */

   287 class IXR_Server {

   288     var $data;

   289     var $callbacks = array();

   290     var $message;

   291     var $capabilities;

   292     function IXR_Server($callbacks = false, $data = false) {

   293         $this->setCapabilities();

   294         if ($callbacks) {

   295             $this->callbacks = $callbacks;

   296         }

   297         $this->setCallbacks();

   298         $this->serve($data);

   299     }

   300     function serve($data = false) {

   301         if (!$data) {

   302             global $HTTP_RAW_POST_DATA;

   303             if (!$HTTP_RAW_POST_DATA) {

   304                header( 'Content-Type: text/plain' );

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

   306             }

   307             $data = $HTTP_RAW_POST_DATA;

   308         }

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

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

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

   312         }

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

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

   315         }

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

   317         // Is the result an error?

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

   319             $this->error($result);

   320         }

   321         // Encode the result

   322         $r = new IXR_Value($result);

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

   324         // Create the XML

   325         $xml = <<<EOD

   326 <methodResponse>

   327   <params>

   328     <param>

   329       <value>

   330         $resultxml

   331       </value>

   332     </param>

   333   </params>

   334 </methodResponse>

   335 

   336 EOD;

   337         // Send it

   338         $this->output($xml);

   339     }

   340     function call($methodname, $args) {

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

   342             return new IXR_Error(-32601, 'server error. requested method '.

   343                 $methodname.' does not exist.');

   344         }

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

   346         // Perform the callback and send the response

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

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

   349             $args = $args[0];

   350         }

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

   352         if (substr($method, 0, 5) == 'this:') {

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

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

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

   356                 return new IXR_Error(-32601, 'server error. requested class method "'.

   357                     $method.'" does not exist.');

   358             }

   359             // Call the method

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

   361         } else {

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

   363             if (is_array($method)) {

   364                 if (!method_exists($method[0], $method[1])) {

   365                     return new IXR_Error(-32601, 'server error. requested object method "'.

   366                         $method[1].'" does not exist.');

   367                 }

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

   369                 return new IXR_Error(-32601, 'server error. requested function "'.

   370                     $method.'" does not exist.');

   371             }

   372             // Call the function

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

   374         }

   375         return $result;

   376     }

   377 

   378     function error($error, $message = false) {

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

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

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

   382         }

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

   384     }

   385     function output($xml) {

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

   387         $length = strlen($xml);

   388         header('Connection: close');

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

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

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

   392         echo $xml;

   393         exit;

   394     }

   395     function hasMethod($method) {

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

   397     }

   398     function setCapabilities() {

   399         // Initialises capabilities array

   400         $this->capabilities = array(

   401             'xmlrpc' => array(

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

   403                 'specVersion' => 1

   404             ),

   405             'faults_interop' => array(

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

   407                 'specVersion' => 20010516

   408             ),

   409             'system.multicall' => array(

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

   411                 'specVersion' => 1

   412             ),

   413         );

   414     }

   415     function getCapabilities($args) {

   416         return $this->capabilities;

   417     }

   418     function setCallbacks() {

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

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

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

   422     }

   423     function listMethods($args) {

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

   425         // methods are listed before server defined methods

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

   427     }

   428     function multiCall($methodcalls) {

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

   430         $return = array();

   431         foreach ($methodcalls as $call) {

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

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

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

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

   436             } else {

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

   438             }

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

   440                 $return[] = array(

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

   442                     'faultString' => $result->message

   443                 );

   444             } else {

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

   446             }

   447         }

   448         return $return;

   449     }

   450 }

   451 

   452 /**

   453  * IXR_Request

   454  *

   455  * @package IXR

   456  * @since 1.5

   457  */

   458 class IXR_Request {

   459     var $method;

   460     var $args;

   461     var $xml;

   462     function IXR_Request($method, $args) {

   463         $this->method = $method;

   464         $this->args = $args;

   465         $this->xml = <<<EOD

   466 <?xml version="1.0"?>

   467 <methodCall>

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

   469 <params>

   470 

   471 EOD;

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

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

   474             $v = new IXR_Value($arg);

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

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

   477         }

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

   479     }

   480     function getLength() {

   481         return strlen($this->xml);

   482     }

   483     function getXml() {

   484         return $this->xml;

   485     }

   486 }

   487 

   488 /**

   489  * IXR_Client

   490  *

   491  * @package IXR

   492  * @since 1.5

   493  */

   494 class IXR_Client {

   495     var $server;

   496     var $port;

   497     var $path;

   498     var $useragent;

   499 	var $headers;

   500     var $response;

   501     var $message = false;

   502     var $debug = false;

   503     var $timeout;

   504     // Storage place for an error message

   505     var $error = false;

   506     function IXR_Client($server, $path = false, $port = 80, $timeout = false) {

   507         if (!$path) {

   508             // Assume we have been given a URL instead

   509             $bits = parse_url($server);

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

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

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

   513             // Make absolutely sure we have a path

   514             if (!$this->path) {

   515                 $this->path = '/';

   516             }

   517         } else {

   518             $this->server = $server;

   519             $this->path = $path;

   520             $this->port = $port;

   521         }

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

   523         $this->timeout = $timeout;

   524     }

   525     function query() {

   526         $args = func_get_args();

   527         $method = array_shift($args);

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

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

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

   531         $r = "\r\n";

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

   533 

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

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

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

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

   538 

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

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

   541 		}

   542 		$request .= $r;

   543 

   544         $request .= $xml;

   545         // Now send the request

   546         if ($this->debug) {

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

   548         }

   549         if ($this->timeout) {

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

   551         } else {

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

   553         }

   554         if (!$fp) {

   555             $this->error = new IXR_Error(-32300, "transport error - could not open socket: $errno $errstr");

   556             return false;

   557         }

   558         fputs($fp, $request);

   559         $contents = '';

   560         $debug_contents = '';

   561         $gotFirstLine = false;

   562         $gettingHeaders = true;

   563         while (!feof($fp)) {

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

   565             if (!$gotFirstLine) {

   566                 // Check line for '200'

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

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

   569                     return false;

   570                 }

   571                 $gotFirstLine = true;

   572             }

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

   574                 $gettingHeaders = false;

   575             }

   576             if (!$gettingHeaders) {

   577                 $contents .= trim($line);

   578             }

   579             if ($this->debug) {

   580                 $debug_contents .= $line;

   581             }

   582         }

   583         if ($this->debug) {

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

   585         }

   586         // Now parse what we've got back

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

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

   589             // XML error

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

   591             return false;

   592         }

   593         // Is the message a fault?

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

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

   596             return false;

   597         }

   598         // Message must be OK

   599         return true;

   600     }

   601     function getResponse() {

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

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

   604     }

   605     function isError() {

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

   607     }

   608     function getErrorCode() {

   609         return $this->error->code;

   610     }

   611     function getErrorMessage() {

   612         return $this->error->message;

   613     }

   614 }

   615 

   616 /**

   617  * IXR_Error

   618  *

   619  * @package IXR

   620  * @since 1.5

   621  */

   622 class IXR_Error {

   623     var $code;

   624     var $message;

   625     function IXR_Error($code, $message) {

   626         $this->code = $code;

   627         // WP adds htmlspecialchars(). See #5666

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

   629     }

   630     function getXml() {

   631         $xml = <<<EOD

   632 <methodResponse>

   633   <fault>

   634     <value>

   635       <struct>

   636         <member>

   637           <name>faultCode</name>

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

   639         </member>

   640         <member>

   641           <name>faultString</name>

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

   643         </member>

   644       </struct>

   645     </value>

   646   </fault>

   647 </methodResponse>

   648 

   649 EOD;

   650         return $xml;

   651     }

   652 }

   653 

   654 /**

   655  * IXR_Date

   656  *

   657  * @package IXR

   658  * @since 1.5

   659  */

   660 class IXR_Date {

   661     var $year;

   662     var $month;

   663     var $day;

   664     var $hour;

   665     var $minute;

   666     var $second;

   667     var $timezone;

   668     function IXR_Date($time) {

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

   670         if (is_numeric($time)) {

   671             $this->parseTimestamp($time);

   672         } else {

   673             $this->parseIso($time);

   674         }

   675     }

   676     function parseTimestamp($timestamp) {

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

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

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

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

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

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

   683         // WP adds timezone. See #2036

   684         $this->timezone = '';

   685     }

   686     function parseIso($iso) {

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

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

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

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

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

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

   693         // WP adds timezone. See #2036

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

   695     }

   696     function getIso() {

   697     	// WP adds timezone. See #2036

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

   699     }

   700     function getXml() {

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

   702     }

   703     function getTimestamp() {

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

   705     }

   706 }

   707 

   708 /**

   709  * IXR_Base64

   710  *

   711  * @package IXR

   712  * @since 1.5

   713  */

   714 class IXR_Base64 {

   715     var $data;

   716     function IXR_Base64($data) {

   717         $this->data = $data;

   718     }

   719     function getXml() {

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

   721     }

   722 }

   723 

   724 /**

   725  * IXR_IntrospectionServer

   726  *

   727  * @package IXR

   728  * @since 1.5

   729  */

   730 class IXR_IntrospectionServer extends IXR_Server {

   731     var $signatures;

   732     var $help;

   733     function IXR_IntrospectionServer() {

   734         $this->setCallbacks();

   735         $this->setCapabilities();

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

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

   738             'specVersion' => 1

   739         );

   740         $this->addCallback(

   741             'system.methodSignature',

   742             'this:methodSignature',

   743             array('array', 'string'),

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

   745         );

   746         $this->addCallback(

   747             'system.getCapabilities',

   748             'this:getCapabilities',

   749             array('struct'),

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

   751         );

   752         $this->addCallback(

   753             'system.listMethods',

   754             'this:listMethods',

   755             array('array'),

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

   757         );

   758         $this->addCallback(

   759             'system.methodHelp',

   760             'this:methodHelp',

   761             array('string', 'string'),

   762             'Returns a documentation string for the specified method'

   763         );

   764     }

   765     function addCallback($method, $callback, $args, $help) {

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

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

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

   769     }

   770     function call($methodname, $args) {

   771         // Make sure it's in an array

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

   773             $args = array($args);

   774         }

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

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

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

   778         }

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

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

   781         $returnType = array_shift($signature);

   782         // Check the number of arguments

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

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

   785         }

   786         // Check the argument types

   787         $ok = true;

   788         $argsbackup = $args;

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

   790             $arg = array_shift($args);

   791             $type = array_shift($signature);

   792             switch ($type) {

   793                 case 'int':

   794                 case 'i4':

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

   796                         $ok = false;

   797                     }

   798                     break;

   799                 case 'base64':

   800                 case 'string':

   801                     if (!is_string($arg)) {

   802                         $ok = false;

   803                     }

   804                     break;

   805                 case 'boolean':

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

   807                         $ok = false;

   808                     }

   809                     break;

   810                 case 'float':

   811                 case 'double':

   812                     if (!is_float($arg)) {

   813                         $ok = false;

   814                     }

   815                     break;

   816                 case 'date':

   817                 case 'dateTime.iso8601':

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

   819                         $ok = false;

   820                     }

   821                     break;

   822             }

   823             if (!$ok) {

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

   825             }

   826         }

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

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

   829     }

   830     function methodSignature($method) {

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

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

   833         }

   834         // We should be returning an array of types

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

   836         $return = array();

   837         foreach ($types as $type) {

   838             switch ($type) {

   839                 case 'string':

   840                     $return[] = 'string';

   841                     break;

   842                 case 'int':

   843                 case 'i4':

   844                     $return[] = 42;

   845                     break;

   846                 case 'double':

   847                     $return[] = 3.1415;

   848                     break;

   849                 case 'dateTime.iso8601':

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

   851                     break;

   852                 case 'boolean':

   853                     $return[] = true;

   854                     break;

   855                 case 'base64':

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

   857                     break;

   858                 case 'array':

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

   860                     break;

   861                 case 'struct':

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

   863                     break;

   864             }

   865         }

   866         return $return;

   867     }

   868     function methodHelp($method) {

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

   870     }

   871 }

   872 

   873 /**

   874  * IXR_ClientMulticall

   875  *

   876  * @package IXR

   877  * @since 1.5

   878  */

   879 class IXR_ClientMulticall extends IXR_Client {

   880     var $calls = array();

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

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

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

   884     }

   885     function addCall() {

   886         $args = func_get_args();

   887         $methodName = array_shift($args);

   888         $struct = array(

   889             'methodName' => $methodName,

   890             'params' => $args

   891         );

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

   893     }

   894     function query() {

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

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

   897     }

   898 }

   899 

   900 ?>