includes/installer/Installer.php

   1 <?php
   2
   3 /**
   4  * Base installer class
   5  * Handles everything that is independent of user interface
   6  */
   7 abstract class Installer {
   8         var $settings, $output;
   9
  10         /**
  11          * MediaWiki configuration globals that will eventually be passed through
  12          * to LocalSettings.php. The names only are given here, the defaults
  13          * typically come from DefaultSettings.php.
  14          */
  15         protected $defaultVarNames = array(
  16                 'wgSitename',
  17                 'wgPasswordSender',
  18                 'wgLanguageCode',
  19                 'wgRightsIcon',
  20                 'wgRightsText',
  21                 'wgRightsUrl',
  22                 'wgMainCacheType',
  23                 'wgEnableEmail',
  24                 'wgEnableUserEmail',
  25                 'wgEnotifUserTalk',
  26                 'wgEnotifWatchlist',
  27                 'wgEmailAuthentication',
  28                 'wgDBtype',
  29                 'wgDiff3',
  30                 'wgImageMagickConvertCommand',
  31                 'IP',
  32                 'wgScriptPath',
  33                 'wgScriptExtension',
  34                 'wgMetaNamespace',
  35                 'wgDeletedDirectory',
  36                 'wgEnableUploads',
  37                 'wgLogo',
  38                 'wgShellLocale',
  39                 'wgSecretKey',
  40                 'wgUseInstantCommons',
  41         );
  42
  43         /**
  44          * Variables that are stored alongside globals, and are used for any
  45          * configuration of the installation process aside from the MediaWiki
  46          * configuration. Map of names to defaults.
  47          */
  48         protected $internalDefaults = array(
  49                 '_UserLang' => 'en',
  50                 '_Environment' => false,
  51                 '_CompiledDBs' => array(),
  52                 '_SafeMode' => false,
  53                 '_RaiseMemory' => false,
  54                 '_UpgradeDone' => false,
  55                 '_InstallDone' => false,
  56                 '_Caches' => array(),
  57                 '_InstallUser' => 'root',
  58                 '_InstallPassword' => '',
  59                 '_SameAccount' => true,
  60                 '_CreateDBAccount' => false,
  61                 '_NamespaceType' => 'site-name',
  62                 '_AdminName' => '', // will be set later, when the user selects language
  63                 '_AdminPassword' => '',
  64                 '_AdminPassword2' => '',
  65                 '_AdminEmail' => '',
  66                 '_Subscribe' => false,
  67                 '_SkipOptional' => 'continue',
  68                 '_RightsProfile' => 'wiki',
  69                 '_LicenseCode' => 'none',
  70                 '_CCDone' => false,
  71                 '_Extensions' => array(),
  72                 '_MemCachedServers' => '',
  73                 '_ExternalHTTP' => false,
  74         );
  75
  76         /**
  77          * Known database types. These correspond to the class names <type>Installer,
  78          * and are also MediaWiki database types valid for $wgDBtype.
  79          *
  80          * To add a new type, create a <type>Installer class and a Database<type>
  81          * class, and add a config-type-<type> message to MessagesEn.php.
  82          */
  83         private $dbTypes = array(
  84                 'mysql',
  85                 'postgres',
  86                 'sqlite',
  87                 'oracle'
  88         );
  89
  90         /**
  91          * Minimum memory size in MB
  92          */
  93         private $minMemorySize = 50;
  94
  95         /**
  96          * Cached DB installer instances, access using getDBInstaller()
  97          */
  98         private $dbInstallers = array();
  99
 100         /**
 101          * A list of environment check methods called by doEnvironmentChecks().
 102          * These may output warnings using showMessage(), and/or abort the
 103          * installation process by returning false.
 104          */
 105         protected $envChecks = array(
 106                 'envLatestVersion',
 107                 'envCheckDB',
 108                 'envCheckRegisterGlobals',
 109                 'envCheckMagicQuotes',
 110                 'envCheckMagicSybase',
 111                 'envCheckMbstring',
 112                 'envCheckZE1',
 113                 'envCheckSafeMode',
 114                 'envCheckXML',
 115                 'envCheckPCRE',
 116                 'envCheckMemory',
 117                 'envCheckCache',
 118                 'envCheckDiff3',
 119                 'envCheckGraphics',
 120                 'envCheckPath',
 121                 'envCheckWriteableDir',
 122                 'envCheckExtension',
 123                 'envCheckShellLocale',
 124                 'envCheckUploadsDirectory',
 125         );
 126
 127         /**
 128          * Steps for installation.
 129          */
 130         protected $installSteps = array(
 131                 'database',
 132                 'tables',
 133                 'interwiki',
 134                 'secretkey',
 135                 'sysop',
 136         );
 137
 138         /**
 139          * Known object cache types and the functions used to test for their existence
 140          */
 141         protected $objectCaches = array(
 142                 'xcache' => 'xcache_get',
 143                 'apc' => 'apc_fetch',
 144                 'eaccel' => 'eaccelerator_get',
 145                 'wincache' => 'wincache_ucache_get'
 146         );
 147
 148         /**
 149          * User rights profiles
 150          */
 151         var $rightsProfiles = array(
 152                 'wiki' => array(),
 153                 'no-anon' => array(
 154                         '*' => array( 'edit' => false )
 155                 ),
 156                 'fishbowl' => array(
 157                         '*' => array(
 158                                 'createaccount' => false,
 159                                 'edit' => false,
 160                         ),
 161                 ),
 162                 'private' => array(
 163                         '*' => array(
 164                                 'createaccount' => false,
 165                                 'edit' => false,
 166                                 'read' => false,
 167                         ),
 168                 ),
 169         );
 170
 171         /**
 172          * License types
 173          */
 174         var $licenses = array(
 175                 'none' => array(
 176                         'url' => '',
 177                         'icon' => '',
 178                         'text' => ''
 179                 ),
 180                 'cc-by-sa' => array(
 181                         'url' => 'http://creativecommons.org/licenses/by-sa/3.0/',
 182                         'icon' => '{$wgStylePath}/common/images/cc-by-sa.png',
 183                 ),
 184                 'cc-by-nc-sa' => array(
 185                         'url' => 'http://creativecommons.org/licenses/by-nc-sa/3.0/',
 186                         'icon' => '{$wgStylePath}/common/images/cc-by-nc-sa.png',
 187                 ),
 188                 'pd' => array(
 189                         'url' => 'http://creativecommons.org/licenses/publicdomain/',
 190                         'icon' => '{$wgStylePath}/common/images/public-domain.png',
 191                 ),
 192                 'gfdl-old' => array(
 193                         'url' => 'http://www.gnu.org/licenses/old-licenses/fdl-1.2.html',
 194                         'icon' => '{$wgStylePath}/common/images/gnu-fdl.png',
 195                 ),
 196                 'gfdl-current' => array(
 197                         'url' => 'http://www.gnu.org/copyleft/fdl.html',
 198                         'icon' => '{$wgStylePath}/common/images/gnu-fdl.png',
 199                 ),
 200                 'cc-choose' => array(
 201                         // details will be filled in by the selector
 202                         'url' => '',
 203                         'icon' => '',
 204                         'text' => '',
 205                 ),
 206         );
 207         /**
 208          * Cached Title and ParserOptions used by parse()
 209          */
 210         private $parserTitle, $parserOptions;
 211
 212         /**
 213          * Constructor, always call this from child classes
 214          */
 215         function __construct() {
 216                 // Disable the i18n cache and LoadBalancer
 217                 Language::getLocalisationCache()->disableBackend();
 218                 LBFactory::disableBackend();
 219
 220                 // Load the installer's i18n file
 221                 global $wgExtensionMessagesFiles;
 222                 $wgExtensionMessagesFiles['MediawikiInstaller'] =
 223                         './includes/installer/Installer.i18n.php';
 224
 225                 global $wgUser;
 226                 $wgUser = User::newFromId( 0 );
 227                 // Having a user with id = 0 safeguards us from DB access via User::loadOptions()
 228
 229                 // Set our custom <doclink> hook
 230                 global $wgHooks;
 231                 $wgHooks['ParserFirstCallInit'][] = array( $this, 'registerDocLink' );
 232
 233                 $this->settings = $this->internalDefaults;
 234                 foreach ( $this->defaultVarNames as $var ) {
 235                         $this->settings[$var] = $GLOBALS[$var];
 236                 }
 237                 foreach ( $this->dbTypes as $type ) {
 238                         $installer = $this->getDBInstaller( $type );
 239                         if ( !$installer->isCompiled() ) {
 240                                 continue;
 241                         }
 242                         $defaults = $installer->getGlobalDefaults();
 243                         foreach ( $installer->getGlobalNames() as $var ) {
 244                                 if ( isset( $defaults[$var] ) ) {
 245                                         $this->settings[$var] = $defaults[$var];
 246                                 } else {
 247                                         $this->settings[$var] = $GLOBALS[$var];
 248                                 }
 249                         }
 250                 }
 251
 252                 $this->parserTitle = Title::newFromText( 'Installer' );
 253                 $this->parserOptions = new ParserOptions;
 254                 $this->parserOptions->setEditSection( false );
 255         }
 256
 257         /**
 258          * UI interface for displaying a short message
 259          * The parameters are like parameters to wfMsg().
 260          * The messages will be in wikitext format, which will be converted to an
 261          * output format such as HTML or text before being sent to the user.
 262          */
 263         abstract function showMessage( $msg /*, ... */ );
 264
 265         abstract function showStatusMessage( $status );
 266
 267         /**
 268          * Get a list of known DB types
 269          */
 270         function getDBTypes() {
 271                 return $this->dbTypes;
 272         }
 273
 274         /**
 275          * Get an instance of InstallerDBType for the specified DB type
 276          * @param $type Mixed: DB installer for which is needed, false to use default
 277          */
 278         function getDBInstaller( $type = false ) {
 279                 if ( !$type ) {
 280                         $type = $this->getVar( 'wgDBtype' );
 281                 }
 282                 $type = strtolower($type);
 283
 284                 if ( !isset( $this->dbInstallers[$type] ) ) {
 285                         $class = ucfirst( $type ). 'Installer';
 286                         $this->dbInstallers[$type] = new $class( $this );
 287                 }
 288                 return $this->dbInstallers[$type];
 289         }
 290
 291         /**
 292          * Do initial checks of the PHP environment. Set variables according to
 293          * the observed environment.
 294          *
 295          * It's possible that this may be called under the CLI SAPI, not the SAPI
 296          * that the wiki will primarily run under. In that case, the subclass should
 297          * initialise variables such as wgScriptPath, before calling this function.
 298          *
 299          * Under the web subclass, it can already be assumed that PHP 5+ is in use
 300          * and that sessions are working.
 301          */
 302         function doEnvironmentChecks() {
 303                 $this->showMessage( 'config-env-php', phpversion() );
 304
 305                 $good = true;
 306                 foreach ( $this->envChecks as $check ) {
 307                         $status = $this->$check();
 308                         if ( $status === false ) {
 309                                 $good = false;
 310                         }
 311                 }
 312                 $this->setVar( '_Environment', $good );
 313                 if ( $good ) {
 314                         $this->showMessage( 'config-env-good' );
 315                 } else {
 316                         $this->showMessage( 'config-env-bad' );
 317                 }
 318                 return $good;
 319         }
 320
 321         /**
 322          * Get an MW configuration variable, or internal installer configuration variable.
 323          * The defaults come from $GLOBALS (ultimately DefaultSettings.php).
 324          * Installer variables are typically prefixed by an underscore.
 325          */
 326         function getVar( $name, $default = null ) {
 327                 if ( !isset( $this->settings[$name] ) ) {
 328                         return $default;
 329                 } else {
 330                         return $this->settings[$name];
 331                 }
 332         }
 333
 334         /**
 335          * Set a MW configuration variable, or internal installer configuration variable.
 336          */
 337         function setVar( $name, $value ) {
 338                 $this->settings[$name] = $value;
 339         }
 340
 341         /**
 342          * Exports all wg* variables stored by the installer into global scope
 343          */
 344         function exportVars() {
 345                 foreach ( $this->settings as $name => $value ) {
 346                         if ( substr( $name, 0, 2 ) == 'wg' ) {
 347                                 $GLOBALS[$name] = $value;
 348                         }
 349                 }
 350         }
 351
 352         /**
 353          * Get a fake password for sending back to the user in HTML.
 354          * This is a security mechanism to avoid compromise of the password in the
 355          * event of session ID compromise.
 356          */
 357         function getFakePassword( $realPassword ) {
 358                 return str_repeat( '*', strlen( $realPassword ) );
 359         }
 360
 361         /**
 362          * Set a variable which stores a password, except if the new value is a
 363          * fake password in which case leave it as it is.
 364          */
 365         function setPassword( $name, $value ) {
 366                 if ( !preg_match( '/^\*+$/', $value ) ) {
 367                         $this->setVar( $name, $value );
 368                 }
 369         }
 370
 371         /** Check if we're installing the latest version */
 372         function envLatestVersion() {
 373                 global $wgVersion;
 374                 $latestInfoUrl = 'http://www.mediawiki.org/w/api.php?action=mwreleases&format=json';
 375                 $latestInfo = Http::get( $latestInfoUrl );
 376                 if( !$latestInfo ) {
 377                         $this->showMessage( 'config-env-latest-can-not-check', $latestInfoUrl );
 378                         return;
 379                 }
 380                 $this->setVar( '_ExternalHTTP', true );
 381                 $latestInfo = FormatJson::decode($latestInfo);
 382                 if ($latestInfo === false || !isset( $latestInfo->mwreleases ) ) {
 383                         # For when the request is successful but there's e.g. some silly man in
 384                         # the middle firewall blocking us, e.g. one of those annoying airport ones
 385                         $this->showMessage( 'config-env-latest-data-invalid', $latestInfoUrl );
 386                         return;
 387                 }
 388                 foreach( $latestInfo->mwreleases as $rel ) {
 389                         if( isset( $rel->current ) )
 390                                 $currentVersion = $rel->version;
 391                 }
 392                 if( version_compare( $wgVersion, $currentVersion, '<' ) ) {
 393                         $this->showMessage( 'config-env-latest-old' );
 394                         $this->showHelpBox( 'config-env-latest-help', $wgVersion, $currentVersion );
 395                 } elseif( version_compare( $wgVersion, $currentVersion, '>' ) ) {
 396                         $this->showMessage( 'config-env-latest-new' );
 397                 }
 398                 $this->showMessage( 'config-env-latest-ok' );
 399         }
 400
 401         /** Environment check for DB types */
 402         function envCheckDB() {
 403                 $compiledDBs = array();
 404                 $goodNames = array();
 405                 $allNames = array();
 406                 foreach ( $this->dbTypes as $name ) {
 407                         $db = $this->getDBInstaller( $name );
 408                         $readableName = wfMsg( 'config-type-' . $name );
 409                         if ( $db->isCompiled() ) {
 410                                 $compiledDBs[] = $name;
 411                                 $goodNames[] = $readableName;
 412                         }
 413                         $allNames[] = $readableName;
 414                 }
 415                 $this->setVar( '_CompiledDBs', $compiledDBs );
 416
 417                 global $wgLang;
 418                 if ( !$compiledDBs ) {
 419                         $this->showMessage( 'config-no-db' );
 420                         $this->showHelpBox( 'config-no-db-help', $wgLang->commaList( $allNames ) );
 421                         return false;
 422                 }
 423                 $this->showMessage( 'config-have-db', $wgLang->commaList( $goodNames ) );
 424         }
 425
 426         /** Environment check for register_globals */
 427         function envCheckRegisterGlobals() {
 428                 if( wfIniGetBool( "magic_quotes_runtime" ) ) {
 429                         $this->showMessage( 'config-register-globals' );
 430                 }
 431         }
 432
 433         /** Environment check for magic_quotes_runtime */
 434         function envCheckMagicQuotes() {
 435                 if( wfIniGetBool( "magic_quotes_runtime" ) ) {
 436                         $this->showMessage( 'config-magic-quotes-runtime' );
 437                         return false;
 438                 }
 439         }
 440
 441         /** Environment check for magic_quotes_sybase */
 442         function envCheckMagicSybase() {
 443                 if ( wfIniGetBool( 'magic_quotes_sybase' ) ) {
 444                         $this->showMessage( 'config-magic-quotes-sybase' );
 445                         return false;
 446                 }
 447         }
 448
 449         /* Environment check for mbstring.func_overload */
 450         function envCheckMbstring() {
 451                 if ( wfIniGetBool( 'mbstring.func_overload' ) ) {
 452                         $this->showMessage( 'config-mbstring' );
 453                         return false;
 454                 }
 455         }
 456
 457         /** Environment check for zend.ze1_compatibility_mode */
 458         function envCheckZE1() {
 459                 if ( wfIniGetBool( 'zend.ze1_compatibility_mode' ) ) {
 460                         $this->showMessage( 'config-ze1' );
 461                         return false;
 462                 }
 463         }
 464
 465         /** Environment check for safe_mode */
 466         function envCheckSafeMode() {
 467                 if ( wfIniGetBool( 'safe_mode' ) ) {
 468                         $this->setVar( '_SafeMode', true );
 469                         $this->showMessage( 'config-safe-mode' );
 470                 }
 471         }
 472
 473         /** Environment check for the XML module */
 474         function envCheckXML() {
 475                 if ( !function_exists( "utf8_encode" ) ) {
 476                         $this->showMessage( 'config-xml-bad' );
 477                         return false;
 478                 }
 479                 $this->showMessage( 'config-xml-good' );
 480         }
 481
 482         /** Environment check for the PCRE module */
 483         function envCheckPCRE() {
 484                 if ( !function_exists( 'preg_match' ) ) {
 485                         $this->showMessage( 'config-pcre' );
 486                         return false;
 487                 }
 488         }
 489
 490         /** Environment check for available memory */
 491         function envCheckMemory() {
 492                 $limit = ini_get( 'memory_limit' );
 493                 if ( !$limit || $limit == -1 ) {
 494                         $this->showMessage( 'config-memory-none' );
 495                         return true;
 496                 }
 497                 $n = intval( $limit );
 498                 if( preg_match( '/^([0-9]+)[Mm]$/', trim( $limit ), $m ) ) {
 499                         $n = intval( $m[1] * (1024*1024) );
 500                 }
 501                 if( $n < $this->minMemorySize*1024*1024 ) {
 502                         $newLimit = "{$this->minMemorySize}M";
 503                         if( false === ini_set( "memory_limit", $newLimit ) ) {
 504                                 $this->showMessage( 'config-memory-bad', $limit );
 505                         } else {
 506                                 $this->showMessage( 'config-memory-raised', $limit, $newLimit );
 507                                 $this->setVar( '_RaiseMemory', true );
 508                         }
 509                 } else {
 510                         $this->showMessage( 'config-memory-ok', $limit );
 511                 }
 512         }
 513
 514         /** Environment check for compiled object cache types */
 515         function envCheckCache() {
 516                 $caches = array();
 517                 foreach ( $this->objectCaches as $name => $function ) {
 518                         if ( function_exists( $function ) ) {
 519                                 $caches[$name] = true;
 520                                 $this->showMessage( 'config-' . $name );
 521                         }
 522                 }
 523                 if ( !$caches ) {
 524                         $this->showMessage( 'config-no-cache' );
 525                 }
 526                 $this->setVar( '_Caches', $caches );
 527         }
 528
 529         /** Search for GNU diff3 */
 530         function envCheckDiff3() {
 531                 $paths = array_merge(
 532                         array(
 533                                 "/usr/bin",
 534                                 "/usr/local/bin",
 535                                 "/opt/csw/bin",
 536                                 "/usr/gnu/bin",
 537                                 "/usr/sfw/bin" ),
 538                         explode( PATH_SEPARATOR, getenv( "PATH" ) ) );
 539                 $names = array( "gdiff3", "diff3", "diff3.exe" );
 540
 541                 $versionInfo = array( '$1 --version 2>&1', 'diff3 (GNU diffutils)' );
 542                 $haveDiff3 = false;
 543                 foreach ( $paths as $path ) {
 544                         $exe = $this->locateExecutable( $path, $names, $versionInfo );
 545                         if ($exe !== false) {
 546                                 $this->setVar( 'wgDiff3', $exe );
 547                                 $haveDiff3 = true;
 548                                 break;
 549                         }
 550                 }
 551                 if ( $haveDiff3 ) {
 552                         $this->showMessage( 'config-diff3-good', $exe );
 553                 } else {
 554                         $this->setVar( 'wgDiff3', false );
 555                         $this->showMessage( 'config-diff3-bad' );
 556                 }
 557         }
 558
 559         /**
 560          * Search a path for any of the given executable names. Returns the
 561          * executable name if found. Also checks the version string returned
 562          * by each executable
 563          *
 564          * @param $path String: path to search
 565          * @param $names Array of executable names
 566          * @param $versionInfo Boolean false or array with two members:
 567          *       0 => Command to run for version check, with $1 for the path
 568          *       1 => String to compare the output with
 569          *
 570          * If $versionInfo is not false, only executables with a version
 571          * matching $versionInfo[1] will be returned.
 572          */
 573         function locateExecutable( $path, $names, $versionInfo = false ) {
 574                 if (!is_array($names))
 575                         $names = array($names);
 576
 577                 foreach ($names as $name) {
 578                         $command = "$path/$name";
 579                         if ( @file_exists( $command ) ) {
 580                                 if ( !$versionInfo )
 581                                         return $command;
 582
 583                                 $file = str_replace( '$1', $command, $versionInfo[0] );
 584                                 # Should maybe be wfShellExec( $file), but runs into a ulimit, see
 585                                 # http://www.mediawiki.org/w/index.php?title=New-installer_issues&diff=prev&oldid=335456
 586                                 if ( strstr( `$file`, $versionInfo[1]) !== false )
 587                                         return $command;
 588                         }
 589                 }
 590                 return false;
 591         }
 592
 593         /** Environment check for ImageMagick and GD */
 594         function envCheckGraphics() {
 595                 $imcheck = array( "/usr/bin", "/opt/csw/bin", "/usr/local/bin", "/sw/bin", "/opt/local/bin" );
 596                 foreach( $imcheck as $dir ) {
 597                         $im = "$dir/convert";
 598                         if( @file_exists( $im ) ) {
 599                                 $this->showMessage( 'config-imagemagick', $im );
 600                                 $this->setVar( 'wgImageMagickConvertCommand', $im );
 601                                 return true;
 602                         }
 603                 }
 604                 if ( function_exists( 'imagejpeg' ) ) {
 605                         $this->showMessage( 'config-gd' );
 606                         return true;
 607                 }
 608                 $this->showMessage( 'no-scaling' );
 609         }
 610
 611         /** Environment check for setting $IP and $wgScriptPath */
 612         function envCheckPath() {
 613                 $IP = dirname( dirname( dirname( __FILE__ ) ) );
 614                 $this->setVar( 'IP', $IP );
 615                 $this->showMessage( 'config-dir', $IP );
 616
 617                 // PHP_SELF isn't available sometimes, such as when PHP is CGI but
 618                 // cgi.fix_pathinfo is disabled. In that case, fall back to SCRIPT_NAME
 619                 // to get the path to the current script... hopefully it's reliable. SIGH
 620                 if ( !empty( $_SERVER['PHP_SELF'] ) ) {
 621                         $path = $_SERVER['PHP_SELF'];
 622                 } elseif ( !empty( $_SERVER['SCRIPT_NAME'] ) ) {
 623                         $path = $_SERVER['SCRIPT_NAME'];
 624                 } elseif ( $this->getVar( 'wgScriptPath' ) ) {
 625                         // Some kind soul has set it for us already (e.g. debconf)
 626                         return true;
 627                 } else {
 628                         $this->showMessage( 'config-no-uri' );
 629                         return false;
 630                 }
 631                 $uri = preg_replace( '{^(.*)/config.*$}', '$1', $path );
 632                 $this->setVar( 'wgScriptPath', $uri );
 633                 $this->showMessage( 'config-uri', $uri );
 634         }
 635
 636         /** Environment check for writable config/ directory */
 637         function envCheckWriteableDir() {
 638                 $ipDir = $this->getVar( 'IP' );
 639                 $configDir = $ipDir . '/config';
 640                 if( !is_writeable( $configDir ) ) {
 641                         $webserverGroup = self::maybeGetWebserverPrimaryGroup();
 642                         if ( $webserverGroup !== null ) {
 643                                 $this->showMessage( 'config-dir-not-writable-group', $ipDir, $webserverGroup );
 644                         } else {
 645                                 $this->showMessage( 'config-dir-not-writable-nogroup', $ipDir, $webserverGroup );
 646                         }
 647                         return false;
 648                 }
 649         }
 650
 651         /** Environment check for setting the preferred PHP file extension */
 652         function envCheckExtension() {
 653                 // FIXME: detect this properly
 654                 if ( defined( 'MW_INSTALL_PHP5_EXT' ) ) {
 655                         $ext = 'php5';
 656                 } else {
 657                         $ext = 'php';
 658                 }
 659                 $this->setVar( 'wgScriptExtension', ".$ext" );
 660                 $this->showMessage( 'config-file-extension', $ext );
 661         }
 662
 663         function envCheckShellLocale() {
 664                 # Give up now if we're in safe mode or open_basedir
 665                 # It's theoretically possible but tricky to work with
 666                 if ( wfIniGetBool( "safe_mode" ) || ini_get( 'open_basedir' ) || !function_exists( 'exec' ) ) {
 667                         return true;
 668                 }
 669
 670                 $os = php_uname( 's' );
 671                 $supported = array( 'Linux', 'SunOS', 'HP-UX' ); # Tested these
 672                 if ( !in_array( $os, $supported ) ) {
 673                         return true;
 674                 }
 675
 676                 # Get a list of available locales
 677                 $lines = $ret = false;
 678                 exec( '/usr/bin/locale -a', $lines, $ret );
 679                 if ( $ret ) {
 680                         return true;
 681                 }
 682
 683                 $lines = wfArrayMap( 'trim', $lines );
 684                 $candidatesByLocale = array();
 685                 $candidatesByLang = array();
 686                 foreach ( $lines as $line ) {
 687                         if ( $line === '' ) {
 688                                 continue;
 689                         }
 690                         if ( !preg_match( '/^([a-zA-Z]+)(_[a-zA-Z]+|)\.(utf8|UTF-8)(@[a-zA-Z_]*|)$/i', $line, $m ) ) {
 691                                 continue;
 692                         }
 693                         list( $all, $lang, $territory, $charset, $modifier ) = $m;
 694                         $candidatesByLocale[$m[0]] = $m;
 695                         $candidatesByLang[$lang][] = $m;
 696                 }
 697
 698                 # Try the current value of LANG
 699                 if ( isset( $candidatesByLocale[ getenv( 'LANG' ) ] ) ) {
 700                         $this->setVar( 'wgShellLocale', getenv( 'LANG' ) );
 701                         $this->showMessage( 'config-shell-locale', getenv( 'LANG' ) );
 702                         return true;
 703                 }
 704
 705                 # Try the most common ones
 706                 $commonLocales = array( 'en_US.UTF-8', 'en_US.utf8', 'de_DE.UTF-8', 'de_DE.utf8' );
 707                 foreach ( $commonLocales as $commonLocale ) {
 708                         if ( isset( $candidatesByLocale[$commonLocale] ) ) {
 709                                 $this->setVar( 'wgShellLocale', $commonLocale );
 710                                 $this->showMessage( 'config-shell-locale', $commonLocale );
 711                                 return true;
 712                         }
 713                 }
 714
 715                 # Is there an available locale in the Wiki's language?
 716                 $wikiLang = $this->getVar( 'wgLanguageCode' );
 717                 if ( isset( $candidatesByLang[$wikiLang] ) ) {
 718                         $m = reset( $candidatesByLang[$wikiLang] );
 719                         $this->setVar( 'wgShellLocale', $m[0] );
 720                         $this->showMessage( 'config-shell-locale', $m[0] );
 721                         return true;
 722                 }
 723
 724                 # Are there any at all?
 725                 if ( count( $candidatesByLocale ) ) {
 726                         $m = reset( $candidatesByLocale );
 727                         $this->setVar( 'wgShellLocale', $m[0] );
 728                         $this->showMessage( 'config-shell-locale', $m[0] );
 729                         return true;
 730                 }
 731
 732                 # Give up
 733                 return true;
 734         }
 735
 736         function envCheckUploadsDirectory() {
 737                 global $IP, $wgServer;
 738                 $dir = $IP . '/images/';
 739                 $url = $wgServer . $this->getVar( 'wgScriptPath' ) . '/images/';
 740                 $safe = !$this->dirIsExecutable( $dir, $url );
 741                 if ( $safe ) {
 742                         $this->showMessage( 'config-uploads-safe' );
 743                 } else {
 744                         $this->showMessage( 'config-uploads-not-safe', $dir );
 745                 }
 746         }
 747
 748         /**
 749          * Checks if scripts located in the given directory can be executed via the given URL
 750          */
 751         function dirIsExecutable( $dir, $url ) {
 752                 $scriptTypes = array(
 753                         'php' => array(
 754                                 "<?php echo 'ex' . 'ec';",
 755                                 "#!/var/env php5\n<?php echo 'ex' . 'ec';",
 756                         ),
 757                 );
 758                 // it would be good to check other popular languages here, but it'll be slow
 759
 760                 wfSuppressWarnings();
 761                 foreach ( $scriptTypes as $ext => $contents ) {
 762                         foreach ( $contents as $source ) {
 763                                 $file = 'exectest.' . $ext;
 764                                 if ( !file_put_contents( $dir . $file, $source ) ) {
 765                                         break;
 766                                 }
 767                                 $text = Http::get( $url . $file );
 768                                 unlink( $dir . $file );
 769                                 if ( $text == 'exec' ) {
 770                                         wfRestoreWarnings();
 771                                         return $ext;
 772                                 }
 773                         }
 774                 }
 775                 wfRestoreWarnings();
 776                 return false;
 777         }
 778
 779         /**
 780          * Convert wikitext $text to HTML.
 781          *
 782          * This is potentially error prone since many parser features require a complete
 783          * installed MW database. The solution is to just not use those features when you
 784          * write your messages. This appears to work well enough. Basic formatting and
 785          * external links work just fine.
 786          *
 787          * But in case a translator decides to throw in a #ifexist or internal link or
 788          * whatever, this function is guarded to catch attempted DB access and to present
 789          * some fallback text.
 790          *
 791          * @param $text String
 792          * @param $lineStart Boolean
 793          * @return String
 794          */
 795         function parse( $text, $lineStart = false ) {
 796                 global $wgParser;
 797                 try {
 798                         $out = $wgParser->parse( $text, $this->parserTitle, $this->parserOptions, $lineStart );
 799                         $html = $out->getText();
 800                 } catch ( DBAccessError $e ) {
 801                         $html = '<!--DB access attempted during parse-->  ' . htmlspecialchars( $text );
 802                         if ( !empty( $this->debug ) ) {
 803                                 $html .= "<!--\n" . $e->getTraceAsString() . "\n-->";
 804                         }
 805                 }
 806                 return $html;
 807         }
 808
 809         /**
 810          * Register tag hook below
 811          */
 812         function registerDocLink( &$parser ) {
 813                 $parser->setHook( 'doclink', array( $this, 'docLink' ) );
 814                 return true;
 815         }
 816
 817         /**
 818          * Extension tag hook for a documentation link
 819          */
 820         function docLink( $linkText, $attribs, $parser ) {
 821                 $url = $this->getDocUrl( $attribs['href'] );
 822                 return '<a href="' . htmlspecialchars( $url ) . '">' .
 823                         htmlspecialchars( $linkText ) .
 824                         '</a>';
 825         }
 826
 827         /**
 828          * Overridden by WebInstaller to provide lastPage parameters
 829          */
 830         protected function getDocUrl( $page ) {
 831                 return "{$_SERVER['PHP_SELF']}?page=" . urlencode( $attribs['href'] );
 832         }
 833
 834         public function findExtensions() {
 835                 if( $this->getVar( 'IP' ) === null ) {
 836                         return false;
 837                 }
 838                 $exts = array();
 839                 $dir = $this->getVar( 'IP' ) . '/extensions';
 840                 $dh = opendir( $dir );
 841                 while ( ( $file = readdir( $dh ) ) !== false ) {
 842                         if( file_exists( "$dir/$file/$file.php" ) ) {
 843                                 $exts[$file] = null;
 844                         }
 845                 }
 846                 $this->setVar( '_Extensions', $exts );
 847                 return $exts;
 848         }
 849
 850         public function getInstallSteps() {
 851                 if( $this->getVar( '_UpgradeDone' ) ) {
 852                         $this->installSteps = array( 'localsettings' );
 853                 }
 854                 if( count( $this->getVar( '_Extensions' ) ) ) {
 855                         array_unshift( $this->installSteps, 'extensions' );
 856                 }
 857                 return $this->installSteps;
 858         }
 859
 860         /**
 861          * Actually perform the installation
 862          * @param Array $startCB A callback array for the beginning of each step
 863          * @param Array $endCB A callback array for the end of each step
 864          * @return Array of Status objects
 865          */
 866         public function performInstallation( $startCB, $endCB ) {
 867                 $installResults = array();
 868                 $installer = $this->getDBInstaller();
 869                 foreach( $this->getInstallSteps() as $stepObj ) {
 870                         $step = is_array( $stepObj ) ? $stepObj['name'] : $stepObj;
 871                         call_user_func_array( $startCB, array( $step ) );
 872                         $status = null;
 873
 874                         # Call our working function
 875                         if ( is_array( $stepObj ) ) {
 876                                 # A custom callaback
 877                                 $callback = $stepObj['callback'];
 878                                 $status = call_user_func_array( $callback, array( $installer ) );
 879                         } else {
 880                                 # Boring implicitly named callback
 881                                 $func = 'install' . ucfirst( $step );
 882                                 $status = $this->{$func}( $installer );
 883                         }
 884                         call_user_func_array( $endCB, array( $step, $status ) );
 885                         $installResults[$step] = $status;
 886
 887                         // If we've hit some sort of fatal, we need to bail. Callback
 888                         // already had a chance to do output above.
 889                         if( !$status->isOk() )
 890                                 break;
 891                 }
 892                 if( $status->isOk() ) {
 893                         $this->setVar( '_InstallDone', true );
 894                 }
 895                 return $installResults;
 896         }
 897
 898         public function installExtensions() {
 899                 global $wgHooks, $wgAutoloadClasses;
 900                 $exts = $this->getVar( '_Extensions' );
 901                 $path = $this->getVar( 'IP' ) . '/extensions';
 902                 foreach( $exts as $e ) {
 903                         require( "$path/$e/$e.php" );
 904                 }
 905                 return Status::newGood();
 906         }
 907
 908         public function installDatabase( &$installer ) {
 909                 if(!$installer) {
 910                         $type = $this->getVar( 'wgDBtype' );
 911                         $status = Status::newFatal( "config-no-db", $type );
 912                 } else {
 913                         $status = $installer->setupDatabase();
 914                 }
 915                 return $status;
 916         }
 917
 918         public function installTables( &$installer ) {
 919                 $status = $installer->createTables();
 920                 if( $status->isOK() ) {
 921                         LBFactory::enableBackend();
 922                 }
 923                 return $status;
 924         }
 925
 926         public function installInterwiki( &$installer ) {
 927                 return $installer->populateInterwikiTable();
 928         }
 929
 930         public function installSecretKey() {
 931                 if ( wfIsWindows() ) {
 932                         $file = null;
 933                 } else {
 934                         wfSuppressWarnings();
 935                         $file = fopen( "/dev/urandom", "r" );
 936                         wfRestoreWarnings();
 937                 }
 938
 939                 $status = Status::newGood();
 940
 941                 if ( $file ) {
 942                         $secretKey = bin2hex( fread( $file, 32 ) );
 943                         fclose( $file );
 944                 } else {
 945                         $secretKey = "";
 946                         for ( $i=0; $i<8; $i++ ) {
 947                                 $secretKey .= dechex(mt_rand(0, 0x7fffffff));
 948                         }
 949                         $status->warning( 'config-insecure-secretkey' );
 950                 }
 951                 $this->setVar( 'wgSecretKey', $secretKey );
 952
 953                 return $status;
 954         }
 955
 956         public function installSysop() {
 957                 $name = $this->getVar( '_AdminName' );
 958                 $user = User::newFromName( $name );
 959                 if ( !$user ) {
 960                         // we should've validated this earlier anyway!
 961                         return Status::newFatal( 'config-admin-error-user', $name );
 962                 }
 963                 if ( $user->idForName() == 0 ) {
 964                         $user->addToDatabase();
 965                         try {
 966                                 $user->setPassword( $this->getVar( '_AdminPassword' ) );
 967                         } catch( PasswordError $pwe ) {
 968                                 return Status::newFatal( 'config-admin-error-password', $name, $pwe->getMessage() );
 969                         }
 970                         $user->addGroup( 'sysop' );
 971                         $user->addGroup( 'bureaucrat' );
 972                         $user->saveSettings();
 973                 }
 974                 return Status::newGood();
 975         }
 976
 977         /**
 978          * Determine if LocalSettings exists. If it does, return an appropriate
 979          * status for whether we should can upgrade or not
 980          * @return Status
 981          */
 982         function getLocalSettingsStatus() {
 983                 global $IP;
 984
 985                 $status = Status::newGood();
 986
 987                 wfSuppressWarnings();
 988                 $ls = file_exists( "$IP/LocalSettings.php" );
 989                 wfRestoreWarnings();
 990
 991                 if( $ls ) {
 992                         if( $this->getDBInstaller()->needsUpgrade() ) {
 993                                 $status->warning( 'config-localsettings-upgrade' );
 994                         }
 995                         else {
 996                                 $status->fatal( 'config-localsettings-noupgrade' );
 997                         }
 998                 }
 999                 return $status;
1000         }
1001
1002         /**
1003          * On POSIX systems return the primary group of the webserver we're running under.
1004          * On other systems just returns null.
1005          *
1006          * This is used to advice the user that he should chgrp his config/data/images directory as the
1007          * webserver user before he can install.
1008          *
1009          * Public because SqliteInstaller needs it, and doesn't subclass Installer.
1010          *
1011          * @return String
1012          */
1013         public static function maybeGetWebserverPrimaryGroup() {
1014                 if ( ! function_exists('posix_getegid') || ! function_exists('posix_getpwuid') ) {
1015                         # I don't know this, this isn't UNIX
1016                         return null;
1017                 }
1018
1019                 # posix_getegid() *not* getmygid() because we want the group of the webserver,
1020                 # not whoever owns the current script
1021                 $gid = posix_getegid();
1022                 $getpwuid = posix_getpwuid( $gid );
1023                 $group = $getpwuid["name"];
1024
1025                 return $group;
1026         }
1027
1028         /**
1029          * Override the necessary bits of the config to run an installation
1030          */
1031         public static function overrideConfig() {
1032                 define( 'MW_NO_SESSION', 1 );
1033
1034                 // Don't access the database
1035                 $GLOBALS['wgUseDatabaseMessages'] = false;
1036                 // Debug-friendly
1037                 $GLOBALS['wgShowExceptionDetails'] = true;
1038                 // Don't break forms
1039                 $GLOBALS['wgExternalLinkTarget'] = '_blank';
1040
1041                 // Extended debugging. Maybe disable before release?
1042                 $GLOBALS['wgShowSQLErrors'] = true;
1043                 $GLOBALS['wgShowDBErrorBacktrace'] = true;
1044         }
1045
1046         /**
1047          * Add an installation step following the given step.
1048          * @param $findStep String the step to find.  Use NULL to put the step at the beginning.
1049          * @param $callback array
1050          */
1051         function addInstallStepFollowing( $findStep, $callback ) {
1052                 $where = 0;
1053                 if( $findStep !== null ) $where = array_search( $findStep, $this->installSteps );
1054
1055                 array_splice( $this->installSteps, $where, 0, $callback );
1056         }
1057
1058
1059 }