libraries/classes/VersionInformation.php

   1 <?php
   2 /* vim: set expandtab sw=4 ts=4 sts=4: */
   3 /**
   4  * Responsible for retrieving version information and notifiying about latest version
   5  *
   6  * @package PhpMyAdmin
   7  */
   8 declare(strict_types=1);
   9
  10 namespace PhpMyAdmin;
  11
  12 use PhpMyAdmin\Utils\HttpRequest;
  13 use \stdClass;
  14
  15 /**
  16  * Responsible for retrieving version information and notifiying about latest version
  17  *
  18  * @package PhpMyAdmin
  19  *
  20  */
  21 class VersionInformation
  22 {
  23     /**
  24      * Returns information with latest version from phpmyadmin.net
  25      *
  26      * @return stdClass|null JSON decoded object with the data
  27      */
  28     public function getLatestVersion(): ?stdClass
  29     {
  30         if (! $GLOBALS['cfg']['VersionCheck']) {
  31             return null;
  32         }
  33
  34         // Get response text from phpmyadmin.net or from the session
  35         // Update cache every 6 hours
  36         if (isset($_SESSION['cache']['version_check'])
  37             && time() < $_SESSION['cache']['version_check']['timestamp'] + 3600 * 6
  38         ) {
  39             $save = false;
  40             $response = $_SESSION['cache']['version_check']['response'];
  41         } else {
  42             $save = true;
  43             $file = 'https://www.phpmyadmin.net/home_page/version.json';
  44             $httpRequest = new HttpRequest();
  45             $response = $httpRequest->create($file, 'GET');
  46         }
  47         $response = $response ?: '{}';
  48         /* Parse response */
  49         $data = json_decode($response);
  50
  51         /* Basic sanity checking */
  52         if (! is_object($data)
  53             || empty($data->version)
  54             || empty($data->releases)
  55             || empty($data->date)
  56         ) {
  57             return null;
  58         }
  59
  60         if ($save) {
  61             $_SESSION['cache']['version_check'] = [
  62                 'response' => $response,
  63                 'timestamp' => time(),
  64             ];
  65         }
  66         return $data;
  67     }
  68
  69     /**
  70      * Calculates numerical equivalent of phpMyAdmin version string
  71      *
  72      * @param string $version version
  73      *
  74      * @return mixed false on failure, integer on success
  75      */
  76     public function versionToInt($version)
  77     {
  78         $parts = explode('-', $version);
  79         if (count($parts) > 1) {
  80             $suffix = $parts[1];
  81         } else {
  82             $suffix = '';
  83         }
  84         $parts = explode('.', $parts[0]);
  85
  86         $result = 0;
  87
  88         if (count($parts) >= 1 && is_numeric($parts[0])) {
  89             $result += 1000000 * (int) $parts[0];
  90         }
  91
  92         if (count($parts) >= 2 && is_numeric($parts[1])) {
  93             $result += 10000 * (int) $parts[1];
  94         }
  95
  96         if (count($parts) >= 3 && is_numeric($parts[2])) {
  97             $result += 100 * (int) $parts[2];
  98         }
  99
 100         if (count($parts) >= 4 && is_numeric($parts[3])) {
 101             $result += 1 * (int) $parts[3];
 102         }
 103
 104         if (! empty($suffix)) {
 105             $matches = [];
 106             if (preg_match('/^(\D+)(\d+)$/', $suffix, $matches)) {
 107                 $suffix = $matches[1];
 108                 $result += intval($matches[2]);
 109             }
 110             switch ($suffix) {
 111                 case 'pl':
 112                     $result += 60;
 113                     break;
 114                 case 'rc':
 115                     $result += 30;
 116                     break;
 117                 case 'beta':
 118                     $result += 20;
 119                     break;
 120                 case 'alpha':
 121                     $result += 10;
 122                     break;
 123                 case 'dev':
 124                     $result += 0;
 125                     break;
 126             }
 127         } else {
 128             $result += 50; // for final
 129         }
 130
 131         return $result;
 132     }
 133
 134     /**
 135      * Returns the version and date of the latest phpMyAdmin version compatible
 136      * with the available PHP and MySQL versions
 137      *
 138      * @param array $releases array of information related to each version
 139      *
 140      * @return array|null containing the version and date of latest compatible version
 141      */
 142     public function getLatestCompatibleVersion(array $releases)
 143     {
 144         foreach ($releases as $release) {
 145             $phpVersions = $release->php_versions;
 146             $phpConditions = explode(",", $phpVersions);
 147             foreach ($phpConditions as $phpCondition) {
 148                 if (! $this->evaluateVersionCondition('PHP', $phpCondition)) {
 149                     continue 2;
 150                 }
 151             }
 152
 153             // We evalute MySQL version constraint if there are only
 154             // one server configured.
 155             if (count($GLOBALS['cfg']['Servers']) === 1) {
 156                 $mysqlVersions = $release->mysql_versions;
 157                 $mysqlConditions = explode(",", $mysqlVersions);
 158                 foreach ($mysqlConditions as $mysqlCondition) {
 159                     if (! $this->evaluateVersionCondition('MySQL', $mysqlCondition)) {
 160                         continue 2;
 161                     }
 162                 }
 163             }
 164
 165             return [
 166                 'version' => $release->version,
 167                 'date' => $release->date,
 168             ];
 169         }
 170
 171         // no compatible version
 172         return null;
 173     }
 174
 175     /**
 176      * Checks whether PHP or MySQL version meets supplied version condition
 177      *
 178      * @param string $type      PHP or MySQL
 179      * @param string $condition version condition
 180      *
 181      * @return boolean whether the condition is met
 182      */
 183     public function evaluateVersionCondition(string $type, string $condition)
 184     {
 185         $operator = null;
 186         $version = null;
 187         $operators = [
 188             "<=",
 189             ">=",
 190             "!=",
 191             "<>",
 192             "<",
 193             ">",
 194             "=",
 195         ]; // preserve order
 196         foreach ($operators as $oneOperator) {
 197             if (strpos($condition, $oneOperator) === 0) {
 198                 $operator = $oneOperator;
 199                 $version = substr($condition, strlen($oneOperator));
 200                 break;
 201             }
 202         }
 203
 204         $myVersion = null;
 205         if ($type == 'PHP') {
 206             $myVersion = $this->getPHPVersion();
 207         } elseif ($type == 'MySQL') {
 208             $myVersion = $this->getMySQLVersion();
 209         }
 210
 211         if ($myVersion !== null && $operator !== null) {
 212             return version_compare($myVersion, $version, $operator);
 213         }
 214         return false;
 215     }
 216
 217     /**
 218      * Returns the PHP version
 219      *
 220      * @return string PHP version
 221      */
 222     protected function getPHPVersion()
 223     {
 224         return PHP_VERSION;
 225     }
 226
 227     /**
 228      * Returns the MySQL version if connected to a database
 229      *
 230      * @return string|null MySQL version
 231      */
 232     protected function getMySQLVersion()
 233     {
 234         if (isset($GLOBALS['dbi'])) {
 235             return $GLOBALS['dbi']->getVersionString();
 236         }
 237         return null;
 238     }
 239 }