{

// no need for dependency injection here, if you have the object, call the method yourself!

$type_cast_helper = new phpbb_request_type_cast_helper();

$type_cast_helper->set_var($result, $var, $type, $multibyte);

{

// This is all just an ugly hack to add "Dependency Injection" to a function

// the only real code is the function call which maps this function to a method.

static $static_request = null;

if ($request instanceof phpbb_request_interface)

{

$static_request = $request;

if (empty($var_name))

{

return;

}

}

else if ($request === false)

{

$static_request = null;

if (empty($var_name))

{

return;

}

}

$tmp_request = $static_request;

// no request class set, create a temporary one ourselves to keep backwards compatability

if ($tmp_request === null)

{

// false param: enable super globals, so the created request class does not

// make super globals inaccessible everywhere outside this function.

$tmp_request = new phpbb_request(new phpbb_request_type_cast_helper(), false);

}

return $tmp_request->variable($var_name, $default, $multibyte, ($cookie) ? phpbb_request_interface::COOKIE : phpbb_request_interface::REQUEST);

{

static $config = null;

if ($set_config !== null)

{

$config = $set_config;

if (empty($config_name))

{

return;

}

}

$config->set($config_name, $config_value, !$is_dynamic);

{

static $config = null;

if ($set_config !== null)

{

$config = $set_config;

if (empty($config_name))

{

return;

}

}

$config->increment($config_name, $increment, !$is_dynamic);

{

// [a, z] + [0, 9] = 36

return substr(strtoupper(base_convert(unique_id(), 16, 36)), 0, $num_chars);

{

$rand_str = unique_id();

// Remove Z and Y from the base_convert(), replace 0 with Z and O with Y

// [a, z] + [0, 9] - {z, y} = [a, z] + [0, 9] - {0, o} = 34

$rand_str = str_replace(array('0', 'O'), array('Z', 'Y'), strtoupper(base_convert($rand_str, 16, 34)));

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

{

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_last_update', time(), true);

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

$dss_seeded = true;

}

return substr($val, 4, 16);

{

if ($time === false)

{

$time = time();

}

// getdate() interprets timestamps in local time.

// What follows uses the fact that getdate() and

// date('Z') balance each other out.

return getdate($time - date('Z'));

{

global $user;

$available_units = array(

'gb' => array(

'min' => 1073741824, // pow(2, 30)

'index' => 3,

'si_unit' => 'GB',

'iec_unit' => 'GIB',

),

'mb' => array(

'min' => 1048576, // pow(2, 20)

'index' => 2,

'si_unit' => 'MB',

'iec_unit' => 'MIB',

),

'kb' => array(

'min' => 1024, // pow(2, 10)

'index' => 1,

'si_unit' => 'KB',

'iec_unit' => 'KIB',

),

'b' => array(

'min' => 0,

'index' => 0,

'si_unit' => 'BYTES', // Language index

'iec_unit' => 'BYTES', // Language index

),

);

foreach ($available_units as $si_identifier => $unit_info)

{

if (!empty($allowed_units) && $si_identifier != 'b' && !in_array($si_identifier, $allowed_units))

{

continue;

}

if ($value >= $unit_info['min'])

{

$unit_info['si_identifier'] = $si_identifier;

break;

}

}

unset($available_units);

for ($i = 0; $i < $unit_info['index']; $i++)

{

$value /= 1024;

}

$value = round($value, 2);

// Lookup units in language dictionary

$unit_info['si_unit'] = (isset($user->lang[$unit_info['si_unit']])) ? $user->lang[$unit_info['si_unit']] : $unit_info['si_unit'];

$unit_info['iec_unit'] = (isset($user->lang[$unit_info['iec_unit']])) ? $user->lang[$unit_info['iec_unit']] : $unit_info['iec_unit'];

// Default to IEC

$unit_info['unit'] = $unit_info['iec_unit'];

if (!$string_only)

{

$unit_info['value'] = $value;

return $unit_info;

}

return $value . ' ' . $unit_info['unit'];

{

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;

{

$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);

{

$itoa64 = './0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';

if (strlen($hash) == 34)

{

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

}

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

{

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

{

$iteration_count_log2 = 8;

}

$output = '$H$';

$output .= $itoa64[min($iteration_count_log2 + 5, 30)];

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

return $output;

{

$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;

{

$output = '*';

// Check for correct hash

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

{

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;

}

/**

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

do

{

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

}

while (--$count);

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

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

return $output;

{

$version1 = strtolower($version1);

$version2 = strtolower($version2);

if (is_null($operator))

{

return version_compare($version1, $version2);

}

else

{

return version_compare($version1, $version2, $operator);

}

{

static $_chmod_info;

// Return if the file no longer exists.

if (!file_exists($filename))

{

return false;

}

// Determine some common vars

if (empty($_chmod_info))

{

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

{

// No need to further determine owner/group - it is unknown

$_chmod_info['process'] = 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);

// 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;

// If we are unable to get owner/group, then do not try to set them by guessing

if (!$php_uid || empty($php_gids) || !$common_php_owner || !$common_php_group)

{

$_chmod_info['process'] = false;

}

else

{

$_chmod_info = array(

'process' => true,

'common_owner' => $common_php_owner,

'common_group' => $common_php_group,

'php_uid' => $php_uid,

'php_gids' => $php_gids,

);

}

}

}

if ($_chmod_info['process'])

{

$file_uid = @fileowner($filename);

$file_gid = @filegroup($filename);

// Change owner

if (@chown($filename, $_chmod_info['common_owner']))

{

clearstatcache();

$file_uid = @fileowner($filename);

}

// Change group

if (@chgrp($filename, $_chmod_info['common_group']))

{

clearstatcache();

$file_gid = @filegroup($filename);

}

// If the file_uid/gid now match the one from common.php we can process further, else we are not able to change something

if ($file_uid != $_chmod_info['common_owner'] || $file_gid != $_chmod_info['common_group'])

{

$_chmod_info['process'] = false;

}

}

// Still able to process?

if ($_chmod_info['process'])

{

if ($file_uid == $_chmod_info['php_uid'])

{

$php = 'owner';

}

else if (in_array($file_gid, $_chmod_info['php_gids']))

{

$php = 'group';

}

else

{

// Since we are setting the everyone bit anyway, no need to do expensive operations

$_chmod_info['process'] = false;

}

}

// We are not able to determine or change something

if (!$_chmod_info['process'])

{

$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 'owner':

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

clearstatcache();

if (is_readable($filename) && phpbb_is_writable($filename))

{

break;

}

case 'group':

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

clearstatcache();

if ((!($perms & CHMOD_READ) || is_readable($filename)) && (!($perms & CHMOD_WRITE) || phpbb_is_writable($filename)))

{

break;

}

case 'other':

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

clearstatcache();

if ((!($perms & CHMOD_READ) || is_readable($filename)) && (!($perms & CHMOD_WRITE) || phpbb_is_writable($filename)))

{

break;

}

default:

return false;

break;

}

return $result;

{

if (strtolower(substr(PHP_OS, 0, 3)) === 'win' || !function_exists('is_writable'))

{

if (file_exists($file))

{

// Canonicalise path to absolute path

$file = phpbb_realpath($file);

if (is_dir($file))

{

// Test directory by creating a file inside the directory

$result = @tempnam($file, 'i_w');

if (is_string($result) && file_exists($result))

{

unlink($result);

// Ensure the file is actually in the directory (returned realpathed)

return (strpos($result, $file) === 0) ? true : false;

}

}

else

{

$handle = @fopen($file, 'r+');

if (is_resource($handle))

{

fclose($handle);

return true;

}

}

}

else

{

// file does not exist test if we can write to the directory

$dir = dirname($file);

if (file_exists($dir) && is_dir($dir) && phpbb_is_writable($dir))

{

return true;

}

}

return false;

}

else

{

return is_writable($file);

}

{

global $request;

// Now to perform funky shizzle

// Switch to use UNIX slashes

$path = str_replace(DIRECTORY_SEPARATOR, '/', $path);

$path_prefix = '';

// Determine what sort of path we have

if (phpbb_is_absolute($path))

{

$absolute = true;

if ($path[0] == '/')

{

// Absolute path, *NIX style

$path_prefix = '';

}

else

{

// Absolute path, Windows style

// Remove the drive letter and colon

$path_prefix = $path[0] . ':';

$path = substr($path, 2);

}

}

else

{

// Relative Path

// Prepend the current working directory

if (function_exists('getcwd'))

{

// This is the best method, hopefully it is enabled!

$path = str_replace(DIRECTORY_SEPARATOR, '/', getcwd()) . '/' . $path;

$absolute = true;

if (preg_match('#^[a-z]:#i', $path))

{

$path_prefix = $path[0] . ':';

$path = substr($path, 2);

}

else

{

$path_prefix = '';

}

}

else if ($request->server('SCRIPT_FILENAME'))

{

// Warning: If chdir() has been used this will lie!

// Warning: This has some problems sometime (CLI can create them easily)

$filename = htmlspecialchars_decode($request->server('SCRIPT_FILENAME'));

$path = str_replace(DIRECTORY_SEPARATOR, '/', dirname($filename)) . '/' . $path;

$absolute = true;

$path_prefix = '';

}

else

{

// We have no way of getting the absolute path, just run on using relative ones.

$absolute = false;

$path_prefix = '.';

}

}

// Remove any repeated slashes

$path = preg_replace('#/{2,}#', '/', $path);

// Remove the slashes from the start and end of the path

$path = trim($path, '/');

// Break the string into little bits for us to nibble on

$bits = explode('/', $path);

// Remove any . in the path, renumber array for the loop below

$bits = array_values(array_diff($bits, array('.')));

// Lets get looping, run over and resolve any .. (up directory)

for ($i = 0, $max = sizeof($bits); $i < $max; $i++)

{

// @todo Optimise

if ($bits[$i] == '..' )

{

if (isset($bits[$i - 1]))

{

if ($bits[$i - 1] != '..')

{

// We found a .. and we are able to traverse upwards, lets do it!

unset($bits[$i]);

unset($bits[$i - 1]);

$i -= 2;

$max -= 2;

$bits = array_values($bits);

}

}

else if ($absolute) // ie. !isset($bits[$i - 1]) && $absolute

{

// We have an absolute path trying to descend above the root of the filesystem

// ... Error!

return false;

}

}

}

// Prepend the path prefix

array_unshift($bits, $path_prefix);

$resolved = '';

$max = sizeof($bits) - 1;

// Check if we are able to resolve symlinks, Windows cannot.

$symlink_resolve = (function_exists('readlink')) ? true : false;

foreach ($bits as $i => $bit)

{

if (@is_dir("$resolved/$bit") || ($i == $max && @is_file("$resolved/$bit")))

{

// Path Exists

if ($symlink_resolve && is_link("$resolved/$bit") && ($link = readlink("$resolved/$bit")))

{

// Resolved a symlink.

$resolved = $link . (($i == $max) ? '' : '/');

continue;

}

}

else

{

// Something doesn't exist here!

// This is correct realpath() behaviour but sadly open_basedir and safe_mode make this problematic

// return false;

}

$resolved .= $bit . (($i == $max) ? '' : '/');

}

// @todo If the file exists fine and open_basedir only has one path we should be able to prepend it

// because we must be inside that basedir, the question is where...

// @internal The slash in is_dir() gets around an open_basedir restriction

if (!@file_exists($resolved) || (!@is_dir($resolved . '/') && !is_file($resolved)))

{

return false;

}

// Put the slashes back to the native operating systems slashes

$resolved = str_replace('/', DIRECTORY_SEPARATOR, $resolved);

// Check for DIRECTORY_SEPARATOR at the end (and remove it!)

if (substr($resolved, -1) == DIRECTORY_SEPARATOR)

{

return substr($resolved, 0, -1);

}

return $resolved; // We got here, in the end!