Code Forge

<?php

/**

*

* @package phpBB3

* @copyright (c) 2005 phpBB Group

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

*

*/

/**

* @ignore

*/

if (!defined('IN_PHPBB'))

{

        exit;

}

// Common global functions

/**

* Casts a variable to the given type.

*

* @deprecated

*/

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

{

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

}

/**

* Wrapper function of phpbb_request::variable which exists for backwards compatability.

* See {@link phpbb_request_interface::variable phpbb_request_interface::variable} for

* documentation of this function's use.

*

* @deprecated

* @param        mixed                        $var_name        The form variable's name from which data shall be retrieved.

*                                                                                 If the value is an array this may be an array of indizes which will give

*                                                                                 direct access to a value at any depth. E.g. if the value of "var" is array(1 => "a")

*                                                                                 then specifying array("var", 1) as the name will return "a".

*                                                                                 If you pass an instance of {@link phpbb_request_interface phpbb_request_interface}

*                                                                                 as this parameter it will overwrite the current request class instance. If you do

*                                                                                 not do so, it will create its own instance (but leave superglobals enabled).

* @param        mixed                        $default        A default value that is returned if the variable was not set.

*                                                                                 This function will always return a value of the same type as the default.

* @param        bool                        $multibyte        If $default is a string this paramater has to be true if the variable may contain any UTF-8 characters

*                                                                                Default is false, causing all bytes outside the ASCII range (0-127) to be replaced with question marks

* @param        bool                        $cookie                This param is mapped to phpbb_request_interface::COOKIE as the last param for

*                                                                                 phpbb_request_interface::variable for backwards compatability reasons.

* @param        phpbb_request_interface|null|false        If an instance of phpbb_request_interface is given the instance is stored in

*                                                                                a static variable and used for all further calls where this parameters is null. Until

*                                                                                the function is called with an instance it automatically creates a new phpbb_request

*                                                                                instance on every call. By passing false this per-call instantiation can be restored

*                                                                                after having passed in a phpbb_request_interface instance.

*

* @return        mixed        The value of $_REQUEST[$var_name] run through {@link set_var set_var} to ensure that the type is the

*                                         the same as that of $default. If the variable is not set $default is returned.

*/

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

{

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

}

/**

* Set config value. Creates missing config entry.

*

* @deprecated

*/

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

{

        static $config = null;

        if ($set_config !== null)

        {

                $config = $set_config;

                if (empty($config_name))

                {

                        return;

                }

        }

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

}

/**

* Set dynamic config value with arithmetic operation.

*

* @deprecated

*/

function set_config_count($config_name, $increment, $is_dynamic = false, phpbb_config $set_config = null)

{

        static $config = null;

        if ($set_config !== null)

        {

                $config = $set_config;

                if (empty($config_name))

                {

                        return;

                }

        }

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

}

/**

* Generates an alphanumeric random string of given length

*

* @return string

*/

function gen_rand_string($num_chars = 8)

{

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

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

}

/**

* Generates a user-friendly alphanumeric random string of given length

* We remove 0 and O so users cannot confuse those in passwords etc.

*

* @return string

*/

function gen_rand_string_friendly($num_chars = 8)

{

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

}

/**

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

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

                $dss_seeded = true;

        }

        return substr($val, 4, 16);

}

/**

* Wrapper for mt_rand() which allows swapping $min and $max parameters.

*

* PHP does not allow us to swap the order of the arguments for mt_rand() anymore.

* (since PHP 5.3.4, see http://bugs.php.net/46587)

*

* @param int $min                Lowest value to be returned

* @param int $max                Highest value to be returned

*

* @return int                        Random integer between $min and $max (or $max and $min)

*/

function phpbb_mt_rand($min, $max)

{

        return ($min > $max) ? mt_rand($max, $min) : mt_rand($min, $max);

}

/**

* Wrapper for getdate() which returns the equivalent array for UTC timestamps.

*

* @param int $time                Unix timestamp (optional)

*

* @return array                        Returns an associative array of information related to the timestamp.

*                                                See http://www.php.net/manual/en/function.getdate.php

*/

function phpbb_gmgetdate($time = false)

{

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

}

/**

* Return formatted string for filesizes

*

* @param int        $value                        filesize in bytes

* @param bool        $string_only        true if language string should be returned

* @param array        $allowed_units        only allow these units (data array indexes)

*

* @return mixed                                        data array if $string_only is false

* @author bantu

*/

function get_formatted_filesize($value, $string_only = true, $allowed_units = false)

{

        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'];

}

/**

* 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 + 5, 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$' && 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;

        }

        /**

        * 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).

        */

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

}

/**

* Hashes an email address to a big integer

*

* @param string $email                Email address

*

* @return string                        Unsigned Big Integer

*/

function phpbb_email_hash($email)

{

        return sprintf('%u', crc32(strtolower($email))) . strlen($email);

}

/**

* Wrapper for version_compare() that allows using uppercase A and B

* for alpha and beta releases.

*

* See http://www.php.net/manual/en/function.version-compare.php

*

* @param string $version1                First version number

* @param string $version2                Second version number

* @param string $operator                Comparison operator (optional)

*

* @return mixed                                        Boolean (true, false) if comparison operator is specified.

*                                                                Integer (-1, 0, 1) otherwise.

*/

function phpbb_version_compare($version1, $version2, $operator = null)

{

        $version1 = strtolower($version1);

        $version2 = strtolower($version2);

        if (is_null($operator))

        {

                return version_compare($version1, $version2);

        }

        else

        {

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

        }

}

/**

* 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.

* 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 string        $filename        The file/directory to be chmodded

* @param int        $perms                Permissions to set

*

* @return bool        true on success, otherwise false

* @author faw, phpBB Group

*/

function phpbb_chmod($filename, $perms = CHMOD_READ)

{

        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;

}

/**

* Test if a file/directory is writable

*

* This function calls the native is_writable() when not running under

* Windows and it is not disabled.

*

* @param string $file Path to perform write test on

* @return bool True when the path is writable, otherwise false.

*/

function phpbb_is_writable($file)

{

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

        }

}

/**

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

*

* @param string $path Path to check absoluteness of

* @return boolean

*/