PageRenderTime 46ms CodeModel.GetById 27ms RepoModel.GetById 0ms app.codeStats 1ms

/ezUser.php

https://bitbucket.org/dominicsayers/ezuser
PHP | 4848 lines | 3186 code | 596 blank | 1066 comment | 529 complexity | c1fa27ac6a012155e52c1ac5d417d03a MD5 | raw file
    

  1. <?php

    2. 

  2. /**

    3. 

  3.  * Enables user registration and authentication for a website

    4. 

  4.  * 

    5. 

  5.  * This code has three principle design goals:

    6. 

  6.  * 

    7. 

  7.  *     1. To make it easy for people to register and sign in to your site.

    8. 

  8.  *     2. To make it easy for you to add this functionality to your site.

    9. 

  9.  *     3. To make it easy for you to administer the user database on your site.

    10. 

  10.  * 

    11. 

  11.  * Other design goals, such as run-time efficiency, are important but secondary to

    12. 

  12.  * these.

    13. 

  13.  * 

    14. 

  14.  * Copyright (c) 2008-2010, Dominic Sayers							<br>

    15. 

  15.  * All rights reserved.

    16. 

  16.  * 

    17. 

  17.  * Redistribution and use in source and binary forms, with or without modification,

    18. 

  18.  * are permitted provided that the following conditions are met:

    19. 

  19.  * 

    20. 

  20.  *     - Redistributions of source code must retain the above copyright notice,

    21. 

  21.  *       this list of conditions and the following disclaimer.

    22. 

  22.  *     - Redistributions in binary form must reproduce the above copyright notice,

    23. 

  23.  *       this list of conditions and the following disclaimer in the documentation

    24. 

  24.  *       and/or other materials provided with the distribution.

    25. 

  25.  *     - Neither the name of Dominic Sayers nor the names of its contributors may be

    26. 

  26.  *       used to endorse or promote products derived from this software without

    27. 

  27.  *       specific prior written permission.

    28. 

  28.  * 

    29. 

  29.  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND

    30. 

  30.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

    31. 

  31.  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

    32. 

  32.  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR

    33. 

  33.  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

    34. 

  34.  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

    35. 

  35.  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON

    36. 

  36.  * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

    37. 

  37.  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

    38. 

  38.  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

    39. 

  39.  * 

    40. 

  40.  * @package	ezUser

    41. 

  41.  * @author	Dominic Sayers <dominic@sayers.cc>

    42. 

  42.  * @copyright	2008-2010 Dominic Sayers

    43. 

  43.  * @license	http://www.opensource.org/licenses/bsd-license.php BSD License

    44. 

  44.  * @link	http://code.google.com/p/ezuser/

    45. 

  45.  * @version	0.25.5 - Floating div dialog boxes

    46. 

  46.  */

    47. 

  47. 

    48. 

  48. // The quality of this code has been improved greatly by using PHPLint

    49. 

  49. // PHPLint is copyright (c) 2009 Umberto Salsi

    50. 

  50. // PHPLint is free software; see the license for copying conditions.

    51. 

  51. // More info: http://www.icosaedro.it/phplint/

    52. 

  52. /*.

    53. 

  53. require_module 'dom';

    54. 

  54. require_module 'pcre';

    55. 

  55. require_module 'hash';

    56. 

  56. require_module 'session';

    57. 

  57. .*/

    58. 

  58. 

    59. 

  59. /* Comment out profiling statements if not needed

    60. 

  60. function ezuser_time() {list($usec, $sec) = explode(" ",microtime()); return ((float)$usec + (float)$sec);}

    61. 

  61. $ezuser_profile			= array();

    62. 

  62. $ezuser_profile['REQUEST_TIME']	= $_SERVER['REQUEST_TIME'];

    63. 

  63. $ezuser_profile['received']	= ezuser_time();

    64. 

  64. */

    65. 

  65. 

    66. 

  66. /**

    67. 

  67.  * Common utility functions

    68. 

  68.  *

    69. 

  69.  * @package ezUser

    70. 

  70.  * @version 1.14 (revision number of this common functions class only)

    71. 

  71.  */

    72. 

  72. 

    73. 

  73. interface I_ezUser_common {

    74. 

  74. //	const	PACKAGE				= 'ezUser',

    75. 

  75. //		VERSION				= '0.25', // Version 1.13: added

    76. 

  76. // Version 1.14: PACKAGE & VERSION now hard-coded by build process.

    77. 

  77. 

    78. 

  78. 	const	HASH_FUNCTION			= 'SHA256',

    79. 

  79. 		URL_SEPARATOR			= '/',

    80. 

  80. 

    81. 

  81. 		// Behaviour settings for strleft()

    82. 

  82. 		STRLEFT_MODE_NONE		= 0,

    83. 

  83. 		STRLEFT_MODE_ALL		= 1,

    84. 

  84. 

    85. 

  85. 		// Behaviour settings for getURL()

    86. 

  86. 		URL_MODE_PROTOCOL		= 1,

    87. 

  87. 		URL_MODE_HOST			= 2,

    88. 

  88. 		URL_MODE_PORT			= 4,

    89. 

  89. 		URL_MODE_PATH			= 8,

    90. 

  90. 		URL_MODE_ALL			= 15,

    91. 

  91. 

    92. 

  92. 		// Behaviour settings for getPackage()

    93. 

  93. //		PACKAGE_CASE_DEFAULT		= 0,

    94. 

  94. ////		PACKAGE_CASE_LOWER		= 0,

    95. 

  95. //		PACKAGE_CASE_CAMEL		= 1,

    96. 

  96. //		PACKAGE_CASE_UPPER		= 2,

    97. 

  97. // Version 1.14: PACKAGE & VERSION now hard-coded by build process.

    98. 

  98. 

    99. 

  99. 		// Extra GLOB constant for safe_glob()

    100. 

  100. 		GLOB_NODIR			= 256,

    101. 

  101. 		GLOB_PATH			= 512,

    102. 

  102. 		GLOB_NODOTS			= 1024,

    103. 

  103. 		GLOB_RECURSE			= 2048,

    104. 

  104. 

    105. 

  105. 		// Email validation constants

    106. 

  106. 		ISEMAIL_VALID			= 0,

    107. 

  107. 		ISEMAIL_TOOLONG			= 1,

    108. 

  108. 		ISEMAIL_NOAT			= 2,

    109. 

  109. 		ISEMAIL_NOLOCALPART		= 3,

    110. 

  110. 		ISEMAIL_NODOMAIN		= 4,

    111. 

  111. 		ISEMAIL_ZEROLENGTHELEMENT	= 5,

    112. 

  112. 		ISEMAIL_BADCOMMENT_START	= 6,

    113. 

  113. 		ISEMAIL_BADCOMMENT_END		= 7,

    114. 

  114. 		ISEMAIL_UNESCAPEDDELIM		= 8,

    115. 

  115. 		ISEMAIL_EMPTYELEMENT		= 9,

    116. 

  116. 		ISEMAIL_UNESCAPEDSPECIAL	= 10,

    117. 

  117. 		ISEMAIL_LOCALTOOLONG		= 11,

    118. 

  118. 		ISEMAIL_IPV4BADPREFIX		= 12,

    119. 

  119. 		ISEMAIL_IPV6BADPREFIXMIXED	= 13,

    120. 

  120. 		ISEMAIL_IPV6BADPREFIX		= 14,

    121. 

  121. 		ISEMAIL_IPV6GROUPCOUNT		= 15,

    122. 

  122. 		ISEMAIL_IPV6DOUBLEDOUBLECOLON	= 16,

    123. 

  123. 		ISEMAIL_IPV6BADCHAR		= 17,

    124. 

  124. 		ISEMAIL_IPV6TOOMANYGROUPS	= 18,

    125. 

  125. 		ISEMAIL_TLD			= 19,

    126. 

  126. 		ISEMAIL_DOMAINEMPTYELEMENT	= 20,

    127. 

  127. 		ISEMAIL_DOMAINELEMENTTOOLONG	= 21,

    128. 

  128. 		ISEMAIL_DOMAINBADCHAR		= 22,

    129. 

  129. 		ISEMAIL_DOMAINTOOLONG		= 23,

    130. 

  130. 		ISEMAIL_TLDNUMERIC		= 24,

    131. 

  131. 		ISEMAIL_DOMAINNOTFOUND		= 25;

    132. 

  132. //		ISEMAIL_NOTDEFINED		= 99;

    133. 

  133. 

    134. 

  134. 	// Basic utility functions

    135. 

  135. 	public static /*.string.*/			function strleft(/*.string.*/ $haystack, /*.string.*/ $needle);

    136. 

  136. 	public static /*.mixed.*/			function getInnerHTML(/*.string.*/ $html, /*.string.*/ $tag);

    137. 

  137. 	public static /*.array[string][string]string.*/	function meta_to_array(/*.string.*/ $html);

    138. 

  138. 	public static /*.string.*/			function var_dump_to_HTML(/*.string.*/ $var_dump, $offset = 0);

    139. 

  139. 	public static /*.string.*/			function array_to_HTML(/*.array[]mixed.*/ $source = NULL);

    140. 

  140. 

    141. 

  141. 	// Session functions

    142. 

  142. 	public static /*.void.*/			function checkSession();

    143. 

  143. 

    144. 

  144. 	// Environment functions

    145. 

  145. //	public static /*.string.*/			function getPackage($mode = self::PACKAGE_CASE_DEFAULT); // Version 1.14: PACKAGE & VERSION now hard-coded by build process.

    146. 

  146. 	public static /*.string.*/			function getURL($mode = self::URL_MODE_PATH, $filename = '');

    147. 

  147. 	public static /*.string.*/			function docBlock_to_HTML(/*.string.*/ $php);

    148. 

  148. 

    149. 

  149. 	// File system functions

    150. 

  150. 	public static /*.mixed.*/			function safe_glob(/*.string.*/ $pattern, /*.int.*/ $flags = 0);

    151. 

  151. 	public static /*.string.*/			function getFileContents(/*.string.*/ $filename, /*.int.*/ $flags = 0, /*.object.*/ $context = NULL, /*.int.*/ $offset = -1, /*.int.*/ $maxLen = -1);

    152. 

  152. 	public static /*.string.*/			function findIndexFile(/*.string.*/ $folder);

    153. 

  153. 	public static /*.string.*/			function findTarget(/*.string.*/ $target);

    154. 

  154. 

    155. 

  155. 	// Data functions

    156. 

  156. 	public static /*.string.*/			function makeId();

    157. 

  157. 	public static /*.string.*/			function makeUniqueKey(/*.string.*/ $id);

    158. 

  158. 	public static /*.string.*/			function mt_shuffle(/*.string.*/ $str, /*.int.*/ $seed = 0);

    159. 

  159. //	public static /*.void.*/			function mt_shuffle_array(/*.array.*/ &$arr, /*.int.*/ $seed = 0);

    160. 

  160. 	public static /*.string.*/			function prkg(/*.int.*/ $index, /*.int.*/ $length = 6, /*.int.*/ $base = 34, /*.int.*/ $seed = 0);

    161. 

  161. 

    162. 

  162. 	// Validation functions

    163. 

  163. //	public static /*.boolean.*/			function is_email(/*.string.*/ $email, $checkDNS = false);

    164. 

  164. 	public static /*.mixed.*/			function is_email(/*.string.*/ $email, $checkDNS = false, $diagnose = false); // New parameters from version 1.8

    165. 

  165. }

    166. 

  166. 

    167. 

  167. /**

    168. 

  168.  * Common utility functions

    169. 

  169.  */

    170. 

  170. abstract class ezUser_common implements I_ezUser_common {

    171. 

  171. /**

    172. 

  172.  * Return the beginning of a string, up to but not including the search term.

    173. 

  173.  *

    174. 

  174.  * @param string $haystack The string containing the search term

    175. 

  175.  * @param string $needle The end point of the returned string. In other words, if <var>needle</var> is found then the begging of <var>haystack</var> is returned up to the character before <needle>.

    176. 

  176.  * @param int $mode If <var>needle</var> is not found then <pre>FALSE</pre> will be returned. */

    177. 

  177. 	public static /*.string.*/ function strleft(/*.string.*/ $haystack, /*.string.*/ $needle, /*.int.*/ $mode = self::STRLEFT_MODE_NONE) {

    178. 

  178. 		$posNeedle = strpos($haystack, $needle);

    179. 

  179. 

    180. 

  180. 		if ($posNeedle === false) {

    181. 

  181. 			if ($mode === self::STRLEFT_MODE_ALL)

    182. 

  182. 				return $haystack;

    183. 

  183. 			else

    184. 

  184. 				return (string) $posNeedle;

    185. 

  185. 		} else

    186. 

  186. 			return substr($haystack, 0, $posNeedle);

    187. 

  187. 	}

    188. 

  188. 

    189. 

  189. /**

    190. 

  190.  * Return the contents of an HTML element, the first one matching the <var>tag</var> parameter.

    191. 

  191.  *

    192. 

  192.  * @param string $html The string containing the html to be searched

    193. 

  193.  * @param string $tag The type of element to search for. The contents of first matching element will be returned. If the element doesn't exist then <var>false</var> is returned.

    194. 

  194.  */

    195. 

  195. 	public static /*.mixed.*/ function getInnerHTML(/*.string.*/ $html, /*.string.*/ $tag) {

    196. 

  196. 		$pos_tag_open_start	= stripos($html, "<$tag")				; if ($pos_tag_open_start	=== false) return false;

    197. 

  197. 		$pos_tag_open_end	= strpos($html, '>',		$pos_tag_open_start)	; if ($pos_tag_open_end		=== false) return false;

    198. 

  198. 		$pos_tag_close		= stripos($html, "</$tag>",	$pos_tag_open_end)	; if ($pos_tag_close		=== false) return false;

    199. 

  199. 		return substr($html, $pos_tag_open_end + 1, $pos_tag_close - $pos_tag_open_end - 1);

    200. 

  200. 	}

    201. 

  201. 

    202. 

  202. /**

    203. 

  203.  * Return the <var>meta</var> tags from an HTML document as an array.

    204. 

  204.  *

    205. 

  205.  * The array returned will have a 'key' element which is an array of name/value pairs representing all the metadata

    206. 

  206.  * from the HTML document. If there are any <var>name</var> or <var>http-equiv</var> meta elements

    207. 

  207.  * these will be in their own sub-array. The 'key' sub-array combines all meta tags.

    208. 

  208.  *

    209. 

  209.  * Qualifying attributes such as <var>lang</var> and <var>scheme</var> have their own sub-arrays with the same key

    210. 

  210.  * as the main sub-array.

    211. 

  211.  *

    212. 

  212.  * Here are some example meta tags:

    213. 

  213.  *

    214. 

  214.  * <pre>

    215. 

  215.  * <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />

    216. 

  216.  * <meta name="description" content="Free Web tutorials" />

    217. 

  217.  * <meta name="keywords" content="HTML,CSS,XML,JavaScript" />

    218. 

  218.  * <meta name="author" content="Hege Refsnes" />

    219. 

  219.  * <meta http-equiv="Content-Type" content="text/html;charset=ISO-8859-1" />

    220. 

  220.  * <META NAME="ROBOTS" CONTENT="NOYDIR">

    221. 

  221.  * <META NAME="Slurp" CONTENT="NOYDIR">

    222. 

  222.  * <META name="author" content="John Doe">

    223. 

  223.  *   <META name ="copyright" content="&copy; 1997 Acme Corp.">

    224. 

  224.  *   <META name= "keywords" content="corporate,guidelines,cataloging">

    225. 

  225.  *   <META name = "date" content="1994-11-06T08:49:37+00:00">

    226. 

  226.  *       <meta name="DC.title" lang="en" content="Services to Government" >

    227. 

  227.  *     <meta name="DCTERMS.modified" scheme="XSD.date" content="2007-07-22" >

    228. 

  228.  * <META http-equiv="Content-Type" content="text/html; charset=iso-8859-1">

    229. 

  229.  * <META name="geo.position" content="26.367559;-80.12172">

    230. 

  230.  * <META name="geo.region" content="US-FL">

    231. 

  231.  * <META name="geo.placename" content="Boca Raton, FL">

    232. 

  232.  * <META name="ICBM" content="26.367559, -80.12172">

    233. 

  233.  * <META name="DC.title" content="THE NAME OF YOUR SITE">

    234. 

  234.  * </pre>

    235. 

  235.  *

    236. 

  236.  * Here is a dump of the returned array:

    237. 

  237.  *

    238. 

  238.  * <pre>

    239. 

  239.  * array (

    240. 

  240.  *   'key' => 

    241. 

  241.  *   array (

    242. 

  242.  *     'Content-Type' => 'text/html; charset=iso-8859-1',

    243. 

  243.  *     'description' => 'Free Web tutorials',

    244. 

  244.  *     'keywords' => 'corporate,guidelines,cataloging',

    245. 

  245.  *     'author' => 'John Doe',

    246. 

  246.  *     'ROBOTS' => 'NOYDIR',

    247. 

  247.  *     'Slurp' => 'NOYDIR',

    248. 

  248.  *     'copyright' => '&copy; 1997 Acme Corp.',

    249. 

  249.  *     'date' => '1994-11-06T08:49:37+00:00',

    250. 

  250.  *     'DC.title' => 'THE NAME OF YOUR SITE',

    251. 

  251.  *     'DCTERMS.modified' => '2007-07-22',

    252. 

  252.  *     'geo.position' => '26.367559;-80.12172',

    253. 

  253.  *     'geo.region' => 'US-FL',

    254. 

  254.  *     'geo.placename' => 'Boca Raton, FL',

    255. 

  255.  *     'ICBM' => '26.367559, -80.12172',

    256. 

  256.  *   ),

    257. 

  257.  *   'http-equiv' => 

    258. 

  258.  *   array (

    259. 

  259.  *     'Content-Type' => 'text/html; charset=iso-8859-1',

    260. 

  260.  *   ),

    261. 

  261.  *   'name' => 

    262. 

  262.  *   array (

    263. 

  263.  *     'description' => 'Free Web tutorials',

    264. 

  264.  *     'keywords' => 'corporate,guidelines,cataloging',

    265. 

  265.  *     'author' => 'John Doe',

    266. 

  266.  *     'ROBOTS' => 'NOYDIR',

    267. 

  267.  *     'Slurp' => 'NOYDIR',

    268. 

  268.  *     'copyright' => '&copy; 1997 Acme Corp.',

    269. 

  269.  *     'date' => '1994-11-06T08:49:37+00:00',

    270. 

  270.  *     'DC.title' => 'THE NAME OF YOUR SITE',

    271. 

  271.  *     'DCTERMS.modified' => '2007-07-22',

    272. 

  272.  *     'geo.position' => '26.367559;-80.12172',

    273. 

  273.  *     'geo.region' => 'US-FL',

    274. 

  274.  *     'geo.placename' => 'Boca Raton, FL',

    275. 

  275.  *     'ICBM' => '26.367559, -80.12172',

    276. 

  276.  *   ),

    277. 

  277.  *   'lang' => 

    278. 

  278.  *   array (

    279. 

  279.  *     'DC.title' => 'en',

    280. 

  280.  *   ),

    281. 

  281.  *   'scheme' => 

    282. 

  282.  *   array (

    283. 

  283.  *     'DCTERMS.modified' => 'XSD.date',

    284. 

  284.  *   ),

    285. 

  285.  * </pre>

    286. 

  286.  *

    287. 

  287.  * Note how repeated tags cause the previous value to be overwritten in the resulting array

    288. 

  288.  * (for example the <var>Content-Type</var> and <var>keywords</var> tags appear twice but the

    289. 

  289.  * final array only has one element for each - the lowest one in the original list).

    290. 

  290.  *

    291. 

  291.  * @param string $html The string containing the html to be parsed

    292. 

  292.  */

    293. 

  293. 	public static /*.array[string][string]string.*/ function meta_to_array(/*.string.*/ $html) {

    294. 

  294. 		$keyAttributes	= array('name', 'http-equiv', 'charset', 'itemprop');

    295. 

  295. 		$tags		= /*.(array[int][int]string).*/ array();

    296. 

  296. 		$query		= '?';

    297. 

  297. 

    298. 

  298. 		preg_match_all("|<meta.+/$query>|i", $html, $tags);

    299. 

  299. 

    300. 

  300. 		$meta		= /*.(array[string][string]string).*/ array();

    301. 

  301. 		$key_type	= '';

    302. 

  302. 		$key		= '';

    303. 

  303. 		$content	= '';

    304. 

  304. 

    305. 

  305. 		foreach ($tags[0] as $tag) {

    306. 

  306. 			$attributes	= array();

    307. 

  307. 			$wip		= /*.(array[string]string).*/ array();

    308. 

  308. 

    309. 

  309. 			preg_match_all('|\\s(\\S+?)\\s*=\\s*"(.*?)"|', $tag, $attributes);

    310. 

  310. 

    311. 

  311. 

    312. 

  312. 			unset($key_type);

    313. 

  313. 			unset($key);

    314. 

  314. 			unset($content);

    315. 

  315. 

    316. 

  316. 			for ($i = 0; $i < count($attributes[1]); $i++) {

    317. 

  317. 				$attribute	= strtolower($attributes[1][$i]);

    318. 

  318. 				$value		= $attributes[2][$i];

    319. 

  319. 

    320. 

  320. 				if (in_array($attribute, $keyAttributes)) {

    321. 

  321. 					$key_type		= $attribute;

    322. 

  322. 					$key			= $value;

    323. 

  323. 				} elseif ($attribute === 'content') {

    324. 

  324. 					$content		= $value;

    325. 

  325. 				} else {

    326. 

  326. 					$wip[$attribute]	= $value;

    327. 

  327. 				}

    328. 

  328. 			}

    329. 

  329. 

    330. 

  330. 			if (isset($key_type)) {

    331. 

  331. 				$meta['key'][$key]	= $content;

    332. 

  332. 				$meta[$key_type][$key]	= $content;

    333. 

  333. 

    334. 

  334. 				foreach ($wip as $attribute => $value) {

    335. 

  335. 					$meta[$attribute][$key] = $value;

    336. 

  336. 				}

    337. 

  337. 			}

    338. 

  338. 		}

    339. 

  339. 

    340. 

  340. 		return $meta;

    341. 

  341. 	}

    342. 

  342. 

    343. 

  343. /**

    344. 

  344.  * Return the contents of a captured var_dump() as HTML. This is a recursive function.

    345. 

  345.  *

    346. 

  346.  * @param string $var_dump The captured <var>var_dump()</var>.

    347. 

  347.  * @param int $offset Whereabouts to start in the captured string. Defaults to the beginning of the string.

    348. 

  348.  */

    349. 

  349. 	public static /*.string.*/ function var_dump_to_HTML(/*.string.*/ $var_dump, $offset = 0) {

    350. 

  350. 		$indent	= '';

    351. 

  351. 		$value	= '';

    352. 

  352. 

    353. 

  353. 		while ((boolean) ($posStart = strpos($var_dump, '(', $offset))) {

    354. 

  354. 			$type	= substr($var_dump, $offset, $posStart - $offset);

    355. 

  355. 			$nests	= strrpos($type, ' ');

    356. 

  356. 

    357. 

  357. 			if ($nests === false) $nests = 0; else $nests = intval(($nests + 1) / 2);

    358. 

  358. 

    359. 

  359. 			$indent = str_pad('', $nests * 3, "\t");

    360. 

  360. 			$type	= trim($type);

    361. 

  361. 			$offset	= ++$posStart;

    362. 

  362. 			$posEnd	= strpos($var_dump, ')', $offset); if ($posEnd === false) break;

    363. 

  363. 			$offset	= $posEnd + 1;

    364. 

  364. 			$value	= substr($var_dump, $posStart, $posEnd - $posStart);

    365. 

  365. 

    366. 

  366. 			switch ($type) {

    367. 

  367. 			case 'string':

    368. 

  368. 				$length	= (int) $value;

    369. 

  369. 				$value	= '<pre>' . htmlspecialchars(substr($var_dump, $offset + 2, $length)) . '</pre>';

    370. 

  370. 				$offset	+= $length + 3;

    371. 

  371. 				break;

    372. 

  372. 			case 'array':

    373. 

  373. 				$elementTellTale	= "\n" . str_pad('', ($nests + 1) * 2) . '['; // Not perfect but the best var_dump will allow

    374. 

  374. 				$elementCount		= (int) $value;

    375. 

  375. 				$value			= "\n$indent<table>\n";

    376. 

  376. 

    377. 

  377. 				for ($i = 1; $i <= $elementCount; $i++) {

    378. 

  378. 					$posStart	= strpos($var_dump, $elementTellTale, $offset);	if ($posStart	=== false) break;

    379. 

  379. 					$posStart	+= ($nests + 1) * 2 + 2;

    380. 

  380. 					$offset		= $posStart;

    381. 

  381. 					$posEnd		= strpos($var_dump, ']', $offset);		if ($posEnd	=== false) break;

    382. 

  382. 					$offset		= $posEnd + 4; // Read past the =>\n

    383. 

  383. 					$key		= substr($var_dump, $posStart, $posEnd - $posStart);

    384. 

  384. 

    385. 

  385. 					if (!is_numeric($key)) $key = substr($key, 1, strlen($key) - 2); // Strip off the double quotes

    386. 

  386. 

    387. 

  387. 					$search		= ($i === $elementCount) ? "\n" . str_pad('', $nests * 2) . '}' : $elementTellTale;

    388. 

  388. 					$posStart	= strpos($var_dump, $search, $offset);		if ($posStart	=== false) break;

    389. 

  389. 					$next		= substr($var_dump, $offset, $posStart - $offset);

    390. 

  390. 					$offset		= $posStart;

    391. 

  391. 					$inner_value	= self::var_dump_to_HTML($next);

    392. 

  392. 

    393. 

  393. 					$value		.= "$indent\t<tr>\n";

    394. 

  394. 					$value		.= "$indent\t\t<td>$key</td>\n";

    395. 

  395. 					$value		.= "$indent\t\t<td>$inner_value</td>\n";

    396. 

  396. 					$value		.= "$indent\t</tr>\n";

    397. 

  397. 				}

    398. 

  398. 

    399. 

  399. 				$value			.= "$indent</table>\n";

    400. 

  400. 				break;

    401. 

  401. 			case 'object':

    402. 

  402. 				if ($value === '__PHP_Incomplete_Class') {

    403. 

  403. 					$posStart	= strpos($var_dump, '(', $offset);	if ($posStart	=== false) break;

    404. 

  404. 					$offset		= ++$posStart;

    405. 

  405. echo "$indent Corrected \$offset = $offset\n"; // debug

    406. 

  406. 					$posEnd		= strpos($var_dump, ')', $offset);	if ($posEnd	=== false) break;

    407. 

  407. 					$offset		= $posEnd + 1;

    408. 

  408. echo "$indent Corrected \$offset = $offset\n"; // debug

    409. 

  409. 					$value		= substr($var_dump, $posStart, $posEnd - $posStart);

    410. 

  410. 				}

    411. 

  411. 

    412. 

  412. 				break;

    413. 

  413. 			default:

    414. 

  414. 				break;

    415. 

  415. 			}

    416. 

  416. 

    417. 

  417. 		}

    418. 

  418. 

    419. 

  419. 		return $value;

    420. 

  420. 	}

    421. 

  421. 

    422. 

  422. /**

    423. 

  423.  * Return the contents of an array as HTML (like <var>var_dump()</var> on steroids), including object members

    424. 

  424.  *

    425. 

  425.  * @param mixed $source The array to export. If it's empty then $GLOBALS is exported.

    426. 

  426.  */

    427. 

  427. 	public static /*.string.*/ function array_to_HTML(/*.array[]mixed.*/ $source = NULL) {

    428. 

  428. // If no specific array is passed we will export $GLOBALS to HTML

    429. 

  429. // Unfortunately, this means we have to use var_dump() because var_export() barfs on $GLOBALS

    430. 

  430. // In fact var_dump is easier to walk than var_export anyway so this is no bad thing.

    431. 

  431. 

    432. 

  432. 		ob_start();

    433. 

  433. 		if (empty($source)) var_dump($GLOBALS); else var_dump($source);

    434. 

  434. 		$var_dump = ob_get_clean();

    435. 

  435. 

    436. 

  436. 		return self::var_dump_to_HTML($var_dump);

    437. 

  437. 	}

    438. 

  438. 

    439. 

  439. /**

    440. 

  440.  * Check session is running. If not start one.

    441. 

  441.  */

    442. 

  442. 	public static /*.void.*/ function checkSession() {if (!isset($_SESSION) || !is_array($_SESSION) || (session_id() === '')) session_start();}

    443. 

  443. 

    444. 

  444. ///**

    445. 

  445. // * Return the name of this package. By default this will be in lower case for use in Javascript tags etc.

    446. 

  446. // *

    447. 

  447. // * @param int $mode One of the <var>PACKAGE_CASE_XXX</var> predefined constants defined in this class

    448. 

  448. // */

    449. 

  449. //	public static /*.string.*/ function getPackage($mode = self::PACKAGE_CASE_DEFAULT) {

    450. 

  450. //		switch ($mode) {

    451. 

  451. //		case self::PACKAGE_CASE_CAMEL:

    452. 

  452. //			$package = self::PACKAGE;

    453. 

  453. //			break;

    454. 

  454. //		case self::PACKAGE_CASE_UPPER:

    455. 

  455. //			$package = strtoupper(self::PACKAGE);

    456. 

  456. //			break;

    457. 

  457. //		default:

    458. 

  458. //			$package = strtolower(self::PACKAGE);

    459. 

  459. //			break;

    460. 

  460. //		}

    461. 

  461. //

    462. 

  462. //		return $package;

    463. 

  463. //	}

    464. 

  464. 

    465. 

  465. /**

    466. 

  466.  * Return all or part of the URL of the current script.

    467. 

  467.  *

    468. 

  468.  * @param int $mode One of the <var>URL_MODE_XXX</var> predefined constants defined in this class

    469. 

  469.  * @param string $filename If this is not empty then the returned script name is forced to be this filename.

    470. 

  470.  */

    471. 

  471. 	public static /*.string.*/ function getURL($mode = self::URL_MODE_PATH, $filename = 'ezUser') {

    472. 

  472. // Version 1.14: PACKAGE & VERSION now hard-coded by build process.

    473. 

  473. 		$portInteger = array_key_exists('SERVER_PORT', $_SERVER) ? (int) $_SERVER['SERVER_PORT'] : 0;

    474. 

  474. 

    475. 

  475. 		if (array_key_exists('HTTPS', $_SERVER) && $_SERVER['HTTPS'] === 'on') {

    476. 

  476. 			$protocolType = 'https';

    477. 

  477. 		} else if (array_key_exists('SERVER_PROTOCOL', $_SERVER)) {

    478. 

  478. 			$protocolType = strtolower(self::strleft($_SERVER['SERVER_PROTOCOL'], self::URL_SEPARATOR, self::STRLEFT_MODE_ALL));

    479. 

  479. 		} else if ($portInteger === 443) {

    480. 

  480. 			$protocolType = 'https';

    481. 

  481. 		} else {

    482. 

  482. 			$protocolType = 'http';

    483. 

  483. 		}

    484. 

  484. 

    485. 

  485. 		if ($portInteger === 0) $portInteger = ($protocolType === 'https') ? 443 : 80;

    486. 

  486. 

    487. 

  487. 		// Protocol

    488. 

  488. 		if ((boolean) ($mode & self::URL_MODE_PROTOCOL)) {

    489. 

  489. 			$protocol = ($mode === self::URL_MODE_PROTOCOL) ? $protocolType : "$protocolType://";

    490. 

  490. 		} else {

    491. 

  491. 			$protocol = '';

    492. 

  492. 		}

    493. 

  493. 

    494. 

  494. 		// Host

    495. 

  495. 		if ((boolean) ($mode & self::URL_MODE_HOST)) {

    496. 

  496. 			$host = array_key_exists('HTTP_HOST', $_SERVER) ? self::strleft($_SERVER['HTTP_HOST'], ':', self::STRLEFT_MODE_ALL) : '';

    497. 

  497. 		} else {

    498. 

  498. 			$host = '';

    499. 

  499. 		}

    500. 

  500. 

    501. 

  501. 		// Port

    502. 

  502. 		if ((boolean) ($mode & self::URL_MODE_PORT)) {

    503. 

  503. 			$port = (string) $portInteger;

    504. 

  504. 

    505. 

  505. 			if ($mode !== self::URL_MODE_PORT)

    506. 

  506. 				$port = (($protocolType === 'http' && $portInteger === 80) || ($protocolType === 'https' && $portInteger === 443)) ? '' : ":$port";

    507. 

  507. 		} else {

    508. 

  508. 			$port = '';

    509. 

  509. 		}

    510. 

  510. 

    511. 

  511. 		// Path

    512. 

  512. 		if ((boolean) ($mode & self::URL_MODE_PATH)) {

    513. 

  513. 			$includePath	= __FILE__;

    514. 

  514. 			$scriptPath	= realpath($_SERVER['SCRIPT_FILENAME']);

    515. 

  515. 

    516. 

  516. 			if (DIRECTORY_SEPARATOR !== self::URL_SEPARATOR) {

    517. 

  517. 				$includePath	= (string) str_replace(DIRECTORY_SEPARATOR, self::URL_SEPARATOR , $includePath);

    518. 

  518. 				$scriptPath	= (string) str_replace(DIRECTORY_SEPARATOR, self::URL_SEPARATOR , $scriptPath);

    519. 

  519. 			}

    520. 

  520. 

    521. 

  521. /*

    522. 

  522. echo "<pre>\n"; // debug

    523. 

  523. echo "\$_SERVER['SCRIPT_FILENAME'] = " . $_SERVER['SCRIPT_FILENAME'] . "\n"; // debug

    524. 

  524. echo "\$_SERVER['SCRIPT_NAME'] = " . $_SERVER['SCRIPT_NAME'] . "\n"; // debug

    525. 

  525. echo "dirname(\$_SERVER['SCRIPT_NAME']) = " . dirname($_SERVER['SCRIPT_NAME']) . "\n"; // debug

    526. 

  526. echo "\$includePath = $includePath\n"; // debug

    527. 

  527. echo "\$scriptPath = $scriptPath\n"; // debug

    528. 

  528. //echo self::array_to_HTML(); // debug

    529. 

  529. echo "</pre>\n"; // debug

    530. 

  530. */

    531. 

  531. 

    532. 

  532. 			$start	= strpos(strtolower($scriptPath), strtolower($_SERVER['SCRIPT_NAME']));

    533. 

  533. 			$path	= ($start === false) ? dirname($_SERVER['SCRIPT_NAME']) : dirname(substr($includePath, $start));

    534. 

  534. 			$path	.= self::URL_SEPARATOR . $filename;

    535. 

  535. 		} else {

    536. 

  536. 			$path = '';

    537. 

  537. 		}

    538. 

  538. 

    539. 

  539. 		return $protocol . $host . $port . $path;

    540. 

  540. 	}

    541. 

  541. 

    542. 

  542. /**

    543. 

  543.  * Convert a DocBlock to HTML (see http://java.sun.com/j2se/javadoc/writingdoccomments/index.html)

    544. 

  544.  *

    545. 

  545.  * @param string $docBlock Some PHP code containing a valid DocBlock.

    546. 

  546.  */

    547. 

  547. 	public static /*.string.*/ function docBlock_to_HTML(/*.string.*/ $php) {

    548. 

  548. // Updated in version 1.12 (bug fixes and formatting)

    549. 

  549. //		$package	= self::getPackage(self::PACKAGE_CASE_CAMEL); // Version 1.14: PACKAGE & VERSION now hard-coded by build process.

    550. 

  550. 		$eol		= "\r\n";

    551. 

  551. 		$tagStart	= strpos($php, "/**$eol * ");

    552. 

  552. 

    553. 

  553. 		if ($tagStart === false) return 'Development version';

    554. 

  554. 

    555. 

  555. 		// Get summary and long description

    556. 

  556. 		$tagStart	+= 8;

    557. 

  557. 		$tagEnd		= strpos($php, $eol, $tagStart);

    558. 

  558. 		$summary	= substr($php, $tagStart, $tagEnd - $tagStart);

    559. 

  559. 		$tagStart	= $tagEnd + 7;

    560. 

  560. 		$tagPos		= strpos($php, "$eol * @") + 2;

    561. 

  561. 		$description	= substr($php, $tagStart, $tagPos - $tagStart - 7);

    562. 

  562. 		$description	= (string) str_replace(' * ', '' , $description);

    563. 

  563. 

    564. 

  564. 		// Get tags and values from DocBlock

    565. 

  565. 		do {

    566. 

  566. 			$tagStart	= $tagPos + 4;

    567. 

  567. 			$tagEnd		= strpos($php, "\t", $tagStart);

    568. 

  568. 			$tag		= substr($php, $tagStart, $tagEnd - $tagStart);

    569. 

  569. 			$offset		= $tagEnd + 1;

    570. 

  570. 			$tagPos		= strpos($php, $eol, $offset);

    571. 

  571. 			$value		= htmlspecialchars(substr($php, $tagEnd + 1, $tagPos - $tagEnd - 1));

    572. 

  572. 			$tagPos		= strpos($php, " * @", $offset);

    573. 

  573. 

    574. 

  574. //			$$tag		= htmlspecialchars($value); // The easy way. But PHPlint doesn't like it, so...

    575. 

  575. 

    576. 

  576. //			$package	= '';

    577. 

  577. //			$summary	= '';

    578. 

  578. //			$description	= '';

    579. 

  579. 

    580. 

  580. 			switch ($tag) {

    581. 

  581. 			case 'license':		$license	= $value; break;

    582. 

  582. 			case 'author':		$author		= $value; break;

    583. 

  583. 			case 'link':		$link		= $value; break;

    584. 

  584. 			case 'version':		$version	= $value; break;

    585. 

  585. 			case 'copyright':	$copyright	= $value; break;

    586. 

  586. 			default:		$value		= $value;

    587. 

  587. 			}

    588. 

  588. 		} while ((boolean) $tagPos);

    589. 

  589. 

    590. 

  590. 		// Add some links

    591. 

  591. 		// 1. License

    592. 

  592. 		if (isset($license) && (boolean) strpos($license, '://')) {

    593. 

  593. 			$tagPos		= strpos($license, ' ');

    594. 

  594. 			$license	= '<a href="' . substr($license, 0, $tagPos) . '">' . substr($license, $tagPos + 1) . '</a>';

    595. 

  595. 		}

    596. 

  596. 

    597. 

  597. 		// 2. Author

    598. 

  598. 		if (isset($author) && preg_match('/&lt;.+@.+&gt;/', $author) > 0) {

    599. 

  599. 			$tagStart	= strpos($author, '&lt;') + 4;

    600. 

  600. 			$tagEnd		= strpos($author, '&gt;', $tagStart);

    601. 

  601. 			$author		= '<a href="mailto:' . substr($author, $tagStart, $tagEnd - $tagStart) . '">' . substr($author, 0, $tagStart - 5) . '</a>';

    602. 

  602. 		}

    603. 

  603. 

    604. 

  604. 		// 3. Link

    605. 

  605. 		if (isset($link) && (boolean) strpos($link, '://')) {

    606. 

  606. 			$link		= '<a href="' . $link . '">' . $link . '</a>';

    607. 

  607. 		}

    608. 

  608. 

    609. 

  609. 		// Build the HTML

    610. 

  610. 		$html = <<<HTML

    611. 

  611. 	<h1>ezUser</h1>

    612. 

  612. 	<h2>$summary</h2>

    613. 

  613. 	<pre>$description</pre>

    614. 

  614. 	<hr />

    615. 

  615. 	<table>

    616. 

  616. 

    617. 

  617. HTML;

    618. 

  618. // Version 1.14: PACKAGE & VERSION now hard-coded by build process.

    619. 

  619. 

    620. 

  620. 		if (isset($version))	$html .= "\t\t<tr><td>Version</td><td>$version</td></tr>\n";

    621. 

  621. 		if (isset($copyright))	$html .= "\t\t<tr><td>Copyright</td><td>$copyright</td></tr>\n";

    622. 

  622. 		if (isset($license))	$html .= "\t\t<tr><td>License</td><td>$license</td></tr>\n";

    623. 

  623. 		if (isset($author))	$html .= "\t\t<tr><td>Author</td><td>$author</td></tr>\n";

    624. 

  624. 		if (isset($link))	$html .= "\t\t<tr><td>Link</td><td>$link</td></tr>\n";

    625. 

  625. 

    626. 

  626. 		$html .= "\t</table>";

    627. 

  627. 		return $html;

    628. 

  628. 	}

    629. 

  629. 

    630. 

  630. /**

    631. 

  631.  * glob() replacement (in case glob() is disabled).

    632. 

  632.  *

    633. 

  633.  * Function glob() is prohibited on some server (probably in safe mode)

    634. 

  634.  * (Message "Warning: glob() has been disabled for security reasons in

    635. 

  635.  * (script) on line (line)") for security reasons as stated on:

    636. 

  636.  * http://seclists.org/fulldisclosure/2005/Sep/0001.html

    637. 

  637.  *

    638. 

  638.  * safe_glob() intends to replace glob() using readdir() & fnmatch() instead.

    639. 

  639.  * Supported flags: GLOB_MARK, GLOB_NOSORT, GLOB_ONLYDIR

    640. 

  640.  * Additional flags: GLOB_NODIR, GLOB_PATH, GLOB_NODOTS, GLOB_RECURSE

    641. 

  641.  * (these were not original glob() flags)

    642. 

  642.  * @author BigueNique AT yahoo DOT ca

    643. 

  643.  */

    644. 

  644. 	public static /*.mixed.*/ function safe_glob(/*.string.*/ $pattern, /*.int.*/ $flags = 0) {

    645. 

  645. 		$split	= explode('/', (string) str_replace('\\', '/', $pattern));

    646. 

  646. 		$mask	= (string) array_pop($split);

    647. 

  647. 		$path	= (count($split) === 0) ? '.' : implode('/', $split);

    648. 

  648. 		$dir	= @opendir($path);

    649. 

  649. 

    650. 

  650. 		if ($dir === false) return false;

    651. 

  651. 

    652. 

  652. 		$glob	= /*.(array[int]).*/ array();

    653. 

  653. 

    654. 

  654. 		do {

    655. 

  655. 			$filename = readdir($dir);

    656. 

  656. 			if ($filename === false) break;

    657. 

  657. 

    658. 

  658. 			$is_dir	= is_dir("$path/$filename");

    659. 

  659. 			$is_dot	= in_array($filename, array('.', '..'));

    660. 

  660. 

    661. 

  661. 			// Recurse subdirectories (if GLOB_RECURSE is supplied)

    662. 

  662. 			if ($is_dir && !$is_dot && (($flags & self::GLOB_RECURSE) !== 0)) {

    663. 

  663. 				$sub_glob	= /*.(array[int]).*/ self::safe_glob($path.'/'.$filename.'/'.$mask,  $flags);

    664. 

  664. //					array_prepend($sub_glob, ((boolean) ($flags & self::GLOB_PATH) ? '' : $filename.'/'));

    665. 

  665. 				$glob		= /*.(array[int]).*/ array_merge($glob, $sub_glob);

    666. 

  666. 			}

    667. 

  667. 

    668. 

  668. 			// Match file mask

    669. 

  669. 			if (fnmatch($mask, $filename)) {

    670. 

  670. 				if (	((($flags & GLOB_ONLYDIR) === 0)	|| $is_dir)

    671. 

  671. 				&&	((($flags & self::GLOB_NODIR) === 0)	|| !$is_dir)

    672. 

  672. 				&&	((($flags & self::GLOB_NODOTS) === 0)	|| !$is_dot)

    673. 

  673. 				)

    674. 

  674. 					$glob[] = (($flags & self::GLOB_PATH) !== 0 ? $path.'/' : '') . $filename . (($flags & GLOB_MARK) !== 0 ? '/' : '');

    675. 

  675. 			}

    676. 

  676. 		} while(true);

    677. 

  677. 

    678. 

  678. 		closedir($dir);

    679. 

  679. 		if (($flags & GLOB_NOSORT) === 0) sort($glob);

    680. 

  680. 

    681. 

  681. 		return $glob;

    682. 

  682. 	}

    683. 

  683. 

    684. 

  684. /**

    685. 

  685.  * Return file contents as a string. Fail silently if the file can't be opened.

    686. 

  686.  *

    687. 

  687.  * The parameters are the same as the built-in PHP function {@link http://www.php.net/file_get_contents file_get_contents}

    688. 

  688.  */

    689. 

  689. 	public static /*.string.*/ function getFileContents(/*.string.*/ $filename, /*.int.*/ $flags = 0, /*.object.*/ $context = NULL, /*.int.*/ $offset = -1, /*.int.*/ $maxlen = -1) {

    690. 

  690. 		// From the documentation of file_get_contents:

    691. 

  691. 		// Note: The default value of maxlen is not actually -1; rather, it is an internal PHP value which means to copy the entire stream until end-of-file is reached. The only way to specify this default value is to leave it out of the parameter list.

    692. 

  692. 		if ($maxlen === -1) {

    693. 

  693. 			$contents = @file_get_contents($filename, $flags, $context, $offset);

    694. 

  694. 		} else {

    695. 

  695. 			$contents = @file_get_contents($filename, $flags, $context, $offset, $maxlen);

    696. 

  696. // version 1.9 - remembered the @s

    697. 

  697. 		}

    698. 

  698. 

    699. 

  699. 		if ($contents === false) $contents = '';

    700. 

  700. 		return $contents;

    701. 

  701. 	}

    702. 

  702. 

    703. 

  703. /**

    704. 

  704.  * Return the name of the index file (e.g. <var>index.php</var>) from a folder

    705. 

  705.  *

    706. 

  706.  * @param string $folder The folder to look for the index file. If not a folder or no index file can be found then an empty string is returned.

    707. 

  707.  */

    708. 

  708. 	public static /*.string.*/ function findIndexFile(/*.string.*/ $folder) {

    709. 

  709. 		if (!is_dir($folder)) return '';

    710. 

  710. 		$filelist = array('index.php', 'index.pl', 'index.cgi', 'index.asp', 'index.shtml', 'index.html', 'index.htm', 'default.php', 'default.pl', 'default.cgi', 'default.asp', 'default.shtml', 'default.html', 'default.htm', 'home.php', 'home.pl', 'home.cgi', 'home.asp', 'home.shtml', 'home.html', 'home.htm');

    711. 

  711. 

    712. 

  712. 		foreach ($filelist as $filename) {

    713. 

  713. 			$target = $folder . DIRECTORY_SEPARATOR . $filename;

    714. 

  714. 			if (is_file($target)) return $target;

    715. 

  715. 		}

    716. 

  716. 

    717. 

  717. 		return '';

    718. 

  718. 	}

    719. 

  719. 

    720. 

  720. /**

    721. 

  721.  * Return the name of the target file from a string that might be a directory or just a basename without a suffix. If it's a directory then look for an index file in the directory.

    722. 

  722.  *

    723. 

  723.  * @param string $target The file to look for or folder to look in. If no file can be found then an empty string is returned.

    724. 

  724.  */

    725. 

  725. 	public static /*.string.*/ function findTarget(/*.string.*/ $target) {

    726. 

  726. 		// Is it actually a file? If so, look no further

    727. 

  727. 		if (is_file($target)) return $target;

    728. 

  728. 

    729. 

  729. 		// Added in version 1.7

    730. 

  730. 		// Is it a basename? i.e. can we find $target.html or something?

    731. 

  731. 		$suffixes = array('shtml', 'html', 'php', 'pl', 'cgi', 'asp', 'htm');

    732. 

  732. 

    733. 

  733. 		foreach ($suffixes as $suffix) {

    734. 

  734. 			$filename = "$target.$suffix";

    735. 

  735. 			if (is_file($filename)) return $filename;

    736. 

  736. 		}

    737. 

  737. 

    738. 

  738. 		// Otherwise, let's assume it's a directory and try to find an index file in that directory

    739. 

  739. 		return self::findIndexFile($target);

    740. 

  740. 	}

    741. 

  741. 

    742. 

  742. /**

    743. 

  743.  * Make a unique ID based on the current date and time

    744. 

  744.  */

    745. 

  745. 	public static /*.string.*/ function makeId() {

    746. 

  746. // Note could also try this: return md5(uniqid(mt_rand(), true));

    747. 

  747. 		list($usec, $sec) = explode(" ", (string) microtime());

    748. 

  748. 		return base_convert($sec, 10, 36) . base_convert((string) mt_rand(0, 35), 10, 36) . str_pad(base_convert(($usec * 1000000), 10, 36), 4, '_', STR_PAD_LEFT);

    749. 

  749. 	}

    750. 

  750. 

    751. 

  751. /**

    752. 

  752.  * Make a unique hash key from a string (usually an ID)

    753. 

  753.  */

    754. 

  754. 	public static /*.string.*/ function makeUniqueKey(/*.string.*/ $id) {

    755. 

  755. 		return hash(self::HASH_FUNCTION, $_SERVER['REQUEST_TIME'] . $id);

    756. 

  756. 	}

    757. 

  757. 

    758. 

  758. // Added in version 1.10

    759. 

  759. /**

    760. 

  760.  * Shuffle a string using the Mersenne Twist PRNG (can be deterministically seeded)

    761. 

  761.  *

    762. 

  762.  * @param string $str The string to be shuffled

    763. 

  763.  * @param int $seed The seed for the PRNG means this can be used to shuffle the string in the same order every time

    764. 

  764.  */

    765. 

  765. 	public static /*.string.*/ function mt_shuffle(/*.string.*/ $str, /*.int.*/ $seed = 0) {

    766. 

  766. 		$count	= strlen($str);

    767. 

  767. 		$result	= $str;

    768. 

  768. 

    769. 

  769. 		// Seed the RNG with a deterministic seed

    770. 

  770. 		mt_srand($seed);

    771. 

  771. 

    772. 

  772. 		// Shuffle the digits

    773. 

  773. 		for ($element = $count - 1; $element >= 0; $element--) {

    774. 

  774. 			$shuffle		= mt_rand(0, $element);

    775. 

  775. 

    776. 

  776. 			$value			= $result[$shuffle];

    777. 

  777. //			$result[$shuffle]	= $result[$element];

    778. 

  778. //			$result[$element]	= $value;		// PHPLint doesn't like this syntax, so...

    779. 

  779. 

    780. 

  780. 			substr_replace($result, $result[$element], $shuffle, 1);

    781. 

  781. 			substr_replace($result, $value, $element, 1);

    782. 

  782. 		}

    783. 

  783. 

    784. 

  784. 		return $result;

    785. 

  785. 	}

    786. 

  786. 

    787. 

  787. // Added in version 1.10

    788. 

  788. /**

    789. 

  789.  * Shuffle an array using the Mersenne Twist PRNG (can be deterministically seeded)

    790. 

  790.  *

    791. 

  791.  */

    792. 

  792. 	public static /*.void.*/ function mt_shuffle_array(/*.array.*/ &$arr, /*.int.*/ $seed = 0) {

    793. 

  793. 		$count	= count($arr);

    794. 

  794. 		$keys	= array_keys($arr);

    795. 

  795. 

    796. 

  796. 		// Seed the RNG with a deterministic seed

    797. 

  797. 		mt_srand($seed);

    798. 

  798. 

    799. 

  799. 		// Shuffle the digits

    800. 

  800. 		for ($element = $count - 1; $element >= 0; $element--) {

    801. 

  801. 			$shuffle		= mt_rand(0, $element);

    802. 

  802. 

    803. 

  803. 			$key_shuffle		= $keys[$shuffle];

    804. 

  804. 			$key_element		= $keys[$element];

    805. 

  805. 

    806. 

  806. 			$value			= $arr[$key_shuffle];

    807. 

  807. 			$arr[$key_shuffle]	= $arr[$key_element];

    808. 

  808. 			$arr[$key_element]	= $value;

    809. 

  809. 		}

    810. 

  810. 	}

    811. 

  811. 

    812. 

  812. // Added in version 1.10

    813. 

  813. /**

    814. 

  814.  * The Pseudo-Random Key Generator returns an apparently random key of

    815. 

  815.  * length $length and comprising digits specified by $base. However, for

    816. 

  816.  * a given seed this key depends only on $index.

    817. 

  817.  * 

    818. 

  818.  * In other words, if you keep the $seed constant then you'll get a

    819. 

  819.  * non-repeating series of keys as you increment $index but these keys

    820. 

  820.  * will be returned in a pseudo-random order.

    821. 

  821.  * 

    822. 

  822.  * The $seed parameter is available in case you want your series of keys

    823. 

  823.  * to come out in a different order to mine.

    824. 

  824.  * 

    825. 

  825.  * Comparison of bases:

    826. 

  826.  * <pre>

    827. 

  827.  * +------+----------------+---------------------------------------------+

    828. 

  828.  * |      | Max keys       |                                             |

    829. 

  829.  * |      | (based on      |                                             |

    830. 

  830.  * | Base | $length = 6)   | Notes                                       |

    831. 

  831.  * +------+----------------+---------------------------------------------+

    832. 

  832.  * | 2    | 64             | Uses digits 0 and 1 only                    |

    833. 

  833.  * | 8    | 262,144        | Uses digits 0-7 only                        |

    834. 

  834.  * | 10   | 1,000,000      | Good choice if you need integer keys        |

    835. 

  835.  * | 16   | 16,777,216     | Good choice if you need hex keys            |

    836. 

  836.  * | 26   | 308,915,776    | Good choice if you need purely alphabetic   |

    837. 

  837.  * |      |                | keys (case-insensitive)                     |

    838. 

  838.  * | 32   | 1,073,741,824  | Smallest base that gives you a billion keys |

    839. 

  839.  * |      |                | in 6 digits                                 |

    840. 

  840.  * | 34   | 1,544,804,416  | (default) Good choice if you want to        |

    841. 

  841.  * |      |                | maximise your keyset size but still         |

    842. 

  842.  * |      |                | generate keys that are unambiguous and      |

    843. 

  843.  * |      |                | case-insensitive (no confusion between 1, I |

    844. 

  844.  * |      |                | and l for instance)                         |

    845. 

  845.  * | 36   | 2,176,782,336  | Same digits as base-34 but includes 'O' and |

    846. 

  846.  * |      |                | 'I' (may be confused with '0' and '1' in    |

    847. 

  847.  * |      |                | some fonts)                                 |

    848. 

  848.  * | 52   | 19,770,609,664 | Good choice if you need purely alphabetic   |

    849. 

  849.  * |      |                | keys (case-sensitive)                       |

    850. 

  850.  * | 62   | 56,800,235,584 | Same digits as other URL shorteners         |

    851. 

  851.  * |      |                | (e.g bit.ly)                                |

    852. 

  852.  * | 66   | 82,653,950,016 | Includes all legal URI characters           |

    853. 

  853.  * |      |                | (http://tools.ietf.org/html/rfc3986)        |

    854. 

  854.  * |      |                | This is the maximum size of keyset that     |

    855. 

  855.  * |      |                | results in a legal URL for a given length   |

    856. 

  856.  * |      |                | of key.                                     |

    857. 

  857.  * +------+----------------+---------------------------------------------+

    858. 

  858.  * </pre>

    859. 

  859.  * @param int $index The number to be converted into a key

    860. 

  860.  * @param int $length The length of key to be returned. Along with the $base this determines the size of the keyset

    861. 

  861.  * @param int $base The number of distinct characters that can be included in the key to be returned. Along with the $length this determines the size of the keyset

    862. 

  862.  * @param int $seed The seed for the PRNG means this can be used to generate keys in the same sequence every time

    863. 

  863.  */

    864. 

  864. 	public static /*.string.*/ function prkg($index, $length = 6, $base = 34, $seed = 0) {

    865. 

  865. 		/*

    866. 

  866. 		To return a pseudo-random key, we will take $index, convert it

    867. 

  867. 		to base $base, then randomize the order of the digits. In

    868. 

  868. 		addition we will give each digit a random offset.

    869. 

  869. 

    870. 

  870. 		All the randomization operations are deterministic (based on

    871. 

  871. 		$seed) so each time the function is called we will get the

    872. 

  872. 		same shuffling of digits and the same offset for each digit.

    873. 

  873. 		*/

    874. 

  874. 		$digits	= '0123456789ABCDEFGHJKLMNPQRSTUVWXYZIOabcdefghijklmnopqrstuvwxyz-._~';

    875. 

  875. 		//					    ^ base 34 recommended

    876. 

  876. 

    877. 

  877. 		// Is $base in range?

    878. 

  878. 		if ($base < 2)			{die('Base must be greater than or equal to 2');}

    879. 

  879. 		if ($base > 66)			{die('Base must be less than or equal to 66');}

    880. 

  880. 

    881. 

  881. 		// Is $length in range?

    882. 

  882. 		if ($length < 1)		{die('Length must be greater than or equal to 1');}

    883. 

  883. 		// Max length depends on arithmetic functions of PHP

    884. 

  884. 

    885. 

  885. 		// Is $index in range?

    886. 

  886. 		$max_index = (int) pow($base, $length);

    887. 

  887. 		if ($index < 0)			{die('Index must be greater than or equal to 0');}

    888. 

  888. 		if ($index > $max_index)	{die('Index must be less than or equal to ' . $max_index);}

    889. 

  889. 

    890. 

  890. 		// Seed the RNG with a deterministic seed

    891. 

  891. 		mt_srand($seed);

    892. 

  892. 

    893. 

  893. 		// Convert to $base

    894. 

  894. 		$remainder	= $index;

    895. 

  895. 		$digit		= 0;

    896. 

  896. 		$result		= '';

    897. 

  897. 

    898. 

  898. 		while ($digit < $length) {

    899. 

  899. 			$unit		= (int) pow($base, $length - $digit++ - 1);

    900. 

  900. 			$value		= (int) floor($remainder / $unit);

    901. 

  901. 			$remainder	= $remainder - ($value * $unit);

    902. 

  902. 

    903. 

  903. 			// Shift the digit

    904. 

  904. 			$value		= ($value + mt_rand(0, $base - 1)) % $base;

    905. 

  905. 			$result		.= $digits[$value];

    906. 

  906. 		}

    907. 

  907. 

    908. 

  908. 		// Shuffle the digits

    909. 

  909. 		$result	= self::mt_shuffle($result, $seed);

    910. 

  910. 

    911. 

  911. 		// We're done

    912. 

  912. 		return $result;

    913. 

  913. 	}

    914. 

  914. 

    915. 

  915. // Updated in version 1.8

    916. 

  916. /**

    917. 

  917.  * Check that an email address conforms to RFC5322 and other RFCs

    918. 

  918.  *

    919. 

  919.  * @param boolean $checkDNS If true then a DNS check for A and MX records will be made

    920. 

  920.  * @param boolean $diagnose If true then return an integer error number rather than true or false

    921. 

  921.  */

    922. 

  922. 	public static /*.mixed.*/ function is_email (/*.string.*/ $email, $checkDNS = false, $diagnose = false) {

    923. 

  923. 		// Check that $email is a valid address. Read the following RFCs to understand the constraints:

    924. 

  924. 		// 	(http://tools.ietf.org/html/rfc5322)

    925. 

  925. 		// 	(http://tools.ietf.org/html/rfc3696)

    926. 

  926. 		// 	(http://tools.ietf.org/html/rfc5321)

    927. 

  927. 		// 	(http://tools.ietf.org/html/rfc4291#section-2.2)

    928. 

  928. 		// 	(http://tools.ietf.org/html/rfc1123#section-2.1)

    929. 

  929. 

    930. 

  930. 		// the upper limit on address lengths should normally be considered to be 256

    931. 

  931. 		// 	(http://www.rfc-editor.org/errata_search.php?rfc=3696)

    932. 

  932. 		// 	NB I think John Klensin is misreading RFC 5321 and the the limit should actually be 254

    933. 

  933. 		// 	However, I will stick to the published number until it is changed.

    934. 

  934. 		//

    935. 

  935. 		// The maximum total length of a reverse-path or forward-path is 256

    936. 

  936. 		// characters (including the punctuation and element separators)

    937. 

  937. 		// 	(http://tools.ietf.org/html/rfc5321#section-4.5.3.1.3)

    938. 

  938. 		$emailLength = strlen($email);

    939. 

  939. 		if ($emailLength > 256)			if ($diagnose) return self::ISEMAIL_TOOLONG; else return false;	// Too long

    940. 

  940. 

    941. 

  941. 		// Contemporary email addresses consist of a "local part" separated from

    942. 

  942. 		// a "domain part" (a fully-qualified domain name) by an at-sign ("@").

    943. 

  943. 		// 	(http://tools.ietf.org/html/rfc3696#section-3)

    944. 

  944. 		$atIndex = strrpos($email,'@');

    945. 

  945. 

    946. 

  946. 		if ($atIndex === false)			if ($diagnose) return self::ISEMAIL_NOAT; else return false;	// No at-sign

    947. 

  947. 		if ($atIndex === 0)			if ($diagnose) return self::ISEMAIL_NOLOCALPART; else return false;	// No local part

    948. 

  948. 		if ($atIndex === $emailLength - 1)	if ($diagnose) return self::ISEMAIL_NODOMAIN; else return false;	// No domain part

    949. 

  949. 	// revision 1.14: Length test bug suggested by Andrew Campbell of Gloucester, MA

    950. 

  950. 

    951. 

  951. 		// Sanitize comments

    952. 

  952. 		// - remove nested comments, quotes and dots in comments

    953. 

  953. 		// - remove parentheses and dots from quoted strings

    954. 

  954. 		$braceDepth	= 0;

    955. 

  955. 		$inQuote	= false;

    956. 

  956. 		$escapeThisChar	= false;

    957. 

  957. 

    958. 

  958. 		for ($i = 0; $i < $emailLength; ++$i) {

    959. 

  959. 			$char = $email[$i];

    960. 

  960. 			$replaceChar = false;

    961. 

  961. 

    962. 

  962. 			if ($char === '\\') {

    963. 

  963. 				$escapeThisChar = !$escapeThisChar;	// Escape the next character?

    964. 

  964. 			} else {

    965. 

  965. 				switch ($char) {

    966. 

  966. 				case '(':

    967. 

  967. 					if ($escapeThisChar) {

    968. 

  968. 						$replaceChar = true;

    969. 

  969. 					} else {

    970. 

  970. 						if ($inQuote) {

    971. 

  971. 							$replaceChar = true;

    972. 

  972. 						} else {

    973. 

  973. 							if ($braceDepth++ > 0) $replaceChar = true;	// Increment brace depth

    974. 

  974. 						}

    975. 

  975. 					}

    976. 

  976. 

    977. 

  977. 					break;

    978. 

  978. 				case ')':

    979. 

  979. 					if ($escapeThisChar) {

    980. 

  980. 						$replaceChar = true;

    981. 

  981. 					} else {

    982. 

  982. 						if ($inQuote) {

    983. 

  983. 							$replaceChar = true;

    984. 

  984. 						} else {

    985. 

  985. 							if (--$braceDepth > 0) $replaceChar = true;	// Decrement brace depth

    986. 

  986. 							if ($braceDepth < 0) $braceDepth = 0;

    987. 

  987. 						}

    988. 

  988. 					}

    989. 

  989. 

    990. 

  990. 					break;

    991. 

  991. 				case '"':

    992. 

  992. 					if ($escapeThisChar) {

    993. 

  993. 						$replaceChar = true;

    994. 

  994. 					} else {

    995. 

  995. 						if ($braceDepth === 0) {

    996. 

  996. 							$inQuote = !$inQuote;	// Are we inside a quoted string?

    997. 

  997. 						} else {

    998. 

  998. 							$replaceChar = true;

    999. 

  999. 						}

    1000. 

  1000. 					}

    1001. 

  1001. 

    1002. 

  1002. 					break;

    1003. 

  1003. 				case '.':	// Dots don't help us either

    1004. 

  1004. 					if ($escapeThisChar) {

    1005. 

  1005. 						$replaceChar = true;

    1006. 

  1006. 					} else {

    1007. 

  1007. 						if ($braceDepth > 0) $replaceChar = true;

    1008. 

  1008. 					}

    1009. 

  1009. 

    1010. 

  1010. 					break;

    1011. 

  1011. 				default:

    1012. 

  1012. 				}

    1013. 

  1013. 

    1014. 

  1014. 				$escapeThisChar = false;

    1015. 

  1015. 	//			if ($replaceChar) $email[$i] = 'x';	// Replace the offending character with something harmless

    1016. 

  1016. 	// revision 1.12: Line above replaced because PHPLint doesn't like that syntax

    1017. 

  1017. 				if ($replaceChar) $email = (string) substr_replace($email, 'x', $i, 1);	// Replace the offending character with something harmless

    1018. 

  1018. 			}

    1019. 

  1019. 		}

    1020. 

  1020. 

    1021. 

  1021. 		$localPart	= substr($email, 0, $atIndex);

    1022. 

  1022. 		$domain		= substr($email, $atIndex + 1);

    1023. 

  1023. 		$FWS		= "(?:(?:(?:[ \\t]*(?:\\r\\n))?[ \\t]+)|(?:[ \\t]+(?:(?:\\r\\n)[ \\t]+)*))";	// Folding white space

    1024. 

  1024. 		// Let's check the local part for RFC compliance...

    1025. 

  1025. 		//

    1026. 

  1026. 		// local-part      =       dot-atom / quoted-string / obs-local-part

    1027. 

  1027. 		// obs-local-part  =       word *("." word)

    1028. 

  1028. 		// 	(http://tools.ietf.org/html/rfc5322#section-3.4.1)

    1029. 

  1029. 		//

    1030. 

  1030. 		// Problem: need to distinguish between "first.last" and "first"."last"

    1031. 

  1031. 		// (i.e. one element or two). And I suck at regexes.

    1032. 

  1032. 		$dotArray	= /*. (array[int]string) .*/ preg_split('/\\.(?=(?:[^\\"]*\\"[^\\"]*\\")*(?![^\\"]*\\"))/m', $localPart);

    1033. 

  1033. 		$partLength	= 0;

    1034. 

  1034. 

    1035. 

  1035. 		foreach ($dotArray as $element) {

    1036. 

  1036. 			// Remove any leading or trailing FWS

    1037. 

  1037. 			$element	= preg_replace("/^$FWS|$FWS\$/", '', $element);

    1038. 

  1038. 			$elementLength	= strlen($element);

    1039. 

  1039. 

    1040. 

  1040. 			if ($elementLength === 0)								if ($diagnose) return self::ISEMAIL_ZEROLENGTHELEMENT; else return false;	// Can't have empty element (consecutive dots or dots at the start or end)

    1041. 

  1041. 	// revision 1.15: Speed up the test and get rid of "unitialized string offset" notices from PHP

    1042. 

  1042. 

    1043. 

  1043. 			// We need to remove any valid comments (i.e. those at the start or end of the element)

    1044. 

  1044. 			if ($element[0] === '(') {

    1045. 

  1045. 				$indexBrace = strpos($element, ')');

    1046. 

  1046. 				if ($indexBrace !== false) {

    1047. 

  1047. 					if (preg_match('/(?<!\\\\)[\\(\\)]/', substr($element, 1, $indexBrace - 1)) > 0) {

    1048. 

  1048. 														if ($diagnose) return self::ISEMAIL_BADCOMMENT_START; else return false;	// Illegal characters in comment

    1049. 

  1049. 					}

    1050. 

  1050. 					$element	= substr($element, $indexBrace + 1, $elementLength - $indexBrace - 1);

    1051. 

  1051. 					$elementLength	= strlen($element);

    1052. 

  1052. 				}

    1053. 

  1053. 			}

    1054. 

  1054. 

    1055. 

  1055. 			if ($element[$elementLength - 1] === ')') {

    1056. 

  1056. 				$indexBrace = strrpos($element, '(');

    1057. 

  1057. 				if ($indexBrace !== false) {

    1058. 

  1058. 					if (preg_match('/(?<!\\\\)(?:[\\(\\)])/', substr($element, $indexBrace + 1, $elementLength - $indexBrace - 2)) > 0) {

    1059. 

  1059. 														if ($diagnose) return self::ISEMAIL_BADCOMMENT_END; else return false;	// Illegal characters in comment

    1060. 

  1060. 					}

    1061. 

  1061. 					$element	= substr($element, 0, $indexBrace);

    1062. 

  1062. 					$elementLength	= strlen($element);

    1063. 

  1063. 				}

    1064. 

  1064. 			}

    1065. 

  1065. 

    1066. 

  1066. 			// Remove any leading or trailing FWS around the element (inside any comments)

    1067. 

  1067. 			$element = preg_replace("/^$FWS|$FWS\$/", '', $element);

    1068. 

  1068. 

    1069. 

  1069. 			// What's left counts towards the maximum length for this part

    1070. 

  1070. 			if ($partLength > 0) $partLength++;	// for the dot

    1071. 

  1071. 			$partLength += strlen($element);

    1072. 

  1072. 

    1073. 

  1073. 			// Each dot-delimited component can be an atom or a quoted string

    1074. 

  1074. 			// (because of the obs-local-part provision)

    1075. 

  1075. 			if (preg_match('/^"(?:.)*"$/s', $element) > 0) {

    1076. 

  1076. 				// Quoted-string tests:

    1077. 

  1077. 				//

    1078. 

  1078. 				// Remove any FWS

    1079. 

  1079. 				$element = preg_replace("/(?<!\\\\)$FWS/", '', $element);

    1080. 

  1080. 				// My regex skillz aren't up to distinguishing between \" \\" \\\" \\\\" etc.

    1081. 

  1081. 				// So remove all \\ from the string first...

    1082. 

  1082. 				$element = preg_replace('/\\\\\\\\/', ' ', $element);

    1083. 

  1083. 				if (preg_match('/(?<!\\\\|^)["\\r\\n\\x00](?!$)|\\\\"$|""/', $element) > 0)	if ($diagnose) return self::ISEMAIL_UNESCAPEDDELIM; else return false;	// ", CR, LF and NUL must be escaped, "" is too short

    1084. 

  1084. 			} else {

    1085. 

  1085. 				// Unquoted string tests:

    1086. 

  1086. 				//

    1087. 

  1087. 				// Period (".") may...appear, but may not be used to start or end the

    1088. 

  1088. 				// local part, nor may two or more consecutive periods appear.

    1089. 

  1089. 				// 	(http://tools.ietf.org/html/rfc3696#section-3)

    1090. 

  1090. 				//

    1091. 

  1091. 				// A zero-length element implies a period at the beginning or end of the

    1092. 

  1092. 				// local part, or two periods together. Either way it's not allowed.

    1093. 

  1093. 				if ($element === '')								if ($diagnose) return self::ISEMAIL_EMPTYELEMENT; else return false;	// Dots in wrong place

    1094. 

  1094. 

    1095. 

  1095. 				// Any ASCII graphic (printing) character other than the

    1096. 

  1096. 				// at-sign ("@"), backslash, double quote, comma, or square brackets may

    1097. 

  1097. 				// appear without quoting.  If any of that list of excluded characters

    1098. 

  1098. 				// are to appear, they must be quoted

    1099. 

  1099. 				// 	(http://tools.ietf.org/html/rfc3696#section-3)

    1100. 

  1100. 				//

    1101. 

  1101. 				// Any excluded characters? i.e. 0x00-0x20, (, ), <, >, [, ], :, ;, @, \, comma, period, "

    1102. 

  1102. 				if (preg_match('/[\\x00-\\x20\\(\\)<>\\[\\]:;@\\\\,\\."]/', $element) > 0)	if ($diagnose) return self::ISEMAIL_UNESCAPEDSPECIAL; else return false;	// These characters must be in a quoted string

    1103. 

  1103. 			}

    1104. 

  1104. 		}

    1105. 

  1105. 

    1106. 

  1106. 		if ($partLength > 64) if ($diagnose) return self::ISEMAIL_LOCALTOOLONG; else return false;	// Local part must be 64 characters or less

    1107. 

  1107. 

    1108. 

  1108. 		// Now let's check the domain part...

    1109. 

  1109. 

    1110. 

  1110. 		// The domain name can also be replaced by an IP address in square brackets

    1111. 

  1111. 		// 	(http://tools.ietf.org/html/rfc3696#section-3)

    1112. 

  1112. 		// 	(http://tools.ietf.org/html/rfc5321#section-4.1.3)

    1113. 

  1113. 		// 	(http://tools.ietf.org/html/rfc4291#section-2.2)

    1114. 

  1114. 		if (preg_match('/^\\[(.)+]$/', $domain) === 1) {

    1115. 

  1115. 			// It's an address-literal

    1116. 

  1116. 			$addressLiteral = substr($domain, 1, strlen($domain) - 2);

    1117. 

  1117. 			$matchesIP	= array();

    1118. 

  1118. 

    1119. 

  1119. 			// Extract IPv4 part from the end of the address-literal (if there is one)

    1120. 

  1120. 			if (preg_match('/\\b(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/', $addressLiteral, $matchesIP) > 0) {

    1121. 

  1121. 				$index = strrpos($addressLiteral, $matchesIP[0]);

    1122. 

  1122. 

    1123. 

  1123. 				if ($index === 0) {

    1124. 

  1124. 					// Nothing there except a valid IPv4 address, so...

    1125. 

  1125. 					if ($diagnose) return self::ISEMAIL_VALID; else return true;

    1126. 

  1126. 				} else {

    1127. 

  1127. 					// Assume it's an attempt at a mixed address (IPv6 + IPv4)

    1128. 

  1128. 					if ($addressLiteral[$index - 1] !== ':')	if ($diagnose) return self::ISEMAIL_IPV4BADPREFIX; else return false;	// Character preceding IPv4 address must be ':'

    1129. 

  1129. 					if (substr($addressLiteral, 0, 5) !== 'IPv6:')	if ($diagnose) return self::ISEMAIL_IPV6BADPREFIXMIXED; else return false;	// RFC5321 section 4.1.3

    1130. 

  1130. 

    1131. 

  1131. 					$IPv6		= substr($addressLiteral, 5, ($index ===7) ? 2 : $index - 6);

    1132. 

  1132. 					$groupMax	= 6;

    1133. 

  1133. 				}

    1134. 

  1134. 			} else {

    1135. 

  1135. 				// It must be an attempt at pure IPv6

    1136. 

  1136. 				if (substr($addressLiteral, 0, 5) !== 'IPv6:')		if ($diagnose) return self::ISEMAIL_IPV6BADPREFIX; else return false;	// RFC5321 section 4.1.3

    1137. 

  1137. 				$IPv6 = substr($addressLiteral, 5);

    1138. 

  1138. 				$groupMax = 8;

    1139. 

  1139. 			}

    1140. 

  1140. 

    1141. 

  1141. 			$groupCount	= preg_match_all('/^[0-9a-fA-F]{0,4}|\\:[0-9a-fA-F]{0,4}|(.)/', $IPv6, $matchesIP);

    1142. 

  1142. 			$index		= strpos($IPv6,'::');

    1143. 

  1143. 

    1144. 

  1144. 			if ($index === false) {

    1145. 

  1145. 				// We need exactly the right number of groups

    1146. 

  1146. 				if ($groupCount !== $groupMax)				if ($diagnose) return self::ISEMAIL_IPV6GROUPCOUNT; else return false;	// RFC5321 section 4.1.3

    1147. 

  1147. 			} else {

    1148. 

  1148. 				if ($index !== strrpos($IPv6,'::'))			if ($diagnose) return self::ISEMAIL_IPV6DOUBLEDOUBLECOLON; else return false;	// More than one '::'

    1149. 

  1149. 				$groupMax = ($index === 0 || $index === (strlen($IPv6) - 2)) ? $groupMax : $groupMax - 1;

    1150. 

  1150. 				if ($groupCount > $groupMax)				if ($diagnose) return self::ISEMAIL_IPV6TOOMANYGROUPS; else return false;	// Too many IPv6 groups in address

    1151. 

  1151. 			}

    1152. 

  1152. 

    1153. 

  1153. 			// Check for unmatched characters

    1154. 

  1154. 			array_multisort($matchesIP[1], SORT_DESC);

    1155. 

  1155. 			if ($matchesIP[1][0] !== '')					if ($diagnose) return self::ISEMAIL_IPV6BADCHAR; else return false;	// Illegal characters in address

    1156. 

  1156. 

    1157. 

  1157. 			// It's a valid IPv6 address, so...

    1158. 

  1158. 			if ($diagnose) return self::ISEMAIL_VALID; else return true;

    1159. 

  1159. 		} else {

    1160. 

  1160. 			// It's a domain name...

    1161. 

  1161. 

    1162. 

  1162. 			// The syntax of a legal Internet host name was specified in RFC-952

    1163. 

  1163. 			// One aspect of host name syntax is hereby changed: the

    1164. 

  1164. 			// restriction on the first character is relaxed to allow either a

    1165. 

  1165. 			// letter or a digit.

    1166. 

  1166. 			// 	(http://tools.ietf.org/html/rfc1123#section-2.1)

    1167. 

  1167. 			//

    1168. 

  1168. 			// NB RFC 1123 updates RFC 1035, but this is not currently apparent from reading RFC 1035.

    1169. 

  1169. 			//

    1170. 

  1170. 			// Most common applications, including email and the Web, will generally not

    1171. 

  1171. 			// permit...escaped strings

    1172. 

  1172. 			// 	(http://tools.ietf.org/html/rfc3696#section-2)

    1173. 

  1173. 			//

    1174. 

  1174. 			// the better strategy has now become to make the "at least one period" test,

    1175. 

  1175. 			// to verify LDH conformance (including verification that the apparent TLD name

    1176. 

  1176. 			// is not all-numeric)

    1177. 

  1177. 			// 	(http://tools.ietf.org/html/rfc3696#section-2)

    1178. 

  1178. 			//

    1179. 

  1179. 			// Characters outside the set of alphabetic characters, digits, and hyphen MUST NOT appear in domain name

    1180. 

  1180. 			// labels for SMTP clients or servers

    1181. 

  1181. 			// 	(http://tools.ietf.org/html/rfc5321#section-4.1.2)

    1182. 

  1182. 			//

    1183. 

  1183. 			// RFC5321 precludes the use of a trailing dot in a domain name for SMTP purposes

    1184. 

  1184. 			// 	(http://tools.ietf.org/html/rfc5321#section-4.1.2)

    1185. 

  1185. 			$dotArray	= /*. (array[int]string) .*/ preg_split('/\\.(?=(?:[^\\"]*\\"[^\\"]*\\")*(?![^\\"]*\\"))/m', $domain);

    1186. 

  1186. 			$partLength	= 0;

    1187. 

  1187. 			$element	= ''; // Since we use $element after the foreach loop let's make sure it has a value

    1188. 

  1188. 	// revision 1.13: Line above added because PHPLint now checks for Definitely Assigned Variables

    1189. 

  1189. 

    1190. 

  1190. 			if (count($dotArray) === 1)					if ($diagnose) return self::ISEMAIL_TLD; else return false;	// Mail host can't be a TLD (cite? What about localhost?)

    1191. 

  1191. 

    1192. 

  1192. 			foreach ($dotArray as $element) {

    1193. 

  1193. 				// Remove any leading or trailing FWS

    1194. 

  1194. 				$element	= preg_replace("/^$FWS|$FWS\$/", '', $element);

    1195. 

  1195. 				$elementLength	= strlen($element);

    1196. 

  1196. 

    1197. 

  1197. 				// Each dot-delimited component must be of type atext

    1198. 

  1198. 				// A zero-length element implies a period at the beginning or end of the

    1199. 

  1199. 				// local part, or two periods together. Either way it's not allowed.

    1200. 

  1200. 				if ($elementLength === 0)				if ($diagnose) return self::ISEMAIL_DOMAINEMPTYELEMENT; else return false;	// Dots in wrong place

    1201. 

  1201. 	// revision 1.15: Speed up the test and get rid of "unitialized string offset" notices from PHP

    1202. 

  1202. 

    1203. 

  1203. 				// Then we need to remove all valid comments (i.e. those at the start or end of the element

    1204. 

  1204. 				if ($element[0] === '(') {

    1205. 

  1205. 					$indexBrace = strpos($element, ')');

    1206. 

  1206. 					if ($indexBrace !== false) {

    1207. 

  1207. 						if (preg_match('/(?<!\\\\)[\\(\\)]/', substr($element, 1, $indexBrace - 1)) > 0) {

    1208. 

  1208. 											if ($diagnose) return self::ISEMAIL_BADCOMMENT_START; else return false;	// Illegal characters in comment

    1209. 

  1209. 						}

    1210. 

  1210. 						$element	= substr($element, $indexBrace + 1, $elementLength - $indexBrace - 1);

    1211. 

  1211. 						$elementLength	= strlen($element);

    1212. 

  1212. 					}

    1213. 

  1213. 				}

    1214. 

  1214. 

    1215. 

  1215. 				if ($element[$elementLength - 1] === ')') {

    1216. 

  1216. 					$indexBrace = strrpos($element, '(');

    1217. 

  1217. 					if ($indexBrace !== false) {

    1218. 

  1218. 						if (preg_match('/(?<!\\\\)(?:[\\(\\)])/', substr($element, $indexBrace + 1, $elementLength - $indexBrace - 2)) > 0)

    1219. 

  1219. 											if ($diagnose) return self::ISEMAIL_BADCOMMENT_END; else return false;	// Illegal characters in comment

    1220. 

  1220. 

    1221. 

  1221. 						$element	= substr($element, 0, $indexBrace);

    1222. 

  1222. 						$elementLength	= strlen($element);

    1223. 

  1223. 					}

    1224. 

  1224. 				}

    1225. 

  1225. 

    1226. 

  1226. 				// Remove any leading or trailing FWS around the element (inside any comments)

    1227. 

  1227. 				$element = preg_replace("/^$FWS|$FWS\$/", '', $element);

    1228. 

  1228. 

    1229. 

  1229. 				// What's left counts towards the maximum length for this part

    1230. 

  1230. 				if ($partLength > 0) $partLength++;	// for the dot

    1231. 

  1231. 				$partLength += strlen($element);

    1232. 

  1232. 

    1233. 

  1233. 				// The DNS defines domain name syntax very generally -- a

    1234. 

  1234. 				// string of labels each containing up to 63 8-bit octets,

    1235. 

  1235. 				// separated by dots, and with a maximum total of 255

    1236. 

  1236. 				// octets.

    1237. 

  1237. 				// 	(http://tools.ietf.org/html/rfc1123#section-6.1.3.5)

    1238. 

  1238. 				if ($elementLength > 63)				if ($diagnose) return self::ISEMAIL_DOMAINELEMENTTOOLONG; else return false;	// Label must be 63 characters or less

    1239. 

  1239. 

    1240. 

  1240. 				// Any ASCII graphic (printing) character other than the

    1241. 

  1241. 				// at-sign ("@"), backslash, double quote, comma, or square brackets may

    1242. 

  1242. 				// appear without quoting.  If any of that list of excluded characters

    1243. 

  1243. 				// are to appear, they must be quoted

    1244. 

  1244. 				// 	(http://tools.ietf.org/html/rfc3696#section-3)

    1245. 

  1245. 				//

    1246. 

  1246. 				// If the hyphen is used, it is not permitted to appear at

    1247. 

  1247. 				// either the beginning or end of a label.

    1248. 

  1248. 				// 	(http://tools.ietf.org/html/rfc3696#section-2)

    1249. 

  1249. 				//

    1250. 

  1250. 				// Any excluded characters? i.e. 0x00-0x20, (, ), <, >, [, ], :, ;, @, \, comma, period, "

    1251. 

  1251. 				if (preg_match('/[\\x00-\\x20\\(\\)<>\\[\\]:;@\\\\,\\."]|^-|-$/', $element) > 0) {

    1252. 

  1252. 											if ($diagnose) return self::ISEMAIL_DOMAINBADCHAR; else return false;

    1253. 

  1253. 				}

    1254. 

  1254. 			}

    1255. 

  1255. 

    1256. 

  1256. 			if ($partLength > 255) 						if ($diagnose) return self::ISEMAIL_DOMAINTOOLONG; else return false;	// Domain part must be 255 characters or less (http://tools.ietf.org/html/rfc1123#section-6.1.3.5)

    1257. 

  1257. 

    1258. 

  1258. 			if (preg_match('/^[0-9]+$/', $element) > 0)			if ($diagnose) return self::ISEMAIL_TLDNUMERIC; else return false;	// TLD can't be all-numeric (http://www.apps.ietf.org/rfc/rfc3696.html#sec-2)

    1259. 

  1259. 

    1260. 

  1260. 			// Check DNS?

    1261. 

  1261. 			if ($checkDNS && function_exists('checkdnsrr')) {

    1262. 

  1262. 				if (!(checkdnsrr($domain, 'A') || checkdnsrr($domain, 'MX'))) {

    1263. 

  1263. 											if ($diagnose) return self::ISEMAIL_DOMAINNOTFOUND; else return false;	// Domain doesn't actually exist

    1264. 

  1264. 				}

    1265. 

  1265. 			}

    1266. 

  1266. 		}

    1267. 

  1267. 

    1268. 

  1268. 		// Eliminate all other factors, and the one which remains must be the truth.

    1269. 

  1269. 		// 	(Sherlock Holmes, The Sign of Four)

    1270. 

  1270. 		if ($diagnose) return self::ISEMAIL_VALID; else return true;

    1271. 

  1271. 	}

    1272. 

  1272. }

    1273. 

  1273. // End of class ezUser_common

    1274. 

  1274. 

    1275. 

  1275. 

    1276. 

  1276. /**

    1277. 

  1277.  * Password reset handling for ezUser

    1278. 

  1278.  *

    1279. 

  1279.  * @package ezUser

    1280. 

  1280.  */

    1281. 

  1281. interface I_ezUser_reset {

    1282. 

  1282. // Methods may be commented out to reduce the attack surface when they are

    1283. 

  1283. // not required. Uncomment them if you need them.

    1284. 

  1284. //	public	/*.string.*/	function id();

    1285. 

  1285. 	public	/*.string.*/	function resetKey();

    1286. 

  1286. //	public	/*.DateTime.*/	function expires();

    1287. 

  1287. 	public	/*.string.*/	function data();

    1288. 

  1288. 	public	/*.void.*/	function initialize();

    1289. 

  1289. 	public	/*.void.*/	function setId(/*.string.*/ $id);

    1290. 

  1290. 	public	/*.void.*/	function setData(/*.string.*/ $data);

    1291. 

  1291. }

    1292. 

  1292. 

    1293. 

  1293. /**

    1294. 

  1294.  * Password reset handling for ezUser

    1295. 

  1295.  *

    1296. 

  1296.  * @package ezUser

    1297. 

  1297.  */

    1298. 

  1298. class ezUser_reset extends ezUser_common implements I_ezUser_reset {

    1299. 

  1299. 	private	/*.string.*/	$id;

    1300. 

  1300. 	private /*.string.*/	$resetKey;

    1301. 

  1301. 	private	/*.DateTime.*/	$expires;

    1302. 

  1302. 

    1303. 

  1303. // Methods may be commented out to reduce the attack surface when they are

    1304. 

  1304. // not required. Uncomment them if you need them.

    1305. 

  1305. //	public	/*.string.*/	function id()		{return $this->id;}

    1306. 

  1306. 	public	/*.string.*/	function resetKey()	{return $this->resetKey;}

    1307. 

  1307. //	public	/*.DateTime.*/	function expires()	{return $this->expires;}

    1308. 

  1308. 	public	/*.string.*/	function data()		{return serialize(array($this->id, $this->resetKey, serialize($this->expires)));}

    1309. 

  1309. 

    1310. 

  1310. 	public /*.void.*/	function initialize() {

    1311. 

  1311. 		$date = new DateTime();

    1312. 

  1312. 		$date->modify('+1 day');

    1313. 

  1313. 

    1314. 

  1314. 		$this->resetKey	= self::makeUniqueKey($this->id);

    1315. 

  1315. 		$this->expires	= $date;

    1316. 

  1316. 	}

    1317. 

  1317. 

    1318. 

  1318. 	public /*.void.*/	function setId(/*.string.*/ $id) {

    1319. 

  1319. 		$this->id = $id;

    1320. 

  1320. 		$this->initialize();

    1321. 

  1321. 	}

    1322. 

  1322. 

    1323. 

  1323. 	public /*.void.*/	function setData(/*.string.*/ $data) {

    1324. 

  1324. 		list($this->id, $this->resetKey, $expiresString) = /*.(array[int]string).*/ unserialize($data);

    1325. 

  1325. 		$this->expires = /*.(DateTime).*/ unserialize($expiresString);

    1326. 

  1326. 	}

    1327. 

  1327. }

    1328. 

  1328. // End of class ezUser_reset

    1329. 

  1329. 

    1330. 

  1330. 

    1331. 

  1331. /**

    1332. 

  1332.  * This class encapsulates all the functions needed for an app to interact

    1333. 

  1333.  * with a user. It has no knowledge of how user information is persisted.

    1334. 

  1334.  *

    1335. 

  1335.  * @package ezUser

    1336. 

  1336.  */

    1337. 

  1337.  interface I_ezUser_base extends I_ezUser_common {

    1338. 

  1338. 		// REST interface actions

    1339. 

  1339. 	const	ACTION			= 'action',

    1340. 

  1340. 		ACTION_ABOUT		= 'about',

    1341. 

  1341. 		ACTION_ABOUTTEXT	= 'abouttext',

    1342. 

  1342. 		ACTION_ACCOUNT		= 'account',

    1343. 

  1343. 		ACTION_ACCOUNTFORM	= 'accountform',

    1344. 

  1344. 		ACTION_ACCOUNTWIZARD	= 'accountwizard',

    1345. 

  1345. 		ACTION_BITMAP		= 'bitmap',

    1346. 

  1346. 		ACTION_BODY		= 'body',

    1347. 

  1347. 		ACTION_CANCEL		= 'cancel',

    1348. 

  1348. 		ACTION_CONTAINER	= 'container',

    1349. 

  1349. 		ACTION_DASHBOARD	= 'dashboard',

    1350. 

  1350. 		ACTION_JAVASCRIPT	= 'js',

    1351. 

  1351. 		ACTION_MAIN		= 'controlpanel',

    1352. 

  1352. 		ACTION_RESEND		= 'resend',		// Resend verification email

    1353. 

  1353. 		ACTION_RESET		= 'reset',		// Process password reset link

    1354. 

  1354. 		ACTION_RESETPASSWORD	= 'resetpassword',	// Initiate password reset processing

    1355. 

  1355. 		ACTION_RESETREQUEST	= 'resetrequest',	// Request password reset form

    1356. 

  1356. 		ACTION_RESULTFORM	= 'resultform',

    1357. 

  1357. 		ACTION_RESULTTEXT	= 'resulttext',

    1358. 

  1358. 		ACTION_SIGNIN		= 'signin',

    1359. 

  1359. 		ACTION_SIGNOUT		= 'signout',

    1360. 

  1360. 		ACTION_SOURCECODE	= 'source',

    1361. 

  1361. 		ACTION_STATUSTEXT	= 'statustext',

    1362. 

  1362. 		ACTION_STYLESHEET	= 'css',

    1363. 

  1363. 		ACTION_VALIDATE		= 'validate',		// Validate registration form details

    1364. 

  1364. 		ACTION_VERIFY		= 'verify',		// Verify verification email

    1365. 

  1365. 

    1366. 

  1366. 		// Keys for the user data array members

    1367. 

  1367. 		TAGNAME_CONFIRM		= 'confirm',

    1368. 

  1368. 		TAGNAME_DATA		= 'data',

    1369. 

  1369. 		TAGNAME_EMAIL		= 'email',

    1370. 

  1370. 		TAGNAME_FIRSTNAME	= 'firstname',

    1371. 

  1371. 		TAGNAME_FULLNAME	= 'fullname',

    1372. 

  1372. 		TAGNAME_ID		= 'id',

    1373. 

  1373. 		TAGNAME_LASTNAME	= 'lastname',

    1374. 

  1374. 		TAGNAME_NEWUSER		= 'newuser',

    1375. 

  1375. 		TAGNAME_PASSWORD	= 'password',

    1376. 

  1376. 		TAGNAME_REMEMBERME	= 'rememberme',

    1377. 

  1377. 		TAGNAME_RESETKEY	= 'resetkey',

    1378. 

  1378. 		TAGNAME_RESETDATA	= 'resetdata',

    1379. 

  1379. 		TAGNAME_SAVEDPASSWORD	= 'usesavedpassword',

    1380. 

  1380. 		TAGNAME_STATUS		= 'status',

    1381. 

  1381. 		TAGNAME_STAYSIGNEDIN	= 'staysignedin',

    1382. 

  1382. 		TAGNAME_USER		= 'user',

    1383. 

  1383. 		TAGNAME_USERNAME	= 'username',

    1384. 

  1384. 		TAGNAME_VERIFICATIONKEY	= 'verificationkey',

    1385. 

  1385. 		TAGNAME_VERBOSE		= 'verbose',

    1386. 

  1386. 		TAGNAME_WIZARD		= 'wizard',

    1387. 

  1387. 

    1388. 

  1388. 		// Registration status codes

    1389. 

  1389. 		STATUS_UNKNOWN		= 0,

    1390. 

  1390. 		STATUS_PENDING		= 1,

    1391. 

  1391. 		STATUS_CONFIRMED	= 2,

    1392. 

  1392. 		STATUS_INACTIVE		= 3,

    1393. 

  1393. 

    1394. 

  1394. 		// Authentication result codes

    1395. 

  1395. 		RESULT_UNDEFINED	= 0,

    1396. 

  1396. 		RESULT_SUCCESS		= 1,

    1397. 

  1397. 		RESULT_UNKNOWNUSER	= 2,

    1398. 

  1398. 		RESULT_BADPASSWORD	= 3,

    1399. 

  1399. 		RESULT_UNKNOWNACTION	= 4,

    1400. 

  1400. 		RESULT_NOACTION		= 5,

    1401. 

  1401. 		RESULT_FAILEDAUTOSIGNIN	= 6,

    1402. 

  1402. 

    1403. 

  1403. 		// Validation result codes

    1404. 

  1404. 		RESULT_VALIDATED	= 32,

    1405. 

  1405. 		RESULT_NOID		= 33,

    1406. 

  1406. 		RESULT_NOUSERNAME	= 34,

    1407. 

  1407. 		RESULT_NOEMAIL		= 35,

    1408. 

  1408. 		RESULT_EMAILFORMATERR	= 36,

    1409. 

  1409. 		RESULT_NOPASSWORD	= 37,

    1410. 

  1410. 		RESULT_NULLPASSWORD	= 38,

    1411. 

  1411. 		RESULT_STATUSNAN	= 39,

    1412. 

  1412. 		RESULT_RESULTNAN	= 40,

    1413. 

  1413. 		RESULT_CONFIGNOTARRAY	= 41,

    1414. 

  1414. 		RESULT_USERNAMEEXISTS	= 42,

    1415. 

  1415. 		RESULT_EMAILEXISTS	= 43,

    1416. 

  1416. 		RESULT_NOTSIGNEDIN	= 44,

    1417. 

  1417. 		RESULT_INCOMPLETE	= 45,

    1418. 

  1418. 

    1419. 

  1419. 		// Result codes for session and environment issues

    1420. 

  1420. 		RESULT_NOSESSION	= 64,

    1421. 

  1421. 		RESULT_NOSESSIONCOOKIES	= 65,

    1422. 

  1422. 		RESULT_STORAGEERR	= 66,

    1423. 

  1423. 		RESULT_EMAILERR		= 67,

    1424. 

  1424. 		RESULT_HEADERSSENT	= 68,

    1425. 

  1425. 

    1426. 

  1426. 		// Miscellaneous constants

    1427. 

  1427. 		DELIMITER_SPACE		= ' ',

    1428. 

  1428. 		STRING_TRUE		= 'true',

    1429. 

  1429. 		STRING_FALSE		= 'false';

    1430. 

  1430. 

    1431. 

  1431. 	public /*.int.*/	function authenticate($passwordHash = '');

    1432. 

  1432. 

    1433. 

  1433. 	public /*.string.*/	function username();

    1434. 

  1434. 	public /*.string.*/	function firstName();

    1435. 

  1435. 	public /*.string.*/	function lastName();

    1436. 

  1436. 	public /*.string.*/	function fullName();

    1437. 

  1437. 	public /*.string.*/	function email();

    1438. 

  1438. 	public /*.int.*/	function status();

    1439. 

  1439. 	public /*.boolean.*/	function authenticated();

    1440. 

  1440. 

    1441. 

  1441. 	public /*.void.*/	function setFirstName(/*.string.*/ $name);

    1442. 

  1442. 	public /*.void.*/	function setLastName(/*.string.*/ $name);

    1443. 

  1443. }

    1444. 

  1444. // End of interface I_ezUser_base

    1445. 

  1445. 

    1446. 

  1446. /**

    1447. 

  1447.  * This class encapsulates all the functions needed for an app to interact

    1448. 

  1448.  * with a user. It has no knowledge of how user information is persisted.

    1449. 

  1449.  *

    1450. 

  1450.  * @package ezUser

    1451. 

  1451.  */

    1452. 

  1452. class ezUser_base extends ezUser_common implements I_ezUser_base {

    1453. 

  1453. 	// User data

    1454. 

  1454. 	private		$keys	= array (

    1455. 

  1455. 						self::TAGNAME_USERNAME	,

    1456. 

  1456. 						self::TAGNAME_EMAIL	,

    1457. 

  1457. 						self::TAGNAME_ID	,

    1458. 

  1458. 						self::TAGNAME_PASSWORD	,

    1459. 

  1459. 						self::TAGNAME_STATUS	,

    1460. 

  1460. 						self::TAGNAME_FIRSTNAME	,

    1461. 

  1461. 						self::TAGNAME_LASTNAME	,

    1462. 

  1462. 						self::TAGNAME_FULLNAME	,

    1463. 

  1463. 						self::TAGNAME_VERIFICATIONKEY,

    1464. 

  1464. 					);

    1465. 

  1465. 

    1466. 

  1466. 	private		$values	= array (

    1467. 

  1467. 						self::TAGNAME_USERNAME		=> '',

    1468. 

  1468. 						self::TAGNAME_EMAIL		=> '',

    1469. 

  1469. 						self::TAGNAME_ID		=> '',

    1470. 

  1470. 						self::TAGNAME_PASSWORD		=> '',

    1471. 

  1471. 						self::TAGNAME_STATUS		=> '0',

    1472. 

  1472. 						self::TAGNAME_FIRSTNAME		=> '',

    1473. 

  1473. 						self::TAGNAME_LASTNAME		=> '',

    1474. 

  1474. 						self::TAGNAME_FULLNAME		=> '',

    1475. 

  1475. 						self::TAGNAME_VERIFICATIONKEY	=> ''

    1476. 

  1476. 					);

    1477. 

  1477. 

    1478. 

  1478. 	// State and derived data

    1479. 

  1479. 	private		$authenticated		= false;					// User is signed in

    1480. 

  1480. 	private		$usernameIsDefault	= true;						// username === firstName.lastName

    1481. 

  1481. 	private		$isChanged		= false;					// Unsaved changes?

    1482. 

  1482. 	private		$result			= self::RESULT_UNDEFINED;			// Result of any change operation

    1483. 

  1483. 	private		$config			= /*.(array[string]string).*/	array();	// Configuration settings

    1484. 

  1484. 	private		$errors			= /*.(array[string]string).*/	array();	// Validation errors

    1485. 

  1485. 	private		$signOutActions		= /*.(array[int]string).*/	array();	// Things to do on signing out

    1486. 

  1486. 	private		$manualSignOut		= false;					// User chose to sign out

    1487. 

  1487. 

    1488. 

  1488. // ---------------------------------------------------------------------------

    1489. 

  1489. // Helper methods

    1490. 

  1490. // ---------------------------------------------------------------------------

    1491. 

  1491. 	private /*.boolean.*/ function setValue(/*.string.*/ $key, /*.string.*/ $value) {

    1492. 

  1492. 		if ($value !== $this->values[$key]) {

    1493. 

  1493. 			$this->values[$key]	= $value;

    1494. 

  1494. 			$this->isChanged	= true;

    1495. 

  1495. 			return true;

    1496. 

  1496. 		} else {

    1497. 

  1497. 			return false;

    1498. 

  1498. 		}

    1499. 

  1499. 	}

    1500. 

  1500. 

    1501. 

  1501. 	private /*.string.*/ function getValue(/*.string.*/ $key) {

    1502. 

  1502. 		$value = '';

    1503. 

  1503. 		if (!in_array($key, $this->keys)) return $value;

    1504. 

  1504. 

    1505. 

  1505. 		switch ($key) {

    1506. 

  1506. 		case self::TAGNAME_VERIFICATIONKEY:

    1507. 

  1507. 			if ((int) $this->getValue(self::TAGNAME_STATUS) === self::STATUS_PENDING) $value = $this->values[$key];

    1508. 

  1508. 			break;

    1509. 

  1509. 		case self::TAGNAME_ID:

    1510. 

  1510. 			if ($this->values[$key] === '') $this->setValue($key, self::makeId());

    1511. 

  1511. 			$value	= $this->values[$key];

    1512. 

  1512. 			break;

    1513. 

  1513. 		default:

    1514. 

  1514. 			$value	= $this->values[$key];

    1515. 

  1515. 			break;

    1516. 

  1516. 		}

    1517. 

  1517. 

    1518. 

  1518. 		return $value;

    1519. 

  1519. 	}

    1520. 

  1520. 

    1521. 

  1521. // ---------------------------------------------------------------------------

    1522. 

  1522. // Authenticate

    1523. 

  1523. // ---------------------------------------------------------------------------

    1524. 

  1524. 	public /*.int.*/ function authenticate($passwordHash = '') {

    1525. 

  1525. 		if (empty($passwordHash)) {

    1526. 

  1526. 			// Sign out

    1527. 

  1527. 			$this->authenticated	= false;

    1528. 

  1528. 			$this->manualSignOut	= true;

    1529. 

  1529. 			$result = self::RESULT_SUCCESS;

    1530. 

  1530. 		} else {

    1531. 

  1531. 			// Sign in

    1532. 

  1532. 			self::checkSession();

    1533. 

  1533. 			$sessionHash = hash(self::HASH_FUNCTION, session_id() . hash(self::HASH_FUNCTION, $_SERVER['REMOTE_ADDR'] . $this->values[self::TAGNAME_PASSWORD]));

    1534. 

  1534. //error_log(date('Y-m-d H:i:s', time()) . "\t" . session_id() . '|' . $_SERVER['REMOTE_ADDR'] . '|' . $this->values[self::TAGNAME_PASSWORD] . '|' . hash(self::HASH_FUNCTION, $_SERVER['REMOTE_ADDR'] . $this->values[self::TAGNAME_PASSWORD]) . "|$sessionHash|$passwordHash\n", 3, dirname(__FILE__) . self::URL_SEPARATOR . '.ezuser-log.php'); // Debug

    1535. 

  1535. 			$this->authenticated = ($passwordHash === $sessionHash);

    1536. 

  1536. 

    1537. 

  1537. 			if ($this->authenticated) {

    1538. 

  1538. 				$result			= self::RESULT_SUCCESS;

    1539. 

  1539. 				$this->manualSignOut	= false;

    1540. 

  1540. 			} else {

    1541. 

  1541. 				$result			= self::RESULT_BADPASSWORD;

    1542. 

  1542. 			}

    1543. 

  1543. 		}

    1544. 

  1544. 

    1545. 

  1545. 		$this->result = $result;

    1546. 

  1546. 		return $result;

    1547. 

  1547. 	}

    1548. 

  1548. 

    1549. 

  1549. // ---------------------------------------------------------------------------

    1550. 

  1550. // "Get" methods

    1551. 

  1551. // ---------------------------------------------------------------------------

    1552. 

  1552. 	protected	/*.string.*/			function data()			{return serialize($this->values);}

    1553. 

  1553. 	protected	/*.string.*/			function id()			{return $this->getValue(self::TAGNAME_ID);}

    1554. 

  1554. 	public		/*.string.*/			function username()		{return $this->getValue(self::TAGNAME_USERNAME);}

    1555. 

  1555. 	protected	/*.string.*/			function passwordHash()		{return $this->getValue(self::TAGNAME_PASSWORD);}

    1556. 

  1556. 	public		/*.string.*/			function firstName()		{return $this->getValue(self::TAGNAME_FIRSTNAME);}

    1557. 

  1557. 	public		/*.string.*/			function lastName()		{return $this->getValue(self::TAGNAME_LASTNAME);}

    1558. 

  1558. 	public		/*.string.*/			function fullName()		{return $this->getValue(self::TAGNAME_FULLNAME);}

    1559. 

  1559. 	public		/*.string.*/			function email()		{return $this->getValue(self::TAGNAME_EMAIL);}

    1560. 

  1560. 	protected	/*.string.*/			function verificationKey()	{return $this->getValue(self::TAGNAME_VERIFICATIONKEY);}

    1561. 

  1561. 	public		/*.int.*/			function status()		{return (int) $this->getValue(self::TAGNAME_STATUS);}

    1562. 

  1562. 	public		/*.boolean.*/			function authenticated()	{return $this->authenticated;}

    1563. 

  1563. 	protected	/*.int.*/			function result()		{return $this->result;}

    1564. 

  1564. 	protected	/*.array[string]string.*/	function config()		{return $this->config;}

    1565. 

  1565. 	protected	/*.array[string]string.*/	function errors()		{return $this->errors;}

    1566. 

  1566. 	protected	/*.string.*/			function signOutActions()	{return implode(self::DELIMITER_SPACE, $this->signOutActions);}

    1567. 

  1567. 	protected	/*.boolean.*/			function isChanged()		{return $this->isChanged;}

    1568. 

  1568. 	protected	/*.boolean.*/			function manualSignOut()	{return $this->manualSignOut;}

    1569. 

  1569. 	protected	/*.boolean.*/			function incomplete() {

    1570. 

  1570. 		return	(	empty($this->values[self::TAGNAME_USERNAME])	||

    1571. 

  1571. 				empty($this->values[self::TAGNAME_EMAIL])	||

    1572. 

  1572. 				empty($this->values[self::TAGNAME_ID])

    1573. 

  1573. 			);

    1574. 

  1574. 	}

    1575. 

  1575. 

    1576. 

  1576. 

    1577. 

  1577. // ---------------------------------------------------------------------------

    1578. 

  1578. // Name manipulation

    1579. 

  1579. // ---------------------------------------------------------------------------

    1580. 

  1580. 	private /*.string.*/ function getDefaultUsername() {

    1581. 

  1581. 		$lastName	= $this->values[self::TAGNAME_LASTNAME];

    1582. 

  1582. 		$firstName	= $this->values[self::TAGNAME_FIRSTNAME];

    1583. 

  1583. 		$username	= strtolower($firstName . $lastName);

    1584. 

  1584. 		$username	= preg_replace('/[^0-9a-z_-]/', '', $username);

    1585. 

  1585. 		return $username;

    1586. 

  1586. 	}

    1587. 

  1587. 

    1588. 

  1588. 	private /*.void.*/ function setFullName() {

    1589. 

  1589. 		$firstName	= $this->values[self::TAGNAME_FIRSTNAME];

    1590. 

  1590. 		$lastName	= $this->values[self::TAGNAME_LASTNAME];

    1591. 

  1591. 		$separator	= (empty($firstName) || empty($lastName)) ? '' : self::DELIMITER_SPACE;

    1592. 

  1592. 

    1593. 

  1593. 		$this->setValue(self::TAGNAME_FULLNAME, $firstName . $separator . $lastName);

    1594. 

  1594. 

    1595. 

  1595. 		if ($this->usernameIsDefault) {$this->setValue(self::TAGNAME_USERNAME, $this->getDefaultUsername());}

    1596. 

  1596. 	}

    1597. 

  1597. 

    1598. 

  1598. 	private /*.void.*/ function setNamePart(/*.string.*/ $key, /*.string.*/ $name) {

    1599. 

  1599. 		$name = trim($name);

    1600. 

  1600. 		if ($this->setValue($key, $name)) $this->setFullName();

    1601. 

  1601. 	}

    1602. 

  1602. 

    1603. 

  1603. // ---------------------------------------------------------------------------

    1604. 

  1604. // "Set" methods

    1605. 

  1605. // ---------------------------------------------------------------------------

    1606. 

  1606. 	protected /*.void.*/ function setData(/*.string.*/ $data) {

    1607. 

  1607. 		$this->values = /*.(array[string]string).*/ unserialize($data);

    1608. 

  1608. 	}

    1609. 

  1609. 

    1610. 

  1610. 	protected /*.void.*/ function clearErrors() {

    1611. 

  1611. 		$this->errors = /*.(array[string]string).*/ array();

    1612. 

  1612. 	}

    1613. 

  1613. 

    1614. 

  1614. 	protected /*.int.*/ function setStatus(/*.int.*/ $status) {

    1615. 

  1615. 		if (!is_numeric($status)) return self::RESULT_STATUSNAN;

    1616. 

  1616. 

    1617. 

  1617. 		// If we're setting this user to Pending then generate a verification key

    1618. 

  1618. 		if ($status === self::STATUS_PENDING && $this->status() !== self::STATUS_PENDING) {

    1619. 

  1619. 			// Use the ID to generate a verification key

    1620. 

  1620. 			$this->setValue(self::TAGNAME_VERIFICATIONKEY, self::makeUniqueKey($this->id()));

    1621. 

  1621. 		}

    1622. 

  1622. 

    1623. 

  1623. 		$this->setValue(self::TAGNAME_STATUS, (string) $status);

    1624. 

  1624. 		return self::RESULT_VALIDATED;

    1625. 

  1625. 	}

    1626. 

  1626. 

    1627. 

  1627. 	protected /*.int.*/ function setResult(/*.int.*/ $result) {

    1628. 

  1628. 		if (!is_numeric($result)) return self::RESULT_RESULTNAN;

    1629. 

  1629. 		$this->result = $result;

    1630. 

  1630. 		return self::RESULT_VALIDATED;

    1631. 

  1631. 	}

    1632. 

  1632. 

    1633. 

  1633. 	protected /*.int.*/ function setConfig(/*.array[string]string.*/ $config) {

    1634. 

  1634. 		if (!is_array($config)) return self::RESULT_CONFIGNOTARRAY;

    1635. 

  1635. 		$this->config = $config;

    1636. 

  1636. 		return self::RESULT_VALIDATED;

    1637. 

  1637. 	}

    1638. 

  1638. 

    1639. 

  1639. 	public /*.void.*/ function setFirstName(/*.string.*/ $name)	{$this->setNamePart(self::TAGNAME_FIRSTNAME, $name);}

    1640. 

  1640. 	public /*.void.*/ function setLastName(/*.string.*/ $name)	{$this->setNamePart(self::TAGNAME_LASTNAME, $name);}

    1641. 

  1641. 

    1642. 

  1642. 	protected /*.int.*/ function setUsername($name = '') {

    1643. 

  1643. 		$this->usernameIsDefault = empty($name);

    1644. 

  1644. 		if ($this->usernameIsDefault) $name = $this->getDefaultUsername();

    1645. 

  1645. 		if (empty($name)) return self::RESULT_NOUSERNAME;

    1646. 

  1646. 		$this->setValue(self::TAGNAME_USERNAME, $name);

    1647. 

  1647. 		return self::RESULT_VALIDATED;

    1648. 

  1648. 	}

    1649. 

  1649. 

    1650. 

  1650. 	protected /*.int.*/ function setEmail(/*.string.*/ $email) {

    1651. 

  1651. 		if (empty($email)) return self::RESULT_NOEMAIL;

    1652. 

  1652. 

    1653. 

  1653. 		if (!(boolean) self::is_email($email)) {

    1654. 

  1654. 			$this->errors[self::TAGNAME_EMAIL] = $email;

    1655. 

  1655. 			return self::RESULT_EMAILFORMATERR;

    1656. 

  1656. 		}

    1657. 

  1657. 

    1658. 

  1658. 		$this->setValue(self::TAGNAME_EMAIL, $email);

    1659. 

  1659. 		return self::RESULT_VALIDATED;

    1660. 

  1660. 	}

    1661. 

  1661. 

    1662. 

  1662. 	protected /*.int.*/ function setPasswordHash(/*.string.*/ $passwordHash) {

    1663. 

  1663. 		if (empty($passwordHash))				return self::RESULT_NOPASSWORD;

    1664. 

  1664. 		if ($passwordHash === hash(self::HASH_FUNCTION, ''))	return self::RESULT_NULLPASSWORD;

    1665. 

  1665. 		$this->setValue(self::TAGNAME_PASSWORD, $passwordHash);

    1666. 

  1666. 		return self::RESULT_VALIDATED;

    1667. 

  1667. 	}

    1668. 

  1668. 

    1669. 

  1669. 	protected /*.void.*/ function addSignOutAction(/*.string.*/ $action) {

    1670. 

  1670. 		if (!in_array($action, $this->signOutActions)) $this->signOutActions[] = $action;

    1671. 

  1671. 	}

    1672. 

  1672. 

    1673. 

  1673. 	protected /*.void.*/ function clearSignOutActions() {

    1674. 

  1674. 		$this->signOutActions = /*.(array[int]string).*/ array();

    1675. 

  1675. 	}

    1676. 

  1676. 

    1677. 

  1677. 	protected /*.void.*/ function clearChanges() {

    1678. 

  1678. 		$this->isChanged = false;

    1679. 

  1679. 	}

    1680. 

  1680. 

    1681. 

  1681. // ---------------------------------------------------------------------------

    1682. 

  1682. // Password reset handling

    1683. 

  1683. // ---------------------------------------------------------------------------

    1684. 

  1684. 	private $passwordResetFlag = false;

    1685. 

  1685. 	private /*.ezUser_reset.*/ $passwordReset;

    1686. 

  1686. 

    1687. 

  1687. 	public /*.boolean.*/ function hasPasswordReset() {return $this->passwordResetFlag;}

    1688. 

  1688. 

    1689. 

  1689. 	public /*.ezUser_reset.*/ function passwordReset($terminate = false) {

    1690. 

  1690. 		$passwordReset = new ezUser_reset();

    1691. 

  1691. 

    1692. 

  1692. 		if ($terminate) {

    1693. 

  1693. 			unset($this->passwordReset);

    1694. 

  1694. 			$this->passwordResetFlag = false;

    1695. 

  1695. 			return $passwordReset; // empty

    1696. 

  1696. 		} else {

    1697. 

  1697. 			$passwordReset->setId($this->id());

    1698. 

  1698. 			$this->passwordReset = $passwordReset;

    1699. 

  1699. 			$this->passwordResetFlag = true;

    1700. 

  1700. 			return $this->passwordReset;

    1701. 

  1701. 		}

    1702. 

  1702. 	}

    1703. 

  1703. }

    1704. 

  1704. // End of class ezUser_base

    1705. 

  1705. 

    1706. 

  1706. 

    1707. 

  1707. /**

    1708. 

  1708.  * This class encapsulates all the functions needed to manage the collection

    1709. 

  1709.  * of stored users. It interacts with the storage mechanism (e.g. database or

    1710. 

  1710.  * XML file).

    1711. 

  1711.  *

    1712. 

  1712.  * @package ezUser

    1713. 

  1713.  */

    1714. 

  1714. interface I_ezUser_environment extends I_ezUser_base {

    1715. 

  1715. 		// Cookie names

    1716. 

  1716. 	const	COOKIE_USERNAME		= 'ezuser-1',

    1717. 

  1717. 		COOKIE_PASSWORD		= 'ezuser-2',

    1718. 

  1718. 		COOKIE_AUTOSIGN		= 'ezuser-3',

    1719. 

  1719. 

    1720. 

  1720. 		// Storage locations

    1721. 

  1721. 		STORAGE			= '.ezuser-data.php',

    1722. 

  1722. 		SETTINGS		= '.ezuser-settings.php',

    1723. 

  1723. 		LOG			= '.ezuser-log.php',

    1724. 

  1724. 

    1725. 

  1725. 		// Keys for the configuration settings

    1726. 

  1726. 		SETTINGS_ADMINEMAIL	= 'adminEmail',

    1727. 

  1727. 		SETTINGS_PERSISTED	= 'persisted',

    1728. 

  1728. 		SETTINGS_EMPTY		= 'empty',

    1729. 

  1729. 		SETTINGS_ACCOUNTPAGE	= 'accountPage',

    1730. 

  1730. 		SETTINGS_SECUREFOLDER	= 'secureFolder',

    1731. 

  1731. 

    1732. 

  1732. 		// Miscellaneous constants

    1733. 

  1733. 		DELIMITER_EMAIL		= '@';

    1734. 

  1734. 

    1735. 

  1735. 	public static /*.ezUser_base.*/ function lookup			($needle = '', $tagName = '');

    1736. 

  1736. 	public static /*.ezUser_base.*/ function save			(/*.array[string]mixed.*/ $userData);

    1737. 

  1737. 	public static /*.ezUser_base.*/	function signIn			($userData = /*.(array[string]mixed).*/ array());

    1738. 

  1738. }

    1739. 

  1739. 

    1740. 

  1740. /**

    1741. 

  1741.  * This class encapsulates all the functions needed to manage the collection

    1742. 

  1742.  * of stored users. It interacts with the storage mechanism (e.g. database or

    1743. 

  1743.  * XML file).

    1744. 

  1744.  *

    1745. 

  1745.  * @package ezUser

    1746. 

  1746.  */

    1747. 

  1747. abstract class ezUser_environment extends ezUser_base implements I_ezUser_environment {

    1748. 

  1748. 

    1749. 

  1749. // ---------------------------------------------------------------------------

    1750. 

  1750. // Helper methods

    1751. 

  1751. // ---------------------------------------------------------------------------

    1752. 

  1752. 	protected static /*.boolean.*/ function logMessage($message = 'Unknown') {

    1753. 

  1753. 		$filename = dirname(__FILE__) . self::URL_SEPARATOR . self::LOG;

    1754. 

  1754. 		$logWhen	= date('Y-m-d H:i:s', time());

    1755. 

  1755. 		return error_log("$logWhen\t$message\n", 3, $filename);

    1756. 

  1756. 	}

    1757. 

  1757. 

    1758. 

  1758. 	private static /*.DOMDocument.*/ function openStorage() {

    1759. 

  1759. 		// Connect to database or whatever our storage mechanism is in this version

    1760. 

  1760. 

    1761. 

  1761. 		// Where is the storage container?

    1762. 

  1762. 		$storage_file = realpath(dirname(__FILE__)) . self::URL_SEPARATOR . self::STORAGE;

    1763. 

  1763. 

    1764. 

  1764. 		// If storage container doesn't exist then create it

    1765. 

  1765. 		if (!is_file($storage_file)) {

    1766. 

  1766. 			$query = '?';

    1767. 

  1767. 			$html = <<<HTML

    1768. 

  1768. <?php header("Location: /"); $query>

    1769. 

  1769. <users>

    1770. 

  1770. </users>

    1771. 

  1771. HTML;

    1772. 

  1772. 

    1773. 

  1773. 			$handle = @fopen($storage_file, 'wb');

    1774. 

  1774. 			if (is_bool($handle)) exit(self::RESULT_STORAGEERR);

    1775. 

  1775. 			fwrite($handle, $html);

    1776. 

  1776. 			fclose($handle);

    1777. 

  1777. 			chmod($storage_file, 0600);

    1778. 

  1778. 		}

    1779. 

  1779. 

    1780. 

  1780. 		// Open the container for use

    1781. 

  1781. 		$storage = new DOMDocument();

    1782. 

  1782. 		$storage->load($storage_file);

    1783. 

  1783. 

    1784. 

  1784. 		return $storage;

    1785. 

  1785. 	}

    1786. 

  1786. 

    1787. 

  1787. // ---------------------------------------------------------------------------

    1788. 

  1788. 	private static /*.void.*/ function closeStorage(DOMDocument $storage) {

    1789. 

  1789. 		$storage_file = dirname(__FILE__) . self::URL_SEPARATOR . self::STORAGE;

    1790. 

  1790. 

    1791. 

  1791. 		for ($attempt = 0; $attempt < 3; $attempt++) {

    1792. 

  1792. 			$count = @$storage->save($storage_file);

    1793. 

  1793. 			if ((bool) $count) break;

    1794. 

  1794. 			sleep(1); // File may occasionally be locked by indexing/backups etc.

    1795. 

  1795. 		}

    1796. 

  1796. }

    1797. 

  1797. 

    1798. 

  1798. // ---------------------------------------------------------------------------

    1799. 

  1799. 	private static /*.DOMElement.*/ function findUser(DOMDocument $storage, $needle = '', $tagName = '') {

    1800. 

  1800. 		if ($needle === '') return $storage->createElement(self::TAGNAME_USER);

    1801. 

  1801. 

    1802. 

  1802. 		if ($tagName === '') $tagName = ((bool) strpos($needle,self::DELIMITER_EMAIL)) ? self::TAGNAME_EMAIL : self::TAGNAME_USERNAME;

    1803. 

  1803. 

    1804. 

  1804. 		$nodeList	= $storage->getElementsByTagName($tagName);

    1805. 

  1805. 		$found		= false;

    1806. 

  1806. 

    1807. 

  1807. 		for ($i = 0; $i < $nodeList->length; $i++) {

    1808. 

  1808. 			$node	= $nodeList->item($i);

    1809. 

  1809. 			$found	= (strcasecmp($node->nodeValue, $needle) === 0);

    1810. 

  1810. 			if ($found) break;

    1811. 

  1811. 		}

    1812. 

  1812. 

    1813. 

  1813. 

    1814. 

  1814. 		if ($found && isset($node)) {

    1815. 

  1815. 			/*.object.*/ $userElement_PHPLint = $node->parentNode;	// PHPLint-compliant typecasting (yawn)

    1816. 

  1816. 			$userElement = /*.(DOMElement).*/ $userElement_PHPLint;

    1817. 

  1817. 			return $userElement;

    1818. 

  1818. 		} else {

    1819. 

  1819. 			return $storage->createElement(self::TAGNAME_USER);

    1820. 

  1820. 		}

    1821. 

  1821. 	}

    1822. 

  1822. 

    1823. 

  1823. // ---------------------------------------------------------------------------

    1824. 

  1824. 	public static /*.ezUser_base.*/ function lookup($needle = '', $tagName = '') {

    1825. 

  1825. 		$ezUser = new ezUser_base();

    1826. 

  1826. 		if ($needle === '') return $ezUser;

    1827. 

  1827. 

    1828. 

  1828. 		if ($tagName === '' || $tagName === self::TAGNAME_USERNAME || $tagName === self::TAGNAME_EMAIL) {

    1829. 

  1829. 			$ezUser->setUsername($needle); // Will get overwritten if we successfully find the user in the database

    1830. 

  1830. 		}

    1831. 

  1831. 

    1832. 

  1832. 		$storage	= self::openStorage();

    1833. 

  1833. 		$record		= self::findUser($storage, $needle, $tagName);

    1834. 

  1834. 

    1835. 

  1835. 		if ($record->hasChildNodes()) {

    1836. 

  1836. 			$data = $record->getElementsByTagName(self::TAGNAME_DATA)->item(0)->nodeValue;

    1837. 

  1837. 			if (!empty($data)) $ezUser->setData($data);

    1838. 

  1838. 

    1839. 

  1839. 			$nodeList = $record->getElementsByTagName(self::TAGNAME_RESETDATA);

    1840. 

  1840. 

    1841. 

  1841. 			if ((bool) $nodeList->length) {

    1842. 

  1842. 				$data = $nodeList->item(0)->nodeValue;

    1843. 

  1843. 				if (!empty($data)) {

    1844. 

  1844. 					$passwordReset = $ezUser->passwordReset();

    1845. 

  1845. 					$passwordReset->setData($data);

    1846. 

  1846. 				}

    1847. 

  1847. 			}

    1848. 

  1848. 		}

    1849. 

  1849. 

    1850. 

  1850. 		return $ezUser;

    1851. 

  1851. 	}

    1852. 

  1852. 

    1853. 

  1853. // ---------------------------------------------------------------------------

    1854. 

  1854. // Functions for sending stuff to the browser

    1855. 

  1855. // ---------------------------------------------------------------------------

    1856. 

  1856. 	protected static /*.void.*/ function sendContent(/*.string.*/ $content, $container = '', $contentType = 'text/html') {

    1857. 

  1857. 		// Send headers first

    1858. 

  1858. 		if (!headers_sent()) {

    1859. 

  1859. //			$package = 'ezuser';

    1860. 

  1860. 			if ($container === '') $container = 'ezuser';

    1861. 

  1861. //header("Container-length: " . strlen($container)); // debug

    1862. 

  1862. 			header('Package: ezUser');

    1863. 

  1863. 			header("ezUser-container: $container");

    1864. 

  1864. 			header("Content-type: $contentType");

    1865. 

  1865. 		}

    1866. 

  1866. 

    1867. 

  1867. 		// Send content

    1868. 

  1868. 		echo $content;

    1869. 

  1869. 

    1870. 

  1870. /* Comment out profiling statements if not needed

    1871. 

  1871. 		// Send profiling data as a comment

    1872. 

  1872. 		global $ezuser_profile;

    1873. 

  1873. 

    1874. 

  1874. 		if (count($ezuser_profile) > 0) {

    1875. 

  1875. 			$ezuser_profile['response'] = ezuser_time();

    1876. 

  1876. 

    1877. 

  1877. 			if ($contentType === 'text/javascript' || $contentType === 'text/css') {

    1878. 

  1878. 				$commentStart	= '/' . '*';

    1879. 

  1879. 				$commentEnd	= '*' . '/';

    1880. 

  1880. 			} else {

    1881. 

  1881. 				$commentStart	= '<!--';

    1882. 

  1882. 				$commentEnd	= '-->';

    1883. 

  1883. 			}

    1884. 

  1884. 

    1885. 

  1885. 			echo "\n$commentStart\n";

    1886. 

  1886. 			$previous = reset($ezuser_profile);

    1887. 

  1887. 

    1888. 

  1888. 			while (list($key, $value) = each($ezuser_profile)) {

    1889. 

  1889. 				$elapsed	= round($value - $previous, 4);

    1890. 

  1890. 				$previous	= $value;

    1891. 

  1891. 				echo "$key\t$value\t$elapsed\n";

    1892. 

  1892. 			}

    1893. 

  1893. 			echo "$commentEnd\n";

    1894. 

  1894. 		}

    1895. 

  1895. */

    1896. 

  1896. 	}

    1897. 

  1897. 

    1898. 

  1898. 	protected static /*.string.*/ function resultText(/*.int.*/ $result, $more = '', $sendToBrowser = false) {

    1899. 

  1899. 		switch ($result) {

    1900. 

  1900. 			// Authentication results

    1901. 

  1901. 			case self::RESULT_UNDEFINED:		$text = "Undefined";					break;

    1902. 

  1902. 			case self::RESULT_SUCCESS:		$text = "Success";					break;

    1903. 

  1903. 			case self::RESULT_UNKNOWNUSER:		$text = "Username not recognised";			break;

    1904. 

  1904. 			case self::RESULT_BADPASSWORD:		$text = "Password is wrong";				break;

    1905. 

  1905. 			case self::RESULT_UNKNOWNACTION:	$text = "Unrecognised action";				break;

    1906. 

  1906. 			case self::RESULT_NOACTION:		$text = "No action specified";				break;

    1907. 

  1907. 

    1908. 

  1908. 			// Registration and validation results

    1909. 

  1909. 			case self::RESULT_VALIDATED:		$text = "Validation was successful";			break;

    1910. 

  1910. 			case self::RESULT_NOID:			$text = "ID cannot be blank";				break;

    1911. 

  1911. 			case self::RESULT_NOUSERNAME:		$text = "The username cannot be blank";			break;

    1912. 

  1912. 			case self::RESULT_NOEMAIL:		$text = "Please provide an email address";		break;

    1913. 

  1913. 			case self::RESULT_EMAILFORMATERR:	$text = "Incorrect email address format";		break;

    1914. 

  1914. 			case self::RESULT_NOPASSWORD:		$text = "Password hash cannot be blank";		break;

    1915. 

  1915. 			case self::RESULT_NULLPASSWORD:		$text = "Password cannot be blank";			break;

    1916. 

  1916. 			case self::RESULT_STATUSNAN:		$text = "Status code must be numeric";			break;

    1917. 

  1917. 			case self::RESULT_RESULTNAN:		$text = "Result code must be numeric";			break;

    1918. 

  1918. 			case self::RESULT_CONFIGNOTARRAY:	$text = "Configuration settings must be an array";	break;

    1919. 

  1919. 			case self::RESULT_USERNAMEEXISTS:	$text = "This username already exists";			break;

    1920. 

  1920. 			case self::RESULT_EMAILEXISTS:		$text = "Email address is already registered";		break;

    1921. 

  1921. 			case self::RESULT_NOTSIGNEDIN:		$text = "You must be signed in to update your account";	break;

    1922. 

  1922. 			case self::RESULT_INCOMPLETE:		$text = "Not enough information to update the account";	break;

    1923. 

  1923. 

    1924. 

  1924. 			// Session and environment issues

    1925. 

  1925. 			case self::RESULT_NOSESSION:		$text = "No session data available";			break;

    1926. 

  1926. 			case self::RESULT_NOSESSIONCOOKIES:	$text = "Session cookies are not enabled";		break;

    1927. 

  1927. 			case self::RESULT_STORAGEERR:		$text = "Error with stored user details";		break;

    1928. 

  1928. 			case self::RESULT_EMAILERR:		$text = "Error sending email";				break;

    1929. 

  1929. 			case self::RESULT_HEADERSSENT:		$text = "Headers already sent";				break;

    1930. 

  1930. 			default:				$text = "Unknown result code";				break;

    1931. 

  1931. 		}

    1932. 

  1932. 

    1933. 

  1933. 		if ($more !== '')	$text .= ": $more";

    1934. 

  1934. 		if ($sendToBrowser)	{self::sendContent($text); return '';} else return $text;

    1935. 

  1935. 	}

    1936. 

  1936. 

    1937. 

  1937. // ---------------------------------------------------------------------------

    1938. 

  1938. // Sign-in and session variables

    1939. 

  1939. // ---------------------------------------------------------------------------

    1940. 

  1940. 	protected static /*.string.*/ function getInstanceId($container = 'ezuser') {

    1941. 

  1941. 		return ($container === self::ACTION_MAIN || $container === 'ezuser') ? 'ezuser' : "ezuser-$container";

    1942. 

  1942. 	}

    1943. 

  1943. 

    1944. 

  1944. 	protected static /*.void.*/ function setSessionObject(ezUser_base $ezUser, $instance = 'ezuser') {

    1945. 

  1945. 		self::checkSession();

    1946. 

  1946. 		$instanceId = self::getInstanceId($instance);

    1947. 

  1947. 		$_SESSION[$instanceId] = $ezUser;

    1948. 

  1948. 

    1949. 

  1949. /*

    1950. 

  1950. $debug_isset		= (isset($_SESSION))										? 'true' : 'false'; // debug

    1951. 

  1951. $debug_isarray		= ((isset($_SESSION)) && (is_array($_SESSION)))							? 'true' : 'false'; // debug

    1952. 

  1952. $debug_keyexists	= ((isset($_SESSION)) && (is_array($_SESSION)) && (array_key_exists($instanceId, $_SESSION)))	? 'true' : 'false'; // debug

    1953. 

  1953. $debug_result		= ((isset($_SESSION)) && (is_array($_SESSION)) && (array_key_exists($instanceId, $_SESSION)))	? $_SESSION[$instanceId]->result() : 'n/a'; // debug

    1954. 

  1954. self::logMessage("setSessionObject|\$_SESSION exists: $debug_isset|\$_SESSION is array: $debug_isarray|\$instanceId = $instanceId|array key exists: $debug_keyexists|result = $debug_result|session_id = " . session_id()); // debug

    1955. 

  1955. */

    1956. 

  1956. 	}

    1957. 

  1957. 

    1958. 

  1958. 	private static /*.boolean.*/ function autoSignInAvailable(){

    1959. 

  1959. 		return	(

    1960. 

  1960. 			array_key_exists(self::COOKIE_AUTOSIGN, $_COOKIE)	&&

    1961. 

  1961. 			array_key_exists(self::COOKIE_USERNAME, $_COOKIE)	&&

    1962. 

  1962. 			($_COOKIE[self::COOKIE_AUTOSIGN] === self::STRING_TRUE)	&&

    1963. 

  1963. 			($_COOKIE[self::COOKIE_USERNAME] !== '')

    1964. 

  1964. 			);

    1965. 

  1965. 	}

    1966. 

  1966. 

    1967. 

  1967. 	public static /*.ezUser_base.*/ function signIn($userData = /*.(array[string]mixed).*/ array()) {

    1968. 

  1968. 		$autoSignInRequest	= (count($userData) === 0);

    1969. 

  1969. 		$logEntry		= 'Sign in';

    1970. 

  1970. 

    1971. 

  1971. 		if ($autoSignInRequest) {

    1972. 

  1972. 			if (self::autoSignInAvailable()) {

    1973. 

  1973. 				$userData[self::COOKIE_USERNAME]	= (string) $_COOKIE[self::COOKIE_USERNAME];

    1974. 

  1974. 				$userData[self::COOKIE_PASSWORD]	= hash(self::HASH_FUNCTION, session_id() . (string) $_COOKIE[self::COOKIE_PASSWORD]);

    1975. 

  1975. 				$logEntry				.= '|auto';

    1976. 

  1976. 			} else {

    1977. 

  1977. 				$userData[self::COOKIE_USERNAME]	= '';

    1978. 

  1978. 				$userData[self::COOKIE_PASSWORD]	= '';

    1979. 

  1979. 				$logEntry				.= '|auto not available';

    1980. 

  1980. 			}

    1981. 

  1981. 		} else {

    1982. 

  1982. 			$logEntry				.= '|manual';

    1983. 

  1983. 		}

    1984. 

  1984. 

    1985. 

  1985. 		$username	= (string) $userData[self::COOKIE_USERNAME];

    1986. 

  1986. 		$password	= (string) $userData[self::COOKIE_PASSWORD];

    1987. 

  1987. 		$logEntry	.= "|$username|$password";

    1988. 

  1988. 

    1989. 

  1989. 		if ($username === '') {

    1990. 

  1990. 			$ezUser		= new ezUser_base();

    1991. 

  1991. 		} else {

    1992. 

  1992. 			$ezUser		= self::lookup($username);

    1993. 

  1993. 

    1994. 

  1994. 			if ($ezUser->status() === self::STATUS_UNKNOWN) {

    1995. 

  1995. 				$ezUser->setResult(($autoSignInRequest) ? self::RESULT_FAILEDAUTOSIGNIN : self::RESULT_UNKNOWNUSER);

    1996. 

  1996. 			} else {

    1997. 

  1997. 				$ezUser->authenticate($password); // Sets result itself

    1998. 

  1998. 			}

    1999. 

  1999. 		}

    2000. 

  2000. 

    2001. 

  2001. 		self::setSessionObject($ezUser);

    2002. 

  2002. 		self::logMessage($logEntry . '|' . $ezUser->result());

    2003. 

  2003. 		return $ezUser;

    2004. 

  2004. 	}

    2005. 

  2005. 

    2006. 

  2006. 	protected static /*.ezUser_base.*/ function getSessionObject($instance = 'ezuser') {

    2007. 

  2007. 		$file		= '';

    2008. 

  2008. 		$lineInt	= 0;

    2009. 

  2009. 

    2010. 

  2010. 		// There may already be a session in progress. We will use the existing

    2011. 

  2011. 		// session if possible.

    2012. 

  2012. 		if ((int) ini_get('session.use_cookies') === 0) {

    2013. 

  2013. 			echo self::resultText(self::RESULT_NOSESSIONCOOKIES);

    2014. 

  2014. 			die(self::RESULT_NOSESSIONCOOKIES);

    2015. 

  2015. 		} else if (headers_sent($file, $lineInt)) {

    2016. 

  2016. 			$line = (string) $lineInt;

    2017. 

  2017. 			echo self::resultText(self::RESULT_HEADERSSENT, "$file (line $line)");

    2018. 

  2018. 			die(self::RESULT_HEADERSSENT);

    2019. 

  2019. 		} else {

    2020. 

  2020. 			self::checkSession();

    2021. 

  2021. 		}

    2022. 

  2022. 

    2023. 

  2023. 		$instanceId = self::getInstanceId($instance);

    2024. 

  2024. 

    2025. 

  2025. /*

    2026. 

  2026. $debug_isset		= (isset($_SESSION))										? 'true' : 'false'; // debug

    2027. 

  2027. $debug_isarray		= ((isset($_SESSION)) && (is_array($_SESSION)))							? 'true' : 'false'; // debug

    2028. 

  2028. $debug_keyexists	= ((isset($_SESSION)) && (is_array($_SESSION)) && (array_key_exists($instanceId, $_SESSION)))	? 'true' : 'false'; // debug

    2029. 

  2029. $debug_result		= ((isset($_SESSION)) && (is_array($_SESSION)) && (array_key_exists($instanceId, $_SESSION)))	? $_SESSION[$instanceId]->result() : 'n/a'; // debug

    2030. 

  2030. self::logMessage("getSessionObject|\$_SESSION exists: $debug_isset|\$_SESSION is array: $debug_isarray|\$instanceId = $instanceId|array key exists: $debug_keyexists|result = $debug_result|session_id = " . session_id()); // debug

    2031. 

  2031. */

    2032. 

  2032. 

    2033. 

  2033. 		if	(!array_key_exists($instanceId, $_SESSION))	$_SESSION[$instanceId] = self::signIn(); // Returns ezUser object, signed in if possible

    2034. 

  2034. 

    2035. 

  2035. 		$ezUser = /*.(ezUser_base).*/ $_SESSION[$instanceId];

    2036. 

  2036. 

    2037. 

  2037. 		if	(

    2038. 

  2038. 			!$ezUser->authenticated() &&

    2039. 

  2039. 			!$ezUser->manualSignOut() &&

    2040. 

  2040. 			self::autoSignInAvailable()

    2041. 

  2041. 			)						$_SESSION[$instanceId] = self::signIn(); // Returns ezUser object, signed in if possible

    2042. 

  2042. 		return /*.(ezUser_base).*/ $_SESSION[$instanceId];

    2043. 

  2043. 	}

    2044. 

  2044. 

    2045. 

  2045. // ---------------------------------------------------------------------------

    2046. 

  2046. // Configuration settings

    2047. 

  2047. // ---------------------------------------------------------------------------

    2048. 

  2048. 	protected static /*.string.*/ function thisURL() {

    2049. 

  2049. 		return self::getURL(self::URL_MODE_PATH, 'ezuser.php');

    2050. 

  2050. 	}

    2051. 

  2051. 

    2052. 

  2052. 	private static /*.array[string]string.*/ function loadConfig() {

    2053. 

  2053. 		$ezUser		= self::getSessionObject();

    2054. 

  2054. 		$config		= $ezUser->config();

    2055. 

  2055. 		$settingsFile	= realpath(dirname(__FILE__) . self::URL_SEPARATOR . self::SETTINGS);

    2056. 

  2056. 

    2057. 

  2057. 		// If configuration settings file doesn't exist then use default settings

    2058. 

  2058. 		if (($settingsFile === false) || !is_file($settingsFile)) {

    2059. 

  2059. 			$config[self::SETTINGS_EMPTY] = self::STRING_TRUE;

    2060. 

  2060. 		} else {

    2061. 

  2061. 			// Open the vessel

    2062. 

  2062. 			$storage = new DOMDocument();

    2063. 

  2063. 			$storage->load($settingsFile);

    2064. 

  2064. 			$nodeList = $storage->getElementsByTagName('settings')->item(0)->childNodes;

    2065. 

  2065. 

    2066. 

  2066. 			for ($i = 0; $i < $nodeList->length; $i++) {

    2067. 

  2067. 				$node = $nodeList->item($i);

    2068. 

  2068. 

    2069. 

  2069. 				if ($node->nodeType == XML_ELEMENT_NODE) {

    2070. 

  2070. 					$config[$node->nodeName] = $node->nodeValue;

    2071. 

  2071. 				}

    2072. 

  2072. 			}

    2073. 

  2073. 		}

    2074. 

  2074. 

    2075. 

  2075. 		$config[self::SETTINGS_PERSISTED] = self::STRING_TRUE;

    2076. 

  2076. 		$ezUser->setConfig($config);

    2077. 

  2077. 		return $config;

    2078. 

  2078. 	}

    2079. 

  2079. 

    2080. 

  2080. 	private static /*.array[string]string.*/ function getSettings() {

    2081. 

  2081. 		$ezUser	= self::getSessionObject();

    2082. 

  2082. 		$config = $ezUser->config();

    2083. 

  2083. 

    2084. 

  2084. 		if (!is_array($config))						{$config = self::loadConfig();}

    2085. 

  2085. 		if (!array_key_exists(self::SETTINGS_PERSISTED, $config))	{$config = self::loadConfig();}

    2086. 

  2086. 		if ($config[self::SETTINGS_PERSISTED] !== self::STRING_TRUE)	{$config = self::loadConfig();}

    2087. 

  2087. 

    2088. 

  2088. 		return $config;

    2089. 

  2089. 	}

    2090. 

  2090. 

    2091. 

  2091. 	protected static /*.string.*/ function getSetting(/*.string.*/ $setting) {

    2092. 

  2092. 		$config		= self::getSettings();

    2093. 

  2093. 		$thisSetting	= (array_key_exists($setting, $config)) ? $config[$setting] : '';

    2094. 

  2094. 

    2095. 

  2095. 		return $thisSetting;

    2096. 

  2096. 	}

    2097. 

  2097. // ---------------------------------------------------------------------------

    2098. 

  2098. 	private static /*.boolean.*/ function sendEmail($to = '', $subject = '', $message = '', $additional_headers = '') {

    2099. 

  2099. 		if ($to === '')			return false;	// Can't send to an empty address

    2100. 

  2100. 		if ($subject.$message === '')	return false;	// Can't send empty subject and message - that's just creepy

    2101. 

  2101. 

    2102. 

  2102. 		$from	= self::getSetting(self::SETTINGS_ADMINEMAIL);

    2103. 

  2103. 		$from	= ($from === '') ? 'webmaster' : $from;

    2104. 

  2104. 

    2105. 

  2105. 		// If there's no domain, then assume same as this host

    2106. 

  2106. 		if (strpos($from, self::DELIMITER_EMAIL) === false) {

    2107. 

  2107. 			$host	= self::getURL(self::URL_MODE_HOST);

    2108. 

  2108. 			$domain = (substr_count($host, '.') > 1) ? substr($host, strpos($host, '.') + 1) : $host;

    2109. 

  2109. 			$from	.= self::DELIMITER_EMAIL . $domain;

    2110. 

  2110. 		}

    2111. 

  2111. 

    2112. 

  2112. 		// Extra headers

    2113. 

  2113. 		$additional_headers .= "From: $from\r\n";

    2114. 

  2114. 

    2115. 

  2115. 		date_default_timezone_set(@date_default_timezone_get());	// E_STRICT needs this or it complains about the mail function

    2116. 

  2116. 

    2117. 

  2117. 		// Try three times to send the mail

    2118. 

  2118. 		$success = false;

    2119. 

  2119. 

    2120. 

  2120. 		for ($i = 0; $i < 3; $i++) {

    2121. 

  2121. 			if ($i > 0) self::logMessage('Failed to send email, retrying');

    2122. 

  2122. 			$success = @mail($to, $subject, $message, $additional_headers);

    2123. 

  2123. 			if ($success) break;

    2124. 

  2124. 		}

    2125. 

  2125. 

    2126. 

  2126. 		if (!$success) self::logMessage('Failed to send email');

    2127. 

  2127. 		return $success;

    2128. 

  2128. 	}

    2129. 

  2129. 

    2130. 

  2130. // ---------------------------------------------------------------------------

    2131. 

  2131. 	private static /*.int.*/ function is_duplicate(/*.string.*/ $username_or_email, /*.string.*/ $id) {

    2132. 

  2132. 		$resultCode	= ((bool) strpos($username_or_email, self::DELIMITER_EMAIL)) ? self::RESULT_EMAILEXISTS : self::RESULT_USERNAMEEXISTS;

    2133. 

  2133. 		$ezUser		= self::lookup($username_or_email);

    2134. 

  2134. 

    2135. 

  2135. 		return ($ezUser->status() === self::STATUS_UNKNOWN) || ($ezUser->id() === $id) ? self::RESULT_VALIDATED : $resultCode;

    2136. 

  2136. 	}

    2137. 

  2137. 

    2138. 

  2138. // ---------------------------------------------------------------------------

    2139. 

  2139. //	Storage methods

    2140. 

  2140. // ---------------------------------------------------------------------------

    2141. 

  2141. 	private static /*.void.*/ function addElement (DOMDocument $storage, DOMElement $record, /*.string.*/ $tagName, /*.string.*/ $value) {

    2142. 

  2142. 		$record->appendChild($storage->createTextNode("\n\t\t")); // XML formatting

    2143. 

  2143. 		$record->appendChild($storage->createElement($tagName, $value));

    2144. 

  2144. 	}

    2145. 

  2145. 

    2146. 

  2146. 	private static /*.DOMElement.*/ function createRecord(DOMDocument $storage, ezUser_base $ezUser) {

    2147. 

  2147. 		$record = $storage->createElement(self::TAGNAME_USER);

    2148. 

  2148. 		self::addElement($storage, $record, self::TAGNAME_USERNAME,	$ezUser->username());			// Add username

    2149. 

  2149. 		self::addElement($storage, $record, self::TAGNAME_EMAIL,	$ezUser->email());				// Add email address

    2150. 

  2150. 		self::addElement($storage, $record, self::TAGNAME_ID,		$ezUser->id());					// Add id

    2151. 

  2151. 		self::addElement($storage, $record, self::TAGNAME_DATA,		$ezUser->data());				// Add data blob

    2152. 

  2152. 

    2153. 

  2153. 		// Add verification key if necessary

    2154. 

  2154. 		$verificationKey = $ezUser->verificationKey();

    2155. 

  2155. 

    2156. 

  2156. 		if (!empty($verificationKey)) {

    2157. 

  2157. 			self::addElement($storage, $record, self::TAGNAME_VERIFICATIONKEY, $verificationKey);		// Add verification key

    2158. 

  2158. 		}

    2159. 

  2159. 

    2160. 

  2160. 		// Add password reset data if necessary

    2161. 

  2161. 		if ($ezUser->hasPasswordReset()) {

    2162. 

  2162. 			$passwordReset = $ezUser->passwordReset();

    2163. 

  2163. 			self::addElement($storage, $record, self::TAGNAME_RESETKEY,	$passwordReset->resetKey());	// Add password reset key

    2164. 

  2164. 			self::addElement($storage, $record, self::TAGNAME_RESETDATA,	$passwordReset->data());		// Add password reset data

    2165. 

  2165. 		}

    2166. 

  2166. 

    2167. 

  2167. 		self::addElement($storage, $record, 'updated', gmdate("Y-m-d H:i:s (T)"));				// Note when the record was updated

    2168. 

  2168. 		$record->appendChild($storage->createTextNode("\n\t")); // XML formatting

    2169. 

  2169. 		return $record;

    2170. 

  2170. 	}

    2171. 

  2171. 

    2172. 

  2172. // ---------------------------------------------------------------------------

    2173. 

  2173. 	private static /*.int.*/ function add(ezUser_base $ezUser) {

    2174. 

  2174. 		$storage	= self::openStorage();

    2175. 

  2175. 		$record		= self::createRecord($storage, $ezUser);

    2176. 

  2176. 

    2177. 

  2177. 		$users = $storage->getElementsByTagName('users')->item(0);

    2178. 

  2178. 		$users->appendChild($storage->createTextNode("\t")); // XML formatting

    2179. 

  2179. 		$users->appendChild($record);

    2180. 

  2180. 		$users->appendChild($storage->createTextNode("\n")); // XML formatting

    2181. 

  2181. 

    2182. 

  2182. 		self::closeStorage($storage);

    2183. 

  2183. 		return self::RESULT_SUCCESS;

    2184. 

  2184. 	}

    2185. 

  2185. 

    2186. 

  2186. // ---------------------------------------------------------------------------

    2187. 

  2187. 	private static /*.int.*/ function update(ezUser_base $ezUser) {

    2188. 

  2188. 		$storage	= self::openStorage();

    2189. 

  2189. 		$oldRecord	= self::findUser($storage, $ezUser->id(), self::TAGNAME_ID);

    2190. 

  2190. 

    2191. 

  2191. 		if (!$oldRecord->hasChildNodes()) return self::RESULT_STORAGEERR;

    2192. 

  2192. 

    2193. 

  2193. 		$newRecord	= self::createRecord($storage, $ezUser);

    2194. 

  2194. 

    2195. 

  2195. 		$oldRecord->parentNode->replaceChild($newRecord, $oldRecord);

    2196. 

  2196. 		self::closeStorage($storage);

    2197. 

  2197. 		return self::RESULT_SUCCESS;

    2198. 

  2198. 	}

    2199. 

  2199. 

    2200. 

  2200. // ---------------------------------------------------------------------------

    2201. 

  2201. //	Account verification

    2202. 

  2202. // ---------------------------------------------------------------------------

    2203. 

  2203. 	protected static /*.boolean.*/ function verify_notify($username_or_email = '') {

    2204. 

  2204. 		$ezUser = self::lookup($username_or_email);

    2205. 

  2205. 

    2206. 

  2206. 		if ($ezUser->status() !== self::STATUS_PENDING) return false;	// Only send confirmation email to users who are pending verification

    2207. 

  2207. 

    2208. 

  2208. 		// Message - SMTP needs CRLF not a bare LF (http://cr.yp.to/docs/smtplf.html)

    2209. 

  2209. 		$URL		= self::getURL(self::URL_MODE_ALL, 'ezuser.php');

    2210. 

  2210. 		$host		= self::getURL(self::URL_MODE_HOST);

    2211. 

  2211. 		$message	= "Somebody calling themselves " . $ezUser->fullName() . " created an account at $host using this email address.\r\n";

    2212. 

  2212. 		$message	.= "If it was you please click on the following link to verify the account.\r\n\r\n";

    2213. 

  2213. 		$message	.= "$URL?" . self::ACTION_VERIFY . "=" . $ezUser->verificationKey() . "\r\n\r\n";

    2214. 

  2214. 		$message	.= "After you click the link your account will be fully functional.\r\n";

    2215. 

  2215. 

    2216. 

  2216. 		// Send it

    2217. 

  2217. 		return self::sendEmail($ezUser->email(), 'New account confirmation', $message);

    2218. 

  2218. 	}

    2219. 

  2219. 

    2220. 

  2220. 	protected static /*.void.*/ function verify_update(ezUser_base $ezUser, /*.string.*/ $verificationKey) {

    2221. 

  2221. 		if ($ezUser->status() === self::STATUS_PENDING && $ezUser->verificationKey() === $verificationKey) {

    2222. 

  2222. 			$ezUser->setStatus(self::STATUS_CONFIRMED);

    2223. 

  2223. 			self::update($ezUser);

    2224. 

  2224. 		}

    2225. 

  2225. 	}

    2226. 

  2226. 

    2227. 

  2227. // ---------------------------------------------------------------------------

    2228. 

  2228. 	public static /*.ezUser_base.*/ function save(/*.array[string]mixed.*/ $userData) {

    2229. 

  2229. 		$result			= self::RESULT_VALIDATED;

    2230. 

  2230. 		$newUser		= (array_key_exists(self::TAGNAME_NEWUSER, $userData) && ($userData[self::TAGNAME_NEWUSER] === self::STRING_TRUE)) ? true : false;

    2231. 

  2231. 		$emailChanged		= false;

    2232. 

  2232. 		$usernameChanged	= false;

    2233. 

  2233. 		$ezUser			= self::getSessionObject(self::ACTION_ACCOUNT);

    2234. 

  2234. 

    2235. 

  2235. 		if (!$newUser && $ezUser->authenticated()) $ezUser->clearErrors(); else $newUser = true;

    2236. 

  2236. 

    2237. 

  2237. 		if ($newUser) {

    2238. 

  2238. 			$ezUser = new ezUser_base();

    2239. 

  2239. 			self::setSessionObject($ezUser, self::ACTION_ACCOUNT);

    2240. 

  2240. 		}

    2241. 

  2241. 

    2242. 

  2242. 		// Update email address

    2243. 

  2243. 		if (array_key_exists(self::TAGNAME_EMAIL, $userData)) {

    2244. 

  2244. 			$email			= (string) $userData[self::TAGNAME_EMAIL];

    2245. 

  2245. 			$emailChanged		= ($email !== $ezUser->email());

    2246. 

  2246. 			$thisResult		= $ezUser->setEmail($email);

    2247. 

  2247. 			$result			= ($result === self::RESULT_VALIDATED) ? $thisResult : $result;

    2248. 

  2248. 		} else	$email			= '';

    2249. 

  2249. 

    2250. 

  2250. 		// Update username

    2251. 

  2251. 		if (array_key_exists(self::COOKIE_USERNAME, $userData)) {

    2252. 

  2252. 			$username		= (string) $userData[self::COOKIE_USERNAME];

    2253. 

  2253. 			$usernameChanged	= ($username !== $ezUser->username());

    2254. 

  2254. 			$thisResult		= $ezUser->setUsername($username);

    2255. 

  2255. 			$result			= ($result === self::RESULT_VALIDATED) ? $thisResult : $result;

    2256. 

  2256. 		} else	$username		= '';

    2257. 

  2257. 

    2258. 

  2258. 		// Update password

    2259. 

  2259. 		if (array_key_exists(self::COOKIE_PASSWORD, $userData)) {

    2260. 

  2260. 			$passwordHash		= (string) $userData[self::COOKIE_PASSWORD];

    2261. 

  2261. 			$thisResult		= $ezUser->setPasswordHash($passwordHash);

    2262. 

  2262. 			$result			= ($result === self::RESULT_VALIDATED) ? $thisResult : $result;

    2263. 

  2263. 		}

    2264. 

  2264. 

    2265. 

  2265. 		// Update first name and last name

    2266. 

  2266. 		if (array_key_exists(self::TAGNAME_FIRSTNAME,	$userData)) $ezUser->setFirstName((string) $userData[self::TAGNAME_FIRSTNAME]);

    2267. 

  2267. 		if (array_key_exists(self::TAGNAME_LASTNAME,	$userData)) $ezUser->setLastName ((string) $userData[self::TAGNAME_LASTNAME]);

    2268. 

  2268. 

    2269. 

  2269. 		// Check for duplicates

    2270. 

  2270. 		$id = $ezUser->id();

    2271. 

  2271. 		if (($result === self::RESULT_VALIDATED) && $emailChanged)	$result = self::is_duplicate($email,	$id);

    2272. 

  2272. 		if (($result === self::RESULT_VALIDATED) && $usernameChanged)	$result = self::is_duplicate($username,	$id);

    2273. 

  2273. 

    2274. 

  2274. 		// Final checks and update

    2275. 

  2275. 		if ($result === self::RESULT_VALIDATED) {

    2276. 

  2276. 			if ($ezUser->isChanged()) {

    2277. 

  2277. 				if ($newUser || $emailChanged) $ezUser->setStatus(self::STATUS_PENDING);

    2278. 

  2278. 

    2279. 

  2279. 				if ($ezUser->incomplete()) {

    2280. 

  2280. 					$result = self::RESULT_INCOMPLETE;

    2281. 

  2281. 				} else {

    2282. 

  2282. 					$result = ($newUser) ? self::add($ezUser) : self::update($ezUser);

    2283. 

  2283. 					if ($result === self::RESULT_SUCCESS) $ezUser->clearChanges();

    2284. 

  2284. 					if ($newUser || $emailChanged) self::verify_notify($email);

    2285. 

  2285. 				}

    2286. 

  2286. 

    2287. 

  2287. 			} else {

    2288. 

  2288. 				$result = self::RESULT_SUCCESS;

    2289. 

  2289. 			}

    2290. 

  2290. 		}

    2291. 

  2291. 

    2292. 

  2292. 		$ezUser->setResult($result);

    2293. 

  2293. 		return $ezUser;

    2294. 

  2294. 	}

    2295. 

  2295. 

    2296. 

  2296. // ---------------------------------------------------------------------------

    2297. 

  2297. //	Secure content handling

    2298. 

  2298. // ---------------------------------------------------------------------------

    2299. 

  2299. 	private static /*.array[int]string.*/  function findBestMatch(/*.array[int]string.*/ $refererElements, /*.string.*/ $folder) {

    2300. 

  2300. 		$refererCount	= count($refererElements);

    2301. 

  2301. 		$name		= $refererElements[$refererCount - 1];

    2302. 

  2302. 		$filename	= realpath("$folder/$name");

    2303. 

  2303. 		$score		= 0;

    2304. 

  2304. 

    2305. 

  2305. 		// Is there a match in this folder?

    2306. 

  2306. 		if (is_file($filename)) {

    2307. 

  2307. 			// compute its score by counting matching elements back from the last one

    2308. 

  2308. 			$file		= (DIRECTORY_SEPARATOR !== self::URL_SEPARATOR) ? (string) str_replace(DIRECTORY_SEPARATOR, self::URL_SEPARATOR , $filename) : $filename;

    2309. 

  2309. 			$fileElements	= explode(self::URL_SEPARATOR, $file);

    2310. 

  2310. 			$fileElement	= end($fileElements);

    2311. 

  2311. 			$refererElement	= end($refererElements);

    2312. 

  2312. 

    2313. 

  2313. 			while ((bool) $fileElement && (bool) $refererElement && ($fileElement === $refererElement)) {

    2314. 

  2314. 				$score++;

    2315. 

  2315. 				$fileElement	= prev($fileElements);

    2316. 

  2316. 				$refererElement	= prev($refererElements);

    2317. 

  2317. 			}

    2318. 

  2318. 

    2319. 

  2319. 			// If it's a perfect match then it's the same page as the referer

    2320. 

  2320. 			// Don't use this one or we'll get in a loop

    2321. 

  2321. 			if ($score === $refererCount) $score = 0;

    2322. 

  2322. 		}

    2323. 

  2323. 

    2324. 

  2324. 		// Check subfolders

    2325. 

  2325. 		$folders = glob("$folder/*", GLOB_ONLYDIR);

    2326. 

  2326. 

    2327. 

  2327. 		foreach ($folders as $subfolder) {

    2328. 

  2328. 			// Exclude known red herrings

    2329. 

  2329. 			$basename = basename($subfolder);

    2330. 

  2330. 

    2331. 

  2331. 			switch ($basename) {

    2332. 

  2332. 			case '_vti_cnf':	// Fall-through ->

    2333. 

  2333. 			case '.git':		// Fall-through ->

    2334. 

  2334. 			case '.hg':		$redHerring = true;	break;

    2335. 

  2335. 			default:		$redHerring = false;	break;

    2336. 

  2336. 			}

    2337. 

  2337. 

    2338. 

  2338. 			if (!$redHerring) {

    2339. 

  2339. 				$match	= self::findBestMatch($refererElements, $subfolder);

    2340. 

  2340. 

    2341. 

  2341. 				if ((int) $match[1] > $score) {

    2342. 

  2342. 					$filename	= $match[0];

    2343. 

  2343. 					$score		= (int) $match[1];

    2344. 

  2344. 					break;

    2345. 

  2345. 				}

    2346. 

  2346. 			}

    2347. 

  2347. 		}

    2348. 

  2348. 

    2349. 

  2349. 		return array($filename, (string) $score);

    2350. 

  2350. 	}

    2351. 

  2351. 

    2352. 

  2352. // ---------------------------------------------------------------------------

    2353. 

  2353. 	protected static /*.string.*/ function getSecureContent(/*.string.*/ $referer) {

    2354. 

  2354. 		$refererElements	= /*.(array[int]string).*/ array_slice(explode(self::URL_SEPARATOR, $referer), 3);

    2355. 

  2355. 		$folder			= self::getSetting(self::SETTINGS_SECUREFOLDER);

    2356. 

  2356. 

    2357. 

  2357. 		if ($folder === '') $folder = dirname(realpath(__FILE__));

    2358. 

  2358. 

    2359. 

  2359. 		$match			= self::findBestMatch($refererElements, $folder);

    2360. 

  2360. 		$filename		= $match[0];

    2361. 

  2361. 		$html			= (is_file($filename)) ? self::getFileContents($filename) : '';

    2362. 

  2362. 		$start			= strpos($html, '<body>') + 6;

    2363. 

  2363. 		$length			= strpos($html, '</body>') - $start;

    2364. 

  2364. 		$html			= substr($html, $start, $length);

    2365. 

  2365. 

    2366. 

  2366. 		return $html;

    2367. 

  2367. 	}

    2368. 

  2368. 

    2369. 

  2369. // ---------------------------------------------------------------------------

    2370. 

  2370. //	Password reset handling

    2371. 

  2371. // ---------------------------------------------------------------------------

    2372. 

  2372. 	private static /*.boolean.*/ function passwordReset_notify(ezUser_base $ezUser) {

    2373. 

  2373. 		$passwordReset = $ezUser->passwordReset();

    2374. 

  2374. 

    2375. 

  2375. 		// Message

    2376. 

  2376. 		$URL		= self::getURL(self::URL_MODE_ALL, 'ezuser.php');

    2377. 

  2377. 		$host		= self::getURL(self::URL_MODE_HOST);

    2378. 

  2378. 		$message	= "A password reset was requested for an account at $host using this email address.\r\n";

    2379. 

  2379. 		$message	.= "If you want to reset your password please click on the following link.\r\n\r\n";

    2380. 

  2380. 		$message	.= "$URL?" . self::ACTION_RESET . "=" . $passwordReset->resetKey() . "\r\n\r\n";

    2381. 

  2381. 		$message	.= "If nothing happens when you click on the link then please copy it into your browser's address bar.\r\n";

    2382. 

  2382. 

    2383. 

  2383. 		// Send it

    2384. 

  2384. 		return self::sendEmail($ezUser->email(), 'Account maintenance', $message);

    2385. 

  2385. 	}

    2386. 

  2386. 

    2387. 

  2387. 	protected static /*.boolean.*/ function passwordReset_initialize(/*.string.*/ $username_or_email) {

    2388. 

  2388. 		$ezUser = self::lookup($username_or_email);

    2389. 

  2389. 		if ($ezUser->status() === self::STATUS_UNKNOWN) return false;

    2390. 

  2390. 		$passwordReset = $ezUser->passwordReset();

    2391. 

  2391. 		$passwordReset->initialize();

    2392. 

  2392. 		return ((bool) self::update($ezUser)) ? self::passwordReset_notify($ezUser) : false;

    2393. 

  2393. 	}

    2394. 

  2394. 

    2395. 

  2395. 	protected static /*.void.*/ function passwordReset_update(ezUser_base $ezUser, /*.string.*/$passwordHash) {

    2396. 

  2396. 		if ($ezUser->hasPasswordReset()) {

    2397. 

  2397. 			$ezUser->setPasswordHash($passwordHash);

    2398. 

  2398. 			$ezUser->passwordReset(true); // Clear password reset data

    2399. 

  2399. 			self::update($ezUser);

    2400. 

  2400. 		}

    2401. 

  2401. 	}

    2402. 

  2402. }

    2403. 

  2403. // End of class ezUser_environment

    2404. 

  2404. 

    2405. 

  2405. 

    2406. 

  2406. /**

    2407. 

  2407.  * This class manages the HTML, CSS and Javascript that you can include in

    2408. 

  2408.  * your web pages to support user registration and authentication.

    2409. 

  2409.  *

    2410. 

  2410.  * @package ezUser

    2411. 

  2411.  */

    2412. 

  2412. interface I_ezUser extends I_ezUser_environment {

    2413. 

  2413. 		// Modes for account form

    2414. 

  2414. 	const	ACCOUNT_MODE_NEW	= 'new',

    2415. 

  2415. 		ACCOUNT_MODE_EDIT	= 'edit',

    2416. 

  2416. 		ACCOUNT_MODE_DISPLAY	= 'display',

    2417. 

  2417. 		ACCOUNT_MODE_RESULT	= 'result',

    2418. 

  2418. 		ACCOUNT_MODE_CANCEL	= 'cancel',

    2419. 

  2419. 

    2420. 

  2420. 		// Button types

    2421. 

  2421. 		BUTTON_TYPE_ACTION	= 'action',

    2422. 

  2422. 		BUTTON_TYPE_PREFERENCE	= 'preference',

    2423. 

  2423. 		BUTTON_TYPE_HIDDEN	= 'hidden',

    2424. 

  2424. 

    2425. 

  2425. 		// Message types

    2426. 

  2426. 		MESSAGE_TYPE_DEFAULT	= 'message',

    2427. 

  2427. 		MESSAGE_TYPE_TEXT	= 'text',

    2428. 

  2428. 

    2429. 

  2429. 		// Message styles

    2430. 

  2430. 		MESSAGE_STYLE_DEFAULT	= 'info',

    2431. 

  2431. 		MESSAGE_STYLE_FAIL	= 'fail',

    2432. 

  2432. 		MESSAGE_STYLE_TEXT	= 'text',

    2433. 

  2433. 		MESSAGE_STYLE_PLAIN	= 'plain',

    2434. 

  2434. 

    2435. 

  2435. 		// Miscellaneous constants

    2436. 

  2436. 		DELIMITER_PLUS		= '+',

    2437. 

  2437. 		PASSWORD_MASK		= '************',

    2438. 

  2438. 		STRING_LEFT		= 'left',

    2439. 

  2439. 		STRING_RIGHT		= 'right';

    2440. 

  2440. 

    2441. 

  2441. 

    2442. 

  2442. // Methods may be commented out to reduce the attack surface when they are

    2443. 

  2443. // not required. Uncomment them if you need them.

    2444. 

  2444. //	public static /*.void.*/	function getStatusText		(/*.int.*/ $status, $more = '');

    2445. 

  2445. //	public static /*.void.*/	function getResultText		(/*.int.*/ $result, $more = '');

    2446. 

  2446. //	public static /*.void.*/	function getStatusDescription	(/*.int.*/ $status, $more = '');

    2447. 

  2447. //	public static /*.void.*/	function getResultDescription	(/*.int.*/ $result, $more = '');

    2448. 

  2448. 	public static /*.void.*/	function getResultForm		(/*.int.*/ $result, $more = '');

    2449. 

  2449. //	public static /*.void.*/	function fatalError		(/*.int.*/ $result, $more = '');

    2450. 

  2450. 	public static /*.void.*/	function getAccountForm		($mode = '', $newUser = false);

    2451. 

  2451. //	public static /*.void.*/	function getDashboard		();

    2452. 

  2452. //	public static /*.void.*/	function getSignInForm		();

    2453. 

  2453. 	public static /*.void.*/	function getControlPanel	($username = '');

    2454. 

  2454. //	public static /*.void.*/	function getStyleSheet		();

    2455. 

  2455. //	public static /*.void.*/	function getJavascript		($containerList = '');

    2456. 

  2456. 	public static /*.void.*/	function getContainer		($action = self::ACTION_MAIN);

    2457. 

  2457. 	public static /*.void.*/	function getAbout		();

    2458. 

  2458. 	public static /*.void.*/	function getAboutText		();

    2459. 

  2459. //	public static /*.void.*/	function getSourceCode		();

    2460. 

  2460. }

    2461. 

  2461. 

    2462. 

  2462. /**

    2463. 

  2463.  * This class manages the HTML, CSS and Javascript that you can include in

    2464. 

  2464.  * your web pages to support user registration and authentication.

    2465. 

  2465.  *

    2466. 

  2466.  * @package ezUser

    2467. 

  2467.  */

    2468. 

  2468. class ezUser extends ezUser_environment implements I_ezUser {

    2469. 

  2469. 	private static /*.string.*/ function getXML($html = '', $container = '') {

    2470. 

  2470. 		if (is_numeric($container) || $container === '') $container = 'ezuser'; // If passed to sendXML as an array

    2471. 

  2471. 		return "<ezuser container=\"$container\"><![CDATA[$html]]></ezuser>";

    2472. 

  2472. 	}

    2473. 

  2473. 

    2474. 

  2474. 	private static /*.void.*/ function sendXML(/*.mixed.*/ $content = '', $container = '') {

    2475. 

  2475. 		if (is_array($content)) {

    2476. 

  2476. 			// Expected array format is $content['container'] = '<html>'

    2477. 

  2477. 			$contentArray	= /*.(array[]string).*/ $content;

    2478. 

  2478. 			$xmlArray	= /*.(array[]string).*/ array_map('self::getXML', $contentArray, array_keys($contentArray)); // wrap each element

    2479. 

  2479. 			$xml		= implode('', $xmlArray);

    2480. 

  2480. 			$xml		= "<ezuser>$xml</ezuser>";

    2481. 

  2481. 

    2482. 

  2482. 		} else {

    2483. 

  2483. 			$xml = self::getXML((string) $content, $container);

    2484. 

  2484. 		}

    2485. 

  2485. 

    2486. 

  2486. 		self::sendContent($xml, $container, 'text/xml');

    2487. 

  2487. 	}

    2488. 

  2488. 

    2489. 

  2489. // ---------------------------------------------------------------------------

    2490. 

  2490. // Functions that build common HTML fragments

    2491. 

  2491. // ---------------------------------------------------------------------------

    2492. 

  2492. 	private static /*.string.*/ function htmlPage($body = '', $title = '', $sendToBrowser = false) {

    2493. 

  2493. 		$URL		= self::thisURL();

    2494. 

  2494. 		$actionJs	= self::ACTION_JAVASCRIPT;

    2495. 

  2495. 		$actionCSS	= self::ACTION_STYLESHEET;

    2496. 

  2496. 

    2497. 

  2497. 		$html = <<<HTML

    2498. 

  2498. <!DOCTYPE html>

    2499. 

  2499. <html>

    2500. 

  2500. 

    2501. 

  2501. <head>

    2502. 

  2502. 	<meta content="text/html; charset=utf-8" http-equiv="Content-Type" />

    2503. 

  2503. 	<title>$title</title>

    2504. 

  2504. 	<script src="$URL?$actionJs"></script>

    2505. 

  2505. 	<link type="text/css" rel="stylesheet" href="$URL?$actionCSS" title="ezUser">

    2506. 

  2506. </head>

    2507. 

  2507. 

    2508. 

  2508. <body class="ezuser">

    2509. 

  2509. $body

    2510. 

  2510. </body>

    2511. 

  2511. 

    2512. 

  2512. </html>

    2513. 

  2513. HTML;

    2514. 

  2514. 

    2515. 

  2515. 		if ($sendToBrowser) {self::sendContent($html); return '';} else return $html;

    2516. 

  2516. 	}

    2517. 

  2517. 

    2518. 

  2518. 	private static /*.string.*/ function htmlContainer($action = self::ACTION_MAIN, $sendToBrowser = false) {

    2519. 

  2519. 		$baseAction	= explode('=', $action);

    2520. 

  2520. 		$container	= self::getInstanceId($baseAction[0]);

    2521. 

  2521. 		$actionCommand	= self::ACTION;

    2522. 

  2522. 		$actionJs	= self::ACTION_JAVASCRIPT;

    2523. 

  2523. 		$URL		= self::thisURL();

    2524. 

  2524. 

    2525. 

  2525. 		$html = <<<HTML

    2526. 

  2526. 	<div id="$container"></div>

    2527. 

  2527. 	<script type="text/javascript">document.write(unescape('%3Cscript src="$URL?$actionCommand=$actionJs"%3E%3C/script%3E'));</script>

    2528. 

  2528. 	<script type="text/javascript">ezUser.ajax.execute('$action');</script>

    2529. 

  2529. HTML;

    2530. 

  2530. 

    2531. 

  2531. 		if ($sendToBrowser) {self::sendContent($html); return '';} else return $html;

    2532. 

  2532. 	}

    2533. 

  2533. 

    2534. 

  2534. 	private static /*.string.*/ function htmlInputText($styleFloat = self::STRING_RIGHT) {

    2535. 

  2535. 		$onKeyUp	= 'ezUser.keyUp';

    2536. 

  2536. 

    2537. 

  2537. 		return <<<HTML

    2538. 

  2538. 					class		=	"ezuser-text ezuser-$styleFloat"

    2539. 

  2539. 					onkeyup		=	"$onKeyUp(event)"

    2540. 

  2540. 					size		=	"40"

    2541. 

  2541. HTML;

    2542. 

  2542. 	}

    2543. 

  2543. 

    2544. 

  2544. 	private static /*.string.*/ function htmlButton(/*.string.*/ $type, $styleFloat = self::STRING_RIGHT, $verbose = false) {

    2545. 

  2545. 		$classVerbose	= ($verbose) ? ' ezuser-' . self::BUTTON_TYPE_PREFERENCE . '-' . self::TAGNAME_VERBOSE : '';

    2546. 

  2546. 		$styleString	= ($type === self::BUTTON_TYPE_HIDDEN) ? 'ezuser-' . self::BUTTON_TYPE_ACTION . " ezuser-$type" : "ezuser-$type";

    2547. 

  2547. 		$setButtonState	= 'ezUser.setButtonState';

    2548. 

  2548. 		$onClick	= 'ezUser.click';

    2549. 

  2549. 

    2550. 

  2550. 		return <<<HTML

    2551. 

  2551. 					type		=	"button"

    2552. 

  2552. 					class		=	"ezuser-button ezuser-$styleFloat $styleString$classVerbose ezuser-buttonstate-0"

    2553. 

  2553. 					onclick		=	"$onClick(this)"

    2554. 

  2554. 					onmouseover	=	"$setButtonState(this, 1, true)"

    2555. 

  2555. 					onmouseout	=	"$setButtonState(this, 1, false)"

    2556. 

  2556. 					onfocus		=	"$setButtonState(this, 2, true)"

    2557. 

  2557. 					onblur		=	"$setButtonState(this, 2, false)"

    2558. 

  2558. HTML;

    2559. 

  2559. 	}

    2560. 

  2560. 

    2561. 

  2561. 	private static /*.string.*/ function htmlMessage($message = '', $style = self::MESSAGE_STYLE_DEFAULT, $container = '', $type = self::MESSAGE_TYPE_DEFAULT, $styleFloat = self::STRING_RIGHT) {

    2562. 

  2562. 		$style		= ($message === '') ? 'hidden' : $style;

    2563. 

  2563. 		$message	= "<p class=\"ezuser-message-$style\">$message</p>";

    2564. 

  2564. 		$id		= ($container === '') ? "ezuser-$type" : "$container-$type";

    2565. 

  2565. 		$onClick	= 'ezUser.click';

    2566. 

  2566. 

    2567. 

  2567. 		return <<<HTML

    2568. 

  2568. 				<div id="$id" class="ezuser-$type ezuser-$styleFloat" onclick="$onClick(this)">$message</div>

    2569. 

  2569. HTML;

    2570. 

  2570. 	}

    2571. 

  2571. 

    2572. 

  2572. // ---------------------------------------------------------------------------

    2573. 

  2573. // Text versions of status and result codes

    2574. 

  2574. // ---------------------------------------------------------------------------

    2575. 

  2575. 	private static /*.string.*/ function statusText(/*.int.*/ $status, $more = '', $sendToBrowser = false) {

    2576. 

  2576. 		switch ($status) {

    2577. 

  2577. 			case self::STATUS_UNKNOWN:		$text = "Unknown status";				break;

    2578. 

  2578. 			case self::STATUS_PENDING:		$text = "Awaiting confirmation";			break;

    2579. 

  2579. 			case self::STATUS_CONFIRMED:		$text = "Confirmed and active";				break;

    2580. 

  2580. 			case self::STATUS_INACTIVE:		$text = "Inactive";					break;

    2581. 

  2581. 			default:				$text = "Unknown status code";				break;

    2582. 

  2582. 		}

    2583. 

  2583. 

    2584. 

  2584. 		if ($more !== '')	$text .= ": $more";

    2585. 

  2585. 		if ($sendToBrowser)	{self::sendContent($text); return '';} else return $text;

    2586. 

  2586. 	}

    2587. 

  2587. 

    2588. 

  2588. 	private static /*.string.*/ function statusDescription(/*.int.*/ $status, $more = '', $sendToBrowser = false) {

    2589. 

  2589. 		switch ($status) {

    2590. 

  2590. 			case self::STATUS_PENDING:		$text = "Your account has been created and a confirmation email has been sent. Please click on the link in the confirmation email to verify your account.";

    2591. 

  2591. 															break;

    2592. 

  2592. 			default:				$text = self::statusText($status);			break;

    2593. 

  2593. 		}

    2594. 

  2594. 

    2595. 

  2595. 		if ($more !== '')	$text .= ": $more";

    2596. 

  2596. 		if ($sendToBrowser)	{self::sendContent($text); return '';} else return $text;

    2597. 

  2597. 	}

    2598. 

  2598. 

    2599. 

  2599. 	private static /*.string.*/ function resultDescription(/*.int.*/ $result, $more = '', $sendToBrowser = false) {

    2600. 

  2600. 		switch ($result) {

    2601. 

  2601. 			case self::RESULT_EMAILFORMATERR:	$text = "The format of the email address you entered was incorrect. Email addresses should be in the form <em>joe.smith@example.com</em>";

    2602. 

  2602. 															break;

    2603. 

  2603. 			default:				$text = self::resultText($result);			break;

    2604. 

  2604. 		}

    2605. 

  2605. 

    2606. 

  2606. 		if ($more !== '')	$text .= ": $more";

    2607. 

  2607. 		if ($sendToBrowser)	{self::sendContent($text); return '';} else return $text;

    2608. 

  2608. 	}

    2609. 

  2609. 

    2610. 

  2610. // ---------------------------------------------------------------------------

    2611. 

  2611. // HTML for UI Forms

    2612. 

  2612. // ---------------------------------------------------------------------------

    2613. 

  2613. /**

    2614. 

  2614.  * Render the HTML for the account maintenance form

    2615. 

  2615.  *

    2616. 

  2616.  * $newUser indicates whether this is an existing user from the

    2617. 

  2617.  * database, or a new registration that we are processing. If the user

    2618. 

  2618.  * enters invalid data we might render this form a number of times

    2619. 

  2619.  * until validation is successful. $newUser should persist until

    2620. 

  2620.  * registration is successful.

    2621. 

  2621.  *

    2622. 

  2622.  * The form can also operate as a "wizard" (with Next and Back buttons). This

    2623. 

  2623.  * allows it to work in the confined space of the ezUser control panel

    2624. 

  2624.  *

    2625. 

  2625.  * This function is also driven by the mode parameter as follows:

    2626. 

  2626.  *

    2627. 

  2627.  * Mode		Behaviour

    2628. 

  2628.  * -------	--------------------------------------------------------------

    2629. 

  2629.  * - (none)	Infer mode from current ezUser object - if it's authenticated

    2630. 

  2630.  *		then display the account page for that user. If not then

    2631. 

  2631.  *		display a registration form for a new user. Inferred mode will

    2632. 

  2632.  *		be 'display' or 'new'

    2633. 

  2633.  *

    2634. 

  2634.  * - new	Register a new user. Input controls are blank but available.

    2635. 

  2635.  *		Button says Register.

    2636. 

  2636.  *

    2637. 

  2637.  * - display	View account details. Input controls are populated but

    2638. 

  2638.  *		unavailable. Button says Edit.

    2639. 

  2639.  *

    2640. 

  2640.  * - edit	Edit an existing account or correct a failed registration.

    2641. 

  2641.  *		Input controls are populated with existing data. Buttons say

    2642. 

  2642.  *		OK and Cancel

    2643. 

  2643.  *

    2644. 

  2644.  * - result	Infer actual mode from result of validation. If validated then

    2645. 

  2645.  *		display account details, otherwise allow them to be corrected.

    2646. 

  2646.  * 		Inferred mode will be either 'display' or 'edit'.

    2647. 

  2647.  *

    2648. 

  2648.  * - cancel	Infer actual mode from $newUser. If we're cancelling a new

    2649. 

  2649.  *		registration then clear the form. If we're cancelling editing

    2650. 

  2650.  *		an existing user then redisplay details from the database.

    2651. 

  2651.  * 		Inferred mode will be either 'new' or 'display'.

    2652. 

  2652.  *

    2653. 

  2653.  * So, the difference between $mode = 'new' and $newUser = true is as

    2654. 

  2654.  * follows:

    2655. 

  2655.  *

    2656. 

  2656.  * - $mode = 'new'	means this is a blank form for a new registration

    2657. 

  2657.  *

    2658. 

  2658.  * - $newUser = true	means we are processing a new registration but we

    2659. 

  2659.  *			might be asking the user to re-enter certain values:

    2660. 

  2660.  *			the form might therefore need to be populated with the

    2661. 

  2661.  *			attempted registration details.

    2662. 

  2662.  *

    2663. 

  2663.  * @param string	$mode		See above

    2664. 

  2664.  * @param boolean	$newUser	Is this a new or existing user?

    2665. 

  2665.  * @param boolean	$wizard		Display as a wizard within control panel

    2666. 

  2666.  * @param boolean	$sendToBrowser	Send HTML to browser?

    2667. 

  2667.  */

    2668. 

  2668. 	private static /*.string.*/ function htmlAccountForm($mode = '', $newUser = false, $wizard = false, $sendToBrowser = false) {

    2669. 

  2669. 		/* Comment out profiling statements if not needed

    2670. 

  2670. 		global $ezuser_profile;

    2671. 

  2671. 		$ezuser_profile[self::ACTION_ACCOUNT . '-start'] = ezuser_time();

    2672. 

  2672. 		*/

    2673. 

  2673. 

    2674. 

  2674. 		$action			= self::ACTION_ACCOUNT;

    2675. 

  2675. 		$actionResend		= self::ACTION_RESEND;

    2676. 

  2676. 		$actionValidate		= self::ACTION_VALIDATE;

    2677. 

  2677. 		$accountForm		= self::getInstanceId($action);

    2678. 

  2678. 		$container		= ($wizard) ? 'ezuser' : $accountForm;

    2679. 

  2679. 

    2680. 

  2680. 		$tagFirstName		= self::TAGNAME_FIRSTNAME;

    2681. 

  2681. 		$tagLastName		= self::TAGNAME_LASTNAME;

    2682. 

  2682. 		$tagEmail		= self::TAGNAME_EMAIL;

    2683. 

  2683. 		$tagUsername		= self::TAGNAME_USERNAME;

    2684. 

  2684. 		$tagPassword		= self::TAGNAME_PASSWORD;

    2685. 

  2685. 		$tagConfirm		= self::TAGNAME_CONFIRM;

    2686. 

  2686. 		$tagNewUser		= self::TAGNAME_NEWUSER;

    2687. 

  2687. 		$tagUseSavedPassword	= self::TAGNAME_SAVEDPASSWORD;

    2688. 

  2688. 		$tagWizard		= self::TAGNAME_WIZARD;

    2689. 

  2689. 

    2690. 

  2690. 		$modeNew		= self::ACCOUNT_MODE_NEW;

    2691. 

  2691. 		$modeEdit		= self::ACCOUNT_MODE_EDIT;

    2692. 

  2692. 		$modeDisplay		= self::ACCOUNT_MODE_DISPLAY;

    2693. 

  2693. 		$modeResult		= self::ACCOUNT_MODE_RESULT;

    2694. 

  2694. 		$modeCancel		= self::ACCOUNT_MODE_CANCEL;

    2695. 

  2695. 

    2696. 

  2696. 		$stringRight		= self::STRING_RIGHT;

    2697. 

  2697. 		$htmlButtonAction	= self::htmlButton(self::BUTTON_TYPE_ACTION);

    2698. 

  2698. 		$htmlButtonHidden	= self::htmlButton(self::BUTTON_TYPE_HIDDEN);

    2699. 

  2699. 		$passwordOnFocus	= 'ezUser.passwordFocus';

    2700. 

  2700. 		$passwordOnBlur		= 'ezUser.passwordBlur';

    2701. 

  2701. 		$htmlInputText		= self::htmlInputText();

    2702. 

  2702. 		$messageShort		= self::htmlMessage('* reqd', self::MESSAGE_STYLE_PLAIN, $accountForm);

    2703. 

  2703. 		$resendButton		= '';

    2704. 

  2704. 

    2705. 

  2705. 		if (!isset($mode) || empty($mode)) $mode = '';

    2706. 

  2706. 

    2707. 

  2707. 		$modeInfo		= ($newUser) ? self::STRING_TRUE : self::STRING_FALSE;

    2708. 

  2708. 		$modeInfo		= "(originally mode was '$mode', new flag was $modeInfo) -->";

    2709. 

  2709. 

    2710. 

  2710. 		if ($mode === '') {

    2711. 

  2711. 			$ezUser	= self::getSessionObject();

    2712. 

  2712. 			$result	= self::RESULT_SUCCESS;

    2713. 

  2713. 

    2714. 

  2714. 			if ($ezUser->authenticated()) {

    2715. 

  2715. 				$mode	= $modeDisplay;

    2716. 

  2716. 				$ezUser->addSignOutAction($action);

    2717. 

  2717. 				self::setSessionObject($ezUser, $action);

    2718. 

  2718. 			} else {

    2719. 

  2719. 				$mode	= $modeNew;

    2720. 

  2720. 				$ezUser->clearSignOutActions();

    2721. 

  2721. 			}

    2722. 

  2722. 		} else {

    2723. 

  2723. 			$ezUser	= self::getSessionObject($action);

    2724. 

  2724. 			$result	= $ezUser->result();

    2725. 

  2725. 		}

    2726. 

  2726. 

    2727. 

  2727. 		if ($mode === $modeCancel) $ezUser->clearErrors();

    2728. 

  2728. 

    2729. 

  2729. 		// Some raw logic - think carefully about these lines before amending

    2730. 

  2730. 		if (!isset($newUser))		$newUser	= false;

    2731. 

  2731. 		if ($mode === $modeNew)		$newUser	= true;

    2732. 

  2732. 		if ($mode === $modeCancel)	$mode		= ($newUser)				? $modeNew	: $modeDisplay;

    2733. 

  2733. 		if ($mode === $modeResult)	$mode		= ($result === self::RESULT_SUCCESS)	? $modeDisplay	: $modeEdit;

    2734. 

  2734. 

    2735. 

  2735. 

    2736. 

  2736. 		switch ($mode) {

    2737. 

  2737. 		case self::ACCOUNT_MODE_NEW:

    2738. 

  2738. 			$email			= '';

    2739. 

  2739. 			$firstName		= '';

    2740. 

  2740. 			$lastName		= '';

    2741. 

  2741. 			$username		= '';

    2742. 

  2742. 			$password		= '';

    2743. 

  2743. 

    2744. 

  2744. 			$buttonId		= $actionValidate;

    2745. 

  2745. 			$buttonText		= 'Register';

    2746. 

  2746. 			$buttonAction		= $actionValidate;

    2747. 

  2747. 			$disabled		= '';

    2748. 

  2748. 			$htmlOtherButton	= "\t\t\t\t<input id=\"$accountForm-$modeCancel\" data-ezuser-action=\"$action=$modeCancel\" value=\"Cancel\"\n\t\t\t\t\ttabindex\t=\t\"3219\"\n$htmlButtonAction\n\t\t\t\t/>\n";

    2749. 

  2749. 			$useSavedPassword	= false;

    2750. 

  2750. 			$messageLong		= self::htmlMessage('', self::MESSAGE_STYLE_TEXT, $accountForm, self::MESSAGE_TYPE_TEXT);

    2751. 

  2751. 			break;

    2752. 

  2752. 		case self::ACCOUNT_MODE_DISPLAY:

    2753. 

  2753. 			$errors			= $ezUser->errors();

    2754. 

  2754. 

    2755. 

  2755. 			$email			= (array_key_exists(self::TAGNAME_EMAIL, $errors))	? $errors[self::TAGNAME_EMAIL]		: $ezUser->email();

    2756. 

  2756. 			$firstName		= (array_key_exists(self::TAGNAME_FIRSTNAME, $errors))	? $errors[self::TAGNAME_FIRSTNAME]	: $ezUser->firstName();

    2757. 

  2757. 			$lastName		= (array_key_exists(self::TAGNAME_LASTNAME, $errors))	? $errors[self::TAGNAME_LASTNAME]	: $ezUser->lastName();

    2758. 

  2758. 			$username		= (array_key_exists(self::TAGNAME_USERNAME, $errors))	? $errors[self::TAGNAME_USERNAME]	: $ezUser->username();

    2759. 

  2759. 			$password		= ($ezUser->passwordHash() === '') ? '' : self::PASSWORD_MASK;

    2760. 

  2760. 

    2761. 

  2761. 			$buttonId		= $modeEdit;

    2762. 

  2762. 			$buttonText		= 'Edit';

    2763. 

  2763. 			$buttonAction		= "$action=$modeEdit";

    2764. 

  2764. 			$disabled		= "\t\t\t\t\tdisabled\t=\t\"disabled\"\r\n";

    2765. 

  2765. 			$htmlOtherButton	= "\t\t\t\t<input id=\"$accountForm-$modeNew\" data-ezuser-action=\"$action=$modeNew\" value=\"New\"\n\t\t\t\t\ttabindex\t=\t\"3219\"\n$htmlButtonAction\n\t\t\t\t/>\n";

    2766. 

  2766. 			$useSavedPassword	= false;

    2767. 

  2767. 			$newUser		= false;

    2768. 

  2768. 

    2769. 

  2769. 			if ($result === self::RESULT_SUCCESS || $result === self::RESULT_UNDEFINED) {

    2770. 

  2770. 				// Show status information

    2771. 

  2771. 				$status		= $ezUser->status();

    2772. 

  2772. 				$messageLong	= ($status === self::STATUS_CONFIRMED) ? '' : self::statusDescription($status);

    2773. 

  2773. 				$messageLong	= self::htmlMessage($messageLong, self::MESSAGE_STYLE_TEXT, $accountForm, self::MESSAGE_TYPE_TEXT);

    2774. 

  2774. 

    2775. 

  2775. 				if ($status === self::STATUS_PENDING) $resendButton = "\n\t\t\t\t<input id=\"$accountForm-$actionResend\" data-ezuser-action=\"$actionResend\" value=\"Resend\"\n\t\t\t\t\ttabindex\t=\t\"3219\"\n$htmlButtonAction\n\t\t\t\t/>";

    2776. 

  2776. 			} else {

    2777. 

  2777. 				// Show result information

    2778. 

  2778. 				$messageLong	= self::resultDescription($result);

    2779. 

  2779. 				$messageLong	= self::htmlMessage($messageLong, self::MESSAGE_STYLE_FAIL, $accountForm, self::MESSAGE_TYPE_TEXT);

    2780. 

  2780. 			}

    2781. 

  2781. 

    2782. 

  2782. 			break;

    2783. 

  2783. 		case self::ACCOUNT_MODE_EDIT:

    2784. 

  2784. 			$errors			= $ezUser->errors();

    2785. 

  2785. 

    2786. 

  2786. 			$email			= (array_key_exists(self::TAGNAME_EMAIL,	$errors)) ? $errors[self::TAGNAME_EMAIL]	: $ezUser->email();

    2787. 

  2787. 			$firstName		= (array_key_exists(self::TAGNAME_FIRSTNAME,	$errors)) ? $errors[self::TAGNAME_FIRSTNAME]	: $ezUser->firstName();

    2788. 

  2788. 			$lastName		= (array_key_exists(self::TAGNAME_LASTNAME,	$errors)) ? $errors[self::TAGNAME_LASTNAME]	: $ezUser->lastName();

    2789. 

  2789. 			$username		= (array_key_exists(self::TAGNAME_USERNAME,	$errors)) ? $errors[self::TAGNAME_USERNAME]	: $ezUser->username();

    2790. 

  2790. 			$password		= ($ezUser->passwordHash() === '') ? '' : self::PASSWORD_MASK;

    2791. 

  2791. 

    2792. 

  2792. 			$buttonId		= $actionValidate;

    2793. 

  2793. 			$buttonText		= 'OK';

    2794. 

  2794. 			$buttonAction		= $actionValidate;

    2795. 

  2795. 			$disabled		= '';

    2796. 

  2796. 			$htmlOtherButton	= "\t\t\t\t<input id=\"$accountForm-$modeCancel\" data-ezuser-action=\"$action=$modeCancel\" value=\"Cancel\"\n\t\t\t\t\ttabindex\t=\t\"3219\"\n$htmlButtonAction\n\t\t\t\t/>\n";

    2797. 

  2797. 			$useSavedPassword	= $newUser;

    2798. 

  2798. 

    2799. 

  2799. 			if ($result === self::RESULT_SUCCESS || $result === self::RESULT_UNDEFINED) {

    2800. 

  2800. 				$messageLong	= self::htmlMessage('', self::MESSAGE_STYLE_TEXT, $accountForm, self::MESSAGE_TYPE_TEXT);

    2801. 

  2801. 			} else {

    2802. 

  2802. 				// Show result information

    2803. 

  2803. 				$messageLong	= self::resultDescription($result);

    2804. 

  2804. 				$messageLong	= self::htmlMessage($messageLong, self::MESSAGE_STYLE_FAIL, $accountForm, self::MESSAGE_TYPE_TEXT);

    2805. 

  2805. 			}

    2806. 

  2806. 

    2807. 

  2807. 			break;

    2808. 

  2808. 		default:

    2809. 

  2809. 			$useSavedPassword	= false;

    2810. 

  2810. 			$email			= '';

    2811. 

  2811. 			$disabled		= '';

    2812. 

  2812. 			$firstName		= '';

    2813. 

  2813. 			$lastName		= '';

    2814. 

  2814. 			$username		= '';

    2815. 

  2815. 			$password		= '';

    2816. 

  2816. 			$buttonId		= '';

    2817. 

  2817. 			$buttonAction		= '';

    2818. 

  2818. 			$buttonText		= '';

    2819. 

  2819. 			$htmlOtherButton	= '';

    2820. 

  2820. 			$messageLong		= '';

    2821. 

  2821. 			break;

    2822. 

  2822. 		}

    2823. 

  2823. 

    2824. 

  2824. 		// Some hidden form elements

    2825. 

  2825. 		$newString		= ($newUser)		? self::STRING_TRUE : self::STRING_FALSE;

    2826. 

  2826. 		$useSavedPasswordString	= ($useSavedPassword)	? self::STRING_TRUE : self::STRING_FALSE;

    2827. 

  2827. 		$modeInfo		= "<!-- Mode is '$mode', new flag is $newString $modeInfo";

    2828. 

  2828. 

    2829. 

  2829. 		// Form varies slightly if it's working in wizard mode

    2830. 

  2830. 		if ($wizard) {

    2831. 

  2831. 			$wizardString	= self::STRING_TRUE;

    2832. 

  2832. 			$styleHidden	= ' ezuser-hidden';

    2833. 

  2833. 			$htmlNavigation = <<<HTML

    2834. 

  2834. 				<input id="$accountForm-next" data-ezuser-action="next" value="Next &gt;"

    2835. 

  2835. 					tabindex	=	"3218"

    2836. 

  2836. $htmlButtonAction

    2837. 

  2837. 				/>

    2838. 

  2838. 				<input id="$accountForm-back" data-ezuser-action="back" value="&lt; Back"

    2839. 

  2839. 					tabindex	=	"3217"

    2840. 

  2840. $htmlButtonHidden

    2841. 

  2841. 				/>

    2842. 

  2842. HTML;

    2843. 

  2843. 		} else {

    2844. 

  2844. 			$wizardString	= self::STRING_FALSE;

    2845. 

  2845. 			$styleHidden	= '';

    2846. 

  2846. 			$htmlNavigation = '';

    2847. 

  2847. 		}

    2848. 

  2848. 

    2849. 

  2849. 		// The lower two fieldsets are transposed if we're in wizard mode

    2850. 

  2850. 		$messageFieldset = <<<HTML

    2851. 

  2851. 			<fieldset id="$accountForm-fieldset-3" class="ezuser-fieldset$styleHidden">

    2852. 

  2852. $messageLong$resendButton

    2853. 

  2853. 				<input id="$accountForm-$tagNewUser"		type="hidden" value="$newString" />

    2854. 

  2854. 				<input id="$accountForm-$tagWizard"		type="hidden" value="$wizardString" />

    2855. 

  2855. 				<input id="$accountForm-$tagUseSavedPassword"	type="hidden" value="$useSavedPasswordString" />

    2856. 

  2856. 			</fieldset>

    2857. 

  2857. 

    2858. 

  2858. HTML;

    2859. 

  2859. 

    2860. 

  2860. 		$buttonsFieldset = <<<HTML

    2861. 

  2861. 			<fieldset class="ezuser-fieldset">

    2862. 

  2862. $messageShort

    2863. 

  2863. 				<input id="$accountForm-$buttonId" data-ezuser-action="$buttonAction" value="$buttonText"

    2864. 

  2864. 					tabindex	=	"3220"

    2865. 

  2865. $htmlButtonAction

    2866. 

  2866. 				/>

    2867. 

  2867. $htmlOtherButton$htmlNavigation			</fieldset>

    2868. 

  2868. 

    2869. 

  2869. HTML;

    2870. 

  2870. 

    2871. 

  2871. 		$bottomFieldsets = ($wizard) ? "$messageFieldset$buttonsFieldset" : "$buttonsFieldset$messageFieldset";

    2872. 

  2872. 

    2873. 

  2873. 		// At this point we have finished with the result of any prior validation

    2874. 

  2874. 		// so we can clear the result field

    2875. 

  2875. 		$ezUser->setResult(self::RESULT_UNDEFINED);

    2876. 

  2876. 

    2877. 

  2877. 		$html = <<<HTML

    2878. 

  2878. 		$modeInfo

    2879. 

  2879. 		<form id="$accountForm-form" class="ezuser-form" onsubmit="return false">

    2880. 

  2880. 			<fieldset id="$accountForm-fieldset-1" class="ezuser-fieldset">

    2881. 

  2881. 				<input id= "$accountForm-$tagEmail"

    2882. 

  2882. 					tabindex	=	"3211"

    2883. 

  2883. 					value		=	"$email"

    2884. 

  2884. 					type		=	"text"

    2885. 

  2885. $disabled$htmlInputText

    2886. 

  2886. 				/>

    2887. 

  2887. 				<label class="ezuser-label ezuser-$stringRight" for="$accountForm-$tagEmail">* Email address:</label>

    2888. 

  2888. 				<input id= "$accountForm-$tagFirstName"

    2889. 

  2889. 					tabindex	=	"3212"

    2890. 

  2890. 					value		=	"$firstName"

    2891. 

  2891. 					type		=	"text"

    2892. 

  2892. $disabled$htmlInputText

    2893. 

  2893. 				/>

    2894. 

  2894. 				<label class="ezuser-label ezuser-$stringRight" for="$accountForm-$tagFirstName">First name:</label>

    2895. 

  2895. 				<input id= "$accountForm-$tagLastName"

    2896. 

  2896. 					tabindex	=	"3213"

    2897. 

  2897. 					value		=	"$lastName"

    2898. 

  2898. 					type		=	"text"

    2899. 

  2899. $disabled$htmlInputText

    2900. 

  2900. 				/>

    2901. 

  2901. 				<label class="ezuser-label ezuser-$stringRight" for="$accountForm-$tagLastName">Last name:</label>

    2902. 

  2902. 			</fieldset>

    2903. 

  2903. 			<fieldset id="$accountForm-fieldset-2" class="ezuser-fieldset$styleHidden">

    2904. 

  2904. 				<input id= "$accountForm-$tagUsername"

    2905. 

  2905. 					tabindex	=	"3214"

    2906. 

  2906. 					value		=	"$username"

    2907. 

  2907. 					type		=	"text"

    2908. 

  2908. 					onkeypress	=	"return ezUser.keyPress(event)"

    2909. 

  2909. $disabled$htmlInputText

    2910. 

  2910. 				/>

    2911. 

  2911. 				<label class="ezuser-label ezuser-$stringRight" for="$accountForm-$tagUsername">* Username:</label>

    2912. 

  2912. 				<input id= "$accountForm-$tagPassword"

    2913. 

  2913. 					tabindex	=	"3215"

    2914. 

  2914. 					value		=	"$password"

    2915. 

  2915. 					type		=	"password"

    2916. 

  2916. 					onfocus		=	"$passwordOnFocus(this)"

    2917. 

  2917. 					onblur		=	"$passwordOnBlur(this)"

    2918. 

  2918. $disabled$htmlInputText

    2919. 

  2919. 				/>

    2920. 

  2920. 				<label class="ezuser-label ezuser-$stringRight" for="$accountForm-$tagPassword">* Password:</label>

    2921. 

  2921. 				<input id= "$accountForm-confirm"

    2922. 

  2922. 					tabindex	=	"3216"

    2923. 

  2923. 					value		=	"$password"

    2924. 

  2924. 					type		=	"password"

    2925. 

  2925. 					onfocus		=	"$passwordOnFocus(this)"

    2926. 

  2926. 					onblur		=	"$passwordOnBlur(this)"

    2927. 

  2927. $disabled$htmlInputText

    2928. 

  2928. 				/>

    2929. 

  2929. 				<label class="ezuser-label ezuser-$stringRight" for="$accountForm-$tagConfirm">* Confirm password:</label>

    2930. 

  2930. 			</fieldset>

    2931. 

  2931. $bottomFieldsets		</form>

    2932. 

  2932. HTML;

    2933. 

  2933. 

    2934. 

  2934. 		/* Comment out profiling statements if not needed

    2935. 

  2935. 		$ezuser_profile[self::ACTION_ACCOUNT . '-end'] = ezuser_time();

    2936. 

  2936. 		*/

    2937. 

  2937. 

    2938. 

  2938. 		if ($sendToBrowser) {self::sendXML($html, $container); return '';} else return $html;

    2939. 

  2939. 	}

    2940. 

  2940. 

    2941. 

  2941. // ---------------------------------------------------------------------------

    2942. 

  2942. 	private static /*.string.*/ function htmlDashboard($sendToBrowser = false) {

    2943. 

  2943. 		$action			= self::ACTION_DASHBOARD;

    2944. 

  2944. 		$actionSignOut		= self::ACTION_SIGNOUT;

    2945. 

  2945. 		$actionAccountForm	= self::ACTION_ACCOUNTFORM;

    2946. 

  2946. 		$tagFullName		= self::TAGNAME_FULLNAME;

    2947. 

  2947. 		$htmlButtonPreference	= self::htmlButton(self::BUTTON_TYPE_PREFERENCE);

    2948. 

  2948. 		$message		= self::htmlMessage();

    2949. 

  2949. 		$ezUser			= self::getSessionObject();

    2950. 

  2950. 		$fullName		= $ezUser->fullName();

    2951. 

  2951. 

    2952. 

  2952. 		$html = <<<HTML

    2953. 

  2953. 		<form id="ezuser-$action-form" class="ezuser-form" onsubmit="return false">

    2954. 

  2954. 			<fieldset class="ezuser-fieldset">

    2955. 

  2955. 				<input id="ezuser-$actionSignOut" data-ezuser-action="$actionSignOut" value="Sign out"

    2956. 

  2956. 					tabindex	=	"3222"

    2957. 

  2957. $htmlButtonPreference

    2958. 

  2958. 				/>

    2959. 

  2959. 				<input id="ezuser-$actionAccountForm" data-ezuser-action="$actionAccountForm" value="My account"

    2960. 

  2960. 					tabindex	=	"3221"

    2961. 

  2961. $htmlButtonPreference

    2962. 

  2962. 				/>

    2963. 

  2963. 				<div id="ezuser-$tagFullName" class="ezuser-$tagFullName">$fullName</div>

    2964. 

  2964. 			</fieldset>

    2965. 

  2965. 			<fieldset class="ezuser-fieldset">

    2966. 

  2966. $message

    2967. 

  2967. 			</fieldset>

    2968. 

  2968. 		</form>

    2969. 

  2969. HTML;

    2970. 

  2970. 

    2971. 

  2971. 		if ($sendToBrowser) {self::sendXML($html); return '';} else return $html;

    2972. 

  2972. 	}

    2973. 

  2973. 

    2974. 

  2974. // ---------------------------------------------------------------------------

    2975. 

  2975. 	private static /*.string.*/ function htmlSignInForm($username = '', $sendToBrowser = false) {

    2976. 

  2976. 		$verbose		= false;	// Set to true to let the user see detailed result information (recommended setting is false)

    2977. 

  2977. //$verbose = true; // debug

    2978. 

  2978. 

    2979. 

  2979. 		$action			= self::ACTION_SIGNIN;

    2980. 

  2980. 		$actionAccountForm	= self::ACTION_ACCOUNTFORM;

    2981. 

  2981. 		$actionResetRequest	= self::ACTION_RESETREQUEST;

    2982. 

  2982. 		$actionBitmap		= self::ACTION_BITMAP;

    2983. 

  2983. 		$tagUsername		= self::TAGNAME_USERNAME;

    2984. 

  2984. 		$tagPassword		= self::TAGNAME_PASSWORD;

    2985. 

  2985. 		$tagRememberMe		= self::TAGNAME_REMEMBERME;

    2986. 

  2986. 		$tagStaySignedIn	= self::TAGNAME_STAYSIGNEDIN;

    2987. 

  2987. 		$tagVerbose		= self::TAGNAME_VERBOSE;

    2988. 

  2988. 

    2989. 

  2989. 		$stringRight		= self::STRING_RIGHT;

    2990. 

  2990. 		$htmlButtonAction	= self::htmlButton(self::BUTTON_TYPE_ACTION);

    2991. 

  2991. 		$htmlButtonPreference	= self::htmlButton(self::BUTTON_TYPE_PREFERENCE);

    2992. 

  2992. 		$passwordOnFocus	= 'ezUser.passwordFocus';

    2993. 

  2993. 		$passwordOnBlur		= 'ezUser.passwordBlur';

    2994. 

  2994. 		$htmlInputText		= self::htmlInputText();

    2995. 

  2995. 		$ezUser			= self::getSessionObject();

    2996. 

  2996. 		$result			= $ezUser->result();

    2997. 

  2997. 		$URL			= self::thisURL();

    2998. 

  2998. 

    2999. 

  2999. 		if ($result <= self::RESULT_SUCCESS) {

    3000. 

  3000. 			$message = self::htmlMessage();

    3001. 

  3001. 			$verboseHTML = "";

    3002. 

  3002. 		} else {

    3003. 

  3003. 			$ezUser->setResult(self::RESULT_UNDEFINED);

    3004. 

  3004. 			$username = $ezUser->username();

    3005. 

  3005. 			$message = self::htmlMessage("Check username &amp; password", self::MESSAGE_STYLE_FAIL);

    3006. 

  3006. 

    3007. 

  3007. 			if ($verbose) {

    3008. 

  3008. 				$verboseHTML = self::htmlButton(self::BUTTON_TYPE_PREFERENCE, $stringRight, true);

    3009. 

  3009. 				$verboseHTML = <<<HTML

    3010. 

  3010. 				<input id="ezuser-$tagVerbose" value="$result"

    3011. 

  3011. $verboseHTML

    3012. 

  3012. 				/>

    3013. 

  3013. HTML;

    3014. 

  3014. 			} else {

    3015. 

  3015. 				$verboseHTML = '';

    3016. 

  3016. 			}

    3017. 

  3017. 		}

    3018. 

  3018. 

    3019. 

  3019. 		$password = '';

    3020. 

  3020. 

    3021. 

  3021. 		$html = <<<HTML

    3022. 

  3022. 		<img id="ezuser-close" class="ezuser-dialog-control" src="$URL?$actionBitmap=close" onclick="ezUser.click(this)" />

    3023. 

  3023. 		<form id="ezuser-$action-form" class="ezuser-form" onsubmit="return false">

    3024. 

  3024. 			<fieldset class="ezuser-fieldset">

    3025. 

  3025. 				<input id= "ezuser-$tagUsername"

    3026. 

  3026. 					tabindex	=	"3201"

    3027. 

  3027. 					value		=	"$username"

    3028. 

  3028. 					type		=	"text"

    3029. 

  3029. $htmlInputText

    3030. 

  3030. 				/>

    3031. 

  3031. 				<label class="ezuser-label ezuser-$stringRight" for="ezuser-$tagUsername">Username:</label>

    3032. 

  3032. 				<input id= "ezuser-$tagPassword"

    3033. 

  3033. 					tabindex	=	"3202"

    3034. 

  3034. 					value		=	"$password"

    3035. 

  3035. 					type		=	"password"

    3036. 

  3036. 					onfocus		=	"$passwordOnFocus(this)"

    3037. 

  3037. 					onblur		=	"$passwordOnBlur(this)"

    3038. 

  3038. $htmlInputText

    3039. 

  3039. 				/>

    3040. 

  3040. 				<label class="ezuser-label ezuser-$stringRight" for="ezuser-$tagPassword">Password:</label>

    3041. 

  3041. $verboseHTML			</fieldset>

    3042. 

  3042. 			<fieldset class="ezuser-fieldset">

    3043. 

  3043. $message

    3044. 

  3044. 				<input id="ezuser-$actionAccountForm" data-ezuser-action="$actionAccountForm" value="Register"

    3045. 

  3045. 					tabindex	=	"3204"

    3046. 

  3046. $htmlButtonAction

    3047. 

  3047. 				/>

    3048. 

  3048. 				<input id="ezuser-$action" data-ezuser-action="$action" value="Sign in"

    3049. 

  3049. 					tabindex	=	"3203"

    3050. 

  3050. $htmlButtonAction

    3051. 

  3051. 				/>

    3052. 

  3052. 			</fieldset>

    3053. 

  3053. 			<fieldset class="ezuser-fieldset">

    3054. 

  3054. 				<input id="ezuser-$tagStaySignedIn" value="Stay signed in"

    3055. 

  3055. 					tabindex	=	"3207"

    3056. 

  3056. $htmlButtonPreference

    3057. 

  3057. 				/>

    3058. 

  3058. 				<input id="ezuser-$tagRememberMe" value="Remember me"

    3059. 

  3059. 					tabindex	=	"3206"

    3060. 

  3060. $htmlButtonPreference

    3061. 

  3061. 				/>

    3062. 

  3062. 				<input id="ezuser-$actionResetRequest" data-ezuser-action="$actionResetRequest" value="Reset password"

    3063. 

  3063. 					tabindex	=	"3205"

    3064. 

  3064. $htmlButtonPreference

    3065. 

  3065. 				/>

    3066. 

  3066. 			</fieldset>

    3067. 

  3067. 		</form>

    3068. 

  3068. HTML;

    3069. 

  3069. 

    3070. 

  3070. 		if ($sendToBrowser) {self::sendXML($html); return '';} else return $html;

    3071. 

  3071. 	}

    3072. 

  3072. 

    3073. 

  3073. // ---------------------------------------------------------------------------

    3074. 

  3074. 	private static /*.string.*/ function htmlControlPanel($username = '', $sendToBrowser = false) {

    3075. 

  3075. 		$ezUser = self::getSessionObject();

    3076. 

  3076. 		$html = ($ezUser->authenticated()) ? self::htmlDashboard() : self::htmlSignInForm($username);

    3077. 

  3077. 		if ($sendToBrowser) {self::sendXML($html); return '';} else return $html;

    3078. 

  3078. 	}

    3079. 

  3079. 

    3080. 

  3080. // ---------------------------------------------------------------------------

    3081. 

  3081. 	private static /*.string.*/ function htmlResetRequest ($username = '', $sendToBrowser = false) {

    3082. 

  3082. 		$action			= self::ACTION_RESETREQUEST;

    3083. 

  3083. 		$actionCancel		= self::ACTION_CANCEL;

    3084. 

  3084. 		$actionResetPassword	= self::ACTION_RESETPASSWORD;

    3085. 

  3085. 		$actionMain		= self::ACTION_MAIN;

    3086. 

  3086. 		$tagUsername		= self::TAGNAME_USERNAME;

    3087. 

  3087. 		$htmlButtonPreference	= self::htmlButton(self::BUTTON_TYPE_PREFERENCE);

    3088. 

  3088. 		$stringLeft		= self::STRING_LEFT;

    3089. 

  3089. 		$htmlInputText		= self::htmlInputText($stringLeft);

    3090. 

  3090. 

    3091. 

  3091. 		$html = <<<HTML

    3092. 

  3092. 		<form id="ezuser-$action-form" class="ezuser-form" onsubmit="return false">

    3093. 

  3093. 			<fieldset class="ezuser-fieldset-float">

    3094. 

  3094. 					<label class="ezuser-label ezuser-$stringLeft" for="ezuser-$tagUsername">Username or email address:</label>

    3095. 

  3095. 					<input style="clear:both;" id="ezuser-$tagUsername"

    3096. 

  3096. 					tabindex	=	"3241"

    3097. 

  3097. 					value		=	"$username"

    3098. 

  3098. 					type		=	"text"

    3099. 

  3099. $htmlInputText

    3100. 

  3100. 				/>

    3101. 

  3101. 			</fieldset>

    3102. 

  3102. 			<fieldset class="ezuser-fieldset">

    3103. 

  3103. 				<input id="ezuser-$actionCancel" data-ezuser-action="$actionMain" value="Cancel"

    3104. 

  3104. 					tabindex	=	"3243"

    3105. 

  3105. $htmlButtonPreference

    3106. 

  3106. 				/>

    3107. 

  3107. 				<input id="ezuser-$actionResetPassword" data-ezuser-action="$actionResetPassword" value="Reset password"

    3108. 

  3108. 					tabindex	=	"3242"

    3109. 

  3109. $htmlButtonPreference

    3110. 

  3110. 				/>

    3111. 

  3111. 			</fieldset>

    3112. 

  3112. 		</form>

    3113. 

  3113. HTML;

    3114. 

  3114. 

    3115. 

  3115. 		if ($sendToBrowser) {self::sendXML($html); return '';} else return $html;

    3116. 

  3116. 	}

    3117. 

  3117. 

    3118. 

  3118. /**

    3119. 

  3119.  * Password reset form (& confirmation form below)

    3120. 

  3120.  *

    3121. 

  3121.  * This function is slightly different as it send the HTML for an entire

    3122. 

  3122.  * page, rather than the contents of a DIV. This is because this form

    3123. 

  3123.  * is displayed in response to the user clicking on a link in an email.

    3124. 

  3124.  * We have no context in which to display it and no knowledge of the

    3125. 

  3125.  * site that ezUser is living in, so we are forced to display a bare page.

    3126. 

  3126.  *

    3127. 

  3127.  * @param boolean $sendToBrowser

    3128. 

  3128.  */

    3129. 

  3129. 	private static /*.string.*/ function htmlResetPassword (ezUser_base $ezUser, $sendToBrowser = false) {

    3130. 

  3130. 		$action			= self::ACTION_RESET;

    3131. 

  3131. 		$tagPassword		= self::TAGNAME_PASSWORD;

    3132. 

  3132. 		$tagConfirm		= self::TAGNAME_CONFIRM;

    3133. 

  3133. 		$container		= self::getInstanceId($action);

    3134. 

  3134. 		$htmlInputText		= self::htmlInputText();

    3135. 

  3135. 		$htmlButtonPreference	= self::htmlButton(self::BUTTON_TYPE_ACTION);

    3136. 

  3136. 		$stringRight		= self::STRING_RIGHT;

    3137. 

  3137. 		$passwordOnFocus	= 'ezUser.passwordFocus';

    3138. 

  3138. 		$passwordOnBlur		= 'ezUser.passwordBlur';

    3139. 

  3139. 		$fullName		= $ezUser->fullName();

    3140. 

  3140. 		$message		= self::htmlMessage('', self::MESSAGE_STYLE_PLAIN, 'ezuser', self::MESSAGE_TYPE_TEXT);

    3141. 

  3141. 

    3142. 

  3142. 		$html = <<<HTML

    3143. 

  3143. 	<div id="ezuser">

    3144. 

  3144. 		<h4 class="ezuser-heading">Welcome $fullName</h4>

    3145. 

  3145. 		<p class="ezuser-message-plain">Please enter a new password for your account:</p>

    3146. 

  3146. 		<form id="$container-form" class="ezuser-form" onsubmit="return false">

    3147. 

  3147. 			<fieldset class="ezuser-fieldset">

    3148. 

  3148. 				<input id= "$container-$tagPassword"

    3149. 

  3149. 					tabindex	=	"3241"

    3150. 

  3150. 					value		=	""

    3151. 

  3151. 					type		=	"password"

    3152. 

  3152. 					onfocus		=	"$passwordOnFocus(this)"

    3153. 

  3153. 					onblur		=	"$passwordOnBlur(this)"

    3154. 

  3154. $htmlInputText

    3155. 

  3155. 				/>

    3156. 

  3156. 				<label class="ezuser-label ezuser-$stringRight" for="$container-$tagPassword">Password:</label>

    3157. 

  3157. 				<input id= "$container-confirm"

    3158. 

  3158. 					tabindex	=	"3242"

    3159. 

  3159. 					value		=	""

    3160. 

  3160. 					type		=	"password"

    3161. 

  3161. 					onfocus		=	"$passwordOnFocus(this)"

    3162. 

  3162. 					onblur		=	"$passwordOnBlur(this)"

    3163. 

  3163. $htmlInputText

    3164. 

  3164. 				/>

    3165. 

  3165. 				<label class="ezuser-label ezuser-$stringRight" for="$container-$tagConfirm">Confirm password:</label>

    3166. 

  3166. 			</fieldset>

    3167. 

  3167. 			<fieldset class="ezuser-fieldset">

    3168. 

  3168. 				<input id="$container-OK" data-ezuser-action="$action" value="OK"

    3169. 

  3169. 					tabindex	=	"3243"

    3170. 

  3170. $htmlButtonPreference

    3171. 

  3171. 				/>

    3172. 

  3172. 			</fieldset>

    3173. 

  3173. 			<fieldset class="ezuser-fieldset">

    3174. 

  3174. $message

    3175. 

  3175. 			</fieldset>

    3176. 

  3176. 		</form>

    3177. 

  3177. 	</div>

    3178. 

  3178. HTML;

    3179. 

  3179. 

    3180. 

  3180. 		$html = self::htmlPage($html, 'Reset your password');

    3181. 

  3181. 

    3182. 

  3182. 		if ($sendToBrowser) {self::sendContent($html); return '';} else return $html;

    3183. 

  3183. 	}

    3184. 

  3184. 

    3185. 

  3185. 	private static /*.string.*/ function htmlMessagePage (/*.string.*/ $title, /*.string.*/ $message, $sendToBrowser = false) {

    3186. 

  3186. 		$message		= self::htmlMessage($message, self::MESSAGE_STYLE_PLAIN, 'ezuser', self::MESSAGE_TYPE_TEXT);

    3187. 

  3187. 

    3188. 

  3188. 		$html = <<<HTML

    3189. 

  3189. 	<div id="ezuser">

    3190. 

  3190. 		<h4 class="ezuser-heading">$title</h4>

    3191. 

  3191. $message

    3192. 

  3192. 	</div>

    3193. 

  3193. HTML;

    3194. 

  3194. 

    3195. 

  3195. 		$html = self::htmlPage($html, $title);

    3196. 

  3196. 

    3197. 

  3197. 		if ($sendToBrowser) {self::sendContent($html); return '';} else return $html;

    3198. 

  3198. 	}

    3199. 

  3199. 

    3200. 

  3200. // ---------------------------------------------------------------------------

    3201. 

  3201. 	private static /*.string.*/ function htmlMessageForm ($message = '', $action = self::ACTION_MAIN, $sendToBrowser = false) {

    3202. 

  3202. 		$actionMain		= self::ACTION_MAIN;

    3203. 

  3203. 		$htmlButtonPreference	= self::htmlButton(self::BUTTON_TYPE_PREFERENCE);

    3204. 

  3204. 		$message		= self::htmlMessage($message, self::MESSAGE_STYLE_TEXT, '', self::MESSAGE_TYPE_TEXT);

    3205. 

  3205. 

    3206. 

  3206. 		$html = <<<HTML

    3207. 

  3207. 		<form id="ezuser-$action-form" class="ezuser-form" onsubmit="return false">

    3208. 

  3208. 			<fieldset class="ezuser-fieldset">

    3209. 

  3209. $message

    3210. 

  3210. 				<input id="ezuser-OK" data-ezuser-action="$actionMain" value="OK"

    3211. 

  3211. 					tabindex	=	"3241"

    3212. 

  3212. $htmlButtonPreference

    3213. 

  3213. 				/>

    3214. 

  3214. 			</fieldset>

    3215. 

  3215. 		</form>

    3216. 

  3216. HTML;

    3217. 

  3217. 

    3218. 

  3218. 		if ($sendToBrowser) {self::sendXML($html); return '';} else return $html;

    3219. 

  3219. 	}

    3220. 

  3220. 

    3221. 

  3221. 	private static /*.string.*/ function htmlResultForm (/*.int.*/ $result, $more = '', $sendToBrowser = false) {

    3222. 

  3222. 		$html = self::htmlMessageForm(self::resultText($result, $more), self::ACTION_RESULTFORM);

    3223. 

  3223. 		if ($sendToBrowser) {self::sendXML($html); return '';} else return $html;

    3224. 

  3224. 	}

    3225. 

  3225. 

    3226. 

  3226. // ---------------------------------------------------------------------------

    3227. 

  3227. 	private	static /*.string.*/ function htmlAboutText($sendToBrowser = false) {

    3228. 

  3228. 		$php	= self::getFileContents('ezuser.php', 0, NULL, -1, 4096);

    3229. 

  3229. 		$html	= self::docBlock_to_HTML($php);

    3230. 

  3230. 

    3231. 

  3231. 		if ($sendToBrowser) {self::sendContent($html); return '';} else return $html;

    3232. 

  3232. 	}

    3233. 

  3233. 

    3234. 

  3234. // ---------------------------------------------------------------------------

    3235. 

  3235. 	private	static /*.string.*/ function htmlAbout($sendToBrowser = false) {

    3236. 

  3236. 		$html	= self::htmlPage(self::htmlAboutText(), 'ezUser - About');

    3237. 

  3237. 

    3238. 

  3238. 		if ($sendToBrowser) {self::sendContent($html); return '';} else return $html;

    3239. 

  3239. 	}

    3240. 

  3240. 

    3241. 

  3241. // ---------------------------------------------------------------------------

    3242. 

  3242. 	private	static /*.string.*/ function htmlSourceCode($sendToBrowser = false) {

    3243. 

  3243. 		$html = (string) highlight_file(__FILE__, 1);

    3244. 

  3244. 		if ($sendToBrowser) {self::sendContent($html); return '';} else return $html;

    3245. 

  3245. 	}

    3246. 

  3246. 

    3247. 

  3247. /**

    3248. 

  3248.  * Other MIME types: CSS, Javascript, bitmaps

    3249. 

  3249.  */

    3250. 

  3250. 	private static /*.string.*/ function htmlStyleSheet(/*.boolean.*/ $sendToBrowser = false) {

    3251. 

  3251. 		$container		= self::getInstanceId(self::ACTION_ACCOUNT);

    3252. 

  3252. 		$tagFullName		= self::TAGNAME_FULLNAME;

    3253. 

  3253. 		$tagVerbose		= self::TAGNAME_VERBOSE;

    3254. 

  3254. 		$buttonTypeAction	= self::BUTTON_TYPE_ACTION;

    3255. 

  3255. 		$buttonTypePreference	= self::BUTTON_TYPE_PREFERENCE;

    3256. 

  3256. 

    3257. 

  3257. 		$css = <<<GENERATED
    3258. 

  3258. @charset "UTF-8";

    3259. 

  3259. /**

    3260. 

  3260.  * Enables user registration and authentication for a website

    3261. 

  3261.  * 

    3262. 

  3262.  * This code has three principle design goals:

    3263. 

  3263.  * 

    3264. 

  3264.  *     1. To make it easy for people to register and sign in to your site.

    3265. 

  3265.  *     2. To make it easy for you to add this functionality to your site.

    3266. 

  3266.  *     3. To make it easy for you to administer the user database on your site.

    3267. 

  3267.  * 

    3268. 

  3268.  * Other design goals, such as run-time efficiency, are important but secondary to

    3269. 

  3269.  * these.

    3270. 

  3270.  * 

    3271. 

  3271.  * Copyright (c) 2008-2010, Dominic Sayers							<br>

    3272. 

  3272.  * All rights reserved.

    3273. 

  3273.  * 

    3274. 

  3274.  * Redistribution and use in source and binary forms, with or without modification,

    3275. 

  3275.  * are permitted provided that the following conditions are met:

    3276. 

  3276.  * 

    3277. 

  3277.  *     - Redistributions of source code must retain the above copyright notice,

    3278. 

  3278.  *       this list of conditions and the following disclaimer.

    3279. 

  3279.  *     - Redistributions in binary form must reproduce the above copyright notice,

    3280. 

  3280.  *       this list of conditions and the following disclaimer in the documentation

    3281. 

  3281.  *       and/or other materials provided with the distribution.

    3282. 

  3282.  *     - Neither the name of Dominic Sayers nor the names of its contributors may be

    3283. 

  3283.  *       used to endorse or promote products derived from this software without

    3284. 

  3284.  *       specific prior written permission.

    3285. 

  3285.  * 

    3286. 

  3286.  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND

    3287. 

  3287.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

    3288. 

  3288.  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

    3289. 

  3289.  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR

    3290. 

  3290.  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

    3291. 

  3291.  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

    3292. 

  3292.  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON

    3293. 

  3293.  * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

    3294. 

  3294.  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

    3295. 

  3295.  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

    3296. 

  3296.  * 

    3297. 

  3297.  * @package	ezUser

    3298. 

  3298.  * @author	Dominic Sayers <dominic@sayers.cc>

    3299. 

  3299.  * @copyright	2008-2010 Dominic Sayers

    3300. 

  3300.  * @license	http://www.opensource.org/licenses/bsd-license.php BSD License

    3301. 

  3301.  * @link	http://code.google.com/p/ezuser/

    3302. 

  3302.  * @version	0.25.5 - Floating div dialog boxes

    3303. 

  3303.  */

    3304. 

  3304. 

    3305. 

  3305. .dummy {} /* Webkit is ignoring the first item so we'll put a dummy one in */

    3306. 

  3306. 

    3307. 

  3307. .ezuser {

    3308. 

  3308. 	margin:0;

    3309. 

  3309. 	padding:0;

    3310. 

  3310. 	font-family:"Segoe UI",Geneva,Tahoma,Arial,Helvetica,sans-serif;

    3311. 

  3311. 	font-size:11px;

    3312. 

  3312. }

    3313. 

  3313. 

    3314. 

  3314. pre.ezuser {font-family:Consolas, Courier New, Courier, fixedsys;}

    3315. 

  3315. 

    3316. 

  3316. .ezuser-left		{float:left;}

    3317. 

  3317. .ezuser-right		{float:right;}

    3318. 

  3318. .ezuser-hidden	{display:none;}

    3319. 

  3319. .ezuser-heading	{padding:6px;margin:0 0 1em 0;}

    3320. 

  3320. .ezuser-dialog-control	{cursor:pointer;}

    3321. 

  3321. 

    3322. 

  3322. img#ezuser-close {

    3323. 

  3323. 	width:40px;

    3324. 

  3324. 	height:40px;

    3325. 

  3325. 	position:absolute;

    3326. 

  3326. 	left:319px;

    3327. 

  3327. 	top:-25px;

    3328. 

  3328. }

    3329. 

  3329. 

    3330. 

  3330. div#ezuser {

    3331. 

  3331. 	text-align: left;

    3332. 

  3332. 	width: 300px;

    3333. 

  3333. 	height: 100px;

    3334. 

  3334. 	font-family:"Segoe UI",Geneva,Tahoma,Arial,Helvetica,sans-serif;

    3335. 

  3335. 	font-size:11px;

    3336. 

  3336. 	padding:1.5em;

    3337. 

  3337. 	border:1em solid #CCCCCC;

    3338. 

  3338. 	border-radius: 2em;

    3339. 

  3339. 	-icab-border-radius: 2em;	/* iCab */

    3340. 

  3340. 	-khtml-border-radius: 2em;	/* Konqueror */

    3341. 

  3341. 	-moz-border-radius: 2em;	/* Firefox */

    3342. 

  3342. 	-o-border-radius: 2em;		/* Opera */

    3343. 

  3343. 	-webkit-border-radius: 2em;	/* Chrome, Safari */

    3344. 

  3344. 	box-shadow: 0.4em 0.4em 1.8em #555555;

    3345. 

  3345. 	-icab-box-shadow: 0.4em 0.4em 1.8em #555555;		/* iCab */

    3346. 

  3346. 	-khtml-box-shadow: 0.4em 0.4em 1.8em #555555;		/* Konqueror */

    3347. 

  3347. 	-moz-box-shadow: 0.4em 0.4em 1.8em #555555;		/* Firefox */

    3348. 

  3348. 	-o-box-shadow: 0.4em 0.4em 1.8em #555555;		/* Opera */

    3349. 

  3349. 	-webkit-box-shadow: 0.4em 0.4em 1.8em #555555;	/* Chrome, Safari */

    3350. 

  3350. 	line-height:100%;

    3351. 

  3351. 	background-color:#EEEEEE;

    3352. 

  3352. }

    3353. 

  3353. 

    3354. 

  3354. div#$container {

    3355. 

  3355. 	font-family:"Segoe UI",Geneva,Tahoma,Arial,Helvetica,sans-serif;

    3356. 

  3356. 	font-size:12px;

    3357. 

  3357. 	line-height:100%;

    3358. 

  3358. 	float:left;

    3359. 

  3359. }

    3360. 

  3360. 

    3361. 

  3361. div.ezuser-message {

    3362. 

  3362. 	float:left;

    3363. 

  3363. 	text-align:center;

    3364. 

  3364. 	font-weight:normal;

    3365. 

  3365. }

    3366. 

  3366. 

    3367. 

  3367. div.ezuser-text {

    3368. 

  3368. 	width:286px;

    3369. 

  3369. 	float:left;

    3370. 

  3370. 	padding:0;

    3371. 

  3371. 	text-align:justify;

    3372. 

  3372. 	margin:7px 0 7px 0;

    3373. 

  3373. 	line-height:16px;

    3374. 

  3374. }

    3375. 

  3375. 

    3376. 

  3376. p.ezuser-message-plain	{margin:0;padding:6px;}

    3377. 

  3377. p.ezuser-message-info	{margin:0;padding:6px;background-color:#FFCC00;color:#000000;}

    3378. 

  3378. p.ezuser-message-text	{margin:0;padding:6px;background-color:#EEEEEE;color:#000000;}

    3379. 

  3379. p.ezuser-message-fail	{margin:0;padding:6px;background-color:#FF0000;color:#FFFFFF;font-weight:bold;}

    3380. 

  3380. p.ezuser-message-hidden	{display:none;}

    3381. 

  3381. 

    3382. 

  3382. div.ezuser-$tagFullName {

    3383. 

  3383. 	float:right;

    3384. 

  3384. 	margin:4px 0 0 0;

    3385. 

  3385. 	padding:6px;

    3386. 

  3386. 	color:#555555;

    3387. 

  3387. 	font-weight:bold;

    3388. 

  3388. }

    3389. 

  3389. 

    3390. 

  3390. form.ezuser-form			{margin:0;}

    3391. 

  3391. fieldset.ezuser-fieldset		{margin:0;padding:0;border:0;clear:both;float:right;width:286px;}

    3392. 

  3392. fieldset.ezuser-fieldset-float	{margin:0;padding:0;border:0;clear:both;float:right;}

    3393. 

  3393. label.ezuser-label			{padding:4px;}

    3394. 

  3394. 

    3395. 

  3395. input.ezuser-text {

    3396. 

  3396. 	font-size:11px;

    3397. 

  3397. 	width:160px;

    3398. 

  3398. 	margin-bottom:4px;

    3399. 

  3399. }

    3400. 

  3400. 

    3401. 

  3401. input.ezuser-button {

    3402. 

  3402. 	padding:2px;

    3403. 

  3403. 	font-family:"Segoe UI",Geneva,Tahoma,Arial,Helvetica,sans-serif;

    3404. 

  3404. 	border-style:solid;

    3405. 

  3405. 	border-width:1px;

    3406. 

  3406. 	border-radius: 4px;

    3407. 

  3407. 	-icab-border-radius: 4px;	/* iCab */

    3408. 

  3408. 	-khtml-border-radius: 4px;	/* Konqueror */

    3409. 

  3409. 	-moz-border-radius: 4px;	/* Firefox */

    3410. 

  3410. 	-o-border-radius: 4px;		/* Opera */

    3411. 

  3411. 	-webkit-border-radius: 4px;	/* Chrome, Safari */

    3412. 

  3412. 	cursor:pointer;

    3413. 

  3413. }

    3414. 

  3414. 

    3415. 

  3415. input.ezuser-$buttonTypeAction {

    3416. 

  3416. 	font-size:12px;

    3417. 

  3417. 	width:52px;

    3418. 

  3418. 	margin:0 0 0 6px;

    3419. 

  3419. }

    3420. 

  3420. 

    3421. 

  3421. input.ezuser-$buttonTypePreference {

    3422. 

  3422. 	font-size:10px;

    3423. 

  3423. 	margin:4px 0 0 6px;

    3424. 

  3424. }

    3425. 

  3425. 

    3426. 

  3426. input.ezuser-preference-$tagVerbose {float:left;margin:0;}

    3427. 

  3427. 

    3428. 

  3428. input.ezuser-buttonstate-0 {background-color:#FFFFFF;color:#444444;border-color:#666666 #333333 #333333 #666666;}

    3429. 

  3429. input.ezuser-buttonstate-1 {background-color:#FFFFFF;color:#444444;border-color:#FF9900 #CC6600 #CC6600 #FF9900;}

    3430. 

  3430. input.ezuser-buttonstate-2 {background-color:#FFFFFF;color:#444444;border-color:#666666 #333333 #333333 #666666;}

    3431. 

  3431. input.ezuser-buttonstate-3 {background-color:#FFFFFF;color:#444444;border-color:#FF9900 #CC6600 #CC6600 #FF9900;}

    3432. 

  3432. input.ezuser-buttonstate-4 {background-color:#CCCCCC;color:#222222;border-color:#333333 #666666 #666666 #333333;}

    3433. 

  3433. input.ezuser-buttonstate-5 {background-color:#CCCCCC;color:#222222;border-color:#CC6600 #FF9900 #FF9900 #CC6600;}

    3434. 

  3434. input.ezuser-buttonstate-6 {background-color:#CCCCCC;color:#222222;border-color:#333333 #666666 #666666 #333333;}

    3435. 

  3435. input.ezuser-buttonstate-7 {background-color:#CCCCCC;color:#222222;border-color:#CC6600 #FF9900 #FF9900 #CC6600;}

    3436. 

  3436. 

  3437. GENERATED;
    3438. 

  3438. // Generated code - do not modify in built package

    3439. 

  3439. 

    3440. 

  3440. 		if ($sendToBrowser) {self::sendContent($css, '', 'text/css'); return '';} else return $css;

    3441. 

  3441. 	}

    3442. 

  3442. 

    3443. 

  3443. // ---------------------------------------------------------------------------

    3444. 

  3444. 	private static /*.string.*/ function htmlJavascript($containerList = '', $sendToBrowser = false) {

    3445. 

  3445. 		$accountForm		= self::getInstanceId(self::ACTION_ACCOUNT);

    3446. 

  3446. 

    3447. 

  3447. 		$sessionName		= ini_get('session.name');

    3448. 

  3448. 		$remoteAddress		= $_SERVER['REMOTE_ADDR'];

    3449. 

  3449. 		$URL			= self::thisURL();

    3450. 

  3450. 		$folder			= dirname($URL);

    3451. 

  3451. 

    3452. 

  3452. 		$cookieUsername		= self::COOKIE_USERNAME;

    3453. 

  3453. 		$cookiePassword		= self::COOKIE_PASSWORD;

    3454. 

  3454. 		$cookieStaySignedIn	= self::COOKIE_AUTOSIGN;

    3455. 

  3455. 

    3456. 

  3456. 		$tagFirstName		= self::TAGNAME_FIRSTNAME;

    3457. 

  3457. 		$tagLastName		= self::TAGNAME_LASTNAME;

    3458. 

  3458. 		$tagEmail		= self::TAGNAME_EMAIL;

    3459. 

  3459. 		$tagUsername		= self::TAGNAME_USERNAME;

    3460. 

  3460. 		$tagPassword		= self::TAGNAME_PASSWORD;

    3461. 

  3461. 		$tagConfirm		= self::TAGNAME_CONFIRM;

    3462. 

  3462. 		$tagNewUser		= self::TAGNAME_NEWUSER;

    3463. 

  3463. 		$tagRememberMe		= self::TAGNAME_REMEMBERME;

    3464. 

  3464. 		$tagStaySignedIn	= self::TAGNAME_STAYSIGNEDIN;

    3465. 

  3465. 		$tagUseSavedPassword	= self::TAGNAME_SAVEDPASSWORD;

    3466. 

  3466. 		$tagVerbose		= self::TAGNAME_VERBOSE;

    3467. 

  3467. 		$tagWizard		= self::TAGNAME_WIZARD;

    3468. 

  3468. 

    3469. 

  3469. 		$action			= self::ACTION;

    3470. 

  3470. 		$actionAccountForm	= self::ACTION_ACCOUNTFORM;

    3471. 

  3471. 		$actionAccountWizard	= self::ACTION_ACCOUNTWIZARD;

    3472. 

  3472. 		$actionValidate		= self::ACTION_VALIDATE;

    3473. 

  3473. 		$actionSignIn		= self::ACTION_SIGNIN;

    3474. 

  3474. 		$actionCancel		= self::ACTION_CANCEL;

    3475. 

  3475. 		$actionCSS		= self::ACTION_STYLESHEET;

    3476. 

  3476. 		$actionResultForm	= self::ACTION_RESULTFORM;

    3477. 

  3477. 		$actionResend		= self::ACTION_RESEND;

    3478. 

  3478. 		$actionReset		= self::ACTION_RESET;

    3479. 

  3479. 		$actionResetPassword	= self::ACTION_RESETPASSWORD;

    3480. 

  3480. 		$actionResetRequest	= self::ACTION_RESETREQUEST;

    3481. 

  3481. 

    3482. 

  3482. 		$modeEdit		= self::ACCOUNT_MODE_EDIT;

    3483. 

  3483. 

    3484. 

  3484. 		$messageTypeText	= self::MESSAGE_TYPE_TEXT;

    3485. 

  3485. 		$delimPlus		= self::DELIMITER_PLUS;

    3486. 

  3486. 		$stringRight		= self::STRING_RIGHT;

    3487. 

  3487. 		$stringTrue		= self::STRING_TRUE;

    3488. 

  3488. 		$stringFalse		= self::STRING_FALSE;

    3489. 

  3489. 		$passwordMask		= self::PASSWORD_MASK;

    3490. 

  3490. 

    3491. 

  3491. 		$accountPage		= self::getSetting(self::SETTINGS_ACCOUNTPAGE);

    3492. 

  3492. 		$accountClick		= ($accountPage === '') ? "ezUser.ajax.execute('$actionAccountWizard')" : "window.location = '$folder/$accountPage'";

    3493. 

  3493. 

    3494. 

  3494. 		// Append code to request container content

    3495. 

  3495. 		if ($containerList === '') {

    3496. 

  3496. 			$immediateJavascript = '';

    3497. 

  3497. 		} else {

    3498. 

  3498. 			// Space-separated list of containers to fill

    3499. 

  3499. 			$immediateJavascript = "ezUser.ajax.execute('" . (string) str_replace(self::DELIMITER_SPACE, self::DELIMITER_PLUS, $containerList) . "');";

    3500. 

  3500. 		}

    3501. 

  3501. 

    3502. 

  3502. 		$js = <<<GENERATED
    3503. 

  3503. /**

    3504. 

  3504.  * Enables user registration and authentication for a website

    3505. 

  3505.  * 

    3506. 

  3506.  * This code has three principle design goals:

    3507. 

  3507.  * 

    3508. 

  3508.  *     1. To make it easy for people to register and sign in to your site.

    3509. 

  3509.  *     2. To make it easy for you to add this functionality to your site.

    3510. 

  3510.  *     3. To make it easy for you to administer the user database on your site.

    3511. 

  3511.  * 

    3512. 

  3512.  * Other design goals, such as run-time efficiency, are important but secondary to

    3513. 

  3513.  * these.

    3514. 

  3514.  * 

    3515. 

  3515.  * Copyright (c) 2008-2010, Dominic Sayers							<br>

    3516. 

  3516.  * All rights reserved.

    3517. 

  3517.  * 

    3518. 

  3518.  * Redistribution and use in source and binary forms, with or without modification,

    3519. 

  3519.  * are permitted provided that the following conditions are met:

    3520. 

  3520.  * 

    3521. 

  3521.  *     - Redistributions of source code must retain the above copyright notice,

    3522. 

  3522.  *       this list of conditions and the following disclaimer.

    3523. 

  3523.  *     - Redistributions in binary form must reproduce the above copyright notice,

    3524. 

  3524.  *       this list of conditions and the following disclaimer in the documentation

    3525. 

  3525.  *       and/or other materials provided with the distribution.

    3526. 

  3526.  *     - Neither the name of Dominic Sayers nor the names of its contributors may be

    3527. 

  3527.  *       used to endorse or promote products derived from this software without

    3528. 

  3528.  *       specific prior written permission.

    3529. 

  3529.  * 

    3530. 

  3530.  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND

    3531. 

  3531.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

    3532. 

  3532.  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

    3533. 

  3533.  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR

    3534. 

  3534.  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

    3535. 

  3535.  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

    3536. 

  3536.  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON

    3537. 

  3537.  * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

    3538. 

  3538.  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

    3539. 

  3539.  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

    3540. 

  3540.  * 

    3541. 

  3541.  * @package	ezUser

    3542. 

  3542.  * @author	Dominic Sayers <dominic@sayers.cc>

    3543. 

  3543.  * @copyright	2008-2010 Dominic Sayers

    3544. 

  3544.  * @license	http://www.opensource.org/licenses/bsd-license.php BSD License

    3545. 

  3545.  * @link	http://code.google.com/p/ezuser/

    3546. 

  3546.  * @version	0.25.5 - Floating div dialog boxes

    3547. 

  3547.  */

    3548. 

  3548. 

    3549. 

  3549. /*jslint eqeqeq: true, immed: true, nomen: true, onevar: true, regexp: true, undef: true */

    3550. 

  3550. /*global window, document, event, ActiveXObject */ // For JSLint

    3551. 

  3551. //"use strict";

    3552. 

  3552. 

    3553. 

  3553. /**

    3554. 

  3554.  * All ezUser functionality is held in this class to avoid namespace clashes

    3555. 

  3555.  */

    3556. 

  3556. function C_ezUser() {

    3557. 

  3557. 	if (!(this instanceof arguments.callee)) {throw Error('Constructor called as a function');}

    3558. 

  3558. 

    3559. 

  3559. // Generated code - do not modify in built package
    3560. 

  3560. /**

    3561. 

  3561. *

    3562. 

  3562. *  Secure Hash Algorithm (SHA256)

    3563. 

  3563. *  http://www.webtoolkit.info/

    3564. 

  3564. *

    3565. 

  3565. *  Original code by Angel Marin, Paul Johnston.

    3566. 

  3566. *

    3567. 

  3567. **/

    3568. 

  3568. 

    3569. 

  3569. function SHA256(s){

    3570. 

  3570. 

    3571. 

  3571. 	var chrsz   = 8, hexcase = 0;

    3572. 

  3572. 

    3573. 

  3573. 	function safe_add (x, y) {

    3574. 

  3574. 		var lsw = (x & 0xFFFF) + (y & 0xFFFF),

    3575. 

  3575. 		msw = (x >> 16) + (y >> 16) + (lsw >> 16);

    3576. 

  3576. 		return (msw << 16) | (lsw & 0xFFFF);

    3577. 

  3577. 	}

    3578. 

  3578. 

    3579. 

  3579. 	function S (X, n) { return ( X >>> n ) | (X << (32 - n)); }

    3580. 

  3580. 	function R (X, n) { return ( X >>> n ); }

    3581. 

  3581. 	function Ch(x, y, z) { return ((x & y) ^ ((~x) & z)); }

    3582. 

  3582. 	function Maj(x, y, z) { return ((x & y) ^ (x & z) ^ (y & z)); }

    3583. 

  3583. 	function Sigma0256(x) { return (S(x, 2) ^ S(x, 13) ^ S(x, 22)); }

    3584. 

  3584. 	function Sigma1256(x) { return (S(x, 6) ^ S(x, 11) ^ S(x, 25)); }

    3585. 

  3585. 	function Gamma0256(x) { return (S(x, 7) ^ S(x, 18) ^ R(x, 3)); }

    3586. 

  3586. 	function Gamma1256(x) { return (S(x, 17) ^ S(x, 19) ^ R(x, 10)); }

    3587. 

  3587. 

    3588. 

  3588. 	function core_sha256 (m, l) {

    3589. 

  3589. 		var K = [0x428A2F98, 0x71374491, 0xB5C0FBCF, 0xE9B5DBA5, 0x3956C25B, 0x59F111F1, 0x923F82A4, 0xAB1C5ED5, 0xD807AA98, 0x12835B01, 0x243185BE, 0x550C7DC3, 0x72BE5D74, 0x80DEB1FE, 0x9BDC06A7, 0xC19BF174, 0xE49B69C1, 0xEFBE4786, 0xFC19DC6, 0x240CA1CC, 0x2DE92C6F, 0x4A7484AA, 0x5CB0A9DC, 0x76F988DA, 0x983E5152, 0xA831C66D, 0xB00327C8, 0xBF597FC7, 0xC6E00BF3, 0xD5A79147, 0x6CA6351, 0x14292967, 0x27B70A85, 0x2E1B2138, 0x4D2C6DFC, 0x53380D13, 0x650A7354, 0x766A0ABB, 0x81C2C92E, 0x92722C85, 0xA2BFE8A1, 0xA81A664B, 0xC24B8B70, 0xC76C51A3, 0xD192E819, 0xD6990624, 0xF40E3585, 0x106AA070, 0x19A4C116, 0x1E376C08, 0x2748774C, 0x34B0BCB5, 0x391C0CB3, 0x4ED8AA4A, 0x5B9CCA4F, 0x682E6FF3, 0x748F82EE, 0x78A5636F, 0x84C87814, 0x8CC70208, 0x90BEFFFA, 0xA4506CEB, 0xBEF9A3F7, 0xC67178F2],

    3590. 

  3590. 		HASH = [0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A, 0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19],

    3591. 

  3591. 		W = new Array(64),

    3592. 

  3592. 		a, b, c, d, e, f, g, h, i, j,

    3593. 

  3593. 		T1, T2;

    3594. 

  3594. 

    3595. 

  3595. 		m[l >> 5] |= 0x80 << (24 - l % 32);

    3596. 

  3596. 		m[((l + 64 >> 9) << 4) + 15] = l;

    3597. 

  3597. 

    3598. 

  3598. 		for ( var i = 0; i<m.length; i+=16 ) {

    3599. 

  3599. 			a = HASH[0];

    3600. 

  3600. 			b = HASH[1];

    3601. 

  3601. 			c = HASH[2];

    3602. 

  3602. 			d = HASH[3];

    3603. 

  3603. 			e = HASH[4];

    3604. 

  3604. 			f = HASH[5];

    3605. 

  3605. 			g = HASH[6];

    3606. 

  3606. 			h = HASH[7];

    3607. 

  3607. 

    3608. 

  3608. 			for ( var j = 0; j<64; j++) {

    3609. 

  3609. 				if (j < 16) W[j] = m[j + i];

    3610. 

  3610. 				else W[j] = safe_add(safe_add(safe_add(Gamma1256(W[j - 2]), W[j - 7]), Gamma0256(W[j - 15])), W[j - 16]);

    3611. 

  3611. 

    3612. 

  3612. 				T1 = safe_add(safe_add(safe_add(safe_add(h, Sigma1256(e)), Ch(e, f, g)), K[j]), W[j]);

    3613. 

  3613. 				T2 = safe_add(Sigma0256(a), Maj(a, b, c));

    3614. 

  3614. 

    3615. 

  3615. 				h = g;

    3616. 

  3616. 				g = f;

    3617. 

  3617. 				f = e;

    3618. 

  3618. 				e = safe_add(d, T1);

    3619. 

  3619. 				d = c;

    3620. 

  3620. 				c = b;

    3621. 

  3621. 				b = a;

    3622. 

  3622. 				a = safe_add(T1, T2);

    3623. 

  3623. 			}

    3624. 

  3624. 

    3625. 

  3625. 			HASH[0] = safe_add(a, HASH[0]);

    3626. 

  3626. 			HASH[1] = safe_add(b, HASH[1]);

    3627. 

  3627. 			HASH[2] = safe_add(c, HASH[2]);

    3628. 

  3628. 			HASH[3] = safe_add(d, HASH[3]);

    3629. 

  3629. 			HASH[4] = safe_add(e, HASH[4]);

    3630. 

  3630. 			HASH[5] = safe_add(f, HASH[5]);

    3631. 

  3631. 			HASH[6] = safe_add(g, HASH[6]);

    3632. 

  3632. 			HASH[7] = safe_add(h, HASH[7]);

    3633. 

  3633. 		}

    3634. 

  3634. 		return HASH;

    3635. 

  3635. 	}

    3636. 

  3636. 

    3637. 

  3637. 	function str2binb (str) {

    3638. 

  3638. 		var bin = Array();

    3639. 

  3639. 		var mask = (1 << chrsz) - 1;

    3640. 

  3640. 		for(var i = 0; i < str.length * chrsz; i += chrsz) {

    3641. 

  3641. 			bin[i>>5] |= (str.charCodeAt(i / chrsz) & mask) << (24 - i%32);

    3642. 

  3642. 		}

    3643. 

  3643. 		return bin;

    3644. 

  3644. 	}

    3645. 

  3645. 

    3646. 

  3646. 	function Utf8Encode(string) {

    3647. 

  3647. 		string = string.replace(/\\r\\n/g,"\\n");

    3648. 

  3648. 		var utftext = "";

    3649. 

  3649. 

    3650. 

  3650. 		for (var n = 0; n < string.length; n++) {

    3651. 

  3651. 

    3652. 

  3652. 			var c = string.charCodeAt(n);

    3653. 

  3653. 

    3654. 

  3654. 			if (c < 128) {

    3655. 

  3655. 				utftext += String.fromCharCode(c);

    3656. 

  3656. 			}

    3657. 

  3657. 			else if((c > 127) && (c < 2048)) {

    3658. 

  3658. 				utftext += String.fromCharCode((c >> 6) | 192);

    3659. 

  3659. 				utftext += String.fromCharCode((c & 63) | 128);

    3660. 

  3660. 			}

    3661. 

  3661. 			else {

    3662. 

  3662. 				utftext += String.fromCharCode((c >> 12) | 224);

    3663. 

  3663. 				utftext += String.fromCharCode(((c >> 6) & 63) | 128);

    3664. 

  3664. 				utftext += String.fromCharCode((c & 63) | 128);

    3665. 

  3665. 			}

    3666. 

  3666. 

    3667. 

  3667. 		}

    3668. 

  3668. 

    3669. 

  3669. 		return utftext;

    3670. 

  3670. 	}

    3671. 

  3671. 

    3672. 

  3672. 	function binb2hex (binarray) {

    3673. 

  3673. 		var hex_tab = hexcase ? "0123456789ABCDEF" : "0123456789abcdef";

    3674. 

  3674. 		var str = "";

    3675. 

  3675. 		for(var i = 0; i < binarray.length * 4; i++) {

    3676. 

  3676. 			str += hex_tab.charAt((binarray[i>>2] >> ((3 - i%4)*8+4)) & 0xF) +

    3677. 

  3677. 			hex_tab.charAt((binarray[i>>2] >> ((3 - i%4)*8  )) & 0xF);

    3678. 

  3678. 		}

    3679. 

  3679. 		return str;

    3680. 

  3680. 	}

    3681. 

  3681. 

    3682. 

  3682. 	s = Utf8Encode(s);

    3683. 

  3683. 	return binb2hex(core_sha256(str2binb(s), s.length * chrsz));

    3684. 

  3684. 

    3685. 

  3685. }
    3686. 

  3686. // End of generated code

    3687. 

  3687. 

    3688. 

  3688. 	this.getControl	= function (id)		{return document.getElementById(id);};

    3689. 

  3689. 	this.getValue	= function (id)		{return this.getControl(id).value;};

    3690. 

  3690. 	this.setValue	= function (id, value)	{this.getControl(id).value = value;};

    3691. 

  3691. 

    3692. 

  3692. 	var that = this;

    3693. 

  3693. 

    3694. 

  3694. // ---------------------------------------------------------------------------

    3695. 

  3695. 	function fireEvent(control, eventType, detail) {

    3696. 

  3696. 		var e, result; // Returned result from dispatchEvent

    3697. 

  3697. 

    3698. 

  3698. 		switch (eventType.toLowerCase()) {

    3699. 

  3699. 		case 'keyup':

    3700. 

  3700. 		case 'keydown':

    3701. 

  3701. 			if (document.createEventObject) {

    3702. 

  3702. 				// IE

    3703. 

  3703. 				e		= document.createEventObject();

    3704. 

  3704. 				e.keyCode	= detail;

    3705. 

  3705. 				result		= control.fireEvent('on' + eventType);

    3706. 

  3706. 			} else if (window.KeyEvent) {

    3707. 

  3707. 				// Firefox

    3708. 

  3708. 				e		= document.createEvent('KeyEvents');

    3709. 

  3709. 				e.initKeyEvent(eventType, true, true, window, false, false, false, false, detail, 0);

    3710. 

  3710. 				result		= control.dispatchEvent(e);

    3711. 

  3711. 			} else {

    3712. 

  3712. 				e		= document.createEvent('UIEvents');

    3713. 

  3713. 				e.initUIEvent(eventType, true, true, window, 1);

    3714. 

  3714. 				e.keyCode	= detail;

    3715. 

  3715. 				result		= control.dispatchEvent(e);

    3716. 

  3716. 			}

    3717. 

  3717. 

    3718. 

  3718. 			break;

    3719. 

  3719. 		case 'focus':

    3720. 

  3720. 		case 'blur':

    3721. 

  3721. 		case 'change':

    3722. 

  3722. 			if (document.createEventObject) {

    3723. 

  3723. 				// IE

    3724. 

  3724. 				e		= document.createEventObject();

    3725. 

  3725. 				result		= control.fireEvent('on' + eventType);

    3726. 

  3726. 			} else {

    3727. 

  3727. 				e		= document.createEvent('UIEvents');

    3728. 

  3728. 				e.initUIEvent(eventType, true, true, window, 1);

    3729. 

  3729. 				result		= control.dispatchEvent(e);

    3730. 

  3730. 			}

    3731. 

  3731. 

    3732. 

  3732. 			break;

    3733. 

  3733. 		case 'click':

    3734. 

  3734. 			if (document.createEventObject) {

    3735. 

  3735. 				// IE

    3736. 

  3736. 				e		= document.createEventObject();

    3737. 

  3737. 				result		= control.fireEvent('on' + eventType);

    3738. 

  3738. 			} else {

    3739. 

  3739. 				e		= document.createEvent('MouseEvents');

    3740. 

  3740. 				e.initMouseEvent(eventType, true, true, window, 1);

    3741. 

  3741. 				result		= control.dispatchEvent(e);

    3742. 

  3742. 			}

    3743. 

  3743. 

    3744. 

  3744. 			break;

    3745. 

  3745. 		}

    3746. 

  3746. 

    3747. 

  3747. 		return result;

    3748. 

  3748. 	}

    3749. 

  3749. 

    3750. 

  3750. // ---------------------------------------------------------------------------

    3751. 

  3751. 	function setFocus(control) {

    3752. 

  3752. 		var doEvent;

    3753. 

  3753. 

    3754. 

  3754. 		if (control.disabled) {return;}

    3755. 

  3755. 

    3756. 

  3756. 		if (typeof document.activeElement.onBlur === 'function') {fireEvent(document.activeElement, 'blur');}

    3757. 

  3757. 		if (typeof document.activeElement.onblur === 'function') {fireEvent(document.activeElement, 'blur');}

    3758. 

  3758. 		if (typeof control.onFocus === 'function') {doEvent = fireEvent(control, 'focus');}

    3759. 

  3759. 		if (typeof control.onfocus === 'function') {doEvent = fireEvent(control, 'focus');}

    3760. 

  3760. 		if (doEvent !== false) {control.focus();}

    3761. 

  3761. 		control.select();

    3762. 

  3762. 	}

    3763. 

  3763. 

    3764. 

  3764. // ---------------------------------------------------------------------------

    3765. 

  3765. 	function setInitialFocus(id) {

    3766. 

  3766. 		// Set focus to the first text control

    3767. 

  3767. 		var textId = '', control = null;

    3768. 

  3768. 

    3769. 

  3769. 		switch (id) {

    3770. 

  3770. 		case 'ezuser':

    3771. 

  3771. 			textId = 'ezuser-$tagUsername';

    3772. 

  3772. 			break;

    3773. 

  3773. 		case '$accountForm':

    3774. 

  3774. 			textId = '$accountForm-$tagEmail';

    3775. 

  3775. 			break;

    3776. 

  3776. 		}

    3777. 

  3777. 

    3778. 

  3778. 		if (textId !== '') {control = that.getControl(textId);}

    3779. 

  3779. 		if (control === null || typeof control === 'undefined' || control.disabled === 'disabled') {return;}

    3780. 

  3780. 		setFocus(control);

    3781. 

  3781. 	}

    3782. 

  3782. 

    3783. 

  3783. // ---------------------------------------------------------------------------

    3784. 

  3784. 	function hideControl(id) {

    3785. 

  3785. 		var	control		= that.getControl(id),

    3786. 

  3786. 			className	= control.className + ' ezuser-hidden';

    3787. 

  3787. 

    3788. 

  3788. 		control.className	= className;

    3789. 

  3789. 		control.style.display	= 'none';	// belt and braces

    3790. 

  3790. 	}

    3791. 

  3791. 

    3792. 

  3792. // ---------------------------------------------------------------------------

    3793. 

  3793. 	function showControl(id) {

    3794. 

  3794. 		var	control		= that.getControl(id),

    3795. 

  3795. 			classString	= control.className;

    3796. 

  3796. 

    3797. 

  3797. 		classString		= classString.replace(/ezuser-hidden/g, '');

    3798. 

  3798. 		classString		= classString.replace(/ {2}/g, ' ');

    3799. 

  3799. 		control.className	= classString;

    3800. 

  3800. 		control.style.display	= '';	// belt and braces

    3801. 

  3801. 	}

    3802. 

  3802. 

    3803. 

  3803. // ---------------------------------------------------------------------------

    3804. 

  3804. 	// Public properties

    3805. 

  3805. 	this.passwordSaved		= '';

    3806. 

  3806. 	this.passwordDefault_SignIn	= false;

    3807. 

  3807. 	this.passwordDefault_Account	= false;

    3808. 

  3808. 	this.usernameDefault_Account	= false;

    3809. 

  3809. 

    3810. 

  3810. 	// Public methods

    3811. 

  3811. // ---------------------------------------------------------------------------

    3812. 

  3812. 	this.showMessage = function (message, fail, messageType, instance) {

    3813. 

  3813. 		if (arguments.length < 1) {message	= '';}

    3814. 

  3814. 		if (arguments.length < 2) {fail		= false;}

    3815. 

  3815. 		if (arguments.length < 3) {messageType	= 'message';}

    3816. 

  3816. 		if (arguments.length < 4) {instance	= 'ezuser';}

    3817. 

  3817. 

    3818. 

  3818. 		var	id		= instance + '-' + messageType,

    3819. 

  3819. 			div		= this.getControl(id),

    3820. 

  3820. 			classString	= 'ezuser-' + messageType + ' ezuser-$stringRight',

    3821. 

  3821. 			subClass	= (fail) ? 'fail' : 'info',

    3822. 

  3822. 			p;

    3823. 

  3823. 

    3824. 

  3824. 		if (div === null)		{return;} // No such control

    3825. 

  3825. 		if (div.hasChildNodes())	{div.removeChild(div.firstChild);}

    3826. 

  3826. 

    3827. 

  3827. 		if (message !== '') {

    3828. 

  3828. 			p		= document.createElement('p');

    3829. 

  3829. 			p.className	= 'ezuser-message-' + subClass;

    3830. 

  3830. 			p.innerHTML	= message;

    3831. 

  3831. 			div.className	= classString;

    3832. 

  3832. 

    3833. 

  3833. 			div.appendChild(p);

    3834. 

  3834. 		}

    3835. 

  3835. 

    3836. 

  3836. 		div = this.getControl('ezuser-$tagVerbose');

    3837. 

  3837. 		if (div !== null) {div.parentNode.removeChild(div);}

    3838. 

  3838. 	};

    3839. 

  3839. 

    3840. 

  3840. // ---------------------------------------------------------------------------

    3841. 

  3841. 	this.bodyAppend = function (html) {

    3842. 

  3842. 		document.getElementsByTagName('body')[0].innerHTML += html;

    3843. 

  3843. 	};

    3844. 

  3844. 

    3845. 

  3845. /**

    3846. 

  3846.  * Responds to various UI events and controls the appearance of the form's

    3847. 

  3847.  * buttons

    3848. 

  3848.  */

    3849. 

  3849. 	this.setButtonState = function (control, eventID, setOn) {

    3850. 

  3850. 		// eventID	1 = mouseover/mouseout

    3851. 

  3851. 		//		2 = focus/blur

    3852. 

  3852. 		//		4 = selected/unselected

    3853. 

  3853. 

    3854. 

  3854. 		if (control === null) {return false;}

    3855. 

  3855. 

    3856. 

  3856. 		var	baseClass	= control.className,

    3857. 

  3857. 			stateClass	= 'ezuser-buttonstate-',

    3858. 

  3858. 			pos		= baseClass.indexOf(stateClass),

    3859. 

  3859. 			currentState	= Number(control.state);

    3860. 

  3860. 

    3861. 

  3861. 		currentState		= (setOn) ? currentState | eventID : currentState & ~eventID;

    3862. 

  3862. 		control.state		= String(currentState);

    3863. 

  3863. 		baseClass		= (pos === -1) ? baseClass + ' ' : baseClass.substring(0, pos);

    3864. 

  3864. 		control.className	= baseClass + stateClass + String(currentState);

    3865. 

  3865. 		return true;

    3866. 

  3866. 	};

    3867. 

  3867. 

    3868. 

  3868. /**

    3869. 

  3869.  * Cookies! Mmmm.

    3870. 

  3870.  */

    3871. 

  3871. 	this.cookies	= {

    3872. 

  3872. 		sessionId:	'',

    3873. 

  3873. 		username:	'',

    3874. 

  3874. 		passwordHash:	'',

    3875. 

  3875. 		staySignedIn:	false,

    3876. 

  3876. 		rememberMe:	false,

    3877. 

  3877. 

    3878. 

  3878. 		persist: function (name, value, days) {

    3879. 

  3879. 			var date, expires;

    3880. 

  3880. 

    3881. 

  3881. 			if (typeof days !== 'undefined') {

    3882. 

  3882. 				date = new Date();

    3883. 

  3883. 				date.setTime(date.getTime() + (days * 1000 * 3600 * 24));

    3884. 

  3884. 				expires = '; expires=' + date.toGMTString();

    3885. 

  3885. 			} else {

    3886. 

  3886. 				expires = '';

    3887. 

  3887. 			}

    3888. 

  3888. 

    3889. 

  3889. 			document.cookie = name + '=' + value + expires + '; path=/';

    3890. 

  3890. 		},

    3891. 

  3891. 

    3892. 

  3892. 		acquire: function (name) {

    3893. 

  3893. 			var i, c, carray = document.cookie.split(';');

    3894. 

  3894. 			name = name + '=';

    3895. 

  3895. 

    3896. 

  3896. 			for (i = 0; i < carray.length; i += 1) {

    3897. 

  3897. 				c = carray[i];

    3898. 

  3898. 				while (c.charAt(0) === ' ') {c = c.substring(1, c.length);}

    3899. 

  3899. 				if (c.indexOf(name) === 0) {return c.substring(name.length, c.length);}

    3900. 

  3900. 			}

    3901. 

  3901. 

    3902. 

  3902. 			return '';

    3903. 

  3903. 		},

    3904. 

  3904. 

    3905. 

  3905. 		remove: function (name) {this.persist(name, '', -1);},

    3906. 

  3906. 

    3907. 

  3907. 		read: function () {

    3908. 

  3908. 			this.sessionId		= this.acquire('$sessionName');

    3909. 

  3909. 			this.username		= this.acquire('$cookieUsername');

    3910. 

  3910. 			this.passwordHash	= this.acquire('$cookiePassword');

    3911. 

  3911. 			this.staySignedIn	= this.acquire('$cookieStaySignedIn');

    3912. 

  3912. 			this.staySignedIn	= (this.staySignedIn === '') ? false : true;

    3913. 

  3913. 

    3914. 

  3914. 			if (this.username === '') {

    3915. 

  3915. 				this.staySignedIn		= false;

    3916. 

  3916. 			} else {

    3917. 

  3917. 				this.rememberMe			= true;

    3918. 

  3918. 			}

    3919. 

  3919. 

    3920. 

  3920. 			if (this.passwordHash === '') {

    3921. 

  3921. 				that.passwordDefault_SignIn	= false;

    3922. 

  3922. 				this.staySignedIn		= false;

    3923. 

  3923. 			} else {

    3924. 

  3924. 				that.passwordDefault_SignIn	= true;

    3925. 

  3925. 				this.rememberMe			= true;

    3926. 

  3926. 			}

    3927. 

  3927. 		},

    3928. 

  3928. 

    3929. 

  3929. 		update: function () {

    3930. 

  3930. 			this.username = that.getValue('ezuser-$tagUsername');

    3931. 

  3931. 

    3932. 

  3932. //			if (typeof ajaxUnit === 'function') {ajaxUnit('passwordDefault_SignIn = ' + that.passwordDefault_SignIn,	true);}	// Debug

    3933. 

  3933. //			if (typeof ajaxUnit === 'function') {ajaxUnit('this.passwordHash = ' + this.passwordHash,			true);}	// Debug

    3934. 

  3934. 

    3935. 

  3935. 			if (!that.passwordDefault_SignIn || (this.passwordHash === '')) {

    3936. 

  3936. 				var password		= that.getValue('ezuser-$tagPassword');

    3937. 

  3937. 				this.passwordHash	= SHA256('$remoteAddress' + SHA256(password));

    3938. 

  3938. 			}

    3939. 

  3939. 

    3940. 

  3940. //			if (typeof ajaxUnit === 'function') {ajaxUnit('\\$remoteAddress = $remoteAddress',				true);}	// Debug

    3941. 

  3941. //			if (typeof ajaxUnit === 'function') {ajaxUnit('this.passwordHash = ' + this.passwordHash,			true);}	// Debug

    3942. 

  3942. 

    3943. 

  3943. 			if (this.rememberMe) {

    3944. 

  3944. 				// Remember username & password for 30 days

    3945. 

  3945. 				this.persist('$cookieUsername', this.username, 30);

    3946. 

  3946. 				this.persist('$cookiePassword', this.passwordHash, 30);

    3947. 

  3947. 			} else {

    3948. 

  3948. 				this.remove('$cookieUsername');

    3949. 

  3949. 				this.remove('$cookiePassword');

    3950. 

  3950. 			}

    3951. 

  3951. 

    3952. 

  3952. 			if (this.staySignedIn) {

    3953. 

  3953. 				// Stay signed in for 2 weeks

    3954. 

  3954. 				this.persist('$cookieStaySignedIn', true, 24);

    3955. 

  3955. 			} else {

    3956. 

  3956. 				this.remove('$cookieStaySignedIn');

    3957. 

  3957. 			}

    3958. 

  3958. 		},

    3959. 

  3959. 

    3960. 

  3960. 		showPreferences: function () {

    3961. 

  3961. 			that.setButtonState(that.getControl('ezuser-$tagRememberMe'),		4, this.rememberMe);

    3962. 

  3962. 			that.setButtonState(that.getControl('ezuser-$tagStaySignedIn'),	4, this.staySignedIn);

    3963. 

  3963. 		},

    3964. 

  3964. 

    3965. 

  3965. 		toggleRememberMe: function() {

    3966. 

  3966. 			this.rememberMe		= !this.rememberMe;

    3967. 

  3967. 			this.staySignedIn	= (this.rememberMe) ? this.staySignedIn : false;

    3968. 

  3968. 

    3969. 

  3969. 			this.showPreferences();

    3970. 

  3970. 			this.update();

    3971. 

  3971. 		},

    3972. 

  3972. 

    3973. 

  3973. 		toggleStaySignedIn: function() {

    3974. 

  3974. 			this.staySignedIn	= !this.staySignedIn;

    3975. 

  3975. 			this.rememberMe		= (this.staySignedIn) ? true : this.rememberMe;

    3976. 

  3976. 

    3977. 

  3977. 			this.showPreferences();

    3978. 

  3978. 			this.update();

    3979. 

  3979. 		}

    3980. 

  3980. 	};

    3981. 

  3981. 

    3982. 

  3982. /**

    3983. 

  3983.  * AJAX handling

    3984. 

  3984.  */

    3985. 

  3985. 	this.ajax = {

    3986. 

  3986. 		xhr: new window.XMLHttpRequest(),

    3987. 

  3987. 

    3988. 

  3988. 		handleServerResponse: function () {

    3989. 

  3989. 			var id, fail, message, cancelButton;

    3990. 

  3990. 

    3991. 

  3991. 			if ((this.readyState === 4) && (this.status === 200)) {

    3992. 

  3992. 				if (isNaN(this.responseText)) {

    3993. 

  3993. 					id = this.getResponseHeader('ezUser-container');

    3994. 

  3994. 

    3995. 

  3995. 					if (this.responseXML !== null) {

    3996. 

  3996. 						that.fillContainersXML(this.responseXML);

    3997. 

  3997. 					} else if (id === null) {

    3998. 

  3998. 						that.bodyAppend(this.responseText);

    3999. 

  3999. 					} else {

    4000. 

  4000. 						that.fillContainerText(id, this.responseText);

    4001. 

  4001. 					}

    4002. 

  4002. 

    4003. 

  4003. 					that.dialog(id).position();

    4004. 

  4004. 				} else {

    4005. 

  4005. 					fail		= true;

    4006. 

  4006. 					message		= 'Server error, please try later';

    4007. 

  4007. 					cancelButton	= that.getControl('ezuser-$actionCancel');

    4008. 

  4008. 

    4009. 

  4009. 					that.showMessage(message, fail);

    4010. 

  4010. 

    4011. 

  4011. 					if (cancelButton !== null) {

    4012. 

  4012. 						cancelButton.id		= 'ezuser-$actionSignIn';

    4013. 

  4013. 						cancelButton.value	= 'Sign in';

    4014. 

  4014. 						cancelButton.setAttribute('data-ezuser-action', '$actionSignIn');

    4015. 

  4015. 					}

    4016. 

  4016. 				}

    4017. 

  4017. 

    4018. 

  4018. 				if (typeof ajaxUnit === 'function') {ajaxUnit(this);}	// Automated unit testing

    4019. 

  4019. 			}

    4020. 

  4020. 		},

    4021. 

  4021. 

    4022. 

  4022. 		serverTalk: function (URL, requestType, requestData) {

    4023. 

  4023. 			this.xhr.open(requestType, URL);

    4024. 

  4024. 			this.xhr.onreadystatechange = this.handleServerResponse;

    4025. 

  4025. 			this.xhr.setRequestHeader('Accept', 'text/html,application/ezuser');

    4026. 

  4026. 			if (requestType === 'POST') {this.xhr.setRequestHeader('Content-type', 'application/x-www-form-urlencoded');}

    4027. 

  4027. 			this.xhr.send(requestData);

    4028. 

  4028. 		},

    4029. 

  4029. 

    4030. 

  4030. 		execute: function (thisAction) {

    4031. 

  4031. 			var	action,

    4032. 

  4032. 				passwordHash,

    4033. 

  4033. 				equals		= '=',

    4034. 

  4034. 				requestType	= 'GET',

    4035. 

  4035. 				requestData	= '',

    4036. 

  4036. 				URL		= '$URL',

    4037. 

  4037. 				delimPos	= thisAction.indexOf('$delimPlus'),

    4038. 

  4038. 				control,

    4039. 

  4039. 				textNew,

    4040. 

  4040. 				readyState;

    4041. 

  4041. 

    4042. 

  4042. 			thisAction	= (delimPos === -1) ? thisAction : '$action=' + thisAction;

    4043. 

  4043. 			delimPos	= thisAction.indexOf(equals);

    4044. 

  4044. 			action		= (delimPos === -1) ? thisAction : thisAction.slice(0, delimPos);

    4045. 

  4045. 

    4046. 

  4046. 			switch (action) {

    4047. 

  4047. 			case '$actionSignIn':

    4048. 

  4048. 				control		= that.getControl('ezuser-$actionSignIn');

    4049. 

  4049. 				control.id	= 'ezuser-$actionCancel';

    4050. 

  4050. 				control.value	= 'Cancel';

    4051. 

  4051. 				control.setAttribute('data-ezuser-action', '$actionCancel');

    4052. 

  4052. 

    4053. 

  4053. 				that.showMessage('Signing in - please wait');

    4054. 

  4054. 				that.cookies.update();	// Updates ezuser.passwordHash;

    4055. 

  4055. 

    4056. 

  4056. 				passwordHash	= SHA256(that.cookies.sessionId + that.cookies.passwordHash);

    4057. 

  4057. //				if (typeof ajaxUnit === 'function') {ajaxUnit('sessionId = ' + that.cookies.sessionId,		true);}	// Debug

    4058. 

  4058. //				if (typeof ajaxUnit === 'function') {ajaxUnit('passwordHash = ' + passwordHash,			true);}	// Debug

    4059. 

  4059. 				requestData	= '$action='			+ action;

    4060. 

  4060. 				requestData	+= '&$cookieUsername='		+ that.getValue('ezuser-$tagUsername');

    4061. 

  4061. 				requestData	+= '&$cookiePassword='		+ passwordHash;

    4062. 

  4062. 				requestType	= 'POST';

    4063. 

  4063. 

    4064. 

  4064. 				break;

    4065. 

  4065. 			case '$actionValidate':

    4066. 

  4066. 				textNew		= that.getValue('$accountForm-$tagNewUser');

    4067. 

  4067. 				requestData	= '$action='			+ action;

    4068. 

  4068. 				requestData	+= '&$tagNewUser='		+ textNew;

    4069. 

  4069. 				requestData	+= '&$tagWizard='		+ encodeURIComponent(that.getValue('$accountForm-$tagWizard'));

    4070. 

  4070. 				requestData	+= '&$tagEmail='		+ encodeURIComponent(that.getValue('$accountForm-$tagEmail'));

    4071. 

  4071. 				requestData	+= '&$tagFirstName='		+ encodeURIComponent(that.getValue('$accountForm-$tagFirstName'));

    4072. 

  4072. 				requestData	+= '&$tagLastName='		+ encodeURIComponent(that.getValue('$accountForm-$tagLastName'));

    4073. 

  4073. 				requestData	+= '&$cookieUsername='		+ that.getValue('$accountForm-$tagUsername');

    4074. 

  4074. 

    4075. 

  4075. 				if (!that.passwordDefault_Account || (textNew === '$stringTrue')) {

    4076. 

  4076. 					passwordHash	= SHA256(that.getValue('$accountForm-$tagPassword'));

    4077. 

  4077. 					requestData	+= '&$cookiePassword='	+ passwordHash;

    4078. 

  4078. 				}

    4079. 

  4079. 

    4080. 

  4080. 				requestType	= 'POST';

    4081. 

  4081. 

    4082. 

  4082. 				break;

    4083. 

  4083. 			case '$actionCancel':

    4084. 

  4084. 				readyState = this.xhr.readyState;

    4085. 

  4085. 

    4086. 

  4086. 				if ((readyState > 0) && (readyState < 4)) {

    4087. 

  4087. 					// Cancel ongoing sign-in

    4088. 

  4088. 					this.xhr.abort();

    4089. 

  4089. 					this.xhr = new window.XMLHttpRequest();

    4090. 

  4090. 				}

    4091. 

  4091. 

    4092. 

  4092. 				return;

    4093. 

  4093. 			case '$actionResend':

    4094. 

  4094. 				URL += '?' + thisAction + equals + encodeURIComponent(that.getValue('$accountForm-$tagEmail'));

    4095. 

  4095. 				break;

    4096. 

  4096. 			case '$actionResetPassword':		// Fall-through ->

    4097. 

  4097. 			case '$actionResetRequest':

    4098. 

  4098. 				URL += '?' + thisAction + equals + that.getValue('ezuser-$tagUsername');

    4099. 

  4099. 				break;

    4100. 

  4100. 			case '$actionReset':

    4101. 

  4101. 				passwordHash = SHA256(that.getValue('ezuser-$actionReset-$tagPassword'));

    4102. 

  4102. 				URL = window.location.href + '&$cookiePassword=' + passwordHash;

    4103. 

  4103. 				break;

    4104. 

  4104. 			default:

    4105. 

  4105. 				URL += '?' + thisAction;

    4106. 

  4106. 				break;

    4107. 

  4107. 			}

    4108. 

  4108. 

    4109. 

  4109. 			this.serverTalk(URL, requestType, requestData);

    4110. 

  4110. 		}

    4111. 

  4111. 	};

    4112. 

  4112. 

    4113. 

  4113. /**

    4114. 

  4114.  * Account wizard page handling

    4115. 

  4115.  */

    4116. 

  4116. 	this.wizard = {

    4117. 

  4117. 		page: 1,

    4118. 

  4118. 

    4119. 

  4119. 		changePage: function (delta) {

    4120. 

  4120. 			var nextPageId, nextPage;

    4121. 

  4121. 

    4122. 

  4122. 			if (this.getValue('$accountForm-$tagWizard') === '$stringFalse') {return;}	// Not in wizard mode

    4123. 

  4123. 

    4124. 

  4124. 			this.page = (arguments.length === 0) ? 1 : this.page + delta;

    4125. 

  4125. 			if (this.page < 1) {this.page = 1;}

    4126. 

  4126. 

    4127. 

  4127. 			// Previous page

    4128. 

  4128. 			if (this.page === 1) {

    4129. 

  4129. 				hideControl('$accountForm-back');				// Hide 'Back' button

    4130. 

  4130. 			} else {

    4131. 

  4131. 				showControl('$accountForm-back');				// Show 'Back' button

    4132. 

  4132. 				hideControl('$accountForm-fieldset-' + (this.page - 1));	// Hide previous page

    4133. 

  4133. 			}

    4134. 

  4134. 

    4135. 

  4135. 			// Current page

    4136. 

  4136. 			showControl('$accountForm-fieldset-' + this.page);			// Show this page

    4137. 

  4137. 

    4138. 

  4138. 			// Next page

    4139. 

  4139. 			nextPageId	= '$accountForm-fieldset-' + (this.page + 1);

    4140. 

  4140. 			nextPage	= this.getControl(nextPageId);

    4141. 

  4141. 

    4142. 

  4142. 			if (nextPage === null) {

    4143. 

  4143. 				hideControl('$accountForm-next');				// Hide 'Next' button

    4144. 

  4144. 			} else {

    4145. 

  4145. 				showControl('$accountForm-next');				// Show 'Next' button

    4146. 

  4146. 				hideControl(nextPageId);					// Hide next page

    4147. 

  4147. 			}

    4148. 

  4148. 		},

    4149. 

  4149. 

    4150. 

  4150. 		pageNext:	function () {this.changePage(1);},

    4151. 

  4151. 		pageBack:	function () {this.changePage(-1);},

    4152. 

  4152. 		initialize:	function () {this.page = 1;}

    4153. 

  4153. 	};

    4154. 

  4154. 

    4155. 

  4155. /**

    4156. 

  4156.  * Responds to clicks on the ezUser form

    4157. 

  4157.  */

    4158. 

  4158. 	this.click = function (control) {

    4159. 

  4159. 		var	id	= control.id,

    4160. 

  4160. 			action	= control.getAttribute('data-ezuser-action');

    4161. 

  4161. 

    4162. 

  4162. 		switch (id) {

    4163. 

  4163. 		case 'ezuser-$actionAccountForm':

    4164. 

  4164. 			$accountClick;

    4165. 

  4165. 			break;

    4166. 

  4166. 		case 'ezuser-$tagRememberMe':

    4167. 

  4167. 			this.cookies.toggleRememberMe();

    4168. 

  4168. 			break;

    4169. 

  4169. 		case 'ezuser-$tagStaySignedIn':

    4170. 

  4170. 			this.cookies.toggleStaySignedIn();

    4171. 

  4171. 			break;

    4172. 

  4172. 		case '$accountForm-next':

    4173. 

  4173. 			this.wizard.pageNext();	// Next wizard page

    4174. 

  4174. 			break;

    4175. 

  4175. 		case '$accountForm-back':

    4176. 

  4176. 			this.wizard.pageBack();	// Previous wizard page

    4177. 

  4177. 			break;

    4178. 

  4178. 		case 'ezuser-$tagVerbose':

    4179. 

  4179. 			this.ajax.execute('$actionResultForm=' + control.value);

    4180. 

  4180. 			break;

    4181. 

  4181. 		case 'ezuser-$actionResetPassword':	// Fall-through ->

    4182. 

  4182. 		case 'ezuser-$actionReset-OK':		// Fall-through ->

    4183. 

  4183. 		case '$accountForm-$actionValidate':

    4184. 

  4184. 			if (this.localValidation(control.form.id)) {this.ajax.execute(action);}

    4185. 

  4185. 			break;

    4186. 

  4186. 		default:

    4187. 

  4187. 			if (action === null) {break;}

    4188. 

  4188. 			this.ajax.execute(action);

    4189. 

  4189. 			break;

    4190. 

  4190. 		}

    4191. 

  4191. 

    4192. 

  4192. 		return false;

    4193. 

  4193. 	};

    4194. 

  4194. 

    4195. 

  4195. /**

    4196. 

  4196.  * Responds to keypresses on the ezUser form

    4197. 

  4197.  */

    4198. 

  4198. 	this.keyPress = function (e) {

    4199. 

  4199. 		if (!e) {e = window.event;}

    4200. 

  4200. 

    4201. 

  4201. 		var formId, id, target, status = true;

    4202. 

  4202. 

    4203. 

  4203. 		// Process Carriage Return and tidy up form

    4204. 

  4204. 		target	= (e.target) ? e.target : e.srcElement;

    4205. 

  4205. 		formId	= target.form.id;

    4206. 

  4206. 		id	= target.id;

    4207. 

  4207. 

    4208. 

  4208. 		if (formId === '$accountForm-form' && id === '$accountForm-$tagUsername') {

    4209. 

  4209. 			// If we are messing with the username then forget creating a default

    4210. 

  4210. 			this.usernameDefault_Account = false;

    4211. 

  4211. 

    4212. 

  4212. 			if ('' === this.removeIllegalCharacters(String.fromCharCode(e.charCode))) {

    4213. 

  4213. 				status = false; // cancel the event (i.e. don't allow the character)

    4214. 

  4214. 			}

    4215. 

  4215. 		}

    4216. 

  4216. 

    4217. 

  4217. 		return status;

    4218. 

  4218. 	};

    4219. 

  4219. 

    4220. 

  4220. 	this.keyUp = function (e) {

    4221. 

  4221. 		if (!e) {e = window.event;}

    4222. 

  4222. 		var formId, id, control, target;

    4223. 

  4223. 

    4224. 

  4224. 		// Process Carriage Return and tidy up form

    4225. 

  4225. 		target	= (e.target) ? e.target : e.srcElement;

    4226. 

  4226. 		formId	= target.form.id;

    4227. 

  4227. 		id	= target.id;

    4228. 

  4228. 

    4229. 

  4229. 		switch (formId) {

    4230. 

  4230. 		case 'ezuser-$actionSignIn-form':

    4231. 

  4231. 			if (id === 'ezuser-$tagPassword' && this.passwordDefault_SignIn) {

    4232. 

  4232. 				// Forget password from cookie

    4233. 

  4233. 				this.cookies.passwordHash	= '';

    4234. 

  4234. 				this.passwordDefault_SignIn	= false;

    4235. 

  4235. 			}

    4236. 

  4236. 

    4237. 

  4237. 			if (e.keyCode === 13) {

    4238. 

  4238. 				this.click(this.getControl('ezuser-$actionSignIn'));

    4239. 

  4239. 			} else {

    4240. 

  4240. 				this.showMessage(); // Hide message

    4241. 

  4241. 			}

    4242. 

  4242. 

    4243. 

  4243. 			break;

    4244. 

  4244. 		case '$accountForm-form':

    4245. 

  4245. 			switch (id) {

    4246. 

  4246. 			case '$accountForm-$tagFirstName':

    4247. 

  4247. 			case '$accountForm-$tagLastName':

    4248. 

  4248. 				if (this.getValue('$accountForm-$tagUsername') === '') {this.usernameDefault_Account = true;}

    4249. 

  4249. 				if (this.usernameDefault_Account) {this.normalizeUsername(this.getValue('$accountForm-$tagFirstName') + this.getValue('$accountForm-$tagLastName'));}

    4250. 

  4250. 				break;

    4251. 

  4251. 			case '$accountForm-$tagPassword':

    4252. 

  4252. 				this.passwordSaved = target.value;

    4253. 

  4253. 				this.passwordDefault_Account = false;

    4254. 

  4254. 				break;

    4255. 

  4255. 			case '$accountForm-$tagConfirm':

    4256. 

  4256. 				this.passwordDefault_Account = false;

    4257. 

  4257. 				break;

    4258. 

  4258. 			}

    4259. 

  4259. 

    4260. 

  4260. 			if (e.keyCode === 13) {

    4261. 

  4261. 				control = this.getControl('$accountForm-$actionValidate');

    4262. 

  4262. 				if (control === null) {control = this.getControl('$accountForm-$modeEdit');}

    4263. 

  4263. 				this.click(control);

    4264. 

  4264. 			} else {

    4265. 

  4265. 				this.showMessage('', false, '$messageTypeText', '$accountForm'); // Hide message

    4266. 

  4266. 			}

    4267. 

  4267. 

    4268. 

  4268. 			break;

    4269. 

  4269. 		case 'ezuser-$actionReset-form':

    4270. 

  4270. 			if (e.keyCode === 13) {

    4271. 

  4271. 				this.click(this.getControl('ezuser-$actionReset-OK'));

    4272. 

  4272. 			} else {

    4273. 

  4273. 				this.showMessage('', false, '$messageTypeText'); // Hide message

    4274. 

  4274. 			}

    4275. 

  4275. 

    4276. 

  4276. 			break;

    4277. 

  4277. 		}

    4278. 

  4278. 

    4279. 

  4279. 		return true;

    4280. 

  4280. 	};

    4281. 

  4281. 

    4282. 

  4282. /**

    4283. 

  4283.  * Manages the ezUser forms as dialog boxes

    4284. 

  4284.  */

    4285. 

  4285. 	 this.dialog = function(id) {

    4286. 

  4286. 		this.control = document.getElementById(id);

    4287. 

  4287. 

    4288. 

  4288. 		this.windowRect = function() {

    4289. 

  4289. 			var	width	= 0,

    4290. 

  4290. 				height	= 0;

    4291. 

  4291. 

    4292. 

  4292. 			if (typeof window.innerWidth === 'number') {

    4293. 

  4293. 				width	= window.innerWidth;

    4294. 

  4294. 				height	= window.innerHeight;

    4295. 

  4295. 			} else if (document.documentElement && document.documentElement.clientWidth) {

    4296. 

  4296. 				width	= document.documentElement.clientWidth;

    4297. 

  4297. 				height	= document.documentElement.clientHeight;

    4298. 

  4298. 			} else if (document.body && document.body.clientWidth) {

    4299. 

  4299. 				width	= document.body.clientWidth;

    4300. 

  4300. 				height	= document.body.clientHeight;

    4301. 

  4301. 			}

    4302. 

  4302. 

    4303. 

  4303. 			return {width: width, height: height};

    4304. 

  4304. 		};

    4305. 

  4305. 

    4306. 

  4306. 		this.rect = function() {

    4307. 

  4307. 			return {width: this.control.offsetWidth, height: this.control.offsetHeight};

    4308. 

  4308. 		};

    4309. 

  4309. 

    4310. 

  4310. 		this.position = function() {

    4311. 

  4311. 			var	dialogRect		= this.rect(),

    4312. 

  4312. 				windowRect		= this.windowRect(),

    4313. 

  4313. 				goldenSectionCenter	= 2 * windowRect.height / (3 + Math.sqrt(5)),

    4314. 

  4314. 				dialogCenter		= dialogRect.height / 2,

    4315. 

  4315. 				top			= (goldenSectionCenter	> dialogCenter)		? (goldenSectionCenter		- dialogCenter)			+ 'px' : 0,

    4316. 

  4316. 				left			= (windowRect.width	> dialogRect.width)	? ((windowRect.width / 2)	- (dialogRect.width / 2))	+ 'px' : 0;

    4317. 

  4317. 

    4318. 

  4318. 				this.control.style.position	= 'absolute';

    4319. 

  4319. 				this.control.style.left		= left;

    4320. 

  4320. 				this.control.style.top		= top;

    4321. 

  4321. 		};

    4322. 

  4322. 

    4323. 

  4323. 		return this;

    4324. 

  4324. 	};

    4325. 

  4325. 

    4326. 

  4326. // ---------------------------------------------------------------------------

    4327. 

  4327. 	this.fillContainerText = function (id, html) {

    4328. 

  4328. 		var	container	= this.getControl(id),

    4329. 

  4329. 			containerList,

    4330. 

  4330. 			formList,

    4331. 

  4331. 			formId;

    4332. 

  4332. 

    4333. 

  4333. 		if (container === null || typeof container === 'undefined') {

    4334. 

  4334. 			containerList = document.getElementsByTagName(id);

    4335. 

  4335. 

    4336. 

  4336. 			if (containerList === null || typeof containerList === 'undefined' || containerList.length === 0) {

    4337. 

  4337. 				window.alert('Can\\'t find a container \\'' + id + '\\' for this content: ' + html.substring(0, 256));

    4338. 

  4338. 				return;

    4339. 

  4339. 			} else {

    4340. 

  4340. 				container = containerList[0];

    4341. 

  4341. 			}

    4342. 

  4342. 		}

    4343. 

  4343. 

    4344. 

  4344. 		if (container.className.length === 0) {container.className = id;} // IE6 uses container.class

    4345. 

  4345. 

    4346. 

  4346. 		container.innerHTML	= html;

    4347. 

  4347. 		formList		= container.getElementsByTagName('form');

    4348. 

  4348. 		formId			= ((typeof formList === 'undefined') || (formList.length === 0)) ? '' : formList[0].getAttribute('id');

    4349. 

  4349. 

    4350. 

  4350. 		switch (formId) {

    4351. 

  4351. 		case 'ezuser-$actionSignIn-form':

    4352. 

  4352. 			this.cookies.showPreferences();

    4353. 

  4353. 

    4354. 

  4354. 			if (this.cookies.rememberMe) {

    4355. 

  4355. 				this.passwordDefault_SignIn = true;

    4356. 

  4356. 				this.setValue('ezuser-$tagUsername', this.cookies.username);

    4357. 

  4357. 				this.setValue('ezuser-$tagPassword', '$passwordMask');

    4358. 

  4358. 			}

    4359. 

  4359. 

    4360. 

  4360. 			break;

    4361. 

  4361. 		case '$accountForm-form':

    4362. 

  4362. 			this.wizard.initialize(); // Set wizard to page 1

    4363. 

  4363. 			this.usernameDefault_Account = (this.getValue('$accountForm-$tagUsername') === '');

    4364. 

  4364. 			this.passwordDefault_Account = (this.getValue('$accountForm-$tagNewUser') !== '$stringTrue');

    4365. 

  4365. 

    4366. 

  4366. 			if (this.getValue('$accountForm-$tagUseSavedPassword') === '$stringTrue') {

    4367. 

  4367. 				this.setValue('$accountForm-$tagPassword', this.passwordSaved);

    4368. 

  4368. 				this.setValue('$accountForm-$tagConfirm', this.passwordSaved);

    4369. 

  4369. 			} else {

    4370. 

  4370. 				this.savedPassword = '';

    4371. 

  4371. 			}

    4372. 

  4372. 

    4373. 

  4373. 			break;

    4374. 

  4374. 		}

    4375. 

  4375. 

    4376. 

  4376. 		setInitialFocus(id);

    4377. 

  4377. 	};

    4378. 

  4378. 

    4379. 

  4379. // ---------------------------------------------------------------------------

    4380. 

  4380. 	this.fillContainersXML = function (xml) {

    4381. 

  4381. 		var i, iHalt, id, html, formNode, formList;

    4382. 

  4382. 

    4383. 

  4383. 		formList	= xml.childNodes;

    4384. 

  4384. 		iHalt		= formList.length;

    4385. 

  4385. 

    4386. 

  4386. 		for (i = 0; i < iHalt; i++) {

    4387. 

  4387. 			formNode = formList[i];

    4388. 

  4388. 

    4389. 

  4389. 			switch (formNode.nodeType) {

    4390. 

  4390. 			case 1: // Node.ELEMENT_NODE: // recurse

    4391. 

  4391. 				this.fillContainersXML(formNode);

    4392. 

  4392. 				break;

    4393. 

  4393. 			case 4: // Node.CDATA_SECTION_NODE: // fill the container

    4394. 

  4394. 				id	= formNode.parentNode.getAttribute('container');

    4395. 

  4395. 				html	= formNode.nodeValue;

    4396. 

  4396. 

    4397. 

  4397. 				this.fillContainerText(id, html);

    4398. 

  4398. 				break;

    4399. 

  4399. 			case 3: // Node.TEXT_NODE:

    4400. 

  4400. 			case 7: // Node.PROCESSING_INSTRUCTION_NODE: // Usually caused by PHP passing an error message along with the XHR content

    4401. 

  4401. 			case 8: // Node.COMMENT_NODE

    4402. 

  4402. 				break; // Ignore

    4403. 

  4403. 			default:

    4404. 

  4404. 				window.alert('I wasn\\'t expecting a node type of ' + formNode.nodeType);

    4405. 

  4405. 				break;

    4406. 

  4406. 			}

    4407. 

  4407. 		}

    4408. 

  4408. 	};

    4409. 

  4409. 

    4410. 

  4410. // ---------------------------------------------------------------------------

    4411. 

  4411. 	this.localValidation = function (formId) {

    4412. 

  4412. 		var	control,

    4413. 

  4413. 			textEmail,

    4414. 

  4414. 			textUsername,

    4415. 

  4415. 			textPassword,

    4416. 

  4416. 			textConfirm,

    4417. 

  4417. 			textNew,

    4418. 

  4418. 			instance,

    4419. 

  4419. 			message		= '';

    4420. 

  4420. 

    4421. 

  4421. 		switch (formId) {

    4422. 

  4422. 		case '$accountForm-form':

    4423. 

  4423. 			textEmail	= this.getControl('$accountForm-$tagEmail');

    4424. 

  4424. 			textUsername	= this.getControl('$accountForm-$tagUsername');

    4425. 

  4425. 			textPassword	= this.getControl('$accountForm-$tagPassword');

    4426. 

  4426. 			textConfirm	= this.getControl('$accountForm-$tagConfirm');

    4427. 

  4427. 			textNew		= this.getControl('$accountForm-$tagNewUser');

    4428. 

  4428. 			instance	= '$accountForm';

    4429. 

  4429. 

    4430. 

  4430. 			// Valid email address

    4431. 

  4431. 			if (textEmail.value === '') {

    4432. 

  4432. 				message = 'You must provide an email address';

    4433. 

  4433. 				control	= textEmail;

    4434. 

  4434. 			} else {

    4435. 

  4435. 				// Valid username

    4436. 

  4436. 				this.normalizeUsername(textUsername.value);

    4437. 

  4437. 

    4438. 

  4438. 				if (textUsername.value === '') {

    4439. 

  4439. 					message = 'The username cannot be blank';

    4440. 

  4440. 					control	= textUsername;

    4441. 

  4441. 				} else {

    4442. 

  4442. 					// Password OK?

    4443. 

  4443. 					if (textPassword.value !== textConfirm.value) {

    4444. 

  4444. 						message = 'Passwords are not the same';

    4445. 

  4445. 					} else if (this.passwordDefault_Account) {

    4446. 

  4446. 						if (textNew.value === '$stringTrue') {message = 'Password cannot be blank';}

    4447. 

  4447. 					} else if (textPassword.value === '') {

    4448. 

  4448. 						message = 'Password cannot be blank';

    4449. 

  4449. 					}

    4450. 

  4450. 

    4451. 

  4451. 					control	= textPassword;

    4452. 

  4452. 				}

    4453. 

  4453. 			}

    4454. 

  4454. 

    4455. 

  4455. 			break;

    4456. 

  4456. 		case 'ezuser-$actionReset-form':

    4457. 

  4457. 			textPassword	= this.getControl('ezuser-$actionReset-$tagPassword');

    4458. 

  4458. 			textConfirm	= this.getControl('ezuser-$actionReset-$tagConfirm');

    4459. 

  4459. 			instance	= 'ezuser';

    4460. 

  4460. 			control		= textPassword;

    4461. 

  4461. 

    4462. 

  4462. 			// Password OK?

    4463. 

  4463. 			if (textPassword.value !== textConfirm.value) {

    4464. 

  4464. 				message = 'Passwords are not the same';

    4465. 

  4465. 			} else if (textPassword.value === '') {

    4466. 

  4466. 				message = 'Password cannot be blank';

    4467. 

  4467. 			}

    4468. 

  4468. 

    4469. 

  4469. 			break;

    4470. 

  4470. 		case 'ezuser-$actionResetRequest-form':

    4471. 

  4471. 			textUsername	= this.getControl('ezuser-$tagUsername');

    4472. 

  4472. 			instance	= 'ezuser';

    4473. 

  4473. 			control		= textUsername;

    4474. 

  4474. 

    4475. 

  4475. 			// Username entered?

    4476. 

  4476. 			if (textUsername.value === '') {message = 'Username cannot be blank';}

    4477. 

  4477. 			break;

    4478. 

  4478. 		}

    4479. 

  4479. 

    4480. 

  4480. 		if (message === '') {

    4481. 

  4481. 			return true;

    4482. 

  4482. 		} else {

    4483. 

  4483. 			this.showMessage(message, true, '$messageTypeText', instance);

    4484. 

  4484. 			setFocus(control);

    4485. 

  4485. 			return false;

    4486. 

  4486. 		}

    4487. 

  4487. 	};

    4488. 

  4488. 

    4489. 

  4489. // ---------------------------------------------------------------------------

    4490. 

  4490. 	this.removeIllegalCharacters = function (restrictedString) {

    4491. 

  4491. 		var	regexString	= '[^0-9A-Za-z_-]',

    4492. 

  4492. 			regex		= new RegExp(regexString, 'g');

    4493. 

  4493. 

    4494. 

  4494. 		return restrictedString.replace(regex, '');

    4495. 

  4495. 	}

    4496. 

  4496. 

    4497. 

  4497. 	this.normalizeUsername = function (username) {

    4498. 

  4498. 		username		= this.removeIllegalCharacters(username);

    4499. 

  4499. 

    4500. 

  4500. 		var control		= this.getControl('$accountForm-$tagUsername');

    4501. 

  4501. 		control.defaultValue	= username;

    4502. 

  4502. 		control.value		= username;

    4503. 

  4503. 	};

    4504. 

  4504. 

    4505. 

  4505. // ---------------------------------------------------------------------------

    4506. 

  4506. 	this.addStyleSheet = function () {

    4507. 

  4507. 		var	htmlHead	= document.getElementsByTagName('head')[0],

    4508. 

  4508. 			nodeList	= htmlHead.getElementsByTagName('link'),

    4509. 

  4509. 			elementCount	= nodeList.length,

    4510. 

  4510. 			found		= false,

    4511. 

  4511. 			i, node;

    4512. 

  4512. 

    4513. 

  4513. 		for (i = 0; i < elementCount; i++) {

    4514. 

  4514. 			if (nodeList[i].title === 'ezUser') {

    4515. 

  4515. 				found = true;

    4516. 

  4516. 				break;

    4517. 

  4517. 			}

    4518. 

  4518. 		}

    4519. 

  4519. 

    4520. 

  4520. 		if (!found) {

    4521. 

  4521. 			// Add style sheet

    4522. 

  4522. 			node		= document.createElement('link');

    4523. 

  4523. 			node.type	= 'text/css';

    4524. 

  4524. 			node.rel	= 'stylesheet';

    4525. 

  4525. 			node.href	= '$URL?$actionCSS';

    4526. 

  4526. 			node.title	= 'ezUser';

    4527. 

  4527. 			htmlHead.appendChild(node);

    4528. 

  4528. 		}

    4529. 

  4529. 	};

    4530. 

  4530. 

    4531. 

  4531. 	this.passwordFocus = function (control) {

    4532. 

  4532. 		switch (control.form.id) {

    4533. 

  4533. 		case 'ezuser-$actionSignIn-form':

    4534. 

  4534. 			if (this.passwordDefault_SignIn) {control.value = '';}

    4535. 

  4535. 			break;

    4536. 

  4536. 		case '$accountForm-form':

    4537. 

  4537. 			if (this.passwordDefault_Account) {

    4538. 

  4538. 				this.setValue('$accountForm-$tagPassword', '');

    4539. 

  4539. 				this.setValue('$accountForm-$tagConfirm', '');

    4540. 

  4540. 			}

    4541. 

  4541. 			break;

    4542. 

  4542. 		}

    4543. 

  4543. 

    4544. 

  4544. 		return true;

    4545. 

  4545. 	};

    4546. 

  4546. 

    4547. 

  4547. 	this.passwordBlur = function (control) {

    4548. 

  4548. 		switch (control.form.id) {

    4549. 

  4549. 		case 'ezuser-$actionSignIn-form':

    4550. 

  4550. 			if (this.passwordDefault_SignIn) {control.value = '$passwordMask';}

    4551. 

  4551. 			break;

    4552. 

  4552. 		case '$accountForm-form':

    4553. 

  4553. 			if (this.passwordDefault_Account) {

    4554. 

  4554. 				this.setValue('$accountForm-$tagPassword', '$passwordMask');

    4555. 

  4555. 				this.setValue('$accountForm-$tagConfirm', '$passwordMask');

    4556. 

  4556. 			}

    4557. 

  4557. 			break;

    4558. 

  4558. 		}

    4559. 

  4559. 

    4560. 

  4560. 		return true;

    4561. 

  4561. 	};

    4562. 

  4562. 

    4563. 

  4563. /**

    4564. 

  4564.  * Constructor

    4565. 

  4565.  */

    4566. 

  4566. 	this.cookies.read();

    4567. 

  4567. 	this.addStyleSheet();

    4568. 

  4568. }

    4569. 

  4569. 

    4570. 

  4570. /**

    4571. 

  4571.  * Do stuff

    4572. 

  4572.  */

    4573. 

  4573. var ezUser = new C_ezUser();

    4574. 

  4574. $immediateJavascript
    4575. 

  4575. GENERATED;
    4576. 

  4576. // Generated code - do not modify in built package

    4577. 

  4577. 

    4578. 

  4578. 		if ($sendToBrowser) {self::sendContent($js, '', 'text/javascript'); return '';} else return $js;

    4579. 

  4579. 	}

    4580. 

  4580. 

    4581. 

  4581. 	public static /*.string.*/ function inlineBitmap(/*.string.*/ $id, $sendToBrowser = true) {

    4582. 

  4582. 		switch ($id) {

    4583. 

  4583. 		case 'close':

    4584. 

  4584. 			$mimeType	= 'image/gif';

    4585. 

  4585. 			$bitmap		= base64_decode('R0lGODlhKAAoAIQaAMzMzM3Nzc7Ozs/Pz9DQ0NLS0tXV1djY2Nra2tvb293d3d7e3uDg4OHh4ePj4+np6erq6uzs7O7u7vPz8/X19fb29vn5+fr6+vz8/P7+/v///////////////////////yH+IUNvcHlyaWdodCAoYykgMjAxMCBEb21pbmljIFNheWVycwAh+QQBCgAfACwAAAAAKAAoAAAF/uAnjmT5EcQQBANqvvArtI00WVlmTVKTCrHgaOagaI7I5JHiGACFMsYlSZE8HI6HxIi8MJ5QkaBQQU4aBYB6rS40JshKARwcHDDHCoLN5yPKGhgHA0IDCxkaGQ59jHwOiBkLhDACB4gYe42aagh4GQd0JAV4GAabpwAGpAUyZRmZqJsIiBWhAgxHi2sKEQmoCxEMbA5HXyQDUxVsuEcQmxBICmxlF5MfAsQasAARSc6M0EgRbAi5TwNGE3wLSt9s4Ui+bHAUkwRHDX3wze/tfQ1HCIgAqCGNPn8A9mlwx6YAvhMSNFDQpBBCRU1GJKCAI+GZEoSNIk5IYUHDg1MK5pEwZPRAgwUViHR5BKmJWIYVMVGlXMnIJouSJ2d+5Mmn5UsCHIV+XLhJJIqIExtVvNgoo0CCBvlQpcrHoYYGIu59PeitX1k+BAV+QKdBHZsENNUoXMCH3iRsR7Z1Uyk1ybg15TQ4AINMg7JdfCkiEbaGmrVrzGQCYBCB7qkEEaStyWaMhABX22IxmmU4lIhRgUyJZqQqECsZlgKFXt0pEagYhiBJFv0okaRCd/LMbvTniKDHMcYAaoumkRs4eeaEGSKFihUsWrgc8WI6DBHtS5c06T79Gg0bOHTw8OGkfBgUKli4KB8CADs=');	// Generated code - do not modify in built package

    4586. 

  4586. 			break;

    4587. 

  4587. 		default:

    4588. 

  4588. 			$mimeType	= '';

    4589. 

  4589. 			$bitmap		= 'Unknown bitmap';

    4590. 

  4590. 		}

    4591. 

  4591. 

    4592. 

  4592. 		if ($sendToBrowser) {self::sendContent($bitmap, 'bitmap', $mimeType); return '';} else return $bitmap;

    4593. 

  4593. 	}

    4594. 

  4594. 

    4595. 

  4595. 

    4596. 

  4596. // ---------------------------------------------------------------------------

    4597. 

  4597. // Account verification

    4598. 

  4598. // ---------------------------------------------------------------------------

    4599. 

  4599. 	private static /*.string.*/ function verify_renotify($username_or_email = '', $sendToBrowser = false) {

    4600. 

  4600. 		$success	= self::verify_notify($username_or_email);

    4601. 

  4601. 		$message	= ($success) ? 'Verification email has been resent.' : 'Verification email was not sent: please try again later';

    4602. 

  4602. 		$container	= self::getInstanceId(self::ACTION_ACCOUNT . '-' . self::MESSAGE_TYPE_TEXT);

    4603. 

  4603. 

    4604. 

  4604. 		if ($sendToBrowser) {self::sendContent($message, $container); return '';} else return $message;

    4605. 

  4605. 	}

    4606. 

  4606. 

    4607. 

  4607. 	private static /*.void.*/ function verify(/*.string.*/ $verificationKey) {

    4608. 

  4608. 		$title	= 'Email address verification';

    4609. 

  4609. 		$ezUser	= self::lookup($verificationKey, self::TAGNAME_VERIFICATIONKEY);

    4610. 

  4610. 

    4611. 

  4611. 		switch ($ezUser->status()) {

    4612. 

  4612. 		case self::STATUS_PENDING:

    4613. 

  4613. 			self::verify_update($ezUser, $verificationKey);

    4614. 

  4614. 			$message = 'Your email address has been confirmed. You can now close this browser tab.';

    4615. 

  4615. 			break;

    4616. 

  4616. 		case self::STATUS_CONFIRMED:

    4617. 

  4617. 			$message = 'This email address has already been verified.';

    4618. 

  4618. 			break;

    4619. 

  4619. 		default:

    4620. 

  4620. 			$message = 'Sorry, this is not a valid account verification key.';

    4621. 

  4621. 			break;

    4622. 

  4622. 		}

    4623. 

  4623. 

    4624. 

  4624. 		self::htmlMessagePage($title, $message, true);

    4625. 

  4625. 	}

    4626. 

  4626. 

    4627. 

  4627. // ---------------------------------------------------------------------------

    4628. 

  4628. // Password reset

    4629. 

  4629. // ---------------------------------------------------------------------------

    4630. 

  4630. 	private static /*.void.*/ function passwordReset_validate(/*.string.*/ $username_or_email) {

    4631. 

  4631. 		if ($username_or_email === '')

    4632. 

  4632. 			self::htmlResetRequest($username_or_email, true);

    4633. 

  4633. 		else {

    4634. 

  4634. 			$message =	(self::passwordReset_initialize($username_or_email))

    4635. 

  4635. 					? 'An email has been sent to your registered address with instructions for resetting your password.'

    4636. 

  4636. 					: 'Couldn\'t complete password reset for this user.';

    4637. 

  4637. 

    4638. 

  4638. 			self::htmlMessageForm($message, self::ACTION_RESET, true);

    4639. 

  4639. 		}

    4640. 

  4640. 	}

    4641. 

  4641. 

    4642. 

  4642. 	private static /*.void.*/ function passwordReset_reset(/*.string.*/ $resetKey) {

    4643. 

  4643. 		$title	= 'Password reset';

    4644. 

  4644. 		$ezUser	= self::lookup($resetKey, self::TAGNAME_RESETKEY);

    4645. 

  4645. 

    4646. 

  4646. 		if ($ezUser->status() === self::STATUS_UNKNOWN) {

    4647. 

  4647. 			self::htmlMessagePage($title, 'Sorry, this is not a valid password reset key.', true);

    4648. 

  4648. 			return;

    4649. 

  4649. 		}

    4650. 

  4650. 

    4651. 

  4651. 		// Is there a password hash in $_GET?

    4652. 

  4652. 		if (array_key_exists(self::COOKIE_PASSWORD, $_GET)) {

    4653. 

  4653. 			// Attempt to update user's account with the new password

    4654. 

  4654. 			$passwordHash = (string) $_GET[self::COOKIE_PASSWORD];

    4655. 

  4655. 			self::passwordReset_update($ezUser, $passwordHash);

    4656. 

  4656. 			self::htmlMessagePage($title, 'Your password has been updated. You can now close this browser tab.', true);

    4657. 

  4657. 		} else {

    4658. 

  4658. 			// Get the new password from the user

    4659. 

  4659. 			self::htmlResetPassword($ezUser, true);

    4660. 

  4660. 		}

    4661. 

  4661. 	}

    4662. 

  4662. 

    4663. 

  4663. // ---------------------------------------------------------------------------

    4664. 

  4664. // Secure content handling

    4665. 

  4665. // ---------------------------------------------------------------------------

    4666. 

  4666. 	private static /*.string.*/ function htmlSecureContent($sendToBrowser = false) {

    4667. 

  4667. 		$ezUser		= self::getSessionObject();

    4668. 

  4668. 		$refererKey	= 'HTTP_REFERER';

    4669. 

  4669. 

    4670. 

  4670. 		if (array_key_exists($refererKey, $_SERVER)) {

    4671. 

  4671. 			$referer = $_SERVER[$refererKey];

    4672. 

  4672. 

    4673. 

  4673. 			if ($ezUser->authenticated()) {

    4674. 

  4674. 				$html = self::getSecureContent($referer);

    4675. 

  4675. 			} else {

    4676. 

  4676. 				header('HTTP/1.1 403 Forbidden', false, 403);

    4677. 

  4677. 				$referer = (string) str_replace('http://' . $_SERVER['HTTP_HOST'], '' , $referer);

    4678. 

  4678. 				$html = <<<HTML

    4679. 

  4679. <h1>Forbidden</h1>

    4680. 

  4680. <p>You don't have permission to access $referer on this server.</p>

    4681. 

  4681. HTML;

    4682. 

  4682. 			}

    4683. 

  4683. 		} else {

    4684. 

  4684. 			$html = 'No referer';

    4685. 

  4685. 		}

    4686. 

  4686. 

    4687. 

  4687. 		if ($sendToBrowser) {self::sendContent($html, self::ACTION_BODY); return '';} else return $html;

    4688. 

  4688. 	}

    4689. 

  4689. 

    4690. 

  4690. // ---------------------------------------------------------------------------

    4691. 

  4691. // Sign in and sign out

    4692. 

  4692. // ---------------------------------------------------------------------------

    4693. 

  4693. 

    4694. 

  4694. 	private static /*.void.*/ function fatalError(/*.int.*/ $result, $more = '') {

    4695. 

  4695. 		self::htmlResultForm($result, $more, true);

    4696. 

  4696. 		exit;

    4697. 

  4697. 	}

    4698. 

  4698. 

    4699. 

  4699. // ---------------------------------------------------------------------------

    4700. 

  4700. 	/*. forward public static void function doActions(array[string]string $actions); .*/

    4701. 

  4701. 

    4702. 

  4702. 	private static /*.void.*/ function signOut() {

    4703. 

  4703. 		$ezUser	= self::getSessionObject();

    4704. 

  4704. 		if (!$ezUser->authenticated()) return;	// Not signed in so nothing to do

    4705. 

  4705. 

    4706. 

  4706. 		// Sign out then check if a post-signout function has been registered

    4707. 

  4707. 		$ezUser->authenticate();		// Sign out

    4708. 

  4708. 		$ezUser->addSignOutAction(self::ACTION_MAIN);

    4709. 

  4709. 		$signOutActions = $ezUser->signOutActions();

    4710. 

  4710. 		self::setSessionObject(new ezUser_base(), self::ACTION_ACCOUNT);

    4711. 

  4711. 		self::doActions(array(self::ACTION => $signOutActions));

    4712. 

  4712. 	}

    4713. 

  4713. 

    4714. 

  4714. // ---------------------------------------------------------------------------

    4715. 

  4715. // General action handling

    4716. 

  4716. // ---------------------------------------------------------------------------

    4717. 

  4717. 	private static /*.string.*/ function doAction($action = '', $id = '', $sendToBrowser = true) {

    4718. 

  4718. 		$html = '';

    4719. 

  4719. 

    4720. 

  4720. 		switch ($action) {

    4721. 

  4721. 		case self::ACTION_CONTAINER:		$html = self::htmlContainer		($id,			$sendToBrowser);	break;

    4722. 

  4722. 		case self::ACTION_MAIN:			$html = self::htmlControlPanel		($id,			$sendToBrowser);	break;

    4723. 

  4723. 		case self::ACTION_BITMAP:		$html = self::inlineBitmap		($id,			$sendToBrowser);	break;

    4724. 

  4724. 		case self::ACTION_RESETREQUEST:		$html = self::htmlResetRequest		($id,			$sendToBrowser);	break;

    4725. 

  4725. 		case self::ACTION_ACCOUNT:		$html = self::htmlAccountForm		($id, false, false,	$sendToBrowser);	break;

    4726. 

  4726. 		case self::ACTION_ACCOUNTWIZARD:	$html = self::htmlAccountForm		($id, false, true,	$sendToBrowser);	break;

    4727. 

  4727. 		case self::ACTION_STATUSTEXT:		$html = self::statusText		((int) $id, '',		$sendToBrowser);	break;

    4728. 

  4728. 		case self::ACTION_RESULTTEXT:		$html = self::resultText		((int) $id, '',		$sendToBrowser);	break;

    4729. 

  4729. 		case self::ACTION_RESULTFORM:		$html = self::htmlResultForm		((int) $id, '',		$sendToBrowser);	break;

    4730. 

  4730. 		case self::ACTION_RESEND:		$html = self::verify_renotify		($id,			$sendToBrowser);	break;

    4731. 

  4731. 		case self::ACTION_JAVASCRIPT:		$html = self::htmlJavascript		($id,			$sendToBrowser);	break;

    4732. 

  4732. 		case self::ACTION_STYLESHEET:		$html = self::htmlStyleSheet		($sendToBrowser);				break;

    4733. 

  4733. 		case self::ACTION_BODY:			$html = self::htmlSecureContent		($sendToBrowser);				break;

    4734. 

  4734. 		case self::ACTION_ABOUT:		$html = self::htmlAbout			($sendToBrowser);				break;

    4735. 

  4735. 		case self::ACTION_ABOUTTEXT:		$html = self::htmlAboutText		($sendToBrowser);				break;

    4736. 

  4736. 		case self::ACTION_SOURCECODE:		$html = self::htmlSourceCode		($sendToBrowser);				break;

    4737. 

  4737. 		case self::ACTION_VERIFY:		self::verify				($id);						break;

    4738. 

  4738. 		case self::ACTION_RESETPASSWORD:	self::passwordReset_validate		($id);						break;

    4739. 

  4739. 		case self::ACTION_RESET:		self::passwordReset_reset		($id);						break;

    4740. 

  4740. 		case self::ACTION_SIGNOUT:		self::signOut				();						break;

    4741. 

  4741. 		default:				self::fatalError			(self::RESULT_UNKNOWNACTION, $action);		break;

    4742. 

  4742. 		}

    4743. 

  4743. 

    4744. 

  4744. 		return $html;

    4745. 

  4745. 	}

    4746. 

  4746. 

    4747. 

  4747. // ---------------------------------------------------------------------------

    4748. 

  4748. /**

    4749. 

  4749.  * Performs one or more actions

    4750. 

  4750.  *

    4751. 

  4751.  * To perform more than one action, specify them in the condensed format <action>[=<id>]

    4752. 

  4752.  *

    4753. 

  4753.  * <pre>

    4754. 

  4754.  *     ezuser.php?foo1+foo2+foo3=bar1+bar2+bar3

    4755. 

  4755.  * </pre>

    4756. 

  4756.  *

    4757. 

  4757.  * or the extended format action=<action>[&id-<id>]

    4758. 

  4758.  *

    4759. 

  4759.  * <pre>

    4760. 

  4760.  *     ezuser.php?action=foo1+foo2+foo3&id=bar1+bar2+bar3

    4761. 

  4761.  * </pre>

    4762. 

  4762.  *

    4763. 

  4763.  * By the time it reaches this function they will be in an array with the '+'

    4764. 

  4764.  * delimiters replaced with spaces by the magic of PHP. So if you're calling

    4765. 

  4765.  * this function with your own parameters you would specify them like this:

    4766. 

  4766.  *

    4767. 

  4767.  * <pre>

    4768. 

  4768.  *     [$actions] => Array

    4769. 

  4769.  *        (

    4770. 

  4770.  *            [action] => foo1 foo2 foo3

    4771. 

  4771.  *            [id] => bar1 bar2 bar3

    4772. 

  4772.  *        )

    4773. 

  4773.  * </pre>

    4774. 

  4774.  *

    4775. 

  4775.  * Each space-delimited element in the <kbd>action</kbd> member of the {@link $actions}

    4776. 

  4776.  * array will be performed.

    4777. 

  4777.  *

    4778. 

  4778.  * @param array $actions Same format as {@link http://www.php.net/$_GET $_GET} (which is where it usually comes from)

    4779. 

  4779.  */

    4780. 

  4780. 	public static /*.void.*/ function doActions(/*.array[string]string.*/ $actions) {

    4781. 

  4781. 		// Translate from short form (ezuser.php?foo=bar) to extended form (ezuser.php?action=foo&id=bar)

    4782. 

  4782. 		if (!array_key_exists(self::ACTION, $actions)) {

    4783. 

  4783. 			$actions[self::TAGNAME_ID]	= (string) reset($actions);

    4784. 

  4784. 			$actions[self::ACTION]		= (string) key($actions);

    4785. 

  4785. 		}

    4786. 

  4786. 

    4787. 

  4787. 		$actionList	= (array_key_exists(self::ACTION, $actions))		? $actions[self::ACTION]	: '';

    4788. 

  4788. 		$id		= (array_key_exists(self::TAGNAME_ID, $actions))	? $actions[self::TAGNAME_ID]	: '';

    4789. 

  4789. 

    4790. 

  4790. 		if (strpos($actionList, self::DELIMITER_SPACE) !== false) {

    4791. 

  4791. 			$actionItems	= explode(self::DELIMITER_SPACE, $actionList);

    4792. 

  4792. 			$content	= /*.(array[string]string).*/ array();

    4793. 

  4793. 			foreach ($actionItems as $action) $content[self::getInstanceId($action)] = self::doAction($action, $id, false);

    4794. 

  4794. 			self::sendXML($content);

    4795. 

  4795. 		} else {

    4796. 

  4796. 			self::doAction($actionList, $id);

    4797. 

  4797. 		}

    4798. 

  4798. 	}

    4799. 

  4799. 

    4800. 

  4800. // ---------------------------------------------------------------------------

    4801. 

  4801. // 'Get' actions

    4802. 

  4802. // ---------------------------------------------------------------------------

    4803. 

  4803. // Methods may be commented out to reduce the attack surface if they are not

    4804. 

  4804. // required. Uncomment them if you need them.

    4805. 

  4805. //	public static /*.void.*/ function getStatusText		(/*.int.*/ $status, $more = '')			{self::statusText($status, $more,			true);}

    4806. 

  4806. //	public static /*.void.*/ function getResultText		(/*.int.*/ $result, $more = '')			{self::resultText($result, $more,			true);}

    4807. 

  4807. //	public static /*.void.*/ function getStatusDescription	(/*.int.*/ $status, $more = '')			{self::statusDescription($status, $more,		true);}

    4808. 

  4808. //	public static /*.void.*/ function getResultDescription	(/*.int.*/ $result, $more = '')			{self::resultDescription($result, $more,		true);}

    4809. 

  4809. 	public static /*.void.*/ function getResultForm		(/*.int.*/ $result, $more = '')			{self::htmlResultForm($result, $more,			true);}

    4810. 

  4810. 	public static /*.void.*/ function getAccountForm	($mode = '', $newUser = false, $wizard = false)	{self::htmlAccountForm($mode, $newUser, $wizard,	true);}

    4811. 

  4811. //	public static /*.void.*/ function getDashboard		()						{self::htmlDashboard(					true);}

    4812. 

  4812. //	public static /*.void.*/ function getSignInForm		()						{self::htmlSignInForm(					true);}

    4813. 

  4813. 	public static /*.void.*/ function getControlPanel	($username = '')				{self::htmlControlPanel($username,			true);}

    4814. 

  4814. //	public static /*.void.*/ function getStyleSheet		()						{self::htmlStyleSheet(					true);}

    4815. 

  4815. //	public static /*.void.*/ function getJavascript		($containerList = '')				{self::htmlJavascript($containerList,			true);}

    4816. 

  4816. 	public static /*.void.*/ function getContainer		($action = self::ACTION_MAIN)			{self::htmlContainer($action,				true);}

    4817. 

  4817. 	public static /*.void.*/ function getAbout		()						{self::htmlAbout(					true);}

    4818. 

  4818. 	public static /*.void.*/ function getAboutText		()						{self::htmlAboutText(					true);}

    4819. 

  4819. //	public static /*.void.*/ function getSourceCode		()						{self::htmlSourceCode(					true);}

    4820. 

  4820. }

    4821. 

  4821. // End of class ezUser

    4822. 

  4822. 

    4823. 

  4823. 

    4824. 

  4824. 

    4825. 

  4825. // Is this script included in another page or is it the HTTP target itself?

    4826. 

  4826. if (basename($_SERVER['SCRIPT_NAME']) === basename(__FILE__)) {

    4827. 

  4827. 	// This script has been called directly by the browser, so check what it has sent

    4828. 

  4828. 	if (is_array($_POST) && array_key_exists(ezUser::ACTION, $_POST)) {

    4829. 

  4829. 		switch ((string) $_POST[ezUser::ACTION]) {

    4830. 

  4830. 		case ezUser::ACTION_SIGNIN:

    4831. 

  4831. 			ezUser::signIn($_POST);

    4832. 

  4832. 			ezUser::getControlPanel();

    4833. 

  4833. 			break;

    4834. 

  4834. 		case ezUser::ACTION_VALIDATE:

    4835. 

  4835. 			ezUser::save($_POST);

    4836. 

  4836. 			ezUser::getAccountForm(ezUser::ACCOUNT_MODE_RESULT, ($_POST[ezUser::TAGNAME_NEWUSER] === ezUser::STRING_TRUE), ($_POST[ezUser::TAGNAME_WIZARD] === ezUser::STRING_TRUE));

    4837. 

  4837. 			break;

    4838. 

  4838. 		default:

    4839. 

  4839. 			ezUser::getResultForm(ezUser::RESULT_UNKNOWNACTION);

    4840. 

  4840. 			break;

    4841. 

  4841. 		}

    4842. 

  4842. 	} else if (is_array($_GET) && (count($_GET) > 0)) {

    4843. 

  4843. 		ezUser::doActions(/*.(array[string]string).*/ $_GET);

    4844. 

  4844. 	} else {

    4845. 

  4845. 		ezUser::getAbout(); // Nothing useful in $_GET or $_POST, so give a friendly greeting

    4846. 

  4846. 	}

    4847. 

  4847. }

    4848. 

  4848. ?>
    4849.