libraries/config/ConfigFile.class.php

   1 <?php
   2 /* vim: set expandtab sw=4 ts=4 sts=4: */
   3 /**
   4  * Config file management
   5  *
   6  * @package phpMyAdmin
   7  */
   8
   9 /**
  10  * Config file management class.
  11  * Stores its data in $_SESSION
  12  *
  13  * @package    phpMyAdmin
  14  */
  15 class ConfigFile
  16 {
  17     /**
  18      * Stores default PMA config from config.default.php
  19      * @var array
  20      */
  21     private $cfg;
  22
  23     /**
  24      * Stores original PMA_Config object, not modified by user preferences
  25      * @var PMA_Config
  26      */
  27     private $orgCfgObject;
  28
  29     /**
  30      * Stores allowed values for non-standard fields
  31      * @var array
  32      */
  33     private $cfgDb;
  34
  35     /**
  36      * Keys which will be always written to config file
  37      * @var array
  38      */
  39     private $persistKeys = array();
  40
  41     /**
  42      * Changes keys while updating config in {@link updateWithGlobalConfig()} or reading
  43      * by {@link getConfig()} or {@link getConfigArray()}
  44      * @var array
  45      */
  46     private $cfgUpdateReadMapping = array();
  47
  48     /**
  49      * Key filter for {@link set()}
  50      * @var array|null
  51      */
  52     private $setFilter;
  53
  54     /**
  55      * Instance id (key in $_SESSION array, separate for each server - ConfigFile{server id})
  56      * @var string
  57      */
  58     private $id;
  59
  60     /**
  61      * Result for {@link _flattenArray()}
  62      * @var array
  63      */
  64     private $_flattenArrayResult;
  65
  66     /**
  67      * ConfigFile instance
  68      * @var ConfigFile
  69      */
  70     private static $_instance;
  71
  72     /**
  73      * Private constructor, use {@link getInstance()}
  74      *
  75      */
  76     private function __construct()
  77     {
  78         // load default config values
  79         $cfg = &$this->cfg;
  80         require './libraries/config.default.php';
  81         $cfg['fontsize'] = '82%';
  82
  83         // create PMA_Config to read config.inc.php values
  84         $this->orgCfgObject = new PMA_Config(CONFIG_FILE);
  85
  86         // load additional config information
  87         $cfg_db = &$this->cfgDb;
  88         require './libraries/config.values.php';
  89
  90         // apply default values overrides
  91         if (count($cfg_db['_overrides'])) {
  92             foreach ($cfg_db['_overrides'] as $path => $value) {
  93                 PMA_array_write($path, $cfg, $value);
  94             }
  95         }
  96
  97         $this->id = 'ConfigFile' . $GLOBALS['server'];
  98         if (!isset($_SESSION[$this->id])) {
  99             $_SESSION[$this->id] = array();
 100         }
 101     }
 102
 103     /**
 104      * Returns class instance
 105      *
 106      * @return ConfigFile
 107      */
 108     public static function getInstance()
 109     {
 110         if (is_null(self::$_instance)) {
 111             self::$_instance = new ConfigFile();
 112         }
 113         return self::$_instance;
 114     }
 115
 116     /**
 117      * Returns PMA_Config without user preferences applied
 118      *
 119      * @return PMA_Config
 120      */
 121     public function getOrgConfigObj()
 122     {
 123         return $this->orgCfgObject;
 124     }
 125
 126     /**
 127      * Sets names of config options which will be placed in config file even if they are set
 128      * to their default values (use only full paths)
 129      *
 130      * @param array $keys
 131      */
 132     public function setPersistKeys($keys)
 133     {
 134         // checking key presence is much faster than searching so move values to keys
 135         $this->persistKeys = array_flip($keys);
 136     }
 137
 138     /**
 139      * Returns flipped array set by {@link setPersistKeys()}
 140      *
 141      * @return array
 142      */
 143     public function getPersistKeysMap()
 144     {
 145         return $this->persistKeys;
 146     }
 147
 148     /**
 149      * By default ConfigFile allows setting of all configuration keys, use this method
 150      * to set up a filter on {@link set()} method
 151      *
 152      * @param array|null $keys array of allowed keys or null to remove filter
 153      */
 154     public function setAllowedKeys($keys)
 155     {
 156         if ($keys === null) {
 157             $this->setFilter = null;
 158             return;
 159         }
 160         // checking key presence is much faster than searching so move values to keys
 161         $this->setFilter = array_flip($keys);
 162     }
 163
 164     /**
 165      * Sets path mapping for updating config in {@link updateWithGlobalConfig()} or reading
 166      * by {@link getConfig()} or {@link getConfigArray()}
 167      * @var array
 168      */
 169     public function setCfgUpdateReadMapping(array $mapping)
 170     {
 171         $this->cfgUpdateReadMapping = $mapping;
 172     }
 173
 174     /**
 175      * Resets configuration data
 176      */
 177     public function resetConfigData()
 178     {
 179         $_SESSION[$this->id] = array();
 180     }
 181
 182     /**
 183      * Sets configuration data (overrides old data)
 184      *
 185      * @param array $cfg
 186      */
 187     public function setConfigData(array $cfg)
 188     {
 189         $_SESSION[$this->id] = $cfg;
 190     }
 191
 192     /**
 193      * Sets config value
 194      *
 195      * @param string $path
 196      * @param mixed  $value
 197      * @param string $canonical_path
 198      */
 199     public function set($path, $value, $canonical_path = null)
 200     {
 201         if ($canonical_path === null) {
 202             $canonical_path = $this->getCanonicalPath($path);
 203         }
 204         // apply key whitelist
 205         if ($this->setFilter !== null && !isset($this->setFilter[$canonical_path])) {
 206             return;
 207         }
 208         // remove if the path isn't protected and it's empty or has a default value
 209         if (!isset($this->persistKeys[$canonical_path])) {
 210             $default_value = $this->getDefault($canonical_path);
 211             // we need oryginal config values not overwritten by user preferences
 212             // to allow for overwriting options set in config.inc.php with default values
 213             $instance_default_value = PMA_array_read($canonical_path, $this->orgCfgObject->settings);
 214             if (($value === $default_value && (defined('PMA_SETUP') || $instance_default_value === $default_value))
 215                     || (empty($value) && empty($default_value) && (defined('PMA_SETUP') || empty($current_global)))) {
 216                 PMA_array_remove($path, $_SESSION[$this->id]);
 217                 return;
 218             }
 219         }
 220         PMA_array_write($path, $_SESSION[$this->id], $value);
 221     }
 222
 223     /**
 224      * Flattens multidimensional array, changes indices to paths (eg. 'key/subkey').
 225      * Used as array_walk() callback.
 226      *
 227      * @param mixed $value
 228      * @param mixed $key
 229      * @param mixed $prefix
 230      */
 231     private function _flattenArray($value, $key, $prefix)
 232     {
 233         // no recursion for numeric arrays
 234         if (is_array($value) && !isset($value[0])) {
 235             $prefix .= $key . '/';
 236             array_walk($value, array($this, '_flattenArray'), $prefix);
 237         } else {
 238             $this->_flattenArrayResult[$prefix . $key] = $value;
 239         }
 240     }
 241
 242     /**
 243      * Returns default config in a flattened array
 244      *
 245      * @return array
 246      */
 247     public function getFlatDefaultConfig()
 248     {
 249         $this->_flattenArrayResult = array();
 250         array_walk($this->cfg, array($this, '_flattenArray'), '');
 251         $flat_cfg = $this->_flattenArrayResult;
 252         $this->_flattenArrayResult = null;
 253         return $flat_cfg;
 254     }
 255
 256     /**
 257      * Updates config with values read from given array
 258      * (config will contain differences to defaults from config.defaults.php).
 259      *
 260      * @param array $cfg
 261      */
 262     public function updateWithGlobalConfig(array $cfg)
 263     {
 264         // load config array and flatten it
 265         $this->_flattenArrayResult = array();
 266         array_walk($cfg, array($this, '_flattenArray'), '');
 267         $flat_cfg = $this->_flattenArrayResult;
 268         $this->_flattenArrayResult = null;
 269
 270         // save values
 271         // map for translating a few user preferences paths, should be complemented
 272         // by code reading from generated config to perform inverse mapping
 273         foreach ($flat_cfg as $path => $value) {
 274             if (isset($this->cfgUpdateReadMapping[$path])) {
 275                 $path = $this->cfgUpdateReadMapping[$path];
 276             }
 277             $this->set($path, $value, $path);
 278         }
 279     }
 280
 281     /**
 282      * Returns config value or $default if it's not set
 283      *
 284      * @param  string $path
 285      * @param  mixed  $default
 286      * @return mixed
 287      */
 288     public function get($path, $default = null)
 289     {
 290         return PMA_array_read($path, $_SESSION[$this->id], $default);
 291     }
 292
 293     /**
 294      * Returns default config value or $default it it's not set ie. it doesn't
 295      * exist in config.default.php ($cfg) and config.values.php
 296      * ($_cfg_db['_overrides'])
 297      *
 298      * @param  string $canonical_path
 299      * @param  mixed  $default
 300      * @return mixed
 301      */
 302     public function getDefault($canonical_path, $default = null)
 303     {
 304         return PMA_array_read($canonical_path, $this->cfg, $default);
 305     }
 306
 307     /**
 308      * Returns config value, if it's not set uses the default one; returns
 309      * $default if the path isn't set and doesn't contain a default value
 310      *
 311      * @param  string $path
 312      * @param  mixed  $default
 313      * @return mixed
 314      */
 315     public function getValue($path, $default = null)
 316     {
 317         $v = PMA_array_read($path, $_SESSION[$this->id], null);
 318         if ($v !== null) {
 319             return $v;
 320         }
 321         $path = $this->getCanonicalPath($path);
 322         return $this->getDefault($path, $default);
 323     }
 324
 325     /**
 326      * Returns canonical path
 327      *
 328      * @param string $path
 329      * @return string
 330      */
 331     public function getCanonicalPath($path) {
 332         return preg_replace('#^Servers/([\d]+)/#', 'Servers/1/', $path);
 333     }
 334
 335     /**
 336      * Returns config database entry for $path ($cfg_db in config_info.php)
 337      *
 338      * @param  string $path
 339      * @param  mixed  $default
 340      * @return mixed
 341      */
 342     public function getDbEntry($path, $default = null)
 343     {
 344         return PMA_array_read($path, $this->cfgDb, $default);
 345     }
 346
 347     /**
 348      * Returns server count
 349      *
 350      * @return int
 351      */
 352     public function getServerCount()
 353     {
 354         return isset($_SESSION[$this->id]['Servers'])
 355             ? count($_SESSION[$this->id]['Servers'])
 356             : 0;
 357     }
 358
 359     /**
 360      * Returns server list
 361      *
 362      * @return array|null
 363      */
 364     public function getServers()
 365     {
 366       return isset($_SESSION[$this->id]['Servers'])
 367           ? $_SESSION[$this->id]['Servers']
 368           : null;
 369     }
 370
 371     /**
 372      * Returns DSN of given server
 373      *
 374      * @param integer $server
 375      * @return string
 376      */
 377     function getServerDSN($server)
 378     {
 379         if (!isset($_SESSION[$this->id]['Servers'][$server])) {
 380             return '';
 381         }
 382
 383         $path = 'Servers/' . $server;
 384         $dsn = $this->getValue("$path/extension") . '://';
 385         if ($this->getValue("$path/auth_type") == 'config') {
 386             $dsn .= $this->getValue("$path/user");
 387             if (!$this->getValue("$path/nopassword")) {
 388                 $dsn .= ':***';
 389             }
 390             $dsn .= '@';
 391         }
 392         if ($this->getValue("$path/connect_type") == 'tcp') {
 393             $dsn .= $this->getValue("$path/host");
 394             $port = $this->getValue("$path/port");
 395             if ($port) {
 396                 $dsn .= ':' . $port;
 397             }
 398         } else {
 399             $dsn .= $this->getValue("$path/socket");
 400         }
 401         return $dsn;
 402     }
 403
 404     /**
 405      * Returns server name
 406      *
 407      * @param int $id
 408      * @return string
 409      */
 410     public function getServerName($id)
 411     {
 412         if (!isset($_SESSION[$this->id]['Servers'][$id])) {
 413             return '';
 414         }
 415         $verbose = $this->get("Servers/$id/verbose");
 416         if (!empty($verbose)) {
 417             return $verbose;
 418         }
 419         $host = $this->get("Servers/$id/host");
 420         return empty($host) ? 'localhost' : $host;
 421     }
 422
 423     /**
 424      * Removes server
 425      *
 426      * @param int $server
 427      */
 428     public function removeServer($server)
 429     {
 430         if (!isset($_SESSION[$this->id]['Servers'][$server])) {
 431             return;
 432         }
 433         $last_server = $this->getServerCount();
 434
 435         for ($i = $server; $i < $last_server; $i++) {
 436             $_SESSION[$this->id]['Servers'][$i] = $_SESSION[$this->id]['Servers'][$i+1];
 437         }
 438         unset($_SESSION[$this->id]['Servers'][$last_server]);
 439
 440         if (isset($_SESSION[$this->id]['ServerDefault'])
 441             && $_SESSION[$this->id]['ServerDefault'] >= 0) {
 442             unset($_SESSION[$this->id]['ServerDefault']);
 443         }
 444     }
 445
 446     /**
 447      * Returns config file path, relative to phpMyAdmin's root path
 448      *
 449      * @return string
 450      */
 451     public function getFilePath()
 452     {
 453         // Load paths
 454         if (!defined('SETUP_CONFIG_FILE')) {
 455             require_once './libraries/vendor_config.php';
 456         }
 457
 458         return SETUP_CONFIG_FILE;
 459     }
 460
 461     /**
 462      * Returns configuration array (full, multidimensional format)
 463      *
 464      * @return array
 465      */
 466     public function getConfig()
 467     {
 468         $c = $_SESSION[$this->id];
 469         foreach ($this->cfgUpdateReadMapping as $map_to => $map_from) {
 470             PMA_array_write($map_to, $c, PMA_array_read($map_from, $c));
 471             PMA_array_remove($map_from, $c);
 472         }
 473         return $c;
 474     }
 475
 476     /**
 477      * Returns configuration array (flat format)
 478      *
 479      * @return array
 480      */
 481     public function getConfigArray()
 482     {
 483         $this->_flattenArrayResult = array();
 484         array_walk($_SESSION[$this->id], array($this, '_flattenArray'), '');
 485         $c = $this->_flattenArrayResult;
 486         $this->_flattenArrayResult = null;
 487
 488         $persistKeys = array_diff(array_keys($this->persistKeys), array_keys($c));
 489         foreach ($persistKeys as $k) {
 490             $c[$k] = $this->getDefault($k);
 491         }
 492
 493         foreach ($this->cfgUpdateReadMapping as $map_to => $map_from) {
 494             if (!isset($c[$map_from])) {
 495                 continue;
 496             }
 497             $c[$map_to] = $c[$map_from];
 498             unset($c[$map_from]);
 499         }
 500         return $c;
 501     }
 502 }
 503 ?>