auth/db/auth.php

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