lib/sessionlib.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  * @package    core
  19  * @subpackage session
  20  * @copyright  1999 onwards Martin Dougiamas  {@link http://moodle.com}
  21  * @copyright  2008, 2009 Petr Skoda  {@link http://skodak.org}
  22  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  23  */
  24
  25 defined('MOODLE_INTERNAL') || die();
  26
  27 if (!defined('SESSION_ACQUIRE_LOCK_TIMEOUT')) {
  28     /**
  29      * How much time to wait for session lock before displaying error (in seconds),
  30      * 2 minutes by default should be a reasonable time before telling users to wait and refresh browser.
  31      */
  32     define('SESSION_ACQUIRE_LOCK_TIMEOUT', 60*2);
  33 }
  34
  35 /**
  36   * Factory method returning moodle_session object.
  37   * @return moodle_session
  38   */
  39 function session_get_instance() {
  40     global $CFG, $DB;
  41
  42     static $session = null;
  43
  44     if (is_null($session)) {
  45         if (empty($CFG->sessiontimeout)) {
  46             $CFG->sessiontimeout = 7200;
  47         }
  48
  49         try {
  50             if (defined('SESSION_CUSTOM_CLASS')) {
  51                 // this is a hook for webservices, key based login, etc.
  52                 if (defined('SESSION_CUSTOM_FILE')) {
  53                     require_once($CFG->dirroot.SESSION_CUSTOM_FILE);
  54                 }
  55                 $session_class = SESSION_CUSTOM_CLASS;
  56                 $session = new $session_class();
  57
  58             } else if ((!isset($CFG->dbsessions) or $CFG->dbsessions) and $DB->session_lock_supported()) {
  59                 // default recommended session type
  60                 $session = new database_session();
  61
  62             } else {
  63                 // legacy limited file based storage - some features and auth plugins will not work, sorry
  64                 $session = new legacy_file_session();
  65             }
  66         } catch (Exception $ex) {
  67             // prevent repeated inits
  68             $session = new emergency_session();
  69             throw $ex;
  70         }
  71     }
  72
  73     return $session;
  74 }
  75
  76
  77 /**
  78  * Moodle session abstraction
  79  *
  80  * @package    core
  81  * @subpackage session
  82  * @copyright  2008 Petr Skoda  {@link http://skodak.org}
  83  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  84  */
  85 interface moodle_session {
  86     /**
  87      * Terminate current session
  88      * @return void
  89      */
  90     public function terminate_current();
  91
  92     /**
  93      * No more changes in session expected.
  94      * Unblocks the sessions, other scripts may start executing in parallel.
  95      * @return void
  96      */
  97     public function write_close();
  98
  99     /**
 100      * Check for existing session with id $sid
 101      * @param unknown_type $sid
 102      * @return boolean true if session found.
 103      */
 104     public function session_exists($sid);
 105 }
 106
 107
 108 /**
 109  * Fallback session handler when standard session init fails.
 110  * This prevents repeated attempts to init faulty handler.
 111  *
 112  * @package    core
 113  * @subpackage session
 114  * @copyright  2011 Petr Skoda  {@link http://skodak.org}
 115  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 116  */
 117 class emergency_session implements moodle_session {
 118
 119     public function __construct() {
 120         // session not used at all
 121         $_SESSION = array();
 122         $_SESSION['SESSION'] = new stdClass();
 123         $_SESSION['USER']    = new stdClass();
 124     }
 125
 126     /**
 127      * Terminate current session
 128      * @return void
 129      */
 130     public function terminate_current() {
 131         return;
 132     }
 133
 134     /**
 135      * No more changes in session expected.
 136      * Unblocks the sessions, other scripts may start executing in parallel.
 137      * @return void
 138      */
 139     public function write_close() {
 140         return;
 141     }
 142
 143     /**
 144      * Check for existing session with id $sid
 145      * @param unknown_type $sid
 146      * @return boolean true if session found.
 147      */
 148     public function session_exists($sid) {
 149         return false;
 150     }
 151 }
 152
 153
 154 /**
 155  * Class handling all session and cookies related stuff.
 156  *
 157  * @package    core
 158  * @subpackage session
 159  * @copyright  2009 Petr Skoda  {@link http://skodak.org}
 160  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 161  */
 162 abstract class session_stub implements moodle_session {
 163     protected $justloggedout;
 164
 165     public function __construct() {
 166         global $CFG;
 167
 168         if (NO_MOODLE_COOKIES) {
 169             // session not used at all
 170             $_SESSION = array();
 171             $_SESSION['SESSION'] = new stdClass();
 172             $_SESSION['USER']    = new stdClass();
 173
 174         } else {
 175             $this->prepare_cookies();
 176             $this->init_session_storage();
 177
 178             $newsession = empty($_COOKIE['MoodleSession'.$CFG->sessioncookie]);
 179
 180             ini_set('session.use_trans_sid', '0');
 181
 182             session_name('MoodleSession'.$CFG->sessioncookie);
 183             session_set_cookie_params(0, $CFG->sessioncookiepath, $CFG->sessioncookiedomain, $CFG->cookiesecure, $CFG->cookiehttponly);
 184             session_start();
 185             if (!isset($_SESSION['SESSION'])) {
 186                 $_SESSION['SESSION'] = new stdClass();
 187                 if (!$newsession and !$this->justloggedout) {
 188                     $_SESSION['SESSION']->has_timed_out = true;
 189                 }
 190             }
 191             if (!isset($_SESSION['USER'])) {
 192                 $_SESSION['USER'] = new stdClass();
 193             }
 194         }
 195
 196         $this->check_user_initialised();
 197
 198         $this->check_security();
 199     }
 200
 201     /**
 202      * Terminate current session
 203      * @return void
 204      */
 205     public function terminate_current() {
 206         global $CFG, $SESSION, $USER, $DB;
 207
 208         try {
 209             $DB->delete_records('external_tokens', array('sid'=>session_id(), 'tokentype'=>EXTERNAL_TOKEN_EMBEDDED));
 210         } catch (Exception $ignored) {
 211             // probably install/upgrade - ignore this problem
 212         }
 213
 214         if (NO_MOODLE_COOKIES) {
 215             return;
 216         }
 217
 218         // Initialize variable to pass-by-reference to headers_sent(&$file, &$line)
 219         $_SESSION = array();
 220         $_SESSION['SESSION'] = new stdClass();
 221         $_SESSION['USER']    = new stdClass();
 222         $_SESSION['USER']->id = 0;
 223         if (isset($CFG->mnet_localhost_id)) {
 224             $_SESSION['USER']->mnethostid = $CFG->mnet_localhost_id;
 225         }
 226         $SESSION = $_SESSION['SESSION']; // this may not work properly
 227         $USER    = $_SESSION['USER'];    // this may not work properly
 228
 229         $file = null;
 230         $line = null;
 231         if (headers_sent($file, $line)) {
 232             error_log('Can not terminate session properly - headers were already sent in file: '.$file.' on line '.$line);
 233         }
 234
 235         // now let's try to get a new session id and delete the old one
 236         $this->justloggedout = true;
 237         session_regenerate_id(true);
 238         $this->justloggedout = false;
 239
 240         // write the new session
 241         session_write_close();
 242     }
 243
 244     /**
 245      * No more changes in session expected.
 246      * Unblocks the sessions, other scripts may start executing in parallel.
 247      * @return void
 248      */
 249     public function write_close() {
 250         if (NO_MOODLE_COOKIES) {
 251             return;
 252         }
 253
 254         session_write_close();
 255     }
 256
 257     /**
 258      * Initialise $USER object, handles google access
 259      * and sets up not logged in user properly.
 260      *
 261      * @return void
 262      */
 263     protected function check_user_initialised() {
 264         global $CFG;
 265
 266         if (isset($_SESSION['USER']->id)) {
 267             // already set up $USER
 268             return;
 269         }
 270
 271         $user = null;
 272
 273         if (!empty($CFG->opentogoogle) and !NO_MOODLE_COOKIES) {
 274             if (is_web_crawler()) {
 275                 $user = guest_user();
 276             }
 277             if (!empty($CFG->guestloginbutton) and !$user and !empty($_SERVER['HTTP_REFERER'])) {
 278                 // automaticaly log in users coming from search engine results
 279                 if (strpos($_SERVER['HTTP_REFERER'], 'google') !== false ) {
 280                     $user = guest_user();
 281                 } else if (strpos($_SERVER['HTTP_REFERER'], 'altavista') !== false ) {
 282                     $user = guest_user();
 283                 }
 284             }
 285         }
 286
 287         if (!$user) {
 288             $user = new stdClass();
 289             $user->id = 0; // to enable proper function of $CFG->notloggedinroleid hack
 290             if (isset($CFG->mnet_localhost_id)) {
 291                 $user->mnethostid = $CFG->mnet_localhost_id;
 292             } else {
 293                 $user->mnethostid = 1;
 294             }
 295         }
 296         session_set_user($user);
 297     }
 298
 299     /**
 300      * Does various session security checks
 301      * @global void
 302      */
 303     protected function check_security() {
 304         global $CFG;
 305
 306         if (NO_MOODLE_COOKIES) {
 307             return;
 308         }
 309
 310         if (!empty($_SESSION['USER']->id) and !empty($CFG->tracksessionip)) {
 311             /// Make sure current IP matches the one for this session
 312             $remoteaddr = getremoteaddr();
 313
 314             if (empty($_SESSION['USER']->sessionip)) {
 315                 $_SESSION['USER']->sessionip = $remoteaddr;
 316             }
 317
 318             if ($_SESSION['USER']->sessionip != $remoteaddr) {
 319                 // this is a security feature - terminate the session in case of any doubt
 320                 $this->terminate_current();
 321                 print_error('sessionipnomatch2', 'error');
 322             }
 323         }
 324     }
 325
 326     /**
 327      * Prepare cookies and various system settings
 328      */
 329     protected function prepare_cookies() {
 330         global $CFG;
 331
 332         if (!isset($CFG->cookiesecure) or (strpos($CFG->wwwroot, 'https://') !== 0 and empty($CFG->sslproxy))) {
 333             $CFG->cookiesecure = 0;
 334         }
 335
 336         if (!isset($CFG->cookiehttponly)) {
 337             $CFG->cookiehttponly = 0;
 338         }
 339
 340     /// Set sessioncookie and sessioncookiepath variable if it isn't already
 341         if (!isset($CFG->sessioncookie)) {
 342             $CFG->sessioncookie = '';
 343         }
 344
 345         // make sure cookie domain makes sense for this wwwroot
 346         if (!isset($CFG->sessioncookiedomain)) {
 347             $CFG->sessioncookiedomain = '';
 348         } else if ($CFG->sessioncookiedomain !== '') {
 349             $host = parse_url($CFG->wwwroot, PHP_URL_HOST);
 350             if ($CFG->sessioncookiedomain !== $host) {
 351                 if (substr($CFG->sessioncookiedomain, 0, 1) === '.') {
 352                     if (!preg_match('|^.*'.preg_quote($CFG->sessioncookiedomain, '|').'$|', $host)) {
 353                         // invalid domain - it must be end part of host
 354                         $CFG->sessioncookiedomain = '';
 355                     }
 356                 } else {
 357                     if (!preg_match('|^.*\.'.preg_quote($CFG->sessioncookiedomain, '|').'$|', $host)) {
 358                         // invalid domain - it must be end part of host
 359                         $CFG->sessioncookiedomain = '';
 360                     }
 361                 }
 362             }
 363         }
 364
 365         // make sure the cookiepath is valid for this wwwroot or autodetect if not specified
 366         if (!isset($CFG->sessioncookiepath)) {
 367             $CFG->sessioncookiepath = '';
 368         }
 369         if ($CFG->sessioncookiepath !== '/') {
 370             $path = parse_url($CFG->wwwroot, PHP_URL_PATH).'/';
 371             if ($CFG->sessioncookiepath === '') {
 372                 $CFG->sessioncookiepath = $path;
 373             } else {
 374                 if (strpos($path, $CFG->sessioncookiepath) !== 0 or substr($CFG->sessioncookiepath, -1) !== '/') {
 375                     $CFG->sessioncookiepath = $path;
 376                 }
 377             }
 378         }
 379
 380         //discard session ID from POST, GET and globals to tighten security,
 381         //this is session fixation prevention
 382         unset(${'MoodleSession'.$CFG->sessioncookie});
 383         unset($_GET['MoodleSession'.$CFG->sessioncookie]);
 384         unset($_POST['MoodleSession'.$CFG->sessioncookie]);
 385         unset($_REQUEST['MoodleSession'.$CFG->sessioncookie]);
 386
 387         //compatibility hack for Moodle Cron, cookies not deleted, but set to "deleted" - should not be needed with NO_MOODLE_COOKIES in cron.php now
 388         if (!empty($_COOKIE['MoodleSession'.$CFG->sessioncookie]) && $_COOKIE['MoodleSession'.$CFG->sessioncookie] == "deleted") {
 389             unset($_COOKIE['MoodleSession'.$CFG->sessioncookie]);
 390         }
 391     }
 392
 393     /**
 394      * Init session storage.
 395      */
 396     protected abstract function init_session_storage();
 397 }
 398
 399
 400 /**
 401  * Legacy moodle sessions stored in files, not recommended any more.
 402  *
 403  * @package    core
 404  * @subpackage session
 405  * @copyright  2009 Petr Skoda  {@link http://skodak.org}
 406  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 407  */
 408 class legacy_file_session extends session_stub {
 409     /**
 410      * Init session storage.
 411      */
 412     protected function init_session_storage() {
 413         global $CFG;
 414
 415         ini_set('session.save_handler', 'files');
 416
 417         // Some distros disable GC by setting probability to 0
 418         // overriding the PHP default of 1
 419         // (gc_probability is divided by gc_divisor, which defaults to 1000)
 420         if (ini_get('session.gc_probability') == 0) {
 421             ini_set('session.gc_probability', 1);
 422         }
 423
 424         ini_set('session.gc_maxlifetime', $CFG->sessiontimeout);
 425
 426         // make sure sessions dir exists and is writable, throws exception if not
 427         make_upload_directory('sessions');
 428
 429         // Need to disable debugging since disk_free_space()
 430         // will fail on very large partitions (see MDL-19222)
 431         $freespace = @disk_free_space($CFG->dataroot.'/sessions');
 432         if (!($freespace > 2048) and $freespace !== false) {
 433             print_error('sessiondiskfull', 'error');
 434         }
 435         ini_set('session.save_path', $CFG->dataroot .'/sessions');
 436     }
 437     /**
 438      * Check for existing session with id $sid
 439      * @param unknown_type $sid
 440      * @return boolean true if session found.
 441      */
 442     public function session_exists($sid){
 443         global $CFG;
 444
 445         $sid = clean_param($sid, PARAM_FILE);
 446         $sessionfile = "$CFG->dataroot/sessions/sess_$sid";
 447         return file_exists($sessionfile);
 448     }
 449 }
 450
 451
 452 /**
 453  * Recommended moodle session storage.
 454  *
 455  * @package    core
 456  * @subpackage session
 457  * @copyright  2009 Petr Skoda  {@link http://skodak.org}
 458  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 459  */
 460 class database_session extends session_stub {
 461     /** @var stdClass $record session record */
 462     protected $record   = null;
 463
 464     /** @var moodle_database $database session database */
 465     protected $database = null;
 466
 467     /** @var bool $failed session read/init failed, do not write back to DB */
 468     protected $failed   = false;
 469
 470     public function __construct() {
 471         global $DB;
 472         $this->database = $DB;
 473         parent::__construct();
 474
 475         if (!empty($this->record->state)) {
 476             // something is very wrong
 477             session_kill($this->record->sid);
 478
 479             if ($this->record->state == 9) {
 480                 print_error('dbsessionmysqlpacketsize', 'error');
 481             }
 482         }
 483     }
 484
 485     /**
 486      * Check for existing session with id $sid
 487      * @param unknown_type $sid
 488      * @return boolean true if session found.
 489      */
 490     public function session_exists($sid){
 491         global $CFG;
 492         try {
 493             $sql = "SELECT * FROM {sessions} WHERE timemodified < ? AND sid=? AND state=?";
 494             $params = array(time() + $CFG->sessiontimeout, $sid, 0);
 495
 496             return $this->database->record_exists_sql($sql, $params);
 497         } catch (dml_exception $ex) {
 498             error_log('Error checking existance of database session');
 499             return false;
 500         }
 501     }
 502
 503     /**
 504      * Init session storage.
 505      */
 506     protected function init_session_storage() {
 507         global $CFG;
 508
 509         // gc only from CRON - individual user timeouts now checked during each access
 510         ini_set('session.gc_probability', 0);
 511
 512         ini_set('session.gc_maxlifetime', $CFG->sessiontimeout);
 513
 514         $result = session_set_save_handler(array($this, 'handler_open'),
 515                                            array($this, 'handler_close'),
 516                                            array($this, 'handler_read'),
 517                                            array($this, 'handler_write'),
 518                                            array($this, 'handler_destroy'),
 519                                            array($this, 'handler_gc'));
 520         if (!$result) {
 521             print_error('dbsessionhandlerproblem', 'error');
 522         }
 523     }
 524
 525     /**
 526      * Open session handler
 527      *
 528      * {@see http://php.net/manual/en/function.session-set-save-handler.php}
 529      *
 530      * @param string $save_path
 531      * @param string $session_name
 532      * @return bool success
 533      */
 534     public function handler_open($save_path, $session_name) {
 535         return true;
 536     }
 537
 538     /**
 539      * Close session handler
 540      *
 541      * {@see http://php.net/manual/en/function.session-set-save-handler.php}
 542      *
 543      * @return bool success
 544      */
 545     public function handler_close() {
 546         if (isset($this->record->id)) {
 547             try {
 548                 $this->database->release_session_lock($this->record->id);
 549             } catch (Exception $ex) {
 550                 // ignore any problems
 551             }
 552         }
 553         $this->record = null;
 554         return true;
 555     }
 556
 557     /**
 558      * Read session handler
 559      *
 560      * {@see http://php.net/manual/en/function.session-set-save-handler.php}
 561      *
 562      * @param string $sid
 563      * @return string
 564      */
 565     public function handler_read($sid) {
 566         global $CFG;
 567
 568         if ($this->record and $this->record->sid != $sid) {
 569             error_log('Weird error reading database session - mismatched sid');
 570             $this->failed = true;
 571             return '';
 572         }
 573
 574         try {
 575             if (!$record = $this->database->get_record('sessions', array('sid'=>$sid))) {
 576                 $record = new stdClass();
 577                 $record->state        = 0;
 578                 $record->sid          = $sid;
 579                 $record->sessdata     = null;
 580                 $record->userid       = 0;
 581                 $record->timecreated  = $record->timemodified = time();
 582                 $record->firstip      = $record->lastip = getremoteaddr();
 583                 $record->id           = $this->database->insert_record_raw('sessions', $record);
 584             }
 585         } catch (Exception $ex) {
 586             // do not rethrow exceptions here, we need this to work somehow before 1.9.x upgrade and during install
 587             error_log('Can not read or insert database sessions');
 588             $this->failed = true;
 589             return '';
 590         }
 591
 592         try {
 593             $this->database->get_session_lock($record->id, SESSION_ACQUIRE_LOCK_TIMEOUT);
 594         } catch (Exception $ex) {
 595             // This is a fatal error, better inform users.
 596             // It should not happen very often - all pages that need long time to execute
 597             // should close session soon after access control checks
 598             error_log('Can not obtain session lock');
 599             $this->failed = true;
 600             throw $ex;
 601         }
 602
 603         // verify timeout
 604         if ($record->timemodified + $CFG->sessiontimeout < time()) {
 605             $ignoretimeout = false;
 606             if (!empty($record->userid)) { // skips not logged in
 607                 if ($user = $this->database->get_record('user', array('id'=>$record->userid))) {
 608                     if (!isguestuser($user)) {
 609                         $authsequence = get_enabled_auth_plugins(); // auths, in sequence
 610                         foreach($authsequence as $authname) {
 611                             $authplugin = get_auth_plugin($authname);
 612                             if ($authplugin->ignore_timeout_hook($user, $record->sid, $record->timecreated, $record->timemodified)) {
 613                                 $ignoretimeout = true;
 614                                 break;
 615                             }
 616                         }
 617                     }
 618                 }
 619             }
 620             if ($ignoretimeout) {
 621                 //refresh session
 622                 $record->timemodified = time();
 623                 try {
 624                     $this->database->update_record('sessions', $record);
 625                 } catch (Exception $ex) {
 626                     // very unlikely error
 627                     error_log('Can not refresh database session');
 628                     $this->failed = true;
 629                     throw $ex;
 630                 }
 631             } else {
 632                 //time out session
 633                 $record->state        = 0;
 634                 $record->sessdata     = null;
 635                 $record->userid       = 0;
 636                 $record->timecreated  = $record->timemodified = time();
 637                 $record->firstip      = $record->lastip = getremoteaddr();
 638                 try {
 639                     $this->database->update_record('sessions', $record);
 640                 } catch (Exception $ex) {
 641                     // very unlikely error
 642                     error_log('Can not time out database session');
 643                     $this->failed = true;
 644                     throw $ex;
 645                 }
 646             }
 647         }
 648
 649         $data = is_null($record->sessdata) ? '' : base64_decode($record->sessdata);
 650
 651         unset($record->sessdata); // conserve memory
 652         $this->record = $record;
 653
 654         return $data;
 655     }
 656
 657     /**
 658      * Write session handler.
 659      *
 660      * {@see http://php.net/manual/en/function.session-set-save-handler.php}
 661      *
 662      * NOTE: Do not write to output or throw any exceptions!
 663      *       Hopefully the next page is going to display nice error or it recovers...
 664      *
 665      * @param string $sid
 666      * @param string $session_data
 667      * @return bool success
 668      */
 669     public function handler_write($sid, $session_data) {
 670         global $USER;
 671
 672         // TODO: MDL-20625 we need to rollback all active transactions and log error if any open needed
 673
 674         if ($this->failed) {
 675             // do not write anything back - we failed to start the session properly
 676             return false;
 677         }
 678
 679         $userid = 0;
 680         if (!empty($USER->realuser)) {
 681             $userid = $USER->realuser;
 682         } else if (!empty($USER->id)) {
 683             $userid = $USER->id;
 684         }
 685
 686         if (isset($this->record->id)) {
 687             $record = new stdClass();
 688             $record->state              = 0;
 689             $record->sid                = $sid;                         // might be regenerating sid
 690             $this->record->sessdata     = base64_encode($session_data); // there might be some binary mess :-(
 691             $this->record->userid       = $userid;
 692             $this->record->timemodified = time();
 693             $this->record->lastip       = getremoteaddr();
 694
 695             // TODO: verify session changed before doing update,
 696             //       also make sure the timemodified field is changed only every 10s if nothing else changes  MDL-20462
 697
 698             try {
 699                 $this->database->update_record_raw('sessions', $this->record);
 700             } catch (dml_exception $ex) {
 701                 if ($this->database->get_dbfamily() === 'mysql') {
 702                     try {
 703                         $this->database->set_field('sessions', 'state', 9, array('id'=>$this->record->id));
 704                     } catch (Exception $ignored) {
 705                     }
 706                     error_log('Can not write database session - please verify max_allowed_packet is at least 4M!');
 707                 } else {
 708                     error_log('Can not write database session');
 709                 }
 710                 return false;
 711             } catch (Exception $ex) {
 712                 error_log('Can not write database session');
 713                 return false;
 714             }
 715
 716         } else {
 717             // fresh new session
 718             try {
 719                 $record = new stdClass();
 720                 $record->state        = 0;
 721                 $record->sid          = $sid;
 722                 $record->sessdata     = base64_encode($session_data); // there might be some binary mess :-(
 723                 $record->userid       = $userid;
 724                 $record->timecreated  = $record->timemodified = time();
 725                 $record->firstip      = $record->lastip = getremoteaddr();
 726                 $record->id           = $this->database->insert_record_raw('sessions', $record);
 727                 $this->record = $record;
 728
 729                 $this->database->get_session_lock($this->record->id, SESSION_ACQUIRE_LOCK_TIMEOUT);
 730             } catch (Exception $ex) {
 731                 // this should not happen
 732                 error_log('Can not write new database session or acquire session lock');
 733                 $this->failed = true;
 734                 return false;
 735             }
 736         }
 737
 738         return true;
 739     }
 740
 741     /**
 742      * Destroy session handler
 743      *
 744      * {@see http://php.net/manual/en/function.session-set-save-handler.php}
 745      *
 746      * @param string $sid
 747      * @return bool success
 748      */
 749     public function handler_destroy($sid) {
 750         session_kill($sid);
 751
 752         if (isset($this->record->id) and $this->record->sid === $sid) {
 753             try {
 754                 $this->database->release_session_lock($this->record->id);
 755             } catch (Exception $ex) {
 756                 // ignore problems
 757             }
 758             $this->record = null;
 759         }
 760
 761         return true;
 762     }
 763
 764     /**
 765      * GC session handler
 766      *
 767      * {@see http://php.net/manual/en/function.session-set-save-handler.php}
 768      *
 769      * @param int $ignored_maxlifetime moodle uses special timeout rules
 770      * @return bool success
 771      */
 772     public function handler_gc($ignored_maxlifetime) {
 773         session_gc();
 774         return true;
 775     }
 776 }
 777
 778
 779 /**
 780  * returns true if legacy session used.
 781  * @return bool true if legacy(==file) based session used
 782  */
 783 function session_is_legacy() {
 784     global $CFG, $DB;
 785     return ((isset($CFG->dbsessions) and !$CFG->dbsessions) or !$DB->session_lock_supported());
 786 }
 787
 788 /**
 789  * Terminates all sessions, auth hooks are not executed.
 790  * Useful in upgrade scripts.
 791  */
 792 function session_kill_all() {
 793     global $CFG, $DB;
 794
 795     // always check db table - custom session classes use sessions table
 796     try {
 797         $DB->delete_records('sessions');
 798     } catch (dml_exception $ignored) {
 799         // do not show any warnings - might be during upgrade/installation
 800     }
 801
 802     if (session_is_legacy()) {
 803         $sessiondir = "$CFG->dataroot/sessions";
 804         if (is_dir($sessiondir)) {
 805             foreach (glob("$sessiondir/sess_*") as $filename) {
 806                 @unlink($filename);
 807             }
 808         }
 809     }
 810 }
 811
 812 /**
 813  * Mark session as accessed, prevents timeouts.
 814  * @param string $sid
 815  */
 816 function session_touch($sid) {
 817     global $CFG, $DB;
 818
 819     // always check db table - custom session classes use sessions table
 820     try {
 821         $sql = "UPDATE {sessions} SET timemodified=? WHERE sid=?";
 822         $params = array(time(), $sid);
 823         $DB->execute($sql, $params);
 824     } catch (dml_exception $ignored) {
 825         // do not show any warnings - might be during upgrade/installation
 826     }
 827
 828     if (session_is_legacy()) {
 829         $sid = clean_param($sid, PARAM_FILE);
 830         $sessionfile = clean_param("$CFG->dataroot/sessions/sess_$sid", PARAM_FILE);
 831         if (file_exists($sessionfile)) {
 832             // if the file is locked it means that it will be updated anyway
 833             @touch($sessionfile);
 834         }
 835     }
 836 }
 837
 838 /**
 839  * Terminates one sessions, auth hooks are not executed.
 840  *
 841  * @param string $sid session id
 842  */
 843 function session_kill($sid) {
 844     global $CFG, $DB;
 845
 846     // always check db table - custom session classes use sessions table
 847     try {
 848         $DB->delete_records('sessions', array('sid'=>$sid));
 849     } catch (dml_exception $ignored) {
 850         // do not show any warnings - might be during upgrade/installation
 851     }
 852
 853     if (session_is_legacy()) {
 854         $sid = clean_param($sid, PARAM_FILE);
 855         $sessionfile = "$CFG->dataroot/sessions/sess_$sid";
 856         if (file_exists($sessionfile)) {
 857             @unlink($sessionfile);
 858         }
 859     }
 860 }
 861
 862 /**
 863  * Terminates all sessions of one user, auth hooks are not executed.
 864  * NOTE: This can not work for file based sessions!
 865  *
 866  * @param int $userid user id
 867  */
 868 function session_kill_user($userid) {
 869     global $CFG, $DB;
 870
 871     // always check db table - custom session classes use sessions table
 872     try {
 873         $DB->delete_records('sessions', array('userid'=>$userid));
 874     } catch (dml_exception $ignored) {
 875         // do not show any warnings - might be during upgrade/installation
 876     }
 877
 878     if (session_is_legacy()) {
 879         // log error?
 880     }
 881 }
 882
 883 /**
 884  * Session garbage collection
 885  * - verify timeout for all users
 886  * - kill sessions of all deleted users
 887  * - kill sessions of users with disabled plugins or 'nologin' plugin
 888  *
 889  * NOTE: this can not work when legacy file sessions used!
 890  */
 891 function session_gc() {
 892     global $CFG, $DB;
 893
 894     $maxlifetime = $CFG->sessiontimeout;
 895
 896     try {
 897         /// kill all sessions of deleted users
 898         $DB->delete_records_select('sessions', "userid IN (SELECT id FROM {user} WHERE deleted <> 0)");
 899
 900         /// kill sessions of users with disabled plugins
 901         $auth_sequence = get_enabled_auth_plugins(true);
 902         $auth_sequence = array_flip($auth_sequence);
 903         unset($auth_sequence['nologin']); // no login allowed
 904         $auth_sequence = array_flip($auth_sequence);
 905         $notplugins = null;
 906         list($notplugins, $params) = $DB->get_in_or_equal($auth_sequence, SQL_PARAMS_QM, '', false);
 907         $DB->delete_records_select('sessions', "userid IN (SELECT id FROM {user} WHERE auth $notplugins)", $params);
 908
 909         /// now get a list of time-out candidates
 910         $sql = "SELECT u.*, s.sid, s.timecreated AS s_timecreated, s.timemodified AS s_timemodified
 911                   FROM {user} u
 912                   JOIN {sessions} s ON s.userid = u.id
 913                  WHERE s.timemodified + ? < ? AND u.id <> ?";
 914         $params = array($maxlifetime, time(), $CFG->siteguest);
 915
 916         $authplugins = array();
 917         foreach($auth_sequence as $authname) {
 918             $authplugins[$authname] = get_auth_plugin($authname);
 919         }
 920         $rs = $DB->get_recordset_sql($sql, $params);
 921         foreach ($rs as $user) {
 922             foreach ($authplugins as $authplugin) {
 923                 if ($authplugin->ignore_timeout_hook($user, $user->sid, $user->s_timecreated, $user->s_timemodified)) {
 924                     continue;
 925                 }
 926             }
 927             $DB->delete_records('sessions', array('sid'=>$user->sid));
 928         }
 929         $rs->close();
 930
 931         $purgebefore = time() - $maxlifetime;
 932         // delete expired sessions for guest user account
 933         $DB->delete_records_select('sessions', 'userid = ? AND timemodified < ?', array($CFG->siteguest, $purgebefore));
 934         // delete expired sessions for userid = 0 (not logged in)
 935         $DB->delete_records_select('sessions', 'userid = 0 AND timemodified < ?', array($purgebefore));
 936     } catch (dml_exception $ex) {
 937         error_log('Error gc-ing sessions');
 938     }
 939 }
 940
 941 /**
 942  * Makes sure that $USER->sesskey exists, if $USER itself exists. It sets a new sesskey
 943  * if one does not already exist, but does not overwrite existing sesskeys. Returns the
 944  * sesskey string if $USER exists, or boolean false if not.
 945  *
 946  * @uses $USER
 947  * @return string
 948  */
 949 function sesskey() {
 950     // note: do not use $USER because it may not be initialised yet
 951     if (empty($_SESSION['USER']->sesskey)) {
 952         $_SESSION['USER']->sesskey = random_string(10);
 953     }
 954
 955     return $_SESSION['USER']->sesskey;
 956 }
 957
 958
 959 /**
 960  * Check the sesskey and return true of false for whether it is valid.
 961  * (You might like to imagine this function is called sesskey_is_valid().)
 962  *
 963  * Every script that lets the user perform a significant action (that is,
 964  * changes data in the database) should check the sesskey before doing the action.
 965  * Depending on your code flow, you may want to use the {@link require_sesskey()}
 966  * helper function.
 967  *
 968  * @param string $sesskey The sesskey value to check (optional). Normally leave this blank
 969  *      and this function will do required_param('sesskey', ...).
 970  * @return bool whether the sesskey sent in the request matches the one stored in the session.
 971  */
 972 function confirm_sesskey($sesskey=NULL) {
 973     global $USER;
 974
 975     if (!empty($USER->ignoresesskey)) {
 976         return true;
 977     }
 978
 979     if (empty($sesskey)) {
 980         $sesskey = required_param('sesskey', PARAM_RAW);  // Check script parameters
 981     }
 982
 983     return (sesskey() === $sesskey);
 984 }
 985
 986 /**
 987  * Check the session key using {@link confirm_sesskey()},
 988  * and cause a fatal error if it does not match.
 989  */
 990 function require_sesskey() {
 991     if (!confirm_sesskey()) {
 992         print_error('invalidsesskey');
 993     }
 994 }
 995
 996 /**
 997  * Sets a moodle cookie with a weakly encrypted username
 998  *
 999  * @param string $username to encrypt and place in a cookie, '' means delete current cookie
1000  * @return void
1001  */
1002 function set_moodle_cookie($username) {
1003     global $CFG;
1004
1005     if (NO_MOODLE_COOKIES) {
1006         return;
1007     }
1008
1009     if (empty($CFG->rememberusername)) {
1010         // erase current and do not store permanent cookies
1011         $username = '';
1012     }
1013
1014     if ($username === 'guest') {
1015         // keep previous cookie in case of guest account login
1016         return;
1017     }
1018
1019     $cookiename = 'MOODLEID1_'.$CFG->sessioncookie;
1020
1021     // delete old cookie
1022     setcookie($cookiename, '', time() - HOURSECS, $CFG->sessioncookiepath, $CFG->sessioncookiedomain, $CFG->cookiesecure, $CFG->cookiehttponly);
1023
1024     if ($username !== '') {
1025         // set username cookie for 60 days
1026         setcookie($cookiename, rc4encrypt($username, true), time()+(DAYSECS*60), $CFG->sessioncookiepath, $CFG->sessioncookiedomain, $CFG->cookiesecure, $CFG->cookiehttponly);
1027     }
1028 }
1029
1030 /**
1031  * Gets a moodle cookie with a weakly encrypted username
1032  *
1033  * @return string username
1034  */
1035 function get_moodle_cookie() {
1036     global $CFG;
1037
1038     if (NO_MOODLE_COOKIES) {
1039         return '';
1040     }
1041
1042     if (empty($CFG->rememberusername)) {
1043         return '';
1044     }
1045
1046     $cookiename = 'MOODLEID1_'.$CFG->sessioncookie;
1047
1048     if (empty($_COOKIE[$cookiename])) {
1049         return '';
1050     } else {
1051         $username = rc4decrypt($_COOKIE[$cookiename], true);
1052         if ($username === 'guest' or $username === 'nobody') {
1053             // backwards compatibility - we do not set these cookies any more
1054             $username = '';
1055         }
1056         return $username;
1057     }
1058 }
1059
1060
1061 /**
1062  * Setup $USER object - called during login, loginas, etc.
1063  *
1064  * Call sync_user_enrolments() manually after log-in, or log-in-as.
1065  *
1066  * @param stdClass $user full user record object
1067  * @return void
1068  */
1069 function session_set_user($user) {
1070     $_SESSION['USER'] = $user;
1071     unset($_SESSION['USER']->description); // conserve memory
1072     sesskey(); // init session key
1073 }
1074
1075 /**
1076  * Is current $USER logged-in-as somebody else?
1077  * @return bool
1078  */
1079 function session_is_loggedinas() {
1080     return !empty($_SESSION['USER']->realuser);
1081 }
1082
1083 /**
1084  * Returns the $USER object ignoring current login-as session
1085  * @return stdClass user object
1086  */
1087 function session_get_realuser() {
1088     if (session_is_loggedinas()) {
1089         return $_SESSION['REALUSER'];
1090     } else {
1091         return $_SESSION['USER'];
1092     }
1093 }
1094
1095 /**
1096  * Login as another user - no security checks here.
1097  * @param int $userid
1098  * @param stdClass $context
1099  * @return void
1100  */
1101 function session_loginas($userid, $context) {
1102     if (session_is_loggedinas()) {
1103         return;
1104     }
1105
1106     // switch to fresh new $SESSION
1107     $_SESSION['REALSESSION'] = $_SESSION['SESSION'];
1108     $_SESSION['SESSION']     = new stdClass();
1109
1110     /// Create the new $USER object with all details and reload needed capabilities
1111     $_SESSION['REALUSER'] = $_SESSION['USER'];
1112     $user = get_complete_user_data('id', $userid);
1113     $user->realuser       = $_SESSION['REALUSER']->id;
1114     $user->loginascontext = $context;
1115
1116     // let enrol plugins deal with new enrolments if necessary
1117     enrol_check_plugins($user);
1118     // set up global $USER
1119     session_set_user($user);
1120 }
1121
1122 /**
1123  * Sets up current user and course environment (lang, etc.) in cron.
1124  * Do not use outside of cron script!
1125  *
1126  * @param stdClass $user full user object, null means default cron user (admin)
1127  * @param $course full course record, null means $SITE
1128  * @return void
1129  */
1130 function cron_setup_user($user = NULL, $course = NULL) {
1131     global $CFG, $SITE, $PAGE;
1132
1133     static $cronuser    = NULL;
1134     static $cronsession = NULL;
1135
1136     if (empty($cronuser)) {
1137         /// ignore admins timezone, language and locale - use site default instead!
1138         $cronuser = get_admin();
1139         $cronuser->timezone = $CFG->timezone;
1140         $cronuser->lang     = '';
1141         $cronuser->theme    = '';
1142         unset($cronuser->description);
1143
1144         $cronsession = new stdClass();
1145     }
1146
1147     if (!$user) {
1148         // cached default cron user (==modified admin for now)
1149         session_set_user($cronuser);
1150         $_SESSION['SESSION'] = $cronsession;
1151
1152     } else {
1153         // emulate real user session - needed for caps in cron
1154         if ($_SESSION['USER']->id != $user->id) {
1155             session_set_user($user);
1156             $_SESSION['SESSION'] = new stdClass();
1157         }
1158     }
1159
1160     // TODO MDL-19774 relying on global $PAGE in cron is a bad idea.
1161     // Temporary hack so that cron does not give fatal errors.
1162     $PAGE = new moodle_page();
1163     if ($course) {
1164         $PAGE->set_course($course);
1165     } else {
1166         $PAGE->set_course($SITE);
1167     }
1168
1169     // TODO: it should be possible to improve perf by caching some limited number of users here ;-)
1170
1171 }