PHP
sessioni

Sintassi

• void session_abort (void)
• int session_cache_expire ([string $ new_cache_expire])
• void session_commit (void)
• string session_create_id ([stringa $ prefisso])
• bool session_decode (stringa $ dati)
• bool session_destroy (void)
• string session_encode (void)
• int session_gc (void)
• array session_get_cookie_params (void)
• string session_id ([stringa $ id])
• bool session_is_registered (stringa $ nome)
• stringa session_module_name ([stringa $ modulo])
• string session_name ([stringa $ nome])
• bool session_regenerate_id ([bool $ delete_old_session = false])
• void session_register_shutdown (void)
• bool session_register (mixed $ name [, mixed $ ...])
• void session_reset (void)
• string session_save_path ([stringa $ percorso])
• void session_set_cookie_params (int $ lifetime [, stringa $ percorso [, stringa $ dominio [, bool $ secure = false [, bool $ httponly = false]]]])
• bool session_set_save_handler (callable $ open, callable $ close, callable $ read, callable $ write, callable $ destroy, callable $ gc [, callable $ create_sid [, callable $ validate_sid [, callable $ update_timestamp]]])
• bool session_start ([array $ options = []])
• int session_status (void)
• bool session_unregister (stringa $ nome)
• void session_unset (void)
• void session_write_close (void)

Osservazioni

Manipolazione dei dati di sessione

La variabile $_SESSION è una matrice e puoi recuperarla o manipolarla come un normale array.

<?php
// Starting the session
session_start();

// Storing the value in session
$_SESSION['id'] = 342;

// conditional usage of session values that may have been set in a previous session
if(!isset($_SESSION["login"])) {
    echo "Please login first";
    exit;
}
// now you can use the login safely
$user = $_SESSION["login"];

// Getting a value from the session data, or with default value, 
//     using the Null Coalescing operator in PHP 7
$name = $_SESSION['name'] ?? 'Anonymous';

Vedi anche Manipolazione di una matrice per maggiori informazioni su come lavorare su un array.

Si noti che se si memorizza un oggetto in una sessione, è possibile recuperarlo con garbo solo se si dispone di un caricatore automatico di classe o se è già stata caricata la classe. In caso contrario, l'oggetto verrà visualizzato come tipo __PHP_Incomplete_Class , che in seguito potrebbe causare arresti anomali . Vedi Namespacing e Autoloading sull'auto- caricamento.

Avvertimento:

I dati della sessione possono essere dirottati. Questo è delineato in: Sicurezza Pro PHP: dai principi di sicurezza delle applicazioni all'implementazione della difesa XSS - Capitolo 7: Prevenzione del dirottamento della sessione Quindi si consiglia vivamente di non memorizzare mai alcuna informazione personale in $_SESSION . Ciò includerebbe in modo critico i numeri delle carte di credito , gli ID di governo e le password ; ma si estenderebbe anche a dati meno ipotetici come nomi , e-mail , numeri di telefono , ecc. che consentirebbero a un hacker di impersonare / compromettere un utente legittimo. Come regola generale, utilizzare valori senza valore / non personali, come gli identificatori numerici, nei dati di sessione.

Distruggi un'intera sessione

Se hai una sessione che desideri distruggere, puoi farlo con session_destroy()

/*
    Let us assume that our session looks like this:
    Array([firstname] => Jon, [id] => 123)

    We first need to start our session:
*/
session_start();

/*
    We can now remove all the values from the `SESSION` superglobal:
    If you omitted this step all of the global variables stored in the 
    superglobal would still exist even though the session had been destroyed.
*/
$_SESSION = array();

// If it's desired to kill the session, also delete the session cookie.
// Note: This will destroy the session, and not just the session data!
if (ini_get("session.use_cookies")) {
    $params = session_get_cookie_params();
    setcookie(session_name(), '', time() - 42000,
        $params["path"], $params["domain"],
        $params["secure"], $params["httponly"]
    );
}

//Finally we can destroy the session:
session_destroy();

Usare session_destroy() è diverso $_SESSION = array(); qualcosa come $_SESSION = array(); che rimuoverà tutti i valori memorizzati nella SESSION superglobale ma non distruggerà la versione memorizzata effettiva della sessione.

Nota : usiamo $_SESSION = array(); invece di session_unset() perché il manuale stabilisce:

