4e1ad1d8135d6d5e60686f906c3cb00d10d2cb27
[moodle.git] / mnet / lib.php
1 <?php
2 /**
3  * Library functions for mnet
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  */
10 require_once $CFG->dirroot.'/mnet/xmlrpc/xmlparser.php';
11 require_once $CFG->dirroot.'/mnet/peer.php';
12 require_once $CFG->dirroot.'/mnet/environment.php';
14 /// CONSTANTS ///////////////////////////////////////////////////////////
16 define('RPC_OK',                0);
17 define('RPC_NOSUCHFILE',        1);
18 define('RPC_NOSUCHCLASS',       2);
19 define('RPC_NOSUCHFUNCTION',    3);
20 define('RPC_FORBIDDENFUNCTION', 4);
21 define('RPC_NOSUCHMETHOD',      5);
22 define('RPC_FORBIDDENMETHOD',   6);
24 /**
25  * Strip extraneous detail from a URL or URI and return the hostname
26  *
27  * @param  string  $uri  The URI of a file on the remote computer, optionally
28  *                       including its http:// prefix like
29  *                       http://www.example.com/index.html
30  * @return string        Just the hostname
31  */
32 function mnet_get_hostname_from_uri($uri = null) {
33     $count = preg_match("@^(?:http[s]?://)?([A-Z0-9\-\.]+).*@i", $uri, $matches);
34     if ($count > 0) return $matches[1];
35     return false;
36 }
38 /**
39  * Get the remote machine's SSL Cert
40  *
41  * @param  string  $uri     The URI of a file on the remote computer, including
42  *                          its http:// or https:// prefix
43  * @return string           A PEM formatted SSL Certificate.
44  */
45 function mnet_get_public_key($uri, $application=null) {
46     global $CFG, $DB;
47     $mnet = get_mnet_environment();
48     // The key may be cached in the mnet_set_public_key function...
49     // check this first
50     $key = mnet_set_public_key($uri);
51     if ($key != false) {
52         return $key;
53     }
55     if (empty($application)) {
56         $application = $DB->get_record('mnet_application', array('name'=>'moodle'));
57     }
59     $rq = xmlrpc_encode_request('system/keyswap', array($CFG->wwwroot, $mnet->public_key, $application->name), array("encoding" => "utf-8"));
60     $ch = curl_init($uri . $application->xmlrpc_server_url);
62     curl_setopt($ch, CURLOPT_TIMEOUT, 60);
63     curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
64     curl_setopt($ch, CURLOPT_POST, true);
65     curl_setopt($ch, CURLOPT_USERAGENT, 'Moodle');
66     curl_setopt($ch, CURLOPT_POSTFIELDS, $rq);
67     curl_setopt($ch, CURLOPT_HTTPHEADER, array("Content-Type: text/xml charset=UTF-8"));
68     curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
69     curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 0);
71     // check for proxy
72     if (!empty($CFG->proxyhost) and !is_proxybypass($uri)) {
73         // SOCKS supported in PHP5 only
74         if (!empty($CFG->proxytype) and ($CFG->proxytype == 'SOCKS5')) {
75             if (defined('CURLPROXY_SOCKS5')) {
76                 curl_setopt($ch, CURLOPT_PROXYTYPE, CURLPROXY_SOCKS5);
77             } else {
78                 curl_close($ch);
79                 print_error( 'socksnotsupported','mnet' );
80             }
81         }
83         curl_setopt($ch, CURLOPT_HTTPPROXYTUNNEL, false);
85         if (empty($CFG->proxyport)) {
86             curl_setopt($ch, CURLOPT_PROXY, $CFG->proxyhost);
87         } else {
88             curl_setopt($ch, CURLOPT_PROXY, $CFG->proxyhost.':'.$CFG->proxyport);
89         }
91         if (!empty($CFG->proxyuser) and !empty($CFG->proxypassword)) {
92             curl_setopt($ch, CURLOPT_PROXYUSERPWD, $CFG->proxyuser.':'.$CFG->proxypassword);
93             if (defined('CURLOPT_PROXYAUTH')) {
94                 // any proxy authentication if PHP 5.1
95                 curl_setopt($ch, CURLOPT_PROXYAUTH, CURLAUTH_BASIC | CURLAUTH_NTLM);
96             }
97         }
98     }
100     $res = xmlrpc_decode(curl_exec($ch));
102     // check for curl errors
103     $curlerrno = curl_errno($ch);
104     if ($curlerrno!=0) {
105         debugging("Request for $uri failed with curl error $curlerrno");
106     }
108     // check HTTP error code
109     $info =  curl_getinfo($ch);
110     if (!empty($info['http_code']) and ($info['http_code'] != 200)) {
111         debugging("Request for $uri failed with HTTP code ".$info['http_code']);
112     }
114     curl_close($ch);
116     if (!is_array($res)) { // ! error
117         $public_certificate = $res;
118         $credentials=array();
119         if (strlen(trim($public_certificate))) {
120             $credentials = openssl_x509_parse($public_certificate);
121             $host = $credentials['subject']['CN'];
122             if (array_key_exists( 'subjectAltName', $credentials['subject'])) {
123                 $host = $credentials['subject']['subjectAltName'];
124             }
125             if (strpos($uri, $host) !== false) {
126                 mnet_set_public_key($uri, $public_certificate);
127                 return $public_certificate;
128             }
129             else {
130                 debugging("Request for $uri returned public key for different URI - $host");
131             }
132         }
133         else {
134             debugging("Request for $uri returned empty response");
135         }
136     }
137     else {
138         debugging( "Request for $uri returned unexpected result");
139     }
140     return false;
143 /**
144  * Store a URI's public key in a static variable, or retrieve the key for a URI
145  *
146  * @param  string  $uri  The URI of a file on the remote computer, including its
147  *                       https:// prefix
148  * @param  mixed   $key  A public key to store in the array OR null. If the key
149  *                       is null, the function will return the previously stored
150  *                       key for the supplied URI, should it exist.
151  * @return mixed         A public key OR true/false.
152  */
153 function mnet_set_public_key($uri, $key = null) {
154     static $keyarray = array();
155     if (isset($keyarray[$uri]) && empty($key)) {
156         return $keyarray[$uri];
157     } elseif (!empty($key)) {
158         $keyarray[$uri] = $key;
159         return true;
160     }
161     return false;
164 /**
165  * Sign a message and return it in an XML-Signature document
166  *
167  * This function can sign any content, but it was written to provide a system of
168  * signing XML-RPC request and response messages. The message will be base64
169  * encoded, so it does not need to be text.
170  *
171  * We compute the SHA1 digest of the message.
172  * We compute a signature on that digest with our private key.
173  * We link to the public key that can be used to verify our signature.
174  * We base64 the message data.
175  * We identify our wwwroot - this must match our certificate's CN
176  *
177  * The XML-RPC document will be parceled inside an XML-SIG document, which holds
178  * the base64_encoded XML as an object, the SHA1 digest of that document, and a
179  * signature of that document using the local private key. This signature will
180  * uniquely identify the RPC document as having come from this server.
181  *
182  * See the {@Link http://www.w3.org/TR/xmldsig-core/ XML-DSig spec} at the W3c
183  * site
184  *
185  * @param  string   $message              The data you want to sign
186  * @param  resource $privatekey           The private key to sign the response with
187  * @return string                         An XML-DSig document
188  */
189 function mnet_sign_message($message, $privatekey = null) {
190     global $CFG;
191     $digest = sha1($message);
193     $mnet = get_mnet_environment();
194     // If the user hasn't supplied a private key (for example, one of our older,
195     //  expired private keys, we get the current default private key and use that.
196     if ($privatekey == null) {
197         $privatekey = $mnet->get_private_key();
198     }
200     // The '$sig' value below is returned by reference.
201     // We initialize it first to stop my IDE from complaining.
202     $sig  = '';
203     $bool = openssl_sign($message, $sig, $privatekey); // TODO: On failure?
205     $message = '<?xml version="1.0" encoding="iso-8859-1"?>
206     <signedMessage>
207         <Signature Id="MoodleSignature" xmlns="http://www.w3.org/2000/09/xmldsig#">
208             <SignedInfo>
209                 <CanonicalizationMethod Algorithm="http://www.w3.org/TR/2001/REC-xml-c14n-20010315"/>
210                 <SignatureMethod Algorithm="http://www.w3.org/2000/09/xmldsig#rsa-sha1"/>
211                 <Reference URI="#XMLRPC-MSG">
212                     <DigestMethod Algorithm="http://www.w3.org/2000/09/xmldsig#sha1"/>
213                     <DigestValue>'.$digest.'</DigestValue>
214                 </Reference>
215             </SignedInfo>
216             <SignatureValue>'.base64_encode($sig).'</SignatureValue>
217             <KeyInfo>
218                 <RetrievalMethod URI="'.$CFG->wwwroot.'/mnet/publickey.php"/>
219             </KeyInfo>
220         </Signature>
221         <object ID="XMLRPC-MSG">'.base64_encode($message).'</object>
222         <wwwroot>'.$mnet->wwwroot.'</wwwroot>
223         <timestamp>'.time().'</timestamp>
224     </signedMessage>';
225     return $message;
228 /**
229  * Encrypt a message and return it in an XML-Encrypted document
230  *
231  * This function can encrypt any content, but it was written to provide a system
232  * of encrypting XML-RPC request and response messages. The message will be
233  * base64 encoded, so it does not need to be text - binary data should work.
234  *
235  * We compute the SHA1 digest of the message.
236  * We compute a signature on that digest with our private key.
237  * We link to the public key that can be used to verify our signature.
238  * We base64 the message data.
239  * We identify our wwwroot - this must match our certificate's CN
240  *
241  * The XML-RPC document will be parceled inside an XML-SIG document, which holds
242  * the base64_encoded XML as an object, the SHA1 digest of that document, and a
243  * signature of that document using the local private key. This signature will
244  * uniquely identify the RPC document as having come from this server.
245  *
246  * See the {@Link http://www.w3.org/TR/xmlenc-core/ XML-ENC spec} at the W3c
247  * site
248  *
249  * @param  string   $message              The data you want to sign
250  * @param  string   $remote_certificate   Peer's certificate in PEM format
251  * @return string                         An XML-ENC document
252  */
253 function mnet_encrypt_message($message, $remote_certificate) {
254     $mnet = get_mnet_environment();
256     // Generate a key resource from the remote_certificate text string
257     $publickey = openssl_get_publickey($remote_certificate);
259     if ( gettype($publickey) != 'resource' ) {
260         // Remote certificate is faulty.
261         return false;
262     }
264     // Initialize vars
265     $encryptedstring = '';
266     $symmetric_keys = array();
268     //        passed by ref ->     &$encryptedstring &$symmetric_keys
269     $bool = openssl_seal($message, $encryptedstring, $symmetric_keys, array($publickey));
270     $message = $encryptedstring;
271     $symmetrickey = array_pop($symmetric_keys);
273     $message = '<?xml version="1.0" encoding="iso-8859-1"?>
274     <encryptedMessage>
275         <EncryptedData Id="ED" xmlns="http://www.w3.org/2001/04/xmlenc#">
276             <EncryptionMethod Algorithm="http://www.w3.org/2001/04/xmlenc#arcfour"/>
277             <ds:KeyInfo xmlns:ds="http://www.w3.org/2000/09/xmldsig#">
278                 <ds:RetrievalMethod URI="#EK" Type="http://www.w3.org/2001/04/xmlenc#EncryptedKey"/>
279                 <ds:KeyName>XMLENC</ds:KeyName>
280             </ds:KeyInfo>
281             <CipherData>
282                 <CipherValue>'.base64_encode($message).'</CipherValue>
283             </CipherData>
284         </EncryptedData>
285         <EncryptedKey Id="EK" xmlns="http://www.w3.org/2001/04/xmlenc#">
286             <EncryptionMethod Algorithm="http://www.w3.org/2001/04/xmlenc#rsa-1_5"/>
287             <ds:KeyInfo xmlns:ds="http://www.w3.org/2000/09/xmldsig#">
288                 <ds:KeyName>SSLKEY</ds:KeyName>
289             </ds:KeyInfo>
290             <CipherData>
291                 <CipherValue>'.base64_encode($symmetrickey).'</CipherValue>
292             </CipherData>
293             <ReferenceList>
294                 <DataReference URI="#ED"/>
295             </ReferenceList>
296             <CarriedKeyName>XMLENC</CarriedKeyName>
297         </EncryptedKey>
298         <wwwroot>'.$mnet->wwwroot.'</wwwroot>
299     </encryptedMessage>';
300     return $message;
303 /**
304  * Get your SSL keys from the database, or create them (if they don't exist yet)
305  *
306  * Get your SSL keys from the database, or (if they don't exist yet) call
307  * mnet_generate_keypair to create them
308  *
309  * @param   string  $string     The text you want to sign
310  * @return  string              The signature over that text
311  */
312 function mnet_get_keypair() {
313     global $CFG, $DB;
314     static $keypair = null;
315     if (!is_null($keypair)) return $keypair;
316     if ($result = get_config('mnet', 'openssl')) {
317         list($keypair['certificate'], $keypair['keypair_PEM']) = explode('@@@@@@@@', $result);
318         $keypair['privatekey'] = openssl_pkey_get_private($keypair['keypair_PEM']);
319         $keypair['publickey']  = openssl_pkey_get_public($keypair['certificate']);
320         return $keypair;
321     } else {
322         $keypair = mnet_generate_keypair();
323         return $keypair;
324     }
327 /**
328  * Generate public/private keys and store in the config table
329  *
330  * Use the distinguished name provided to create a CSR, and then sign that CSR
331  * with the same credentials. Store the keypair you create in the config table.
332  * If a distinguished name is not provided, create one using the fullname of
333  * 'the course with ID 1' as your organization name, and your hostname (as
334  * detailed in $CFG->wwwroot).
335  *
336  * @param   array  $dn  The distinguished name of the server
337  * @return  string      The signature over that text
338  */
339 function mnet_generate_keypair($dn = null, $days=28) {
340     global $CFG, $USER, $DB;
342     // check if lifetime has been overriden
343     if (!empty($CFG->mnetkeylifetime)) {
344         $days = $CFG->mnetkeylifetime;
345     }
347     $host = strtolower($CFG->wwwroot);
348     $host = preg_replace("~^http(s)?://~",'',$host);
349     $break = strpos($host.'/' , '/');
350     $host   = substr($host, 0, $break);
352     $site = get_site();
353     $organization = $site->fullname;
355     $keypair = array();
357     $country  = 'NZ';
358     $province = 'Wellington';
359     $locality = 'Wellington';
360     $email    = !empty($CFG->noreplyaddress) ? $CFG->noreplyaddress : 'noreply@'.$_SERVER['HTTP_HOST'];
362     if(!empty($USER->country)) {
363         $country  = $USER->country;
364     }
365     if(!empty($USER->city)) {
366         $province = $USER->city;
367         $locality = $USER->city;
368     }
369     if(!empty($USER->email)) {
370         $email    = $USER->email;
371     }
373     if (is_null($dn)) {
374         $dn = array(
375            "countryName" => $country,
376            "stateOrProvinceName" => $province,
377            "localityName" => $locality,
378            "organizationName" => $organization,
379            "organizationalUnitName" => 'Moodle',
380            "commonName" => substr($CFG->wwwroot, 0, 64),
381            "subjectAltName" => $CFG->wwwroot,
382            "emailAddress" => $email
383         );
384     }
386     $dnlimits = array(
387            'countryName'            => 2,
388            'stateOrProvinceName'    => 128,
389            'localityName'           => 128,
390            'organizationName'       => 64,
391            'organizationalUnitName' => 64,
392            'commonName'             => 64,
393            'emailAddress'           => 128
394     );
396     foreach ($dnlimits as $key => $length) {
397         $dn[$key] = substr($dn[$key], 0, $length);
398     }
400     // ensure we remove trailing slashes
401     $dn["commonName"] = preg_replace(':/$:', '', $dn["commonName"]);
402     if (!empty($CFG->opensslcnf)) { //allow specification of openssl.cnf especially for Windows installs
403         $new_key = openssl_pkey_new(array("config" => $CFG->opensslcnf));
404     } else {
405         $new_key = openssl_pkey_new();
406     }
407     if ($new_key === false) {
408         // can not generate keys - missing openssl.cnf??
409         return null;
410     }
411     if (!empty($CFG->opensslcnf)) { //allow specification of openssl.cnf especially for Windows installs
412         $csr_rsc = openssl_csr_new($dn, $new_key, array("config" => $CFG->opensslcnf));
413         $selfSignedCert = openssl_csr_sign($csr_rsc, null, $new_key, $days, array("config" => $CFG->opensslcnf));
414     } else {
415         $csr_rsc = openssl_csr_new($dn, $new_key, array('private_key_bits',2048));
416         $selfSignedCert = openssl_csr_sign($csr_rsc, null, $new_key, $days);
417     }
418     unset($csr_rsc); // Free up the resource
420     // We export our self-signed certificate to a string.
421     openssl_x509_export($selfSignedCert, $keypair['certificate']);
422     openssl_x509_free($selfSignedCert);
424     // Export your public/private key pair as a PEM encoded string. You
425     // can protect it with an optional passphrase if you wish.
426     if (!empty($CFG->opensslcnf)) { //allow specification of openssl.cnf especially for Windows installs
427         $export = openssl_pkey_export($new_key, $keypair['keypair_PEM'], null, array("config" => $CFG->opensslcnf));
428     } else {
429         $export = openssl_pkey_export($new_key, $keypair['keypair_PEM'] /* , $passphrase */);
430     }
431     openssl_pkey_free($new_key);
432     unset($new_key); // Free up the resource
434     return $keypair;
438 function mnet_update_sso_access_control($username, $mnet_host_id, $accessctrl) {
439     global $DB;
441     $mnethost = $DB->get_record('mnet_host', array('id'=>$mnet_host_id));
442     if ($aclrecord = $DB->get_record('mnet_sso_access_control', array('username'=>$username, 'mnet_host_id'=>$mnet_host_id))) {
443         // Update.
444         $aclrecord->accessctrl = $accessctrl;
445         $DB->update_record('mnet_sso_access_control', $aclrecord);
447         // Trigger access control updated event.
448         $params = array(
449             'objectid' => $aclrecord->id,
450             'context' => context_system::instance()
451         );
452         $event = \core\event\mnet_access_control_updated::create($params);
453         $event->add_record_snapshot('mnet_host', $mnethost);
454         $event->trigger();
455     } else {
456         // Insert.
457         $aclrecord = new stdClass();
458         $aclrecord->username = $username;
459         $aclrecord->accessctrl = $accessctrl;
460         $aclrecord->mnet_host_id = $mnet_host_id;
461         $aclrecord->id = $DB->insert_record('mnet_sso_access_control', $aclrecord);
463         // Trigger access control created event.
464         $params = array(
465             'objectid' => $aclrecord->id,
466             'context' => context_system::instance()
467         );
468         $event = \core\event\mnet_access_control_created::create($params);
469         $event->add_record_snapshot('mnet_host', $mnethost);
470         $event->trigger();
471     }
472     return true;
475 function mnet_get_peer_host ($mnethostid) {
476     global $DB;
477     static $hosts;
478     if (!isset($hosts[$mnethostid])) {
479         $host = $DB->get_record('mnet_host', array('id' => $mnethostid));
480         $hosts[$mnethostid] = $host;
481     }
482     return $hosts[$mnethostid];
485 /**
486  * Inline function to modify a url string so that mnet users are requested to
487  * log in at their mnet identity provider (if they are not already logged in)
488  * before ultimately being directed to the original url.
489  *
490  * @param string $jumpurl the url which user should initially be directed to.
491  *     This is a URL associated with a moodle networking peer when it
492  *     is fulfiling a role as an identity provider (IDP). Different urls for
493  *     different peers, the jumpurl is formed partly from the IDP's webroot, and
494  *     partly from a predefined local path within that webwroot.
495  *     The result of the user hitting this jump url is that they will be asked
496  *     to login (at their identity provider (if they aren't already)), mnet
497  *     will prepare the necessary authentication information, then redirect
498  *     them back to somewhere at the content provider(CP) moodle (this moodle)
499  * @param array $url array with 2 elements
500  *     0 - context the url was taken from, possibly just the url, possibly href="url"
501  *     1 - the destination url
502  * @return string the url the remote user should be supplied with.
503  */
504 function mnet_sso_apply_indirection ($jumpurl, $url) {
505     global $USER, $CFG;
507     $localpart='';
508     $urlparts = parse_url($url[1]);
509     if($urlparts) {
510         if (isset($urlparts['path'])) {
511             $path = $urlparts['path'];
512             // if our wwwroot has a path component, need to strip that path from beginning of the
513             // 'localpart' to make it relative to moodle's wwwroot
514             $wwwrootpath = parse_url($CFG->wwwroot, PHP_URL_PATH);
515             if (!empty($wwwrootpath) and strpos($path, $wwwrootpath) === 0) {
516                 $path = substr($path, strlen($wwwrootpath));
517             }
518             $localpart .= $path;
519         }
520         if (isset($urlparts['query'])) {
521             $localpart .= '?'.$urlparts['query'];
522         }
523         if (isset($urlparts['fragment'])) {
524             $localpart .= '#'.$urlparts['fragment'];
525         }
526     }
527     $indirecturl = $jumpurl . urlencode($localpart);
528     //If we matched on more than just a url (ie an html link), return the url to an href format
529     if ($url[0] != $url[1]) {
530         $indirecturl = 'href="'.$indirecturl.'"';
531     }
532     return $indirecturl;
535 function mnet_get_app_jumppath ($applicationid) {
536     global $DB;
537     static $appjumppaths;
538     if (!isset($appjumppaths[$applicationid])) {
539         $ssojumpurl = $DB->get_field('mnet_application', 'sso_jump_url', array('id' => $applicationid));
540         $appjumppaths[$applicationid] = $ssojumpurl;
541     }
542     return $appjumppaths[$applicationid];
546 /**
547  * Output debug information about mnet.  this will go to the <b>error_log</b>.
548  *
549  * @param mixed $debugdata this can be a string, or array or object.
550  * @param int   $debuglevel optional , defaults to 1. bump up for very noisy debug info
551  */
552 function mnet_debug($debugdata, $debuglevel=1) {
553     global $CFG;
554     $setlevel = get_config('', 'mnet_rpcdebug');
555     if (empty($setlevel) || $setlevel < $debuglevel) {
556         return;
557     }
558     if (is_object($debugdata)) {
559         $debugdata = (array)$debugdata;
560     }
561     if (is_array($debugdata)) {
562         mnet_debug('DUMPING ARRAY');
563         foreach ($debugdata as $key => $value) {
564             mnet_debug("$key: $value");
565         }
566         mnet_debug('END DUMPING ARRAY');
567         return;
568     }
569     $prefix = 'MNET DEBUG ';
570     if (defined('MNET_SERVER')) {
571         $prefix .= " (server $CFG->wwwroot";
572         if ($peer = get_mnet_remote_client() && !empty($peer->wwwroot)) {
573             $prefix .= ", remote peer " . $peer->wwwroot;
574         }
575         $prefix .= ')';
576     } else {
577         $prefix .= " (client $CFG->wwwroot) ";
578     }
579     error_log("$prefix $debugdata");
582 /**
583  * Return an array of information about all moodle's profile fields
584  * which ones are optional, which ones are forced.
585  * This is used as the basis of providing lists of profile fields to the administrator
586  * to pick which fields to import/export over MNET
587  *
588  * @return array(forced => array, optional => array)
589  */
590 function mnet_profile_field_options() {
591     global $DB;
592     static $info;
593     if (!empty($info)) {
594         return $info;
595     }
597     $excludes = array(
598         'id',              // makes no sense
599         'mnethostid',      // makes no sense
600         'timecreated',     // will be set to relative to the host anyway
601         'timemodified',    // will be set to relative to the host anyway
602         'auth',            // going to be set to 'mnet'
603         'deleted',         // we should never get deleted users sent over, but don't send this anyway
604         'confirmed',       // unconfirmed users can't log in to their home site, all remote users considered confirmed
605         'password',        // no password for mnet users
606         'theme',           // handled separately
607         'lastip',          // will be set to relative to the host anyway
608     );
610     // these are the ones that user_not_fully_set_up will complain about
611     // and also special case ones
612     $forced = array(
613         'username',
614         'email',
615         'firstname',
616         'lastname',
617         'auth',
618         'wwwroot',
619         'session.gc_lifetime',
620         '_mnet_userpicture_timemodified',
621         '_mnet_userpicture_mimetype',
622     );
624     // these are the ones we used to send/receive (pre 2.0)
625     $legacy = array(
626         'username',
627         'email',
628         'auth',
629         'deleted',
630         'firstname',
631         'lastname',
632         'city',
633         'country',
634         'lang',
635         'timezone',
636         'description',
637         'mailformat',
638         'maildigest',
639         'maildisplay',
640         'htmleditor',
641         'wwwroot',
642         'picture',
643     );
645     // get a random user record from the database to pull the fields off
646     $randomuser = $DB->get_record('user', array(), '*', IGNORE_MULTIPLE);
647     foreach ($randomuser as $key => $discard) {
648         if (in_array($key, $excludes) || in_array($key, $forced)) {
649             continue;
650         }
651         $fields[$key] = $key;
652     }
653     $info = array(
654         'forced'   => $forced,
655         'optional' => $fields,
656         'legacy'   => $legacy,
657     );
658     return $info;
662 /**
663  * Returns information about MNet peers
664  *
665  * @param bool $withdeleted should the deleted peers be returned too
666  * @return array
667  */
668 function mnet_get_hosts($withdeleted = false) {
669     global $CFG, $DB;
671     $sql = "SELECT h.id, h.deleted, h.wwwroot, h.ip_address, h.name, h.public_key, h.public_key_expires,
672                    h.transport, h.portno, h.last_connect_time, h.last_log_id, h.applicationid,
673                    a.name as app_name, a.display_name as app_display_name, a.xmlrpc_server_url
674               FROM {mnet_host} h
675               JOIN {mnet_application} a ON h.applicationid = a.id
676              WHERE h.id <> ?";
678     if (!$withdeleted) {
679         $sql .= "  AND h.deleted = 0";
680     }
682     $sql .= " ORDER BY h.deleted, h.name, h.id";
684     return $DB->get_records_sql($sql, array($CFG->mnet_localhost_id));
688 /**
689  * return an array information about services enabled for the given peer.
690  * in two modes, fulldata or very basic data.
691  *
692  * @param mnet_peer $mnet_peer the peer to get information abut
693  * @param boolean   $fulldata whether to just return which services are published/subscribed, or more information (defaults to full)
694  *
695  * @return array  If $fulldata is false, an array is returned like:
696  *                publish => array(
697  *                    serviceid => boolean,
698  *                    serviceid => boolean,
699  *                ),
700  *                subscribe => array(
701  *                    serviceid => boolean,
702  *                    serviceid => boolean,
703  *                )
704  *                If $fulldata is true, an array is returned like:
705  *                servicename => array(
706  *                   apiversion => array(
707  *                        name           => string
708  *                        offer          => boolean
709  *                        apiversion     => int
710  *                        plugintype     => string
711  *                        pluginname     => string
712  *                        hostsubscribes => boolean
713  *                        hostpublishes  => boolean
714  *                   ),
715  *               )
716  */
717 function mnet_get_service_info(mnet_peer $mnet_peer, $fulldata=true) {
718     global $CFG, $DB;
720     $requestkey = (!empty($fulldata) ? 'fulldata' : 'mydata');
722     static $cache = array();
723     if (array_key_exists($mnet_peer->id, $cache)) {
724         return $cache[$mnet_peer->id][$requestkey];
725     }
727     $id_list = $mnet_peer->id;
728     if (!empty($CFG->mnet_all_hosts_id)) {
729         $id_list .= ', '.$CFG->mnet_all_hosts_id;
730     }
732     $concat = $DB->sql_concat('COALESCE(h2s.id,0) ', ' \'-\' ', ' svc.id', '\'-\'', 'r.plugintype', '\'-\'', 'r.pluginname');
734     $query = "
735         SELECT DISTINCT
736             $concat as id,
737             svc.id as serviceid,
738             svc.name,
739             svc.offer,
740             svc.apiversion,
741             r.plugintype,
742             r.pluginname,
743             h2s.hostid,
744             h2s.publish,
745             h2s.subscribe
746         FROM
747             {mnet_service2rpc} s2r,
748             {mnet_rpc} r,
749             {mnet_service} svc
750         LEFT JOIN
751             {mnet_host2service} h2s
752         ON
753             h2s.hostid in ($id_list) AND
754             h2s.serviceid = svc.id
755         WHERE
756             svc.offer = '1' AND
757             s2r.serviceid = svc.id AND
758             s2r.rpcid = r.id
759         ORDER BY
760             svc.name ASC";
762     $resultset = $DB->get_records_sql($query);
764     if (is_array($resultset)) {
765         $resultset = array_values($resultset);
766     } else {
767         $resultset = array();
768     }
770     require_once $CFG->dirroot.'/mnet/xmlrpc/client.php';
772     $remoteservices = array();
773     if ($mnet_peer->id != $CFG->mnet_all_hosts_id) {
774         // Create a new request object
775         $mnet_request = new mnet_xmlrpc_client();
777         // Tell it the path to the method that we want to execute
778         $mnet_request->set_method('system/listServices');
779         $mnet_request->send($mnet_peer);
780         if (is_array($mnet_request->response)) {
781             foreach($mnet_request->response as $service) {
782                 $remoteservices[$service['name']][$service['apiversion']] = $service;
783             }
784         }
785     }
787     $myservices = array();
788     $mydata = array();
789     foreach($resultset as $result) {
790         $result->hostpublishes  = false;
791         $result->hostsubscribes = false;
792         if (isset($remoteservices[$result->name][$result->apiversion])) {
793             if ($remoteservices[$result->name][$result->apiversion]['publish'] == 1) {
794                 $result->hostpublishes  = true;
795             }
796             if ($remoteservices[$result->name][$result->apiversion]['subscribe'] == 1) {
797                 $result->hostsubscribes  = true;
798             }
799         }
801         if (empty($myservices[$result->name][$result->apiversion])) {
802             $myservices[$result->name][$result->apiversion] = array('serviceid' => $result->serviceid,
803                                                                     'name' => $result->name,
804                                                                     'offer' => $result->offer,
805                                                                     'apiversion' => $result->apiversion,
806                                                                     'plugintype' => $result->plugintype,
807                                                                     'pluginname' => $result->pluginname,
808                                                                     'hostsubscribes' => $result->hostsubscribes,
809                                                                     'hostpublishes' => $result->hostpublishes
810                                                                     );
811         }
813         // allhosts_publish allows us to tell the admin that even though he
814         // is disabling a service, it's still available to the host because
815         // he's also publishing it to 'all hosts'
816         if ($result->hostid == $CFG->mnet_all_hosts_id && $CFG->mnet_all_hosts_id != $mnet_peer->id) {
817             $myservices[$result->name][$result->apiversion]['allhosts_publish'] = $result->publish;
818             $myservices[$result->name][$result->apiversion]['allhosts_subscribe'] = $result->subscribe;
819         } elseif (!empty($result->hostid)) {
820             $myservices[$result->name][$result->apiversion]['I_publish'] = $result->publish;
821             $myservices[$result->name][$result->apiversion]['I_subscribe'] = $result->subscribe;
822         }
823         $mydata['publish'][$result->serviceid] = $result->publish;
824         $mydata['subscribe'][$result->serviceid] = $result->subscribe;
826     }
828     $cache[$mnet_peer->id]['fulldata'] = $myservices;
829     $cache[$mnet_peer->id]['mydata'] = $mydata;
831     return $cache[$mnet_peer->id][$requestkey];
834 /**
835  * return an array of the profile fields to send
836  * with user information to the given mnet host.
837  *
838  * @param mnet_peer $peer the peer to send the information to
839  *
840  * @return array (like 'username', 'firstname', etc)
841  */
842 function mnet_fields_to_send(mnet_peer $peer) {
843     return _mnet_field_helper($peer, 'export');
846 /**
847  * return an array of the profile fields to import
848  * from the given host, when creating/updating user accounts
849  *
850  * @param mnet_peer $peer the peer we're getting the information from
851  *
852  * @return array (like 'username', 'firstname', etc)
853  */
854 function mnet_fields_to_import(mnet_peer $peer) {
855     return _mnet_field_helper($peer, 'import');
858 /**
859  * helper for {@see mnet_fields_to_import} and {@mnet_fields_to_send}
860  *
861  * @access private
862  *
863  * @param mnet_peer $peer the peer object
864  * @param string    $key 'import' or 'export'
865  *
866  * @return array (like 'username', 'firstname', etc)
867  */
868 function _mnet_field_helper(mnet_peer $peer, $key) {
869     $tmp = mnet_profile_field_options();
870     $defaults = explode(',', get_config('moodle', 'mnetprofile' . $key . 'fields'));
871     if ('1' === get_config('mnet', 'host' . $peer->id . $key . 'default')) {
872         return array_merge($tmp['forced'], $defaults);
873     }
874     $hostsettings = get_config('mnet', 'host' . $peer->id . $key . 'fields');
875     if (false === $hostsettings) {
876         return array_merge($tmp['forced'], $defaults);
877     }
878     return array_merge($tmp['forced'], explode(',', $hostsettings));
882 /**
883  * given a user object (or array) and a list of allowed fields,
884  * strip out all the fields that should not be included.
885  * This can be used both for outgoing data and incoming data.
886  *
887  * @param mixed $user array or object representing a database record
888  * @param array $fields an array of allowed fields (usually from mnet_fields_to_{send,import}
889  *
890  * @return mixed array or object, depending what type of $user object was passed (datatype is respected)
891  */
892 function mnet_strip_user($user, $fields) {
893     if (is_object($user)) {
894         $user = (array)$user;
895         $wasobject = true; // so we can cast back before we return
896     }
898     foreach ($user as $key => $value) {
899         if (!in_array($key, $fields)) {
900             unset($user[$key]);
901         }
902     }
903     if (!empty($wasobject)) {
904         $user = (object)$user;
905     }
906     return $user;