includes/installer/WebInstaller.php

   1 <?php
   2 /**
   3  * Core installer web interface.
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  18  * http://www.gnu.org/copyleft/gpl.html
  19  *
  20  * @file
  21  * @ingroup Deployment
  22  */
  23
  24 use MediaWiki\MediaWikiServices;
  25
  26 /**
  27  * Class for the core installer web interface.
  28  *
  29  * @ingroup Deployment
  30  * @since 1.17
  31  */
  32 class WebInstaller extends Installer {
  33
  34         /**
  35          * @var WebInstallerOutput
  36          */
  37         public $output;
  38
  39         /**
  40          * WebRequest object.
  41          *
  42          * @var WebRequest
  43          */
  44         public $request;
  45
  46         /**
  47          * Cached session array.
  48          *
  49          * @var array[]
  50          */
  51         protected $session;
  52
  53         /**
  54          * Captured PHP error text. Temporary.
  55          *
  56          * @var string[]
  57          */
  58         protected $phpErrors;
  59
  60         /**
  61          * The main sequence of page names. These will be displayed in turn.
  62          *
  63          * To add a new installer page:
  64          *    * Add it to this WebInstaller::$pageSequence property
  65          *    * Add a "config-page-<name>" message
  66          *    * Add a "WebInstaller<name>" class
  67          *
  68          * @var string[]
  69          */
  70         public $pageSequence = [
  71                 'Language',
  72                 'ExistingWiki',
  73                 'Welcome',
  74                 'DBConnect',
  75                 'Upgrade',
  76                 'DBSettings',
  77                 'Name',
  78                 'Options',
  79                 'Install',
  80                 'Complete',
  81         ];
  82
  83         /**
  84          * Out of sequence pages, selectable by the user at any time.
  85          *
  86          * @var string[]
  87          */
  88         protected $otherPages = [
  89                 'Restart',
  90                 'Readme',
  91                 'ReleaseNotes',
  92                 'Copying',
  93                 'UpgradeDoc', // Can't use Upgrade due to Upgrade step
  94         ];
  95
  96         /**
  97          * Array of pages which have declared that they have been submitted, have validated
  98          * their input, and need no further processing.
  99          *
 100          * @var bool[]
 101          */
 102         protected $happyPages;
 103
 104         /**
 105          * List of "skipped" pages. These are pages that will automatically continue
 106          * to the next page on any GET request. To avoid breaking the "back" button,
 107          * they need to be skipped during a back operation.
 108          *
 109          * @var bool[]
 110          */
 111         protected $skippedPages;
 112
 113         /**
 114          * Flag indicating that session data may have been lost.
 115          *
 116          * @var bool
 117          */
 118         public $showSessionWarning = false;
 119
 120         /**
 121          * Numeric index of the page we're on
 122          *
 123          * @var int
 124          */
 125         protected $tabIndex = 1;
 126
 127         /**
 128          * Name of the page we're on
 129          *
 130          * @var string
 131          */
 132         protected $currentPageName;
 133
 134         /**
 135          * @param WebRequest $request
 136          */
 137         public function __construct( WebRequest $request ) {
 138                 parent::__construct();
 139                 $this->output = new WebInstallerOutput( $this );
 140                 $this->request = $request;
 141
 142                 // Add parser hooks
 143                 $parser = MediaWikiServices::getInstance()->getParser();
 144                 $parser->setHook( 'downloadlink', [ $this, 'downloadLinkHook' ] );
 145                 $parser->setHook( 'doclink', [ $this, 'docLink' ] );
 146         }
 147
 148         /**
 149          * Main entry point.
 150          *
 151          * @param array[] $session Initial session array
 152          *
 153          * @return array[] New session array
 154          */
 155         public function execute( array $session ) {
 156                 $this->session = $session;
 157
 158                 if ( isset( $session['settings'] ) ) {
 159                         $this->settings = $session['settings'] + $this->settings;
 160                         // T187586 MediaWikiServices works with globals
 161                         foreach ( $this->settings as $key => $val ) {
 162                                 $GLOBALS[$key] = $val;
 163                         }
 164                 }
 165
 166                 $this->setupLanguage();
 167
 168                 if ( ( $this->getVar( '_InstallDone' ) || $this->getVar( '_UpgradeDone' ) )
 169                         && $this->request->getVal( 'localsettings' )
 170                 ) {
 171                         $this->outputLS();
 172                         return $this->session;
 173                 }
 174
 175                 $isCSS = $this->request->getVal( 'css' );
 176                 if ( $isCSS ) {
 177                         $this->outputCss();
 178                         return $this->session;
 179                 }
 180
 181                 $this->happyPages = $session['happyPages'] ?? [];
 182
 183                 $this->skippedPages = $session['skippedPages'] ?? [];
 184
 185                 $lowestUnhappy = $this->getLowestUnhappy();
 186
 187                 # Special case for Creative Commons partner chooser box.
 188                 if ( $this->request->getVal( 'SubmitCC' ) ) {
 189                         $page = $this->getPageByName( 'Options' );
 190                         $this->output->useShortHeader();
 191                         $this->output->allowFrames();
 192                         $page->submitCC();
 193
 194                         return $this->finish();
 195                 }
 196
 197                 if ( $this->request->getVal( 'ShowCC' ) ) {
 198                         $page = $this->getPageByName( 'Options' );
 199                         $this->output->useShortHeader();
 200                         $this->output->allowFrames();
 201                         $this->output->addHTML( $page->getCCDoneBox() );
 202
 203                         return $this->finish();
 204                 }
 205
 206                 # Get the page name.
 207                 $pageName = $this->request->getVal( 'page' );
 208
 209                 if ( in_array( $pageName, $this->otherPages ) ) {
 210                         # Out of sequence
 211                         $pageId = false;
 212                         $page = $this->getPageByName( $pageName );
 213                 } else {
 214                         # Main sequence
 215                         if ( !$pageName || !in_array( $pageName, $this->pageSequence ) ) {
 216                                 $pageId = $lowestUnhappy;
 217                         } else {
 218                                 $pageId = array_search( $pageName, $this->pageSequence );
 219                         }
 220
 221                         # If necessary, move back to the lowest-numbered unhappy page
 222                         if ( $pageId > $lowestUnhappy ) {
 223                                 $pageId = $lowestUnhappy;
 224                                 if ( $lowestUnhappy == 0 ) {
 225                                         # Knocked back to start, possible loss of session data.
 226                                         $this->showSessionWarning = true;
 227                                 }
 228                         }
 229
 230                         $pageName = $this->pageSequence[$pageId];
 231                         $page = $this->getPageByName( $pageName );
 232                 }
 233
 234                 # If a back button was submitted, go back without submitting the form data.
 235                 if ( $this->request->wasPosted() && $this->request->getBool( 'submit-back' ) ) {
 236                         if ( $this->request->getVal( 'lastPage' ) ) {
 237                                 $nextPage = $this->request->getVal( 'lastPage' );
 238                         } elseif ( $pageId !== false ) {
 239                                 # Main sequence page
 240                                 # Skip the skipped pages
 241                                 $nextPageId = $pageId;
 242
 243                                 do {
 244                                         $nextPageId--;
 245                                         $nextPage = $this->pageSequence[$nextPageId];
 246                                 } while ( isset( $this->skippedPages[$nextPage] ) );
 247                         } else {
 248                                 $nextPage = $this->pageSequence[$lowestUnhappy];
 249                         }
 250
 251                         $this->output->redirect( $this->getUrl( [ 'page' => $nextPage ] ) );
 252
 253                         return $this->finish();
 254                 }
 255
 256                 # Execute the page.
 257                 $this->currentPageName = $page->getName();
 258                 $this->startPageWrapper( $pageName );
 259
 260                 if ( $page->isSlow() ) {
 261                         $this->disableTimeLimit();
 262                 }
 263
 264                 $result = $page->execute();
 265
 266                 $this->endPageWrapper();
 267
 268                 if ( $result == 'skip' ) {
 269                         # Page skipped without explicit submission.
 270                         # Skip it when we click "back" so that we don't just go forward again.
 271                         $this->skippedPages[$pageName] = true;
 272                         $result = 'continue';
 273                 } else {
 274                         unset( $this->skippedPages[$pageName] );
 275                 }
 276
 277                 # If it was posted, the page can request a continue to the next page.
 278                 if ( $result === 'continue' && !$this->output->headerDone() ) {
 279                         if ( $pageId !== false ) {
 280                                 $this->happyPages[$pageId] = true;
 281                         }
 282
 283                         $lowestUnhappy = $this->getLowestUnhappy();
 284
 285                         if ( $this->request->getVal( 'lastPage' ) ) {
 286                                 $nextPage = $this->request->getVal( 'lastPage' );
 287                         } elseif ( $pageId !== false ) {
 288                                 $nextPage = $this->pageSequence[$pageId + 1];
 289                         } else {
 290                                 $nextPage = $this->pageSequence[$lowestUnhappy];
 291                         }
 292
 293                         if ( array_search( $nextPage, $this->pageSequence ) > $lowestUnhappy ) {
 294                                 $nextPage = $this->pageSequence[$lowestUnhappy];
 295                         }
 296
 297                         $this->output->redirect( $this->getUrl( [ 'page' => $nextPage ] ) );
 298                 }
 299
 300                 return $this->finish();
 301         }
 302
 303         /**
 304          * Find the next page in sequence that hasn't been completed
 305          * @return int
 306          */
 307         public function getLowestUnhappy() {
 308                 if ( count( $this->happyPages ) == 0 ) {
 309                         return 0;
 310                 } else {
 311                         return max( array_keys( $this->happyPages ) ) + 1;
 312                 }
 313         }
 314
 315         /**
 316          * Start the PHP session. This may be called before execute() to start the PHP session.
 317          *
 318          * @throws Exception
 319          * @return bool
 320          */
 321         public function startSession() {
 322                 if ( wfIniGetBool( 'session.auto_start' ) || session_id() ) {
 323                         // Done already
 324                         return true;
 325                 }
 326
 327                 $this->phpErrors = [];
 328                 set_error_handler( [ $this, 'errorHandler' ] );
 329                 try {
 330                         session_name( 'mw_installer_session' );
 331                         session_start();
 332                 } catch ( Exception $e ) {
 333                         restore_error_handler();
 334                         throw $e;
 335                 }
 336                 restore_error_handler();
 337
 338                 if ( $this->phpErrors ) {
 339                         return false;
 340                 }
 341
 342                 return true;
 343         }
 344
 345         /**
 346          * Get a hash of data identifying this MW installation.
 347          *
 348          * This is used by mw-config/index.php to prevent multiple installations of MW
 349          * on the same cookie domain from interfering with each other.
 350          *
 351          * @return string
 352          */
 353         public function getFingerprint() {
 354                 // Get the base URL of the installation
 355                 $url = $this->request->getFullRequestURL();
 356                 if ( preg_match( '!^(.*\?)!', $url, $m ) ) {
 357                         // Trim query string
 358                         $url = $m[1];
 359                 }
 360                 if ( preg_match( '!^(.*)/[^/]*/[^/]*$!', $url, $m ) ) {
 361                         // This... seems to try to get the base path from
 362                         // the /mw-config/index.php. Kinda scary though?
 363                         $url = $m[1];
 364                 }
 365
 366                 return md5( serialize( [
 367                         'local path' => dirname( __DIR__ ),
 368                         'url' => $url,
 369                         'version' => $GLOBALS['wgVersion']
 370                 ] ) );
 371         }
 372
 373         /**
 374          * Show an error message in a box. Parameters are like wfMessage(), or
 375          * alternatively, pass a Message object in.
 376          * @param string|Message $msg
 377          */
 378         public function showError( $msg /*...*/ ) {
 379                 if ( !( $msg instanceof Message ) ) {
 380                         $args = func_get_args();
 381                         array_shift( $args );
 382                         $args = array_map( 'htmlspecialchars', $args );
 383                         $msg = wfMessage( $msg, $args );
 384                 }
 385                 $text = $msg->useDatabase( false )->plain();
 386                 $this->output->addHTML( $this->getErrorBox( $text ) );
 387         }
 388
 389         /**
 390          * Temporary error handler for session start debugging.
 391          *
 392          * @param int $errno Unused
 393          * @param string $errstr
 394          */
 395         public function errorHandler( $errno, $errstr ) {
 396                 $this->phpErrors[] = $errstr;
 397         }
 398
 399         /**
 400          * Clean up from execute()
 401          *
 402          * @return array[]
 403          */
 404         public function finish() {
 405                 $this->output->output();
 406
 407                 $this->session['happyPages'] = $this->happyPages;
 408                 $this->session['skippedPages'] = $this->skippedPages;
 409                 $this->session['settings'] = $this->settings;
 410
 411                 return $this->session;
 412         }
 413
 414         /**
 415          * We're restarting the installation, reset the session, happyPages, etc
 416          */
 417         public function reset() {
 418                 $this->session = [];
 419                 $this->happyPages = [];
 420                 $this->settings = [];
 421         }
 422
 423         /**
 424          * Get a URL for submission back to the same script.
 425          *
 426          * @param string[] $query
 427          *
 428          * @return string
 429          */
 430         public function getUrl( $query = [] ) {
 431                 $url = $this->request->getRequestURL();
 432                 # Remove existing query
 433                 $url = preg_replace( '/\?.*$/', '', $url );
 434
 435                 if ( $query ) {
 436                         $url .= '?' . wfArrayToCgi( $query );
 437                 }
 438
 439                 return $url;
 440         }
 441
 442         /**
 443          * Get a WebInstallerPage by name.
 444          *
 445          * @param string $pageName
 446          * @return WebInstallerPage
 447          */
 448         public function getPageByName( $pageName ) {
 449                 $pageClass = 'WebInstaller' . $pageName;
 450
 451                 return new $pageClass( $this );
 452         }
 453
 454         /**
 455          * Get a session variable.
 456          *
 457          * @param string $name
 458          * @param array|null $default
 459          *
 460          * @return array
 461          */
 462         public function getSession( $name, $default = null ) {
 463                 return $this->session[$name] ?? $default;
 464         }
 465
 466         /**
 467          * Set a session variable.
 468          *
 469          * @param string $name Key for the variable
 470          * @param mixed $value
 471          */
 472         public function setSession( $name, $value ) {
 473                 $this->session[$name] = $value;
 474         }
 475
 476         /**
 477          * Get the next tabindex attribute value.
 478          *
 479          * @return int
 480          */
 481         public function nextTabIndex() {
 482                 return $this->tabIndex++;
 483         }
 484
 485         /**
 486          * Initializes language-related variables.
 487          */
 488         public function setupLanguage() {
 489                 global $wgLang, $wgContLang, $wgLanguageCode;
 490
 491                 if ( $this->getSession( 'test' ) === null && !$this->request->wasPosted() ) {
 492                         $wgLanguageCode = $this->getAcceptLanguage();
 493                         $wgLang = Language::factory( $wgLanguageCode );
 494                         RequestContext::getMain()->setLanguage( $wgLang );
 495                         $this->setVar( 'wgLanguageCode', $wgLanguageCode );
 496                         $this->setVar( '_UserLang', $wgLanguageCode );
 497                 } else {
 498                         $wgLanguageCode = $this->getVar( 'wgLanguageCode' );
 499                 }
 500                 $wgContLang = MediaWikiServices::getInstance()->getContentLanguage();
 501         }
 502
 503         /**
 504          * Retrieves MediaWiki language from Accept-Language HTTP header.
 505          *
 506          * @return string
 507          */
 508         public function getAcceptLanguage() {
 509                 global $wgLanguageCode, $wgRequest;
 510
 511                 $mwLanguages = Language::fetchLanguageNames( null, 'mwfile' );
 512                 $headerLanguages = array_keys( $wgRequest->getAcceptLang() );
 513
 514                 foreach ( $headerLanguages as $lang ) {
 515                         if ( isset( $mwLanguages[$lang] ) ) {
 516                                 return $lang;
 517                         }
 518                 }
 519
 520                 return $wgLanguageCode;
 521         }
 522
 523         /**
 524          * Called by execute() before page output starts, to show a page list.
 525          *
 526          * @param string $currentPageName
 527          */
 528         private function startPageWrapper( $currentPageName ) {
 529                 $s = "<div class=\"config-page-wrapper\">\n";
 530                 $s .= "<div class=\"config-page\">\n";
 531                 $s .= "<div class=\"config-page-list\"><ul>\n";
 532                 $lastHappy = -1;
 533
 534                 foreach ( $this->pageSequence as $id => $pageName ) {
 535                         $happy = !empty( $this->happyPages[$id] );
 536                         $s .= $this->getPageListItem(
 537                                 $pageName,
 538                                 $happy || $lastHappy == $id - 1,
 539                                 $currentPageName
 540                         );
 541
 542                         if ( $happy ) {
 543                                 $lastHappy = $id;
 544                         }
 545                 }
 546
 547                 $s .= "</ul><br/><ul>\n";
 548                 $s .= $this->getPageListItem( 'Restart', true, $currentPageName );
 549                 // End list pane
 550                 $s .= "</ul></div>\n";
 551
 552                 // Messages:
 553                 // config-page-language, config-page-welcome, config-page-dbconnect, config-page-upgrade,
 554                 // config-page-dbsettings, config-page-name, config-page-options, config-page-install,
 555                 // config-page-complete, config-page-restart, config-page-readme, config-page-releasenotes,
 556                 // config-page-copying, config-page-upgradedoc, config-page-existingwiki
 557                 $s .= Html::element( 'h2', [],
 558                         wfMessage( 'config-page-' . strtolower( $currentPageName ) )->text() );
 559
 560                 $this->output->addHTMLNoFlush( $s );
 561         }
 562
 563         /**
 564          * Get a list item for the page list.
 565          *
 566          * @param string $pageName
 567          * @param bool $enabled
 568          * @param string $currentPageName
 569          *
 570          * @return string
 571          */
 572         private function getPageListItem( $pageName, $enabled, $currentPageName ) {
 573                 $s = "<li class=\"config-page-list-item\">";
 574
 575                 // Messages:
 576                 // config-page-language, config-page-welcome, config-page-dbconnect, config-page-upgrade,
 577                 // config-page-dbsettings, config-page-name, config-page-options, config-page-install,
 578                 // config-page-complete, config-page-restart, config-page-readme, config-page-releasenotes,
 579                 // config-page-copying, config-page-upgradedoc, config-page-existingwiki
 580                 $name = wfMessage( 'config-page-' . strtolower( $pageName ) )->text();
 581
 582                 if ( $enabled ) {
 583                         $query = [ 'page' => $pageName ];
 584
 585                         if ( !in_array( $pageName, $this->pageSequence ) ) {
 586                                 if ( in_array( $currentPageName, $this->pageSequence ) ) {
 587                                         $query['lastPage'] = $currentPageName;
 588                                 }
 589
 590                                 $link = Html::element( 'a',
 591                                         [
 592                                                 'href' => $this->getUrl( $query )
 593                                         ],
 594                                         $name
 595                                 );
 596                         } else {
 597                                 $link = htmlspecialchars( $name );
 598                         }
 599
 600                         if ( $pageName == $currentPageName ) {
 601                                 $s .= "<span class=\"config-page-current\">$link</span>";
 602                         } else {
 603                                 $s .= $link;
 604                         }
 605                 } else {
 606                         $s .= Html::element( 'span',
 607                                 [
 608                                         'class' => 'config-page-disabled'
 609                                 ],
 610                                 $name
 611                         );
 612                 }
 613
 614                 $s .= "</li>\n";
 615
 616                 return $s;
 617         }
 618
 619         /**
 620          * Output some stuff after a page is finished.
 621          */
 622         private function endPageWrapper() {
 623                 $this->output->addHTMLNoFlush(
 624                         "<div class=\"visualClear\"></div>\n" .
 625                         "</div>\n" .
 626                         "<div class=\"visualClear\"></div>\n" .
 627                         "</div>" );
 628         }
 629
 630         /**
 631          * Get HTML for an error box with an icon.
 632          *
 633          * @param string $text Wikitext, get this with wfMessage()->plain()
 634          *
 635          * @return string
 636          */
 637         public function getErrorBox( $text ) {
 638                 return $this->getInfoBox( $text, 'critical-32.png', 'config-error-box' );
 639         }
 640
 641         /**
 642          * Get HTML for a warning box with an icon.
 643          *
 644          * @param string $text Wikitext, get this with wfMessage()->plain()
 645          *
 646          * @return string
 647          */
 648         public function getWarningBox( $text ) {
 649                 return $this->getInfoBox( $text, 'warning-32.png', 'config-warning-box' );
 650         }
 651
 652         /**
 653          * Get HTML for an info box with an icon.
 654          *
 655          * @param string $text Wikitext, get this with wfMessage()->plain()
 656          * @param string|bool $icon Icon name, file in mw-config/images. Default: false
 657          * @param string|bool $class Additional class name to add to the wrapper div. Default: false.
 658          *
 659          * @return string
 660          */
 661         public function getInfoBox( $text, $icon = false, $class = false ) {
 662                 $text = $this->parse( $text, true );
 663                 $icon = ( $icon == false ) ?
 664                         'images/info-32.png' :
 665                         'images/' . $icon;
 666                 $alt = wfMessage( 'config-information' )->text();
 667
 668                 return Html::infoBox( $text, $icon, $alt, $class );
 669         }
 670
 671         /**
 672          * Get small text indented help for a preceding form field.
 673          * Parameters like wfMessage().
 674          *
 675          * @param string $msg
 676          * @return string
 677          */
 678         public function getHelpBox( $msg /*, ... */ ) {
 679                 $args = func_get_args();
 680                 array_shift( $args );
 681                 $args = array_map( 'htmlspecialchars', $args );
 682                 $text = wfMessage( $msg, $args )->useDatabase( false )->plain();
 683                 $html = $this->parse( $text, true );
 684
 685                 return "<div class=\"config-help-field-container\">\n" .
 686                         "<span class=\"config-help-field-hint\" title=\"" .
 687                         wfMessage( 'config-help-tooltip' )->escaped() . "\">" .
 688                         wfMessage( 'config-help' )->escaped() . "</span>\n" .
 689                         "<div class=\"config-help-field-data\">" . $html . "</div>\n" .
 690                         "</div>\n";
 691         }
 692
 693         /**
 694          * Output a help box.
 695          * @param string $msg Key for wfMessage()
 696          */
 697         public function showHelpBox( $msg /*, ... */ ) {
 698                 $args = func_get_args();
 699                 $html = $this->getHelpBox( ...$args );
 700                 $this->output->addHTML( $html );
 701         }
 702
 703         /**
 704          * Show a short informational message.
 705          * Output looks like a list.
 706          *
 707          * @param string $msg
 708          */
 709         public function showMessage( $msg /*, ... */ ) {
 710                 $args = func_get_args();
 711                 array_shift( $args );
 712                 $html = '<div class="config-message">' .
 713                         $this->parse( wfMessage( $msg, $args )->useDatabase( false )->plain() ) .
 714                         "</div>\n";
 715                 $this->output->addHTML( $html );
 716         }
 717
 718         /**
 719          * @param Status $status
 720          */
 721         public function showStatusMessage( Status $status ) {
 722                 $errors = array_merge( $status->getErrorsArray(), $status->getWarningsArray() );
 723                 foreach ( $errors as $error ) {
 724                         $this->showMessage( ...$error );
 725                 }
 726         }
 727
 728         /**
 729          * Label a control by wrapping a config-input div around it and putting a
 730          * label before it.
 731          *
 732          * @param string $msg
 733          * @param string $forId
 734          * @param string $contents
 735          * @param string $helpData
 736          * @return string
 737          */
 738         public function label( $msg, $forId, $contents, $helpData = "" ) {
 739                 if ( strval( $msg ) == '' ) {
 740                         $labelText = "\u{00A0}";
 741                 } else {
 742                         $labelText = wfMessage( $msg )->escaped();
 743                 }
 744
 745                 $attributes = [ 'class' => 'config-label' ];
 746
 747                 if ( $forId ) {
 748                         $attributes['for'] = $forId;
 749                 }
 750
 751                 return "<div class=\"config-block\">\n" .
 752                         "  <div class=\"config-block-label\">\n" .
 753                         Xml::tags( 'label',
 754                                 $attributes,
 755                                 $labelText
 756                         ) . "\n" .
 757                         $helpData .
 758                         "  </div>\n" .
 759                         "  <div class=\"config-block-elements\">\n" .
 760                         $contents .
 761                         "  </div>\n" .
 762                         "</div>\n";
 763         }
 764
 765         /**
 766          * Get a labelled text box to configure a variable.
 767          *
 768          * @param mixed[] $params
 769          *    Parameters are:
 770          *      var:         The variable to be configured (required)
 771          *      label:       The message name for the label (required)
 772          *      attribs:     Additional attributes for the input element (optional)
 773          *      controlName: The name for the input element (optional)
 774          *      value:       The current value of the variable (optional)
 775          *      help:        The html for the help text (optional)
 776          *
 777          * @return string
 778          */
 779         public function getTextBox( $params ) {
 780                 if ( !isset( $params['controlName'] ) ) {
 781                         $params['controlName'] = 'config_' . $params['var'];
 782                 }
 783
 784                 if ( !isset( $params['value'] ) ) {
 785                         $params['value'] = $this->getVar( $params['var'] );
 786                 }
 787
 788                 if ( !isset( $params['attribs'] ) ) {
 789                         $params['attribs'] = [];
 790                 }
 791                 if ( !isset( $params['help'] ) ) {
 792                         $params['help'] = "";
 793                 }
 794
 795                 return $this->label(
 796                         $params['label'],
 797                         $params['controlName'],
 798                         Xml::input(
 799                                 $params['controlName'],
 800                                 30, // intended to be overridden by CSS
 801                                 $params['value'],
 802                                 $params['attribs'] + [
 803                                         'id' => $params['controlName'],
 804                                         'class' => 'config-input-text',
 805                                         'tabindex' => $this->nextTabIndex()
 806                                 ]
 807                         ),
 808                         $params['help']
 809                 );
 810         }
 811
 812         /**
 813          * Get a labelled textarea to configure a variable
 814          *
 815          * @param mixed[] $params
 816          *    Parameters are:
 817          *      var:         The variable to be configured (required)
 818          *      label:       The message name for the label (required)
 819          *      attribs:     Additional attributes for the input element (optional)
 820          *      controlName: The name for the input element (optional)
 821          *      value:       The current value of the variable (optional)
 822          *      help:        The html for the help text (optional)
 823          *
 824          * @return string
 825          */
 826         public function getTextArea( $params ) {
 827                 if ( !isset( $params['controlName'] ) ) {
 828                         $params['controlName'] = 'config_' . $params['var'];
 829                 }
 830
 831                 if ( !isset( $params['value'] ) ) {
 832                         $params['value'] = $this->getVar( $params['var'] );
 833                 }
 834
 835                 if ( !isset( $params['attribs'] ) ) {
 836                         $params['attribs'] = [];
 837                 }
 838                 if ( !isset( $params['help'] ) ) {
 839                         $params['help'] = "";
 840                 }
 841
 842                 return $this->label(
 843                         $params['label'],
 844                         $params['controlName'],
 845                         Xml::textarea(
 846                                 $params['controlName'],
 847                                 $params['value'],
 848                                 30,
 849                                 5,
 850                                 $params['attribs'] + [
 851                                         'id' => $params['controlName'],
 852                                         'class' => 'config-input-text',
 853                                         'tabindex' => $this->nextTabIndex()
 854                                 ]
 855                         ),
 856                         $params['help']
 857                 );
 858         }
 859
 860         /**
 861          * Get a labelled password box to configure a variable.
 862          *
 863          * Implements password hiding
 864          * @param mixed[] $params
 865          *    Parameters are:
 866          *      var:         The variable to be configured (required)
 867          *      label:       The message name for the label (required)
 868          *      attribs:     Additional attributes for the input element (optional)
 869          *      controlName: The name for the input element (optional)
 870          *      value:       The current value of the variable (optional)
 871          *      help:        The html for the help text (optional)
 872          *
 873          * @return string
 874          */
 875         public function getPasswordBox( $params ) {
 876                 if ( !isset( $params['value'] ) ) {
 877                         $params['value'] = $this->getVar( $params['var'] );
 878                 }
 879
 880                 if ( !isset( $params['attribs'] ) ) {
 881                         $params['attribs'] = [];
 882                 }
 883
 884                 $params['value'] = $this->getFakePassword( $params['value'] );
 885                 $params['attribs']['type'] = 'password';
 886
 887                 return $this->getTextBox( $params );
 888         }
 889
 890         /**
 891          * Get a labelled checkbox to configure a boolean variable.
 892          *
 893          * @param mixed[] $params
 894          *    Parameters are:
 895          *      var:         The variable to be configured (required)
 896          *      label:       The message name for the label (required)
 897          *      labelAttribs:Additional attributes for the label element (optional)
 898          *      attribs:     Additional attributes for the input element (optional)
 899          *      controlName: The name for the input element (optional)
 900          *      value:       The current value of the variable (optional)
 901          *      help:        The html for the help text (optional)
 902          *
 903          * @return string
 904          */
 905         public function getCheckBox( $params ) {
 906                 if ( !isset( $params['controlName'] ) ) {
 907                         $params['controlName'] = 'config_' . $params['var'];
 908                 }
 909
 910                 if ( !isset( $params['value'] ) ) {
 911                         $params['value'] = $this->getVar( $params['var'] );
 912                 }
 913
 914                 if ( !isset( $params['attribs'] ) ) {
 915                         $params['attribs'] = [];
 916                 }
 917                 if ( !isset( $params['help'] ) ) {
 918                         $params['help'] = "";
 919                 }
 920                 if ( !isset( $params['labelAttribs'] ) ) {
 921                         $params['labelAttribs'] = [];
 922                 }
 923                 $labelText = $params['rawtext'] ?? $this->parse( wfMessage( $params['label'] )->plain() );
 924
 925                 return "<div class=\"config-input-check\">\n" .
 926                         $params['help'] .
 927                         Html::rawElement(
 928                                 'label',
 929                                 $params['labelAttribs'],
 930                                 Xml::check(
 931                                         $params['controlName'],
 932                                         $params['value'],
 933                                         $params['attribs'] + [
 934                                                 'id' => $params['controlName'],
 935                                                 'tabindex' => $this->nextTabIndex(),
 936                                         ]
 937                                 ) .
 938                                 $labelText . "\n"
 939                                 ) .
 940                         "</div>\n";
 941         }
 942
 943         /**
 944          * Get a set of labelled radio buttons.
 945          *
 946          * @param mixed[] $params
 947          *    Parameters are:
 948          *      var:             The variable to be configured (required)
 949          *      label:           The message name for the label (required)
 950          *      itemLabelPrefix: The message name prefix for the item labels (required)
 951          *      itemLabels:      List of message names to use for the item labels instead
 952          *                       of itemLabelPrefix, keyed by values
 953          *      values:          List of allowed values (required)
 954          *      itemAttribs:     Array of attribute arrays, outer key is the value name (optional)
 955          *      commonAttribs:   Attribute array applied to all items
 956          *      controlName:     The name for the input element (optional)
 957          *      value:           The current value of the variable (optional)
 958          *      help:            The html for the help text (optional)
 959          *
 960          * @return string
 961          */
 962         public function getRadioSet( $params ) {
 963                 $items = $this->getRadioElements( $params );
 964
 965                 $label = $params['label'] ?? '';
 966
 967                 if ( !isset( $params['controlName'] ) ) {
 968                         $params['controlName'] = 'config_' . $params['var'];
 969                 }
 970
 971                 if ( !isset( $params['help'] ) ) {
 972                         $params['help'] = "";
 973                 }
 974
 975                 $s = "<ul>\n";
 976                 foreach ( $items as $value => $item ) {
 977                         $s .= "<li>$item</li>\n";
 978                 }
 979                 $s .= "</ul>\n";
 980
 981                 return $this->label( $label, $params['controlName'], $s, $params['help'] );
 982         }
 983
 984         /**
 985          * Get a set of labelled radio buttons. You probably want to use getRadioSet(), not this.
 986          *
 987          * @see getRadioSet
 988          *
 989          * @param mixed[] $params
 990          * @return array
 991          */
 992         public function getRadioElements( $params ) {
 993                 if ( !isset( $params['controlName'] ) ) {
 994                         $params['controlName'] = 'config_' . $params['var'];
 995                 }
 996
 997                 if ( !isset( $params['value'] ) ) {
 998                         $params['value'] = $this->getVar( $params['var'] );
 999                 }
1000
1001                 $items = [];
1002
1003                 foreach ( $params['values'] as $value ) {
1004                         $itemAttribs = [];
1005
1006                         if ( isset( $params['commonAttribs'] ) ) {
1007                                 $itemAttribs = $params['commonAttribs'];
1008                         }
1009
1010                         if ( isset( $params['itemAttribs'][$value] ) ) {
1011                                 $itemAttribs = $params['itemAttribs'][$value] + $itemAttribs;
1012                         }
1013
1014                         $checked = $value == $params['value'];
1015                         $id = $params['controlName'] . '_' . $value;
1016                         $itemAttribs['id'] = $id;
1017                         $itemAttribs['tabindex'] = $this->nextTabIndex();
1018
1019                         $items[$value] =
1020                                 Xml::radio( $params['controlName'], $value, $checked, $itemAttribs ) .
1021                                 "\u{00A0}" .
1022                                 Xml::tags( 'label', [ 'for' => $id ], $this->parse(
1023                                         isset( $params['itemLabels'] ) ?
1024                                                 wfMessage( $params['itemLabels'][$value] )->plain() :
1025                                                 wfMessage( $params['itemLabelPrefix'] . strtolower( $value ) )->plain()
1026                                 ) );
1027                 }
1028
1029                 return $items;
1030         }
1031
1032         /**
1033          * Output an error or warning box using a Status object.
1034          *
1035          * @param Status $status
1036          */
1037         public function showStatusBox( $status ) {
1038                 if ( !$status->isGood() ) {
1039                         $text = $status->getWikiText();
1040
1041                         if ( $status->isOK() ) {
1042                                 $box = $this->getWarningBox( $text );
1043                         } else {
1044                                 $box = $this->getErrorBox( $text );
1045                         }
1046
1047                         $this->output->addHTML( $box );
1048                 }
1049         }
1050
1051         /**
1052          * Convenience function to set variables based on form data.
1053          * Assumes that variables containing "password" in the name are (potentially
1054          * fake) passwords.
1055          *
1056          * @param string[] $varNames
1057          * @param string $prefix The prefix added to variables to obtain form names
1058          *
1059          * @return string[]
1060          */
1061         public function setVarsFromRequest( $varNames, $prefix = 'config_' ) {
1062                 $newValues = [];
1063
1064                 foreach ( $varNames as $name ) {
1065                         $value = $this->request->getVal( $prefix . $name );
1066                         // T32524, do not trim passwords
1067                         if ( stripos( $name, 'password' ) === false ) {
1068                                 $value = trim( $value );
1069                         }
1070                         $newValues[$name] = $value;
1071
1072                         if ( $value === null ) {
1073                                 // Checkbox?
1074                                 $this->setVar( $name, false );
1075                         } elseif ( stripos( $name, 'password' ) !== false ) {
1076                                 $this->setPassword( $name, $value );
1077                         } else {
1078                                 $this->setVar( $name, $value );
1079                         }
1080                 }
1081
1082                 return $newValues;
1083         }
1084
1085         /**
1086          * Helper for Installer::docLink()
1087          *
1088          * @param string $page
1089          *
1090          * @return string
1091          */
1092         protected function getDocUrl( $page ) {
1093                 $query = [ 'page' => $page ];
1094
1095                 if ( in_array( $this->currentPageName, $this->pageSequence ) ) {
1096                         $query['lastPage'] = $this->currentPageName;
1097                 }
1098
1099                 return $this->getUrl( $query );
1100         }
1101
1102         /**
1103          * Extension tag hook for a documentation link.
1104          *
1105          * @param string $linkText
1106          * @param string[] $attribs
1107          * @param Parser $parser Unused
1108          *
1109          * @return string
1110          */
1111         public function docLink( $linkText, $attribs, $parser ) {
1112                 $url = $this->getDocUrl( $attribs['href'] );
1113
1114                 return Html::element( 'a', [ 'href' => $url ], $linkText );
1115         }
1116
1117         /**
1118          * Helper for "Download LocalSettings" link on WebInstall_Complete
1119          *
1120          * @param string $text Unused
1121          * @param string[] $attribs Unused
1122          * @param Parser $parser Unused
1123          *
1124          * @return string Html for download link
1125          */
1126         public function downloadLinkHook( $text, $attribs, $parser ) {
1127                 $anchor = Html::rawElement( 'a',
1128                         [ 'href' => $this->getUrl( [ 'localsettings' => 1 ] ) ],
1129                         wfMessage( 'config-download-localsettings' )->parse()
1130                 );
1131
1132                 return Html::rawElement( 'div', [ 'class' => 'config-download-link' ], $anchor );
1133         }
1134
1135         /**
1136          * If the software package wants the LocalSettings.php file
1137          * to be placed in a specific location, override this function
1138          * (see mw-config/overrides/README) to return the path of
1139          * where the file should be saved, or false for a generic
1140          * "in the base of your install"
1141          *
1142          * @since 1.27
1143          * @return string|bool
1144          */
1145         public function getLocalSettingsLocation() {
1146                 return false;
1147         }
1148
1149         /**
1150          * @return bool
1151          */
1152         public function envCheckPath() {
1153                 // PHP_SELF isn't available sometimes, such as when PHP is CGI but
1154                 // cgi.fix_pathinfo is disabled. In that case, fall back to SCRIPT_NAME
1155                 // to get the path to the current script... hopefully it's reliable. SIGH
1156                 $path = false;
1157                 if ( !empty( $_SERVER['PHP_SELF'] ) ) {
1158                         $path = $_SERVER['PHP_SELF'];
1159                 } elseif ( !empty( $_SERVER['SCRIPT_NAME'] ) ) {
1160                         $path = $_SERVER['SCRIPT_NAME'];
1161                 }
1162                 if ( $path === false ) {
1163                         $this->showError( 'config-no-uri' );
1164                         return false;
1165                 }
1166
1167                 return parent::envCheckPath();
1168         }
1169
1170         public function envPrepPath() {
1171                 parent::envPrepPath();
1172                 // PHP_SELF isn't available sometimes, such as when PHP is CGI but
1173                 // cgi.fix_pathinfo is disabled. In that case, fall back to SCRIPT_NAME
1174                 // to get the path to the current script... hopefully it's reliable. SIGH
1175                 $path = false;
1176                 if ( !empty( $_SERVER['PHP_SELF'] ) ) {
1177                         $path = $_SERVER['PHP_SELF'];
1178                 } elseif ( !empty( $_SERVER['SCRIPT_NAME'] ) ) {
1179                         $path = $_SERVER['SCRIPT_NAME'];
1180                 }
1181                 if ( $path !== false ) {
1182                         $scriptPath = preg_replace( '{^(.*)/(mw-)?config.*$}', '$1', $path );
1183
1184                         $this->setVar( 'wgScriptPath', "$scriptPath" );
1185                         // Update variables set from Setup.php that are derived from wgScriptPath
1186                         $this->setVar( 'wgScript', "$scriptPath/index.php" );
1187                         $this->setVar( 'wgLoadScript', "$scriptPath/load.php" );
1188                         $this->setVar( 'wgStylePath', "$scriptPath/skins" );
1189                         $this->setVar( 'wgLocalStylePath', "$scriptPath/skins" );
1190                         $this->setVar( 'wgExtensionAssetsPath', "$scriptPath/extensions" );
1191                         $this->setVar( 'wgUploadPath', "$scriptPath/images" );
1192                         $this->setVar( 'wgResourceBasePath', "$scriptPath" );
1193                 }
1194         }
1195
1196         /**
1197          * @return string
1198          */
1199         protected function envGetDefaultServer() {
1200                 return WebRequest::detectServer();
1201         }
1202
1203         /**
1204          * Actually output LocalSettings.php for download
1205          *
1206          * @suppress SecurityCheck-XSS
1207          */
1208         private function outputLS() {
1209                 $this->request->response()->header( 'Content-type: application/x-httpd-php' );
1210                 $this->request->response()->header(
1211                         'Content-Disposition: attachment; filename="LocalSettings.php"'
1212                 );
1213
1214                 $ls = InstallerOverrides::getLocalSettingsGenerator( $this );
1215                 $rightsProfile = $this->rightsProfiles[$this->getVar( '_RightsProfile' )];
1216                 foreach ( $rightsProfile as $group => $rightsArr ) {
1217                         $ls->setGroupRights( $group, $rightsArr );
1218                 }
1219                 echo $ls->getText();
1220         }
1221
1222         /**
1223          * Output stylesheet for web installer pages
1224          */
1225         public function outputCss() {
1226                 $this->request->response()->header( 'Content-type: text/css' );
1227                 echo $this->output->getCSS();
1228         }
1229
1230         /**
1231          * @return string[]
1232          */
1233         public function getPhpErrors() {
1234                 return $this->phpErrors;
1235         }
1236
1237 }