Utilizzare solo session_unset () per codice deprecato meno recente che non usa $ _SESSION.

opzioni session_start ()

A partire da PHP Sessions possiamo passare una matrice con opzioni php.ini basate sulla sessione alla funzione session_start .

Esempio

<?php
   if (version_compare(PHP_VERSION, '7.0.0') >= 0) {
       // php >= 7 version
       session_start([
          'cache_limiter' => 'private',
          'read_and_close' => true,
       ]);
   } else {
       // php < 7 version
       session_start();
   }
?>

Questa funzione introduce anche una nuova impostazione php.ini denominata session.lazy_write , che per impostazione predefinita è true e che i dati della sessione vengono solo riscritti, se cambia.

Riferimenti: https://wiki.php.net/rfc/session-lock-ini

Nome della sessione

Verifica se i cookie di sessione sono stati creati

Il nome della sessione è il nome del cookie utilizzato per memorizzare le sessioni. È possibile utilizzare questo per rilevare se i cookie per una sessione sono stati creati per l'utente:

if(isset($_COOKIE[session_name()])) {
    session_start();
}

Si noti che questo metodo in genere non è utile a meno che non si desideri realmente creare cookie inutilmente.

Modifica del nome della sessione

È possibile aggiornare il nome della sessione chiamando session_name() .

//Set the session name
session_name('newname');
//Start the session
session_start();

Se non viene fornito alcun argomento in session_name() , viene restituito il nome della sessione corrente.

Dovrebbe contenere solo caratteri alfanumerici; dovrebbe essere breve e descrittivo (vale a dire per gli utenti con avvertimenti sui cookie abilitati). Il nome della sessione non può essere composto solo da cifre, deve essere presente almeno una lettera. Altrimenti viene generato un nuovo ID di sessione ogni volta.

Blocco delle sessioni

Come tutti sappiamo, PHP scrive i dati di sessione in un file sul lato server. Quando viene fatta una richiesta allo script php che avvia la sessione tramite session_start() , PHP blocca questo file di sessione risultante per bloccare / attendere altre richieste in ingresso per lo stesso session_id da completare, a causa del quale le altre richieste rimarranno bloccate su session_start() fino a oppure a meno che il file di sessione bloccato non sia stato rilasciato

Il file di sessione rimane bloccato fino al completamento dello script o alla chiusura manuale della sessione. Per evitare questa situazione, per evitare che più richieste vengano bloccate , possiamo avviare la sessione e chiudere la sessione che rilascerà il blocco dal file di sessione e consentire di continuare le richieste rimanenti.

// php < 7.0 
// start session 
session_start();

// write data to session
$_SESSION['id'] = 123; // session file is locked, so other requests are blocked

// close the session, release lock
session_write_close();

Ora si penserà che se la sessione è chiusa, come leggiamo i valori della sessione, abbelliamo anche dopo che la sessione è stata chiusa, la sessione è ancora disponibile. Quindi, possiamo ancora leggere i dati della sessione.

echo $_SESSION['id'];    // will output  123

In PHP> = 7.0, possiamo avere sessione read_only, sessione READ_WRITE e la sessione lazy_write, quindi potrebbe non necessaria per utilizzare session_write_close()

Inizio sessione sicura senza errori

Molti sviluppatori hanno questo problema quando lavorano su progetti enormi, specialmente se lavorano su alcuni CMS modulari su plug-in, componenti aggiuntivi, componenti ecc. Ecco la soluzione per l'avvio sicuro della sessione dove se prima si verificava la versione di PHP per coprire tutte le versioni e il successivo è controllato se la sessione è iniziata. Se la sessione non esiste, inizio la sessione in sicurezza. Se la sessione esiste non succede nulla.

if (version_compare(PHP_VERSION, '7.0.0') >= 0) {
    if(session_status() == PHP_SESSION_NONE) {
        session_start(array(
          'cache_limiter' => 'private',
          'read_and_close' => true,
       ));
    }
}
else if (version_compare(PHP_VERSION, '5.4.0') >= 0)
{
    if (session_status() == PHP_SESSION_NONE) {
        session_start();
    }
}
else
{
    if(session_id() == '') {
        session_start();
    }
}

Questo può aiutarti molto a evitare l'errore session_start .