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

Open in your IDE?
  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\Session\Session;
  17. use Symfony\Component\HttpFoundation\Session\SessionInterface;
  18. use Symfony\Component\HttpKernel\Event\FinishRequestEvent;
  19. use Symfony\Component\HttpKernel\Event\RequestEvent;
  20. use Symfony\Component\HttpKernel\Event\ResponseEvent;
  21. use Symfony\Component\HttpKernel\Exception\UnexpectedSessionUsageException;
  22. use Symfony\Component\HttpKernel\KernelEvents;
  24. /**
  25.  * Sets the session onto the request on the "kernel.request" event and saves
  26.  * it on the "kernel.response" event.
  27.  *
  28.  * In addition, if the session has been started it overrides the Cache-Control
  29.  * header in such a way that all caching is disabled in that case.
  30.  * If you have a scenario where caching responses with session information in
  31.  * them makes sense, you can disable this behaviour by setting the header
  32.  * AbstractSessionListener::NO_AUTO_CACHE_CONTROL_HEADER on the response.
  33.  *
  34.  * @author Johannes M. Schmitt <schmittjoh@gmail.com>
  35.  * @author Tobias Schultze <http://tobion.de>
  36.  *
  37.  * @internal
  38.  */
  39. abstract class AbstractSessionListener implements EventSubscriberInterface
  40. {
  41.     const NO_AUTO_CACHE_CONTROL_HEADER = 'Symfony-Session-NoAutoCacheControl';
  43.     protected $container;
  44.     private $sessionUsageStack = [];
  45.     private $debug;
  47.     public function __construct(ContainerInterface $container = null, bool $debug = false)
  48.     {
  49.         $this->container = $container;
  50.         $this->debug = $debug;
  51.     }
  53.     public function onKernelRequest(RequestEvent $event)
  54.     {
  55.         if (!$event->isMasterRequest()) {
  56.             return;
  57.         }
  59.         $session = null;
  60.         $request = $event->getRequest();
  61.         if ($request->hasSession()) {
  62.             // no-op
  63.         } elseif (method_exists($request, 'setSessionFactory')) {
  64.             $request->setSessionFactory(function () { return $this->getSession(); });
  65.         } elseif ($session = $this->getSession()) {
  66.             $request->setSession($session);
  67.         }
  69.         $session = $session ?? ($this->container && $this->container->has('initialized_session') ? $this->container->get('initialized_session') : null);
  70.         $this->sessionUsageStack[] = $session instanceof Session ? $session->getUsageIndex() : 0;
  71.     }
  73.     public function onKernelResponse(ResponseEvent $event)
  74.     {
  75.         if (!$event->isMasterRequest()) {
  76.             return;
  77.         }
  79.         $response = $event->getResponse();
  80.         $autoCacheControl = !$response->headers->has(self::NO_AUTO_CACHE_CONTROL_HEADER);
  81.         // Always remove the internal header if present
  82.         $response->headers->remove(self::NO_AUTO_CACHE_CONTROL_HEADER);
  84.         if (!$session = $this->container && $this->container->has('initialized_session') ? $this->container->get('initialized_session') : $event->getRequest()->getSession()) {
  85.             return;
  86.         }
  88.         if ($session->isStarted()) {
  89.             /*
  90.              * Saves the session, in case it is still open, before sending the response/headers.
  91.              *
  92.              * This ensures several things in case the developer did not save the session explicitly:
  93.              *
  94.              *  * If a session save handler without locking is used, it ensures the data is available
  95.              *    on the next request, e.g. after a redirect. PHPs auto-save at script end via
  96.              *    session_register_shutdown is executed after fastcgi_finish_request. So in this case
  97.              *    the data could be missing the next request because it might not be saved the moment
  98.              *    the new request is processed.
  99.              *  * A locking save handler (e.g. the native 'files') circumvents concurrency problems like
  100.              *    the one above. But by saving the session before long-running things in the terminate event,
  101.              *    we ensure the session is not blocked longer than needed.
  102.              *  * When regenerating the session ID no locking is involved in PHPs session design. See
  103.              *    https://bugs.php.net/61470 for a discussion. So in this case, the session must
  104.              *    be saved anyway before sending the headers with the new session ID. Otherwise session
  105.              *    data could get lost again for concurrent requests with the new ID. One result could be
  106.              *    that you get logged out after just logging in.
  107.              *
  108.              * This listener should be executed as one of the last listeners, so that previous listeners
  109.              * can still operate on the open session. This prevents the overhead of restarting it.
  110.              * Listeners after closing the session can still work with the session as usual because
  111.              * Symfonys session implementation starts the session on demand. So writing to it after
  112.              * it is saved will just restart it.
  113.              */
  114.             $session->save();
  115.         }
  117.         if ($session instanceof Session ? $session->getUsageIndex() === end($this->sessionUsageStack) : !$session->isStarted()) {
  118.             return;
  119.         }
  121.         if ($autoCacheControl) {
  122.             $response
  123.                 ->setExpires(new \DateTime())
  124.                 ->setPrivate()
  125.                 ->setMaxAge(0)
  126.                 ->headers->addCacheControlDirective('must-revalidate');
  127.         }
  129.         if (!$event->getRequest()->attributes->get('_stateless', false)) {
  130.             return;
  131.         }
  133.         if ($this->debug) {
  134.             throw new UnexpectedSessionUsageException('Session was used while the request was declared stateless.');
  135.         }
  137.         if ($this->container->has('logger')) {
  138.             $this->container->get('logger')->warning('Session was used while the request was declared stateless.');
  139.         }
  140.     }
  142.     public function onFinishRequest(FinishRequestEvent $event)
  143.     {
  144.         if ($event->isMasterRequest()) {
  145.             array_pop($this->sessionUsageStack);
  146.         }
  147.     }
  149.     public function onSessionUsage(): void
  150.     {
  151.         if (!$this->debug) {
  152.             return;
  153.         }
  155.         if (!$requestStack = $this->container && $this->container->has('request_stack') ? $this->container->get('request_stack') : null) {
  156.             return;
  157.         }
  159.         $stateless = false;
  160.         $clonedRequestStack = clone $requestStack;
  161.         while (null !== ($request = $clonedRequestStack->pop()) && !$stateless) {
  162.             $stateless = $request->attributes->get('_stateless');
  163.         }
  165.         if (!$stateless) {
  166.             return;
  167.         }
  169.         if (!$session = $this->container && $this->container->has('initialized_session') ? $this->container->get('initialized_session') : $requestStack->getCurrentRequest()->getSession()) {
  170.             return;
  171.         }
  173.         if ($session->isStarted()) {
  174.             $session->save();
  175.         }
  177.         throw new UnexpectedSessionUsageException('Session was used while the request was declared stateless.');
  178.     }
  180.     public static function getSubscribedEvents(): array
  181.     {
  182.         return [
  183.             KernelEvents::REQUEST => ['onKernelRequest', 128],
  184.             // low priority to come after regular response listeners, but higher than StreamedResponseListener
  185.             KernelEvents::RESPONSE => ['onKernelResponse', -1000],
  186.             KernelEvents::FINISH_REQUEST => ['onFinishRequest'],
  187.         ];
  188.     }
  190.     /**
  191.      * Gets the session object.
  192.      *
  193.      * @return SessionInterface|null A SessionInterface instance or null if no session is available
  194.      */
  195.     abstract protected function getSession();
  196. }