vendor/symfony/http-foundation/Session/Storage/NativeSessionStorage.php line 343

Open in your IDE?
  1. <?php
  2. /*
  3.  * This file is part of the Symfony package.
  4.  *
  5.  * (c) Fabien Potencier <fabien@symfony.com>
  6.  *
  7.  * For the full copyright and license information, please view the LICENSE
  8.  * file that was distributed with this source code.
  9.  */
  10. namespace Symfony\Component\HttpFoundation\Session\Storage;
  11. use Symfony\Component\HttpFoundation\Session\SessionBagInterface;
  12. use Symfony\Component\HttpFoundation\Session\SessionUtils;
  13. use Symfony\Component\HttpFoundation\Session\Storage\Handler\StrictSessionHandler;
  14. use Symfony\Component\HttpFoundation\Session\Storage\Proxy\AbstractProxy;
  15. use Symfony\Component\HttpFoundation\Session\Storage\Proxy\SessionHandlerProxy;
  16. // Help opcache.preload discover always-needed symbols
  17. class_exists(MetadataBag::class);
  18. class_exists(StrictSessionHandler::class);
  19. class_exists(SessionHandlerProxy::class);
  20. /**
  21.  * This provides a base class for session attribute storage.
  22.  *
  23.  * @author Drak <drak@zikula.org>
  24.  */
  25. class NativeSessionStorage implements SessionStorageInterface
  26. {
  27.     /**
  28.      * @var SessionBagInterface[]
  29.      */
  30.     protected $bags = [];
  31.     /**
  32.      * @var bool
  33.      */
  34.     protected $started false;
  35.     /**
  36.      * @var bool
  37.      */
  38.     protected $closed false;
  39.     /**
  40.      * @var AbstractProxy|\SessionHandlerInterface
  41.      */
  42.     protected $saveHandler;
  43.     /**
  44.      * @var MetadataBag
  45.      */
  46.     protected $metadataBag;
  47.     /**
  48.      * @var string|null
  49.      */
  50.     private $emulateSameSite;
  51.     /**
  52.      * Depending on how you want the storage driver to behave you probably
  53.      * want to override this constructor entirely.
  54.      *
  55.      * List of options for $options array with their defaults.
  56.      *
  57.      * @see https://php.net/session.configuration for options
  58.      * but we omit 'session.' from the beginning of the keys for convenience.
  59.      *
  60.      * ("auto_start", is not supported as it tells PHP to start a session before
  61.      * PHP starts to execute user-land code. Setting during runtime has no effect).
  62.      *
  63.      * cache_limiter, "" (use "0" to prevent headers from being sent entirely).
  64.      * cache_expire, "0"
  65.      * cookie_domain, ""
  66.      * cookie_httponly, ""
  67.      * cookie_lifetime, "0"
  68.      * cookie_path, "/"
  69.      * cookie_secure, ""
  70.      * cookie_samesite, null
  71.      * gc_divisor, "100"
  72.      * gc_maxlifetime, "1440"
  73.      * gc_probability, "1"
  74.      * lazy_write, "1"
  75.      * name, "PHPSESSID"
  76.      * referer_check, ""
  77.      * serialize_handler, "php"
  78.      * use_strict_mode, "1"
  79.      * use_cookies, "1"
  80.      * use_only_cookies, "1"
  81.      * use_trans_sid, "0"
  82.      * sid_length, "32"
  83.      * sid_bits_per_character, "5"
  84.      * trans_sid_hosts, $_SERVER['HTTP_HOST']
  85.      * trans_sid_tags, "a=href,area=href,frame=src,form="
  86.      *
  87.      * @param AbstractProxy|\SessionHandlerInterface|null $handler
  88.      */
  89.     public function __construct(array $options = [], $handler nullMetadataBag $metaBag null)
  90.     {
  91.         if (!\extension_loaded('session')) {
  92.             throw new \LogicException('PHP extension "session" is required.');
  93.         }
  94.         $options += [
  95.             'cache_limiter' => '',
  96.             'cache_expire' => 0,
  97.             'use_cookies' => 1,
  98.             'lazy_write' => 1,
  99.             'use_strict_mode' => 1,
  100.         ];
  101.         session_register_shutdown();
  102.         $this->setMetadataBag($metaBag);
  103.         $this->setOptions($options);
  104.         $this->setSaveHandler($handler);
  105.     }
  106.     /**
  107.      * Gets the save handler instance.
  108.      *
  109.      * @return AbstractProxy|\SessionHandlerInterface
  110.      */
  111.     public function getSaveHandler()
  112.     {
  113.         return $this->saveHandler;
  114.     }
  115.     /**
  116.      * {@inheritdoc}
  117.      */
  118.     public function start()
  119.     {
  120.         if ($this->started) {
  121.             return true;
  122.         }
  123.         if (\PHP_SESSION_ACTIVE === session_status()) {
  124.             throw new \RuntimeException('Failed to start the session: already started by PHP.');
  125.         }
  126.         if (filter_var(\ini_get('session.use_cookies'), \FILTER_VALIDATE_BOOLEAN) && headers_sent($file$line)) {
  127.             throw new \RuntimeException(sprintf('Failed to start the session because headers have already been sent by "%s" at line %d.'$file$line));
  128.         }
  129.         $sessionId $_COOKIE[session_name()] ?? null;
  130.         /*
  131.          * Explanation of the session ID regular expression: `/^[a-zA-Z0-9,-]{22,250}$/`.
  132.          *
  133.          * ---------- Part 1
  134.          *
  135.          * The part `[a-zA-Z0-9,-]` is related to the PHP ini directive `session.sid_bits_per_character` defined as 6.
  136.          * See https://www.php.net/manual/en/session.configuration.php#ini.session.sid-bits-per-character.
  137.          * Allowed values are integers such as:
  138.          * - 4 for range `a-f0-9`
  139.          * - 5 for range `a-v0-9`
  140.          * - 6 for range `a-zA-Z0-9,-`
  141.          *
  142.          * ---------- Part 2
  143.          *
  144.          * The part `{22,250}` is related to the PHP ini directive `session.sid_length`.
  145.          * See https://www.php.net/manual/en/session.configuration.php#ini.session.sid-length.
  146.          * Allowed values are integers between 22 and 256, but we use 250 for the max.
  147.          *
  148.          * Where does the 250 come from?
  149.          * - The length of Windows and Linux filenames is limited to 255 bytes. Then the max must not exceed 255.
  150.          * - The session filename prefix is `sess_`, a 5 bytes string. Then the max must not exceed 255 - 5 = 250.
  151.          *
  152.          * ---------- Conclusion
  153.          *
  154.          * The parts 1 and 2 prevent the warning below:
  155.          * `PHP Warning: SessionHandler::read(): Session ID is too long or contains illegal characters. Only the A-Z, a-z, 0-9, "-", and "," characters are allowed.`
  156.          *
  157.          * The part 2 prevents the warning below:
  158.          * `PHP Warning: SessionHandler::read(): open(filepath, O_RDWR) failed: No such file or directory (2).`
  159.          */
  160.         if ($sessionId && $this->saveHandler instanceof AbstractProxy && 'files' === $this->saveHandler->getSaveHandlerName() && !preg_match('/^[a-zA-Z0-9,-]{22,250}$/'$sessionId)) {
  161.             // the session ID in the header is invalid, create a new one
  162.             session_id(session_create_id());
  163.         }
  164.         // ok to try and start the session
  165.         if (!session_start()) {
  166.             throw new \RuntimeException('Failed to start the session.');
  167.         }
  168.         if (null !== $this->emulateSameSite) {
  169.             $originalCookie SessionUtils::popSessionCookie(session_name(), session_id());
  170.             if (null !== $originalCookie) {
  171.                 header(sprintf('%s; SameSite=%s'$originalCookie$this->emulateSameSite), false);
  172.             }
  173.         }
  174.         $this->loadSession();
  175.         return true;
  176.     }
  177.     /**
  178.      * {@inheritdoc}
  179.      */
  180.     public function getId()
  181.     {
  182.         return $this->saveHandler->getId();
  183.     }
  184.     /**
  185.      * {@inheritdoc}
  186.      */
  187.     public function setId(string $id)
  188.     {
  189.         $this->saveHandler->setId($id);
  190.     }
  191.     /**
  192.      * {@inheritdoc}
  193.      */
  194.     public function getName()
  195.     {
  196.         return $this->saveHandler->getName();
  197.     }
  198.     /**
  199.      * {@inheritdoc}
  200.      */
  201.     public function setName(string $name)
  202.     {
  203.         $this->saveHandler->setName($name);
  204.     }
  205.     /**
  206.      * {@inheritdoc}
  207.      */
  208.     public function regenerate(bool $destroy falseint $lifetime null)
  209.     {
  210.         // Cannot regenerate the session ID for non-active sessions.
  211.         if (\PHP_SESSION_ACTIVE !== session_status()) {
  212.             return false;
  213.         }
  214.         if (headers_sent()) {
  215.             return false;
  216.         }
  217.         if (null !== $lifetime && $lifetime != \ini_get('session.cookie_lifetime')) {
  218.             $this->save();
  219.             ini_set('session.cookie_lifetime'$lifetime);
  220.             $this->start();
  221.         }
  222.         if ($destroy) {
  223.             $this->metadataBag->stampNew();
  224.         }
  225.         $isRegenerated session_regenerate_id($destroy);
  226.         if (null !== $this->emulateSameSite) {
  227.             $originalCookie SessionUtils::popSessionCookie(session_name(), session_id());
  228.             if (null !== $originalCookie) {
  229.                 header(sprintf('%s; SameSite=%s'$originalCookie$this->emulateSameSite), false);
  230.             }
  231.         }
  232.         return $isRegenerated;
  233.     }
  234.     /**
  235.      * {@inheritdoc}
  236.      */
  237.     public function save()
  238.     {
  239.         // Store a copy so we can restore the bags in case the session was not left empty
  240.         $session $_SESSION;
  241.         foreach ($this->bags as $bag) {
  242.             if (empty($_SESSION[$key $bag->getStorageKey()])) {
  243.                 unset($_SESSION[$key]);
  244.             }
  245.         }
  246.         if ($_SESSION && [$key $this->metadataBag->getStorageKey()] === array_keys($_SESSION)) {
  247.             unset($_SESSION[$key]);
  248.         }
  249.         // Register error handler to add information about the current save handler
  250.         $previousHandler set_error_handler(function ($type$msg$file$line) use (&$previousHandler) {
  251.             if (\E_WARNING === $type && str_starts_with($msg'session_write_close():')) {
  252.                 $handler $this->saveHandler instanceof SessionHandlerProxy $this->saveHandler->getHandler() : $this->saveHandler;
  253.                 $msg sprintf('session_write_close(): Failed to write session data with "%s" handler'\get_class($handler));
  254.             }
  255.             return $previousHandler $previousHandler($type$msg$file$line) : false;
  256.         });
  257.         try {
  258.             session_write_close();
  259.         } finally {
  260.             restore_error_handler();
  261.             // Restore only if not empty
  262.             if ($_SESSION) {
  263.                 $_SESSION $session;
  264.             }
  265.         }
  266.         $this->closed true;
  267.         $this->started false;
  268.     }
  269.     /**
  270.      * {@inheritdoc}
  271.      */
  272.     public function clear()
  273.     {
  274.         // clear out the bags
  275.         foreach ($this->bags as $bag) {
  276.             $bag->clear();
  277.         }
  278.         // clear out the session
  279.         $_SESSION = [];
  280.         // reconnect the bags to the session
  281.         $this->loadSession();
  282.     }
  283.     /**
  284.      * {@inheritdoc}
  285.      */
  286.     public function registerBag(SessionBagInterface $bag)
  287.     {
  288.         if ($this->started) {
  289.             throw new \LogicException('Cannot register a bag when the session is already started.');
  290.         }
  291.         $this->bags[$bag->getName()] = $bag;
  292.     }
  293.     /**
  294.      * {@inheritdoc}
  295.      */
  296.     public function getBag(string $name)
  297.     {
  298.         if (!isset($this->bags[$name])) {
  299.             throw new \InvalidArgumentException(sprintf('The SessionBagInterface "%s" is not registered.'$name));
  300.         }
  301.         if (!$this->started && $this->saveHandler->isActive()) {
  302.             $this->loadSession();
  303.         } elseif (!$this->started) {
  304.             $this->start();
  305.         }
  306.         return $this->bags[$name];
  307.     }
  308.     public function setMetadataBag(MetadataBag $metaBag null)
  309.     {
  310.         if (null === $metaBag) {
  311.             $metaBag = new MetadataBag();
  312.         }
  313.         $this->metadataBag $metaBag;
  314.     }
  315.     /**
  316.      * Gets the MetadataBag.
  317.      *
  318.      * @return MetadataBag
  319.      */
  320.     public function getMetadataBag()
  321.     {
  322.         return $this->metadataBag;
  323.     }
  324.     /**
  325.      * {@inheritdoc}
  326.      */
  327.     public function isStarted()
  328.     {
  329.         return $this->started;
  330.     }
  331.     /**
  332.      * Sets session.* ini variables.
  333.      *
  334.      * For convenience we omit 'session.' from the beginning of the keys.
  335.      * Explicitly ignores other ini keys.
  336.      *
  337.      * @param array $options Session ini directives [key => value]
  338.      *
  339.      * @see https://php.net/session.configuration
  340.      */
  341.     public function setOptions(array $options)
  342.     {
  343.         if (headers_sent() || \PHP_SESSION_ACTIVE === session_status()) {
  344.             return;
  345.         }
  346.         $validOptions array_flip([
  347.             'cache_expire''cache_limiter''cookie_domain''cookie_httponly',
  348.             'cookie_lifetime''cookie_path''cookie_secure''cookie_samesite',
  349.             'gc_divisor''gc_maxlifetime''gc_probability',
  350.             'lazy_write''name''referer_check',
  351.             'serialize_handler''use_strict_mode''use_cookies',
  352.             'use_only_cookies''use_trans_sid''upload_progress.enabled',
  353.             'upload_progress.cleanup''upload_progress.prefix''upload_progress.name',
  354.             'upload_progress.freq''upload_progress.min_freq''url_rewriter.tags',
  355.             'sid_length''sid_bits_per_character''trans_sid_hosts''trans_sid_tags',
  356.         ]);
  357.         foreach ($options as $key => $value) {
  358.             if (isset($validOptions[$key])) {
  359.                 if (str_starts_with($key'upload_progress.')) {
  360.                     trigger_deprecation('symfony/http-foundation''5.4''Support for the "%s" session option is deprecated. The settings prefixed with "session.upload_progress." can not be changed at runtime.'$key);
  361.                     continue;
  362.                 }
  363.                 if ('url_rewriter.tags' === $key) {
  364.                     trigger_deprecation('symfony/http-foundation''5.4''Support for the "%s" session option is deprecated. Use "trans_sid_tags" instead.'$key);
  365.                 }
  366.                 if ('cookie_samesite' === $key && \PHP_VERSION_ID 70300) {
  367.                     // PHP < 7.3 does not support same_site cookies. We will emulate it in
  368.                     // the start() method instead.
  369.                     $this->emulateSameSite $value;
  370.                     continue;
  371.                 }
  372.                 if ('cookie_secure' === $key && 'auto' === $value) {
  373.                     continue;
  374.                 }
  375.                 ini_set('url_rewriter.tags' !== $key 'session.'.$key $key$value);
  376.             }
  377.         }
  378.     }
  379.     /**
  380.      * Registers session save handler as a PHP session handler.
  381.      *
  382.      * To use internal PHP session save handlers, override this method using ini_set with
  383.      * session.save_handler and session.save_path e.g.
  384.      *
  385.      *     ini_set('session.save_handler', 'files');
  386.      *     ini_set('session.save_path', '/tmp');
  387.      *
  388.      * or pass in a \SessionHandler instance which configures session.save_handler in the
  389.      * constructor, for a template see NativeFileSessionHandler.
  390.      *
  391.      * @see https://php.net/session-set-save-handler
  392.      * @see https://php.net/sessionhandlerinterface
  393.      * @see https://php.net/sessionhandler
  394.      *
  395.      * @param AbstractProxy|\SessionHandlerInterface|null $saveHandler
  396.      *
  397.      * @throws \InvalidArgumentException
  398.      */
  399.     public function setSaveHandler($saveHandler null)
  400.     {
  401.         if (!$saveHandler instanceof AbstractProxy
  402.             && !$saveHandler instanceof \SessionHandlerInterface
  403.             && null !== $saveHandler
  404.         ) {
  405.             throw new \InvalidArgumentException('Must be instance of AbstractProxy; implement \SessionHandlerInterface; or be null.');
  406.         }
  407.         // Wrap $saveHandler in proxy and prevent double wrapping of proxy
  408.         if (!$saveHandler instanceof AbstractProxy && $saveHandler instanceof \SessionHandlerInterface) {
  409.             $saveHandler = new SessionHandlerProxy($saveHandler);
  410.         } elseif (!$saveHandler instanceof AbstractProxy) {
  411.             $saveHandler = new SessionHandlerProxy(new StrictSessionHandler(new \SessionHandler()));
  412.         }
  413.         $this->saveHandler $saveHandler;
  414.         if (headers_sent() || \PHP_SESSION_ACTIVE === session_status()) {
  415.             return;
  416.         }
  417.         if ($this->saveHandler instanceof SessionHandlerProxy) {
  418.             session_set_save_handler($this->saveHandlerfalse);
  419.         }
  420.     }
  421.     /**
  422.      * Load the session with attributes.
  423.      *
  424.      * After starting the session, PHP retrieves the session from whatever handlers
  425.      * are set to (either PHP's internal, or a custom save handler set with session_set_save_handler()).
  426.      * PHP takes the return value from the read() handler, unserializes it
  427.      * and populates $_SESSION with the result automatically.
  428.      */
  429.     protected function loadSession(array &$session null)
  430.     {
  431.         if (null === $session) {
  432.             $session = &$_SESSION;
  433.         }
  434.         $bags array_merge($this->bags, [$this->metadataBag]);
  435.         foreach ($bags as $bag) {
  436.             $key $bag->getStorageKey();
  437.             $session[$key] = isset($session[$key]) && \is_array($session[$key]) ? $session[$key] : [];
  438.             $bag->initialize($session[$key]);
  439.         }
  440.         $this->started true;
  441.         $this->closed false;
  442.     }
  443. }