Installer.php

Go to the documentation of this file.

<?php
abstract class Installer {
 
    // This is the absolute minimum PHP version we can support
    const MINIMUM_PHP_VERSION = '5.3.2';
 
    const MINIMUM_PCRE_VERSION = '7.2';
 
    protected $settings;
 
    protected $compiledDBs;
 
    protected $dbInstallers = array();
 
    protected $minMemorySize = 50;
 
    protected $parserTitle;
 
    protected $parserOptions;
 
    protected static $dbTypes = array(
        'mysql',
        'postgres',
        'oracle',
        'mssql',
        'sqlite',
    );
 
    protected $envChecks = array(
        'envCheckDB',
        'envCheckRegisterGlobals',
        'envCheckBrokenXML',
        'envCheckMagicQuotes',
        'envCheckMagicSybase',
        'envCheckMbstring',
        'envCheckSafeMode',
        'envCheckXML',
        'envCheckPCRE',
        'envCheckMemory',
        'envCheckCache',
        'envCheckModSecurity',
        'envCheckDiff3',
        'envCheckGraphics',
        'envCheckGit',
        'envCheckServer',
        'envCheckPath',
        'envCheckExtension',
        'envCheckShellLocale',
        'envCheckUploadsDirectory',
        'envCheckLibicu',
        'envCheckSuhosinMaxValueLength',
        'envCheckCtype',
        'envCheckJSON',
    );
 
    protected $defaultVarNames = array(
        'wgSitename',
        'wgPasswordSender',
        'wgLanguageCode',
        'wgRightsIcon',
        'wgRightsText',
        'wgRightsUrl',
        'wgMainCacheType',
        'wgEnableEmail',
        'wgEnableUserEmail',
        'wgEnotifUserTalk',
        'wgEnotifWatchlist',
        'wgEmailAuthentication',
        'wgDBtype',
        'wgDiff3',
        'wgImageMagickConvertCommand',
        'wgGitBin',
        'IP',
        'wgScriptPath',
        'wgScriptExtension',
        'wgMetaNamespace',
        'wgDeletedDirectory',
        'wgEnableUploads',
        'wgShellLocale',
        'wgSecretKey',
        'wgUseInstantCommons',
        'wgUpgradeKey',
        'wgDefaultSkin',
        'wgResourceLoaderMaxQueryLength',
    );
 
    protected $internalDefaults = array(
        '_UserLang' => 'en',
        '_Environment' => false,
        '_SafeMode' => false,
        '_RaiseMemory' => false,
        '_UpgradeDone' => false,
        '_InstallDone' => false,
        '_Caches' => array(),
        '_InstallPassword' => '',
        '_SameAccount' => true,
        '_CreateDBAccount' => false,
        '_NamespaceType' => 'site-name',
        '_AdminName' => '', // will be set later, when the user selects language
        '_AdminPassword' => '',
        '_AdminPassword2' => '',
        '_AdminEmail' => '',
        '_Subscribe' => false,
        '_SkipOptional' => 'continue',
        '_RightsProfile' => 'wiki',
        '_LicenseCode' => 'none',
        '_CCDone' => false,
        '_Extensions' => array(),
        '_MemCachedServers' => '',
        '_UpgradeKeySupplied' => false,
        '_ExistingDBSettings' => false,
 
        // $wgLogo is probably wrong (bug 48084); set something that will work.
        // Single quotes work fine here, as LocalSettingsGenerator outputs this unescaped.
        'wgLogo' => '$wgStylePath/common/images/wiki.png',
    );
 
    private $installSteps = array();
 
    protected $extraInstallSteps = array();
 
    protected $objectCaches = array(
        'xcache' => 'xcache_get',
        'apc' => 'apc_fetch',
        'wincache' => 'wincache_ucache_get'
    );
 
    public $rightsProfiles = array(
        'wiki' => array(),
        'no-anon' => array(
            '*' => array( 'edit' => false )
        ),
        'fishbowl' => array(
            '*' => array(
                'createaccount' => false,
                'edit' => false,
            ),
        ),
        'private' => array(
            '*' => array(
                'createaccount' => false,
                'edit' => false,
                'read' => false,
            ),
        ),
    );
 
