xmlrpc.server.inc 11.6 KB
Newer Older
Dries's avatar
 
Dries committed
1 2
<?php

3 4
/**
 * @file
5
 * Page callback file for the xmlrpc module.
6 7
 */

8 9 10
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpKernel\Exception\BadRequestHttpException;

11 12
/**
 * Process an XML-RPC request.
13 14 15
 *
 * @return \Symfony\Component\HttpFoundation\Response
 *   A Response object.
16 17
 *
 * @deprecated Use \Drupal\xmlrpc\Controller\XmlrpcController::php()
18 19 20
 */
function xmlrpc_server_page() {
  module_load_include('inc', 'xmlrpc');
21
  return xmlrpc_server(\Drupal::moduleHandler()->invokeAll('xmlrpc'));
22 23
}

24
/**
25
 * Invokes XML-RPC methods on this server.
26
 *
27
 * @param array $callbacks
28
 *   Array of external XML-RPC method names with the callbacks they map to.
29 30 31
 *
 * @return \Symfony\Component\HttpFoundation\Response
 *   A Response object.
32
 */
33 34
function xmlrpc_server($callbacks) {
  $xmlrpc_server = new stdClass();
35
  // Define built-in XML-RPC method names
36
  $defaults = array(
37
    'system.multicall' => 'xmlrpc_server_multicall',
38 39 40 41
    array(
      'system.methodSignature',
      'xmlrpc_server_method_signature',
      array('array', 'string'),
42
      'Returns an array describing the return type and required parameters of a method.',
43 44 45 46 47
    ),
    array(
      'system.getCapabilities',
      'xmlrpc_server_get_capabilities',
      array('struct'),
48
      'Returns a struct describing the XML-RPC specifications supported by this server.',
49 50 51 52 53
    ),
    array(
      'system.listMethods',
      'xmlrpc_server_list_methods',
      array('array'),
54 55
      'Returns an array of available methods on this server.',
    ),
56 57 58 59
    array(
      'system.methodHelp',
      'xmlrpc_server_method_help',
      array('string', 'string'),
60 61
      'Returns a documentation string for the specified method.',
    ),
62
  );
63 64 65
  // We build an array of all method names by combining the built-ins
  // with those defined by modules implementing the _xmlrpc hook.
  // Built-in methods are overridable.
66 67 68
  $callbacks = array_merge($defaults, (array) $callbacks);
  drupal_alter('xmlrpc', $callbacks);
  foreach ($callbacks as $key => $callback) {
69 70 71 72 73 74 75 76 77 78 79 80 81
    // we could check for is_array($callback)
    if (is_int($key)) {
      $method = $callback[0];
      $xmlrpc_server->callbacks[$method] = $callback[1];
      $xmlrpc_server->signatures[$method] = $callback[2];
      $xmlrpc_server->help[$method] = $callback[3];
    }
    else {
      $xmlrpc_server->callbacks[$key] = $callback;
      $xmlrpc_server->signatures[$key] = '';
      $xmlrpc_server->help[$key] = '';
    }
  }
Dries's avatar
 
Dries committed
82

83
  $data = file_get_contents('php://input');
84
  if (!$data) {
85
    throw new BadRequestHttpException('XML-RPC server accepts POST requests only.');
Dries's avatar
 
Dries committed
86
  }
87 88
  $xmlrpc_server->message = xmlrpc_message($data);
  if (!xmlrpc_message_parse($xmlrpc_server->message)) {
89
    return xmlrpc_server_error(-32700, t('Parse error. Request not well formed.'));
Dries's avatar
 
Dries committed
90
  }
91
  if ($xmlrpc_server->message->messagetype != 'methodCall') {
92
    return xmlrpc_server_error(-32600, t('Server error. Invalid XML-RPC. Request must be a methodCall.'));
Dries's avatar
 
Dries committed
93
  }
94 95 96
  if (!isset($xmlrpc_server->message->params)) {
    $xmlrpc_server->message->params = array();
  }
97
  xmlrpc_server_set($xmlrpc_server);
98
  $result = xmlrpc_server_call($xmlrpc_server, $xmlrpc_server->message->methodname, $xmlrpc_server->message->params);
99

100
  if (is_object($result) && !empty($result->is_error)) {
101
    return xmlrpc_server_error($result);
Dries's avatar
 
Dries committed
102
  }
103 104 105 106 107 108 109
  // Encode the result
  $r = xmlrpc_value($result);
  // Create the XML
  $xml = '
<methodResponse>
  <params>
  <param>
110
    <value>' . xmlrpc_value_get_xml($r) . '</value>
111 112 113
  </param>
  </params>
</methodResponse>
Dries's avatar
 
Dries committed
114

115 116
';
  // Send it
117
  return xmlrpc_server_output($xml);
118
}
Dries's avatar
 
Dries committed
119

120
/**
121
 * Throws an XML-RPC error.
122 123
 *
 * @param $error
124
 *   An error object or integer error code.
125
 * @param $message
126 127
 *   (optional) The description of the error. Used only if an integer error
 *   code was passed in.
128 129 130
 *
 * @return \Symfony\Component\HttpFoundation\Response
 *   A Response object.
131
 */
