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