Witam
Ostanio pisałem własną obsługe sesji opartą na bazie mysql. Oto kod:

[PHP] pobierz, plaintext 
<?php
/**
*@author Apo
*@package Obsluga sesji
*/
 
require_once('db.php');
 
db::connect('localhost', 'root', '', 'session');
 
$session = new session();
 
  // przykład
 
  $session->imie = 'Alfred';
 
  try
  {
  echo $session->imie;
  } catch(SessionException $e)
	{
	echo $e->getMessage();
	}
 
 // klasa
 
final class session {
 
  // unikalny numer identyfikacyjny uzytkownika
private $id = null;
 
  // nazwa tabeli w bazie danych gdzie beda trzymane sesje
private $table = '`session`';
 
  // ilosc czasu (w sekundach) przez jaką ma być wazna sesja
private $limit = 3600;
 
  // tablica z danymi
private $sessionTable = array();
 
 /**
 * Konstruktor sprawdza czy dany uzytkownik ma juz utworzoną sesje, jesli nie je
st ona tworzona
 *
 */
  public function __construct()
  {
	$this->id = $this->hash();
 
	if(!$this->getSessionRows())
	  $this->createSession();
  }
 
 /**
  * Tworzy unikalny numer identyfikacyjny dla kazdego uzytwownika
  *
  * return String
  */
  private function hash()
  {
	return md5($_SERVER['REMOTE_ADDR'] . addslashes($_SERVER['HTTP_USER_AGENT']));
  }
 
 /**
  * Sprawdza czy uzytkownik ma utworzona sesje na podstawie ilosci rekordow w bazi
e
  *
  * return Boolean
  */
  private function getSessionRows()
  {
	db::query('SELECT `czas`, `dane` FROM '.$this->table.'
			   WHERE `id`=''.$this->id.'' AND `czas`>'.(time()-$this->limit));
 
	  if(db::num_rows() == 1)
	  {
		$dane = '';
		  while($array = db::fetch_row())
		  $dane = $array;
 
		$this->sessionTable = unserialize($dane['dane']);
		return true;
	  }
	  else
		return false;
  }
 
 /**
  * Tworzy sesje dla uzytkownika
  *
  * return query
  */
  private function createSession()
  {
	db::query('DELETE FROM '.$this->table.' WHERE id=''.$this->id.''');
	return db::query('INSERT INTO '.$this->table.'(`id`, `czas`) VALUES(''.$this->id.'', ''.time().'')');
  }
 
 /**
  * Przychwytuje przypisywanie wartosci do niezdefiniowanych skladowych i dodaje d
o tablicy ktora zostanie zapisana
  *
  */
  public function __set($name, $value)
  {
	return $this->sessionTable[$name] = $value;
  }
 
 /**
  * Przychwytuje niezdefiniowane metody i wywoluje odpowiedni klucz z tablicy
  *
  * return String, Int
  */
  public function __get($name)
  {
	if(array_key_exists($name, $this->sessionTable))
	  return $this->sessionTable[$name];
	throw new SessionException('Nie zdefiniowano klucza: '.$name);
  }
 
 /**
  * Niszczy sesje dla danego uzytkownika
  *
  */
  public function destroy()
  {
	return db::query('DELETE FROM '.$this->table.' WHERE `id`=''.$this->id.''');
  }
 
 /**
  * Zapisuje zserializowane dane do bazy
  *
  */
  public function __destruct()
  {
	db::query('UPDATE '.$this->table.' SET `czas`='.time().', dane=''.serialize($this->sessionTable).'' WHERE `id`=''.$this->id.''');
  }
}
 
class SessionException extends Exception {}
 
/* TABELA
 
CREATE TABLE `session` (
  `id` varchar(32) default NULL,
  `czas` int(11) default NULL,
  `dane` longtext,
  UNIQUE KEY `id` (`id`)
) TYPE=MyISAM;
 
 
*/
?>
[PHP] pobierz, plaintext 

No i chciałem się zapytać co sądzicie o takim rozwiązaniu. Muszę jeszcze popracować nad zmniejszeniem ilości zapytań, bo w aktualnej chwili wynoszą średnio one 3.

Pozdrawiam

A nie pożna poprostu użyć session_set_save_handler ?
Sprawdzony sposób

[PHP] pobierz, plaintext 
<?php
md5($_SERVER['REMOTE_ADDR'] . addslashes($_SERVER['HTTP_USER_AGENT']));
?>
[PHP] pobierz, plaintext 

a co jesli ktos ma siec przy uzyciu NAT i na kilku kompach jest ta sama przegladarka??

no wlasnie też sie chciałem zapytać co tu jeszcze można dodać ;p

Jakiś czas temu było wyjaśniane na forum, że nie zrobisz tego bezpiecznie bez ciastek. Po prostu nie da się, bo wszystkie te informacje można nie przemęczając się nadpisać. Ciastka są najbezpieczniejszym sposobem na przenoszenie sesji między żądaniami.

Myśle, że SID można wygenerować poprzez time() + ip + przeglądarka ew. + host.

Jeżeli dodasz time(), to po sekundzie nie odzyskasz tego identyfikatora... Poza tym, za dużo kombinowania - wystarczy dodać liczbę losową z dużego przedziału i sprawdzać, czy nie występują kolizje. Identyfikator sesji przenosić ciastkami. Opieranie się na User-Agent, adresie IP i hoście jest dużym błędem w zabezpieczeniach i nikt nie wdraża takich rozwiązań do swoich systemów...

Ja sie zastanawiam po co ludzie pisza swoje wlasne klasy do obslugi sesji skoro zaimplementowany w php mechanizm jest dobry. Nalezy jedynie zwrocic uwagę na to aby zmienic domyslny katalog dla plikow sesji.

Ludvik: nikt przecież nie zabronił Ci przechowac SID'a w ciastku.

Czytając kod, który napisał Apo, można odczytać jego intencje. Poza tym mam w głowie poprzedni temat. Dla mnie oczywiste jest użycie ciastek

No ok to chyba bede zapisywał ID w cookies, ale czy jest jakaś możliwość zrobienie takiej rzeczy (jak jest domyślne w php) ze jeśli jest wyłączone cookie to ID zostanie doklejaony do $_GET ?

php samemu dokleja identyfikator sesji.

No ale my tu mówimy o mojej obsłudze sesji której kod jest na samej górze ;p

Moze wylacz ciastka sobie w browserze i sprawdz co sie dzieje OK ?

A co myślicie o następującym rozwiązaniu:

[PHP] pobierz, plaintext 
<?php
 
class elSess
{
	public $sess_dir = '/tmp/';
	public $sess_time = 360;
 
