MDL-11728 finally defining the exact meaning of is_internal() in auth plugins
[moodle.git] / auth / db / auth.php
1 <?php
3 /**
4  * Authentication Plugin: External Database Authentication
5  *
6  * Checks against an external database.
7  *
8  * @package    auth
9  * @subpackage db
10  * @author     Martin Dougiamas
11  * @license    http://www.gnu.org/copyleft/gpl.html GNU Public License
12  */
14 defined('MOODLE_INTERNAL') || die();
16 require_once($CFG->libdir.'/authlib.php');
17 require_once($CFG->libdir.'/adodb/adodb.inc.php');
19 /**
20  * External database authentication plugin.
21  */
22 class auth_plugin_db extends auth_plugin_base {
24     /**
25      * Constructor.
26      */
27     function auth_plugin_db() {
28         $this->authtype = 'db';
29         $this->config = get_config('auth/db');
30         if (empty($this->config->extencoding)) {
31             $this->config->extencoding = 'utf-8';
32         }
33     }
35     /**
36      * Returns true if the username and password work and false if they are
37      * wrong or don't exist.
38      *
39      * @param string $username The username
40      * @param string $password The password
41      *
42      * @return bool Authentication success or failure.
43      */
44     function user_login($username, $password) {
45         global $CFG, $DB;
47         $textlib = textlib_get_instance();
48         $extusername = $textlib->convert($username, 'utf-8', $this->config->extencoding);
49         $extpassword = $textlib->convert($password, 'utf-8', $this->config->extencoding);
51         $authdb = $this->db_init();
53         if ($this->is_internal()) {
54             // lookup username externally, but resolve
55             // password locally -- to support backend that
56             // don't track passwords
57             $rs = $authdb->Execute("SELECT * FROM {$this->config->table}
58                                      WHERE {$this->config->fielduser} = '".$this->ext_addslashes($extusername)."' ");
59             if (!$rs) {
60                 $authdb->Close();
61                 debugging(get_string('auth_dbcantconnect','auth_db'));
62                 return false;
63             }
65             if (!$rs->EOF) {
66                 $rs->Close();
67                 $authdb->Close();
68                 // user exists externally
69                 // check username/password internally
70                 if ($user = $DB->get_record('user', array('username'=>$username, 'mnethostid'=>$CFG->mnet_localhost_id))) {
71                     return validate_internal_user_password($user, $password);
72                 }
73             } else {
74                 $rs->Close();
75                 $authdb->Close();
76                 // user does not exist externally
77                 return false;
78             }
80         } else {
81             // normal case: use external db for both usernames and passwords
83             if ($this->config->passtype === 'md5') {   // Re-format password accordingly
84                 $extpassword = md5($extpassword);
85             } else if ($this->config->passtype === 'sha1') {
86                 $extpassword = sha1($extpassword);
87             }
89             $rs = $authdb->Execute("SELECT * FROM {$this->config->table}
90                                 WHERE {$this->config->fielduser} = '".$this->ext_addslashes($extusername)."'
91                                   AND {$this->config->fieldpass} = '".$this->ext_addslashes($extpassword)."' ");
92             if (!$rs) {
93                 $authdb->Close();
94                 debugging(get_string('auth_dbcantconnect','auth_db'));
95                 return false;
96             }
98             if (!$rs->EOF) {
99                 $rs->Close();
100                 $authdb->Close();
101                 return true;
102             } else {
103                 $rs->Close();
104                 $authdb->Close();
105                 return false;
106             }
108         }
109     }
111     function db_init() {
112         // Connect to the external database (forcing new connection)
113         $authdb = &ADONewConnection($this->config->type);
114         if (!empty($this->config->debugauthdb)) {
115             $authdb->debug = true;
116             ob_start();//start output buffer to allow later use of the page headers
117         }
118         $authdb->Connect($this->config->host, $this->config->user, $this->config->pass, $this->config->name, true);
119         $authdb->SetFetchMode(ADODB_FETCH_ASSOC);
120         if (!empty($this->config->setupsql)) {
121             $authdb->Execute($this->config->setupsql);
122         }
124         return $authdb;
125     }
127     /**
128      * retuns user attribute mappings between moodle and ldap
129      *
130      * @return array
131      */
132     function db_attributes() {
133         $moodleattributes = array();
134         foreach ($this->userfields as $field) {
135             if (!empty($this->config->{"field_map_$field"})) {
136                 $moodleattributes[$field] = $this->config->{"field_map_$field"};
137             }
138         }
139         $moodleattributes['username'] = $this->config->fielduser;
140         return $moodleattributes;
141     }
143     /**
144      * Reads any other information for a user from external database,
145      * then returns it in an array
146      *
147      * @param string $username
148      *
149      * @return array without magic quotes
150      */
151     function get_userinfo($username) {
152         global $CFG;
154         $textlib = textlib_get_instance();
155         $extusername = $textlib->convert($username, 'utf-8', $this->config->extencoding);
157         $authdb = $this->db_init();
159         //Array to map local fieldnames we want, to external fieldnames
160         $selectfields = $this->db_attributes();
162         $result = array();
163         //If at least one field is mapped from external db, get that mapped data:
164         if ($selectfields) {
165             $select = '';
166             foreach ($selectfields as $localname=>$externalname) {
167                 $select .= ", $externalname AS $localname";
168             }
169             $select = 'SELECT ' . substr($select,1);
170             $sql = $select .
171                 " FROM {$this->config->table}" .
172                 " WHERE {$this->config->fielduser} = '".$this->ext_addslashes($extusername)."'";
173             if ($rs = $authdb->Execute($sql)) {
174                 if ( !$rs->EOF ) {
175                     $fields_obj = $rs->FetchObj();
176                     $fields_obj = (object)array_change_key_case((array)$fields_obj , CASE_LOWER);
177                     foreach ($selectfields as $localname=>$externalname) {
178                         $result[$localname] = $textlib->convert($fields_obj->{$localname}, $this->config->extencoding, 'utf-8');
179                      }
180                  }
181                  $rs->Close();
182             }
183         }
184         $authdb->Close();
185         return $result;
186     }
188     /**
189      * Change a user's password
190      *
191      * @param  object  $user        User table object
192      * @param  string  $newpassword Plaintext password
193      *
194      * @return bool                  True on success
195      */
196     function user_update_password($user, $newpassword) {
197         if ($this->is_internal()) {
198             return update_internal_user_password($user, $newpassword);
199         } else {
200             // we should have never been called!
201             return false;
202         }
203     }
205     /**
206      * syncronizes user fron external db to moodle user table
207      *
208      * Sync shouid be done by using idnumber attribute, not username.
209      * You need to pass firstsync parameter to function to fill in
210      * idnumbers if they dont exists in moodle user table.
211      *
212      * Syncing users removes (disables) users that dont exists anymore in external db.
213      * Creates new users and updates coursecreator status of users.
214      *
215      * This implementation is simpler but less scalable than the one found in the LDAP module.
216      *
217      * @param bool $do_updates  Optional: set to true to force an update of existing accounts
218      * @return bool success
219      */
220     function sync_users($do_updates=false) {
221         global $CFG, $DB;
223 /// list external users
224         $userlist = $this->get_userlist();
226 /// delete obsolete internal users
227         if (!empty($this->config->removeuser)) {
229             // find obsolete users
230             if (count($userlist)) {
231                         list($notin_sql, $params) = $DB->get_in_or_equal($userlist, SQL_PARAMS_NAMED, 'u0000', false);
232                         $params['authtype'] = $this->authtype;
233                 $sql = "SELECT u.id, u.username, u.email, u.auth
234                           FROM {user} u
235                          WHERE u.auth=:authtype AND u.deleted=0 AND u.username $notin_sql";
236             } else {
237                 $sql = "SELECT u.id, u.username, u.email, u.auth
238                           FROM {user} u
239                          WHERE u.auth=:authtype AND u.deleted=0";
240                 $params = array();
241                         $params['authtype'] = $this->authtype;
242             }
243             $remove_users = $DB->get_records_sql($sql, $params);
245             if (!empty($remove_users)) {
246                 print_string('auth_dbuserstoremove','auth_db', count($remove_users)); echo "\n";
248                 foreach ($remove_users as $user) {
249                     if ($this->config->removeuser == AUTH_REMOVEUSER_FULLDELETE) {
250                         if (delete_user($user)) {
251                             echo "\t"; print_string('auth_dbdeleteuser', 'auth_db', array('name'=>$user->username, 'id'=>$user->id)); echo "\n";
252                         } else {
253                             echo "\t"; print_string('auth_dbdeleteusererror', 'auth_db', $user->username); echo "\n";
254                         }
255                     } else if ($this->config->removeuser == AUTH_REMOVEUSER_SUSPEND) {
256                         $updateuser = new stdClass();
257                         $updateuser->id   = $user->id;
258                         $updateuser->auth = 'nologin';
259                         $DB->update_record('user', $updateuser);
260                         echo "\t"; print_string('auth_dbsuspenduser', 'auth_db', array('name'=>$user->username, 'id'=>$user->id)); echo "\n";
261                     }
262                 }
263             }
264             unset($remove_users); // free mem!
265         }
267         if (!count($userlist)) {
268             // exit right here
269             // nothing else to do
270             return true;
271         }
273         ///
274         /// update existing accounts
275         ///
276         if ($do_updates) {
277             // narrow down what fields we need to update
278             $all_keys = array_keys(get_object_vars($this->config));
279             $updatekeys = array();
280             foreach ($all_keys as $key) {
281                 if (preg_match('/^field_updatelocal_(.+)$/',$key, $match)) {
282                     if ($this->config->{$key} === 'onlogin') {
283                         array_push($updatekeys, $match[1]); // the actual key name
284                     }
285                 }
286             }
287             // print_r($all_keys); print_r($updatekeys);
288             unset($all_keys); unset($key);
290             // only go ahead if we actually
291             // have fields to update locally
292             if (!empty($updatekeys)) {
293                 list($in_sql, $params) = $DB->get_in_or_equal($userlist, SQL_PARAMS_NAMED, 'u0000', true);
294                 $params['authtype'] = $this->authtype;
295                 $sql = "SELECT u.id, u.username
296                           FROM {user} u
297                          WHERE u.auth=:authtype AND u.deleted=0 AND u.username {$in_sql}";
298                 if ($update_users = $DB->get_records_sql($sql, $params)) {
299                     print "User entries to update: ". count($update_users). "\n";
301                     foreach ($update_users as $user) {
302                         echo "\t"; print_string('auth_dbupdatinguser', 'auth_db', array('name'=>$user->username, 'id'=>$user->id));
303                         if (!$this->update_user_record($user->username, $updatekeys)) {
304                             echo " - ".get_string('skipped');
305                         }
306                         echo "\n";
307                     }
308                     unset($update_users); // free memory
309                 }
310             }
311         }
314         ///
315         /// create missing accounts
316         ///
317         // NOTE: this is very memory intensive
318         // and generally inefficient
319         $sql = 'SELECT u.id, u.username
320                 FROM {user} u
321                 WHERE u.auth=\'' . $this->authtype . '\' AND u.deleted=\'0\'';
323         $users = $DB->get_records_sql($sql);
325         // simplify down to usernames
326         $usernames = array();
327         if (!empty($users)) {
328             foreach ($users as $user) {
329                 array_push($usernames, $user->username);
330             }
331             unset($users);
332         }
334         $add_users = array_diff($userlist, $usernames);
335         unset($usernames);
337         if (!empty($add_users)) {
338             print_string('auth_dbuserstoadd','auth_db',count($add_users)); echo "\n";
339             $transaction = $DB->start_delegated_transaction();
340             foreach($add_users as $user) {
341                 $username = $user;
342                 $user = $this->get_userinfo_asobj($user);
344                 // prep a few params
345                 $user->username   = $username;
346                 $user->modified   = time();
347                 $user->confirmed  = 1;
348                 $user->auth       = $this->authtype;
349                 $user->mnethostid = $CFG->mnet_localhost_id;
350                 if (empty($user->lang)) {
351                     $user->lang = $CFG->lang;
352                 }
354                 // maybe the user has been deleted before
355                 if ($old_user = $DB->get_record('user', array('username'=>$user->username, 'deleted'=>1, 'mnethostid'=>$user->mnethostid))) {
356                     $user->id = $old_user->id;
357                     $DB->set_field('user', 'deleted', 0, array('username'=>$user->username));
358                     echo "\t"; print_string('auth_dbreviveduser', 'auth_db', array('name'=>$user->username, 'id'=>$user->id)); echo "\n";
360                 } else {
361                     $id = $DB->insert_record ('user',$user); // it is truly a new user
362                     echo "\t"; print_string('auth_dbinsertuser','auth_db',array('name'=>$user->username, 'id'=>$id)); echo "\n";
363                     // if relevant, tag for password generation
364                     if ($this->is_internal()) {
365                         set_user_preference('auth_forcepasswordchange', 1, $id);
366                         set_user_preference('create_password',          1, $id);
367                     }
368                 }
369             }
370             $transaction->allow_commit();
371             unset($add_users); // free mem
372         }
373         return true;
374     }
376     function user_exists($username) {
378     /// Init result value
379         $result = false;
381         $textlib = textlib_get_instance();
382         $extusername = $textlib->convert($username, 'utf-8', $this->config->extencoding);
384         $authdb = $this->db_init();
386         $rs = $authdb->Execute("SELECT * FROM {$this->config->table}
387                                      WHERE {$this->config->fielduser} = '".$this->ext_addslashes($extusername)."' ");
389         if (!$rs) {
390             print_error('auth_dbcantconnect','auth_db');
391         } else if (!$rs->EOF) {
392             // user exists exterally
393             $result = true;
394         }
396         $authdb->Close();
397         return $result;
398     }
401     function get_userlist() {
403     /// Init result value
404         $result = array();
406         $authdb = $this->db_init();
408         // fetch userlist
409         $rs = $authdb->Execute("SELECT {$this->config->fielduser} AS username
410                                 FROM   {$this->config->table} ");
412         if (!$rs) {
413             print_error('auth_dbcantconnect','auth_db');
414         } else if (!$rs->EOF) {
415             while ($rec = $rs->FetchRow()) {
416                 $rec = (object)array_change_key_case((array)$rec , CASE_LOWER);
417                 array_push($result, $rec->username);
418             }
419         }
421         $authdb->Close();
422         return $result;
423     }
425     /**
426      * reads userinformation from DB and return it in an object
427      *
428      * @param string $username username (with system magic quotes)
429      * @return array
430      */
431     function get_userinfo_asobj($username) {
432         $user_array = truncate_userinfo($this->get_userinfo($username));
433         $user = new stdClass();
434         foreach($user_array as $key=>$value) {
435             $user->{$key} = $value;
436         }
437         return $user;
438     }
440     /**
441      * will update a local user record from an external source.
442      * is a lighter version of the one in moodlelib -- won't do
443      * expensive ops such as enrolment
444      *
445      * If you don't pass $updatekeys, there is a performance hit and
446      * values removed from DB won't be removed from moodle.
447      *
448      * @param string $username username
449      */
450     function update_user_record($username, $updatekeys=false) {
451         global $CFG, $DB;
453         //just in case check text case
454         $username = trim(moodle_strtolower($username));
456         // get the current user record
457         $user = $DB->get_record('user', array('username'=>$username, 'mnethostid'=>$CFG->mnet_localhost_id));
458         if (empty($user)) { // trouble
459             error_log("Cannot update non-existent user: $username");
460             print_error('auth_dbusernotexist','auth_db',$username);
461             die;
462         }
464         // Ensure userid is not overwritten
465         $userid = $user->id;
467         if ($newinfo = $this->get_userinfo($username)) {
468             $newinfo = truncate_userinfo($newinfo);
470             if (empty($updatekeys)) { // all keys? this does not support removing values
471                 $updatekeys = array_keys($newinfo);
472             }
474             foreach ($updatekeys as $key) {
475                 if (isset($newinfo[$key])) {
476                     $value = $newinfo[$key];
477                 } else {
478                     $value = '';
479                 }
481                 if (!empty($this->config->{'field_updatelocal_' . $key})) {
482                     if (isset($user->{$key}) and $user->{$key} != $value) { // only update if it's changed
483                         $DB->set_field('user', $key, $value, array('id'=>$userid));
484                     }
485                 }
486             }
487         }
488         return $DB->get_record('user', array('id'=>$userid, 'deleted'=>0));
489     }
491     /**
492      * Called when the user record is updated.
493      * Modifies user in external database. It takes olduser (before changes) and newuser (after changes)
494      * conpares information saved modified information to external db.
495      *
496      * @param mixed $olduser     Userobject before modifications
497      * @param mixed $newuser     Userobject new modified userobject
498      * @return boolean result
499      *
500      */
501     function user_update($olduser, $newuser) {
502         if (isset($olduser->username) and isset($newuser->username) and $olduser->username != $newuser->username) {
503             error_log("ERROR:User renaming not allowed in ext db");
504             return false;
505         }
507         if (isset($olduser->auth) and $olduser->auth != $this->authtype) {
508             return true; // just change auth and skip update
509         }
511         $curruser = $this->get_userinfo($olduser->username);
512         if (empty($curruser)) {
513             error_log("ERROR:User $olduser->username found in ext db");
514             return false;
515         }
517         $textlib = textlib_get_instance();
518         $extusername = $textlib->convert($olduser->username, 'utf-8', $this->config->extencoding);
520         $authdb = $this->db_init();
522         $update = array();
523         foreach($curruser as $key=>$value) {
524             if ($key == 'username') {
525                 continue; // skip this
526             }
527             if (empty($this->config->{"field_updateremote_$key"})) {
528                 continue; // remote update not requested
529             }
530             if (!isset($newuser->$key)) {
531                 continue;
532             }
533             $nuvalue = $newuser->$key;
534             if ($nuvalue != $value) {
535                 $update[] = $this->config->{"field_map_$key"}."='".$this->ext_addslashes($textlib->convert($nuvalue, 'utf-8', $this->config->extencoding))."'";
536             }
537         }
538         if (!empty($update)) {
539             $authdb->Execute("UPDATE {$this->config->table}
540                                  SET ".implode(',', $update)."
541                                WHERE {$this->config->fielduser}='".$this->ext_addslashes($extusername)."'");
542         }
543         $authdb->Close();
544         return true;
545     }
547     /**
548      * A chance to validate form data, and last chance to
549      * do stuff before it is inserted in config_plugin
550      */
551      function validate_form(&$form, &$err) {
552         if ($form->passtype === 'internal') {
553             $this->config->changepasswordurl = '';
554             set_config('changepasswordurl', '', 'auth/db');
555         }
556     }
558     function prevent_local_passwords() {
559         return !$this->is_internal();
560     }
562     /**
563      * Returns true if this authentication plugin is "internal".
564      *
565      * Internal plugins use password hashes from Moodle user table for authentication.
566      *
567      * @return bool
568      */
569     function is_internal() {
570         if (!isset($this->config->passtype)) {
571             return true;
572         }
573         return ($this->config->passtype === 'internal');
574     }
576     /**
577      * Indicates if moodle should automatically update internal user
578      * records with data from external sources using the information
579      * from auth_plugin_base::get_userinfo().
580      *
581      * @return bool true means automatically copy data from ext to user table
582      */
583     function is_synchronised_with_external() {
584         return true;
585     }
587     /**
588      * Returns true if this authentication plugin can change the user's
589      * password.
590      *
591      * @return bool
592      */
593     function can_change_password() {
594         return ($this->is_internal() or !empty($this->config->changepasswordurl));
595     }
597     /**
598      * Returns the URL for changing the user's pw, or empty if the default can
599      * be used.
600      *
601      * @return moodle_url
602      */
603     function change_password_url() {
604         if ($this->is_internal()) {
605             // standard form
606             return null;
607         } else {
608             // use admin defined custom url
609             return new moodle_url($this->config->changepasswordurl);
610         }
611     }
613     /**
614      * Returns true if plugin allows resetting of internal password.
615      *
616      * @return bool
617      */
618     function can_reset_password() {
619         return $this->is_internal();
620     }
622     /**
623      * Prints a form for configuring this authentication plugin.
624      *
625      * This function is called from admin/auth.php, and outputs a full page with
626      * a form for configuring this plugin.
627      *
628      * @param array $page An object containing all the data for this page.
629      */
630     function config_form($config, $err, $user_fields) {
631         include 'config.html';
632     }
634     /**
635      * Processes and stores configuration data for this authentication plugin.
636      */
637     function process_config($config) {
638         // set to defaults if undefined
639         if (!isset($config->host)) {
640             $config->host = 'localhost';
641         }
642         if (!isset($config->type)) {
643             $config->type = 'mysql';
644         }
645         if (!isset($config->sybasequoting)) {
646             $config->sybasequoting = 0;
647         }
648         if (!isset($config->name)) {
649             $config->name = '';
650         }
651         if (!isset($config->user)) {
652             $config->user = '';
653         }
654         if (!isset($config->pass)) {
655             $config->pass = '';
656         }
657         if (!isset($config->table)) {
658             $config->table = '';
659         }
660         if (!isset($config->fielduser)) {
661             $config->fielduser = '';
662         }
663         if (!isset($config->fieldpass)) {
664             $config->fieldpass = '';
665         }
666         if (!isset($config->passtype)) {
667             $config->passtype = 'plaintext';
668         }
669         if (!isset($config->extencoding)) {
670             $config->extencoding = 'utf-8';
671         }
672         if (!isset($config->setupsql)) {
673             $config->setupsql = '';
674         }
675         if (!isset($config->debugauthdb)) {
676             $config->debugauthdb = 0;
677         }
678         if (!isset($config->removeuser)) {
679             $config->removeuser = AUTH_REMOVEUSER_KEEP;
680         }
681         if (!isset($config->changepasswordurl)) {
682             $config->changepasswordurl = '';
683         }
685         // save settings
686         set_config('host',          $config->host,          'auth/db');
687         set_config('type',          $config->type,          'auth/db');
688         set_config('sybasequoting', $config->sybasequoting, 'auth/db');
689         set_config('name',          $config->name,          'auth/db');
690         set_config('user',          $config->user,          'auth/db');
691         set_config('pass',          $config->pass,          'auth/db');
692         set_config('table',         $config->table,         'auth/db');
693         set_config('fielduser',     $config->fielduser,     'auth/db');
694         set_config('fieldpass',     $config->fieldpass,     'auth/db');
695         set_config('passtype',      $config->passtype,      'auth/db');
696         set_config('extencoding',   trim($config->extencoding), 'auth/db');
697         set_config('setupsql',      trim($config->setupsql),'auth/db');
698         set_config('debugauthdb',   $config->debugauthdb,   'auth/db');
699         set_config('removeuser',    $config->removeuser,    'auth/db');
700         set_config('changepasswordurl', trim($config->changepasswordurl), 'auth/db');
702         return true;
703     }
705     function ext_addslashes($text) {
706         // using custom made function for now
707         if (empty($this->config->sybasequoting)) {
708             $text = str_replace('\\', '\\\\', $text);
709             $text = str_replace(array('\'', '"', "\0"), array('\\\'', '\\"', '\\0'), $text);
710         } else {
711             $text = str_replace("'", "''", $text);
712         }
713         return $text;
714     }