auth/ldap/auth.php

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