/**

*

* @package phpBB3

* @version $Id: functions.php 9153 2008-12-02 17:02:56Z acydburn $

* @copyright (c) 2005 phpBB Group

* @license http://opensource.org/licenses/gpl-license.php GNU Public License

*

*/

/**

* @ignore

*/

if (!defined('IN_PHPBB'))

{

	exit;

}

// Common global functions

/**

* set_var

*

* Set variable, used by {@link request_var the request_var function}

*

* @access private

*/

function set_var(&$result, $var, $type, $multibyte = false)

{

	settype($var, $type);

	$result = $var;

	if ($type == 'string')

	{

		$result = trim(htmlspecialchars(str_replace(array("\r\n", "\r", "\0"), array("\n", "\n", ''), $result), ENT_COMPAT, 'UTF-8'));

		if (!empty($result))

		{

			// Make sure multibyte characters are wellformed

			if ($multibyte)

			{

				if (!preg_match('/^./u', $result))

				{

					$result = '';

				}

			}

			else

			{

				// no multibyte, allow only ASCII (0-127)

				$result = preg_replace('/[\x80-\xFF]/', '?', $result);

			}

		}

		$result = (STRIP) ? stripslashes($result) : $result;

	}

}

/**

* request_var

*

* Used to get passed variable

*/

function request_var($var_name, $default, $multibyte = false, $cookie = false)

{

	if (!$cookie && isset($_COOKIE[$var_name]))

	{

		if (!isset($_GET[$var_name]) && !isset($_POST[$var_name]))

		{

			return (is_array($default)) ? array() : $default;

		}

		$_REQUEST[$var_name] = isset($_POST[$var_name]) ? $_POST[$var_name] : $_GET[$var_name];

	}

	if (!isset($_REQUEST[$var_name]) || (is_array($_REQUEST[$var_name]) && !is_array($default)) || (is_array($default) && !is_array($_REQUEST[$var_name])))

	{

		return (is_array($default)) ? array() : $default;

	}

	$var = $_REQUEST[$var_name];

	if (!is_array($default))

	{

		$type = gettype($default);

	}

	else

	{

		list($key_type, $type) = each($default);

		$type = gettype($type);

		$key_type = gettype($key_type);

		if ($type == 'array')

		{

			reset($default);

			$default = current($default);

			list($sub_key_type, $sub_type) = each($default);

			$sub_type = gettype($sub_type);

			$sub_type = ($sub_type == 'array') ? 'NULL' : $sub_type;

			$sub_key_type = gettype($sub_key_type);

		}

	}

	if (is_array($var))

	{

		$_var = $var;

		$var = array();

		foreach ($_var as $k => $v)

		{

			set_var($k, $k, $key_type);

			if ($type == 'array' && is_array($v))

			{

				foreach ($v as $_k => $_v)

				{

					if (is_array($_v))

					{

						$_v = null;

					}

					set_var($_k, $_k, $sub_key_type);

					set_var($var[$k][$_k], $_v, $sub_type, $multibyte);

				}

			}

			else

			{

				if ($type == 'array' || is_array($v))

				{

					$v = null;

				}

				set_var($var[$k], $v, $type, $multibyte);

			}

		}

	}

	else

	{

		set_var($var, $var, $type, $multibyte);

	}

	return $var;

}

/**

* Set config value. Creates missing config entry.

*/

function set_config($config_name, $config_value, $is_dynamic = false)

{

	global $db, $cache, $config;

	$sql = 'UPDATE ' . CONFIG_TABLE . "

		SET config_value = '" . $db->sql_escape($config_value) . "'

		WHERE config_name = '" . $db->sql_escape($config_name) . "'";

	$db->sql_query($sql);

	if (!$db->sql_affectedrows() && !isset($config[$config_name]))

	{

		$sql = 'INSERT INTO ' . CONFIG_TABLE . ' ' . $db->sql_build_array('INSERT', array(

			'config_name'	=> $config_name,

			'config_value'	=> $config_value,

			'is_dynamic'	=> ($is_dynamic) ? 1 : 0));

		$db->sql_query($sql);

	}

	$config[$config_name] = $config_value;

	if (!$is_dynamic)

	{

		$cache->destroy('config');

	}

}

/**

* Generates an alphanumeric random string of given length

*/

function gen_rand_string($num_chars = 8)

{

	$rand_str = unique_id();

	$rand_str = str_replace('0', 'Z', strtoupper(base_convert($rand_str, 16, 35)));

	return substr($rand_str, 0, $num_chars);

}

/**

* Return unique id

* @param string $extra additional entropy

*/

function unique_id($extra = 'c')

