Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified	Actions
📁 ..	-	2025-05-25 12:37
📁 Handler	-	2025-05-25 12:37
📄 MetadataBag.php <?php /* * This file is part of the Symfony package. * * (c) Fabien Potencier <fabien@symfony.com> * * 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; use Symfony\Component\HttpFoundation\Session\SessionBagInterface; /* * Metadata container. * * Adds metadata to the session. * * @author Drak <drak@zikula.org> / class MetadataBag implements SessionBagInterface { const CREATED = 'c'; const UPDATED = 'u'; const LIFETIME = 'l'; /* * @var string / private $name = '__metadata'; /* * @var string / private $storageKey; /* * @var array / protected $meta = array(self::CREATED => 0, self::UPDATED => 0, self::LIFETIME => 0); /* * Unix timestamp. * * @var integer / private $lastUsed; /* * @var integer / private $updateThreshold; /* * Constructor. * * @param string $storageKey The key used to store bag in the session. * @param integer $updateThreshold The time to wait between two UPDATED updates / public function __construct($storageKey = '_sf2_meta', $updateThreshold = 0) { $this->storageKey = $storageKey; $this->updateThreshold = $updateThreshold; } /* * {@inheritdoc} / public function initialize(array &$array) { $this->meta = &$array; if (isset($array[self::CREATED])) { $this->lastUsed = $this->meta[self::UPDATED]; $timeStamp = time(); if ($timeStamp - $array[self::UPDATED] >= $this->updateThreshold) { $this->meta[self::UPDATED] = $timeStamp; } } else { $this->stampCreated(); } } /* * Gets the lifetime that the session cookie was set with. * * @return integer / public function getLifetime() { return $this->meta[self::LIFETIME]; } /* * Stamps a new session's metadata. * * @param integer $lifetime Sets the cookie lifetime for the session cookie. A null value * will leave the system settings unchanged, 0 sets the cookie * to expire with browser session. Time is in seconds, and is * not a Unix timestamp. / public function stampNew($lifetime = null) { $this->stampCreated($lifetime); } /* * {@inheritdoc} / public function getStorageKey() { return $this->storageKey; } /* * Gets the created timestamp metadata. * * @return integer Unix timestamp / public function getCreated() { return $this->meta[self::CREATED]; } /* * Gets the last used metadata. * * @return integer Unix timestamp / public function getLastUsed() { return $this->lastUsed; } /* * {@inheritdoc} / public function clear() { // nothing to do } /* * {@inheritdoc} / public function getName() { return $this->name; } /* * Sets name. * * @param string $name */ public function setName($name) { $this->name = $name; } private function stampCreated($lifetime = null) { $timeStamp = time(); $this->meta[self::CREATED] = $this->meta[self::UPDATED] = $this->lastUsed = $timeStamp; $this->meta[self::LIFETIME] = (null === $lifetime) ? ini_get('session.cookie_lifetime') : $lifetime; } }	3.63 KB	2024-07-17 10:22
📄 MockArraySessionStorage.php <?php /* * This file is part of the Symfony package. * * (c) Fabien Potencier <fabien@symfony.com> * * 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; use Symfony\Component\HttpFoundation\Session\SessionBagInterface; /* * MockArraySessionStorage mocks the session for unit tests. * * No PHP session is actually started since a session can be initialized * and shutdown only once per PHP execution cycle. * * When doing functional testing, you should use MockFileSessionStorage instead. * * @author Fabien Potencier <fabien@symfony.com> * @author Bulat Shakirzyanov <mallluhuct@gmail.com> * @author Drak <drak@zikula.org> / class MockArraySessionStorage implements SessionStorageInterface { /* * @var string / protected $id = ''; /* * @var string / protected $name; /* * @var boolean / protected $started = false; /* * @var boolean / protected $closed = false; /* * @var array / protected $data = array(); /* * @var MetadataBag / protected $metadataBag; /* * @var array / protected $bags; /* * Constructor. * * @param string $name Session name * @param MetadataBag $metaBag MetadataBag instance. / public function __construct($name = 'MOCKSESSID', MetadataBag $metaBag = null) { $this->name = $name; $this->setMetadataBag($metaBag); } /* * Sets the session data. * * @param array $array / public function setSessionData(array $array) { $this->data = $array; } /* * {@inheritdoc} / public function start() { if ($this->started && !$this->closed) { return true; } if (empty($this->id)) { $this->id = $this->generateId(); } $this->loadSession(); return true; } /* * {@inheritdoc} / public function regenerate($destroy = false, $lifetime = null) { if (!$this->started) { $this->start(); } $this->metadataBag->stampNew($lifetime); $this->id = $this->generateId(); return true; } /* * {@inheritdoc} / public function getId() { return $this->id; } /* * {@inheritdoc} / public function setId($id) { if ($this->started) { throw new \LogicException('Cannot set session ID after the session has started.'); } $this->id = $id; } /* * {@inheritdoc} / public function getName() { return $this->name; } /* * {@inheritdoc} / public function setName($name) { $this->name = $name; } /* * {@inheritdoc} / public function save() { if (!$this->started \|\| $this->closed) { throw new \RuntimeException("Trying to save a session that was not started yet or was already closed"); } // nothing to do since we don't persist the session data $this->closed = false; $this->started = false; } /* * {@inheritdoc} / public function clear() { // clear out the bags foreach ($this->bags as $bag) { $bag->clear(); } // clear out the session $this->data = array(); // reconnect the bags to the session $this->loadSession(); } /* * {@inheritdoc} / public function registerBag(SessionBagInterface $bag) { $this->bags[$bag->getName()] = $bag; } /* * {@inheritdoc} / public function getBag($name) { if (!isset($this->bags[$name])) { throw new \InvalidArgumentException(sprintf('The SessionBagInterface %s is not registered.', $name)); } if (!$this->started) { $this->start(); } return $this->bags[$name]; } /* * {@inheritdoc} / public function isStarted() { return $this->started; } /* * Sets the MetadataBag. * * @param MetadataBag $bag / public function setMetadataBag(MetadataBag $bag = null) { if (null === $bag) { $bag = new MetadataBag(); } $this->metadataBag = $bag; } /* * Gets the MetadataBag. * * @return MetadataBag / public function getMetadataBag() { return $this->metadataBag; } /* * Generates a session ID. * * This doesn't need to be particularly cryptographically secure since this is just * a mock. * * @return string */ protected function generateId() { return hash('sha256', uniqid(mt_rand())); } protected function loadSession() { $bags = array_merge($this->bags, array($this->metadataBag)); foreach ($bags as $bag) { $key = $bag->getStorageKey(); $this->data[$key] = isset($this->data[$key]) ? $this->data[$key] : array(); $bag->initialize($this->data[$key]); } $this->started = true; $this->closed = false; } }	5.28 KB	2024-07-17 10:22
📄 MockFileSessionStorage.php <?php /* * This file is part of the Symfony package. * * (c) Fabien Potencier <fabien@symfony.com> * * 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; /* * MockFileSessionStorage is used to mock sessions for * functional testing when done in a single PHP process. * * No PHP session is actually started since a session can be initialized * and shutdown only once per PHP execution cycle and this class does * not pollute any session related globals, including session_() functions or session.* PHP ini directives. * * @author Drak <drak@zikula.org> / class MockFileSessionStorage extends MockArraySessionStorage { /* * @var string / private $savePath; /* * Constructor. * * @param string $savePath Path of directory to save session files. * @param string $name Session name. * @param MetadataBag $metaBag MetadataBag instance. / public function __construct($savePath = null, $name = 'MOCKSESSID', MetadataBag $metaBag = null) { if (null === $savePath) { $savePath = sys_get_temp_dir(); } if (!is_dir($savePath)) { mkdir($savePath, 0777, true); } $this->savePath = $savePath; parent::__construct($name, $metaBag); } /* * {@inheritdoc} / public function start() { if ($this->started) { return true; } if (!$this->id) { $this->id = $this->generateId(); } $this->read(); $this->started = true; return true; } /* * {@inheritdoc} / public function regenerate($destroy = false, $lifetime = null) { if (!$this->started) { $this->start(); } if ($destroy) { $this->destroy(); } return parent::regenerate($destroy, $lifetime); } /* * {@inheritdoc} / public function save() { if (!$this->started) { throw new \RuntimeException("Trying to save a session that was not started yet or was already closed"); } file_put_contents($this->getFilePath(), serialize($this->data)); // this is needed for Silex, where the session object is re-used across requests // in functional tests. In Symfony, the container is rebooted, so we don't have // this issue $this->started = false; } /* * Deletes a session from persistent storage. * Deliberately leaves session data in memory intact. / private function destroy() { if (is_file($this->getFilePath())) { unlink($this->getFilePath()); } } /* * Calculate path to file. * * @return string File path / private function getFilePath() { return $this->savePath.'/'.$this->id.'.mocksess'; } /* * Reads session from storage and loads session. */ private function read() { $filePath = $this->getFilePath(); $this->data = is_readable($filePath) && is_file($filePath) ? unserialize(file_get_contents($filePath)) : array(); $this->loadSession(); } }	3.27 KB	2024-07-17 10:22
📄 NativeSessionStorage.php <?php /* * This file is part of the Symfony package. * * (c) Fabien Potencier <fabien@symfony.com> * * 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; use Symfony\Component\HttpFoundation\Session\SessionBagInterface; use Symfony\Component\HttpFoundation\Session\Storage\Handler\NativeSessionHandler; use Symfony\Component\HttpFoundation\Session\Storage\Proxy\NativeProxy; use Symfony\Component\HttpFoundation\Session\Storage\Proxy\AbstractProxy; use Symfony\Component\HttpFoundation\Session\Storage\Proxy\SessionHandlerProxy; /* * This provides a base class for session attribute storage. * * @author Drak <drak@zikula.org> / class NativeSessionStorage implements SessionStorageInterface { /* * Array of SessionBagInterface * * @var SessionBagInterface[] / protected $bags; /* * @var Boolean / protected $started = false; /* * @var Boolean / protected $closed = false; /* * @var AbstractProxy / protected $saveHandler; /* * @var MetadataBag / protected $metadataBag; /* * Constructor. * * Depending on how you want the storage driver to behave you probably * want to override this constructor entirely. * * List of options for $options array with their defaults. * @see http://php.net/session.configuration for options * but we omit 'session.' from the beginning of the keys for convenience. * * ("auto_start", is not supported as it tells PHP to start a session before * PHP starts to execute user-land code. Setting during runtime has no effect). * * cache_limiter, "nocache" (use "0" to prevent headers from being sent entirely). * cookie_domain, "" * cookie_httponly, "" * cookie_lifetime, "0" * cookie_path, "/" * cookie_secure, "" * entropy_file, "" * entropy_length, "0" * gc_divisor, "100" * gc_maxlifetime, "1440" * gc_probability, "1" * hash_bits_per_character, "4" * hash_function, "0" * name, "PHPSESSID" * referer_check, "" * serialize_handler, "php" * use_cookies, "1" * use_only_cookies, "1" * use_trans_sid, "0" * upload_progress.enabled, "1" * upload_progress.cleanup, "1" * upload_progress.prefix, "upload_progress_" * upload_progress.name, "PHP_SESSION_UPLOAD_PROGRESS" * upload_progress.freq, "1%" * upload_progress.min-freq, "1" * url_rewriter.tags, "a=href,area=href,frame=src,form=,fieldset=" * * @param array $options Session configuration options. * @param AbstractProxy\|NativeSessionHandler\|\SessionHandlerInterface\|null $handler * @param MetadataBag $metaBag MetadataBag. / public function __construct(array $options = array(), $handler = null, MetadataBag $metaBag = null) { session_cache_limiter(''); // disable by default because it's managed by HeaderBag (if used) ini_set('session.use_cookies', 1); if (version_compare(phpversion(), '5.4.0', '>=')) { session_register_shutdown(); } else { register_shutdown_function('session_write_close'); } $this->setMetadataBag($metaBag); $this->setOptions($options); $this->setSaveHandler($handler); } /* * Gets the save handler instance. * * @return AbstractProxy / public function getSaveHandler() { return $this->saveHandler; } /* * {@inheritdoc} / public function start() { if ($this->started && !$this->closed) { return true; } if (version_compare(phpversion(), '5.4.0', '>=') && \PHP_SESSION_ACTIVE === session_status()) { throw new \RuntimeException('Failed to start the session: already started by PHP.'); } if (version_compare(phpversion(), '5.4.0', '<') && isset($_SESSION) && session_id()) { // not 100% fool-proof, but is the most reliable way to determine if a session is active in PHP 5.3 throw new \RuntimeException('Failed to start the session: already started by PHP ($_SESSION is set).'); } if (ini_get('session.use_cookies') && headers_sent($file, $line)) { throw new \RuntimeException(sprintf('Failed to start the session because headers have already been sent by "%s" at line %d.', $file, $line)); } // ok to try and start the session if (!session_start()) { throw new \RuntimeException('Failed to start the session'); } $this->loadSession(); if (!$this->saveHandler->isWrapper() && !$this->saveHandler->isSessionHandlerInterface()) { // This condition matches only PHP 5.3 with internal save handlers $this->saveHandler->setActive(true); } return true; } /* * {@inheritdoc} / public function getId() { if (!$this->started && !$this->closed) { return ''; // returning empty is consistent with session_id() behaviour } return $this->saveHandler->getId(); } /* * {@inheritdoc} / public function setId($id) { $this->saveHandler->setId($id); } /* * {@inheritdoc} / public function getName() { return $this->saveHandler->getName(); } /* * {@inheritdoc} / public function setName($name) { $this->saveHandler->setName($name); } /* * {@inheritdoc} / public function regenerate($destroy = false, $lifetime = null) { if (null !== $lifetime) { ini_set('session.cookie_lifetime', $lifetime); } if ($destroy) { $this->metadataBag->stampNew(); } $ret = session_regenerate_id($destroy); // workaround for https://bugs.php.net/bug.php?id=61470 as suggested by David Grudl if ('files' === $this->getSaveHandler()->getSaveHandlerName()) { session_write_close(); if (isset($_SESSION)) { $backup = $_SESSION; session_start(); $_SESSION = $backup; } else { session_start(); } $this->loadSession(); } return $ret; } /* * {@inheritdoc} / public function save() { session_write_close(); if (!$this->saveHandler->isWrapper() && !$this->saveHandler->isSessionHandlerInterface()) { // This condition matches only PHP 5.3 with internal save handlers $this->saveHandler->setActive(false); } $this->closed = true; $this->started = false; } /* * {@inheritdoc} / public function clear() { // clear out the bags foreach ($this->bags as $bag) { $bag->clear(); } // clear out the session $_SESSION = array(); // reconnect the bags to the session $this->loadSession(); } /* * {@inheritdoc} / public function registerBag(SessionBagInterface $bag) { $this->bags[$bag->getName()] = $bag; } /* * {@inheritdoc} / public function getBag($name) { if (!isset($this->bags[$name])) { throw new \InvalidArgumentException(sprintf('The SessionBagInterface %s is not registered.', $name)); } if ($this->saveHandler->isActive() && !$this->started) { $this->loadSession(); } elseif (!$this->started) { $this->start(); } return $this->bags[$name]; } /* * Sets the MetadataBag. * * @param MetadataBag $metaBag / public function setMetadataBag(MetadataBag $metaBag = null) { if (null === $metaBag) { $metaBag = new MetadataBag(); } $this->metadataBag = $metaBag; } /* * Gets the MetadataBag. * * @return MetadataBag / public function getMetadataBag() { return $this->metadataBag; } /* * {@inheritdoc} / public function isStarted() { return $this->started; } /* * Sets session.* ini variables. * * For convenience we omit 'session.' from the beginning of the keys. * Explicitly ignores other ini keys. * * @param array $options Session ini directives array(key => value). * * @see http://php.net/session.configuration / public function setOptions(array $options) { $validOptions = array_flip(array( 'cache_limiter', 'cookie_domain', 'cookie_httponly', 'cookie_lifetime', 'cookie_path', 'cookie_secure', 'entropy_file', 'entropy_length', 'gc_divisor', 'gc_maxlifetime', 'gc_probability', 'hash_bits_per_character', 'hash_function', 'name', 'referer_check', 'serialize_handler', 'use_cookies', 'use_only_cookies', 'use_trans_sid', 'upload_progress.enabled', 'upload_progress.cleanup', 'upload_progress.prefix', 'upload_progress.name', 'upload_progress.freq', 'upload_progress.min-freq', 'url_rewriter.tags', )); foreach ($options as $key => $value) { if (isset($validOptions[$key])) { ini_set('session.'.$key, $value); } } } /* * Registers session save handler as a PHP session handler. * * To use internal PHP session save handlers, override this method using ini_set with * session.save_handler and session.save_path e.g. * * ini_set('session.save_handler', 'files'); * ini_set('session.save_path', /tmp'); * * or pass in a NativeSessionHandler instance which configures session.save_handler in the * constructor, for a template see NativeFileSessionHandler or use handlers in * composer package drak/native-session * * @see http://php.net/session-set-save-handler * @see http://php.net/sessionhandlerinterface * @see http://php.net/sessionhandler * @see http://github.com/drak/NativeSession * * @param AbstractProxy\|NativeSessionHandler\|\SessionHandlerInterface\|null $saveHandler * * @throws \InvalidArgumentException / public function setSaveHandler($saveHandler = null) { if (!$saveHandler instanceof AbstractProxy && !$saveHandler instanceof NativeSessionHandler && !$saveHandler instanceof \SessionHandlerInterface && null !== $saveHandler) { throw new \InvalidArgumentException('Must be instance of AbstractProxy or NativeSessionHandler; implement \SessionHandlerInterface; or be null.'); } // Wrap $saveHandler in proxy and prevent double wrapping of proxy if (!$saveHandler instanceof AbstractProxy && $saveHandler instanceof \SessionHandlerInterface) { $saveHandler = new SessionHandlerProxy($saveHandler); } elseif (!$saveHandler instanceof AbstractProxy) { $saveHandler = version_compare(phpversion(), '5.4.0', '>=') ? new SessionHandlerProxy(new \SessionHandler()) : new NativeProxy(); } $this->saveHandler = $saveHandler; if ($this->saveHandler instanceof \SessionHandlerInterface) { if (version_compare(phpversion(), '5.4.0', '>=')) { session_set_save_handler($this->saveHandler, false); } else { session_set_save_handler( array($this->saveHandler, 'open'), array($this->saveHandler, 'close'), array($this->saveHandler, 'read'), array($this->saveHandler, 'write'), array($this->saveHandler, 'destroy'), array($this->saveHandler, 'gc') ); } } } /* * Load the session with attributes. * * After starting the session, PHP retrieves the session from whatever handlers * are set to (either PHP's internal, or a custom save handler set with session_set_save_handler()). * PHP takes the return value from the read() handler, unserializes it * and populates $_SESSION with the result automatically. * * @param array\|null $session */ protected function loadSession(array &$session = null) { if (null === $session) { $session = &$_SESSION; } $bags = array_merge($this->bags, array($this->metadataBag)); foreach ($bags as $bag) { $key = $bag->getStorageKey(); $session[$key] = isset($session[$key]) ? $session[$key] : array(); $bag->initialize($session[$key]); } $this->started = true; $this->closed = false; } }	12.89 KB	2024-07-17 10:22
📄 PhpBridgeSessionStorage.php <?php /* * This file is part of the Symfony package. * * (c) Fabien Potencier <fabien@symfony.com> * * 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; use Symfony\Component\HttpFoundation\Session\Storage\Proxy\AbstractProxy; use Symfony\Component\HttpFoundation\Session\Storage\Handler\NativeSessionHandler; /* * Allows session to be started by PHP and managed by Symfony2 * * @author Drak <drak@zikula.org> / class PhpBridgeSessionStorage extends NativeSessionStorage { /* * Constructor. * * @param AbstractProxy\|NativeSessionHandler\|\SessionHandlerInterface\|null $handler * @param MetadataBag $metaBag MetadataBag / public function __construct($handler = null, MetadataBag $metaBag = null) { $this->setMetadataBag($metaBag); $this->setSaveHandler($handler); } /* * {@inheritdoc} / public function start() { if ($this->started && !$this->closed) { return true; } $this->loadSession(); if (!$this->saveHandler->isWrapper() && !$this->saveHandler->isSessionHandlerInterface()) { // This condition matches only PHP 5.3 + internal save handlers $this->saveHandler->setActive(true); } return true; } /* * {@inheritdoc} */ public function clear() { // clear out the bags and nothing else that may be set // since the purpose of this driver is to share a handler foreach ($this->bags as $bag) { $bag->clear(); } // reconnect the bags to the session $this->loadSession(); } }	1.8 KB	2024-07-17 10:22
📁 Proxy	-	2025-05-25 12:37
📄 SessionStorageInterface.php <?php /* * This file is part of the Symfony package. * * (c) Fabien Potencier <fabien@symfony.com> * * 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; use Symfony\Component\HttpFoundation\Session\SessionBagInterface; /* * StorageInterface. * * @author Fabien Potencier <fabien@symfony.com> * @author Drak <drak@zikula.org> * * @api / interface SessionStorageInterface { /* * Starts the session. * * @throws \RuntimeException If something goes wrong starting the session. * * @return boolean True if started. * * @api / public function start(); /* * Checks if the session is started. * * @return boolean True if started, false otherwise. / public function isStarted(); /* * Returns the session ID * * @return string The session ID or empty. * * @api / public function getId(); /* * Sets the session ID * * @param string $id * * @api / public function setId($id); /* * Returns the session name * * @return mixed The session name. * * @api / public function getName(); /* * Sets the session name * * @param string $name * * @api / public function setName($name); /* * Regenerates id that represents this storage. * * This method must invoke session_regenerate_id($destroy) unless * this interface is used for a storage object designed for unit * or functional testing where a real PHP session would interfere * with testing. * * Note regenerate+destroy should not clear the session data in memory * only delete the session data from persistent storage. * * @param Boolean $destroy Destroy session when regenerating? * @param integer $lifetime Sets the cookie lifetime for the session cookie. A null value * will leave the system settings unchanged, 0 sets the cookie * to expire with browser session. Time is in seconds, and is * not a Unix timestamp. * * @return Boolean True if session regenerated, false if error * * @throws \RuntimeException If an error occurs while regenerating this storage * * @api / public function regenerate($destroy = false, $lifetime = null); /* * Force the session to be saved and closed. * * This method must invoke session_write_close() unless this interface is * used for a storage object design for unit or functional testing where * a real PHP session would interfere with testing, in which case it * it should actually persist the session data if required. * * @throws \RuntimeException If the session is saved without being started, or if the session * is already closed. / public function save(); /* * Clear all session data in memory. / public function clear(); /* * Gets a SessionBagInterface by name. * * @param string $name * * @return SessionBagInterface * * @throws \InvalidArgumentException If the bag does not exist / public function getBag($name); /* * Registers a SessionBagInterface for use. * * @param SessionBagInterface $bag / public function registerBag(SessionBagInterface $bag); /* * @return MetadataBag */ public function getMetadataBag(); }	3.62 KB	2024-07-17 10:22

Terminal