PageRenderTime 65ms CodeModel.GetById 27ms RepoModel.GetById 1ms 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

Large files files are truncated, but you can click here to view the full 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 ==…
    1201.

Large files files are truncated, but you can click here to view the full file