added http foundation.

vendor/Symfony/Component/HttpFoundation/Session/Storage/Handler/MemcacheSessionHandler.php

@@ -0,0 +1,139 @@
+<?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\Handler;
+
+/**
+ * MemcacheSessionHandler.
+ *
+ * @author Drak <drak@zikula.org>
+ */
+class MemcacheSessionHandler implements \SessionHandlerInterface
+{
+    /**
+     * Memcache driver.
+     *
+     * @var \Memcache
+     */
+    private $memcache;
+
+    /**
+     * Configuration options.
+     *
+     * @var array
+     */
+    private $memcacheOptions;
+
+    /**
+     * Key prefix for shared environments.
+     *
+     * @var string
+     */
+    private $prefix;
+
+    /**
+     * Constructor.
+     *
+     * @param \Memcache $memcache        A \Memcache instance
+     * @param array     $memcacheOptions An associative array of Memcache options
+     * @param array     $options         Session configuration options.
+     */
+    public function __construct(\Memcache $memcache, array $memcacheOptions = array(), array $options = array())
+    {
+        $this->memcache = $memcache;
+
+        // defaults
+        if (!isset($memcacheOptions['serverpool'])) {
+            $memcacheOptions['serverpool'] = array(array(
+                'host' => '127.0.0.1',
+                'port' => 11211,
+                'timeout' => 1,
+                'persistent' => false,
+                'weight' => 1,
+                'retry_interval' => 15,
+            ));
+        }
+
+        $memcacheOptions['expiretime'] = isset($memcacheOptions['expiretime']) ? (int)$memcacheOptions['expiretime'] : 86400;
+        $this->prefix = isset($memcacheOptions['prefix']) ? $memcacheOptions['prefix'] : 'sf2s';
+
+        $this->memcacheOptions = $memcacheOptions;
+    }
+
+    protected function addServer(array $server)
+    {
+        if (!array_key_exists('host', $server)) {
+            throw new \InvalidArgumentException('host key must be set');
+        }
+
+        $server['port'] = isset($server['port']) ? (int)$server['port'] : 11211;
+        $server['timeout'] = isset($server['timeout']) ? (int)$server['timeout'] : 1;
+        $server['persistent'] = isset($server['persistent']) ? (bool)$server['persistent'] : false;
+        $server['weight'] = isset($server['weight']) ? (int)$server['weight'] : 1;
+        $server['retry_interval'] = isset($server['retry_interval']) ? (int)$server['retry_interval'] : 15;
+
+        $this->memcache->addserver($server['host'], $server['port'], $server['persistent'],$server['weight'],$server['timeout'],$server['retry_interval']);
+
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function open($savePath, $sessionName)
+    {
+        foreach ($this->memcacheOptions['serverpool'] as $server) {
+            $this->addServer($server);
+        }
+
+        return true;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function close()
+    {
+        return $this->memcache->close();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function read($sessionId)
+    {
+        return $this->memcache->get($this->prefix.$sessionId) ?: '';
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function write($sessionId, $data)
+    {
+        return $this->memcache->set($this->prefix.$sessionId, $data, 0, $this->memcacheOptions['expiretime']);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function destroy($sessionId)
+    {
+        return $this->memcache->delete($this->prefix.$sessionId);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function gc($lifetime)
+    {
+        // not required here because memcache will auto expire the records anyhow.
+        return true;
+    }
+}

vendor/Symfony/Component/HttpFoundation/Session/Storage/Handler/MemcachedSessionHandler.php

@@ -0,0 +1,130 @@
+<?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\Handler;
+
+/**
+ * MemcachedSessionHandler.
+ *
+ * Memcached based session storage handler based on the Memcached class
+ * provided by the PHP memcached extension.
+ *
+ * @see http://php.net/memcached
+ *
+ * @author Drak <drak@zikula.org>
+ */
+class MemcachedSessionHandler implements \SessionHandlerInterface
+{
+    /**
+     * Memcached driver.
+     *
+     * @var \Memcached
+     */
+    private $memcached;
+
+    /**
+     * Configuration options.
+     *
+     * @var array
+     */
+    private $memcachedOptions;
+
+    /**
+     * Constructor.
+     *
+     * @param \Memcached $memcached        A \Memcached instance
+     * @param array      $memcachedOptions An associative array of Memcached options
+     * @param array      $options          Session configuration options.
+     */
+    public function __construct(\Memcached $memcached, array $memcachedOptions = array(), array $options = array())
+    {
+        $this->memcached = $memcached;
+
+        // defaults
+        if (!isset($memcachedOptions['serverpool'])) {
+            $memcachedOptions['serverpool'][] = array(
+                'host' => '127.0.0.1',
+                'port' => 11211,
+                'weight' => 1);
+        }
+
+        $memcachedOptions['expiretime'] = isset($memcachedOptions['expiretime']) ? (int)$memcachedOptions['expiretime'] : 86400;
+
+        $this->memcached->setOption(\Memcached::OPT_PREFIX_KEY, isset($memcachedOptions['prefix']) ? $memcachedOptions['prefix'] : 'sf2s');
+
+        $this->memcachedOptions = $memcachedOptions;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function open($savePath, $sessionName)
+    {
+        return $this->memcached->addServers($this->memcachedOptions['serverpool']);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function close()
+    {
+        return true;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function read($sessionId)
+    {
+        return $this->memcached->get($sessionId) ?: '';
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function write($sessionId, $data)
+    {
+        return $this->memcached->set($sessionId, $data, $this->memcachedOptions['expiretime']);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function destroy($sessionId)
+    {
+        return $this->memcached->delete($sessionId);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function gc($lifetime)
+    {
+        // not required here because memcached will auto expire the records anyhow.
+        return true;
+    }
+
+    /**
+     * Adds a server to the memcached handler.
+     *
+     * @param array $server
+     */
+    protected function addServer(array $server)
+    {
+        if (array_key_exists('host', $server)) {
+            throw new \InvalidArgumentException('host key must be set');
+        }
+        $server['port'] = isset($server['port']) ? (int)$server['port'] : 11211;
+        $server['timeout'] = isset($server['timeout']) ? (int)$server['timeout'] : 1;
+        $server['presistent'] = isset($server['presistent']) ? (bool)$server['presistent'] : false;
+        $server['weight'] = isset($server['weight']) ? (bool)$server['weight'] : 1;
+    }
+}

vendor/Symfony/Component/HttpFoundation/Session/Storage/Handler/NativeFileSessionHandler.php

@@ -0,0 +1,41 @@
+<?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\Handler;
+
+/**
+ * NativeFileSessionHandler.
+ *
+ * Native session handler using PHP's built in file storage.
+ *
+ * @author Drak <drak@zikula.org>
+ */
+class NativeFileSessionHandler extends NativeSessionHandler
+{
+    /**
+     * Constructor.
+     *
+     * @param string $savePath Path of directory to save session files.  Default null will leave setting as defined by PHP.
+     */
+    public function __construct($savePath = null)
+    {
+        if (null === $savePath) {
+            $savePath = ini_get('session.save_path');
+        }
+
+        if ($savePath && !is_dir($savePath)) {
+            mkdir($savePath, 0777, true);
+        }
+
+        ini_set('session.save_handler', 'files');
+        ini_set('session.save_path', $savePath);
+    }
+}

vendor/Symfony/Component/HttpFoundation/Session/Storage/Handler/NativeMemcacheSessionHandler.php

@@ -0,0 +1,65 @@
+<?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\Handler;
+
+/**
+ * NativeMemcacheSessionHandler.
+ *
+ * Driver for the memcache session save hadlers provided by the memcache PHP extension.
+ *
+ * @see http://php.net/memcache
+ *
+ * @author Drak <drak@zikula.org>
+ */
+class NativeMemcacheSessionHandler extends NativeSessionHandler
+{
+    /**
+     * Constructor.
+     *
+     * @param string $savePath Path of memcache server.
+     * @param array  $options  Session configuration options.
+     */
+    public function __construct($savePath = 'tcp://127.0.0.1:11211?persistent=0', array $options = array())
+    {
+        if (!extension_loaded('memcache')) {
+            throw new \RuntimeException('PHP does not have "memcache" session module registered');
+        }
+
+        if (null === $savePath) {
+            $savePath = ini_get('session.save_path');
+        }
+
+        ini_set('session.save_handler', 'memcache');
+        ini_set('session.save_path', $savePath);
+
+        $this->setOptions($options);
+    }
+
+    /**
+     * Set any memcached ini values.
+     *
+     * @see http://php.net/memcache.ini
+     */
+    protected function setOptions(array $options)
+    {
+        foreach ($options as $key => $value) {
+            if (in_array($key, array(
+                'memcache.allow_failover', 'memcache.max_failover_attempts',
+                'memcache.chunk_size', 'memcache.default_port', 'memcache.hash_strategy',
+                'memcache.hash_function', 'memcache.protocol', 'memcache.redundancy',
+                'memcache.session_redundancy', 'memcache.compress_threshold',
+                'memcache.lock_timeout'))) {
+                ini_set($key, $value);
+            }
+        }
+    }
+}

vendor/Symfony/Component/HttpFoundation/Session/Storage/Handler/NativeMemcachedSessionHandler.php

@@ -0,0 +1,64 @@
+<?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\Handler;
+
+/**
+ * NativeMemcachedSessionHandler.
+ *
+ * Driver for the memcached session save hadlers provided by the memcached PHP extension.
+ *
+ * @see http://php.net/memcached.sessions
+ *
+ * @author Drak <drak@zikula.org>
+ */
+class NativeMemcachedSessionHandler extends NativeSessionHandler
+{
+    /**
+     * Constructor.
+     *
+     * @param string $savePath Comma separated list of servers: e.g. memcache1.example.com:11211,memcache2.example.com:11211
+     * @param array  $options  Session configuration options.
+     */
+    public function __construct($savePath = '127.0.0.1:11211', array $options = array())
+    {
+        if (!extension_loaded('memcached')) {
+            throw new \RuntimeException('PHP does not have "memcached" session module registered');
+        }
+
+        if (null === $savePath) {
+            $savePath = ini_get('session.save_path');
+        }
+
+        ini_set('session.save_handler', 'memcached');
+        ini_set('session.save_path', $savePath);
+
+        $this->setOptions($options);
+    }
+
+    /**
+     * Set any memcached ini values.
+     *
+     * @see https://github.com/php-memcached-dev/php-memcached/blob/master/memcached.ini
+     */
+    protected function setOptions(array $options)
+    {
+        foreach ($options as $key => $value) {
+            if (in_array($key, array(
+                'memcached.sess_locking', 'memcached.sess_lock_wait',
+                'memcached.sess_prefix', 'memcached.compression_type',
+                'memcached.compression_factor', 'memcached.compression_threshold',
+                'memcached.serializer'))) {
+                ini_set($key, $value);
+            }
+        }
+    }
+}

vendor/Symfony/Component/HttpFoundation/Session/Storage/Handler/NativeSessionHandler.php

@@ -0,0 +1,24 @@
+<?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\Handler;
+
+/**
+ * Adds SessionHandler functionality if available.
+ *
+ * @see http://php.net/sessionhandler
+ */
+
+if (version_compare(phpversion(), '5.4.0', '>=')) {
+    class NativeSessionHandler extends \SessionHandler {}
+} else {
+    class NativeSessionHandler {}
+}

vendor/Symfony/Component/HttpFoundation/Session/Storage/Handler/NativeSqliteSessionHandler.php

@@ -0,0 +1,58 @@
+<?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\Handler;
+
+/**
+ * NativeSqliteSessionHandler.
+ *
+ * Driver for the sqlite session save hadlers provided by the SQLite PHP extension.
+ *
+ * @author Drak <drak@zikula.org>
+ */
+class NativeSqliteSessionHandler extends NativeSessionHandler
+{
+    /**
+     * Constructor.
+     *
+     * @param string $savePath Path to SQLite database file itself.
+     * @param array  $options  Session configuration options.
+     */
+    public function __construct($savePath, array $options = array())
+    {
+        if (!extension_loaded('sqlite')) {
+            throw new \RuntimeException('PHP does not have "sqlite" session module registered');
+        }
+
+        if (null === $savePath) {
+            $savePath = ini_get('session.save_path');
+        }
+
+        ini_set('session.save_handler', 'sqlite');
+        ini_set('session.save_path', $savePath);
+
+        $this->setOptions($options);
+    }
+
+    /**
+     * Set any sqlite ini values.
+     *
+     * @see http://php.net/sqlite.configuration
+     */
+    protected function setOptions(array $options)
+    {
+        foreach ($options as $key => $value) {
+            if (in_array($key, array('sqlite.assoc_case'))) {
+                ini_set($key, $value);
+            }
+        }
+    }
+}

vendor/Symfony/Component/HttpFoundation/Session/Storage/Handler/NullSessionHandler.php

@@ -0,0 +1,72 @@
+<?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\Handler;
+
+/**
+ * NullSessionHandler.
+ *
+ * Can be used in unit testing or in a sitation where persisted sessions are not desired.
+ *
+ * @author Drak <drak@zikula.org>
+ *
+ * @api
+ */
+class NullSessionHandler implements \SessionHandlerInterface
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function open($savePath, $sessionName)
+    {
+        return true;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function close()
+    {
+        return true;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function read($sessionId)
+    {
+        return '';
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function write($sessionId, $data)
+    {
+        return true;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function destroy($sessionId)
+    {
+        return true;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function gc($lifetime)
+    {
+        return true;
+    }
+}

vendor/Symfony/Component/HttpFoundation/Session/Storage/Handler/PdoSessionHandler.php

@@ -0,0 +1,221 @@
+<?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\Handler;
+
+/**
+ * PdoSessionHandler.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ * @author Michael Williams <michael.williams@funsational.com>
+ */
+class PdoSessionHandler implements \SessionHandlerInterface
+{
+    /**
+     * PDO instance.
+     *
+     * @var \PDO
+     */
+    private $pdo;
+
+    /**
+     * Database options.
+     *
+     *
+     * @var array
+     */
+    private $dbOptions;
+
+    /**
+     * Constructor.
+     *
+     * @param \PDO  $pdo       A \PDO instance
+     * @param array $dbOptions An associative array of DB options
+     * @param array $options   Session configuration options
+     *
+     * @throws \InvalidArgumentException When "db_table" option is not provided
+     */
+    public function __construct(\PDO $pdo, array $dbOptions = array(), array $options = array())
+    {
+        if (!array_key_exists('db_table', $dbOptions)) {
+            throw new \InvalidArgumentException('You must provide the "db_table" option for a PdoSessionStorage.');
+        }
+
+        $this->pdo = $pdo;
+        $this->dbOptions = array_merge(array(
+            'db_id_col'   => 'sess_id',
+            'db_data_col' => 'sess_data',
+            'db_time_col' => 'sess_time',
+        ), $dbOptions);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function open($path, $name)
+    {
+        return true;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function close()
+    {
+        return true;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function destroy($id)
+    {
+        // get table/column
+        $dbTable  = $this->dbOptions['db_table'];
+        $dbIdCol = $this->dbOptions['db_id_col'];
+
+        // delete the record associated with this id
+        $sql = "DELETE FROM $dbTable WHERE $dbIdCol = :id";
+
+        try {
+            $stmt = $this->pdo->prepare($sql);
+            $stmt->bindParam(':id', $id, \PDO::PARAM_STR);
+            $stmt->execute();
+        } catch (\PDOException $e) {
+            throw new \RuntimeException(sprintf('PDOException was thrown when trying to manipulate session data: %s', $e->getMessage()), 0, $e);
+        }
+
+        return true;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function gc($lifetime)
+    {
+        // get table/column
+        $dbTable    = $this->dbOptions['db_table'];
+        $dbTimeCol = $this->dbOptions['db_time_col'];
+
+        // delete the session records that have expired
+        $sql = "DELETE FROM $dbTable WHERE $dbTimeCol < (:time - $lifetime)";
+
+        try {
+            $stmt = $this->pdo->prepare($sql);
+            $stmt->bindValue(':time', time(), \PDO::PARAM_INT);
+            $stmt->execute();
+        } catch (\PDOException $e) {
+            throw new \RuntimeException(sprintf('PDOException was thrown when trying to manipulate session data: %s', $e->getMessage()), 0, $e);
+        }
+
+        return true;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function read($id)
+    {
+        // get table/columns
+        $dbTable    = $this->dbOptions['db_table'];
+        $dbDataCol = $this->dbOptions['db_data_col'];
+        $dbIdCol   = $this->dbOptions['db_id_col'];
+
+        try {
+            $sql = "SELECT $dbDataCol FROM $dbTable WHERE $dbIdCol = :id";
+
+            $stmt = $this->pdo->prepare($sql);
+            $stmt->bindParam(':id', $id, \PDO::PARAM_STR);
+
+            $stmt->execute();
+            // it is recommended to use fetchAll so that PDO can close the DB cursor
+            // we anyway expect either no rows, or one row with one column. fetchColumn, seems to be buggy #4777
+            $sessionRows = $stmt->fetchAll(\PDO::FETCH_NUM);
+
+            if (count($sessionRows) == 1) {
+                return base64_decode($sessionRows[0][0]);
+            }
+
+            // session does not exist, create it
+            $this->createNewSession($id);
+
+            return '';
+        } catch (\PDOException $e) {
+            throw new \RuntimeException(sprintf('PDOException was thrown when trying to read the session data: %s', $e->getMessage()), 0, $e);
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function write($id, $data)
+    {
+        // get table/column
+        $dbTable   = $this->dbOptions['db_table'];
+        $dbDataCol = $this->dbOptions['db_data_col'];
+        $dbIdCol   = $this->dbOptions['db_id_col'];
+        $dbTimeCol = $this->dbOptions['db_time_col'];
+
+        $sql = ('mysql' === $this->pdo->getAttribute(\PDO::ATTR_DRIVER_NAME))
+            ? "INSERT INTO $dbTable ($dbIdCol, $dbDataCol, $dbTimeCol) VALUES (:id, :data, :time) "
+              ."ON DUPLICATE KEY UPDATE $dbDataCol = VALUES($dbDataCol), $dbTimeCol = CASE WHEN $dbTimeCol = :time THEN (VALUES($dbTimeCol) + 1) ELSE VALUES($dbTimeCol) END"
+            : "UPDATE $dbTable SET $dbDataCol = :data, $dbTimeCol = :time WHERE $dbIdCol = :id";
+
+        try {
+            //session data can contain non binary safe characters so we need to encode it
+            $encoded = base64_encode($data);
+            $stmt = $this->pdo->prepare($sql);
+            $stmt->bindParam(':id', $id, \PDO::PARAM_STR);
+            $stmt->bindParam(':data', $encoded, \PDO::PARAM_STR);
+            $stmt->bindValue(':time', time(), \PDO::PARAM_INT);
+            $stmt->execute();
+
+            if (!$stmt->rowCount()) {
+                // No session exists in the database to update. This happens when we have called
+                // session_regenerate_id()
+                $this->createNewSession($id, $data);
+            }
+        } catch (\PDOException $e) {
+            throw new \RuntimeException(sprintf('PDOException was thrown when trying to write the session data: %s', $e->getMessage()), 0, $e);
+        }
+
+        return true;
+    }
+
+    /**
+     * Creates a new session with the given $id and $data
+     *
+     * @param string $id
+     * @param string $data
+     *
+     * @return boolean True.
+     */
+    private function createNewSession($id, $data = '')
+    {
+        // get table/column
+        $dbTable    = $this->dbOptions['db_table'];
+        $dbDataCol = $this->dbOptions['db_data_col'];
+        $dbIdCol   = $this->dbOptions['db_id_col'];
+        $dbTimeCol = $this->dbOptions['db_time_col'];
+
+        $sql = "INSERT INTO $dbTable ($dbIdCol, $dbDataCol, $dbTimeCol) VALUES (:id, :data, :time)";
+
+        //session data can contain non binary safe characters so we need to encode it
+        $encoded = base64_encode($data);
+        $stmt = $this->pdo->prepare($sql);
+        $stmt->bindParam(':id', $id, \PDO::PARAM_STR);
+        $stmt->bindParam(':data', $encoded, \PDO::PARAM_STR);
+        $stmt->bindValue(':time', time(), \PDO::PARAM_INT);
+        $stmt->execute();
+
+        return true;
+    }
+}