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