{

	static $dss_seeded = false;

	global $config;

	$val = $config['rand_seed'] . microtime();

	$val = md5($val);

	$config['rand_seed'] = md5($config['rand_seed'] . $val . $extra);

	if ($dss_seeded !== true && ($config['rand_seed_last_update'] < time() - rand(1,10)))

	{

		set_config('rand_seed', $config['rand_seed'], true);

		set_config('rand_seed_last_update', time(), true);

		$dss_seeded = true;

	}

	return substr($val, 4, 16);

}

/**

* Return formatted string for filesizes

*/

function get_formatted_filesize($bytes, $add_size_lang = true)

{

	global $user;

	if ($bytes >= pow(2, 20))

	{

		return ($add_size_lang) ? round($bytes / 1024 / 1024, 2) . ' ' . $user->lang['MIB'] : round($bytes / 1024 / 1024, 2);

	}

	if ($bytes >= pow(2, 10))

	{

		return ($add_size_lang) ? round($bytes / 1024, 2) . ' ' . $user->lang['KIB'] : round($bytes / 1024, 2);

	}

	return ($add_size_lang) ? ($bytes) . ' ' . $user->lang['BYTES'] : ($bytes);

}

/**

* Determine whether we are approaching the maximum execution time. Should be called once

* at the beginning of the script in which it's used.

* @return	bool	Either true if the maximum execution time is nearly reached, or false

*					if some time is still left.

*/

function still_on_time($extra_time = 15)

{

	static $max_execution_time, $start_time;

	$time = explode(' ', microtime());

	$current_time = $time[0] + $time[1];

	if (empty($max_execution_time))

	{

		$max_execution_time = (function_exists('ini_get')) ? (int) @ini_get('max_execution_time') : (int) @get_cfg_var('max_execution_time');

		// If zero, then set to something higher to not let the user catch the ten seconds barrier.

		if ($max_execution_time === 0)

		{

			$max_execution_time = 50 + $extra_time;

		}

		$max_execution_time = min(max(10, ($max_execution_time - $extra_time)), 50);

		// For debugging purposes

		// $max_execution_time = 10;

		global $starttime;

		$start_time = (empty($starttime)) ? $current_time : $starttime;

	}

	return (ceil($current_time - $start_time) < $max_execution_time) ? true : false;

}

/**

*

* @version Version 0.1 / slightly modified for phpBB 3.0.x (using $H$ as hash type identifier)

*

* Portable PHP password hashing framework.

*

* Written by Solar Designer <solar at openwall.com> in 2004-2006 and placed in

* the public domain.

*

* There's absolutely no warranty.

*

* The homepage URL for this framework is:

*

*	http://www.openwall.com/phpass/

*

* Please be sure to update the Version line if you edit this file in any way.

* It is suggested that you leave the main version number intact, but indicate

* your project name (after the slash) and add your own revision information.

*

* Please do not change the "private" password hashing method implemented in

* here, thereby making your hashes incompatible.  However, if you must, please

* change the hash type identifier (the "$P$") to something different.

*

* Obviously, since this code is in the public domain, the above are not

* requirements (there can be none), but merely suggestions.

*

*

* Hash the password

*/

function phpbb_hash($password)

{

	$itoa64 = './0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';

	$random_state = unique_id();

	$random = '';

	$count = 6;

	if (($fh = @fopen('/dev/urandom', 'rb')))

	{

		$random = fread($fh, $count);

		fclose($fh);

	}

	if (strlen($random) < $count)

	{

		$random = '';

		for ($i = 0; $i < $count; $i += 16)

		{

			$random_state = md5(unique_id() . $random_state);

			$random .= pack('H*', md5($random_state));

		}

		$random = substr($random, 0, $count);

	}

	$hash = _hash_crypt_private($password, _hash_gensalt_private($random, $itoa64), $itoa64);

	if (strlen($hash) == 34)

	{

		return $hash;

	}

	return md5($password);

}

/**

* Check for correct password

*

* @param string $password The password in plain text

* @param string $hash The stored password hash

*

* @return bool Returns true if the password is correct, false if not.

*/

function phpbb_check_hash($password, $hash)

{

	$itoa64 = './0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';

	if (strlen($hash) == 34)

	{

		return (_hash_crypt_private($password, $hash, $itoa64) === $hash) ? true : false;

	}

	return (md5($password) === $hash) ? true : false;

}

/**

* Generate salt for hash generation

*/

function _hash_gensalt_private($input, &$itoa64, $iteration_count_log2 = 6)

{

	if ($iteration_count_log2 < 4 || $iteration_count_log2 > 31)

	{

		$iteration_count_log2 = 8;

	}

	$output = '$H$';

	$output .= $itoa64[min($iteration_count_log2 + ((PHP_VERSION >= 5) ? 5 : 3), 30)];

	$output .= _hash_encode64($input, 6, $itoa64);

	return $output;

}

/**

* Encode hash

*/

