Merge branch 'MDL-34742-23' of git://github.com/FMCorz/moodle into MOODLE_23_STABLE
[moodle.git] / auth / ldap / auth.php
1 <?php
3 /**
4  * @author Martin Dougiamas
5  * @author I´┐Żaki Arenaza
6  * @license http://www.gnu.org/copyleft/gpl.html GNU Public License
7  * @package moodle multiauth
8  *
9  * Authentication Plugin: LDAP Authentication
10  *
11  * Authentication using LDAP (Lightweight Directory Access Protocol).
12  *
13  * 2006-08-28  File created.
14  */
16 if (!defined('MOODLE_INTERNAL')) {
17     die('Direct access to this script is forbidden.');    ///  It must be included from a Moodle page
18 }
20 // See http://support.microsoft.com/kb/305144 to interprete these values.
21 if (!defined('AUTH_AD_ACCOUNTDISABLE')) {
22     define('AUTH_AD_ACCOUNTDISABLE', 0x0002);
23 }
24 if (!defined('AUTH_AD_NORMAL_ACCOUNT')) {
25     define('AUTH_AD_NORMAL_ACCOUNT', 0x0200);
26 }
27 if (!defined('AUTH_NTLMTIMEOUT')) {  // timewindow for the NTLM SSO process, in secs...
28     define('AUTH_NTLMTIMEOUT', 10);
29 }
31 // UF_DONT_EXPIRE_PASSWD value taken from MSDN directly
32 if (!defined('UF_DONT_EXPIRE_PASSWD')) {
33     define ('UF_DONT_EXPIRE_PASSWD', 0x00010000);
34 }
36 // The Posix uid and gid of the 'nobody' account and 'nogroup' group.
37 if (!defined('AUTH_UID_NOBODY')) {
38     define('AUTH_UID_NOBODY', -2);
39 }
40 if (!defined('AUTH_GID_NOGROUP')) {
41     define('AUTH_GID_NOGROUP', -2);
42 }
44 require_once($CFG->libdir.'/authlib.php');
45 require_once($CFG->libdir.'/ldaplib.php');
47 /**
48  * LDAP authentication plugin.
49  */
50 class auth_plugin_ldap extends auth_plugin_base {
52     /**
53      * Init plugin config from database settings depending on the plugin auth type.
54      */
55     function init_plugin($authtype) {
56         $this->pluginconfig = 'auth/'.$authtype;
57         $this->config = get_config($this->pluginconfig);
58         if (empty($this->config->ldapencoding)) {
59             $this->config->ldapencoding = 'utf-8';
60         }
61         if (empty($this->config->user_type)) {
62             $this->config->user_type = 'default';
63         }
65         $ldap_usertypes = ldap_supported_usertypes();
66         $this->config->user_type_name = $ldap_usertypes[$this->config->user_type];
67         unset($ldap_usertypes);
69         $default = ldap_getdefaults();
71         // Use defaults if values not given
72         foreach ($default as $key => $value) {
73             // watch out - 0, false are correct values too
74             if (!isset($this->config->{$key}) or $this->config->{$key} == '') {
75                 $this->config->{$key} = $value[$this->config->user_type];
76             }
77         }
79         // Hack prefix to objectclass
80         if (empty($this->config->objectclass)) {
81             // Can't send empty filter
82             $this->config->objectclass = '(objectClass=*)';
83         } else if (stripos($this->config->objectclass, 'objectClass=') === 0) {
84             // Value is 'objectClass=some-string-here', so just add ()
85             // around the value (filter _must_ have them).
86             $this->config->objectclass = '('.$this->config->objectclass.')';
87         } else if (strpos($this->config->objectclass, '(') !== 0) {
88             // Value is 'some-string-not-starting-with-left-parentheses',
89             // which is assumed to be the objectClass matching value.
90             // So build a valid filter with it.
91             $this->config->objectclass = '(objectClass='.$this->config->objectclass.')';
92         } else {
93             // There is an additional possible value
94             // '(some-string-here)', that can be used to specify any
95             // valid filter string, to select subsets of users based
96             // on any criteria. For example, we could select the users
97             // whose objectClass is 'user' and have the
98             // 'enabledMoodleUser' attribute, with something like:
99             //
100             //   (&(objectClass=user)(enabledMoodleUser=1))
101             //
102             // In this particular case we don't need to do anything,
103             // so leave $this->config->objectclass as is.
104         }
105     }
107     /**
108      * Constructor with initialisation.
109      */
110     function auth_plugin_ldap() {
111         $this->authtype = 'ldap';
112         $this->roleauth = 'auth_ldap';
113         $this->errorlogtag = '[AUTH LDAP] ';
114         $this->init_plugin($this->authtype);
115     }
117     /**
118      * Returns true if the username and password work and false if they are
119      * wrong or don't exist.
120      *
121      * @param string $username The username (without system magic quotes)
122      * @param string $password The password (without system magic quotes)
123      *
124      * @return bool Authentication success or failure.
125      */
126     function user_login($username, $password) {
127         if (! function_exists('ldap_bind')) {
128             print_error('auth_ldapnotinstalled', 'auth_ldap');
129             return false;
130         }
132         if (!$username or !$password) {    // Don't allow blank usernames or passwords
133             return false;
134         }
136         $extusername = textlib::convert($username, 'utf-8', $this->config->ldapencoding);
137         $extpassword = textlib::convert($password, 'utf-8', $this->config->ldapencoding);
139         // Before we connect to LDAP, check if this is an AD SSO login
140         // if we succeed in this block, we'll return success early.
141         //
142         $key = sesskey();
143         if (!empty($this->config->ntlmsso_enabled) && $key === $password) {
144             $cf = get_cache_flags($this->pluginconfig.'/ntlmsess');
145             // We only get the cache flag if we retrieve it before
146             // it expires (AUTH_NTLMTIMEOUT seconds).
147             if (!isset($cf[$key]) || $cf[$key] === '') {
148                 return false;
149             }
151             $sessusername = $cf[$key];
152             if ($username === $sessusername) {
153                 unset($sessusername);
154                 unset($cf);
156                 // Check that the user is inside one of the configured LDAP contexts
157                 $validuser = false;
158                 $ldapconnection = $this->ldap_connect();
159                 // if the user is not inside the configured contexts,
160                 // ldap_find_userdn returns false.
161                 if ($this->ldap_find_userdn($ldapconnection, $extusername)) {
162                     $validuser = true;
163                 }
164                 $this->ldap_close();
166                 // Shortcut here - SSO confirmed
167                 return $validuser;
168             }
169         } // End SSO processing
170         unset($key);
172         $ldapconnection = $this->ldap_connect();
173         $ldap_user_dn = $this->ldap_find_userdn($ldapconnection, $extusername);
175         // If ldap_user_dn is empty, user does not exist
176         if (!$ldap_user_dn) {
177             $this->ldap_close();
178             return false;
179         }
181         // Try to bind with current username and password
182         $ldap_login = @ldap_bind($ldapconnection, $ldap_user_dn, $extpassword);
183         $this->ldap_close();
184         if ($ldap_login) {
185             return true;
186         }
187         return false;
188     }
190     /**
191      * Reads user information from ldap and returns it in array()
192      *
193      * Function should return all information available. If you are saving
194      * this information to moodle user-table you should honor syncronization flags
195      *
196      * @param string $username username
197      *
198      * @return mixed array with no magic quotes or false on error
199      */
200     function get_userinfo($username) {
201         $extusername = textlib::convert($username, 'utf-8', $this->config->ldapencoding);
203         $ldapconnection = $this->ldap_connect();
204         if(!($user_dn = $this->ldap_find_userdn($ldapconnection, $extusername))) {
205             return false;
206         }
208         $search_attribs = array();
209         $attrmap = $this->ldap_attributes();
210         foreach ($attrmap as $key => $values) {
211             if (!is_array($values)) {
212                 $values = array($values);
213             }
214             foreach ($values as $value) {
215                 if (!in_array($value, $search_attribs)) {
216                     array_push($search_attribs, $value);
217                 }
218             }
219         }
221         if (!$user_info_result = ldap_read($ldapconnection, $user_dn, '(objectClass=*)', $search_attribs)) {
222             return false; // error!
223         }
225         $user_entry = ldap_get_entries_moodle($ldapconnection, $user_info_result);
226         if (empty($user_entry)) {
227             return false; // entry not found
228         }
230         $result = array();
231         foreach ($attrmap as $key => $values) {
232             if (!is_array($values)) {
233                 $values = array($values);
234             }
235             $ldapval = NULL;
236             foreach ($values as $value) {
237                 $entry = array_change_key_case($user_entry[0], CASE_LOWER);
238                 if (($value == 'dn') || ($value == 'distinguishedname')) {
239                     $result[$key] = $user_dn;
240                     continue;
241                 }
242                 if (!array_key_exists($value, $entry)) {
243                     continue; // wrong data mapping!
244                 }
245                 if (is_array($entry[$value])) {
246                     $newval = textlib::convert($entry[$value][0], $this->config->ldapencoding, 'utf-8');
247                 } else {
248                     $newval = textlib::convert($entry[$value], $this->config->ldapencoding, 'utf-8');
249                 }
250                 if (!empty($newval)) { // favour ldap entries that are set
251                     $ldapval = $newval;
252                 }
253             }
254             if (!is_null($ldapval)) {
255                 $result[$key] = $ldapval;
256             }
257         }
259         $this->ldap_close();
260         return $result;
261     }
263     /**
264      * Reads user information from ldap and returns it in an object
265      *
266      * @param string $username username (with system magic quotes)
267      * @return mixed object or false on error
268      */
269     function get_userinfo_asobj($username) {
270         $user_array = $this->get_userinfo($username);
271         if ($user_array == false) {
272             return false; //error or not found
273         }
274         $user_array = truncate_userinfo($user_array);
275         $user = new stdClass();
276         foreach ($user_array as $key=>$value) {
277             $user->{$key} = $value;
278         }
279         return $user;
280     }
282     /**
283      * Returns all usernames from LDAP
284      *
285      * get_userlist returns all usernames from LDAP
286      *
287      * @return array
288      */
289     function get_userlist() {
290         return $this->ldap_get_userlist("({$this->config->user_attribute}=*)");
291     }
293     /**
294      * Checks if user exists on LDAP
295      *
296      * @param string $username
297      */
298     function user_exists($username) {
299         $extusername = textlib::convert($username, 'utf-8', $this->config->ldapencoding);
301         // Returns true if given username exists on ldap
302         $users = $this->ldap_get_userlist('('.$this->config->user_attribute.'='.ldap_filter_addslashes($extusername).')');
303         return count($users);
304     }
306     /**
307      * Creates a new user on LDAP.
308      * By using information in userobject
309      * Use user_exists to prevent duplicate usernames
310      *
311      * @param mixed $userobject  Moodle userobject
312      * @param mixed $plainpass   Plaintext password
313      */
314     function user_create($userobject, $plainpass) {
315         $extusername = textlib::convert($userobject->username, 'utf-8', $this->config->ldapencoding);
316         $extpassword = textlib::convert($plainpass, 'utf-8', $this->config->ldapencoding);
318         switch ($this->config->passtype) {
319             case 'md5':
320                 $extpassword = '{MD5}' . base64_encode(pack('H*', md5($extpassword)));
321                 break;
322             case 'sha1':
323                 $extpassword = '{SHA}' . base64_encode(pack('H*', sha1($extpassword)));
324                 break;
325             case 'plaintext':
326             default:
327                 break; // plaintext
328         }
330         $ldapconnection = $this->ldap_connect();
331         $attrmap = $this->ldap_attributes();
333         $newuser = array();
335         foreach ($attrmap as $key => $values) {
336             if (!is_array($values)) {
337                 $values = array($values);
338             }
339             foreach ($values as $value) {
340                 if (!empty($userobject->$key) ) {
341                     $newuser[$value] = textlib::convert($userobject->$key, 'utf-8', $this->config->ldapencoding);
342                 }
343             }
344         }
346         //Following sets all mandatory and other forced attribute values
347         //User should be creted as login disabled untill email confirmation is processed
348         //Feel free to add your user type and send patches to paca@sci.fi to add them
349         //Moodle distribution
351         switch ($this->config->user_type)  {
352             case 'edir':
353                 $newuser['objectClass']   = array('inetOrgPerson', 'organizationalPerson', 'person', 'top');
354                 $newuser['uniqueId']      = $extusername;
355                 $newuser['logindisabled'] = 'TRUE';
356                 $newuser['userpassword']  = $extpassword;
357                 $uadd = ldap_add($ldapconnection, $this->config->user_attribute.'='.ldap_addslashes($extusername).','.$this->config->create_context, $newuser);
358                 break;
359             case 'rfc2307':
360             case 'rfc2307bis':
361                 // posixAccount object class forces us to specify a uidNumber
362                 // and a gidNumber. That is quite complicated to generate from
363                 // Moodle without colliding with existing numbers and without
364                 // race conditions. As this user is supposed to be only used
365                 // with Moodle (otherwise the user would exist beforehand) and
366                 // doesn't need to login into a operating system, we assign the
367                 // user the uid of user 'nobody' and gid of group 'nogroup'. In
368                 // addition to that, we need to specify a home directory. We
369                 // use the root directory ('/') as the home directory, as this
370                 // is the only one can always be sure exists. Finally, even if
371                 // it's not mandatory, we specify '/bin/false' as the login
372                 // shell, to prevent the user from login in at the operating
373                 // system level (Moodle ignores this).
375                 $newuser['objectClass']   = array('posixAccount', 'inetOrgPerson', 'organizationalPerson', 'person', 'top');
376                 $newuser['cn']            = $extusername;
377                 $newuser['uid']           = $extusername;
378                 $newuser['uidNumber']     = AUTH_UID_NOBODY;
379                 $newuser['gidNumber']     = AUTH_GID_NOGROUP;
380                 $newuser['homeDirectory'] = '/';
381                 $newuser['loginShell']    = '/bin/false';
383                 // IMPORTANT:
384                 // We have to create the account locked, but posixAccount has
385                 // no attribute to achive this reliably. So we are going to
386                 // modify the password in a reversable way that we can later
387                 // revert in user_activate().
388                 //
389                 // Beware that this can be defeated by the user if we are not
390                 // using MD5 or SHA-1 passwords. After all, the source code of
391                 // Moodle is available, and the user can see the kind of
392                 // modification we are doing and 'undo' it by hand (but only
393                 // if we are using plain text passwords).
394                 //
395                 // Also bear in mind that you need to use a binding user that
396                 // can create accounts and has read/write privileges on the
397                 // 'userPassword' attribute for this to work.
399                 $newuser['userPassword']  = '*'.$extpassword;
400                 $uadd = ldap_add($ldapconnection, $this->config->user_attribute.'='.ldap_addslashes($extusername).','.$this->config->create_context, $newuser);
401                 break;
402             case 'ad':
403                 // User account creation is a two step process with AD. First you
404                 // create the user object, then you set the password. If you try
405                 // to set the password while creating the user, the operation
406                 // fails.
408                 // Passwords in Active Directory must be encoded as Unicode
409                 // strings (UCS-2 Little Endian format) and surrounded with
410                 // double quotes. See http://support.microsoft.com/?kbid=269190
411                 if (!function_exists('mb_convert_encoding')) {
412                     print_error('auth_ldap_no_mbstring', 'auth_ldap');
413                 }
415                 // Check for invalid sAMAccountName characters.
416                 if (preg_match('#[/\\[\]:;|=,+*?<>@"]#', $extusername)) {
417                     print_error ('auth_ldap_ad_invalidchars', 'auth_ldap');
418                 }
420                 // First create the user account, and mark it as disabled.
421                 $newuser['objectClass'] = array('top', 'person', 'user', 'organizationalPerson');
422                 $newuser['sAMAccountName'] = $extusername;
423                 $newuser['userAccountControl'] = AUTH_AD_NORMAL_ACCOUNT |
424                                                  AUTH_AD_ACCOUNTDISABLE;
425                 $userdn = 'cn='.ldap_addslashes($extusername).','.$this->config->create_context;
426                 if (!ldap_add($ldapconnection, $userdn, $newuser)) {
427                     print_error('auth_ldap_ad_create_req', 'auth_ldap');
428                 }
430                 // Now set the password
431                 unset($newuser);
432                 $newuser['unicodePwd'] = mb_convert_encoding('"' . $extpassword . '"',
433                                                              'UCS-2LE', 'UTF-8');
434                 if(!ldap_modify($ldapconnection, $userdn, $newuser)) {
435                     // Something went wrong: delete the user account and error out
436                     ldap_delete ($ldapconnection, $userdn);
437                     print_error('auth_ldap_ad_create_req', 'auth_ldap');
438                 }
439                 $uadd = true;
440                 break;
441             default:
442                print_error('auth_ldap_unsupportedusertype', 'auth_ldap', '', $this->config->user_type_name);
443         }
444         $this->ldap_close();
445         return $uadd;
446     }
448     /**
449      * Returns true if plugin allows resetting of password from moodle.
450      *
451      * @return bool
452      */
453     function can_reset_password() {
454         return !empty($this->config->stdchangepassword);
455     }
457     /**
458      * Returns true if plugin allows signup and user creation.
459      *
460      * @return bool
461      */
462     function can_signup() {
463         return (!empty($this->config->auth_user_create) and !empty($this->config->create_context));
464     }
466     /**
467      * Sign up a new user ready for confirmation.
468      * Password is passed in plaintext.
469      *
470      * @param object $user new user object
471      * @param boolean $notify print notice with link and terminate
472      */
473     function user_signup($user, $notify=true) {
474         global $CFG, $DB, $PAGE, $OUTPUT;
476         require_once($CFG->dirroot.'/user/profile/lib.php');
478         if ($this->user_exists($user->username)) {
479             print_error('auth_ldap_user_exists', 'auth_ldap');
480         }
482         $plainslashedpassword = $user->password;
483         unset($user->password);
485         if (! $this->user_create($user, $plainslashedpassword)) {
486             print_error('auth_ldap_create_error', 'auth_ldap');
487         }
489         $user->id = $DB->insert_record('user', $user);
491         // Save any custom profile field information
492         profile_save_data($user);
494         $this->update_user_record($user->username);
495         update_internal_user_password($user, $plainslashedpassword);
497         $user = $DB->get_record('user', array('id'=>$user->id));
498         events_trigger('user_created', $user);
500         if (! send_confirmation_email($user)) {
501             print_error('noemail', 'auth_ldap');
502         }
504         if ($notify) {
505             $emailconfirm = get_string('emailconfirm');
506             $PAGE->set_url('/auth/ldap/auth.php');
507             $PAGE->navbar->add($emailconfirm);
508             $PAGE->set_title($emailconfirm);
509             $PAGE->set_heading($emailconfirm);
510             echo $OUTPUT->header();
511             notice(get_string('emailconfirmsent', '', $user->email), "{$CFG->wwwroot}/index.php");
512         } else {
513             return true;
514         }
515     }
517     /**
518      * Returns true if plugin allows confirming of new users.
519      *
520      * @return bool
521      */
522     function can_confirm() {
523         return $this->can_signup();
524     }
526     /**
527      * Confirm the new user as registered.
528      *
529      * @param string $username
530      * @param string $confirmsecret
531      */
532     function user_confirm($username, $confirmsecret) {
533         global $DB;
535         $user = get_complete_user_data('username', $username);
537         if (!empty($user)) {
538             if ($user->confirmed) {
539                 return AUTH_CONFIRM_ALREADY;
541             } else if ($user->auth != $this->authtype) {
542                 return AUTH_CONFIRM_ERROR;
544             } else if ($user->secret == $confirmsecret) {   // They have provided the secret key to get in
545                 if (!$this->user_activate($username)) {
546                     return AUTH_CONFIRM_FAIL;
547                 }
548                 $DB->set_field('user', 'confirmed', 1, array('id'=>$user->id));
549                 $DB->set_field('user', 'firstaccess', time(), array('id'=>$user->id));
550                 return AUTH_CONFIRM_OK;
551             }
552         } else {
553             return AUTH_CONFIRM_ERROR;
554         }
555     }
557     /**
558      * Return number of days to user password expires
559      *
560      * If userpassword does not expire it should return 0. If password is already expired
561      * it should return negative value.
562      *
563      * @param mixed $username username
564      * @return integer
565      */
566     function password_expire($username) {
567         $result = 0;
569         $extusername = textlib::convert($username, 'utf-8', $this->config->ldapencoding);
571         $ldapconnection = $this->ldap_connect();
572         $user_dn = $this->ldap_find_userdn($ldapconnection, $extusername);
573         $search_attribs = array($this->config->expireattr);
574         $sr = ldap_read($ldapconnection, $user_dn, '(objectClass=*)', $search_attribs);
575         if ($sr)  {
576             $info = ldap_get_entries_moodle($ldapconnection, $sr);
577             if (!empty ($info)) {
578                 $info = array_change_key_case($info[0], CASE_LOWER);
579                 if (!empty($info[$this->config->expireattr][0])) {
580                     $expiretime = $this->ldap_expirationtime2unix($info[$this->config->expireattr][0], $ldapconnection, $user_dn);
581                     if ($expiretime != 0) {
582                         $now = time();
583                         if ($expiretime > $now) {
584                             $result = ceil(($expiretime - $now) / DAYSECS);
585                         } else {
586                             $result = floor(($expiretime - $now) / DAYSECS);
587                         }
588                     }
589                 }
590             }
591         } else {
592             error_log($this->errorlogtag.get_string('didtfindexpiretime', 'auth_ldap'));
593         }
595         return $result;
596     }
598     /**
599      * Syncronizes user fron external LDAP server to moodle user table
600      *
601      * Sync is now using username attribute.
602      *
603      * Syncing users removes or suspends users that dont exists anymore in external LDAP.
604      * Creates new users and updates coursecreator status of users.
605      *
606      * @param bool $do_updates will do pull in data updates from LDAP if relevant
607      */
608     function sync_users($do_updates=true) {
609         global $CFG, $DB;
611         print_string('connectingldap', 'auth_ldap');
612         $ldapconnection = $this->ldap_connect();
614         $dbman = $DB->get_manager();
616     /// Define table user to be created
617         $table = new xmldb_table('tmp_extuser');
618         $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
619         $table->add_field('username', XMLDB_TYPE_CHAR, '100', null, XMLDB_NOTNULL, null, null);
620         $table->add_field('mnethostid', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, null);
621         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
622         $table->add_index('username', XMLDB_INDEX_UNIQUE, array('mnethostid', 'username'));
624         print_string('creatingtemptable', 'auth_ldap', 'tmp_extuser');
625         $dbman->create_temp_table($table);
627         ////
628         //// get user's list from ldap to sql in a scalable fashion
629         ////
630         // prepare some data we'll need
631         $filter = '(&('.$this->config->user_attribute.'=*)'.$this->config->objectclass.')';
633         $contexts = explode(';', $this->config->contexts);
635         if (!empty($this->config->create_context)) {
636               array_push($contexts, $this->config->create_context);
637         }
639         $fresult = array();
640         foreach ($contexts as $context) {
641             $context = trim($context);
642             if (empty($context)) {
643                 continue;
644             }
645             if ($this->config->search_sub) {
646                 //use ldap_search to find first user from subtree
647                 $ldap_result = ldap_search($ldapconnection, $context,
648                                            $filter,
649                                            array($this->config->user_attribute));
650             } else {
651                 //search only in this context
652                 $ldap_result = ldap_list($ldapconnection, $context,
653                                          $filter,
654                                          array($this->config->user_attribute));
655             }
657             if(!$ldap_result) {
658                 continue;
659             }
661             if ($entry = @ldap_first_entry($ldapconnection, $ldap_result)) {
662                 do {
663                     $value = ldap_get_values_len($ldapconnection, $entry, $this->config->user_attribute);
664                     $value = textlib::convert($value[0], $this->config->ldapencoding, 'utf-8');
665                     $this->ldap_bulk_insert($value);
666                 } while ($entry = ldap_next_entry($ldapconnection, $entry));
667             }
668             unset($ldap_result); // free mem
669         }
671         /// preserve our user database
672         /// if the temp table is empty, it probably means that something went wrong, exit
673         /// so as to avoid mass deletion of users; which is hard to undo
674         $count = $DB->count_records_sql('SELECT COUNT(username) AS count, 1 FROM {tmp_extuser}');
675         if ($count < 1) {
676             print_string('didntgetusersfromldap', 'auth_ldap');
677             exit;
678         } else {
679             print_string('gotcountrecordsfromldap', 'auth_ldap', $count);
680         }
683 /// User removal
684         // Find users in DB that aren't in ldap -- to be removed!
685         // this is still not as scalable (but how often do we mass delete?)
686         if ($this->config->removeuser !== AUTH_REMOVEUSER_KEEP) {
687             $sql = 'SELECT u.*
688                       FROM {user} u
689                       LEFT JOIN {tmp_extuser} e ON (u.username = e.username AND u.mnethostid = e.mnethostid)
690                      WHERE u.auth = ?
691                            AND u.deleted = 0
692                            AND e.username IS NULL';
693             $remove_users = $DB->get_records_sql($sql, array($this->authtype));
695             if (!empty($remove_users)) {
696                 print_string('userentriestoremove', 'auth_ldap', count($remove_users));
698                 foreach ($remove_users as $user) {
699                     if ($this->config->removeuser == AUTH_REMOVEUSER_FULLDELETE) {
700                         if (delete_user($user)) {
701                             echo "\t"; print_string('auth_dbdeleteuser', 'auth_db', array('name'=>$user->username, 'id'=>$user->id)); echo "\n";
702                         } else {
703                             echo "\t"; print_string('auth_dbdeleteusererror', 'auth_db', $user->username); echo "\n";
704                         }
705                     } else if ($this->config->removeuser == AUTH_REMOVEUSER_SUSPEND) {
706                         $updateuser = new stdClass();
707                         $updateuser->id = $user->id;
708                         $updateuser->auth = 'nologin';
709                         $DB->update_record('user', $updateuser);
710                         echo "\t"; print_string('auth_dbsuspenduser', 'auth_db', array('name'=>$user->username, 'id'=>$user->id)); echo "\n";
711                     }
712                 }
713             } else {
714                 print_string('nouserentriestoremove', 'auth_ldap');
715             }
716             unset($remove_users); // free mem!
717         }
719 /// Revive suspended users
720         if (!empty($this->config->removeuser) and $this->config->removeuser == AUTH_REMOVEUSER_SUSPEND) {
721             $sql = "SELECT u.id, u.username
722                       FROM {user} u
723                       JOIN {tmp_extuser} e ON (u.username = e.username AND u.mnethostid = e.mnethostid)
724                      WHERE u.auth = 'nologin' AND u.deleted = 0";
725             $revive_users = $DB->get_records_sql($sql);
727             if (!empty($revive_users)) {
728                 print_string('userentriestorevive', 'auth_ldap', count($revive_users));
730                 foreach ($revive_users as $user) {
731                     $updateuser = new stdClass();
732                     $updateuser->id = $user->id;
733                     $updateuser->auth = $this->authtype;
734                     $DB->update_record('user', $updateuser);
735                     echo "\t"; print_string('auth_dbreviveduser', 'auth_db', array('name'=>$user->username, 'id'=>$user->id)); echo "\n";
736                 }
737             } else {
738                 print_string('nouserentriestorevive', 'auth_ldap');
739             }
741             unset($revive_users);
742         }
745 /// User Updates - time-consuming (optional)
746         if ($do_updates) {
747             // Narrow down what fields we need to update
748             $all_keys = array_keys(get_object_vars($this->config));
749             $updatekeys = array();
750             foreach ($all_keys as $key) {
751                 if (preg_match('/^field_updatelocal_(.+)$/', $key, $match)) {
752                     // If we have a field to update it from
753                     // and it must be updated 'onlogin' we
754                     // update it on cron
755                     if (!empty($this->config->{'field_map_'.$match[1]})
756                          and $this->config->{$match[0]} === 'onlogin') {
757                         array_push($updatekeys, $match[1]); // the actual key name
758                     }
759                 }
760             }
761             unset($all_keys); unset($key);
763         } else {
764             print_string('noupdatestobedone', 'auth_ldap');
765         }
766         if ($do_updates and !empty($updatekeys)) { // run updates only if relevant
767             $users = $DB->get_records_sql('SELECT u.username, u.id
768                                              FROM {user} u
769                                             WHERE u.deleted = 0 AND u.auth = ? AND u.mnethostid = ?',
770                                           array($this->authtype, $CFG->mnet_localhost_id));
771             if (!empty($users)) {
772                 print_string('userentriestoupdate', 'auth_ldap', count($users));
774                 $sitecontext = get_context_instance(CONTEXT_SYSTEM);
775                 if (!empty($this->config->creators) and !empty($this->config->memberattribute)
776                   and $roles = get_archetype_roles('coursecreator')) {
777                     $creatorrole = array_shift($roles);      // We can only use one, let's use the first one
778                 } else {
779                     $creatorrole = false;
780                 }
782                 $transaction = $DB->start_delegated_transaction();
783                 $xcount = 0;
784                 $maxxcount = 100;
786                 foreach ($users as $user) {
787                     echo "\t"; print_string('auth_dbupdatinguser', 'auth_db', array('name'=>$user->username, 'id'=>$user->id));
788                     if (!$this->update_user_record($user->username, $updatekeys)) {
789                         echo ' - '.get_string('skipped');
790                     }
791                     echo "\n";
792                     $xcount++;
794                     // Update course creators if needed
795                     if ($creatorrole !== false) {
796                         if ($this->iscreator($user->username)) {
797                             role_assign($creatorrole->id, $user->id, $sitecontext->id, $this->roleauth);
798                         } else {
799                             role_unassign($creatorrole->id, $user->id, $sitecontext->id, $this->roleauth);
800                         }
801                     }
802                 }
803                 $transaction->allow_commit();
804                 unset($users); // free mem
805             }
806         } else { // end do updates
807             print_string('noupdatestobedone', 'auth_ldap');
808         }
810 /// User Additions
811         // Find users missing in DB that are in LDAP
812         // and gives me a nifty object I don't want.
813         // note: we do not care about deleted accounts anymore, this feature was replaced by suspending to nologin auth plugin
814         $sql = 'SELECT e.id, e.username
815                   FROM {tmp_extuser} e
816                   LEFT JOIN {user} u ON (e.username = u.username AND e.mnethostid = u.mnethostid)
817                  WHERE u.id IS NULL';
818         $add_users = $DB->get_records_sql($sql);
820         if (!empty($add_users)) {
821             print_string('userentriestoadd', 'auth_ldap', count($add_users));
823             $sitecontext = get_context_instance(CONTEXT_SYSTEM);
824             if (!empty($this->config->creators) and !empty($this->config->memberattribute)
825               and $roles = get_archetype_roles('coursecreator')) {
826                 $creatorrole = array_shift($roles);      // We can only use one, let's use the first one
827             } else {
828                 $creatorrole = false;
829             }
831             $transaction = $DB->start_delegated_transaction();
832             foreach ($add_users as $user) {
833                 $user = $this->get_userinfo_asobj($user->username);
835                 // Prep a few params
836                 $user->modified   = time();
837                 $user->confirmed  = 1;
838                 $user->auth       = $this->authtype;
839                 $user->mnethostid = $CFG->mnet_localhost_id;
840                 // get_userinfo_asobj() might have replaced $user->username with the value
841                 // from the LDAP server (which can be mixed-case). Make sure it's lowercase
842                 $user->username = trim(textlib::strtolower($user->username));
843                 if (empty($user->lang)) {
844                     $user->lang = $CFG->lang;
845                 }
847                 $id = $DB->insert_record('user', $user);
848                 echo "\t"; print_string('auth_dbinsertuser', 'auth_db', array('name'=>$user->username, 'id'=>$id)); echo "\n";
849                 if (!empty($this->config->forcechangepassword)) {
850                     set_user_preference('auth_forcepasswordchange', 1, $id);
851                 }
853                 // Add course creators if needed
854                 if ($creatorrole !== false and $this->iscreator($user->username)) {
855                     role_assign($creatorrole->id, $id, $sitecontext->id, $this->roleauth);
856                 }
858             }
859             $transaction->allow_commit();
860             unset($add_users); // free mem
861         } else {
862             print_string('nouserstobeadded', 'auth_ldap');
863         }
865         $dbman->drop_table($table);
866         $this->ldap_close();
868         return true;
869     }
871     /**
872      * Update a local user record from an external source.
873      * This is a lighter version of the one in moodlelib -- won't do
874      * expensive ops such as enrolment.
875      *
876      * If you don't pass $updatekeys, there is a performance hit and
877      * values removed from LDAP won't be removed from moodle.
878      *
879      * @param string $username username
880      * @param boolean $updatekeys true to update the local record with the external LDAP values.
881      */
882     function update_user_record($username, $updatekeys = false) {
883         global $CFG, $DB;
885         // Just in case check text case
886         $username = trim(textlib::strtolower($username));
888         // Get the current user record
889         $user = $DB->get_record('user', array('username'=>$username, 'mnethostid'=>$CFG->mnet_localhost_id));
890         if (empty($user)) { // trouble
891             error_log($this->errorlogtag.get_string('auth_dbusernotexist', 'auth_db', '', $username));
892             print_error('auth_dbusernotexist', 'auth_db', '', $username);
893             die;
894         }
896         // Protect the userid from being overwritten
897         $userid = $user->id;
899         if ($newinfo = $this->get_userinfo($username)) {
900             $newinfo = truncate_userinfo($newinfo);
902             if (empty($updatekeys)) { // all keys? this does not support removing values
903                 $updatekeys = array_keys($newinfo);
904             }
906             foreach ($updatekeys as $key) {
907                 if (isset($newinfo[$key])) {
908                     $value = $newinfo[$key];
909                 } else {
910                     $value = '';
911                 }
913                 if (!empty($this->config->{'field_updatelocal_' . $key})) {
914                     if ($user->{$key} != $value) { // only update if it's changed
915                         $DB->set_field('user', $key, $value, array('id'=>$userid));
916                     }
917                 }
918             }
919         } else {
920             return false;
921         }
922         return $DB->get_record('user', array('id'=>$userid, 'deleted'=>0));
923     }
925     /**
926      * Bulk insert in SQL's temp table
927      */
928     function ldap_bulk_insert($username) {
929         global $DB, $CFG;
931         $username = textlib::strtolower($username); // usernames are __always__ lowercase.
932         $DB->insert_record_raw('tmp_extuser', array('username'=>$username,
933                                                     'mnethostid'=>$CFG->mnet_localhost_id), false, true);
934         echo '.';
935     }
937     /**
938      * Activates (enables) user in external LDAP so user can login
939      *
940      * @param mixed $username
941      * @return boolean result
942      */
943     function user_activate($username) {
944         $extusername = textlib::convert($username, 'utf-8', $this->config->ldapencoding);
946         $ldapconnection = $this->ldap_connect();
948         $userdn = $this->ldap_find_userdn($ldapconnection, $extusername);
949         switch ($this->config->user_type)  {
950             case 'edir':
951                 $newinfo['loginDisabled'] = 'FALSE';
952                 break;
953             case 'rfc2307':
954             case 'rfc2307bis':
955                 // Remember that we add a '*' character in front of the
956                 // external password string to 'disable' the account. We just
957                 // need to remove it.
958                 $sr = ldap_read($ldapconnection, $userdn, '(objectClass=*)',
959                                 array('userPassword'));
960                 $info = ldap_get_entries($ldapconnection, $sr);
961                 $info[0] = array_change_key_case($info[0], CASE_LOWER);
962                 $newinfo['userPassword'] = ltrim($info[0]['userpassword'][0], '*');
963                 break;
964             case 'ad':
965                 // We need to unset the ACCOUNTDISABLE bit in the
966                 // userAccountControl attribute ( see
967                 // http://support.microsoft.com/kb/305144 )
968                 $sr = ldap_read($ldapconnection, $userdn, '(objectClass=*)',
969                                 array('userAccountControl'));
970                 $info = ldap_get_entries($ldapconnection, $sr);
971                 $info[0] = array_change_key_case($info[0], CASE_LOWER);
972                 $newinfo['userAccountControl'] = $info[0]['useraccountcontrol'][0]
973                                                  & (~AUTH_AD_ACCOUNTDISABLE);
974                 break;
975             default:
976                 print_error('user_activatenotsupportusertype', 'auth_ldap', '', $this->config->user_type_name);
977         }
978         $result = ldap_modify($ldapconnection, $userdn, $newinfo);
979         $this->ldap_close();
980         return $result;
981     }
983     /**
984      * Returns true if user should be coursecreator.
985      *
986      * @param mixed $username    username (without system magic quotes)
987      * @return mixed result      null if course creators is not configured, boolean otherwise.
988      */
989     function iscreator($username) {
990         if (empty($this->config->creators) or empty($this->config->memberattribute)) {
991             return null;
992         }
994         $extusername = textlib::convert($username, 'utf-8', $this->config->ldapencoding);
996         $ldapconnection = $this->ldap_connect();
998         if ($this->config->memberattribute_isdn) {
999             if(!($userid = $this->ldap_find_userdn($ldapconnection, $extusername))) {
1000                 return false;
1001             }
1002         } else {
1003             $userid = $extusername;
1004         }
1006         $group_dns = explode(';', $this->config->creators);
1007         $creator = ldap_isgroupmember($ldapconnection, $userid, $group_dns, $this->config->memberattribute);
1009         $this->ldap_close();
1011         return $creator;
1012     }
1014     /**
1015      * Called when the user record is updated.
1016      *
1017      * Modifies user in external LDAP server. It takes olduser (before
1018      * changes) and newuser (after changes) compares information and
1019      * saves modified information to external LDAP server.
1020      *
1021      * @param mixed $olduser     Userobject before modifications    (without system magic quotes)
1022      * @param mixed $newuser     Userobject new modified userobject (without system magic quotes)
1023      * @return boolean result
1024      *
1025      */
1026     function user_update($olduser, $newuser) {
1027         global $USER;
1029         if (isset($olduser->username) and isset($newuser->username) and $olduser->username != $newuser->username) {
1030             error_log($this->errorlogtag.get_string('renamingnotallowed', 'auth_ldap'));
1031             return false;
1032         }
1034         if (isset($olduser->auth) and $olduser->auth != $this->authtype) {
1035             return true; // just change auth and skip update
1036         }
1038         $attrmap = $this->ldap_attributes();
1039         // Before doing anything else, make sure we really need to update anything
1040         // in the external LDAP server.
1041         $update_external = false;
1042         foreach ($attrmap as $key => $ldapkeys) {
1043             if (!empty($this->config->{'field_updateremote_'.$key})) {
1044                 $update_external = true;
1045                 break;
1046             }
1047         }
1048         if (!$update_external) {
1049             return true;
1050         }
1052         $extoldusername = textlib::convert($olduser->username, 'utf-8', $this->config->ldapencoding);
1054         $ldapconnection = $this->ldap_connect();
1056         $search_attribs = array();
1057         foreach ($attrmap as $key => $values) {
1058             if (!is_array($values)) {
1059                 $values = array($values);
1060             }
1061             foreach ($values as $value) {
1062                 if (!in_array($value, $search_attribs)) {
1063                     array_push($search_attribs, $value);
1064                 }
1065             }
1066         }
1068         if(!($user_dn = $this->ldap_find_userdn($ldapconnection, $extoldusername))) {
1069             return false;
1070         }
1072         $user_info_result = ldap_read($ldapconnection, $user_dn, '(objectClass=*)', $search_attribs);
1073         if ($user_info_result) {
1074             $user_entry = ldap_get_entries_moodle($ldapconnection, $user_info_result);
1075             if (empty($user_entry)) {
1076                 $attribs = join (', ', $search_attribs);
1077                 error_log($this->errorlogtag.get_string('updateusernotfound', 'auth_ldap',
1078                                                           array('userdn'=>$user_dn,
1079                                                                 'attribs'=>$attribs)));
1080                 return false; // old user not found!
1081             } else if (count($user_entry) > 1) {
1082                 error_log($this->errorlogtag.get_string('morethanoneuser', 'auth_ldap'));
1083                 return false;
1084             }
1086             $user_entry = array_change_key_case($user_entry[0], CASE_LOWER);
1088             foreach ($attrmap as $key => $ldapkeys) {
1089                 // Only process if the moodle field ($key) has changed and we
1090                 // are set to update LDAP with it
1091                 if (isset($olduser->$key) and isset($newuser->$key)
1092                   and $olduser->$key !== $newuser->$key
1093                   and !empty($this->config->{'field_updateremote_'. $key})) {
1094                     // For ldap values that could be in more than one
1095                     // ldap key, we will do our best to match
1096                     // where they came from
1097                     $ambiguous = true;
1098                     $changed   = false;
1099                     if (!is_array($ldapkeys)) {
1100                         $ldapkeys = array($ldapkeys);
1101                     }
1102                     if (count($ldapkeys) < 2) {
1103                         $ambiguous = false;
1104                     }
1106                     $nuvalue = textlib::convert($newuser->$key, 'utf-8', $this->config->ldapencoding);
1107                     empty($nuvalue) ? $nuvalue = array() : $nuvalue;
1108                     $ouvalue = textlib::convert($olduser->$key, 'utf-8', $this->config->ldapencoding);
1110                     foreach ($ldapkeys as $ldapkey) {
1111                         $ldapkey   = $ldapkey;
1112                         $ldapvalue = $user_entry[$ldapkey][0];
1113                         if (!$ambiguous) {
1114                             // Skip update if the values already match
1115                             if ($nuvalue !== $ldapvalue) {
1116                                 // This might fail due to schema validation
1117                                 if (@ldap_modify($ldapconnection, $user_dn, array($ldapkey => $nuvalue))) {
1118                                     continue;
1119                                 } else {
1120                                     error_log($this->errorlogtag.get_string ('updateremfail', 'auth_ldap',
1121                                                                              array('errno'=>ldap_errno($ldapconnection),
1122                                                                                    'errstring'=>ldap_err2str(ldap_errno($ldapconnection)),
1123                                                                                    'key'=>$key,
1124                                                                                    'ouvalue'=>$ouvalue,
1125                                                                                    'nuvalue'=>$nuvalue)));
1126                                     continue;
1127                                 }
1128                             }
1129                         } else {
1130                             // Ambiguous. Value empty before in Moodle (and LDAP) - use
1131                             // 1st ldap candidate field, no need to guess
1132                             if ($ouvalue === '') { // value empty before - use 1st ldap candidate
1133                                 // This might fail due to schema validation
1134                                 if (@ldap_modify($ldapconnection, $user_dn, array($ldapkey => $nuvalue))) {
1135                                     $changed = true;
1136                                     continue;
1137                                 } else {
1138                                     error_log($this->errorlogtag.get_string ('updateremfail', 'auth_ldap',
1139                                                                              array('errno'=>ldap_errno($ldapconnection),
1140                                                                                    'errstring'=>ldap_err2str(ldap_errno($ldapconnection)),
1141                                                                                    'key'=>$key,
1142                                                                                    'ouvalue'=>$ouvalue,
1143                                                                                    'nuvalue'=>$nuvalue)));
1144                                     continue;
1145                                 }
1146                             }
1148                             // We found which ldap key to update!
1149                             if ($ouvalue !== '' and $ouvalue === $ldapvalue ) {
1150                                 // This might fail due to schema validation
1151                                 if (@ldap_modify($ldapconnection, $user_dn, array($ldapkey => $nuvalue))) {
1152                                     $changed = true;
1153                                     continue;
1154                                 } else {
1155                                     error_log($this->errorlogtag.get_string ('updateremfail', 'auth_ldap',
1156                                                                              array('errno'=>ldap_errno($ldapconnection),
1157                                                                                    'errstring'=>ldap_err2str(ldap_errno($ldapconnection)),
1158                                                                                    'key'=>$key,
1159                                                                                    'ouvalue'=>$ouvalue,
1160                                                                                    'nuvalue'=>$nuvalue)));
1161                                     continue;
1162                                 }
1163                             }
1164                         }
1165                     }
1167                     if ($ambiguous and !$changed) {
1168                         error_log($this->errorlogtag.get_string ('updateremfailamb', 'auth_ldap',
1169                                                                  array('key'=>$key,
1170                                                                        'ouvalue'=>$ouvalue,
1171                                                                        'nuvalue'=>$nuvalue)));
1172                     }
1173                 }
1174             }
1175         } else {
1176             error_log($this->errorlogtag.get_string ('usernotfound', 'auth_ldap'));
1177             $this->ldap_close();
1178             return false;
1179         }
1181         $this->ldap_close();
1182         return true;
1184     }
1186     /**
1187      * Changes userpassword in LDAP
1188      *
1189      * Called when the user password is updated. It assumes it is
1190      * called by an admin or that you've otherwise checked the user's
1191      * credentials
1192      *
1193      * @param  object  $user        User table object
1194      * @param  string  $newpassword Plaintext password (not crypted/md5'ed)
1195      * @return boolean result
1196      *
1197      */
1198     function user_update_password($user, $newpassword) {
1199         global $USER;
1201         $result = false;
1202         $username = $user->username;
1204         $extusername = textlib::convert($username, 'utf-8', $this->config->ldapencoding);
1205         $extpassword = textlib::convert($newpassword, 'utf-8', $this->config->ldapencoding);
1207         switch ($this->config->passtype) {
1208             case 'md5':
1209                 $extpassword = '{MD5}' . base64_encode(pack('H*', md5($extpassword)));
1210                 break;
1211             case 'sha1':
1212                 $extpassword = '{SHA}' . base64_encode(pack('H*', sha1($extpassword)));
1213                 break;
1214             case 'plaintext':
1215             default:
1216                 break; // plaintext
1217         }
1219         $ldapconnection = $this->ldap_connect();
1221         $user_dn = $this->ldap_find_userdn($ldapconnection, $extusername);
1223         if (!$user_dn) {
1224             error_log($this->errorlogtag.get_string ('nodnforusername', 'auth_ldap', $user->username));
1225             return false;
1226         }
1228         switch ($this->config->user_type) {
1229             case 'edir':
1230                 // Change password
1231                 $result = ldap_modify($ldapconnection, $user_dn, array('userPassword' => $extpassword));
1232                 if (!$result) {
1233                     error_log($this->errorlogtag.get_string ('updatepasserror', 'auth_ldap',
1234                                                                array('errno'=>ldap_errno($ldapconnection),
1235                                                                      'errstring'=>ldap_err2str(ldap_errno($ldapconnection)))));
1236                 }
1237                 // Update password expiration time, grace logins count
1238                 $search_attribs = array($this->config->expireattr, 'passwordExpirationInterval', 'loginGraceLimit');
1239                 $sr = ldap_read($ldapconnection, $user_dn, '(objectClass=*)', $search_attribs);
1240                 if ($sr) {
1241                     $entry = ldap_get_entries_moodle($ldapconnection, $sr);
1242                     $info = array_change_key_case($entry[0], CASE_LOWER);
1243                     $newattrs = array();
1244                     if (!empty($info[$this->config->expireattr][0])) {
1245                         // Set expiration time only if passwordExpirationInterval is defined
1246                         if (!empty($info['passwordexpirationinterval'][0])) {
1247                            $expirationtime = time() + $info['passwordexpirationinterval'][0];
1248                            $ldapexpirationtime = $this->ldap_unix2expirationtime($expirationtime);
1249                            $newattrs['passwordExpirationTime'] = $ldapexpirationtime;
1250                         }
1252                         // Set gracelogin count
1253                         if (!empty($info['logingracelimit'][0])) {
1254                            $newattrs['loginGraceRemaining']= $info['logingracelimit'][0];
1255                         }
1257                         // Store attribute changes in LDAP
1258                         $result = ldap_modify($ldapconnection, $user_dn, $newattrs);
1259                         if (!$result) {
1260                             error_log($this->errorlogtag.get_string ('updatepasserrorexpiregrace', 'auth_ldap',
1261                                                                        array('errno'=>ldap_errno($ldapconnection),
1262                                                                              'errstring'=>ldap_err2str(ldap_errno($ldapconnection)))));
1263                         }
1264                     }
1265                 }
1266                 else {
1267                     error_log($this->errorlogtag.get_string ('updatepasserrorexpire', 'auth_ldap',
1268                                                              array('errno'=>ldap_errno($ldapconnection),
1269                                                                    'errstring'=>ldap_err2str(ldap_errno($ldapconnection)))));
1270                 }
1271                 break;
1273             case 'ad':
1274                 // Passwords in Active Directory must be encoded as Unicode
1275                 // strings (UCS-2 Little Endian format) and surrounded with
1276                 // double quotes. See http://support.microsoft.com/?kbid=269190
1277                 if (!function_exists('mb_convert_encoding')) {
1278                     error_log($this->errorlogtag.get_string ('needmbstring', 'auth_ldap'));
1279                     return false;
1280                 }
1281                 $extpassword = mb_convert_encoding('"'.$extpassword.'"', "UCS-2LE", $this->config->ldapencoding);
1282                 $result = ldap_modify($ldapconnection, $user_dn, array('unicodePwd' => $extpassword));
1283                 if (!$result) {
1284                     error_log($this->errorlogtag.get_string ('updatepasserror', 'auth_ldap',
1285                                                              array('errno'=>ldap_errno($ldapconnection),
1286                                                                    'errstring'=>ldap_err2str(ldap_errno($ldapconnection)))));
1287                 }
1288                 break;
1290             default:
1291                 // Send LDAP the password in cleartext, it will md5 it itself
1292                 $result = ldap_modify($ldapconnection, $user_dn, array('userPassword' => $extpassword));
1293                 if (!$result) {
1294                     error_log($this->errorlogtag.get_string ('updatepasserror', 'auth_ldap',
1295                                                              array('errno'=>ldap_errno($ldapconnection),
1296                                                                    'errstring'=>ldap_err2str(ldap_errno($ldapconnection)))));
1297                 }
1299         }
1301         $this->ldap_close();
1302         return $result;
1303     }
1305     /**
1306      * Take expirationtime and return it as unix timestamp in seconds
1307      *
1308      * Takes expiration timestamp as read from LDAP and returns it as unix timestamp in seconds
1309      * Depends on $this->config->user_type variable
1310      *
1311      * @param mixed time   Time stamp read from LDAP as it is.
1312      * @param string $ldapconnection Only needed for Active Directory.
1313      * @param string $user_dn User distinguished name for the user we are checking password expiration (only needed for Active Directory).
1314      * @return timestamp
1315      */
1316     function ldap_expirationtime2unix ($time, $ldapconnection, $user_dn) {
1317         $result = false;
1318         switch ($this->config->user_type) {
1319             case 'edir':
1320                 $yr=substr($time, 0, 4);
1321                 $mo=substr($time, 4, 2);
1322                 $dt=substr($time, 6, 2);
1323                 $hr=substr($time, 8, 2);
1324                 $min=substr($time, 10, 2);
1325                 $sec=substr($time, 12, 2);
1326                 $result = mktime($hr, $min, $sec, $mo, $dt, $yr);
1327                 break;
1328             case 'rfc2307':
1329             case 'rfc2307bis':
1330                 $result = $time * DAYSECS; // The shadowExpire contains the number of DAYS between 01/01/1970 and the actual expiration date
1331                 break;
1332             case 'ad':
1333                 $result = $this->ldap_get_ad_pwdexpire($time, $ldapconnection, $user_dn);
1334                 break;
1335             default:
1336                 print_error('auth_ldap_usertypeundefined', 'auth_ldap');
1337         }
1338         return $result;
1339     }
1341     /**
1342      * Takes unix timestamp and returns it formated for storing in LDAP
1343      *
1344      * @param integer unix time stamp
1345      */
1346     function ldap_unix2expirationtime($time) {
1347         $result = false;
1348         switch ($this->config->user_type) {
1349             case 'edir':
1350                 $result=date('YmdHis', $time).'Z';
1351                 break;
1352             case 'rfc2307':
1353             case 'rfc2307bis':
1354                 $result = $time ; // Already in correct format
1355                 break;
1356             default:
1357                 print_error('auth_ldap_usertypeundefined2', 'auth_ldap');
1358         }
1359         return $result;
1361     }
1363     /**
1364      * Returns user attribute mappings between moodle and LDAP
1365      *
1366      * @return array
1367      */
1369     function ldap_attributes () {
1370         $moodleattributes = array();
1371         foreach ($this->userfields as $field) {
1372             if (!empty($this->config->{"field_map_$field"})) {
1373                 $moodleattributes[$field] = textlib::strtolower(trim($this->config->{"field_map_$field"}));
1374                 if (preg_match('/,/', $moodleattributes[$field])) {
1375                     $moodleattributes[$field] = explode(',', $moodleattributes[$field]); // split ?
1376                 }
1377             }
1378         }
1379         $moodleattributes['username'] = textlib::strtolower(trim($this->config->user_attribute));
1380         return $moodleattributes;
1381     }
1383     /**
1384      * Returns all usernames from LDAP
1385      *
1386      * @param $filter An LDAP search filter to select desired users
1387      * @return array of LDAP user names converted to UTF-8
1388      */
1389     function ldap_get_userlist($filter='*') {
1390         $fresult = array();
1392         $ldapconnection = $this->ldap_connect();
1394         if ($filter == '*') {
1395            $filter = '(&('.$this->config->user_attribute.'=*)'.$this->config->objectclass.')';
1396         }
1398         $contexts = explode(';', $this->config->contexts);
1399         if (!empty($this->config->create_context)) {
1400               array_push($contexts, $this->config->create_context);
1401         }
1403         foreach ($contexts as $context) {
1404             $context = trim($context);
1405             if (empty($context)) {
1406                 continue;
1407             }
1409             if ($this->config->search_sub) {
1410                 // Use ldap_search to find first user from subtree
1411                 $ldap_result = ldap_search($ldapconnection, $context,
1412                                            $filter,
1413                                            array($this->config->user_attribute));
1414             } else {
1415                 // Search only in this context
1416                 $ldap_result = ldap_list($ldapconnection, $context,
1417                                          $filter,
1418                                          array($this->config->user_attribute));
1419             }
1421             if(!$ldap_result) {
1422                 continue;
1423             }
1425             $users = ldap_get_entries_moodle($ldapconnection, $ldap_result);
1427             // Add found users to list
1428             for ($i = 0; $i < count($users); $i++) {
1429                 $extuser = textlib::convert($users[$i][$this->config->user_attribute][0],
1430                                              $this->config->ldapencoding, 'utf-8');
1431                 array_push($fresult, $extuser);
1432             }
1433         }
1435         $this->ldap_close();
1436         return $fresult;
1437     }
1439     /**
1440      * Indicates if password hashes should be stored in local moodle database.
1441      *
1442      * @return bool true means flag 'not_cached' stored instead of password hash
1443      */
1444     function prevent_local_passwords() {
1445         return !empty($this->config->preventpassindb);
1446     }
1448     /**
1449      * Returns true if this authentication plugin is 'internal'.
1450      *
1451      * @return bool
1452      */
1453     function is_internal() {
1454         return false;
1455     }
1457     /**
1458      * Returns true if this authentication plugin can change the user's
1459      * password.
1460      *
1461      * @return bool
1462      */
1463     function can_change_password() {
1464         return !empty($this->config->stdchangepassword) or !empty($this->config->changepasswordurl);
1465     }
1467     /**
1468      * Returns the URL for changing the user's password, or empty if the default can
1469      * be used.
1470      *
1471      * @return moodle_url
1472      */
1473     function change_password_url() {
1474         if (empty($this->config->stdchangepassword)) {
1475             return new moodle_url($this->config->changepasswordurl);
1476         } else {
1477             return null;
1478         }
1479     }
1481     /**
1482      * Will get called before the login page is shownr. Ff NTLM SSO
1483      * is enabled, and the user is in the right network, we'll redirect
1484      * to the magic NTLM page for SSO...
1485      *
1486      */
1487     function loginpage_hook() {
1488         global $CFG, $SESSION;
1490         // HTTPS is potentially required
1491         //httpsrequired(); - this must be used before setting the URL, it is already done on the login/index.php
1493         if (($_SERVER['REQUEST_METHOD'] === 'GET'         // Only on initial GET of loginpage
1494              || ($_SERVER['REQUEST_METHOD'] === 'POST'
1495                  && (get_referer() != strip_querystring(qualified_me()))))
1496                                                           // Or when POSTed from another place
1497                                                           // See MDL-14071
1498             && !empty($this->config->ntlmsso_enabled)     // SSO enabled
1499             && !empty($this->config->ntlmsso_subnet)      // have a subnet to test for
1500             && empty($_GET['authldap_skipntlmsso'])       // haven't failed it yet
1501             && (isguestuser() || !isloggedin())           // guestuser or not-logged-in users
1502             && address_in_subnet(getremoteaddr(), $this->config->ntlmsso_subnet)) {
1504             // First, let's remember where we were trying to get to before we got here
1505             if (empty($SESSION->wantsurl)) {
1506                 $SESSION->wantsurl = (array_key_exists('HTTP_REFERER', $_SERVER) &&
1507                                       $_SERVER['HTTP_REFERER'] != $CFG->wwwroot &&
1508                                       $_SERVER['HTTP_REFERER'] != $CFG->wwwroot.'/' &&
1509                                       $_SERVER['HTTP_REFERER'] != $CFG->httpswwwroot.'/login/' &&
1510                                       $_SERVER['HTTP_REFERER'] != $CFG->httpswwwroot.'/login/index.php')
1511                     ? $_SERVER['HTTP_REFERER'] : NULL;
1512             }
1514             // Now start the whole NTLM machinery.
1515             if(!empty($this->config->ntlmsso_ie_fastpath)) {
1516                 // Shortcut for IE browsers: skip the attempt page
1517                 if(check_browser_version('MSIE')) {
1518                     $sesskey = sesskey();
1519                     redirect($CFG->wwwroot.'/auth/ldap/ntlmsso_magic.php?sesskey='.$sesskey);
1520                 } else {
1521                     redirect($CFG->httpswwwroot.'/login/index.php?authldap_skipntlmsso=1');
1522                 }
1523             } else {
1524                 redirect($CFG->wwwroot.'/auth/ldap/ntlmsso_attempt.php');
1525             }
1526         }
1528         // No NTLM SSO, Use the normal login page instead.
1530         // If $SESSION->wantsurl is empty and we have a 'Referer:' header, the login
1531         // page insists on redirecting us to that page after user validation. If
1532         // we clicked on the redirect link at the ntlmsso_finish.php page (instead
1533         // of waiting for the redirection to happen) then we have a 'Referer:' header
1534         // we don't want to use at all. As we can't get rid of it, just point
1535         // $SESSION->wantsurl to $CFG->wwwroot (after all, we came from there).
1536         if (empty($SESSION->wantsurl)
1537             && (get_referer() == $CFG->httpswwwroot.'/auth/ldap/ntlmsso_finish.php')) {
1539             $SESSION->wantsurl = $CFG->wwwroot;
1540         }
1541     }
1543     /**
1544      * To be called from a page running under NTLM's
1545      * "Integrated Windows Authentication".
1546      *
1547      * If successful, it will set a special "cookie" (not an HTTP cookie!)
1548      * in cache_flags under the $this->pluginconfig/ntlmsess "plugin" and return true.
1549      * The "cookie" will be picked up by ntlmsso_finish() to complete the
1550      * process.
1551      *
1552      * On failure it will return false for the caller to display an appropriate
1553      * error message (probably saying that Integrated Windows Auth isn't enabled!)
1554      *
1555      * NOTE that this code will execute under the OS user credentials,
1556      * so we MUST avoid dealing with files -- such as session files.
1557      * (The caller should define('NO_MOODLE_COOKIES', true) before including config.php)
1558      *
1559      */
1560     function ntlmsso_magic($sesskey) {
1561         if (isset($_SERVER['REMOTE_USER']) && !empty($_SERVER['REMOTE_USER'])) {
1563             // HTTP __headers__ seem to be sent in ISO-8859-1 encoding
1564             // (according to my reading of RFC-1945, RFC-2616 and RFC-2617 and
1565             // my local tests), so we need to convert the REMOTE_USER value
1566             // (i.e., what we got from the HTTP WWW-Authenticate header) into UTF-8
1567             $username = textlib::convert($_SERVER['REMOTE_USER'], 'iso-8859-1', 'utf-8');
1569             switch ($this->config->ntlmsso_type) {
1570                 case 'ntlm':
1571                     // Format is DOMAIN\username
1572                     $username = substr(strrchr($username, '\\'), 1);
1573                     break;
1574                 case 'kerberos':
1575                     // Format is username@DOMAIN
1576                     $username = substr($username, 0, strpos($username, '@'));
1577                     break;
1578                 default:
1579                     error_log($this->errorlogtag.get_string ('ntlmsso_unknowntype', 'auth_ldap'));
1580                     return false; // Should never happen!
1581             }
1583             $username = textlib::strtolower($username); // Compatibility hack
1584             set_cache_flag($this->pluginconfig.'/ntlmsess', $sesskey, $username, AUTH_NTLMTIMEOUT);
1585             return true;
1586         }
1587         return false;
1588     }
1590     /**
1591      * Find the session set by ntlmsso_magic(), validate it and
1592      * call authenticate_user_login() to authenticate the user through
1593      * the auth machinery.
1594      *
1595      * It is complemented by a similar check in user_login().
1596      *
1597      * If it succeeds, it never returns.
1598      *
1599      */
1600     function ntlmsso_finish() {
1601         global $CFG, $USER, $SESSION;
1603         $key = sesskey();
1604         $cf = get_cache_flags($this->pluginconfig.'/ntlmsess');
1605         if (!isset($cf[$key]) || $cf[$key] === '') {
1606             return false;
1607         }
1608         $username   = $cf[$key];
1609         // Here we want to trigger the whole authentication machinery
1610         // to make sure no step is bypassed...
1611         $user = authenticate_user_login($username, $key);
1612         if ($user) {
1613             add_to_log(SITEID, 'user', 'login', "view.php?id=$USER->id&course=".SITEID,
1614                        $user->id, 0, $user->id);
1615             complete_user_login($user);
1617             // Cleanup the key to prevent reuse...
1618             // and to allow re-logins with normal credentials
1619             unset_cache_flag($this->pluginconfig.'/ntlmsess', $key);
1621             // Redirection
1622             if (user_not_fully_set_up($USER)) {
1623                 $urltogo = $CFG->wwwroot.'/user/edit.php';
1624                 // We don't delete $SESSION->wantsurl yet, so we get there later
1625             } else if (isset($SESSION->wantsurl) and (strpos($SESSION->wantsurl, $CFG->wwwroot) === 0)) {
1626                 $urltogo = $SESSION->wantsurl;    // Because it's an address in this site
1627                 unset($SESSION->wantsurl);
1628             } else {
1629                 // No wantsurl stored or external - go to homepage
1630                 $urltogo = $CFG->wwwroot.'/';
1631                 unset($SESSION->wantsurl);
1632             }
1633             redirect($urltogo);
1634         }
1635         // Should never reach here.
1636         return false;
1637     }
1639     /**
1640      * Sync roles for this user
1641      *
1642      * @param $user object user object (without system magic quotes)
1643      */
1644     function sync_roles($user) {
1645         $iscreator = $this->iscreator($user->username);
1646         if ($iscreator === null) {
1647             return; // Nothing to sync - creators not configured
1648         }
1650         if ($roles = get_archetype_roles('coursecreator')) {
1651             $creatorrole = array_shift($roles);      // We can only use one, let's use the first one
1652             $systemcontext = get_context_instance(CONTEXT_SYSTEM);
1654             if ($iscreator) { // Following calls will not create duplicates
1655                 role_assign($creatorrole->id, $user->id, $systemcontext->id, $this->roleauth);
1656             } else {
1657                 // Unassign only if previously assigned by this plugin!
1658                 role_unassign($creatorrole->id, $user->id, $systemcontext->id, $this->roleauth);
1659             }
1660         }
1661     }
1663     /**
1664      * Prints a form for configuring this authentication plugin.
1665      *
1666      * This function is called from admin/auth.php, and outputs a full page with
1667      * a form for configuring this plugin.
1668      *
1669      * @param array $page An object containing all the data for this page.
1670      */
1671     function config_form($config, $err, $user_fields) {
1672         global $CFG, $OUTPUT;
1674         if (!function_exists('ldap_connect')) { // Is php-ldap really there?
1675             echo $OUTPUT->notification(get_string('auth_ldap_noextension', 'auth_ldap'));
1676             return;
1677         }
1679         include($CFG->dirroot.'/auth/ldap/config.html');
1680     }
1682     /**
1683      * Processes and stores configuration data for this authentication plugin.
1684      */
1685     function process_config($config) {
1686         // Set to defaults if undefined
1687         if (!isset($config->host_url)) {
1688              $config->host_url = '';
1689         }
1690         if (empty($config->ldapencoding)) {
1691          $config->ldapencoding = 'utf-8';
1692         }
1693         if (!isset($config->contexts)) {
1694              $config->contexts = '';
1695         }
1696         if (!isset($config->user_type)) {
1697              $config->user_type = 'default';
1698         }
1699         if (!isset($config->user_attribute)) {
1700              $config->user_attribute = '';
1701         }
1702         if (!isset($config->search_sub)) {
1703              $config->search_sub = '';
1704         }
1705         if (!isset($config->opt_deref)) {
1706              $config->opt_deref = LDAP_DEREF_NEVER;
1707         }
1708         if (!isset($config->preventpassindb)) {
1709              $config->preventpassindb = 0;
1710         }
1711         if (!isset($config->bind_dn)) {
1712             $config->bind_dn = '';
1713         }
1714         if (!isset($config->bind_pw)) {
1715             $config->bind_pw = '';
1716         }
1717         if (!isset($config->ldap_version)) {
1718             $config->ldap_version = '3';
1719         }
1720         if (!isset($config->objectclass)) {
1721             $config->objectclass = '';
1722         }
1723         if (!isset($config->memberattribute)) {
1724             $config->memberattribute = '';
1725         }
1726         if (!isset($config->memberattribute_isdn)) {
1727             $config->memberattribute_isdn = '';
1728         }
1729         if (!isset($config->creators)) {
1730             $config->creators = '';
1731         }
1732         if (!isset($config->create_context)) {
1733             $config->create_context = '';
1734         }
1735         if (!isset($config->expiration)) {
1736             $config->expiration = '';
1737         }
1738         if (!isset($config->expiration_warning)) {
1739             $config->expiration_warning = '10';
1740         }
1741         if (!isset($config->expireattr)) {
1742             $config->expireattr = '';
1743         }
1744         if (!isset($config->gracelogins)) {
1745             $config->gracelogins = '';
1746         }
1747         if (!isset($config->graceattr)) {
1748             $config->graceattr = '';
1749         }
1750         if (!isset($config->auth_user_create)) {
1751             $config->auth_user_create = '';
1752         }
1753         if (!isset($config->forcechangepassword)) {
1754             $config->forcechangepassword = 0;
1755         }
1756         if (!isset($config->stdchangepassword)) {
1757             $config->stdchangepassword = 0;
1758         }
1759         if (!isset($config->passtype)) {
1760             $config->passtype = 'plaintext';
1761         }
1762         if (!isset($config->changepasswordurl)) {
1763             $config->changepasswordurl = '';
1764         }
1765         if (!isset($config->removeuser)) {
1766             $config->removeuser = AUTH_REMOVEUSER_KEEP;
1767         }
1768         if (!isset($config->ntlmsso_enabled)) {
1769             $config->ntlmsso_enabled = 0;
1770         }
1771         if (!isset($config->ntlmsso_subnet)) {
1772             $config->ntlmsso_subnet = '';
1773         }
1774         if (!isset($config->ntlmsso_ie_fastpath)) {
1775             $config->ntlmsso_ie_fastpath = 0;
1776         }
1777         if (!isset($config->ntlmsso_type)) {
1778             $config->ntlmsso_type = 'ntlm';
1779         }
1781         // Try to remove duplicates before storing the contexts (to avoid problems in sync_users()).
1782         $config->contexts = explode(';', $config->contexts);
1783         $config->contexts = array_map(create_function('$x', 'return textlib::strtolower(trim($x));'),
1784                                       $config->contexts);
1785         $config->contexts = implode(';', array_unique($config->contexts));
1787         // Save settings
1788         set_config('host_url', trim($config->host_url), $this->pluginconfig);
1789         set_config('ldapencoding', trim($config->ldapencoding), $this->pluginconfig);
1790         set_config('contexts', $config->contexts, $this->pluginconfig);
1791         set_config('user_type', textlib::strtolower(trim($config->user_type)), $this->pluginconfig);
1792         set_config('user_attribute', textlib::strtolower(trim($config->user_attribute)), $this->pluginconfig);
1793         set_config('search_sub', $config->search_sub, $this->pluginconfig);
1794         set_config('opt_deref', $config->opt_deref, $this->pluginconfig);
1795         set_config('preventpassindb', $config->preventpassindb, $this->pluginconfig);
1796         set_config('bind_dn', trim($config->bind_dn), $this->pluginconfig);
1797         set_config('bind_pw', $config->bind_pw, $this->pluginconfig);
1798         set_config('ldap_version', $config->ldap_version, $this->pluginconfig);
1799         set_config('objectclass', trim($config->objectclass), $this->pluginconfig);
1800         set_config('memberattribute', textlib::strtolower(trim($config->memberattribute)), $this->pluginconfig);
1801         set_config('memberattribute_isdn', $config->memberattribute_isdn, $this->pluginconfig);
1802         set_config('creators', trim($config->creators), $this->pluginconfig);
1803         set_config('create_context', trim($config->create_context), $this->pluginconfig);
1804         set_config('expiration', $config->expiration, $this->pluginconfig);
1805         set_config('expiration_warning', trim($config->expiration_warning), $this->pluginconfig);
1806         set_config('expireattr', textlib::strtolower(trim($config->expireattr)), $this->pluginconfig);
1807         set_config('gracelogins', $config->gracelogins, $this->pluginconfig);
1808         set_config('graceattr', textlib::strtolower(trim($config->graceattr)), $this->pluginconfig);
1809         set_config('auth_user_create', $config->auth_user_create, $this->pluginconfig);
1810         set_config('forcechangepassword', $config->forcechangepassword, $this->pluginconfig);
1811         set_config('stdchangepassword', $config->stdchangepassword, $this->pluginconfig);
1812         set_config('passtype', $config->passtype, $this->pluginconfig);
1813         set_config('changepasswordurl', trim($config->changepasswordurl), $this->pluginconfig);
1814         set_config('removeuser', $config->removeuser, $this->pluginconfig);
1815         set_config('ntlmsso_enabled', (int)$config->ntlmsso_enabled, $this->pluginconfig);
1816         set_config('ntlmsso_subnet', trim($config->ntlmsso_subnet), $this->pluginconfig);
1817         set_config('ntlmsso_ie_fastpath', (int)$config->ntlmsso_ie_fastpath, $this->pluginconfig);
1818         set_config('ntlmsso_type', $config->ntlmsso_type, 'auth/ldap');
1820         return true;
1821     }
1823     /**
1824      * Get password expiration time for a given user from Active Directory
1825      *
1826      * @param string $pwdlastset The time last time we changed the password.
1827      * @param resource $lcapconn The open LDAP connection.
1828      * @param string $user_dn The distinguished name of the user we are checking.
1829      *
1830      * @return string $unixtime
1831      */
1832     function ldap_get_ad_pwdexpire($pwdlastset, $ldapconn, $user_dn){
1833         global $CFG;
1835         if (!function_exists('bcsub')) {
1836             error_log($this->errorlogtag.get_string ('needbcmath', 'auth_ldap'));
1837             return 0;
1838         }
1840         // If UF_DONT_EXPIRE_PASSWD flag is set in user's
1841         // userAccountControl attribute, the password doesn't expire.
1842         $sr = ldap_read($ldapconn, $user_dn, '(objectClass=*)',
1843                         array('userAccountControl'));
1844         if (!$sr) {
1845             error_log($this->errorlogtag.get_string ('useracctctrlerror', 'auth_ldap', $user_dn));
1846             // Don't expire password, as we are not sure if it has to be
1847             // expired or not.
1848             return 0;
1849         }
1851         $entry = ldap_get_entries_moodle($ldapconn, $sr);
1852         $info = array_change_key_case($entry[0], CASE_LOWER);
1853         $useraccountcontrol = $info['useraccountcontrol'][0];
1854         if ($useraccountcontrol & UF_DONT_EXPIRE_PASSWD) {
1855             // Password doesn't expire.
1856             return 0;
1857         }
1859         // If pwdLastSet is zero, the user must change his/her password now
1860         // (unless UF_DONT_EXPIRE_PASSWD flag is set, but we already
1861         // tested this above)
1862         if ($pwdlastset === '0') {
1863             // Password has expired
1864             return -1;
1865         }
1867         // ----------------------------------------------------------------
1868         // Password expiration time in Active Directory is the composition of
1869         // two values:
1870         //
1871         //   - User's pwdLastSet attribute, that stores the last time
1872         //     the password was changed.
1873         //
1874         //   - Domain's maxPwdAge attribute, that sets how long
1875         //     passwords last in this domain.
1876         //
1877         // We already have the first value (passed in as a parameter). We
1878         // need to get the second one. As we don't know the domain DN, we
1879         // have to query rootDSE's defaultNamingContext attribute to get
1880         // it. Then we have to query that DN's maxPwdAge attribute to get
1881         // the real value.
1882         //
1883         // Once we have both values, we just need to combine them. But MS
1884         // chose to use a different base and unit for time measurements.
1885         // So we need to convert the values to Unix timestamps (see
1886         // details below).
1887         // ----------------------------------------------------------------
1889         $sr = ldap_read($ldapconn, ROOTDSE, '(objectClass=*)',
1890                         array('defaultNamingContext'));
1891         if (!$sr) {
1892             error_log($this->errorlogtag.get_string ('rootdseerror', 'auth_ldap'));
1893             return 0;
1894         }
1896         $entry = ldap_get_entries_moodle($ldapconn, $sr);
1897         $info = array_change_key_case($entry[0], CASE_LOWER);
1898         $domaindn = $info['defaultnamingcontext'][0];
1900         $sr = ldap_read ($ldapconn, $domaindn, '(objectClass=*)',
1901                          array('maxPwdAge'));
1902         $entry = ldap_get_entries_moodle($ldapconn, $sr);
1903         $info = array_change_key_case($entry[0], CASE_LOWER);
1904         $maxpwdage = $info['maxpwdage'][0];
1906         // ----------------------------------------------------------------
1907         // MSDN says that "pwdLastSet contains the number of 100 nanosecond
1908         // intervals since January 1, 1601 (UTC), stored in a 64 bit integer".
1909         //
1910         // According to Perl's Date::Manip, the number of seconds between
1911         // this date and Unix epoch is 11644473600. So we have to
1912         // substract this value to calculate a Unix time, once we have
1913         // scaled pwdLastSet to seconds. This is the script used to
1914         // calculate the value shown above:
1915         //
1916         //    #!/usr/bin/perl -w
1917         //
1918         //    use Date::Manip;
1919         //
1920         //    $date1 = ParseDate ("160101010000 UTC");
1921         //    $date2 = ParseDate ("197001010000 UTC");
1922         //    $delta = DateCalc($date1, $date2, \$err);
1923         //    $secs = Delta_Format($delta, 0, "%st");
1924         //    print "$secs \n";
1925         //
1926         // MSDN also says that "maxPwdAge is stored as a large integer that
1927         // represents the number of 100 nanosecond intervals from the time
1928         // the password was set before the password expires." We also need
1929         // to scale this to seconds. Bear in mind that this value is stored
1930         // as a _negative_ quantity (at least in my AD domain).
1931         //
1932         // As a last remark, if the low 32 bits of maxPwdAge are equal to 0,
1933         // the maximum password age in the domain is set to 0, which means
1934         // passwords do not expire (see
1935         // http://msdn2.microsoft.com/en-us/library/ms974598.aspx)
1936         //
1937         // As the quantities involved are too big for PHP integers, we
1938         // need to use BCMath functions to work with arbitrary precision
1939         // numbers.
1940         // ----------------------------------------------------------------
1942         // If the low order 32 bits are 0, then passwords do not expire in
1943         // the domain. Just do '$maxpwdage mod 2^32' and check the result
1944         // (2^32 = 4294967296)
1945         if (bcmod ($maxpwdage, 4294967296) === '0') {
1946             return 0;
1947         }
1949         // Add up pwdLastSet and maxPwdAge to get password expiration
1950         // time, in MS time units. Remember maxPwdAge is stored as a
1951         // _negative_ quantity, so we need to substract it in fact.
1952         $pwdexpire = bcsub ($pwdlastset, $maxpwdage);
1954         // Scale the result to convert it to Unix time units and return
1955         // that value.
1956         return bcsub( bcdiv($pwdexpire, '10000000'), '11644473600');
1957     }
1959     /**
1960      * Connect to the LDAP server, using the plugin configured
1961      * settings. It's actually a wrapper around ldap_connect_moodle()
1962      *
1963      * @return resource A valid LDAP connection (or dies if it can't connect)
1964      */
1965     function ldap_connect() {
1966         // Cache ldap connections. They are expensive to set up
1967         // and can drain the TCP/IP ressources on the server if we
1968         // are syncing a lot of users (as we try to open a new connection
1969         // to get the user details). This is the least invasive way
1970         // to reuse existing connections without greater code surgery.
1971         if(!empty($this->ldapconnection)) {
1972             $this->ldapconns++;
1973             return $this->ldapconnection;
1974         }
1976         if($ldapconnection = ldap_connect_moodle($this->config->host_url, $this->config->ldap_version,
1977                                                  $this->config->user_type, $this->config->bind_dn,
1978                                                  $this->config->bind_pw, $this->config->opt_deref,
1979                                                  $debuginfo)) {
1980             $this->ldapconns = 1;
1981             $this->ldapconnection = $ldapconnection;
1982             return $ldapconnection;
1983         }
1985         print_error('auth_ldap_noconnect_all', 'auth_ldap', '', $debuginfo);
1986     }
1988     /**
1989      * Disconnects from a LDAP server
1990      *
1991      */
1992     function ldap_close() {
1993         $this->ldapconns--;
1994         if($this->ldapconns == 0) {
1995             @ldap_close($this->ldapconnection);
1996             unset($this->ldapconnection);
1997         }
1998     }
2000     /**
2001      * Search specified contexts for username and return the user dn
2002      * like: cn=username,ou=suborg,o=org. It's actually a wrapper
2003      * around ldap_find_userdn().
2004      *
2005      * @param resource $ldapconnection a valid LDAP connection
2006      * @param string $extusername the username to search (in external LDAP encoding, no db slashes)
2007      * @return mixed the user dn (external LDAP encoding) or false
2008      */
2009     function ldap_find_userdn($ldapconnection, $extusername) {
2010         $ldap_contexts = explode(';', $this->config->contexts);
2011         if (!empty($this->config->create_context)) {
2012             array_push($ldap_contexts, $this->config->create_context);
2013         }
2015         return ldap_find_userdn($ldapconnection, $extusername, $ldap_contexts, $this->config->objectclass,
2016                                 $this->config->user_attribute, $this->config->search_sub);
2017     }
2019 } // End of the class