PageRenderTime 67ms CodeModel.GetById 24ms RepoModel.GetById 0ms app.codeStats 1ms

/administrator/components/com_patch/patch/administrator/components/com_jaclplus/patch/joomla.php

https://github.com/viollarr/alab
PHP | 6212 lines | 5335 code | 227 blank | 650 comment | 250 complexity | a0d7c6cfbf70d91d12fb69fb4836601d MD5 | raw file
Possible License(s): LGPL-2.1, GPL-2.0, AGPL-3.0, Apache-2.0, BSD-3-Clause, GPL-3.0

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

    

  1. <?php


    2. 

  2. /**


    3. 

  3. * This file has been modified by Vincent Cheah, ByOS Technologies 2008-02-27 12:07 


    4. 

  4. * for integration with JACLPlus Component 


    5. 

  5. */


    6. 

  6. /**


    7. 

  7. * @version $Id: joomla.php 9997 2008-02-07 11:27:04Z eddieajau $


    8. 

  8. * @package Joomla


    9. 

  9. * @copyright Copyright (C) 2005 Open Source Matters. All rights reserved.


    10. 

  10. * @license http://www.gnu.org/copyleft/gpl.html GNU/GPL, see LICENSE.php


    11. 

  11. * Joomla! is free software. This version may have been modified pursuant


    12. 

  12. * to the GNU General Public License, and as distributed it includes or


    13. 

  13. * is derivative of works licensed under the GNU General Public License or


    14. 

  14. * other free or open source software licenses.


    15. 

  15. * See COPYRIGHT.php for copyright notices and details.


    16. 

  16. */


    17. 

  17. 


    18. 

  18. // no direct access


    19. 

  19. defined( '_VALID_MOS' ) or die( 'Restricted access' );


    20. 

  20. define( '_MOS_MAMBO_INCLUDED', 1 );


    21. 

  21. 


    22. 

  22. /**


    23. 

  23.  * Page generation time


    24. 

  24.  * @package Joomla


    25. 

  25.  */


    26. 

  26. class mosProfiler {


    27. 

  27. 	/** @var int Start time stamp */


    28. 

  28. 	var $start=0;


    29. 

  29. 	/** @var string A prefix for mark messages */


    30. 

  30. 	var $prefix='';


    31. 

  31. 


    32. 

  32. 	/**


    33. 

  33. 	 * Constructor


    34. 

  34. 	 * @param string A prefix for mark messages


    35. 

  35. 	 */


    36. 

  36. 	function mosProfiler( $prefix='' ) {


    37. 

  37. 		$this->start = $this->getmicrotime();


    38. 

  38. 		$this->prefix = $prefix;


    39. 

  39. 	}


    40. 

  40. 


    41. 

  41. 	/**


    42. 

  42. 	 * @return string A format message of the elapsed time


    43. 

  43. 	 */


    44. 

  44. 	function mark( $label ) {


    45. 

  45. 		return sprintf ( "\n<div class=\"profiler\">$this->prefix %.3f $label</div>", $this->getmicrotime() - $this->start );


    46. 

  46. 	}


    47. 

  47. 


    48. 

  48. 	/**


    49. 

  49. 	 * @return float The current time in milliseconds


    50. 

  50. 	 */


    51. 

  51. 	function getmicrotime(){


    52. 

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


    53. 

  53. 		return ((float)$usec + (float)$sec);


    54. 

  54. 	}


    55. 

  55. }


    56. 

  56. 


    57. 

  57. if (phpversion() < '4.2.0') {


    58. 

  58. 	require_once( dirname( __FILE__ ) . '/compat.php41x.php' );


    59. 

  59. }


    60. 

  60. if (phpversion() < '4.3.0') {


    61. 

  61. 	require_once( dirname( __FILE__ ) . '/compat.php42x.php' );


    62. 

  62. }


    63. 

  63. if (version_compare( phpversion(), '5.0' ) < 0) {


    64. 

  64. 	require_once( dirname( __FILE__ ) . '/compat.php50x.php' );


    65. 

  65. }


    66. 

  66. 


    67. 

  67. @set_magic_quotes_runtime( 0 );


    68. 

  68. 


    69. 

  69. if ( @$mosConfig_error_reporting === 0 || @$mosConfig_error_reporting === '0' ) {


    70. 

  70. 	error_reporting( 0 );


    71. 

  71. } else if (@$mosConfig_error_reporting > 0) {


    72. 

  72. 	error_reporting( $mosConfig_error_reporting );


    73. 

  73. }


    74. 

  74. 


    75. 

  75. /* Hack for integration with JACLPlus Component */


    76. 

  76. if(file_exists($mosConfig_absolute_path . '/administrator/components/com_jaclplus/jaclplus.class.php')) {


    77. 

  77. 	require_once( $mosConfig_absolute_path . '/administrator/components/com_jaclplus/jaclplus.class.php' );


    78. 

  78. }


    79. 

  79. /* End of hack for JACLPlus Component */


    80. 

  80. require_once( $mosConfig_absolute_path . '/includes/version.php' );


    81. 

  81. require_once( $mosConfig_absolute_path . '/includes/database.php' );


    82. 

  82. require_once( $mosConfig_absolute_path . '/includes/gacl.class.php' );


    83. 

  83. require_once( $mosConfig_absolute_path . '/includes/gacl_api.class.php' );


    84. 

  84. require_once( $mosConfig_absolute_path . '/includes/phpmailer/class.phpmailer.php' );


    85. 

  85. require_once( $mosConfig_absolute_path . '/includes/joomla.xml.php' );


    86. 

  86. require_once( $mosConfig_absolute_path . '/includes/phpInputFilter/class.inputfilter.php' );


    87. 

  87. 


    88. 

  88. $database = new database( $mosConfig_host, $mosConfig_user, $mosConfig_password, $mosConfig_db, $mosConfig_dbprefix );


    89. 

  89. if ($database->getErrorNum()) {


    90. 

  90. 	$mosSystemError = $database->getErrorNum();


    91. 

  91. 	$basePath = dirname( __FILE__ );


    92. 

  92. 	include $basePath . '/../configuration.php';


    93. 

  93. 	include $basePath . '/../offline.php';


    94. 

  94. 	exit();


    95. 

  95. }


    96. 

  96. $database->debug( $mosConfig_debug );


    97. 

  97. $acl = new gacl_api();


    98. 

  98. 


    99. 

  99. // platform neurtral url handling


    100. 

  100. if ( isset( $_SERVER['REQUEST_URI'] ) ) {


    101. 

  101. 	$request_uri = $_SERVER['REQUEST_URI'];


    102. 

  102. } else {


    103. 

  103. 	$request_uri = $_SERVER['SCRIPT_NAME'];


    104. 

  104. 	// Append the query string if it exists and isn't null


    105. 

  105. 	if ( isset( $_SERVER['QUERY_STRING'] ) && !empty( $_SERVER['QUERY_STRING'] ) ) {


    106. 

  106. 		$request_uri .= '?' . $_SERVER['QUERY_STRING'];


    107. 

  107. 	}


    108. 

  108. }


    109. 

  109. $_SERVER['REQUEST_URI'] = $request_uri;


    110. 

  110. 


    111. 

  111. // current server time


    112. 

  112. $now = date( 'Y-m-d H:i', time() );


    113. 

  113. DEFINE( '_CURRENT_SERVER_TIME', $now );


    114. 

  114. DEFINE( '_CURRENT_SERVER_TIME_FORMAT', '%Y-%m-%d %H:%M:%S' );


    115. 

  115. 


    116. 

  116. // Non http/https URL Schemes


    117. 

  117. $url_schemes = 'data:, file:, ftp:, gopher:, imap:, ldap:, mailto:, news:, nntp:, telnet:, javascript:, irc:, mms:';


    118. 

  118. DEFINE( '_URL_SCHEMES', $url_schemes );


    119. 

  119. 


    120. 

  120. // disable strict mode in MySQL 5


    121. 

  121. if (!defined( '_JOS_SET_SQLMODE' )) {


    122. 

  122. 	/** ensure that functions are declared only once */


    123. 

  123. 	define( '_JOS_SET_SQLMODE', 1 );


    124. 

  124. 


    125. 

  125. 	// if running mysql 5, set sql-mode to mysql40 - thereby circumventing strict mode problems


    126. 

  126. 	if ( strpos( $database->getVersion(), '5' ) === 0 ) {


    127. 

  127. 		$query = "SET sql_mode = 'MYSQL40'";


    128. 

  128. 		$database->setQuery( $query );


    129. 

  129. 		$database->query();


    130. 

  130. 	}


    131. 

  131. }


    132. 

  132. 


    133. 

  133. /**


    134. 

  134.  * @package Joomla


    135. 

  135.  * @abstract


    136. 

  136.  */


    137. 

  137. class mosAbstractLog {


    138. 

  138. 	/** @var array */


    139. 

  139. 	var $_log	= null;


    140. 

  140. 


    141. 

  141. 	/**


    142. 

  142. 	 * Constructor


    143. 

  143. 	 */


    144. 

  144. 	function mosAbstractLog() {


    145. 

  145. 		$this->__constructor();


    146. 

  146. 	}


    147. 

  147. 


    148. 

  148. 	/**


    149. 

  149. 	 * Generic constructor


    150. 

  150. 	 */


    151. 

  151. 	function __constructor() {


    152. 

  152. 		$this->_log = array();


    153. 

  153. 	}


    154. 

  154. 


    155. 

  155. 	/**


    156. 

  156. 	 * @param string Log message


    157. 

  157. 	 * @param boolean True to append to last message


    158. 

  158. 	 */


    159. 

  159. 	function log( $text, $append=false ) {


    160. 

  160. 		$n = count( $this->_log );


    161. 

  161. 		if ($append && $n > 0) {


    162. 

  162. 			$this->_log[count( $this->_log )-1] .= $text;


    163. 

  163. 		} else {


    164. 

  164. 			$this->_log[] = $text;


    165. 

  165. 		}


    166. 

  166. 	}


    167. 

  167. 


    168. 

  168. 	/**


    169. 

  169. 	 * @param string The glue for each log item


    170. 

  170. 	 * @return string Returns the log


    171. 

  171. 	 */


    172. 

  172. 	function getLog( $glue='<br/>', $truncate=9000, $htmlSafe=false ) {


    173. 

  173. 		$logs = array();


    174. 

  174. 		foreach ($this->_log as $log) {


    175. 

  175. 			if ($htmlSafe) {


    176. 

  176. 				$log = htmlspecialchars( $log );


    177. 

  177. 			}


    178. 

  178. 			$logs[] = substr( $log, 0, $truncate );


    179. 

  179. 		}


    180. 

  180. 		return  implode( $glue, $logs );


    181. 

  181. 	}


    182. 

  182. }


    183. 

  183. 


    184. 

  184. /**


    185. 

  185.  * Task routing class


    186. 

  186.  * @package Joomla


    187. 

  187.  * @abstract


    188. 

  188.  */


    189. 

  189. class mosAbstractTasker {


    190. 

  190. 	/** @var array An array of the class methods to call for a task */


    191. 

  191. 	var $_taskMap 	= null;


    192. 

  192. 	/** @var string The name of the current task*/


    193. 

  193. 	var $_task 		= null;


    194. 

  194. 	/** @var array An array of the class methods*/


    195. 

  195. 	var $_methods 	= null;


    196. 

  196. 	/** @var string A url to redirect to */


    197. 

  197. 	var $_redirect 	= null;


    198. 

  198. 	/** @var string A message about the operation of the task */


    199. 

  199. 	var $_message 	= null;


    200. 

  200. 


    201. 

  201. 	// action based access control


    202. 

  202. 


    203. 

  203. 	/** @var string The ACO Section */


    204. 

  204. 	var $_acoSection 		= null;


    205. 

  205. 	/** @var string The ACO Section value */


    206. 

  206. 	var $_acoSectionValue 	= null;


    207. 

  207. 


    208. 

  208. 	/**


    209. 

  209. 	 * Constructor


    210. 

  210. 	 * @param string Set the default task


    211. 

  211. 	 */


    212. 

  212. 	function mosAbstractTasker( $default='' ) {


    213. 

  213. 		$this->_taskMap = array();


    214. 

  214. 		$this->_methods = array();


    215. 

  215. 		foreach (get_class_methods( get_class( $this ) ) as $method) {


    216. 

  216. 			if (substr( $method, 0, 1 ) != '_') {


    217. 

  217. 				$this->_methods[] = strtolower( $method );


    218. 

  218. 				// auto register public methods as tasks


    219. 

  219. 				$this->_taskMap[strtolower( $method )] = $method;


    220. 

  220. 			}


    221. 

  221. 		}


    222. 

  222. 		$this->_redirect = '';


    223. 

  223. 		$this->_message = '';


    224. 

  224. 		if ($default) {


    225. 

  225. 			$this->registerDefaultTask( $default );


    226. 

  226. 		}


    227. 

  227. 	}


    228. 

  228. 


    229. 

  229. 	/**


    230. 

  230. 	 * Sets the access control levels


    231. 

  231. 	 * @param string The ACO section (eg, the component)


    232. 

  232. 	 * @param string The ACO section value (if using a constant value)


    233. 

  233. 	 */


    234. 

  234. 	function setAccessControl( $section, $value=null ) {


    235. 

  235. 		$this->_acoSection = $section;


    236. 

  236. 		$this->_acoSectionValue = $value;


    237. 

  237. 	}


    238. 

  238. 	/**


    239. 

  239. 	 * Access control check


    240. 

  240. 	 */


    241. 

  241. 	function accessCheck( $task ) {


    242. 

  242. 		global $acl, $my;


    243. 

  243. 


    244. 

  244. 		// only check if the derived class has set these values


    245. 

  245. 		if ($this->_acoSection) {


    246. 

  246. 			// ensure user has access to this function


    247. 

  247. 			if ($this->_acoSectionValue) {


    248. 

  248. 				// use a 'constant' task for this task handler


    249. 

  249. 				$task = $this->_acoSectionValue;


    250. 

  250. 			}


    251. 

  251. 			return $acl->acl_check( $this->_acoSection, $task, 'users', $my->usertype );


    252. 

  252. 		} else {


    253. 

  253. 			return true;


    254. 

  254. 		}


    255. 

  255. 	}


    256. 

  256. 


    257. 

  257. 	/**


    258. 

  258. 	 * Set a URL to redirect the browser to


    259. 

  259. 	 * @param string A URL


    260. 

  260. 	 */


    261. 

  261. 	function setRedirect( $url, $msg = null ) {


    262. 

  262. 		$this->_redirect = $url;


    263. 

  263. 		if ($msg !== null) {


    264. 

  264. 			$this->_message = $msg;


    265. 

  265. 		}


    266. 

  266. 	}


    267. 

  267. 	/**


    268. 

  268. 	 * Redirects the browser


    269. 

  269. 	 */


    270. 

  270. 	function redirect() {


    271. 

  271. 		if ($this->_redirect) {


    272. 

  272. 			mosRedirect( $this->_redirect, $this->_message );


    273. 

  273. 		}


    274. 

  274. 	}


    275. 

  275. 	/**


    276. 

  276. 	 * Register (map) a task to a method in the class


    277. 

  277. 	 * @param string The task


    278. 

  278. 	 * @param string The name of the method in the derived class to perform for this task


    279. 

  279. 	 */


    280. 

  280. 	function registerTask( $task, $method ) {


    281. 

  281. 		if (in_array( strtolower( $method ), $this->_methods )) {


    282. 

  282. 			$this->_taskMap[strtolower( $task )] = $method;


    283. 

  283. 		} else {


    284. 

  284. 			$this->methodNotFound( $method );


    285. 

  285. 		}


    286. 

  286. 	}


    287. 

  287. 	/**


    288. 

  288. 	 * Register the default task to perfrom if a mapping is not found


    289. 

  289. 	 * @param string The name of the method in the derived class to perform if the task is not found


    290. 

  290. 	 */


    291. 

  291. 	function registerDefaultTask( $method ) {


    292. 

  292. 		$this->registerTask( '__default', $method );


    293. 

  293. 	}


    294. 

  294. 	/**


    295. 

  295. 	 * Perform a task by triggering a method in the derived class


    296. 

  296. 	 * @param string The task to perform


    297. 

  297. 	 * @return mixed The value returned by the function


    298. 

  298. 	 */


    299. 

  299. 	function performTask( $task ) {


    300. 

  300. 		$this->_task = $task;


    301. 

  301. 


    302. 

  302. 		$task = strtolower( $task );


    303. 

  303. 		if (isset( $this->_taskMap[$task] )) {


    304. 

  304. 			$doTask = $this->_taskMap[$task];


    305. 

  305. 		} else if (isset( $this->_taskMap['__default'] )) {


    306. 

  306. 			$doTask = $this->_taskMap['__default'];


    307. 

  307. 		} else {


    308. 

  308. 			return $this->taskNotFound( $this->_task );


    309. 

  309. 		}


    310. 

  310. 


    311. 

  311. 		if ($this->accessCheck( $doTask )) {


    312. 

  312. 			return call_user_func( array( &$this, $doTask ) );


    313. 

  313. 		} else {


    314. 

  314. 			return $this->notAllowed( $task );


    315. 

  315. 		}


    316. 

  316. 	}


    317. 

  317. 	/**


    318. 

  318. 	 * Get the last task that was to be performed


    319. 

  319. 	 * @return string The task that was or is being performed


    320. 

  320. 	 */


    321. 

  321. 	function getTask() {


    322. 

  322. 		return $this->_task;


    323. 

  323. 	}


    324. 

  324. 	/**


    325. 

  325. 	 * Basic method if the task is not found


    326. 

  326. 	 * @param string The task


    327. 

  327. 	 * @return null


    328. 

  328. 	 */


    329. 

  329. 	function taskNotFound( $task ) {


    330. 

  330. 		echo 'Task ' . $task . ' not found';


    331. 

  331. 		return null;


    332. 

  332. 	}


    333. 

  333. 	/**


    334. 

  334. 	 * Basic method if the registered method is not found


    335. 

  335. 	 * @param string The name of the method in the derived class


    336. 

  336. 	 * @return null


    337. 

  337. 	 */


    338. 

  338. 	function methodNotFound( $name ) {


    339. 

  339. 		echo 'Method ' . $name . ' not found';


    340. 

  340. 		return null;


    341. 

  341. 	}


    342. 

  342. 	/**


    343. 

  343. 	 * Basic method if access is not permitted to the task


    344. 

  344. 	 * @param string The name of the method in the derived class


    345. 

  345. 	 * @return null


    346. 

  346. 	 */


    347. 

  347. 	function notAllowed( $name ) {


    348. 

  348. 		echo _NOT_AUTH;


    349. 

  349. 


    350. 

  350. 		return null;


    351. 

  351. 	}


    352. 

  352. }


    353. 

  353. /**


    354. 

  354. * Class to support function caching


    355. 

  355. * @package Joomla


    356. 

  356. */


    357. 

  357. class mosCache {


    358. 

  358. 	/**


    359. 

  359. 	* @return object A function cache object


    360. 

  360. 	*/


    361. 

  361. 	function &getCache(  $group=''  ) {


    362. 

  362. 		global $mosConfig_absolute_path, $mosConfig_caching, $mosConfig_cachepath, $mosConfig_cachetime;


    363. 

  363. 


    364. 

  364. 		require_once( $mosConfig_absolute_path . '/includes/joomla.cache.php' );


    365. 

  365. 


    366. 

  366. 		$options = array(


    367. 

  367. 			'cacheDir' 		=> $mosConfig_cachepath . '/',


    368. 

  368. 			'caching' 		=> $mosConfig_caching,


    369. 

  369. 			'defaultGroup' 	=> $group,


    370. 

  370. 			'lifeTime' 		=> $mosConfig_cachetime


    371. 

  371. 		);


    372. 

  372. 		$cache = new JCache_Lite_Function( $options );


    373. 

  373. 		return $cache;


    374. 

  374. 	}


    375. 

  375. 	/**


    376. 

  376. 	* Cleans the cache


    377. 

  377. 	*/


    378. 

  378. 	function cleanCache( $group=false ) {


    379. 

  379. 		global $mosConfig_caching;


    380. 

  380. 		if ($mosConfig_caching) {


    381. 

  381. 			$cache =& mosCache::getCache( $group );


    382. 

  382. 			$cache->clean( $group );


    383. 

  383. 		}


    384. 

  384. 	}


    385. 

  385. }


    386. 

  386. /**


    387. 

  387. * Joomla! Mainframe class


    388. 

  388. *


    389. 

  389. * Provide many supporting API functions


    390. 

  390. * @package Joomla


    391. 

  391. */


    392. 

  392. class mosMainFrame {


    393. 

  393. 	/** @var database Internal database class pointer */


    394. 

  394. 	var $_db						= null;


    395. 

  395. 	/** @var object An object of configuration variables */


    396. 

  396. 	var $_config					= null;


    397. 

  397. 	/** @var object An object of path variables */


    398. 

  398. 	var $_path						= null;


    399. 

  399. 	/** @var mosSession The current session */


    400. 

  400. 	var $_session					= null;


    401. 

  401. 	/** @var string The current template */


    402. 

  402. 	var $_template					= null;


    403. 

  403. 	/** @var array An array to hold global user state within a session */


    404. 

  404. 	var $_userstate					= null;


    405. 

  405. 	/** @var array An array of page meta information */


    406. 

  406. 	var $_head						= null;


    407. 

  407. 	/** @var string Custom html string to append to the pathway */


    408. 

  408. 	var $_custom_pathway			= null;


    409. 

  409. 	/** @var boolean True if in the admin client */


    410. 

  410. 	var $_isAdmin 					= false;


    411. 

  411. 


    412. 

  412. 


    413. 

  413. 	/**


    414. 

  414. 	* Class constructor


    415. 

  415. 	* @param database A database connection object


    416. 

  416. 	* @param string The url option


    417. 

  417. 	* @param string The path of the mos directory


    418. 

  418. 	*/


    419. 

  419. 	function mosMainFrame( &$db, $option, $basePath, $isAdmin=false ) {


    420. 

  420. 		$this->_db =& $db;


    421. 

  421. 


    422. 

  422. 		// load the configuration values


    423. 

  423. 		$this->_setTemplate( $isAdmin );


    424. 

  424. 		$this->_setAdminPaths( $option, $this->getCfg( 'absolute_path' ) );


    425. 

  425. 		if (isset( $_SESSION['session_userstate'] )) {


    426. 

  426. 			$this->_userstate =& $_SESSION['session_userstate'];


    427. 

  427. 		} else {


    428. 

  428. 			$this->_userstate = null;


    429. 

  429. 		}


    430. 

  430. 		$this->_head = array();


    431. 

  431. 		$this->_head['title'] 	= $GLOBALS['mosConfig_sitename'];


    432. 

  432. 		$this->_head['meta'] 	= array();


    433. 

  433. 		$this->_head['custom'] 	= array();


    434. 

  434. 


    435. 

  435. 		//set the admin check


    436. 

  436. 		$this->_isAdmin 		= (boolean) $isAdmin;


    437. 

  437. 


    438. 

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


    439. 

  439. 		$this->set( 'now', $now );


    440. 

  440. 	}


    441. 

  441. 


    442. 

  442. 	/**


    443. 

  443. 	 * Gets the id number for a client


    444. 

  444. 	 * @param mixed A client identifier


    445. 

  445. 	 */


    446. 

  446. 	function getClientID( $client ) {


    447. 

  447. 		switch ($client) {


    448. 

  448. 			case '2':


    449. 

  449. 			case 'installation':


    450. 

  450. 				return 2;


    451. 

  451. 				break;


    452. 

  452. 


    453. 

  453. 			case '1':


    454. 

  454. 			case 'admin':


    455. 

  455. 			case 'administrator':


    456. 

  456. 				return 1;


    457. 

  457. 				break;


    458. 

  458. 


    459. 

  459. 			case '0':


    460. 

  460. 			case 'site':


    461. 

  461. 			case 'front':


    462. 

  462. 			default:


    463. 

  463. 				return 0;


    464. 

  464. 				break;


    465. 

  465. 		}


    466. 

  466. 	}


    467. 

  467. 


    468. 

  468. 	/**


    469. 

  469. 	 * Gets the client name


    470. 

  470. 	 * @param int The client identifier


    471. 

  471. 	 * @return strint The text name of the client


    472. 

  472. 	 */


    473. 

  473. 	function getClientName( $client_id ) {


    474. 

  474. 		 // do not translate


    475. 

  475. 		$clients = array( 'site', 'admin', 'installer' );


    476. 

  476. 		return mosGetParam( $clients, $client_id, 'unknown' );


    477. 

  477. 	}


    478. 

  478. 


    479. 

  479. 	/**


    480. 

  480. 	 * Gets the base path for the client


    481. 

  481. 	 * @param mixed A client identifier


    482. 

  482. 	 * @param boolean True (default) to add traling slash


    483. 

  483. 	 */


    484. 

  484. 	function getBasePath( $client=0, $addTrailingSlash=true ) {


    485. 

  485. 		global $mosConfig_absolute_path;


    486. 

  486. 


    487. 

  487. 		switch ($client) {


    488. 

  488. 			case '0':


    489. 

  489. 			case 'site':


    490. 

  490. 			case 'front':


    491. 

  491. 			default:


    492. 

  492. 				return mosPathName( $mosConfig_absolute_path, $addTrailingSlash );


    493. 

  493. 				break;


    494. 

  494. 


    495. 

  495. 			case '2':


    496. 

  496. 			case 'installation':


    497. 

  497. 				return mosPathName( $mosConfig_absolute_path . '/installation', $addTrailingSlash );


    498. 

  498. 				break;


    499. 

  499. 


    500. 

  500. 			case '1':


    501. 

  501. 			case 'admin':


    502. 

  502. 			case 'administrator':


    503. 

  503. 				return mosPathName( $mosConfig_absolute_path . '/administrator', $addTrailingSlash );


    504. 

  504. 				break;


    505. 

  505. 


    506. 

  506. 		}


    507. 

  507. 	}


    508. 

  508. 


    509. 

  509. 	/**


    510. 

  510. 	* @param string


    511. 

  511. 	*/


    512. 

  512. 	function setPageTitle( $title=null ) {


    513. 

  513. 		if (@$GLOBALS['mosConfig_pagetitles']) {


    514. 

  514. 			$title = trim( htmlspecialchars( $title ) );


    515. 

  515. 			$title = stripslashes($title);


    516. 

  516. 			$this->_head['title'] = $title ? $GLOBALS['mosConfig_sitename'] . ' - '. $title : $GLOBALS['mosConfig_sitename'];


    517. 

  517. 		}


    518. 

  518. 	}


    519. 

  519. 	/**


    520. 

  520. 	* @param string The value of the name attibute


    521. 

  521. 	* @param string The value of the content attibute


    522. 

  522. 	* @param string Text to display before the tag


    523. 

  523. 	* @param string Text to display after the tag


    524. 

  524. 	*/


    525. 

  525. 	function addMetaTag( $name, $content, $prepend='', $append='' ) {


    526. 

  526. 		$name = trim( htmlspecialchars( $name ) );


    527. 

  527. 		$content = trim( htmlspecialchars( $content ) );


    528. 

  528. 		$prepend = trim( $prepend );


    529. 

  529. 		$append = trim( $append );


    530. 

  530. 		$this->_head['meta'][] = array( $name, $content, $prepend, $append );


    531. 

  531. 	}


    532. 

  532. 	/**


    533. 

  533. 	* @param string The value of the name attibute


    534. 

  534. 	* @param string The value of the content attibute to append to the existing


    535. 

  535. 	* Tags ordered in with Site Keywords and Description first


    536. 

  536. 	*/


    537. 

  537. 	function appendMetaTag( $name, $content ) {


    538. 

  538. 		$name = trim( htmlspecialchars( $name ) );


    539. 

  539. 		$n = count( $this->_head['meta'] );


    540. 

  540. 		for ($i = 0; $i < $n; $i++) {


    541. 

  541. 			if ($this->_head['meta'][$i][0] == $name) {


    542. 

  542. 				$content = trim( htmlspecialchars( $content ) );


    543. 

  543. 				if ( $content ) {


    544. 

  544. 					if ( !$this->_head['meta'][$i][1] ) {


    545. 

  545. 						$this->_head['meta'][$i][1] = $content ;


    546. 

  546. 					} else {


    547. 

  547. 						$this->_head['meta'][$i][1] = $content .', '. $this->_head['meta'][$i][1];


    548. 

  548. 					}


    549. 

  549. 				}


    550. 

  550. 				return;


    551. 

  551. 			}


    552. 

  552. 		}


    553. 

  553. 		$this->addMetaTag( $name , $content );


    554. 

  554. 	}


    555. 

  555. 


    556. 

  556. 	/**


    557. 

  557. 	* @param string The value of the name attibute


    558. 

  558. 	* @param string The value of the content attibute to append to the existing


    559. 

  559. 	*/


    560. 

  560. 	function prependMetaTag( $name, $content ) {


    561. 

  561. 		$name = trim( htmlspecialchars( $name ) );


    562. 

  562. 		$n = count( $this->_head['meta'] );


    563. 

  563. 		for ($i = 0; $i < $n; $i++) {


    564. 

  564. 			if ($this->_head['meta'][$i][0] == $name) {


    565. 

  565. 				$content = trim( htmlspecialchars( $content ) );


    566. 

  566. 				$this->_head['meta'][$i][1] = $content . $this->_head['meta'][$i][1];


    567. 

  567. 				return;


    568. 

  568. 			}


    569. 

  569. 		}


    570. 

  570. 		$this->addMetaTag( $name, $content );


    571. 

  571. 	}


    572. 

  572. 	/**


    573. 

  573. 	 * Adds a custom html string to the head block


    574. 

  574. 	 * @param string The html to add to the head


    575. 

  575. 	 */


    576. 

  576. 	function addCustomHeadTag( $html ) {


    577. 

  577. 		$this->_head['custom'][] = trim( $html );


    578. 

  578. 	}


    579. 

  579. 	/**


    580. 

  580. 	* @return string


    581. 

  581. 	*/


    582. 

  582. 	function getHead() {


    583. 

  583. 		$head = array();


    584. 

  584. 		$head[] = '<title>' . $this->_head['title'] . '</title>';


    585. 

  585. 		foreach ($this->_head['meta'] as $meta) {


    586. 

  586. 			if ($meta[2]) {


    587. 

  587. 				$head[] = $meta[2];


    588. 

  588. 			}


    589. 

  589. 			$head[] = '<meta name="' . $meta[0] . '" content="' . $meta[1] . '" />';


    590. 

  590. 			if ($meta[3]) {


    591. 

  591. 				$head[] = $meta[3];


    592. 

  592. 			}


    593. 

  593. 		}


    594. 

  594. 		foreach ($this->_head['custom'] as $html) {


    595. 

  595. 			$head[] = $html;


    596. 

  596. 		}


    597. 

  597. 		return implode( "\n", $head ) . "\n";


    598. 

  598. 	}


    599. 

  599. 


    600. 

  600. 


    601. 

  601. 	/**


    602. 

  602. 	* @return string


    603. 

  603. 	*/


    604. 

  604. 	function getPageTitle() {


    605. 

  605. 		return $this->_head['title'];


    606. 

  606. 	}


    607. 

  607. 


    608. 

  608. 	/**


    609. 

  609. 	* @return string


    610. 

  610. 	*/


    611. 

  611. 	function getCustomPathWay() {


    612. 

  612. 		return $this->_custom_pathway;


    613. 

  613. 	}


    614. 

  614. 


    615. 

  615. 	function appendPathWay( $html ) {


    616. 

  616. 		$this->_custom_pathway[] = $html;


    617. 

  617. 	}


    618. 

  618. 


    619. 

  619.   /**


    620. 

  620. 	* Gets the value of a user state variable


    621. 

  621. 	* @param string The name of the variable


    622. 

  622. 	*/


    623. 

  623. 	function getUserState( $var_name ) {


    624. 

  624. 		if (is_array( $this->_userstate )) {


    625. 

  625. 			return mosGetParam( $this->_userstate, $var_name, null );


    626. 

  626. 		} else {


    627. 

  627. 			return null;


    628. 

  628. 		}


    629. 

  629. 	}


    630. 

  630. 	/**


    631. 

  631. 	* Gets the value of a user state variable


    632. 

  632. 	* @param string The name of the user state variable


    633. 

  633. 	* @param string The name of the variable passed in a request


    634. 

  634. 	* @param string The default value for the variable if not found


    635. 

  635. 	*/


    636. 

  636. 	function getUserStateFromRequest( $var_name, $req_name, $var_default=null ) {


    637. 

  637. 		if (is_array( $this->_userstate )) {


    638. 

  638. 			if (isset( $_REQUEST[$req_name] )) {


    639. 

  639. 				$this->setUserState( $var_name, $_REQUEST[$req_name] );


    640. 

  640. 			} else if (!isset( $this->_userstate[$var_name] )) {


    641. 

  641. 				$this->setUserState( $var_name, $var_default );


    642. 

  642. 			}


    643. 

  643. 


    644. 

  644. 			// filter input


    645. 

  645. 			$iFilter = new InputFilter();


    646. 

  646. 			$this->_userstate[$var_name] = $iFilter->process( $this->_userstate[$var_name] );


    647. 

  647. 


    648. 

  648. 			return $this->_userstate[$var_name];


    649. 

  649. 		} else {


    650. 

  650. 			return null;


    651. 

  651. 		}


    652. 

  652. 	}


    653. 

  653. 	/**


    654. 

  654. 	* Sets the value of a user state variable


    655. 

  655. 	* @param string The name of the variable


    656. 

  656. 	* @param string The value of the variable


    657. 

  657. 	*/


    658. 

  658. 	function setUserState( $var_name, $var_value ) {


    659. 

  659. 		if (is_array( $this->_userstate )) {


    660. 

  660. 			$this->_userstate[$var_name] = $var_value;


    661. 

  661. 		}


    662. 

  662. 	}


    663. 

  663. 	/**


    664. 

  664. 	* Initialises the user session


    665. 

  665. 	*


    666. 

  666. 	* Old sessions are flushed based on the configuration value for the cookie


    667. 

  667. 	* lifetime. If an existing session, then the last access time is updated.


    668. 

  668. 	* If a new session, a session id is generated and a record is created in


    669. 

  669. 	* the jos_sessions table.


    670. 

  670. 	*/


    671. 

  671. 	function initSession() {


    672. 

  672. 		// initailize session variables


    673. 

  673. 		$session 	=& $this->_session;


    674. 

  674. 		$session 	= new mosSession( $this->_db );


    675. 

  675. 


    676. 

  676. 		// purge expired sessions


    677. 

  677. 		$session->purge('core');


    678. 

  678. 


    679. 

  679. 		// Session Cookie `name`


    680. 

  680. 		$sessionCookieName 	= mosMainFrame::sessionCookieName();


    681. 

  681. 		// Get Session Cookie `value`


    682. 

  682. 		$sessioncookie 		= strval( mosGetParam( $_COOKIE, $sessionCookieName, null ) );


    683. 

  683. 


    684. 

  684. 		// Session ID / `value`


    685. 

  685. 		$sessionValueCheck 	= mosMainFrame::sessionCookieValue( $sessioncookie );


    686. 

  686. 


    687. 

  687. 		// Check if existing session exists in db corresponding to Session cookie `value`


    688. 

  688. 		// extra check added in 1.0.8 to test sessioncookie value is of correct length


    689. 

  689. 		if ( $sessioncookie && strlen($sessioncookie) == 32 && $sessioncookie != '-' && $session->load($sessionValueCheck) ) {


    690. 

  690. 			// update time in session table


    691. 

  691. 			$session->time = time();


    692. 

  692. 			$session->update();


    693. 

  693. 		} else {


    694. 

  694. 			// Remember Me Cookie `name`


    695. 

  695. 			$remCookieName = mosMainFrame::remCookieName_User();


    696. 

  696. 


    697. 

  697. 			// test if cookie found


    698. 

  698. 			$cookie_found = false;


    699. 

  699. 			if ( isset($_COOKIE[$sessionCookieName]) || isset($_COOKIE[$remCookieName]) || isset($_POST['force_session']) ) {


    700. 

  700. 				$cookie_found = true;


    701. 

  701. 			}


    702. 

  702. 


    703. 

  703. 			/* Hack for integration with JACLPlus Component */


    704. 

  704. 			if(class_exists('JACLPlus')) $session->jaclplus	= JACLPlus::DefaultAL();


    705. 

  705. 			/* End of hack for JACLPlus Component */


    706. 

  706. 			// check if neither remembermecookie or sessioncookie found


    707. 

  707. 			if (!$cookie_found) {


    708. 

  708. 				// create sessioncookie and set it to a test value set to expire on session end


    709. 

  709. 				setcookie( $sessionCookieName, '-', false, '/' );


    710. 

  710. 			} else {


    711. 

  711. 			// otherwise, sessioncookie was found, but set to test val or the session expired, prepare for session registration and register the session


    712. 

  712. 				$url = strval( mosGetParam( $_SERVER, 'REQUEST_URI', null ) );


    713. 

  713. 				// stop sessions being created for requests to syndicated feeds


    714. 

  714. 				if ( strpos( $url, 'option=com_rss' ) === false && strpos( $url, 'feed=' ) === false ) {


    715. 

  715. 					$session->guest 	= 1;


    716. 

  716. 					$session->username 	= '';


    717. 

  717. 					$session->time 		= time();


    718. 

  718. 					$session->gid 		= 0;


    719. 

  719. 					// Generate Session Cookie `value`


    720. 

  720. 					$session->generateId();


    721. 

  721. 


    722. 

  722. 					if (!$session->insert()) {


    723. 

  723. 						die( $session->getError() );


    724. 

  724. 					}


    725. 

  725. 


    726. 

  726. 					// create Session Tracking Cookie set to expire on session end


    727. 

  727. 					setcookie( $sessionCookieName, $session->getCookie(), false, '/' );


    728. 

  728. 				}


    729. 

  729. 			}


    730. 

  730. 


    731. 

  731. 			// Cookie used by Remember me functionality


    732. 

  732. 			$remCookieValue	= strval( mosGetParam( $_COOKIE, $remCookieName, null ) );


    733. 

  733. 


    734. 

  734. 			// test if cookie is correct length


    735. 

  735. 			if ( strlen($remCookieValue) > 64 ) {


    736. 

  736. 				// Separate Values from Remember Me Cookie


    737. 

  737. 				$remUser	= substr( $remCookieValue, 0, 32 );


    738. 

  738. 				$remPass	= substr( $remCookieValue, 32, 32 );


    739. 

  739. 				$remID		= intval( substr( $remCookieValue, 64  ) );


    740. 

  740. 


    741. 

  741. 				// check if Remember me cookie exists. Login with usercookie info.


    742. 

  742. 				if ( strlen($remUser) == 32 && strlen($remPass) == 32 ) {


    743. 

  743. 					$this->login( $remUser, $remPass, 1, $remID );


    744. 

  744. 				}


    745. 

  745. 			}


    746. 

  746. 		}


    747. 

  747. 	}


    748. 

  748. 


    749. 

  749. 	/*


    750. 

  750. 	* Function used to conduct admin session duties


    751. 

  751. 	* Added as of 1.0.8


    752. 

  752. 	* Deprecated 1.1


    753. 

  753. 	*/


    754. 

  754. 	function initSessionAdmin($option, $task) {


    755. 

  755. 		global $_VERSION, $mosConfig_admin_expired;


    756. 

  756. 


    757. 

  757. 		// logout check


    758. 

  758. 		if ($option == 'logout') {


    759. 

  759. 			require $GLOBALS['mosConfig_absolute_path'] .'/administrator/logout.php';


    760. 

  760. 			exit();


    761. 

  761. 		}


    762. 

  762. 


    763. 

  763. 		$site = $GLOBALS['mosConfig_live_site'];


    764. 

  764. 


    765. 

  765. 		// check if session name corresponds to correct format


    766. 

  766. 		if ( session_name() != md5( $site ) ) {


    767. 

  767. 			echo "<script>document.location.href='index.php'</script>\n";


    768. 

  768. 			exit();


    769. 

  769. 		}


    770. 

  770. 


    771. 

  771. 		// restore some session variables


    772. 

  772. 		$my 			= new mosUser( $this->_db );


    773. 

  773. 		$my->id 		= intval( mosGetParam( $_SESSION, 'session_user_id', '' ) );


    774. 

  774. 		$my->username 	= strval( mosGetParam( $_SESSION, 'session_username', '' ) );


    775. 

  775. 		$my->usertype 	= strval( mosGetParam( $_SESSION, 'session_usertype', '' ) );


    776. 

  776. 		$my->gid 		= intval( mosGetParam( $_SESSION, 'session_gid', '' ) );


    777. 

  777. 		$my->params		= mosGetParam( $_SESSION, 'session_user_params', '' );


    778. 

  778. 		/* Hack for integration with JACLPlus Component */


    779. 

  779. 		if(class_exists('JACLPlus')) $my->jaclplus	= mosGetParam( $_SESSION, 'session_jaclplus', '' );


    780. 

  780. 		/* End of hack for JACLPlus Component */


    781. 

  781. 


    782. 

  782. 		$session_id		= mosGetParam( $_SESSION, 'session_id', '' );


    783. 

  783. 		$logintime 		= mosGetParam( $_SESSION, 'session_logintime', '' );


    784. 

  784. 


    785. 

  785. 		if ($session_id != session_id()) {


    786. 

  786. 			// session id does not correspond to required session format


    787. 

  787. 			echo "<script>document.location.href='index.php?mosmsg=Invalid Session'</script>\n";


    788. 

  788. 			exit();


    789. 

  789. 		}


    790. 

  790. 


    791. 

  791. 		// check to see if session id corresponds with correct format


    792. 

  792. 		if ($session_id == md5( $my->id . $my->username . $my->usertype . $logintime )) {


    793. 

  793. 			// if task action is to `save` or `apply` complete action before doing session checks.


    794. 

  794. 			if ($task != 'save' && $task != 'apply') {


    795. 

  795. 				// test for session_life_admin


    796. 

  796. 				if ( @$GLOBALS['mosConfig_session_life_admin'] ) {


    797. 

  797. 					$session_life_admin = $GLOBALS['mosConfig_session_life_admin'];


    798. 

  798. 				} else {


    799. 

  799. 					$session_life_admin = 1800;


    800. 

  800. 				}


    801. 

  801. 


    802. 

  802. 				// purge expired admin sessions only


    803. 

  803. 				$past = time() - $session_life_admin;


    804. 

  804. 				$query = "DELETE FROM #__session"


    805. 

  805. 				. "\n WHERE time < '" . (int) $past . "'"


    806. 

  806. 				. "\n AND guest = 1"


    807. 

  807. 				//. "\n AND gid = 0"


    808. 

  808. 				. "\n AND userid <> 0"


    809. 

  809. 				;


    810. 

  810. 				$this->_db->setQuery( $query );


    811. 

  811. 				$this->_db->query();


    812. 

  812. 


    813. 

  813. 				$current_time	= time();


    814. 

  814. 


    815. 

  815. 				// update session timestamp


    816. 

  816. 				$query = "UPDATE #__session"


    817. 

  817. 				. "\n SET time = " . $this->_db->Quote( $current_time )


    818. 

  818. 				. "\n WHERE session_id = " . $this->_db->Quote( $session_id )


    819. 

  819. 				;


    820. 

  820. 				$this->_db->setQuery( $query );


    821. 

  821. 				$this->_db->query();


    822. 

  822. 


    823. 

  823. 				// set garbage cleaning timeout


    824. 

  824. 				$this->setSessionGarbageClean();


    825. 

  825. 


    826. 

  826. 				// check against db record of session


    827. 

  827. 				$query = "SELECT COUNT( session_id )"


    828. 

  828. 				. "\n FROM #__session"


    829. 

  829. 				. "\n WHERE session_id = " . $this->_db->Quote( $session_id )


    830. 

  830. 				. "\n AND username = ". $this->_db->Quote( $my->username )


    831. 

  831. 				. "\n AND userid = ". intval( $my->id )


    832. 

  832. 				;


    833. 

  833. 				$this->_db->setQuery( $query );


    834. 

  834. 				$count = $this->_db->loadResult();


    835. 

  835. 


    836. 

  836. 				// if no entry in session table that corresponds boot from admin area


    837. 

  837. 				if ( $count == 0 ) {


    838. 

  838. 					$link 	= NULL;


    839. 

  839. 


    840. 

  840. 					if ($_SERVER['QUERY_STRING']) {


    841. 

  841. 						$link = 'index2.php?'. $_SERVER['QUERY_STRING'];


    842. 

  842. 					}


    843. 

  843. 


    844. 

  844. 					// check if site designated as a production site


    845. 

  845. 					// for a demo site disallow expired page functionality


    846. 

  846. 					// link must also be a Joomla link to stop malicious redirection


    847. 

  847. 					if ( $link && strpos( $link, 'index2.php?option=com_' ) === 0 && $_VERSION->SITE == 1 && @$mosConfig_admin_expired === '1' ) {


    848. 

  848. 						$now 	= time();


    849. 

  849. 


    850. 

  850. 						$file 	= $this->getPath( 'com_xml', 'com_users' );


    851. 

  851. 						$params =& new mosParameters( $my->params, $file, 'component' );


    852. 

  852. 


    853. 

  853. 						// return to expired page functionality


    854. 

  854. 						$params->set( 'expired', 		$link );


    855. 

  855. 						$params->set( 'expired_time', 	$now );


    856. 

  856. 


    857. 

  857. 						// param handling


    858. 

  858. 						if (is_array( $params->toArray() )) {


    859. 

  859. 							$txt = array();


    860. 

  860. 							foreach ( $params->toArray() as $k=>$v) {


    861. 

  861. 								$txt[] = "$k=$v";


    862. 

  862. 							}


    863. 

  863. 							$saveparams = implode( "\n", $txt );


    864. 

  864. 						}


    865. 

  865. 


    866. 

  866. 						// save expired page info to user data


    867. 

  867. 						$query = "UPDATE #__users"


    868. 

  868. 						. "\n SET params = ". $this->_db->Quote( $saveparams )


    869. 

  869. 						. "\n WHERE id = " . (int) $my->id


    870. 

  870. 						. "\n AND username = ". $this->_db->Quote( $my->username )


    871. 

  871. 						. "\n AND usertype = ". $this->_db->Quote( $my->usertype )


    872. 

  872. 						;


    873. 

  873. 						$this->_db->setQuery( $query );


    874. 

  874. 						$this->_db->query();


    875. 

  875. 					}


    876. 

  876. 


    877. 

  877. 					echo "<script>document.location.href='index.php?mosmsg=Admin Session Expired'</script>\n";


    878. 

  878. 					exit();


    879. 

  879. 				} else {


    880. 

  880. 					// load variables into session, used to help secure /popups/ functionality


    881. 

  881. 					$_SESSION['option'] = $option;


    882. 

  882. 					$_SESSION['task'] 	= $task;


    883. 

  883. 				}


    884. 

  884. 			}


    885. 

  885. 		} else if ($session_id == '') {


    886. 

  886. 			// no session_id as user has not attempted to login, or session.auto_start is switched on


    887. 

  887. 			if (ini_get( 'session.auto_start' ) || !ini_get( 'session.use_cookies' )) {


    888. 

  888. 				echo "<script>document.location.href='index.php?mosmsg=You need to login. If PHP\'s session.auto_start setting is on or session.use_cookies setting is off, you may need to correct this before you will be able to login.'</script>\n";


    889. 

  889. 			} else {


    890. 

  890. 				echo "<script>document.location.href='index.php?mosmsg=You need to login'</script>\n";


    891. 

  891. 			}


    892. 

  892. 			exit();


    893. 

  893. 		} else {


    894. 

  894. 			// session id does not correspond to required session format


    895. 

  895. 			echo "<script>document.location.href='index.php?mosmsg=Invalid Session'</script>\n";


    896. 

  896. 			exit();


    897. 

  897. 		}


    898. 

  898. 


    899. 

  899. 		/* Hack for integration with JACLPlus Component */


    900. 

  900. 		if(class_exists('JACLPlus')) JACLPlus::AccessChecking($my, 'backend');


    901. 

  901. 		/* End of hack for JACLPlus Component */


    902. 

  902. 		return $my;


    903. 

  903. 	}


    904. 

  904. 


    905. 

  905. 	/*


    906. 

  906. 	* Function used to set Session Garbage Cleaning


    907. 

  907. 	* garbage cleaning set at configured session time + 600 seconds


    908. 

  908. 	* Added as of 1.0.8


    909. 

  909. 	* Deprecated 1.1


    910. 

  910. 	*/


    911. 

  911. 	function setSessionGarbageClean() {


    912. 

  912. 		/** ensure that funciton is only called once */


    913. 

  913. 		if (!defined( '_JOS_GARBAGECLEAN' )) {


    914. 

  914. 			define( '_JOS_GARBAGECLEAN', 1 );


    915. 

  915. 


    916. 

  916. 			$garbage_timeout = $this->getCfg('session_life_admin') + 600;


    917. 

  917. 			@ini_set('session.gc_maxlifetime', $garbage_timeout);


    918. 

  918. 		}


    919. 

  919. 	}


    920. 

  920. 


    921. 

  921. 	/*


    922. 

  922. 	* Static Function used to generate the Session Cookie Name


    923. 

  923. 	* Added as of 1.0.8


    924. 

  924. 	* Deprecated 1.1


    925. 

  925. 	*/


    926. 

  926. 	function sessionCookieName() {


    927. 

  927. 		global $mainframe, $mosConfig_live_site;


    928. 

  928. 


    929. 

  929. 		if( substr( $mosConfig_live_site, 0, 7 ) == 'http://' ) {


    930. 

  930. 			$hash = md5( 'site' . substr( $mosConfig_live_site, 7 ) );


    931. 

  931. 		} elseif( substr( $mosConfig_live_site, 0, 8 ) == 'https://' ) {


    932. 

  932. 			$hash = md5( 'site' . substr( $mosConfig_live_site, 8 ) );


    933. 

  933. 		} else {


    934. 

  934. 			$hash = md5( 'site' . $mainframe->getCfg( 'live_site' ) );


    935. 

  935. 		}


    936. 

  936. 


    937. 

  937. 		return $hash;


    938. 

  938. 	}


    939. 

  939. 


    940. 

  940. 	/*


    941. 

  941. 	* Static Function used to generate the Session Cookie Value


    942. 

  942. 	* Added as of 1.0.8


    943. 

  943. 	* Deprecated 1.1


    944. 

  944. 	*/


    945. 

  945. 	function sessionCookieValue( $id=null ) {


    946. 

  946. 		global $mainframe;


    947. 

  947. 


    948. 

  948. 		$type 		= $mainframe->getCfg( 'session_type' );


    949. 

  949. 


    950. 

  950. 		$browser 	= @$_SERVER['HTTP_USER_AGENT'];


    951. 

  951. 


    952. 

  952. 		switch ($type) {


    953. 

  953. 			case 2:


    954. 

  954. 			// 1.0.0 to 1.0.7 Compatibility


    955. 

  955. 			// lowest level security


    956. 

  956. 				$value 			= md5( $id . $_SERVER['REMOTE_ADDR'] );


    957. 

  957. 				break;


    958. 

  958. 


    959. 

  959. 			case 1:


    960. 

  960. 			// slightly reduced security - 3rd level IP authentication for those behind IP Proxy


    961. 

  961. 				$remote_addr 	= explode('.',$_SERVER['REMOTE_ADDR']);


    962. 

  962. 				$ip				= $remote_addr[0] .'.'. $remote_addr[1] .'.'. $remote_addr[2];


    963. 

  963. 				$value 			= mosHash( $id . $ip . $browser );


    964. 

  964. 				break;


    965. 

  965. 


    966. 

  966. 			default:


    967. 

  967. 			// Highest security level - new default for 1.0.8 and beyond


    968. 

  968. 				$ip				= $_SERVER['REMOTE_ADDR'];


    969. 

  969. 				$value 			= mosHash( $id . $ip . $browser );


    970. 

  970. 				break;


    971. 

  971. 		}


    972. 

  972. 


    973. 

  973. 		return $value;


    974. 

  974. 	}


    975. 

  975. 


    976. 

  976. 	/*


    977. 

  977. 	* Static Function used to generate the Rememeber Me Cookie Name for Username information


    978. 

  978. 	* Added as of 1.0.8


    979. 

  979. 	* Depreciated 1.1


    980. 

  980. 	*/


    981. 

  981. 	function remCookieName_User() {


    982. 

  982. 		$value = mosHash( 'remembermecookieusername'. mosMainFrame::sessionCookieName() );


    983. 

  983. 


    984. 

  984. 		return $value;


    985. 

  985. 	}


    986. 

  986. 


    987. 

  987. 	/*


    988. 

  988. 	* Static Function used to generate the Rememeber Me Cookie Name for Password information


    989. 

  989. 	* Added as of 1.0.8


    990. 

  990. 	* Depreciated 1.1


    991. 

  991. 	*/


    992. 

  992. 	function remCookieName_Pass() {


    993. 

  993. 		$value = mosHash( 'remembermecookiepassword'. mosMainFrame::sessionCookieName() );


    994. 

  994. 


    995. 

  995. 		return $value;


    996. 

  996. 	}


    997. 

  997. 


    998. 

  998. 	/*


    999. 

  999. 	* Static Function used to generate the Remember Me Cookie Value for Username information


    1000. 

  1000. 	* Added as of 1.0.8


    1001. 

  1001. 	* Depreciated 1.1


    1002. 

  1002. 	*/


    1003. 

  1003. 	function remCookieValue_User( $username ) {


    1004. 

  1004. 		$value = md5( $username . mosHash( @$_SERVER['HTTP_USER_AGENT'] ) );


    1005. 

  1005. 


    1006. 

  1006. 		return $value;


    1007. 

  1007. 	}


    1008. 

  1008. 


    1009. 

  1009. 	/*


    1010. 

  1010. 	* Static Function used to generate the Remember Me Cookie Value for Password information


    1011. 

  1011. 	* Added as of 1.0.8


    1012. 

  1012. 	* Depreciated 1.1


    1013. 

  1013. 	*/


    1014. 

  1014. 	function remCookieValue_Pass( $passwd ) {


    1015. 

  1015. 		$value 	= md5( $passwd . mosHash( @$_SERVER['HTTP_USER_AGENT'] ) );


    1016. 

  1016. 


    1017. 

  1017. 		return $value;


    1018. 

  1018. 	}


    1019. 

  1019. 


    1020. 

  1020. 	/**


    1021. 

  1021. 	* Login validation function


    1022. 

  1022. 	*


    1023. 

  1023. 	* Username and encoded password is compare to db entries in the jos_users


    1024. 

  1024. 	* table. A successful validation updates the current session record with


    1025. 

  1025. 	* the users details.


    1026. 

  1026. 	*/


    1027. 

  1027. 	function login( $username=null, $passwd=null, $remember=0, $userid=NULL ) {


    1028. 

  1028. 		global $acl, $_VERSION;


    1029. 

  1029. 


    1030. 

  1030. 		$bypost = 0;


    1031. 

  1031. 		$valid_remember = false;


    1032. 

  1032. 


    1033. 

  1033. 		// if no username and password passed from function, then function is being called from login module/component


    1034. 

  1034. 		if (!$username || !$passwd) {


    1035. 

  1035. 			$username 	= stripslashes( strval( mosGetParam( $_POST, 'username', '' ) ) );


    1036. 

  1036. 			$passwd 	= stripslashes( strval( mosGetParam( $_POST, 'passwd', '' ) ) );


    1037. 

  1037. 


    1038. 

  1038. 			$bypost 	= 1;


    1039. 

  1039. 


    1040. 

  1040. 			// extra check to ensure that Joomla! sessioncookie exists


    1041. 

  1041. 			if (!$this->_session->session_id) {


    1042. 

  1042. 				mosErrorAlert( _ALERT_ENABLED );


    1043. 

  1043. 				return;


    1044. 

  1044. 			}


    1045. 

  1045. 


    1046. 

  1046. 			josSpoofCheck(NULL,1);


    1047. 

  1047. 		}


    1048. 

  1048. 


    1049. 

  1049. 		$row = null;


    1050. 

  1050. 		if (!$username || !$passwd) {


    1051. 

  1051. 			mosErrorAlert( _LOGIN_INCOMPLETE );


    1052. 

  1052. 			exit();


    1053. 

  1053. 		} else {


    1054. 

  1054. 			if ( $remember && strlen($username) == 32 && $userid ) {


    1055. 

  1055. 			// query used for remember me cookie


    1056. 

  1056. 				$harden = mosHash( @$_SERVER['HTTP_USER_AGENT'] );


    1057. 

  1057. 


    1058. 

  1058. 				$query = "SELECT id, name, username, password, usertype, block, gid"


    1059. 

  1059. 				. "\n FROM #__users"


    1060. 

  1060. 				. "\n WHERE id = " . (int) $userid


    1061. 

  1061. 				;


    1062. 

  1062. 				$this->_db->setQuery( $query );


    1063. 

  1063. 				$this->_db->loadObject($user);


    1064. 

  1064. 


    1065. 

  1065. 				list($hash, $salt) = explode(':', $user->password);


    1066. 

  1066. 


    1067. 

  1067. 				$check_username = md5( $user->username . $harden );


    1068. 

  1068. 				$check_password = md5( $hash . $harden );


    1069. 

  1069. 


    1070. 

  1070. 				if ( $check_username == $username && $check_password == $passwd ) {


    1071. 

  1071. 					$row = $user;


    1072. 

  1072. 					$valid_remember = true;


    1073. 

  1073. 				}


    1074. 

  1074. 			} else {


    1075. 

  1075. 			// query used for login via login module


    1076. 

  1076. 				$query = "SELECT id, name, username, password, usertype, block, gid"


    1077. 

  1077. 				. "\n FROM #__users"


    1078. 

  1078. 				. "\n WHERE username = ". $this->_db->Quote( $username )


    1079. 

  1079. 				;


    1080. 

  1080. 


    1081. 

  1081. 				$this->_db->setQuery( $query );


    1082. 

  1082. 				$this->_db->loadObject( $row );


    1083. 

  1083. 			}


    1084. 

  1084. 


    1085. 

  1085. 			if (is_object($row)) {


    1086. 

  1086. 				// user blocked from login


    1087. 

  1087. 				if ($row->block == 1) {


    1088. 

  1088. 					mosErrorAlert(_LOGIN_BLOCKED);


    1089. 

  1089. 				}


    1090. 

  1090. 


    1091. 

  1091. 				if (!$valid_remember) {


    1092. 

  1092. 					// Conversion to new type


    1093. 

  1093. 					if ((strpos($row->password, ':') === false) && $row->password == md5($passwd)) {


    1094. 

  1094. 						// Old password hash storage but authentic ... lets convert it


    1095. 

  1095. 						$salt = mosMakePassword(16);


    1096. 

  1096. 						$crypt = md5($passwd.$salt);


    1097. 

  1097. 						$row->password = $crypt.':'.$salt;


    1098. 

  1098. 


    1099. 

  1099. 						// Now lets store it in the database


    1100. 

  1100. 						$query	= 'UPDATE #__users'


    1101. 

  1101. 								. ' SET password = '.$this->_db->Quote($row->password)


    1102. 

  1102. 								. ' WHERE id = '.(int)$row->id;


    1103. 

  1103. 						$this->_db->setQuery($query);


    1104. 

  1104. 						if (!$this->_db->query()) {


    1105. 

  1105. 							// This is an error but not sure what to do with it ... we'll still work for now


    1106. 

  1106. 						}


    1107. 

  1107. 					}


    1108. 

  1108. 


    1109. 

  1109. 					list($hash, $salt) = explode(':', $row->password);


    1110. 

  1110. 					$cryptpass = md5($passwd.$salt);


    1111. 

  1111. 					if ($hash != $cryptpass) {


    1112. 

  1112. 						if ( $bypost ) {


    1113. 

  1113. 							mosErrorAlert(_LOGIN_INCORRECT);


    1114. 

  1114. 						} else {


    1115. 

  1115. 							$this->logout();


    1116. 

  1116. 							mosRedirect('index.php');


    1117. 

  1117. 						}


    1118. 

  1118. 						exit();


    1119. 

  1119. 					}


    1120. 

  1120. 				}


    1121. 

  1121. 


    1122. 

  1122. 				/* Hack for integration with JACLPlus Component */


    1123. 

  1123. 				// fudge the group stuff


    1124. 

  1124. 				$grp = $acl->getAroGroup( $row->id );


    1125. 

  1125. 				$row->gid = $grp->group_id;


    1126. 

  1126. 				if(!class_exists('JACLPlus')) {


    1127. 

  1127. 				$row->gid = 1;


    1128. 

  1128. 				if ($acl->is_group_child_of( $grp->name, 'Registered', 'ARO' ) || $acl->is_group_child_of( $grp->name, 'Public Backend', 'ARO' )) {


    1129. 

  1129. 					// fudge Authors, Editors, Publishers and Super Administrators into the Special Group


    1130. 

  1130. 					$row->gid = 2;


    1131. 

  1131. 				}


    1132. 

  1132. 				}


    1133. 

  1133. 				$row->usertype = $grp->name;


    1134. 

  1134. 


    1135. 

  1135. 				// initialize session data


    1136. 

  1136. 				$session 			=& $this->_session;


    1137. 

  1137. 				$session->guest 	= 0;


    1138. 

  1138. 				$session->username 	= $row->username;


    1139. 

  1139. 				$session->userid 	= intval( $row->id );


    1140. 

  1140. 				$session->usertype 	= $row->usertype;


    1141. 

  1141. 				$session->gid 		= intval( $row->gid );


    1142. 

  1142. 				if(class_exists('JACLPlus')) $session->jaclplus		= $grp->jaclplus;


    1143. 

  1143. 				/* End of hack for JACLPlus Component */


    1144. 

  1144. 


    1145. 

  1145. 				$session->update();


    1146. 

  1146. 


    1147. 

  1147. 				// check to see if site is a production site


    1148. 

  1148. 				// allows multiple logins with same user for a demo site


    1149. 

  1149. 				if ( $_VERSION->SITE ) {


    1150. 

  1150. 					// delete any old front sessions to stop duplicate sessions


    1151. 

  1151. 					$query = "DELETE FROM #__session"


    1152. 

  1152. 					. "\n WHERE session_id != ". $this->_db->Quote( $session->session_id )


    1153. 

  1153. 					. "\n AND username = ". $this->_db->Quote( $row->username )


    1154. 

  1154. 					. "\n AND userid = " . (int) $row->id


    1155. 

  1155. 					. "\n AND gid = " . (int) $row->gid


    1156. 

  1156. 					. "\n AND guest = 0"


    1157. 

  1157. 					;


    1158. 

  1158. 					$this->_db->setQuery( $query );


    1159. 

  1159. 					$this->_db->query();


    1160. 

  1160. 				}


    1161. 

  1161. 


    1162. 

  1162. 				// update user visit data


    1163. 

  1163. 				$currentDate = date("Y-m-d\TH:i:s");


    1164. 

  1164. 


    1165. 

  1165. 				$query = "UPDATE #__users"


    1166. 

  1166. 				. "\n SET lastvisitDate = ". $this->_db->Quote( $currentDate )


    1167. 

  1167. 				. "\n WHERE id = " . (int) $session->userid


    1168. 

  1168. 				;


    1169. 

  1169. 				$this->_db->setQuery($query);


    1170. 

  1170. 				if (!$this->_db->query()) {


    1171. 

  1171. 					die($this->_db->stderr(true));


    1172. 

  1172. 				}


    1173. 

  1173. 


    1174. 

  1174. 				// set remember me cookie if selected


    1175. 

  1175. 				$remember = strval( mosGetParam( $_POST, 'remember', '' ) );


    1176. 

  1176. 				if ( $remember == 'yes' ) {


    1177. 

  1177. 					// cookie lifetime of 365 days


    1178. 

  1178. 					$lifetime 		= time() + 365*24*60*60;


    1179. 

  1179. 					$remCookieName 	= mosMainFrame::remCookieName_User();


    1180. 

  1180. 					$remCookieValue = mosMainFrame::remCookieValue_User( $row->username ) . mosMainFrame::remCookieValue_Pass( $hash ) . $row->id;


    1181. 

  1181. 					setcookie( $remCookieName, $remCookieValue, $lifetime, '/' );


    1182. 

  1182. 				}


    1183. 

  1183. 				mosCache::cleanCache();


    1184. 

  1184. 			} else {


    1185. 

  1185. 				if ( $bypost ) {


    1186. 

  1186. 					mosErrorAlert(_LOGIN_INCORRECT);


    1187. 

  1187. 				} else {


    1188. 

  1188. 					$this->logout();


    1189. 

  1189. 					mosRedirect('index.php');


    1190. 

  1190. 				}


    1191. 

  1191. 				exit();


    1192. 

  1192. 			}


    1193. 

  1193. 		}


    1194. 

  1194. 	}


    1195. 

  1195. 


    1196. 

  1196. 	/**


    1197. 

  1197. 	* User logout


    1198. 

  1198. 	*


    1199. 

  1199. 	* Reverts the current session record back to 'anonymous' parameters


    1200. 

  1200. 	*/


    1201. 

  1201. 	function logout() {


    1202. 

  1202. 		mosCache::cleanCache();


    1203. 

  1203. 


    1204. 

  1204. 		$session 			=& $this->_session;


    1205. 

  1205. 		$session->guest 	= 1;


    1206. 

  1206. 		$session->username 	= '';


    1207. 

  1207. 		$session->userid 	= 0;//$session->userid 	= '';


    1208. 

  1208. 		$session->usertype 	= '';


    1209. 

  1209. 		$session->gid 		= 0;


    1210. 

  1210. 		/* Hack for integration with JACLPlus Component */


    1211. 

  1211. 		if(class_exists('JACLPlus')) $session->jaclplus	= JACLPlus::DefaultAL();


    1212. 

  1212. 		/* End of hack for JACLPlus Component */


    1213. 

  1213. 


    1214. 

  1214. 		$session->update();


    1215. 

  1215. 


    1216. 

  1216. 		// kill remember me cookie


    1217. 

  1217. 		$lifetime 		= time() - 86400;


    1218. 

  1218. 		$remCookieName 	= mosMainFrame::remCookieName_User();


    1219. 

  1219. 		setcookie( $remCookieName, ' ', $lifetime, '/' );


    1220. 

  1220. 


    1221. 

  1221. 		@session_destroy();


    1222. 

  1222. 	}


    1223. 

  1223. 


    1224. 

  1224. 	/**


    1225. 

  1225. 	* @return mosUser A user object with the information from the current session


    1226. 

  1226. 	*/


    1227. 

  1227. 	function getUser() {


    1228. 

  1228. 		global $database;


    1229. 

  1229. 


    1230. 

  1230. 		$user = new mosUser( $this->_db );


    1231. 

  1231. 


    1232. 

  1232. 		$user->id 			= intval( $this->_session->userid );


    1233. 

  1233. 		$user->username 	= $this->_session->username;


    1234. 

  1234. 		$user->usertype 	= $this->_session->usertype;


    1235. 

  1235. 		$user->gid 			= intval( $this->_session->gid );


    1236. 

  1236. 		/* Hack for integration with JACLPlus Component */


    1237. 

  1237. 		if(class_exists('JACLPlus')) {


    1238. 

  1238. 			$jaclplus = explode( ',', $this->_session->jaclplus );


    1239. 

  1239. 			mosArrayToInts( $jaclplus );


    1240. 

  1240. 			$user->jaclplus		= implode( ',', $jaclplus );


    1241. 

  1241. 		}


    1242. 

  1242. 		/* End of hack for JACLPlus Component */


    1243. 

  1243. 


    1244. 

  1244. 		if ($user->id) {


    1245. 

  1245. 			$query = "SELECT id, name, email, block, sendEmail, registerDate, lastvisitDate, activation, params"


    1246. 

  1246. 			. "\n FROM #__users"


    1247. 

  1247. 			. "\n WHERE id = " . (int) $user->id


    1248. 

  1248. 			;


    1249. 

  1249. 			$database->setQuery( $query );


    1250. 

  1250. 			$database->loadObject( $my );


    1251. 

  1251. 


    1252. 

  1252. 			$user->params 			= $my->params;


    1253. 

  1253. 			$user->name				= $my->name;


    1254. 

  1254. 			$user->email			= $my->email;


    1255. 

  1255. 			$user->block			= $my->block;


    1256. 

  1256. 			$user->sendEmail		= $my->sendEmail;


    1257. 

  1257. 			$user->registerDate		= $my->registerDate;


    1258. 

  1258. 			$user->lastvisitDate	= $my->lastvisitDate;


    1259. 

  1259. 			$user->activation		= $my->activation;


    1260. 

  1260. 		}


    1261. 

  1261. 


    1262. 

  1262. 		/* Hack for integration with JACLPlus Component */


    1263. 

  1263. 		if(class_exists('JACLPlus')) JACLPlus::AccessChecking($user, 'frontend');


    1264. 

  1264. 		/* End of hack for JACLPlus Component */


    1265. 

  1265. 		return $user;


    1266. 

  1266. 	}


    1267. 

  1267. 	/**


    1268. 

  1268. 	 * @param string The name of the variable (from configuration.php)


    1269. 

  1269. 	 * @return mixed The value of the configuration variable or null if not found


    1270. 

  1270. 	 */


    1271. 

  1271. 	function getCfg( $varname ) {


    1272. 

  1272. 		$varname = 'mosConfig_' . $varname;


    1273. 

  1273. 		if (isset( $GLOBALS[$varname] )) {


    1274. 

  1274. 			return $GLOBALS[$varname];


    1275. 

  1275. 		} else {


    1276. 

  1276. 			return null;


    1277. 

  1277. 		}


    1278. 

  1278. 	}


    1279. 

  1279. 


    1280. 

  1280. 	function _setTemplate( $isAdmin=false ) {


    1281. 

  1281. 		global $Itemid;


    1282. 

  1282. 		$mosConfig_absolute_path = $this->getCfg( 'absolute_path' );


    1283. 

  1283. 


    1284. 

  1284. 		if ($isAdmin) {


    1285. 

  1285. 			$query = "SELECT template"


    1286. 

  1286. 			. "\n FROM #__templates_menu"


    1287. 

  1287. 			. "\n WHERE client_id = 1"


    1288. 

  1288. 			. "\n AND menuid = 0"


    1289. 

  1289. 			;


    1290. 

  1290. 			$this->_db->setQuery( $query );


    1291. 

  1291. 			$cur_template = $this->_db->loadResult();


    1292. 

  1292. 			$path = "$mosConfig_absolute_path/administrator/templates/$cur_template/index.php";


    1293. 

  1293. 			if (!file_exists( $path )) {


    1294. 

  1294. 				$cur_template = 'joomla_admin';


    1295. 

  1295. 			}


    1296. 

  1296. 		} else {


    1297. 

  1297. 			$assigned = ( !empty( $Itemid ) ? " OR menuid = " . (int) $Itemid : '' );


    1298. 

  1298. 


    1299. 

  1299. 			$query = "SELECT template"


    1300. 

  1300. 			. "\n FROM #__templates_menu"


    1301. 

  1301. 			. "\n WHERE client_id = 0"


    1302. 

  1302. 			. "\n AND ( menuid = 0 $assigned )"


    1303. 

  1303. 			. "\n ORDER BY menuid DESC"


    1304. 

  1304. 			;


    1305. 

  1305. 			$this->_db->setQuery( $query, 0, 1 );


    1306. 

  1306. 			$cur_template = $this->_db->loadResult();


    1307. 

  1307. 


    1308. 

  1308. 			// TemplateChooser Start


    1309. 

  1309. 			$jos_user_template 		= strval( mosGetParam( $_COOKIE, 'jos_user_template', '' ) );


    1310. 

  1310. 			$jos_change_template 	= strval( mosGetParam( $_REQUEST, 'jos_change_template', $jos_user_template ) );


    1311. 

  1311. 			if ($jos_change_template) {


    1312. 

  1312. 				// clean template name


    1313. 

  1313. 				$jos_change_template = preg_replace( '#\W#', '', $jos_change_template );


    1314. 

  1314. 				if ( strlen( $jos_change_template ) >= 40 ) {


    1315. 

  1315. 					$jos_change_template = substr($jos_change_template, 0 , 39);


    1316. 

  1316. 				}


    1317. 

  1317. 


    1318. 

  1318. 				// check that template exists in case it was deleted


    1319. 

  1319. 				if (file_exists( $mosConfig_absolute_path .'/templates/'. $jos_change_template .'/index.php' )) {


    1320. 

  1320. 					$lifetime 		= 60*10;


    1321. 

  1321. 					$cur_template 	= $jos_change_template;


    1322. 

  1322. 					setcookie( 'jos_user_template', "$jos_change_template", time()+$lifetime);


    1323. 

  1323. 				} else {


    1324. 

  1324. 					setcookie( 'jos_user_template', '', time()-3600 );


    1325. 

  1325. 				}


    1326. 

  1326. 			}


    1327. 

  1327. 			// TemplateChooser End


    1328. 

  1328. 		}


    1329. 

  1329. 


    1330. 

  1330. 		$this->_template = $cur_template;


    1331. 

  1331. 	}


    1332. 

  1332. 


    1333. 

  1333. 	function getTemplate() {


    1334. 

  1334. 		return $this->_template;


    1335. 

  1335. 	}


    1336. 

  1336. 


    1337. 

  1337. 	/**


    1338. 

  1338. 	* Determines the paths for including engine and menu files


    1339. 

  1339. 	* @param string The current option used in the url


    1340. 

  1340. 	* @param string The base path from which to load the configuration file


    1341. 

  1341. 	*/


    1342. 

  1342. 	function _setAdminPaths( $option, $basePath='.' ) {


    1343. 

  1343. 		$option 		= strtolower( $option );


    1344. 

  1344. 


    1345. 

  1345. 		$this->_path 	= new stdClass();


    1346. 

  1346. 


    1347. 

  1347. 		// security check to disable use of `/`, `\\` and `:` in $options variable


    1348. 

  1348. 		if (strpos($option, '/') !== false || strpos($option, '\\') !== false || strpos($option, ':') !== false) {


    1349. 

  1349. 			mosErrorAlert( 'Restricted access' );


    1350. 

  1350. 			return;


    1351. 

  1351. 		}


    1352. 

  1352. 


    1353. 

  1353. 		$prefix = substr( $option, 0, 4 );


    1354. 

  1354. 		if ($prefix != 'com_' && $prefix != 'mod_') {


    1355. 

  1355. 			// ensure backward compatibility with existing links


    1356. 

  1356. 			$name 	= $option;


    1357. 

  1357. 			$option = "com_$option";


    1358. 

  1358. 		} else {


    1359. 

  1359. 			$name 	= substr( $option, 4 );


    1360. 

  1360. 		}


    1361. 

  1361. 


    1362. 

  1362. 		// components


    1363. 

  1363. 		if (file_exists( "$basePath/templates/$this->_template/components/$name.html.php" )) {


    1364. 

  1364. 			$this->_path->front 		= "$basePath/components/$option/$name.php";


    1365. 

  1365. 			$this->_path->front_html 	= "$basePath/templates/$this->_template/components/$name.html.php";


    1366. 

  1366. 		} else if (file_exists( "$basePath/components/$option/$name.php" )) {


    1367. 

  1367. 			$this->_path->front 		= "$basePath/components/$option/$name.php";


    1368. 

  1368. 			$this->_path->front_html 	= "$basePath/components/$option/$name.html.php";


    1369. 

  1369. 		}


    1370. 

  1370. 


    1371. 

  1371. 		if (file_exists( "$basePath/administrator/components/$option/admin.$name.php" )) {


    1372. 

  1372. 			$this->_path->admin 		= "$basePath/administrator/components/$option/admin.$name.php";


    1373. 

  1373. 			$this->_path->admin_html 	= "$basePath/administrator/components/$option/admin.$name.html.php";


    1374. 

  1374. 		}


    1375. 

  1375. 


    1376. 

  1376. 		if (file_exists( "$basePath/administrator/components/$option/toolbar.$name.php" )) {


    1377. 

  1377. 			$this->_path->toolbar 			= "$basePath/administrator/components/$option/toolbar.$name.php";


    1378. 

  1378. 			$this->_path->toolbar_html 		= "$basePath/administrator/components/$option/toolbar.$name.html.php";


    1379. 

  1379. 			$this->_path->toolbar_default 	= "$basePath/administrator/includes/toolbar.html.php";


    1380. 

  1380. 		}


    1381. 

  1381. 


    1382. 

  1382. 		if (file_exists( "$basePath/components/$option/$name.class.php" )) {


    1383. 

  1383. 			$this->_path->class = "$basePath/components/$option/$name.class.php";


    1384. 

  1384. 		} else if (file_exists( "$basePath/administrator/components/$option/$name.class.php" )) {


    1385. 

  1385. 			$this->_path->class = "$basePath/administrator/components/$option/$name.class.php";


    1386. 

  1386. 		} else if (file_exists( "$basePath/includes/$name.php" )) {


    1387. 

  1387. 			$this->_path->class = "$basePath/includes/$name.php";


    1388. 

  1388. 		}


    1389. 

  1389. 


    1390. 

  1390. 		if ($prefix == 'mod_' && file_exists("$basePath/administrator/modules/$option.php")) {


    1391. 

  1391. 			$this->_path->admin 		= "$basePath/administrator/modules/$option.php";


    1392. 

  1392. 			$this->_path->admin_html 	= "$basePath/administrator/modules/mod_$name.html.php";


    1393. 

  1393. 		} else if (file_exists("$basePath/administrator/components/$option/admin.$name.php" )) {


    1394. 

  1394. 			$this->_path->admin 		= "$basePath/administrator/components/$option/admin.$name.php";


    1395. 

  1395. 			$this->_path->admin_html 	= "$basePath/administrator/components/$option/admin.$name.html.php";


    1396. 

  1396. 		} else {


    1397. 

  1397. 			$this->_path->admin 		= "$basePath/administrator/components/com_admin/admin.admin.php";


    1398. 

  1398. 			$this->_path->admin_html 	= "$basePath/administrator/components/com_admin/admin.admin.html.php";


    1399. 

  1399. 		}


    1400. 

  1400. 	}


    1401. 

  1401. 	/**


    1402. 

  1402. 	* Returns a stored path variable


    1403. 

  1403. 	*


    1404. 

  1404. 	*/


    1405. 

  1405. 	function getPath( $varname, $option='' ) {


    1406. 

  1406. 		global $mosConfig_absolute_path;


    1407. 

  1407. 		if ($option) {


    1408. 

  1408. 			$temp = $this->_path;


    1409. 

  1409. 			$this->_setAdminPaths( $option, $this->getCfg( 'absolute_path' ) );


    1410. 

  1410. 		}


    1411. 

  1411. 		$result = null;


    1412. 

  1412. 		if (isset( $this->_path->$varname )) {


    1413. 

  1413. 			$result = $this->_path->$varname;


    1414. 

  1414. 		} else {


    1415. 

  1415. 			switch ($varname) {


    1416. 

  1416. 				case 'com_xml':


    1417. 

  1417. 					$name = substr( $option, 4 );


    1418. 

  1418. 					$path = "$mosConfig_absolute_path/administrator/components/$option/$name.xml";


    1419. 

  1419. 					if (file_exists( $path )) {


    1420. 

  1420. 						$result = $path;


    1421. 

  1421. 					} else {


    1422. 

  1422. 						$path = "$mosConfig_absolute_path/components/$option/$name.xml";


    1423. 

  1423. 						if (file_exists( $path )) {


    1424. 

  1424. 							$result = $path;


    1425. 

  1425. 						}


    1426. 

  1426. 					}


    1427. 

  1427. 					break;


    1428. 

  1428. 


    1429. 

  1429. 				case 'mod0_xml':


    1430. 

  1430. 					// Site modules


    1431. 

  1431. 					if ($option == '') {


    1432. 

  1432. 						$path = $mosConfig_absolute_path . "/modules/custom.xml";


    1433. 

  1433. 					} else {


    1434. 

  1434. 						$path = $mosConfig_absolute_path . "/modules/$option.xml";


    1435. 

  1435. 					}


    1436. 

  1436. 					if (file_exists( $path )) {


    1437. 

  1437. 						$result = $path;


    1438. 

  1438. 					}


    1439. 

  1439. 					break;


    1440. 

  1440. 


    1441. 

  1441. 				case 'mod1_xml':


    1442. 

  1442. 					// admin modules


    1443. 

  1443. 					if ($option == '') {


    1444. 

  1444. 						$path = $mosConfig_absolute_path . '/administrator/modules/custom.xml';


    1445. 

  1445. 					} else {


    1446. 

  1446. 						$path = $mosConfig_absolute_path . "/administrator/modules/$option.xml";


    1447. 

  1447. 					}


    1448. 

  1448. 					if (file_exists( $path )) {


    1449. 

  1449. 						$result = $path;


    1450. 

  1450. 					}


    1451. 

  1451. 					break;


    1452. 

  1452. 


    1453. 

  1453. 				case 'bot_xml':


    1454. 

  1454. 					// Site mambots


    1455. 

  1455. 					$path = $mosConfig_absolute_path . "/mambots/$option.xml";


    1456. 

  1456. 					if (file_exists( $path )) {


    1457. 

  1457. 						$result = $path;


    1458. 

  1458. 					}


    1459. 

  1459. 					break;


    1460. 

  1460. 


    1461. 

  1461. 				case 'menu_xml':


    1462. 

  1462. 					$path = $mosConfig_absolute_path . "/administrator/components/com_menus/$option/$option.xml";


    1463. 

  1463. 					if (file_exists( $path )) {


    1464. 

  1464. 						$result = $path;


    1465. 

  1465. 					}


    1466. 

  1466. 					break;


    1467. 

  1467. 


    1468. 

  1468. 				case 'installer_html':


    1469. 

  1469. 					$path = $mosConfig_absolute_path . "/administrator/components/com_installer/$option/$option.html.php";


    1470. 

  1470. 					if (file_exists( $path )) {


    1471. 

  1471. 						$result = $path;


    1472. 

  1472. 					}


    1473. 

  1473. 					break;


    1474. 

  1474. 


    1475. 

  1475. 				case 'installer_class':


    1476. 

  1476. 					$path = $mosConfig_absolute_path . "/administrator/components/com_installer/$option/$option.class.php";


    1477. 

  1477. 					if (file_exists( $path )) {


    1478. 

  1478. 						$result = $path;


    1479. 

  1479. 					}


    1480. 

  1480. 					break;


    1481. 

  1481. 			}


    1482. 

  1482. 		}


    1483. 

  1483. 		if ($option) {


    1484. 

  1484. 			$this->_path = $temp;


    1485. 

  1485. 		}


    1486. 

  1486. 		return $result;


    1487. 

  1487. 	}


    1488. 

  1488. 	/**


    1489. 

  1489. 	* Detects a 'visit'


    1490. 

  1490. 	*


    1491. 

  1491. 	* This function updates the agent and domain table hits for a particular


    1492. 

  1492. 	* visitor.  The user agent is recorded/incremented if this is the first visit.


    1493. 

  1493. 	* A cookie is set to mark the first visit.


    1494. 

  1494. 	*/


    1495. 

  1495. 	function detect() {


    1496. 

  1496. 		global $mosConfig_enable_stats;


    1497. 

  1497. 		if ($mosConfig_enable_stats == 1) {


    1498. 

  1498. 			if (mosGetParam( $_COOKIE, 'mosvisitor', 0 )) {


    1499. 

  1499. 				return;


    1500. 

  1500. 			}


    1501. 

  1501. 			setcookie( 'mosvisitor', 1 );


    1502. 

  1502. 


    1503. 

  1503. 			if (phpversion() <= '4.2.1') {


    1504. 

  1504. 				$agent = getenv( 'HTTP_USER_AGENT' );


    1505. 

  1505. 				$domain = @gethostbyaddr( getenv( "REMOTE_ADDR" ) );


    1506. 

  1506. 			} else {


    1507. 

  1507. 				if ( isset($_SERVER['HTTP_USER_AGENT']) ) {


    1508. 

  1508. 					$agent = $_SERVER['HTTP_USER_AGENT'];


    1509. 

  1509. 				} else {


    1510. 

  1510. 					$agent = 'Unknown';


    1511. 

  1511. 				}


    1512. 

  1512. 


    1513. 

  1513. 				$domain = @gethostbyaddr( $_SERVER['REMOTE_ADDR'] );


    1514. 

  1514. 			}


    1515. 

  1515. 


    1516. 

  1516. 			$browser = mosGetBrowser( $agent );


    1517. 

  1517. 


    1518. 

  1518. 			$query = "SELECT COUNT(*)"


    1519. 

  1519. 			. "\n FROM #__stats_agents"


    1520. 

  1520. 			. "\n WHERE agent = " . $this->_db->Quote( $browser )


    1521. 

  1521. 			. "\n AND type = 0"


    1522. 

  1522. 			;


    1523. 

  1523. 			$this->_db->setQuery( $query );


    1524. 

  1524. 			if ($this->_db->loadResult()) {


    1525. 

  1525. 				$query = "UPDATE #__stats_agents"


    1526. 

  1526. 				. "\n SET hits = ( hits + 1 )"


    1527. 

  1527. 				. "\n WHERE agent = " . $this->_db->Quote( $browser )


    1528. 

  1528. 				. "\n AND type = 0"


    1529. 

  1529. 				;


    1530. 

  1530. 				$this->_db->setQuery( $query );


    1531. 

  1531. 			} else {


    1532. 

  1532. 				$query = "INSERT INTO #__stats_agents"


    1533. 

  1533. 				. "\n ( agent, type )"


    1534. 

  1534. 				. "\n VALUES ( " . $this->_db->Quote( $browser ) . ", 0 )"


    1535. 

  1535. 				;


    1536. 

  1536. 				$this->_db->setQuery( $query );


    1537. 

  1537. 			}


    1538. 

  1538. 			$this->_db->query();


    1539. 

  1539. 


    1540. 

  1540. 			$os = mosGetOS( $agent );


    1541. 

  1541. 


    1542. 

  1542. 			$query = "SELECT COUNT(*)"


    1543. 

  1543. 			. "\n FROM #__stats_agents"


    1544. 

  1544. 			. "\n WHERE agent = " . $this->_db->Quote( $os )


    1545. 

  1545. 			. "\n AND type = 1"


    1546. 

  1546. 			;


    1547. 

  1547. 			$this->_db->setQuery( $query );


    1548. 

  1548. 			if ($this->_db->loadResult()) {


    1549. 

  1549. 				$query = "UPDATE #__stats_agents"


    1550. 

  1550. 				. "\n SET…
    1551.

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