657 lines
13 KiB
PHP
657 lines
13 KiB
PHP
<?php
|
|
|
|
namespace Illuminate\Session;
|
|
|
|
use Closure;
|
|
use Illuminate\Support\Arr;
|
|
use Illuminate\Support\Str;
|
|
use SessionHandlerInterface;
|
|
use Illuminate\Contracts\Session\Session;
|
|
|
|
class Store implements Session
|
|
{
|
|
/**
|
|
* The session ID.
|
|
*
|
|
* @var string
|
|
*/
|
|
protected $id;
|
|
|
|
/**
|
|
* The session name.
|
|
*
|
|
* @var string
|
|
*/
|
|
protected $name;
|
|
|
|
/**
|
|
* The session attributes.
|
|
*
|
|
* @var array
|
|
*/
|
|
protected $attributes = [];
|
|
|
|
/**
|
|
* The session handler implementation.
|
|
*
|
|
* @var \SessionHandlerInterface
|
|
*/
|
|
protected $handler;
|
|
|
|
/**
|
|
* Session store started status.
|
|
*
|
|
* @var bool
|
|
*/
|
|
protected $started = false;
|
|
|
|
/**
|
|
* Create a new session instance.
|
|
*
|
|
* @param string $name
|
|
* @param \SessionHandlerInterface $handler
|
|
* @param string|null $id
|
|
* @return void
|
|
*/
|
|
public function __construct($name, SessionHandlerInterface $handler, $id = null)
|
|
{
|
|
$this->setId($id);
|
|
$this->name = $name;
|
|
$this->handler = $handler;
|
|
}
|
|
|
|
/**
|
|
* Start the session, reading the data from a handler.
|
|
*
|
|
* @return bool
|
|
*/
|
|
public function start()
|
|
{
|
|
$this->loadSession();
|
|
|
|
if (! $this->has('_token')) {
|
|
$this->regenerateToken();
|
|
}
|
|
|
|
return $this->started = true;
|
|
}
|
|
|
|
/**
|
|
* Load the session data from the handler.
|
|
*
|
|
* @return void
|
|
*/
|
|
protected function loadSession()
|
|
{
|
|
$this->attributes = array_merge($this->attributes, $this->readFromHandler());
|
|
}
|
|
|
|
/**
|
|
* Read the session data from the handler.
|
|
*
|
|
* @return array
|
|
*/
|
|
protected function readFromHandler()
|
|
{
|
|
if ($data = $this->handler->read($this->getId())) {
|
|
$data = @unserialize($this->prepareForUnserialize($data));
|
|
|
|
if ($data !== false && ! is_null($data) && is_array($data)) {
|
|
return $data;
|
|
}
|
|
}
|
|
|
|
return [];
|
|
}
|
|
|
|
/**
|
|
* Prepare the raw string data from the session for unserialization.
|
|
*
|
|
* @param string $data
|
|
* @return string
|
|
*/
|
|
protected function prepareForUnserialize($data)
|
|
{
|
|
return $data;
|
|
}
|
|
|
|
/**
|
|
* Save the session data to storage.
|
|
*
|
|
* @return bool
|
|
*/
|
|
public function save()
|
|
{
|
|
$this->ageFlashData();
|
|
|
|
$this->handler->write($this->getId(), $this->prepareForStorage(
|
|
serialize($this->attributes)
|
|
));
|
|
|
|
$this->started = false;
|
|
}
|
|
|
|
/**
|
|
* Prepare the serialized session data for storage.
|
|
*
|
|
* @param string $data
|
|
* @return string
|
|
*/
|
|
protected function prepareForStorage($data)
|
|
{
|
|
return $data;
|
|
}
|
|
|
|
/**
|
|
* Age the flash data for the session.
|
|
*
|
|
* @return void
|
|
*/
|
|
public function ageFlashData()
|
|
{
|
|
$this->forget($this->get('_flash.old', []));
|
|
|
|
$this->put('_flash.old', $this->get('_flash.new', []));
|
|
|
|
$this->put('_flash.new', []);
|
|
}
|
|
|
|
/**
|
|
* Get all of the session data.
|
|
*
|
|
* @return array
|
|
*/
|
|
public function all()
|
|
{
|
|
return $this->attributes;
|
|
}
|
|
|
|
/**
|
|
* Checks if a key exists.
|
|
*
|
|
* @param string|array $key
|
|
* @return bool
|
|
*/
|
|
public function exists($key)
|
|
{
|
|
return ! collect(is_array($key) ? $key : func_get_args())->contains(function ($key) {
|
|
return ! Arr::exists($this->attributes, $key);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Checks if a key is present and not null.
|
|
*
|
|
* @param string|array $key
|
|
* @return bool
|
|
*/
|
|
public function has($key)
|
|
{
|
|
return ! collect(is_array($key) ? $key : func_get_args())->contains(function ($key) {
|
|
return is_null($this->get($key));
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Get an item from the session.
|
|
*
|
|
* @param string $key
|
|
* @param mixed $default
|
|
* @return mixed
|
|
*/
|
|
public function get($key, $default = null)
|
|
{
|
|
return Arr::get($this->attributes, $key, $default);
|
|
}
|
|
|
|
/**
|
|
* Get the value of a given key and then forget it.
|
|
*
|
|
* @param string $key
|
|
* @param string $default
|
|
* @return mixed
|
|
*/
|
|
public function pull($key, $default = null)
|
|
{
|
|
return Arr::pull($this->attributes, $key, $default);
|
|
}
|
|
|
|
/**
|
|
* Determine if the session contains old input.
|
|
*
|
|
* @param string $key
|
|
* @return bool
|
|
*/
|
|
public function hasOldInput($key = null)
|
|
{
|
|
$old = $this->getOldInput($key);
|
|
|
|
return is_null($key) ? count($old) > 0 : ! is_null($old);
|
|
}
|
|
|
|
/**
|
|
* Get the requested item from the flashed input array.
|
|
*
|
|
* @param string $key
|
|
* @param mixed $default
|
|
* @return mixed
|
|
*/
|
|
public function getOldInput($key = null, $default = null)
|
|
{
|
|
return Arr::get($this->get('_old_input', []), $key, $default);
|
|
}
|
|
|
|
/**
|
|
* Replace the given session attributes entirely.
|
|
*
|
|
* @param array $attributes
|
|
* @return void
|
|
*/
|
|
public function replace(array $attributes)
|
|
{
|
|
$this->put($attributes);
|
|
}
|
|
|
|
/**
|
|
* Put a key / value pair or array of key / value pairs in the session.
|
|
*
|
|
* @param string|array $key
|
|
* @param mixed $value
|
|
* @return void
|
|
*/
|
|
public function put($key, $value = null)
|
|
{
|
|
if (! is_array($key)) {
|
|
$key = [$key => $value];
|
|
}
|
|
|
|
foreach ($key as $arrayKey => $arrayValue) {
|
|
Arr::set($this->attributes, $arrayKey, $arrayValue);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get an item from the session, or store the default value.
|
|
*
|
|
* @param string $key
|
|
* @param \Closure $callback
|
|
* @return mixed
|
|
*/
|
|
public function remember($key, Closure $callback)
|
|
{
|
|
if (! is_null($value = $this->get($key))) {
|
|
return $value;
|
|
}
|
|
|
|
return tap($callback(), function ($value) use ($key) {
|
|
$this->put($key, $value);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Push a value onto a session array.
|
|
*
|
|
* @param string $key
|
|
* @param mixed $value
|
|
* @return void
|
|
*/
|
|
public function push($key, $value)
|
|
{
|
|
$array = $this->get($key, []);
|
|
|
|
$array[] = $value;
|
|
|
|
$this->put($key, $array);
|
|
}
|
|
|
|
/**
|
|
* Increment the value of an item in the session.
|
|
*
|
|
* @param string $key
|
|
* @param int $amount
|
|
* @return mixed
|
|
*/
|
|
public function increment($key, $amount = 1)
|
|
{
|
|
$this->put($key, $value = $this->get($key, 0) + $amount);
|
|
|
|
return $value;
|
|
}
|
|
|
|
/**
|
|
* Decrement the value of an item in the session.
|
|
*
|
|
* @param string $key
|
|
* @param int $amount
|
|
* @return int
|
|
*/
|
|
public function decrement($key, $amount = 1)
|
|
{
|
|
return $this->increment($key, $amount * -1);
|
|
}
|
|
|
|
/**
|
|
* Flash a key / value pair to the session.
|
|
*
|
|
* @param string $key
|
|
* @param mixed $value
|
|
* @return void
|
|
*/
|
|
public function flash(string $key, $value = true)
|
|
{
|
|
$this->put($key, $value);
|
|
|
|
$this->push('_flash.new', $key);
|
|
|
|
$this->removeFromOldFlashData([$key]);
|
|
}
|
|
|
|
/**
|
|
* Flash a key / value pair to the session for immediate use.
|
|
*
|
|
* @param string $key
|
|
* @param mixed $value
|
|
* @return void
|
|
*/
|
|
public function now($key, $value)
|
|
{
|
|
$this->put($key, $value);
|
|
|
|
$this->push('_flash.old', $key);
|
|
}
|
|
|
|
/**
|
|
* Reflash all of the session flash data.
|
|
*
|
|
* @return void
|
|
*/
|
|
public function reflash()
|
|
{
|
|
$this->mergeNewFlashes($this->get('_flash.old', []));
|
|
|
|
$this->put('_flash.old', []);
|
|
}
|
|
|
|
/**
|
|
* Reflash a subset of the current flash data.
|
|
*
|
|
* @param array|mixed $keys
|
|
* @return void
|
|
*/
|
|
public function keep($keys = null)
|
|
{
|
|
$this->mergeNewFlashes($keys = is_array($keys) ? $keys : func_get_args());
|
|
|
|
$this->removeFromOldFlashData($keys);
|
|
}
|
|
|
|
/**
|
|
* Merge new flash keys into the new flash array.
|
|
*
|
|
* @param array $keys
|
|
* @return void
|
|
*/
|
|
protected function mergeNewFlashes(array $keys)
|
|
{
|
|
$values = array_unique(array_merge($this->get('_flash.new', []), $keys));
|
|
|
|
$this->put('_flash.new', $values);
|
|
}
|
|
|
|
/**
|
|
* Remove the given keys from the old flash data.
|
|
*
|
|
* @param array $keys
|
|
* @return void
|
|
*/
|
|
protected function removeFromOldFlashData(array $keys)
|
|
{
|
|
$this->put('_flash.old', array_diff($this->get('_flash.old', []), $keys));
|
|
}
|
|
|
|
/**
|
|
* Flash an input array to the session.
|
|
*
|
|
* @param array $value
|
|
* @return void
|
|
*/
|
|
public function flashInput(array $value)
|
|
{
|
|
$this->flash('_old_input', $value);
|
|
}
|
|
|
|
/**
|
|
* Remove an item from the session, returning its value.
|
|
*
|
|
* @param string $key
|
|
* @return mixed
|
|
*/
|
|
public function remove($key)
|
|
{
|
|
return Arr::pull($this->attributes, $key);
|
|
}
|
|
|
|
/**
|
|
* Remove one or many items from the session.
|
|
*
|
|
* @param string|array $keys
|
|
* @return void
|
|
*/
|
|
public function forget($keys)
|
|
{
|
|
Arr::forget($this->attributes, $keys);
|
|
}
|
|
|
|
/**
|
|
* Remove all of the items from the session.
|
|
*
|
|
* @return void
|
|
*/
|
|
public function flush()
|
|
{
|
|
$this->attributes = [];
|
|
}
|
|
|
|
/**
|
|
* Flush the session data and regenerate the ID.
|
|
*
|
|
* @return bool
|
|
*/
|
|
public function invalidate()
|
|
{
|
|
$this->flush();
|
|
|
|
return $this->migrate(true);
|
|
}
|
|
|
|
/**
|
|
* Generate a new session identifier.
|
|
*
|
|
* @param bool $destroy
|
|
* @return bool
|
|
*/
|
|
public function regenerate($destroy = false)
|
|
{
|
|
return $this->migrate($destroy);
|
|
}
|
|
|
|
/**
|
|
* Generate a new session ID for the session.
|
|
*
|
|
* @param bool $destroy
|
|
* @return bool
|
|
*/
|
|
public function migrate($destroy = false)
|
|
{
|
|
if ($destroy) {
|
|
$this->handler->destroy($this->getId());
|
|
}
|
|
|
|
$this->setExists(false);
|
|
|
|
$this->setId($this->generateSessionId());
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Determine if the session has been started.
|
|
*
|
|
* @return bool
|
|
*/
|
|
public function isStarted()
|
|
{
|
|
return $this->started;
|
|
}
|
|
|
|
/**
|
|
* Get the name of the session.
|
|
*
|
|
* @return string
|
|
*/
|
|
public function getName()
|
|
{
|
|
return $this->name;
|
|
}
|
|
|
|
/**
|
|
* Set the name of the session.
|
|
*
|
|
* @param string $name
|
|
* @return void
|
|
*/
|
|
public function setName($name)
|
|
{
|
|
$this->name = $name;
|
|
}
|
|
|
|
/**
|
|
* Get the current session ID.
|
|
*
|
|
* @return string
|
|
*/
|
|
public function getId()
|
|
{
|
|
return $this->id;
|
|
}
|
|
|
|
/**
|
|
* Set the session ID.
|
|
*
|
|
* @param string $id
|
|
* @return void
|
|
*/
|
|
public function setId($id)
|
|
{
|
|
$this->id = $this->isValidId($id) ? $id : $this->generateSessionId();
|
|
}
|
|
|
|
/**
|
|
* Determine if this is a valid session ID.
|
|
*
|
|
* @param string $id
|
|
* @return bool
|
|
*/
|
|
public function isValidId($id)
|
|
{
|
|
return is_string($id) && ctype_alnum($id) && strlen($id) === 40;
|
|
}
|
|
|
|
/**
|
|
* Get a new, random session ID.
|
|
*
|
|
* @return string
|
|
*/
|
|
protected function generateSessionId()
|
|
{
|
|
return Str::random(40);
|
|
}
|
|
|
|
/**
|
|
* Set the existence of the session on the handler if applicable.
|
|
*
|
|
* @param bool $value
|
|
* @return void
|
|
*/
|
|
public function setExists($value)
|
|
{
|
|
if ($this->handler instanceof ExistenceAwareInterface) {
|
|
$this->handler->setExists($value);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the CSRF token value.
|
|
*
|
|
* @return string
|
|
*/
|
|
public function token()
|
|
{
|
|
return $this->get('_token');
|
|
}
|
|
|
|
/**
|
|
* Regenerate the CSRF token value.
|
|
*
|
|
* @return void
|
|
*/
|
|
public function regenerateToken()
|
|
{
|
|
$this->put('_token', Str::random(40));
|
|
}
|
|
|
|
/**
|
|
* Get the previous URL from the session.
|
|
*
|
|
* @return string|null
|
|
*/
|
|
public function previousUrl()
|
|
{
|
|
return $this->get('_previous.url');
|
|
}
|
|
|
|
/**
|
|
* Set the "previous" URL in the session.
|
|
*
|
|
* @param string $url
|
|
* @return void
|
|
*/
|
|
public function setPreviousUrl($url)
|
|
{
|
|
$this->put('_previous.url', $url);
|
|
}
|
|
|
|
/**
|
|
* Get the underlying session handler implementation.
|
|
*
|
|
* @return \SessionHandlerInterface
|
|
*/
|
|
public function getHandler()
|
|
{
|
|
return $this->handler;
|
|
}
|
|
|
|
/**
|
|
* Determine if the session handler needs a request.
|
|
*
|
|
* @return bool
|
|
*/
|
|
public function handlerNeedsRequest()
|
|
{
|
|
return $this->handler instanceof CookieSessionHandler;
|
|
}
|
|
|
|
/**
|
|
* Set the request on the handler instance.
|
|
*
|
|
* @param \Illuminate\Http\Request $request
|
|
* @return void
|
|
*/
|
|
public function setRequestOnHandler($request)
|
|
{
|
|
if ($this->handlerNeedsRequest()) {
|
|
$this->handler->setRequest($request);
|
|
}
|
|
}
|
|
}
|