86ec4bbc55b350604fd3d6ba9c8472740b785c8d
[moodle.git] / auth / ldap / auth.php
1 <?php
3 /**
4  * @author Martin Dougiamas
5  * @license http://www.gnu.org/copyleft/gpl.html GNU Public License
6  * @package moodle multiauth
7  *
8  * Authentication Plugin: LDAP Authentication
9  *
10  * Authentication using LDAP (Lightweight Directory Access Protocol).
11  *
12  * 2006-08-28  File created.
13  */
15 if (!defined('MOODLE_INTERNAL')) {
16     die('Direct access to this script is forbidden.');    ///  It must be included from a Moodle page
17 }
19 // See http://support.microsoft.com/kb/305144 to interprete these values.
20 if (!defined('AUTH_AD_ACCOUNTDISABLE')) {
21     define('AUTH_AD_ACCOUNTDISABLE', 0x0002);
22 }
23 if (!defined('AUTH_AD_NORMAL_ACCOUNT')) {
24     define('AUTH_AD_NORMAL_ACCOUNT', 0x0200);
25 }
26 if (!defined('AUTH_NTLMTIMEOUT')) {  // timewindow for the NTLM SSO process, in secs...
27     define('AUTH_NTLMTIMEOUT', 10);
28 }
31 require_once($CFG->libdir.'/authlib.php');
33 /**
34  * LDAP authentication plugin.
35  */
36 class auth_plugin_ldap extends auth_plugin_base {
38     /**
39      * Constructor with initialisation.
40      */
41     function auth_plugin_ldap() {
42         $this->authtype = 'ldap';
43         $this->config = get_config('auth/ldap');
44         if (empty($this->config->ldapencoding)) {
45             $this->config->ldapencoding = 'utf-8';
46         }
47         if (empty($this->config->user_type)) {
48             $this->config->user_type = 'default';
49         }
51         $default = $this->ldap_getdefaults();
53         //use defaults if values not given
54         foreach ($default as $key => $value) {
55             // watch out - 0, false are correct values too
56             if (!isset($this->config->{$key}) or $this->config->{$key} == '') {
57                 $this->config->{$key} = $value[$this->config->user_type];
58             }
59         }
61         // Hack prefix to objectclass
62         if (empty($this->config->objectclass)) {
63             // Can't send empty filter
64             $this->config->objectclass='(objectClass=*)';
65         } else if (stripos($this->config->objectclass, 'objectClass=') === 0) {
66             // Value is 'objectClass=some-string-here', so just add ()
67             // around the value (filter _must_ have them).
68             $this->config->objectclass = '('.$this->config->objectclass.')';
69         } else if (stripos($this->config->objectclass, '(') !== 0) {
70             // Value is 'some-string-not-starting-with-left-parentheses',
71             // which is assumed to be the objectClass matching value.
72             // So build a valid filter with it.
73             $this->config->objectclass = '(objectClass='.$this->config->objectclass.')';
74         } else {
75             // There is an additional possible value
76             // '(some-string-here)', that can be used to specify any
77             // valid filter string, to select subsets of users based
78             // on any criteria. For example, we could select the users
79             // whose objectClass is 'user' and have the
80             // 'enabledMoodleUser' attribute, with something like:
81             //
82             //   (&(objectClass=user)(enabledMoodleUser=1))
83             //
84             // This is only used in the functions that deal with the
85             // whole potential set of users (currently sync_users()
86             // and get_user_list() only).
87             //
88             // In this particular case we don't need to do anything,
89             // so leave $this->config->objectclass as is.
90         }
92     }
94     /**
95      * Returns true if the username and password work and false if they are
96      * wrong or don't exist.
97      *
98      * @param string $username The username (with system magic quotes)
99      * @param string $password The password (with system magic quotes)
100      *
101      * @return bool Authentication success or failure.
102      */
103     function user_login($username, $password) {
104         if (! function_exists('ldap_bind')) {
105             print_error('auth_ldapnotinstalled','auth_ldap');
106             return false;
107         }
109         if (!$username or !$password) {    // Don't allow blank usernames or passwords
110             return false;
111         }
113         $textlib = textlib_get_instance();
114         $extusername = $textlib->convert($username, 'utf-8', $this->config->ldapencoding);
115         $extpassword = $textlib->convert($password, 'utf-8', $this->config->ldapencoding);
117         //
118         // Before we connect to LDAP, check if this is an AD SSO login
119         // if we succeed in this block, we'll return success early.
120         //
121         $key = sesskey();
122         if (!empty($this->config->ntlmsso_enabled) && $key === $password) {
123             $cf = get_cache_flags('auth/ldap/ntlmsess');
124             // We only get the cache flag if we retrieve it before
125             // it expires (AUTH_NTLMTIMEOUT seconds).
126             if (!isset($cf[$key]) || $cf[$key] === '') {
127                 return false;
128             }
130             $sessusername = $cf[$key];
131             if ($username === $sessusername) {
132                 unset($sessusername);
133                 unset($cf);
135                 // Check that the user is inside one of the configured LDAP contexts
136                 $validuser = false;
137                 $ldapconnection = $this->ldap_connect();
138                 if ($ldapconnection) {
139                     // if the user is not inside the configured contexts,
140                     // ldap_find_userdn returns false.
141                     if ($this->ldap_find_userdn($ldapconnection, $extusername)) {
142                         $validuser = true;
143                     }
144                     $this->ldap_close();
145                 }
147                 // Shortcut here - SSO confirmed
148                 return $validuser;
149             }
150         } // End SSO processing
151         unset($key);
153         $ldapconnection = $this->ldap_connect();
154         if ($ldapconnection) {
155             $ldap_user_dn = $this->ldap_find_userdn($ldapconnection, $extusername);
157             //if ldap_user_dn is empty, user does not exist
158             if (!$ldap_user_dn) {
159                 $this->ldap_close();
160                 return false;
161             }
163             // Try to bind with current username and password
164             $ldap_login = @ldap_bind($ldapconnection, $ldap_user_dn, $extpassword);
165             $this->ldap_close();
166             if ($ldap_login) {
167                 return true;
168             }
169         }
170         else {
171             $this->ldap_close();
172             print_error('auth_ldap_noconnect','auth_ldap','',$this->config->host_url);
173         }
174         return false;
175     }
177     /**
178      * reads userinformation from ldap and return it in array()
179      *
180      * Read user information from external database and returns it as array().
181      * Function should return all information available. If you are saving
182      * this information to moodle user-table you should honor syncronization flags
183      *
184      * @param string $username username
185      *
186      * @return mixed array with no magic quotes or false on error
187      */
188     function get_userinfo($username) {
189         $textlib = textlib_get_instance();
190         $extusername = $textlib->convert($username, 'utf-8', $this->config->ldapencoding);
192         $ldapconnection = $this->ldap_connect();
193         $attrmap = $this->ldap_attributes();
195         $result = array();
196         $search_attribs = array();
198         foreach ($attrmap as $key=>$values) {
199             if (!is_array($values)) {
200                 $values = array($values);
201             }
202             foreach ($values as $value) {
203                 if (!in_array($value, $search_attribs)) {
204                     array_push($search_attribs, $value);
205                 }
206             }
207         }
209         $user_dn = $this->ldap_find_userdn($ldapconnection, $extusername);
211         if (!$user_info_result = ldap_read($ldapconnection, $user_dn, $this->config->objectclass, $search_attribs)) {
212             return false; // error!
213         }
214         $user_entry = $this->ldap_get_entries($ldapconnection, $user_info_result);
215         if (empty($user_entry)) {
216             return false; // entry not found
217         }
219         foreach ($attrmap as $key=>$values) {
220             if (!is_array($values)) {
221                 $values = array($values);
222             }
223             $ldapval = NULL;
224             foreach ($values as $value) {
225                 if ($value == 'dn') {
226                     $result[$key] = $user_dn;
227                 }
228                 if (!array_key_exists($value, $user_entry[0])) {
229                     continue; // wrong data mapping!
230                 }
231                 if (is_array($user_entry[0][$value])) {
232                     $newval = $textlib->convert($user_entry[0][$value][0], $this->config->ldapencoding, 'utf-8');
233                 } else {
234                     $newval = $textlib->convert($user_entry[0][$value], $this->config->ldapencoding, 'utf-8');
235                 }
236                 if (!empty($newval)) { // favour ldap entries that are set
237                     $ldapval = $newval;
238                 }
239             }
240             if (!is_null($ldapval)) {
241                 $result[$key] = $ldapval;
242             }
243         }
245         $this->ldap_close();
246         return $result;
247     }
249     /**
250      * reads userinformation from ldap and return it in an object
251      *
252      * @param string $username username (with system magic quotes)
253      * @return mixed object or false on error
254      */
255     function get_userinfo_asobj($username) {
256         $user_array = $this->get_userinfo($username);
257         if ($user_array == false) {
258             return false; //error or not found
259         }
260         $user_array = truncate_userinfo($user_array);
261         $user = new object();
262         foreach ($user_array as $key=>$value) {
263             $user->{$key} = $value;
264         }
265         return $user;
266     }
268     /**
269      * returns all usernames from external database
270      *
271      * get_userlist returns all usernames from external database
272      *
273      * @return array
274      */
275     function get_userlist() {
276         return $this->ldap_get_userlist("({$this->config->user_attribute}=*)");
277     }
279     /**
280      * checks if user exists on external db
281      *
282      * @param string $username
283      */
284     function user_exists($username) {
286         $textlib = textlib_get_instance();
287         $extusername = $textlib->convert($username, 'utf-8', $this->config->ldapencoding);
289         //returns true if given username exist on ldap
290         $users = $this->ldap_get_userlist("({$this->config->user_attribute}=".$this->filter_addslashes($extusername).")");
291         return count($users);
292     }
294     /**
295      * Creates a new user on external database.
296      * By using information in userobject
297      * Use user_exists to prevent dublicate usernames
298      *
299      * @param mixed $userobject  Moodle userobject
300      * @param mixed $plainpass   Plaintext password
301      */
302     function user_create($userobject, $plainpass) {
303         $textlib = textlib_get_instance();
304         $extusername = $textlib->convert($userobject->username, 'utf-8', $this->config->ldapencoding);
305         $extpassword = $textlib->convert($plainpass, 'utf-8', $this->config->ldapencoding);
307         switch ($this->config->passtype) {
308             case 'md5':
309                 $extpassword = '{MD5}' . base64_encode(pack('H*', md5($extpassword)));
310                 break;
311             case 'sha1':
312                 $extpassword = '{SHA}' . base64_encode(pack('H*', sha1($extpassword)));
313                 break;
314             case 'plaintext':
315             default:
316                 break; // plaintext
317         }
319         $ldapconnection = $this->ldap_connect();
320         $attrmap = $this->ldap_attributes();
322         $newuser = array();
324         foreach ($attrmap as $key => $values) {
325             if (!is_array($values)) {
326                 $values = array($values);
327             }
328             foreach ($values as $value) {
329                 if (!empty($userobject->$key) ) {
330                     $newuser[$value] = $textlib->convert($userobject->$key, 'utf-8', $this->config->ldapencoding);
331                 }
332             }
333         }
335         //Following sets all mandatory and other forced attribute values
336         //User should be creted as login disabled untill email confirmation is processed
337         //Feel free to add your user type and send patches to paca@sci.fi to add them
338         //Moodle distribution
340         switch ($this->config->user_type)  {
341             case 'edir':
342                 $newuser['objectClass']   = array("inetOrgPerson","organizationalPerson","person","top");
343                 $newuser['uniqueId']      = $extusername;
344                 $newuser['logindisabled'] = "TRUE";
345                 $newuser['userpassword']  = $extpassword;
346                 $uadd = ldap_add($ldapconnection, $this->config->user_attribute.'="'.$this->ldap_addslashes($userobject->username).','.$this->config->create_context.'"', $newuser);
347                 break;
348             case 'ad':
349                 // User account creation is a two step process with AD. First you
350                 // create the user object, then you set the password. If you try
351                 // to set the password while creating the user, the operation
352                 // fails.
354                 // Passwords in Active Directory must be encoded as Unicode
355                 // strings (UCS-2 Little Endian format) and surrounded with
356                 // double quotes. See http://support.microsoft.com/?kbid=269190
357                 if (!function_exists('mb_convert_encoding')) {
358                     print_error('auth_ldap_no_mbstring', 'auth_ldap');
359                 }
361                 // First create the user account, and mark it as disabled.
362                 $newuser['objectClass'] = array('top','person','user','organizationalPerson');
363                 $newuser['sAMAccountName'] = $extusername;
364                 $newuser['userAccountControl'] = AUTH_AD_NORMAL_ACCOUNT |
365                                                  AUTH_AD_ACCOUNTDISABLE;
366                 $userdn = 'cn=' .  $this->ldap_addslashes($extusername) .
367                           ',' . $this->config->create_context;
368                 if (!ldap_add($ldapconnection, $userdn, $newuser)) {
369                     print_error('auth_ldap_ad_create_req', 'auth_ldap');
370                 }
372                 // Now set the password
373                 unset($newuser);
374                 $newuser['unicodePwd'] = mb_convert_encoding('"' . $extpassword . '"',
375                                                              "UCS-2LE", "UTF-8");
376                 if(!ldap_modify($ldapconnection, $userdn, $newuser)) {
377                     // Something went wrong: delete the user account and error out
378                     ldap_delete ($ldapconnection, $userdn);
379                     print_error('auth_ldap_ad_create_req', 'auth_ldap');
380                 }
381                 $uadd = true;
382                 break;
383             default:
384                print_error('auth_ldap_unsupportedusertype','auth_ldap','',$this->config->user_type);
385         }
386         $this->ldap_close();
387         return $uadd;
389     }
391     function can_reset_password() {
392         return !empty($this->config->stdchangepassword);
393     }
395     function can_signup() {
396         return (!empty($this->config->auth_user_create) and !empty($this->config->create_context));
397     }
399     /**
400      * Sign up a new user ready for confirmation.
401      * Password is passed in plaintext.
402      *
403      * @param object $user new user object
404      * @param boolean $notify print notice with link and terminate
405      */
406     function user_signup($user, $notify=true) {
407         global $CFG, $DB;
409         require_once($CFG->dirroot.'/user/profile/lib.php');
411         if ($this->user_exists($user->username)) {
412             print_error('auth_ldap_user_exists', 'auth_ldap');
413         }
415         $plainslashedpassword = $user->password;
416         unset($user->password);
418         if (! $this->user_create($user, $plainslashedpassword)) {
419             print_error('auth_ldap_create_error', 'auth_ldap');
420         }
422         //TODO - username required to use PARAM_USERNAME before inserting into user table (MDL-16919)
423         if (! ($user->id = $DB->insert_record('user', $user)) ) {
424             print_error('auth_emailnoinsert', 'auth_email');
425         }
427         /// Save any custom profile field information
428         profile_save_data($user);
430         $this->update_user_record($user->username);
431         update_internal_user_password($user, $plainslashedpassword);
433         $user = $DB->get_record('user', array('id'=>$user->id));
434         events_trigger('user_created', $user);
436         if (! send_confirmation_email($user)) {
437             print_error('auth_emailnoemail', 'auth_email');
438         }
440         if ($notify) {
441             global $CFG;
442             $emailconfirm = get_string('emailconfirm');
443             $PAGE->navbar->add($emailconfirm);
444             $PAGE->set_title($emailconfirm);
445             $PAGE->set_heading($emailconfirm);
446             echo $OUTPUT->header();
447             notice(get_string('emailconfirmsent', '', $user->email), "$CFG->wwwroot/index.php");
448         } else {
449             return true;
450         }
451     }
453     /**
454      * Returns true if plugin allows confirming of new users.
455      *
456      * @return bool
457      */
458     function can_confirm() {
459         return $this->can_signup();
460     }
462     /**
463      * Confirm the new user as registered.
464      *
465      * @param string $username
466      * @param string $confirmsecret
467      */
468     function user_confirm($username, $confirmsecret) {
469         global $DB;
471         $user = get_complete_user_data('username', $username);
473         if (!empty($user)) {
474             if ($user->confirmed) {
475                 return AUTH_CONFIRM_ALREADY;
477             } else if ($user->auth != 'ldap') {
478                 return AUTH_CONFIRM_ERROR;
480             } else if ($user->secret == $confirmsecret) {   // They have provided the secret key to get in
481                 if (!$this->user_activate($username)) {
482                     return AUTH_CONFIRM_FAIL;
483                 }
484                 if (!$DB->set_field("user", "confirmed", 1, array("id"=>$user->id))) {
485                     return AUTH_CONFIRM_FAIL;
486                 }
487                 if (!$DB->set_field("user", "firstaccess", time(), array("id"=>$user->id))) {
488                     return AUTH_CONFIRM_FAIL;
489                 }
490                 return AUTH_CONFIRM_OK;
491             }
492         } else {
493             return AUTH_CONFIRM_ERROR;
494         }
495     }
497     /**
498      * return number of days to user password expires
499      *
500      * If userpassword does not expire it should return 0. If password is already expired
501      * it should return negative value.
502      *
503      * @param mixed $username username
504      * @return integer
505      */
506     function password_expire($username) {
507         $result = 0;
509         $textlib = textlib_get_instance();
510         $extusername = $textlib->convert($username, 'utf-8', $this->config->ldapencoding);
512         $ldapconnection = $this->ldap_connect();
513         $user_dn = $this->ldap_find_userdn($ldapconnection, $extusername);
514         $search_attribs = array($this->config->expireattr);
515         $sr = ldap_read($ldapconnection, $user_dn, '(objectClass=*)', $search_attribs);
516         if ($sr)  {
517             $info = $this->ldap_get_entries($ldapconnection, $sr);
518             if (!empty ($info) and !empty($info[0][$this->config->expireattr][0])) {
519                 $expiretime = $this->ldap_expirationtime2unix($info[0][$this->config->expireattr][0], $ldapconnection, $user_dn);
520                 if ($expiretime != 0) {
521                     $now = time();
522                     if ($expiretime > $now) {
523                         $result = ceil(($expiretime - $now) / DAYSECS);
524                     }
525                     else {
526                         $result = floor(($expiretime - $now) / DAYSECS);
527                     }
528                 }
529             }
530         } else {
531             error_log("ldap: password_expire did't find expiration time.");
532         }
534         //error_log("ldap: password_expire user $user_dn expires in $result days!");
535         return $result;
536     }
538     /**
539      * syncronizes user fron external db to moodle user table
540      *
541      * Sync is now using username attribute.
542      *
543      * Syncing users removes or suspends users that dont exists anymore in external db.
544      * Creates new users and updates coursecreator status of users.
545      *
546      * @param bool $do_updates will do pull in data updates from ldap if relevant
547      */
548     function sync_users($do_updates=true) {
549         global $CFG, $DB;
551         $textlib = textlib_get_instance();
552         $dbman = $DB->get_manager();
554     /// Define table user to be created
555         $table = new xmldb_table('tmp_extuser');
556         $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
557         $table->add_field('username', XMLDB_TYPE_CHAR, '100', null, XMLDB_NOTNULL, null, null);
558         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
559         $table->add_index('username', XMLDB_INDEX_UNIQUE, array('mnethostid', 'username'));
561         echo "Creating temp table $temptable\n";
562         if (!$dbman->create_temp_table($table)) {
563             print  "Failed to create temporary users table - aborting\n";
564             exit;
565         }
567         print "Connecting to ldap...\n";
568         $ldapconnection = $this->ldap_connect();
570         if (!$ldapconnection) {
571             $this->ldap_close();
572             print get_string('auth_ldap_noconnect','auth_ldap',$this->config->host_url);
573             exit;
574         }
576         ////
577         //// get user's list from ldap to sql in a scalable fashion
578         ////
579         // prepare some data we'll need
580         $filter = '(&('.$this->config->user_attribute.'=*)'.$this->config->objectclass.')';
582         $contexts = explode(";",$this->config->contexts);
584         if (!empty($this->config->create_context)) {
585               array_push($contexts, $this->config->create_context);
586         }
588         $fresult = array();
589         foreach ($contexts as $context) {
590             $context = trim($context);
591             if (empty($context)) {
592                 continue;
593             }
594             if ($this->config->search_sub) {
595                 //use ldap_search to find first user from subtree
596                 $ldap_result = ldap_search($ldapconnection, $context,
597                                            $filter,
598                                            array($this->config->user_attribute));
599             } else {
600                 //search only in this context
601                 $ldap_result = ldap_list($ldapconnection, $context,
602                                          $filter,
603                                          array($this->config->user_attribute));
604             }
606             if ($entry = ldap_first_entry($ldapconnection, $ldap_result)) {
607                 do {
608                     $value = ldap_get_values_len($ldapconnection, $entry, $this->config->user_attribute);
609                     $value = $textlib->convert($value[0], $this->config->ldapencoding, 'utf-8');
610                     $this->ldap_bulk_insert($value);
611                 } while ($entry = ldap_next_entry($ldapconnection, $entry));
612             }
613             unset($ldap_result); // free mem
614         }
616         /// preserve our user database
617         /// if the temp table is empty, it probably means that something went wrong, exit
618         /// so as to avoid mass deletion of users; which is hard to undo
619         $count = $DB->count_records_sql('SELECT COUNT(username) AS count, 1 FROM {tmp_extuser}');
620         if ($count < 1) {
621             print "Did not get any users from LDAP -- error? -- exiting\n";
622             exit;
623         } else {
624             print "Got $count records from LDAP\n\n";
625         }
628 /// User removal
629         // find users in DB that aren't in ldap -- to be removed!
630         // this is still not as scalable (but how often do we mass delete?)
631         if (!empty($this->config->removeuser)) {
632             $sql = "SELECT u.id, u.username, u.email, u.auth
633                       FROM {user} u
634                       LEFT JOIN {tmp_extuser} e ON (u.username = e.username AND u.mnethostid = ?)
635                      WHERE u.auth='ldap'
636                            AND u.deleted=0
637                            AND e.username IS NULL";
638             $remove_users = $DB->get_records_sql($sql, array($CFG->mnet_localhost_id));
640             if (!empty($remove_users)) {
641                 print "User entries to remove: ". count($remove_users) . "\n";
643                 foreach ($remove_users as $user) {
644                     if ($this->config->removeuser == AUTH_REMOVEUSER_FULLDELETE) {
645                         if (delete_user($user)) {
646                             echo "\t"; print_string('auth_dbdeleteuser', 'auth_db', array($user->username, $user->id)); echo "\n";
647                         } else {
648                             echo "\t"; print_string('auth_dbdeleteusererror', 'auth_db', $user->username); echo "\n";
649                         }
650                     } else if ($this->config->removeuser == AUTH_REMOVEUSER_SUSPEND) {
651                         $updateuser = new object();
652                         $updateuser->id = $user->id;
653                         $updateuser->auth = 'nologin';
654                         if ($DB->update_record('user', $updateuser)) {
655                             echo "\t"; print_string('auth_dbsuspenduser', 'auth_db', array($user->username, $user->id)); echo "\n";
656                         } else {
657                             echo "\t"; print_string('auth_dbsuspendusererror', 'auth_db', $user->username); echo "\n";
658                         }
659                     }
660                 }
661             } else {
662                 print "No user entries to be removed\n";
663             }
664             unset($remove_users); // free mem!
665         }
667 /// Revive suspended users
668         if (!empty($this->config->removeuser) and $this->config->removeuser == AUTH_REMOVEUSER_SUSPEND) {
669             $sql = "SELECT u.id, u.username
670                       FROM {user} u
671                       JOIN {tmp_extuser} e ON (u.username = e.username AND u.mnethostid = ?)
672                      WHERE u.auth='nologin' AND u.deleted=0";
673             $revive_users = $DB->get_records_sql($sql, array($CFG->mnet_localhost_id));
675             if (!empty($revive_users)) {
676                 print "User entries to be revived: ". count($revive_users) . "\n";
678                 foreach ($revive_users as $user) {
679                     $updateuser = new object();
680                     $updateuser->id = $user->id;
681                     $updateuser->auth = 'ldap';
682                     if ($DB->pdate_record('user', $updateuser)) {
683                         echo "\t"; print_string('auth_dbreviveduser', 'auth_db', array($user->username, $user->id)); echo "\n";
684                     } else {
685                         echo "\t"; print_string('auth_dbrevivedusererror', 'auth_db', $user->username); echo "\n";
686                     }
687                 }
688             } else {
689                 print "No user entries to be revived\n";
690             }
692             unset($revive_users);
693         }
696 /// User Updates - time-consuming (optional)
697         if ($do_updates) {
698             // narrow down what fields we need to update
699             $all_keys = array_keys(get_object_vars($this->config));
700             $updatekeys = array();
701             foreach ($all_keys as $key) {
702                 if (preg_match('/^field_updatelocal_(.+)$/',$key, $match)) {
703                     // if we have a field to update it from
704                     // and it must be updated 'onlogin' we
705                     // update it on cron
706                     if ( !empty($this->config->{'field_map_'.$match[1]})
707                          and $this->config->{$match[0]} === 'onlogin') {
708                         array_push($updatekeys, $match[1]); // the actual key name
709                     }
710                 }
711             }
712             // print_r($all_keys); print_r($updatekeys);
713             unset($all_keys); unset($key);
715         } else {
716             print "No updates to be done\n";
717         }
718         if ( $do_updates and !empty($updatekeys) ) { // run updates only if relevant
719             $users = $DB->get_records_sql("SELECT u.username, u.id
720                                              FROM {user} u
721                                             WHERE u.deleted=0 AND u.auth='ldap' AND u.mnethostid = ?", array($CFG->mnet_localhost_id));
722             if (!empty($users)) {
723                 print "User entries to update: ". count($users). "\n";
725                 $sitecontext = get_context_instance(CONTEXT_SYSTEM);
726                 if (!empty($this->config->creators) and !empty($this->config->memberattribute)
727                   and $roles = get_archetype_roles('coursecreator')) {
728                     $creatorrole = array_shift($roles);      // We can only use one, let's use the first one
729                 } else {
730                     $creatorrole = false;
731                 }
733                 $transaction = $DB->start_delegated_transaction();
734                 $xcount = 0;
735                 $maxxcount = 100;
737                 foreach ($users as $user) {
738                     echo "\t"; print_string('auth_dbupdatinguser', 'auth_db', array($user->username, $user->id));
739                     if (!$this->update_user_record($user->username, $updatekeys)) {
740                         echo " - ".get_string('skipped');
741                     }
742                     echo "\n";
743                     $xcount++;
745                     // update course creators if needed
746                     if ($creatorrole !== false) {
747                         if ($this->iscreator($user->username)) {
748                             role_assign($creatorrole->id, $user->id, 0, $sitecontext->id, 0, 0, 0, 'ldap');
749                         } else {
750                             role_unassign($creatorrole->id, $user->id, 0, $sitecontext->id, 'ldap');
751                         }
752                     }
753                 }
754                 $transaction->allow_commit();
755                 unset($users); // free mem
756             }
757         } else { // end do updates
758             print "No updates to be done\n";
759         }
761 /// User Additions
762         // find users missing in DB that are in LDAP
763         // and gives me a nifty object I don't want.
764         // note: we do not care about deleted accounts anymore, this feature was replaced by suspending to nologin auth plugin
765         // mnetid not used here in join because we can not add users with the same username
766         $sql = "SELECT e.id, e.username
767                   FROM {user} u
768                   LEFT JOIN {tmp_extuser} e ON u.username = e.username
769                  WHERE u.id IS NULL";
770         $add_users = $DB->get_records_sql($sql); // get rid of the fat
772         if (!empty($add_users)) {
773             print "User entries to add: ". count($add_users). "\n";
775             $sitecontext = get_context_instance(CONTEXT_SYSTEM);
776             if (!empty($this->config->creators) and !empty($this->config->memberattribute)
777               and $roles = get_archetype_roles('coursecreator')) {
778                 $creatorrole = array_shift($roles);      // We can only use one, let's use the first one
779             } else {
780                 $creatorrole = false;
781             }
783             $transaction = $DB->start_delegated_transaction();
784             foreach ($add_users as $user) {
785                 $user = $this->get_userinfo_asobj($user->username);
787                 // prep a few params
788                 $user->modified   = time();
789                 $user->confirmed  = 1;
790                 $user->auth       = 'ldap';
791                 $user->mnethostid = $CFG->mnet_localhost_id;
792                 // get_userinfo_asobj() might have replaced $user->username with the value
793                 // from the LDAP server (which can be mixed-case). Make sure it's lowercase
794                 $user->username = trim(moodle_strtolower($user->username));
795                 if (empty($user->lang)) {
796                     $user->lang = $CFG->lang;
797                 }
799                 //TODO - username required to use PARAM_USERNAME before inserting into user table (MDL-16919)
800                 if ($id = $DB->insert_record('user', $user)) {
801                     echo "\t"; print_string('auth_dbinsertuser', 'auth_db', array($user->username, $id)); echo "\n";
802                     $userobj = $this->update_user_record($user->username);
803                     if (!empty($this->config->forcechangepassword)) {
804                         set_user_preference('auth_forcepasswordchange', 1, $userobj->id);
805                     }
806                 } else {
807                     echo "\t"; print_string('auth_dbinsertusererror', 'auth_db', $user->username); echo "\n";
808                 }
810                 // add course creators if needed
811                 if ($creatorrole !== false and $this->iscreator($user->username)) {
812                     role_assign($creatorrole->id, $user->id, 0, $sitecontext->id, 0, 0, 0, 'ldap');
813                 }
814             }
815             $transaction->allow_commit();
816             unset($add_users); // free mem
817         } else {
818             print "No users to be added\n";
819         }
821         $dbman->drop_temp_table($table);
822         $this->ldap_close();
824         return true;
825     }
827     /**
828      * Update a local user record from an external source.
829      * This is a lighter version of the one in moodlelib -- won't do
830      * expensive ops such as enrolment.
831      *
832      * If you don't pass $updatekeys, there is a performance hit and
833      * values removed from LDAP won't be removed from moodle.
834      *
835      * @param string $username username
836      */
837     function update_user_record($username, $updatekeys = false) {
838         global $CFG;
840         //just in case check text case
841         $username = trim(moodle_strtolower($username));
843         // get the current user record
844         $user = $DB->get_record('user', array('username'=>$username, 'mnethostid'=>$CFG->mnet_localhost_id));
845         if (empty($user)) { // trouble
846             error_log("Cannot update non-existent user: ".$username);
847             print_error('auth_dbusernotexist','auth_db','',$username);
848             die;
849         }
851         // Protect the userid from being overwritten
852         $userid = $user->id;
854         if ($newinfo = $this->get_userinfo($username)) {
855             $newinfo = truncate_userinfo($newinfo);
857             if (empty($updatekeys)) { // all keys? this does not support removing values
858                 $updatekeys = array_keys($newinfo);
859             }
861             foreach ($updatekeys as $key) {
862                 if (isset($newinfo[$key])) {
863                     $value = $newinfo[$key];
864                 } else {
865                     $value = '';
866                 }
868                 if (!empty($this->config->{'field_updatelocal_' . $key})) {
869                     if ($user->{$key} != $value) { // only update if it's changed
870                         $DB->set_field('user', $key, $value, array('id'=>$userid));
871                     }
872                 }
873             }
874         } else {
875             return false;
876         }
877         return $DB->get_record('user', array('id'=>$userid, 'deleted'=>0));
878     }
880     /**
881      * Bulk insert in SQL's temp table
882      */
883     function ldap_bulk_insert($username) {
884         global $DB;
886         $username = moodle_strtolower($username); // usernames are __always__ lowercase.
887         $DB->insert_record_raw('tmp_extuser', array('username'=>$username), false, true);
888         print ".";
889     }
892     /**
893      * Activates (enables) user in external db so user can login to external db
894      *
895      * @param mixed $username
896      * @return boolen result
897      */
898     function user_activate($username) {
899         $textlib = textlib_get_instance();
900         $extusername = $textlib->convert($username, 'utf-8', $this->config->ldapencoding);
902         $ldapconnection = $this->ldap_connect();
904         $userdn = $this->ldap_find_userdn($ldapconnection, $extusername);
905         switch ($this->config->user_type)  {
906             case 'edir':
907                 $newinfo['loginDisabled']="FALSE";
908                 break;
909             case 'ad':
910                 // We need to unset the ACCOUNTDISABLE bit in the
911                 // userAccountControl attribute ( see
912                 // http://support.microsoft.com/kb/305144 )
913                 $sr = ldap_read($ldapconnection, $userdn, '(objectClass=*)',
914                                 array('userAccountControl'));
915                 $info = ldap_get_entries($ldapconnection, $sr);
916                 $newinfo['userAccountControl'] = $info[0]['userAccountControl'][0]
917                                                  & (~AUTH_AD_ACCOUNTDISABLE);
918                 break;
919             default:
920                 print_error('user_activatenotsupportusertype', 'auth', '', $this->config->user_type);
921         }
922         $result = ldap_modify($ldapconnection, $userdn, $newinfo);
923         $this->ldap_close();
924         return $result;
925     }
927     /**
928      * Disables user in external db so user can't login to external db
929      *
930      * @param mixed $username    username
931      * @return boolean result
932      */
933 /*    function user_disable($username) {
934         $textlib = textlib_get_instance();
935         $extusername = $textlib->convert($username, 'utf-8', $this->config->ldapencoding);
937         $ldapconnection = $this->ldap_connect();
939         $userdn = $this->ldap_find_userdn($ldapconnection, $extusername);
940         switch ($this->config->user_type)  {
941             case 'edir':
942                 $newinfo['loginDisabled']="TRUE";
943                 break;
944             case 'ad':
945                 // We need to set the ACCOUNTDISABLE bit in the
946                 // userAccountControl attribute ( see
947                 // http://support.microsoft.com/kb/305144 )
948                 $sr = ldap_read($ldapconnection, $userdn, '(objectClass=*)',
949                                 array('userAccountControl'));
950                 $info = auth_ldap_get_entries($ldapconnection, $sr);
951                 $newinfo['userAccountControl'] = $info[0]['userAccountControl'][0]
952                                                  | AUTH_AD_ACCOUNTDISABLE;
953                 break;
954             default:
955                 print_error('user_disablenotsupportusertype', 'auth');
956         }
957         $result = ldap_modify($ldapconnection, $userdn, $newinfo);
958         $this->ldap_close();
959         return $result;
960     }*/
962     /**
963      * Returns true if user should be coursecreator.
964      *
965      * @param mixed $username    username (without system magic quotes)
966      * @return boolean result
967      */
968     function iscreator($username) {
969         if (empty($this->config->creators) or empty($this->config->memberattribute)) {
970             return null;
971         }
973         $textlib = textlib_get_instance();
974         $extusername = $textlib->convert($username, 'utf-8', $this->config->ldapencoding);
976         return (boolean)$this->ldap_isgroupmember($extusername, $this->config->creators);
977     }
979     /**
980      * Called when the user record is updated.
981      * Modifies user in external database. It takes olduser (before changes) and newuser (after changes)
982      * conpares information saved modified information to external db.
983      *
984      * @param mixed $olduser     Userobject before modifications    (without system magic quotes)
985      * @param mixed $newuser     Userobject new modified userobject (without system magic quotes)
986      * @return boolean result
987      *
988      */
989     function user_update($olduser, $newuser) {
991         global $USER;
993         if (isset($olduser->username) and isset($newuser->username) and $olduser->username != $newuser->username) {
994             error_log("ERROR:User renaming not allowed in LDAP");
995             return false;
996         }
998         if (isset($olduser->auth) and $olduser->auth != 'ldap') {
999             return true; // just change auth and skip update
1000         }
1002         $attrmap = $this->ldap_attributes();
1004         // Before doing anything else, make sure really need to update anything
1005         // in the external LDAP server.
1006         $update_external = false;
1007         foreach ($attrmap as $key => $ldapkeys) {
1008             if (!empty($this->config->{'field_updateremote_'.$key})) {
1009                 $update_external = true;
1010                 break;
1011             }
1012         }
1013         if (!$update_external) {
1014             return true;
1015         }
1017         $textlib = textlib_get_instance();
1018         $extoldusername = $textlib->convert($olduser->username, 'utf-8', $this->config->ldapencoding);
1020         $ldapconnection = $this->ldap_connect();
1022         $search_attribs = array();
1024         foreach ($attrmap as $key => $values) {
1025             if (!is_array($values)) {
1026                 $values = array($values);
1027             }
1028             foreach ($values as $value) {
1029                 if (!in_array($value, $search_attribs)) {
1030                     array_push($search_attribs, $value);
1031                 }
1032             }
1033         }
1035         $user_dn = $this->ldap_find_userdn($ldapconnection, $extoldusername);
1037         $user_info_result = ldap_read($ldapconnection, $user_dn,
1038                                 $this->config->objectclass, $search_attribs);
1040         if ($user_info_result) {
1042             $user_entry = $this->ldap_get_entries($ldapconnection, $user_info_result);
1043             if (empty($user_entry)) {
1044                 $error = 'ldap: Could not find user while updating externally. '.
1045                          'Details follow: search base: \''.$user_dn.'\'; search filter: \''.
1046                          $this->config->objectclass.'\'; search attributes: ';
1047                 foreach ($search_attribs as $attrib) {
1048                     $error .= $attrib.' ';
1049                 }
1050                 error_log($error);
1051                 return false; // old user not found!
1052             } else if (count($user_entry) > 1) {
1053                 error_log('ldap: Strange! More than one user record found in ldap. Only using the first one.');
1054                 return false;
1055             }
1056             $user_entry = $user_entry[0];
1058             //error_log(var_export($user_entry) . 'fpp' );
1060             foreach ($attrmap as $key => $ldapkeys) {
1061                 // only process if the moodle field ($key) has changed and we
1062                 // are set to update LDAP with it
1063                 if (isset($olduser->$key) and isset($newuser->$key)
1064                   and $olduser->$key !== $newuser->$key
1065                   and !empty($this->config->{'field_updateremote_'. $key})) {
1066                     // for ldap values that could be in more than one
1067                     // ldap key, we will do our best to match
1068                     // where they came from
1069                     $ambiguous = true;
1070                     $changed   = false;
1071                     if (!is_array($ldapkeys)) {
1072                         $ldapkeys = array($ldapkeys);
1073                     }
1074                     if (count($ldapkeys) < 2) {
1075                         $ambiguous = false;
1076                     }
1078                     $nuvalue = $textlib->convert($newuser->$key, 'utf-8', $this->config->ldapencoding);
1079                     empty($nuvalue) ? $nuvalue = array() : $nuvalue;
1080                     $ouvalue = $textlib->convert($olduser->$key, 'utf-8', $this->config->ldapencoding);
1082                     foreach ($ldapkeys as $ldapkey) {
1083                         $ldapkey   = $ldapkey;
1084                         $ldapvalue = $user_entry[$ldapkey][0];
1085                         if (!$ambiguous) {
1086                             // skip update if the values already match
1087                             if ($nuvalue !== $ldapvalue) {
1088                                 //this might fail due to schema validation
1089                                 if (@ldap_modify($ldapconnection, $user_dn, array($ldapkey => $nuvalue))) {
1090                                     continue;
1091                                 } else {
1092                                     error_log('Error updating LDAP record. Error code: '
1093                                       . ldap_errno($ldapconnection) . '; Error string : '
1094                                       . ldap_err2str(ldap_errno($ldapconnection))
1095                                       . "\nKey ($key) - old moodle value: '$ouvalue' new value: '$nuvalue'");
1096                                     continue;
1097                                 }
1098                             }
1099                         } else {
1100                             // ambiguous
1101                             // value empty before in Moodle (and LDAP) - use 1st ldap candidate field
1102                             // no need to guess
1103                             if ($ouvalue === '') { // value empty before - use 1st ldap candidate
1104                                 //this might fail due to schema validation
1105                                 if (@ldap_modify($ldapconnection, $user_dn, array($ldapkey => $nuvalue))) {
1106                                     $changed = true;
1107                                     continue;
1108                                 } else {
1109                                     error_log('Error updating LDAP record. Error code: '
1110                                       . ldap_errno($ldapconnection) . '; Error string : '
1111                                       . ldap_err2str(ldap_errno($ldapconnection))
1112                                       . "\nKey ($key) - old moodle value: '$ouvalue' new value: '$nuvalue'");
1113                                     continue;
1114                                 }
1115                             }
1117                             // we found which ldap key to update!
1118                             if ($ouvalue !== '' and $ouvalue === $ldapvalue ) {
1119                                 //this might fail due to schema validation
1120                                 if (@ldap_modify($ldapconnection, $user_dn, array($ldapkey => $nuvalue))) {
1121                                     $changed = true;
1122                                     continue;
1123                                 } else {
1124                                     error_log('Error updating LDAP record. Error code: '
1125                                       . ldap_errno($ldapconnection) . '; Error string : '
1126                                       . ldap_err2str(ldap_errno($ldapconnection))
1127                                       . "\nKey ($key) - old moodle value: '$ouvalue' new value: '$nuvalue'");
1128                                     continue;
1129                                 }
1130                             }
1131                         }
1132                     }
1134                     if ($ambiguous and !$changed) {
1135                         error_log("Failed to update LDAP with ambiguous field $key".
1136                                   "  old moodle value: '" . $ouvalue .
1137                                   "' new value '" . $nuvalue );
1138                     }
1139                 }
1140             }
1141         } else {
1142             error_log("ERROR:No user found in LDAP");
1143             $this->ldap_close();
1144             return false;
1145         }
1147         $this->ldap_close();
1149         return true;
1151     }
1153     /**
1154      * changes userpassword in external db
1155      *
1156      * called when the user password is updated.
1157      * changes userpassword in external db
1158      *
1159      * @param  object  $user        User table object
1160      * @param  string  $newpassword Plaintext password
1161      * @return boolean result
1162      *
1163      */
1164     function user_update_password($user, $newpassword) {
1165     /// called when the user password is updated -- it assumes it is called by an admin
1166     /// or that you've otherwise checked the user's credentials
1167     /// IMPORTANT: $newpassword must be cleartext, not crypted/md5'ed
1169         global $USER;
1170         $result = false;
1171         $username = $user->username;
1173         $textlib = textlib_get_instance();
1174         $extusername = $textlib->convert($username, 'utf-8', $this->config->ldapencoding);
1175         $extpassword = $textlib->convert($newpassword, 'utf-8', $this->config->ldapencoding);
1177         switch ($this->config->passtype) {
1178             case 'md5':
1179                 $extpassword = '{MD5}' . base64_encode(pack('H*', md5($extpassword)));
1180                 break;
1181             case 'sha1':
1182                 $extpassword = '{SHA}' . base64_encode(pack('H*', sha1($extpassword)));
1183                 break;
1184             case 'plaintext':
1185             default:
1186                 break; // plaintext
1187         }
1189         $ldapconnection = $this->ldap_connect();
1191         $user_dn = $this->ldap_find_userdn($ldapconnection, $extusername);
1193         if (!$user_dn) {
1194             error_log('LDAP Error in user_update_password(). No DN for: ' . $user->username);
1195             return false;
1196         }
1198         switch ($this->config->user_type) {
1199             case 'edir':
1200                 //Change password
1201                 $result = ldap_modify($ldapconnection, $user_dn, array('userPassword' => $extpassword));
1202                 if (!$result) {
1203                     error_log('LDAP Error in user_update_password(). Error code: '
1204                               . ldap_errno($ldapconnection) . '; Error string : '
1205                               . ldap_err2str(ldap_errno($ldapconnection)));
1206                 }
1207                 //Update password expiration time, grace logins count
1208                 $search_attribs = array($this->config->expireattr, 'passwordExpirationInterval','loginGraceLimit' );
1209                 $sr = ldap_read($ldapconnection, $user_dn, '(objectClass=*)', $search_attribs);
1210                 if ($sr)  {
1211                     $info=$this->ldap_get_entries($ldapconnection, $sr);
1212                     $newattrs = array();
1213                     if (!empty($info[0][$this->config->expireattr][0])) {
1214                         //Set expiration time only if passwordExpirationInterval is defined
1215                         if (!empty($info[0]['passwordExpirationInterval'][0])) {
1216                            $expirationtime = time() + $info[0]['passwordExpirationInterval'][0];
1217                            $ldapexpirationtime = $this->ldap_unix2expirationtime($expirationtime);
1218                            $newattrs['passwordExpirationTime'] = $ldapexpirationtime;
1219                         }
1221                         //set gracelogin count
1222                         if (!empty($info[0]['loginGraceLimit'][0])) {
1223                            $newattrs['loginGraceRemaining']= $info[0]['loginGraceLimit'][0];
1224                         }
1226                         //Store attribute changes to ldap
1227                         $result = ldap_modify($ldapconnection, $user_dn, $newattrs);
1228                         if (!$result) {
1229                            error_log('LDAP Error in user_update_password() when modifying expirationtime and/or gracelogins. Error code: '
1230                                      . ldap_errno($ldapconnection) . '; Error string : '
1231                                      . ldap_err2str(ldap_errno($ldapconnection)));
1232                         }
1233                     }
1234                 }
1235                 else {
1236                     error_log('LDAP Error in user_update_password() when reading password expiration time. Error code: '
1237                               . ldap_errno($ldapconnection) . '; Error string : '
1238                               . ldap_err2str(ldap_errno($ldapconnection)));
1239                 }
1240                 break;
1242             case 'ad':
1243                 // Passwords in Active Directory must be encoded as Unicode
1244                 // strings (UCS-2 Little Endian format) and surrounded with
1245                 // double quotes. See http://support.microsoft.com/?kbid=269190
1246                 if (!function_exists('mb_convert_encoding')) {
1247                     error_log ('You need the mbstring extension to change passwords in Active Directory');
1248                     return false;
1249                 }
1250                 $extpassword = mb_convert_encoding('"'.$extpassword.'"', "UCS-2LE", $this->config->ldapencoding);
1251                 $result = ldap_modify($ldapconnection, $user_dn, array('unicodePwd' => $extpassword));
1252                 if (!$result) {
1253                     error_log('LDAP Error in user_update_password(). Error code: '
1254                               . ldap_errno($ldapconnection) . '; Error string : '
1255                               . ldap_err2str(ldap_errno($ldapconnection)));
1256                 }
1257                 break;
1259             default:
1260                 $usedconnection = &$ldapconnection;
1261                 // send ldap the password in cleartext, it will md5 it itself
1262                 $result = ldap_modify($ldapconnection, $user_dn, array('userPassword' => $extpassword));
1263                 if (!$result) {
1264                     error_log('LDAP Error in user_update_password(). Error code: '
1265                         . ldap_errno($ldapconnection) . '; Error string : '
1266                         . ldap_err2str(ldap_errno($ldapconnection)));
1267                 }
1269         }
1271         $this->ldap_close();
1272         return $result;
1273     }
1275     //PRIVATE FUNCTIONS starts
1276     //private functions are named as ldap_*
1278     /**
1279      * returns predefined usertypes
1280      *
1281      * @return array of predefined usertypes
1282      */
1283     function ldap_suppported_usertypes() {
1284         $types = array();
1285         $types['edir']='Novell Edirectory';
1286         $types['rfc2307']='posixAccount (rfc2307)';
1287         $types['rfc2307bis']='posixAccount (rfc2307bis)';
1288         $types['samba']='sambaSamAccount (v.3.0.7)';
1289         $types['ad']='MS ActiveDirectory';
1290         $types['default']=get_string('default');
1291         return $types;
1292     }
1295     /**
1296      * Initializes needed variables for ldap-module
1297      *
1298      * Uses names defined in ldap_supported_usertypes.
1299      * $default is first defined as:
1300      * $default['pseudoname'] = array(
1301      *                      'typename1' => 'value',
1302      *                      'typename2' => 'value'
1303      *                      ....
1304      *                      );
1305      *
1306      * @return array of default values
1307      */
1308     function ldap_getdefaults() {
1309         $default['objectclass'] = array(
1310                             'edir' => 'User',
1311                             'rfc2307' => 'posixAccount',
1312                             'rfc2307bis' => 'posixAccount',
1313                             'samba' => 'sambaSamAccount',
1314                             'ad' => 'user',
1315                             'default' => '*'
1316                             );
1317         $default['user_attribute'] = array(
1318                             'edir' => 'cn',
1319                             'rfc2307' => 'uid',
1320                             'rfc2307bis' => 'uid',
1321                             'samba' => 'uid',
1322                             'ad' => 'cn',
1323                             'default' => 'cn'
1324                             );
1325         $default['memberattribute'] = array(
1326                             'edir' => 'member',
1327                             'rfc2307' => 'member',
1328                             'rfc2307bis' => 'member',
1329                             'samba' => 'member',
1330                             'ad' => 'member',
1331                             'default' => 'member'
1332                             );
1333         $default['memberattribute_isdn'] = array(
1334                             'edir' => '1',
1335                             'rfc2307' => '0',
1336                             'rfc2307bis' => '1',
1337                             'samba' => '0', //is this right?
1338                             'ad' => '1',
1339                             'default' => '0'
1340                             );
1341         $default['expireattr'] = array (
1342                             'edir' => 'passwordExpirationTime',
1343                             'rfc2307' => 'shadowExpire',
1344                             'rfc2307bis' => 'shadowExpire',
1345                             'samba' => '', //No support yet
1346                             'ad' => 'pwdLastSet',
1347                             'default' => ''
1348                             );
1349         return $default;
1350     }
1352     /**
1353      * return binaryfields of selected usertype
1354      *
1355      *
1356      * @return array
1357      */
1358     function ldap_getbinaryfields () {
1359         $binaryfields = array (
1360                             'edir' => array('guid'),
1361                             'rfc2307' => array(),
1362                             'rfc2307bis' => array(),
1363                             'samba' => array(),
1364                             'ad' => array(),
1365                             'default' => array()
1366                             );
1367         if (!empty($this->config->user_type)) {
1368             return $binaryfields[$this->config->user_type];
1369         }
1370         else {
1371             return $binaryfields['default'];
1372         }
1373     }
1375     function ldap_isbinary ($field) {
1376         if (empty($field)) {
1377             return false;
1378         }
1379         return array_search($field, $this->ldap_getbinaryfields());
1380     }
1382     /**
1383      * take expirationtime and return it as unixseconds
1384      *
1385      * takes expriration timestamp as readed from ldap
1386      * returns it as unix seconds
1387      * depends on $this->config->user_type variable
1388      *
1389      * @param mixed time   Time stamp readed from ldap as it is.
1390      * @param string $ldapconnection Just needed for Active Directory.
1391      * @param string $user_dn User distinguished name for the user we are checking password expiration (just needed for Active Directory).
1392      * @return timestamp
1393      */
1394     function ldap_expirationtime2unix ($time, $ldapconnection, $user_dn) {
1395         $result = false;
1396         switch ($this->config->user_type) {
1397             case 'edir':
1398                 $yr=substr($time,0,4);
1399                 $mo=substr($time,4,2);
1400                 $dt=substr($time,6,2);
1401                 $hr=substr($time,8,2);
1402                 $min=substr($time,10,2);
1403                 $sec=substr($time,12,2);
1404                 $result = mktime($hr,$min,$sec,$mo,$dt,$yr);
1405                 break;
1406             case 'rfc2307':
1407             case 'rfc2307bis':
1408                 $result = $time * DAYSECS; //The shadowExpire contains the number of DAYS between 01/01/1970 and the actual expiration date
1409                 break;
1410             case 'ad':
1411                 $result = $this->ldap_get_ad_pwdexpire($time, $ldapconnection, $user_dn);
1412                 break;
1413             default:
1414                 print_error('auth_ldap_usertypeundefined', 'auth_ldap');
1415         }
1416         return $result;
1417     }
1419     /**
1420      * takes unixtime and return it formated for storing in ldap
1421      *
1422      * @param integer unix time stamp
1423      */
1424     function ldap_unix2expirationtime($time) {
1425         $result = false;
1426         switch ($this->config->user_type) {
1427             case 'edir':
1428                 $result=date('YmdHis', $time).'Z';
1429                 break;
1430             case 'rfc2307':
1431             case 'rfc2307bis':
1432                 $result = $time ; //Already in correct format
1433                 break;
1434             default:
1435                 print_error('auth_ldap_usertypeundefined2', 'auth_ldap');
1436         }
1437         return $result;
1439     }
1441     /**
1442      * checks if user belong to specific group(s)
1443      * or is in a subtree.
1444      *
1445      * Returns true if user belongs group in grupdns string OR
1446      * if the DN of the user is in a subtree pf the DN provided
1447      * as "group"
1448      *
1449      * @param mixed $username    username
1450      * @param mixed $groupdns    string of group dn separated by ;
1451      *
1452      */
1453     function ldap_isgroupmember($extusername='', $groupdns='') {
1454     // Takes username and groupdn(s) , separated by ;
1455     // Returns true if user is member of any given groups
1457         $ldapconnection = $this->ldap_connect();
1459         if (empty($extusername) or empty($groupdns)) {
1460             return false;
1461             }
1463         if ($this->config->memberattribute_isdn) {
1464             $memberuser = $this->ldap_find_userdn($ldapconnection, $extusername);
1465         } else {
1466             $memberuser = $extusername;
1467         }
1469         if (empty($memberuser)) {
1470             return false;
1471         }
1473         $groups = explode(";",$groupdns);
1475         $result = false;
1476         foreach ($groups as $group) {
1477             $group = trim($group);
1478             if (empty($group)) {
1479                 continue;
1480             }
1482             // check cheaply if the user's DN sits in a subtree
1483             // of the "group" DN provided. Granted, this isn't
1484             // a proper LDAP group, but it's a popular usage.
1485             if (strpos(strrev($memberuser), strrev($group))===0) {
1486                 $result = true;
1487                 break;
1488             }
1490             //echo "Checking group $group for member $username\n";
1491             $search = ldap_read($ldapconnection, $group,  '('.$this->config->memberattribute.'='.$this->filter_addslashes($memberuser).')', array($this->config->memberattribute));
1492             if (!empty($search) and ldap_count_entries($ldapconnection, $search)) {
1493                 $info = $this->ldap_get_entries($ldapconnection, $search);
1495                 if (count($info) > 0 ) {
1496                     // user is member of group
1497                     $result = true;
1498                     break;
1499                 }
1500           }
1501         }
1503         return $result;
1505     }
1507     /**
1508      * connects to ldap server
1509      *
1510      * Tries connect to specified ldap servers.
1511      * Returns connection result or error.
1512      *
1513      * @return connection result
1514      */
1515     function ldap_connect($binddn='',$bindpwd='') {
1516         // Cache ldap connections (they are expensive to set up
1517         // and can drain the TCP/IP ressources on the server if we
1518         // are syncing a lot of users (as we try to open a new connection
1519         // to get the user details). This is the least invasive way
1520         // to reuse existing connections without greater code surgery.
1521         if(!empty($this->ldapconnection)) {
1522             $this->ldapconns++;
1523             return $this->ldapconnection;
1524         }
1526         //Select bind password, With empty values use
1527         //ldap_bind_* variables or anonymous bind if ldap_bind_* are empty
1528         if ($binddn == '' and $bindpwd == '') {
1529             if (!empty($this->config->bind_dn)) {
1530                $binddn = $this->config->bind_dn;
1531             }
1532             if (!empty($this->config->bind_pw)) {
1533                $bindpwd = $this->config->bind_pw;
1534             }
1535         }
1537         $urls = explode(";",$this->config->host_url);
1539         foreach ($urls as $server) {
1540             $server = trim($server);
1541             if (empty($server)) {
1542                 continue;
1543             }
1545             $connresult = ldap_connect($server);
1546             //ldap_connect returns ALWAYS true
1548             if (!empty($this->config->version)) {
1549                 ldap_set_option($connresult, LDAP_OPT_PROTOCOL_VERSION, $this->config->version);
1550             }
1552             // Fix MDL-10921
1553             if ($this->config->user_type == 'ad') {
1554                  ldap_set_option($connresult, LDAP_OPT_REFERRALS, 0);
1555             }
1557             if (!empty($binddn)) {
1558                 //bind with search-user
1559                 //$debuginfo .= 'Using bind user'.$binddn.'and password:'.$bindpwd;
1560                 $bindresult=ldap_bind($connresult, $binddn,$bindpwd);
1561             }
1562             else {
1563                 //bind anonymously
1564                 $bindresult=@ldap_bind($connresult);
1565             }
1567             if (!empty($this->config->opt_deref)) {
1568                 ldap_set_option($connresult, LDAP_OPT_DEREF, $this->config->opt_deref);
1569             }
1571             if ($bindresult) {
1572         // Set the connection counter so we can call PHP's ldap_close()
1573         // when we call $this->ldap_close() for the last 'open' connection.
1574                 $this->ldapconns = 1;
1575                 $this->ldapconnection = $connresult;
1576                 return $connresult;
1577             }
1579             $debuginfo .= "<br/>Server: '$server' <br/> Connection: '$connresult'<br/> Bind result: '$bindresult'</br>";
1580         }
1582         //If any of servers are alive we have already returned connection
1583         print_error('auth_ldap_noconnect_all','auth_ldap','', $debuginfo);
1584         return false;
1585     }
1587     /**
1588      * disconnects from a ldap server
1589      *
1590      */
1591     function ldap_close() {
1592         $this->ldapconns--;
1593         if($this->ldapconns == 0) {
1594             @ldap_close($this->ldapconnection);
1595             unset($this->ldapconnection);
1596         }
1597     }
1599     /**
1600      * retuns dn of username
1601      *
1602      * Search specified contexts for username and return user dn
1603      * like: cn=username,ou=suborg,o=org
1604      *
1605      * @param mixed $ldapconnection  $ldapconnection result
1606      * @param mixed $username username (external encoding no slashes)
1607      *
1608      */
1610     function ldap_find_userdn ($ldapconnection, $extusername) {
1612         //default return value
1613         $ldap_user_dn = FALSE;
1615         //get all contexts and look for first matching user
1616         $ldap_contexts = explode(";",$this->config->contexts);
1618         if (!empty($this->config->create_context)) {
1619           array_push($ldap_contexts, $this->config->create_context);
1620         }
1622         foreach ($ldap_contexts as $context) {
1624             $context = trim($context);
1625             if (empty($context)) {
1626                 continue;
1627             }
1629             if ($this->config->search_sub) {
1630                 //use ldap_search to find first user from subtree
1631                 $ldap_result = ldap_search($ldapconnection, $context, "(".$this->config->user_attribute."=".$this->filter_addslashes($extusername).")",array($this->config->user_attribute));
1633             }
1634             else {
1635                 //search only in this context
1636                 $ldap_result = ldap_list($ldapconnection, $context, "(".$this->config->user_attribute."=".$this->filter_addslashes($extusername).")",array($this->config->user_attribute));
1637             }
1639             $entry = ldap_first_entry($ldapconnection,$ldap_result);
1641             if ($entry) {
1642                 $ldap_user_dn = ldap_get_dn($ldapconnection, $entry);
1643                 break ;
1644             }
1645         }
1647         return $ldap_user_dn;
1648     }
1650     /**
1651      * retuns user attribute mappings between moodle and ldap
1652      *
1653      * @return array
1654      */
1656     function ldap_attributes () {
1657         $moodleattributes = array();
1658         foreach ($this->userfields as $field) {
1659             if (!empty($this->config->{"field_map_$field"})) {
1660                 $moodleattributes[$field] = $this->config->{"field_map_$field"};
1661                 if (preg_match('/,/',$moodleattributes[$field])) {
1662                     $moodleattributes[$field] = explode(',', $moodleattributes[$field]); // split ?
1663                 }
1664             }
1665         }
1666         $moodleattributes['username'] = $this->config->user_attribute;
1667         return $moodleattributes;
1668     }
1670     /**
1671      * return all usernames from ldap
1672      *
1673      * @return array
1674      */
1676     function ldap_get_userlist($filter="*") {
1677     /// returns all users from ldap servers
1678         $fresult = array();
1680         $ldapconnection = $this->ldap_connect();
1682         if ($filter=="*") {
1683            $filter = '(&('.$this->config->user_attribute.'=*)'.$this->config->objectclass.')';
1684         }
1686         $contexts = explode(";",$this->config->contexts);
1688         if (!empty($this->config->create_context)) {
1689               array_push($contexts, $this->config->create_context);
1690         }
1692         foreach ($contexts as $context) {
1694             $context = trim($context);
1695             if (empty($context)) {
1696                 continue;
1697             }
1699             if ($this->config->search_sub) {
1700                 //use ldap_search to find first user from subtree
1701                 $ldap_result = ldap_search($ldapconnection, $context,$filter,array($this->config->user_attribute));
1702             }
1703             else {
1704                 //search only in this context
1705                 $ldap_result = ldap_list($ldapconnection, $context,
1706                                          $filter,
1707                                          array($this->config->user_attribute));
1708             }
1710             $users = $this->ldap_get_entries($ldapconnection, $ldap_result);
1712             //add found users to list
1713             for ($i=0;$i<count($users);$i++) {
1714                 array_push($fresult, ($users[$i][$this->config->user_attribute][0]) );
1715             }
1716         }
1718         return $fresult;
1719     }
1721     /**
1722      * return entries from ldap
1723      *
1724      * Returns values like ldap_get_entries but is
1725      * binary compatible and return all attributes as array
1726      *
1727      * @return array ldap-entries
1728      */
1730     function ldap_get_entries($conn, $searchresult) {
1731     //Returns values like ldap_get_entries but is
1732     //binary compatible
1733         $i=0;
1734         $fresult=array();
1735         $entry = ldap_first_entry($conn, $searchresult);
1736         do {
1737             $attributes = @ldap_get_attributes($conn, $entry);
1738             for ($j=0; $j<$attributes['count']; $j++) {
1739                 $values = ldap_get_values_len($conn, $entry,$attributes[$j]);
1740                 if (is_array($values)) {
1741                 $fresult[$i][$attributes[$j]] = $values;
1742                 }
1743                 else {
1744                     $fresult[$i][$attributes[$j]] = array($values);
1745                 }
1746             }
1747             $i++;
1748         }
1749         while ($entry = @ldap_next_entry($conn, $entry));
1750         //were done
1751         return ($fresult);
1752     }
1754     function prevent_local_passwords() {
1755         return !empty($this->config->preventpassindb);
1756     }
1758     /**
1759      * Returns true if this authentication plugin is 'internal'.
1760      *
1761      * @return bool
1762      */
1763     function is_internal() {
1764         return false;
1765     }
1767     /**
1768      * Returns true if this authentication plugin can change the user's
1769      * password.
1770      *
1771      * @return bool
1772      */
1773     function can_change_password() {
1774         return !empty($this->config->stdchangepassword) or !empty($this->config->changepasswordurl);
1775     }
1777     /**
1778      * Returns the URL for changing the user's pw, or empty if the default can
1779      * be used.
1780      *
1781      * @return string url
1782      */
1783     function change_password_url() {
1784         if (empty($this->config->stdchangepassword)) {
1785             return $this->config->changepasswordurl;
1786         } else {
1787             return '';
1788         }
1789     }
1791     /**
1792      * Will get called before the login page is shown, if NTLM SSO
1793      * is enabled, and the user is in the right network, we'll redirect
1794      * to the magic NTLM page for SSO...
1795      *
1796      */
1797     function loginpage_hook() {
1798         global $CFG, $SESSION;
1800         // HTTPS is potentially required
1801         httpsrequired();
1803         if (($_SERVER['REQUEST_METHOD'] === 'GET'         // Only on initial GET of loginpage
1804                 || ($_SERVER['REQUEST_METHOD'] === 'POST'
1805                    && (get_referer() != strip_querystring(qualified_me()))))
1806                                                            // Or when POSTed from another place
1807                                                            // See MDL-14071
1808            && !empty($this->config->ntlmsso_enabled)     // SSO enabled
1809            && !empty($this->config->ntlmsso_subnet)      // have a subnet to test for
1810            && empty($_GET['authldap_skipntlmsso'])       // haven't failed it yet
1811            && (isguestuser() || !isloggedin())           // guestuser or not-logged-in users
1812             && address_in_subnet(getremoteaddr(), $this->config->ntlmsso_subnet)) {
1814             // First, let's remember where we were trying to get to before we got here
1815             if (empty($SESSION->wantsurl)) {
1816                 $SESSION->wantsurl = (array_key_exists('HTTP_REFERER', $_SERVER) &&
1817                                       $_SERVER['HTTP_REFERER'] != $CFG->wwwroot &&
1818                                       $_SERVER['HTTP_REFERER'] != $CFG->wwwroot.'/' &&
1819                                       $_SERVER['HTTP_REFERER'] != $CFG->httpswwwroot.'/login/' &&
1820                                       $_SERVER['HTTP_REFERER'] != $CFG->httpswwwroot.'/login/index.php')
1821                     ? $_SERVER['HTTP_REFERER'] : NULL;
1822             }
1824             // Now start the whole NTLM machinery.
1825             if(!empty($this->config->ntlmsso_ie_fastpath)) {
1826                 // Shortcut for IE browsers: skip the attempt page at all
1827                 if(check_browser_version('MSIE')) {
1828                     $sesskey = sesskey();
1829                     redirect($CFG->wwwroot.'/auth/ldap/ntlmsso_magic.php?sesskey='.$sesskey);
1830                 } else {
1831                     redirect($CFG->httpswwwroot.'/login/index.php?authldap_skipntlmsso=1');
1832                 }
1833             } else {
1834                 redirect($CFG->wwwroot.'/auth/ldap/ntlmsso_attempt.php');
1835             }
1836         }
1838         // No NTLM SSO, Use the normal login page instead.
1840         // If $SESSION->wantsurl is empty and we have a 'Referer:' header, the login
1841         // page insists on redirecting us to that page after user validation. If
1842         // we clicked on the redirect link at the ntlmsso_finish.php page instead
1843         // of waiting for the redirection to happen, then we have a 'Referer:' header
1844         // we don't want to use at all. As we can't get rid of it, just point
1845         // $SESSION->wantsurl to $CFG->wwwroot (after all, we came from there).
1846         if (empty($SESSION->wantsurl)
1847             && (get_referer() == $CFG->httpswwwroot.'/auth/ldap/ntlmsso_finish.php')) {
1849             $SESSION->wantsurl = $CFG->wwwroot;
1850         }
1851     }
1853     /**
1854      * To be called from a page running under NTLM's
1855      * "Integrated Windows Authentication".
1856      *
1857      * If successful, it will set a special "cookie" (not an HTTP cookie!)
1858      * in cache_flags under the "auth/ldap/ntlmsess" "plugin" and return true.
1859      * The "cookie" will be picked up by ntlmsso_finish() to complete the
1860      * process.
1861      *
1862      * On failure it will return false for the caller to display an appropriate
1863      * error message (probably saying that Integrated Windows Auth isn't enabled!)
1864      *
1865      * NOTE that this code will execute under the OS user credentials,
1866      * so we MUST avoid dealing with files -- such as session files.
1867      * (The caller should define('NO_MOODLE_COOKIES', true) before including config.php)
1868      *
1869      */
1870     function ntlmsso_magic($sesskey) {
1871         if (isset($_SERVER['REMOTE_USER']) && !empty($_SERVER['REMOTE_USER'])) {
1873             // HTTP __headers__ seem to be sent in ISO-8859-1 encoding
1874             // (according to my reading of RFC-1945, RFC-2616 and RFC-2617 and
1875             // my local tests), so we need to convert the REMOTE_USER value
1876             // (i.e., what we got from the HTTP WWW-Authenticate header) into UTF-8
1877             $textlib = textlib_get_instance();
1878             $username = $textlib->convert($_SERVER['REMOTE_USER'], 'iso-8859-1', 'utf-8');
1880             $username = substr(strrchr($username, '\\'), 1); //strip domain info
1881             $username = moodle_strtolower($username); //compatibility hack
1882             set_cache_flag('auth/ldap/ntlmsess', $sesskey, $username, AUTH_NTLMTIMEOUT);
1883             return true;
1884         }
1885         return false;
1886     }
1888     /**
1889      * Find the session set by ntlmsso_magic(), validate it and
1890      * call authenticate_user_login() to authenticate the user through
1891      * the auth machinery.
1892      *
1893      * It is complemented by a similar check in user_login().
1894      *
1895      * If it succeeds, it never returns.
1896      *
1897      */
1898     function ntlmsso_finish() {
1899         global $CFG, $USER, $SESSION;
1901         $key = sesskey();
1902         $cf = get_cache_flags('auth/ldap/ntlmsess');
1903         if (!isset($cf[$key]) || $cf[$key] === '') {
1904             return false;
1905         }
1906         $username   = $cf[$key];
1907         // Here we want to trigger the whole authentication machinery
1908         // to make sure no step is bypassed...
1909         $user = authenticate_user_login($username, $key);
1910         if ($user) {
1911             add_to_log(SITEID, 'user', 'login', "view.php?id=$USER->id&course=".SITEID,
1912                        $user->id, 0, $user->id);
1913             complete_user_login($user);
1915             // Cleanup the key to prevent reuse...
1916             // and to allow re-logins with normal credentials
1917             unset_cache_flag('auth/ldap/ntlmsess', $key);
1919             /// Redirection
1920             if (user_not_fully_set_up($USER)) {
1921                 $urltogo = $CFG->wwwroot.'/user/edit.php';
1922                 // We don't delete $SESSION->wantsurl yet, so we get there later
1923             } else if (isset($SESSION->wantsurl) and (strpos($SESSION->wantsurl, $CFG->wwwroot) === 0)) {
1924                 $urltogo = $SESSION->wantsurl;    /// Because it's an address in this site
1925                 unset($SESSION->wantsurl);
1926             } else {
1927                 // no wantsurl stored or external - go to homepage
1928                 $urltogo = $CFG->wwwroot.'/';
1929                 unset($SESSION->wantsurl);
1930             }
1931             redirect($urltogo);
1932         }
1933         // Should never reach here.
1934         return false;
1935     }
1937     /**
1938      * Sync roles for this user
1939      *
1940      * @param $user object user object (without system magic quotes)
1941      */
1942     function sync_roles($user) {
1943         $iscreator = $this->iscreator($user->username);
1944         if ($iscreator === null) {
1945             return; //nothing to sync - creators not configured
1946         }
1948         if ($roles = get_archetype_roles('coursecreator')) {
1949             $creatorrole = array_shift($roles);      // We can only use one, let's use the first one
1950             $systemcontext = get_context_instance(CONTEXT_SYSTEM);
1952             if ($iscreator) { // Following calls will not create duplicates
1953                 role_assign($creatorrole->id, $user->id, 0, $systemcontext->id, 0, 0, 0, 'ldap');
1954             } else {
1955                 //unassign only if previously assigned by this plugin!
1956                 role_unassign($creatorrole->id, $user->id, 0, $systemcontext->id, 'ldap');
1957             }
1958         }
1959     }
1961     /**
1962      * Prints a form for configuring this authentication plugin.
1963      *
1964      * This function is called from admin/auth.php, and outputs a full page with
1965      * a form for configuring this plugin.
1966      *
1967      * @param array $page An object containing all the data for this page.
1968      */
1969     function config_form($config, $err, $user_fields) {
1970         global $OUTPUT;
1972         include 'config.html';
1973     }
1975     /**
1976      * Processes and stores configuration data for this authentication plugin.
1977      */
1978     function process_config($config) {
1979         // set to defaults if undefined
1980         if (!isset($config->host_url))
1981             { $config->host_url = ''; }
1982         if (empty($config->ldapencoding))
1983             { $config->ldapencoding = 'utf-8'; }
1984         if (!isset($config->contexts))
1985             { $config->contexts = ''; }
1986         if (!isset($config->user_type))
1987             { $config->user_type = 'default'; }
1988         if (!isset($config->user_attribute))
1989             { $config->user_attribute = ''; }
1990         if (!isset($config->search_sub))
1991             { $config->search_sub = ''; }
1992         if (!isset($config->opt_deref))
1993             { $config->opt_deref = ''; }
1994         if (!isset($config->preventpassindb))
1995             { $config->preventpassindb = 0; }
1996         if (!isset($config->bind_dn))
1997             {$config->bind_dn = ''; }
1998         if (!isset($config->bind_pw))
1999             {$config->bind_pw = ''; }
2000         if (!isset($config->version))
2001             {$config->version = '2'; }
2002         if (!isset($config->objectclass))
2003             {$config->objectclass = ''; }
2004         if (!isset($config->memberattribute))
2005             {$config->memberattribute = ''; }
2006         if (!isset($config->memberattribute_isdn))
2007             {$config->memberattribute_isdn = ''; }
2008         if (!isset($config->creators))
2009             {$config->creators = ''; }
2010         if (!isset($config->create_context))
2011             {$config->create_context = ''; }
2012         if (!isset($config->expiration))
2013             {$config->expiration = ''; }
2014         if (!isset($config->expiration_warning))
2015             {$config->expiration_warning = '10'; }
2016         if (!isset($config->expireattr))
2017             {$config->expireattr = ''; }
2018         if (!isset($config->gracelogins))
2019             {$config->gracelogins = ''; }
2020         if (!isset($config->graceattr))
2021             {$config->graceattr = ''; }
2022         if (!isset($config->auth_user_create))
2023             {$config->auth_user_create = ''; }
2024         if (!isset($config->forcechangepassword))
2025             {$config->forcechangepassword = 0; }
2026         if (!isset($config->stdchangepassword))
2027             {$config->stdchangepassword = 0; }
2028         if (!isset($config->passtype))
2029             {$config->passtype = 'plaintext'; }
2030         if (!isset($config->changepasswordurl))
2031             {$config->changepasswordurl = ''; }
2032         if (!isset($config->removeuser))
2033             {$config->removeuser = AUTH_REMOVEUSER_KEEP; }
2034         if (!isset($config->ntlmsso_enabled))
2035             {$config->ntlmsso_enabled = 0; }
2036         if (!isset($config->ntlmsso_subnet))
2037             {$config->ntlmsso_subnet = ''; }
2038         if (!isset($config->ntlmsso_ie_fastpath))
2039             {$config->ntlmsso_ie_fastpath = 0; }
2041         // save settings
2042         set_config('host_url', $config->host_url, 'auth/ldap');
2043         set_config('ldapencoding', $config->ldapencoding, 'auth/ldap');
2044         set_config('host_url', $config->host_url, 'auth/ldap');
2045         set_config('contexts', $config->contexts, 'auth/ldap');
2046         set_config('user_type', $config->user_type, 'auth/ldap');
2047         set_config('user_attribute', $config->user_attribute, 'auth/ldap');
2048         set_config('search_sub', $config->search_sub, 'auth/ldap');
2049         set_config('opt_deref', $config->opt_deref, 'auth/ldap');
2050         set_config('preventpassindb', $config->preventpassindb, 'auth/ldap');
2051         set_config('bind_dn', $config->bind_dn, 'auth/ldap');
2052         set_config('bind_pw', $config->bind_pw, 'auth/ldap');
2053         set_config('version', $config->version, 'auth/ldap');
2054         set_config('objectclass', trim($config->objectclass), 'auth/ldap');
2055         set_config('memberattribute', $config->memberattribute, 'auth/ldap');
2056         set_config('memberattribute_isdn', $config->memberattribute_isdn, 'auth/ldap');
2057         set_config('creators', $config->creators, 'auth/ldap');
2058         set_config('create_context', $config->create_context, 'auth/ldap');
2059         set_config('expiration', $config->expiration, 'auth/ldap');
2060         set_config('expiration_warning', $config->expiration_warning, 'auth/ldap');
2061         set_config('expireattr', $config->expireattr, 'auth/ldap');
2062         set_config('gracelogins', $config->gracelogins, 'auth/ldap');
2063         set_config('graceattr', $config->graceattr, 'auth/ldap');
2064         set_config('auth_user_create', $config->auth_user_create, 'auth/ldap');
2065         set_config('forcechangepassword', $config->forcechangepassword, 'auth/ldap');
2066         set_config('stdchangepassword', $config->stdchangepassword, 'auth/ldap');
2067         set_config('passtype', $config->passtype, 'auth/ldap');
2068         set_config('changepasswordurl', $config->changepasswordurl, 'auth/ldap');
2069         set_config('removeuser', $config->removeuser, 'auth/ldap');
2070         set_config('ntlmsso_enabled', (int)$config->ntlmsso_enabled, 'auth/ldap');
2071         set_config('ntlmsso_subnet', $config->ntlmsso_subnet, 'auth/ldap');
2072         set_config('ntlmsso_ie_fastpath', (int)$config->ntlmsso_ie_fastpath, 'auth/ldap');
2074         return true;
2075     }
2077     /**
2078      * Quote control characters in texts used in ldap filters - see rfc2254.txt
2079      *
2080      * @param string
2081      */
2082     function filter_addslashes($text) {
2083         $text = str_replace('\\', '\\5c', $text);
2084         $text = str_replace(array('*',    '(',    ')',    "\0"),
2085                             array('\\2a', '\\28', '\\29', '\\00'), $text);
2086         return $text;
2087     }
2089     /**
2090      * Quote control characters in quoted "texts" used in ldap
2091      *
2092      * @param string
2093      */
2094     function ldap_addslashes($text) {
2095         $text = str_replace('\\', '\\\\', $text);
2096         $text = str_replace(array('"',   "\0"),
2097                             array('\\"', '\\00'), $text);
2098         return $text;
2099     }
2101     /**
2102      * Get password expiration time for a given user from Active Directory
2103      *
2104      * @param string $pwdlastset The time last time we changed the password.
2105      * @param resource $lcapconn The open LDAP connection.
2106      * @param string $user_dn The distinguished name of the user we are checking.
2107      *
2108      * @return string $unixtime
2109      */
2110     function ldap_get_ad_pwdexpire($pwdlastset, $ldapconn, $user_dn){
2111         define ('ROOTDSE', '');
2112         // UF_DONT_EXPIRE_PASSWD value taken from MSDN directly
2113         define ('UF_DONT_EXPIRE_PASSWD', 0x00010000);
2115         global $CFG;
2117         if (!function_exists('bcsub')) {
2118             error_log ('You need the BCMath extension to use grace logins with Active Directory');
2119             return 0;
2120         }
2122         // If UF_DONT_EXPIRE_PASSWD flag is set in user's
2123         // userAccountControl attribute, the password doesn't expire.
2124         $sr = ldap_read($ldapconn, $user_dn, '(objectClass=*)',
2125                         array('userAccountControl'));
2126         if (!$sr) {
2127             error_log("ldap: error getting userAccountControl for $user_dn");
2128             // don't expire password, as we are not sure it has to be
2129             // expired or not.
2130             return 0;
2131         }
2133         $info = $this->ldap_get_entries($ldapconn, $sr);
2134         $useraccountcontrol = $info[0]['userAccountControl'][0];
2135         if ($useraccountcontrol & UF_DONT_EXPIRE_PASSWD) {
2136             // password doesn't expire.
2137             return 0;
2138         }
2140         // If pwdLastSet is zero, the user must change his/her password now
2141         // (unless UF_DONT_EXPIRE_PASSWD flag is set, but we already
2142         // tested this above)
2143         if ($pwdlastset === '0') {
2144             // password has expired
2145             return -1;
2146         }
2148         // ----------------------------------------------------------------
2149         // Password expiration time in Active Directory is the composition of
2150         // two values:
2151         //
2152         //   - User's pwdLastSet attribute, that stores the last time
2153         //     the password was changed.
2154         //
2155         //   - Domain's maxPwdAge attribute, that sets how long
2156         //     passwords last in this domain.
2157         //
2158         // We already have the first value (passed in as a parameter). We
2159         // need to get the second one. As we don't know the domain DN, we
2160         // have to query rootDSE's defaultNamingContext attribute to get
2161         // it. Then we have to query that DN's maxPwdAge attribute to get
2162         // the real value.
2163         //
2164         // Once we have both values, we just need to combine them. But MS
2165         // chose to use a different base and unit for time measurements.
2166         // So we need to convert the values to Unix timestamps (see
2167         // details below).
2168         // ----------------------------------------------------------------
2170         $sr = ldap_read($ldapconn, ROOTDSE, '(objectClass=*)',
2171                         array('defaultNamingContext'));
2172         if (!$sr) {
2173             error_log("ldap: error querying rootDSE for Active Directory");
2174             return 0;
2175         }
2177         $info = $this->ldap_get_entries($ldapconn, $sr);
2178         $domaindn = $info[0]['defaultNamingContext'][0];
2180         $sr = ldap_read ($ldapconn, $domaindn, '(objectClass=*)',
2181                          array('maxPwdAge'));
2182         $info = $this->ldap_get_entries($ldapconn, $sr);
2183         $maxpwdage = $info[0]['maxPwdAge'][0];
2185         // ----------------------------------------------------------------
2186         // MSDN says that "pwdLastSet contains the number of 100 nanosecond
2187         // intervals since January 1, 1601 (UTC), stored in a 64 bit integer".
2188         //
2189         // According to Perl's Date::Manip, the number of seconds between
2190         // this date and Unix epoch is 11644473600. So we have to
2191         // substract this value to calculate a Unix time, once we have
2192         // scaled pwdLastSet to seconds. This is the script used to
2193         // calculate the value shown above:
2194         //
2195         //    #!/usr/bin/perl -w
2196         //
2197         //    use Date::Manip;
2198         //
2199         //    $date1 = ParseDate ("160101010000 UTC");
2200         //    $date2 = ParseDate ("197001010000 UTC");
2201         //    $delta = DateCalc($date1, $date2, \$err);
2202         //    $secs = Delta_Format($delta, 0, "%st");
2203         //    print "$secs \n";
2204         //
2205         // MSDN also says that "maxPwdAge is stored as a large integer that
2206         // represents the number of 100 nanosecond intervals from the time
2207         // the password was set before the password expires." We also need
2208         // to scale this to seconds. Bear in mind that this value is stored
2209         // as a _negative_ quantity (at least in my AD domain).
2210         //
2211         // As a last remark, if the low 32 bits of maxPwdAge are equal to 0,
2212         // the maximum password age in the domain is set to 0, which means
2213         // passwords do not expire (see
2214         // http://msdn2.microsoft.com/en-us/library/ms974598.aspx)
2215         //
2216         // As the quantities involved are too big for PHP integers, we
2217         // need to use BCMath functions to work with arbitrary precision
2218         // numbers.
2219         // ----------------------------------------------------------------
2222         // If the low order 32 bits are 0, then passwords do not expire in
2223         // the domain. Just do '$maxpwdage mod 2^32' and check the result
2224         // (2^32 = 4294967296)
2225         if (bcmod ($maxpwdage, 4294967296) === '0') {
2226             return 0;
2227         }
2229         // Add up pwdLastSet and maxPwdAge to get password expiration
2230         // time, in MS time units. Remember maxPwdAge is stored as a
2231         // _negative_ quantity, so we need to substract it in fact.
2232         $pwdexpire = bcsub ($pwdlastset, $maxpwdage);
2234         // Scale the result to convert it to Unix time units and return
2235         // that value.
2236         return bcsub( bcdiv($pwdexpire, '10000000'), '11644473600');
2237     }