Subversion-Projekte lars-tiefland.ci

Revision

Revision 2254 | Zur aktuellen Revision | Details | Vergleich mit vorheriger | Letzte Änderung | Log anzeigen | RSS feed

Revision Autor Zeilennr. Zeile
68 lars 1 
<?php
2 
/**
3 
 * CodeIgniter
4 
 *
5 
 * An open source application development framework for PHP
6 
 *
7 
 * This content is released under the MIT License (MIT)
8 
 *
2257 lars 9 
 * Copyright (c) 2014 - 2018, British Columbia Institute of Technology
68 lars 10 
 *
11 
 * Permission is hereby granted, free of charge, to any person obtaining a copy
12 
 * of this software and associated documentation files (the "Software"), to deal
13 
 * in the Software without restriction, including without limitation the rights
14 
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
15 
 * copies of the Software, and to permit persons to whom the Software is
16 
 * furnished to do so, subject to the following conditions:
17 
 *
18 
 * The above copyright notice and this permission notice shall be included in
19 
 * all copies or substantial portions of the Software.
20 
 *
21 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
22 
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
23 
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
24 
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
25 
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
26 
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
27 
 * THE SOFTWARE.
28 
 *
29 
 * @package	CodeIgniter
30 
 * @author	EllisLab Dev Team
31 
 * @copyright	Copyright (c) 2008 - 2014, EllisLab, Inc. (https://ellislab.com/)
2257 lars 32 
 * @copyright	Copyright (c) 2014 - 2018, British Columbia Institute of Technology (http://bcit.ca/)
68 lars 33 
 * @license	http://opensource.org/licenses/MIT	MIT License
34 
 * @link	https://codeigniter.com
35 
 * @since	Version 2.0.0
36 
 * @filesource
37 
 */
38 
defined('BASEPATH') OR exit('No direct script access allowed');
39 
 
40 
/**
41 
 * CodeIgniter Session Class
42 
 *
43 
 * @package		CodeIgniter
44 
 * @subpackage	Libraries
45 
 * @category	Sessions
46 
 * @author		Andrey Andreev
47 
 * @link		https://codeigniter.com/user_guide/libraries/sessions.html
48 
 */
