PageRenderTime 286ms CodeModel.GetById 26ms RepoModel.GetById 1ms app.codeStats 1ms

/WeBid/trunk/includes/useragent.inc.php

https://github.com/cipiceuca25/webid
PHP | 1221 lines | 712 code | 44 blank | 465 comment | 104 complexity | 2e0ab15e498b3d9944acdd1ab8bfa3cf MD5 | raw file
Possible License(s): AGPL-1.0

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

    

  1. <?php
    2. 

  2. /*
    3. 

  3. Script Name: Full Featured PHP Browser/OS detection
    4. 

  4. Author: Harald Hope, Website: http://techpatterns.com/
    5. 

  5. Script Source URI: http://techpatterns.com/downloads/php_browser_detection.php
    6. 

  6. Version 5.3.16
    7. 

  7. Copyright (C) May 2 2011
    8. 

    9. 

  9. Special thanks to alanjstr for cleaning up the code, especially on function get_item_version(),
    10. 

  10. which he improved greatly. Also to Tapio Markula, for his initial inspiration of creating a 
    11. 

  11. useable php browser detector. Also to silver Harloe for his ideas about using associative arrays
    12. 

  12. to both return and use as main return handler.
    13. 

    14. 

  14. This program is free software; you can redistribute it and/or modify it under
    15. 

  15. the terms of the GNU General Public License as published by the Free Software
    16. 

  16. Foundation; either version 3 of the License, or (at your option) any later version.
    17. 

    18. 

  18. This program is distributed in the hope that it will be useful, but WITHOUT
    19. 

  19. ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
    20. 

  20. FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
    21. 

    22. 

  22. Get the full text of the GPL here: http://www.gnu.org/licenses/gpl.txt
    23. 

    24. 

  24. Coding conventions:
    25. 

  25. http://cvs.sourceforge.net/viewcvs.py/phpbb/phpBB2/docs/codingstandards.htm?rev=1.3
    26. 

    27. 

  27. ******************************************
    28. 

  28. This is currently set to accept these primary parameters, although you can add as many as you want:
    29. 

  29. Note: all string data is returned as LOWER CASE, so make sure to keep that in mind when testing.
    30. 

  30. NOTE: as 5.3.0 some of these names have been changed to be more human readable. The old names will
    31. 

  31. still work, and it is noted where this change has happened like this: [deprecated: moz_version].
    32. 

  32. This change will will NOT break your existing programming or browser detection function calls.
    33. 

  33. ******************************************
    34. 

  34. 1. browser_math_number - [deprecated: math_number] returns basic version number, for math
    35. 

  35.    comparison, ie. 1.2rel2a becomes 1.2
    36. 

  36. 2. browser_name - returns the full browser name string, if available, otherwise returns ''
    37. 

  37.    (information not available)
    38. 

  38. 2. browser_number - [deprecated: number] returns the browser version number, if available,
    39. 

  39.    otherwise returns '' (information not available)
    40. 

  40. 3. browser_working [deprecated: browser] - returns the working shorthand browser name: 
    41. 

  41.    ie, op, moz, konq, saf, ns4, webkit, and some others. If not shorthand, it will probably just
    42. 

  42.    return the full browser name, like lynx
    43. 

  43. 4. dom - returns true/false if it is a basic dom browser, ie >= 5, opera >= 5, all new mozillas,
    44. 

  44.    safaris, konquerors
    45. 

  45. 5. ie_version - tests to see what general IE it is.
    46. 

  46.    Possible return values:
    47. 

  47.      ie9x - all new msie 9 or greater - note that if in compat mode, 7,8,9 all show as 7
    48. 

  48.      ie7x - all new msie 7 or greater
    49. 

  49.      ie5x - msie 5 and 6, not mac
    50. 

  50.      ieMac - msie 5.x mac release
    51. 

  51.      ie4 - msie 4
    52. 

  52.      old - pre msie 4
    53. 

  53. 6. full - returns this array, listed by array index number: 
    54. 

  54.      0 - $browser_working
    55. 

  55.      1 - $browser_number
    56. 

  56.      2 - $ie_version
    57. 

  57.      3 - $b_dom_browser
    58. 

  58.      4 - $b_safe_browser
    59. 

  59.      5 - $os_type
    60. 

  60.      6 - $os_number
    61. 

  61.      7 - $browser_name
    62. 

  62.      8 - $ua_type
    63. 

  63.      9 - $browser_math_number
    64. 

  64.      10 - $a_moz_data
    65. 

  65.      11 - $a_webkit_data
    66. 

  66.      12 - $mobile_test (null or string value)
    67. 

  67.      13 - $a_mobile_data (null or array of mobile data)
    68. 

  68.      14 - $true_ie_number
    69. 

  69.      15 - $run_time
    70. 

  70.    Note that moz/webkit_data are arrays which could contain null data, so always test first before
    71. 

  71.    assuming the moz/webkit arrays contain any data, ie, if moz or if webkit, then...
    72. 

  72. 7. full_assoc - returns all relevant browser information in an associative array, same as above
    73. 

  73.    only with string indexes instead of numeric:
    74. 

  74.      'browser_working' => $browser_working,
    75. 

  75.      'browser_number' => $browser_number,
    76. 

  76.      'ie_version' => $ie_version,
    77. 

  77.      'dom' => $b_dom_browser,
    78. 

  78.      'safe' => $b_safe_browser,
    79. 

  79.      'os' => $os_type,
    80. 

  80.      'os_number' => $os_number,
    81. 

  81.      'browser_name_' => $browser_name,
    82. 

  82.      'ua_type' => $ua_type,
    83. 

  83.      'browser_math_number' => $browser_math_number,
    84. 

  84.      'moz_data' => $a_moz_data,
    85. 

  85.      'webkit_data' => $a_webkit_data,
    86. 

  86.      'mobile_test' => $mobile_test,
    87. 

  87.      'mobile_data' => $a_mobile_data,
    88. 

  88.      'true_ie_number' => $true_ie_number
    89. 

  89.      'run_time' => $run_time
    90. 

  90. 8. mobile_test - returns a string of various mobile id methods, from device to os to browser. 
    91. 

  91.    If string is not null, should be a mobile. Also see 15, 'type', which will be 'mobile' 
    92. 

  92.    if handheld.
    93. 

  93. 9. mobile_data - returns an array of data about mobiles. Note the browser/os number data is very
    94. 

  94.    unreliable so don't count on that. No blackberry version handling done explicitly.
    95. 

  95.    Make sure to test if this is an array because if it's not mobile it will be null, not an array
    96. 

  96.    listed by array index number: 
    97. 

  97.      0 - $mobile_device 
    98. 

  98.      1 - $mobile_browser
    99. 

  99.      2 - $mobile_browser_number
    100. 

  100.      3 - $mobile_os
    101. 

  101.      4 - $mobile_os_number
    102. 

  102.      5 - $mobile_server
    103. 

  103.      6 - $mobile_server_number
    104. 

  104.      7 - $mobile_device_number (this was added so has to be end of list to not break existing code)
    105. 

  105.     Note: $mobile_browser only returns if a specifically mobile browser is detected, like minimo.
    106. 

  106.     Same for mobile os, with the exception of linux. Otherwise the standard script os/browser data
    107. 

  107.     is used. $mobile_server is a handheld service like docomo, novarro-vision, etc. Sometimes the
    108. 

  108.     string will contain no other usable data than this to determine if it's handheld or not.
    109. 

  109. 10. moz_data [deprecated: moz_version] - returns array of mozilla / gecko information
    110. 

  110.     Return Array listed by index number:
    111. 

  111.       0 - $moz_type [moz version - the specific brand name that is, eg: firefox)
    112. 

  112.       1 - $moz_number - the full version number of $moz_type (eg: for firefox: 3.6+2b)
    113. 

  113.       2 - $moz_rv - the Mozilla rv version number, math comparison version. This tells you what
    114. 

  114.           gecko engine is running in the browser (eg rv: 1.8)
    115. 

  115.       3 - $moz_rv_full - rv number (for full rv, including alpha and beta versions: 1.8.1-b3)
    116. 

  116.       4 - $moz_release_date - release date of the browser
    117. 

  117. 11. os - returns which os is being used - win, nt, mac, OR iphone, blackberry, palmos, palmsource, 
    118. 

  118.     symbian, beos, os2, amiga, webtv, linux, unix. 
    119. 

  119. 12. os_number - returns windows versions, 95, 98, ce, me, nt: 4; 5 [windows 2000]; 
    120. 

  120.     5.1 [windows xp]; 5.2 [Server 2003]; 6.0 [Windows Vista], 6.1 [Windows 7].
    121. 

  121.     Only win, nt, mac, iphone return os numbers (mac/iphone return 10 if OS X.)
    122. 

  122.     OR returns linux distro/unix release name, otherwise returns null
    123. 

  123. 13. run_time - the time it takes this script to execute from start to point of returning value
    124. 

  124.     Requires PHP 5 or greater. Returns time in seconds to 8 decimal places: 0.00245687 
    125. 

  125.     Run time does not count the time used by PHP to include/parse the file initially. That total
    126. 

  126.     time is about 5-10x longer. Because subsequent script run throughs go VERY fast, you will see
    127. 

  127.     the seconds go from something like 0.00115204 for first time, to something like 0.00004005
    128. 

  128.     for second and more runs. 
    129. 

  129. 14. safe - returns true/false, you can determine what makes the browser be safe lower down,
    130. 

  130.     currently it's set for ns4 and pre version 1 mozillas not being safe, plus all older browsers
    131. 

  131. 15. true_ie_number - [deprecated: true_msie_version] returns the true version of msie running,
    132. 

  132.     ignoring the compat mode version.
    133. 

  133.     Note that php will turn 7.0 to 8 when adding 1, so keep that in mind in your tests. 7.1 
    134. 

  134.     will become 8.1 as expected, however. This test currently only tests for 7.x -> 8.x
    135. 

  135.     FYI: in PHP, 7.0 == 7 is true but 7.0 === 7 is NOT true.
    136. 

  136.     If this is null but set, then it is NOT running in compatibility mode.
    137. 

  137. 16. ua_type [deprecated: type] - returns one of the following: 
    138. 

  138.       bot (web bot)
    139. 

  139.       bro (normal browser)
    140. 

  140.       bbro (simple browser)
    141. 

  141.       mobile (handheld)
    142. 

  142.       dow (downloading agent)
    143. 

  143.       lib (http library)
    144. 

  144. 17. webkit_data - [deprecated: webkit_version] returns array of webkit data.
    145. 

  145.     Return Array listed by index number:
    146. 

  146.       0 - $webkit_type [webkit version name (Eg. chrome)]
    147. 

  147.       1 - $webkit_type_number [webkit version number (Eg. Chrome's: 1.2)]
    148. 

  148.       2 - $browser_number [the actual webkit version number (Eg. Webkit's: 436)]
    149. 

  149. ******************************************
    150. 

  150. Optional second script parameter, to turn off features if not required. These would be the second
    151. 

  151. argument used in the function call if used, like: browser_detection( 'full', '1' );
    152. 

  152. Test Exclusions - switches to turn off various tests, useful if you want to optimize execution
    153. 

  153. and don't need the test data type excluded.
    154. 

  154. ******************************************
    155. 

  155. 1 - turn off os tests
    156. 

  156. 2 - turn off mobile tests
    157. 

  157. 3 - turn off mobile and os tests
    158. 

  158. ******************************************
    159. 

  159. Optional third script parameter, pass the script externally derived UA strings, for testing/
    160. 

  160. processing purposes. Idea from Rui Teixeira 
    161. 

  161. Note: include a blank second arg when you use the 3rd parameter if the second is not set:  
    162. 

  162. example: browser_detection( 'full', '', $test_string_data ) 
    163. 

  163. Using third parameter sets $b_repeat to false in other words, if you use this parameter, the script
    164. 

  164. will do the full processing on the UA string, then switch $b_repeat back to true at the end.
    165. 

    166. 

  166. However, be aware that all requests to the script after the last testing value is sent will
    167. 

  167. use the previous testing value, NOT the actual UA string, so make sure to handle that in your
    168. 

  168. programming if you require the true UA data to be processed after the final testing value is sent
    169. 

  169. by resetting that data with the true UA value.
    170. 

  170. *******************************************/
    171. 

  171. 

  172. // main script, uses two other functions, get_os_data() and get_item_version() as needed
    173. 

  173. // Optional $test_excludes is either null or one of the above values
    174. 

  174. 

  175. function browser_detection( $which_test, $test_excludes='', $external_ua_string='' ) 
    176. 

  176. {
    177. 

  177. 	/*
    178. 

  178. 	uncomment the global variable declaration if you want the variables to be available on 
    179. 

  179. 	a global level throughout your php page, make sure that php is configured to support 
    180. 

  180. 	the use of globals first!
    181. 

  181. 	Use of globals should be avoided however, and they are not necessary with this script
    182. 

  182. 	/*
    183. 

  183. 	/*
    184. 

  184. 	global $a_full_assoc_data, $a_mobile_data, $a_moz_data, $a_webkit_data, $b_dom_browser, $b_repeat, $b_safe_browser, $browser_name, $browser_number, $browser_math_number, $browser_user_agent, $browser_working, $ie_version, $mobile_test, $moz_number, $moz_rv, $moz_rv_full, $moz_release_date, $moz_type, $os_number, $os_type, $true_ie_number, $ua_type, $webkit_type, $webkit_type_number;
    185. 

  185. 	*/
    186. 

  186. 	script_time(); // set script timer to start timing
    187. 

  187. 

  188. 	static $a_full_assoc_data, $a_mobile_data, $a_moz_data, $a_webkit_data, $b_dom_browser, $b_repeat, $b_safe_browser, $browser_name, $browser_number, $browser_math_number, $browser_user_agent, $browser_working, $ie_version, $mobile_test, $moz_number, $moz_rv, $moz_rv_full, $moz_release_date, $moz_type, $os_number, $os_type, $true_ie_number, $ua_type, $webkit_type, $webkit_type_number;
    189. 

  189. 	
    190. 

  190. 	// switch off the optimization for external ua string testing.
    191. 

  191. 	if ( $external_ua_string )
    192. 

  192. 	{
    193. 

  193. 		$b_repeat = false;
    194. 

  194. 	}
    195. 

  195. 	
    196. 

  196. 	/*
    197. 

  197. 	this makes the test only run once no matter how many times you call it since 
    198. 

  198. 	all the variables are filled on the first run through, it's only a matter of 
    199. 

  199. 	returning the the right ones
    200. 

  200. 	*/
    201. 

  201. 	if ( !$b_repeat )
    202. 

  202. 	{
    203. 

  203. 		//initialize all variables with default values to prevent error
    204. 

  204. 		$a_browser_math_number = '';
    205. 

  205. 		$a_full_assoc_data = '';
    206. 

  206. 		$a_full_data = '';
    207. 

  207. 		$a_mobile_data = '';
    208. 

  208. 		$a_moz_data = '';
    209. 

  209. 		$a_os_data = '';
    210. 

  210. 		$a_unhandled_browser = '';
    211. 

  211. 		$a_webkit_data = '';
    212. 

  212. 		$b_dom_browser = false;
    213. 

  213. 		$b_os_test = true;
    214. 

  214. 		$b_mobile_test = true;
    215. 

  215. 		$b_safe_browser = false;
    216. 

  216. 		$b_success = false;// boolean for if browser found in main test
    217. 

  217. 		$browser_math_number = '';
    218. 

  218. 		$browser_temp = '';
    219. 

  219. 		$browser_working = '';
    220. 

  220. 		$browser_number = '';
    221. 

  221. 		$ie_version = '';
    222. 

  222. 		$mobile_test = '';
    223. 

  223. 		$moz_release_date = '';
    224. 

  224. 		$moz_rv = '';
    225. 

  225. 		$moz_rv_full = '';
    226. 

  226. 		$moz_type = '';
    227. 

  227. 		$moz_number = '';
    228. 

  228. 		$os_number = '';
    229. 

  229. 		$os_type = '';
    230. 

  230. 		$run_time = '';
    231. 

  231. 		$true_ie_number = '';
    232. 

  232. 		$ua_type = 'bot';// default to bot since you never know with bots
    233. 

  233. 		$webkit_type = '';
    234. 

  234. 		$webkit_type_number = '';
    235. 

  235. 

  236. 		// set the excludes if required
    237. 

  237. 		if ( $test_excludes )
    238. 

  238. 		{
    239. 

  239. 			switch ( $test_excludes )
    240. 

  240. 			{
    241. 

  241. 				case '1':
    242. 

  242. 					$b_os_test = false;
    243. 

  243. 					break;
    244. 

  244. 				case '2':
    245. 

  245. 					$b_mobile_test = false;
    246. 

  246. 					break;
    247. 

  247. 				case '3':
    248. 

  248. 					$b_os_test = false;
    249. 

  249. 					$b_mobile_test = false;
    250. 

  250. 					break;
    251. 

  251. 				default:
    252. 

  252. 					die( 'Error: bad $test_excludes parameter 2 used: ' . $test_excludes );
    253. 

  253. 					break;
    254. 

  254. 			}
    255. 

  255. 		}
    256. 

  256. 

  257. 		/*
    258. 

  258. 		make navigator user agent string lower case to make sure all versions get caught
    259. 

  259. 		isset protects against blank user agent failure. tolower also lets the script use
    260. 

  260. 		strstr instead of stristr, which drops overhead slightly.
    261. 

  261. 		*/
    262. 

  262. 		if ( $external_ua_string )
    263. 

  263. 		{
    264. 

  264. 			$browser_user_agent = strtolower( $external_ua_string );
    265. 

  265. 		}
    266. 

  266. 		elseif ( isset( $_SERVER['HTTP_USER_AGENT'] ) )
    267. 

  267. 		{
    268. 

  268. 			$browser_user_agent = strtolower( $_SERVER['HTTP_USER_AGENT'] );
    269. 

  269. 		}
    270. 

  270. 		else
    271. 

  271. 		{
    272. 

  272. 			$browser_user_agent = '';
    273. 

  273. 		}
    274. 

  274. 

  275. 		/*
    276. 

  276. 		pack the browser type array, in this order
    277. 

  277. 		the order is important, because opera must be tested first, then omniweb [which has safari
    278. 

  278. 		data in string], same for konqueror, then safari, then gecko, since safari navigator user
    279. 

  279. 		agent id's with 'gecko' in string.
    280. 

  280. 		Note that $b_dom_browser is set for all  modern dom browsers, this gives you a default to use.
    281. 

    282. 

  282. 		array[0] = id string for useragent, array[1] is if dom capable, array[2] is working name 
    283. 

  283. 		for browser, array[3] identifies navigator useragent type
    284. 

    285. 

  285. 		Note: all browser strings are in lower case to match the strtolower output, this avoids
    286. 

  286. 		possible detection errors
    287. 

    288. 

  288. 		Note: These are the navigator user agent types:
    289. 

  289. 		bro - modern, css supporting browser.
    290. 

  290. 		bbro - basic browser, text only, table only, defective css implementation
    291. 

  291. 		bot - search type spider
    292. 

  292. 		dow - known download agent
    293. 

  293. 		lib - standard http libraries
    294. 

  294. 		mobile - handheld or mobile browser, set using $mobile_test
    295. 

  295. 		*/
    296. 

  296. 		// known browsers, list will be updated routinely, check back now and then
    297. 

  297. 		$a_browser_types = array(
    298. 

  298. 			array( 'opera', true, 'op', 'bro' ),
    299. 

  299. 			array( 'msie', true, 'ie', 'bro' ),
    300. 

  300. 			// webkit before gecko because some webkit ua strings say: like gecko
    301. 

  301. 			array( 'webkit', true, 'webkit', 'bro' ),
    302. 

  302. 			// konq will be using webkit soon
    303. 

  303. 			array( 'konqueror', true, 'konq', 'bro' ),
    304. 

  304. 			// covers Netscape 6-7, K-Meleon, Most linux versions, uses moz array below
    305. 

  305. 			array( 'gecko', true, 'moz', 'bro' ),
    306. 

  306. 			array( 'netpositive', false, 'netp', 'bbro' ),// beos browser
    307. 

  307. 			array( 'lynx', false, 'lynx', 'bbro' ), // command line browser
    308. 

  308. 			array( 'elinks ', false, 'elinks', 'bbro' ), // new version of links
    309. 

  309. 			array( 'elinks', false, 'elinks', 'bbro' ), // alternate id for it
    310. 

  310. 			array( 'links2', false, 'links2', 'bbro' ), // alternate links version
    311. 

  311. 			array( 'links ', false, 'links', 'bbro' ), // old name for links
    312. 

  312. 			array( 'links', false, 'links', 'bbro' ), // alternate id for it
    313. 

  313. 			array( 'w3m', false, 'w3m', 'bbro' ), // open source browser, more features than lynx/links
    314. 

  314. 			array( 'webtv', false, 'webtv', 'bbro' ),// junk ms webtv
    315. 

  315. 			array( 'amaya', false, 'amaya', 'bbro' ),// w3c browser
    316. 

  316. 			array( 'dillo', false, 'dillo', 'bbro' ),// linux browser, basic table support
    317. 

  317. 			array( 'ibrowse', false, 'ibrowse', 'bbro' ),// amiga browser
    318. 

  318. 			array( 'icab', false, 'icab', 'bro' ),// mac browser
    319. 

  319. 			array( 'crazy browser', true, 'ie', 'bro' ),// uses ie rendering engine
    320. 

  320. 	
    321. 

  321. 			// search engine spider bots:
    322. 

  322. 			array( 'bingbot', false, 'bing', 'bot' ),// bing 
    323. 

  323. 			array( 'exabot', false, 'exabot', 'bot' ),// exabot
    324. 

  324. 			array( 'googlebot', false, 'google', 'bot' ),// google
    325. 

  325. 			array( 'google web preview', false, 'googlewp', 'bot' ),// google preview 
    326. 

  326. 			array( 'mediapartners-google', false, 'adsense', 'bot' ),// google adsense
    327. 

  327. 			array( 'yahoo-verticalcrawler', false, 'yahoo', 'bot' ),// old yahoo bot
    328. 

  328. 			array( 'yahoo! slurp', false, 'yahoo', 'bot' ), // new yahoo bot
    329. 

  329. 			array( 'yahoo-mm', false, 'yahoomm', 'bot' ), // gets Yahoo-MMCrawler and Yahoo-MMAudVid bots
    330. 

  330. 			array( 'inktomi', false, 'inktomi', 'bot' ), // inktomi bot
    331. 

  331. 			array( 'slurp', false, 'inktomi', 'bot' ), // inktomi bot
    332. 

  332. 			array( 'fast-webcrawler', false, 'fast', 'bot' ),// Fast AllTheWeb
    333. 

  333. 			array( 'msnbot', false, 'msn', 'bot' ),// msn search
    334. 

  334. 			array( 'ask jeeves', false, 'ask', 'bot' ), //jeeves/teoma
    335. 

  335. 			array( 'teoma', false, 'ask', 'bot' ),//jeeves teoma
    336. 

  336. 			array( 'scooter', false, 'scooter', 'bot' ),// altavista
    337. 

  337. 			array( 'openbot', false, 'openbot', 'bot' ),// openbot, from taiwan
    338. 

  338. 			array( 'ia_archiver', false, 'ia_archiver', 'bot' ),// ia archiver
    339. 

  339. 			array( 'zyborg', false, 'looksmart', 'bot' ),// looksmart
    340. 

  340. 			array( 'almaden', false, 'ibm', 'bot' ),// ibm almaden web crawler
    341. 

  341. 			array( 'baiduspider', false, 'baidu', 'bot' ),// Baiduspider asian search spider
    342. 

  342. 			array( 'psbot', false, 'psbot', 'bot' ),// psbot image crawler
    343. 

  343. 			array( 'gigabot', false, 'gigabot', 'bot' ),// gigabot crawler
    344. 

  344. 			array( 'naverbot', false, 'naverbot', 'bot' ),// naverbot crawler, bad bot, block
    345. 

  345. 			array( 'surveybot', false, 'surveybot', 'bot' ),//
    346. 

  346. 			array( 'boitho.com-dc', false, 'boitho', 'bot' ),//norwegian search engine
    347. 

  347. 			array( 'objectssearch', false, 'objectsearch', 'bot' ),// open source search engine
    348. 

  348. 			array( 'answerbus', false, 'answerbus', 'bot' ),// http://www.answerbus.com/, web questions
    349. 

  349. 			array( 'sohu-search', false, 'sohu', 'bot' ),// chinese media company, search component
    350. 

  350. 			array( 'iltrovatore-setaccio', false, 'il-set', 'bot' ),
    351. 

  351. 	
    352. 

  352. 			// various http utility libaries
    353. 

  353. 			array( 'w3c_validator', false, 'w3c', 'lib' ), // uses libperl, make first
    354. 

  354. 			array( 'wdg_validator', false, 'wdg', 'lib' ), //
    355. 

  355. 			array( 'libwww-perl', false, 'libwww-perl', 'lib' ),
    356. 

  356. 			array( 'jakarta commons-httpclient', false, 'jakarta', 'lib' ),
    357. 

  357. 			array( 'python-urllib', false, 'python-urllib', 'lib' ),
    358. 

  358. 	
    359. 

  359. 			// download apps
    360. 

  360. 			array( 'getright', false, 'getright', 'dow' ),
    361. 

  361. 			array( 'wget', false, 'wget', 'dow' ),// open source downloader, obeys robots.txt
    362. 

  362. 	
    363. 

  363. 			// netscape 4 and earlier tests, put last so spiders don't get caught
    364. 

  364. 			array( 'mozilla/4.', false, 'ns', 'bbro' ),
    365. 

  365. 			array( 'mozilla/3.', false, 'ns', 'bbro' ),
    366. 

  366. 			array( 'mozilla/2.', false, 'ns', 'bbro' )
    367. 

  367. 		);
    368. 

  368. 	
    369. 

  369. 		//array( '', false ); // browser array template
    370. 

  370. 

  371. 		/*
    372. 

  372. 		moz types array
    373. 

  373. 		note the order, netscape6 must come before netscape, which  is how netscape 7 id's itself.
    374. 

  374. 		rv comes last in case it is plain old mozilla. firefox/netscape/seamonkey need to be later
    375. 

  375. 		Thanks to: http://www.zytrax.com/tech/web/firefox-history.html
    376. 

  376. 		*/
    377. 

  377. 		$a_moz_types = array( 'bonecho', 'camino', 'epiphany', 'firebird', 'flock', 'galeon', 'iceape', 'icecat', 'k-meleon', 'minimo', 'multizilla', 'phoenix', 'songbird', 'swiftfox', 'seamonkey', 'shiretoko', 'iceweasel', 'firefox', 'minefield', 'netscape6', 'netscape', 'rv' );
    378. 

  378. 

  379. 		/*
    380. 

  380. 		webkit types, this is going to expand over time as webkit browsers spread
    381. 

  381. 		konqueror is probably going to move to webkit, so this is preparing for that
    382. 

  382. 		It will now default to khtml. gtklauncher is the temp id for epiphany, might
    383. 

  383. 		change. Defaults to applewebkit, and will all show the webkit number.
    384. 

  384. 		*/
    385. 

  385. 		$a_webkit_types = array( 'arora', 'chrome', 'epiphany', 'gtklauncher', 'icab', 'konqueror', 'maxthon',  'midori', 'omniweb', 'rekonq', 'safari', 'shiira', 'uzbl', 'applewebkit', 'webkit' );
    386. 

  386. 

  387. 		/*
    388. 

  388. 		run through the browser_types array, break if you hit a match, if no match, assume old browser
    389. 

  389. 		or non dom browser, assigns false value to $b_success.
    390. 

  390. 		*/
    391. 

  391. 		$i_count = count( $a_browser_types );
    392. 

  392. 		for ( $i = 0; $i < $i_count; $i++ )
    393. 

  393. 		{
    394. 

  394. 			//unpacks browser array, assigns to variables, need to not assign til found in string
    395. 

  395. 			$browser_temp = $a_browser_types[$i][0];// text string to id browser from array
    396. 

  396. 

  397. 			if ( strstr( $browser_user_agent, $browser_temp ) )
    398. 

  398. 			{
    399. 

  399. 				/*
    400. 

  400. 				it defaults to true, will become false below if needed
    401. 

  401. 				this keeps it easier to keep track of what is safe, only
    402. 

  402. 				explicit false assignment will make it false.
    403. 

  403. 				*/
    404. 

  404. 				$b_safe_browser = true;
    405. 

  405. 				$browser_name = $browser_temp;// text string to id browser from array
    406. 

  406. 

  407. 				// assign values based on match of user agent string
    408. 

  408. 				$b_dom_browser = $a_browser_types[$i][1];// hardcoded dom support from array
    409. 

  409. 				$browser_working = $a_browser_types[$i][2];// working name for browser
    410. 

  410. 				$ua_type = $a_browser_types[$i][3];// sets whether bot or browser
    411. 

  411. 

  412. 				switch ( $browser_working )
    413. 

  413. 				{
    414. 

  414. 					// this is modified quite a bit, now will return proper netscape version number
    415. 

  415. 					// check your implementation to make sure it works
    416. 

  416. 					case 'ns':
    417. 

  417. 						$b_safe_browser = false;
    418. 

  418. 						$browser_number = get_item_version( $browser_user_agent, 'mozilla' );
    419. 

  419. 						break;
    420. 

  420. 					case 'moz':
    421. 

  421. 						/*
    422. 

  422. 						note: The 'rv' test is not absolute since the rv number is very different on
    423. 

  423. 						different versions, for example Galean doesn't use the same rv version as Mozilla,
    424. 

  424. 						neither do later Netscapes, like 7.x. For more on this, read the full mozilla
    425. 

  425. 						numbering conventions here: http://www.mozilla.org/releases/cvstags.html
    426. 

  426. 						*/
    427. 

  427. 						// this will return alpha and beta version numbers, if present
    428. 

  428. 						$moz_rv_full = get_item_version( $browser_user_agent, 'rv' );
    429. 

  429. 						// this slices them back off for math comparisons
    430. 

  430. 						$moz_rv = substr( $moz_rv_full, 0, 3 );
    431. 

  431. 

  432. 						// this is to pull out specific mozilla versions, firebird, netscape etc..
    433. 

  433. 						$j_count = count( $a_moz_types );
    434. 

  434. 						for ( $j = 0; $j < $j_count; $j++ )
    435. 

  435. 						{
    436. 

  436. 							if ( strstr( $browser_user_agent, $a_moz_types[$j] ) )
    437. 

  437. 							{
    438. 

  438. 								$moz_type = $a_moz_types[$j];
    439. 

  439. 								$moz_number = get_item_version( $browser_user_agent, $moz_type );
    440. 

  440. 								break;
    441. 

  441. 							}
    442. 

  442. 						}
    443. 

  443. 						/*
    444. 

  444. 						this is necesary to protect against false id'ed moz'es and new moz'es.
    445. 

  445. 						this corrects for galeon, or any other moz browser without an rv number
    446. 

  446. 						*/
    447. 

  447. 						if ( !$moz_rv )
    448. 

  448. 						{
    449. 

  449. 							// you can use this if you are running php >= 4.2
    450. 

  450. 							if ( function_exists( 'floatval' ) )
    451. 

  451. 							{
    452. 

  452. 								$moz_rv = floatval( $moz_number );
    453. 

  453. 							}
    454. 

  454. 							else
    455. 

  455. 							{
    456. 

  456. 								$moz_rv = substr( $moz_number, 0, 3 );
    457. 

  457. 							}
    458. 

  458. 							$moz_rv_full = $moz_number;
    459. 

  459. 						}
    460. 

  460. 						// this corrects the version name in case it went to the default 'rv' for the test
    461. 

  461. 						if ( $moz_type == 'rv' )
    462. 

  462. 						{
    463. 

  463. 							$moz_type = 'mozilla';
    464. 

  464. 						}
    465. 

  465. 

  466. 						//the moz version will be taken from the rv number, see notes above for rv problems
    467. 

  467. 						$browser_number = $moz_rv;
    468. 

  468. 						// gets the actual release date, necessary if you need to do functionality tests
    469. 

  469. 						get_set_count( 'set', 0 );
    470. 

  470. 						$moz_release_date = get_item_version( $browser_user_agent, 'gecko/' );
    471. 

  471. 						/*
    472. 

  472. 						Test for mozilla 0.9.x / netscape 6.x
    473. 

  473. 						test your javascript/CSS to see if it works in these mozilla releases, if it
    474. 

  474. 						does, just default it to: $b_safe_browser = true;
    475. 

  475. 						*/
    476. 

  476. 						if ( ( $moz_release_date < 20020400 ) || ( $moz_rv < 1 ) )
    477. 

  477. 						{
    478. 

  478. 							$b_safe_browser = false;
    479. 

  479. 						}
    480. 

  480. 						break;
    481. 

  481. 					case 'ie':
    482. 

  482. 						/*
    483. 

  483. 						note we're adding in the trident/ search to return only first instance in case
    484. 

  484. 						of msie 8, and we're triggering the  break last condition in the test, as well
    485. 

  485. 						as the test for a second search string, trident/
    486. 

  486. 						Sample: Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 6.1; Trident/6.0)
    487. 

  487. 						*/
    488. 

  488. 						$browser_number = get_item_version( $browser_user_agent, $browser_name, true, 'trident/' );
    489. 

  489. 						// construct the proper real number if it's in compat mode and msie 10
    490. 

  490. 						if ( strstr( $browser_number, '7.' ) )
    491. 

  491. 						{
    492. 

  492. 							if ( strstr( $browser_user_agent, 'trident/7' ) )
    493. 

  493. 							{
    494. 

  494. 								// note that 7.0 becomes 11 when adding 4, but if it's 7.1 it will be 11.1
    495. 

  495. 								$true_ie_number = $browser_number + 4;
    496. 

  496. 							}
    497. 

  497. 							elseif ( strstr( $browser_user_agent, 'trident/6' ) )
    498. 

  498. 							{
    499. 

  499. 								// note that 7.0 becomes 10 when adding 3, but if it's 7.1 it will be 10.1
    500. 

  500. 								$true_ie_number = $browser_number + 3;
    501. 

  501. 							}
    502. 

  502. 							// construct the proper real number if it's in compat mode and msie 8.0/9.0
    503. 

  503. 							elseif ( strstr( $browser_user_agent, 'trident/5' ) )
    504. 

  504. 							{
    505. 

  505. 								// note that 7.0 becomes 9 when adding 2, but if it's 7.1 it will be 9.1
    506. 

  506. 								$true_ie_number = $browser_number + 2;
    507. 

  507. 							}
    508. 

  508. 							elseif ( strstr( $browser_user_agent, 'trident/4' ) )
    509. 

  509. 							{
    510. 

  510. 								// note that 7.0 becomes 8 when adding 1, but if it's 7.1 it will be 8.1
    511. 

  511. 								$true_ie_number = $browser_number + 1;
    512. 

  512. 							}
    513. 

  513. 						}
    514. 

  514. 						// the 9 series is finally standards compatible, html 5 etc, so worth a new id
    515. 

  515. 						if ( $browser_number >= 9 )
    516. 

  516. 						{
    517. 

  517. 							$ie_version = 'ie9x';
    518. 

  518. 						}
    519. 

  519. 						// 7/8 were not yet quite to standards levels but getting there
    520. 

  520. 						elseif ( $browser_number >= 7 )
    521. 

  521. 						{
    522. 

  522. 							$ie_version = 'ie7x';
    523. 

  523. 						}
    524. 

  524. 						// then test for IE 5x mac, that's the most problematic IE out there
    525. 

  525. 						elseif ( strstr( $browser_user_agent, 'mac') )
    526. 

  526. 						{
    527. 

  527. 							$ie_version = 'ieMac';
    528. 

  528. 						}
    529. 

  529. 						// ie 5/6 are both very weak in standards compliance
    530. 

  530. 						elseif ( $browser_number >= 5 )
    531. 

  531. 						{
    532. 

  532. 							$ie_version = 'ie5x';
    533. 

  533. 						}
    534. 

  534. 						elseif ( ( $browser_number > 3 ) && ( $browser_number < 5 ) )
    535. 

  535. 						{
    536. 

  536. 							$b_dom_browser = false;
    537. 

  537. 							$ie_version = 'ie4';
    538. 

  538. 							// this depends on what you're using the script for, make sure this fits your needs
    539. 

  539. 							$b_safe_browser = true;
    540. 

  540. 						}
    541. 

  541. 						else
    542. 

  542. 						{
    543. 

  543. 							$ie_version = 'old';
    544. 

  544. 							$b_dom_browser = false;
    545. 

  545. 							$b_safe_browser = false;
    546. 

  546. 						}
    547. 

  547. 						break;
    548. 

  548. 					case 'op':
    549. 

  549. 						$browser_number = get_item_version( $browser_user_agent, $browser_name );
    550. 

  550. 						// opera is leaving version at 9.80 (or xx) for 10.x - see this for explanation
    551. 

  551. 						// http://dev.opera.com/articles/view/opera-ua-string-changes/
    552. 

  552. 						if ( strstr( $browser_number, '9.' ) && strstr( $browser_user_agent, 'version/' ) )
    553. 

  553. 						{
    554. 

  554. 							get_set_count( 'set', 0 );
    555. 

  555. 							$browser_number = get_item_version( $browser_user_agent, 'version/' );
    556. 

  556. 						}
    557. 

  557. 						
    558. 

  558. 						if ( $browser_number < 5 )// opera 4 wasn't very useable.
    559. 

  559. 						{
    560. 

  560. 							$b_safe_browser = false;
    561. 

  561. 						}
    562. 

  562. 						break;
    563. 

  563. 					/*
    564. 

  564. 					note: webkit returns always the webkit version number, not the specific user
    565. 

  565. 					agent version, ie, webkit 583, not chrome 0.3
    566. 

  566. 					*/
    567. 

  567. 					case 'webkit':
    568. 

  568. 						// note that this is the Webkit version number
    569. 

  569. 						$browser_number = get_item_version( $browser_user_agent, $browser_name );
    570. 

  570. 						// this is to pull out specific webkit versions, safari, google-chrome etc..
    571. 

  571. 						$j_count = count( $a_webkit_types );
    572. 

  572. 						for ( $j = 0; $j < $j_count; $j++ )
    573. 

  573. 						{
    574. 

  574. 							if ( strstr( $browser_user_agent, $a_webkit_types[$j] ) )
    575. 

  575. 							{
    576. 

  576. 								$webkit_type = $a_webkit_types[$j];
    577. 

  577. 								/*
    578. 

  578. 								and this is the webkit type version number, like: chrome 1.2
    579. 

  579. 								if omni web, we want the count 2, not default 1
    580. 

  580. 								*/
    581. 

  581. 								if ( $webkit_type == 'omniweb' )
    582. 

  582. 								{
    583. 

  583. 									get_set_count( 'set', 2 );
    584. 

  584. 								}
    585. 

  585. 								$webkit_type_number = get_item_version( $browser_user_agent, $webkit_type );
    586. 

  586. 								// epiphany hack
    587. 

  587. 								if ( $a_webkit_types[$j] == 'gtklauncher' )
    588. 

  588. 								{
    589. 

  589. 									$browser_name = 'epiphany';
    590. 

  590. 								}
    591. 

  591. 								else
    592. 

  592. 								{
    593. 

  593. 									$browser_name = $a_webkit_types[$j];
    594. 

  594. 								}
    595. 

  595. 								break;
    596. 

  596. 							}
    597. 

  597. 						}
    598. 

  598. 						break;
    599. 

  599. 					default:
    600. 

  600. 						$browser_number = get_item_version( $browser_user_agent, $browser_name );
    601. 

  601. 						break;
    602. 

  602. 				}
    603. 

  603. 				// the browser was id'ed
    604. 

  604. 				$b_success = true;
    605. 

  605. 				break;
    606. 

  606. 			}
    607. 

  607. 		}
    608. 

  608. 		
    609. 

  609. 		//assigns defaults if the browser was not found in the loop test
    610. 

  610. 		if ( !$b_success )
    611. 

  611. 		{
    612. 

  612. 			/*
    613. 

  613. 			this will return the first part of the browser string if the above id's failed
    614. 

  614. 			usually the first part of the browser string has the navigator useragent name/version in it.
    615. 

  615. 			This will usually correctly id the browser and the browser number if it didn't get
    616. 

  616. 			caught by the above routine.
    617. 

  617. 			If you want a '' to do a if browser == '' type test, just comment out all lines below
    618. 

  618. 			except for the last line, and uncomment the last line. If you want undefined values,
    619. 

  619. 			the browser_name is '', you can always test for that
    620. 

  620. 			*/
    621. 

  621. 			// delete this part if you want an unknown browser returned
    622. 

  622. 			$browser_name = substr( $browser_user_agent, 0, strcspn( $browser_user_agent , '();') );
    623. 

  623. 			// this extracts just the browser name from the string, if something usable was found
    624. 

  624. 			if ( $browser_name && preg_match( '/[^0-9][a-z]*-*\ *[a-z]*\ *[a-z]*/', $browser_name, $a_unhandled_browser ) )
    625. 

  625. 			{
    626. 

  626. 				$browser_name = $a_unhandled_browser[0];
    627. 

  627. 				
    628. 

  628. 				if ( $browser_name == 'blackberry' )
    629. 

  629. 				{
    630. 

  630. 					get_set_count( 'set', 0 );
    631. 

  631. 				}
    632. 

  632. 				$browser_number = get_item_version( $browser_user_agent, $browser_name );
    633. 

  633. 			}
    634. 

  634. 			else
    635. 

  635. 			{
    636. 

  636. 				$browser_name = 'NA';
    637. 

  637. 				$browser_number = 'NA';
    638. 

  638. 			}
    639. 

  639. 

  640. 			// then uncomment this part
    641. 

  641. 			//$browser_name = '';//deletes the last array item in case the browser was not a match
    642. 

  642. 		}
    643. 

  643. 		// get os data, mac os x test requires browser/version information, this is a change from older scripts
    644. 

  644. 		if ( $b_os_test )
    645. 

  645. 		{
    646. 

  646. 			$a_os_data = get_os_data( $browser_user_agent, $browser_working, $browser_number );
    647. 

  647. 			$os_type = $a_os_data[0];// os name, abbreviated
    648. 

  648. 			$os_number = $a_os_data[1];// os number or version if available
    649. 

  649. 		}
    650. 

  650. 		/*
    651. 

  651. 		this ends the run through once if clause, set the boolean
    652. 

  652. 		to true so the function won't retest everything
    653. 

  653. 		*/
    654. 

  654. 		$b_repeat = true;
    655. 

  655. 		/*
    656. 

  656. 		pulls out primary version number from more complex string, like 7.5a,
    657. 

  657. 		use this for numeric version comparison
    658. 

  658. 		*/
    659. 

  659. 		if ( $browser_number && preg_match( '/[0-9]*\.*[0-9]*/', $browser_number, $a_browser_math_number ) )
    660. 

  660. 		{ 
    661. 

  661. 			$browser_math_number = $a_browser_math_number[0];
    662. 

  662. 			//print_r($a_browser_math_number);
    663. 

  663. 		}
    664. 

  664. 		if ( $b_mobile_test )
    665. 

  665. 		{
    666. 

  666. 			$mobile_test = check_is_mobile( $browser_user_agent );
    667. 

  667. 			if ( $mobile_test )
    668. 

  668. 			{
    669. 

  669. 				$a_mobile_data = get_mobile_data( $browser_user_agent );
    670. 

  670. 				$ua_type = 'mobile';
    671. 

  671. 			}
    672. 

  672. 		}
    673. 

  673. 	}
    674. 

  674. 	//$browser_number = $_SERVER["REMOTE_ADDR"];
    675. 

  675. 	/*
    676. 

  676. 	This is where you return values based on what parameter you used to call the function
    677. 

  677. 	$which_test is the passed parameter in the initial browser_detection('os') for example returns
    678. 

  678. 	the os version only.
    679. 

  679. 	
    680. 

  680. 	Update deprecated parameter names to new names
    681. 

  681. 	*/
    682. 

  682. 	switch ( $which_test )
    683. 

  683. 	{
    684. 

  684. 		case 'math_number':
    685. 

  685. 			$which_test = 'browser_math_number';
    686. 

  686. 			break;
    687. 

  687. 		case 'number':
    688. 

  688. 			$which_test = 'browser_number';
    689. 

  689. 			break;
    690. 

  690. 		case 'browser':
    691. 

  691. 			$which_test = 'browser_working';
    692. 

  692. 			break;
    693. 

  693. 		case 'moz_version':
    694. 

  694. 			$which_test = 'moz_data';
    695. 

  695. 			break;
    696. 

  696. 		case 'true_msie_version':
    697. 

  697. 			$which_test = 'true_ie_number';
    698. 

  698. 			break;
    699. 

  699. 		case 'type':
    700. 

  700. 			$which_test = 'ua_type';
    701. 

  701. 			break;
    702. 

  702. 		case 'webkit_version':
    703. 

  703. 			$which_test = 'webkit_data';
    704. 

  704. 			break;
    705. 

  705. 	}
    706. 

  706. 	/*
    707. 

  707. 	assemble these first so they can be included in full return data, using static variables
    708. 

  708. 	Note that there's no need to keep repacking these every time the script is called
    709. 

  709. 	*/
    710. 

  710. 	if ( !$a_moz_data )
    711. 

  711. 	{
    712. 

  712. 		$a_moz_data = array( $moz_type, $moz_number, $moz_rv, $moz_rv_full, $moz_release_date );
    713. 

  713. 	}
    714. 

  714. 	if ( !$a_webkit_data )
    715. 

  715. 	{
    716. 

  716. 		$a_webkit_data = array( $webkit_type, $webkit_type_number, $browser_number );
    717. 

  717. 	}
    718. 

  718. 	$run_time = script_time();
    719. 

  719. 	// then pack the primary data array
    720. 

  720. 	if ( !$a_full_assoc_data )
    721. 

  721. 	{
    722. 

  722. 		$a_full_assoc_data = array(
    723. 

  723. 			'browser_working' => $browser_working,
    724. 

  724. 			'browser_number' => $browser_number,
    725. 

  725. 			'ie_version' => $ie_version,
    726. 

  726. 			'dom' => $b_dom_browser,
    727. 

  727. 			'safe' => $b_safe_browser,
    728. 

  728. 			'os' => $os_type,
    729. 

  729. 			'os_number' => $os_number,
    730. 

  730. 			'browser_name' => $browser_name,
    731. 

  731. 			'ua_type' => $ua_type,
    732. 

  732. 			'browser_math_number' => $browser_math_number,
    733. 

  733. 			'moz_data' => $a_moz_data,
    734. 

  734. 			'webkit_data' => $a_webkit_data,
    735. 

  735. 			'mobile_test' => $mobile_test,
    736. 

  736. 			'mobile_data' => $a_mobile_data,
    737. 

  737. 			'true_ie_number' => $true_ie_number,
    738. 

  738. 			'run_time' => $run_time
    739. 

  739. 		);
    740. 

  740. 	}
    741. 

  741. 	// return parameters, either full data arrays, or by associative array index key
    742. 

  742. 	switch ( $which_test )
    743. 

  743. 	{
    744. 

  744. 		// returns all relevant browser information in an array with standard numberic indexes
    745. 

  745. 		case 'full':
    746. 

  746. 			$a_full_data = array( 
    747. 

  747. 				$browser_working, 
    748. 

  748. 				$browser_number, 
    749. 

  749. 				$ie_version, 
    750. 

  750. 				$b_dom_browser, 
    751. 

  751. 				$b_safe_browser, 
    752. 

  752. 				$os_type, 
    753. 

  753. 				$os_number, 
    754. 

  754. 				$browser_name, 
    755. 

  755. 				$ua_type, 
    756. 

  756. 				$browser_math_number, 
    757. 

  757. 				$a_moz_data, 
    758. 

  758. 				$a_webkit_data, 
    759. 

  759. 				$mobile_test, 
    760. 

  760. 				$a_mobile_data, 
    761. 

  761. 				$true_ie_number,
    762. 

  762. 				$run_time
    763. 

  763. 			);
    764. 

  764. 			// print_r( $a_full_data );
    765. 

  765. 			return $a_full_data;
    766. 

  766. 			break;
    767. 

  767. 		// returns all relevant browser information in an associative array
    768. 

  768. 		case 'full_assoc':
    769. 

  769. 			return $a_full_assoc_data;
    770. 

  770. 			break;
    771. 

  771. 		default:
    772. 

  772. 			# check to see if the data is available, otherwise it's user typo of unsupported option
    773. 

  773. 			if ( isset( $a_full_assoc_data[$which_test] ) ) 
    774. 

  774. 			{
    775. 

  775. 				return $a_full_assoc_data[$which_test];
    776. 

  776. 			}
    777. 

  777. 			else 
    778. 

  778. 			{
    779. 

  779. 				die( "You passed the browser detector an unsupported option for parameter 1: " . $which_test );
    780. 

  780. 			}
    781. 

  781. 			break;
    782. 

  782. 	}
    783. 

  783. }
    784. 

  784. 

  785. // gets which os from the browser string
    786. 

  786. function get_os_data ( $pv_browser_string, $pv_browser_name, $pv_version_number  )
    787. 

  787. {
    788. 

  788. 	// initialize variables
    789. 

  789. 	$os_working_type = '';
    790. 

  790. 	$os_working_number = '';
    791. 

  791. 	/*
    792. 

  792. 	packs the os array. Use this order since some navigator user agents will put 'macintosh' 
    793. 

  793. 	in the navigator user agent string which would make the nt test register true
    794. 

  794. 	*/
    795. 

  795. 	$a_mac = array( 'intel mac', 'ppc mac', 'mac68k' );// this is not used currently
    796. 

  796. 	// same logic, check in order to catch the os's in order, last is always default item
    797. 

  797. 	$a_unix_types = array( 'dragonfly', 'freebsd', 'openbsd', 'netbsd', 'bsd', 'unixware', 'solaris', 'sunos', 'sun4', 'sun5', 'suni86', 'sun', 'irix5', 'irix6', 'irix', 'hpux9', 'hpux10', 'hpux11', 'hpux', 'hp-ux', 'aix1', 'aix2', 'aix3', 'aix4', 'aix5', 'aix', 'sco', 'unixware', 'mpras', 'reliant', 'dec', 'sinix', 'unix' );
    798. 

  798. 	// only sometimes will you get a linux distro to id itself...
    799. 

  799. 	$a_linux_distros = array( 'ubuntu', 'kubuntu', 'xubuntu', 'mepis', 'xandros', 'linspire', 'winspire', 'jolicloud', 'sidux', 'kanotix', 'debian', 'opensuse', 'suse', 'fedora', 'redhat', 'slackware', 'slax', 'mandrake', 'mandriva', 'gentoo', 'sabayon', 'linux' );
    800. 

  800. 	$a_linux_process = array ( 'i386', 'i586', 'i686' );// not use currently
    801. 

  801. 	// note, order of os very important in os array, you will get failed ids if changed
    802. 

  802. 	$a_os_types = array( 'android', 'blackberry', 'iphone', 'palmos', 'palmsource', 'symbian', 'beos', 'os2', 'amiga', 'webtv', 'mac', 'nt', 'win', $a_unix_types, $a_linux_distros );
    803. 

  803. 	
    804. 

  804. 	//os tester
    805. 

  805. 	$i_count = count( $a_os_types );
    806. 

  806. 	for ( $i = 0; $i < $i_count; $i++ )
    807. 

  807. 	{
    808. 

  808. 		// unpacks os array, assigns to variable $a_os_working
    809. 

  809. 		$os_working_data = $a_os_types[$i];
    810. 

  810. 		/*
    811. 

  811. 		assign os to global os variable, os flag true on success
    812. 

  812. 		!strstr($pv_browser_string, "linux" ) corrects a linux detection bug
    813. 

  813. 		*/
    814. 

  814. 		if ( !is_array( $os_working_data ) && strstr( $pv_browser_string, $os_working_data ) && !strstr( $pv_browser_string, "linux" ) )
    815. 

  815. 		{
    816. 

  816. 			$os_working_type = $os_working_data;
    817. 

  817. 			
    818. 

  818. 			switch ( $os_working_type )
    819. 

  819. 			{
    820. 

  820. 				// most windows now uses: NT X.Y syntax
    821. 

  821. 				case 'nt':
    822. 

  822. 					if ( strstr( $pv_browser_string, 'nt 6.1' ) )// windows 7
    823. 

  823. 					{
    824. 

  824. 						$os_working_number = 6.1;
    825. 

  825. 					}
    826. 

  826. 					elseif ( strstr( $pv_browser_string, 'nt 6.0' ) )// windows vista/server 2008
    827. 

  827. 					{
    828. 

  828. 						$os_working_number = 6.0;
    829. 

  829. 					}
    830. 

  830. 					elseif ( strstr( $pv_browser_string, 'nt 5.2' ) )// windows server 2003
    831. 

  831. 					{
    832. 

  832. 						$os_working_number = 5.2;
    833. 

  833. 					}
    834. 

  834. 					elseif ( strstr( $pv_browser_string, 'nt 5.1' ) || strstr( $pv_browser_string, 'xp' ) )// windows xp
    835. 

  835. 					{
    836. 

  836. 						$os_working_number = 5.1;//
    837. 

  837. 					}
    838. 

  838. 					elseif ( strstr( $pv_browser_string, 'nt 5' ) || strstr( $pv_browser_string, '2000' ) )// windows 2000
    839. 

  839. 					{
    840. 

  840. 						$os_working_number = 5.0;
    841. 

  841. 					}
    842. 

  842. 					elseif ( strstr( $pv_browser_string, 'nt 4' ) )// nt 4
    843. 

  843. 					{
    844. 

  844. 						$os_working_number = 4;
    845. 

  845. 					}
    846. 

  846. 					elseif ( strstr( $pv_browser_string, 'nt 3' ) )// nt 4
    847. 

  847. 					{
    848. 

  848. 						$os_working_number = 3;
    849. 

  849. 					}
    850. 

  850. 					break;
    851. 

  851. 				case 'win':
    852. 

  852. 					if ( strstr( $pv_browser_string, 'vista' ) )// windows vista, for opera ID
    853. 

  853. 					{
    854. 

  854. 						$os_working_number = 6.0;
    855. 

  855. 						$os_working_type = 'nt';
    856. 

  856. 					}
    857. 

  857. 					elseif ( strstr( $pv_browser_string, 'xp' ) )// windows xp, for opera ID
    858. 

  858. 					{
    859. 

  859. 						$os_working_number = 5.1;
    860. 

  860. 						$os_working_type = 'nt';
    861. 

  861. 					}
    862. 

  862. 					elseif ( strstr( $pv_browser_string, '2003' ) )// windows server 2003, for opera ID
    863. 

  863. 					{
    864. 

  864. 						$os_working_number = 5.2;
    865. 

  865. 						$os_working_type = 'nt';
    866. 

  866. 					}
    867. 

  867. 					elseif ( strstr( $pv_browser_string, 'windows ce' ) )// windows CE
    868. 

  868. 					{
    869. 

  869. 						$os_working_number = 'ce';
    870. 

  870. 						$os_working_type = 'nt';
    871. 

  871. 					}
    872. 

  872. 					elseif ( strstr( $pv_browser_string, '95' ) )
    873. 

  873. 					{
    874. 

  874. 						$os_working_number = '95';
    875. 

  875. 					}
    876. 

  876. 					elseif ( ( strstr( $pv_browser_string, '9x 4.9' ) ) || ( strstr( $pv_browser_string, ' me' ) ) )
    877. 

  877. 					{
    878. 

  878. 						$os_working_number = 'me';
    879. 

  879. 					}
    880. 

  880. 					elseif ( strstr( $pv_browser_string, '98' ) )
    881. 

  881. 					{
    882. 

  882. 						$os_working_number = '98';
    883. 

  883. 					}
    884. 

  884. 					elseif ( strstr( $pv_browser_string, '2000' ) )// windows 2000, for opera ID
    885. 

  885. 					{
    886. 

  886. 						$os_working_number = 5.0;
    887. 

  887. 						$os_working_type = 'nt';
    888. 

  888. 					}
    889. 

  889. 					break;
    890. 

  890. 				case 'mac':
    891. 

  891. 					if ( strstr( $pv_browser_string, 'os x' ) )
    892. 

  892. 					{
    893. 

  893. 						// if it doesn't have a version number, it is os x;
    894. 

  894. 						if ( strstr( $pv_browser_string, 'os x ' ) )
    895. 

  895. 						{
    896. 

  896. 							// numbers are like: 10_2.4, others 10.2.4
    897. 

  897. 							$os_working_number = str_replace( '_', '.', get_item_version( $pv_browser_string, 'os x' ) );
    898. 

  898. 						}
    899. 

  899. 						else
    900. 

  900. 						{
    901. 

  901. 							$os_working_number = 10;
    902. 

  902. 						}
    903. 

  903. 					}
    904. 

  904. 					/*
    905. 

  905. 					this is a crude test for os x, since safari, camino, ie 5.2, & moz >= rv 1.3
    906. 

  906. 					are only made for os x
    907. 

  907. 					*/
    908. 

  908. 					elseif ( ( $pv_browser_name == 'saf' ) || ( $pv_browser_name == 'cam' ) ||
    909. 

  909. 						( ( $pv_browser_name == 'moz' ) && ( $pv_version_number >= 1.3 ) ) ||
    910. 

  910. 						( ( $pv_browser_name == 'ie' ) && ( $pv_version_number >= 5.2 ) ) )
    911. 

  911. 					{
    912. 

  912. 						$os_working_number = 10;
    913. 

  913. 					}
    914. 

  914. 					break;
    915. 

  915. 				case 'iphone':
    916. 

  916. 					$os_working_number = 10;
    917. 

  917. 					break;
    918. 

  918. 				default:
    919. 

  919. 					break;
    920. 

  920. 			}
    921. 

  921. 			break;
    922. 

  922. 		}
    923. 

  923. 		/*
    924. 

  924. 		check that it's an array, check it's the second to last item
    925. 

  925. 		in the main os array, the unix one that is
    926. 

  926. 		*/
    927. 

  927. 		elseif ( is_array( $os_working_data ) && ( $i == ( $i_count - 2 ) ) )
    928. 

  928. 		{
    929. 

  929. 			$j_count = count($os_working_data);
    930. 

  930. 			for ($j = 0; $j < $j_count; $j++)
    931. 

  931. 			{
    932. 

  932. 				if ( strstr( $pv_browser_string, $os_working_data[$j] ) )
    933. 

  933. 				{
    934. 

  934. 					$os_working_type = 'unix'; //if the os is in the unix array, it's unix, obviously...
    935. 

  935. 					$os_working_number = ( $os_working_data[$j] != 'unix' ) ? $os_working_data[$j] : '';// assign sub unix version from the unix array
    936. 

  936. 					break;
    937. 

  937. 				}
    938. 

  938. 			}
    939. 

  939. 		}
    940. 

  940. 		/*
    941. 

  941. 		check that it's an array, check it's the last item
    942. 

  942. 		in the main os array, the linux one that is
    943. 

  943. 		*/
    944. 

  944. 		elseif ( is_array( $os_working_data ) && ( $i == ( $i_count - 1 ) ) )
    945. 

  945. 		{
    946. 

  946. 			$j_count = count($os_working_data);
    947. 

  947. 			for ($j = 0; $j < $j_count; $j++)
    948. 

  948. 			{
    949. 

  949. 				if ( strstr( $pv_browser_string, $os_working_data[$j] ) )
    950. 

  950. 				{
    951. 

  951. 					$os_working_type = 'lin';
    952. 

  952. 					// assign linux distro from the linux array, there's a default
    953. 

  953. 					//search for 'lin', if it's that, set version to ''
    954. 

  954. 					$os_working_number = ( $os_working_data[$j] != 'linux' ) ? $os_working_data[$j] : '';
    955. 

  955. 					break;
    956. 

  956. 				}
    957. 

  957. 			}
    958. 

  958. 		}
    959. 

  959. 	}
    960. 

  960. 

  961. 	// pack the os data array for return to main function
    962. 

  962. 	$a_os_data = array( $os_working_type, $os_working_number );
    963. 

  963. 

  964. 	return $a_os_data;
    965. 

  965. }
    966. 

  966. 

  967. /* 
    968. 

  968. Function Info:
    969. 

  969. function returns browser number, gecko rv number, or gecko release date
    970. 

  970. function get_item_version( $browser_user_agent, $search_string, $substring_length )
    971. 

  971. $pv_extra_search='' allows us to set an additional search/exit loop parameter, but we
    972. 

  972. only want this running when needed 
    973. 

  973. */
    974. 

  974. function get_item_version( $pv_browser_user_agent, $pv_search_string, $pv_b_break_last='', $pv_extra_search='' )
    975. 

  975. {
    976. 

  976. 	// 12 is the longest that will be required, handles release dates: 20020323; 0.8.0+
    977. 

  977. 	$substring_length = 15;
    978. 

  978. 	$start_pos = 0; // set $start_pos to 0 for first iteration
    979. 

  979. 	//initialize browser number, will return '' if not found
    980. 

  980. 	$string_working_number = '';
    981. 

  981. 	/* 
    982. 

  982. 	use the passed parameter for $pv_search_string
    983. 

  983. 	start the substring slice right after these moz search strings
    984. 

  984. 	there are some cases of double msie id's, first in string and then with then number
    985. 

  985. 	$start_pos = 0;
    986. 

  986. 	this test covers you for multiple occurrences of string, only with ie though
    987. 

  987. 	with for example google bot you want the first occurance returned, since that's where the
    988. 

  988. 	numbering happens 
    989. 

  989. 	*/
    990. 

  990. 	for ( $i = 0; $i < 4; $i++ )
    991. 

  991. 	{
    992. 

  992. 		//start the search after the first string occurrence
    993. 

  993. 		if ( strpos( $pv_browser_user_agent, $pv_search_string, $start_pos ) !== false )
    994. 

  994. 		{
    995. 

  995. 			// update start position if position found
    996. 

  996. 			$start_pos = strpos( $pv_browser_user_agent, $pv_search_string, $start_pos ) + strlen( $pv_search_string );
    997. 

  997. 			/*
    998. 

  998. 			msie (and maybe other userAgents requires special handling because some apps inject 
    999. 

  999. 			a second msie, usually at the beginning, custom modes allow breaking at first instance
    1000. 

  1000. 			if $pv_b_break_last $pv_extra_search conditions exist. Since we only want this test
    1001. 

  1001. 			to run if and only if we need it, it's triggered by caller passing these values.
    1002. 

  1002. 			*/
    1003. 

  1003. 			if ( !$pv_b_break_last || ( $pv_extra_search && strstr( $pv_browser_user_agent, $pv_extra_search ) ) ) 
    1004. 

  1004. 			{
    1005. 

  1005. 				break;
    1006. 

  1006. 			}
    1007. 

  1007. 		}
    1008. 

  1008. 		else
    1009. 

  1009. 		{
    1010. 

  1010. 			break;
    1011. 

  1011. 		}
    1012. 

  1012. 	}
    1013. 

  1013. 	/*
    1014. 

  1014. 	Handles things like extra omniweb/v456, gecko/, blackberry9700
    1015. 

  1015. 	also corrects for the omniweb 'v'
    1016. 

  1016. 	*/
    1017. 

  1017. 	$start_pos += get_set_count( 'get' );
    1018. 

  1018. 	$string_working_number = substr( $pv_browser_user_agent, $start_pos, $substring_length );
    1019. 

  1019. 

  1020. 	// Find the space, ;, or parentheses that ends the number
    1021. 

  1021. 	$string_working_number = substr( $string_working_number, 0, strcspn($string_working_number, ' );/') );
    1022. 

  1022. 

  1023. 	//make sure the returned value is actually the id number and not a string
    1024. 

  1024. 	// otherwise return ''
    1025. 

  1025. 	// strcspn( $string_working_number, '0123456789.') == strlen( $string_working_number)
    1026. 

  1026. 	//	if ( preg_match("/\\d/", $string_working_number) == 0 )
    1027. 

  1027.  	if ( !is_numeric( substr( $string_working_number, 0, 1 ) ) )
    1028. 

  1028. 	{
    1029. 

  1029. 		$string_working_number = '';
    1030. 

  1030. 	}
    1031. 

  1031. 	//$string_working_number = strrpos( $pv_browser_user_agent, $pv_search_string );
    1032. 

  1032. 	return $string_working_number;
    1033. 

  1033. }
    1034. 

  1034. 

  1035. function get_set_count( $pv_type, $pv_value='' )
    1036. 

  1036. {
    1037. 

  1037. 	static $slice_increment;
    1038. 

  1038. 	$return_value = '';
    1039. 

  1039. 	switch ( $pv_type )
    1040. 

  1040. 	{
    1041. 

  1041. 		case 'get':
    1042. 

  1042. 			// set if unset, ie, first use. note that empty and isset are not good tests here
    1043. 

  1043. 			if ( is_null( $slice_increment ) )
    1044. 

  1044. 			{
    1045. 

  1045. 				$slice_increment = 1;
    1046. 

  1046. 			}
    1047. 

  1047. 			$return_value = $slice_increment;
    1048. 

  1048. 			$slice_increment = 1; // reset to default
    1049. 

  1049. 			return $return_value;
    1050. 

  1050. 			break;
    1051. 

  1051. 		case 'set':
    1052. 

  1052. 			$slice_increment = $pv_value;
    1053. 

  1053. 			break;
    1054. 

  1054. 	}
    1055. 

  1055. }
    1056. 

  1056. 

  1057. /*
    1058. 

  1058. Special ID notes:
    1059. 

  1059. Novarra-Vision is a Content Transformation Server (CTS)
    1060. 

  1060. */
    1061. 

  1061. function check_is_mobile( $pv_browser_user_agent )
    1062. 

  1062. {
    1063. 

  1063. 	$mobile_working_test = '';
    1064. 

  1064. 	/*
    1065. 

  1065. 	these will search for basic mobile hints, this should catch most of them, first check
    1066. 

  1066. 	known hand held device os, then check device names, then mobile browser names
    1067. 

  1067. 	This list is almost the same but not exactly as the 4 arrays in function below
    1068. 

  1068. 	*/
    1069. 

  1069. 	$a_mobile_search = array( 
    1070. 

  1070. 	/*
    1071. 

  1071. 	Make sure to use only data here that always will be a mobile, so this list is not
    1072. 

  1072. 	identical to the list of get_mobile_data
    1073. 

  1073. 	*/
    1074. 

  1074. 	// os
    1075. 

  1075. 	'android', 'epoc', 'linux armv', 'palmos', 'palmsource', 'windows ce', 'windows phone os', 'symbianos', 'symbian os', 'symbian', 'webos', 
    1076. 

  1076. 	// devices - ipod before iphone or fails
    1077. 

  1077. 	'benq', 'blackberry', 'danger hiptop', 'ddipocket', ' droid', 'ipad', 'ipod', 'iphone', 'kindle', 'lge-cx', 'lge-lx', 'lge-mx', 'lge vx', 'lge ', 'lge-', 'lg;lx', 'nintendo wii', 'nokia', 'palm', 'pdxgw', 'playstation', 'sagem', 'samsung', 'sec-sgh', 'sharp', 'sonyericsson', 'sprint', 'zune', 'j-phone', 'n410', 'mot 24', 'mot-', 'htc-', 'htc_', 'htc ', 'sec-', 'sie-m', 'sie-s', 'spv ', 'vodaphone', 'smartphone', 'armv', 'midp', 'mobilephone',
    1078. 

  1078. 	// browsers
    1079. 

  1079. 	'avantgo', 'blazer', 'elaine', 'eudoraweb', 'iemobile',  'minimo', 'mobile safari', 'mobileexplorer', 'opera mobi', 'opera mini', 'netfront', 'opwv', 'polaris', 'semc-browser', 'up.browser', 'webpro', 'wms pie', 'xiino', 
    1080. 

  1080. 	// services - astel out of business
    1081. 

  1081. 	'astel',  'docomo',  'novarra-vision', 'portalmmm', 'reqwirelessweb', 'vodafone'
    1082. 

  1082. 	);
    1083. 

  1083. 

  1084. 	// then do basic mobile type search, this uses data from: get_mobile_data()
    1085. 

  1085. 	$j_count = count( $a_mobile_search );
    1086. 

  1086. 	for ($j = 0; $j < $j_count; $j++)
    1087. 

  1087. 	{
    1088. 

  1088. 		if ( strstr( $pv_browser_user_agent, $a_mobile_search[$j] ) )
    1089. 

  1089. 		{
    1090. 

  1090. 			$mobile_working_test = $a_mobile_search[$j];
    1091. 

  1091. 			break;
    1092. 

  1092. 		}
    1093. 

  1093. 	}
    1094. 

  1094. 	
    1095. 

  1095. 	return $mobile_working_test;
    1096. 

  1096. }
    1097. 

  1097. 

  1098. /*
    1099. 

  1099. thanks to this page: http://www.zytrax.com/tech/web/mobile_ids.html
    1100. 

  1100. for data used here
    1101. 

  1101. */
    1102. 

  1102. function get_mobile_data( $pv_browser_user_agent )
    1103. 

  1103. {
    1104. 

  1104. 	$mobile_browser = '';
    1105. 

  1105. 	$mobile_browser_number = '';
    1106. 

  1106. 	$mobile_device = '';
    1107. 

  1107. 	$mobile_device_number = '';
    1108. 

  1108. 	$mobile_os = ''; // will usually be null, sorry
    1109. 

  1109. 	$mobile_os_number = '';
    1110. 

  1110. 	$mobile_server = '';
    1111. 

  1111. 	$mobile_server_number = '';
    1112. 

  1112. 	
    1113. 

  1113. 	// browsers, show it as a handheld, but is not the os
    1114. 

  1114. 	$a_mobile_browser = array( 'avantgo', 'blazer', 'elaine', 'eudoraweb', 'iemobile',  'minimo', 'mobile safari', 'mobileexplorer', 'opera mobi', 'opera mini', 'netfront', 'opwv', 'polaris', 'semc-browser', 'up.browser', 'webpro', 'wms pie', 'xiino' );
    1115. 

  1115. 	/*
    1116. 

  1116. 	This goes from easiest to detect to hardest, so don't use this for output unless you
    1117. 

  1117. 	clean it up more is my advice.
    1118. 

  1118. 	Special Notes: do not include milestone in general mobile type test above, it's too generic
    1119. 

  1119. 	*/
    1120. 

  1120. 	$a_mobile_device = array( 'benq', 'blackberry', 'danger hiptop', 'ddipocket', ' droid', 'htc_dream', 'htc espresso', 'htc hero', 'htc halo', 'htc huangshan', 'htc legend', 'htc liberty', 'htc paradise', 'htc supersonic', 'htc tattoo', 'ipad', 'ipod', 'iphone', 'kindle', 'lge-cx', 'lge-lx', 'lge-mx', 'lge vx', 'lg;lx', 'nintendo wii', 'nokia', 'palm', 'pdxgw', 'playstation', 'sagem', 'samsung', 'sec-sgh', 'sharp', 'sonyericsson', 'sprint', 'zunehd', 'zune', 'j-phone', 'milestone', 'n410', 'mot 24', 'mot-', 'htc-', 'htc_',  'htc ', 'lge ', 'lge-', 'sec-', 'sie-m', 'sie-s', 'spv ', 'smartphone', 'armv', 'midp', 'mobilephone' );
    1121. 

  1121. 	/*
    1122. 

  1122. 	note: linux alone can't be searched for, and almost all linux devices are armv types
    1123. 

  1123. 	ipad 'cpu os' is how the real os number is handled
    1124. 

  1124. 	*/
    1125. 

  1125. 	$a_mobile_os = array( 'android', 'epoc', 'cpu os', 'iphone os', 'palmos', 'palmsource', 'windows phone os', 'windows ce', 'symbianos', 'symbian os', 'symbian', 'webos', 'linux armv'  );
    1126. 

  1126. 	
    1127. 

  1127. 	// sometimes there is just no other id for the unit that the CTS type service/server
    1128. 

  1128. 	$a_mobile_server = array( 'astel', 'docomo', 'novarra-vision', 'portalmmm', 'reqwirelessweb', 'vodafone' );
    1129. 

  1129. 

  1130. 	$k_count = count( $a_mobile_browser );
    1131. 

  1131. 	for ( $k = 0; $k < $k_count; $k++ )
    1132. 

  1132. 	{
    1133. 

  1133. 		if ( strstr( $pv_browser_user_agent, $a_mobile_browser[$k] ) )
    1134. 

  1134. 		{
    1135. 

  1135. 			$mobile_browser = $a_mobile_browser[$k];
    1136. 

  1136. 			// this may or may not work, highly unreliable because mobile ua strings are random
    1137. 

  1137. 			$mobile_browser_number = get_item_version( $pv_browser_user_agent, $mobile_browser );
    1138. 

  1138. 			break;
    1139. 

  1139. 		}
    1140. 

  1140. 	}
    1141. 

  1141. 	$k_count = count( $a_mobile_device );
    1142. 

  1142. 	for ( $k = 0; $k < $k_count; $k++ )
    1143. 

  1143. 	{
    1144. 

  1144. 		if ( strstr( $pv_browser_user_agent, $a_mobile_device[$k] ) )
    1145. 

  1145. 		{
    1146. 

  1146. 			$mobile_device = trim ( $a_mobile_device[$k], '-_' ); // but not space trims yet
    1147. 

  1147. 			if ( $mobile_device == 'blackberry' )
    1148. 

  1148. 			{
    1149. 

  1149. 				get_set_count( 'set', 0 );
    1150. 

  1150. 			}
    1151. 

  1151. 			$mobile_device_number = get_item_version( $pv_browser_user_agent, $mobile_device );
    1152. 

  1152. 			$mobile_device = trim( $mobile_device ); // some of the id search strings have white space
    1153. 

  1153. 			break;
    1154. 

  1154. 		}
    1155. 

  1155. 	}
    1156. 

  1156. 	$k_count = count( $a_mobile_os );
    1157. 

  1157. 	for ( $k = 0; $k < $k_count; $k++ )
    1158. 

  1158. 	{
    1159. 

  1159. 		if ( strstr( $pv_browser_user_agent, $a_mobile_os[$k] ) )
    1160. 

  1160. 		{
    1161. 

  1161. 			$mobile_os = $a_mobile_os[$k];
    1162. 

  1162. 			// this may or may not work, highly unreliable
    1163. 

  1163. 			$mobile_os_number = str_replace( '_', '.', get_item_version( $pv_browser_user_agent, $mobile_os ) );
    1164. 

  1164. 			break;
    1165. 

  1165. 		}
    1166. 

  1166. 	}
    1167. 

  1167. 	$k_count = count( $a_mobile_server );
    1168. 

  1168. 	for ( $k = 0; $k < $k_count; $k++ )
    1169. 

  1169. 	{
    1170. 

  1170. 		if ( strstr( $pv_browser_user_agent, $a_mobile_server[$k] ) )
    1171. 

  1171. 		{
    1172. 

  1172. 			$mobile_server = $a_mobile_server[$k];
    1173. 

  1173. 			// this may or may not work, highly unreliable
    1174. 

  1174. 			$mobile_server_number = get_item_version( $pv_browser_user_agent, $mobile_server );
    1175. 

  1175. 			break;
    1176. 

  1176. 		}
    1177. 

  1177. 	}
    1178. 

  1178. 	// just for cases where we know it's a mobile device already
    1179. 

  1179. 	if ( !$mobile_os && ( $mobile_browser || $mobile_device || $mobile_server ) && strstr( $pv_browser_user_agent, 'linux' ) )
    1180. 

  1180. 	{
    1181. 

  1181. 		$mobile_os = 'linux';
    1182. 

  1182. 		$mobile_os_number = get_item_version( $pv_browser_user_agent, 'linux' );
    1183. 

  1183. 	}
    1184. 

  1184. 

  1185. 	$a_mobile_data = array( $mobile_device, $mobile_browser, $mobile_browser_number, $mobile_os, $mobile_os_number, $mobile_server, $mobile_server_number, $mobile_device_number );
    1186. 

  1186. 	return $a_mobile_data;
    1187. 

  1187. }
    1188. 

  1188. 

  1189. // track total script execution time
    1190. 

  1190. function script_time() 
    1191. 

  1191. {
    1192. 

  1192. 	static $script_time;
    1193. 

  1193. 	$elapsed_time = '';
    1194. 

  1194. 	/* 
    1195. 

  1195. 	note that microtime(true) requires php 5 or greater for microtime(true)
    1196. 

  1196. 	*/
    1197. 

  1197. 	if ( sprintf("%01.1f", phpversion() ) >= 5 ) {
    1198. 

  1198. 		if ( is_null( $script_time) ) {
    1199. 

  1199. 			$script_time = microtime(true);
    1200. 

  1200. 		}
    1201. 

  1201. 		else {
    1202. 

  1202. 			// note: (string)$var is same as strval($var)
    1203. 

  1203. 			// $elapsed_time = (string)( microtime(true) - $script_time );
    1204. 

  1204. 			$elapsed_time = ( microtime(true) - $script_time );
    1205. 

  1205. 			$elapsed_time = sprintf("%01.8f", $elapsed_time );
    1206. 

  1206. 			$script_time = NULL; // can't unset a static variable
    1207. 

  1207. 			return $elapsed_time;
    1208. 

  1208. 		}
    1209. 

  1209. 	}
    1210. 

  1210. }
    1211. 

  1211. 

  1212. /*
    1213. 

  1213. Here are some navigator.userAgent strings so you can see where the data comes from
    1214. 

  1214. UserAgent Data:
    1215. 

  1215. Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 6.0; Trident/4.0; User-agent: Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; http://bsalsa.com) ; SLCC1; .NET CLR 2.0.50727; Media Center PC 5.0; .NET CLR 3.5.30729; .NET CLR 3.0.30618)
    1216. 

  1216. Mozilla/5.0 (Windows; U; Windows NT 6.0; en-US; rv:1.9.0.7) Gecko/2009021910 Firefox/3.0.7 (.NET CLR 3.5.30729)
    1217. 

  1217. Mozilla/5.0 (Windows; U; Windows NT 5.0; en-US; rv:1.5) Gecko/20031007 Firebird/0.7
    1218. 

  1218. Mozilla/5.0 (Windows; U; Windows NT 5.0; en-US; rv:0.9.4) Gecko/20011128 Net…
    1219.

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