PageRenderTime 47ms CodeModel.GetById 21ms RepoModel.GetById 0ms app.codeStats 0ms

/lib/simpletestlib/cookies.php

https://bitbucket.org/systime/screening2
PHP | 380 lines | 173 code | 25 blank | 182 comment | 30 complexity | 7087903ab921d682e172075a454ec7e1 MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.1, GPL-3.0, BSD-3-Clause, LGPL-2.0
  1. <?php
  2. /**
  3. * Base include file for SimpleTest
  4. * @package SimpleTest
  5. * @subpackage WebTester
  6. * @version $Id: cookies.php,v 1.2 2007/04/26 07:11:44 nicolasconnault Exp $
  7. */
  8. /**#@+
  9. * include other SimpleTest class files
  10. */
  11. require_once(dirname(__FILE__) . '/url.php');
  12. /**#@-*/
  13. /**
  14. * Cookie data holder. Cookie rules are full of pretty
  15. * arbitary stuff. I have used...
  16. * http://wp.netscape.com/newsref/std/cookie_spec.html
  17. * http://www.cookiecentral.com/faq/
  18. * @package SimpleTest
  19. * @subpackage WebTester
  20. */
  21. class SimpleCookie {
  22. var $_host;
  23. var $_name;
  24. var $_value;
  25. var $_path;
  26. var $_expiry;
  27. var $_is_secure;
  28. /**
  29. * Constructor. Sets the stored values.
  30. * @param string $name Cookie key.
  31. * @param string $value Value of cookie.
  32. * @param string $path Cookie path if not host wide.
  33. * @param string $expiry Expiry date as string.
  34. * @param boolean $is_secure Currently ignored.
  35. */
  36. function SimpleCookie($name, $value = false, $path = false, $expiry = false, $is_secure = false) {
  37. $this->_host = false;
  38. $this->_name = $name;
  39. $this->_value = $value;
  40. $this->_path = ($path ? $this->_fixPath($path) : "/");
  41. $this->_expiry = false;
  42. if (is_string($expiry)) {
  43. $this->_expiry = strtotime($expiry);
  44. } elseif (is_integer($expiry)) {
  45. $this->_expiry = $expiry;
  46. }
  47. $this->_is_secure = $is_secure;
  48. }
  49. /**
  50. * Sets the host. The cookie rules determine
  51. * that the first two parts are taken for
  52. * certain TLDs and three for others. If the
  53. * new host does not match these rules then the
  54. * call will fail.
  55. * @param string $host New hostname.
  56. * @return boolean True if hostname is valid.
  57. * @access public
  58. */
  59. function setHost($host) {
  60. if ($host = $this->_truncateHost($host)) {
  61. $this->_host = $host;
  62. return true;
  63. }
  64. return false;
  65. }
  66. /**
  67. * Accessor for the truncated host to which this
  68. * cookie applies.
  69. * @return string Truncated hostname.
  70. * @access public
  71. */
  72. function getHost() {
  73. return $this->_host;
  74. }
  75. /**
  76. * Test for a cookie being valid for a host name.
  77. * @param string $host Host to test against.
  78. * @return boolean True if the cookie would be valid
  79. * here.
  80. */
  81. function isValidHost($host) {
  82. return ($this->_truncateHost($host) === $this->getHost());
  83. }
  84. /**
  85. * Extracts just the domain part that determines a
  86. * cookie's host validity.
  87. * @param string $host Host name to truncate.
  88. * @return string Domain or false on a bad host.
  89. * @access private
  90. */
  91. function _truncateHost($host) {
  92. $tlds = SimpleUrl::getAllTopLevelDomains();
  93. if (preg_match('/[a-z\-]+\.(' . $tlds . ')$/i', $host, $matches)) {
  94. return $matches[0];
  95. } elseif (preg_match('/[a-z\-]+\.[a-z\-]+\.[a-z\-]+$/i', $host, $matches)) {
  96. return $matches[0];
  97. }
  98. return false;
  99. }
  100. /**
  101. * Accessor for name.
  102. * @return string Cookie key.
  103. * @access public
  104. */
  105. function getName() {
  106. return $this->_name;
  107. }
  108. /**
  109. * Accessor for value. A deleted cookie will
  110. * have an empty string for this.
  111. * @return string Cookie value.
  112. * @access public
  113. */
  114. function getValue() {
  115. return $this->_value;
  116. }
  117. /**
  118. * Accessor for path.
  119. * @return string Valid cookie path.
  120. * @access public
  121. */
  122. function getPath() {
  123. return $this->_path;
  124. }
  125. /**
  126. * Tests a path to see if the cookie applies
  127. * there. The test path must be longer or
  128. * equal to the cookie path.
  129. * @param string $path Path to test against.
  130. * @return boolean True if cookie valid here.
  131. * @access public
  132. */
  133. function isValidPath($path) {
  134. return (strncmp(
  135. $this->_fixPath($path),
  136. $this->getPath(),
  137. strlen($this->getPath())) == 0);
  138. }
  139. /**
  140. * Accessor for expiry.
  141. * @return string Expiry string.
  142. * @access public
  143. */
  144. function getExpiry() {
  145. if (! $this->_expiry) {
  146. return false;
  147. }
  148. return gmdate("D, d M Y H:i:s", $this->_expiry) . " GMT";
  149. }
  150. /**
  151. * Test to see if cookie is expired against
  152. * the cookie format time or timestamp.
  153. * Will give true for a session cookie.
  154. * @param integer/string $now Time to test against. Result
  155. * will be false if this time
  156. * is later than the cookie expiry.
  157. * Can be either a timestamp integer
  158. * or a cookie format date.
  159. * @access public
  160. */
  161. function isExpired($now) {
  162. if (! $this->_expiry) {
  163. return true;
  164. }
  165. if (is_string($now)) {
  166. $now = strtotime($now);
  167. }
  168. return ($this->_expiry < $now);
  169. }
  170. /**
  171. * Ages the cookie by the specified number of
  172. * seconds.
  173. * @param integer $interval In seconds.
  174. * @public
  175. */
  176. function agePrematurely($interval) {
  177. if ($this->_expiry) {
  178. $this->_expiry -= $interval;
  179. }
  180. }
  181. /**
  182. * Accessor for the secure flag.
  183. * @return boolean True if cookie needs SSL.
  184. * @access public
  185. */
  186. function isSecure() {
  187. return $this->_is_secure;
  188. }
  189. /**
  190. * Adds a trailing and leading slash to the path
  191. * if missing.
  192. * @param string $path Path to fix.
  193. * @access private
  194. */
  195. function _fixPath($path) {
  196. if (substr($path, 0, 1) != '/') {
  197. $path = '/' . $path;
  198. }
  199. if (substr($path, -1, 1) != '/') {
  200. $path .= '/';
  201. }
  202. return $path;
  203. }
  204. }
  205. /**
  206. * Repository for cookies. This stuff is a
  207. * tiny bit browser dependent.
  208. * @package SimpleTest
  209. * @subpackage WebTester
  210. */
  211. class SimpleCookieJar {
  212. var $_cookies;
  213. /**
  214. * Constructor. Jar starts empty.
  215. * @access public
  216. */
  217. function SimpleCookieJar() {
  218. $this->_cookies = array();
  219. }
  220. /**
  221. * Removes expired and temporary cookies as if
  222. * the browser was closed and re-opened.
  223. * @param string/integer $now Time to test expiry against.
  224. * @access public
  225. */
  226. function restartSession($date = false) {
  227. $surviving_cookies = array();
  228. for ($i = 0; $i < count($this->_cookies); $i++) {
  229. if (! $this->_cookies[$i]->getValue()) {
  230. continue;
  231. }
  232. if (! $this->_cookies[$i]->getExpiry()) {
  233. continue;
  234. }
  235. if ($date && $this->_cookies[$i]->isExpired($date)) {
  236. continue;
  237. }
  238. $surviving_cookies[] = $this->_cookies[$i];
  239. }
  240. $this->_cookies = $surviving_cookies;
  241. }
  242. /**
  243. * Ages all cookies in the cookie jar.
  244. * @param integer $interval The old session is moved
  245. * into the past by this number
  246. * of seconds. Cookies now over
  247. * age will be removed.
  248. * @access public
  249. */
  250. function agePrematurely($interval) {
  251. for ($i = 0; $i < count($this->_cookies); $i++) {
  252. $this->_cookies[$i]->agePrematurely($interval);
  253. }
  254. }
  255. /**
  256. * Sets an additional cookie. If a cookie has
  257. * the same name and path it is replaced.
  258. * @param string $name Cookie key.
  259. * @param string $value Value of cookie.
  260. * @param string $host Host upon which the cookie is valid.
  261. * @param string $path Cookie path if not host wide.
  262. * @param string $expiry Expiry date.
  263. * @access public
  264. */
  265. function setCookie($name, $value, $host = false, $path = '/', $expiry = false) {
  266. $cookie = new SimpleCookie($name, $value, $path, $expiry);
  267. if ($host) {
  268. $cookie->setHost($host);
  269. }
  270. $this->_cookies[$this->_findFirstMatch($cookie)] = $cookie;
  271. }
  272. /**
  273. * Finds a matching cookie to write over or the
  274. * first empty slot if none.
  275. * @param SimpleCookie $cookie Cookie to write into jar.
  276. * @return integer Available slot.
  277. * @access private
  278. */
  279. function _findFirstMatch($cookie) {
  280. for ($i = 0; $i < count($this->_cookies); $i++) {
  281. $is_match = $this->_isMatch(
  282. $cookie,
  283. $this->_cookies[$i]->getHost(),
  284. $this->_cookies[$i]->getPath(),
  285. $this->_cookies[$i]->getName());
  286. if ($is_match) {
  287. return $i;
  288. }
  289. }
  290. return count($this->_cookies);
  291. }
  292. /**
  293. * Reads the most specific cookie value from the
  294. * browser cookies. Looks for the longest path that
  295. * matches.
  296. * @param string $host Host to search.
  297. * @param string $path Applicable path.
  298. * @param string $name Name of cookie to read.
  299. * @return string False if not present, else the
  300. * value as a string.
  301. * @access public
  302. */
  303. function getCookieValue($host, $path, $name) {
  304. $longest_path = '';
  305. foreach ($this->_cookies as $cookie) {
  306. if ($this->_isMatch($cookie, $host, $path, $name)) {
  307. if (strlen($cookie->getPath()) > strlen($longest_path)) {
  308. $value = $cookie->getValue();
  309. $longest_path = $cookie->getPath();
  310. }
  311. }
  312. }
  313. return (isset($value) ? $value : false);
  314. }
  315. /**
  316. * Tests cookie for matching against search
  317. * criteria.
  318. * @param SimpleTest $cookie Cookie to test.
  319. * @param string $host Host must match.
  320. * @param string $path Cookie path must be shorter than
  321. * this path.
  322. * @param string $name Name must match.
  323. * @return boolean True if matched.
  324. * @access private
  325. */
  326. function _isMatch($cookie, $host, $path, $name) {
  327. if ($cookie->getName() != $name) {
  328. return false;
  329. }
  330. if ($host && $cookie->getHost() && ! $cookie->isValidHost($host)) {
  331. return false;
  332. }
  333. if (! $cookie->isValidPath($path)) {
  334. return false;
  335. }
  336. return true;
  337. }
  338. /**
  339. * Uses a URL to sift relevant cookies by host and
  340. * path. Results are list of strings of form "name=value".
  341. * @param SimpleUrl $url Url to select by.
  342. * @return array Valid name and value pairs.
  343. * @access public
  344. */
  345. function selectAsPairs($url) {
  346. $pairs = array();
  347. foreach ($this->_cookies as $cookie) {
  348. if ($this->_isMatch($cookie, $url->getHost(), $url->getPath(), $cookie->getName())) {
  349. $pairs[] = $cookie->getName() . '=' . $cookie->getValue();
  350. }
  351. }
  352. return $pairs;
  353. }
  354. }
  355. ?>