49 
class CI_Session {
50 
 
51 
	/**
52 
	 * Userdata array
53 
	 *
54 
	 * Just a reference to $_SESSION, for BC purposes.
55 
	 */
56 
	public $userdata;
57 
 
58 
	protected $_driver = 'files';
59 
	protected $_config;
1257 lars 60 
	protected $_sid_regexp;
68 lars 61 
 
62 
	// ------------------------------------------------------------------------
63 
 
64 
	/**
65 
	 * Class constructor
66 
	 *
67 
	 * @param	array	$params	Configuration parameters
68 
	 * @return	void
69 
	 */
70 
	public function __construct(array $params = array())
71 
	{
72 
		// No sessions under CLI
73 
		if (is_cli())
74 
		{
75 
			log_message('debug', 'Session: Initialization under CLI aborted.');
76 
			return;
77 
		}
78 
		elseif ((bool) ini_get('session.auto_start'))
79 
		{
80 
			log_message('error', 'Session: session.auto_start is enabled in php.ini. Aborting.');
81 
			return;
82 
		}
83 
		elseif ( ! empty($params['driver']))
84 
		{
85 
			$this->_driver = $params['driver'];
86 
			unset($params['driver']);
87 
		}
88 
		elseif ($driver = config_item('sess_driver'))
89 
		{
90 
			$this->_driver = $driver;
91 
		}
92 
		// Note: BC workaround
93 
		elseif (config_item('sess_use_database'))
94 
		{
95 
			log_message('debug', 'Session: "sess_driver" is empty; using BC fallback to "sess_use_database".');
96 
			$this->_driver = 'database';
97 
		}
98 
 
99 
		$class = $this->_ci_load_classes($this->_driver);
100 
 
101 
		// Configuration ...
102 
		$this->_configure($params);
1257 lars 103 
		$this->_config['_sid_regexp'] = $this->_sid_regexp;
68 lars 104 
 
105 
		$class = new $class($this->_config);
106 
		if ($class instanceof SessionHandlerInterface)
107 
		{
108 
			if (is_php('5.4'))
109 
			{
110 
				session_set_save_handler($class, TRUE);
111 
			}
112 
			else
113 
			{
114 
				session_set_save_handler(
115 
					array($class, 'open'),
116 
					array($class, 'close'),
117 
					array($class, 'read'),
118 
					array($class, 'write'),
119 
					array($class, 'destroy'),
120 
					array($class, 'gc')
121 
				);
122 
 
123 
				register_shutdown_function('session_write_close');
124 
			}
125 
		}
126 
		else
127 
		{
128 
			log_message('error', "Session: Driver '".$this->_driver."' doesn't implement SessionHandlerInterface. Aborting.");
129 
			return;
130 
		}
131 
 
132 
		// Sanitize the cookie, because apparently PHP doesn't do that for userspace handlers
133 
		if (isset($_COOKIE[$this->_config['cookie_name']])
134 
			&& (
135 
				! is_string($_COOKIE[$this->_config['cookie_name']])
1257 lars 136 
				OR ! preg_match('#\A'.$this->_sid_regexp.'\z#', $_COOKIE[$this->_config['cookie_name']])
68 lars 137 
			)
138 
		)
139 
		{
140 
			unset($_COOKIE[$this->_config['cookie_name']]);
141 
		}
142 
 
143 
		session_start();
144 
 
145 
		// Is session ID auto-regeneration configured? (ignoring ajax requests)
146 
		if ((empty($_SERVER['HTTP_X_REQUESTED_WITH']) OR strtolower($_SERVER['HTTP_X_REQUESTED_WITH']) !== 'xmlhttprequest')
147 
			&& ($regenerate_time = config_item('sess_time_to_update')) > 0
148 
		)
149 
		{
150 
			if ( ! isset($_SESSION['__ci_last_regenerate']))
151 
			{
152 
				$_SESSION['__ci_last_regenerate'] = time();
153 
			}
154 
			elseif ($_SESSION['__ci_last_regenerate'] < (time() - $regenerate_time))
155 
			{
156 
				$this->sess_regenerate((bool) config_item('sess_regenerate_destroy'));
157 
			}
158 
		}
159 
		// Another work-around ... PHP doesn't seem to send the session cookie
160 
		// unless it is being currently created or regenerated
161 
		elseif (isset($_COOKIE[$this->_config['cookie_name']]) && $_COOKIE[$this->_config['cookie_name']] === session_id())
162 
		{
163 
			setcookie(
164 
				$this->_config['cookie_name'],
165 
				session_id(),
166 
				(empty($this->_config['cookie_lifetime']) ? 0 : time() + $this->_config['cookie_lifetime']),
167 
				$this->_config['cookie_path'],
168 
				$this->_config['cookie_domain'],
169 
				$this->_config['cookie_secure'],
170 
				TRUE
171 
			);
172 
		}
173 
 
174 
		$this->_ci_init_vars();
175 
 
176 
		log_message('info', "Session: Class initialized using '".$this->_driver."' driver.");
177 
	}
178 
 
179 
	// ------------------------------------------------------------------------
180 
 
181 
	/**
182 
	 * CI Load Classes
183 
	 *
184 
	 * An internal method to load all possible dependency and extension
185 
	 * classes. It kind of emulates the CI_Driver library, but is
186 
	 * self-sufficient.
187 
	 *
188 
	 * @param	string	$driver	Driver name
189 
	 * @return	string	Driver class name
190 
	 */
191 
	protected function _ci_load_classes($driver)
192 
	{
193 
		// PHP 5.4 compatibility
194 
		interface_exists('SessionHandlerInterface', FALSE) OR require_once(BASEPATH.'libraries/Session/SessionHandlerInterface.php');
195 
 
196 
		$prefix = config_item('subclass_prefix');
197 
 
198 
		if ( ! class_exists('CI_Session_driver', FALSE))
199 
		{
200 
			require_once(
201 
				file_exists(APPPATH.'libraries/Session/Session_driver.php')
202 
					? APPPATH.'libraries/Session/Session_driver.php'
203 
					: BASEPATH.'libraries/Session/Session_driver.php'
204 
			);
205 
 
206 
			if (file_exists($file_path = APPPATH.'libraries/Session/'.$prefix.'Session_driver.php'))
207 
			{
208 
				require_once($file_path);
209 
			}
210 
		}
211 
 
212 
		$class = 'Session_'.$driver.'_driver';
213 
 
214 
		// Allow custom drivers without the CI_ or MY_ prefix
215 
		if ( ! class_exists($class, FALSE) && file_exists($file_path = APPPATH.'libraries/Session/drivers/'.$class.'.php'))
216 
		{
217 
			require_once($file_path);
218 
			if (class_exists($class, FALSE))
219 
			{
220 
				return $class;
221 
			}
222 
		}
223 
 
224 
		if ( ! class_exists('CI_'.$class, FALSE))
225 
		{
226 
			if (file_exists($file_path = APPPATH.'libraries/Session/drivers/'.$class.'.php') OR file_exists($file_path = BASEPATH.'libraries/Session/drivers/'.$class.'.php'))
227 
			{
228 
				require_once($file_path);
229 
			}
230 
 
231 
			if ( ! class_exists('CI_'.$class, FALSE) && ! class_exists($class, FALSE))
232 
			{
233 
				throw new UnexpectedValueException("Session: Configured driver '".$driver."' was not found. Aborting.");
234 
			}
235 
		}
236 
 
237 
		if ( ! class_exists($prefix.$class, FALSE) && file_exists($file_path = APPPATH.'libraries/Session/drivers/'.$prefix.$class.'.php'))
238 
		{
239 
			require_once($file_path);
240 
			if (class_exists($prefix.$class, FALSE))
241 
			{
242 
				return $prefix.$class;
243 
			}
2257 lars 244 
 
245 
			log_message('debug', 'Session: '.$prefix.$class.".php found but it doesn't declare class ".$prefix.$class.'.');
68 lars 246 
		}
247 
 
248 
		return 'CI_'.$class;
249 
	}
250 
 
251 
	// ------------------------------------------------------------------------
252 
 
253 
	/**
254 
	 * Configuration
255 
	 *
256 
	 * Handle input parameters and configuration defaults
257 
	 *
258 
	 * @param	array	&$params	Input parameters
259 
	 * @return	void
260 
	 */
261 
	protected function _configure(&$params)
262 
	{
263 
		$expiration = config_item('sess_expiration');
264 
 
265 
		if (isset($params['cookie_lifetime']))
266 
		{
267 
			$params['cookie_lifetime'] = (int) $params['cookie_lifetime'];
268 
		}
269 
		else
270 
		{
271 
			$params['cookie_lifetime'] = ( ! isset($expiration) && config_item('sess_expire_on_close'))
272 
				? 0 : (int) $expiration;
273 
		}
274 
 
275 
		isset($params['cookie_name']) OR $params['cookie_name'] = config_item('sess_cookie_name');
276 
		if (empty($params['cookie_name']))
277 
		{
278 
			$params['cookie_name'] = ini_get('session.name');
279 
		}
280 
		else
281 
		{
282 
			ini_set('session.name', $params['cookie_name']);
283 
		}
284 
 
285 
		isset($params['cookie_path']) OR $params['cookie_path'] = config_item('cookie_path');
286 
		isset($params['cookie_domain']) OR $params['cookie_domain'] = config_item('cookie_domain');
287 
		isset($params['cookie_secure']) OR $params['cookie_secure'] = (bool) config_item('cookie_secure');
288 
 
289 
		session_set_cookie_params(
290 
			$params['cookie_lifetime'],
291 
			$params['cookie_path'],
292 
			$params['cookie_domain'],
293 
			$params['cookie_secure'],
294 
			TRUE // HttpOnly; Yes, this is intentional and not configurable for security reasons
295 
		);
296 
 
297 
		if (empty($expiration))
298 
		{
299 
			$params['expiration'] = (int) ini_get('session.gc_maxlifetime');
300 
		}
301 
		else
302 
		{
303 
			$params['expiration'] = (int) $expiration;
304 
			ini_set('session.gc_maxlifetime', $expiration);
305 
		}
306 
 
307 
		$params['match_ip'] = (bool) (isset($params['match_ip']) ? $params['match_ip'] : config_item('sess_match_ip'));
308 
 
309 
		isset($params['save_path']) OR $params['save_path'] = config_item('sess_save_path');
310 
 
311 
		$this->_config = $params;
312 
 
313 
		// Security is king
314 
		ini_set('session.use_trans_sid', 0);
315 
		ini_set('session.use_strict_mode', 1);
316 
		ini_set('session.use_cookies', 1);
317 
		ini_set('session.use_only_cookies', 1);
1257 lars 318 
 
319 
		$this->_configure_sid_length();
68 lars 320 
	}
321 
 
322 
	// ------------------------------------------------------------------------
323 
 
324 
	/**
1257 lars 325 
	 * Configure session ID length
326 
	 *
327 
	 * To make life easier, we used to force SHA-1 and 4 bits per
328 
	 * character on everyone. And of course, someone was unhappy.
329 
	 *
330 
	 * Then PHP 7.1 broke backwards-compatibility because ext/session
331 
	 * is such a mess that nobody wants to touch it with a pole stick,
332 
	 * and the one guy who does, nobody has the energy to argue with.
333 
	 *
334 
	 * So we were forced to make changes, and OF COURSE something was
335 
	 * going to break and now we have this pile of shit. -- Narf
336 
	 *
337 
	 * @return	void
338 
	 */
339 
	protected function _configure_sid_length()
340 
	{
341 
		if (PHP_VERSION_ID < 70100)
342 
		{
343 
			$hash_function = ini_get('session.hash_function');
344 
			if (ctype_digit($hash_function))
345 
			{
346 
				if ($hash_function !== '1')
347 
				{
348 
					ini_set('session.hash_function', 1);
349 
				}
350 
 
351 
				$bits = 160;
352 
			}
353 
			elseif ( ! in_array($hash_function, hash_algos(), TRUE))
354 
			{
355 
				ini_set('session.hash_function', 1);
356 
				$bits = 160;
357 
			}
358 
			elseif (($bits = strlen(hash($hash_function, 'dummy', false)) * 4) < 160)
359 
			{
360 
				ini_set('session.hash_function', 1);
361 
				$bits = 160;
362 
			}
363 
 
364 
			$bits_per_character = (int) ini_get('session.hash_bits_per_character');
365 
			$sid_length         = (int) ceil($bits / $bits_per_character);
366 
		}
367 
		else
368 
		{
369 
			$bits_per_character = (int) ini_get('session.sid_bits_per_character');
370 
			$sid_length         = (int) ini_get('session.sid_length');
371 
			if (($bits = $sid_length * $bits_per_character) < 160)
372 
			{
373 
				// Add as many more characters as necessary to reach at least 160 bits
374 
				$sid_length += (int) ceil((160 % $bits) / $bits_per_character);
375 
				ini_set('session.sid_length', $sid_length);
376 
			}
377 
		}
378 
 
379 
		// Yes, 4,5,6 are the only known possible values as of 2016-10-27
380 
		switch ($bits_per_character)
381 
		{
382 
			case 4:
383 
				$this->_sid_regexp = '[0-9a-f]';
384 
				break;
385 
			case 5:
386 
				$this->_sid_regexp = '[0-9a-v]';
387 
				break;
388 
			case 6:
389 
				$this->_sid_regexp = '[0-9a-zA-Z,-]';
390 
				break;
391 
		}
392 
 
393 
		$this->_sid_regexp .= '{'.$sid_length.'}';
394 
	}
395 
 
396 
	// ------------------------------------------------------------------------
397 
 
398 
	/**
68 lars 399 
	 * Handle temporary variables
400 
	 *
401 
	 * Clears old "flash" data, marks the new one for deletion and handles
402 
	 * "temp" data deletion.
403 
	 *
404 
	 * @return	void
405 
	 */
406 
	protected function _ci_init_vars()
407 
	{
408 
		if ( ! empty($_SESSION['__ci_vars']))
409 
		{
410 
			$current_time = time();
411 
 
412 
			foreach ($_SESSION['__ci_vars'] as $key => &$value)
413 
			{
414 
				if ($value === 'new')
415 
				{
416 
					$_SESSION['__ci_vars'][$key] = 'old';
417 
				}
418 
				// Hacky, but 'old' will (implicitly) always be less than time() ;)
419 
				// DO NOT move this above the 'new' check!
420 
				elseif ($value < $current_time)
421 
				{
422 
					unset($_SESSION[$key], $_SESSION['__ci_vars'][$key]);
423 
				}
424 
			}
425 
 
426 
			if (empty($_SESSION['__ci_vars']))
427 
			{
428 
				unset($_SESSION['__ci_vars']);
429 
			}
430 
		}
431 
 
432 
		$this->userdata =& $_SESSION;
433 
	}
434 
 
435 
	// ------------------------------------------------------------------------
436 
 
437 
	/**
438 
	 * Mark as flash
439 
	 *
440 
	 * @param	mixed	$key	Session data key(s)
441 
	 * @return	bool
442 
	 */
443 
	public function mark_as_flash($key)
444 
	{
445 
		if (is_array($key))
446 
		{
447 
			for ($i = 0, $c = count($key); $i < $c; $i++)
448 
			{
449 
				if ( ! isset($_SESSION[$key[$i]]))
450 
				{
451 
					return FALSE;
452 
				}
453 
			}
454 
 
455 
			$new = array_fill_keys($key, 'new');
456 
 
457 
			$_SESSION['__ci_vars'] = isset($_SESSION['__ci_vars'])
458 
				? array_merge($_SESSION['__ci_vars'], $new)
459 
				: $new;
460 
 
461 
			return TRUE;
462 
		}
463 
 
464 
		if ( ! isset($_SESSION[$key]))
465 
		{
466 
			return FALSE;
467 
		}
468 
 
469 
		$_SESSION['__ci_vars'][$key] = 'new';
470 
		return TRUE;
471 
	}
472 
 
473 
	// ------------------------------------------------------------------------
474 
 
475 
	/**
476 
	 * Get flash keys
477 
	 *
478 
	 * @return	array
479 
	 */
480 
	public function get_flash_keys()
481 
	{
482 
		if ( ! isset($_SESSION['__ci_vars']))
483 
		{
484 
			return array();
485 
		}
486 
 
487 
		$keys = array();
488 
		foreach (array_keys($_SESSION['__ci_vars']) as $key)
489 
		{
490 
			is_int($_SESSION['__ci_vars'][$key]) OR $keys[] = $key;
491 
		}
492 
 
493 
		return $keys;
494 
	}
495 
 
496 
	// ------------------------------------------------------------------------
497 
 
498 
	/**
499 
	 * Unmark flash
500 
	 *
501 
	 * @param	mixed	$key	Session data key(s)
502 
	 * @return	void
503 
	 */
504 
	public function unmark_flash($key)
505 
	{
506 
		if (empty($_SESSION['__ci_vars']))
507 
		{
508 
			return;
509 
		}
510 
 
511 
		is_array($key) OR $key = array($key);
512 
 
513 
		foreach ($key as $k)
514 
		{
515 
			if (isset($_SESSION['__ci_vars'][$k]) && ! is_int($_SESSION['__ci_vars'][$k]))
516 
			{
517 
				unset($_SESSION['__ci_vars'][$k]);
518 
			}
519 
		}
520 
 
521 
		if (empty($_SESSION['__ci_vars']))
522 
		{
523 
			unset($_SESSION['__ci_vars']);
524 
		}
525 
	}
526 
 
527 
	// ------------------------------------------------------------------------
528 
 
529 
	/**
530 
	 * Mark as temp
531 
	 *
532 
	 * @param	mixed	$key	Session data key(s)
533 
	 * @param	int	$ttl	Time-to-live in seconds
534 
	 * @return	bool
535 
	 */
536 
	public function mark_as_temp($key, $ttl = 300)
537 
	{
538 
		$ttl += time();
539 
 
540 
		if (is_array($key))
541 
		{
542 
			$temp = array();
543 
 
544 
			foreach ($key as $k => $v)
545 
			{
546 
				// Do we have a key => ttl pair, or just a key?
547 
				if (is_int($k))
548 
				{
549 
					$k = $v;
550 
					$v = $ttl;
551 
				}
552 
				else
553 
				{
554 
					$v += time();
555 
				}
556 
 
557 
				if ( ! isset($_SESSION[$k]))
558 
				{
559 
					return FALSE;
560 
				}
561 
 
562 
				$temp[$k] = $v;
563 
			}
564 
 
565 
			$_SESSION['__ci_vars'] = isset($_SESSION['__ci_vars'])
566 
				? array_merge($_SESSION['__ci_vars'], $temp)
567 
				: $temp;
568 
 
569 
			return TRUE;
570 
		}
571 
 
572 
		if ( ! isset($_SESSION[$key]))
573 
		{
574 
			return FALSE;
575 
		}
576 
 
577 
		$_SESSION['__ci_vars'][$key] = $ttl;
578 
		return TRUE;
579 
	}
580 
 
581 
	// ------------------------------------------------------------------------
582 
 
583 
	/**
584 
	 * Get temp keys
585 
	 *
586 
	 * @return	array
587 
	 */
588 
	public function get_temp_keys()
589 
	{
590 
		if ( ! isset($_SESSION['__ci_vars']))
591 
		{
592 
			return array();
593 
		}
594 
 
595 
		$keys = array();
596 
		foreach (array_keys($_SESSION['__ci_vars']) as $key)
597 
		{
598 
			is_int($_SESSION['__ci_vars'][$key]) && $keys[] = $key;
599 
		}
600 
 
601 
		return $keys;
602 
	}
603 
 
604 
	// ------------------------------------------------------------------------
605 
 
606 
	/**
2254 lars 607 
	 * Unmark flash
68 lars 608 
	 *
609 
	 * @param	mixed	$key	Session data key(s)
610 
	 * @return	void
611 
	 */
612 
	public function unmark_temp($key)
613 
	{
614 
		if (empty($_SESSION['__ci_vars']))
615 
		{
616 
			return;
617 
		}
618 
 
619 
		is_array($key) OR $key = array($key);
620 
 
621 
		foreach ($key as $k)
622 
		{
623 
			if (isset($_SESSION['__ci_vars'][$k]) && is_int($_SESSION['__ci_vars'][$k]))
624 
			{
625 
				unset($_SESSION['__ci_vars'][$k]);
626 
			}
627 
		}
628 
 
629 
		if (empty($_SESSION['__ci_vars']))
630 
		{
631 
			unset($_SESSION['__ci_vars']);
632 
		}
633 
	}
634 
 
635 
	// ------------------------------------------------------------------------
636 
 
637 
	/**
638 
	 * __get()
639 
	 *
640 
	 * @param	string	$key	'session_id' or a session data key
641 
	 * @return	mixed
642 
	 */
643 
	public function __get($key)
644 
	{
645 
		// Note: Keep this order the same, just in case somebody wants to
646 
		//       use 'session_id' as a session data key, for whatever reason
647 
		if (isset($_SESSION[$key]))
648 
		{
649 
			return $_SESSION[$key];
650 
		}
651 
		elseif ($key === 'session_id')
652 
		{
653 
			return session_id();
654 
		}
655 
 
656 
		return NULL;
657 
	}
658 
 
659 
	// ------------------------------------------------------------------------
660 
 
661 
	/**
662 
	 * __isset()
663 
	 *
664 
	 * @param	string	$key	'session_id' or a session data key
665 
	 * @return	bool
666 
	 */
667 
	public function __isset($key)
668 
	{
669 
		if ($key === 'session_id')
670 
		{
671 
			return (session_status() === PHP_SESSION_ACTIVE);
672 
		}
673 
 
674 
		return isset($_SESSION[$key]);
675 
	}
676 
 
677 
	// ------------------------------------------------------------------------
678 
 
679 
	/**
680 
	 * __set()
681 
	 *
682 
	 * @param	string	$key	Session data key
683 
	 * @param	mixed	$value	Session data value
684 
	 * @return	void
685 
	 */
686 
	public function __set($key, $value)
687 
	{
688 
		$_SESSION[$key] = $value;
689 
	}
690 
 
691 
	// ------------------------------------------------------------------------
692 
 
693 
	/**
694 
	 * Session destroy
695 
	 *
696 
	 * Legacy CI_Session compatibility method
697 
	 *
698 
	 * @return	void
699 
	 */
700 
	public function sess_destroy()
701 
	{
702 
		session_destroy();
703 
	}
704 
 
705 
	// ------------------------------------------------------------------------
706 
 
707 
	/**
708 
	 * Session regenerate
709 
	 *
710 
	 * Legacy CI_Session compatibility method
711 
	 *
712 
	 * @param	bool	$destroy	Destroy old session data flag
713 
	 * @return	void
714 
	 */
715 
	public function sess_regenerate($destroy = FALSE)
716 
	{
717 
		$_SESSION['__ci_last_regenerate'] = time();
718 
		session_regenerate_id($destroy);
719 
	}
720 
 
721 
	// ------------------------------------------------------------------------
722 
 
723 
	/**
724 
	 * Get userdata reference
725 
	 *
726 
	 * Legacy CI_Session compatibility method
727 
	 *
728 
	 * @returns	array
729 
	 */
730 
	public function &get_userdata()
731 
	{
732 
		return $_SESSION;
733 
	}
734 
 
735 
	// ------------------------------------------------------------------------
736 
 
737 
	/**
738 
	 * Userdata (fetch)
739 
	 *
740 
	 * Legacy CI_Session compatibility method
741 
	 *
742 
	 * @param	string	$key	Session data key
743 
	 * @return	mixed	Session data value or NULL if not found
744 
	 */
745 
	public function userdata($key = NULL)
746 
	{
747 
		if (isset($key))
748 
		{
749 
			return isset($_SESSION[$key]) ? $_SESSION[$key] : NULL;
750 
		}
751 
		elseif (empty($_SESSION))
752 
		{
753 
			return array();
754 
		}
755 
 
756 
		$userdata = array();
757 
		$_exclude = array_merge(
758 
			array('__ci_vars'),
759 
			$this->get_flash_keys(),
760 
			$this->get_temp_keys()
761 
		);
762 
 
763 
		foreach (array_keys($_SESSION) as $key)
764 
		{
765 
			if ( ! in_array($key, $_exclude, TRUE))
766 
			{
767 
				$userdata[$key] = $_SESSION[$key];
768 
			}
769 
		}
770 
 
771 
		return $userdata;
772 
	}
773 
 
774 
	// ------------------------------------------------------------------------
775 
 
776 
	/**
777 
	 * Set userdata
778 
	 *
779 
	 * Legacy CI_Session compatibility method
780 
	 *
781 
	 * @param	mixed	$data	Session data key or an associative array
782 
	 * @param	mixed	$value	Value to store
783 
	 * @return	void
784 
	 */
785 
	public function set_userdata($data, $value = NULL)
786 
	{
787 
		if (is_array($data))
788 
		{
789 
			foreach ($data as $key => &$value)
790 
			{
791 
				$_SESSION[$key] = $value;
792 
			}
793 
 
794 
			return;
795 
		}
796 
 
797 
		$_SESSION[$data] = $value;
798 
	}
799 
 
800 
	// ------------------------------------------------------------------------
801 
 
802 
	/**
803 
	 * Unset userdata
804 
	 *
805 
	 * Legacy CI_Session compatibility method
806 
	 *
807 
	 * @param	mixed	$key	Session data key(s)
808 
	 * @return	void
809 
	 */
810 
	public function unset_userdata($key)
811 
	{
812 
		if (is_array($key))
813 
		{
814 
			foreach ($key as $k)
815 
			{
816 
				unset($_SESSION[$k]);
817 
			}
818 
 
819 
			return;
820 
		}
821 
 
822 
		unset($_SESSION[$key]);
823 
	}
824 
 
825 
	// ------------------------------------------------------------------------
826 
 
827 
	/**
828 
	 * All userdata (fetch)
829 
	 *
830 
	 * Legacy CI_Session compatibility method
831 
	 *
832 
	 * @return	array	$_SESSION, excluding flash data items
833 
	 */
834 
	public function all_userdata()
835 
	{
836 
		return $this->userdata();
837 
	}
838 
 
839 
	// ------------------------------------------------------------------------
840 
 
841 
	/**
842 
	 * Has userdata
843 
	 *
844 
	 * Legacy CI_Session compatibility method
845 
	 *
846 
	 * @param	string	$key	Session data key
847 
	 * @return	bool
848 
	 */
849 
	public function has_userdata($key)
850 
	{
851 
		return isset($_SESSION[$key]);
852 
	}
853 
 
854 
	// ------------------------------------------------------------------------
855 
 
856 
	/**
857 
	 * Flashdata (fetch)
858 
	 *
859 
	 * Legacy CI_Session compatibility method
860 
	 *
861 
	 * @param	string	$key	Session data key
862 
	 * @return	mixed	Session data value or NULL if not found
863 
	 */
864 
	public function flashdata($key = NULL)
865 
	{
866 
		if (isset($key))
867 
		{
868 
			return (isset($_SESSION['__ci_vars'], $_SESSION['__ci_vars'][$key], $_SESSION[$key]) && ! is_int($_SESSION['__ci_vars'][$key]))
869 
				? $_SESSION[$key]
870 
				: NULL;
871 
		}
872 
 
873 
		$flashdata = array();
874 
 
875 
		if ( ! empty($_SESSION['__ci_vars']))
876 
		{
877 
			foreach ($_SESSION['__ci_vars'] as $key => &$value)
878 
			{
879 
				is_int($value) OR $flashdata[$key] = $_SESSION[$key];
880 
			}
881 
		}
882 
 
883 
		return $flashdata;
884 
	}
885 
 
886 
	// ------------------------------------------------------------------------
887 
 
888 
	/**
889 
	 * Set flashdata
890 
	 *
891 
	 * Legacy CI_Session compatibility method
892 
	 *
893 
	 * @param	mixed	$data	Session data key or an associative array
894 
	 * @param	mixed	$value	Value to store
895 
	 * @return	void
896 
	 */
897 
	public function set_flashdata($data, $value = NULL)
898 
	{
899 
		$this->set_userdata($data, $value);
900 
		$this->mark_as_flash(is_array($data) ? array_keys($data) : $data);
901 
	}
902 
 
903 
	// ------------------------------------------------------------------------
904 
 
905 
	/**
906 
	 * Keep flashdata
907 
	 *
908 
	 * Legacy CI_Session compatibility method
909 
	 *
910 
	 * @param	mixed	$key	Session data key(s)
911 
	 * @return	void
912 
	 */
913 
	public function keep_flashdata($key)
914 
	{
915 
		$this->mark_as_flash($key);
916 
	}
917 
 
918 
	// ------------------------------------------------------------------------
919 
 
920 
	/**
921 
	 * Temp data (fetch)
922 
	 *
923 
	 * Legacy CI_Session compatibility method
924 
	 *
925 
	 * @param	string	$key	Session data key
926 
	 * @return	mixed	Session data value or NULL if not found
927 
	 */
928 
	public function tempdata($key = NULL)
929 
	{
930 
		if (isset($key))
931 
		{
932 
			return (isset($_SESSION['__ci_vars'], $_SESSION['__ci_vars'][$key], $_SESSION[$key]) && is_int($_SESSION['__ci_vars'][$key]))
933 
				? $_SESSION[$key]
934 
				: NULL;
935 
		}
936 
 
937 
		$tempdata = array();
938 
 
939 
		if ( ! empty($_SESSION['__ci_vars']))
940 
		{
941 
			foreach ($_SESSION['__ci_vars'] as $key => &$value)
942 
			{
943 
				is_int($value) && $tempdata[$key] = $_SESSION[$key];
944 
			}
945 
		}
946 
 
947 
		return $tempdata;
948 
	}
949 
 
950 
	// ------------------------------------------------------------------------
951 
 
952 
	/**
953 
	 * Set tempdata
954 
	 *
955 
	 * Legacy CI_Session compatibility method
956 
	 *
957 
	 * @param	mixed	$data	Session data key or an associative array of items
958 
	 * @param	mixed	$value	Value to store
959 
	 * @param	int	$ttl	Time-to-live in seconds
960 
	 * @return	void
961 
	 */
962 
	public function set_tempdata($data, $value = NULL, $ttl = 300)
963 
	{
964 
		$this->set_userdata($data, $value);
965 
		$this->mark_as_temp(is_array($data) ? array_keys($data) : $data, $ttl);
966 
	}
967 
 
968 
	// ------------------------------------------------------------------------
969 
 
970 
	/**
971 
	 * Unset tempdata
972 
	 *
973 
	 * Legacy CI_Session compatibility method
974 
	 *
975 
	 * @param	mixed	$data	Session data key(s)
976 
	 * @return	void
977 
	 */
978 
	public function unset_tempdata($key)
979 
	{
980 
		$this->unmark_temp($key);
981 
	}
982 
 
983 
}