    public $licenses = array(
        'cc-by' => array(
            'url' => 'http://creativecommons.org/licenses/by/3.0/',
            'icon' => '{$wgStylePath}/common/images/cc-by.png',
        ),
        'cc-by-sa' => array(
            'url' => 'http://creativecommons.org/licenses/by-sa/3.0/',
            'icon' => '{$wgStylePath}/common/images/cc-by-sa.png',
        ),
        'cc-by-nc-sa' => array(
            'url' => 'http://creativecommons.org/licenses/by-nc-sa/3.0/',
            'icon' => '{$wgStylePath}/common/images/cc-by-nc-sa.png',
        ),
        'cc-0' => array(
            'url' => 'https://creativecommons.org/publicdomain/zero/1.0/',
            'icon' => '{$wgStylePath}/common/images/cc-0.png',
        ),
        'pd' => array(
            'url' => '',
            'icon' => '{$wgStylePath}/common/images/public-domain.png',
        ),
        'gfdl' => array(
            'url' => 'http://www.gnu.org/copyleft/fdl.html',
            'icon' => '{$wgStylePath}/common/images/gnu-fdl.png',
        ),
        'none' => array(
            'url' => '',
            'icon' => '',
            'text' => ''
        ),
        'cc-choose' => array(
            // Details will be filled in by the selector.
            'url' => '',
            'icon' => '',
            'text' => '',
        ),
    );
 
    protected $mediaWikiAnnounceUrl =
        'https://lists.wikimedia.org/mailman/subscribe/mediawiki-announce';
 
    protected $mediaWikiAnnounceLanguages = array(
        'ca', 'cs', 'da', 'de', 'en', 'es', 'et', 'eu', 'fi', 'fr', 'hr', 'hu',
        'it', 'ja', 'ko', 'lt', 'nl', 'no', 'pl', 'pt', 'pt-br', 'ro', 'ru',
        'sl', 'sr', 'sv', 'tr', 'uk'
    );
 
    abstract public function showMessage( $msg /*, ... */ );
 
    abstract public function showError( $msg /*, ... */ );
 
    abstract public function showStatusMessage( Status $status );
 
    public function __construct() {
        global $wgMessagesDirs, $wgUser;
 
        // Disable the i18n cache and LoadBalancer
        Language::getLocalisationCache()->disableBackend();
        LBFactory::disableBackend();
 
        // Load the installer's i18n.
        $wgMessagesDirs['MediawikiInstaller'] = __DIR__ . '/i18n';
 
        // Having a user with id = 0 safeguards us from DB access via User::loadOptions().
        $wgUser = User::newFromId( 0 );
 
        $this->settings = $this->internalDefaults;
 
        foreach ( $this->defaultVarNames as $var ) {
            $this->settings[$var] = $GLOBALS[$var];
        }
 
        $this->compiledDBs = array();
        foreach ( self::getDBTypes() as $type ) {
            $installer = $this->getDBInstaller( $type );
 
            if ( !$installer->isCompiled() ) {
                continue;
            }
            $this->compiledDBs[] = $type;
        }
 
        $this->parserTitle = Title::newFromText( 'Installer' );
        $this->parserOptions = new ParserOptions; // language will  be wrong :(
        $this->parserOptions->setEditSection( false );
    }
 
    public static function getDBTypes() {
        return self::$dbTypes;
    }
 
    public function doEnvironmentChecks() {
        $phpVersion = phpversion();
        if ( version_compare( $phpVersion, self::MINIMUM_PHP_VERSION, '>=' ) ) {
            $this->showMessage( 'config-env-php', $phpVersion );
            $good = true;
        } else {
            $this->showMessage( 'config-env-php-toolow', $phpVersion, self::MINIMUM_PHP_VERSION );
            $good = false;
        }
 
        // Must go here because an old version of PCRE can prevent other checks from completing
        if ( $good ) {
            list( $pcreVersion ) = explode( ' ', PCRE_VERSION, 2 );
            if ( version_compare( $pcreVersion, self::MINIMUM_PCRE_VERSION, '<' ) ) {
                $this->showError( 'config-pcre-old', self::MINIMUM_PCRE_VERSION, $pcreVersion );
                $good = false;
            }
        }
 
        if ( $good ) {
            foreach ( $this->envChecks as $check ) {
                $status = $this->$check();
                if ( $status === false ) {
                    $good = false;
                }
            }
        }
 
        $this->setVar( '_Environment', $good );
 
        return $good ? Status::newGood() : Status::newFatal( 'config-env-bad' );
    }
 
    public function setVar( $name, $value ) {
        $this->settings[$name] = $value;
    }
 
    public function getVar( $name, $default = null ) {
        if ( !isset( $this->settings[$name] ) ) {
            return $default;
        } else {
            return $this->settings[$name];
        }
    }
 
    public function getCompiledDBs() {
        return $this->compiledDBs;
    }
 
    public function getDBInstaller( $type = false ) {
        if ( !$type ) {
            $type = $this->getVar( 'wgDBtype' );
        }
 
        $type = strtolower( $type );
 
        if ( !isset( $this->dbInstallers[$type] ) ) {
            $class = ucfirst( $type ) . 'Installer';
            $this->dbInstallers[$type] = new $class( $this );
        }
 
        return $this->dbInstallers[$type];
    }
 
