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 ?>