function _hash_encode64($input, $count, &$itoa64)

{

	$output = '';

	$i = 0;

	do

	{

		$value = ord($input[$i++]);

		$output .= $itoa64[$value & 0x3f];

		if ($i < $count)

		{

			$value |= ord($input[$i]) << 8;

		}

		$output .= $itoa64[($value >> 6) & 0x3f];

		if ($i++ >= $count)

		{

			break;

		}

		if ($i < $count)

		{

			$value |= ord($input[$i]) << 16;

		}

		$output .= $itoa64[($value >> 12) & 0x3f];

		if ($i++ >= $count)

		{

			break;

		}

		$output .= $itoa64[($value >> 18) & 0x3f];

	}

	while ($i < $count);

	return $output;

}

/**

* The crypt function/replacement

*/

function _hash_crypt_private($password, $setting, &$itoa64)

{

	$output = '*';

	// Check for correct hash

	if (substr($setting, 0, 3) != '$H$')

	{

		return $output;

	}

	$count_log2 = strpos($itoa64, $setting[3]);

	if ($count_log2 < 7 || $count_log2 > 30)

	{

		return $output;

	}

	$count = 1 << $count_log2;

	$salt = substr($setting, 4, 8);

	if (strlen($salt) != 8)

	{

		return $output;

	}

	/**

	* We're kind of forced to use MD5 here since it's the only

	* cryptographic primitive available in all versions of PHP

	* currently in use.  To implement our own low-level crypto

	* in PHP would result in much worse performance and

	* consequently in lower iteration counts and hashes that are

	* quicker to crack (by non-PHP code).

	*/

	if (PHP_VERSION >= 5)

	{

		$hash = md5($salt . $password, true);

		do

		{

			$hash = md5($hash . $password, true);

		}

		while (--$count);

	}

	else

	{

		$hash = pack('H*', md5($salt . $password));

		do

		{

			$hash = pack('H*', md5($hash . $password));

		}

		while (--$count);

	}

	$output = substr($setting, 0, 12);

	$output .= _hash_encode64($hash, 16, $itoa64);

	return $output;

}

/**

* Global function for chmodding directories and files for internal use

* This function determines owner and group whom the file belongs to and user and group of PHP and then set safest possible file permissions.

* The function determines owner and group from common.php file and sets the same to the provided file. Permissions are mapped to the group, user always has rw(x) permission.

* The function uses bit fields to build the permissions.

* The function sets the appropiate execute bit on directories.

*

* Supported constants representing bit fields are:

*

* CHMOD_ALL - all permissions (7)

* CHMOD_READ - read permission (4)

* CHMOD_WRITE - write permission (2)

* CHMOD_EXECUTE - execute permission (1)

*

* NOTE: The function uses POSIX extension and fileowner()/filegroup() functions. If any of them is disabled, this function tries to build proper permissions, by calling is_readable() and is_writable() functions.

*

* @param $filename The file/directory to be chmodded

* @param $perms Permissions to set

* @return true on success, otherwise false

*

* @author faw, phpBB Group

*/

function phpbb_chmod($filename, $perms = CHMOD_READ)