	private $key;
	private $iv;
 
	function elSess()
	{
		if (!is_writable($this -> sess_dir))
			throw new exception('elSess: sess_dir is not writable');
		$this -> key = md5($_SERVER['REMOTE_ADDR'] . $_SERVER['HTTP_USER_AGENT']);
		$this -> iv = md5($this -> key);
	}
 
	function elKoduj($string)
	{
		return base64_encode(mcrypt_encrypt(MCRYPT_RIJNDAEL_256, $this -> key, $string, MCRYPT_MODE_CFB, $this -> iv));
	}
 
	function elDekoduj($string)
	{
		return mcrypt_decrypt(MCRYPT_RIJNDAEL_256, $this -> key, base64_decode($string), MCRYPT_MODE_CFB, $this -> iv);
	}	
 
	function _open($session_savepath, $session_name)
	{
		return true;
	}
 
	function _close()
	{
		return true;
	}
 
	function _read($session_id)
	{
		if(!file_exists($this -> sess_dir . $session_id))
			return '';
		$sess_data = $this -> elDekoduj(@file_get_contents($this -> sess_dir . $session_id)) . '';
			return($sess_data);
	}
 
	function _write($session_id, $session_value)
	{
		return (@file_put_contents($this -> sess_dir . $session_id, $this -> elKoduj($session_value)) && @chmod($this -> sess_dir . $session_id, 0700));
	}
 
	function _destroy($session_id)
	{
		  return @unlink($this -> sess_dir . $session_id);		
	}
 
	function _gc($session_lifetime)
	{
		if ($handle = @opendir($this -> sess_dir)) 
		{
			 while (false !== ($file = readdir($handle)))
				 if(@is_file($this -> sess_dir . $file) && @filemtime($this -> sess_dir . $file) < time() - $this -> sess_time)
					 @unlink($this -> sess_dir . $file);
			@closedir($handle);
			return true; 
		}
		else
			return false;
	}
};
 
$sess = new elSess;
session_set_save_handler (array(&$sess, '_open'),  array(&$sess, '_close'),  array(&$sess, '_read'),  array(&$sess, '_write'),  array(&$sess, '_destroy'),  array(&$sess, '_gc'));
 
?>
[PHP] pobierz, plaintext 

bigZbig: a moze po to by sprawdzic, ilu ludzi jest aktywnych na stronie.
a moze po to ilu zalogowanych. A moze po to by efektywnie sledzic sciezki przejsc uzytkownika, wyswietlic jego aktualna pozycje, zrobic statystyki uzywanych przegladarek zarazem i milion innych rzeczy....

trzymasz dane w bazie, nie musisz ich usuwać (do przedawnienia sesji służy pole w tabeli int(10) trzymajace timestamp).

Korzyści jest wiele.

@Vengeance - zgadzam się, że chcąc czegoś więcej ponad podstawową użyteczność sesji trzeba napisać coś swojego, ale większość ludzi piszących klasy do obsługi sesji implementuje jedynie ich podstawową funkcjonalność, a w takim wypadku jest to sztuka dla sztuki.

Ano... ale to już ich problem a nie mój Pytałeś do czego... to napisałem do czego ja używam własnych sesji. Tzn tylko własnego handlera podpinanego pod ten z php oczywiscie. Nie wyobrazam sobie robic SessionCostam::register('lol', 'blabla'); zamiast standardowego $_SESSION[]

Teoretycznnie rzecz biorac to moznaby zamiennie uzywac tablicy $_SESSION i metod statycznych przykladowej klasy MySession. Nie sprawdzalem, ale takie cos mogloby zadzialac.

[PHP] pobierz, plaintext 
<?php
class MySession {
  static private $_aSession = &$_SESSION;
 
  static public function register($sVariable, $mValue) 
  {
	self::$_aSession[$sVariable] = $mValue;
  }
 
  static public function registry($sVariable)
  {
	return self::$_aSession[$sVariable];
  }
}
 
?>
[PHP] pobierz, plaintext