root/trunk/lib/SGL/Session.php

Revision 3125, 24.2 kB (checked in by demian, 3 weeks ago)

bugfix to trunk merge -3

  • Property svn:eol-style set to native
Line 
1 <?php
2 /* Reminder: always indent with 4 spaces (no tabs). */
3 // +---------------------------------------------------------------------------+
4 // | Copyright (c) 2006, Demian Turner                                         |
5 // | All rights reserved.                                                      |
6 // |                                                                           |
7 // | Redistribution and use in source and binary forms, with or without        |
8 // | modification, are permitted provided that the following conditions        |
9 // | are met:                                                                  |
10 // |                                                                           |
11 // | o Redistributions of source code must retain the above copyright          |
12 // |   notice, this list of conditions and the following disclaimer.           |
13 // | o Redistributions in binary form must reproduce the above copyright       |
14 // |   notice, this list of conditions and the following disclaimer in the     |
15 // |   documentation and/or other materials provided with the distribution.    |
16 // | o The names of the authors may not be used to endorse or promote          |
17 // |   products derived from this software without specific prior written      |
18 // |   permission.                                                             |
19 // |                                                                           |
20 // | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS       |
21 // | "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT         |
22 // | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR     |
23 // | A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT      |
24 // | OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,     |
25 // | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT          |
26 // | LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,     |
27 // | DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY     |
28 // | THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT       |
29 // | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE     |
30 // | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.      |
31 // |                                                                           |
32 // +---------------------------------------------------------------------------+
33 // | Seagull 0.6                                                               |
34 // +---------------------------------------------------------------------------+
35 // | Session.php                                                               |
36 // +---------------------------------------------------------------------------+
37 // | Author:   Demian Turner <demian@phpkitchen.com>                           |
38 // +---------------------------------------------------------------------------+
39 // $Id: Session.php,v 1.36 2005/06/06 22:05:35 demian Exp $
40
41 define('SGL_SESSION_UPDATE_WINDOW', 10);
42
43 /**
44  * Handles session management.
45  *
46  * Typically looks like this for an admin login:
47     Array
48     (
49         [uid] => 1
50         [rid] => 1
51         [oid] => 1
52         [username] => admin
53         [startTime] => 1131308728
54         [lastRefreshed] => 1131309174
55         [key] => 0e3b45dea658ac339d26395ff528db1d
56         [currentResRange] => all
57         [sortOrder] => ASC
58         [aPrefs] => Array
59             (
60                 [sessionTimeout] => 1800
61                 [timezone] => UTC
62                 [theme] => default
63                 [dateFormat] => UK
64                 [language] => en-iso-8859-15
65                 [resPerPage] => 10
66                 [showExecutionTimes] => 1
67                 [locale] => en_GB
68             )
69
70         [aPerms] => Array
71             (
72             )
73
74         [currentCatId] => 1
75         [dataTypeId] => 1
76     )
77  *
78  * @package SGL
79  * @author  Demian Turner <demian@phpkitchen.com>
80  * @version $Revision: 1.36 $
81  * @since   PHP 4.1
82  */
83 class SGL_Session
84 {
85     /**
86      * Session timeout configurable in preferences.
87      *
88      * @access  private
89      * @var     int
90      */
91     var $_timeout;
92
93     /**
94      * Setup session.
95      *
96      *  o custimise session name
97      *  o configure custom cookie params
98      *  o setup session backed, ie, file or DB
99      *  o start session
100      *  o persist user object in session
101      *
102      * @access  public
103      * @param   int $uid       user id if present
104      * @param   int $lifetime  cookie lifetime in seconds
105      * @return  void
106      */
107     function SGL_Session($uid = -1, $lifetime = 0)
108     {
109         SGL::logMessage(null, PEAR_LOG_DEBUG);
110         $c = &SGL_Config::singleton();
111         $conf = $c->getAll();
112
113         //  customise session
114         $sessName = isset($conf['cookie']['name']) ? $conf['cookie']['name'] : 'SGLSESSID';
115         session_name($sessName);
116
117         //  set session timeout to 0 (until the browser is closed) initially,
118         //  then use user timeout in isTimedOut() method
119         session_set_cookie_params(
120             $lifetime,
121             $conf['cookie']['path'],
122             $conf['cookie']['domain'],
123             $conf['cookie']['secure']);
124
125         if ($conf['session']['handler'] == 'database') {
126              $ok = session_set_save_handler(
127                 array(& $this, 'dbOpen'),
128                 array(& $this, 'dbClose'),
129                 array(& $this, 'dbRead'),
130                 array(& $this, 'dbWrite'),
131                 array(& $this, 'dbDestroy'),
132                 array(& $this, 'dbGc')
133                 );
134         } else {
135             session_save_path(SGL_TMP_DIR);
136         }
137
138         //  start PHP session handler
139 //        if (!(defined('SID'))) {
140 //            $req = & SGL_Request::singleton();
141 //            define('SID', $conf['cookie']['name'] . '=' . $req->get('SGLSESSID'));
142 //        }
143         @session_start();
144
145         //  if user id is passed in constructor, ie, during login, init user
146         if ($uid > 0) {
147             require_once 'DB/DataObject.php';
148             $sessUser = DB_DataObject::factory($conf['table']['user']);
149             $sessUser->get($uid);
150             $this->_init($sessUser);
151
152         //  if session doesn't exist, initialise
153         } elseif (!SGL_Session::exists()){
154             $this->_init();
155         }
156     }
157
158     /**
159      * Initialises session, sets some default values.
160      *
161      * @access  private
162      * @param   object  $oUser  user object if present
163      * @return  boolean true on successful initialisation
164      */
165     function _init($oUser = null)
166     {
167         SGL::logMessage(null, PEAR_LOG_DEBUG);
168
169         //  get UserDAO object
170         require_once SGL_MOD_DIR . '/user/classes/UserDAO.php';
171         $da = & UserDAO::singleton();
172
173         //  set secure session key
174         $startTime = mktime();
175         $acceptLang = @$_SERVER['HTTP_ACCEPT_LANGUAGE'];
176         $userAgent = @$_SERVER['HTTP_USER_AGENT'];
177
178         //  user object is passed only during login
179         if (is_object($oUser)) {
180
181             $aSessVars = array(
182                 'uid'               => $oUser->usr_id,
183                 'rid'               => $oUser->role_id,
184                 'oid'               => !empty($oUser->organisation_id) ? $oUser->organisation_id : 0,
185                 'username'          => $oUser->username,
186                 'startTime'         => $startTime,
187                 'lastRefreshed'     => $startTime,
188                 'key'               => md5($oUser->username . $startTime . $acceptLang . $userAgent),
189                 'aPrefs'            => $da->getPrefsByUserId($oUser->usr_id, $oUser->role_id),
190                 'aPerms'            => ($oUser->role_id == SGL_ADMIN)
191                     ? array()
192                     : $da->getPermsByUserId($oUser->usr_id),
193             );
194         //  otherwise it's a guest session, these values always get
195         //  set and exist in the session before a login
196         } else {
197             //  initialise session with some default values
198             $aSessVars = array(
199                 'uid'               => 0,
200                 'rid'               => 0,
201                 'oid'               => 0,
202                 'username'          => 'guest',
203                 'startTime'         => $startTime,
204                 'lastRefreshed'     => $startTime,
205                 'key'               => md5($startTime . $acceptLang . $userAgent),
206                 'currentResRange'   => 'all',
207                 'sortOrder'         => 'ASC',
208                 'aPrefs'            => $da->getPrefsByUserId(),
209                 'aPerms'            => $da->getPermsByRoleId(),
210             );
211         }
212         //  set vars in session
213         if (isset($_SESSION)) {
214             foreach ($aSessVars as $k => $v) {
215                 $_SESSION[$k] = $v;
216             }
217         }
218
219         //  make session more secure if possible
220         if  (function_exists('session_regenerate_id')) {
221             $c = &SGL_Config::singleton();
222             $conf = $c->getAll();
223             $oldSessionId = session_id();
224             @session_regenerate_id();
225
226             if ($conf['session']['handler'] == 'file') {
227
228                 //  manually remove old session file, see http://ilia.ws/archives/47-session_regenerate_id-Improvement.html
229                 @unlink(SGL_TMP_DIR . '/sess_'.$oldSessionId);
230
231             } elseif ($conf['session']['handler'] == 'database') {
232                 $value = $this->dbRead($oldSessionId);
233                 $this->dbDestroy($oldSessionId);
234                 $this->dbRead(session_id());          // creates new session record
235                 $this->dbWrite(session_id(), $value); // store old session value in new session record
236             } else {
237                 die('Internal Error: unknown session handler');
238             }
239         }
240         return true;
241     }
242
243     /**
244      * Determines whether a session currently exists.
245      *
246      * @access  public
247      * @static
248      * @return  boolean true if session exists and has 1 or more elements
249      */
250     function exists()
251     {
252         SGL::logMessage(null, PEAR_LOG_DEBUG);
253         return isset($_SESSION) && count($_SESSION);
254     }
255
256     /**
257      * Determines whether the current session is valid.
258      *
259      * @access  public
260      * @static
261      * @return  boolean true if session is valid
262      */
263     function isValid()
264     {
265         SGL::logMessage(null, PEAR_LOG_DEBUG);
266         $acceptLang = @$_SERVER['HTTP_ACCEPT_LANGUAGE'];
267         $userAgent = @$_SERVER['HTTP_USER_AGENT'];
268         $currentKey = md5($_SESSION['username'] . $_SESSION['startTime'] .
269             $acceptLang . $userAgent);
270
271         //  compare actual key with session key, and that UID is not 0 (guest)
272         return  ($currentKey == $_SESSION['key']) && $_SESSION['uid'];
273     }
274
275     /**
276      * Determines whether the current session is timed out.
277      *
278      * @access  public
279      * @return  boolean true if session is timed out
280      */
281     function isTimedOut()
282      {
283         SGL::logMessage(null, PEAR_LOG_DEBUG);
284
285         //  check for session timeout
286         $currentTime = mktime();
287         $lastPageRefreshTime = $_SESSION['lastRefreshed'];
288         $timeout = $_SESSION['aPrefs']['sessionTimeout'];
289         //  if timeout is set to zero session never expires
290         if (empty($timeout)) {
291             return false;
292         }
293         if ($currentTime - $lastPageRefreshTime > $timeout) {
294             return true;
295         } else {
296             return false;
297         }
298     }
299
300     /**
301      * Updates the idle time.
302      *
303      * @access  public
304      * @return  boolean true if session idle time delayed
305      */
306     function updateIdle()
307      {
308         SGL::logMessage(null, PEAR_LOG_DEBUG);
309
310         $ret = false;
311         //  check for session timeout
312         if (!$this->isTimedOut()) {
313             if (mktime() - $_SESSION['lastRefreshed'] > SGL_SESSION_UPDATE_WINDOW ) {
314                 $_SESSION['lastRefreshed'] = mktime();
315             }
316             $ret = true;
317         }
318         return $ret;
319     }
320
321
322     /**
323      * Returns true if specified permission exists in the session.
324      *
325      * @access  public
326      * @param   int $permId the permission id
327      * @return  boolean if perm exists or not
328      */
329     function hasPerms($permId)
330     {
331         if (!count($_SESSION)) {
332             $ret = false;
333         }
334         //  if admin role, give perms by default
335         if (@$_SESSION['rid'] == SGL_ADMIN) {
336             $ret = true;
337         } else {
338             if (is_array($_SESSION['aPerms'])) {
339                 $ret = in_array($permId, $_SESSION['aPerms']);
340             } else {
341                 $ret = false;
342             }
343         }
344         return $ret;
345     }
346
347     function currentUserIsOwner($ownerId)
348     {
349         if (!isset($_SESSION)) {
350             return false;
351         }
352         return $_SESSION['uid'] == $ownerId;
353     }
354
355     /**
356      * Returns the current user's id.
357      *
358      * @access  public
359      * @return  int the id
360      */
361     function getUid()
362     {
363         SGL::logMessage(null, PEAR_LOG_DEBUG);
364
365         if (count($_SESSION && isset($_SESSION['uid']))) {
366             return $_SESSION['uid'];
367         } else {
368             return false;
369         }
370     }
371
372     /**
373      * Returns the current user's username.
374      *
375      * @access  public
376      * @return  int the role id
377      */
378     function getUsername()
379     {
380         SGL::logMessage(null, PEAR_LOG_DEBUG);
381
382         if (count($_SESSION && isset($_SESSION['username']))) {
383             return $_SESSION['username'];
384         } else {
385             return false;
386         }
387     }
388
389     /**
390      * Returns the current user's role id.
391      *
392      * @access  public
393      * @return  int the role id
394      */
395     function getRoleId()
396     {
397         SGL::logMessage(null, PEAR_LOG_DEBUG);
398
399         if (isset($_SESSION) && count($_SESSION) && isset($_SESSION['rid'])) {
400             return $_SESSION['rid'];
401         } else {
402             return false;
403         }
404     }
405
406     /**
407      * Returns the current user's organisation id.
408      *
409      * @access  public
410      * @return  int the organisation id
411      */
412     function getOrganisationId()
413     {
414         SGL::logMessage(null, PEAR_LOG_DEBUG);
415
416         if (count($_SESSION && isset($_SESSION['oid']))) {
417             return $_SESSION['oid'];
418         } else {
419             return false;
420         }
421     }
422
423     /**
424      * Removes specified var from session.
425      *
426      * @access  public
427      * @static
428      * @param   string  $sessVarName   name of session var
429      * @return  boolean
430      */
431     function remove($sessVarName)
432     {
433         SGL::logMessage(null, PEAR_LOG_DEBUG);
434
435         if (isset($sessVarName)) {
436             unset($_SESSION[$sessVarName]);
437             return true;
438         } else {
439             return false;
440         }
441     }
442
443     /**
444      * Gets specified var from session.
445      *
446      * @access  public
447      * @static
448      * @param   string  $sessVarName    name of session var
449      * @return  string                  value of session variable
450      */
451     function get($sessVarName)
452     {
453         if (isset($sessVarName) && isset($_SESSION)) {
454             return is_array($_SESSION)
455                 ? (array_key_exists($sessVarName, $_SESSION) ? $_SESSION[$sessVarName] : '')
456                 : '';
457         } else {
458             return null;
459         }
460     }
461
462     /**
463      * Sets specified var in session.
464      *
465      * @access  public
466      * @static
467      * @param   string  $sessVarName   name of session var
468      * @param   mixed   $sessVarValue  value of session var
469      * @return  void
470      */
471     function set($sessVarName, $sessVarValue)
472     {
473         $_SESSION[$sessVarName] = $sessVarValue;
474     }
475
476     /**
477      * Dumps session contents.
478      *
479      * @access  public
480      * @static
481      * @return  void
482      */
483     function debug()
484     {
485         SGL::logMessage(null, PEAR_LOG_DEBUG);
486         $ret = '';
487         foreach ($_SESSION as $sessVarName => $sessVarValue) {
488             $ret .= "$sessVarName => $sessVarValue<br />\n";
489         }
490         return $ret;
491     }
492
493     /**
494      * Returns a valid session identifier that can be used as a URL paramenter, ie
495      * SGLSESSID=1cgmq51l7jh8og8qvt0qu1ntf4
496      *
497      * @return string
498      */
499     function getId()
500     {
501         $c = &SGL_Config::singleton();
502         $conf = $c->getAll();
503
504         return defined('SID') && SID !=''
505             ? SID
506             : $conf['cookie']['name'] . '='. session_id();
507     }
508
509     /**
510      * Destroys current session.
511      *
512      * @access  public
513      * @static
514      * @return  void
515      * @todo    why does session_destroy fail sometimes?
516      */
517     function destroy()
518     {
519         SGL::logMessage(null, PEAR_LOG_DEBUG);
520
521         $c = &SGL_Config::singleton();
522         $conf = $c->getAll();
523
524         foreach ($_SESSION as $sessVarName => $sessVarValue) {
525             if (isset($_SESSION)) {
526                 unset($sessVarName);
527             }
528         }
529         @session_destroy();
530         $_SESSION = array();
531
532         //  clear session cookie so theme comes from DB and not session
533         setcookie$conf['cookie']['name'], null, 0, $conf['cookie']['path'],
534                     $conf['cookie']['domain'], $conf['cookie']['secure']);
535
536         $sess = & new SGL_Session();
537     }
538
539     /**
540      * Returns active session count for a particular user.
541      *
542      * @return integer
543      */
544     function getUserSessionCount($uid, $sessId = -1)
545     {
546         $dbh = & SGL_DB::singleton();
547         $c = &SGL_Config::singleton();
548         $conf = $c->getAll();
549
550         if ($sessId == -1) {
551             $query = "SELECT count(*) FROM {$conf['table']['user_session']} WHERE usr_id = $uid";
552         } else {
553             $query = "
554                 SELECT count(*)
555                 FROM {$conf['table']['user_session']}
556                 WHERE usr_id = $uid
557                 AND session_id != '$sessId'";
558         }
559         $res = $dbh->getOne($query);
560         return $res;
561
562     }
563
564     /**
565      * Destroys all active sessions for a particular user.
566      *
567      * If a session Id is passed, spare it from deletion. Sigh!
568      *
569      * @return integer
570      */
571     function destroyUserSessions($uid, $sessId = -1)
572     {
573         SGL::logMessage(null, PEAR_LOG_DEBUG);
574         $dbh = & SGL_DB::singleton();
575         $c = &SGL_Config::singleton();
576         $conf = $c->getAll();
577
578         if ($sessId == -1) {
579             $query = "DELETE FROM {$conf['table']['user_session']} WHERE usr_id = $uid";
580         } else {
581             $query = "
582                 DELETE FROM {$conf['table']['user_session']}
583                 WHERE usr_id = $uid AND session_id != '$sessId'";
584         }
585         $dbh->query($query);
586     }
587
588     /**
589      * Returns all active guest session count.
590      *
591      * @return integer
592      */
593     function getGuestSessionCount()
594     {
595         $dbh = & SGL_DB::singleton();
596         $c = &SGL_Config::singleton();
597         $conf = $c->getAll();
598
599         $query = "SELECT count(*) FROM {$conf['table']['user_session']} WHERE username = 'guest'";
600         $res = $dbh->getOne($query);
601         return $res;
602     }
603
604     /**
605      * Returns all active members session count.
606      *
607      * @return integer
608      */
609     function getMemberSessionCount()
610     {
611         $dbh = & SGL_DB::singleton();
612         $c = &SGL_Config::singleton();
613         $conf = $c->getAll();
614
615         $query = "SELECT count(*) FROM {$conf['table']['user_session']} WHERE username != 'guest'";
616         $res = $dbh->getOne($query);
617         return $res;
618     }
619
620     /**
621      * Returns all active subscribed users session count.
622      *
623      * @return integer
624      */
625     function getSessionCount()
626     {
627         $dbh = & SGL_DB::singleton();
628         $c = &SGL_Config::singleton();
629         $conf = $c->getAll();
630
631         $query = "SELECT count(*) FROM {$conf['table']['user_session']}";
632         $res = $dbh->getOne($query);
633         return $res;
634     }
635
636     /**
637      * Callback method for DB session start.
638      *
639      * @return  boolean
640      */
641     function dbOpen()
642     {
643         $timeout = isset($_SESSION['aPrefs']['sessionTimeout'])
644             ? $_SESSION['aPrefs']['sessionTimeout']
645             : 900;
646         $this->dbGc($timeout);
647         return true;
648     }
649
650     /**
651      * Callback method for DB session end.
652      *
653      * @return  boolean
654      */
655     function dbClose()
656     {
657         return true;
658     }
659
660     /**
661      * Callback method for DB session get.
662      *
663      * @return  string  return session value
664      */
665     function dbRead($sessId)
666     {
667         $dbh = & SGL_DB::singleton();
668         $c = &SGL_Config::singleton();
669         $conf = $c->getAll();
670
671         $user_session = $conf['table']['user_session'];
672         $query = "SELECT data_value FROM {$user_session} WHERE session_id = '$sessId'";
673         $res = $dbh->query($query);
674         if (PEAR::isError($res)) {
675             return $res;
676         }
677         if ($res->numRows() == 1) {
678             $sessionContent = $dbh->getOne($query);
679             if (!defined('SGL_SESSION_DATA')) {
680                 define('SGL_SESSION_DATA', $sessionContent);
681             }
682             return $sessionContent;
683         } else {
684             $timeStamp = SGL_Date::getTime(true);
685             if (!empty($conf['session']['extended'])) {
686                 $uid = isset($_SESSION['uid']) ? $_SESSION['uid'] : 0;
687                 $username = $_SESSION['username'];
688                 $timeout = isset($_SESSION['aPrefs']['sessionTimeout'])
689                     ? $_SESSION['aPrefs']['sessionTimeout']
690                     : 900;
691                 $query = "
692                     INSERT INTO {$user_session} (session_id, last_updated, data_value, usr_id, username, expiry)
693                     VALUES ('$sessId', '$timeStamp', '', $uid, '$username', $timeout)";
694             } else {
695                 $query = "
696                     INSERT INTO {$user_session} (session_id, last_updated, data_value)
697                     VALUES ('$sessId', '$timeStamp', '')";
698             }
699             $dbh->query($query);
700             return '';
701         }
702     }
703
704     /**
705      * Callback method for DB session set.
706      *
707      * @return  boolean
708      */
709     function dbWrite($sessId, $value)
710     {
711         /* If session havent changed, return here. */
712         if ($value == SGL_SESSION_DATA) {
713             return true;
714         }
715
716         $dbh = & SGL_DB::singleton();
717         $c = &SGL_Config::singleton();
718         $conf = $c->getAll();
719
720         $timeStamp = SGL_Date::getTime(true);
721         $qval = $dbh->quote($value);
722         $user_session = $conf['table']['user_session'];
723         if (!empty($conf['session']['extended'])) {
724             $uid = isset($_SESSION['uid']) ? $_SESSION['uid'] : 0;
725             $username = $_SESSION['username'];
726             $timeout = isset($_SESSION['aPrefs']['sessionTimeout'])
727                 ? $_SESSION['aPrefs']['sessionTimeout']
728                 : 900;
729             $query = "
730                 UPDATE {$user_session}
731                 SET data_value = $qval,
732                     last_updated = '$timeStamp',
733                     usr_id='$uid',
734                     username='$username',
735                     expiry='$timeout'
736                 WHERE session_id = '$sessId'";
737         } else {
738             $query = "
739             UPDATE {$user_session}
740             SET data_value = $qval,
741                 last_updated = '$timeStamp'
742                 WHERE session_id = '$sessId'";
743         }
744         $res = $dbh->query($query);
745         return true;
746     }
747
748     /**
749      * Callback method for DB session destroy.
750      *
751      * @return  boolean
752      */
753     function dbDestroy($sessId)
754     {
755         $dbh = & SGL_DB::singleton();
756         $c = &SGL_Config::singleton();
757         $conf = $c->getAll();
758
759         $query = "DELETE FROM {$conf['table']['user_session']} WHERE session_id = '$sessId'";
760         $res = $dbh->query($query);
761         return true;
762     }
763
764     /**
765      * Callback method for DB session garbage collection.
766      *
767      * @return  boolean
768      */
769     function dbGc($max_expiry)
770     {
771         SGL::logMessage(null, PEAR_LOG_DEBUG);
772         $dbh = & SGL_DB::singleton();
773         $c = &SGL_Config::singleton();
774         $conf = $c->getAll();
775
776         $timeStamp = SGL_Date::getTime(true);
777         $user_session = $conf['table']['user_session'];
778
779         // For extended sessions, enforce session deletion per user expiry setting
780         if (!empty($conf['session']['extended'])) {
781             $query = "
782                 DELETE  FROM {$user_session}
783                 WHERE   (UNIX_TIMESTAMP('$timeStamp') - UNIX_TIMESTAMP(last_updated)) > $max_expiry
784                 AND     (UNIX_TIMESTAMP('$timeStamp') - UNIX_TIMESTAMP(last_updated)) >  expiry";
785         } else {
786             $query = "
787                 DELETE FROM {$user_session}
788                 WHERE UNIX_TIMESTAMP('$timeStamp') - UNIX_TIMESTAMP(last_updated ) > $max_expiry";
789         }
790         $dbh->query($query);
791         return true;
792     }
793 }
794
795 ?>
796
Note: See TracBrowser for help on using the browser.