{

	// Return if the file no longer exists.

	if (!file_exists($filename))

	{

		return false;

	}

	if (!function_exists('fileowner') || !function_exists('filegroup'))

	{

		$file_uid = $file_gid = false;

		$common_php_owner = $common_php_group = false;

	}

	else

	{

		global $phpbb_root_path, $phpEx;

		// Determine owner/group of common.php file and the filename we want to change here

		$common_php_owner = fileowner($phpbb_root_path . 'common.' . $phpEx);

		$common_php_group = filegroup($phpbb_root_path . 'common.' . $phpEx);

		$file_uid = fileowner($filename);

		$file_gid = filegroup($filename);

		// Try to set the owner to the same common.php has

		if ($common_php_owner !== $file_uid && $common_php_owner !== false && $file_uid !== false)

		{

			// Will most likely not work

			if (@chown($filename, $common_php_owner));

			{

				clearstatcache();

				$file_uid = fileowner($filename);

			}

		}

		// Try to set the group to the same common.php has

		if ($common_php_group !== $file_gid && $common_php_group !== false && $file_gid !== false)

		{

			if (@chgrp($filename, $common_php_group));

			{

				clearstatcache();

				$file_gid = filegroup($filename);

			}

		}

	}

	// And the owner and the groups PHP is running under.

	$php_uid = (function_exists('posix_getuid')) ? @posix_getuid() : false;

	$php_gids = (function_exists('posix_getgroups')) ? @posix_getgroups() : false;

	// Who is PHP?

	if ($file_uid === false || $file_gid === false || $php_uid === false || $php_gids === false)

	{

		$php = NULL;

	}

	else if ($file_uid == $php_uid /* && $common_php_owner !== false && $common_php_owner === $file_uid*/)

	{

		$php = 'owner';

	}

	else if (in_array($file_gid, $php_gids))

	{

		$php = 'group';

	}

	else

	{

		$php = 'other';

	}

	// Owner always has read/write permission

	$owner = CHMOD_READ | CHMOD_WRITE;

	if (is_dir($filename))

	{

		$owner |= CHMOD_EXECUTE;

		// Only add execute bit to the permission if the dir needs to be readable

		if ($perms & CHMOD_READ)

		{

			$perms |= CHMOD_EXECUTE;

		}

	}

	switch ($php)

	{

		case null:

		case 'owner':

			/* ATTENTION: if php is owner or NULL we set it to group here. This is the most failsafe combination for the vast majority of server setups.

			$result = @chmod($filename, ($owner << 6) + (0 << 3) + (0 << 0));

			clearstatcache();

			if (!is_null($php) || (is_readable($filename) && is_writable($filename)))

			{

				break;

			}

		*/

		case 'group':

			$result = @chmod($filename, ($owner << 6) + ($perms << 3) + (0 << 0));

			clearstatcache();

			if (!is_null($php) || ((!($perms & CHMOD_READ) || is_readable($filename)) && (!($perms & CHMOD_WRITE) || is_writable($filename))))

			{

				break;

			}

		case 'other':

			$result = @chmod($filename, ($owner << 6) + ($perms << 3) + ($perms << 0));

			clearstatcache();

			if (!is_null($php) || ((!($perms & CHMOD_READ) || is_readable($filename)) && (!($perms & CHMOD_WRITE) || is_writable($filename))))

			{

				break;

			}

		default:

			return false;

		break;

	}

	return $result;

}

// Compatibility functions

if (!function_exists('array_combine'))

{

	/**

	* A wrapper for the PHP5 function array_combine()

	* @param array $keys contains keys for the resulting array

	* @param array $values contains values for the resulting array

	*

	* @return Returns an array by using the values from the keys array as keys and the

	* 	values from the values array as the corresponding values. Returns false if the

	* 	number of elements for each array isn't equal or if the arrays are empty.

	*/

	function array_combine($keys, $values)

	{

		$keys = array_values($keys);

		$values = array_values($values);

		$n = sizeof($keys);

		$m = sizeof($values);

		if (!$n || !$m || ($n != $m))

		{

			return false;

		}

		$combined = array();

		for ($i = 0; $i < $n; $i++)

		{

			$combined[$keys[$i]] = $values[$i];

		}

		return $combined;

	}

}

if (!function_exists('str_split'))

{

	/**

	* A wrapper for the PHP5 function str_split()

	* @param array $string contains the string to be converted

	* @param array $split_length contains the length of each chunk

	*

	* @return  Converts a string to an array. If the optional split_length parameter is specified,

	*  	the returned array will be broken down into chunks with each being split_length in length,

	*  	otherwise each chunk will be one character in length. FALSE is returned if split_length is

	*  	less than 1. If the split_length length exceeds the length of string, the entire string is

	*  	returned as the first (and only) array element.

	*/

	function str_split($string, $split_length = 1)

	{

		if ($split_length < 1)

		{

			return false;

		}

		else if ($split_length >= strlen($string))

		{

			return array($string);

		}

		else

		{

			preg_match_all('#.{1,' . $split_length . '}#s', $string, $matches);

			return $matches[0];

		}

	}

}

if (!function_exists('stripos'))

{

	/**

	* A wrapper for the PHP5 function stripos

	* Find position of first occurrence of a case-insensitive string

	*

	* @param string $haystack is the string to search in

	* @param string $needle is the string to search for

	*

	* @return mixed Returns the numeric position of the first occurrence of needle in the haystack string. Unlike strpos(), stripos() is case-insensitive.

	* Note that the needle may be a string of one or more characters.

	* If needle is not found, stripos() will return boolean FALSE.

	*/

	function stripos($haystack, $needle)

	{

		if (preg_match('#' . preg_quote($needle, '#') . '#i', $haystack, $m))

		{

			return strpos($haystack, $m[0]);

		}

		return false;

	}

}

/**

* Checks if a path ($path) is absolute or relative

*

* @param string $path Path to check absoluteness of

* @return boolean

*/

function is_absolute($path)

{

	return ($path[0] == '/' || (DIRECTORY_SEPARATOR == '\\' && preg_match('#^[a-z]:/#i', $path))) ? true : false;

}

/**

* @author Chris Smith <chris@project-minerva.org>

* @copyright 2006 Project Minerva Team

* @param string $path The path which we should attempt to resolve.

* @return mixed

*/

function phpbb_own_realpath($path)

{

	// Now to perform funky shizzle

	// Switch to use UNIX slashes