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