132
function xmlrpc_server_error($error, $message = FALSE) {
133 134
  if ($message && !is_object($error)) {
    $error = xmlrpc_error($error, $message);
Dries's avatar
 
Dries committed
135
  }
136
  return xmlrpc_server_output(xmlrpc_error_get_xml($error));
Dries's avatar
 
Dries committed
137 138
}

139 140 141 142 143
/**
 * Sends XML-RPC output to the browser.
 *
 * @param string $xml
 *   XML to send to the browser.
144 145 146
 *
 * @return \Symfony\Component\HttpFoundation\Response
 *   A Response object.
147
 */
148
function xmlrpc_server_output($xml) {
149
  $xml = '<?xml version="1.0"?>' . "\n" . $xml;
150 151 152 153 154
  $headers = array(
    'Content-Length' => strlen($xml),
    'Content-Type' => 'text/xml'
  );
  return new Response($xml, 200, $headers);
Dries's avatar
 
Dries committed
155 156
}

157
/**
158 159 160 161 162
 * Stores a copy of an XML-RPC request temporarily.
 *
 * @param object $xmlrpc_server
 *   (optional) Request object created by xmlrpc_server(). Omit to leave the
 *   previous server object saved.
163
 *
164 165 166 167
 * @return
 *   The latest stored request.
 *
 * @see xmlrpc_server_get()
168
 */
169 170 171 172
function xmlrpc_server_set($xmlrpc_server = NULL) {
  static $server;
  if (!isset($server)) {
    $server = $xmlrpc_server;
Dries's avatar
 
Dries committed
173
  }
174 175
  return $server;
}
Dries's avatar
 
Dries committed
176

177 178 179 180 181 182 183 184
/**
 * Retrieves the latest stored XML-RPC request.
 *
 * @return object
 *   The stored request.
 *
 * @see xmlrpc_server_set()
 */
185 186 187
function xmlrpc_server_get() {
  return xmlrpc_server_set();
}
Dries's avatar
 
Dries committed
188

189
/**
190 191 192 193 194 195 196 197 198
 * Dispatches an XML-RPC request and any parameters to the appropriate handler.
 *
 * @param object $xmlrpc_server
 *   Object containing information about this XML-RPC server, the methods it
 *   provides, their signatures, etc.
 * @param string $methodname
 *   The external XML-RPC method name; e.g., 'system.methodHelp'.
 * @param array $args
 *   Array containing any parameters that are to be sent along with the request.
199
 *
200 201
 * @return
 *   The results of the call.
202
 */
203
function xmlrpc_server_call($xmlrpc_server, $methodname, $args) {
204
  // Make sure parameters are in an array
205 206
  if ($args && !is_array($args)) {
    $args = array($args);
Dries's avatar
 
Dries committed
207
  }
208
  // Has this method been mapped to a Drupal function by us or by modules?
209
  if (!isset($xmlrpc_server->callbacks[$methodname])) {
210
    return xmlrpc_error(-32601, t('Server error. Requested method @methodname not specified.', array("@methodname" => $xmlrpc_server->message->methodname)));
211 212 213
  }
  $method = $xmlrpc_server->callbacks[$methodname];
  $signature = $xmlrpc_server->signatures[$methodname];
Dries's avatar
 
Dries committed
214

215
  // If the method has a signature, validate the request against the signature
216
  if (is_array($signature)) {
217
    $ok = TRUE;
218 219
    // Remove first element of $signature which is the unused 'return type'.
    array_shift($signature);
220 221
    // Check the number of arguments
    if (count($args) != count($signature)) {
222
      return xmlrpc_error(-32602, t('Server error. Wrong number of method parameters.'));
Dries's avatar
 
Dries committed
223
    }
224 225 226 227 228 229 230
    // Check the argument types
    foreach ($signature as $key => $type) {
      $arg = $args[$key];
      switch ($type) {
        case 'int':
        case 'i4':
          if (is_array($arg) || !is_int($arg)) {
231
            $ok = FALSE;
232 233
          }
          break;
234

235 236 237
        case 'base64':
        case 'string':
          if (!is_string($arg)) {
238
            $ok = FALSE;
239 240
          }
          break;
241

242
        case 'boolean':
243 244
          if ($arg !== FALSE && $arg !== TRUE) {
            $ok = FALSE;
245 246
          }
          break;
247

248 249 250
        case 'float':
        case 'double':
          if (!is_float($arg)) {
251
            $ok = FALSE;
252 253
          }
          break;
254

255 256 257
        case 'date':
        case 'dateTime.iso8601':
          if (!$arg->is_date) {
258
            $ok = FALSE;
259 260
          }
          break;
Dries's avatar
 
Dries committed
261
      }
262
      if (!$ok) {
263
        return xmlrpc_error(-32602, t('Server error. Invalid method parameters.'));
Dries's avatar
 
Dries committed
264 265 266
      }
    }
  }
267

268
  if (!function_exists($method)) {
269
    return xmlrpc_error(-32601, t('Server error. Requested function @method does not exist.', array("@method" => $method)));
270
  }
271
  // Call the mapped function
272 273
  return call_user_func_array($method, $args);
}
Dries's avatar
 
