Code Coverage |
||||||||||
Classes and Traits |
Functions and Methods |
Lines |
||||||||
| Total | |
0.00% |
0 / 1 |
|
61.54% |
8 / 13 |
CRAP | |
93.13% |
122 / 131 |
| version_helper | |
0.00% |
0 / 1 |
|
61.54% |
8 / 13 |
66.37 | |
93.13% |
122 / 131 |
| __construct | |
0.00% |
0 / 1 |
2.01 | |
85.71% |
6 / 7 |
|||
| set_file_location | |
100.00% |
1 / 1 |
1 | |
100.00% |
5 / 5 |
|||
| set_current_version | |
100.00% |
1 / 1 |
1 | |
100.00% |
2 / 2 |
|||
| force_stability | |
100.00% |
1 / 1 |
1 | |
100.00% |
2 / 2 |
|||
| compare | |
100.00% |
1 / 1 |
1 | |
100.00% |
1 / 1 |
|||
| is_stable | |
100.00% |
1 / 1 |
2 | |
100.00% |
5 / 5 |
|||
| get_latest_on_current_branch | |
100.00% |
1 / 1 |
3 | |
100.00% |
9 / 9 |
|||
| get_update_on_branch | |
100.00% |
1 / 1 |
8 | |
100.00% |
12 / 12 |
|||
| get_ext_update_on_branch | |
0.00% |
0 / 1 |
9.01 | |
94.74% |
18 / 19 |
|||
| get_suggested_updates | |
100.00% |
1 / 1 |
1 | |
100.00% |
5 / 5 |
|||
| get_versions_matching_stability | |
0.00% |
0 / 1 |
4.25 | |
75.00% |
3 / 4 |
|||
| get_versions | |
0.00% |
0 / 1 |
12.11 | |
90.91% |
20 / 22 |
|||
| validate_versions | |
0.00% |
0 / 1 |
20.47 | |
89.47% |
34 / 38 |
|||
| <?php | |
| /** | |
| * | |
| * This file is part of the phpBB Forum Software package. | |
| * | |
| * @copyright (c) phpBB Limited <https://www.phpbb.com> | |
| * @license GNU General Public License, version 2 (GPL-2.0) | |
| * | |
| * For full copyright and license information, please see | |
| * the docs/CREDITS.txt file. | |
| * | |
| */ | |
| namespace phpbb; | |
| use phpbb\exception\version_check_exception; | |
| /** | |
| * Class to handle version checking and comparison | |
| */ | |
| class version_helper | |
| { | |
| /** | |
| * @var string Host | |
| */ | |
| protected $host = 'version.phpbb.com'; | |
| /** | |
| * @var string Path to file | |
| */ | |
| protected $path = '/phpbb'; | |
| /** | |
| * @var string File name | |
| */ | |
| protected $file = 'versions.json'; | |
| /** | |
| * @var bool Use SSL or not | |
| */ | |
| protected $use_ssl = false; | |
| /** | |
| * @var string Current version installed | |
| */ | |
| protected $current_version; | |
| /** | |
| * @var null|string Null to not force stability, 'unstable' or 'stable' to | |
| * force the corresponding stability | |
| */ | |
| protected $force_stability; | |
| /** @var \phpbb\cache\service */ | |
| protected $cache; | |
| /** @var \phpbb\config\config */ | |
| protected $config; | |
| /** @var \phpbb\file_downloader */ | |
| protected $file_downloader; | |
| protected $version_schema = array( | |
| 'stable' => array( | |
| 'current' => 'version', | |
| 'download' => 'url', | |
| 'announcement' => 'url', | |
| 'eol' => 'url', | |
| 'security' => 'bool', | |
| ), | |
| 'unstable' => array( | |
| 'current' => 'version', | |
| 'download' => 'url', | |
| 'announcement' => 'url', | |
| 'eol' => 'url', | |
| 'security' => 'bool', | |
| ), | |
| ); | |
| /** | |
| * Constructor | |
| * | |
| * @param \phpbb\cache\service $cache | |
| * @param \phpbb\config\config $config | |
| * @param \phpbb\file_downloader $file_downloader | |
| */ | |
| public function __construct(\phpbb\cache\service $cache, \phpbb\config\config $config, \phpbb\file_downloader $file_downloader) | |
| { | |
| $this->cache = $cache; | |
| $this->config = $config; | |
| $this->file_downloader = $file_downloader; | |
| if (defined('PHPBB_QA')) | |
| { | |
| $this->force_stability = 'unstable'; | |
| } | |
| $this->current_version = $this->config['version']; | |
| } | |
| /** | |
| * Set location to the file | |
| * | |
| * @param string $host Host (e.g. version.phpbb.com) | |
| * @param string $path Path to file (e.g. /phpbb) | |
| * @param string $file File name (Default: versions.json) | |
| * @param bool $use_ssl Use SSL or not (Default: false) | |
| * @return version_helper | |
| */ | |
| public function set_file_location($host, $path, $file = 'versions.json', $use_ssl = false) | |
| { | |
| $this->host = $host; | |
| $this->path = $path; | |
| $this->file = $file; | |
| $this->use_ssl = $use_ssl; | |
| return $this; | |
| } | |
| /** | |
| * Set current version | |
| * | |
| * @param string $version The current version | |
| * @return version_helper | |
| */ | |
| public function set_current_version($version) | |
| { | |
| $this->current_version = $version; | |
| return $this; | |
| } | |
| /** | |
| * Over-ride the stability to force check to include unstable versions | |
| * | |
| * @param null|string $stability Null to not force stability, 'unstable' or 'stable' to | |
| * force the corresponding stability | |
| * @return version_helper | |
| */ | |
| public function force_stability($stability) | |
| { | |
| $this->force_stability = $stability; | |
| return $this; | |
| } | |
| /** | |
| * 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. | |
| */ | |
| public function compare($version1, $version2, $operator = null) | |
| { | |
| return phpbb_version_compare($version1, $version2, $operator); | |
| } | |
| /** | |
| * Check whether or not a version is "stable" | |
| * | |
| * Stable means only numbers OR a pl release | |
| * | |
| * @param string $version | |
| * @return bool Bool true or false | |
| */ | |
| public function is_stable($version) | |
| { | |
| $matches = false; | |
| preg_match('/^[\d\.]+/', $version, $matches); | |
| if (empty($matches[0])) | |
| { | |
| return false; | |
| } | |
| return $this->compare($version, $matches[0], '>='); | |
| } | |
| /** | |
| * Gets the latest version for the current branch the user is on | |
| * | |
| * @param bool $force_update Ignores cached data. Defaults to false. | |
| * @param bool $force_cache Force the use of the cache. Override $force_update. | |
| * @return string | |
| * @throws version_check_exception | |
| */ | |
| public function get_latest_on_current_branch($force_update = false, $force_cache = false) | |
| { | |
| $versions = $this->get_versions_matching_stability($force_update, $force_cache); | |
| $self = $this; | |
| $current_version = $this->current_version; | |
| // Filter out any versions less than the current version | |
| $versions = array_filter($versions, function($data) use ($self, $current_version) { | |
| return $self->compare($data['current'], $current_version, '>='); | |
| }); | |
| // Get the lowest version from the previous list. | |
| return array_reduce($versions, function($value, $data) use ($self) { | |
| if ($value === null || $self->compare($data['current'], $value, '<')) | |
| { | |
| return $data['current']; | |
| } | |
| return $value; | |
| }); | |
| } | |
| /** | |
| * Gets the latest update for the current branch the user is on | |
| * Will suggest versions from newer branches when EoL has been reached | |
| * and/or version from newer branch is needed for having all known security | |
| * issues fixed. | |
| * | |
| * @param bool $force_update Ignores cached data. Defaults to false. | |
| * @param bool $force_cache Force the use of the cache. Override $force_update. | |
| * @return array Version info or empty array if there are no updates | |
| * @throws \RuntimeException | |
| */ | |
| public function get_update_on_branch($force_update = false, $force_cache = false) | |
| { | |
| $versions = $this->get_versions_matching_stability($force_update, $force_cache); | |
| $self = $this; | |
| $current_version = $this->current_version; | |
| // Filter out any versions less than the current version | |
| $versions = array_filter($versions, function($data) use ($self, $current_version) { | |
| return $self->compare($data['current'], $current_version, '>='); | |
| }); | |
| // Get the lowest version from the previous list. | |
| $update_info = array_reduce($versions, function($value, $data) use ($self, $current_version) { | |
| if ($value === null && $self->compare($data['current'], $current_version, '>=')) | |
| { | |
| if (!$data['eol'] && (!$data['security'] || $self->compare($data['security'], $data['current'], '<='))) | |
| { | |
| return ($self->compare($data['current'], $current_version, '>')) ? $data : array(); | |
| } | |
| else | |
| { | |
| return null; | |
| } | |
| } | |
| return $value; | |
| }); | |
| return $update_info === null ? array() : $update_info; | |
| } | |
| /** | |
| * Gets the latest extension update for the current phpBB branch the user is on | |
| * Will suggest versions from newer branches when EoL has been reached | |
| * and/or version from newer branch is needed for having all known security | |
| * issues fixed. | |
| * | |
| * @param bool $force_update Ignores cached data. Defaults to false. | |
| * @param bool $force_cache Force the use of the cache. Override $force_update. | |
| * @return array Version info or empty array if there are no updates | |
| * @throws \RuntimeException | |
| */ | |
| public function get_ext_update_on_branch($force_update = false, $force_cache = false) | |
| { | |
| $versions = $this->get_versions_matching_stability($force_update, $force_cache); | |
| $self = $this; | |
| $current_version = $this->current_version; | |
| // Get current phpBB branch from version, e.g.: 3.2 | |
| preg_match('/^(\d+\.\d+).*$/', $this->config['version'], $matches); | |
| $current_branch = $matches[1]; | |
| // Filter out any versions less than the current version | |
| $versions = array_filter($versions, function($data) use ($self, $current_version) { | |
| return $self->compare($data['current'], $current_version, '>='); | |
| }); | |
| // Filter out any phpbb branches less than the current version | |
| $branches = array_filter(array_keys($versions), function($branch) use ($self, $current_branch) { | |
| return $self->compare($branch, $current_branch, '>='); | |
| }); | |
| if (!empty($branches)) | |
| { | |
| $versions = array_intersect_key($versions, array_flip($branches)); | |
| } | |
| else | |
| { | |
| // If branches are empty, it means the current phpBB branch is newer than any branch the | |
| // extension was validated against. Reverse sort the versions array so we get the newest | |
| // validated release available. | |
| krsort($versions); | |
| } | |
| // Get the first available version from the previous list. | |
| $update_info = array_reduce($versions, function($value, $data) use ($self, $current_version) { | |
| if ($value === null && $self->compare($data['current'], $current_version, '>=')) | |
| { | |
| if (!$data['eol'] && (!$data['security'] || $self->compare($data['security'], $data['current'], '<='))) | |
| { | |
| return $self->compare($data['current'], $current_version, '>') ? $data : array(); | |
| } | |
| else | |
| { | |
| return null; | |
| } | |
| } | |
| return $value; | |
| }); | |
| return $update_info === null ? array() : $update_info; | |
| } | |
| /** | |
| * Obtains the latest version information | |
| * | |
| * @param bool $force_update Ignores cached data. Defaults to false. | |
| * @param bool $force_cache Force the use of the cache. Override $force_update. | |
| * @return array | |
| * @throws version_check_exception | |
| */ | |
| public function get_suggested_updates($force_update = false, $force_cache = false) | |
| { | |
| $versions = $this->get_versions_matching_stability($force_update, $force_cache); | |
| $self = $this; | |
| $current_version = $this->current_version; | |
| // Filter out any versions less than or equal to the current version | |
| return array_filter($versions, function($data) use ($self, $current_version) { | |
| return $self->compare($data['current'], $current_version, '>'); | |
| }); | |
| } | |
| /** | |
| * Obtains the latest version information matching the stability of the current install | |
| * | |
| * @param bool $force_update Ignores cached data. Defaults to false. | |
| * @param bool $force_cache Force the use of the cache. Override $force_update. | |
| * @return array Version info | |
| * @throws version_check_exception | |
| */ | |
| public function get_versions_matching_stability($force_update = false, $force_cache = false) | |
| { | |
| $info = $this->get_versions($force_update, $force_cache); | |
| if ($this->force_stability !== null) | |
| { | |
| return ($this->force_stability === 'unstable') ? $info['unstable'] : $info['stable']; | |
| } | |
| return ($this->is_stable($this->current_version)) ? $info['stable'] : $info['unstable']; | |
| } | |
| /** | |
| * Obtains the latest version information | |
| * | |
| * @param bool $force_update Ignores cached data. Defaults to false. | |
| * @param bool $force_cache Force the use of the cache. Override $force_update. | |
| * @return array Version info, includes stable and unstable data | |
| * @throws version_check_exception | |
| */ | |
| public function get_versions($force_update = false, $force_cache = false) | |
| { | |
| $cache_file = '_versioncheck_' . $this->host . $this->path . $this->file . $this->use_ssl; | |
| $info = $this->cache->get($cache_file); | |
| if ($info === false && $force_cache) | |
| { | |
| throw new version_check_exception('VERSIONCHECK_FAIL'); | |
| } | |
| else if ($info === false || $force_update) | |
| { | |
| $info = $this->file_downloader->get($this->host, $this->path, $this->file, $this->use_ssl ? 443 : 80, 30); | |
| $error_string = $this->file_downloader->get_error_string(); | |
| if (!empty($error_string)) | |
| { | |
| throw new version_check_exception($error_string); | |
| } | |
| $info = json_decode($info, true); | |
| // Sanitize any data we retrieve from a server | |
| if (!empty($info)) | |
| { | |
| $json_sanitizer = function (&$value, $key) { | |
| $type_cast_helper = new \phpbb\request\type_cast_helper(); | |
| $type_cast_helper->set_var($value, $value, gettype($value), true); | |
| }; | |
| array_walk_recursive($info, $json_sanitizer); | |
| } | |
| if (empty($info['stable']) && empty($info['unstable'])) | |
| { | |
| throw new version_check_exception('VERSIONCHECK_FAIL'); | |
| } | |
| $info['stable'] = (empty($info['stable'])) ? array() : $info['stable']; | |
| $info['unstable'] = (empty($info['unstable'])) ? $info['stable'] : $info['unstable']; | |
| $info = $this->validate_versions($info); | |
| $this->cache->put($cache_file, $info, 86400); // 24 hours | |
| } | |
| return $info; | |
| } | |
| /** | |
| * Validate versions info input | |
| * | |
| * @param array $versions_info Decoded json data array. Will be modified | |
| * and cleaned by this method | |
| * | |
| * @return array Versions info array | |
| * @throws version_check_exception | |
| */ | |
| public function validate_versions($versions_info) | |
| { | |
| $array_diff = array_diff_key($versions_info, array($this->version_schema)); | |
| // Remove excessive data | |
| if (count($array_diff) > 0) | |
| { | |
| $old_versions_info = $versions_info; | |
| $versions_info = array( | |
| 'stable' => !empty($old_versions_info['stable']) ? $old_versions_info['stable'] : array(), | |
| 'unstable' => !empty($old_versions_info['unstable']) ? $old_versions_info['unstable'] : array(), | |
| ); | |
| unset($old_versions_info); | |
| } | |
| foreach ($versions_info as $stability_type => &$versions_data) | |
| { | |
| foreach ($versions_data as $branch => &$version_data) | |
| { | |
| if (!preg_match('/^[0-9a-z\-\.]+$/i', $branch)) | |
| { | |
| unset($versions_data[$branch]); | |
| continue; | |
| } | |
| $stability_diff = array_diff_key($version_data, $this->version_schema[$stability_type]); | |
| if (count($stability_diff) > 0) | |
| { | |
| $old_version_data = $version_data; | |
| $version_data = array(); | |
| foreach ($this->version_schema[$stability_type] as $key => $value) | |
| { | |
| if (isset($old_version_data[$key])) | |
| { | |
| $version_data[$key] = $old_version_data[$key]; | |
| } | |
| } | |
| unset($old_version_data); | |
| } | |
| foreach ($version_data as $key => &$value) | |
| { | |
| if (!isset($this->version_schema[$stability_type][$key])) | |
| { | |
| unset($version_data[$key]); | |
| throw new version_check_exception('VERSIONCHECK_INVALID_ENTRY'); | |
| } | |
| switch ($this->version_schema[$stability_type][$key]) | |
| { | |
| case 'bool': | |
| $value = (bool) $value; | |
| break; | |
| case 'url': | |
| if (!empty($value) && !preg_match('#^' . get_preg_expression('url') . '$#iu', $value) && | |
| !preg_match('#^' . get_preg_expression('www_url') . '$#iu', $value)) | |
| { | |
| throw new version_check_exception('VERSIONCHECK_INVALID_URL'); | |
| } | |
| break; | |
| case 'version': | |
| if (!empty($value) && !preg_match(get_preg_expression('semantic_version'), $value)) | |
| { | |
| throw new version_check_exception('VERSIONCHECK_INVALID_VERSION'); | |
| } | |
| break; | |
| default: | |
| // Shouldn't be possible to trigger this | |
| throw new version_check_exception('VERSIONCHECK_INVALID_ENTRY'); | |
| } | |
| } | |
| } | |
| } | |
| return $versions_info; | |
| } | |
| } |