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