PageRenderTime 60ms CodeModel.GetById 30ms RepoModel.GetById 1ms app.codeStats 0ms

/pub/lib/adodb/session/adodb-session.php

https://bitbucket.org/rabusmar/vsp-xp
PHP | 822 lines | 557 code | 132 blank | 133 comment | 102 complexity | dd37b18cbfc17e7c159260915fbe84f9 MD5 | raw file
Possible License(s): LGPL-2.1, BSD-3-Clause
  1. <?php
  2. /*
  3. V4.01 23 Oct 2003 (c) 2000-2004 John Lim (jlim@natsoft.com.my). All rights reserved.
  4. Contributed by Ross Smith (adodb@netebb.com).
  5. Released under both BSD license and Lesser GPL library license.
  6. Whenever there is any discrepancy between the two licenses,
  7. the BSD license will take precedence.
  8. Set tabs to 4 for best viewing.
  9. */
  10. /*
  11. You may want to rename the 'data' field to 'session_data' as
  12. 'data' appears to be a reserved word for one or more of the following:
  13. ANSI SQL
  14. IBM DB2
  15. MS SQL Server
  16. Postgres
  17. SAP
  18. If you do, then execute:
  19. ADODB_Session::dataFieldName('session_data');
  20. */
  21. if (!defined('_ADODB_LAYER')) {
  22. require_once realpath(dirname(__FILE__) . '/../adodb.inc.php');
  23. }
  24. if (defined('ADODB_SESSION')) return 1;
  25. define('ADODB_SESSION', dirname(__FILE__));
  26. /*!
  27. \static
  28. */
  29. class ADODB_Session {
  30. /////////////////////
  31. // getter/setter methods
  32. /////////////////////
  33. /*!
  34. */
  35. function driver($driver = null) {
  36. static $_driver = 'mysql';
  37. static $set = false;
  38. if (!is_null($driver)) {
  39. $_driver = trim($driver);
  40. $set = true;
  41. } elseif (!$set) {
  42. // backwards compatibility
  43. if (isset($GLOBALS['ADODB_SESSION_DRIVER'])) {
  44. return $GLOBALS['ADODB_SESSION_DRIVER'];
  45. }
  46. }
  47. return $_driver;
  48. }
  49. /*!
  50. */
  51. function host($host = null) {
  52. static $_host = 'localhost';
  53. static $set = false;
  54. if (!is_null($host)) {
  55. $_host = trim($host);
  56. $set = true;
  57. } elseif (!$set) {
  58. // backwards compatibility
  59. if (isset($GLOBALS['ADODB_SESSION_CONNECT'])) {
  60. return $GLOBALS['ADODB_SESSION_CONNECT'];
  61. }
  62. }
  63. return $_host;
  64. }
  65. /*!
  66. */
  67. function user($user = null) {
  68. static $_user = 'root';
  69. static $set = false;
  70. if (!is_null($user)) {
  71. $_user = trim($user);
  72. $set = true;
  73. } elseif (!$set) {
  74. // backwards compatibility
  75. if (isset($GLOBALS['ADODB_SESSION_USER'])) {
  76. return $GLOBALS['ADODB_SESSION_USER'];
  77. }
  78. }
  79. return $_user;
  80. }
  81. /*!
  82. */
  83. function password($password = null) {
  84. static $_password = '';
  85. static $set = false;
  86. if (!is_null($password)) {
  87. $_password = $password;
  88. $set = true;
  89. } elseif (!$set) {
  90. // backwards compatibility
  91. if (isset($GLOBALS['ADODB_SESSION_PWD'])) {
  92. return $GLOBALS['ADODB_SESSION_PWD'];
  93. }
  94. }
  95. return $_password;
  96. }
  97. /*!
  98. */
  99. function database($database = null) {
  100. static $_database = 'xphplens_2';
  101. static $set = false;
  102. if (!is_null($database)) {
  103. $_database = trim($database);
  104. $set = true;
  105. } elseif (!$set) {
  106. // backwards compatibility
  107. if (isset($GLOBALS['ADODB_SESSION_DB'])) {
  108. return $GLOBALS['ADODB_SESSION_DB'];
  109. }
  110. }
  111. return $_database;
  112. }
  113. /*!
  114. */
  115. function persist($persist = null)
  116. {
  117. static $_persist = true;
  118. if (!is_null($persist)) {
  119. $_persist = trim($persist);
  120. }
  121. return $_persist;
  122. }
  123. /*!
  124. */
  125. function lifetime($lifetime = null) {
  126. static $_lifetime;
  127. static $set = false;
  128. if (!is_null($lifetime)) {
  129. $_lifetime = (int) $lifetime;
  130. $set = true;
  131. } elseif (!$set) {
  132. // backwards compatibility
  133. if (isset($GLOBALS['ADODB_SESS_LIFE'])) {
  134. return $GLOBALS['ADODB_SESS_LIFE'];
  135. }
  136. }
  137. if (!$_lifetime) {
  138. $_lifetime = ini_get('session.gc_maxlifetime');
  139. if ($_lifetime <= 1) {
  140. // bug in PHP 4.0.3 pl 1 -- how about other versions?
  141. //print "<h3>Session Error: PHP.INI setting <i>session.gc_maxlifetime</i>not set: $lifetime</h3>";
  142. $_lifetime = 1440;
  143. }
  144. }
  145. return $_lifetime;
  146. }
  147. /*!
  148. */
  149. function debug($debug = null) {
  150. static $_debug = false;
  151. static $set = false;
  152. if (!is_null($debug)) {
  153. $_debug = (bool) $debug;
  154. $conn = ADODB_Session::_conn();
  155. if ($conn) {
  156. $conn->debug = $_debug;
  157. }
  158. $set = true;
  159. } elseif (!$set) {
  160. // backwards compatibility
  161. if (isset($GLOBALS['ADODB_SESS_DEBUG'])) {
  162. return $GLOBALS['ADODB_SESS_DEBUG'];
  163. }
  164. }
  165. return $_debug;
  166. }
  167. /*!
  168. */
  169. function expireNotify($expire_notify = null) {
  170. static $_expire_notify;
  171. static $set = false;
  172. if (!is_null($expire_notify)) {
  173. $_expire_notify = $expire_notify;
  174. $set = true;
  175. } elseif (!$set) {
  176. // backwards compatibility
  177. if (isset($GLOBALS['ADODB_SESSION_EXPIRE_NOTIFY'])) {
  178. return $GLOBALS['ADODB_SESSION_EXPIRE_NOTIFY'];
  179. }
  180. }
  181. return $_expire_notify;
  182. }
  183. /*!
  184. */
  185. function table($table = null) {
  186. static $_table = 'sessions';
  187. static $set = false;
  188. if (!is_null($table)) {
  189. $_table = trim($table);
  190. $set = true;
  191. } elseif (!$set) {
  192. // backwards compatibility
  193. if (isset($GLOBALS['ADODB_SESSION_TBL'])) {
  194. return $GLOBALS['ADODB_SESSION_TBL'];
  195. }
  196. }
  197. return $_table;
  198. }
  199. /*!
  200. */
  201. function optimize($optimize = null) {
  202. static $_optimize = false;
  203. static $set = false;
  204. if (!is_null($optimize)) {
  205. $_optimize = (bool) $optimize;
  206. $set = true;
  207. } elseif (!$set) {
  208. // backwards compatibility
  209. if (defined('ADODB_SESSION_OPTIMIZE')) {
  210. return true;
  211. }
  212. }
  213. return $_optimize;
  214. }
  215. /*!
  216. */
  217. function syncSeconds($sync_seconds = null) {
  218. static $_sync_seconds = 60;
  219. static $set = false;
  220. if (!is_null($sync_seconds)) {
  221. $_sync_seconds = (int) $sync_seconds;
  222. $set = true;
  223. } elseif (!$set) {
  224. // backwards compatibility
  225. if (defined('ADODB_SESSION_SYNCH_SECS')) {
  226. return ADODB_SESSION_SYNCH_SECS;
  227. }
  228. }
  229. return $_sync_seconds;
  230. }
  231. /*!
  232. */
  233. function clob($clob = null) {
  234. static $_clob = false;
  235. static $set = false;
  236. if (!is_null($clob)) {
  237. $_clob = strtolower(trim($clob));
  238. $set = true;
  239. } elseif (!$set) {
  240. // backwards compatibility
  241. if (isset($GLOBALS['ADODB_SESSION_USE_LOBS'])) {
  242. return $GLOBALS['ADODB_SESSION_USE_LOBS'];
  243. }
  244. }
  245. return $_clob;
  246. }
  247. /*!
  248. */
  249. function dataFieldName($data_field_name = null) {
  250. static $_data_field_name = 'data';
  251. if (!is_null($data_field_name)) {
  252. $_data_field_name = trim($data_field_name);
  253. }
  254. return $_data_field_name;
  255. }
  256. /*!
  257. */
  258. function filter($filter = null) {
  259. static $_filter = array();
  260. if (!is_null($filter)) {
  261. if (!is_array($filter)) {
  262. $filter = array($filter);
  263. }
  264. $_filter = $filter;
  265. }
  266. return $_filter;
  267. }
  268. /*!
  269. */
  270. function encryptionKey($encryption_key = null) {
  271. static $_encryption_key = 'CRYPTED ADODB SESSIONS ROCK!';
  272. if (!is_null($encryption_key)) {
  273. $_encryption_key = $encryption_key;
  274. }
  275. return $_encryption_key;
  276. }
  277. /////////////////////
  278. // private methods
  279. /////////////////////
  280. /*!
  281. */
  282. function &_conn($conn=null) {
  283. return $GLOBALS['ADODB_SESS_CONN'];
  284. }
  285. /*!
  286. */
  287. function _crc($crc = null) {
  288. static $_crc = false;
  289. if (!is_null($crc)) {
  290. $_crc = $crc;
  291. }
  292. return $_crc;
  293. }
  294. /*!
  295. */
  296. function _init() {
  297. session_module_name('user');
  298. session_set_save_handler(
  299. array('ADODB_Session', 'open'),
  300. array('ADODB_Session', 'close'),
  301. array('ADODB_Session', 'read'),
  302. array('ADODB_Session', 'write'),
  303. array('ADODB_Session', 'destroy'),
  304. array('ADODB_Session', 'gc')
  305. );
  306. }
  307. /*!
  308. */
  309. function _sessionKey() {
  310. // use this function to create the encryption key for crypted sessions
  311. // crypt the used key, ADODB_Session::encryptionKey() as key and session_id() as salt
  312. return crypt(ADODB_Session::encryptionKey(), session_id());
  313. }
  314. /*!
  315. */
  316. function _dumprs($rs) {
  317. $conn =& ADODB_Session::_conn();
  318. $debug = ADODB_Session::debug();
  319. if (!$conn) {
  320. return;
  321. }
  322. if (!$debug) {
  323. return;
  324. }
  325. if (!$rs) {
  326. echo "<br />\$rs is null or false<br />\n";
  327. return;
  328. }
  329. //echo "<br />\nAffected_Rows=",$conn->Affected_Rows(),"<br />\n";
  330. if (!is_object($rs)) {
  331. return;
  332. }
  333. require_once ADODB_SESSION.'/../tohtml.inc.php';
  334. rs2html($rs);
  335. }
  336. /////////////////////
  337. // public methods
  338. /////////////////////
  339. /*!
  340. Create the connection to the database.
  341. If $conn already exists, reuse that connection
  342. */
  343. function open($save_path, $session_name, $persist = null) {
  344. $conn =& ADODB_Session::_conn();
  345. if ($conn) {
  346. return true;
  347. }
  348. $database = ADODB_Session::database();
  349. $debug = ADODB_Session::debug();
  350. $driver = ADODB_Session::driver();
  351. $host = ADODB_Session::host();
  352. $password = ADODB_Session::password();
  353. $user = ADODB_Session::user();
  354. if (!is_null($persist)) {
  355. ADODB_Session::persist($persist);
  356. } else {
  357. $persist = ADODB_Session::persist();
  358. }
  359. # these can all be defaulted to in php.ini
  360. # assert('$database');
  361. # assert('$driver');
  362. # assert('$host');
  363. // cannot use =& below - do not know why...
  364. $conn =& ADONewConnection($driver);
  365. if ($debug) {
  366. $conn->debug = true;
  367. // ADOConnection::outp( " driver=$driver user=$user pwd=$password db=$database ");
  368. }
  369. if ($persist) {
  370. switch($persist) {
  371. default:
  372. case 'P': $ok = $conn->PConnect($host, $user, $password, $database); break;
  373. case 'C': $ok = $conn->Connect($host, $user, $password, $database); break;
  374. case 'N': $ok = $conn->NConnect($host, $user, $password, $database); break;
  375. }
  376. } else {
  377. $ok = $conn->Connect($host, $user, $password, $database);
  378. }
  379. if ($ok) $GLOBALS['ADODB_SESS_CONN'] =& $conn;
  380. else
  381. ADOConnection::outp('<p>Session: connection failed</p>', false);
  382. return $ok;
  383. }
  384. /*!
  385. Close the connection
  386. */
  387. function close() {
  388. $conn =& ADODB_Session::_conn();
  389. if ($conn) {
  390. $conn->Close();
  391. }
  392. return true;
  393. }
  394. /*
  395. Slurp in the session variables and return the serialized string
  396. */
  397. function read($key) {
  398. $conn =& ADODB_Session::_conn();
  399. $data = ADODB_Session::dataFieldName();
  400. $filter = ADODB_Session::filter();
  401. $table = ADODB_Session::table();
  402. if (!$conn) {
  403. return '';
  404. }
  405. assert('$table');
  406. $qkey = $conn->quote($key);
  407. $binary = $conn->dataProvider === 'mysql' ? '/*! BINARY */' : '';
  408. $sql = "SELECT $data FROM $table WHERE $binary sesskey = $qkey AND expiry >= " . time();
  409. $rs =& $conn->Execute($sql);
  410. //ADODB_Session::_dumprs($rs);
  411. if ($rs) {
  412. if ($rs->EOF) {
  413. $v = '';
  414. } else {
  415. $v = reset($rs->fields);
  416. $filter = array_reverse($filter);
  417. foreach ($filter as $f) {
  418. if (is_object($f)) {
  419. $v = $f->read($v, ADODB_Session::_sessionKey());
  420. }
  421. }
  422. $v = rawurldecode($v);
  423. }
  424. $rs->Close();
  425. ADODB_Session::_crc(strlen($v) . crc32($v));
  426. return $v;
  427. }
  428. return '';
  429. }
  430. /*!
  431. Write the serialized data to a database.
  432. If the data has not been modified since the last read(), we do not write.
  433. */
  434. function write($key, $val) {
  435. $clob = ADODB_Session::clob();
  436. $conn =& ADODB_Session::_conn();
  437. $crc = ADODB_Session::_crc();
  438. $data = ADODB_Session::dataFieldName();
  439. $debug = ADODB_Session::debug();
  440. $driver = ADODB_Session::driver();
  441. $expire_notify = ADODB_Session::expireNotify();
  442. $filter = ADODB_Session::filter();
  443. $lifetime = ADODB_Session::lifetime();
  444. $table = ADODB_Session::table();
  445. if (!$conn) {
  446. return false;
  447. }
  448. assert('$table');
  449. $expiry = time() + $lifetime;
  450. $qkey = $conn->quote($key);
  451. $binary = $conn->dataProvider === 'mysql' ? '/*! BINARY */' : '';
  452. // crc32 optimization since adodb 2.1
  453. // now we only update expiry date, thx to sebastian thom in adodb 2.32
  454. if ($crc !== false && $crc == (strlen($val) . crc32($val))) {
  455. if ($debug) {
  456. echo '<p>Session: Only updating date - crc32 not changed</p>';
  457. }
  458. $sql = "UPDATE $table SET expiry = $expiry WHERE $binary sesskey = $qkey AND expiry >= " . time();
  459. $rs =& $conn->Execute($sql);
  460. ADODB_Session::_dumprs($rs);
  461. if ($rs) {
  462. $rs->Close();
  463. }
  464. return true;
  465. }
  466. $val = rawurlencode($val);
  467. foreach ($filter as $f) {
  468. if (is_object($f)) {
  469. $val = $f->write($val, ADODB_Session::_sessionKey());
  470. }
  471. }
  472. $arr = array('sesskey' => $key, 'expiry' => $expiry, $data => $val, 'expireref' => '');
  473. if ($expire_notify) {
  474. $var = reset($expire_notify);
  475. global $$var;
  476. if (isset($$var)) {
  477. $arr['expireref'] = $$var;
  478. }
  479. }
  480. if (!$clob) { // no lobs, simply use replace()
  481. $arr[$data] = $conn->qstr($val);
  482. $rs = $conn->Replace($table, $arr, 'sesskey', $autoQuote = true);
  483. ADODB_Session::_dumprs($rs);
  484. } else {
  485. // what value shall we insert/update for lob row?
  486. switch ($driver) {
  487. // empty_clob or empty_lob for oracle dbs
  488. case 'oracle':
  489. case 'oci8':
  490. case 'oci8po':
  491. case 'oci805':
  492. $lob_value = sprintf('empty_%s()', strtolower($clob));
  493. break;
  494. // null for all other
  495. default:
  496. $lob_value = 'null';
  497. break;
  498. }
  499. // do we insert or update? => as for sesskey
  500. $rs =& $conn->Execute("SELECT COUNT(*) AS cnt FROM $table WHERE $binary sesskey = $qkey");
  501. ADODB_Session::_dumprs($rs);
  502. if ($rs && reset($rs->fields) > 0) {
  503. $sql = "UPDATE $table SET expiry = $expiry, $data = $lob_value WHERE sesskey = $qkey";
  504. } else {
  505. $sql = "INSERT INTO $table (expiry, $data, sesskey) VALUES ($expiry, $lob_value, $qkey)";
  506. }
  507. if ($rs) {
  508. $rs->Close();
  509. }
  510. $err = '';
  511. $rs1 =& $conn->Execute($sql);
  512. ADODB_Session::_dumprs($rs1);
  513. if (!$rs1) {
  514. $err = $conn->ErrorMsg()."\n";
  515. }
  516. $rs2 =& $conn->UpdateBlob($table, $data, $val, " sesskey=$qkey", strtoupper($clob));
  517. ADODB_Session::_dumprs($rs2);
  518. if (!$rs2) {
  519. $err .= $conn->ErrorMsg()."\n";
  520. }
  521. $rs = ($rs && $rs2) ? true : false;
  522. if ($rs1) {
  523. $rs1->Close();
  524. }
  525. if (is_object($rs2)) {
  526. $rs2->Close();
  527. }
  528. }
  529. if (!$rs) {
  530. ADOConnection::outp('<p>Session Replace: ' . $conn->ErrorMsg() . '</p>', false);
  531. return false;
  532. } else {
  533. // bug in access driver (could be odbc?) means that info is not committed
  534. // properly unless select statement executed in Win2000
  535. if ($conn->databaseType == 'access') {
  536. $sql = "SELECT sesskey FROM $table WHERE $binary sesskey = $qkey";
  537. $rs =& $conn->Execute($sql);
  538. ADODB_Session::_dumprs($rs);
  539. if ($rs) {
  540. $rs->Close();
  541. }
  542. }
  543. }
  544. return $rs ? true : false;
  545. }
  546. /*!
  547. */
  548. function destroy($key) {
  549. $conn =& ADODB_Session::_conn();
  550. $table = ADODB_Session::table();
  551. $expire_notify = ADODB_Session::expireNotify();
  552. if (!$conn) {
  553. return false;
  554. }
  555. assert('$table');
  556. $qkey = $conn->quote($key);
  557. $binary = $conn->dataProvider === 'mysql' ? '/*! BINARY */' : '';
  558. if ($expire_notify) {
  559. reset($expire_notify);
  560. $fn = next($expire_notify);
  561. $savem = $conn->SetFetchMode(ADODB_FETCH_NUM);
  562. $sql = "SELECT expireref, sesskey FROM $table WHERE $binary sesskey = $qkey";
  563. $rs =& $conn->Execute($sql);
  564. ADODB_Session::_dumprs($rs);
  565. $conn->SetFetchMode($savem);
  566. if (!$rs) {
  567. return false;
  568. }
  569. if (!$rs->EOF) {
  570. $ref = $rs->fields[0];
  571. $key = $rs->fields[1];
  572. //assert('$ref');
  573. //assert('$key');
  574. $fn($ref, $key);
  575. }
  576. $rs->Close();
  577. }
  578. $sql = "DELETE FROM $table WHERE $binary sesskey = $qkey";
  579. $rs =& $conn->Execute($sql);
  580. ADODB_Session::_dumprs($rs);
  581. if ($rs) {
  582. $rs->Close();
  583. }
  584. return $rs ? true : false;
  585. }
  586. /*!
  587. */
  588. function gc($maxlifetime) {
  589. $conn =& ADODB_Session::_conn();
  590. $debug = ADODB_Session::debug();
  591. $expire_notify = ADODB_Session::expireNotify();
  592. $optimize = ADODB_Session::optimize();
  593. $sync_seconds = ADODB_Session::syncSeconds();
  594. $table = ADODB_Session::table();
  595. if (!$conn) {
  596. return false;
  597. }
  598. assert('$table');
  599. $time = time();
  600. $binary = $conn->dataProvider === 'mysql' ? '/*! BINARY */' : '';
  601. if ($expire_notify) {
  602. reset($expire_notify);
  603. $fn = next($expire_notify);
  604. $savem = $conn->SetFetchMode(ADODB_FETCH_NUM);
  605. $sql = "SELECT expireref, sesskey FROM $table WHERE expiry < $time";
  606. $rs =& $conn->Execute($sql);
  607. ADODB_Session::_dumprs($rs);
  608. $conn->SetFetchMode($savem);
  609. if ($rs) {
  610. $conn->BeginTrans();
  611. $keys = array();
  612. while (!$rs->EOF) {
  613. $ref = $rs->fields[0];
  614. $key = $rs->fields[1];
  615. $fn($ref, $key);
  616. $del = $conn->Execute("DELETE FROM $table WHERE sesskey='$key'");
  617. $rs->MoveNext();
  618. }
  619. $rs->Close();
  620. $conn->CommitTrans();
  621. }
  622. } else {
  623. $sql = "DELETE FROM $table WHERE expiry < $time";
  624. $rs =& $conn->Execute($sql);
  625. ADODB_Session::_dumprs($rs);
  626. if ($rs) {
  627. $rs->Close();
  628. }
  629. if ($debug) {
  630. ADOConnection::outp("<p><b>Garbage Collection</b>: $sql</p>");
  631. }
  632. }
  633. // suggested by Cameron, "GaM3R" <gamr@outworld.cx>
  634. if ($optimize) {
  635. $driver = ADODB_Session::driver();
  636. if (preg_match('/mysql/i', $driver)) {
  637. $sql = "OPTIMIZE TABLE $table";
  638. }
  639. if (preg_match('/postgres/i', $driver)) {
  640. $sql = "VACUUM $table";
  641. }
  642. if (!empty($sql)) {
  643. $conn->Execute($sql);
  644. }
  645. }
  646. if ($sync_seconds) {
  647. $sql = 'SELECT ';
  648. if ($conn->dataProvider === 'oci8') {
  649. $sql .= "TO_CHAR({$conn->sysTimeStamp}, 'RRRR-MM-DD HH24:MI:SS')";
  650. } else {
  651. $sql .= $conn->sysTimeStamp;
  652. }
  653. $sql .= " FROM $table";
  654. $rs =& $conn->SelectLimit($sql, 1);
  655. if ($rs && !$rs->EOF) {
  656. $dbts = reset($rs->fields);
  657. $rs->Close();
  658. $dbt = $conn->UnixTimeStamp($dbts);
  659. $t = time();
  660. if (abs($dbt - $t) >= $sync_seconds) {
  661. global $HTTP_SERVER_VARS;
  662. $msg = __FILE__ .
  663. ": Server time for webserver {$HTTP_SERVER_VARS['HTTP_HOST']} not in synch with database: " .
  664. " database=$dbt ($dbts), webserver=$t (diff=". (abs($dbt - $t) / 3600) . ' hours)';
  665. error_log($msg);
  666. if ($debug) {
  667. ADOConnection::outp("<p>$msg</p>");
  668. }
  669. }
  670. }
  671. }
  672. return true;
  673. }
  674. }
  675. ADODB_Session::_init();
  676. // for backwards compatability only
  677. function adodb_sess_open($save_path, $session_name, $persist = true) {
  678. return ADODB_Session::open($save_path, $session_name, $persist);
  679. }
  680. // for backwards compatability only
  681. function adodb_sess_gc($t)
  682. {
  683. return ADODB_Session::gc($t);
  684. }
  685. ?>