1: <?php
  2: 
  3: /*
  4:  * This file is part of the Symfony package.
  5:  *
  6:  * (c) Fabien Potencier <fabien@symfony.com>
  7:  *
  8:  * For the full copyright and license information, please view the LICENSE
  9:  * file that was distributed with this source code.
 10:  */
 11: 
 12: namespace Symfony\Component\HttpFoundation\Session\Storage;
 13: 
 14: use Symfony\Component\HttpFoundation\Session\SessionBagInterface;
 15: use Symfony\Component\HttpFoundation\Session\Storage\MetadataBag;
 16: use Symfony\Component\HttpFoundation\Session\Storage\Proxy\NativeProxy;
 17: use Symfony\Component\HttpFoundation\Session\Storage\Proxy\AbstractProxy;
 18: use Symfony\Component\HttpFoundation\Session\Storage\Proxy\SessionHandlerProxy;
 19: 
 20: /**
 21:  * This provides a base class for session attribute storage.
 22:  *
 23:  * @author Drak <drak@zikula.org>
 24:  */
 25: class NativeSessionStorage implements SessionStorageInterface
 26: {
 27:     /**
 28:      * Array of SessionBagInterface
 29:      *
 30:      * @var SessionBagInterface[]
 31:      */
 32:     protected $bags;
 33: 
 34:     /**
 35:      * @var Boolean
 36:      */
 37:     protected $started = false;
 38: 
 39:     /**
 40:      * @var Boolean
 41:      */
 42:     protected $closed = false;
 43: 
 44:     /**
 45:      * @var AbstractProxy
 46:      */
 47:     protected $saveHandler;
 48: 
 49:     /**
 50:      * @var MetadataBag
 51:      */
 52:     protected $metadataBag;
 53: 
 54:     /**
 55:      * Constructor.
 56:      *
 57:      * Depending on how you want the storage driver to behave you probably
 58:      * want to override this constructor entirely.
 59:      *
 60:      * List of options for $options array with their defaults.
 61:      * @see http://php.net/session.configuration for options
 62:      * but we omit 'session.' from the beginning of the keys for convenience.
 63:      *
 64:      * ("auto_start", is not supported as it tells PHP to start a session before
 65:      * PHP starts to execute user-land code. Setting during runtime has no effect).
 66:      *
 67:      * cache_limiter, "nocache" (use "0" to prevent headers from being sent entirely).
 68:      * cookie_domain, ""
 69:      * cookie_httponly, ""
 70:      * cookie_lifetime, "0"
 71:      * cookie_path, "/"
 72:      * cookie_secure, ""
 73:      * entropy_file, ""
 74:      * entropy_length, "0"
 75:      * gc_divisor, "100"
 76:      * gc_maxlifetime, "1440"
 77:      * gc_probability, "1"
 78:      * hash_bits_per_character, "4"
 79:      * hash_function, "0"
 80:      * name, "PHPSESSID"
 81:      * referer_check, ""
 82:      * serialize_handler, "php"
 83:      * use_cookies, "1"
 84:      * use_only_cookies, "1"
 85:      * use_trans_sid, "0"
 86:      * upload_progress.enabled, "1"
 87:      * upload_progress.cleanup, "1"
 88:      * upload_progress.prefix, "upload_progress_"
 89:      * upload_progress.name, "PHP_SESSION_UPLOAD_PROGRESS"
 90:      * upload_progress.freq, "1%"
 91:      * upload_progress.min-freq, "1"
 92:      * url_rewriter.tags, "a=href,area=href,frame=src,form=,fieldset="
 93:      *
 94:      * @param array       $options Session configuration options.
 95:      * @param object      $handler SessionHandlerInterface.
 96:      * @param MetadataBag $metaBag MetadataBag.
 97:      */
 98:     public function __construct(array $options = array(), $handler = null, MetadataBag $metaBag = null)
 99:     {
100:         ini_set('session.cache_limiter', ''); // disable by default because it's managed by HeaderBag (if used)
101:         ini_set('session.use_cookies', 1);
102: 
103:         if (version_compare(phpversion(), '5.4.0', '>=')) {
104:             session_register_shutdown();
105:         } else {
106:             register_shutdown_function('session_write_close');
107:         }
108: 
109:         $this->setMetadataBag($metaBag);
110:         $this->setOptions($options);
111:         $this->setSaveHandler($handler);
112:     }
113: 
114:     /**
115:      * Gets the save handler instance.
116:      *
117:      * @return AbstractProxy
118:      */
119:     public function getSaveHandler()
120:     {
121:         return $this->saveHandler;
122:     }
123: 
124:     /**
125:      * {@inheritdoc}
126:      */
127:     public function start()
128:     {
129:         if ($this->started && !$this->closed) {
130:             return true;
131:         }
132: 
133:         // catch condition where session was started automatically by PHP
134:         if (!$this->started && !$this->closed && $this->saveHandler->isActive()
135:             && $this->saveHandler->isSessionHandlerInterface()) {
136:             $this->loadSession();
137: 
138:             return true;
139:         }
140: 
141:         if (ini_get('session.use_cookies') && headers_sent()) {
142:             throw new \RuntimeException('Failed to start the session because headers have already been sent.');
143:         }
144: 
145:         // start the session
146:         if (!session_start()) {
147:             throw new \RuntimeException('Failed to start the session');
148:         }
149: 
150:         $this->loadSession();
151: 
152:         if (!$this->saveHandler->isWrapper() && !$this->saveHandler->isSessionHandlerInterface()) {
153:             $this->saveHandler->setActive(false);
154:         }
155: 
156:         return true;
157:     }
158: 
159:     /**
160:      * {@inheritdoc}
161:      */
162:     public function getId()
163:     {
164:         if (!$this->started) {
165:             return ''; // returning empty is consistent with session_id() behaviour
166:         }
167: 
168:         return $this->saveHandler->getId();
169:     }
170: 
171:     /**
172:      * {@inheritdoc}
173:      */
174:     public function setId($id)
175:     {
176:         $this->saveHandler->setId($id);
177:     }
178: 
179:     /**
180:      * {@inheritdoc}
181:      */
182:     public function getName()
183:     {
184:         return $this->saveHandler->getName();
185:     }
186: 
187:     /**
188:      * {@inheritdoc}
189:      */
190:     public function setName($name)
191:     {
192:         $this->saveHandler->setName($name);
193:     }
194: 
195:     /**
196:      * {@inheritdoc}
197:      */
198:     public function regenerate($destroy = false, $lifetime = null)
199:     {
200:         if (null !== $lifetime) {
201:             ini_set('session.cookie_lifetime', $lifetime);
202:         }
203: 
204:         if ($destroy) {
205:             $this->metadataBag->stampNew();
206:         }
207: 
208:         return session_regenerate_id($destroy);
209:     }
210: 
211:     /**
212:      * {@inheritdoc}
213:      */
214:     public function save()
215:     {
216:         session_write_close();
217: 
218:         if (!$this->saveHandler->isWrapper() && !$this->getSaveHandler()->isSessionHandlerInterface()) {
219:             $this->saveHandler->setActive(false);
220:         }
221: 
222:         $this->closed = true;
223:     }
224: 
225:     /**
226:      * {@inheritdoc}
227:      */
228:     public function clear()
229:     {
230:         // clear out the bags
231:         foreach ($this->bags as $bag) {
232:             $bag->clear();
233:         }
234: 
235:         // clear out the session
236:         $_SESSION = array();
237: 
238:         // reconnect the bags to the session
239:         $this->loadSession();
240:     }
241: 
242:     /**
243:      * {@inheritdoc}
244:      */
245:     public function registerBag(SessionBagInterface $bag)
246:     {
247:         $this->bags[$bag->getName()] = $bag;
248:     }
249: 
250:     /**
251:      * {@inheritdoc}
252:      */
253:     public function getBag($name)
254:     {
255:         if (!isset($this->bags[$name])) {
256:             throw new \InvalidArgumentException(sprintf('The SessionBagInterface %s is not registered.', $name));
257:         }
258: 
259:         if ($this->saveHandler->isActive() && !$this->started) {
260:             $this->loadSession();
261:         } elseif (!$this->started) {
262:             $this->start();
263:         }
264: 
265:         return $this->bags[$name];
266:     }
267: 
268:     /**
269:      * Sets the MetadataBag.
270:      *
271:      * @param MetadataBag $metaBag
272:      */
273:     public function setMetadataBag(MetadataBag $metaBag = null)
274:     {
275:         if (null === $metaBag) {
276:             $metaBag = new MetadataBag();
277:         }
278: 
279:         $this->metadataBag = $metaBag;
280:     }
281: 
282:     /**
283:      * Gets the MetadataBag.
284:      *
285:      * @return MetadataBag
286:      */
287:     public function getMetadataBag()
288:     {
289:         return $this->metadataBag;
290:     }
291: 
292:     /**
293:      * {@inheritdoc}
294:      */
295:     public function isStarted()
296:     {
297:         return $this->started;
298:     }
299: 
300:     /**
301:      * Sets session.* ini variables.
302:      *
303:      * For convenience we omit 'session.' from the beginning of the keys.
304:      * Explicitly ignores other ini keys.
305:      *
306:      * @param array $options Session ini directives array(key => value).
307:      *
308:      * @see http://php.net/session.configuration
309:      */
310:     public function setOptions(array $options)
311:     {
312:         $validOptions = array_flip(array(
313:             'cache_limiter', 'cookie_domain', 'cookie_httponly',
314:             'cookie_lifetime', 'cookie_path', 'cookie_secure',
315:             'entropy_file', 'entropy_length', 'gc_divisor',
316:             'gc_maxlifetime', 'gc_probability', 'hash_bits_per_character',
317:             'hash_function', 'name', 'referer_check',
318:             'serialize_handler', 'use_cookies',
319:             'use_only_cookies', 'use_trans_sid', 'upload_progress.enabled',
320:             'upload_progress.cleanup', 'upload_progress.prefix', 'upload_progress.name',
321:             'upload_progress.freq', 'upload_progress.min-freq', 'url_rewriter.tags',
322:         ));
323: 
324:         foreach ($options as $key => $value) {
325:             if (isset($validOptions[$key])) {
326:                 ini_set('session.'.$key, $value);
327:             }
328:         }
329:     }
330: 
331:     /**
332:      * Registers save handler as a PHP session handler.
333:      *
334:      * To use internal PHP session save handlers, override this method using ini_set with
335:      * session.save_handler and session.save_path e.g.
336:      *
337:      *     ini_set('session.save_handler', 'files');
338:      *     ini_set('session.save_path', /tmp');
339:      *
340:      * @see http://php.net/session-set-save-handler
341:      * @see http://php.net/sessionhandlerinterface
342:      * @see http://php.net/sessionhandler
343:      *
344:      * @param object $saveHandler Default null means NativeProxy.
345:      */
346:     public function setSaveHandler($saveHandler = null)
347:     {
348:         // Wrap $saveHandler in proxy
349:         if (!$saveHandler instanceof AbstractProxy && $saveHandler instanceof \SessionHandlerInterface) {
350:             $saveHandler = new SessionHandlerProxy($saveHandler);
351:         } elseif (!$saveHandler instanceof AbstractProxy) {
352:             $saveHandler = new NativeProxy();
353:         }
354: 
355:         $this->saveHandler = $saveHandler;
356: 
357:         if ($this->saveHandler instanceof \SessionHandlerInterface) {
358:             if (version_compare(phpversion(), '5.4.0', '>=')) {
359:                 session_set_save_handler($this->saveHandler, false);
360:             } else {
361:                 session_set_save_handler(
362:                     array($this->saveHandler, 'open'),
363:                     array($this->saveHandler, 'close'),
364:                     array($this->saveHandler, 'read'),
365:                     array($this->saveHandler, 'write'),
366:                     array($this->saveHandler, 'destroy'),
367:                     array($this->saveHandler, 'gc')
368:                 );
369:             }
370:         }
371:     }
372: 
373:     /**
374:      * Load the session with attributes.
375:      *
376:      * After starting the session, PHP retrieves the session from whatever handlers
377:      * are set to (either PHP's internal, or a custom save handler set with session_set_save_handler()).
378:      * PHP takes the return value from the read() handler, unserializes it
379:      * and populates $_SESSION with the result automatically.
380:      *
381:      * @param array|null $session
382:      */
383:     protected function loadSession(array &$session = null)
384:     {
385:         if (null === $session) {
386:             $session = &$_SESSION;
387:         }
388: 
389:         $bags = array_merge($this->bags, array($this->metadataBag));
390: 
391:         foreach ($bags as $bag) {
392:             $key = $bag->getStorageKey();
393:             $session[$key] = isset($session[$key]) ? $session[$key] : array();
394:             $bag->initialize($session[$key]);
395:         }
396: 
397:         $this->started = true;
398:         $this->closed = false;
399:     }
400: }
401: