libraries/Config.class.php

   1 <?php
   2 /* vim: set expandtab sw=4 ts=4 sts=4: */
   3 /**
   4  *
   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   configuration settings
  28      */
  29     var $settings = array();
  30
  31     /**
  32      * @var string  config source
  33      */
  34     var $source = '';
  35
  36     /**
  37      * @var int     source modification time
  38      */
  39     var $source_mtime = 0;
  40     var $default_source_mtime = 0;
  41     var $set_mtime = 0;
  42
  43     /**
  44      * @var boolean
  45      */
  46     var $error_config_file = false;
  47
  48     /**
  49      * @var boolean
  50      */
  51     var $error_config_default_file = false;
  52
  53     /**
  54      * @var boolean
  55      */
  56     var $error_pma_uri = false;
  57
  58     /**
  59      * @var array
  60      */
  61     var $default_server = array();
  62
  63     /**
  64      * @var boolean whether init is done or not
  65      * set this to false to force some initial checks
  66      * like checking for required functions
  67      */
  68     var $done = false;
  69
  70     /**
  71      * constructor
  72      *
  73      * @param   string  source to read config from
  74      */
  75     function __construct($source = null)
  76     {
  77         $this->settings = array();
  78
  79         // functions need to refresh in case of config file changed goes in
  80         // PMA_Config::load()
  81         $this->load($source);
  82
  83         // other settings, independent from config file, comes in
  84         $this->checkSystem();
  85
  86         $this->checkIsHttps();
  87     }
  88
  89     /**
  90      * sets system and application settings
  91      */
  92     function checkSystem()
  93     {
  94         $this->set('PMA_VERSION', '3.4.0-dev');
  95         /**
  96          * @deprecated
  97          */
  98         $this->set('PMA_THEME_VERSION', 2);
  99         /**
 100          * @deprecated
 101          */
 102         $this->set('PMA_THEME_GENERATION', 2);
 103
 104         $this->checkPhpVersion();
 105         $this->checkWebServerOs();
 106         $this->checkWebServer();
 107         $this->checkGd2();
 108         $this->checkClient();
 109         $this->checkUpload();
 110         $this->checkUploadSize();
 111         $this->checkOutputCompression();
 112     }
 113
 114     /**
 115      * whether to use gzip output compression or not
 116      */
 117     function checkOutputCompression()
 118     {
 119         // If zlib output compression is set in the php configuration file, no
 120         // output buffering should be run
 121         if (@ini_get('zlib.output_compression')) {
 122             $this->set('OBGzip', false);
 123         }
 124
 125         // disable output-buffering (if set to 'auto') for IE6, else enable it.
 126         if (strtolower($this->get('OBGzip')) == 'auto') {
 127             if ($this->get('PMA_USR_BROWSER_AGENT') == 'IE'
 128               && $this->get('PMA_USR_BROWSER_VER') >= 6
 129               && $this->get('PMA_USR_BROWSER_VER') < 7) {
 130                 $this->set('OBGzip', false);
 131             } else {
 132                 $this->set('OBGzip', true);
 133             }
 134         }
 135     }
 136
 137     /**
 138      * Determines platform (OS), browser and version of the user
 139      * Based on a phpBuilder article:
 140      * @see http://www.phpbuilder.net/columns/tim20000821.php
 141      */
 142     function checkClient()
 143     {
 144         if (PMA_getenv('HTTP_USER_AGENT')) {
 145             $HTTP_USER_AGENT = PMA_getenv('HTTP_USER_AGENT');
 146         } elseif (!isset($HTTP_USER_AGENT)) {
 147             $HTTP_USER_AGENT = '';
 148         }
 149
 150         // 1. Platform
 151         if (strstr($HTTP_USER_AGENT, 'Win')) {
 152             $this->set('PMA_USR_OS', 'Win');
 153         } elseif (strstr($HTTP_USER_AGENT, 'Mac')) {
 154             $this->set('PMA_USR_OS', 'Mac');
 155         } elseif (strstr($HTTP_USER_AGENT, 'Linux')) {
 156             $this->set('PMA_USR_OS', 'Linux');
 157         } elseif (strstr($HTTP_USER_AGENT, 'Unix')) {
 158             $this->set('PMA_USR_OS', 'Unix');
 159         } elseif (strstr($HTTP_USER_AGENT, 'OS/2')) {
 160             $this->set('PMA_USR_OS', 'OS/2');
 161         } else {
 162             $this->set('PMA_USR_OS', 'Other');
 163         }
 164
 165         // 2. browser and version
 166         // (must check everything else before Mozilla)
 167
 168         if (preg_match('@Opera(/| )([0-9].[0-9]{1,2})@', $HTTP_USER_AGENT, $log_version)) {
 169             $this->set('PMA_USR_BROWSER_VER', $log_version[2]);
 170             $this->set('PMA_USR_BROWSER_AGENT', 'OPERA');
 171         } elseif (preg_match('@MSIE ([0-9].[0-9]{1,2})@', $HTTP_USER_AGENT, $log_version)) {
 172             $this->set('PMA_USR_BROWSER_VER', $log_version[1]);
 173             $this->set('PMA_USR_BROWSER_AGENT', 'IE');
 174         } elseif (preg_match('@OmniWeb/([0-9].[0-9]{1,2})@', $HTTP_USER_AGENT, $log_version)) {
 175             $this->set('PMA_USR_BROWSER_VER', $log_version[1]);
 176             $this->set('PMA_USR_BROWSER_AGENT', 'OMNIWEB');
 177         // Konqueror 2.2.2 says Konqueror/2.2.2
 178         // Konqueror 3.0.3 says Konqueror/3
 179         } elseif (preg_match('@(Konqueror/)(.*)(;)@', $HTTP_USER_AGENT, $log_version)) {
 180             $this->set('PMA_USR_BROWSER_VER', $log_version[2]);
 181             $this->set('PMA_USR_BROWSER_AGENT', 'KONQUEROR');
 182         } elseif (preg_match('@Mozilla/([0-9].[0-9]{1,2})@', $HTTP_USER_AGENT, $log_version)
 183                    && preg_match('@Safari/([0-9]*)@', $HTTP_USER_AGENT, $log_version2)) {
 184             $this->set('PMA_USR_BROWSER_VER', $log_version[1] . '.' . $log_version2[1]);
 185             $this->set('PMA_USR_BROWSER_AGENT', 'SAFARI');
 186         } elseif (preg_match('@rv:1.9(.*)Gecko@', $HTTP_USER_AGENT)) {
 187             $this->set('PMA_USR_BROWSER_VER', '1.9');
 188             $this->set('PMA_USR_BROWSER_AGENT', 'GECKO');
 189         } elseif (preg_match('@Mozilla/([0-9].[0-9]{1,2})@', $HTTP_USER_AGENT, $log_version)) {
 190             $this->set('PMA_USR_BROWSER_VER', $log_version[1]);
 191             $this->set('PMA_USR_BROWSER_AGENT', 'MOZILLA');
 192         } else {
 193             $this->set('PMA_USR_BROWSER_VER', 0);
 194             $this->set('PMA_USR_BROWSER_AGENT', 'OTHER');
 195         }
 196     }
 197
 198     /**
 199      * Whether GD2 is present
 200      */
 201     function checkGd2()
 202     {
 203         if ($this->get('GD2Available') == 'yes') {
 204             $this->set('PMA_IS_GD2', 1);
 205         } elseif ($this->get('GD2Available') == 'no') {
 206             $this->set('PMA_IS_GD2', 0);
 207         } else {
 208             if (!@function_exists('imagecreatetruecolor')) {
 209                 $this->set('PMA_IS_GD2', 0);
 210             } else {
 211                 if (@function_exists('gd_info')) {
 212                     $gd_nfo = gd_info();
 213                     if (strstr($gd_nfo["GD Version"], '2.')) {
 214                         $this->set('PMA_IS_GD2', 1);
 215                     } else {
 216                         $this->set('PMA_IS_GD2', 0);
 217                     }
 218                 } else {
 219                     /* We must do hard way... but almost no chance to execute this */
 220                     ob_start();
 221                     phpinfo(INFO_MODULES); /* Only modules */
 222                     $a = strip_tags(ob_get_contents());
 223                     ob_end_clean();
 224                     /* Get GD version string from phpinfo output */
 225                     if (preg_match('@GD Version[[:space:]]*\(.*\)@', $a, $v)) {
 226                         if (strstr($v, '2.')) {
 227                             $this->set('PMA_IS_GD2', 1);
 228                         } else {
 229                             $this->set('PMA_IS_GD2', 0);
 230                         }
 231                     } else {
 232                         $this->set('PMA_IS_GD2', 0);
 233                     }
 234                 }
 235             }
 236         }
 237     }
 238
 239     /**
 240      * Whether the Web server php is running on is IIS
 241      */
 242     function checkWebServer()
 243     {
 244         if (PMA_getenv('SERVER_SOFTWARE')
 245           // some versions return Microsoft-IIS, some Microsoft/IIS
 246           // we could use a preg_match() but it's slower
 247           && stristr(PMA_getenv('SERVER_SOFTWARE'), 'Microsoft')
 248           && stristr(PMA_getenv('SERVER_SOFTWARE'), 'IIS')) {
 249             $this->set('PMA_IS_IIS', 1);
 250         } else {
 251             $this->set('PMA_IS_IIS', 0);
 252         }
 253     }
 254
 255     /**
 256      * Whether the os php is running on is windows or not
 257      */
 258     function checkWebServerOs()
 259     {
 260         // Default to Unix or Equiv
 261         $this->set('PMA_IS_WINDOWS', 0);
 262         // If PHP_OS is defined then continue
 263         if (defined('PHP_OS')) {
 264             if (stristr(PHP_OS, 'win')) {
 265                 // Is it some version of Windows
 266                 $this->set('PMA_IS_WINDOWS', 1);
 267             } elseif (stristr(PHP_OS, 'OS/2')) {
 268                 // Is it OS/2 (No file permissions like Windows)
 269                 $this->set('PMA_IS_WINDOWS', 1);
 270             }
 271         }
 272     }
 273
 274     /**
 275      * detects PHP version
 276      */
 277     function checkPhpVersion()
 278     {
 279         $match = array();
 280         if (! preg_match('@([0-9]{1,2}).([0-9]{1,2}).([0-9]{1,2})@',
 281                 phpversion(), $match)) {
 282             $result = preg_match('@([0-9]{1,2}).([0-9]{1,2})@',
 283                 phpversion(), $match);
 284         }
 285         if (isset($match) && ! empty($match[1])) {
 286             if (! isset($match[2])) {
 287                 $match[2] = 0;
 288             }
 289             if (! isset($match[3])) {
 290                 $match[3] = 0;
 291             }
 292             $this->set('PMA_PHP_INT_VERSION',
 293                 (int) sprintf('%d%02d%02d', $match[1], $match[2], $match[3]));
 294         } else {
 295             $this->set('PMA_PHP_INT_VERSION', 0);
 296         }
 297         $this->set('PMA_PHP_STR_VERSION', phpversion());
 298     }
 299
 300     /**
 301      * loads default values from default source
 302      *
 303      * @uses    file_exists()
 304      * @uses    $this->default_source
 305      * @uses    $this->error_config_default_file
 306      * @uses    $this->settings
 307      * @return  boolean     success
 308      */
 309     function loadDefaults()
 310     {
 311         $cfg = array();
 312         if (! file_exists($this->default_source)) {
 313             $this->error_config_default_file = true;
 314             return false;
 315         }
 316         include $this->default_source;
 317
 318         $this->default_source_mtime = filemtime($this->default_source);
 319
 320         $this->default_server = $cfg['Servers'][1];
 321         unset($cfg['Servers']);
 322
 323         $this->settings = PMA_array_merge_recursive($this->settings, $cfg);
 324
 325         $this->error_config_default_file = false;
 326
 327         return true;
 328     }
 329
 330     /**
 331      * loads configuration from $source, usally the config file
 332      * should be called on object creation
 333      *
 334      * @param   string $source  config file
 335      */
 336     function load($source = null)
 337     {
 338         $this->loadDefaults();
 339
 340         if (null !== $source) {
 341             $this->setSource($source);
 342         }
 343
 344         if (! $this->checkConfigSource()) {
 345             return false;
 346         }
 347
 348         $cfg = array();
 349
 350         /**
 351          * Parses the configuration file
 352          */
 353         $old_error_reporting = error_reporting(0);
 354         if (function_exists('file_get_contents')) {
 355             $eval_result =
 356                 eval('?' . '>' . trim(file_get_contents($this->getSource())));
 357         } else {
 358             $eval_result =
 359                 eval('?' . '>' . trim(implode("\n", file($this->getSource()))));
 360         }
 361         error_reporting($old_error_reporting);
 362
 363         if ($eval_result === false) {
 364             $this->error_config_file = true;
 365         } else  {
 366             $this->error_config_file = false;
 367             $this->source_mtime = filemtime($this->getSource());
 368         }
 369
 370         /**
 371          * Backward compatibility code
 372          */
 373         if (!empty($cfg['DefaultTabTable'])) {
 374             $cfg['DefaultTabTable'] = str_replace('_properties', '', str_replace('tbl_properties.php', 'tbl_sql.php', $cfg['DefaultTabTable']));
 375         }
 376         if (!empty($cfg['DefaultTabDatabase'])) {
 377             $cfg['DefaultTabDatabase'] = str_replace('_details', '', str_replace('db_details.php', 'db_sql.php', $cfg['DefaultTabDatabase']));
 378         }
 379
 380         $this->settings = PMA_array_merge_recursive($this->settings, $cfg);
 381         $this->checkPmaAbsoluteUri();
 382         $this->checkFontsize();
 383
 384         $this->checkPermissions();
 385
 386         // Handling of the collation must be done after merging of $cfg
 387         // (from config.inc.php) so that $cfg['DefaultConnectionCollation']
 388         // can have an effect. Note that the presence of collation
 389         // information in a cookie has priority over what is defined
 390         // in the default or user's config files.
 391         /**
 392          * @todo check validity of $_COOKIE['pma_collation_connection']
 393          */
 394         if (! empty($_COOKIE['pma_collation_connection'])) {
 395             $this->set('collation_connection',
 396                 strip_tags($_COOKIE['pma_collation_connection']));
 397         } else {
 398             $this->set('collation_connection',
 399                 $this->get('DefaultConnectionCollation'));
 400         }
 401         // Now, a collation information could come from REQUEST
 402         // (an example of this: the collation selector in main.php)
 403         // so the following handles the setting of collation_connection
 404         // and later, in common.inc.php, the cookie will be set
 405         // according to this.
 406         $this->checkCollationConnection();
 407
 408         return true;
 409     }
 410
 411     /**
 412      * set source
 413      * @param   string  $source
 414      */
 415     function setSource($source)
 416     {
 417         $this->source = trim($source);
 418     }
 419
 420     /**
 421      * checks if the config folder still exists and terminates app if true
 422      */
 423     function checkConfigFolder()
 424     {
 425         // Refuse to work while there still might be some world writable dir:
 426         if (is_dir('./config')) {
 427             die('Remove "./config" directory before using phpMyAdmin!');
 428         }
 429     }
 430
 431     /**
 432      * check config source
 433      *
 434      * @return  boolean whether source is valid or not
 435      */
 436     function checkConfigSource()
 437     {
 438         if (! $this->getSource()) {
 439             // no configuration file set at all
 440             return false;
 441         }
 442
 443         if (! file_exists($this->getSource())) {
 444             // do not trigger error here
 445             // https://sf.net/tracker/?func=detail&aid=1370269&group_id=23067&atid=377408
 446             /*
 447             trigger_error(
 448                 'phpMyAdmin-ERROR: unkown configuration source: ' . $source,
 449                 E_USER_WARNING);
 450             */
 451             $this->source_mtime = 0;
 452             return false;
 453         }
 454
 455         if (! is_readable($this->getSource())) {
 456             $this->source_mtime = 0;
 457             die('Existing configuration file (' . $this->getSource() . ') is not readable.');
 458         }
 459
 460         return true;
 461     }
 462
 463     /**
 464      * verifies the permissions on config file (if asked by configuration)
 465      * (must be called after config.inc.php has been merged)
 466      */
 467     function checkPermissions()
 468     {
 469         // Check for permissions (on platforms that support it):
 470         if ($this->get('CheckConfigurationPermissions')) {
 471             $perms = @fileperms($this->getSource());
 472             if (!($perms === false) && ($perms & 2)) {
 473                 // This check is normally done after loading configuration
 474                 $this->checkWebServerOs();
 475                 if ($this->get('PMA_IS_WINDOWS') == 0) {
 476                     $this->source_mtime = 0;
 477                     die('Wrong permissions on configuration file, should not be world writable!');
 478                 }
 479             }
 480         }
 481     }
 482
 483     /**
 484      * returns specific config setting
 485      * @param   string  $setting
 486      * @return  mixed   value
 487      */
 488     function get($setting)
 489     {
 490         if (isset($this->settings[$setting])) {
 491             return $this->settings[$setting];
 492         }
 493         return null;
 494     }
 495
 496     /**
 497      * sets configuration variable
 498      *
 499      * @uses    $this->settings
 500      * @param   string  $setting    configuration option
 501      * @param   string  $value      new value for configuration option
 502      */
 503     function set($setting, $value)
 504     {
 505         if (!isset($this->settings[$setting]) || $this->settings[$setting] != $value) {
 506             $this->settings[$setting] = $value;
 507             $this->set_mtime = time();
 508         }
 509     }
 510
 511     /**
 512      * returns source for current config
 513      * @return  string  config source
 514      */
 515     function getSource()
 516     {
 517         return $this->source;
 518     }
 519
 520     /**
 521      * returns a unique value to force a CSS reload if either the config
 522      * or the theme changes
 523      * must also check the pma_fontsize cookie in case there is no
 524      * config file
 525      * @return  int  Unix timestamp
 526      */
 527     function getThemeUniqueValue()
 528     {
 529         if (null !== $this->get('fontsize')) {
 530             $fontsize = intval($this->get('fontsize'));
 531         } elseif (isset($_COOKIE['pma_fontsize'])) {
 532             $fontsize = intval($_COOKIE['pma_fontsize']);
 533         } else {
 534             $fontsize = 0;
 535         }
 536         return (
 537             $fontsize +
 538             $this->source_mtime +
 539             $this->default_source_mtime +
 540             $_SESSION['PMA_Theme']->mtime_info +
 541             $_SESSION['PMA_Theme']->filesize_info)
 542             . (isset($_SESSION['tmp_user_values']['custom_color']) ? substr($_SESSION['tmp_user_values']['custom_color'],1,6) : '');
 543     }
 544
 545     /**
 546      * $cfg['PmaAbsoluteUri'] is a required directive else cookies won't be
 547      * set properly and, depending on browsers, inserting or updating a
 548      * record might fail
 549      */
 550     function checkPmaAbsoluteUri()
 551     {
 552         // Setup a default value to let the people and lazy sysadmins work anyway,
 553         // they'll get an error if the autodetect code doesn't work
 554         $pma_absolute_uri = $this->get('PmaAbsoluteUri');
 555         $is_https = $this->detectHttps();
 556
 557         if (strlen($pma_absolute_uri) < 5) {
 558             $url = array();
 559
 560             // At first we try to parse REQUEST_URI, it might contain full URL
 561             /**
 562              * REQUEST_URI contains PATH_INFO too, this is not what we want
 563              * script-php/pathinfo/
 564             if (PMA_getenv('REQUEST_URI')) {
 565                 $url = @parse_url(PMA_getenv('REQUEST_URI')); // produces E_WARNING if it cannot get parsed, e.g. '/foobar:/'
 566                 if ($url === false) {
 567                     $url = array('path' => $_SERVER['REQUEST_URI']);
 568                 }
 569             }
 570              */
 571
 572             // If we don't have scheme, we didn't have full URL so we need to
 573             // dig deeper
 574             if (empty($url['scheme'])) {
 575                 // Scheme
 576                 if (PMA_getenv('HTTP_SCHEME')) {
 577                     $url['scheme'] = PMA_getenv('HTTP_SCHEME');
 578                 } else {
 579                     $url['scheme'] =
 580                         PMA_getenv('HTTPS') && strtolower(PMA_getenv('HTTPS')) != 'off'
 581                             ? 'https'
 582                             : 'http';
 583                 }
 584
 585                 // Host and port
 586                 if (PMA_getenv('HTTP_HOST')) {
 587                     // Prepend the scheme before using parse_url() since this is not part of the RFC2616 Host request-header
 588                     $parsed_url = parse_url($url['scheme'] . '://' . PMA_getenv('HTTP_HOST'));
 589                     if (!empty($parsed_url['host'])) {
 590                         $url = $parsed_url;
 591                     } else {
 592                         $url['host'] = PMA_getenv('HTTP_HOST');
 593                     }
 594                 } elseif (PMA_getenv('SERVER_NAME')) {
 595                     $url['host'] = PMA_getenv('SERVER_NAME');
 596                 } else {
 597                     $this->error_pma_uri = true;
 598                     return false;
 599                 }
 600
 601                 // If we didn't set port yet...
 602                 if (empty($url['port']) && PMA_getenv('SERVER_PORT')) {
 603                     $url['port'] = PMA_getenv('SERVER_PORT');
 604                 }
 605
 606                 // And finally the path could be already set from REQUEST_URI
 607                 if (empty($url['path'])) {
 608                     /**
 609                      * REQUEST_URI contains PATH_INFO too, this is not what we want
 610                      * script-php/pathinfo/
 611                     if (PMA_getenv('PATH_INFO')) {
 612                         $path = parse_url(PMA_getenv('PATH_INFO'));
 613                     } else {
 614                         // PHP_SELF in CGI often points to cgi executable, so use it
 615                         // as last choice
 616                      */
 617                         $path = parse_url($GLOBALS['PMA_PHP_SELF']);
 618                     //}
 619                     $url['path'] = $path['path'];
 620                 }
 621             }
 622
 623             // Make url from parts we have
 624             $pma_absolute_uri = $url['scheme'] . '://';
 625             // Was there user information?
 626             if (!empty($url['user'])) {
 627                 $pma_absolute_uri .= $url['user'];
 628                 if (!empty($url['pass'])) {
 629                     $pma_absolute_uri .= ':' . $url['pass'];
 630                 }
 631                 $pma_absolute_uri .= '@';
 632             }
 633             // Add hostname
 634             $pma_absolute_uri .= $url['host'];
 635             // Add port, if it not the default one
 636             if (! empty($url['port'])
 637               && (($url['scheme'] == 'http' && $url['port'] != 80)
 638                 || ($url['scheme'] == 'https' && $url['port'] != 443))) {
 639                 $pma_absolute_uri .= ':' . $url['port'];
 640             }
 641             // And finally path, without script name, the 'a' is there not to
 642             // strip our directory, when path is only /pmadir/ without filename.
 643             // Backslashes returned by Windows have to be changed.
 644             // Only replace backslashes by forward slashes if on Windows,
 645             // as the backslash could be valid on a non-Windows system.
 646             $this->checkWebServerOs();
 647             if ($this->get('PMA_IS_WINDOWS') == 1) {
 648                 $path = str_replace("\\", "/", dirname($url['path'] . 'a'));
 649             } else {
 650                 $path = dirname($url['path'] . 'a');
 651             }
 652
 653             // To work correctly within transformations overview:
 654             if (defined('PMA_PATH_TO_BASEDIR') && PMA_PATH_TO_BASEDIR == '../../') {
 655                 if ($this->get('PMA_IS_WINDOWS') == 1) {
 656                     $path = str_replace("\\", "/", dirname(dirname($path)));
 657                 } else {
 658                     $path = dirname(dirname($path));
 659                 }
 660             }
 661
 662             // PHP's dirname function would have returned a dot when $path contains no slash
 663             if ($path == '.') {
 664                 $path = '';
 665             }
 666             // in vhost situations, there could be already an ending slash
 667             if (substr($path, -1) != '/') {
 668                 $path .= '/';
 669             }
 670             $pma_absolute_uri .= $path;
 671
 672             // We used to display a warning if PmaAbsoluteUri wasn't set, but now
 673             // the autodetect code works well enough that we don't display the
 674             // warning at all. The user can still set PmaAbsoluteUri manually.
 675             // See
 676             // http://sf.net/tracker/?func=detail&aid=1257134&group_id=23067&atid=377411
 677
 678         } else {
 679             // The URI is specified, however users do often specify this
 680             // wrongly, so we try to fix this.
 681
 682             // Adds a trailing slash et the end of the phpMyAdmin uri if it
 683             // does not exist.
 684             if (substr($pma_absolute_uri, -1) != '/') {
 685                 $pma_absolute_uri .= '/';
 686             }
 687
 688             // If URI doesn't start with http:// or https://, we will add
 689             // this.
 690             if (substr($pma_absolute_uri, 0, 7) != 'http://'
 691               && substr($pma_absolute_uri, 0, 8) != 'https://') {
 692                 $pma_absolute_uri =
 693                     ($is_https ? 'https' : 'http')
 694                     . ':' . (substr($pma_absolute_uri, 0, 2) == '//' ? '' : '//')
 695                     . $pma_absolute_uri;
 696             }
 697         }
 698         $this->set('PmaAbsoluteUri', $pma_absolute_uri);
 699     }
 700
 701     /**
 702      * check selected collation_connection
 703      * @todo check validity of $_REQUEST['collation_connection']
 704      */
 705     function checkCollationConnection()
 706     {
 707         if (! empty($_REQUEST['collation_connection'])) {
 708             $this->set('collation_connection',
 709                 strip_tags($_REQUEST['collation_connection']));
 710         }
 711     }
 712
 713     /**
 714      * checks for font size configuration, and sets font size as requested by user
 715      *
 716      * @uses    $_GET
 717      * @uses    $_POST
 718      * @uses    $_COOKIE
 719      * @uses    preg_match()
 720      * @uses    function_exists()
 721      * @uses    PMA_Config::set()
 722      * @uses    PMA_Config::get()
 723      * @uses    PMA_Config::setCookie()
 724      */
 725     function checkFontsize()
 726     {
 727         $new_fontsize = '';
 728
 729         if (isset($_GET['fontsize'])) {
 730             $new_fontsize = $_GET['fontsize'];
 731         } elseif (isset($_POST['fontsize'])) {
 732             $new_fontsize = $_POST['fontsize'];
 733         } elseif (isset($_COOKIE['pma_fontsize'])) {
 734             $new_fontsize = $_COOKIE['pma_fontsize'];
 735         }
 736
 737         if (preg_match('/^[0-9.]+(px|em|pt|\%)$/', $new_fontsize)) {
 738             $this->set('fontsize', $new_fontsize);
 739         } elseif (! $this->get('fontsize')) {
 740             // 80% would correspond to the default browser font size
 741             // of 16, but use 82% to help read the monoface font
 742             $this->set('fontsize', '82%');
 743         }
 744
 745         $this->setCookie('pma_fontsize', $this->get('fontsize'), '82%');
 746     }
 747
 748     /**
 749      * checks if upload is enabled
 750      *
 751      */
 752
 753     function checkUpload()
 754     {
 755         if (ini_get('file_uploads')) {
 756             $this->set('enable_upload', true);
 757             // if set "php_admin_value file_uploads Off" in httpd.conf
 758             // ini_get() also returns the string "Off" in this case:
 759             if ('off' == strtolower(ini_get('file_uploads'))) {
 760                 $this->set('enable_upload', false);
 761             }
 762          } else {
 763             $this->set('enable_upload', false);
 764          }
 765     }
 766
 767     /**
 768      * Maximum upload size as limited by PHP
 769      * Used with permission from Moodle (http://moodle.org) by Martin Dougiamas
 770      *
 771      * this section generates $max_upload_size in bytes
 772      */
 773     function checkUploadSize()
 774     {
 775         if (! $filesize = ini_get('upload_max_filesize')) {
 776             $filesize = "5M";
 777         }
 778
 779         if ($postsize = ini_get('post_max_size')) {
 780             $this->set('max_upload_size',
 781                 min(PMA_get_real_size($filesize), PMA_get_real_size($postsize)));
 782         } else {
 783             $this->set('max_upload_size', PMA_get_real_size($filesize));
 784         }
 785     }
 786
 787     /**
 788      * check for https
 789      */
 790     function checkIsHttps()
 791     {
 792         $this->set('is_https', $this->isHttps());
 793     }
 794
 795     /**
 796      * @static
 797      */
 798     public function isHttps()
 799     {
 800         static $is_https = null;
 801
 802         if (null !== $is_https) {
 803             return $is_https;
 804         }
 805
 806         $url = parse_url($this->get('PmaAbsoluteUri'));
 807
 808         if (isset($url['scheme'])
 809           && $url['scheme'] == 'https') {
 810             $is_https = true;
 811         } else {
 812             $is_https = false;
 813         }
 814
 815         return $is_https;
 816     }
 817
 818     /**
 819      * Detects whether https appears to be used.
 820      *
 821      * Please note that this just detects what we see, so
 822      * it completely ignores things like reverse proxies.
 823      */
 824     function detectHttps()
 825     {
 826         $is_https = false;
 827
 828         $url = array();
 829
 830         // At first we try to parse REQUEST_URI, it might contain full URL,
 831         if (PMA_getenv('REQUEST_URI')) {
 832             $url = @parse_url(PMA_getenv('REQUEST_URI')); // produces E_WARNING if it cannot get parsed, e.g. '/foobar:/'
 833             if($url === false) {
 834                 $url = array();
 835             }
 836         }
 837
 838         // If we don't have scheme, we didn't have full URL so we need to
 839         // dig deeper
 840         if (empty($url['scheme'])) {
 841             // Scheme
 842             if (PMA_getenv('HTTP_SCHEME')) {
 843                 $url['scheme'] = PMA_getenv('HTTP_SCHEME');
 844             } else {
 845                 $url['scheme'] =
 846                     PMA_getenv('HTTPS') && strtolower(PMA_getenv('HTTPS')) != 'off'
 847                         ? 'https'
 848                         : 'http';
 849             }
 850         }
 851
 852         if (isset($url['scheme'])
 853           && $url['scheme'] == 'https') {
 854             $is_https = true;
 855         } else {
 856             $is_https = false;
 857         }
 858
 859         return $is_https;
 860     }
 861
 862     /**
 863      * detect correct cookie path
 864      */
 865     function checkCookiePath()
 866     {
 867         $this->set('cookie_path', $this->getCookiePath());
 868     }
 869
 870     /**
 871      * @static
 872      */
 873     public function getCookiePath()
 874     {
 875         static $cookie_path = null;
 876
 877         if (null !== $cookie_path) {
 878             return $cookie_path;
 879         }
 880
 881         $parsed_url = parse_url($this->get('PmaAbsoluteUri'));
 882
 883         $cookie_path   = $parsed_url['path'];
 884
 885         return $cookie_path;
 886     }
 887
 888     /**
 889      * enables backward compatibility
 890      */
 891     function enableBc()
 892     {
 893         $GLOBALS['cfg']             = $this->settings;
 894         $GLOBALS['default_server']  = $this->default_server;
 895         unset($this->default_server);
 896         $GLOBALS['collation_connection'] = $this->get('collation_connection');
 897         $GLOBALS['is_upload']       = $this->get('enable_upload');
 898         $GLOBALS['max_upload_size'] = $this->get('max_upload_size');
 899         $GLOBALS['cookie_path']     = $this->get('cookie_path');
 900         $GLOBALS['is_https']        = $this->get('is_https');
 901
 902         $defines = array(
 903             'PMA_VERSION',
 904             'PMA_THEME_VERSION',
 905             'PMA_THEME_GENERATION',
 906             'PMA_PHP_STR_VERSION',
 907             'PMA_PHP_INT_VERSION',
 908             'PMA_IS_WINDOWS',
 909             'PMA_IS_IIS',
 910             'PMA_IS_GD2',
 911             'PMA_USR_OS',
 912             'PMA_USR_BROWSER_VER',
 913             'PMA_USR_BROWSER_AGENT'
 914             );
 915
 916         foreach ($defines as $define) {
 917             if (! defined($define)) {
 918                 define($define, $this->get($define));
 919             }
 920         }
 921     }
 922
 923     /**
 924      * @todo finish
 925      */
 926     function save() {}
 927
 928     /**
 929      * returns options for font size selection
 930      *
 931      * @uses    preg_replace()
 932      * @uses    ksort()
 933      * @static
 934      * @param   string  $current_size   current selected font size with unit
 935      * @return  array   selectable font sizes
 936      */
 937     static protected function _getFontsizeOptions($current_size = '82%')
 938     {
 939         $unit = preg_replace('/[0-9.]*/', '', $current_size);
 940         $value = preg_replace('/[^0-9.]*/', '', $current_size);
 941
 942         $factors = array();
 943         $options = array();
 944         $options["$value"] = $value . $unit;
 945
 946         if ($unit === '%') {
 947             $factors[] = 1;
 948             $factors[] = 5;
 949             $factors[] = 10;
 950         } elseif ($unit === 'em') {
 951             $factors[] = 0.05;
 952             $factors[] = 0.2;
 953             $factors[] = 1;
 954         } elseif ($unit === 'pt') {
 955             $factors[] = 0.5;
 956             $factors[] = 2;
 957         } elseif ($unit === 'px') {
 958             $factors[] = 1;
 959             $factors[] = 5;
 960             $factors[] = 10;
 961         } else {
 962             //unknown font size unit
 963             $factors[] = 0.05;
 964             $factors[] = 0.2;
 965             $factors[] = 1;
 966             $factors[] = 5;
 967             $factors[] = 10;
 968         }
 969
 970         foreach ($factors as $key => $factor) {
 971             $option_inc = $value + $factor;
 972             $option_dec = $value - $factor;
 973             while (count($options) < 21) {
 974                 $options["$option_inc"] = $option_inc . $unit;
 975                 if ($option_dec > $factors[0]) {
 976                     $options["$option_dec"] = $option_dec . $unit;
 977                 }
 978                 $option_inc += $factor;
 979                 $option_dec -= $factor;
 980                 if (isset($factors[$key + 1])
 981                  && $option_inc >= $value + $factors[$key + 1]) {
 982                     break;
 983                 }
 984             }
 985         }
 986         ksort($options);
 987         return $options;
 988     }
 989
 990     /**
 991      * returns html selectbox for font sizes
 992      *
 993      * @uses    $GLOBALS['PMA_Config']
 994      * @uses    PMA_Config::get()
 995      * @uses    PMA_Config::_getFontsizeOptions()
 996      * @static
 997      * @param   string  $current_size   currently slected font size with unit
 998      * @return  string  html selectbox
 999      */
