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