Comment puis-je expirer une session PHP après 30 minutes?
11 réponses
vous devriez implémenter votre propre timeout de session. Les deux options mentionnées par d'autres ( session.gc_maxlifetime et session.cookie_lifetime ) ne sont pas fiables. Je vais vous expliquer les raisons.
d'Abord:
session.gc_maxlifetime
session.gc_maxlifetime spécifie le nombre de secondes après lequel les données seront considérées comme des "déchets" et nettoyé. La collecte des ordures a lieu au début de la session.
mais le collecteur d'ordures n'est démarré qu'avec une probabilité de session.gc_probability divisé par session.gc_diviseur . Et en utilisant les valeurs par défaut pour options (1 et 100, respectivement), la chance est seulement à 1%.
Eh bien, vous pouvez simplement ajuster ces valeurs de sorte que le collecteur d'ordures est commencé plus souvent. Mais lorsque le collecteur d'ordures est lancé, il vérifiera la validité de chaque session enregistrée. Et c'est coûteux.
de plus, lors de L'utilisation de la session par défaut de PHP .save_handler les données de session sont stockées dans des fichiers en un chemin spécifié dans session.save_path . Avec ce gestionnaire de session, l'âge des données de session est calculé sur la dernière date de modification du fichier et non sur la dernière date d'accès:
Note: si vous utilisez le gestionnaire de session par défaut basé sur le fichier, votre système de fichiers doit garder une trace des temps d'accès (atime). Windows GRAISSE de sorte que vous aurez à venir avec un autre moyen de gérer ramassage des déchets de votre session si vous êtes bloqué avec un système de fichiers FAT ou tout autre système de fichiers où le traçage atime n'est pas disponible. Depuis PHP 4.2.3, il utilise mtime (modified date) au lieu d'atime. Ainsi, vous n'aurez pas de problèmes avec les systèmes de fichiers où le tracking atime n'est pas disponible.
de sorte qu'il pourrait en outre se produire qu'un fichier de données de session est supprimé alors que la session elle-même est encore considérée comme valide parce que les données de session n'a pas été mis à jour récemment.
et deuxième:
session.temps de cuisson
session.cookie_lifetime spécifie la durée de vie du cookie en secondes qui est envoyé au navigateur. [ ... ]
Oui, c'est ça. Cela n'affecte que la durée de vie du cookie et la session elle-même peut encore être valide. Mais c'est le serveur tâche d'invalider une session, pas le client. Donc cela n'aide pas quelque chose. En fait, avoir session.cookie_lifetime défini à 0 ferait du cookie de session un vrai cookie de session qui n'est valide que jusqu'à ce que le navigateur soit fermé.
Conclusion / meilleure solution:
la meilleure solution est d'implémenter votre propre timeout de session. Utilisez un simple horodatage qui indique l'Heure de la dernière activité (c.-à-d. la demande) et la mettre à jour avec chaque demande:
if (isset($_SESSION['LAST_ACTIVITY']) && (time() - $_SESSION['LAST_ACTIVITY'] > 1800)) {
// last request was more than 30 minutes ago
session_unset(); // unset $_SESSION variable for the run-time
session_destroy(); // destroy session data in storage
}
$_SESSION['LAST_ACTIVITY'] = time(); // update last activity time stamp
mise à jour des données de session avec chaque requête modifie également la date de modification du fichier de session afin que la session ne soit pas retirée prématurément par le collecteur d'ordures.
vous pouvez également utiliser un horodatage supplémentaire pour régénérer l'ID de session périodiquement pour éviter des attaques sur les sessions comme fixation de session :
if (!isset($_SESSION['CREATED'])) {
$_SESSION['CREATED'] = time();
} else if (time() - $_SESSION['CREATED'] > 1800) {
// session started more than 30 minutes ago
session_regenerate_id(true); // change session ID for the current session and invalidate old session ID
$_SESSION['CREATED'] = time(); // update creation time
}
Notes:
-
session.gc_maxlifetimedoit être au moins égale à la durée de vie de ce gestionnaire d'expiration personnalisé (1800 dans cet exemple); - si vous voulez expirer la session après 30 minutes de activité au lieu de 30 minutes depuis le début de , vous aurez également besoin d'utiliser
setcookieavec un expiration detime()+60*30pour garder le cookie de session actif.
façon Simple d'expiration de session PHP en 30 minutes.
Note: Si vous voulez changer l'heure, il suffit de changer le 30 avec l'heure désirée et ne pas changer * 60: Cela donnera le procès-verbal.
en minutes : (30 * 60)
En jours: (n * 24 * 60 * 60 ) n = nombre de jours
Login.php
<?php
session_start();
?>
<html>
<form name="form1" method="post">
<table>
<tr>
<td>Username</td>
<td><input type="text" name="text"></td>
</tr>
<tr>
<td>Password</td>
<td><input type="password" name="pwd"></td>
</tr>
<tr>
<td><input type="submit" value="SignIn" name="submit"></td>
</tr>
</table>
</form>
</html>
<?php
if (isset($_POST['submit'])) {
$v1 = "FirstUser";
$v2 = "MyPassword";
$v3 = $_POST['text'];
$v4 = $_POST['pwd'];
if ($v1 == $v3 && $v2 == $v4) {
$_SESSION['luser'] = $v1;
$_SESSION['start'] = time(); // Taking now logged in time.
// Ending a session in 30 minutes from the starting time.
$_SESSION['expire'] = $_SESSION['start'] + (30 * 60);
header('Location: http://localhost/somefolder/homepage.php');
} else {
echo "Please enter the username or password again!";
}
}
?>
page d'Accueil.php
<?php
session_start();
if (!isset($_SESSION['luser'])) {
echo "Please Login again";
echo "<a href='http://localhost/somefolder/login.php'>Click Here to Login</a>";
}
else {
$now = time(); // Checking the time now when home page starts.
if ($now > $_SESSION['expire']) {
session_destroy();
echo "Your session has expired! <a href='http://localhost/somefolder/login.php'>Login here</a>";
}
else { //Starting this else one [else1]
?>
<!-- From here all HTML coding can be done -->
<html>
Welcome
<?php
echo $_SESSION['luser'];
echo "<a href='http://localhost/somefolder/logout.php'>Log out</a>";
?>
</html>
<?php
}
}
?>
déconnexion.php
<?php
session_start();
session_destroy();
header('Location: http://localhost/somefolder/login.php');
?>
Est-ce pour déconnecter l'utilisateur après un certain temps? Définir le temps de création de la session (ou un temps d'expiration) lorsqu'elle est enregistrée, et ensuite vérifier que sur chaque chargement de page pourrait gérer cela.
par exemple:
$_SESSION['example'] = array('foo' => 'bar', 'registered' => time());
// later
if ((time() - $_SESSION['example']['registered']) > (60 * 30)) {
unset($_SESSION['example']);
}
Edit: j'ai le sentiment que vous voulez dire quelque chose d'autre cependant.
vous pouvez racler les sessions après une certaine durée de vie en utilisant le paramètre session.gc_maxlifetime ini:
Edit: la fonction ini_set('session.gc_maxlifetime", 60 * 30);
ce post montre quelques façons de contrôler le temps d'arrêt de la session: http://bytes.com/topic/php/insights/889606-setting-timeout-php-sessions
IMHO la deuxième option est une bonne solution:
<?php
/***
* Starts a session with a specific timeout and a specific GC probability.
* @param int $timeout The number of seconds until it should time out.
* @param int $probability The probablity, in int percentage, that the garbage
* collection routine will be triggered right now.
* @param strint $cookie_domain The domain path for the cookie.
*/
function session_start_timeout($timeout=5, $probability=100, $cookie_domain='/') {
// Set the max lifetime
ini_set("session.gc_maxlifetime", $timeout);
// Set the session cookie to timout
ini_set("session.cookie_lifetime", $timeout);
// Change the save path. Sessions stored in teh same path
// all share the same lifetime; the lowest lifetime will be
// used for all. Therefore, for this to work, the session
// must be stored in a directory where only sessions sharing
// it's lifetime are. Best to just dynamically create on.
$seperator = strstr(strtoupper(substr(PHP_OS, 0, 3)), "WIN") ? "\" : "/";
$path = ini_get("session.save_path") . $seperator . "session_" . $timeout . "sec";
if(!file_exists($path)) {
if(!mkdir($path, 600)) {
trigger_error("Failed to create session save path directory '$path'. Check permissions.", E_USER_ERROR);
}
}
ini_set("session.save_path", $path);
// Set the chance to trigger the garbage collection.
ini_set("session.gc_probability", $probability);
ini_set("session.gc_divisor", 100); // Should always be 100
// Start the session!
session_start();
// Renew the time left until this session times out.
// If you skip this, the session will time out based
// on the time when it was created, rather than when
// it was last used.
if(isset($_COOKIE[session_name()])) {
setcookie(session_name(), $_COOKIE[session_name()], time() + $timeout, $cookie_domain);
}
}
je comprends que les réponses ci-dessus sont correctes, mais elles sont au niveau de l'application, pourquoi ne pas simplement utiliser le fichier .htaccess pour définir la date d'expiration ?
<IfModule mod_php5.c>
#Session timeout
php_value session.cookie_lifetime 1800
php_value session.gc_maxlifetime 1800
</IfModule>
if (isSet($_SESSION['started'])){
if((mktime() - $_SESSION['started'] - 60*30) > 0){
//Logout, destroy session, etc.
}
}
else {
$_SESSION['started'] = mktime();
}
utilisez la fonction session_set_cookie_params pour faire ceci.
est nécessaire appelant cette fonction avant session_start() appel.
essayez ceci:
$lifetime = strtotime('+30 minutes', 0);
session_set_cookie_params($lifetime);
session_start();
voir plus dans: http://php.net/manual/function.session-set-cookie-params.php
C'est en fait facile avec une fonction comme suit. Il utilise le nom de la base de données 'sessions' avec les champs 'id' et 'time'.
chaque fois que l'utilisateur visite à nouveau votre site ou service, vous devez invoquer cette fonction pour vérifier si sa valeur de retour est vraie. Si C'est faux l'Utilisateur a expiré et la session sera détruite (Note: Cette fonction utilise une classe de base de données pour se connecter et interroger la base de données, bien sûr vous pouvez également le faire à l'intérieur de votre fonction ou quelque chose comme ça):
function session_timeout_ok() {
global $db;
$timeout = SESSION_TIMEOUT; //const, e.g. 6 * 60 for 6 minutes
$ok = false;
$session_id = session_id();
$sql = "SELECT time FROM sessions WHERE session_id = '".$session_id."'";
$rows = $db->query($sql);
if ($rows === false) {
//Timestamp could not be read
$ok = FALSE;
}
else {
//Timestamp was read succesfully
if (count($rows) > 0) {
$zeile = $rows[0];
$time_past = $zeile['time'];
if ( $timeout + $time_past < time() ) {
//Time has expired
session_destroy();
$sql = "DELETE FROM sessions WHERE session_id = '" . $session_id . "'";
$affected = $db -> query($sql);
$ok = FALSE;
}
else {
//Time is okay
$ok = TRUE;
$sql = "UPDATE sessions SET time='" . time() . "' WHERE session_id = '" . $session_id . "'";
$erg = $db -> query($sql);
if ($erg == false) {
//DB error
}
}
}
else {
//Session is new, write it to database table sessions
$sql = "INSERT INTO sessions(session_id,time) VALUES ('".$session_id."','".time()."')";
$res = $db->query($sql);
if ($res === FALSE) {
//Database error
$ok = false;
}
$ok = true;
}
return $ok;
}
return $ok;
}
stocker un timestamp dans la session
<?php
$user = $_POST['user_name'];
$pass = $_POST['user_pass'];
require ('db_connection.php');
// Hey, always escape input if necessary!
$result = mysql_query(sprintf("SELECT * FROM accounts WHERE user_Name='%s' AND user_Pass='%s'", mysql_real_escape_string($user), mysql_real_escape_string($pass));
if( mysql_num_rows( $result ) > 0)
{
$array = mysql_fetch_assoc($result);
session_start();
$_SESSION['user_id'] = $user;
$_SESSION['login_time'] = time();
header("Location:loggedin.php");
}
else
{
header("Location:login.php");
}
?>
maintenant, vérifiez si l'horodatage est dans la fenêtre de temps autorisée (1800 secondes est de 30 minutes)
<?php
session_start();
if( !isset( $_SESSION['user_id'] ) || time() - $_SESSION['login_time'] > 1800)
{
header("Location:login.php");
}
else
{
// uncomment the next line to refresh the session, so it will expire after thirteen minutes of inactivity, and not thirteen minutes after login
//$_SESSION['login_time'] = time();
echo ( "this session is ". $_SESSION['user_id'] );
//show rest of the page and all other content
}
?>
veuillez utiliser le bloc de code suivant dans votre fichier include qui est chargé dans chaque page.
$expiry = 1800 ;//session expiry required after 30 mins
if (isset($_SESSION['LAST']) && (time() - $_SESSION['LAST'] > $expiry)) {
session_unset();
session_destroy();
}
$_SESSION['LAST'] = time();
utilisant timestamp...
<?php
if (!isset($_SESSION)) {
$session = session_start();
}
if ($session && !isset($_SESSION['login_time'])) {
if ($session == 1) {
$_SESSION['login_time']=time();
echo "Login :".$_SESSION['login_time'];
echo "<br>";
$_SESSION['idle_time']=$_SESSION['login_time']+20;
echo "Session Idle :".$_SESSION['idle_time'];
echo "<br>";
} else{
$_SESSION['login_time']="";
}
} else {
if (time()>$_SESSION['idle_time']){
echo "Session Idle :".$_SESSION['idle_time'];
echo "<br>";
echo "Current :".time();
echo "<br>";
echo "Session Time Out";
session_destroy();
session_unset();
} else {
echo "Logged In<br>";
}
}
?>
j'ai utilisé 20 secondes pour expirer la session en utilisant l'horodatage .
si vous avez besoin de 30 min ajouter 1800 (30 min en secondes)...