4729b6bea814a0ce74361d1a561d1286f3a12d03
[moodle.git] / 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/>.
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  */
25 defined('MOODLE_INTERNAL') || die();
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 }
35 /**
36   * Factory method returning moodle_session object.
37   * @return moodle_session
38   */
39 function session_get_instance() {
40     global $CFG, $DB;
42     static $session = null;
44     if (is_null($session)) {
45         if (empty($CFG->sessiontimeout)) {
46             $CFG->sessiontimeout = 7200;
47         }
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();
58             } else if ((!isset($CFG->dbsessions) or $CFG->dbsessions) and $DB->session_lock_supported()) {
59                 // default recommended session type
60                 $session = new database_session();
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     }
73     return $session;
74 }
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();
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();
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);
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 {
119     public function __construct() {
120         // session not used at all
121         $_SESSION = array();
122         $_SESSION['SESSION'] = new stdClass();
123         $_SESSION['USER']    = new stdClass();
124     }
126     /**
127      * Terminate current session
128      * @return void
129      */
130     public function terminate_current() {
131         return;
132     }
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     }
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     }
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;
165     public function __construct() {
166         global $CFG;
168         if (NO_MOODLE_COOKIES) {
169             // session not used at all
170             $_SESSION = array();
171             $_SESSION['SESSION'] = new stdClass();
172             $_SESSION['USER']    = new stdClass();
174         } else {
175             $this->prepare_cookies();
176             $this->init_session_storage();
178             $newsession = empty($_COOKIE['MoodleSession'.$CFG->sessioncookie]);
180             ini_set('session.use_trans_sid', '0');
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         }
196         $this->check_user_initialised();
198         $this->check_security();
199     }
201     /**
202      * Terminate current session
203      * @return void
204      */
205     public function terminate_current() {
206         global $CFG, $SESSION, $USER, $DB;
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         }
214         if (NO_MOODLE_COOKIES) {
215             return;
216         }
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
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         }
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;
240         // write the new session
241         session_write_close();
242     }
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         }
254         session_write_close();
255     }
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;
266         if (isset($_SESSION['USER']->id)) {
267             // already set up $USER
268             return;
269         }
271         $user = null;
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         }
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     }
299     /**
300      * Does various session security checks
301      * @global void
302      */
303     protected function check_security() {
304         global $CFG;
306         if (NO_MOODLE_COOKIES) {
307             return;
308         }
310         if (!empty($_SESSION['USER']->id) and !empty($CFG->tracksessionip)) {
311             /// Make sure current IP matches the one for this session
312             $remoteaddr = getremoteaddr();
314             if (empty($_SESSION['USER']->sessionip)) {
315                 $_SESSION['USER']->sessionip = $remoteaddr;
316             }
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     }
326     /**
327      * Prepare cookies and various system settings
328      */
329     protected function prepare_cookies() {
330         global $CFG;
332         if (!isset($CFG->cookiesecure) or (strpos($CFG->wwwroot, 'https://') !== 0 and empty($CFG->sslproxy))) {
333             $CFG->cookiesecure = 0;
334         }
336         if (!isset($CFG->cookiehttponly)) {
337             $CFG->cookiehttponly = 0;
338         }
340     /// Set sessioncookie and sessioncookiepath variable if it isn't already
341         if (!isset($CFG->sessioncookie)) {
342             $CFG->sessioncookie = '';
343         }
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         }
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         }
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]);
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     }
393     /**
394      * Init session storage.
395      */
396     protected abstract function init_session_storage();
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;
415         ini_set('session.save_handler', 'files');
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         }
424         ini_set('session.gc_maxlifetime', $CFG->sessiontimeout);
426         // make sure sessions dir exists and is writable, throws exception if not
427         make_upload_directory('sessions');
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;
445         $sid = clean_param($sid, PARAM_FILE);
446         $sessionfile = "$CFG->dataroot/sessions/sess_$sid";
447         return file_exists($sessionfile);
448     }
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;
464     /** @var moodle_database $database session database */
465     protected $database = null;
467     /** @var bool $failed session read/init failed, do not write back to DB */
468     protected $failed   = false;
470     public function __construct() {
471         global $DB;
472         $this->database = $DB;
473         parent::__construct();
475         if (!empty($this->record->state)) {
476             // something is very wrong
477             session_kill($this->record->sid);
479             if ($this->record->state == 9) {
480                 print_error('dbsessionmysqlpacketsize', 'error');
481             }
482         }
483     }
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);
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     }
503     /**
504      * Init session storage.
505      */
506     protected function init_session_storage() {
507         global $CFG;
509         // gc only from CRON - individual user timeouts now checked during each access
510         ini_set('session.gc_probability', 0);
512         ini_set('session.gc_maxlifetime', $CFG->sessiontimeout);
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     }
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     }
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     }
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;
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         }
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         }
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         }
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         }
649         $data = is_null($record->sessdata) ? '' : base64_decode($record->sessdata);
651         unset($record->sessdata); // conserve memory
652         $this->record = $record;
654         return $data;
655     }
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;
672         // TODO: MDL-20625 we need to rollback all active transactions and log error if any open needed
674         if ($this->failed) {
675             // do not write anything back - we failed to start the session properly
676             return false;
677         }
679         $userid = 0;
680         if (!empty($USER->realuser)) {
681             $userid = $USER->realuser;
682         } else if (!empty($USER->id)) {
683             $userid = $USER->id;
684         }
686         if (isset($this->record->id)) {
687             $this->record->sessdata     = base64_encode($session_data); // there might be some binary mess :-(
688             $this->record->userid       = $userid;
689             $this->record->timemodified = time();
690             $this->record->lastip       = getremoteaddr();
692             // TODO: verify session changed before doing update,
693             //       also make sure the timemodified field is changed only every 10s if nothing else changes  MDL-20462
695             try {
696                 $this->database->update_record_raw('sessions', $this->record);
697             } catch (dml_exception $ex) {
698                 if ($this->database->get_dbfamily() === 'mysql') {
699                     try {
700                         $this->database->set_field('sessions', 'state', 9, array('id'=>$this->record->id));
701                     } catch (Exception $ignored) {
702                     }
703                     error_log('Can not write database session - please verify max_allowed_packet is at least 4M!');
704                 } else {
705                     error_log('Can not write database session');
706                 }
707                 return false;
708             } catch (Exception $ex) {
709                 error_log('Can not write database session');
710                 return false;
711             }
713         } else {
714             // fresh new session
715             try {
716                 $record = new stdClass();
717                 $record->state        = 0;
718                 $record->sid          = $sid;
719                 $record->sessdata     = base64_encode($session_data); // there might be some binary mess :-(
720                 $record->userid       = $userid;
721                 $record->timecreated  = $record->timemodified = time();
722                 $record->firstip      = $record->lastip = getremoteaddr();
723                 $record->id           = $this->database->insert_record_raw('sessions', $record);
724                 $this->record = $record;
726                 $this->database->get_session_lock($this->record->id, SESSION_ACQUIRE_LOCK_TIMEOUT);
727             } catch (Exception $ex) {
728                 // this should not happen
729                 error_log('Can not write new database session or acquire session lock');
730                 $this->failed = true;
731                 return false;
732             }
733         }
735         return true;
736     }
738     /**
739      * Destroy session handler
740      *
741      * {@see http://php.net/manual/en/function.session-set-save-handler.php}
742      *
743      * @param string $sid
744      * @return bool success
745      */
746     public function handler_destroy($sid) {
747         session_kill($sid);
749         if (isset($this->record->id) and $this->record->sid === $sid) {
750             try {
751                 $this->database->release_session_lock($this->record->id);
752             } catch (Exception $ex) {
753                 // ignore problems
754             }
755             $this->record = null;
756         }
758         return true;
759     }
761     /**
762      * GC session handler
763      *
764      * {@see http://php.net/manual/en/function.session-set-save-handler.php}
765      *
766      * @param int $ignored_maxlifetime moodle uses special timeout rules
767      * @return bool success
768      */
769     public function handler_gc($ignored_maxlifetime) {
770         session_gc();
771         return true;
772     }
776 /**
777  * returns true if legacy session used.
778  * @return bool true if legacy(==file) based session used
779  */
780 function session_is_legacy() {
781     global $CFG, $DB;
782     return ((isset($CFG->dbsessions) and !$CFG->dbsessions) or !$DB->session_lock_supported());
785 /**
786  * Terminates all sessions, auth hooks are not executed.
787  * Useful in upgrade scripts.
788  */
789 function session_kill_all() {
790     global $CFG, $DB;
792     // always check db table - custom session classes use sessions table
793     try {
794         $DB->delete_records('sessions');
795     } catch (dml_exception $ignored) {
796         // do not show any warnings - might be during upgrade/installation
797     }
799     if (session_is_legacy()) {
800         $sessiondir = "$CFG->dataroot/sessions";
801         if (is_dir($sessiondir)) {
802             foreach (glob("$sessiondir/sess_*") as $filename) {
803                 @unlink($filename);
804             }
805         }
806     }
809 /**
810  * Mark session as accessed, prevents timeouts.
811  * @param string $sid
812  */
813 function session_touch($sid) {
814     global $CFG, $DB;
816     // always check db table - custom session classes use sessions table
817     try {
818         $sql = "UPDATE {sessions} SET timemodified=? WHERE sid=?";
819         $params = array(time(), $sid);
820         $DB->execute($sql, $params);
821     } catch (dml_exception $ignored) {
822         // do not show any warnings - might be during upgrade/installation
823     }
825     if (session_is_legacy()) {
826         $sid = clean_param($sid, PARAM_FILE);
827         $sessionfile = clean_param("$CFG->dataroot/sessions/sess_$sid", PARAM_FILE);
828         if (file_exists($sessionfile)) {
829             // if the file is locked it means that it will be updated anyway
830             @touch($sessionfile);
831         }
832     }
835 /**
836  * Terminates one sessions, auth hooks are not executed.
837  *
838  * @param string $sid session id
839  */
840 function session_kill($sid) {
841     global $CFG, $DB;
843     // always check db table - custom session classes use sessions table
844     try {
845         $DB->delete_records('sessions', array('sid'=>$sid));
846     } catch (dml_exception $ignored) {
847         // do not show any warnings - might be during upgrade/installation
848     }
850     if (session_is_legacy()) {
851         $sid = clean_param($sid, PARAM_FILE);
852         $sessionfile = "$CFG->dataroot/sessions/sess_$sid";
853         if (file_exists($sessionfile)) {
854             @unlink($sessionfile);
855         }
856     }
859 /**
860  * Terminates all sessions of one user, auth hooks are not executed.
861  * NOTE: This can not work for file based sessions!
862  *
863  * @param int $userid user id
864  */
865 function session_kill_user($userid) {
866     global $CFG, $DB;
868     // always check db table - custom session classes use sessions table
869     try {
870         $DB->delete_records('sessions', array('userid'=>$userid));
871     } catch (dml_exception $ignored) {
872         // do not show any warnings - might be during upgrade/installation
873     }
875     if (session_is_legacy()) {
876         // log error?
877     }
880 /**
881  * Session garbage collection
882  * - verify timeout for all users
883  * - kill sessions of all deleted users
884  * - kill sessions of users with disabled plugins or 'nologin' plugin
885  *
886  * NOTE: this can not work when legacy file sessions used!
887  */
888 function session_gc() {
889     global $CFG, $DB;
891     $maxlifetime = $CFG->sessiontimeout;
893     try {
894         /// kill all sessions of deleted users
895         $DB->delete_records_select('sessions', "userid IN (SELECT id FROM {user} WHERE deleted <> 0)");
897         /// kill sessions of users with disabled plugins
898         $auth_sequence = get_enabled_auth_plugins(true);
899         $auth_sequence = array_flip($auth_sequence);
900         unset($auth_sequence['nologin']); // no login allowed
901         $auth_sequence = array_flip($auth_sequence);
902         $notplugins = null;
903         list($notplugins, $params) = $DB->get_in_or_equal($auth_sequence, SQL_PARAMS_QM, '', false);
904         $DB->delete_records_select('sessions', "userid IN (SELECT id FROM {user} WHERE auth $notplugins)", $params);
906         /// now get a list of time-out candidates
907         $sql = "SELECT u.*, s.sid, s.timecreated AS s_timecreated, s.timemodified AS s_timemodified
908                   FROM {user} u
909                   JOIN {sessions} s ON s.userid = u.id
910                  WHERE s.timemodified + ? < ? AND u.id <> ?";
911         $params = array($maxlifetime, time(), $CFG->siteguest);
913         $authplugins = array();
914         foreach($auth_sequence as $authname) {
915             $authplugins[$authname] = get_auth_plugin($authname);
916         }
917         $rs = $DB->get_recordset_sql($sql, $params);
918         foreach ($rs as $user) {
919             foreach ($authplugins as $authplugin) {
920                 if ($authplugin->ignore_timeout_hook($user, $user->sid, $user->s_timecreated, $user->s_timemodified)) {
921                     continue;
922                 }
923             }
924             $DB->delete_records('sessions', array('sid'=>$user->sid));
925         }
926         $rs->close();
928         $purgebefore = time() - $maxlifetime;
929         // delete expired sessions for guest user account
930         $DB->delete_records_select('sessions', 'userid = ? AND timemodified < ?', array($CFG->siteguest, $purgebefore));
931         // delete expired sessions for userid = 0 (not logged in)
932         $DB->delete_records_select('sessions', 'userid = 0 AND timemodified < ?', array($purgebefore));
933     } catch (dml_exception $ex) {
934         error_log('Error gc-ing sessions');
935     }
938 /**
939  * Makes sure that $USER->sesskey exists, if $USER itself exists. It sets a new sesskey
940  * if one does not already exist, but does not overwrite existing sesskeys. Returns the
941  * sesskey string if $USER exists, or boolean false if not.
942  *
943  * @uses $USER
944  * @return string
945  */
946 function sesskey() {
947     // note: do not use $USER because it may not be initialised yet
948     if (empty($_SESSION['USER']->sesskey)) {
949         $_SESSION['USER']->sesskey = random_string(10);
950     }
952     return $_SESSION['USER']->sesskey;
956 /**
957  * Check the sesskey and return true of false for whether it is valid.
958  * (You might like to imagine this function is called sesskey_is_valid().)
959  *
960  * Every script that lets the user perform a significant action (that is,
961  * changes data in the database) should check the sesskey before doing the action.
962  * Depending on your code flow, you may want to use the {@link require_sesskey()}
963  * helper function.
964  *
965  * @param string $sesskey The sesskey value to check (optional). Normally leave this blank
966  *      and this function will do required_param('sesskey', ...).
967  * @return bool whether the sesskey sent in the request matches the one stored in the session.
968  */
969 function confirm_sesskey($sesskey=NULL) {
970     global $USER;
972     if (!empty($USER->ignoresesskey)) {
973         return true;
974     }
976     if (empty($sesskey)) {
977         $sesskey = required_param('sesskey', PARAM_RAW);  // Check script parameters
978     }
980     return (sesskey() === $sesskey);
983 /**
984  * Check the session key using {@link confirm_sesskey()},
985  * and cause a fatal error if it does not match.
986  */
987 function require_sesskey() {
988     if (!confirm_sesskey()) {
989         print_error('invalidsesskey');
990     }
993 /**
994  * Sets a moodle cookie with a weakly encrypted username
995  *
996  * @param string $username to encrypt and place in a cookie, '' means delete current cookie
997  * @return void
998  */
999 function set_moodle_cookie($username) {
1000     global $CFG;
1002     if (NO_MOODLE_COOKIES) {
1003         return;
1004     }
1006     if (empty($CFG->rememberusername)) {
1007         // erase current and do not store permanent cookies
1008         $username = '';
1009     }
1011     if ($username === 'guest') {
1012         // keep previous cookie in case of guest account login
1013         return;
1014     }
1016     $cookiename = 'MOODLEID1_'.$CFG->sessioncookie;
1018     // delete old cookie
1019     setcookie($cookiename, '', time() - HOURSECS, $CFG->sessioncookiepath, $CFG->sessioncookiedomain, $CFG->cookiesecure, $CFG->cookiehttponly);
1021     if ($username !== '') {
1022         // set username cookie for 60 days
1023         setcookie($cookiename, rc4encrypt($username), time()+(DAYSECS*60), $CFG->sessioncookiepath, $CFG->sessioncookiedomain, $CFG->cookiesecure, $CFG->cookiehttponly);
1024     }
1027 /**
1028  * Gets a moodle cookie with a weakly encrypted username
1029  *
1030  * @return string username
1031  */
1032 function get_moodle_cookie() {
1033     global $CFG;
1035     if (NO_MOODLE_COOKIES) {
1036         return '';
1037     }
1039     if (empty($CFG->rememberusername)) {
1040         return '';
1041     }
1043     $cookiename = 'MOODLEID1_'.$CFG->sessioncookie;
1045     if (empty($_COOKIE[$cookiename])) {
1046         return '';
1047     } else {
1048         $username = rc4decrypt($_COOKIE[$cookiename]);
1049         if ($username === 'guest' or $username === 'nobody') {
1050             // backwards compatibility - we do not set these cookies any more
1051             $username = '';
1052         }
1053         return $username;
1054     }
1058 /**
1059  * Setup $USER object - called during login, loginas, etc.
1060  *
1061  * Call sync_user_enrolments() manually after log-in, or log-in-as.
1062  *
1063  * @param stdClass $user full user record object
1064  * @return void
1065  */
1066 function session_set_user($user) {
1067     $_SESSION['USER'] = $user;
1068     unset($_SESSION['USER']->description); // conserve memory
1069     sesskey(); // init session key
1071     if (PHPUNIT_TEST) {
1072         // phpunit tests use reversed reference
1073         global $USER;
1074         $USER = $_SESSION['USER'];
1075         $_SESSION['USER'] =& $USER;
1076     }
1079 /**
1080  * Is current $USER logged-in-as somebody else?
1081  * @return bool
1082  */
1083 function session_is_loggedinas() {
1084     return !empty($_SESSION['USER']->realuser);
1087 /**
1088  * Returns the $USER object ignoring current login-as session
1089  * @return stdClass user object
1090  */
1091 function session_get_realuser() {
1092     if (session_is_loggedinas()) {
1093         return $_SESSION['REALUSER'];
1094     } else {
1095         return $_SESSION['USER'];
1096     }
1099 /**
1100  * Login as another user - no security checks here.
1101  * @param int $userid
1102  * @param stdClass $context
1103  * @return void
1104  */
1105 function session_loginas($userid, $context) {
1106     if (session_is_loggedinas()) {
1107         return;
1108     }
1110     // switch to fresh new $SESSION
1111     $_SESSION['REALSESSION'] = $_SESSION['SESSION'];
1112     $_SESSION['SESSION']     = new stdClass();
1114     /// Create the new $USER object with all details and reload needed capabilities
1115     $_SESSION['REALUSER'] = $_SESSION['USER'];
1116     $user = get_complete_user_data('id', $userid);
1117     $user->realuser       = $_SESSION['REALUSER']->id;
1118     $user->loginascontext = $context;
1120     // let enrol plugins deal with new enrolments if necessary
1121     enrol_check_plugins($user);
1122     // set up global $USER
1123     session_set_user($user);
1126 /**
1127  * Sets up current user and course environment (lang, etc.) in cron.
1128  * Do not use outside of cron script!
1129  *
1130  * @param stdClass $user full user object, null means default cron user (admin)
1131  * @param $course full course record, null means $SITE
1132  * @return void
1133  */
1134 function cron_setup_user($user = NULL, $course = NULL) {
1135     global $CFG, $SITE, $PAGE;
1137     static $cronuser    = NULL;
1138     static $cronsession = NULL;
1140     if (empty($cronuser)) {
1141         /// ignore admins timezone, language and locale - use site default instead!
1142         $cronuser = get_admin();
1143         $cronuser->timezone = $CFG->timezone;
1144         $cronuser->lang     = '';
1145         $cronuser->theme    = '';
1146         unset($cronuser->description);
1148         $cronsession = new stdClass();
1149     }
1151     if (!$user) {
1152         // cached default cron user (==modified admin for now)
1153         session_set_user($cronuser);
1154         $_SESSION['SESSION'] = $cronsession;
1156     } else {
1157         // emulate real user session - needed for caps in cron
1158         if ($_SESSION['USER']->id != $user->id) {
1159             session_set_user($user);
1160             $_SESSION['SESSION'] = new stdClass();
1161         }
1162     }
1164     // TODO MDL-19774 relying on global $PAGE in cron is a bad idea.
1165     // Temporary hack so that cron does not give fatal errors.
1166     $PAGE = new moodle_page();
1167     if ($course) {
1168         $PAGE->set_course($course);
1169     } else {
1170         $PAGE->set_course($SITE);
1171     }
1173     // TODO: it should be possible to improve perf by caching some limited number of users here ;-)