Edit Report a Bug

    Laufzeit-Konfiguration

    Das Verhalten dieser Funktionen wird durch Einstellungen in der php.ini beeinflusst.

    Session-Konfigurationsoptionen
    Name Standard Veränderbar Changelog
    session.save_path "" INI_ALL  
    session.name "PHPSESSID" INI_ALL  
    session.save_handler "files" INI_ALL  
    session.auto_start "0" INI_PERDIR  
    session.gc_probability "1" INI_ALL  
    session.gc_divisor "100" INI_ALL  
    session.gc_maxlifetime "1440" INI_ALL  
    session.serialize_handler "php" INI_ALL  
    session.cookie_lifetime "0" INI_ALL  
    session.cookie_path "/" INI_ALL  
    session.cookie_domain "" INI_ALL  
    session.cookie_secure "0" INI_ALL Vor PHP 7.2.0 war die Grundeinstellung "".
    session.cookie_httponly "0" INI_ALL Vor PHP 7.2.0 war die Grundeinstellung "".
    session.cookie_samesite "" INI_ALL Seit PHP 7.3.0 verfügbar.
    session.use_strict_mode "0" INI_ALL  
    session.use_cookies "1" INI_ALL  
    session.use_only_cookies "1" INI_ALL  
    session.referer_check "" INI_ALL  
    session.cache_limiter "nocache" INI_ALL  
    session.cache_expire "180" INI_ALL  
    session.use_trans_sid "0" INI_ALL  
    session.trans_sid_tags "a=href,area=href,frame=src,form=" INI_ALL Verfügbar seit PHP 7.1.0.
    session.trans_sid_hosts $_SERVER['HTTP_HOST'] INI_ALL Verfügbar seit PHP 7.1.0.
    session.sid_length "32" INI_ALL Verfügbar seit PHP 7.1.0.
    session.sid_bits_per_character "4" INI_ALL Verfügbar seit PHP 7.1.0.
    session.upload_progress.enabled "1" INI_PERDIR  
    session.upload_progress.cleanup "1" INI_PERDIR  
    session.upload_progress.prefix "upload_progress_" INI_PERDIR  
    session.upload_progress.name "PHP_SESSION_UPLOAD_PROGRESS" INI_PERDIR  
    session.upload_progress.freq "1%" INI_PERDIR  
    session.upload_progress.min_freq "1" INI_PERDIR  
    session.lazy_write "1" INI_ALL  
    session.hash_function "0" INI_ALL Entfernt in PHP 7.1.0
    session.hash_bits_per_character "4" INI_ALL Entfernt in PHP 7.1.0
    session.entropy_file "" INI_ALL Entfernt in PHP 7.1.0
    session.entropy_length "0" INI_ALL Entfernt in PHP 7.1.0
    Weitere Details und die Definitionen der INI_*-Konstanten sind unter Wo Konfigurationseinstellungen gesetzt werden können zu finden.

    Das Session-Verwaltungssystem unterstützt eine Anzahl von Konfigurationsoptionen, die in der php.ini gesetzt werden können. Wir geben dazu einen kleinen Überblick.

    session.save_handler string
    session.save_handler definiert den Namen der Routine, die verwendet wird, um die Daten zu speichern und abzurufen, die mit der Session in Verbindung stehen. Grundeinstellung files. Zu beachten ist, dass einzelne Erweiterungen ihre eigenen save_handler registrieren können. Welche Routinen registriert sind, kann auf Basis der jeweiligen Installation mit phpinfo() ermittelt werden. Siehe auch session_set_save_handler().
    session.save_path string
    session.save_path definiert das Argument, das an die Speicherroutine übergeben wird. Wenn die standardmäßige files-Routine gewählt wird, ist das der Pfad, unter dem die Dateien erzeugt werden. Siehe auch session_save_path().

    Für diese Anweisung gibt es ein optionales Argument N, das die Anzahl der Verzeichnisebenen bestimmt, über welche die Session-Dateien verteilt werden. Wird sie zum Beispiel auf '5;/tmp' gesetzt, kann das das Anlegen einer Session-Datei und -Speicherstelle wie /tmp/4/b/1/e/3/sess_4b1e384ad74619bd212e236e52a5a174If bewirken. Um N verwenden zu können, müssen alle diese Verzeichnisse vorher angelegt werden. In ext/session gibt es für diesen Zweck ein kleines Shell-Skript namens mod_files.sh und eine Version für Windows namens mod_files.bat. Zu beachten ist, dass die automatische Speicherbereinigung (Garbage Collection) nicht durchgeführt wird, wenn N verwendet wird und größer 0 ist (für weitere Informationen siehe eine Kopie der php.ini). Außerdem muss bei der Verwendung von N beachtet werden, dass session.save_path zwischen Anführungsstriche gesetzt wird, weil der Trenner (;) in der php.ini auch für Kommentare verwendet wird.

    Standardmäßig erzeugt die files-Speicherroutine Dateien mit dem Modus 600. Dieser Wert kann mit dem optionalen Argument MODE geändert werden: N;MODE;/pfad, wobei MODE die oktale Darstellung des Modus ist. Die Angabe von MODE hat keine Auswirkungen auf den Prozess umask.

    Warnung

    Wenn ein Verzeichnis gewählt wurde, für das jeder Leserechte hat, wie das z. B. bei /tmp (Grundeinstellung) der Fall ist, könnten andere Serverbenutzer mit Hilfe der Dateiliste dieses Verzeichnisses die Sessions entführen.

    Achtung

    Wird das oben beschriebene optionale Argument N für die Verzeichnisebenen verwendet, ist zu beachten, dass ein Wert größer als 1 oder 2 wegen der großen Anzahl an benötigten Verzeichnissen für die meisten Websites unangemessen ist: z. B. bedeutet ein Wert von 3, dass (2 ** session.sid_bits_per_character) ** 3 Verzeichnisse im Dateisystem existieren, was eine große Verschwendung an Speicher und Inodes zur Folge haben kann.

    N größer als 2 sollte nur verwendet werden, wenn die Website wirklich so groß ist, dass dies erforderlich ist.

    session.name string
    session.name definiert den Namen der Session, der als Cookie-Name verwendet wird. Grundeinstellung PHPSESSID. Siehe auch session_name().
    session.auto_start bool
    session.auto_start definiert, ob das Session-Modul zu Beginn einer Anfrage automatisch eine Session startet. Grundeinstellung 0 (deaktiviert).
    session.serialize_handler string
    session.serialize_handler definiert den Namen der Routine, die verwendet wird, um Daten zu serialisieren/deserialisieren. Unterstützt werden das PHP-Serialisierungsformat (Name php_serialize), die internen PHP-Formate (Namen php und php_binary) und WDDX (Name wddx). WDDX steht nur zur Verfügung, wenn PHP mit WDDX-Unterstützung kompiliert wurde. php_serialize verwendet intern die einfachen serialize/unserialize-Funktionen und hat nicht die Einschränkungen, die php und php_binary haben. Ältere Serialisierungsroutinen können weder numerische Indizes noch alphanumerische Indizes, die Sonderzeichen (| und !) enthalten, in $_SESSION speichern. Um am Ende des Skripts Fehler wegen solcher Indizes zu vermeiden, sollte php_serialize verwendet werden. Grundeinstellung php.
    session.gc_probability int
    session.gc_probability wird in Verbindung mit session.gc_divisor dazu verwendet, die Wahrscheinlichkeit zu regeln, mit der die gc-Routine (gc=garbage collection, Speicherbereinigung) gestartet wird. Grundeinstellung 1. Siehe auch session.gc_divisor.
    session.gc_divisor int
    session.gc_divisor definiert gekoppelt mit session.gc_probability die Wahrscheinlichkeit, mit der die gc-Routine (gc=garbage collection, Speicherbereinigung) bei jeder Initialisierung einer Session gestartet wird. Die Wahrscheinlichkeit errechnet sich aus gc_probability/gc_divisor. 1/100 bedeutet z. B., dass die gc-Routine bei jeder Anfrage mit einer Wahrscheinlichkeit von 1% gestartet wird. Grundeinstellung 100.
    session.gc_maxlifetime int
    session.gc_maxlifetime definiert die Anzahl der Sekunden, nach denen Daten als 'garbage' ('Müll') betrachtet und möglicherweise entsorgt werden. Die Speicherbereinigung kann zu Beginn einer Session durchgeführt werden (abhängig von session.gc_probability und session.gc_divisor). Die Grundeinstellung ist 1440 (24 Minuten).

    Hinweis: Falls sich der Wert von session.gc_maxlifetime in verschiedenen Skripten unterscheidet, aber sie die Session-Daten an der selben Stelle speichern, löscht das Skript mit dem kleinsten Wert die Daten. In diesem Fall sollte die Anweisung zusammen mit der Anweisung session.save_path verwendet werden.

    session.referer_check string
    session.referer_check enthält die Zeichenkette, auf die jeder HTTP-Referer überprüft werden soll. Wenn der Referer vom Client gesendet wurde und die Zeichenkette nicht gefunden wurde, wird die eingebettete Session-ID als ungültig gekennzeichnet. Grundeinstellung ist eine leere Zeichenkette.
    session.entropy_file string
    session.entropy_file gibt den Pfad zu einer externen Quelle (Datei) an, die bei der Erzeugung einer Session-ID als zusätzliche Entropiequelle verwendet wird. Beispiele sind /dev/random oder /dev/urandom, die auf vielen Unix-Systemen zur Verfügung stehen. Diese Einstellung wird unter Windows unterstützt. Wenn session.entropy_length auf einen von Null verschiedenen Wert gesetzt wird, verwendet PHP die Windows-Zufalls-API als Entropie-Quelle.

    Hinweis: Entfernt in PHP 7.1.0. Die Grundeinstellung für session.entropy_file ist /dev/urandom oder /dev/arandom, falls es verfügbar ist.

    session.entropy_length int
    session.entropy_length definiert die Anzahl der Bytes, die von der oben spezifizierten Datei gelesen werden. Grundeinstellung 32 (deaktiviert). Entfernt in PHP 7.1.0.
    session.use_strict_mode bool
    session.use_strict_mode definiert ob das Modul den strikten Modus für die Session-ID verwendet. Wenn dieser Modus aktiviert ist, akzeptiert das Modul keine Session-ID, die nicht initialisiert ist. Falls ein Browser eine uninitialisierte Session-ID sendet, wird eine neue Session-ID zum Browser gesendet. Im strikten Modus sind Anwendungen vor der Übernahme der Session durch Session-Fixation geschützt. Grundeinstellung 0 (deaktiviert).

    Hinweis: Das Aktivieren von session.use_strict_mode ist für grundsätzliche Session-Sicherheit verpflichtend. Es wird empfohlen, dass alle Sites dies aktiveren. Verdeutlichender Beispielcode kann der Dokumentation von session_create_id() entnommen werden.

    Warnung

    Wenn eine benutzerdefinierte Session-Routine, die per session_set_save_handler() registriert wurde, weder SessionUpdateTimestampHandlerInterface::validateId() implementiert, noch einen validate_sid-Callback übergibt, ist der strikte Session-ID-Modus praktisch deaktiviert, unabhängig vom Wert dieser Anweisung. Im Besonderen ist zu beachten, dass SessionHandler SessionHandler::validateId() nicht implementiert.

    session.use_cookies bool
    session.use_cookies definiert, ob das Modul Cookies verwendet, um die Session-ID clientseitig zu speichern. Grundeinstellung 1 (aktiviert).
    session.use_only_cookies bool
    session.use_only_cookies definiert, ob das Modul nur Cookies verwendet, um die Session-ID clientseitig zu speichern. Mit Aktivierung dieser Einstellung wird möglichen Angriffen durch Übermittlung von Session-IDs in URLs vorgebeugt. Grundeinstellung 1 (aktiviert).
    session.cookie_lifetime int
    session.cookie_lifetime definiert die Cookie-Lebensdauer, die an den Browser geschickt wird, in Sekunden. Der Wert 0 bedeutet "bis der Browser geschlossen wird." Grundeinstellung 0. Siehe auch session_get_cookie_params() und session_set_cookie_params().

    Hinweis: Der Verfalls-Zeitstempel wird relativ zur Serverzeit gesetzt, die nicht unbedingt mit der Browserzeit des Clients übereinstimmt.

    session.cookie_path string
    session.cookie_path definiert den Pfad, der im Session-Cookie gesetzt wird. Grundeinstellung /. Siehe auch session_get_cookie_params() und session_set_cookie_params().
    session.cookie_domain string
    session.cookie_domain definiert die Domain, die im Session-Cookie gesetzt wird. In der Grundeinstellung überhaupt keine, was bedeutet, dass entsprechend der Spezifikation für Cookies der Hostname des Servers verwendet wird, der das Cookie erzeugt hat. Siehe auch session_get_cookie_params() und session_set_cookie_params().
    session.cookie_secure bool
    session.cookie_secure definiert, ob Cookies nur über sichere Verbindungen geschickt werden sollen. Wenn diese Option auf on gesetzt ist, funktionieren Sessions nur mit HTTPS-Verbindungen. Ist sie auf off gesetzt, funktionieren Sessions sowohl mit HTTP- als auch mit HTTPS-Verbindungen. Grundeinstellung off. Siehe auch session_get_cookie_params() und session_set_cookie_params().
    session.cookie_httponly bool
    session.cookie_httponly markiert das Cookie als nur über das HTTP-Protokoll zugänglich. Das bedeutet, dass Skriptsprachen wie JavaScript nicht auf das Cookie zugreifen können. Diese Einstellung kann helfen, Identitätsdiebstahl durch XSS-Angriffe zu reduzieren (allerdings wird sie nicht von allen Browsern unterstützt).
    session.cookie_samesite string
    Erlaubt es Servern, zu bestätigen, dass ein Cookie nicht mit seitenübergreifenden Anfragen gesendet werden sollte. Diese Bestätigung ermöglicht es User-Agents die Gefahr von herkunftsübergreifenden Informationslecks zu lindern und bietet etwas Schutz gegen Fälschungsangriffe auf seitenübergreifende Anfragen (Cross-Site Request Forgery Attacks). Es ist zu beachten, dass dies nicht von allen Browsern unterstützt wird. Ein leerer Wert bedeutet, dass kein SameSite-Cookie-Attribut gesetzt wird. Lax und Strict bedeuten, dass das Cookie bei POST-Anfragen nicht domainübergreifend gesendet wird; Lax sendet das Cookie für domainübergreifende GET-Anfragen, während Strict das nicht tut.
    session.cache_limiter string
    session.cache_limiter definiert die Methode der Cacheverwaltung, die bei Session-Seiten verwendet wird. Das kann einer der folgenden Werte sein: nocache, private, private_no_expire oder public. Grundeinstellung nocache. Informationen über die Bedeutung dieser Werte sind in der session_cache_limiter()-Dokumentation zu finden.
    session.cache_expire int
    session.cache_expire definiert in Minuten, wie lange Session-Seiten im Cache bleiben. Bei nocache ist diese Angabe wirkungslos. Grundeinstellung 180. Siehe auch session_cache_expire().
    session.use_trans_sid bool
    session.use_trans_sid bestimmt ob transparente SID-Unterstützung aktiviert ist oder nicht. Grundeinstellung 0 (deaktiviert).

    Hinweis: Die URL-basierte Session-Verwaltung hat im Vergleich zur Cookie-basierten Session-Verwaltung zusätzliche Sicherheitsrisiken. Benutzer können zum Beispiel eine URL, die eine aktive Session-ID enthält, per E-Mail an Freunde schicken oder in ihren Bookmarks speichern und immer mit der selben Session-ID auf die Seite zugreifen. Seit PHP 7.1.0 werden auch vollständige URL-Pfade, z. B. https://php.net/, vom trans-sid-Feature unterstützt. Vorherige PHP-Versionen unterstützten nur relative URL-Pfade. Rewrite-Ziel-Hosts werden durch session.trans_sid_hosts definiert.

    session.trans_sid_tags string
    session.trans_sid_tags gibt an, welche HTML-Tags umgeschrieben werden, um die Session-ID zu enthalten, wenn transparente SID-Unterstützung aktiviert ist. Die Voreinstellung ist a=href,area=href,frame=src,input=src,form=. form ist ein besonderes Tag. <input hidden="session_id" name="session_name"> wird als Form-Variable hinzugefügt.

    Hinweis: Vor PHP 7.1.0, wurde url_rewriter.tags für diesen Zweck verwendet. Seit PHP 7.1.0 wird fieldset nicht mehr als besonderes Tag angesehen.

    session.trans_sid_hosts string
    session.trans_sid_hosts gibt an, welche Hosts umgeschrieben werden, um die Session-ID zu enthalten, wenn transparente SID-Unterstützung aktiviert ist. Die Voreinstellung ist $_SERVER['HTTP_HOST']. Mehrere Hosts können durch "," getrennt angegeben werden; Leerzeichen sind nicht erlaubt. Beispiel: php.net,wiki.php.net,bugs.php.net.
    session.sid_length int
    session.sid_length erlaubt die Angabe der Länge der Session-ID-Zeichenkette. Diese Länge kann zwischen 22 und 256 liegen. Die Voreinstellung ist 32. Wird Kompatibilität benötigt, kann 32, 40 etc. angegeben werden. Längere Session-IDs sind schwieriger zu erraten. Wenigstens 32 Zeichen werden empfohlen.
    Tipp

    Hinweis zur Kompatibiliät: Anstelle von session.hash_function=0 (MD5) und session.hash_bits_per_character=4, session.hash_function=1 (SHA1) und session.hash_bits_per_character=6 sollte 32 verwendet werden. Anstelle von session.hash_function=0 (MD5) und session.hash_bits_per_character=5 sollte 26 verwendet werden. Anstelle von session.hash_function=0 (MD5) und session.hash_bits_per_character=6 sollte 22 verwendet werden. Die INI-Werte müssen so konfiguriert werden, dass die Session-ID mindestens 128 Bits enthält. Es ist darauf zu achten, dass der Wert für session.sid_bits_per_character angemessen ist, da die Session-ID sonst schwächer ist.

    Hinweis: Diese Einstellung wurde in PHP 7.1.0 eingeführt.

    session.sid_bits_per_character int
    session.sid_bits_per_character erlaubt die Angabe der Anzahl der Bits in kodierten Session-ID-Zeichen. Die möglichen Werte sind '4' (0-9, a-f), '5' (0-9, a-v) und '6' (0-9, a-z, A-Z, "-", ","). Die Voreinstellung ist 4. Mehr Bits ergeben stärkere Session-IDs. 5 wird für die meisten Umgebungen empfohlen.

    Hinweis: Diese Einstellung wurde in PHP 7.1.0 eingeführt.

    session.hash_function mixed
    session.hash_function ermöglicht es, den Prüfsummen-Algorithmus für die Erzeugung von Session-IDs selbst zu bestimmen. '0' bedeutet MD5 (128 Bit) und '1' bedeutet SHA-1 (160 Bit).

    Es ist auch möglich, einen der Algorithmen zu bestimmen, die durch die Hash-Erweiterung (falls vorhanden) zur Verfügung stehen, z. B. sha512 oder whirlpool. Eine vollständige Liste der unterstützten Algorithmen kann mit der Funktion hash_algos() abgerufen werden.

    Hinweis: Entfernt in PHP 7.1.0.

    session.hash_bits_per_character int
    session.hash_bits_per_character ermöglicht es, zu definieren wieviele Bit bei der Umwandlung der binären Prüfsummen-Daten in etwas Lesbares in jedem Zeichen gespeichert werden. Mögliche Werte sind '4' (0-9, a-f), '5' (0-9, a-v) und '6' (0-9, a-z, A-Z, "-", ",").

    Hinweis: Entfernt in PHP 7.1.0.

    session.upload_progress.enabled bool
    Aktiviert die Überwachung des Upload-Fortschritts und füllt die entsprechende $_SESSION-Variable. Grundeinstellung 1 (aktiviert).
    session.upload_progress.cleanup bool
    Löscht die Fortschritts-Informationen, sobald alle POST-Daten gelesen wurden (also der Upload abgeschlossen ist). Grundeinstellung 1 (aktiviert).

    Hinweis: Es wird dringend empfohlen diese Funktion aktiviert zu lassen.

    session.upload_progress.prefix string
    Ein Präfix für den Namen des Schlüssels für den Upload-Fortschritt im $_SESSION-Array. An diesen wird der Wert von $_POST[ini_get("session.upload_progress.name")] angehängt, um einen eindeutigen Schlüssel zu erhalten. Grundeinstellung "upload_progress_".
    session.upload_progress.name string
    Der Name des Schlüssels im $_SESSION-Array, in welchem die Fortschritts-Informationen gespeichert werden sollen. Siehe auch session.upload_progress.prefix. Falls $_POST[ini_get("session.upload_progress.name")] nicht übergeben wird oder nicht verfügbar ist, wird kein Upload-Fortschritt aufgezeichnet. Grundeinstellung "PHP_SESSION_UPLOAD_PROGRESS".
    session.upload_progress.freq mixed
    Definiert, wie oft die Fortschritts-Information aktualisiert werden soll. Dieser Wert kann entweder in Bytes (d. h. Aktualisierung nachdem eine bestimmte Anzahl an Bytes empfangen wurde) oder in Prozent (d. h. Aktualisierung nachdem eine bestimmte Prozentzahl der gesamten Dateigröße empfangen wurde) angegeben werden. Grundeinstellung "1%".
    session.upload_progress.min_freq int
    Die Zeit, die mindestens zwischen zwei Aktualisierungen vergehen muss. Grundeinstellung "1" (eine Sekunde).
    session.lazy_write bool
    Falls session.lazy_write auf 1 gesetzt ist, werden Daten nur gespeichert, nachdem sie sich geändert haben. Grundeinstellung 1 (aktiviert).

    Der Upload-Fortschritt wird nur aufgezeichnet, wenn session.upload_progress.enabled aktiviert ist und die Variable $_POST[ini_get("session.upload_progress.name")] gesetzt ist. Siehe Session-Upload Fortschritt für weitere diesbezügliche Informationen.

    add a note add a note

    User Contributed Notes 22 notes

    up
    33
    Walerian Walawski - https://w87.eu/
    1 year ago
    Can't find mod_files.sh? Here it is:
    ▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬

    #!/usr/bin/env bash

    if [[ "$2" = "" ]] || [[ "$3" = "" ]]; then
           echo "Usage: $0 BASE_DIRECTORY DEPTH BITS_PER_CHAR"
           echo "BASE_DIRECTORY will be created if it doesn't exist"
           echo "DEPTH must be an integer number >0"
           echo "BITS_PER_CHAR(session.sid_bits_per_character) should be one of 4, 5, or 6."
           # http://php.net/manual/en/session.configuration.php#ini.session.sid-bits-per-character
           exit 1
    fi

    if [[ "$2" = "0" ]] && [[ ! "$4" = "recurse" ]]; then
           echo "Can't create a directory tree with depth of 0, exiting."
    fi

    if [[ "$2" = "0" ]]; then
           exit 0
    fi

    directory="$1"
    depth="$2"
    bitsperchar="$3"

    hash_chars="0 1 2 3 4 5 6 7 8 9 a b c d e f"

    if [[ "$bitsperchar" -ge "5" ]]; then
           hash_chars="$hash_chars g h i j k l m n o p q r s t u v"
    fi

    if [[ "$bitsperchar" -ge "6" ]]; then
           hash_chars="$hash_chars w x y z A B C D E F G H I J K L M N O P Q R S T U V W X Y Z - ,"
    fi

    while [[ -d $directory ]] && [[ $( ls $directory ) ]]; do
           echo "Directory $directory is not empty! What would you like to do?"

           options="\"Delete directory contents\" \"Choose another directory\" \"Quit\""
           eval set $options
           select opt in "$@"; do

                  if [[ $opt = "Delete directory contents" ]]; then
                         echo "Deleting $directory contents... "
                         rm -rf $directory/*
                  elif [[ $opt = "Choose another directory" ]]; then
                         echo "Which directory would you like to choose?"
                         read directory
                  elif [[ $opt = "Quit" ]]; then
                         exit 0
                  fi

                  break;
           done
    done

    if [[ ! -d $directory ]]; then
           mkdir -p $directory
    fi

    echo "Creating session path in $directory with a depth of $depth for session.sid_bits_per_character = $bitsperchar"

    for i in $hash_chars; do
           newpath="$directory/$i"
           mkdir $newpath || exit 1
           bash $0 $newpath `expr $depth - 1` $bitsperchar recurse
    done
    up
    76
    Christopher Kramer
    10 years ago
    On debian (based) systems, changing session.gc_maxlifetime at runtime has no real effect. Debian disables PHP's own garbage collector by setting session.gc_probability=0. Instead it has a cronjob running every 30 minutes (see /etc/cron.d/php5) that cleans up old sessions. This cronjob basically looks into your php.ini and uses the value of session.gc_maxlifetime there to decide which sessions to clean (see /usr/lib/php5/maxlifetime).

    You can adjust the global value in your php.ini (usually /etc/php5/apache2/php.ini). Or you can change the session.save_path so debian's cronjob will not clean up your sessions anymore. Then you need to either do your own garbage collection with your own cronjob or enable PHP's garbage collection (php then needs sufficient privileges on the save_path).

    Why does Debian not use PHP's garbarage collection?
    For security reasons, they store session data in a place (/var/lib/php5) with very stringent permissions. With the sticky bit set, only root is allowed to rename or delete files there, so PHP itself cannot clean up old session data. See https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=267720 .
    up
    18
    GreenReaper
    10 years ago
    We found a session.save_path depth of 3 led to excessive wastage of inodes and in fact disk space in storing the directory tree. dir_indexes option on ext2/3/4 makes larger directories more feasible anyway, so we decided to move to a depth of 2 instead.

    It took a little puzzling to figure out how to move the existing PHP sessions up one directory tree, but we ended up running this in the root sessions directory:

    #!/bin/sh
    for a in ./* ; do
        cd ./$a
        pwd
        for b in ./* ; do
          cd ./$b
          pwd
          # Move existing sessions out
          find ./* -xdev -type f -print0 | xargs -0 mv -t .
          # Remove subdirectories
          find ./* -xdev -type d -print0 | xargs -0 rmdir
          cd ..
      done
      cd ..
    done

    This script may not be the best way to do it, but it got the job done fast. You can modify it for different depths by adding or removing "for" loops.

    The documentation gives a depth of 5 as an example, but five is right out. If you're going beyond 2, you're at the scale where you may want to to look at a large memcached or redis instance instead.
    up
    16
    info at thimbleopensource dot com
    9 years ago
    I found out that if you need to set custom session settings, you only need to do it once when session starts. Then session maintains its settings, even if you use ini_set and change them, original session still will use it's original setting until it expires.

    Just thought it might be useful to someone.
    up
    5
    boan dot web at outlook dot com
    5 years ago
    session.cache_limiter may be empty string to disable cache headers entirely.

    Quote:
    > Setting the cache limiter to '' will turn off automatic sending of cache headers entirely.

    http://php.net/manual/en/function.session-cache-limiter.php
    up
    8
    Wouter
    14 years ago
    When setting the session.cookie_lifetime directive in a .htaccess use string format like;

    php_value session.cookie_lifetime "123456"

    and not

    php_value session.cookie_lifetime 123456

    Using a integer as stated above dit not work in my case (Apache/2.2.11 (Ubuntu) PHP/5.2.6-3ubuntu4.5 with Suhosin-Patch mod_ssl/2.2.11 OpenSSL/0.9.8g)
    up
    7
    jlevene at etisoftware dot com
    11 years ago
    Being unable to find an actual copy of mod_files.sh, and seeing lots of complaints/bug fix requests for it, here's one that works.  It gets all its parameters from PHP.INI, so you don't have the opportunity to mess up:

    #!/bin/bash
    #
    # Creates directories for PHP session storage.
    # Replaces the one that "comes with" PHP, which (a) doesn't always come with it
    # and (b) doesn't work so great.
    #
    # This version takes no parameters, and uses the values in PHP.INI (if it
    # can find it).
    #
    # Works in OS-X and CentOS (and probably all other) Linux.
    #
    # Feb '13 by Jeff Levene.

    [[ $# -gt 0 ]] && echo "$0 requires NO command-line parameters.
    It gets does whatever is called for in the PHP.INI file (if it can find it).
    " && exit 1

    # Find the PHP.INI file, if possible:
    phpIni=/usr/local/lib/php.ini                        # Default PHP.INI location
    [[ ! -f "$phpIni" ]] && phpIni=/etc/php.ini            # Secondary location
    [[ ! -f "$phpIni" ]] && phpIni=                        # Found it?

    # Outputs the given (as $1) parameter from the PHP.INI file:
    # The "empty" brackets have a SPACE and a TAB in them.
    #
    PhpConfigParam() {
        [[ ! "$phpIni" ]] && return
        # Get the line from the INI file:
        varLine=`grep "^[     ]*$1[     ]*=" "$phpIni"`

        # Extract the value:
        value=`expr "$varLine" : ".*$1[     ]*=[     ]*['\"]*\([^'\"]*\)"`
        echo "$value"
        }

    if [[ "$phpIni" ]]
    then
        savePath=`PhpConfigParam session.save_path`
        # If there's a number and semicolon at the front, remove them:
        dirDepth=`expr "$savePath" : '\([0-9]*\)'`
        [[ "$dirDepth" ]] && savePath=`expr "$savePath" : '[0-9]*;\(.*\)'` || dirDepth=0
        bits=`PhpConfigParam session.hash_bits_per_character`
        case "x$bits" in
            x)    echo "hash_bits_per_character not defined.  Not running." ; exit 2 ;;
            x4) alphabet='0 1 2 3 4 5 6 7 8 9 a b c d e f' ;;
            x5) alphabet='0 1 2 3 4 5 6 7 8 9 a b c d e f g h i j k l m n o p q r s t u v' ;;
            x6) alphabet='0 1 2 3 4 5 6 7 8 9 a b c d e f g h i j k l m n o p q r s t u v'
                alphabet="$alphabet w x y z A B C D E F G H I J K L M N O P Q R S T U V W"
                alphabet="$alphabet X Y Z - ,"
                ;;
            *)    echo "unrecognized hash_bits_per_character.  Not running." ; exit 2 ;;
        esac
    else
        echo "Cannot find the PHP.INI file.  Not running.  Sorry."
        exit 2
    fi

    # The depth of directories to create is $1.  0 means just create the named
    # directory.  Directory to start with is $2.
    #
    # Used recursively, so variables must be "local".

    doDir() {
        local dir="$2"
        if [[ -d "$dir" ]]
        then
            echo "Directory '$dir' already exists.  No problem."
        elif [[ -f "$dir" ]]
        then
            echo "FILE '$dir' exists.  Aborting." ; exit 2
        else
            if mkdir "$dir"
            then
                echo "Directory '$dir' created."
            else
                echo "Cannot create directory '$dir'.  Aborting." ; exit 2
            fi
        fi
        chmod a+rwx "$dir"
        if [[ $1 -gt 0 ]]
        then
            local depth=$(( $1 - 1 ))
            for letter in $alphabet
            do    doDir $depth "$dir/$letter"
            done
        fi
        }
       
       
    echo "Running with savePath='$savePath', dirDepth=$dirDepth, and bitsPerCharacter=$bits."
    sleep 3

    doDir $dirDepth "$savePath"

    exit 0
    up
    7
    hassankhodadadeh at NOSPAM dot gmail dot com
    12 years ago
    max value for "session.gc_maxlifetime" is 65535. values bigger than this may cause  php session stops working.
    up
    2
    li-lingjie
    6 years ago
    Use SessionHandlerInterface interface Custom redis session, found the following:

    Use ini_set ('session.save_path', "tcp: //127.0.0.1: 6379? Auth = password"); will be reported:

    PHP Fatal error: session_start (): Failed to initialize storage module: user (path: tcp: //127.0.0.1: 6379? Auth = password);

    Using session_save_path ("tcp: //127.0.0.1: 6379? Auth = password") will not
    up
    3
    Nicholas
    14 years ago
    Transient sessions do not appear to be working in 5.3.3

    E.g.

    <?php
        ini_set    ("session.use_cookies", 0);
            ini_set("session.use_trans_sid", 1);
            session_start();
       
        if (isset(    $_SESSION["foo"])) {
            echo     "Foo: " . $_SESSION["foo"];
        } else {
                $_SESSION["foo"] = "Bar";
            echo     "<a href=?" . session_name() . "=" . session_id() . ">Begin test</a>";
        }
    ?>

    This works in 5.2.5, but not 5.3.3
    up
    0
    zch1
    10 months ago
    the pwd should be urlencode when it contanis special chars.
    eg:

    save_handler:redis
    save_path: tcp://127.0.0.1:6739?auth=urlencode('xxxxx')
    up
    0
    ohcc at 163 dot com
    6 years ago
    You should take more care configuring session.gc_maxlifetime when virtual hosts share the same session-saving directory. One host's session data may be gc'ed when another host runs php.
    up
    -1
    AskApache
    13 years ago
    This is how I set my session.save_path
    session.save_path = "1;/home/askapache/tmp/s"
    So to create the folder structure you can use this compatible shell script, if you want to create with 777 permissions change the umask to 0000;
    sh -o braceexpand -c "umask 0077;mkdir -p s/{0..9}/{a..z} s/{a..z}/{0..9}"

    Then you can create a cronjob to clean the session folder by adding this to your crontab which deletes any session files older than an hour:
    @daily find /home/askapache/tmp/s -type f -mmin +60 -exec rm -f {} \; &>/dev/null

    That will create sessions in folder like:
    /home/askapache/tmp/s/b/sess_b1aba5q6io4lv01bpc6t52h0ift227j6

    I don't think any non-mega site will need to go more than 1 levels deep.  Otherwise you create so many directories that it slows the performance gained by this.
    up
    -2
    00 at f00n dot com
    16 years ago
    After having many problems with garbage collection not clearing my sessions I have resolved it through the following.

    First I found this in the php.ini (not something i noticed as i use phpinfo(); to see my hosting ini).

    ; NOTE: If you are using the subdirectory option for storing session files
    ;       (see session.save_path above), then garbage collection does *not*
    ;       happen automatically.  You will need to do your own garbage

    ; collection through a shell script, cron entry, or some other method. ;       For example, the following script would is the equivalent of
    ;       setting session.gc_maxlifetime to 1440 (1440 seconds = 24 minutes):
    ;          cd /path/to/sessions; find -cmin +24 | xargs rm

    With this is mind there are options.

    1. dont use a custom save_path.
    ** This means if your isp hasnt defaulted your session temp to something safer than install default or you are using a shared directory for session data then you would be wise to use named sessions to keep your session from being viewable in other people's scripts.  Creating a unique_id name for this is the common method. **

    2. use your custom folder but write a garbage collection script.

    3. use a custom handler and a database
    up
    -2
    mikaelkael at php dot net
    15 years ago
    Recently, I needed to change the session save_path in my program under Windows. With an ini_set('session.save_path', '../data/sessions'); (and session.gc_divisor = 1 for test), I always obtain 'Error #8 session_start(): ps_files_cleanup_dir: opendir(../data/sessions) failed: Result too large'.

    I corrected this by changing with ini_set('session.save_path', realpath('../data/sessions'));
    up
    -3
    orbill
    14 years ago
    apparently the default value for session.use_only_cookies has changed in 5.3.3 from 0 to 1. If you haven't set this in your php.ini or your code to 0 transparent sessions won't work.
    up
    -4
    white-gandalf at web dot de
    6 years ago
    session.use_strict_mode does very little to strengthen your security: only one very specific variant of attack is migitated by this (where the attacker hands an "empty" sid to the victim to adapt his own browser to that session later) - versus for example the case where he pre-opens a session, handing the sid of that one to the victim, so the victim gets adapted to the pre-opened session. In the latter case this flag does nothing to help. In every other scenario with other vulnerabilities where the session id gets leaked, the flag helps nigher.

    But this flag renders the php function session_id() useless in its parameterized variant, thus preventing any php functionality that builds upon this function.
    up
    -1
    descartavel1+php at gmail dot com
    1 year ago
    You should set `session.name` to use either prefix `__Host-` or `__Secure-`. See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie#attributes
    up
    -6
    sony-santos at bol dot com dot br
    16 years ago
    In response to 00 at f00n, this very page explains:

    "(...) if N is used and greater than 0 then automatic garbage collection will not be performed (...)"

    So you can actually use custom save_path with automatic garbage collection, since you don't use the subdirectory option (that N subdirectory levels).
    up
    -3
    polygon dot co dot in at gmail dot com
    2 years ago
    In php.ini, session.save_handler defines the name of the handler which is used for storing and retrieving data associated with a session. [Defaults to files.]

    By default session.save_handler has support for below

    session.save_handler = files
    session.save_handler = sqlite
    session.save_handler = redis
    session.save_handler = memcached

    These locks the session by default for any HTTP request using session.
    Locking means, a user can't access session related pages until current request is completed.

    So, if you are thinking that switching to these will increase performance; the answer is NO! because of locking behaviour.

    To overcome/customise the session locking behaviour use as below.

    session.save_handler = user
    This is for all (including list above) modes of session storage.

    For "user" type save_handler, we can ignore locks for better performance (as explained in function session_set_save_handler). But for this we need to take care to use sessions only for authenticity and not for passing data from one script to other.

    For passing data accross scripts use GET method to achieve the goal.
    up
    -14
    phpforcharity dot 5 dot pistos at geoshell dot com
    16 years ago
    To get session IDs to show up in URIs, and not get stored via cookies, you must not only set session.use_cookies to 0, but also set session.use_trans_sid to 1.  Otherwise, the session ID goes neither in a cookie nor in URIs!
    up
    -22
    Anonymous
    8 years ago
    In response to this comment: http://php.net/manual/en/session.configuration.php#107990 where it is claimed that gc_maxlifetime values larger than 65535 break the session system. I cannot reproduce this.

    I've set gc_maxlifetime to 31536000 (1 year) and the session system works just fine. I haven't tried how long a session lasts now (I'm in the process of testing this), but it certainly doesn't break PHP sessions.
    add a note add a note
    To Top