auth/db/auth.php

   1 <?php
   2 // This file is part of Moodle - http://moodle.org/
   3 //
   4 // Moodle is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU General Public License as published by
   6 // the Free Software Foundation, either version 3 of the License, or
   7 // (at your option) any later version.
   8 //
   9 // Moodle is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU General Public License
  15 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 /**
  18  * Authentication Plugin: External Database Authentication
  19  *
  20  * Checks against an external database.
  21  *
  22  * @package    auth_db
  23  * @author     Martin Dougiamas
  24  * @license    http://www.gnu.org/copyleft/gpl.html GNU Public License
  25  */
  26
  27 defined('MOODLE_INTERNAL') || die();
  28
  29 require_once($CFG->libdir.'/authlib.php');
  30
  31 /**
  32  * External database authentication plugin.
  33  */
  34 class auth_plugin_db extends auth_plugin_base {
  35
  36     /**
  37      * Constructor.
  38      */
  39     function __construct() {
  40         global $CFG;
  41         require_once($CFG->libdir.'/adodb/adodb.inc.php');
  42
  43         $this->authtype = 'db';
  44         $this->config = get_config('auth/db');
  45         if (empty($this->config->extencoding)) {
  46             $this->config->extencoding = 'utf-8';
  47         }
  48     }
  49
  50     /**
  51      * Returns true if the username and password work and false if they are
  52      * wrong or don't exist.
  53      *
  54      * @param string $username The username
  55      * @param string $password The password
  56      * @return bool Authentication success or failure.
  57      */
  58     function user_login($username, $password) {
  59         global $CFG, $DB;
  60
  61         $extusername = core_text::convert($username, 'utf-8', $this->config->extencoding);
  62         $extpassword = core_text::convert($password, 'utf-8', $this->config->extencoding);
  63
  64         if ($this->is_internal()) {
  65             // Lookup username externally, but resolve
  66             // password locally -- to support backend that
  67             // don't track passwords.
  68
  69             if (isset($this->config->removeuser) and $this->config->removeuser == AUTH_REMOVEUSER_KEEP) {
  70                 // No need to connect to external database in this case because users are never removed and we verify password locally.
  71                 if ($user = $DB->get_record('user', array('username'=>$username, 'mnethostid'=>$CFG->mnet_localhost_id, 'auth'=>$this->authtype))) {
  72                     return validate_internal_user_password($user, $password);
  73                 } else {
  74                     return false;
  75                 }
  76             }
  77
  78             $authdb = $this->db_init();
  79
  80             $rs = $authdb->Execute("SELECT *
  81                                       FROM {$this->config->table}
  82                                      WHERE {$this->config->fielduser} = '".$this->ext_addslashes($extusername)."'");
  83             if (!$rs) {
  84                 $authdb->Close();
  85                 debugging(get_string('auth_dbcantconnect','auth_db'));
  86                 return false;
  87             }
  88
  89             if (!$rs->EOF) {
  90                 $rs->Close();
  91                 $authdb->Close();
  92                 // User exists externally - check username/password internally.
  93                 if ($user = $DB->get_record('user', array('username'=>$username, 'mnethostid'=>$CFG->mnet_localhost_id, 'auth'=>$this->authtype))) {
  94                     return validate_internal_user_password($user, $password);
  95                 }
  96             } else {
  97                 $rs->Close();
  98                 $authdb->Close();
  99                 // User does not exist externally.
 100                 return false;
 101             }
 102
 103         } else {
 104             // Normal case: use external db for both usernames and passwords.
 105
 106             $authdb = $this->db_init();
 107
 108             $rs = $authdb->Execute("SELECT {$this->config->fieldpass} AS userpass
 109                                       FROM {$this->config->table}
 110                                      WHERE {$this->config->fielduser} = '".$this->ext_addslashes($extusername)."'");
 111             if (!$rs) {
 112                 $authdb->Close();
 113                 debugging(get_string('auth_dbcantconnect','auth_db'));
 114                 return false;
 115             }
 116
 117             if ($rs->EOF) {
 118                 $authdb->Close();
 119                 return false;
 120             }
 121
 122             $fields = array_change_key_case($rs->fields, CASE_LOWER);
 123             $fromdb = $fields['userpass'];
 124             $rs->Close();
 125             $authdb->Close();
 126
 127             if ($this->config->passtype === 'plaintext') {
 128                 return ($fromdb == $extpassword);
 129             } else if ($this->config->passtype === 'md5') {
 130                 return ($fromdb == md5($extpassword));
 131             } else if ($this->config->passtype === 'sha1') {
 132                 return ($fromdb == sha1($extpassword));
 133             } else if ($this->config->passtype === 'saltedcrypt') {
 134                 require_once($CFG->libdir.'/password_compat/lib/password.php');
 135                 return password_verify($extpassword, $fromdb);
 136             } else {
 137                 return false;
 138             }
 139
 140         }
 141     }
 142
 143     /**
 144      * Connect to external database.
 145      *
 146      * @return ADOConnection
 147      */
 148     function db_init() {
 149         // Connect to the external database (forcing new connection).
 150         $authdb = ADONewConnection($this->config->type);
 151         if (!empty($this->config->debugauthdb)) {
 152             $authdb->debug = true;
 153             ob_start(); //Start output buffer to allow later use of the page headers.
 154         }
 155         $authdb->Connect($this->config->host, $this->config->user, $this->config->pass, $this->config->name, true);
 156         $authdb->SetFetchMode(ADODB_FETCH_ASSOC);
 157         if (!empty($this->config->setupsql)) {
 158             $authdb->Execute($this->config->setupsql);
 159         }
 160
 161         return $authdb;
 162     }
 163
 164     /**
 165      * Returns user attribute mappings between moodle and ldap.
 166      *
 167      * @return array
 168      */
 169     function db_attributes() {
 170         $moodleattributes = array();
 171         foreach ($this->userfields as $field) {
 172             if (!empty($this->config->{"field_map_$field"})) {
 173                 $moodleattributes[$field] = $this->config->{"field_map_$field"};
 174             }
 175         }
 176         $moodleattributes['username'] = $this->config->fielduser;
 177         return $moodleattributes;
 178     }
 179
 180     /**
 181      * Reads any other information for a user from external database,
 182      * then returns it in an array.
 183      *
 184      * @param string $username
 185      * @return array
 186      */
 187     function get_userinfo($username) {
 188         global $CFG;
 189
 190         $extusername = core_text::convert($username, 'utf-8', $this->config->extencoding);
 191
 192         $authdb = $this->db_init();
 193
 194         // Array to map local fieldnames we want, to external fieldnames.
 195         $selectfields = $this->db_attributes();
 196
 197         $result = array();
 198         // If at least one field is mapped from external db, get that mapped data.
 199         if ($selectfields) {
 200             $select = array();
 201             foreach ($selectfields as $localname=>$externalname) {
 202                 $select[] = "$externalname AS $localname";
 203             }
 204             $select = implode(', ', $select);
 205             $sql = "SELECT $select
 206                       FROM {$this->config->table}
 207                      WHERE {$this->config->fielduser} = '".$this->ext_addslashes($extusername)."'";
 208             if ($rs = $authdb->Execute($sql)) {
 209                 if (!$rs->EOF) {
 210                     $fields_obj = $rs->FetchObj();
 211                     $fields_obj = (object)array_change_key_case((array)$fields_obj , CASE_LOWER);
 212                     foreach ($selectfields as $localname=>$externalname) {
 213                         $result[$localname] = core_text::convert($fields_obj->{$localname}, $this->config->extencoding, 'utf-8');
 214                      }
 215                  }
 216                  $rs->Close();
 217             }
 218         }
 219         $authdb->Close();
 220         return $result;
 221     }
 222
 223     /**
 224      * Change a user's password.
 225      *
 226      * @param  stdClass  $user      User table object
 227      * @param  string  $newpassword Plaintext password
 228      * @return bool                 True on success
 229      */
 230     function user_update_password($user, $newpassword) {
 231         global $DB;
 232
 233         if ($this->is_internal()) {
 234             $puser = $DB->get_record('user', array('id'=>$user->id), '*', MUST_EXIST);
 235             // This will also update the stored hash to the latest algorithm
 236             // if the existing hash is using an out-of-date algorithm (or the
 237             // legacy md5 algorithm).
 238             if (update_internal_user_password($puser, $newpassword)) {
 239                 $user->password = $puser->password;
 240                 return true;
 241             } else {
 242                 return false;
 243             }
 244         } else {
 245             // We should have never been called!
 246             return false;
 247         }
 248     }
 249
 250     /**
 251      * Synchronizes user from external db to moodle user table.
 252      *
 253      * Sync should be done by using idnumber attribute, not username.
 254      * You need to pass firstsync parameter to function to fill in
 255      * idnumbers if they don't exists in moodle user table.
 256      *
 257      * Syncing users removes (disables) users that don't exists anymore in external db.
 258      * Creates new users and updates coursecreator status of users.
 259      *
 260      * This implementation is simpler but less scalable than the one found in the LDAP module.
 261      *
 262      * @param progress_trace $trace
 263      * @param bool $do_updates  Optional: set to true to force an update of existing accounts
 264      * @return int 0 means success, 1 means failure
 265      */
 266     function sync_users(progress_trace $trace, $do_updates=false) {
 267         global $CFG, $DB;
 268
 269         require_once($CFG->dirroot . '/user/lib.php');
 270
 271         // List external users.
 272         $userlist = $this->get_userlist();
 273
 274         // Delete obsolete internal users.
 275         if (!empty($this->config->removeuser)) {
 276
 277             $suspendselect = "";
 278             if ($this->config->removeuser == AUTH_REMOVEUSER_SUSPEND) {
 279                 $suspendselect = "AND u.suspended = 0";
 280             }
 281
 282             // Find obsolete users.
 283             if (count($userlist)) {
 284                 list($notin_sql, $params) = $DB->get_in_or_equal($userlist, SQL_PARAMS_NAMED, 'u', false);
 285                 $params['authtype'] = $this->authtype;
 286                 $sql = "SELECT u.*
 287                           FROM {user} u
 288                          WHERE u.auth=:authtype AND u.deleted=0 AND u.mnethostid=:mnethostid $suspendselect AND u.username $notin_sql";
 289             } else {
 290                 $sql = "SELECT u.*
 291                           FROM {user} u
 292                          WHERE u.auth=:authtype AND u.deleted=0 AND u.mnethostid=:mnethostid $suspendselect";
 293                 $params = array();
 294                 $params['authtype'] = $this->authtype;
 295             }
 296             $params['mnethostid'] = $CFG->mnet_localhost_id;
 297             $remove_users = $DB->get_records_sql($sql, $params);
 298
 299             if (!empty($remove_users)) {
 300                 $trace->output(get_string('auth_dbuserstoremove','auth_db', count($remove_users)));
 301
 302                 foreach ($remove_users as $user) {
 303                     if ($this->config->removeuser == AUTH_REMOVEUSER_FULLDELETE) {
 304                         delete_user($user);
 305                         $trace->output(get_string('auth_dbdeleteuser', 'auth_db', array('name'=>$user->username, 'id'=>$user->id)), 1);
 306                     } else if ($this->config->removeuser == AUTH_REMOVEUSER_SUSPEND) {
 307                         $updateuser = new stdClass();
 308                         $updateuser->id   = $user->id;
 309                         $updateuser->suspended = 1;
 310                         user_update_user($updateuser, false);
 311                         $trace->output(get_string('auth_dbsuspenduser', 'auth_db', array('name'=>$user->username, 'id'=>$user->id)), 1);
 312                     }
 313                 }
 314             }
 315             unset($remove_users);
 316         }
 317
 318         if (!count($userlist)) {
 319             // Exit right here, nothing else to do.
 320             $trace->finished();
 321             return 0;
 322         }
 323
 324         // Update existing accounts.
 325         if ($do_updates) {
 326             // Narrow down what fields we need to update.
 327             $all_keys = array_keys(get_object_vars($this->config));
 328             $updatekeys = array();
 329             foreach ($all_keys as $key) {
 330                 if (preg_match('/^field_updatelocal_(.+)$/',$key, $match)) {
 331                     if ($this->config->{$key} === 'onlogin') {
 332                         array_push($updatekeys, $match[1]); // The actual key name.
 333                     }
 334                 }
 335             }
 336             unset($all_keys); unset($key);
 337
 338             // Only go ahead if we actually have fields to update locally.
 339             if (!empty($updatekeys)) {
 340                 list($in_sql, $params) = $DB->get_in_or_equal($userlist, SQL_PARAMS_NAMED, 'u', true);
 341                 $params['authtype'] = $this->authtype;
 342                 $sql = "SELECT u.id, u.username
 343                           FROM {user} u
 344                          WHERE u.auth=:authtype AND u.deleted=0 AND u.username {$in_sql}";
 345                 if ($update_users = $DB->get_records_sql($sql, $params)) {
 346                     $trace->output("User entries to update: ".count($update_users));
 347
 348                     foreach ($update_users as $user) {
 349                         if ($this->update_user_record($user->username, $updatekeys)) {
 350                             $trace->output(get_string('auth_dbupdatinguser', 'auth_db', array('name'=>$user->username, 'id'=>$user->id)), 1);
 351                         } else {
 352                             $trace->output(get_string('auth_dbupdatinguser', 'auth_db', array('name'=>$user->username, 'id'=>$user->id))." - ".get_string('skipped'), 1);
 353                         }
 354                     }
 355                     unset($update_users);
 356                 }
 357             }
 358         }
 359
 360
 361         // Create missing accounts.
 362         // NOTE: this is very memory intensive and generally inefficient.
 363         $suspendselect = "";
 364         if ($this->config->removeuser == AUTH_REMOVEUSER_SUSPEND) {
 365             $suspendselect = "AND u.suspended = 0";
 366         }
 367         $sql = "SELECT u.id, u.username
 368                   FROM {user} u
 369                  WHERE u.auth=:authtype AND u.deleted='0' AND mnethostid=:mnethostid $suspendselect";
 370
 371         $users = $DB->get_records_sql($sql, array('authtype'=>$this->authtype, 'mnethostid'=>$CFG->mnet_localhost_id));
 372
 373         // Simplify down to usernames.
 374         $usernames = array();
 375         if (!empty($users)) {
 376             foreach ($users as $user) {
 377                 array_push($usernames, $user->username);
 378             }
 379             unset($users);
 380         }
 381
 382         $add_users = array_diff($userlist, $usernames);
 383         unset($usernames);
 384
 385         if (!empty($add_users)) {
 386             $trace->output(get_string('auth_dbuserstoadd','auth_db',count($add_users)));
 387             // Do not use transactions around this foreach, we want to skip problematic users, not revert everything.
 388             foreach($add_users as $user) {
 389                 $username = $user;
 390                 if ($this->config->removeuser == AUTH_REMOVEUSER_SUSPEND) {
 391                     if ($olduser = $DB->get_record('user', array('username' => $username, 'deleted' => 0, 'suspended' => 1,
 392                             'mnethostid' => $CFG->mnet_localhost_id, 'auth' => $this->authtype))) {
 393                         $updateuser = new stdClass();
 394                         $updateuser->id = $olduser->id;
 395                         $updateuser->suspended = 0;
 396                         user_update_user($updateuser);
 397                         $trace->output(get_string('auth_dbreviveduser', 'auth_db', array('name' => $username,
 398                             'id' => $olduser->id)), 1);
 399                         continue;
 400                     }
 401                 }
 402
 403                 // Do not try to undelete users here, instead select suspending if you ever expect users will reappear.
 404
 405                 // Prep a few params.
 406                 $user = $this->get_userinfo_asobj($user);
 407                 $user->username   = $username;
 408                 $user->confirmed  = 1;
 409                 $user->auth       = $this->authtype;
 410                 $user->mnethostid = $CFG->mnet_localhost_id;
 411                 if (empty($user->lang)) {
 412                     $user->lang = $CFG->lang;
 413                 }
 414                 if ($collision = $DB->get_record_select('user', "username = :username AND mnethostid = :mnethostid AND auth <> :auth", array('username'=>$user->username, 'mnethostid'=>$CFG->mnet_localhost_id, 'auth'=>$this->authtype), 'id,username,auth')) {
 415                     $trace->output(get_string('auth_dbinsertuserduplicate', 'auth_db', array('username'=>$user->username, 'auth'=>$collision->auth)), 1);
 416                     continue;
 417                 }
 418                 try {
 419                     $id = user_create_user($user, false); // It is truly a new user.
 420                     $trace->output(get_string('auth_dbinsertuser', 'auth_db', array('name'=>$user->username, 'id'=>$id)), 1);
 421                 } catch (moodle_exception $e) {
 422                     $trace->output(get_string('auth_dbinsertusererror', 'auth_db', $user->username), 1);
 423                     continue;
 424                 }
 425                 // If relevant, tag for password generation.
 426                 if ($this->is_internal()) {
 427                     set_user_preference('auth_forcepasswordchange', 1, $id);
 428                     set_user_preference('create_password',          1, $id);
 429                 }
 430                 // Make sure user context is present.
 431                 context_user::instance($id);
 432             }
 433             unset($add_users);
 434         }
 435         $trace->finished();
 436         return 0;
 437     }
 438
 439     function user_exists($username) {
 440
 441         // Init result value.
 442         $result = false;
 443
 444         $extusername = core_text::convert($username, 'utf-8', $this->config->extencoding);
 445
 446         $authdb = $this->db_init();
 447
 448         $rs = $authdb->Execute("SELECT *
 449                                   FROM {$this->config->table}
 450                                  WHERE {$this->config->fielduser} = '".$this->ext_addslashes($extusername)."' ");
 451
 452         if (!$rs) {
 453             print_error('auth_dbcantconnect','auth_db');
 454         } else if (!$rs->EOF) {
 455             // User exists externally.
 456             $result = true;
 457         }
 458
 459         $authdb->Close();
 460         return $result;
 461     }
 462
 463
 464     function get_userlist() {
 465
 466         // Init result value.
 467         $result = array();
 468
 469         $authdb = $this->db_init();
 470
 471         // Fetch userlist.
 472         $rs = $authdb->Execute("SELECT {$this->config->fielduser} AS username
 473                                   FROM {$this->config->table} ");
 474
 475         if (!$rs) {
 476             print_error('auth_dbcantconnect','auth_db');
 477         } else if (!$rs->EOF) {
 478             while ($rec = $rs->FetchRow()) {
 479                 $rec = (object)array_change_key_case((array)$rec , CASE_LOWER);
 480                 array_push($result, $rec->username);
 481             }
 482         }
 483
 484         $authdb->Close();
 485         return $result;
 486     }
 487
 488     /**
 489      * Reads user information from DB and return it in an object.
 490      *
 491      * @param string $username username
 492      * @return array
 493      */
 494     function get_userinfo_asobj($username) {
 495         $user_array = truncate_userinfo($this->get_userinfo($username));
 496         $user = new stdClass();
 497         foreach($user_array as $key=>$value) {
 498             $user->{$key} = $value;
 499         }
 500         return $user;
 501     }
 502
 503     /**
 504      * will update a local user record from an external source.
 505      * is a lighter version of the one in moodlelib -- won't do
 506      * expensive ops such as enrolment.
 507      *
 508      * If you don't pass $updatekeys, there is a performance hit and
 509      * values removed from DB won't be removed from moodle.
 510      *
 511      * @param string $username username
 512      * @param bool $updatekeys
 513      * @return stdClass
 514      */
 515     function update_user_record($username, $updatekeys=false) {
 516         global $CFG, $DB;
 517
 518         //just in case check text case
 519         $username = trim(core_text::strtolower($username));
 520
 521         // get the current user record
 522         $user = $DB->get_record('user', array('username'=>$username, 'mnethostid'=>$CFG->mnet_localhost_id));
 523         if (empty($user)) { // trouble
 524             error_log("Cannot update non-existent user: $username");
 525             print_error('auth_dbusernotexist','auth_db',$username);
 526             die;
 527         }
 528
 529         // Ensure userid is not overwritten.
 530         $userid = $user->id;
 531         $needsupdate = false;
 532
 533         $updateuser = new stdClass();
 534         $updateuser->id = $userid;
 535         if ($newinfo = $this->get_userinfo($username)) {
 536             $newinfo = truncate_userinfo($newinfo);
 537
 538             if (empty($updatekeys)) { // All keys? This does not support removing values.
 539                 $updatekeys = array_keys($newinfo);
 540             }
 541
 542             foreach ($updatekeys as $key) {
 543                 if (isset($newinfo[$key])) {
 544                     $value = $newinfo[$key];
 545                 } else {
 546                     $value = '';
 547                 }
 548
 549                 if (!empty($this->config->{'field_updatelocal_' . $key})) {
 550                     if (isset($user->{$key}) and $user->{$key} != $value) { // Only update if it's changed.
 551                         $needsupdate = true;
 552                         $updateuser->$key = $value;
 553                     }
 554                 }
 555             }
 556         }
 557         if ($needsupdate) {
 558             require_once($CFG->dirroot . '/user/lib.php');
 559             user_update_user($updateuser);
 560         }
 561         return $DB->get_record('user', array('id'=>$userid, 'deleted'=>0));
 562     }
 563
 564     /**
 565      * Called when the user record is updated.
 566      * Modifies user in external database. It takes olduser (before changes) and newuser (after changes)
 567      * compares information saved modified information to external db.
 568      *
 569      * @param stdClass $olduser     Userobject before modifications
 570      * @param stdClass $newuser     Userobject new modified userobject
 571      * @return boolean result
 572      *
 573      */
 574     function user_update($olduser, $newuser) {
 575         if (isset($olduser->username) and isset($newuser->username) and $olduser->username != $newuser->username) {
 576             error_log("ERROR:User renaming not allowed in ext db");
 577             return false;
 578         }
 579
 580         if (isset($olduser->auth) and $olduser->auth != $this->authtype) {
 581             return true; // Just change auth and skip update.
 582         }
 583
 584         $curruser = $this->get_userinfo($olduser->username);
 585         if (empty($curruser)) {
 586             error_log("ERROR:User $olduser->username found in ext db");
 587             return false;
 588         }
 589
 590         $extusername = core_text::convert($olduser->username, 'utf-8', $this->config->extencoding);
 591
 592         $authdb = $this->db_init();
 593
 594         $update = array();
 595         foreach($curruser as $key=>$value) {
 596             if ($key == 'username') {
 597                 continue; // Skip this.
 598             }
 599             if (empty($this->config->{"field_updateremote_$key"})) {
 600                 continue; // Remote update not requested.
 601             }
 602             if (!isset($newuser->$key)) {
 603                 continue;
 604             }
 605             $nuvalue = $newuser->$key;
 606             if ($nuvalue != $value) {
 607                 $update[] = $this->config->{"field_map_$key"}."='".$this->ext_addslashes(core_text::convert($nuvalue, 'utf-8', $this->config->extencoding))."'";
 608             }
 609         }
 610         if (!empty($update)) {
 611             $authdb->Execute("UPDATE {$this->config->table}
 612                                  SET ".implode(',', $update)."
 613                                WHERE {$this->config->fielduser}='".$this->ext_addslashes($extusername)."'");
 614         }
 615         $authdb->Close();
 616         return true;
 617     }
 618
 619     /**
 620      * A chance to validate form data, and last chance to
 621      * do stuff before it is inserted in config_plugin
 622      *
 623      * @param stfdClass $form
 624      * @param array $err errors
 625      * @return void
 626      */
 627      function validate_form($form, &$err) {
 628         if ($form->passtype === 'internal') {
 629             $this->config->changepasswordurl = '';
 630             set_config('changepasswordurl', '', 'auth/db');
 631         }
 632     }
 633
 634     function prevent_local_passwords() {
 635         return !$this->is_internal();
 636     }
 637
 638     /**
 639      * Returns true if this authentication plugin is "internal".
 640      *
 641      * Internal plugins use password hashes from Moodle user table for authentication.
 642      *
 643      * @return bool
 644      */
 645     function is_internal() {
 646         if (!isset($this->config->passtype)) {
 647             return true;
 648         }
 649         return ($this->config->passtype === 'internal');
 650     }
 651
 652     /**
 653      * Indicates if moodle should automatically update internal user
 654      * records with data from external sources using the information
 655      * from auth_plugin_base::get_userinfo().
 656      *
 657      * @return bool true means automatically copy data from ext to user table
 658      */
 659     function is_synchronised_with_external() {
 660         return true;
 661     }
 662
 663     /**
 664      * Returns true if this authentication plugin can change the user's
 665      * password.
 666      *
 667      * @return bool
 668      */
 669     function can_change_password() {
 670         return ($this->is_internal() or !empty($this->config->changepasswordurl));
 671     }
 672
 673     /**
 674      * Returns the URL for changing the user's pw, or empty if the default can
 675      * be used.
 676      *
 677      * @return moodle_url
 678      */
 679     function change_password_url() {
 680         if ($this->is_internal() || empty($this->config->changepasswordurl)) {
 681             // Standard form.
 682             return null;
 683         } else {
 684             // Use admin defined custom url.
 685             return new moodle_url($this->config->changepasswordurl);
 686         }
 687     }
 688
 689     /**
 690      * Returns true if plugin allows resetting of internal password.
 691      *
 692      * @return bool
 693      */
 694     function can_reset_password() {
 695         return $this->is_internal();
 696     }
 697
 698     /**
 699      * Prints a form for configuring this authentication plugin.
 700      *
 701      * This function is called from admin/auth.php, and outputs a full page with
 702      * a form for configuring this plugin.
 703      *
 704      * @param stdClass $config
 705      * @param array $err errors
 706      * @param array $user_fields
 707      * @return void
 708      */
 709     function config_form($config, $err, $user_fields) {
 710         include 'config.html';
 711     }
 712
 713     /**
 714      * Processes and stores configuration data for this authentication plugin.
 715      *
 716      * @param srdClass $config
 717      * @return bool always true or exception
 718      */
 719     function process_config($config) {
 720         // set to defaults if undefined
 721         if (!isset($config->host)) {
 722             $config->host = 'localhost';
 723         }
 724         if (!isset($config->type)) {
 725             $config->type = 'mysql';
 726         }
 727         if (!isset($config->sybasequoting)) {
 728             $config->sybasequoting = 0;
 729         }
 730         if (!isset($config->name)) {
 731             $config->name = '';
 732         }
 733         if (!isset($config->user)) {
 734             $config->user = '';
 735         }
 736         if (!isset($config->pass)) {
 737             $config->pass = '';
 738         }
 739         if (!isset($config->table)) {
 740             $config->table = '';
 741         }
 742         if (!isset($config->fielduser)) {
 743             $config->fielduser = '';
 744         }
 745         if (!isset($config->fieldpass)) {
 746             $config->fieldpass = '';
 747         }
 748         if (!isset($config->passtype)) {
 749             $config->passtype = 'plaintext';
 750         }
 751         if (!isset($config->extencoding)) {
 752             $config->extencoding = 'utf-8';
 753         }
 754         if (!isset($config->setupsql)) {
 755             $config->setupsql = '';
 756         }
 757         if (!isset($config->debugauthdb)) {
 758             $config->debugauthdb = 0;
 759         }
 760         if (!isset($config->removeuser)) {
 761             $config->removeuser = AUTH_REMOVEUSER_KEEP;
 762         }
 763         if (!isset($config->changepasswordurl)) {
 764             $config->changepasswordurl = '';
 765         }
 766
 767         // Save settings.
 768         set_config('host',          $config->host,          'auth/db');
 769         set_config('type',          $config->type,          'auth/db');
 770         set_config('sybasequoting', $config->sybasequoting, 'auth/db');
 771         set_config('name',          $config->name,          'auth/db');
 772         set_config('user',          $config->user,          'auth/db');
 773         set_config('pass',          $config->pass,          'auth/db');
 774         set_config('table',         $config->table,         'auth/db');
 775         set_config('fielduser',     $config->fielduser,     'auth/db');
 776         set_config('fieldpass',     $config->fieldpass,     'auth/db');
 777         set_config('passtype',      $config->passtype,      'auth/db');
 778         set_config('extencoding',   trim($config->extencoding), 'auth/db');
 779         set_config('setupsql',      trim($config->setupsql),'auth/db');
 780         set_config('debugauthdb',   $config->debugauthdb,   'auth/db');
 781         set_config('removeuser',    $config->removeuser,    'auth/db');
 782         set_config('changepasswordurl', trim($config->changepasswordurl), 'auth/db');
 783
 784         return true;
 785     }
 786
 787     /**
 788      * Add slashes, we can not use placeholders or system functions.
 789      *
 790      * @param string $text
 791      * @return string
 792      */
 793     function ext_addslashes($text) {
 794         if (empty($this->config->sybasequoting)) {
 795             $text = str_replace('\\', '\\\\', $text);
 796             $text = str_replace(array('\'', '"', "\0"), array('\\\'', '\\"', '\\0'), $text);
 797         } else {
 798             $text = str_replace("'", "''", $text);
 799         }
 800         return $text;
 801     }
 802
 803     /**
 804      * Test if settings are ok, print info to output.
 805      * @private
 806      */
 807     public function test_settings() {
 808         global $CFG, $OUTPUT;
 809
 810         // NOTE: this is not localised intentionally, admins are supposed to understand English at least a bit...
 811
 812         raise_memory_limit(MEMORY_HUGE);
 813
 814         if (empty($this->config->table)) {
 815             echo $OUTPUT->notification('External table not specified.', 'notifyproblem');
 816             return;
 817         }
 818
 819         if (empty($this->config->fielduser)) {
 820             echo $OUTPUT->notification('External user field not specified.', 'notifyproblem');
 821             return;
 822         }
 823
 824         $olddebug = $CFG->debug;
 825         $olddisplay = ini_get('display_errors');
 826         ini_set('display_errors', '1');
 827         $CFG->debug = DEBUG_DEVELOPER;
 828         $olddebugauthdb = $this->config->debugauthdb;
 829         $this->config->debugauthdb = 1;
 830         error_reporting($CFG->debug);
 831
 832         $adodb = $this->db_init();
 833
 834         if (!$adodb or !$adodb->IsConnected()) {
 835             $this->config->debugauthdb = $olddebugauthdb;
 836             $CFG->debug = $olddebug;
 837             ini_set('display_errors', $olddisplay);
 838             error_reporting($CFG->debug);
 839             ob_end_flush();
 840
 841             echo $OUTPUT->notification('Cannot connect the database.', 'notifyproblem');
 842             return;
 843         }
 844
 845         $rs = $adodb->Execute("SELECT *
 846                                  FROM {$this->config->table}
 847                                 WHERE {$this->config->fielduser} <> 'random_unlikely_username'"); // Any unlikely name is ok here.
 848
 849         if (!$rs) {
 850             echo $OUTPUT->notification('Can not read external table.', 'notifyproblem');
 851
 852         } else if ($rs->EOF) {
 853             echo $OUTPUT->notification('External table is empty.', 'notifyproblem');
 854             $rs->close();
 855
 856         } else {
 857             $fields_obj = $rs->FetchObj();
 858             $columns = array_keys((array)$fields_obj);
 859
 860             echo $OUTPUT->notification('External table contains following columns:<br />'.implode(', ', $columns), 'notifysuccess');
 861             $rs->close();
 862         }
 863
 864         $adodb->Close();
 865
 866         $this->config->debugauthdb = $olddebugauthdb;
 867         $CFG->debug = $olddebug;
 868         ini_set('display_errors', $olddisplay);
 869         error_reporting($CFG->debug);
 870         ob_end_flush();
 871     }
 872 }
 873
 874