Search moodle.org's
Developer Documentation
Developer Documentation
- Bug fixes for general core bugs in 3.11.x will end 14 Nov 2022 (12 months plus 6 months extension).
- Bug fixes for security issues in 3.11.x will end 13 Nov 2023 (18 months plus 12 months extension).
- PHP version: minimum PHP 7.3.0 Note: minimum PHP version has increased since Moodle 3.10. PHP 7.4.x is supported too.
/mnet/xmlrpc/ -> serverlib.php (source)
Differences Between: [Versions 310 and 311] [Versions 311 and 401] [Versions 311 and 402] [Versions 311 and 403] [Versions 39 and 311]
1 <?php 2 3 /** 4 * -----XML-Envelope--------------------------------- 5 * | | 6 * | Encrypted-Symmetric-key---------------- | 7 * | |_____________________________________| | 8 * | | 9 * | Encrypted data------------------------- | 10 * | | | | 11 * | | -XML-Envelope------------------ | | 12 * | | | | | | 13 * | | | --Signature------------- | | | 14 * | | | |______________________| | | | 15 * | | | | | | 16 * | | | --Signed-Payload-------- | | | 17 * | | | | | | | | 18 * | | | | XML-RPC Request | | | | 19 * | | | |______________________| | | | 20 * | | | | | | 21 * | | |_____________________________| | | 22 * | |_____________________________________| | 23 * | | 24 * |________________________________________________| 25 * 26 */ 27 28 /* Strip encryption envelope (if present) and decrypt data 29 * 30 * @param string $rawpostdata The XML that the client sent 31 * 32 * @throws mnet_server_exception 33 * 34 * @return string XML with any encryption envolope removed 35 */ 36 function mnet_server_strip_encryption($rawpostdata) { 37 $remoteclient = get_mnet_remote_client(); 38 $crypt_parser = new mnet_encxml_parser(); 39 $crypt_parser->parse($rawpostdata); 40 $mnet = get_mnet_environment(); 41 42 if (!$crypt_parser->payload_encrypted) { 43 return $rawpostdata; 44 } 45 46 // Make sure we know who we're talking to 47 $host_record_exists = $remoteclient->set_wwwroot($crypt_parser->remote_wwwroot); 48 49 if (false == $host_record_exists) { 50 throw new mnet_server_exception(7020, 'wrong-wwwroot', $crypt_parser->remote_wwwroot); 51 } 52 53 // This key is symmetric, and is itself encrypted. Can be decrypted using our private key 54 $key = array_pop($crypt_parser->cipher); 55 // This data is symmetrically encrypted, can be decrypted using the above key 56 $data = array_pop($crypt_parser->cipher); 57 58 $crypt_parser->free_resource(); 59 $payload = ''; // Initialize payload var 60 61 // &$payload 62 $isOpen = openssl_open(base64_decode($data), $payload, base64_decode($key), $mnet->get_private_key(), 'RC4'); 63 if ($isOpen) { 64 $remoteclient->was_encrypted(); 65 return $payload; 66 } 67 68 // Decryption failed... let's try our archived keys 69 $openssl_history = get_config('mnet', 'openssl_history'); 70 if(empty($openssl_history)) { 71 $openssl_history = array(); 72 set_config('openssl_history', serialize($openssl_history), 'mnet'); 73 } else { 74 $openssl_history = unserialize($openssl_history); 75 } 76 foreach($openssl_history as $keyset) { 77 $keyresource = openssl_pkey_get_private($keyset['keypair_PEM']); 78 $isOpen = openssl_open(base64_decode($data), $payload, base64_decode($key), $keyresource, 'RC4'); 79 if ($isOpen) { 80 // It's an older code, sir, but it checks out 81 $remoteclient->was_encrypted(); 82 $remoteclient->encrypted_to($keyresource); 83 $remoteclient->set_pushkey(); 84 return $payload; 85 } 86 } 87 88 //If after all that we still couldn't decrypt the message, error out. 89 throw new mnet_server_exception(7023, 'encryption-invalid'); 90 } 91 92 /* Strip signature envelope (if present), try to verify any signature using our record of remote peer's public key. 93 * 94 * @param string $plaintextmessage XML envelope containing XMLRPC request and signature 95 * 96 * @return string XMLRPC request 97 */ 98 function mnet_server_strip_signature($plaintextmessage) { 99 $remoteclient = get_mnet_remote_client(); 100 $sig_parser = new mnet_encxml_parser(); 101 $sig_parser->parse($plaintextmessage); 102 103 if ($sig_parser->signature == '') { 104 return $plaintextmessage; 105 } 106 107 // Record that the request was signed in some way 108 $remoteclient->was_signed(); 109 110 // Load any information we have about this mnet peer 111 $remoteclient->set_wwwroot($sig_parser->remote_wwwroot); 112 113 $payload = base64_decode($sig_parser->data_object); 114 $signature = base64_decode($sig_parser->signature); 115 $certificate = $remoteclient->public_key; 116 117 // If we don't have any certificate for the host, don't try to check the signature 118 // Just return the parsed request 119 if ($certificate == false) { 120 return $payload; 121 } 122 123 // Does the signature match the data and the public cert? 124 $signature_verified = openssl_verify($payload, $signature, $certificate); 125 if ($signature_verified == 0) { 126 // $signature was not generated for $payload using $certificate 127 // Get the key the remote peer is currently publishing: 128 $currkey = mnet_get_public_key($remoteclient->wwwroot, $remoteclient->application); 129 // If the key the remote peer is currently publishing is different to $certificate 130 if($currkey != $certificate) { 131 // if pushkey is already set, it means the request was encrypted to an old key 132 // in mnet_server_strip_encryption. 133 // if we call refresh_key() here before pushing out our new key, 134 // and the other site ALSO has a new key, 135 // we'll get into an infinite keyswap loop 136 // so push just bail here, and push out the new key. 137 // the next request will get through to refresh_key 138 if ($remoteclient->pushkey) { 139 return false; 140 } 141 // Try and get the server's new key through trusted means 142 $remoteclient->refresh_key(); 143 // If we did manage to re-key, try to verify the signature again using the new public key. 144 $certificate = $remoteclient->public_key; 145 $signature_verified = openssl_verify($payload, $signature, $certificate); 146 } 147 } 148 149 if ($signature_verified == 1) { 150 $remoteclient->signature_verified(); 151 $remoteclient->touch(); 152 } 153 154 $sig_parser->free_resource(); 155 156 return $payload; 157 } 158 159 /** 160 * Return the proper XML-RPC content to report an error in the local language. 161 * 162 * @param int $code The ID code of the error message 163 * @param string $text The full string of the error message (get_string will <b>not be called</b>) 164 * @param string $param The $a param for the error message in the lang file 165 * @return string $text The text of the error message 166 */ 167 function mnet_server_fault($code, $text, $param = null) { 168 if (!is_numeric($code)) { 169 $code = 0; 170 } 171 $code = intval($code); 172 return mnet_server_fault_xml($code, $text); 173 } 174 175 /** 176 * Return the proper XML-RPC content to report an error. 177 * 178 * @param int $code The ID code of the error message 179 * @param string $text The error message 180 * @param resource $privatekey The private key that should be used to sign the response 181 * @return string $text The XML text of the error message 182 */ 183 function mnet_server_fault_xml($code, $text, $privatekey = null) { 184 global $CFG; 185 // Replace illegal XML chars - is this already in a lib somewhere? 186 $text = str_replace(array('<','>','&','"',"'"), array('<','>','&','"','''), $text); 187 188 $return = mnet_server_prepare_response('<?xml version="1.0"?> 189 <methodResponse> 190 <fault> 191 <value> 192 <struct> 193 <member> 194 <name>faultCode</name> 195 <value><int>'.$code.'</int></value> 196 </member> 197 <member> 198 <name>faultString</name> 199 <value><string>'.$text.'</string></value> 200 </member> 201 </struct> 202 </value> 203 </fault> 204 </methodResponse>', $privatekey); 205 206 if ($code != 7025) { // new key responses 207 mnet_debug("XMLRPC Error Response $code: $text"); 208 //mnet_debug($return); 209 } 210 211 return $return; 212 } 213 214 215 /** 216 * Package a response in any required envelope, and return it to the client 217 * 218 * @param string $response The XMLRPC response string 219 * @param resource $privatekey The private key to sign the response with 220 * @return string The encoded response string 221 */ 222 function mnet_server_prepare_response($response, $privatekey = null) { 223 $remoteclient = get_mnet_remote_client(); 224 if ($remoteclient->request_was_signed) { 225 $response = mnet_sign_message($response, $privatekey); 226 } 227 228 if ($remoteclient->request_was_encrypted) { 229 $response = mnet_encrypt_message($response, $remoteclient->public_key); 230 } 231 232 return $response; 233 } 234 235 /** 236 * If security checks are passed, dispatch the request to the function/method 237 * 238 * The config variable 'mnet_dispatcher_mode' can be: 239 * strict: Only execute functions that are in specific files 240 * off: The default - don't execute anything 241 * 242 * @param string $payload The XML-RPC request 243 * 244 * @throws mnet_server_exception 245 * 246 * @return No return val - just echo the response 247 */ 248 function mnet_server_dispatch($payload) { 249 global $CFG, $DB; 250 $remoteclient = get_mnet_remote_client(); 251 // xmlrpc_decode_request returns an array of parameters, and the $method 252 // variable (which is passed by reference) is instantiated with the value from 253 // the methodName tag in the xml payload 254 // xmlrpc_decode_request($xml, &$method) 255 $params = xmlrpc_decode_request($payload, $method); 256 257 // $method is something like: "mod/forum/lib.php/forum_add_instance" 258 // $params is an array of parameters. A parameter might itself be an array. 259 260 // Check that the method name consists of allowed characters only. 261 // The method name must not begin with a / - avoid absolute paths 262 // A dot character . is only allowed in the filename, i.e. something.php 263 if (0 == preg_match("@^[A-Za-z0-9]+/[A-Za-z0-9/_\.-]+(\.php/)?[A-Za-z0-9_-]+$@",$method)) { 264 throw new mnet_server_exception(713, 'nosuchfunction'); 265 } 266 267 if(preg_match("/^system\./", $method)) { 268 $callstack = explode('.', $method); 269 } else { 270 $callstack = explode('/', $method); 271 // callstack will look like array('mod', 'forum', 'lib.php', 'forum_add_instance'); 272 } 273 274 /** 275 * What has the site administrator chosen as his dispatcher setting? 276 * strict: Only execute functions that are in specific files 277 * off: The default - don't execute anything 278 */ 279 ////////////////////////////////////// OFF 280 if (!isset($CFG->mnet_dispatcher_mode) ) { 281 set_config('mnet_dispatcher_mode', 'off'); 282 throw new mnet_server_exception(704, 'nosuchservice'); 283 } elseif ('off' == $CFG->mnet_dispatcher_mode) { 284 throw new mnet_server_exception(704, 'nosuchservice'); 285 286 ////////////////////////////////////// SYSTEM METHODS 287 } elseif ($callstack[0] == 'system') { 288 $functionname = $callstack[1]; 289 $xmlrpcserver = xmlrpc_server_create(); 290 291 // register all the system methods 292 $systemmethods = array('listMethods', 'methodSignature', 'methodHelp', 'listServices', 'listFiles', 'retrieveFile', 'keyswap'); 293 foreach ($systemmethods as $m) { 294 // I'm adding the canonical xmlrpc references here, however we've 295 // already forbidden that the period (.) should be allowed in the call 296 // stack, so if someone tries to access our XMLRPC in the normal way, 297 // they'll already have received a RPC server fault message. 298 299 // Maybe we should allow an easement so that regular XMLRPC clients can 300 // call our system methods, and find out what we have to offer? 301 $handler = 'mnet_system'; 302 if ($m == 'keyswap') { 303 $handler = 'mnet_keyswap'; 304 } 305 if ($method == 'system.' . $m || $method == 'system/' . $m) { 306 xmlrpc_server_register_method($xmlrpcserver, $method, $handler); 307 $response = xmlrpc_server_call_method($xmlrpcserver, $payload, $remoteclient, array("encoding" => "utf-8")); 308 $response = mnet_server_prepare_response($response); 309 echo $response; 310 xmlrpc_server_destroy($xmlrpcserver); 311 return; 312 } 313 } 314 throw new mnet_server_exception(7018, 'nosuchfunction'); 315 316 //////////////////////////////////// NORMAL PLUGIN DISPATCHER 317 } else { 318 // anything else comes from some sort of plugin 319 if ($rpcrecord = $DB->get_record('mnet_rpc', array('xmlrpcpath' => $method))) { 320 $response = mnet_server_invoke_plugin_method($method, $callstack, $rpcrecord, $payload); 321 $response = mnet_server_prepare_response($response); 322 echo $response; 323 return; 324 // if the rpc record isn't found, check to see if dangerous mode is on 325 ////////////////////////////////////// DANGEROUS 326 } else if ('dangerous' == $CFG->mnet_dispatcher_mode && $remoteclient->plaintext_is_ok()) { 327 $functionname = array_pop($callstack); 328 329 $filename = clean_param(implode('/',$callstack), PARAM_PATH); 330 if (0 == preg_match("/php$/", $filename)) { 331 // Filename doesn't end in 'php'; possible attack? 332 // Generate error response - unable to locate function 333 throw new mnet_server_exception(7012, 'nosuchfunction'); 334 } 335 336 // The call stack holds the path to any include file 337 $includefile = $CFG->dirroot.'/'.$filename; 338 339 $response = mnet_server_invoke_dangerous_method($includefile, $functionname, $method, $payload); 340 echo $response; 341 return; 342 } 343 } 344 throw new mnet_server_exception(7012, 'nosuchfunction'); 345 } 346 347 /** 348 * Execute the system functions - mostly for introspection 349 * 350 * @param string $method XMLRPC method name, e.g. system.listMethods 351 * @param array $params Array of parameters from the XMLRPC request 352 * @param string $hostinfo Hostinfo object from the mnet_host table 353 * 354 * @throws mnet_server_exception 355 * 356 * @return mixed Response data - any kind of PHP variable 357 */ 358 function mnet_system($method, $params, $hostinfo) { 359 global $CFG, $DB; 360 361 if (empty($hostinfo)) return array(); 362 363 $id_list = $hostinfo->id; 364 if (!empty($CFG->mnet_all_hosts_id)) { 365 $id_list .= ', '.$CFG->mnet_all_hosts_id; 366 } 367 368 if ('system.listMethods' == $method || 'system/listMethods' == $method) { 369 $query = ' 370 SELECT DISTINCT 371 rpc.functionname, 372 rpc.xmlrpcpath 373 FROM 374 {mnet_host2service} h2s 375 JOIN {mnet_service2rpc} s2r ON h2s.serviceid = s2r.serviceid 376 JOIN {mnet_rpc} rpc ON s2r.rpcid = rpc.id 377 JOIN {mnet_service} svc ON svc.id = s2r.serviceid 378 WHERE 379 h2s.hostid in ('.$id_list .') AND 380 h2s.publish = 1 AND rpc.enabled = 1 381 ' . ((count($params) > 0) ? 'AND svc.name = ? ' : '') . ' 382 ORDER BY 383 rpc.xmlrpcpath ASC'; 384 if (count($params) > 0) { 385 $params = array($params[0]); 386 } 387 $methods = array(); 388 foreach ($DB->get_records_sql($query, $params) as $result) { 389 $methods[] = $result->xmlrpcpath; 390 } 391 return $methods; 392 } elseif (in_array($method, array('system.methodSignature', 'system/methodSignature', 'system.methodHelp', 'system/methodHelp'))) { 393 $query = ' 394 SELECT DISTINCT 395 rpc.functionname, 396 rpc.help, 397 rpc.profile 398 FROM 399 {mnet_host2service} h2s, 400 {mnet_service2rpc} s2r, 401 {mnet_rpc} rpc 402 WHERE 403 rpc.xmlrpcpath = ? AND 404 s2r.rpcid = rpc.id AND 405 h2s.publish = 1 AND rpc.enabled = 1 AND 406 h2s.serviceid = s2r.serviceid AND 407 h2s.hostid in ('.$id_list .')'; 408 $params = array($params[0]); 409 410 if (!$result = $DB->get_record_sql($query, $params)) { 411 return false; 412 } 413 if (strpos($method, 'methodSignature') !== false) { 414 return unserialize($result->profile); 415 } 416 return $result->help; 417 } elseif ('system.listServices' == $method || 'system/listServices' == $method) { 418 $query = ' 419 SELECT DISTINCT 420 s.id, 421 s.name, 422 s.apiversion, 423 h2s.publish, 424 h2s.subscribe 425 FROM 426 {mnet_host2service} h2s, 427 {mnet_service} s 428 WHERE 429 h2s.serviceid = s.id AND 430 (h2s.publish = 1 OR h2s.subscribe = 1) AND 431 h2s.hostid in ('.$id_list .') 432 ORDER BY 433 s.name ASC'; 434 $params = array(); 435 436 $result = $DB->get_records_sql($query, $params); 437 $services = array(); 438 439 if (is_array($result)) { 440 foreach($result as $service) { 441 $services[] = array('name' => $service->name, 442 'apiversion' => $service->apiversion, 443 'publish' => $service->publish, 444 'subscribe' => $service->subscribe); 445 } 446 } 447 448 return $services; 449 } 450 throw new mnet_server_exception(7019, 'nosuchfunction'); 451 } 452 453 /** 454 * Invoke a normal style plugin method 455 * This will verify permissions first. 456 * 457 * @param string $method the full xmlrpc method that was called eg auth/mnet/auth.php/user_authorise 458 * @param array $callstack the exploded callstack 459 * @param stdclass $rpcrecord the record from mnet_rpc 460 * 461 * @return mixed the response from the invoked method 462 */ 463 function mnet_server_invoke_plugin_method($method, $callstack, $rpcrecord, $payload) { 464 mnet_verify_permissions($rpcrecord); // will throw exceptions 465 mnet_setup_dummy_method($method, $callstack, $rpcrecord); 466 $methodname = array_pop($callstack); 467 468 $xmlrpcserver = xmlrpc_server_create(); 469 xmlrpc_server_register_method($xmlrpcserver, $method, 'mnet_server_dummy_method'); 470 $response = xmlrpc_server_call_method($xmlrpcserver, $payload, $methodname, array("encoding" => "utf-8")); 471 xmlrpc_server_destroy($xmlrpcserver); 472 return $response; 473 } 474 475 /** 476 * Initialize the object (if necessary), execute the method or function, and 477 * return the response 478 * 479 * @param string $includefile The file that contains the object definition 480 * @param string $methodname The name of the method to execute 481 * @param string $method The full path to the method 482 * @param string $payload The XML-RPC request payload 483 * @param string $class The name of the class to instantiate (or false) 484 * 485 * @throws mnet_server_exception 486 * 487 * @return string The XML-RPC response 488 */ 489 function mnet_server_invoke_dangerous_method($includefile, $methodname, $method, $payload) { 490 491 if (file_exists($CFG->dirroot . $includefile)) { 492 require_once $CFG->dirroot . $includefile; 493 // $callprefix matches the rpc convention 494 // of not having a leading slash 495 $callprefix = preg_replace('!^/!', '', $includefile); 496 } else { 497 throw new mnet_server_exception(705, "nosuchfile"); 498 } 499 500 if ($functionname != clean_param($functionname, PARAM_PATH)) { 501 throw new mnet_server_exception(7012, "nosuchfunction"); 502 } 503 504 if (!function_exists($functionname)) { 505 throw new mnet_server_exception(7012, "nosuchfunction"); 506 } 507 $xmlrpcserver = xmlrpc_server_create(); 508 xmlrpc_server_register_method($xmlrpcserver, $method, 'mnet_server_dummy_method'); 509 $response = xmlrpc_server_call_method($xmlrpcserver, $payload, $methodname, array("encoding" => "utf-8")); 510 xmlrpc_server_destroy($xmlrpcserver); 511 return $response; 512 } 513 514 515 /** 516 * Accepts a public key from a new remote host and returns the public key for 517 * this host. If 'register all hosts' is turned on, it will bootstrap a record 518 * for the remote host in the mnet_host table (if it's not already there) 519 * 520 * @param string $function XML-RPC requires this but we don't... discard! 521 * @param array $params Array of parameters 522 * $params[0] is the remote wwwroot 523 * $params[1] is the remote public key 524 * @return string The XML-RPC response 525 */ 526 function mnet_keyswap($function, $params) { 527 global $CFG; 528 $return = array(); 529 $mnet = get_mnet_environment(); 530 531 if (!empty($CFG->mnet_register_allhosts)) { 532 $mnet_peer = new mnet_peer(); 533 list($wwwroot, $pubkey, $application) = $params; 534 $keyok = $mnet_peer->bootstrap($wwwroot, $pubkey, $application); 535 if ($keyok) { 536 $mnet_peer->commit(); 537 } 538 } 539 return $mnet->public_key; 540 } 541 542 /** 543 * Verify that the requested xmlrpc method can be called 544 * This just checks the method exists in the rpc table and is enabled. 545 * 546 * @param stdclass $rpcrecord the record from mnet_rpc 547 * 548 * @throws mnet_server_exception 549 */ 550 function mnet_verify_permissions($rpcrecord) { 551 global $CFG, $DB; 552 $remoteclient = get_mnet_remote_client(); 553 554 $id_list = $remoteclient->id; 555 if (!empty($CFG->mnet_all_hosts_id)) { 556 $id_list .= ', '.$CFG->mnet_all_hosts_id; 557 } 558 559 $sql = "SELECT 560 r.*, h2s.publish 561 FROM 562 {mnet_rpc} r 563 JOIN {mnet_service2rpc} s2r ON s2r.rpcid = r.id 564 LEFT JOIN {mnet_host2service} h2s ON h2s.serviceid = s2r.serviceid 565 WHERE 566 r.id = ? AND 567 h2s.hostid in ($id_list)"; 568 569 $params = array($rpcrecord->id); 570 571 if (!$permission = $DB->get_record_sql($sql, $params)) { 572 throw new mnet_server_exception(7012, "nosuchfunction"); 573 } else if (!$permission->publish || !$permission->enabled) { 574 throw new mnet_server_exception(707, "nosuchfunction"); 575 } 576 } 577 578 /** 579 * Figure out exactly what needs to be called and stashes it in $remoteclient 580 * Does some further verification that the method is callable 581 * 582 * @param string $method the full xmlrpc method that was called eg auth/mnet/auth.php/user_authorise 583 * @param array $callstack the exploded callstack 584 * @param stdclass $rpcrecord the record from mnet_rpc 585 * 586 * @throws mnet_server_exception 587 */ 588 function mnet_setup_dummy_method($method, $callstack, $rpcrecord) { 589 global $CFG; 590 $remoteclient = get_mnet_remote_client(); 591 // verify that the callpath in the stack matches our records 592 // callstack will look like array('mod', 'forum', 'lib.php', 'forum_add_instance'); 593 $path = core_component::get_plugin_directory($rpcrecord->plugintype, $rpcrecord->pluginname); 594 $path = substr($path, strlen($CFG->dirroot)+1); // this is a bit hacky and fragile, it is not guaranteed that plugins are in dirroot 595 array_pop($callstack); 596 $providedpath = implode('/', $callstack); 597 if ($providedpath != $path . '/' . $rpcrecord->filename) { 598 throw new mnet_server_exception(705, "nosuchfile"); 599 } 600 if (!file_exists($CFG->dirroot . '/' . $providedpath)) { 601 throw new mnet_server_exception(705, "nosuchfile"); 602 } 603 require_once($CFG->dirroot . '/' . $providedpath); 604 if (!empty($rpcrecord->classname)) { 605 if (!class_exists($rpcrecord->classname)) { 606 throw new mnet_server_exception(708, 'nosuchclass'); 607 } 608 if (!$rpcrecord->static) { 609 try { 610 $object = new $rpcrecord->classname; 611 } catch (Exception $e) { 612 throw new mnet_server_exception(709, "classerror"); 613 } 614 if (!is_callable(array($object, $rpcrecord->functionname))) { 615 throw new mnet_server_exception(706, "nosuchfunction"); 616 } 617 $remoteclient->object_to_call($object); 618 } else { 619 if (!is_callable(array($rpcrecord->classname, $rpcrecord->functionname))) { 620 throw new mnet_server_exception(706, "nosuchfunction"); 621 } 622 $remoteclient->static_location($rpcrecord->classname); 623 } 624 } 625 } 626 627 /** 628 * Dummy function for the XML-RPC dispatcher - use to call a method on an object 629 * or to call a function 630 * 631 * Translate XML-RPC's strange function call syntax into a more straightforward 632 * PHP-friendly alternative. This dummy function will be called by the 633 * dispatcher, and can be used to call a method on an object, or just a function 634 * 635 * The methodName argument (eg. mnet/testlib/mnet_concatenate_strings) 636 * is ignored. 637 * 638 * @throws mnet_server_exception 639 * 640 * @param string $methodname We discard this - see 'functionname' 641 * @param array $argsarray Each element is an argument to the real 642 * function 643 * @param string $functionname The name of the PHP function you want to call 644 * @return mixed The return value will be that of the real 645 * function, whatever it may be. 646 */ 647 function mnet_server_dummy_method($methodname, $argsarray, $functionname) { 648 $remoteclient = get_mnet_remote_client(); 649 try { 650 if (is_object($remoteclient->object_to_call)) { 651 return @call_user_func_array(array($remoteclient->object_to_call,$functionname), $argsarray); 652 } else if (!empty($remoteclient->static_location)) { 653 return @call_user_func_array(array($remoteclient->static_location, $functionname), $argsarray); 654 } else { 655 return @call_user_func_array($functionname, $argsarray); 656 } 657 } catch (Exception $e) { 658 exit(mnet_server_fault($e->getCode(), $e->getMessage())); 659 } 660 } 661 /** 662 * mnet server exception. extends moodle_exception, but takes slightly different arguments. 663 * and unlike the rest of moodle, the actual int error code is used. 664 * this exception should only be used during an xmlrpc server request, ie, not for client requests. 665 */ 666 class mnet_server_exception extends moodle_exception { 667 668 /** 669 * @param int $intcode the numerical error associated with this fault. this is <b>not</b> the string errorcode 670 * @param string $langkey the error message in full (<b>get_string will not be used</b>) 671 * @param string $module the language module, defaults to 'mnet' 672 * @param mixed $a params for get_string 673 */ 674 public function __construct($intcode, $languagekey, $module='mnet', $a=null) { 675 parent::__construct($languagekey, $module, '', $a); 676 $this->code = $intcode; 677 678 } 679 } 680
title
Description
Body
title
Description
Body
title
Description
Body
title
Body
