vendor/symfony/http-kernel/EventListener/AbstractSessionListener.php line 211

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <[email protected]>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Symfony\Component\HttpKernel\EventListener;
  14. use Psr\Container\ContainerInterface;
  15. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  16. use Symfony\Component\HttpFoundation\Cookie;
  17. use Symfony\Component\HttpFoundation\Session\Session;
  18. use Symfony\Component\HttpFoundation\Session\SessionInterface;
  19. use Symfony\Component\HttpFoundation\Session\SessionUtils;
  20. use Symfony\Component\HttpKernel\Event\FinishRequestEvent;
  21. use Symfony\Component\HttpKernel\Event\RequestEvent;
  22. use Symfony\Component\HttpKernel\Event\ResponseEvent;
  23. use Symfony\Component\HttpKernel\Exception\UnexpectedSessionUsageException;
  24. use Symfony\Component\HttpKernel\KernelEvents;
  25. use Symfony\Contracts\Service\ResetInterface;
  27. /**
  28.  * Sets the session onto the request on the "kernel.request" event and saves
  29.  * it on the "kernel.response" event.
  30.  *
  31.  * In addition, if the session has been started it overrides the Cache-Control
  32.  * header in such a way that all caching is disabled in that case.
  33.  * If you have a scenario where caching responses with session information in
  34.  * them makes sense, you can disable this behaviour by setting the header
  35.  * AbstractSessionListener::NO_AUTO_CACHE_CONTROL_HEADER on the response.
  36.  *
  37.  * @author Johannes M. Schmitt <[email protected]>
  38.  * @author Tobias Schultze <http://tobion.de>
  39.  *
  40.  * @internal
  41.  */
  42. abstract class AbstractSessionListener implements EventSubscriberInterface, ResetInterface
  43. {
  44.     public const NO_AUTO_CACHE_CONTROL_HEADER = 'Symfony-Session-NoAutoCacheControl';
  46.     protected $container;
  47.     private $sessionUsageStack = [];
  48.     private $debug;
  50.     /**
  51.      * @var array<string, mixed>
  52.      */
  53.     private $sessionOptions;
  55.     public function __construct(ContainerInterface $container = null, bool $debug = false, array $sessionOptions = [])
  56.     {
  57.         $this->container = $container;
  58.         $this->debug = $debug;
  59.         $this->sessionOptions = $sessionOptions;
  60.     }
  62.     public function onKernelRequest(RequestEvent $event)
  63.     {
  64.         if (!$event->isMainRequest()) {
  65.             return;
  66.         }
  68.         $request = $event->getRequest();
  69.         if (!$request->hasSession()) {
  70.             // This variable prevents calling `$this->getSession()` twice in case the Request (and the below factory) is cloned
  71.             $sess = null;
  72.             $request->setSessionFactory(function () use (&$sess, $request) {
  73.                 if (!$sess) {
  74.                     $sess = $this->getSession();
  75.                 }
  77.                 /*
  78.                  * For supporting sessions in php runtime with runners like roadrunner or swoole the session
  79.                  * cookie need read from the cookie bag and set on the session storage.
  80.                  */
  81.                 if ($sess && !$sess->isStarted()) {
  82.                     $sessionId = $request->cookies->get($sess->getName(), '');
  83.                     $sess->setId($sessionId);
  84.                 }
  86.                 return $sess;
  87.             });
  88.         }
  90.         $session = $this->container && $this->container->has('initialized_session') ? $this->container->get('initialized_session') : null;
  91.         $this->sessionUsageStack[] = $session instanceof Session ? $session->getUsageIndex() : 0;
  92.     }
  94.     public function onKernelResponse(ResponseEvent $event)
  95.     {
  96.         if (!$event->isMainRequest()) {
  97.             return;
  98.         }
  100.         $response = $event->getResponse();
  101.         $autoCacheControl = !$response->headers->has(self::NO_AUTO_CACHE_CONTROL_HEADER);
  102.         // Always remove the internal header if present
  103.         $response->headers->remove(self::NO_AUTO_CACHE_CONTROL_HEADER);
  105.         if (!$session = $this->container && $this->container->has('initialized_session') ? $this->container->get('initialized_session') : $event->getRequest()->getSession()) {
  106.             return;
  107.         }
  109.         if ($session->isStarted()) {
  110.             /*
  111.              * Saves the session, in case it is still open, before sending the response/headers.
  112.              *
  113.              * This ensures several things in case the developer did not save the session explicitly:
  114.              *
  115.              *  * If a session save handler without locking is used, it ensures the data is available
  116.              *    on the next request, e.g. after a redirect. PHPs auto-save at script end via
  117.              *    session_register_shutdown is executed after fastcgi_finish_request. So in this case
  118.              *    the data could be missing the next request because it might not be saved the moment
  119.              *    the new request is processed.
  120.              *  * A locking save handler (e.g. the native 'files') circumvents concurrency problems like
  121.              *    the one above. But by saving the session before long-running things in the terminate event,
  122.              *    we ensure the session is not blocked longer than needed.
  123.              *  * When regenerating the session ID no locking is involved in PHPs session design. See
  124.              *    https://bugs.php.net/61470 for a discussion. So in this case, the session must
  125.              *    be saved anyway before sending the headers with the new session ID. Otherwise session
  126.              *    data could get lost again for concurrent requests with the new ID. One result could be
  127.              *    that you get logged out after just logging in.
  128.              *
  129.              * This listener should be executed as one of the last listeners, so that previous listeners
  130.              * can still operate on the open session. This prevents the overhead of restarting it.
  131.              * Listeners after closing the session can still work with the session as usual because
  132.              * Symfonys session implementation starts the session on demand. So writing to it after
  133.              * it is saved will just restart it.
  134.              */
  135.             $session->save();
  137.             /*
  138.              * For supporting sessions in php runtime with runners like roadrunner or swoole the session
  139.              * cookie need to be written on the response object and should not be written by PHP itself.
  140.              */
  141.             $sessionName = $session->getName();
  142.             $sessionId = $session->getId();
  143.             $sessionCookiePath = $this->sessionOptions['cookie_path'] ?? '/';
  144.             $sessionCookieDomain = $this->sessionOptions['cookie_domain'] ?? null;
  145.             $sessionCookieSecure = $this->sessionOptions['cookie_secure'] ?? false;
  146.             $sessionCookieHttpOnly = $this->sessionOptions['cookie_httponly'] ?? true;
  147.             $sessionCookieSameSite = $this->sessionOptions['cookie_samesite'] ?? Cookie::SAMESITE_LAX;
  149.             SessionUtils::popSessionCookie($sessionName, $sessionCookiePath);
  151.             $request = $event->getRequest();
  152.             $requestSessionCookieId = $request->cookies->get($sessionName);
  154.             if ($requestSessionCookieId && $session->isEmpty()) {
  155.                 $response->headers->clearCookie(
  156.                     $sessionName,
  157.                     $sessionCookiePath,
  158.                     $sessionCookieDomain,
  159.                     $sessionCookieSecure,
  160.                     $sessionCookieHttpOnly,
  161.                     $sessionCookieSameSite
  162.                 );
  163.             } elseif ($sessionId !== $requestSessionCookieId) {
  164.                 $expire = 0;
  165.                 $lifetime = $this->sessionOptions['cookie_lifetime'] ?? null;
  166.                 if ($lifetime) {
  167.                     $expire = time() + $lifetime;
  168.                 }
  170.                 $response->headers->setCookie(
  171.                     Cookie::create(
  172.                         $sessionName,
  173.                         $sessionId,
  174.                         $expire,
  175.                         $sessionCookiePath,
  176.                         $sessionCookieDomain,
  177.                         $sessionCookieSecure,
  178.                         $sessionCookieHttpOnly,
  179.                         false,
  180.                         $sessionCookieSameSite
  181.                     )
  182.                 );
  183.             }
  184.         }
  186.         if ($session instanceof Session ? $session->getUsageIndex() === end($this->sessionUsageStack) : !$session->isStarted()) {
  187.             return;
  188.         }
  190.         if ($autoCacheControl) {
  191.             $response
  192.                 ->setExpires(new \DateTime())
  193.                 ->setPrivate()
  194.                 ->setMaxAge(0)
  195.                 ->headers->addCacheControlDirective('must-revalidate');
  196.         }
  198.         if (!$event->getRequest()->attributes->get('_stateless', false)) {
  199.             return;
  200.         }
  202.         if ($this->debug) {
  203.             throw new UnexpectedSessionUsageException('Session was used while the request was declared stateless.');
  204.         }
  206.         if ($this->container->has('logger')) {
  207.             $this->container->get('logger')->warning('Session was used while the request was declared stateless.');
  208.         }
  209.     }
  211.     public function onFinishRequest(FinishRequestEvent $event)
  212.     {
  213.         if ($event->isMainRequest()) {
  214.             array_pop($this->sessionUsageStack);
  215.         }
  216.     }
  218.     public function onSessionUsage(): void
  219.     {
  220.         if (!$this->debug) {
  221.             return;
  222.         }
  224.         if ($this->container && $this->container->has('session_collector')) {
  225.             $this->container->get('session_collector')();
  226.         }
  228.         if (!$requestStack = $this->container && $this->container->has('request_stack') ? $this->container->get('request_stack') : null) {
  229.             return;
  230.         }
  232.         $stateless = false;
  233.         $clonedRequestStack = clone $requestStack;
  234.         while (null !== ($request = $clonedRequestStack->pop()) && !$stateless) {
  235.             $stateless = $request->attributes->get('_stateless');
  236.         }
  238.         if (!$stateless) {
  239.             return;
  240.         }
  242.         if (!$session = $this->container && $this->container->has('initialized_session') ? $this->container->get('initialized_session') : $requestStack->getCurrentRequest()->getSession()) {
  243.             return;
  244.         }
  246.         if ($session->isStarted()) {
  247.             $session->save();
  248.         }
  250.         throw new UnexpectedSessionUsageException('Session was used while the request was declared stateless.');
  251.     }
  253.     public static function getSubscribedEvents(): array
  254.     {
  255.         return [
  256.             KernelEvents::REQUEST => ['onKernelRequest', 128],
  257.             // low priority to come after regular response listeners, but higher than StreamedResponseListener
  258.             KernelEvents::RESPONSE => ['onKernelResponse', -1000],
  259.             KernelEvents::FINISH_REQUEST => ['onFinishRequest'],
  260.         ];
  261.     }
  263.     public function reset(): void
  264.     {
  265.         if (\PHP_SESSION_ACTIVE === session_status()) {
  266.             session_abort();
  267.         }
  269.         session_unset();
  270.         $_SESSION = [];
  272.         if (!headers_sent()) { // session id can only be reset when no headers were so we check for headers_sent first
  273.             session_id('');
  274.         }
  275.     }
  277.     /**
  278.      * Gets the session object.
  279.      *
  280.      * @return SessionInterface|null
  281.      */
  282.     abstract protected function getSession();
  283. }