    public static function getExistingLocalSettings() {
        global $IP;
 
        // You might be wondering why this is here. Well if you don't do this
        // then some poorly-formed extensions try to call their own classes
        // after immediately registering them. We really need to get extension
        // registration out of the global scope and into a real format.
        // @see https://bugzilla.wikimedia.org/67440
        global $wgAutoloadClasses;
 
        wfSuppressWarnings();
        $_lsExists = file_exists( "$IP/LocalSettings.php" );
        wfRestoreWarnings();
 
        if ( !$_lsExists ) {
            return false;
        }
        unset( $_lsExists );
 
        require "$IP/includes/DefaultSettings.php";
        require "$IP/LocalSettings.php";
 
        return get_defined_vars();
    }
 
    public function getFakePassword( $realPassword ) {
        return str_repeat( '*', strlen( $realPassword ) );
    }
 
    public function setPassword( $name, $value ) {
        if ( !preg_match( '/^\*+$/', $value ) ) {
            $this->setVar( $name, $value );
        }
    }
 
    public static function maybeGetWebserverPrimaryGroup() {
        if ( !function_exists( 'posix_getegid' ) || !function_exists( 'posix_getpwuid' ) ) {
            # I don't know this, this isn't UNIX.
            return null;
        }
 
        # posix_getegid() *not* getmygid() because we want the group of the webserver,
        # not whoever owns the current script.
        $gid = posix_getegid();
        $getpwuid = posix_getpwuid( $gid );
        $group = $getpwuid['name'];
 
        return $group;
    }
 
    public function parse( $text, $lineStart = false ) {
        global $wgParser;
 
        try {
            $out = $wgParser->parse( $text, $this->parserTitle, $this->parserOptions, $lineStart );
            $html = $out->getText();
        } catch ( DBAccessError $e ) {
            $html = '<!--DB access attempted during parse-->  ' . htmlspecialchars( $text );
 
            if ( !empty( $this->debug ) ) {
                $html .= "<!--\n" . $e->getTraceAsString() . "\n-->";
            }
        }
 
        return $html;
    }
 
    public function getParserOptions() {
        return $this->parserOptions;
    }
 
    public function disableLinkPopups() {
        $this->parserOptions->setExternalLinkTarget( false );
    }
 
    public function restoreLinkPopups() {
        global $wgExternalLinkTarget;
        $this->parserOptions->setExternalLinkTarget( $wgExternalLinkTarget );
    }
 
    public function populateSiteStats( DatabaseInstaller $installer ) {
        $status = $installer->getConnection();
        if ( !$status->isOK() ) {
            return $status;
        }
        $status->value->insert(
            'site_stats',
            array(
                'ss_row_id' => 1,
                'ss_total_views' => 0,
                'ss_total_edits' => 0,
                'ss_good_articles' => 0,
                'ss_total_pages' => 0,
                'ss_users' => 0,
                'ss_images' => 0
            ),
            __METHOD__, 'IGNORE'
        );
 
        return Status::newGood();
    }
 
    public function exportVars() {
        foreach ( $this->settings as $name => $value ) {
            if ( substr( $name, 0, 2 ) == 'wg' ) {
                $GLOBALS[$name] = $value;
            }
        }
    }
 
    protected function envCheckDB() {
        global $wgLang;
 
        $allNames = array();
 
        // Messages: config-type-mysql, config-type-postgres, config-type-oracle,
        // config-type-sqlite
        foreach ( self::getDBTypes() as $name ) {
            $allNames[] = wfMessage( "config-type-$name" )->text();
        }
 
        $databases = $this->getCompiledDBs();
 
        $databases = array_flip( $databases );
        foreach ( array_keys( $databases ) as $db ) {
            $installer = $this->getDBInstaller( $db );
            $status = $installer->checkPrerequisites();
            if ( !$status->isGood() ) {
                $this->showStatusMessage( $status );
            }
            if ( !$status->isOK() ) {
                unset( $databases[$db] );
            }
        }
        $databases = array_flip( $databases );
        if ( !$databases ) {
            $this->showError( 'config-no-db', $wgLang->commaList( $allNames ) );
 
            // @todo FIXME: This only works for the web installer!
            return false;
        }
 
        return true;
    }
 
    protected function envCheckRegisterGlobals() {
        if ( wfIniGetBool( 'register_globals' ) ) {
            $this->showMessage( 'config-register-globals' );
        }
    }
 
    protected function envCheckBrokenXML() {
        $test = new PhpXmlBugTester();
        if ( !$test->ok ) {
            $this->showError( 'config-brokenlibxml' );
 
            return false;
        }
 
        return true;
    }
 
    protected function envCheckMagicQuotes() {
        if ( wfIniGetBool( "magic_quotes_runtime" ) ) {
            $this->showError( 'config-magic-quotes-runtime' );
 
            return false;
        }
 
        return true;
    }
 
    protected function envCheckMagicSybase() {
        if ( wfIniGetBool( 'magic_quotes_sybase' ) ) {
            $this->showError( 'config-magic-quotes-sybase' );
 
            return false;
        }
 
        return true;
    }
 
