source: documentation/trunk/packages/dokuwiki-2011-05-25a/inc/IXR_Library.php@ 30098

Last change on this file since 30098 was 25027, checked in by jmt12, 12 years ago

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