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

  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <fabien@symfony.com>
  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\RequestEvent;
  21. use Symfony\Component\HttpKernel\Event\ResponseEvent;
  22. use Symfony\Component\HttpKernel\Exception\UnexpectedSessionUsageException;
  23. use Symfony\Component\HttpKernel\KernelEvents;
  24. use Symfony\Contracts\Service\ResetInterface;
  26. /**
  27.  * Sets the session onto the request on the "kernel.request" event and saves
  28.  * it on the "kernel.response" event.
  29.  *
  30.  * In addition, if the session has been started it overrides the Cache-Control
  31.  * header in such a way that all caching is disabled in that case.
  32.  * If you have a scenario where caching responses with session information in
  33.  * them makes sense, you can disable this behaviour by setting the header
  34.  * AbstractSessionListener::NO_AUTO_CACHE_CONTROL_HEADER on the response.
  35.  *
  36.  * @author Johannes M. Schmitt <schmittjoh@gmail.com>
  37.  * @author Tobias Schultze <http://tobion.de>
  38.  */
  39. abstract class AbstractSessionListener implements EventSubscriberInterface, ResetInterface
  40. {
  41.     public const NO_AUTO_CACHE_CONTROL_HEADER = 'Symfony-Session-NoAutoCacheControl';
  43.     /**
  44.      * @internal
  45.      */
  46.     protected ?ContainerInterface $container;
  48.     private bool $debug;
  50.     /**
  51.      * @var array<string, mixed>
  52.      */
  53.     private array $sessionOptions;
  55.     /**
  56.      * @internal
  57.      */
  58.     public function __construct(?ContainerInterface $container = null, bool $debug = false, array $sessionOptions = [])
  59.     {
  60.         $this->container = $container;
  61.         $this->debug = $debug;
  62.         $this->sessionOptions = $sessionOptions;
  63.     }
  65.     /**
  66.      * @internal
  67.      */
  68.     public function onKernelRequest(RequestEvent $event): void
  69.     {
  70.         if (!$event->isMainRequest()) {
  71.             return;
  72.         }
  74.         $request = $event->getRequest();
  75.         if (!$request->hasSession()) {
  76.             $request->setSessionFactory(function () use ($request) {
  77.                 // Prevent calling `$this->getSession()` twice in case the Request (and the below factory) is cloned
  78.                 static $sess;
  80.                 if (!$sess) {
  81.                     $sess = $this->getSession();
  82.                     $request->setSession($sess);
  84.                     /*
  85.                      * For supporting sessions in php runtime with runners like roadrunner or swoole, the session
  86.                      * cookie needs to be read from the cookie bag and set on the session storage.
  87.                      *
  88.                      * Do not set it when a native php session is active.
  89.                      */
  90.                     if ($sess && !$sess->isStarted() && \PHP_SESSION_ACTIVE !== session_status()) {
  91.                         $sessionId = $sess->getId() ?: $request->cookies->get($sess->getName(), '');
  92.                         $sess->setId($sessionId);
  93.                     }
  94.                 }
  96.                 return $sess;
  97.             });
  98.         }
  99.     }
  101.     /**
  102.      * @internal
  103.      */
  104.     public function onKernelResponse(ResponseEvent $event): void
  105.     {
  106.         if (!$event->isMainRequest() || (!$this->container->has('initialized_session') && !$event->getRequest()->hasSession())) {
  107.             return;
  108.         }
  110.         $response = $event->getResponse();
  111.         $autoCacheControl = !$response->headers->has(self::NO_AUTO_CACHE_CONTROL_HEADER);
  112.         // Always remove the internal header if present
  113.         $response->headers->remove(self::NO_AUTO_CACHE_CONTROL_HEADER);
  114.         if (!$event->getRequest()->hasSession(true)) {
  115.             return;
  116.         }
  117.         $session = $event->getRequest()->getSession();
  119.         if ($session->isStarted()) {
  120.             /*
  121.              * Saves the session, in case it is still open, before sending the response/headers.
  122.              *
  123.              * This ensures several things in case the developer did not save the session explicitly:
  124.              *
  125.              *  * If a session save handler without locking is used, it ensures the data is available
  126.              *    on the next request, e.g. after a redirect. PHPs auto-save at script end via
  127.              *    session_register_shutdown is executed after fastcgi_finish_request. So in this case
  128.              *    the data could be missing the next request because it might not be saved the moment
  129.              *    the new request is processed.
  130.              *  * A locking save handler (e.g. the native 'files') circumvents concurrency problems like
  131.              *    the one above. But by saving the session before long-running things in the terminate event,
  132.              *    we ensure the session is not blocked longer than needed.
  133.              *  * When regenerating the session ID no locking is involved in PHPs session design. See
  134.              *    https://bugs.php.net/61470 for a discussion. So in this case, the session must
  135.              *    be saved anyway before sending the headers with the new session ID. Otherwise session
  136.              *    data could get lost again for concurrent requests with the new ID. One result could be
  137.              *    that you get logged out after just logging in.
  138.              *
  139.              * This listener should be executed as one of the last listeners, so that previous listeners
  140.              * can still operate on the open session. This prevents the overhead of restarting it.
  141.              * Listeners after closing the session can still work with the session as usual because
  142.              * Symfonys session implementation starts the session on demand. So writing to it after
  143.              * it is saved will just restart it.
  144.              */
  145.             $session->save();
  147.             /*
  148.              * For supporting sessions in php runtime with runners like roadrunner or swoole the session
  149.              * cookie need to be written on the response object and should not be written by PHP itself.
  150.              */
  151.             $sessionName = $session->getName();
  152.             $sessionId = $session->getId();
  153.             $sessionOptions = $this->getSessionOptions($this->sessionOptions);
  154.             $sessionCookiePath = $sessionOptions['cookie_path'] ?? '/';
  155.             $sessionCookieDomain = $sessionOptions['cookie_domain'] ?? null;
  156.             $sessionCookieSecure = $sessionOptions['cookie_secure'] ?? false;
  157.             $sessionCookieHttpOnly = $sessionOptions['cookie_httponly'] ?? true;
  158.             $sessionCookieSameSite = $sessionOptions['cookie_samesite'] ?? Cookie::SAMESITE_LAX;
  159.             $sessionUseCookies = $sessionOptions['use_cookies'] ?? true;
  161.             SessionUtils::popSessionCookie($sessionName, $sessionId);
  163.             if ($sessionUseCookies) {
  164.                 $request = $event->getRequest();
  165.                 $requestSessionCookieId = $request->cookies->get($sessionName);
  167.                 $isSessionEmpty = ($session instanceof Session ? $session->isEmpty() : !$session->all()) && empty($_SESSION); // checking $_SESSION to keep compatibility with native sessions
  168.                 if ($requestSessionCookieId && $isSessionEmpty) {
  169.                     // PHP internally sets the session cookie value to "deleted" when setcookie() is called with empty string $value argument
  170.                     // which happens in \Symfony\Component\HttpFoundation\Session\Storage\Handler\AbstractSessionHandler::destroy
  171.                     // when the session gets invalidated (for example on logout) so we must handle this case here too
  172.                     // otherwise we would send two Set-Cookie headers back with the response
  173.                     SessionUtils::popSessionCookie($sessionName, 'deleted');
  174.                     $response->headers->clearCookie(
  175.                         $sessionName,
  176.                         $sessionCookiePath,
  177.                         $sessionCookieDomain,
  178.                         $sessionCookieSecure,
  179.                         $sessionCookieHttpOnly,
  180.                         $sessionCookieSameSite
  181.                     );
  182.                 } elseif ($sessionId !== $requestSessionCookieId && !$isSessionEmpty) {
  183.                     $expire = 0;
  184.                     $lifetime = $sessionOptions['cookie_lifetime'] ?? null;
  185.                     if ($lifetime) {
  186.                         $expire = time() + $lifetime;
  187.                     }
  189.                     $response->headers->setCookie(
  190.                         Cookie::create(
  191.                             $sessionName,
  192.                             $sessionId,
  193.                             $expire,
  194.                             $sessionCookiePath,
  195.                             $sessionCookieDomain,
  196.                             $sessionCookieSecure,
  197.                             $sessionCookieHttpOnly,
  198.                             false,
  199.                             $sessionCookieSameSite
  200.                         )
  201.                     );
  202.                 }
  203.             }
  204.         }
  206.         if ($session instanceof Session ? 0 === $session->getUsageIndex() : !$session->isStarted()) {
  207.             return;
  208.         }
  210.         if ($autoCacheControl) {
  211.             $maxAge = $response->headers->hasCacheControlDirective('public') ? 0 : (int) $response->getMaxAge();
  212.             $response
  213.                 ->setExpires(new \DateTimeImmutable('+'.$maxAge.' seconds'))
  214.                 ->setPrivate()
  215.                 ->setMaxAge($maxAge)
  216.                 ->headers->addCacheControlDirective('must-revalidate');
  217.         }
  219.         if (!$event->getRequest()->attributes->get('_stateless', false)) {
  220.             return;
  221.         }
  223.         if ($this->debug) {
  224.             throw new UnexpectedSessionUsageException('Session was used while the request was declared stateless.');
  225.         }
  227.         if ($this->container->has('logger')) {
  228.             $this->container->get('logger')->warning('Session was used while the request was declared stateless.');
  229.         }
  230.     }
  232.     /**
  233.      * @internal
  234.      */
  235.     public function onSessionUsage(): void
  236.     {
  237.         if (!$this->debug) {
  238.             return;
  239.         }
  241.         if ($this->container?->has('session_collector')) {
  242.             $this->container->get('session_collector')();
  243.         }
  245.         if (!$requestStack = $this->container?->has('request_stack') ? $this->container->get('request_stack') : null) {
  246.             return;
  247.         }
  249.         $stateless = false;
  250.         $clonedRequestStack = clone $requestStack;
  251.         while (null !== ($request = $clonedRequestStack->pop()) && !$stateless) {
  252.             $stateless = $request->attributes->get('_stateless');
  253.         }
  255.         if (!$stateless) {
  256.             return;
  257.         }
  259.         if (!$session = $requestStack->getCurrentRequest()->getSession()) {
  260.             return;
  261.         }
  263.         if ($session->isStarted()) {
  264.             $session->save();
  265.         }
  267.         throw new UnexpectedSessionUsageException('Session was used while the request was declared stateless.');
  268.     }
  270.     /**
  271.      * @internal
  272.      */
  273.     public static function getSubscribedEvents(): array
  274.     {
  275.         return [
  276.             KernelEvents::REQUEST => ['onKernelRequest', 128],
  277.             // low priority to come after regular response listeners
  278.             KernelEvents::RESPONSE => ['onKernelResponse', -1000],
  279.         ];
  280.     }
  282.     /**
  283.      * @internal
  284.      */
  285.     public function reset(): void
  286.     {
  287.         if (\PHP_SESSION_ACTIVE === session_status()) {
  288.             session_abort();
  289.         }
  291.         session_unset();
  292.         $_SESSION = [];
  294.         if (!headers_sent()) { // session id can only be reset when no headers were so we check for headers_sent first
  295.             session_id('');
  296.         }
  297.     }
  299.     /**
  300.      * Gets the session object.
  301.      *
  302.      * @internal
  303.      */
  304.     abstract protected function getSession(): ?SessionInterface;
  306.     private function getSessionOptions(array $sessionOptions): array
  307.     {
  308.         $mergedSessionOptions = [];
  310.         foreach (session_get_cookie_params() as $key => $value) {
  311.             $mergedSessionOptions['cookie_'.$key] = $value;
  312.         }
  314.         foreach ($sessionOptions as $key => $value) {
  315.             // do the same logic as in the NativeSessionStorage
  316.             if ('cookie_secure' === $key && 'auto' === $value) {
  317.                 continue;
  318.             }
  319.             $mergedSessionOptions[$key] = $value;
  320.         }
  322.         return $mergedSessionOptions;
  323.     }
  324. }