    protected function envCheckMbstring() {
        if ( wfIniGetBool( 'mbstring.func_overload' ) ) {
            $this->showError( 'config-mbstring' );
 
            return false;
        }
 
        return true;
    }
 
    protected function envCheckSafeMode() {
        if ( wfIniGetBool( 'safe_mode' ) ) {
            $this->setVar( '_SafeMode', true );
            $this->showMessage( 'config-safe-mode' );
        }
 
        return true;
    }
 
    protected function envCheckXML() {
        if ( !function_exists( "utf8_encode" ) ) {
            $this->showError( 'config-xml-bad' );
 
            return false;
        }
 
        return true;
    }
 
    protected function envCheckPCRE() {
        wfSuppressWarnings();
        $regexd = preg_replace( '/[\x{0430}-\x{04FF}]/iu', '', '-АБВГД-' );
        // Need to check for \p support too, as PCRE can be compiled
        // with utf8 support, but not unicode property support.
        // check that \p{Zs} (space separators) matches
        // U+3000 (Ideographic space)
        $regexprop = preg_replace( '/\p{Zs}/u', '', "-\xE3\x80\x80-" );
        wfRestoreWarnings();
        if ( $regexd != '--' || $regexprop != '--' ) {
            $this->showError( 'config-pcre-no-utf8' );
 
            return false;
        }
 
        return true;
    }
 
    protected function envCheckMemory() {
        $limit = ini_get( 'memory_limit' );
 
        if ( !$limit || $limit == -1 ) {
            return true;
        }
 
        $n = wfShorthandToInteger( $limit );
 
        if ( $n < $this->minMemorySize * 1024 * 1024 ) {
            $newLimit = "{$this->minMemorySize}M";
 
            if ( ini_set( "memory_limit", $newLimit ) === false ) {
                $this->showMessage( 'config-memory-bad', $limit );
            } else {
                $this->showMessage( 'config-memory-raised', $limit, $newLimit );
                $this->setVar( '_RaiseMemory', true );
            }
        }
 
        return true;
    }
 
    protected function envCheckCache() {
        $caches = array();
        foreach ( $this->objectCaches as $name => $function ) {
            if ( function_exists( $function ) ) {
                if ( $name == 'xcache' && !wfIniGetBool( 'xcache.var_size' ) ) {
                    continue;
                }
                $caches[$name] = true;
            }
        }
 
        if ( !$caches ) {
            $this->showMessage( 'config-no-cache' );
        }
 
        $this->setVar( '_Caches', $caches );
    }
 
    protected function envCheckModSecurity() {
        if ( self::apacheModulePresent( 'mod_security' ) ) {
            $this->showMessage( 'config-mod-security' );
        }
 
        return true;
    }
 
    protected function envCheckDiff3() {
        $names = array( "gdiff3", "diff3", "diff3.exe" );
        $versionInfo = array( '$1 --version 2>&1', 'GNU diffutils' );
 
        $diff3 = self::locateExecutableInDefaultPaths( $names, $versionInfo );
 
        if ( $diff3 ) {
            $this->setVar( 'wgDiff3', $diff3 );
        } else {
            $this->setVar( 'wgDiff3', false );
            $this->showMessage( 'config-diff3-bad' );
        }
 
        return true;
    }
 
    protected function envCheckGraphics() {
        $names = array( wfIsWindows() ? 'convert.exe' : 'convert' );
        $versionInfo = array( '$1 -version', 'ImageMagick' );
        $convert = self::locateExecutableInDefaultPaths( $names, $versionInfo );
 
        $this->setVar( 'wgImageMagickConvertCommand', '' );
        if ( $convert ) {
            $this->setVar( 'wgImageMagickConvertCommand', $convert );
            $this->showMessage( 'config-imagemagick', $convert );
 
            return true;
        } elseif ( function_exists( 'imagejpeg' ) ) {
            $this->showMessage( 'config-gd' );
        } else {
            $this->showMessage( 'config-no-scaling' );
        }
 
        return true;
    }
 
    protected function envCheckGit() {
        $names = array( wfIsWindows() ? 'git.exe' : 'git' );
        $versionInfo = array( '$1 --version', 'git version' );
 
        $git = self::locateExecutableInDefaultPaths( $names, $versionInfo );
 
        if ( $git ) {
            $this->setVar( 'wgGitBin', $git );
            $this->showMessage( 'config-git', $git );
        } else {
            $this->setVar( 'wgGitBin', false );
            $this->showMessage( 'config-git-bad' );
        }
 
        return true;
    }
 
    protected function envCheckServer() {
        $server = $this->envGetDefaultServer();
        if ( $server !== null ) {
            $this->showMessage( 'config-using-server', $server );
            $this->setVar( 'wgServer', $server );
        }
 
        return true;
    }
 
    abstract protected function envGetDefaultServer();
 
