PageRenderTime 69ms CodeModel.GetById 20ms RepoModel.GetById 0ms app.codeStats 1ms

/zina/common.php

https://bitbucket.org/helmespc/zina2
PHP | 1126 lines | 920 code | 101 blank | 105 comment | 152 complexity | 1f8a0875df35ba45dd04fd4092012ea5 MD5 | raw file
    

  1. <?php

    2. 

  2. /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

    3. 

  3.  * ZINA2 (Zina2 is not Zina)

    4. 

  4.  *

    5. 

  5.  * Zina2 is a graphical interface to your MP3 collection, a personal

    6. 

  6.  * jukebox, an MP3 streamer. It can run on its own, embeded into an

    7. 

  7.  * existing website, or as a Drupal/Joomla/Wordpress/etc. module.

    8. 

  8.  *

    9. 

  9.  * https://bitbucket.org/helmespc/zina2 

    10. 

  10.  * Author: Patrick Helmes <helmespc@gmail.com>

    11. 

  11.  * Support: https://bitbucket.org/helmespc/zina2/wiki/Home

    12. 

  12.  * License: GNU GPL2 <http://www.gnu.org/copyleft/gpl.html>

    13. 

  13.  *

    14. 

  14.  * This Software is a fork of Zina (is not Andromeda):

    15. 

  15.  * http://www.pancake.org/zina

    16. 

  16.  * Author: Ryan Lathouwers <ryanlath@pacbell.net>

    17. 

  17.  * Support: http://sourceforge.net/projects/zina/

    18. 

  18.  * License: GNU GPL2 <http://www.gnu.org/copyleft/gpl.html>

    19. 

  19.  *

    20. 

  20.  * common.php

    21. 

  21.  *  - common functions (many modified/inspired from Drupal)

    22. 

  22.  *

    23. 

  23.  *  TODO:

    24. 

  24.  *   - normalize function names

    25. 

  25.  *   - organize file

    26. 

  26.  *

    27. 

  27.  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

    28. 

  28. 

    29. 

  29. /**************************************************

    30. 

  30. Description:

    31. 

  31. 	This function translates a string based on

    32. 

  32. 	the globally defined language setting.

    33. 

  33. Returns:

    34. 

  34. 	- The translated string, if the translation was

    35. 

  35. 	successful. 

    36. 

  36. 	- If the translation was unsuccessful, the 

    37. 

  37. 	original string is returned.

    38. 

  38. Usage Notes:

    39. 

  39. **************************************************/

    40. 

  40. function zt($string, $args = array()) {

    41. 

  41. 	global $zina_lang_code, $zina_lang_path;

    42. 

  42. 	static $lang;

    43. 

  43. 

    44. 

  44. 	// Load the language file (i.e. $lang['fr'])

    45. 

  45. 	if (!isset($lang[$zina_lang_code]) && $zina_lang_path) {

    46. 

  46. 		$lang[$zina_lang_code] = array();

    47. 

  47. 		include($zina_lang_path);

    48. 

  48. 	}

    49. 

  49. 

    50. 

  50. 	// Find input string in the language array

    51. 

  51. 	if (isset($lang[$zina_lang_code][$string])) {

    52. 

  52. 		$string = $lang[$zina_lang_code][$string];

    53. 

  53. 	}

    54. 

  54. 

    55. 

  55. 	// If the args value is empty or invalid, return the original

    56. 

  56. 	// string.

    57. 

  57. 	if (empty($args) || !is_array($args)) {

    58. 

  58. 		return $string;

    59. 

  59. 	}

    60. 

  60. 

    61. 

  61. 	// Transform arguments before inserting them.

    62. 

  62. 	foreach ($args as $key => $value) {

    63. 

  63. 		switch ($key[0]) {

    64. 

  64. 			case '@':

    65. 

  65. 				// Escaped only.

    66. 

  66. 				$args[$key] = zcheck_plain($value);

    67. 

  67. 			break;

    68. 

  68. 			case '%':

    69. 

  69. 			default:

    70. 

  70. 				// Escaped and placeholder.

    71. 

  71. 				$args[$key] = ztheme('placeholder', $value);

    72. 

  72. 			break;

    73. 

  73. 			case '!':

    74. 

  74. 				// Pass-through.

    75. 

  75. 		}

    76. 

  76. 	}

    77. 

  77. 	return strtr($string, $args);

    78. 

  78. }

    79. 

  79. 

    80. 

  80. function zcheck_plain($text) {

    81. 

  81. 	if (zvalidate_utf8($text)) {

    82. 

  82. 		return htmlspecialchars($text, ENT_QUOTES);

    83. 

  83. 	} 

    84. 

  84. 	else {

    85. 

  85. 		global $zc;

    86. 

  86. 		return ((strtolower($zc['charset']) == 'utf-8') ? utf8_encode($text) : '');

    87. 

  87. 	}

    88. 

  88. }

    89. 

  89. 

    90. 

  90. function zcheck_utf8($text, $xml=true) {

    91. 

  91. 	global $zc;

    92. 

  92. 	# Best so far???

    93. 

  93. 	return (!(preg_match('/^./us', $text) == 1) && strtolower($zc['charset']) == 'utf-8') ? utf8_encode($text) : (($xml) ? zxml_encode($text) : $text);

    94. 

  94. 	#return (!zvalidate_utf8($text) && strtolower($zc['charset']) == 'utf-8') ? utf8_encode($text) : (($xml) ? zxml_encode($text) : $text);

    95. 

  95. }

    96. 

  96. 

    97. 

  97. function zvalidate_utf8($text) {

    98. 

  98. 	// If the strlen is 0, valid UTF8

    99. 

  99. 	if (strlen($text) == 0) {

    100. 

  100. 		return true;

    101. 

  101. 	}

    102. 

  102. 

    103. 

  103. 	// Validate against a regex match

    104. 

  104. 	return (preg_match('/^./us', $text) == 1);

    105. 

  105. }

    106. 

  106. 

    107. 

  107. function zina_set_message($message = NULL, $type = 'status', $repeat = TRUE) {

    108. 

  108. 	if ($message) {

    109. 

  109. 		if (!isset($_SESSION['messages'])) {

    110. 

  110. 			$_SESSION['messages'] = array();

    111. 

  111. 		}

    112. 

  112. 

    113. 

  113. 		if (!isset($_SESSION['messages'][$type])) {

    114. 

  114. 			$_SESSION['messages'][$type] = array();

    115. 

  115. 		}

    116. 

  116. 

    117. 

  117. 		if ($repeat || !in_array($message, $_SESSION['messages'][$type])) {

    118. 

  118. 			$_SESSION['messages'][$type][] = $message;

    119. 

  119. 		}

    120. 

  120. 	}

    121. 

  121. 

    122. 

  122. 	// messages not set when DB connection fails

    123. 

  123. 	return isset($_SESSION['messages']) ? $_SESSION['messages'] : NULL;

    124. 

  124. }

    125. 

  125. 

    126. 

  126. function zina_get_messages($type = NULL, $clear_queue = TRUE) {

    127. 

  127. 	if ($messages = zina_set_message()) {

    128. 

  128. 		if ($type) {

    129. 

  129. 

    130. 

  130. 			if ($clear_queue) {

    131. 

  131. 				unset($_SESSION['messages'][$type]);

    132. 

  132. 			}

    133. 

  133. 

    134. 

  134. 			if (isset($messages[$type])) {

    135. 

  135. 				return array($type => $messages[$type]); 

    136. 

  136. 			}

    137. 

  137. 		} 

    138. 

  138. 		else {

    139. 

  139. 

    140. 

  140. 			if ($clear_queue) { 

    141. 

  141. 				unset($_SESSION['messages']);

    142. 

  142. 			}

    143. 

  143. 

    144. 

  144. 			return $messages;

    145. 

  145. 		}

    146. 

  146. 	}

    147. 

  147. 	return array();

    148. 

  148. }

    149. 

  149. 

    150. 

  150. function ztheme() {

    151. 

  151. 	global $zc;

    152. 

  152. 	$args = func_get_args();

    153. 

  153. 	$function = array_shift($args);

    154. 

  154. 

    155. 

  155. 	if (function_exists($zc['theme'].'_'.$function)) {

    156. 

  156. 		return call_user_func_array($zc['theme'].'_'.$function, $args);

    157. 

  157. 	} elseif (function_exists('ztheme_'. $function)){

    158. 

  158. 		return call_user_func_array('ztheme_'.$function, $args);

    159. 

  159. 	}

    160. 

  160. }

    161. 

  161. 

    162. 

  162. #todo: change to drupal 6? arr of $opts??

    163. 

  163. function zurl($path = NULL, $query = NULL, $fragment = NULL, $absolute = FALSE, $direct = FALSE) {

    164. 

  164. 	global $zc;

    165. 

  165. 	if (isset($fragment)) $fragment = '#'. $fragment;

    166. 

  166. 

    167. 

  167. 	// Return an external link

    168. 

  168. 	if (strpos($path, ':') !== FALSE) {

    169. 

  169. 		// Split off the fragment

    170. 

  170. 		if (strpos($path, '#') !== FALSE) {

    171. 

  171. 			list($path, $old_fragment) = explode('#', $path, 2);

    172. 

  172. 			if (isset($old_fragment) && !isset($fragment)) $fragment = '#'. $old_fragment;

    173. 

  173. 		}

    174. 

  174. 		if (isset($query)) $path .= (strpos($path, '?') !== FALSE ? '&' : '?') . $query;

    175. 

  175. 		return $path.$fragment;

    176. 

  176. 	}

    177. 

  177. 

    178. 

  178. 	#todo: base_path not set?

    179. 

  179. 	static $script, $base_url, $base_path, $base_url2, $base_path2, $www_path;

    180. 

  180. 

    181. 

  181. 	if (!isset($script)) {

    182. 

  182. 		$script = (strpos($_SERVER['SERVER_SOFTWARE'], 'Apache') === FALSE && !$zc['clean_urls']) ? 'index.php' : '';

    183. 

  183. 	}

    184. 

  184. 

    185. 

  185. 	if (!isset($base_url)) {

    186. 

  186. 	 	$base_root = (isset($_SERVER['HTTPS']) && $_SERVER['HTTPS'] == 'on') ? 'https' : 'http';

    187. 

  187. 		$base_url = $base_root .= '://'.$zc['auth']. preg_replace('/[^a-z0-9-:._]/i', '', $_SERVER['HTTP_HOST']);

    188. 

  188. 	}

    189. 

  189. 

    190. 

  190. 	if ($direct) {

    191. 

  191. 		$base = ($absolute) ? $base_url : '';

    192. 

  192. 		if (!isset($www_path)) {

    193. 

  193. 			$tmp = preg_replace("#^${_SERVER['DOCUMENT_ROOT']}#i", '', $zc['mp3_dir'], -1, $count);

    194. 

  194. 			$www_path = ($count > 0) ? $tmp : '';

    195. 

  195. 		}

    196. 

  196. 		return $base.$www_path.'/'.zrawurlencode($path);

    197. 

  197. 	} else {

    198. 

  198. 		if (!isset($base_url2)) {

    199. 

  199. 			if ($dir = trim(dirname($_SERVER['SCRIPT_NAME']), '\,/')) {

    200. 

  200. 				$base_path2 = "/$dir";

    201. 

  201. 				$base_url2 = $base_url.$base_path2;

    202. 

  202. 				$base_path2 .= '/';

    203. 

  203. 			} else {

    204. 

  204. 				$base_path2 = '/';

    205. 

  205. 				$base_url2 = $base_url;

    206. 

  206. 	 		}

    207. 

  207. 			if (isset($zc['index_rel'])) {

    208. 

  208. 				$base_url2 .= '/'.$zc['index_rel'];

    209. 

  209. 				$base_path2 .= $zc['index_rel'] .'/';

    210. 

  210. 			}

    211. 

  211. 		}

    212. 

  212. 		$base = ($absolute) ? $base_url2 . '/' : $base_path2;

    213. 

  213. 	}

    214. 

  214. 

    215. 

  215. 	if (isset($zc['url_query'])) {

    216. 

  216. 		$url_query = implode('&',$zc['url_query']);

    217. 

  217. 		$query .= (empty($query)) ? $url_query : '&'.$url_query;

    218. 

  218. 	}

    219. 

  219. 

    220. 

  220. 	if (!empty($path)) {

    221. 

  221. 		if ($zc['clean_urls']) {

    222. 

  222. 			$path = str_replace(array('%2F', '%26', '%23', '//', '%2B'), array('/', '%2526', '%2523', '/%252F', '%252B'), rawurlencode($path));

    223. 

  223. 			return $base.$path.((isset($query)) ? '?'.$query:'').$fragment;

    224. 

  224. 		} else {

    225. 

  225. 			$path = str_replace('%2F', '/', rawurlencode($path));

    226. 

  226. 			return $base.$script.'?p='.$path.(isset($query)?'&'.$query:'').$fragment;

    227. 

  227. 		}

    228. 

  228. 	} else {

    229. 

  229. 		return $base.(isset($query)?$script.'?'.$query:'').$fragment;

    230. 

  230. 	}

    231. 

  231. }

    232. 

  232. 

    233. 

  233. function zrawurlencode($path) {

    234. 

  234. 	return str_replace(array('%2F', '%26', '%23'), array('/', '%2526', '%2523'), rawurlencode($path));

    235. 

  235. }

    236. 

  236. 

    237. 

  237. function zrawurldecode($x) {

    238. 

  238. 	return str_replace(array('%2F', '%26', '%23'), array('/', '&', '#'), rawurldecode($x));

    239. 

  239. }

    240. 

  240. 

    241. 

  241. function zpath_to_theme($path_rel = null) {

    242. 

  242. 	static $theme_dir;

    243. 

  243. 	if (!empty($path_rel)) $theme_dir = $path_rel;

    244. 

  244. 	return $theme_dir;

    245. 

  245. }

    246. 

  246. 

    247. 

  247. /*

    248. 

  248. #TODO: redo ala D6

    249. 

  249. function zl($text, $path, $options = array()) {

    250. 

  250.   $options += array(

    251. 

  251.       'attributes' => array(),

    252. 

  252.       'html' => FALSE,

    253. 

  253. 	);

    254. 

  254. 

    255. 

  255. 	if (isset($options['attributes']['title']) && strpos($options['attributes']['title'], '<') !== FALSE) {

    256. 

  256. 		$options['attributes']['title'] = strip_tags($options['attributes']['title']);

    257. 

  257. 	}

    258. 

  258. 

    259. 

  259. 	return '<a href="' . check_plain(url($path, $options)) . '"' . drupal_attributes($options['attributes']) . '>' . ($options['html'] ? $text : check_plain($text)) . '</a>';

    260. 

  260. }

    261. 

  261.  */

    262. 

  262. function zl($text, $path, $query = NULL, $fragment = NULL, $absolute = FALSE, $attributes = '') {

    263. 

  263. 	if (!empty($attributes)) $attributes = ' '.$attributes;

    264. 

  264. 	return '<a href="'.zurl($path, $query, $fragment, $absolute).'"'.$attributes.'>'.$text.'</a>';

    265. 

  265. }

    266. 

  266. 

    267. 

  267. function zina_get_headers() {

    268. 

  268. 	foreach(zina_set_header() as $header) {

    269. 

  269. 		header($header);

    270. 

  270. 	}

    271. 

  271. }

    272. 

  272. 

    273. 

  273. function zina_set_header($header = NULL) {

    274. 

  274. 	static $stored_headers = array();

    275. 

  275. 

    276. 

  276. 	if (strlen($header)) {

    277. 

  277. 		$stored_headers[] = $header;

    278. 

  278. 	}

    279. 

  279. 	return $stored_headers;

    280. 

  280. }

    281. 

  281. 

    282. 

  282. function zina_set_html_head($header = NULL) {

    283. 

  283. 	static $headers = array();

    284. 

  284. 

    285. 

  285. 	if (strlen($header)) {

    286. 

  286. 		$headers[$header] = true;

    287. 

  287. 	}

    288. 

  288. 	return $headers;

    289. 

  289. }

    290. 

  290. 

    291. 

  291. function zina_get_html_head() {

    292. 

  292. 	return implode("\n", array_keys(zina_set_html_head()));

    293. 

  293. }

    294. 

  294. 

    295. 

  295. # type = inline or file

    296. 

  296. function zina_set_css($type = null, $css = null) {

    297. 

  297. 	global $zc;

    298. 

  298. 	static $files = array(), $inline = '';

    299. 

  299. 	if (empty($files)) {

    300. 

  300. 		$files['themes/'.$zc['theme'].'/common.css'] = true;

    301. 

  301. 	}

    302. 

  302. 

    303. 

  303. 	if (empty($type)) {

    304. 

  304. 		$output = '';

    305. 

  305. 		$files = array_reverse($files);

    306. 

  306. 		foreach ($files as $file => $nothing) {

    307. 

  307. 			$output .= '<link rel="stylesheet" href="'.$zc['zina_dir_rel'].'/'.$file.'" type="text/css" />'."\n";

    308. 

  308. 		}

    309. 

  309. 		if (!empty($inline)) $output .= '<style type="text/css">'.$inline.'</style>'."\n";

    310. 

  310. 

    311. 

  311. 		return $output;

    312. 

  312. 	} else {

    313. 

  313. 		if ($type == 'file')

    314. 

  314. 			$files[$css] = true;

    315. 

  315. 		elseif ($type == 'inline')

    316. 

  316. 			$inline .= $css;

    317. 

  317. 	}

    318. 

  318. }

    319. 

  319. 

    320. 

  320. function zina_get_js() {

    321. 

  321. 	global $zc;

    322. 

  322. 	$js = zina_set_js();

    323. 

  323. 

    324. 

  324. 	$output = '';

    325. 

  325. 	foreach($js['file'] as $file=> $relative) {

    326. 

  326. 		$path = ($relative) ? $zc['zina_dir_rel'].'/' : '';

    327. 

  327. 		$output .= '<script type="text/javascript" src="'.$path.$file.'"></script>'."\n";

    328. 

  328. 	}

    329. 

  329. 	#for validation

    330. 

  330. 	$prefix = "\n<!--//--><![CDATA[//><!--\n";

    331. 

  331. 	$suffix = "\n//--><!]]>\n";

    332. 

  332. 

    333. 

  333. 	if (!empty($js['inline']) || !empty($js['jquery']) || !empty($js['vars'])) {

    334. 

  334. 		$output .= '<script type="text/javascript">'.$prefix;

    335. 

  335. 		if (!empty($js['vars'])) $output .= implode('', $js['vars']);

    336. 

  336. 

    337. 

  337. 		if (!empty($js['jquery'])) {

    338. 

  338. 			$noconflict = (!in_array($zc['embed'], array('standalone', 'drupal'))) ? 'jQuery.noConflict();' : '';

    339. 

  339. 			$output .= $noconflict.'jQuery(document).ready(function($){'.implode('', $js['jquery']).'});';

    340. 

  340. 		}

    341. 

  341. 		if (!empty($js['inline'])) $output .= implode('', $js['inline']);

    342. 

  342. 

    343. 

  343. 		$output .= $suffix.'</script>';

    344. 

  344. 	}

    345. 

  345. 

    346. 

  346. 	return $output;

    347. 

  347. }

    348. 

  348. 

    349. 

  349. # type = inline or file

    350. 

  350. function zina_set_js($type = null, $js = null, $relative = true) {

    351. 

  351. 	static $javascript = array();

    352. 

  352. 

    353. 

  353. 	if (empty($files)) $javascript['file']['zina.js'] = true;

    354. 

  354. 

    355. 

  355. 	if ($type == 'file')

    356. 

  356. 		$javascript['file'][$js] = $relative;

    357. 

  357. 	elseif ($type == 'vars')

    358. 

  358. 		$javascript['vars'][] = $js;

    359. 

  359. 	elseif ($type == 'jquery')

    360. 

  360. 		$javascript['jquery'][] = $js;

    361. 

  361. 	else

    362. 

  362. 		$javascript['inline'][] = $js;

    363. 

  363. 

    364. 

  364. 	return $javascript;

    365. 

  365. }

    366. 

  366. 

    367. 

  367. function zo_shuffle(&$array){

    368. 

  368. 	$last = count($array);

    369. 

  369. 	while ($last > 0){

    370. 

  370. 		$last--;

    371. 

  371. 		$random = mt_rand(0, $last);

    372. 

  372. 		$temp = $array[$random];

    373. 

  373. 		$array[$random] = $array[$last];

    374. 

  374. 		$array[$last] = $temp;

    375. 

  375. 	}

    376. 

  376. 	return 1;

    377. 

  377. }

    378. 

  378. 

    379. 

  379. /*

    380. 

  380.  * Gets serialized content or converts from older format

    381. 

  381.  */

    382. 

  382. function zunserialize_alt($content) {

    383. 

  383. 	if (($array = @unserialize($content)) === false) {

    384. 

  384. 		$array = explode("\n", rtrim($content,"\r\n"));

    385. 

  385. 		foreach($array as $key=>$val) {

    386. 

  386. 			$array[$key] = rtrim($val,"\r\n");

    387. 

  387. 		}

    388. 

  388. 	}

    389. 

  389. 	return $array;

    390. 

  390. }

    391. 

  391. 

    392. 

  392. function unserialize_utf8($text) {

    393. 

  393. 	if (empty($text)) return false;

    394. 

  394. 

    395. 

  395. 	$output = @unserialize(utf8_decode($text));

    396. 

  396. 	if ($output === false) {

    397. 

  397. 		$output = unserialize(preg_replace('!s:(\d+):"(.*?)";!se', "'s:'.strlen('$2').':\"$2\";'", $text));

    398. 

  398. 	}

    399. 

  399. 	return $output;

    400. 

  400. }

    401. 

  401. 

    402. 

  402. function zina_goto($path = '', $query = null, $fragment = null, $absolute = false, $direct = false, $exit_on_done = true) {

    403. 

  403. 	$url = zurl($path, $query, $fragment, $absolute, $direct);

    404. 

  404. 	$url = str_replace(array("\n", "\r"), '', $url);

    405. 

  405. 	@session_write_close();

    406. 

  406. 	while(@ob_end_clean());

    407. 

  407. 	header('Location: '. $url, TRUE, 302);

    408. 

  408. 	if ($exit_on_done) {

    409. 

  409. 		exit();

    410. 

  410. 	}

    411. 

  411. }

    412. 

  412. 

    413. 

  413. function zina_debug($error, $level='warn') {

    414. 

  414. 	global $zc;

    415. 

  415. 	if ($zc['debug']) {

    416. 

  416. 		zina_set_message($error, $level);

    417. 

  417. 		error_log('Zina '.$level.': '.$error);

    418. 

  418. 	}

    419. 

  419. }

    420. 

  420. 

    421. 

  421. function zina_check_directory($directory, $create = 0) {

    422. 

  422. 	global $zc;

    423. 

  423. 	$directory = rtrim($directory, '/\\');

    424. 

  424. 

    425. 

  425. 	if (!is_dir($directory)) {

    426. 

  426. 		if ($create) {

    427. 

  427. 		  	if (@mkdir($directory)) {

    428. 

  428. 				zina_set_message(zt('The directory %directory has been created.', array('%directory' => $directory)));

    429. 

  429. 				@chmod($directory, 0775); // Necessary for non-webserver users.

    430. 

  430. 			} else {

    431. 

  431. 				zina_set_message(zt('Cannot create directory %directory.', array('%directory' => $directory)),'error');

    432. 

  432. 				return FALSE;

    433. 

  433. 			}

    434. 

  434. 		} else {

    435. 

  435. 			zina_set_message(zt('Directory does not exist %directory.', array('%directory' => $directory)),'error');

    436. 

  436. 			return FALSE;

    437. 

  437. 		}

    438. 

  438. 	}

    439. 

  439. 

    440. 

  440. 	// Check to see if the directory is writable.

    441. 

  441. 	if (!is_writable($directory)) {

    442. 

  442. 		if ($mode && @chmod($directory, 0775)) {

    443. 

  443. 			zina_set_message(zt('The permissions of directory %directory have been changed to make it writable.', array('%directory' => $directory)));

    444. 

  444. 		} else {

    445. 

  445. 			zina_set_message(zt('The directory %directory is not writeable.', array('%directory' => $directory)),'error');

    446. 

  446. 			return FALSE;

    447. 

  447. 		}

    448. 

  448. 	}

    449. 

  449. 

    450. 

  450. 	if ($zc['cache_dir_private_abs'] == $directory && !is_file("$directory/.htaccess")) {

    451. 

  451. 		$htaccess_lines = "Options None\nOrder Deny,Allow\nDeny from all";

    452. 

  452. 		if (($fp = fopen("$directory/.htaccess", 'w')) && fputs($fp, $htaccess_lines)) {

    453. 

  453. 			fclose($fp);

    454. 

  454. 			chmod($directory .'/.htaccess', 0664);

    455. 

  455. 		} else {

    456. 

  456. 			$variables = array('%directory' => $directory, '!htaccess' => '<br />'. nl2br(zcheck_plain($htaccess_lines)));

    457. 

  457. 			zina_set_message(zt("Security warning: Couldn't write .htaccess file. Please create a .htaccess file in your %directory directory which contains the following lines: <code>!htaccess</code>", $variables),'warn');

    458. 

  458. 		}

    459. 

  459. 	}

    460. 

  460. 

    461. 

  461. 	return true;

    462. 

  462. }

    463. 

  463. 

    464. 

  464. function zina_strlen($text) {

    465. 

  465. 	global $zc;

    466. 

  466. 	return ($zc['multibyte']) ? mb_strlen($text) : strlen(preg_replace("/[\x80-\xBF]/", '', $text));

    467. 

  467. }

    468. 

  468. 

    469. 

  469. function zina_substr($text, $start, $length = NULL) {

    470. 

  470. 	global $zc;

    471. 

  471. 	if ($zc['multibyte']) {

    472. 

  472. 		return $length === NULL ? mb_substr($text, $start) : mb_substr($text, $start, $length);

    473. 

  473. 	} else {

    474. 

  474. 		# NOT a work-around

    475. 

  475. 		return $length === NULL ? substr($text, $start) : substr($text, $start, $length);

    476. 

  476. 	}

    477. 

  477. }

    478. 

  478. 

    479. 

  479. function zina_strtoupper($text) {

    480. 

  480. 	global $zc;

    481. 

  481. 	# NO NON-MB work-around

    482. 

  482. 	return ($zc['multibyte']) ? mb_strtoupper($text) : strtoupper($text);

    483. 

  483. }

    484. 

  484. 

    485. 

  485. function zina_date($format, $timestamp) {

    486. 

  486. 

    487. 

  487.   $max = strlen($format);

    488. 

  488.   $date = '';

    489. 

  489.   for ($i = 0; $i < $max; $i++) {

    490. 

  490.     $c = $format[$i];

    491. 

  491.     if (strpos('AaDlM', $c) !== FALSE) {

    492. 

  492.       $date .= zt(gmdate($c, $timestamp));

    493. 

  493.     } else if ($c == 'F') {

    494. 

  494.       // Special treatment for long month names: May is both an abbreviation

    495. 

  495.       // and a full month name in English, but other languages have different abbreviations.

    496. 

  496.       $date .= trim(zt('!long-month-name '. gmdate($c, $timestamp), array('!long-month-name' => '')));

    497. 

  497.     } else if (strpos('BdgGhHiIjLmnsStTUwWYyz', $c) !== FALSE) {

    498. 

  498.       $date .= gmdate($c, $timestamp);

    499. 

  499.     } else if ($c == 'r') {

    500. 

  500.       $date .= format_date($timestamp - $timezone, 'custom', 'D, d M Y H:i:s O', $timezone, $langcode);

    501. 

  501.     } else if ($c == 'O') {

    502. 

  502.       $date .= sprintf('%s%02d%02d', ($timezone < 0 ? '-' : '+'), abs($timezone / 3600), abs($timezone % 3600) / 60);

    503. 

  503.     } else if ($c == 'Z') {

    504. 

  504.       $date .= $timezone;

    505. 

  505.     } else if ($c == '\\') {

    506. 

  506.       $date .= $format[++$i];

    507. 

  507.     } else {

    508. 

  508.       $date .= $c;

    509. 

  509.     }

    510. 

  510.   }

    511. 

  511. 

    512. 

  512.   return $date;

    513. 

  513. }

    514. 

  514. 

    515. 

  515. function zina_delete_file($file) {

    516. 

  516. 	global $zc;

    517. 

  517. 	if (!file_exists($file) || !zfile_check_location($file, $zc['mp3_dir'])) {

    518. 

  518. 		zina_set_message(zt('File does not exist: @file', array('@file'=>$file)));

    519. 

  519. 		return false;

    520. 

  520. 	}

    521. 

  521. 	$full_path = substr($file, strlen($zc['mp3_dir'])+1);

    522. 

  522. 	$path = dirname($full_path);

    523. 

  523. 	$file_name = basename($full_path);

    524. 

  524. 

    525. 

  525. 	if (unlink($file)) {

    526. 

  526. 		if ($zc['database']) {

    527. 

  527. 			$id = zdbq_single("SELECT id FROM {files} WHERE path = '%s' AND file = '%s'", array($path, $file_name));

    528. 

  528. 			if (!empty($id)) zdb_remove('file', $id);

    529. 

  529. 		}

    530. 

  530. 

    531. 

  531. 		$exts = $zc['song_es_exts'];

    532. 

  532. 		$exts[] = $zc['remote_ext'];

    533. 

  533. 		$exts[] = $zc['fake_ext'];

    534. 

  534. 		$exts[] = 'txt';

    535. 

  535. 

    536. 

  536. 		foreach($exts as $ext) {

    537. 

  537. 			$aux_files[] = preg_replace('/'.$zc['ext_mus'].'$/i', $ext, $file_name);

    538. 

  538. 		}

    539. 

  539. 		foreach($aux_files as $aux) {

    540. 

  540. 			$aux_file = $path.'/'.$aux;

    541. 

  541. 			if (file_exists($aux_file)) unlink($aux_file);

    542. 

  542. 		}

    543. 

  543. 

    544. 

  544. 		return $path;

    545. 

  545. 	} else {

    546. 

  546. 		zina_set_message(zt('Could not delete file: @file', array('@file'=>$file)));

    547. 

  547. 		return false;

    548. 

  548. 	}

    549. 

  549. }

    550. 

  550. 

    551. 

  551. function zina_delete_directory($dir) {

    552. 

  552. 	if (!file_exists($dir)) return true;

    553. 

  553. 	if (!is_dir($dir) || is_link($dir)) return unlink($dir);

    554. 

  554. 

    555. 

  555. 	foreach (scandir($dir) as $path) {

    556. 

  556. 		if ($path == '.' || $path == '..') continue;

    557. 

  557. 		$item = $dir.'/'.$path;

    558. 

  558. 		if (!zina_delete_directory($item)) {

    559. 

  559. 			chmod($item, 0777);

    560. 

  560. 			if (!zina_delete_directory($item)) return false;

    561. 

  561. 		}

    562. 

  562. 	}

    563. 

  563. 	return rmdir($dir);

    564. 

  564. }

    565. 

  565. 

    566. 

  566. function zina_token_sess($value) {

    567. 

  567. 	static $key;

    568. 

  568. 	if (empty($key)) {

    569. 

  569. 		global $zc;

    570. 

  570. 		$keyfile = $zc['cache_dir_private_abs'].'/sitekey.txt';

    571. 

  571. 		if (file_exists($keyfile)) {

    572. 

  572. 			$key = file_get_contents($keyfile);

    573. 

  573. 		} else {

    574. 

  574. 			zina_debug(zt('Sitekey file does not exist'),'warn');

    575. 

  575. 			return false;

    576. 

  576. 		}

    577. 

  577. 	}

    578. 

  578. 	return md5(session_id() . $value . $key);

    579. 

  579. }

    580. 

  580. 

    581. 

  581. function zina_token_sess_check() {

    582. 

  582. 	global $zc;

    583. 

  583. 	if (isset($_POST['token']) && !empty($_POST['token']) && $_POST['token'] == zina_token_sess($zc['user_id'])) {

    584. 

  584. 		return true;

    585. 

  585. 	}

    586. 

  586. 	return false;

    587. 

  587. }

    588. 

  588. 

    589. 

  589. function zsort_date($a, $b) {

    590. 

  590. 	if ($a['mtime'] == $b['mtime']) return 0;

    591. 

  591. 	return ($a['mtime'] < $b['mtime']) ? -1 : 1;

    592. 

  592. }

    593. 

  593. 

    594. 

  594. function zsort_date_desc($a, $b) {

    595. 

  595. 	if ($a['mtime'] == $b['mtime']) return 0;

    596. 

  596. 	return ($a['mtime'] > $b['mtime']) ? -1 : 1;

    597. 

  597. }

    598. 

  598. 

    599. 

  599. function zsort_trackno($a, $b) {

    600. 

  600. 	if ($a['info']->track == $b['info']->track) return 0;

    601. 

  601. 	return ((int)$a['info']->track < (int)$b['info']->track) ? -1 : 1;

    602. 

  602. }

    603. 

  603. 

    604. 

  604. function zsort_ignore($a, $b) {

    605. 

  605. 	global $zc;

    606. 

  606. 	#return strnatcasecmp(preg_replace('/(^|\/)('.$zc['dir_si_str'].') /i','$1',$a), preg_replace('/(^|\/)('.$zc['dir_si_str'].') /i','$1',$b));

    607. 

  607. 

    608. 

  608. 	if (strpos($a, '/') || strpos($b, '/')) {

    609. 

  609. 		return strnatcasecmp(preg_replace('/^('.$zc['dir_si_str'].') /i','',basename($a)), preg_replace('/^('.$zc['dir_si_str'].') /i','',basename($b)));

    610. 

  610. 	} else {

    611. 

  611. 		if (strpos($a, ' ') || strpos($b, ' ')) {

    612. 

  612. 			return strnatcasecmp(preg_replace('/^('.$zc['dir_si_str'].') /i','',$a), preg_replace('/^('.$zc['dir_si_str'].') /i','',$b));

    613. 

  613. 		} else {

    614. 

  614. 			return strnatcasecmp($a, $b);

    615. 

  615. 		}

    616. 

  616. 	}

    617. 

  617. }

    618. 

  618. 

    619. 

  619. function zsort_title_ignore($a, $b) {

    620. 

  620. 	if ($a['person'] || $b['person']) {

    621. 

  621. 		$a1 = $a['title'];

    622. 

  622. 		$b1 = $b['title'];

    623. 

  623. 		if ($a['person'] && ($pos = strripos($a['title'], ' ')) !== false) {

    624. 

  624. 			$a1 = substr($a['title'], $pos+1).','.substr($a['title'], 0, $pos);

    625. 

  625. 		}

    626. 

  626. 		if ($b['person'] && ($pos = strripos($b['title'], ' ')) !== false) {

    627. 

  627. 			$b1 = substr($b['title'], $pos+1).','.substr($b['title'], 0, $pos);

    628. 

  628. 		}

    629. 

  629. 		

    630. 

  630. 		return zsort_ignore($a1, $b1);

    631. 

  631. 	} else {

    632. 

  632. 		return zsort_ignore($a['title'], $b['title']);

    633. 

  633. 	}

    634. 

  634. }

    635. 

  635. 

    636. 

  636. function zsort_title($a, $b) {

    637. 

  637. 	if ($a['title'] == $b['title']) return 0;

    638. 

  638. 	return ($a['title'] < $b['title']) ? -1 : 1;

    639. 

  639. }

    640. 

  640. 

    641. 

  641. function zina_validate($type, $value, $opts = null) {

    642. 

  642. 	if ($type == 'req') {

    643. 

  643. 		if (is_array($value)) {

    644. 

  644. 			return (!empty($value));

    645. 

  645. 		} else {

    646. 

  646. 			return strlen($value) > 0;

    647. 

  647. 		}

    648. 

  648. 	} elseif ($type == 'tf') {

    649. 

  649. 		return ($value == 0 || $value == 1);

    650. 

  650. 	} elseif ($type == 'int') {

    651. 

  651. 		return (is_numeric($value) ? intval($value) == $value : false);

    652. 

  652. 	} elseif ($type == 'int_split') {

    653. 

  653. 		$ints = explode(',', $value);

    654. 

  654. 		foreach($ints as $int) {

    655. 

  655. 			if (!zina_validate('int', $int)) return false;

    656. 

  656. 		}

    657. 

  657. 		return true;

    658. 

  658. 	} elseif ($type == 'file_exists') {

    659. 

  659. 		return (file_exists($value));

    660. 

  660. 	} elseif ($type == 'alpha_numeric') {

    661. 

  661. 		return (!preg_match('/\W/', $value));

    662. 

  662. 	} elseif ($type == 'path_relative') {

    663. 

  663. 		global $zc;

    664. 

  664. 		return zina_check_directory($zc['zina_dir_abs'].'/'.$value,1);

    665. 

  665. 	} elseif ($type == 'dir_exists') {

    666. 

  666. 		return (file_exists($value) && is_dir($value));

    667. 

  667. 	} elseif ($type == 'dir_writeable') {

    668. 

  668. 		return zina_check_directory($value,1);

    669. 

  669. 	} elseif ($type == 'if') {

    670. 

  670. 		$key = key($opts);

    671. 

  671. 		if (isset($_POST[$key]) && $_POST[$key] == 1) {

    672. 

  672. 			return zina_validate(current($opts), $value);

    673. 

  673. 		}

    674. 

  674. 		return true;

    675. 

  675. 	}

    676. 

  676. 	return false;

    677. 

  677. }

    678. 

  678. 

    679. 

  679. /*

    680. 

  680.  * Thanks to: http://tim-ryan.com/labs/parseINI/

    681. 

  681.  */

    682. 

  682. function zina_parse_ini_string($ini_string) {

    683. 

  683. 	$data = array();

    684. 

  684. 	$currentSection = '';

    685. 

  685. 	foreach (preg_split('/\r\n?|\r?\n/', $ini_string) as $line) {

    686. 

  686. 		if (preg_match('/^\s*\[\s*(.*)\s*\]\s*$/', $line, $matches)) {

    687. 

  687. 			$currentSection = $matches[1];

    688. 

  688. 		} else if (preg_match('/^\s*([^;\s].*?)\s*=\s*([^\s].*?)$/', $line, $matches)) {

    689. 

  689. 			$key = preg_replace('/\[\]$/', '', $matches[1]);

    690. 

  690. 			$isArray = preg_match('/\[\]$/', $matches[1]);

    691. 

  691. 

    692. 

  692. 			preg_match('/^"(?:\\.|[^"])*"|^\'(?:[^\']|\\.)*\'|^[^;]+?\s*(?=;|$)/', $matches[2], $matches);

    693. 

  693. 			$value = preg_replace('/^(["\'])(.*?)\1?$/', '\2', stripslashes($matches[0]));

    694. 

  694. 			if (is_numeric($value))

    695. 

  695. 				$value = (float) $value;

    696. 

  696. 			else if (strtolower($value) == 'true')

    697. 

  697. 				$value = true;

    698. 

  698. 			else if (strtolower($value) == 'false')

    699. 

  699. 				$value = false;

    700. 

  700. 

    701. 

  701. 			$section =& $data[$currentSection];

    702. 

  702. 			foreach (explode('.', $key) as $level) {

    703. 

  703. 				if (isset($section[$level]) && !is_array($section[$level])) {

    704. 

  704. 					$section[$level] = array();

    705. 

  705. 				}

    706. 

  706. 

    707. 

  707. 				$section =& $section[$level];

    708. 

  708. 			}

    709. 

  709. 			$isArray ? $section[] = $value : $section = $value;

    710. 

  710. 		}

    711. 

  711. 	}

    712. 

  712. 	return $data;

    713. 

  713. }

    714. 

  714. 

    715. 

  715. function xml_to_array($data, $type = 'file') {

    716. 

  716. 	$parser = xml_parser_create();

    717. 

  717. 	xml_parser_set_option($parser, XML_OPTION_CASE_FOLDING, 0);

    718. 

  718. 	xml_parser_set_option($parser, XML_OPTION_SKIP_WHITE, 1);

    719. 

  719. 	xml_parse_into_struct($parser, $data, $values, $tags);

    720. 

  720. 	xml_parser_free($parser);

    721. 

  721. 

    722. 

  722. 	$items = array();

    723. 

  723. 

    724. 

  724. 	foreach ($tags as $key=>$val) {

    725. 

  725. 		if ($key == $type) {

    726. 

  726. 			$pairs = $val;

    727. 

  727. 			$num = count($pairs);

    728. 

  728. 			if ($num > 1) {

    729. 

  729. 				$item = null;

    730. 

  730. 

    731. 

  731. 				for ($i=0; $i < $num; $i+=2) {

    732. 

  732. 					$offset = $pairs[$i] + 1;

    733. 

  733. 					$len = $pairs[$i + 1] - $offset;

    734. 

  734. 					$vs =  array_slice($values, $offset, $len);

    735. 

  735. 					for ($j=0; $j < count($vs); $j++) {

    736. 

  736. 						if (isset($vs[$j]["value"])) {

    737. 

  737. 							$item[$vs[$j]["tag"]] = trim($vs[$j]["value"]);

    738. 

  738. 						}

    739. 

  739. 					}

    740. 

  740. 					$items[] = $item;

    741. 

  741. 				}

    742. 

  742. 			}

    743. 

  743. 		} else {

    744. 

  744. 			continue;

    745. 

  745. 		}

    746. 

  746. 	}

    747. 

  747. 	return $items;

    748. 

  748. }

    749. 

  749. 

    750. 

  750. function zfile_check_location($source, $directory = '') {

    751. 

  751.   $check = realpath($source);

    752. 

  752.   if ($check) {

    753. 

  753.     $source = $check;

    754. 

  754.   } else {

    755. 

  755.     // This file does not yet exist

    756. 

  756.     $source = realpath(dirname($source)) .'/'. basename($source);

    757. 

  757.   }

    758. 

  758.   $directory = realpath($directory);

    759. 

  759.   if ($directory && strpos($source, $directory) !== 0) {

    760. 

  760.     return 0;

    761. 

  761.   }

    762. 

  762.   return $source;

    763. 

  763. }

    764. 

  764. 

    765. 

  765. function zina_add_tabledrag($table_id, $action, $relationship, $group, $subgroup = NULL, $source = NULL, $hidden = TRUE, $limit = 0) {

    766. 

  766. 	if (function_exists('drupal_add_tabledrag')) {

    767. 

  767. 		return drupal_add_tabledrag($table_id, $action, $relationship, $group, $subgroup, $source, $hidden, $limit);

    768. 

  768. 	}

    769. 

  769. 

    770. 

  770. 	static $js_added = false;

    771. 

  771. 	if (!$js_added) {

    772. 

  772. 		global $zc;

    773. 

  773. 		zina_set_js('file', 'extras/tabledrag.js');

    774. 

  774. 		$js_added = TRUE;

    775. 

  775. 		if (isset($zc['index_rel'])) {

    776. 

  776. 			$data[] = array('basePath' => '/'.$zc['index_rel'].'/');

    777. 

  777. 		}

    778. 

  778. 

    779. 

  779. 		$trans['Drag to re-order'] = zt('Drag to re-order');

    780. 

  780. 		$trans['Changes made in this table will not be saved until the form is submitted.'] = zt('Changes made in this table will not be saved until the form is submitted.');

    781. 

  781. 		$test = "Drupal.locale={'strings':". zina_to_js($trans) ."};";

    782. 

  782. 		zina_set_js('vars', $test);

    783. 

  783. 	}

    784. 

  784. 

    785. 

  785.   // If a subgroup or source isn't set, assume it is the same as the group.

    786. 

  786.   $target = isset($subgroup) ? $subgroup : $group;

    787. 

  787.   $source = isset($source) ? $source : $target;

    788. 

  788.   $settings['tableDrag'][$table_id][$group][] = array(

    789. 

  789.     'target' => $target,

    790. 

  790.     'source' => $source,

    791. 

  791.     'relationship' => $relationship,

    792. 

  792.     'action' => $action,

    793. 

  793.     'hidden' => $hidden,

    794. 

  794.     'limit' => $limit,

    795. 

  795.   );

    796. 

  796.   $data[] = $settings;

    797. 

  797.   zina_set_js('vars', 'jQuery.extend(Drupal.settings, ' . zina_to_js(call_user_func_array('array_merge_recursive', $data)) . ");");

    798. 

  798. }

    799. 

  799. 

    800. 

  800. function zina_to_js($var) {

    801. 

  801. 	if (function_exists('drupal_to_js')) return drupal_to_js($var);

    802. 

  802. 

    803. 

  803.   switch (gettype($var)) {

    804. 

  804.     case 'boolean':

    805. 

  805.       return $var ? 'true' : 'false'; // Lowercase necessary!

    806. 

  806.     case 'integer':

    807. 

  807.     case 'double':

    808. 

  808.       return $var;

    809. 

  809.     case 'resource':

    810. 

  810.     case 'string':

    811. 

  811.       return '"'. str_replace(array("\r", "\n", "<", ">", "&"),

    812. 

  812.                               array('\r', '\n', '\x3c', '\x3e', '\x26'),

    813. 

  813.                               addslashes($var)) .'"';

    814. 

  814.     case 'array':

    815. 

  815.       // Arrays in JSON can't be associative. If the array is empty or if it

    816. 

  816.       // has sequential whole number keys starting with 0, it's not associative

    817. 

  817.       // so we can go ahead and convert it as an array.

    818. 

  818.       if (empty ($var) || array_keys($var) === range(0, sizeof($var) - 1)) {

    819. 

  819.         $output = array();

    820. 

  820.         foreach ($var as $v) {

    821. 

  821.           $output[] = zina_to_js($v);

    822. 

  822.         }

    823. 

  823.         return '[ '. implode(', ', $output) .' ]';

    824. 

  824.       }

    825. 

  825.       // Otherwise, fall through to convert the array as an object.

    826. 

  826.     case 'object':

    827. 

  827.       $output = array();

    828. 

  828.       foreach ($var as $k => $v) {

    829. 

  829.         $output[] = zina_to_js(strval($k)) .': '. zina_to_js($v);

    830. 

  830.       }

    831. 

  831.       return '{ '. implode(', ', $output) .' }';

    832. 

  832.     default:

    833. 

  833.       return 'null';

    834. 

  834.   }

    835. 

  835. }

    836. 

  836. 

    837. 

  837. function xml_field($name, $value, $decode = true) {

    838. 

  838. 	return '<'.$name.'>'.zxml_encode($value).'</'.$name.'>'."\n";

    839. 

  839. }

    840. 

  840. 

    841. 

  841. function zxml_encode($x) {

    842. 

  842. 	return htmlspecialchars(zdecode_entities($x));

    843. 

  843. }

    844. 

  844. 

    845. 

  845. function zdecode_entities($text, $exclude = array()) {

    846. 

  846.   static $table;

    847. 

  847.   if (!isset($table)) {

    848. 

  848.     $table = array_flip(get_html_translation_table(HTML_ENTITIES));

    849. 

  849.     $table = array_map('utf8_encode', $table);

    850. 

  850.     $table['&apos;'] = "'";

    851. 

  851.   }

    852. 

  852.   $newtable = (!empty($exclude)) ? array_diff($table, $exclude) : $table;

    853. 

  853.   return preg_replace('/&(#x?)?([A-Za-z0-9]+);/e', '_zdecode_entities("$1", "$2", "$0", $newtable, $exclude)', $text);

    854. 

  854. }

    855. 

  855. 

    856. 

  856. /**

    857. 

  857.  * Helper function for decode_entities

    858. 

  858.  */

    859. 

  859. function _zdecode_entities($prefix, $codepoint, $original, &$table, &$exclude) {

    860. 

  860.   if (!$prefix) {

    861. 

  861.     if (isset($table[$original])) {

    862. 

  862.       return $table[$original];

    863. 

  863.     }

    864. 

  864.     else {

    865. 

  865.       return $original;

    866. 

  866.     }

    867. 

  867.   }

    868. 

  868.   if ($prefix == '#x') {

    869. 

  869. 	  $codepoint = base_convert($codepoint, 16, 10);

    870. 

  870.   } else {

    871. 

  871.     $codepoint = preg_replace('/^0+/', '', $codepoint);

    872. 

  872.   }

    873. 

  873.   if ($codepoint < 0x80) {

    874. 

  874.     $str = chr($codepoint);

    875. 

  875.   } else if ($codepoint < 0x800) {

    876. 

  876.     $str = chr(0xC0 | ($codepoint >> 6))

    877. 

  877.          . chr(0x80 | ($codepoint & 0x3F));

    878. 

  878.   } else if ($codepoint < 0x10000) {

    879. 

  879.     $str = chr(0xE0 | ( $codepoint >> 12))

    880. 

  880.          . chr(0x80 | (($codepoint >> 6) & 0x3F))

    881. 

  881.          . chr(0x80 | ( $codepoint       & 0x3F));

    882. 

  882.   } else if ($codepoint < 0x200000) {

    883. 

  883.     $str = chr(0xF0 | ( $codepoint >> 18))

    884. 

  884.          . chr(0x80 | (($codepoint >> 12) & 0x3F))

    885. 

  885.          . chr(0x80 | (($codepoint >> 6)  & 0x3F))

    886. 

  886.          . chr(0x80 | ( $codepoint        & 0x3F));

    887. 

  887.   }

    888. 

  888.   // Check for excluded characters

    889. 

  889.   if (in_array($str, $exclude)) {

    890. 

  890.     return $original;

    891. 

  891.   } else {

    892. 

  892.     return $str;

    893. 

  893.   }

    894. 

  894. }

    895. 

  895. 

    896. 

  896. function zina_sitemap_frequency($interval) {

    897. 

  897.   $frequencies = array(

    898. 

  898.     'always' => 3600,

    899. 

  899.     'hourly' => 86400,

    900. 

  900.     'daily' => 604800,

    901. 

  901.     'weekly' => 2419200,

    902. 

  902.     'monthly' => 29030400,

    903. 

  903.     'yearly' => 100000000,

    904. 

  904.     'never' => 0,

    905. 

  905.   );

    906. 

  906. 

    907. 

  907.   foreach ($frequencies as $frequency => $value)

    908. 

  908.     if ($interval <= $value || $frequency == 'never') break;

    909. 

  909. 

    910. 

  910.   return $frequency;

    911. 

  911. }

    912. 

  912. 

    913. 

  913. function zina_filter_html($text, $tags) {

    914. 

  914. 	global $zc;

    915. 

  915. 	$allowed_tags = preg_split('/\s+|<|>/', $tags, -1, PREG_SPLIT_NO_EMPTY);

    916. 

  916. 	$text = zina_filter_xss($text, $allowed_tags);

    917. 

  917. 	return trim($text);

    918. 

  918. }

    919. 

  919. 

    920. 

  920. function zina_filter_xss($string, $allowed_tags) {

    921. 

  921.  if (!zvalidate_utf8($string)) return '';

    922. 

  922.  

    923. 

  923.   // Store the input format

    924. 

  924.   zina_filter_xss_split($allowed_tags, TRUE);

    925. 

  925.   // Remove NUL characters (ignored by some browsers)

    926. 

  926.   $string = str_replace(chr(0), '', $string);

    927. 

  927.   // Remove Netscape 4 JS entities

    928. 

  928.   $string = preg_replace('%&\s*\{[^}]*(\}\s*;?|$)%', '', $string);

    929. 

  929. 

    930. 

  930.   // Defuse all HTML entities

    931. 

  931.   $string = str_replace('&', '&amp;', $string);

    932. 

  932.   // Change back only well-formed entities in our whitelist

    933. 

  933.   // Decimal numeric entities

    934. 

  934.   $string = preg_replace('/&amp;#([0-9]+;)/', '&#\1', $string);

    935. 

  935.   // Hexadecimal numeric entities

    936. 

  936.   $string = preg_replace('/&amp;#[Xx]0*((?:[0-9A-Fa-f]{2})+;)/', '&#x\1', $string);

    937. 

  937.   // Named entities

    938. 

  938.   $string = preg_replace('/&amp;([A-Za-z][A-Za-z0-9]*;)/', '&\1', $string);

    939. 

  939. 

    940. 

  940.   return preg_replace_callback('%(<(?=[^a-zA-Z!/])|<[^>]*(>|$)|>)%x', 'zina_filter_xss_split', $string);

    941. 

  941. }

    942. 

  942. 

    943. 

  943. function zina_filter_xss_split($m, $store = false) {

    944. 

  944.   static $allowed_html;

    945. 

  945. 

    946. 

  946.   if ($store) {

    947. 

  947.     $allowed_html = array_flip($m);

    948. 

  948.     return;

    949. 

  949.   }

    950. 

  950. 

    951. 

  951.   $string = $m[1];

    952. 

  952. 

    953. 

  953.   if (substr($string, 0, 1) != '<') {

    954. 

  954.     return '&gt;';

    955. 

  955.   } else if (strlen($string) == 1) {

    956. 

  956.     return '&lt;';

    957. 

  957.   }

    958. 

  958. 

    959. 

  959.   if (!preg_match('%^<\s*(/\s*)?([a-zA-Z0-9]+)([^>]*)>?$%', $string, $matches)) {

    960. 

  960.     // Seriously malformed

    961. 

  961.     return '';

    962. 

  962.   }

    963. 

  963. 

    964. 

  964.   $slash = trim($matches[1]);

    965. 

  965.   $elem = &$matches[2];

    966. 

  966.   $attrlist = &$matches[3];

    967. 

  967. 

    968. 

  968.   if (!isset($allowed_html[strtolower($elem)])) return '';

    969. 

  969. 

    970. 

  970.   if ($slash != '') return "</$elem>";

    971. 

  971. 

    972. 

  972.   // Is there a closing XHTML slash at the end of the attributes?

    973. 

  973.   // In PHP 5.1.0+ we could count the changes, currently we need a separate match

    974. 

  974.   $xhtml_slash = preg_match('%\s?/\s*$%', $attrlist) ? ' /' : '';

    975. 

  975.   $attrlist = preg_replace('%(\s?)/\s*$%', '\1', $attrlist);

    976. 

  976. 

    977. 

  977.   // Clean up attributes

    978. 

  978.   $attr2 = implode(' ', zina_filter_xss_attributes($attrlist));

    979. 

  979.   $attr2 = preg_replace('/[<>]/', '', $attr2);

    980. 

  980.   $attr2 = strlen($attr2) ? ' '. $attr2 : '';

    981. 

  981. 

    982. 

  982.   return "<$elem$attr2$xhtml_slash>";

    983. 

  983. }

    984. 

  984. 

    985. 

  985. function zina_filter_xss_attributes($attr) {

    986. 

  986.   $attrarr = array();

    987. 

  987.   $mode = 0;

    988. 

  988.   $attrname = '';

    989. 

  989. 

    990. 

  990.   while (strlen($attr) != 0) {

    991. 

  991.     // Was the last operation successful?

    992. 

  992.     $working = 0;

    993. 

  993. 

    994. 

  994.     switch ($mode) {

    995. 

  995.       case 0:

    996. 

  996.         // Attribute name, href for instance

    997. 

  997.         if (preg_match('/^([-a-zA-Z]+)/', $attr, $match)) {

    998. 

  998.           $attrname = strtolower($match[1]);

    999. 

  999.           $skip = ($attrname == 'style' || substr($attrname, 0, 2) == 'on');

    1000. 

  1000.           $working = $mode = 1;

    1001. 

  1001.           $attr = preg_replace('/^[-a-zA-Z]+/', '', $attr);

    1002. 

  1002.         }

    1003. 

  1003. 

    1004. 

  1004.         break;

    1005. 

  1005. 

    1006. 

  1006.       case 1:

    1007. 

  1007.         // Equals sign or valueless ("selected")

    1008. 

  1008.         if (preg_match('/^\s*=\s*/', $attr)) {

    1009. 

  1009.           $working = 1; $mode = 2;

    1010. 

  1010.           $attr = preg_replace('/^\s*=\s*/', '', $attr);

    1011. 

  1011.           break;

    1012. 

  1012.         }

    1013. 

  1013. 

    1014. 

  1014.         if (preg_match('/^\s+/', $attr)) {

    1015. 

  1015.           $working = 1; $mode = 0;

    1016. 

  1016.           if (!$skip) {

    1017. 

  1017.             $attrarr[] = $attrname;

    1018. 

  1018.           }

    1019. 

  1019.           $attr = preg_replace('/^\s+/', '', $attr);

    1020. 

  1020.         }

    1021. 

  1021. 

    1022. 

  1022.         break;

    1023. 

  1023. 

    1024. 

  1024.       case 2:

    1025. 

  1025.         // Attribute value, a URL after href= for instance

    1026. 

  1026.         if (preg_match('/^"([^"]*)"(\s+|$)/', $attr, $match)) {

    1027. 

  1027.           $thisval = zina_filter_xss_bad_protocol($match[1]);

    1028. 

  1028. 

    1029. 

  1029.           if (!$skip) {

    1030. 

  1030.             $attrarr[] = "$attrname=\"$thisval\"";

    1031. 

  1031.           }

    1032. 

  1032.           $working = 1;

    1033. 

  1033.           $mode = 0;

    1034. 

  1034.           $attr = preg_replace('/^"[^"]*"(\s+|$)/', '', $attr);

    1035. 

  1035.           break;

    1036. 

  1036.         }

    1037. 

  1037. 

    1038. 

  1038.         if (preg_match("/^'([^']*)'(\s+|$)/", $attr, $match)) {

    1039. 

  1039.           $thisval = zina_filter_xss_bad_protocol($match[1]);

    1040. 

  1040. 

    1041. 

  1041.           if (!$skip) {

    1042. 

  1042.             $attrarr[] = "$attrname='$thisval'";;

    1043. 

  1043.           }

    1044. 

  1044.           $working = 1; $mode = 0;

    1045. 

  1045.           $attr = preg_replace("/^'[^']*'(\s+|$)/", '', $attr);

    1046. 

  1046.           break;

    1047. 

  1047.         }

    1048. 

  1048. 

    1049. 

  1049.         if (preg_match("%^([^\s\"']+)(\s+|$)%", $attr, $match)) {

    1050. 

  1050.           $thisval = zina_filter_xss_bad_protocol($match[1]);

    1051. 

  1051. 

    1052. 

  1052.           if (!$skip) {

    1053. 

  1053.             $attrarr[] = "$attrname=\"$thisval\"";

    1054. 

  1054.           }

    1055. 

  1055.           $working = 1; $mode = 0;

    1056. 

  1056.           $attr = preg_replace("%^[^\s\"']+(\s+|$)%", '', $attr);

    1057. 

  1057.         }

    1058. 

  1058. 

    1059. 

  1059.         break;

    1060. 

  1060.     }

    1061. 

  1061. 

    1062. 

  1062.     if ($working == 0) {

    1063. 

  1063.       // not well formed, remove and try again

    1064. 

  1064.       $attr = preg_replace('/

    1065. 

  1065.         ^

    1066. 

  1066.         (

    1067. 

  1067.         "[^"]*("|$)     # - a string that starts with a double quote, up until the next double quote or the end of the string

    1068. 

  1068.         |               # or

    1069. 

  1069.         \'[^\']*(\'|$)| # - a string that starts with a quote, up until the next quote or the end of the string

    1070. 

  1070.         |               # or

    1071. 

  1071.         \S              # - a non-whitespace character

    1072. 

  1072.         )*              # any number of the above three

    1073. 

  1073.         \s*             # any number of whitespaces

    1074. 

  1074.         /x', '', $attr);

    1075. 

  1075.       $mode = 0;

    1076. 

  1076.     }

    1077. 

  1077.   }

    1078. 

  1078. 

    1079. 

  1079.   // the attribute list ends with a valueless attribute like "selected"

    1080. 

  1080.   if ($mode == 1) {

    1081. 

  1081.     $attrarr[] = $attrname;

    1082. 

  1082.   }

    1083. 

  1083.   return $attrarr;

    1084. 

  1084. }

    1085. 

  1085. 

    1086. 

  1086. function zina_filter_xss_bad_protocol($string, $decode = TRUE) {

    1087. 

  1087.   static $allowed_protocols;

    1088. 

  1088.   if (!isset($allowed_protocols)) {

    1089. 

  1089.     $allowed_protocols = array_flip(array('http', 'https', 'ftp', 'mailto', '{internal'));

    1090. 

  1090.   }

    1091. 

  1091. 

    1092. 

  1092.   // Get the plain text representation of the attribute value (i.e. its meaning).

    1093. 

  1093.   if ($decode) $string = zdecode_entities($string);

    1094. 

  1094. 

    1095. 

  1095.   // Iteratively remove any invalid protocol found.

    1096. 

  1096. 

    1097. 

  1097.   do {

    1098. 

  1098.     $before = $string;

    1099. 

  1099.     $colonpos = strpos($string, ':');

    1100. 

  1100.     if ($colonpos > 0) {

    1101. 

  1101.       // We found a colon, possibly a protocol. Verify.

    1102. 

  1102.       $protocol = substr($string, 0, $colonpos);

    1103. 

  1103.       // If a colon is preceded by a slash, question mark or hash, it cannot

    1104. 

  1104.       // possibly be part of the URL scheme. This must be a relative URL,

    1105. 

  1105.       // which inherits the (safe) protocol of the base document.

    1106. 

  1106.       if (preg_match('![/?#]!', $protocol)) {

    1107. 

  1107.         break;

    1108. 

  1108.       }

    1109. 

  1109.       // Per RFC2616, section 3.2.3 (URI Comparison) scheme comparison must be case-insensitive

    1110. 

  1110.       // Check if this is a disallowed protocol.

    1111. 

  1111.       if (!isset($allowed_protocols[strtolower($protocol)])) {

    1112. 

  1112.         $string = substr($string, $colonpos + 1);

    1113. 

  1113.       }

    1114. 

  1114.     }

    1115. 

  1115.   } while ($before != $string);

    1116. 

  1116.   return zcheck_plain($string);

    1117. 

  1117. }

    1118. 

  1118. 

    1119. 

  1119. function zdbg($x, $exit = false, $phpinfo = false) {

    1120. 

  1120. 	echo '<pre>';

    1121. 

  1121. 	print_r($x);

    1122. 

  1122. 	echo '</pre>'."\n";

    1123. 

  1123. 	if ($phpinfo) phpinfo(32);

    1124. 

  1124. 	if ($exit) exit;

    1125. 

  1125. }

    1126. 

  1126. ?>

    1127. 

  1127.