phpmyadmin/libraries/VersionInformation.php

   1 <?php
   2 /* vim: set expandtab sw=4 ts=4 sts=4: */
   3 /**
   4  * Responsile for retrieving version information and notifiying about latest version
   5  *
   6  * @package PhpMyAdmin
   7  */
   8 if (! defined('PHPMYADMIN')) {
   9     exit;
  10 }
  11
  12 /**
  13  * Responsile for retrieving version information and notifiying about latest version
  14  *
  15  * @package PhpMyAdmin
  16  *
  17  */
  18 class VersionInformation
  19 {
  20     /**
  21      * Returns information with latest version from phpmyadmin.net
  22      *
  23      * @return object JSON decoded object with the data
  24      */
  25     public function getLatestVersion()
  26     {
  27         if (!$GLOBALS['cfg']['VersionCheck']) {
  28             return null;
  29         }
  30
  31         // wait 3s at most for server response, it's enough to get information
  32         // from a working server
  33         $connection_timeout = 3;
  34
  35         $response = '{}';
  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             if (ini_get('allow_url_fopen')) {
  47                 $context = array(
  48                     'http' => array(
  49                         'request_fulluri' => true,
  50                         'timeout' => $connection_timeout,
  51                     )
  52                 );
  53                 $context = PMA_Util::handleContext($context);
  54                 if (! defined('TESTSUITE')) {
  55                     session_write_close();
  56                 }
  57                 $response = file_get_contents(
  58                     $file,
  59                     false,
  60                     stream_context_create($context)
  61                 );
  62             } else if (function_exists('curl_init')) {
  63                 $curl_handle = curl_init($file);
  64                 if ($curl_handle === false) {
  65                     return null;
  66                 }
  67                 $curl_handle = PMA_Util::configureCurl($curl_handle);
  68                 curl_setopt(
  69                     $curl_handle,
  70                     CURLOPT_HEADER,
  71                     false
  72                 );
  73                 curl_setopt(
  74                     $curl_handle,
  75                     CURLOPT_RETURNTRANSFER,
  76                     true
  77                 );
  78                 curl_setopt(
  79                     $curl_handle,
  80                     CURLOPT_TIMEOUT,
  81                     $connection_timeout
  82                 );
  83                 if (! defined('TESTSUITE')) {
  84                     session_write_close();
  85                 }
  86                 $response = curl_exec($curl_handle);
  87             }
  88         }
  89
  90         $data = json_decode($response);
  91         if (is_object($data)
  92             && ! empty($data->version)
  93             && ! empty($data->date)
  94             && $save
  95         ) {
  96             if (! isset($_SESSION) && ! defined('TESTSUITE')) {
  97                 ini_set('session.use_only_cookies', 'false');
  98                 ini_set('session.use_cookies', 'false');
  99                 ini_set('session.use_trans_sid', 'false');
 100                 ini_set('session.cache_limiter', 'nocache');
 101                 session_start();
 102             }
 103             $_SESSION['cache']['version_check'] = array(
 104                 'response' => $response,
 105                 'timestamp' => time()
 106             );
 107         }
 108         return $data;
 109     }
 110
 111     /**
 112      * Calculates numerical equivalent of phpMyAdmin version string
 113      *
 114      * @param string $version version
 115      *
 116      * @return mixed false on failure, integer on success
 117      */
 118     public function versionToInt($version)
 119     {
 120         $parts = explode('-', $version);
 121         if (count($parts) > 1) {
 122             $suffix = $parts[1];
 123         } else {
 124             $suffix = '';
 125         }
 126         $parts = explode('.', $parts[0]);
 127
 128         $result = 0;
 129
 130         if (count($parts) >= 1 && is_numeric($parts[0])) {
 131             $result += 1000000 * $parts[0];
 132         }
 133
 134         if (count($parts) >= 2 && is_numeric($parts[1])) {
 135             $result += 10000 * $parts[1];
 136         }
 137
 138         if (count($parts) >= 3 && is_numeric($parts[2])) {
 139             $result += 100 * $parts[2];
 140         }
 141
 142         if (count($parts) >= 4 && is_numeric($parts[3])) {
 143             $result += 1 * $parts[3];
 144         }
 145
 146         if (!empty($suffix)) {
 147             $matches = array();
 148             if (preg_match('/^(\D+)(\d+)$/', $suffix, $matches)) {
 149                 $suffix = $matches[1];
 150                 $result += intval($matches[2]);
 151             }
 152             switch ($suffix) {
 153             case 'pl':
 154                 $result += 60;
 155                 break;
 156             case 'rc':
 157                 $result += 30;
 158                 break;
 159             case 'beta':
 160                 $result += 20;
 161                 break;
 162             case 'alpha':
 163                 $result += 10;
 164                 break;
 165             case 'dev':
 166                 $result += 0;
 167                 break;
 168             }
 169         } else {
 170             $result += 50; // for final
 171         }
 172
 173         return $result;
 174     }
 175
 176     /**
 177      * Returns the version and date of the latest phpMyAdmin version compatible
 178      * with avilable PHP and MySQL versions
 179      *
 180      * @param array $releases array of information related to each version
 181      *
 182      * @return array containing the version and date of latest compatibel version
 183      */
 184     public function getLatestCompatibleVersion($releases)
 185     {
 186         foreach ($releases as $release) {
 187             $phpVersions = $release->php_versions;
 188             $phpConditions = explode(",", $phpVersions);
 189             foreach ($phpConditions as $phpCondition) {
 190                 if (! $this->evaluateVersionCondition("PHP", $phpCondition)) {
 191                     continue 2;
 192                 }
 193             }
 194
 195             // We evalute MySQL version constraint if there are only
 196             // one server configured.
 197             if (count($GLOBALS['cfg']['Servers']) == 1) {
 198                 $mysqlVersions = $release->mysql_versions;
 199                 $mysqlConditions = explode(",", $mysqlVersions);
 200                 foreach ($mysqlConditions as $mysqlCondition) {
 201                     if (! $this->evaluateVersionCondition('MySQL', $mysqlCondition)) {
 202                         continue 2;
 203                     }
 204                 }
 205             }
 206
 207             return array(
 208                 'version' => $release->version,
 209                 'date' => $release->date,
 210             );
 211         }
 212
 213         // no compatible version
 214         return null;
 215     }
 216
 217     /**
 218      * Checks whether PHP or MySQL version meets supplied version condition
 219      *
 220      * @param string $type      PHP or MySQL
 221      * @param string $condition version condition
 222      *
 223      * @return boolean whether the condition is met
 224      */
 225     public function evaluateVersionCondition($type, $condition)
 226     {
 227         $operator = null;
 228         $operators = array("<=", ">=", "!=", "<>", "<", ">", "="); // preserve order
 229         foreach ($operators as $oneOperator) {
 230             if (strpos($condition, $oneOperator) === 0) {
 231                 $operator = $oneOperator;
 232                 $version = substr($condition, strlen($oneOperator));
 233                 break;
 234             }
 235         }
 236
 237         $myVersion = null;
 238         if ($type == 'PHP') {
 239             $myVersion = $this->getPHPVersion();
 240         } elseif ($type == 'MySQL') {
 241             $myVersion = $this->getMySQLVersion();
 242         }
 243
 244         if ($myVersion != null && $operator != null) {
 245             return version_compare($myVersion, $version, $operator);
 246         }
 247         return false;
 248     }
 249
 250     /**
 251      * Returns the PHP version
 252      *
 253      * @return string PHP version
 254      */
 255     protected function getPHPVersion()
 256     {
 257         return PHP_VERSION;
 258     }
 259
 260     /**
 261      * Returns the MySQL version
 262      *
 263      * @return string MySQL version
 264      */
 265     protected function getMySQLVersion()
 266     {
 267         return PMA_Util::cacheGet('PMA_MYSQL_STR_VERSION');
 268     }
 269 }
 270 ?>