    protected function envCheckPath() {
        global $IP;
        $IP = dirname( dirname( __DIR__ ) );
        $this->setVar( 'IP', $IP );
 
        $this->showMessage(
            'config-using-uri',
            $this->getVar( 'wgServer' ),
            $this->getVar( 'wgScriptPath' )
        );
 
        return true;
    }
 
    protected function envCheckExtension() {
        // @todo FIXME: Detect this properly
        if ( defined( 'MW_INSTALL_PHP5_EXT' ) ) {
            $ext = 'php5';
        } else {
            $ext = 'php';
        }
        $this->setVar( 'wgScriptExtension', ".$ext" );
 
        return true;
    }
 
    protected function envCheckShellLocale() {
        $os = php_uname( 's' );
        $supported = array( 'Linux', 'SunOS', 'HP-UX', 'Darwin' ); # Tested these
 
        if ( !in_array( $os, $supported ) ) {
            return true;
        }
 
        # Get a list of available locales.
        $ret = false;
        $lines = wfShellExec( '/usr/bin/locale -a', $ret );
 
        if ( $ret ) {
            return true;
        }
 
        $lines = array_map( 'trim', explode( "\n", $lines ) );
        $candidatesByLocale = array();
        $candidatesByLang = array();
 
        foreach ( $lines as $line ) {
            if ( $line === '' ) {
                continue;
            }
 
            if ( !preg_match( '/^([a-zA-Z]+)(_[a-zA-Z]+|)\.(utf8|UTF-8)(@[a-zA-Z_]*|)$/i', $line, $m ) ) {
                continue;
            }
 
            list( , $lang, , , ) = $m;
 
            $candidatesByLocale[$m[0]] = $m;
            $candidatesByLang[$lang][] = $m;
        }
 
        # Try the current value of LANG.
        if ( isset( $candidatesByLocale[getenv( 'LANG' )] ) ) {
            $this->setVar( 'wgShellLocale', getenv( 'LANG' ) );
 
            return true;
        }
 
        # Try the most common ones.
        $commonLocales = array( 'en_US.UTF-8', 'en_US.utf8', 'de_DE.UTF-8', 'de_DE.utf8' );
        foreach ( $commonLocales as $commonLocale ) {
            if ( isset( $candidatesByLocale[$commonLocale] ) ) {
                $this->setVar( 'wgShellLocale', $commonLocale );
 
                return true;
            }
        }
 
        # Is there an available locale in the Wiki's language?
        $wikiLang = $this->getVar( 'wgLanguageCode' );
 
        if ( isset( $candidatesByLang[$wikiLang] ) ) {
            $m = reset( $candidatesByLang[$wikiLang] );
            $this->setVar( 'wgShellLocale', $m[0] );
 
            return true;
        }
 
        # Are there any at all?
        if ( count( $candidatesByLocale ) ) {
            $m = reset( $candidatesByLocale );
            $this->setVar( 'wgShellLocale', $m[0] );
 
            return true;
        }
 
        # Give up.
        return true;
    }
 
    protected function envCheckUploadsDirectory() {
        global $IP;
 
        $dir = $IP . '/images/';
        $url = $this->getVar( 'wgServer' ) . $this->getVar( 'wgScriptPath' ) . '/images/';
        $safe = !$this->dirIsExecutable( $dir, $url );
 
        if ( !$safe ) {
            $this->showMessage( 'config-uploads-not-safe', $dir );
        }
 
        return true;
    }
 
    protected function envCheckSuhosinMaxValueLength() {
        $maxValueLength = ini_get( 'suhosin.get.max_value_length' );
        if ( $maxValueLength > 0 && $maxValueLength < 1024 ) {
            // Only warn if the value is below the sane 1024
            $this->showMessage( 'config-suhosin-max-value-length', $maxValueLength );
        }
 
        return true;
    }
 
    protected function unicodeChar( $c ) {
        $c = hexdec( $c );
        if ( $c <= 0x7F ) {
            return chr( $c );
        } elseif ( $c <= 0x7FF ) {
            return chr( 0xC0 | $c >> 6 ) . chr( 0x80 | $c & 0x3F );
        } elseif ( $c <= 0xFFFF ) {
            return chr( 0xE0 | $c >> 12 ) . chr( 0x80 | $c >> 6 & 0x3F )
            . chr( 0x80 | $c & 0x3F );
        } elseif ( $c <= 0x10FFFF ) {
            return chr( 0xF0 | $c >> 18 ) . chr( 0x80 | $c >> 12 & 0x3F )
            . chr( 0x80 | $c >> 6 & 0x3F )
            . chr( 0x80 | $c & 0x3F );
        } else {
            return false;
        }
    }
 
