Question Comment est-ce que j'expire une session de PHP après 30 minutes?


Je dois garder une session en vie pendant 30 minutes, puis la détruire.


933
2018-02-06 13:14


origine


Réponses:


Vous devez implémenter un délai d'attente de session de votre choix. Les deux options mentionnées par d'autres (session.gc_maxlifetime et session.cookie_lifetime) ne sont pas fiables. Je vais expliquer les raisons de cela.

Premier:

session.gc_maxlifetime
session.gc_maxlifetime spécifie le nombre de secondes après lesquelles les données seront considérées comme «garbage» et nettoyées. La récupération de place se produit pendant le démarrage de la session.

Mais le garbage collector est seulement commencé avec une probabilité de session.gc_probability divisé par session.gc_divisor. Et en utilisant les valeurs par défaut pour ces options (1 et 100 respectivement), la chance est seulement à 1%.

Eh bien, vous pouvez simplement ajuster ces valeurs pour que le garbage collector soit démarré plus souvent. Mais lorsque le garbage collector est démarré, il vérifie la validité de chaque session enregistrée. Et cela coûte cher.

En outre, lors de l'utilisation de PHP par défaut session.save_handler fichiers, les données de session sont stockées dans des fichiers dans un chemin spécifié dans session.save_path. Avec ce gestionnaire de session, l'âge des données de session est calculé à la date de dernière modification du fichier et non à la dernière date d'accès:

Remarque: Si vous utilisez le gestionnaire de session basé sur un fichier par défaut, votre système de fichiers doit garder une trace des temps d'accès (atime). Windows FAT ne le fait pas, vous devrez donc trouver une autre façon de gérer la collecte des ordures de votre session si vous êtes coincé avec un système de fichiers FAT ou tout autre système de fichiers où le suivi n'est pas disponible. Depuis PHP 4.2.3, il utilise mtime (date de modification) au lieu de atime. Ainsi, vous n'aurez pas de problèmes avec les systèmes de fichiers où le suivi atime n'est pas disponible.

Ainsi, il peut également arriver qu'un fichier de données de session soit supprimé alors que la session elle-même est toujours considérée comme valide car les données de session n'ont pas été mises à jour récemment.

Et deuxieme:

session.cookie_lifetime
session.cookie_lifetime spécifie la durée de vie du cookie en secondes qui est envoyée au navigateur. [...]

Oui c'est vrai. Cela n'affecte que la durée de vie des cookies et la session elle-même peut toujours être valide. Mais c'est la tâche du serveur d'invalider une session, pas le client. Donc cela n'aide rien. En fait, ayant session.cookie_lifetime mis à 0 rendrait le cookie de la session un vrai cookie de session Cela n'est valable que jusqu'à la fermeture du navigateur.

Conclusion / meilleure solution:

La meilleure solution consiste à implémenter un délai d'attente de session de votre choix. Utilisez un horodatage simple qui indique l'heure de la dernière activité (c'est-à-dire la demande) et mettez-le à jour à 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

La mise à jour des données de session avec chaque requête modifie également la date de modification du fichier de session, de sorte que la session n'est pas supprimée prématurément par le garbage collector.

Vous pouvez également utiliser un horodatage supplémentaire pour régénérer l'ID de session périodiquement afin d'éviter les attaques sur des sessions telles que 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
}

Remarques:

  • session.gc_maxlifetime devrait ê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 après depuis le début, vous devrez également utiliser setcookie avec une date d'expiration de time()+60*30 pour conserver le cookie de session actif.

1519
2017-08-13 09:24



Façon simple d'expiration de la session PHP en 30 minutes.

Note: si vous voulez changer l'heure, changez simplement le 30 avec l'heure désirée et ne changez pas * 60: cela donnera les minutes.


En quelques minutes: (30 * 60)
En jours: (n * 24 * 60 * 60) n = non de jours


Login.php

<?php
    session_start();
?>

<html>
    <form name="form1" method="post">
        <table>
            <tr>
                <td>Username</td>
                <td><input type="text" name="text1"></td>
            </tr>
            <tr>
                <td>Password</td>
                <td><input type="password" name="pwd"></td>
            </tr>
            <tr>
                <td><input type="submit" value="SignIn" name="submit1"></td>
            </tr>
        </table>
    </form>
</html>

<?php
    if ($_POST['submit1']) {
        $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!";
        }
    }
?>

HomePage.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
        }
    }
?>

LogOut.php

<?php
    session_start();
    session_destroy();
    header('Location: http://localhost/somefolder/login.php');
?>

113
2017-09-13 06:39



Est-ce que c'est pour déconnecter l'utilisateur après une heure déterminée? Définir l'heure de création de la session (ou une heure d'expiration) lors de son enregistrement, puis vérifier que sur chaque chargement de la 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']);
}

Modifier: J'ai l'impression que tu veux dire autre chose.

Vous pouvez supprimer des sessions après une certaine durée de vie en utilisant session.gc_maxlifetime réglage ini:

Modifier:     ini_set ('session.gc_maxlifetime', 60 * 30);


33
2018-02-06 13:20



Ce message montre plusieurs façons de contrôler le délai d'attente 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);
    }
}

18
2017-10-07 02:31



Eh bien, je comprends que les réponses ci-dessus sont correctes, mais ils sont au niveau de l'application, pourquoi ne pas simplement utiliser .htaccess fichier pour définir l'heure d'expiration?

<IfModule mod_php5.c>
    #Session timeout
    php_value session.cookie_lifetime 1800
    php_value session.gc_maxlifetime 1800
</IfModule>

16
2017-07-15 06:16



if (isSet($_SESSION['started'])){
    if((mktime() - $_SESSION['started'] - 60*30) > 0){
        //Logout, destroy session, etc.
    }
}
else {
    $_SESSION['started'] = mktime();
}

11
2018-02-06 13:21



Utilisez le session_set_cookie_paramsFonciton pour faire ceci.

Est nécessaire d'appeler cette fonction avant session_start() appel.

Essaye ça:

$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


11
2018-05-13 12:43



C'est en fait facile avec une fonction comme celle-ci. Il utilise le nom de la table 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 appeler cette fonction pour vérifier si sa valeur de retour est TRUE. Si elle est FALSE, 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 aussi le faire dans 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;
}

9
2018-01-24 08:40



Enregistrer un horodatage 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 temporelle 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
}
?>

5
2018-05-21 11:20



Veuillez utiliser le bloc de code suivant dans votre fichier d'inclusion 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();

5
2017-08-26 06:55



Utilisation de l'horodatage ...

<?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 minutes, ajoutez 1800 (30 minutes en secondes) ...


0
2018-03-21 10:40