vendor\symfony\http-kernel\EventListener\AbstractSessionListener.php line 60

  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.  * @internal
  40.  */
  41. abstract class AbstractSessionListener implements EventSubscriberInterface, ResetInterface
  42. {
  43.     public const NO_AUTO_CACHE_CONTROL_HEADER = 'Symfony-Session-NoAutoCacheControl';
  45.     protected $container;
  46.     private bool $debug;
  48.     /**
  49.      * @var array<string, mixed>
  50.      */
  51.     private $sessionOptions;
  53.     public function __construct(ContainerInterface $container = null, bool $debug = false, array $sessionOptions = [])
  54.     {
  55.         $this->container = $container;
  56.         $this->debug = $debug;
  57.         $this->sessionOptions = $sessionOptions;
  58.     }
  60.     public function onKernelRequest(RequestEvent $event)
  61.     {
  62.         if (!$event->isMainRequest()) {
  63.             return;
  64.         }
  66.         $request = $event->getRequest();
  67.         if (!$request->hasSession()) {
  68.             // This variable prevents calling `$this->getSession()` twice in case the Request (and the below factory) is cloned
  69.             $sess = null;
  70.             $request->setSessionFactory(function () use (&$sess, $request) {
  71.                 if (!$sess) {
  72.                     $sess = $this->getSession();
  73.                     $request->setSession($sess);
  75.                     /*
  76.                      * For supporting sessions in php runtime with runners like roadrunner or swoole, the session
  77.                      * cookie needs to be read from the cookie bag and set on the session storage.
  78.                      *
  79.                      * Do not set it when a native php session is active.
  80.                      */
  81.                     if ($sess && !$sess->isStarted() && \PHP_SESSION_ACTIVE !== session_status()) {
  82.                         $sessionId = $sess->getId() ?: $request->cookies->get($sess->getName(), '');
  83.                         $sess->setId($sessionId);
  84.                     }
  85.                 }
  87.                 return $sess;
  88.             });
  89.         }
  90.     }
  92.     public function onKernelResponse(ResponseEvent $event)
  93.     {
  94.         if (!$event->isMainRequest() || (!$this->container->has('initialized_session') && !$event->getRequest()->hasSession())) {
  95.             return;
  96.         }
  98.         $response = $event->getResponse();
  99.         $autoCacheControl = !$response->headers->has(self::NO_AUTO_CACHE_CONTROL_HEADER);
  100.         // Always remove the internal header if present
  101.         $response->headers->remove(self::NO_AUTO_CACHE_CONTROL_HEADER);
  102.         if (!$event->getRequest()->hasSession(true)) {
  103.             return;
  104.         }
  105.         $session = $event->getRequest()->getSession();
  107.         if ($session->isStarted()) {
  108.             /*
  109.              * Saves the session, in case it is still open, before sending the response/headers.
  110.              *
  111.              * This ensures several things in case the developer did not save the session explicitly:
  112.              *
  113.              *  * If a session save handler without locking is used, it ensures the data is available
  114.              *    on the next request, e.g. after a redirect. PHPs auto-save at script end via
  115.              *    session_register_shutdown is executed after fastcgi_finish_request. So in this case
  116.              *    the data could be missing the next request because it might not be saved the moment
  117.              *    the new request is processed.
  118.              *  * A locking save handler (e.g. the native 'files') circumvents concurrency problems like
  119.              *    the one above. But by saving the session before long-running things in the terminate event,
  120.              *    we ensure the session is not blocked longer than needed.
  121.              *  * When regenerating the session ID no locking is involved in PHPs session design. See
  122.              *    https://bugs.php.net/61470 for a discussion. So in this case, the session must
  123.              *    be saved anyway before sending the headers with the new session ID. Otherwise session
  124.              *    data could get lost again for concurrent requests with the new ID. One result could be
  125.              *    that you get logged out after just logging in.
  126.              *
  127.              * This listener should be executed as one of the last listeners, so that previous listeners
  128.              * can still operate on the open session. This prevents the overhead of restarting it.
  129.              * Listeners after closing the session can still work with the session as usual because
  130.              * Symfonys session implementation starts the session on demand. So writing to it after
  131.              * it is saved will just restart it.
  132.              */
  133.             $session->save();
  135.             /*
  136.              * For supporting sessions in php runtime with runners like roadrunner or swoole the session
  137.              * cookie need to be written on the response object and should not be written by PHP itself.
  138.              */
  139.             $sessionName = $session->getName();
  140.             $sessionId = $session->getId();
  141.             $sessionOptions = $this->getSessionOptions($this->sessionOptions);
  142.             $sessionCookiePath = $sessionOptions['cookie_path'] ?? '/';
  143.             $sessionCookieDomain = $sessionOptions['cookie_domain'] ?? null;
  144.             $sessionCookieSecure = $sessionOptions['cookie_secure'] ?? false;
  145.             $sessionCookieHttpOnly = $sessionOptions['cookie_httponly'] ?? true;
  146.             $sessionCookieSameSite = $sessionOptions['cookie_samesite'] ?? Cookie::SAMESITE_LAX;
  147.             $sessionUseCookies = $sessionOptions['use_cookies'] ?? true;
  149.             SessionUtils::popSessionCookie($sessionName, $sessionId);
  151.             if ($sessionUseCookies) {
  152.                 $request = $event->getRequest();
  153.                 $requestSessionCookieId = $request->cookies->get($sessionName);
  155.                 $isSessionEmpty = ($session instanceof Session ? $session->isEmpty() : !$session->all()) && empty($_SESSION); // checking $_SESSION to keep compatibility with native sessions
  156.                 if ($requestSessionCookieId && $isSessionEmpty) {
  157.                     // PHP internally sets the session cookie value to "deleted" when setcookie() is called with empty string $value argument
  158.                     // which happens in \Symfony\Component\HttpFoundation\Session\Storage\Handler\AbstractSessionHandler::destroy
  159.                     // when the session gets invalidated (for example on logout) so we must handle this case here too
  160.                     // otherwise we would send two Set-Cookie headers back with the response
  161.                     SessionUtils::popSessionCookie($sessionName, 'deleted');
  162.                     $response->headers->clearCookie(
  163.                         $sessionName,
  164.                         $sessionCookiePath,
  165.                         $sessionCookieDomain,
  166.                         $sessionCookieSecure,
  167.                         $sessionCookieHttpOnly,
  168.                         $sessionCookieSameSite
  169.                     );
  170.                 } elseif ($sessionId !== $requestSessionCookieId && !$isSessionEmpty) {
  171.                     $expire = 0;
  172.                     $lifetime = $sessionOptions['cookie_lifetime'] ?? null;
  173.                     if ($lifetime) {
  174.                         $expire = time() + $lifetime;
  175.                     }
  177.                     $response->headers->setCookie(
  178.                         Cookie::create(
  179.                             $sessionName,
  180.                             $sessionId,
  181.                             $expire,
  182.                             $sessionCookiePath,
  183.                             $sessionCookieDomain,
  184.                             $sessionCookieSecure,
  185.                             $sessionCookieHttpOnly,
  186.                             false,
  187.                             $sessionCookieSameSite
  188.                         )
  189.                     );
  190.                 }
  191.             }
  192.         }
  194.         if ($session instanceof Session ? 0 === $session->getUsageIndex() : !$session->isStarted()) {
  195.             return;
  196.         }
  198.         if ($autoCacheControl) {
  199.             $maxAge = $response->headers->hasCacheControlDirective('public') ? 0 : (int) $response->getMaxAge();
  200.             $response
  201.                 ->setExpires(new \DateTimeImmutable('+'.$maxAge.' seconds'))
  202.                 ->setPrivate()
  203.                 ->setMaxAge($maxAge)
  204.                 ->headers->addCacheControlDirective('must-revalidate');
  205.         }
  207.         if (!$event->getRequest()->attributes->get('_stateless', false)) {
  208.             return;
  209.         }
  211.         if ($this->debug) {
  212.             throw new UnexpectedSessionUsageException('Session was used while the request was declared stateless.');
  213.         }
  215.         if ($this->container->has('logger')) {
  216.             $this->container->get('logger')->warning('Session was used while the request was declared stateless.');
  217.         }
  218.     }
  220.     public function onSessionUsage(): void
  221.     {
  222.         if (!$this->debug) {
  223.             return;
  224.         }
  226.         if ($this->container?->has('session_collector')) {
  227.             $this->container->get('session_collector')();
  228.         }
  230.         if (!$requestStack = $this->container?->has('request_stack') ? $this->container->get('request_stack') : null) {
  231.             return;
  232.         }
  234.         $stateless = false;
  235.         $clonedRequestStack = clone $requestStack;
  236.         while (null !== ($request = $clonedRequestStack->pop()) && !$stateless) {
  237.             $stateless = $request->attributes->get('_stateless');
  238.         }
  240.         if (!$stateless) {
  241.             return;
  242.         }
  244.         if (!$session = $requestStack->getCurrentRequest()->getSession()) {
  245.             return;
  246.         }
  248.         if ($session->isStarted()) {
  249.             $session->save();
  250.         }
  252.         throw new UnexpectedSessionUsageException('Session was used while the request was declared stateless.');
  253.     }
  255.     public static function getSubscribedEvents(): array
  256.     {
  257.         return [
  258.             KernelEvents::REQUEST => ['onKernelRequest', 128],
  259.             // low priority to come after regular response listeners
  260.             KernelEvents::RESPONSE => ['onKernelResponse', -1000],
  261.         ];
  262.     }
  264.     public function reset(): void
  265.     {
  266.         if (\PHP_SESSION_ACTIVE === session_status()) {
  267.             session_abort();
  268.         }
  270.         session_unset();
  271.         $_SESSION = [];
  273.         if (!headers_sent()) { // session id can only be reset when no headers were so we check for headers_sent first
  274.             session_id('');
  275.         }
  276.     }
  278.     /**
  279.      * Gets the session object.
  280.      */
  281.     abstract protected function getSession(): ?SessionInterface;
  283.     private function getSessionOptions(array $sessionOptions): array
  284.     {
  285.         $mergedSessionOptions = [];
  287.         foreach (session_get_cookie_params() as $key => $value) {
  288.             $mergedSessionOptions['cookie_'.$key] = $value;
  289.         }
  291.         foreach ($sessionOptions as $key => $value) {
  292.             // do the same logic as in the NativeSessionStorage
  293.             if ('cookie_secure' === $key && 'auto' === $value) {
  294.                 continue;
  295.             }
  296.             $mergedSessionOptions[$key] = $value;
  297.         }
  299.         return $mergedSessionOptions;
  300.     }
  301. }