    protected function envCheckLibicu() {
        $utf8 = function_exists( 'utf8_normalize' );
        $intl = function_exists( 'normalizer_normalize' );
 
        $not_normal_c = $this->unicodeChar( "FA6C" );
        $normal_c = $this->unicodeChar( "242EE" );
 
        $useNormalizer = 'php';
        $needsUpdate = false;
 
        if ( $utf8 ) {
            $useNormalizer = 'utf8';
            $utf8 = utf8_normalize( $not_normal_c, UtfNormal::UNORM_NFC );
            if ( $utf8 !== $normal_c ) {
                $needsUpdate = true;
            }
        }
        if ( $intl ) {
            $useNormalizer = 'intl';
            $intl = normalizer_normalize( $not_normal_c, Normalizer::FORM_C );
            if ( $intl !== $normal_c ) {
                $needsUpdate = true;
            }
        }
 
        // Uses messages 'config-unicode-using-php', 'config-unicode-using-utf8',
        // 'config-unicode-using-intl'
        if ( $useNormalizer === 'php' ) {
            $this->showMessage( 'config-unicode-pure-php-warning' );
        } else {
            $this->showMessage( 'config-unicode-using-' . $useNormalizer );
            if ( $needsUpdate ) {
                $this->showMessage( 'config-unicode-update-warning' );
            }
        }
    }
 
    protected function envCheckCtype() {
        if ( !function_exists( 'ctype_digit' ) ) {
            $this->showError( 'config-ctype' );
 
            return false;
        }
 
        return true;
    }
 
    protected function envCheckJSON() {
        if ( !function_exists( 'json_decode' ) ) {
            $this->showError( 'config-json' );
 
            return false;
        }
 
        return true;
    }
 
    protected static function getPossibleBinPaths() {
        return array_merge(
            array( '/usr/bin', '/usr/local/bin', '/opt/csw/bin',
                '/usr/gnu/bin', '/usr/sfw/bin', '/sw/bin', '/opt/local/bin' ),
            explode( PATH_SEPARATOR, getenv( 'PATH' ) )
        );
    }
 
    public static function locateExecutable( $path, $names, $versionInfo = false ) {
        if ( !is_array( $names ) ) {
            $names = array( $names );
        }
 
        foreach ( $names as $name ) {
            $command = $path . DIRECTORY_SEPARATOR . $name;
 
            wfSuppressWarnings();
            $file_exists = file_exists( $command );
            wfRestoreWarnings();
 
            if ( $file_exists ) {
                if ( !$versionInfo ) {
                    return $command;
                }
 
                $file = str_replace( '$1', wfEscapeShellArg( $command ), $versionInfo[0] );
                if ( strstr( wfShellExec( $file ), $versionInfo[1] ) !== false ) {
                    return $command;
                }
            }
        }
 
        return false;
    }
 
    public static function locateExecutableInDefaultPaths( $names, $versionInfo = false ) {
        foreach ( self::getPossibleBinPaths() as $path ) {
            $exe = self::locateExecutable( $path, $names, $versionInfo );
            if ( $exe !== false ) {
                return $exe;
            }
        }
 
        return false;
    }
 
    public function dirIsExecutable( $dir, $url ) {
        $scriptTypes = array(
            'php' => array(
                "<?php echo 'ex' . 'ec';",
                "#!/var/env php5\n<?php echo 'ex' . 'ec';",
            ),
        );
 
        // it would be good to check other popular languages here, but it'll be slow.
 
        wfSuppressWarnings();
 
        foreach ( $scriptTypes as $ext => $contents ) {
            foreach ( $contents as $source ) {
                $file = 'exectest.' . $ext;
 
                if ( !file_put_contents( $dir . $file, $source ) ) {
                    break;
                }
 
                try {
                    $text = Http::get( $url . $file, array( 'timeout' => 3 ) );
                } catch ( MWException $e ) {
                    // Http::get throws with allow_url_fopen = false and no curl extension.
                    $text = null;
                }
                unlink( $dir . $file );
 
                if ( $text == 'exec' ) {
                    wfRestoreWarnings();
 
                    return $ext;
                }
            }
        }
 
        wfRestoreWarnings();
 
        return false;
    }
 
    public static function apacheModulePresent( $moduleName ) {
        if ( function_exists( 'apache_get_modules' ) && in_array( $moduleName, apache_get_modules() ) ) {
            return true;
        }
        // try it the hard way
        ob_start();
        phpinfo( INFO_MODULES );
        $info = ob_get_clean();
 
        return strpos( $info, $moduleName ) !== false;
    }
 
    public function setParserLanguage( $lang ) {
        $this->parserOptions->setTargetLanguage( $lang );
        $this->parserOptions->setUserLang( $lang );
    }
 
    protected function getDocUrl( $page ) {
        return "{$_SERVER['PHP_SELF']}?page=" . urlencode( $page );
    }
 
