MDL-16180 - add portfolio support to mnet
[moodle.git] / mnet / xmlrpc / server.php
1 <?php
2 /**
3  * An XML-RPC server
4  *
5  * @author  Donal McMullan  donal@catalyst.net.nz
6  * @version 0.0.1
7  * @license http://www.gnu.org/copyleft/gpl.html GNU Public License
8  * @package mnet
9  */
11 // Make certain that config.php doesn't display any errors, and that it doesn't
12 // override our do-not-display-errors setting:
13 ini_set('display_errors',0);
14 require_once(dirname(dirname(dirname(__FILE__))) . '/config.php');
15 ini_set('display_errors',0);
17 // Include MNET stuff:
18 require_once $CFG->dirroot.'/mnet/lib.php';
19 require_once $CFG->dirroot.'/mnet/remote_client.php';
21 if ($CFG->mnet_dispatcher_mode === 'off') {
22     print_error('mnetdisabled', 'mnet');
23 }
25 // Content type for output is not html:
26 header('Content-type: text/xml; charset=utf-8');
28 // PHP 5.2.2: $HTTP_RAW_POST_DATA not populated bug:
29 // http://bugs.php.net/bug.php?id=41293
30 if (empty($HTTP_RAW_POST_DATA)) {
31     $HTTP_RAW_POST_DATA = file_get_contents('php://input');
32 }
34 if (!empty($CFG->mnet_rpcdebug)) {
35     trigger_error("HTTP_RAW_POST_DATA");
36     trigger_error($HTTP_RAW_POST_DATA);
37 }
39 // New global variable which ONLY gets set in this server page, so you know that
40 // if you've been called by a remote Moodle, this should be set:
41 $MNET_REMOTE_CLIENT = new mnet_remote_client();
43 // Peek at the message to see if it's an XML-ENC document. If it is, note that
44 // the client connection was encrypted, and strip the xml-encryption and
45 // xml-signature wrappers from the XML-RPC payload 
46 if (strpos(substr($HTTP_RAW_POST_DATA, 0, 100), '<encryptedMessage>')) {
47     $MNET_REMOTE_CLIENT->was_encrypted();
48 // Extract the XML-RPC payload from the XML-ENC and XML-SIG wrappers.
49     $payload = mnet_server_strip_wrappers($HTTP_RAW_POST_DATA);
50 } else {
51     $params = xmlrpc_decode_request($HTTP_RAW_POST_DATA, $method);
52     if ($method == 'system.keyswap'      ||
53         $method == 'system/keyswap') {
54         
55         // OK
56         
57     } elseif ($MNET_REMOTE_CLIENT->plaintext_is_ok() == false) {
58         exit(mnet_server_fault(7021, 'forbidden-transport'));
59     }
60     // Looks like plaintext is ok. It is assumed that a plaintext call:
61     //   1. Came from a trusted host on your local network
62     //   2. Is *not* from a Moodle - otherwise why skip encryption/signing?
63     //   3. Is free to execute ANY function in Moodle
64     //   4. Cannot execute any methods (as it can't instantiate a class first)
65     // To execute a method, you'll need to create a wrapper function that first
66     // instantiates the class, and then calls the method.
67     $payload  = $HTTP_RAW_POST_DATA;
68 }
70 if (!empty($CFG->mnet_rpcdebug)) {
71     trigger_error("XMLRPC Payload");
72     trigger_error(print_r($payload,1));
73 }
75 // Parse and action the XML-RPC payload
76 $response = mnet_server_dispatch($payload);
78 /**
79  * Strip the encryption (XML-ENC) and signature (XML-SIG) wrappers and return the XML-RPC payload
80  *
81  * IF COMMUNICATION TAKES PLACE OVER UNENCRYPTED HTTP:
82  * The payload will have been encrypted with a symmetric key. This key will
83  * itself have been encrypted using your public key. The key is decrypted using
84  * your private key, and then used to decrypt the XML payload.
85  *
86  * IF COMMUNICATION TAKES PLACE OVER UNENCRYPTED HTTP *OR* ENCRYPTED HTTPS:
87  * In either case, there will be an XML wrapper which contains your XML-RPC doc
88  * as an object element, a signature for that doc, and various standards-
89  * compliant info to aid in verifying the signature.
90  *
91  * This function parses the encryption wrapper, decrypts the contents, parses
92  * the signature wrapper, and if the signature matches the payload, it returns
93  * the payload, which should be an XML-RPC request.
94  * If there is an error, or the signatures don't match, it echoes an XML-RPC
95  * error and exits.
96  *
97  * See the W3C's {@link http://www.w3.org/TR/xmlenc-core/ XML Encryption Syntax and Processing}
98  * and {@link http://www.w3.org/TR/2001/PR-xmldsig-core-20010820/ XML-Signature Syntax and Processing}
99  * guidelines for more detail on the XML.
100  *
101  * -----XML-Envelope---------------------------------
102  * |                                                |
103  * |    Encrypted-Symmetric-key----------------     |
104  * |    |_____________________________________|     |
105  * |                                                |
106  * |    Encrypted data-------------------------     |
107  * |    |                                     |     |
108  * |    |  -XML-Envelope------------------    |     |
109  * |    |  |                             |    |     |
110  * |    |  |  --Signature-------------   |    |     |
111  * |    |  |  |______________________|   |    |     |
112  * |    |  |                             |    |     |
113  * |    |  |  --Signed-Payload--------   |    |     |
114  * |    |  |  |                      |   |    |     |
115  * |    |  |  |   XML-RPC Request    |   |    |     |
116  * |    |  |  |______________________|   |    |     |
117  * |    |  |                             |    |     |
118  * |    |  |_____________________________|    |     |
119  * |    |_____________________________________|     |
120  * |                                                |
121  * |________________________________________________|
122  *
123  * @param   string  $HTTP_RAW_POST_DATA   The XML that the client sent
124  * @return  string                        The XMLRPC payload.
125  */
126 function mnet_server_strip_wrappers($HTTP_RAW_POST_DATA) {
127     global $MNET, $MNET_REMOTE_CLIENT;
128     if (isset($_SERVER)) {
130         $crypt_parser = new mnet_encxml_parser();
131         $crypt_parser->parse($HTTP_RAW_POST_DATA);
133         // Make sure we know who we're talking to
134         $host_record_exists = $MNET_REMOTE_CLIENT->set_wwwroot($crypt_parser->remote_wwwroot);
136         if (false == $host_record_exists) {
137             exit(mnet_server_fault(7020, 'wrong-wwwroot', $crypt_parser->remote_wwwroot));
138         }
140         if ($crypt_parser->payload_encrypted) {
142             $key  = array_pop($crypt_parser->cipher);  // This key is Symmetric
143             $data = array_pop($crypt_parser->cipher);
145             $crypt_parser->free_resource();
147             $payload          = '';    // Initialize payload var
148             $push_current_key = false; // True if we need to push a fresh key to the peer
150             //                                          &$payload
151             $isOpen = openssl_open(base64_decode($data), $payload, base64_decode($key), $MNET->get_private_key());
153             if (!$isOpen) {
154                 // Decryption failed... let's try our archived keys
155                 $openssl_history = get_config('mnet', 'openssl_history');
156                 if(empty($openssl_history)) {
157                     $openssl_history = array();
158                     set_config('openssl_history', serialize($openssl_history), 'mnet');
159                 } else {
160                     $openssl_history = unserialize($openssl_history);
161                 }
162                 foreach($openssl_history as $keyset) {
163                     $keyresource = openssl_pkey_get_private($keyset['keypair_PEM']);
164                     $isOpen      = openssl_open(base64_decode($data), $payload, base64_decode($key), $keyresource);
165                     if ($isOpen) {
166                         // It's an older code, sir, but it checks out
167                         $push_current_key = true;
168                         break;
169                     }
170                 }
171             }
173             if (!$isOpen) {
174                 exit(mnet_server_fault(7023, 'encryption-invalid'));
175             }
177             if (strpos(substr($payload, 0, 100), '<signedMessage>')) {
178                 $MNET_REMOTE_CLIENT->was_signed();
179                 $sig_parser = new mnet_encxml_parser();
180                 $sig_parser->parse($payload);
181             } else {
182                 exit(mnet_server_fault(7022, 'verifysignature-error'));
183             }
185         } else {
186             exit(mnet_server_fault(7024, 'payload-not-encrypted'));
187         }
189         unset($payload);
191         // if the peer used one of our public keys that have expired, we will
192         // return a signed/encrypted error message with our new public key 
193         if($push_current_key) {
194             // NOTE: Here, we use the 'mnet_server_fault_xml' to avoid
195             // get_string being called on our public_key
196             exit(mnet_server_fault_xml(7025, $MNET->public_key, $keyresource));
197         }
199         /**
200          * Get the certificate (i.e. public key) from the remote server.
201          */
202         $certificate = $MNET_REMOTE_CLIENT->public_key;
204         if ($certificate == false) {
205             exit(mnet_server_fault(709, 'nosuchpublickey'));
206         }
208         $payload = base64_decode($sig_parser->data_object);
210         // Does the signature match the data and the public cert?
211         $signature_verified = openssl_verify($payload, base64_decode($sig_parser->signature), $certificate);
212         if ($signature_verified == 1) {
213             $MNET_REMOTE_CLIENT->touch();
214             // Parse the XML
215         } elseif ($signature_verified == 0) {
216             $currkey = mnet_get_public_key($MNET_REMOTE_CLIENT->wwwroot, $MNET_REMOTE_CLIENT->application);
217             if($currkey != $certificate) {
218                 // Has the server updated its certificate since our last 
219                 // handshake?
220                 if(!$MNET_REMOTE_CLIENT->refresh_key()) {
221                     exit(mnet_server_fault(7026, 'verifysignature-invalid'));
222                 }
223             } else {
224                 exit(mnet_server_fault(710, 'verifysignature-invalid'));
225             }
226         } else {
227             exit(mnet_server_fault(711, 'verifysignature-error'));
228         }
230         $sig_parser->free_resource();
232         return $payload;
233     } else {
234         exit(mnet_server_fault(712, "phperror"));
235     }
238 /**
239  * Return the proper XML-RPC content to report an error in the local language.
240  *
241  * @param  int    $code   The ID code of the error message
242  * @param  string $text   The array-key of the error message in the lang file
243  * @param  string $param  The $a param for the error message in the lang file
244  * @return string $text   The text of the error message
245  */
246 function mnet_server_fault($code, $text, $param = null) {
247     global $MNET_REMOTE_CLIENT;
248     if (!is_numeric($code)) {
249         $code = 0;
250     }
251     $code = intval($code);
253     $text = get_string($text, 'mnet', $param);
254     return mnet_server_fault_xml($code, $text);
257 /**
258  * Return the proper XML-RPC content to report an error.
259  *
260  * @param  int      $code   The ID code of the error message
261  * @param  string   $text   The error message
262  * @param  resource $privatekey The private key that should be used to sign the response
263  * @return string   $text   The XML text of the error message
264  */
265 function mnet_server_fault_xml($code, $text, $privatekey = null) {
266     global $MNET_REMOTE_CLIENT, $CFG;
267     // Replace illegal XML chars - is this already in a lib somewhere?
268     $text = str_replace(array('<','>','&','"',"'"), array('&lt;','&gt;','&amp;','&quot;','&apos;'), $text);
270     $return = mnet_server_prepare_response('<?xml version="1.0"?>
271 <methodResponse>
272    <fault>
273       <value>
274          <struct>
275             <member>
276                <name>faultCode</name>
277                <value><int>'.$code.'</int></value>
278             </member>
279             <member>
280                <name>faultString</name>
281                <value><string>'.$text.'</string></value>
282             </member>
283          </struct>
284       </value>
285    </fault>
286 </methodResponse>', $privatekey);
288     if (!empty($CFG->mnet_rpcdebug)) {
289         trigger_error("XMLRPC Error Response $code: $text");
290         trigger_error(print_r($return,1));
291     }
293     return $return;
296 /**
297  * Dummy function for the XML-RPC dispatcher - use to call a method on an object
298  * or to call a function
299  *
300  * Translate XML-RPC's strange function call syntax into a more straightforward
301  * PHP-friendly alternative. This dummy function will be called by the
302  * dispatcher, and can be used to call a method on an object, or just a function
303  * 
304  * The methodName argument (eg. mnet/testlib/mnet_concatenate_strings)
305  * is ignored.
306  *
307  * @param  string  $methodname     We discard this - see 'functionname'
308  * @param  array   $argsarray      Each element is an argument to the real
309  *                                 function
310  * @param  string  $functionname   The name of the PHP function you want to call
311  * @return mixed                   The return value will be that of the real
312  *                                 function, whateber it may be.
313  */
314 function mnet_server_dummy_method($methodname, $argsarray, $functionname) {
315     global $MNET_REMOTE_CLIENT;
316     
317     if (is_object($MNET_REMOTE_CLIENT->object_to_call)) {
318         return @call_user_method_array($functionname, $MNET_REMOTE_CLIENT->object_to_call, $argsarray);
319     } else if (!empty($MNET_REMOTE_CLIENT->static_location)) {
320         return @call_user_func_array(array($MNET_REMOTE_CLIENT->static_location, $functionname), $argsarray);
321     } else {
322         return @call_user_func_array($functionname, $argsarray);
323     }
326 /**
327  * Package a response in any required envelope, and return it to the client
328  *
329  * @param   string   $response      The XMLRPC response string
330  * @param   resource $privatekey    The private key to sign the response with
331  * @return  string                  The encoded response string
332  */
333 function mnet_server_prepare_response($response, $privatekey = null) {
334     global $MNET_REMOTE_CLIENT;
336     if ($MNET_REMOTE_CLIENT->request_was_signed) {
337         $response = mnet_sign_message($response, $privatekey);
338     }
340     if ($MNET_REMOTE_CLIENT->request_was_encrypted) {
341         $response = mnet_encrypt_message($response, $MNET_REMOTE_CLIENT->public_key);
342     }
344     return $response;
347 /**
348  * If security checks are passed, dispatch the request to the function/method
349  *
350  * The config variable 'mnet_dispatcher_mode' can be:
351  * strict:      Only execute functions that are in specific files
352  * off:         The default - don't execute anything
353  *
354  * @param  string  $payload    The XML-RPC request
355  * @return                     No return val - just echo the response
356  */
357 function mnet_server_dispatch($payload) {
358     global $CFG, $MNET_REMOTE_CLIENT;
359     // xmlrpc_decode_request returns an array of parameters, and the $method
360     // variable (which is passed by reference) is instantiated with the value from
361     // the methodName tag in the xml payload
362     //            xmlrpc_decode_request($xml,                   &$method)
363     $params     = xmlrpc_decode_request($payload, $method);
365     // $method is something like: "mod/forum/lib.php/forum_add_instance"
366     // $params is an array of parameters. A parameter might itself be an array.
368     // Whitelist characters that are permitted in a method name
369     // The method name must not begin with a / - avoid absolute paths
370     // A dot character . is only allowed in the filename, i.e. something.php
371     if (0 == preg_match("@^[A-Za-z0-9]+/[A-Za-z0-9/_-]+(\.php/)?[A-Za-z0-9_-]+$@",$method)) {
372         exit(mnet_server_fault(713, 'nosuchfunction'));
373     }
375     if(preg_match("/^system\./", $method)) {
376         $callstack  = explode('.', $method);
377     } else {
378         $callstack  = explode('/', $method);
379         // callstack will look like array('mod', 'forum', 'lib.php', 'forum_add_instance');
380     }
382     /**
383      * What has the site administrator chosen as his dispatcher setting?
384      * strict:      Only execute functions that are in specific files
385      * off:         The default - don't execute anything
386      */
387     ////////////////////////////////////// OFF
388     if (!isset($CFG->mnet_dispatcher_mode) ) {
389         set_config('mnet_dispatcher_mode', 'off');
390         exit(mnet_server_fault(704, 'nosuchservice'));
391     } elseif ('off' == $CFG->mnet_dispatcher_mode) {
392         exit(mnet_server_fault(704, 'nosuchservice'));
394     ////////////////////////////////////// SYSTEM METHODS
395     } elseif ($callstack[0] == 'system') {
396         $functionname = $callstack[1];
397         $xmlrpcserver = xmlrpc_server_create();
399         // I'm adding the canonical xmlrpc references here, however we've
400         // already forbidden that the period (.) should be allowed in the call
401         // stack, so if someone tries to access our XMLRPC in the normal way,
402         // they'll already have received a RPC server fault message.
404         // Maybe we should allow an easement so that regular XMLRPC clients can
405         // call our system methods, and find out what we have to offer?
407         xmlrpc_server_register_method($xmlrpcserver, 'system.listMethods', 'mnet_system');
408         xmlrpc_server_register_method($xmlrpcserver, 'system/listMethods', 'mnet_system');
410         xmlrpc_server_register_method($xmlrpcserver, 'system.methodSignature', 'mnet_system');
411         xmlrpc_server_register_method($xmlrpcserver, 'system/methodSignature', 'mnet_system');
413         xmlrpc_server_register_method($xmlrpcserver, 'system.methodHelp', 'mnet_system');
414         xmlrpc_server_register_method($xmlrpcserver, 'system/methodHelp', 'mnet_system');
416         xmlrpc_server_register_method($xmlrpcserver, 'system.listServices', 'mnet_system');
417         xmlrpc_server_register_method($xmlrpcserver, 'system/listServices', 'mnet_system');
419         xmlrpc_server_register_method($xmlrpcserver, 'system.keyswap', 'mnet_keyswap');
420         xmlrpc_server_register_method($xmlrpcserver, 'system/keyswap', 'mnet_keyswap');
422         if ($method == 'system.listMethods'     ||
423             $method == 'system/listMethods'     ||
424             $method == 'system.methodSignature' ||
425             $method == 'system/methodSignature' ||
426             $method == 'system.methodHelp'      ||
427             $method == 'system/methodHelp'      ||
428             $method == 'system.listServices'      ||
429             $method == 'system/listServices'      ||
430             $method == 'system.keyswap'      ||
431             $method == 'system/keyswap') {
433             $response = xmlrpc_server_call_method($xmlrpcserver, $payload, $MNET_REMOTE_CLIENT, array("encoding" => "utf-8"));
434             $response = mnet_server_prepare_response($response);
435         } else {
436             exit(mnet_server_fault(7018, 'nosuchfunction'));
437         }
439         xmlrpc_server_destroy($xmlrpcserver);
440         echo $response;
441     ////////////////////////////////////// STRICT AUTH
442     } elseif ($callstack[0] == 'auth') {
444         // Break out the callstack into its elements
445         list($base, $plugin, $filename, $methodname) = $callstack;
447         // We refuse to include anything that is not auth.php
448         if ($filename == 'auth.php' && is_enabled_auth($plugin)) {
449             $authclass   = 'auth_plugin_'.$plugin;
450             $includefile = '/auth/'.$plugin.'/auth.php';
451             $response    = mnet_server_invoke_method($includefile, $methodname, $method, $payload, $authclass);
452             $response = mnet_server_prepare_response($response);
453             echo $response;
454         } else {
455             // Generate error response - unable to locate function
456             exit(mnet_server_fault(702, 'nosuchfunction'));
457         }
459     ////////////////////////////////////// STRICT ENROL
460     } elseif ($callstack[0] == 'enrol') {
462         // Break out the callstack into its elements
463         list($base, $plugin, $filename, $methodname) = $callstack;
465         if ($filename == 'enrol.php' && is_enabled_enrol($plugin)) {
466             $enrolclass  = 'enrolment_plugin_'.$plugin;
467             $includefile = '/enrol/'.$plugin.'/enrol.php';
468             $response    = mnet_server_invoke_method($includefile, $methodname, $method, $payload, $enrolclass);
469             $response = mnet_server_prepare_response($response);
470             echo $response;
471         } else {
472             // Generate error response - unable to locate function
473             exit(mnet_server_fault(703, 'nosuchfunction'));
474         }
476     } else if ($callstack[0] == 'portfolio') {
477         // Break out the callstack into its elements
478         list($base, $plugin, $filename, $methodname) = $callstack;
480         if ($filename == 'lib.php') {
481             $pluginclass = 'portfolio_plugin_' . $plugin;
482             $includefile = '/portfolio/type/'.$plugin.'/lib.php';
483             $response    = mnet_server_invoke_method($includefile, $methodname, $method, $payload, $pluginclass);
484             $response = mnet_server_prepare_response($response);
485             echo $response;
486         } else {
487             // Generate error response - unable to locate function
488             exit(mnet_server_fault(7012, 'nosuchfunction'));
489         }
491     ////////////////////////////////////// STRICT MOD/*
492     } elseif ($callstack[0] == 'mod' || 'dangerous' == $CFG->mnet_dispatcher_mode) {
493         list($base, $module, $filename, $functionname) = $callstack;
495     ////////////////////////////////////// STRICT MOD/*
496         if ($base == 'mod' && $filename == 'rpclib.php') {
497             $includefile = '/mod/'.$module.'/rpclib.php';
498             $response    = mnet_server_invoke_method($includefile, $functionname, $method, $payload);
499             $response = mnet_server_prepare_response($response);
500             echo $response;
502     ////////////////////////////////////// DANGEROUS
503         } elseif ('dangerous' == $CFG->mnet_dispatcher_mode && $MNET_REMOTE_CLIENT->plaintext_is_ok()) {
505             $functionname = array_pop($callstack);
507             if ($MNET_REMOTE_CLIENT->plaintext_is_ok()) {
509                 $filename = clean_param(implode('/',$callstack), PARAM_PATH);
510                 if (0 == preg_match("/php$/", $filename)) {
511                     // Filename doesn't end in 'php'; possible attack?
512                     // Generate error response - unable to locate function
513                     exit(mnet_server_fault(7012, 'nosuchfunction'));
514                 } 
516                 // The call stack holds the path to any include file
517                 $includefile = $CFG->dirroot.'/'.$filename;
519                 $response = mnet_server_invoke_method($includefile, $functionname, $method, $payload);
520                 echo $response;
521             }
523         } else {
524             // Generate error response - unable to locate function
525             exit(mnet_server_fault(7012, 'nosuchfunction'));
526         }
528     } else {
529         // Generate error response - unable to locate function
530         exit(mnet_server_fault(7012, 'nosuchfunction'));
531     }
534 /**
535  * Execute the system functions - mostly for introspection
536  *
537  * @param  string  $method    XMLRPC method name, e.g. system.listMethods
538  * @param  array   $params    Array of parameters from the XMLRPC request
539  * @param  string  $hostinfo  Hostinfo object from the mnet_host table
540  * @return mixed              Response data - any kind of PHP variable
541  */
542 function mnet_system($method, $params, $hostinfo) {
543     global $CFG, $DB;
545     if (empty($hostinfo)) return array();
547     $id_list = $hostinfo->id;
548     if (!empty($CFG->mnet_all_hosts_id)) {
549         $id_list .= ', '.$CFG->mnet_all_hosts_id;
550     }
552     if ('system.listMethods' == $method || 'system/listMethods' == $method) {
553         if (count($params) == 0) {
554             $query = '
555                 SELECT DISTINCT
556                     rpc.function_name,
557                     rpc.xmlrpc_path,
558                     rpc.enabled,
559                     rpc.help,
560                     rpc.profile
561                 FROM
562                     {mnet_host2service} h2s,
563                     {mnet_service2rpc} s2r,
564                     {mnet_rpc} rpc
565                 WHERE
566                     s2r.rpcid = rpc.id AND
567                     h2s.serviceid = s2r.serviceid AND 
568                     h2s.hostid in ('.$id_list .') AND
569                     h2s.publish =\'1\'
570                 ORDER BY
571                     rpc.xmlrpc_path ASC';
572             $params = array();
574         } else {
575             $query = '
576                 SELECT DISTINCT
577                     rpc.function_name,
578                     rpc.xmlrpc_path,
579                     rpc.enabled,
580                     rpc.help,
581                     rpc.profile
582                 FROM
583                     {mnet_host2service} h2s,
584                     {mnet_service2rpc} s2r,
585                     {mnet_service} svc,
586                     {mnet_rpc} rpc
587                 WHERE
588                     s2r.rpcid = rpc.id AND
589                     h2s.serviceid = s2r.serviceid AND 
590                     h2s.hostid in ('.$id_list .') AND
591                     h2s.publish =\'1\' AND
592                     svc.id = h2s.serviceid AND
593                     svc.name = ?
594                 ORDER BY
595                     rpc.xmlrpc_path ASC';
596             $params = array($params[0]);
598         }
599         $resultset = array_values($DB->get_records_sql($query, $params));
600         $methods = array();
601         foreach($resultset as $result) {
602             $methods[] = $result->xmlrpc_path;
603         }
604         return $methods;
605     } elseif ('system.methodSignature' == $method || 'system/methodSignature' == $method) {
606         $query = '
607             SELECT DISTINCT
608                 rpc.function_name,
609                 rpc.xmlrpc_path,
610                 rpc.enabled,
611                 rpc.help,
612                 rpc.profile
613             FROM
614                 {mnet_host2service} h2s,
615                 {mnet_service2rpc} s2r,
616                 {mnet_rpc rpc}
617             WHERE
618                 rpc.xmlrpc_path = ? AND
619                 s2r.rpcid = rpc.id AND
620                 h2s.serviceid = s2r.serviceid AND 
621                 h2s.publish =\'1\' AND
622                 h2s.hostid in ('.$id_list .')';
623         $params = array($params[0]);
625         $result = $DB->get_records_sql($query, $params);
626         $methodsigs = array();
628         if (is_array($result)) {
629             foreach($result as $method) {
630                 $methodsigs[] = unserialize($method->profile);
631             }
632         }
634         return $methodsigs;
635     } elseif ('system.methodHelp' == $method || 'system/methodHelp' == $method) {
636         $query = '
637             SELECT DISTINCT
638                 rpc.function_name,
639                 rpc.xmlrpc_path,
640                 rpc.enabled,
641                 rpc.help,
642                 rpc.profile
643             FROM
644                 {mnet_host2service} h2s,
645                 {mnet_service2rpc} s2r,
646                 {mnet_rpc} rpc
647             WHERE
648                 rpc.xmlrpc_path = ? AND
649                 s2r.rpcid = rpc.id AND
650                 h2s.publish =\'1\' AND
651                 h2s.serviceid = s2r.serviceid AND 
652                 h2s.hostid in ('.$id_list .')';
653         $params = array($params[0]);
655         $result = $DB->get_record_sql($query, $params);
657         if (is_object($result)) {
658             return $result->help;
659         }
660     } elseif ('system.listServices' == $method || 'system/listServices' == $method) {
661         $query = '
662             SELECT DISTINCT
663                 s.id,
664                 s.name,
665                 s.apiversion,
666                 h2s.publish,
667                 h2s.subscribe
668             FROM
669                 {mnet_host2service} h2s,
670                 {mnet_service} s
671             WHERE
672                 h2s.serviceid = s.id AND
673                (h2s.publish =\'1\' OR h2s.subscribe =\'1\') AND
674                 h2s.hostid in ('.$id_list .')
675             ORDER BY
676                 s.name ASC';
677         $params = array();
679         $result = $DB->get_records_sql($query, $params);
680         $services = array();
682         if (is_array($result)) {
683             foreach($result as $service) {
684                 $services[] = array('name' => $service->name, 
685                                     'apiversion' => $service->apiversion, 
686                                     'publish' => $service->publish, 
687                                     'subscribe' => $service->subscribe);
688             }
689         }
691         return $services;
692     }
693     exit(mnet_server_fault(7019, 'nosuchfunction'));
696 /**
697  * Initialize the object (if necessary), execute the method or function, and 
698  * return the response
699  *
700  * @param  string  $includefile    The file that contains the object definition
701  * @param  string  $methodname     The name of the method to execute
702  * @param  string  $method         The full path to the method
703  * @param  string  $payload        The XML-RPC request payload
704  * @param  string  $class          The name of the class to instantiate (or false)
705  * @return string                  The XML-RPC response
706  */
707 function mnet_server_invoke_method($includefile, $methodname, $method, $payload, $class=false) {
709     $permission = mnet_permit_rpc_call($includefile, $methodname, $class);
711     if (RPC_NOSUCHFILE == $permission) {
712         // Generate error response - unable to locate function
713         exit(mnet_server_fault(705, 'nosuchfile', $includefile));
714     }
716     if (RPC_NOSUCHFUNCTION == $permission) {
717         // Generate error response - unable to locate function
718         exit(mnet_server_fault(706, 'nosuchfunction'));
719     }
721     if (RPC_FORBIDDENFUNCTION == $permission) {
722         // Generate error response - unable to locate function
723         exit(mnet_server_fault(707, 'forbidden-function'));
724     }
726     if (RPC_NOSUCHCLASS == $permission) {
727         // Generate error response - unable to locate function
728         exit(mnet_server_fault(7013, 'nosuchfunction'));
729     }
731     if (RPC_NOSUCHMETHOD == $permission) {
732         // Generate error response - unable to locate function
733         exit(mnet_server_fault(7014, 'nosuchmethod'));
734     }
736     if (RPC_NOSUCHFUNCTION == $permission) {
737         // Generate error response - unable to locate function
738         exit(mnet_server_fault(7014, 'nosuchmethod'));
739     }
741     if (RPC_FORBIDDENMETHOD == $permission) {
742         // Generate error response - unable to locate function
743         exit(mnet_server_fault(7015, 'nosuchfunction'));
744     }
746     if (0 < $permission) {
747         // Generate error response - unable to locate function
748         exit(mnet_server_fault(7019, 'unknownerror'));
749     }
751     if (RPC_OK == $permission) {
752         $xmlrpcserver = xmlrpc_server_create();
753         $bool = xmlrpc_server_register_method($xmlrpcserver, $method, 'mnet_server_dummy_method');
754         $response = xmlrpc_server_call_method($xmlrpcserver, $payload, $methodname, array("encoding" => "utf-8"));
755         $bool = xmlrpc_server_destroy($xmlrpcserver);
756         return $response;
757     }
760 /**
761  * Accepts a public key from a new remote host and returns the public key for
762  * this host. If 'register all hosts' is turned on, it will bootstrap a record
763  * for the remote host in the mnet_host table (if it's not already there)
764  * 
765  * @param  string  $function      XML-RPC requires this but we don't... discard!
766  * @param  array   $params        Array of parameters
767  *                                $params[0] is the remote wwwroot
768  *                                $params[1] is the remote public key
769  * @return string                 The XML-RPC response
770  */
771 function mnet_keyswap($function, $params) {
772     global $CFG, $MNET;
773     $return = array();
775     if (!empty($CFG->mnet_register_allhosts)) {
776         $mnet_peer = new mnet_peer();
777         @list($wwwroot, $pubkey, $application) = each($params);
778         $keyok = $mnet_peer->bootstrap($wwwroot, $pubkey, $application);
779         if ($keyok) {
780             $mnet_peer->commit();
781         }
782     }
783     return $MNET->public_key;
786 ?>