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