libraries/Config.class.php

   1 <?php
   2 /* vim: set expandtab sw=4 ts=4 sts=4: */
   3 /**
   4  * Configuration handling.
   5  *
   6  * @package PhpMyAdmin
   7  */
   8
   9 /**
  10  * Load vendor configuration.
  11  */
  12 require './libraries/vendor_config.php';
  13
  14 /**
  15  * Configuration class
  16  *
  17  * @package PhpMyAdmin
  18  */
  19 class PMA_Config
  20 {
  21     /**
  22      * @var string  default config source
  23      */
  24     var $default_source = './libraries/config.default.php';
  25
  26     /**
  27      * @var array   default configuration settings
  28      */
  29     var $default = array();
  30
  31     /**
  32      * @var array   configuration settings
  33      */
  34     var $settings = array();
  35
  36     /**
  37      * @var string  config source
  38      */
  39     var $source = '';
  40
  41     /**
  42      * @var int     source modification time
  43      */
  44     var $source_mtime = 0;
  45     var $default_source_mtime = 0;
  46     var $set_mtime = 0;
  47
  48     /**
  49      * @var boolean
  50      */
  51     var $error_config_file = false;
  52
  53     /**
  54      * @var boolean
  55      */
  56     var $error_config_default_file = false;
  57
  58     /**
  59      * @var boolean
  60      */
  61     var $error_pma_uri = false;
  62
  63     /**
  64      * @var array
  65      */
  66     var $default_server = array();
  67
  68     /**
  69      * @var boolean whether init is done or not
  70      * set this to false to force some initial checks
  71      * like checking for required functions
  72      */
  73     var $done = false;
  74
  75     /**
  76      * constructor
  77      *
  78      * @param string $source source to read config from
  79      */
  80     function __construct($source = null)
  81     {
  82         $this->settings = array();
  83
  84         // functions need to refresh in case of config file changed goes in
  85         // PMA_Config::load()
  86         $this->load($source);
  87
  88         // other settings, independent from config file, comes in
  89         $this->checkSystem();
  90
  91         $this->checkIsHttps();
  92     }
  93
  94     /**
  95      * sets system and application settings
  96      *
  97      * @return nothing
  98      */
  99     function checkSystem()
 100     {
 101         $this->set('PMA_VERSION', '3.5.0-rc1');
 102         /**
 103          * @deprecated
 104          */
 105         $this->set('PMA_THEME_VERSION', 2);
 106         /**
 107          * @deprecated
 108          */
 109         $this->set('PMA_THEME_GENERATION', 2);
 110
 111         $this->checkPhpVersion();
 112         $this->checkWebServerOs();
 113         $this->checkWebServer();
 114         $this->checkGd2();
 115         $this->checkClient();
 116         $this->checkUpload();
 117         $this->checkUploadSize();
 118         $this->checkOutputCompression();
 119     }
 120
 121     /**
 122      * whether to use gzip output compression or not
 123      *
 124      * @return nothing
 125      */
 126     function checkOutputCompression()
 127     {
 128         // If zlib output compression is set in the php configuration file, no
 129         // output buffering should be run
 130         if (@ini_get('zlib.output_compression')) {
 131             $this->set('OBGzip', false);
 132         }
 133
 134         // disable output-buffering (if set to 'auto') for IE6, else enable it.
 135         if (strtolower($this->get('OBGzip')) == 'auto') {
 136             if ($this->get('PMA_USR_BROWSER_AGENT') == 'IE'
 137                 && $this->get('PMA_USR_BROWSER_VER') >= 6
 138                 && $this->get('PMA_USR_BROWSER_VER') < 7
 139             ) {
 140                 $this->set('OBGzip', false);
 141             } else {
 142                 $this->set('OBGzip', true);
 143             }
 144         }
 145     }
 146
 147     /**
 148      * Determines platform (OS), browser and version of the user
 149      * Based on a phpBuilder article:
 150      *
 151      * @see http://www.phpbuilder.net/columns/tim20000821.php
 152      *
 153      * @return nothing
 154      */
 155     function checkClient()
 156     {
 157         if (PMA_getenv('HTTP_USER_AGENT')) {
 158             $HTTP_USER_AGENT = PMA_getenv('HTTP_USER_AGENT');
 159         } elseif (! isset($HTTP_USER_AGENT)) {
 160             $HTTP_USER_AGENT = '';
 161         }
 162
 163         // 1. Platform
 164         if (strstr($HTTP_USER_AGENT, 'Win')) {
 165             $this->set('PMA_USR_OS', 'Win');
 166         } elseif (strstr($HTTP_USER_AGENT, 'Mac')) {
 167             $this->set('PMA_USR_OS', 'Mac');
 168         } elseif (strstr($HTTP_USER_AGENT, 'Linux')) {
 169             $this->set('PMA_USR_OS', 'Linux');
 170         } elseif (strstr($HTTP_USER_AGENT, 'Unix')) {
 171             $this->set('PMA_USR_OS', 'Unix');
 172         } elseif (strstr($HTTP_USER_AGENT, 'OS/2')) {
 173             $this->set('PMA_USR_OS', 'OS/2');
 174         } else {
 175             $this->set('PMA_USR_OS', 'Other');
 176         }
 177
 178         // 2. browser and version
 179         // (must check everything else before Mozilla)
 180
 181         if (preg_match(
 182             '@Opera(/| )([0-9].[0-9]{1,2})@',
 183             $HTTP_USER_AGENT,
 184             $log_version
 185         )) {
 186             $this->set('PMA_USR_BROWSER_VER', $log_version[2]);
 187             $this->set('PMA_USR_BROWSER_AGENT', 'OPERA');
 188         } elseif (preg_match(
 189             '@MSIE ([0-9].[0-9]{1,2})@',
 190             $HTTP_USER_AGENT,
 191             $log_version
 192         )) {
 193             $this->set('PMA_USR_BROWSER_VER', $log_version[1]);
 194             $this->set('PMA_USR_BROWSER_AGENT', 'IE');
 195         } elseif (preg_match(
 196             '@OmniWeb/([0-9].[0-9]{1,2})@',
 197             $HTTP_USER_AGENT,
 198             $log_version
 199         )) {
 200             $this->set('PMA_USR_BROWSER_VER', $log_version[1]);
 201             $this->set('PMA_USR_BROWSER_AGENT', 'OMNIWEB');
 202         // Konqueror 2.2.2 says Konqueror/2.2.2
 203         // Konqueror 3.0.3 says Konqueror/3
 204         } elseif (preg_match(
 205             '@(Konqueror/)(.*)(;)@',
 206             $HTTP_USER_AGENT,
 207             $log_version
 208         )) {
 209             $this->set('PMA_USR_BROWSER_VER', $log_version[2]);
 210             $this->set('PMA_USR_BROWSER_AGENT', 'KONQUEROR');
 211         } elseif (preg_match(
 212             '@Mozilla/([0-9].[0-9]{1,2})@',
 213             $HTTP_USER_AGENT,
 214             $log_version)
 215             && preg_match('@Safari/([0-9]*)@', $HTTP_USER_AGENT, $log_version2)
 216         ) {
 217             $this->set('PMA_USR_BROWSER_VER', $log_version[1] . '.' . $log_version2[1]);
 218             $this->set('PMA_USR_BROWSER_AGENT', 'SAFARI');
 219         } elseif (preg_match('@rv:1.9(.*)Gecko@', $HTTP_USER_AGENT)) {
 220             $this->set('PMA_USR_BROWSER_VER', '1.9');
 221             $this->set('PMA_USR_BROWSER_AGENT', 'GECKO');
 222         } elseif (
 223             preg_match('@Mozilla/([0-9].[0-9]{1,2})@',
 224             $HTTP_USER_AGENT,
 225             $log_version
 226         )) {
 227             $this->set('PMA_USR_BROWSER_VER', $log_version[1]);
 228             $this->set('PMA_USR_BROWSER_AGENT', 'MOZILLA');
 229         } else {
 230             $this->set('PMA_USR_BROWSER_VER', 0);
 231             $this->set('PMA_USR_BROWSER_AGENT', 'OTHER');
 232         }
 233     }
 234
 235     /**
 236      * Whether GD2 is present
 237      *
 238      * @return nothing
 239      */
 240     function checkGd2()
 241     {
 242         if ($this->get('GD2Available') == 'yes') {
 243             $this->set('PMA_IS_GD2', 1);
 244         } elseif ($this->get('GD2Available') == 'no') {
 245             $this->set('PMA_IS_GD2', 0);
 246         } else {
 247             if (!@function_exists('imagecreatetruecolor')) {
 248                 $this->set('PMA_IS_GD2', 0);
 249             } else {
 250                 if (@function_exists('gd_info')) {
 251                     $gd_nfo = gd_info();
 252                     if (strstr($gd_nfo["GD Version"], '2.')) {
 253                         $this->set('PMA_IS_GD2', 1);
 254                     } else {
 255                         $this->set('PMA_IS_GD2', 0);
 256                     }
 257                 } else {
 258                     /* We must do hard way... but almost no chance to execute this */
 259                     ob_start();
 260                     phpinfo(INFO_MODULES); /* Only modules */
 261                     $a = strip_tags(ob_get_contents());
 262                     ob_end_clean();
 263                     /* Get GD version string from phpinfo output */
 264                     if (preg_match('@GD Version[[:space:]]*\(.*\)@', $a, $v)) {
 265                         if (strstr($v, '2.')) {
 266                             $this->set('PMA_IS_GD2', 1);
 267                         } else {
 268                             $this->set('PMA_IS_GD2', 0);
 269                         }
 270                     } else {
 271                         $this->set('PMA_IS_GD2', 0);
 272                     }
 273                 }
 274             }
 275         }
 276     }
 277
 278     /**
 279      * Whether the Web server php is running on is IIS
 280      *
 281      * @return nothing
 282      */
 283     function checkWebServer()
 284     {
 285         if (PMA_getenv('SERVER_SOFTWARE')
 286             // some versions return Microsoft-IIS, some Microsoft/IIS
 287             // we could use a preg_match() but it's slower
 288             && stristr(PMA_getenv('SERVER_SOFTWARE'), 'Microsoft')
 289             && stristr(PMA_getenv('SERVER_SOFTWARE'), 'IIS')
 290         ) {
 291             $this->set('PMA_IS_IIS', 1);
 292         } else {
 293             $this->set('PMA_IS_IIS', 0);
 294         }
 295     }
 296
 297     /**
 298      * Whether the os php is running on is windows or not
 299      *
 300      * @return nothing
 301      */
 302     function checkWebServerOs()
 303     {
 304         // Default to Unix or Equiv
 305         $this->set('PMA_IS_WINDOWS', 0);
 306         // If PHP_OS is defined then continue
 307         if (defined('PHP_OS')) {
 308             if (stristr(PHP_OS, 'win')) {
 309                 // Is it some version of Windows
 310                 $this->set('PMA_IS_WINDOWS', 1);
 311             } elseif (stristr(PHP_OS, 'OS/2')) {
 312                 // Is it OS/2 (No file permissions like Windows)
 313                 $this->set('PMA_IS_WINDOWS', 1);
 314             }
 315         }
 316     }
 317
 318     /**
 319      * detects PHP version
 320      *
 321      * @return nothing
 322      */
 323     function checkPhpVersion()
 324     {
 325         $match = array();
 326         if (! preg_match(
 327             '@([0-9]{1,2}).([0-9]{1,2}).([0-9]{1,2})@',
 328             phpversion(),
 329             $match
 330         )) {
 331             preg_match(
 332                 '@([0-9]{1,2}).([0-9]{1,2})@',
 333                 phpversion(),
 334                 $match
 335             );
 336         }
 337         if (isset($match) && ! empty($match[1])) {
 338             if (! isset($match[2])) {
 339                 $match[2] = 0;
 340             }
 341             if (! isset($match[3])) {
 342                 $match[3] = 0;
 343             }
 344             $this->set(
 345                 'PMA_PHP_INT_VERSION',
 346                 (int) sprintf('%d%02d%02d', $match[1], $match[2], $match[3])
 347             );
 348         } else {
 349             $this->set('PMA_PHP_INT_VERSION', 0);
 350         }
 351         $this->set('PMA_PHP_STR_VERSION', phpversion());
 352     }
 353
 354     /**
 355      * loads default values from default source
 356      *
 357      * @return  boolean     success
 358      */
 359     function loadDefaults()
 360     {
 361         $cfg = array();
 362         if (! file_exists($this->default_source)) {
 363             $this->error_config_default_file = true;
 364             return false;
 365         }
 366         include $this->default_source;
 367
 368         $this->default_source_mtime = filemtime($this->default_source);
 369
 370         $this->default_server = $cfg['Servers'][1];
 371         unset($cfg['Servers']);
 372
 373         $this->default = $cfg;
 374         $this->settings = PMA_array_merge_recursive($this->settings, $cfg);
 375
 376         $this->error_config_default_file = false;
 377
 378         return true;
 379     }
 380
 381     /**
 382      * loads configuration from $source, usally the config file
 383      * should be called on object creation
 384      *
 385      * @param string $source config file
 386      *
 387      * @return bool
 388      */
 389     function load($source = null)
 390     {
 391         $this->loadDefaults();
 392
 393         if (null !== $source) {
 394             $this->setSource($source);
 395         }
 396
 397         if (! $this->checkConfigSource()) {
 398             return false;
 399         }
 400
 401         $cfg = array();
 402
 403         /**
 404          * Parses the configuration file, the eval is used here to avoid
 405          * problems with trailing whitespace, what is often a problem.
 406          */
 407         $old_error_reporting = error_reporting(0);
 408         $eval_result = eval('?' . '>' . trim(file_get_contents($this->getSource())));
 409         error_reporting($old_error_reporting);
 410
 411         if ($eval_result === false) {
 412             $this->error_config_file = true;
 413         } else {
 414             $this->error_config_file = false;
 415             $this->source_mtime = filemtime($this->getSource());
 416         }
 417
 418         /**
 419          * Backward compatibility code
 420          */
 421         if (!empty($cfg['DefaultTabTable'])) {
 422             $cfg['DefaultTabTable'] = str_replace(
 423                 '_properties',
 424                 '',
 425                 str_replace(
 426                     'tbl_properties.php',
 427                     'tbl_sql.php',
 428                     $cfg['DefaultTabTable']
 429                 )
 430             );
 431         }
 432         if (!empty($cfg['DefaultTabDatabase'])) {
 433             $cfg['DefaultTabDatabase'] = str_replace(
 434                 '_details',
 435                 '',
 436                 str_replace(
 437                     'db_details.php',
 438                     'db_sql.php',
 439                     $cfg['DefaultTabDatabase']
 440                 )
 441             );
 442         }
 443
 444         $this->settings = PMA_array_merge_recursive($this->settings, $cfg);
 445         $this->checkPmaAbsoluteUri();
 446         $this->checkFontsize();
 447
 448         $this->checkPermissions();
 449
 450         // Handling of the collation must be done after merging of $cfg
 451         // (from config.inc.php) so that $cfg['DefaultConnectionCollation']
 452         // can have an effect. Note that the presence of collation
 453         // information in a cookie has priority over what is defined
 454         // in the default or user's config files.
 455         /**
 456          * @todo check validity of $_COOKIE['pma_collation_connection']
 457          */
 458         if (! empty($_COOKIE['pma_collation_connection'])) {
 459             $this->set(
 460                 'collation_connection',
 461                 strip_tags($_COOKIE['pma_collation_connection'])
 462             );
 463         } else {
 464             $this->set(
 465                 'collation_connection',
 466                 $this->get('DefaultConnectionCollation')
 467             );
 468         }
 469         // Now, a collation information could come from REQUEST
 470         // (an example of this: the collation selector in main.php)
 471         // so the following handles the setting of collation_connection
 472         // and later, in common.inc.php, the cookie will be set
 473         // according to this.
 474         $this->checkCollationConnection();
 475
 476         return true;
 477     }
 478
 479     /**
 480      * Loads user preferences and merges them with current config
 481      * must be called after control connection has been estabilished
 482      *
 483      * @return boolean
 484      */
 485     function loadUserPreferences()
 486     {
 487         // index.php should load these settings, so that phpmyadmin.css.php
 488         // will have everything avaiable in session cache
 489         $server = isset($GLOBALS['server'])
 490             ? $GLOBALS['server']
 491             : (!empty($GLOBALS['cfg']['ServerDefault'])
 492                 ? $GLOBALS['cfg']['ServerDefault']
 493                 : 0);
 494         $cache_key = 'server_' . $server;
 495         if ($server > 0 && !defined('PMA_MINIMUM_COMMON')) {
 496             $config_mtime = max($this->default_source_mtime, $this->source_mtime);
 497             // cache user preferences, use database only when needed
 498             if (! isset($_SESSION['cache'][$cache_key]['userprefs'])
 499                 || $_SESSION['cache'][$cache_key]['config_mtime'] < $config_mtime
 500             ) {
 501                 // load required libraries
 502                 include_once './libraries/user_preferences.lib.php';
 503                 $prefs = PMA_load_userprefs();
 504                 $_SESSION['cache'][$cache_key]['userprefs']
 505                     = PMA_apply_userprefs($prefs['config_data']);
 506                 $_SESSION['cache'][$cache_key]['userprefs_mtime'] = $prefs['mtime'];
 507                 $_SESSION['cache'][$cache_key]['userprefs_type'] = $prefs['type'];
 508                 $_SESSION['cache'][$cache_key]['config_mtime'] = $config_mtime;
 509             }
 510         } elseif ($server == 0
 511             || ! isset($_SESSION['cache'][$cache_key]['userprefs'])
 512         ) {
 513             $this->set('user_preferences', false);
 514             return;
 515         }
 516         $config_data = $_SESSION['cache'][$cache_key]['userprefs'];
 517         // type is 'db' or 'session'
 518         $this->set(
 519             'user_preferences',
 520             $_SESSION['cache'][$cache_key]['userprefs_type']
 521         );
 522         $this->set(
 523             'user_preferences_mtime',
 524             $_SESSION['cache'][$cache_key]['userprefs_mtime']
 525         );
 526
 527         // backup some settings
 528         $org_fontsize = $this->settings['fontsize'];
 529         // load config array
 530         $this->settings = PMA_array_merge_recursive($this->settings, $config_data);
 531         $GLOBALS['cfg'] = PMA_array_merge_recursive($GLOBALS['cfg'], $config_data);
 532         if (defined('PMA_MINIMUM_COMMON')) {
 533             return;
 534         }
 535
 536         // settings below start really working on next page load, but
 537         // changes are made only in index.php so everything is set when
 538         // in frames
 539
 540         // save theme
 541         $tmanager = $_SESSION['PMA_Theme_Manager'];
 542         if ($tmanager->getThemeCookie() || isset($_REQUEST['set_theme'])) {
 543             if ((! isset($config_data['ThemeDefault'])
 544                 && $tmanager->theme->getId() != 'original')
 545                 || isset($config_data['ThemeDefault'])
 546                 && $config_data['ThemeDefault'] != $tmanager->theme->getId()
 547             ) {
 548                 // new theme was set in common.inc.php
 549                 $this->setUserValue(
 550                     null,
 551                     'ThemeDefault',
 552                     $tmanager->theme->getId(),
 553                     'original'
 554                 );
 555             }
 556         } else {
 557             // no cookie - read default from settings
 558             if ($this->settings['ThemeDefault'] != $tmanager->theme->getId()
 559                 && $tmanager->checkTheme($this->settings['ThemeDefault'])
 560             ) {
 561                 $tmanager->setActiveTheme($this->settings['ThemeDefault']);
 562                 $tmanager->setThemeCookie();
 563             }
 564         }
 565
 566         // save font size
 567         if ((! isset($config_data['fontsize'])
 568             && $org_fontsize != '82%')
 569             || isset($config_data['fontsize'])
 570             && $org_fontsize != $config_data['fontsize']
 571         ) {
 572             $this->setUserValue(null, 'fontsize', $org_fontsize, '82%');
 573         }
 574
 575         // save language
 576         if (isset($_COOKIE['pma_lang']) || isset($_POST['lang'])) {
 577             if ((! isset($config_data['lang'])
 578                 && $GLOBALS['lang'] != 'en')
 579                 || isset($config_data['lang'])
 580                 && $GLOBALS['lang'] != $config_data['lang']
 581             ) {
 582                 $this->setUserValue(null, 'lang', $GLOBALS['lang'], 'en');
 583             }
 584         } else {
 585             // read language from settings
 586             if (isset($config_data['lang']) && PMA_langSet($config_data['lang'])) {
 587                 $this->setCookie('pma_lang', $GLOBALS['lang']);
 588             }
 589         }
 590
 591         // save connection collation
 592         if (isset($_COOKIE['pma_collation_connection'])
 593             || isset($_POST['collation_connection'])
 594         ) {
 595             if ((! isset($config_data['collation_connection'])
 596                 && $GLOBALS['collation_connection'] != 'utf8_general_ci')
 597                 || isset($config_data['collation_connection'])
 598                 && $GLOBALS['collation_connection']
 599                     != $config_data['collation_connection']
 600             ) {
 601                 $this->setUserValue(
 602                     null,
 603                     'collation_connection',
 604                     $GLOBALS['collation_connection'],
 605                     'utf8_general_ci'
 606                 );
 607             }
 608         } else {
 609             // read collation from settings
 610             if (isset($config_data['collation_connection'])) {
 611                 $GLOBALS['collation_connection']
 612                     = $config_data['collation_connection'];
 613                 $this->setCookie(
 614                     'pma_collation_connection',
 615                     $GLOBALS['collation_connection']
 616                 );
 617             }
 618         }
 619     }
 620
 621     /**
 622      * Sets config value which is stored in user preferences (if available)
 623      * or in a cookie.
 624      *
 625      * If user preferences are not yet initialized, option is applied to
 626      * global config and added to a update queue, which is processed
 627      * by {@link loadUserPreferences()}
 628      *
 629      * @param string $cookie_name   can be null
 630      * @param string $cfg_path
 631      * @param mixed  $new_cfg_value new value
 632      * @param mixed  $default_value default value
 633      *
 634      * @return nothing
 635      */
 636     function setUserValue($cookie_name, $cfg_path, $new_cfg_value, $default_value = null)
 637     {
 638         // use permanent user preferences if possible
 639         $prefs_type = $this->get('user_preferences');
 640         if ($prefs_type) {
 641             include_once './libraries/user_preferences.lib.php';
 642             if ($default_value === null) {
 643                 $default_value = PMA_array_read($cfg_path, $this->default);
 644             }
 645             PMA_persist_option($cfg_path, $new_cfg_value, $default_value);
 646         }
 647         if ($prefs_type != 'db' && $cookie_name) {
 648             // fall back to cookies
 649             if ($default_value === null) {
 650                 $default_value = PMA_array_read($cfg_path, $this->settings);
 651             }
 652             $this->setCookie($cookie_name, $new_cfg_value, $default_value);
 653         }
 654         PMA_array_write($cfg_path, $GLOBALS['cfg'], $new_cfg_value);
 655         PMA_array_write($cfg_path, $this->settings, $new_cfg_value);
 656     }
 657
 658     /**
 659      * Reads value stored by {@link setUserValue()}
 660      *
 661      * @param string $cookie_name cookie name
 662      * @param mixed  $cfg_value   config value
 663      *
 664      * @return mixed
 665      */
 666     function getUserValue($cookie_name, $cfg_value)
 667     {
 668         $cookie_exists = isset($_COOKIE) && !empty($_COOKIE[$cookie_name]);
 669         $prefs_type = $this->get('user_preferences');
 670         if ($prefs_type == 'db') {
 671             // permanent user preferences value exists, remove cookie
 672             if ($cookie_exists) {
 673                 $this->removeCookie($cookie_name);
 674             }
 675         } else if ($cookie_exists) {
 676             return $_COOKIE[$cookie_name];
 677         }
 678         // return value from $cfg array
 679         return $cfg_value;
 680     }
 681
 682     /**
 683      * set source
 684      *
 685      * @param string  $source
 686      *
 687      * @return nothing
 688      */
 689     function setSource($source)
 690     {
 691         $this->source = trim($source);
 692     }
 693
 694     /**
 695      * checks if the config folder still exists and terminates app if true
 696      *
 697      * @return nothing
 698      */
 699     function checkConfigFolder()
 700     {
 701         // Refuse to work while there still might be some world writable dir:
 702         if (is_dir('./config')) {
 703             die(__('Remove "./config" directory before using phpMyAdmin!'));
 704         }
 705     }
 706
 707     /**
 708      * check config source
 709      *
 710      * @return  boolean whether source is valid or not
 711      */
 712     function checkConfigSource()
 713     {
 714         if (! $this->getSource()) {
 715             // no configuration file set at all
 716             return false;
 717         }
 718
 719         if (! file_exists($this->getSource())) {
 720             $this->source_mtime = 0;
 721             return false;
 722         }
 723
 724         if (! is_readable($this->getSource())) {
 725             $this->source_mtime = 0;
 726             die(
 727                 sprintf(__('Existing configuration file (%s) is not readable.'),
 728                     $this->getSource()
 729                 )
 730             );
 731         }
 732
 733         return true;
 734     }
 735
 736     /**
 737      * verifies the permissions on config file (if asked by configuration)
 738      * (must be called after config.inc.php has been merged)
 739      *
 740      * @return nothing
 741      */
 742     function checkPermissions()
 743     {
 744         // Check for permissions (on platforms that support it):
 745         if ($this->get('CheckConfigurationPermissions')) {
 746             $perms = @fileperms($this->getSource());
 747             if (!($perms === false) && ($perms & 2)) {
 748                 // This check is normally done after loading configuration
 749                 $this->checkWebServerOs();
 750                 if ($this->get('PMA_IS_WINDOWS') == 0) {
 751                     $this->source_mtime = 0;
 752                     die(__('Wrong permissions on configuration file, should not be world writable!'));
 753                 }
 754             }
 755         }
 756     }
 757
 758     /**
 759      * returns specific config setting
 760      *
 761      * @param string $setting config setting
 762      *
 763      * @return mixed value
 764      */
 765     function get($setting)
 766     {
 767         if (isset($this->settings[$setting])) {
 768             return $this->settings[$setting];
 769         }
 770         return null;
 771     }
 772
 773     /**
 774      * sets configuration variable
 775      *
 776      * @param string $setting configuration option
 777      * @param string $value   new value for configuration option
 778      *
 779      * @return nothing
 780      */
 781     function set($setting, $value)
 782     {
 783         if (! isset($this->settings[$setting])
 784             || $this->settings[$setting] != $value
 785         ) {
 786             $this->settings[$setting] = $value;
 787             $this->set_mtime = time();
 788         }
 789     }
 790
 791     /**
 792      * returns source for current config
 793      *
 794      * @return  string  config source
 795      */
 796     function getSource()
 797     {
 798         return $this->source;
 799     }
 800
 801     /**
 802      * returns a unique value to force a CSS reload if either the config
 803      * or the theme changes
 804      * must also check the pma_fontsize cookie in case there is no
 805      * config file
 806      *
 807      * @return int Summary of unix timestamps and fontsize,
 808      * to be unique on theme parameters change
 809      */
 810     function getThemeUniqueValue()
 811     {
 812         if (null !== $this->get('fontsize')) {
 813             $fontsize = intval($this->get('fontsize'));
 814         } elseif (isset($_COOKIE['pma_fontsize'])) {
 815             $fontsize = intval($_COOKIE['pma_fontsize']);
 816         } else {
 817             $fontsize = 0;
 818         }
 819         return (
 820             $fontsize +
 821             $this->source_mtime +
 822             $this->default_source_mtime +
 823             $this->get('user_preferences_mtime') +
 824             $_SESSION['PMA_Theme']->mtime_info +
 825             $_SESSION['PMA_Theme']->filesize_info);
 826     }
 827
 828     /**
 829      * $cfg['PmaAbsoluteUri'] is a required directive else cookies won't be
 830      * set properly and, depending on browsers, inserting or updating a
 831      * record might fail
 832      *
 833      * @return bool
 834      */
 835     function checkPmaAbsoluteUri()
 836     {
 837         // Setup a default value to let the people and lazy sysadmins work anyway,
 838         // they'll get an error if the autodetect code doesn't work
 839         $pma_absolute_uri = $this->get('PmaAbsoluteUri');
 840         $is_https = $this->detectHttps();
 841
 842         if (strlen($pma_absolute_uri) < 5) {
 843             $url = array();
 844
 845             // If we don't have scheme, we didn't have full URL so we need to
 846             // dig deeper
 847             if (empty($url['scheme'])) {
 848                 // Scheme
 849                 if ($is_https) {
 850                     $url['scheme'] = 'https';
 851                 } else {
 852                     $url['scheme'] = 'http';
 853                 }
 854
 855                 // Host and port
 856                 if (PMA_getenv('HTTP_HOST')) {
 857                     // Prepend the scheme before using parse_url() since this
 858                     // is not part of the RFC2616 Host request-header
 859                     $parsed_url = parse_url(
 860                         $url['scheme'] . '://' . PMA_getenv('HTTP_HOST')
 861                     );
 862                     if (!empty($parsed_url['host'])) {
 863                         $url = $parsed_url;
 864                     } else {
 865                         $url['host'] = PMA_getenv('HTTP_HOST');
 866                     }
 867                 } elseif (PMA_getenv('SERVER_NAME')) {
 868                     $url['host'] = PMA_getenv('SERVER_NAME');
 869                 } else {
 870                     $this->error_pma_uri = true;
 871                     return false;
 872                 }
 873
 874                 // If we didn't set port yet...
 875                 if (empty($url['port']) && PMA_getenv('SERVER_PORT')) {
 876                     $url['port'] = PMA_getenv('SERVER_PORT');
 877                 }
 878
 879                 // And finally the path could be already set from REQUEST_URI
 880                 if (empty($url['path'])) {
 881                     $path = parse_url($GLOBALS['PMA_PHP_SELF']);
 882                     $url['path'] = $path['path'];
 883                 }
 884             }
 885
 886             // Make url from parts we have
 887             $pma_absolute_uri = $url['scheme'] . '://';
 888             // Was there user information?
 889             if (!empty($url['user'])) {
 890                 $pma_absolute_uri .= $url['user'];
 891                 if (!empty($url['pass'])) {
 892                     $pma_absolute_uri .= ':' . $url['pass'];
 893                 }
 894                 $pma_absolute_uri .= '@';
 895             }
 896             // Add hostname
 897             $pma_absolute_uri .= $url['host'];
 898             // Add port, if it not the default one
 899             if (! empty($url['port'])
 900                 && (($url['scheme'] == 'http' && $url['port'] != 80)
 901                 || ($url['scheme'] == 'https' && $url['port'] != 443))
 902             ) {
 903                 $pma_absolute_uri .= ':' . $url['port'];
 904             }
 905             // And finally path, without script name, the 'a' is there not to
 906             // strip our directory, when path is only /pmadir/ without filename.
 907             // Backslashes returned by Windows have to be changed.
 908             // Only replace backslashes by forward slashes if on Windows,
 909             // as the backslash could be valid on a non-Windows system.
 910             $this->checkWebServerOs();
 911             if ($this->get('PMA_IS_WINDOWS') == 1) {
 912                 $path = str_replace("\\", "/", dirname($url['path'] . 'a'));
 913             } else {
 914                 $path = dirname($url['path'] . 'a');
 915             }
 916
 917             // To work correctly within transformations overview:
 918             if (defined('PMA_PATH_TO_BASEDIR') && PMA_PATH_TO_BASEDIR == '../../') {
 919                 if ($this->get('PMA_IS_WINDOWS') == 1) {
 920                     $path = str_replace("\\", "/", dirname(dirname($path)));
 921                 } else {
 922                     $path = dirname(dirname($path));
 923                 }
 924             }
 925
 926             // PHP's dirname function would have returned a dot
 927             // when $path contains no slash
 928             if ($path == '.') {
 929                 $path = '';
 930             }
 931             // in vhost situations, there could be already an ending slash
 932             if (substr($path, -1) != '/') {
 933                 $path .= '/';
 934             }
 935             $pma_absolute_uri .= $path;
 936
 937             // We used to display a warning if PmaAbsoluteUri wasn't set, but now
 938             // the autodetect code works well enough that we don't display the
 939             // warning at all. The user can still set PmaAbsoluteUri manually.
 940             // See
 941             // http://sf.net/tracker/?func=detail&aid=1257134&group_id=23067&atid=377411
 942
 943         } else {
 944             // The URI is specified, however users do often specify this
 945             // wrongly, so we try to fix this.
 946
 947             // Adds a trailing slash et the end of the phpMyAdmin uri if it
 948             // does not exist.
 949             if (substr($pma_absolute_uri, -1) != '/') {
 950                 $pma_absolute_uri .= '/';
 951             }
 952
 953             // If URI doesn't start with http:// or https://, we will add
 954             // this.
 955             if (substr($pma_absolute_uri, 0, 7) != 'http://'
 956                 && substr($pma_absolute_uri, 0, 8) != 'https://'
 957             ) {
 958                 $pma_absolute_uri
 959                     = ($is_https ? 'https' : 'http')
 960                     . ':' . (substr($pma_absolute_uri, 0, 2) == '//' ? '' : '//')
 961                     . $pma_absolute_uri;
 962             }
 963         }
 964         $this->set('PmaAbsoluteUri', $pma_absolute_uri);
 965     }
 966
 967     /**
 968      * check selected collation_connection
 969      *
 970      * @todo check validity of $_REQUEST['collation_connection']
 971      *
 972      * @return nothing
 973      */
 974     function checkCollationConnection()
 975     {
 976         if (! empty($_REQUEST['collation_connection'])) {
 977             $this->set(
 978                 'collation_connection',
 979                 strip_tags($_REQUEST['collation_connection'])
 980             );
 981         }
 982     }
 983
 984     /**
 985      * checks for font size configuration, and sets font size as requested by user
 986      *
 987      * @return nothing
 988      */
 989     function checkFontsize()
 990     {
 991         $new_fontsize = '';
 992
 993         if (isset($_GET['set_fontsize'])) {
 994             $new_fontsize = $_GET['set_fontsize'];
 995         } elseif (isset($_POST['set_fontsize'])) {
 996             $new_fontsize = $_POST['set_fontsize'];
 997         } elseif (isset($_COOKIE['pma_fontsize'])) {
 998             $new_fontsize = $_COOKIE['pma_fontsize'];
 999         }
1000
1001         if (preg_match('/^[0-9.]+(px|em|pt|\%)$/', $new_fontsize)) {
1002             $this->set('fontsize', $new_fontsize);
1003         } elseif (! $this->get('fontsize')) {
1004             // 80% would correspond to the default browser font size
1005             // of 16, but use 82% to help read the monoface font
1006             $this->set('fontsize', '82%');
1007         }
1008
1009         $this->setCookie('pma_fontsize', $this->get('fontsize'), '82%');
1010     }
1011
1012     /**
1013      * checks if upload is enabled
1014      *
1015      * @return nothing
1016      */
1017     function checkUpload()
1018     {
1019         if (ini_get('file_uploads')) {
1020             $this->set('enable_upload', true);
1021             // if set "php_admin_value file_uploads Off" in httpd.conf
1022             // ini_get() also returns the string "Off" in this case:
1023             if ('off' == strtolower(ini_get('file_uploads'))) {
1024                 $this->set('enable_upload', false);
1025             }
1026         } else {
1027             $this->set('enable_upload', false);
1028         }
1029     }
1030
1031     /**
1032      * Maximum upload size as limited by PHP
1033      * Used with permission from Moodle (http://moodle.org) by Martin Dougiamas
1034      *
1035      * this section generates $max_upload_size in bytes
1036      *
1037      * @return nothing
1038      */
1039     function checkUploadSize()
1040     {
1041         if (! $filesize = ini_get('upload_max_filesize')) {
1042             $filesize = "5M";
1043         }
1044
1045         if ($postsize = ini_get('post_max_size')) {
1046             $this->set(
1047                 'max_upload_size',
1048                 min(PMA_get_real_size($filesize), PMA_get_real_size($postsize))
1049             );
1050         } else {
1051             $this->set('max_upload_size', PMA_get_real_size($filesize));
1052         }
1053     }
1054
1055     /**
1056      * check for https
1057      *
1058      * @return nothing
1059      */
1060     function checkIsHttps()
1061     {
1062         $this->set('is_https', $this->isHttps());
1063     }
1064
1065     /**
1066      * Checks if protocol is https
1067      *
1068      * This function checks if the https protocol is used in the PmaAbsoluteUri
1069      * configuration setting, as opposed to detectHttps() which checks if the
1070      * https protocol is used on the active connection.
1071      *
1072      * @return bool
1073      */
1074     public function isHttps()
1075     {
1076         static $is_https = null;
1077
1078         if (null !== $is_https) {
1079             return $is_https;
1080         }
1081
1082         $url = parse_url($this->get('PmaAbsoluteUri'));
1083
1084         if (isset($url['scheme']) && $url['scheme'] == 'https') {
1085             $is_https = true;
1086         } else {
1087             $is_https = false;
1088         }
1089
1090         return $is_https;
1091     }
1092
1093     /**
1094      * Detects whether https appears to be used.
1095      *
1096      * This function checks if the https protocol is used in the current connection
1097      * with the webserver, based on environment variables.
1098      * Please note that this just detects what we see, so
1099      * it completely ignores things like reverse proxies.
1100      *
1101      * @return bool
1102      */
1103     function detectHttps()
1104     {
1105         $is_https = false;
1106
1107         $url = array();
1108
1109         // At first we try to parse REQUEST_URI, it might contain full URL,
1110         if (PMA_getenv('REQUEST_URI')) {
1111             // produces E_WARNING if it cannot get parsed, e.g. '/foobar:/'
1112             $url = @parse_url(PMA_getenv('REQUEST_URI'));
1113             if ($url === false) {
1114                 $url = array();
1115             }
1116         }
1117
1118         // If we don't have scheme, we didn't have full URL so we need to
1119         // dig deeper
1120         if (empty($url['scheme'])) {
1121             // Scheme
1122             if (PMA_getenv('HTTP_SCHEME')) {
1123                 $url['scheme'] = PMA_getenv('HTTP_SCHEME');
1124             } elseif (PMA_getenv('HTTPS') && strtolower(PMA_getenv('HTTPS')) == 'on') {
1125                 $url['scheme'] = 'https';
1126             } elseif (PMA_getenv('HTTP_X_FORWARDED_PROTO')) {
1127                 $url['scheme'] = strtolower(PMA_getenv('HTTP_X_FORWARDED_PROTO'));
1128             } elseif (PMA_getenv('HTTP_FRONT_END_HTTPS') && strtolower(PMA_getenv('HTTP_FRONT_END_HTTPS')) == 'on') {
1129                 $url['scheme'] = 'https';
1130             } else {
1131                 $url['scheme'] = 'http';
1132             }
1133         }
1134
1135         if (isset($url['scheme']) && $url['scheme'] == 'https') {
1136             $is_https = true;
1137         } else {
1138             $is_https = false;
1139         }
1140
1141         return $is_https;
1142     }
1143
1144     /**
1145      * detect correct cookie path
1146      *
1147      * @return nothing
1148      */
1149     function checkCookiePath()
1150     {
1151         $this->set('cookie_path', $this->getCookiePath());
1152     }
1153
1154     /**
1155      * Get cookie path
1156      *
1157      * @return string
1158      */
1159     public function getCookiePath()
1160     {
1161         static $cookie_path = null;
1162
1163         if (null !== $cookie_path) {
1164             return $cookie_path;
1165         }
1166
1167         $parsed_url = parse_url($this->get('PmaAbsoluteUri'));
1168
1169         $cookie_path   = $parsed_url['path'];
1170
1171         return $cookie_path;
1172     }
1173
1174     /**
1175      * enables backward compatibility
1176      *
1177      * @return nothing
1178      */
1179     function enableBc()
1180     {
1181         $GLOBALS['cfg']             = $this->settings;
1182         $GLOBALS['default_server']  = $this->default_server;
1183         unset($this->default_server);
1184         $GLOBALS['collation_connection'] = $this->get('collation_connection');
1185         $GLOBALS['is_upload']       = $this->get('enable_upload');
1186         $GLOBALS['max_upload_size'] = $this->get('max_upload_size');
1187         $GLOBALS['cookie_path']     = $this->get('cookie_path');
1188         $GLOBALS['is_https']        = $this->get('is_https');
1189
1190         $defines = array(
1191             'PMA_VERSION',
1192             'PMA_THEME_VERSION',
1193             'PMA_THEME_GENERATION',
1194             'PMA_PHP_STR_VERSION',
1195             'PMA_PHP_INT_VERSION',
1196             'PMA_IS_WINDOWS',
1197             'PMA_IS_IIS',
1198             'PMA_IS_GD2',
1199             'PMA_USR_OS',
1200             'PMA_USR_BROWSER_VER',
1201             'PMA_USR_BROWSER_AGENT'
1202             );
1203
1204         foreach ($defines as $define) {
1205             if (! defined($define)) {
1206                 define($define, $this->get($define));
1207             }
1208         }
1209     }
1210
1211     /**
1212      * @todo finish
1213      *
1214      * @return nothing
1215      */
1216     function save()
1217     {
1218     }
1219
1220     /**
1221      * returns options for font size selection
1222      *
1223      * @static
1224      * @param string $current_size current selected font size with unit
1225      *
1226      * @return array selectable font sizes
1227      */
1228     static protected function _getFontsizeOptions($current_size = '82%')
1229     {
1230         $unit = preg_replace('/[0-9.]*/', '', $current_size);
1231         $value = preg_replace('/[^0-9.]*/', '', $current_size);
1232
1233         $factors = array();
1234         $options = array();
1235         $options["$value"] = $value . $unit;
1236
1237         if ($unit === '%') {
1238             $factors[] = 1;
1239             $factors[] = 5;
1240             $factors[] = 10;
1241         } elseif ($unit === 'em') {
1242             $factors[] = 0.05;
1243             $factors[] = 0.2;
1244             $factors[] = 1;
1245         } elseif ($unit === 'pt') {
1246             $factors[] = 0.5;
1247             $factors[] = 2;
1248         } elseif ($unit === 'px') {
1249             $factors[] = 1;
1250             $factors[] = 5;
1251             $factors[] = 10;
1252         } else {
1253             //unknown font size unit
1254             $factors[] = 0.05;
1255             $factors[] = 0.2;
1256             $factors[] = 1;
1257             $factors[] = 5;
1258             $factors[] = 10;
1259         }
1260
1261         foreach ($factors as $key => $factor) {
1262             $option_inc = $value + $factor;
1263             $option_dec = $value - $factor;
1264             while (count($options) < 21) {
1265                 $options["$option_inc"] = $option_inc . $unit;
1266                 if ($option_dec > $factors[0]) {
1267                     $options["$option_dec"] = $option_dec . $unit;
1268                 }
1269                 $option_inc += $factor;
1270                 $option_dec -= $factor;
1271                 if (isset($factors[$key + 1])
1272                     && $option_inc >= $value + $factors[$key + 1]
1273                 ) {
1274                     break;
1275                 }
1276             }
1277         }
1278         ksort($options);
1279         return $options;
1280     }
1281
1282     /**
1283      * returns html selectbox for font sizes
1284      *
1285      * @static
1286      * @param string $current_size currently slected font size with unit
1287      *
1288      * @return string html selectbox
1289      */
1290     static protected function _getFontsizeSelection()
1291     {
1292         $current_size = $GLOBALS['PMA_Config']->get('fontsize');
1293         // for the case when there is no config file (this is supported)
1294         if (empty($current_size)) {
1295             if (isset($_COOKIE['pma_fontsize'])) {
1296                 $current_size = $_COOKIE['pma_fontsize'];
1297             } else {
1298                 $current_size = '82%';
1299             }
1300         }
1301         $options = PMA_Config::_getFontsizeOptions($current_size);
1302
1303         $return = '<label for="select_fontsize">' . __('Font size') . ':</label>' . "\n";
1304         $return .= '<select name="set_fontsize" id="select_fontsize" class="autosubmit">' . "\n";
1305         foreach ($options as $option) {
1306             $return .= '<option value="' . $option . '"';
1307             if ($option == $current_size) {
1308                 $return .= ' selected="selected"';
1309             }
1310             $return .= '>' . $option . '</option>' . "\n";
1311         }
1312         $return .= '</select>';
1313
1314         return $return;
1315     }
1316
1317     /**
1318      * return complete font size selection form
1319      *
1320      * @static
1321      * @param string $current_size currently slected font size with unit
1322      *
1323      * @return string html selectbox
1324      */
1325     static public function getFontsizeForm()
1326     {
1327         return '<form name="form_fontsize_selection" id="form_fontsize_selection"'
1328             . ' method="post" action="index.php" target="_parent">' . "\n"
1329             . PMA_generate_common_hidden_inputs() . "\n"
1330             . PMA_Config::_getFontsizeSelection() . "\n"
1331             . '<noscript>' . "\n"
1332             . '<input type="submit" value="' . __('Go') . '" />' . "\n"
1333             . '</noscript>' . "\n"
1334             . '</form>';
1335     }
1336
1337     /**
1338      * removes cookie
1339      *
1340      * @param string $cookie name of cookie to remove
1341      *
1342      * @return boolean result of setcookie()
1343      */
1344     function removeCookie($cookie)
1345     {
1346         return setcookie(
1347             $cookie,
1348             '',
1349             time() - 3600,
1350             $this->getCookiePath(),
1351             '',
1352             $this->isHttps()
1353         );
1354     }
1355
1356     /**
1357      * sets cookie if value is different from current cokkie value,
1358      * or removes if value is equal to default
1359      *
1360      * @param string  $cookie   name of cookie to remove
1361      * @param mixed   $value    new cookie value
1362      * @param string  $default  default value
1363      * @param int     $validity validity of cookie in seconds (default is one month)
1364      * @param bool    $httponly whether cookie is only for HTTP (and not for scripts)
1365      *
1366      * @return boolean result of setcookie()
1367      */
1368     function setCookie($cookie, $value, $default = null, $validity = null, $httponly = true)
1369     {
1370         if ($validity == null) {
1371             $validity = 2592000;
1372         }
1373         if (strlen($value) && null !== $default && $value === $default) {
1374             // default value is used
1375             if (isset($_COOKIE[$cookie])) {
1376                 // remove cookie
1377                 return $this->removeCookie($cookie);
1378             }
1379             return false;
1380         }
1381
1382         if (! strlen($value) && isset($_COOKIE[$cookie])) {
1383             // remove cookie, value is empty
1384             return $this->removeCookie($cookie);
1385         }
1386
1387         if (! isset($_COOKIE[$cookie]) || $_COOKIE[$cookie] !== $value) {
1388             // set cookie with new value
1389             /* Calculate cookie validity */
1390             if ($validity == 0) {
1391                 $v = 0;
1392             } else {
1393                 $v = time() + $validity;
1394             }
1395             return setcookie(
1396                 $cookie,
1397                 $value,
1398                 $v,
1399                 $this->getCookiePath(),
1400                 '',
1401                 $this->isHttps(),
1402                 $httponly
1403             );
1404         }
1405
1406         // cookie has already $value as value
1407         return true;
1408     }
1409 }
1410 ?>