    public function findExtensions() {
        if ( $this->getVar( 'IP' ) === null ) {
            return array();
        }
 
        $extDir = $this->getVar( 'IP' ) . '/extensions';
        if ( !is_readable( $extDir ) || !is_dir( $extDir ) ) {
            return array();
        }
 
        $dh = opendir( $extDir );
        $exts = array();
        while ( ( $file = readdir( $dh ) ) !== false ) {
            if ( !is_dir( "$extDir/$file" ) ) {
                continue;
            }
            if ( file_exists( "$extDir/$file/$file.php" ) ) {
                $exts[] = $file;
            }
        }
        closedir( $dh );
        natcasesort( $exts );
 
        return $exts;
    }
 
    protected function includeExtensions() {
        global $IP;
        $exts = $this->getVar( '_Extensions' );
        $IP = $this->getVar( 'IP' );
 
        global $wgAutoloadClasses;
        $wgAutoloadClasses = array();
 
        require "$IP/includes/DefaultSettings.php";
 
        foreach ( $exts as $e ) {
            require_once "$IP/extensions/$e/$e.php";
        }
 
        $hooksWeWant = isset( $wgHooks['LoadExtensionSchemaUpdates'] ) ?
            $wgHooks['LoadExtensionSchemaUpdates'] : array();
 
        // Unset everyone else's hooks. Lord knows what someone might be doing
        // in ParserFirstCallInit (see bug 27171)
        $GLOBALS['wgHooks'] = array( 'LoadExtensionSchemaUpdates' => $hooksWeWant );
 
        return Status::newGood();
    }
 
    protected function getInstallSteps( DatabaseInstaller $installer ) {
        $coreInstallSteps = array(
            array( 'name' => 'database', 'callback' => array( $installer, 'setupDatabase' ) ),
            array( 'name' => 'tables', 'callback' => array( $installer, 'createTables' ) ),
            array( 'name' => 'interwiki', 'callback' => array( $installer, 'populateInterwikiTable' ) ),
            array( 'name' => 'stats', 'callback' => array( $this, 'populateSiteStats' ) ),
            array( 'name' => 'keys', 'callback' => array( $this, 'generateKeys' ) ),
            array( 'name' => 'sysop', 'callback' => array( $this, 'createSysop' ) ),
            array( 'name' => 'mainpage', 'callback' => array( $this, 'createMainpage' ) ),
        );
 
        // Build the array of install steps starting from the core install list,
        // then adding any callbacks that wanted to attach after a given step
        foreach ( $coreInstallSteps as $step ) {
            $this->installSteps[] = $step;
            if ( isset( $this->extraInstallSteps[$step['name']] ) ) {
                $this->installSteps = array_merge(
                    $this->installSteps,
                    $this->extraInstallSteps[$step['name']]
                );
            }
        }
 
        // Prepend any steps that want to be at the beginning
        if ( isset( $this->extraInstallSteps['BEGINNING'] ) ) {
            $this->installSteps = array_merge(
                $this->extraInstallSteps['BEGINNING'],
                $this->installSteps
            );
        }
 
        // Extensions should always go first, chance to tie into hooks and such
        if ( count( $this->getVar( '_Extensions' ) ) ) {
            array_unshift( $this->installSteps,
                array( 'name' => 'extensions', 'callback' => array( $this, 'includeExtensions' ) )
            );
            $this->installSteps[] = array(
                'name' => 'extension-tables',
                'callback' => array( $installer, 'createExtensionTables' )
            );
        }
 
        return $this->installSteps;
    }
 
    public function performInstallation( $startCB, $endCB ) {
        $installResults = array();
        $installer = $this->getDBInstaller();
        $installer->preInstall();
        $steps = $this->getInstallSteps( $installer );
        foreach ( $steps as $stepObj ) {
            $name = $stepObj['name'];
            call_user_func_array( $startCB, array( $name ) );
 
            // Perform the callback step
            $status = call_user_func( $stepObj['callback'], $installer );
 
            // Output and save the results
            call_user_func( $endCB, $name, $status );
            $installResults[$name] = $status;
 
            // If we've hit some sort of fatal, we need to bail.
            // Callback already had a chance to do output above.
            if ( !$status->isOk() ) {
                break;
            }
        }
        if ( $status->isOk() ) {
            $this->setVar( '_InstallDone', true );
        }
 
        return $installResults;
    }
 
    public function generateKeys() {
        $keys = array( 'wgSecretKey' => 64 );
        if ( strval( $this->getVar( 'wgUpgradeKey' ) ) === '' ) {
            $keys['wgUpgradeKey'] = 16;
        }
 
        return $this->doGenerateKeys( $keys );
    }
 
    protected function doGenerateKeys( $keys ) {
        $status = Status::newGood();
 
        $strong = true;
        foreach ( $keys as $name => $length ) {
            $secretKey = MWCryptRand::generateHex( $length, true );
            if ( !MWCryptRand::wasStrong() ) {
                $strong = false;
            }
 
            $this->setVar( $name, $secretKey );
        }
 
        if ( !$strong ) {
            $names = array_keys( $keys );
            $names = preg_replace( '/^(.*)$/', '\$$1', $names );
            global $wgLang;
            $status->warning( 'config-insecure-keys', $wgLang->listToText( $names ), count( $names ) );
        }
 
        return $status;
    }
 
