Comment savoir si une session est active?

Question

par demande, il y a quelques façons différentes que vous pouvez dire si oui ou non une session a été commencé, comme:

$isSessionActive = (session_id() != ""); 

Ou:

$isSessionActive = defined('SID'); 

Cependant, ces deux échouer si vous commencer une session, puis fermez-la; session_id() renverra l'ID de la session précédente, tandis que SID sera défini. De même, l'appel session_start() à ce stade va générer un E_NOTICE si vous avez déjà une session active. Est-il un moyen sain d'esprit pour vérifier si une session est en cours, sans avoir à recourir à la mise en mémoire tampon de sortie, l'opérateur shut-up (@session_start()), ou quelque chose d'autre tout aussi aki?

EDIT: J'ai écrit un patch pour essayer d'obtenir cette fonctionnalité incluse dans PHP: http://bugs.php.net/bug.php?id=52982

EDIT 8/29/2011: Nouvelle fonction ajoutée à PHP 5.4 pour résoudre ce problème: "Expose session status via new function, session_status"

// as of 8/29/2011 
$isSessionActive = (session_status() == PHP_SESSION_ACTIVE); 

EDIT 05/12/11: session_status() sur le manuel PHP.

Answer 1

Voir les modifications à la question initiale; Fondamentalement, PHP 5.4 et ci-dessus a maintenant une fonction appelée session_status() pour résoudre ce problème!

"Expose session status via new function, session_status" (SVN Revision 315745)

Si vous avez besoin de cette fonctionnalité dans une version pré-PHP 5.4, voir hakre's answer.

Answer 2

Le code suivant dumps un seul session_id() pour moi, pas deux

session_start(); 
echo session_id(); 
session_destroy(); 
echo session_id(); 

Si vous éprouvez des difficultés avec ce que vous pouvez toujours essayer de créer une variable pour vérifier que vous détruisez lorsque vous détruisiez la session.

session_start(); 
$_SESSION['intialized'] = 'This will not print'; 
$_SESSION = array(); // Unset all variables 
session_destroy(); 
echo $_SESSION['initialized']; // No output 

Answer 3

Ken, si la session est détruite, _SESSION $ ne devrait pas être disponible ... ou à tout le moins, vos valeurs seront retirées. Donc, en théorie (non testé), vous devriez être en mesure de vérifier le tableau pour une valeur de savoir si quelque chose est actuellement défini.

Answer 4

J'ai travaillé autour de ce en ajoutant des fonctions wrapper couple autour des différentes mesures de création de la session/fermeture/fonctions détruire. Fondamentalement:

function open_session() { 
    session_start(); 
    $_SESSION['is_open'] = TRUE; 
} 

function close_session() { 
    session_write_close(); 
    $_SESSION['is_open'] = FALSE; 
} 

function destroy_session() { 
    session_destroy(); 
    $_SESSION['is_open'] = FALSE; 
} 

function session_is_open() { 
    return($_SESSION['is_open']); 
} 

Hackish, mais accompli ce dont j'avais besoin.

Answer 5

Je suis en cours d'exécution dans ce aussi bien, et une mise en $_SESSION est pas une option pour moi. Pour PHP 5.3.8:

1. Si une session a été lancé à la demande, define('SID') renverra FALSE, ainsi que $_SESSION est hors service.
2. Ceci est indépendant ou non session_id() a été utilisé pour définir un identifiant de session ou non.
3. Après le premier session_start(), SID est défini et $_SESSION est défini sur un tableau vide.
4. session_destroy() désactive le session_id(), c'est une chaîne vide alors. SID restera défini (et mis à sa valeur précédente qui pourrait être une chaîne vide). $_SESSION est laissé inchangé. Il sera réinitialisé/rempli la prochaine fois session_start est appelée.

Avec ces états, d'autant plus que session_id() peut être appelé entre pour définir l'identifiant pour la prochaine session , il est impossible de déterminer en toute sécurité l'état de session avec SID, $_SESSION et session_id().

« Trying » avec session_start() (par exemple avec @) pourrait ne pas être vraiment utile, car cela va changer l'état de session et modifier le contenu de $_SESSION (et en ajoutant un en-tête set-cookie si le cookie ne faisait pas partie de la demande). Ce n'était pas approprié dans mon cas.

Pendant que j'exécutais des tests, je suis tombé sur le comportement, que vous ne pouvez pas essayer de modifier le paramètre ini de session.serialize_handler lorsque la session est active, même si vous le définissez à la même valeur. La même chose est vraie pour session.use_trans_sid^Docs qui est plus léger. Cela me conduit à la fonction suivante:

/** 
* @return bool 
*/ 
function session_is_active() 
{ 
    $setting = 'session.use_trans_sid'; 
    $current = ini_get($setting); 
    if (FALSE === $current) 
    { 
     throw new UnexpectedValueException(sprintf('Setting %s does not exists.', $setting)); 
    } 
    $result = @ini_set($setting, $current); 
    return $result !== $current; 
} 

Pour autant que je peux voir, l'erreur est la vérification de l'état de session active uniquement (non désactivé), donc cela ne devrait pas revenir un faux positif lorsque les sessions sont désactivées.

Pour obtenir cette fonction compatible avec PHP 5.2, il a besoin d'une petite modification:

/** 
* @return bool 
*/ 
function session_is_active() 
{ 
    $setting = 'session.use_trans_sid'; 
    $current = ini_get($setting); 
    if (FALSE === $current) 
    { 
     throw new UnexpectedValueException(sprintf('Setting %s does not exists.', $setting)); 
    } 
    $testate = "mix$current$current"; 
    $old = @ini_set($setting, $testate); 
    $peek = @ini_set($setting, $current); 
    $result = $peek === $current || $peek === FALSE; 
    return $result; 
} 

Certains sandbox.

Answer 6

Voici une bonne baisse de remplacement qui ne cassera pas des choses lorsque vous passez à 5.4:

if(!function_exists('session_status')){ 
    function session_active(){ 
     return defined('SID'); 
    } 
}else{ 
    function session_active(){ 
     return (session_status() == PHP_SESSION_ACTIVE); 
    }   
} 

Answer 7

Il y a plusieurs endroits que vous devez vérifier pour vérifier la session est active:

1- le cookie existe et n'est pas expiré 2- Le mécanisme de stockage de la session sous-jacente (système de fichiers ou base de données) a un enregistrement correspondant au cookie.