Dries committed
274

275 276 277 278 279 280 281 282 283 284 285 286 287 288
/**
 * Dispatches multiple XML-RPC requests.
 *
 * @param array $methodcalls
 *   An array of XML-RPC requests to make. Each request is an array with the
 *   following elements:
 *   - methodName: Name of the method to invoke.
 *   - params: Parameters to pass to the method.
 *
 * @return
 *   An array of the results of each request.
 *
 * @see xmlrpc_server_call()
 */
289 290 291 292 293
function xmlrpc_server_multicall($methodcalls) {
  // See http://www.xmlrpc.com/discuss/msgReader$1208
  $return = array();
  $xmlrpc_server = xmlrpc_server_get();
  foreach ($methodcalls as $call) {
294
    $ok = TRUE;
295 296
    if (!isset($call['methodName']) || !isset($call['params'])) {
      $result = xmlrpc_error(3, t('Invalid syntax for system.multicall.'));
297
      $ok = FALSE;
298 299 300 301 302 303 304 305 306
    }
    $method = $call['methodName'];
    $params = $call['params'];
    if ($method == 'system.multicall') {
      $result = xmlrpc_error(-32600, t('Recursive calls to system.multicall are forbidden.'));
    }
    elseif ($ok) {
      $result = xmlrpc_server_call($xmlrpc_server, $method, $params);
    }
307
    if (is_object($result) && !empty($result->is_error)) {
308 309
      $return[] = array(
        'faultCode' => $result->code,
310
        'faultString' => $result->message,
311 312 313
      );
    }
    else {
314
      $return[] = array($result);
315 316 317 318 319 320
    }
  }
  return $return;
}

/**
321 322
 * Lists the methods available on this XML-RPC server.
 *
323
 * XML-RPC method system.listMethods maps to this function.
324 325 326
 *
 * @return array
 *   Array of the names of methods available on this server.
327 328 329 330 331 332 333
 */
function xmlrpc_server_list_methods() {
  $xmlrpc_server = xmlrpc_server_get();
  return array_keys($xmlrpc_server->callbacks);
}

/**
334 335
 * Returns a list of the capabilities of this server.
 *
336
 * XML-RPC method system.getCapabilities maps to this function.
337
 *
338 339 340
 * @return array
 *   Array of server capabilities.
 *
341
 * @see http://groups.yahoo.com/group/xml-rpc/message/2897
342 343 344 345 346
 */
function xmlrpc_server_get_capabilities() {
  return array(
    'xmlrpc' => array(
      'specUrl' => 'http://www.xmlrpc.com/spec',
347
      'specVersion' => 1,
348 349 350
    ),
    'faults_interop' => array(
      'specUrl' => 'http://xmlrpc-epi.sourceforge.net/specs/rfc.fault_codes.php',
351
      'specVersion' => 20010516,
352 353 354
    ),
    'system.multicall' => array(
      'specUrl' => 'http://www.xmlrpc.com/discuss/msgReader$1208',
355
      'specVersion' => 1,
356 357
    ),
    'introspection' => array(
358 359 360
      'specUrl' => 'http://scripts.incutio.com/xmlrpc/introspection.html',
      'specVersion' => 1,
    ),
361 362 363 364
  );
}

/**
365
 * Returns one method signature for a function.
366
 *
367
 * This is the function mapped to the XML-RPC method system.methodSignature.
368
 *
369 370 371 372 373 374 375 376
 * A method signature is an array of the input and output types of a method. For
 * instance, the method signature of this function is array('array', 'string'),
 * because it takes an array and returns a string.
 *
 * @param string $methodname
 *   Name of method to return a method signature for.
 *
 * @return array
377 378
 *   An array of arrays of types, each of the arrays representing one method
 *   signature of the function that $methodname maps to.
379 380 381
 */
function xmlrpc_server_method_signature($methodname) {
  $xmlrpc_server = xmlrpc_server_get();
382
  if (!isset($xmlrpc_server->callbacks[$methodname])) {
383
    return xmlrpc_error(-32601, t('Server error. Requested method @methodname not specified.', array("@methodname" => $methodname)));
384
  }
385
  if (!is_array($xmlrpc_server->signatures[$methodname])) {
386
    return xmlrpc_error(-32601, t('Server error. Requested method @methodname signature not specified.', array("@methodname" => $methodname)));
387
  }
388
  // We array of types
389 390
  $return = array();
  foreach ($xmlrpc_server->signatures[$methodname] as $type) {
391
    $return[] = $type;
Dries's avatar
 
Dries committed
392
  }
393
  return array($return);
394 395
}

396
/**
397 398
 * Returns the help for an XML-RPC method.
 *
399 400
 * XML-RPC method system.methodHelp maps to this function.
 *
401
 * @param string $method
402
 *   Name of method for which we return a help string.
403 404 405
 *
 * @return string
 *   Help text for $method.
406
 */
407 408
function xmlrpc_server_method_help($method) {
  $xmlrpc_server = xmlrpc_server_get();
409
  return $xmlrpc_server->help[$method];
410
}