    protected function createSysop() {
        $name = $this->getVar( '_AdminName' );
        $user = User::newFromName( $name );
 
        if ( !$user ) {
            // We should've validated this earlier anyway!
            return Status::newFatal( 'config-admin-error-user', $name );
        }
 
        if ( $user->idForName() == 0 ) {
            $user->addToDatabase();
 
            try {
                $user->setPassword( $this->getVar( '_AdminPassword' ) );
            } catch ( PasswordError $pwe ) {
                return Status::newFatal( 'config-admin-error-password', $name, $pwe->getMessage() );
            }
 
            $user->addGroup( 'sysop' );
            $user->addGroup( 'bureaucrat' );
            if ( $this->getVar( '_AdminEmail' ) ) {
                $user->setEmail( $this->getVar( '_AdminEmail' ) );
            }
            $user->saveSettings();
 
            // Update user count
            $ssUpdate = new SiteStatsUpdate( 0, 0, 0, 0, 1 );
            $ssUpdate->doUpdate();
        }
        $status = Status::newGood();
 
        if ( $this->getVar( '_Subscribe' ) && $this->getVar( '_AdminEmail' ) ) {
            $this->subscribeToMediaWikiAnnounce( $status );
        }
 
        return $status;
    }
 
    private function subscribeToMediaWikiAnnounce( Status $s ) {
        $params = array(
            'email' => $this->getVar( '_AdminEmail' ),
            'language' => 'en',
            'digest' => 0
        );
 
        // Mailman doesn't support as many languages as we do, so check to make
        // sure their selected language is available
        $myLang = $this->getVar( '_UserLang' );
        if ( in_array( $myLang, $this->mediaWikiAnnounceLanguages ) ) {
            $myLang = $myLang == 'pt-br' ? 'pt_BR' : $myLang; // rewrite to Mailman's pt_BR
            $params['language'] = $myLang;
        }
 
        if ( MWHttpRequest::canMakeRequests() ) {
            $res = MWHttpRequest::factory( $this->mediaWikiAnnounceUrl,
                array( 'method' => 'POST', 'postData' => $params ) )->execute();
            if ( !$res->isOK() ) {
                $s->warning( 'config-install-subscribe-fail', $res->getMessage() );
            }
        } else {
            $s->warning( 'config-install-subscribe-notpossible' );
        }
    }
 
    protected function createMainpage( DatabaseInstaller $installer ) {
        $status = Status::newGood();
        try {
            $page = WikiPage::factory( Title::newMainPage() );
            $content = new WikitextContent(
                wfMessage( 'mainpagetext' )->inContentLanguage()->text() . "\n\n" .
                wfMessage( 'mainpagedocfooter' )->inContentLanguage()->text()
            );
 
            $page->doEditContent( $content,
                '',
                EDIT_NEW,
                false,
                User::newFromName( 'MediaWiki default' )
            );
        } catch ( MWException $e ) {
            //using raw, because $wgShowExceptionDetails can not be set yet
            $status->fatal( 'config-install-mainpage-failed', $e->getMessage() );
        }
 
        return $status;
    }
 
    public static function overrideConfig() {
        define( 'MW_NO_SESSION', 1 );
 
        // Don't access the database
        $GLOBALS['wgUseDatabaseMessages'] = false;
        // Don't cache langconv tables
        $GLOBALS['wgLanguageConverterCacheType'] = CACHE_NONE;
        // Debug-friendly
        $GLOBALS['wgShowExceptionDetails'] = true;
        // Don't break forms
        $GLOBALS['wgExternalLinkTarget'] = '_blank';
 
        // Extended debugging
        $GLOBALS['wgShowSQLErrors'] = true;
        $GLOBALS['wgShowDBErrorBacktrace'] = true;
 
        // Allow multiple ob_flush() calls
        $GLOBALS['wgDisableOutputCompression'] = true;
 
        // Use a sensible cookie prefix (not my_wiki)
        $GLOBALS['wgCookiePrefix'] = 'mw_installer';
 
        // Some of the environment checks make shell requests, remove limits
        $GLOBALS['wgMaxShellMemory'] = 0;
 
        // Don't bother embedding images into generated CSS, which is not cached
        $GLOBALS['wgResourceLoaderLESSFunctions']['embeddable'] = function ( $frame, $less ) {
            return $less->toBool( false );
        };
    }
 
    public function addInstallStep( $callback, $findStep = 'BEGINNING' ) {
        $this->extraInstallSteps[$findStep][] = $callback;
    }
 
    protected function disableTimeLimit() {
        wfSuppressWarnings();
        set_time_limit( 0 );
        wfRestoreWarnings();
    }
}