1000     static protected function _getFontsizeSelection()
1001     {
1002         $current_size = $GLOBALS['PMA_Config']->get('fontsize');
1003         // for the case when there is no config file (this is supported)
1004         if (empty($current_size)) {
1005             if (isset($_COOKIE['pma_fontsize'])) {
1006                 $current_size = $_COOKIE['pma_fontsize'];
1007             } else {
1008                 $current_size = '82%';
1009             }
1010         }
1011         $options = PMA_Config::_getFontsizeOptions($current_size);
1012
1013         $return = '<label for="select_fontsize">' . __('Font size') . ':</label>' . "\n";
1014         $return .= '<select name="fontsize" id="select_fontsize" onchange="this.form.submit();">' . "\n";
1015         foreach ($options as $option) {
1016             $return .= '<option value="' . $option . '"';
1017             if ($option == $current_size) {
1018                 $return .= ' selected="selected"';
1019             }
1020             $return .= '>' . $option . '</option>' . "\n";
1021         }
1022         $return .= '</select>';
1023
1024         return $return;
1025     }
1026
1027     /**
1028      * return complete font size selection form
1029      *
1030      * @uses    PMA_generate_common_hidden_inputs()
1031      * @uses    PMA_Config::_getFontsizeSelection()
1032      * @static
1033      * @param   string  $current_size   currently slected font size with unit
1034      * @return  string  html selectbox
1035      */
1036     static public function getFontsizeForm()
1037     {
1038         return '<form name="form_fontsize_selection" id="form_fontsize_selection"'
1039             . ' method="post" action="index.php" target="_parent">' . "\n"
1040             . PMA_generate_common_hidden_inputs() . "\n"
1041             . PMA_Config::_getFontsizeSelection() . "\n"
1042             . '<noscript>' . "\n"
1043             . '<input type="submit" value="' . __('Go') . '" />' . "\n"
1044             . '</noscript>' . "\n"
1045             . '</form>';
1046     }
1047
1048     /**
1049      * removes cookie
1050      *
1051      * @uses    PMA_Config::isHttps()
1052      * @uses    PMA_Config::getCookiePath()
1053      * @uses    setcookie()
1054      * @uses    time()
1055      * @param   string  $cookie     name of cookie to remove
1056      * @return  boolean result of setcookie()
1057      */
1058     function removeCookie($cookie)
1059     {
1060         return setcookie($cookie, '', time() - 3600,
1061             $this->getCookiePath(), '', $this->isHttps());
1062     }
1063
1064     /**
1065      * sets cookie if value is different from current cokkie value,
1066      * or removes if value is equal to default
1067      *
1068      * @uses    PMA_Config::isHttps()
1069      * @uses    PMA_Config::getCookiePath()
1070      * @uses    $_COOKIE
1071      * @uses    PMA_Config::removeCookie()
1072      * @uses    setcookie()
1073      * @uses    time()
1074      * @param   string  $cookie     name of cookie to remove
1075      * @param   mixed   $value      new cookie value
1076      * @param   string  $default    default value
1077      * @param   int     $validity   validity of cookie in seconds (default is one month)
1078      * @param   bool    $httponlt   whether cookie is only for HTTP (and not for scripts)
1079      * @return  boolean result of setcookie()
1080      */
1081     function setCookie($cookie, $value, $default = null, $validity = null, $httponly = true)
1082     {
1083         if ($validity == null) {
1084             $validity = 2592000;
1085         }
1086         if (strlen($value) && null !== $default && $value === $default) {
1087             // default value is used
1088             if (isset($_COOKIE[$cookie])) {
1089                 // remove cookie
1090                 return $this->removeCookie($cookie);
1091             }
1092             return false;
1093         }
1094
1095         if (! strlen($value) && isset($_COOKIE[$cookie])) {
1096             // remove cookie, value is empty
1097             return $this->removeCookie($cookie);
1098         }
1099
1100         if (! isset($_COOKIE[$cookie]) || $_COOKIE[$cookie] !== $value) {
1101             // set cookie with new value
1102             /* Calculate cookie validity */
1103             if ($validity == 0) {
1104                 $v = 0;
1105             } else {
1106                 $v = time() + $validity;
1107             }
1108             return setcookie($cookie, $value, $v,
1109                 $this->getCookiePath(), '', $this->isHttps(), $httponly);
1110         }
1111
1112         // cookie has already $value as value
1113         return true;
1114     }
1115 }
1116 ?>