1. sfSessionStorage.class.php
  2. /**
 * sfSessionStorage allows you to store persistent symfony data in the user session.
 *
 * Optional parameters:
 *
 * # auto_start   - [Yes]     - Should session_start() automatically be called?
 * # session_name - [symfony] - The name of the session.
 *
 * @package    symfony
 * @subpackage storage
 * @author     Fabien Potencier 
 * @author     Sean Kerr 
 * @version    SVN: $Id: sfSessionStorage.class.php 23810 2009-11-12 11:07:44Z Kris.Wallsmith $
 */
  3. class sfSessionStorage extends sfStorage
  4. {
  5.   static protected
  6.     $sessionIdRegenerated = false,
  7.     $sessionStarted       = false;
  9.   /**
  10.    * Available options:
  11.    *
  12.    *  * session_name:            The cookie name (symfony by default)
  13.    *  * session_id:              The session id (null by default)
  14.    *  * auto_start:              Whether to start the session (true by default)
  15.    *  * session_cookie_lifetime: Cookie lifetime
  16.    *  * session_cookie_path:     Cookie path
  17.    *  * session_cookie_domain:   Cookie domain
  18.    *  * session_cookie_secure:   Cookie secure
  19.    *  * session_cookie_httponly: Cookie http only (only for PHP >= 5.2)
  20.    *
  21.    * The default values for all 'session_cookie_*' options are those returned by the session_get_cookie_params() function
  22.    *
  23.    * @param array $options  An associative array of options
  24.    *
  25.    * @see sfStorage
  26.    */
  27.   public function initialize($options = null)
  28.   {
  29.     $cookieDefaults = session_get_cookie_params();
  31.     $options = array_merge(array(
  32.       'session_name'            => 'symfony',
  33.       'session_id'              => null,
  34.       'auto_start'              => true,
  35.       'session_cookie_lifetime' => $cookieDefaults['lifetime'],
  36.       'session_cookie_path'     => $cookieDefaults['path'],
  37.       'session_cookie_domain'   => $cookieDefaults['domain'],
  38.       'session_cookie_secure'   => $cookieDefaults['secure'],
  39.       'session_cookie_httponly' => isset($cookieDefaults['httponly']) ? $cookieDefaults['httponly'] : false,
  40.       'session_cache_limiter'   => 'none',
  41.     ), $options);
  43.     // initialize parent
  44.     parent::initialize($options);
  46.     // set session name
  47.     $sessionName = $this->options['session_name'];
  49.     session_name($sessionName);
  51.     if (!(boolean) ini_get('session.use_cookies') && $sessionId = $this->options['session_id'])
  52.     {
  53.       session_id($sessionId);
  54.     }
  56.     $lifetime = $this->options['session_cookie_lifetime'];
  57.     $path     = $this->options['session_cookie_path'];
  58.     $domain   = $this->options['session_cookie_domain'];
  59.     $secure   = $this->options['session_cookie_secure'];
  60.     $httpOnly = $this->options['session_cookie_httponly'];
  61.     session_set_cookie_params($lifetime, $path, $domain, $secure, $httpOnly);
  63.     if (null !== $this->options['session_cache_limiter'])
  64.     {
  65.       session_cache_limiter($this->options['session_cache_limiter']);
  66.     }
  68.     if ($this->options['auto_start'] && !self::$sessionStarted)
  69.     {
  70.       session_start();
  71.       self::$sessionStarted = true;
  72.     }
  73.   }
  75.   /**
  76.    * Reads data from this storage.
  77.    *
  78.    * The preferred format for a key is directory style so naming conflicts can be avoided.
  79.    *
  80.    * @param  string $key  A unique key identifying your data
  81.    *
  82.    * @return mixed Data associated with the key
  83.    */
  84.   public function read($key)
  85.   {
  86.     $retval = null;
  88.     if (isset($_SESSION[$key]))
  89.     {
  90.       $retval = $_SESSION[$key];
  91.     }
  93.     return $retval;
  94.   }
  96.   /**
  97.    * Removes data from this storage.
  98.    *
  99.    * The preferred format for a key is directory style so naming conflicts can be avoided.
  100.    *
  101.    * @param  string $key  A unique key identifying your data
  102.    *
  103.    * @return mixed Data associated with the key
  104.    */
  105.   public function remove($key)
  106.   {
  107.     $retval = null;
  109.     if (isset($_SESSION[$key]))
  110.     {
  111.       $retval = $_SESSION[$key];
  112.       unset($_SESSION[$key]);
  113.     }
  115.     return $retval;
  116.   }
  118.   /**
  119.    * Writes data to this storage.
  120.    *
  121.    * The preferred format for a key is directory style so naming conflicts can be avoided.
  122.    *
  123.    * @param string $key   A unique key identifying your data
  124.    * @param mixed  $data  Data associated with your key
  125.    *
  126.    */
  127.   public function write($key, $data)
  128.   {
  129.     $_SESSION[$key] = $data;
  130.   }
  132.   /**
  133.    * Regenerates id that represents this storage.
  134.    *
  135.    * @param  boolean $destroy Destroy session when regenerating?
  136.    *
  137.    * @return boolean True if session regenerated, false if error
  138.    *
  139.    */
  140.   public function regenerate($destroy = false)
  141.   {
  142.     if (self::$sessionIdRegenerated)
  143.     {
  144.       return;
  145.     }
  147.     // regenerate a new session id once per object
  148.     session_regenerate_id($destroy);
  150.     self::$sessionIdRegenerated = true;
  151.   }
  153.   /**
  154.    * Executes the shutdown procedure.
  155.    *
  156.    */
  157.   public function shutdown()
  158.   {
  159.     // don't need a shutdown procedure because read/write do it in real-time
  160.     session_write_close();
  161.   }
  162. }
Debug toolbar