You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
788 lines
29 KiB
788 lines
29 KiB
2 years ago
|
<?php
|
||
|
|
// This file is part of Moodle - http://moodle.org/
|
||
|
|
//
|
||
|
|
// Moodle is free software: you can redistribute it and/or modify
|
||
|
|
// it under the terms of the GNU General Public License as published by
|
||
|
|
// the Free Software Foundation, either version 3 of the License, or
|
||
|
|
// (at your option) any later version.
|
||
|
|
//
|
||
|
|
// Moodle is distributed in the hope that it will be useful,
|
||
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
|
|
// GNU General Public License for more details.
|
||
|
|
//
|
||
|
|
// You should have received a copy of the GNU General Public License
|
||
|
|
// along with Moodle. If not, see <http://www.gnu.org/licenses/>.
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Authentication Plugin: External Database Authentication
|
||
|
|
*
|
||
|
|
* Checks against an external database.
|
||
|
|
*
|
||
|
|
* @package auth_db
|
||
|
|
* @author Martin Dougiamas
|
||
|
|
* @license http://www.gnu.org/copyleft/gpl.html GNU Public License
|
||
|
|
*/
|
||
|
|
|
||
|
|
defined('MOODLE_INTERNAL') || die();
|
||
|
|
|
||
|
|
require_once($CFG->libdir.'/authlib.php');
|
||
|
|
|
||
|
|
/**
|
||
|
|
* External database authentication plugin.
|
||
|
|
*/
|
||
|
|
class auth_plugin_db extends auth_plugin_base {
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Constructor.
|
||
|
|
*/
|
||
|
|
function __construct() {
|
||
|
|
global $CFG;
|
||
|
|
require_once($CFG->libdir.'/adodb/adodb.inc.php');
|
||
|
|
|
||
|
|
$this->authtype = 'db';
|
||
|
|
$this->config = get_config('auth_db');
|
||
|
|
$this->errorlogtag = '[AUTH DB] ';
|
||
|
|
if (empty($this->config->extencoding)) {
|
||
|
|
$this->config->extencoding = 'utf-8';
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Returns true if the username and password work and false if they are
|
||
|
|
* wrong or don't exist.
|
||
|
|
*
|
||
|
|
* @param string $username The username
|
||
|
|
* @param string $password The password
|
||
|
|
* @return bool Authentication success or failure.
|
||
|
|
*/
|
||
|
|
function user_login($username, $password) {
|
||
|
|
global $CFG, $DB;
|
||
|
|
|
||
|
|
if ($this->is_configured() === false) {
|
||
|
|
debugging(get_string('auth_notconfigured', 'auth', $this->authtype));
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
$extusername = core_text::convert($username, 'utf-8', $this->config->extencoding);
|
||
|
|
$extpassword = core_text::convert($password, 'utf-8', $this->config->extencoding);
|
||
|
|
|
||
|
|
if ($this->is_internal()) {
|
||
|
|
// Lookup username externally, but resolve
|
||
|
|
// password locally -- to support backend that
|
||
|
|
// don't track passwords.
|
||
|
|
|
||
|
|
if (isset($this->config->removeuser) and $this->config->removeuser == AUTH_REMOVEUSER_KEEP) {
|
||
|
|
// No need to connect to external database in this case because users are never removed and we verify password locally.
|
||
|
|
if ($user = $DB->get_record('user', array('username'=>$username, 'mnethostid'=>$CFG->mnet_localhost_id, 'auth'=>$this->authtype))) {
|
||
|
|
return validate_internal_user_password($user, $password);
|
||
|
|
} else {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
$authdb = $this->db_init();
|
||
|
|
|
||
|
|
$rs = $authdb->Execute("SELECT *
|
||
|
|
FROM {$this->config->table}
|
||
|
|
WHERE {$this->config->fielduser} = '".$this->ext_addslashes($extusername)."'");
|
||
|
|
if (!$rs) {
|
||
|
|
$authdb->Close();
|
||
|
|
debugging(get_string('auth_dbcantconnect','auth_db'));
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!$rs->EOF) {
|
||
|
|
$rs->Close();
|
||
|
|
$authdb->Close();
|
||
|
|
// User exists externally - check username/password internally.
|
||
|
|
if ($user = $DB->get_record('user', array('username'=>$username, 'mnethostid'=>$CFG->mnet_localhost_id, 'auth'=>$this->authtype))) {
|
||
|
|
return validate_internal_user_password($user, $password);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
$rs->Close();
|
||
|
|
$authdb->Close();
|
||
|
|
// User does not exist externally.
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
} else {
|
||
|
|
// Normal case: use external db for both usernames and passwords.
|
||
|
|
|
||
|
|
$authdb = $this->db_init();
|
||
|
|
|
||
|
|
$rs = $authdb->Execute("SELECT {$this->config->fieldpass}
|
||
|
|
FROM {$this->config->table}
|
||
|
|
WHERE {$this->config->fielduser} = '".$this->ext_addslashes($extusername)."'");
|
||
|
|
if (!$rs) {
|
||
|
|
$authdb->Close();
|
||
|
|
debugging(get_string('auth_dbcantconnect','auth_db'));
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
if ($rs->EOF) {
|
||
|
|
$authdb->Close();
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
$fields = array_change_key_case($rs->fields, CASE_LOWER);
|
||
|
|
$fromdb = $fields[strtolower($this->config->fieldpass)];
|
||
|
|
$rs->Close();
|
||
|
|
$authdb->Close();
|
||
|
|
|
||
|
|
if ($this->config->passtype === 'plaintext') {
|
||
|
|
return ($fromdb == $extpassword);
|
||
|
|
} else if ($this->config->passtype === 'md5') {
|
||
|
|
return (strtolower($fromdb) == md5($extpassword));
|
||
|
|
} else if ($this->config->passtype === 'sha1') {
|
||
|
|
return (strtolower($fromdb) == sha1($extpassword));
|
||
|
|
} else if ($this->config->passtype === 'saltedcrypt') {
|
||
|
|
return password_verify($extpassword, $fromdb);
|
||
|
|
} else {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Connect to external database.
|
||
|
|
*
|
||
|
|
* @return ADOConnection
|
||
|
|
* @throws moodle_exception
|
||
|
|
*/
|
||
|
|
function db_init() {
|
||
|
|
if ($this->is_configured() === false) {
|
||
|
|
throw new moodle_exception('auth_dbcantconnect', 'auth_db');
|
||
|
|
}
|
||
|
|
|
||
|
|
// Connect to the external database (forcing new connection).
|
||
|
|
$authdb = ADONewConnection($this->config->type);
|
||
|
|
if (!empty($this->config->debugauthdb)) {
|
||
|
|
$authdb->debug = true;
|
||
|
|
ob_start(); //Start output buffer to allow later use of the page headers.
|
||
|
|
}
|
||
|
|
$authdb->Connect($this->config->host, $this->config->user, $this->config->pass, $this->config->name, true);
|
||
|
|
$authdb->SetFetchMode(ADODB_FETCH_ASSOC);
|
||
|
|
if (!empty($this->config->setupsql)) {
|
||
|
|
$authdb->Execute($this->config->setupsql);
|
||
|
|
}
|
||
|
|
|
||
|
|
return $authdb;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Returns user attribute mappings between moodle and the external database.
|
||
|
|
*
|
||
|
|
* @return array
|
||
|
|
*/
|
||
|
|
function db_attributes() {
|
||
|
|
$moodleattributes = array();
|
||
|
|
// If we have custom fields then merge them with user fields.
|
||
|
|
$customfields = $this->get_custom_user_profile_fields();
|
||
|
|
if (!empty($customfields) && !empty($this->userfields)) {
|
||
|
|
$userfields = array_merge($this->userfields, $customfields);
|
||
|
|
} else {
|
||
|
|
$userfields = $this->userfields;
|
||
|
|
}
|
||
|
|
|
||
|
|
foreach ($userfields as $field) {
|
||
|
|
if (!empty($this->config->{"field_map_$field"})) {
|
||
|
|
$moodleattributes[$field] = $this->config->{"field_map_$field"};
|
||
|
|
}
|
||
|
|
}
|
||
|
|
$moodleattributes['username'] = $this->config->fielduser;
|
||
|
|
return $moodleattributes;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Reads any other information for a user from external database,
|
||
|
|
* then returns it in an array.
|
||
|
|
*
|
||
|
|
* @param string $username
|
||
|
|
* @return array
|
||
|
|
*/
|
||
|
|
function get_userinfo($username) {
|
||
|
|
global $CFG;
|
||
|
|
|
||
|
|
$extusername = core_text::convert($username, 'utf-8', $this->config->extencoding);
|
||
|
|
|
||
|
|
$authdb = $this->db_init();
|
||
|
|
|
||
|
|
// Array to map local fieldnames we want, to external fieldnames.
|
||
|
|
$selectfields = $this->db_attributes();
|
||
|
|
|
||
|
|
$result = array();
|
||
|
|
// If at least one field is mapped from external db, get that mapped data.
|
||
|
|
if ($selectfields) {
|
||
|
|
$select = array();
|
||
|
|
$fieldcount = 0;
|
||
|
|
foreach ($selectfields as $localname=>$externalname) {
|
||
|
|
// Without aliasing, multiple occurrences of the same external
|
||
|
|
// name can coalesce in only occurrence in the result.
|
||
|
|
$select[] = "$externalname AS F".$fieldcount;
|
||
|
|
$fieldcount++;
|
||
|
|
}
|
||
|
|
$select = implode(', ', $select);
|
||
|
|
$sql = "SELECT $select
|
||
|
|
FROM {$this->config->table}
|
||
|
|
WHERE {$this->config->fielduser} = '".$this->ext_addslashes($extusername)."'";
|
||
|
|
|
||
|
|
if ($rs = $authdb->Execute($sql)) {
|
||
|
|
if (!$rs->EOF) {
|
||
|
|
$fields = $rs->FetchRow();
|
||
|
|
// Convert the associative array to an array of its values so we don't have to worry about the case of its keys.
|
||
|
|
$fields = array_values($fields);
|
||
|
|
foreach (array_keys($selectfields) as $index => $localname) {
|
||
|
|
$value = $fields[$index];
|
||
|
|
$result[$localname] = core_text::convert($value, $this->config->extencoding, 'utf-8');
|
||
|
|
}
|
||
|
|
}
|
||
|
|
$rs->Close();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
$authdb->Close();
|
||
|
|
return $result;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Change a user's password.
|
||
|
|
*
|
||
|
|
* @param stdClass $user User table object
|
||
|
|
* @param string $newpassword Plaintext password
|
||
|
|
* @return bool True on success
|
||
|
|
*/
|
||
|
|
function user_update_password($user, $newpassword) {
|
||
|
|
global $DB;
|
||
|
|
|
||
|
|
if ($this->is_internal()) {
|
||
|
|
$puser = $DB->get_record('user', array('id'=>$user->id), '*', MUST_EXIST);
|
||
|
|
// This will also update the stored hash to the latest algorithm
|
||
|
|
// if the existing hash is using an out-of-date algorithm (or the
|
||
|
|
// legacy md5 algorithm).
|
||
|
|
if (update_internal_user_password($puser, $newpassword)) {
|
||
|
|
$user->password = $puser->password;
|
||
|
|
return true;
|
||
|
|
} else {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
// We should have never been called!
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Synchronizes user from external db to moodle user table.
|
||
|
|
*
|
||
|
|
* Sync should be done by using idnumber attribute, not username.
|
||
|
|
* You need to pass firstsync parameter to function to fill in
|
||
|
|
* idnumbers if they don't exists in moodle user table.
|
||
|
|
*
|
||
|
|
* Syncing users removes (disables) users that don't exists anymore in external db.
|
||
|
|
* Creates new users and updates coursecreator status of users.
|
||
|
|
*
|
||
|
|
* This implementation is simpler but less scalable than the one found in the LDAP module.
|
||
|
|
*
|
||
|
|
* @param progress_trace $trace
|
||
|
|
* @param bool $do_updates Optional: set to true to force an update of existing accounts
|
||
|
|
* @return int 0 means success, 1 means failure
|
||
|
|
*/
|
||
|
|
function sync_users(progress_trace $trace, $do_updates=false) {
|
||
|
|
global $CFG, $DB;
|
||
|
|
|
||
|
|
require_once($CFG->dirroot . '/user/lib.php');
|
||
|
|
|
||
|
|
// List external users.
|
||
|
|
$userlist = $this->get_userlist();
|
||
|
|
|
||
|
|
// Delete obsolete internal users.
|
||
|
|
if (!empty($this->config->removeuser)) {
|
||
|
|
|
||
|
|
$suspendselect = "";
|
||
|
|
if ($this->config->removeuser == AUTH_REMOVEUSER_SUSPEND) {
|
||
|
|
$suspendselect = "AND u.suspended = 0";
|
||
|
|
}
|
||
|
|
|
||
|
|
// Find obsolete users.
|
||
|
|
if (count($userlist)) {
|
||
|
|
$removeusers = array();
|
||
|
|
$params['authtype'] = $this->authtype;
|
||
|
|
$sql = "SELECT u.id, u.username
|
||
|
|
FROM {user} u
|
||
|
|
WHERE u.auth=:authtype
|
||
|
|
AND u.deleted=0
|
||
|
|
AND u.mnethostid=:mnethostid
|
||
|
|
$suspendselect";
|
||
|
|
$params['mnethostid'] = $CFG->mnet_localhost_id;
|
||
|
|
$internalusersrs = $DB->get_recordset_sql($sql, $params);
|
||
|
|
|
||
|
|
$usernamelist = array_flip($userlist);
|
||
|
|
foreach ($internalusersrs as $internaluser) {
|
||
|
|
if (!array_key_exists($internaluser->username, $usernamelist)) {
|
||
|
|
$removeusers[] = $internaluser;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
$internalusersrs->close();
|
||
|
|
} else {
|
||
|
|
$sql = "SELECT u.id, u.username
|
||
|
|
FROM {user} u
|
||
|
|
WHERE u.auth=:authtype AND u.deleted=0 AND u.mnethostid=:mnethostid $suspendselect";
|
||
|
|
$params = array();
|
||
|
|
$params['authtype'] = $this->authtype;
|
||
|
|
$params['mnethostid'] = $CFG->mnet_localhost_id;
|
||
|
|
$removeusers = $DB->get_records_sql($sql, $params);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!empty($removeusers)) {
|
||
|
|
$trace->output(get_string('auth_dbuserstoremove', 'auth_db', count($removeusers)));
|
||
|
|
|
||
|
|
foreach ($removeusers as $user) {
|
||
|
|
if ($this->config->removeuser == AUTH_REMOVEUSER_FULLDELETE) {
|
||
|
|
delete_user($user);
|
||
|
|
$trace->output(get_string('auth_dbdeleteuser', 'auth_db', array('name'=>$user->username, 'id'=>$user->id)), 1);
|
||
|
|
} else if ($this->config->removeuser == AUTH_REMOVEUSER_SUSPEND) {
|
||
|
|
$updateuser = new stdClass();
|
||
|
|
$updateuser->id = $user->id;
|
||
|
|
$updateuser->suspended = 1;
|
||
|
|
user_update_user($updateuser, false);
|
||
|
|
$trace->output(get_string('auth_dbsuspenduser', 'auth_db', array('name'=>$user->username, 'id'=>$user->id)), 1);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
unset($removeusers);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!count($userlist)) {
|
||
|
|
// Exit right here, nothing else to do.
|
||
|
|
$trace->finished();
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Update existing accounts.
|
||
|
|
if ($do_updates) {
|
||
|
|
// Narrow down what fields we need to update.
|
||
|
|
$all_keys = array_keys(get_object_vars($this->config));
|
||
|
|
$updatekeys = array();
|
||
|
|
foreach ($all_keys as $key) {
|
||
|
|
if (preg_match('/^field_updatelocal_(.+)$/',$key, $match)) {
|
||
|
|
if ($this->config->{$key} === 'onlogin') {
|
||
|
|
array_push($updatekeys, $match[1]); // The actual key name.
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
unset($all_keys); unset($key);
|
||
|
|
|
||
|
|
// Only go ahead if we actually have fields to update locally.
|
||
|
|
if (!empty($updatekeys)) {
|
||
|
|
$update_users = array();
|
||
|
|
// All the drivers can cope with chunks of 10,000. See line 4491 of lib/dml/tests/dml_est.php
|
||
|
|
$userlistchunks = array_chunk($userlist , 10000);
|
||
|
|
foreach($userlistchunks as $userlistchunk) {
|
||
|
|
list($in_sql, $params) = $DB->get_in_or_equal($userlistchunk, SQL_PARAMS_NAMED, 'u', true);
|
||
|
|
$params['authtype'] = $this->authtype;
|
||
|
|
$params['mnethostid'] = $CFG->mnet_localhost_id;
|
||
|
|
$sql = "SELECT u.id, u.username, u.suspended
|
||
|
|
FROM {user} u
|
||
|
|
WHERE u.auth = :authtype AND u.deleted = 0 AND u.mnethostid = :mnethostid AND u.username {$in_sql}";
|
||
|
|
$update_users = $update_users + $DB->get_records_sql($sql, $params);
|
||
|
|
}
|
||
|
|
|
||
|
|
if ($update_users) {
|
||
|
|
$trace->output("User entries to update: ".count($update_users));
|
||
|
|
|
||
|
|
foreach ($update_users as $user) {
|
||
|
|
if ($this->update_user_record($user->username, $updatekeys, false, (bool) $user->suspended)) {
|
||
|
|
$trace->output(get_string('auth_dbupdatinguser', 'auth_db', array('name'=>$user->username, 'id'=>$user->id)), 1);
|
||
|
|
} else {
|
||
|
|
$trace->output(get_string('auth_dbupdatinguser', 'auth_db', array('name'=>$user->username, 'id'=>$user->id))." - ".get_string('skipped'), 1);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
unset($update_users);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// Create missing accounts.
|
||
|
|
// NOTE: this is very memory intensive and generally inefficient.
|
||
|
|
$suspendselect = "";
|
||
|
|
if ($this->config->removeuser == AUTH_REMOVEUSER_SUSPEND) {
|
||
|
|
$suspendselect = "AND u.suspended = 0";
|
||
|
|
}
|
||
|
|
$sql = "SELECT u.id, u.username
|
||
|
|
FROM {user} u
|
||
|
|
WHERE u.auth=:authtype AND u.deleted='0' AND mnethostid=:mnethostid $suspendselect";
|
||
|
|
|
||
|
|
$users = $DB->get_records_sql($sql, array('authtype'=>$this->authtype, 'mnethostid'=>$CFG->mnet_localhost_id));
|
||
|
|
|
||
|
|
// Simplify down to usernames.
|
||
|
|
$usernames = array();
|
||
|
|
if (!empty($users)) {
|
||
|
|
foreach ($users as $user) {
|
||
|
|
array_push($usernames, $user->username);
|
||
|
|
}
|
||
|
|
unset($users);
|
||
|
|
}
|
||
|
|
|
||
|
|
$add_users = array_diff($userlist, $usernames);
|
||
|
|
unset($usernames);
|
||
|
|
|
||
|
|
if (!empty($add_users)) {
|
||
|
|
$trace->output(get_string('auth_dbuserstoadd','auth_db',count($add_users)));
|
||
|
|
// Do not use transactions around this foreach, we want to skip problematic users, not revert everything.
|
||
|
|
foreach($add_users as $user) {
|
||
|
|
$username = $user;
|
||
|
|
if ($this->config->removeuser == AUTH_REMOVEUSER_SUSPEND) {
|
||
|
|
if ($olduser = $DB->get_record('user', array('username' => $username, 'deleted' => 0, 'suspended' => 1,
|
||
|
|
'mnethostid' => $CFG->mnet_localhost_id, 'auth' => $this->authtype))) {
|
||
|
|
$updateuser = new stdClass();
|
||
|
|
$updateuser->id = $olduser->id;
|
||
|
|
$updateuser->suspended = 0;
|
||
|
|
user_update_user($updateuser);
|
||
|
|
$trace->output(get_string('auth_dbreviveduser', 'auth_db', array('name' => $username,
|
||
|
|
'id' => $olduser->id)), 1);
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Do not try to undelete users here, instead select suspending if you ever expect users will reappear.
|
||
|
|
|
||
|
|
// Prep a few params.
|
||
|
|
$user = $this->get_userinfo_asobj($user);
|
||
|
|
$user->username = $username;
|
||
|
|
$user->confirmed = 1;
|
||
|
|
$user->auth = $this->authtype;
|
||
|
|
$user->mnethostid = $CFG->mnet_localhost_id;
|
||
|
|
if (empty($user->lang)) {
|
||
|
|
$user->lang = $CFG->lang;
|
||
|
|
}
|
||
|
|
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')) {
|
||
|
|
$trace->output(get_string('auth_dbinsertuserduplicate', 'auth_db', array('username'=>$user->username, 'auth'=>$collision->auth)), 1);
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
try {
|
||
|
|
$id = user_create_user($user, false); // It is truly a new user.
|
||
|
|
$trace->output(get_string('auth_dbinsertuser', 'auth_db', array('name'=>$user->username, 'id'=>$id)), 1);
|
||
|
|
} catch (moodle_exception $e) {
|
||
|
|
$trace->output(get_string('auth_dbinsertusererror', 'auth_db', $user->username), 1);
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
// If relevant, tag for password generation.
|
||
|
|
if ($this->is_internal()) {
|
||
|
|
set_user_preference('auth_forcepasswordchange', 1, $id);
|
||
|
|
set_user_preference('create_password', 1, $id);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Save custom profile fields here.
|
||
|
|
require_once($CFG->dirroot . '/user/profile/lib.php');
|
||
|
|
$user->id = $id;
|
||
|
|
profile_save_data($user);
|
||
|
|
|
||
|
|
// Make sure user context is present.
|
||
|
|
context_user::instance($id);
|
||
|
|
}
|
||
|
|
unset($add_users);
|
||
|
|
}
|
||
|
|
$trace->finished();
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
function user_exists($username) {
|
||
|
|
|
||
|
|
// Init result value.
|
||
|
|
$result = false;
|
||
|
|
|
||
|
|
$extusername = core_text::convert($username, 'utf-8', $this->config->extencoding);
|
||
|
|
|
||
|
|
$authdb = $this->db_init();
|
||
|
|
|
||
|
|
$rs = $authdb->Execute("SELECT *
|
||
|
|
FROM {$this->config->table}
|
||
|
|
WHERE {$this->config->fielduser} = '".$this->ext_addslashes($extusername)."' ");
|
||
|
|
|
||
|
|
if (!$rs) {
|
||
|
|
print_error('auth_dbcantconnect','auth_db');
|
||
|
|
} else if (!$rs->EOF) {
|
||
|
|
// User exists externally.
|
||
|
|
$result = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
$authdb->Close();
|
||
|
|
return $result;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
function get_userlist() {
|
||
|
|
|
||
|
|
// Init result value.
|
||
|
|
$result = array();
|
||
|
|
|
||
|
|
$authdb = $this->db_init();
|
||
|
|
|
||
|
|
// Fetch userlist.
|
||
|
|
$rs = $authdb->Execute("SELECT {$this->config->fielduser}
|
||
|
|
FROM {$this->config->table} ");
|
||
|
|
|
||
|
|
if (!$rs) {
|
||
|
|
print_error('auth_dbcantconnect','auth_db');
|
||
|
|
} else if (!$rs->EOF) {
|
||
|
|
while ($rec = $rs->FetchRow()) {
|
||
|
|
$rec = array_change_key_case((array)$rec, CASE_LOWER);
|
||
|
|
array_push($result, $rec[strtolower($this->config->fielduser)]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
$authdb->Close();
|
||
|
|
return $result;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Reads user information from DB and return it in an object.
|
||
|
|
*
|
||
|
|
* @param string $username username
|
||
|
|
* @return array
|
||
|
|
*/
|
||
|
|
function get_userinfo_asobj($username) {
|
||
|
|
$user_array = truncate_userinfo($this->get_userinfo($username));
|
||
|
|
$user = new stdClass();
|
||
|
|
foreach($user_array as $key=>$value) {
|
||
|
|
$user->{$key} = $value;
|
||
|
|
}
|
||
|
|
return $user;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Called when the user record is updated.
|
||
|
|
* Modifies user in external database. It takes olduser (before changes) and newuser (after changes)
|
||
|
|
* compares information saved modified information to external db.
|
||
|
|
*
|
||
|
|
* @param stdClass $olduser Userobject before modifications
|
||
|
|
* @param stdClass $newuser Userobject new modified userobject
|
||
|
|
* @return boolean result
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
function user_update($olduser, $newuser) {
|
||
|
|
if (isset($olduser->username) and isset($newuser->username) and $olduser->username != $newuser->username) {
|
||
|
|
error_log("ERROR:User renaming not allowed in ext db");
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (isset($olduser->auth) and $olduser->auth != $this->authtype) {
|
||
|
|
return true; // Just change auth and skip update.
|
||
|
|
}
|
||
|
|
|
||
|
|
$curruser = $this->get_userinfo($olduser->username);
|
||
|
|
if (empty($curruser)) {
|
||
|
|
error_log("ERROR:User $olduser->username found in ext db");
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
$extusername = core_text::convert($olduser->username, 'utf-8', $this->config->extencoding);
|
||
|
|
|
||
|
|
$authdb = $this->db_init();
|
||
|
|
|
||
|
|
$update = array();
|
||
|
|
foreach($curruser as $key=>$value) {
|
||
|
|
if ($key == 'username') {
|
||
|
|
continue; // Skip this.
|
||
|
|
}
|
||
|
|
if (empty($this->config->{"field_updateremote_$key"})) {
|
||
|
|
continue; // Remote update not requested.
|
||
|
|
}
|
||
|
|
if (!isset($newuser->$key)) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
$nuvalue = $newuser->$key;
|
||
|
|
// Support for textarea fields.
|
||
|
|
if (isset($nuvalue['text'])) {
|
||
|
|
$nuvalue = $nuvalue['text'];
|
||
|
|
}
|
||
|
|
if ($nuvalue != $value) {
|
||
|
|
$update[] = $this->config->{"field_map_$key"}."='".$this->ext_addslashes(core_text::convert($nuvalue, 'utf-8', $this->config->extencoding))."'";
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (!empty($update)) {
|
||
|
|
$authdb->Execute("UPDATE {$this->config->table}
|
||
|
|
SET ".implode(',', $update)."
|
||
|
|
WHERE {$this->config->fielduser}='".$this->ext_addslashes($extusername)."'");
|
||
|
|
}
|
||
|
|
$authdb->Close();
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
function prevent_local_passwords() {
|
||
|
|
return !$this->is_internal();
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Returns true if this authentication plugin is "internal".
|
||
|
|
*
|
||
|
|
* Internal plugins use password hashes from Moodle user table for authentication.
|
||
|
|
*
|
||
|
|
* @return bool
|
||
|
|
*/
|
||
|
|
function is_internal() {
|
||
|
|
if (!isset($this->config->passtype)) {
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
return ($this->config->passtype === 'internal');
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Returns false if this plugin is enabled but not configured.
|
||
|
|
*
|
||
|
|
* @return bool
|
||
|
|
*/
|
||
|
|
public function is_configured() {
|
||
|
|
if (!empty($this->config->type)) {
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Indicates if moodle should automatically update internal user
|
||
|
|
* records with data from external sources using the information
|
||
|
|
* from auth_plugin_base::get_userinfo().
|
||
|
|
*
|
||
|
|
* @return bool true means automatically copy data from ext to user table
|
||
|
|
*/
|
||
|
|
function is_synchronised_with_external() {
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Returns true if this authentication plugin can change the user's
|
||
|
|
* password.
|
||
|
|
*
|
||
|
|
* @return bool
|
||
|
|
*/
|
||
|
|
function can_change_password() {
|
||
|
|
return ($this->is_internal() or !empty($this->config->changepasswordurl));
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Returns the URL for changing the user's pw, or empty if the default can
|
||
|
|
* be used.
|
||
|
|
*
|
||
|
|
* @return moodle_url
|
||
|
|
*/
|
||
|
|
function change_password_url() {
|
||
|
|
if ($this->is_internal() || empty($this->config->changepasswordurl)) {
|
||
|
|
// Standard form.
|
||
|
|
return null;
|
||
|
|
} else {
|
||
|
|
// Use admin defined custom url.
|
||
|
|
return new moodle_url($this->config->changepasswordurl);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Returns true if plugin allows resetting of internal password.
|
||
|
|
*
|
||
|
|
* @return bool
|
||
|
|
*/
|
||
|
|
function can_reset_password() {
|
||
|
|
return $this->is_internal();
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Add slashes, we can not use placeholders or system functions.
|
||
|
|
*
|
||
|
|
* @param string $text
|
||
|
|
* @return string
|
||
|
|
*/
|
||
|
|
function ext_addslashes($text) {
|
||
|
|
if (empty($this->config->sybasequoting)) {
|
||
|
|
$text = str_replace('\\', '\\\\', $text);
|
||
|
|
$text = str_replace(array('\'', '"', "\0"), array('\\\'', '\\"', '\\0'), $text);
|
||
|
|
} else {
|
||
|
|
$text = str_replace("'", "''", $text);
|
||
|
|
}
|
||
|
|
return $text;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Test if settings are ok, print info to output.
|
||
|
|
* @private
|
||
|
|
*/
|
||
|
|
public function test_settings() {
|
||
|
|
global $CFG, $OUTPUT;
|
||
|
|
|
||
|
|
// NOTE: this is not localised intentionally, admins are supposed to understand English at least a bit...
|
||
|
|
|
||
|
|
raise_memory_limit(MEMORY_HUGE);
|
||
|
|
|
||
|
|
if (empty($this->config->table)) {
|
||
|
|
echo $OUTPUT->notification(get_string('auth_dbnoexttable', 'auth_db'), 'notifyproblem');
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (empty($this->config->fielduser)) {
|
||
|
|
echo $OUTPUT->notification(get_string('auth_dbnouserfield', 'auth_db'), 'notifyproblem');
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
$olddebug = $CFG->debug;
|
||
|
|
$olddisplay = ini_get('display_errors');
|
||
|
|
ini_set('display_errors', '1');
|
||
|
|
$CFG->debug = DEBUG_DEVELOPER;
|
||
|
|
$olddebugauthdb = $this->config->debugauthdb;
|
||
|
|
$this->config->debugauthdb = 1;
|
||
|
|
error_reporting($CFG->debug);
|
||
|
|
|
||
|
|
$adodb = $this->db_init();
|
||
|
|
|
||
|
|
if (!$adodb or !$adodb->IsConnected()) {
|
||
|
|
$this->config->debugauthdb = $olddebugauthdb;
|
||
|
|
$CFG->debug = $olddebug;
|
||
|
|
ini_set('display_errors', $olddisplay);
|
||
|
|
error_reporting($CFG->debug);
|
||
|
|
ob_end_flush();
|
||
|
|
|
||
|
|
echo $OUTPUT->notification(get_string('auth_dbcannotconnect', 'auth_db'), 'notifyproblem');
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
$rs = $adodb->Execute("SELECT *
|
||
|
|
FROM {$this->config->table}
|
||
|
|
WHERE {$this->config->fielduser} <> 'random_unlikely_username'"); // Any unlikely name is ok here.
|
||
|
|
|
||
|
|
if (!$rs) {
|
||
|
|
echo $OUTPUT->notification(get_string('auth_dbcannotreadtable', 'auth_db'), 'notifyproblem');
|
||
|
|
|
||
|
|
} else if ($rs->EOF) {
|
||
|
|
echo $OUTPUT->notification(get_string('auth_dbtableempty', 'auth_db'), 'notifyproblem');
|
||
|
|
$rs->close();
|
||
|
|
|
||
|
|
} else {
|
||
|
|
$fields_obj = $rs->FetchObj();
|
||
|
|
$columns = array_keys((array)$fields_obj);
|
||
|
|
|
||
|
|
echo $OUTPUT->notification(get_string('auth_dbcolumnlist', 'auth_db', implode(', ', $columns)), 'notifysuccess');
|
||
|
|
$rs->close();
|
||
|
|
}
|
||
|
|
|
||
|
|
$adodb->Close();
|
||
|
|
|
||
|
|
$this->config->debugauthdb = $olddebugauthdb;
|
||
|
|
$CFG->debug = $olddebug;
|
||
|
|
ini_set('display_errors', $olddisplay);
|
||
|
|
error_reporting($CFG->debug);
|
||
|
|
ob_end_flush();
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Clean the user data that comes from an external database.
|
||
|
|
* @deprecated since 3.1, please use core_user::clean_data() instead.
|
||
|
|
* @param array $user the user data to be validated against properties definition.
|
||
|
|
* @return stdClass $user the cleaned user data.
|
||
|
|
*/
|
||
|
|
public function clean_data($user) {
|
||
|
|
debugging('The method clean_data() has been deprecated, please use core_user::clean_data() instead.',
|
||
|
|
DEBUG_DEVELOPER);
|
||
|
|
return core_user::clean_data($user);
|
||
|
|
}
|
||
|
|
}
|