includes/specialpage/LoginSignupSpecialPage.php

   1 <?php
   2 /**
   3  * Holds shared logic for login and account creation pages.
   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 SpecialPage
  22  */
  23
  24 use MediaWiki\Auth\AuthenticationRequest;
  25 use MediaWiki\Auth\AuthenticationResponse;
  26 use MediaWiki\Auth\AuthManager;
  27 use MediaWiki\Logger\LoggerFactory;
  28 use MediaWiki\MediaWikiServices;
  29 use MediaWiki\Session\SessionManager;
  30 use Wikimedia\ScopedCallback;
  31
  32 /**
  33  * Holds shared logic for login and account creation pages.
  34  *
  35  * @ingroup SpecialPage
  36  */
  37 abstract class LoginSignupSpecialPage extends AuthManagerSpecialPage {
  38         protected $mReturnTo;
  39         protected $mPosted;
  40         protected $mAction;
  41         protected $mLanguage;
  42         protected $mReturnToQuery;
  43         protected $mToken;
  44         protected $mStickHTTPS;
  45         protected $mFromHTTP;
  46         protected $mEntryError = '';
  47         protected $mEntryErrorType = 'error';
  48
  49         protected $mLoaded = false;
  50         protected $mLoadedRequest = false;
  51         protected $mSecureLoginUrl;
  52
  53         /** @var string */
  54         protected $securityLevel;
  55
  56         /** @var bool True if the user if creating an account for someone else. Flag used for internal
  57          * communication, only set at the very end.
  58          */
  59         protected $proxyAccountCreation;
  60         /** @var User FIXME another flag for passing data. */
  61         protected $targetUser;
  62
  63         /** @var HTMLForm */
  64         protected $authForm;
  65
  66         abstract protected function isSignup();
  67
  68         /**
  69          * @param bool $direct True if the action was successful just now; false if that happened
  70          *    pre-redirection (so this handler was called already)
  71          * @param StatusValue|null $extraMessages
  72          * @return void
  73          */
  74         abstract protected function successfulAction( $direct = false, $extraMessages = null );
  75
  76         /**
  77          * Logs to the authmanager-stats channel.
  78          * @param bool $success
  79          * @param string|null $status Error message key
  80          */
  81         abstract protected function logAuthResult( $success, $status = null );
  82
  83         public function __construct( $name ) {
  84                 global $wgUseMediaWikiUIEverywhere;
  85                 parent::__construct( $name );
  86
  87                 // Override UseMediaWikiEverywhere to true, to force login and create form to use mw ui
  88                 $wgUseMediaWikiUIEverywhere = true;
  89         }
  90
  91         protected function setRequest( array $data, $wasPosted = null ) {
  92                 parent::setRequest( $data, $wasPosted );
  93                 $this->mLoadedRequest = false;
  94         }
  95
  96         /**
  97          * Load basic request parameters for this Special page.
  98          */
  99         private function loadRequestParameters() {
 100                 if ( $this->mLoadedRequest ) {
 101                         return;
 102                 }
 103                 $this->mLoadedRequest = true;
 104                 $request = $this->getRequest();
 105
 106                 $this->mPosted = $request->wasPosted();
 107                 $this->mAction = $request->getVal( 'action' );
 108                 $this->mFromHTTP = $request->getBool( 'fromhttp', false )
 109                         || $request->getBool( 'wpFromhttp', false );
 110                 $this->mStickHTTPS = ( !$this->mFromHTTP && $request->getProtocol() === 'https' )
 111                         || $request->getBool( 'wpForceHttps', false );
 112                 $this->mLanguage = $request->getText( 'uselang' );
 113                 $this->mReturnTo = $request->getVal( 'returnto', '' );
 114                 $this->mReturnToQuery = $request->getVal( 'returntoquery', '' );
 115         }
 116
 117         /**
 118          * Load data from request.
 119          * @private
 120          * @param string $subPage Subpage of Special:Userlogin
 121          */
 122         protected function load( $subPage ) {
 123                 global $wgSecureLogin;
 124
 125                 $this->loadRequestParameters();
 126                 if ( $this->mLoaded ) {
 127                         return;
 128                 }
 129                 $this->mLoaded = true;
 130                 $request = $this->getRequest();
 131
 132                 $securityLevel = $this->getRequest()->getText( 'force' );
 133                 if (
 134                         $securityLevel && AuthManager::singleton()->securitySensitiveOperationStatus(
 135                                 $securityLevel ) === AuthManager::SEC_REAUTH
 136                 ) {
 137                         $this->securityLevel = $securityLevel;
 138                 }
 139
 140                 $this->loadAuth( $subPage );
 141
 142                 $this->mToken = $request->getVal( $this->getTokenName() );
 143
 144                 // Show an error or warning passed on from a previous page
 145                 $entryError = $this->msg( $request->getVal( 'error', '' ) );
 146                 $entryWarning = $this->msg( $request->getVal( 'warning', '' ) );
 147                 // bc: provide login link as a parameter for messages where the translation
 148                 // was not updated
 149                 $loginreqlink = $this->getLinkRenderer()->makeKnownLink(
 150                         $this->getPageTitle(),
 151                         $this->msg( 'loginreqlink' )->text(),
 152                         [],
 153                         [
 154                                 'returnto' => $this->mReturnTo,
 155                                 'returntoquery' => $this->mReturnToQuery,
 156                                 'uselang' => $this->mLanguage ?: null,
 157                                 'fromhttp' => $wgSecureLogin && $this->mFromHTTP ? '1' : null,
 158                         ]
 159                 );
 160
 161                 // Only show valid error or warning messages.
 162                 if ( $entryError->exists()
 163                         && in_array( $entryError->getKey(), LoginHelper::getValidErrorMessages(), true )
 164                 ) {
 165                         $this->mEntryErrorType = 'error';
 166                         $this->mEntryError = $entryError->rawParams( $loginreqlink )->parse();
 167
 168                 } elseif ( $entryWarning->exists()
 169                         && in_array( $entryWarning->getKey(), LoginHelper::getValidErrorMessages(), true )
 170                 ) {
 171                         $this->mEntryErrorType = 'warning';
 172                         $this->mEntryError = $entryWarning->rawParams( $loginreqlink )->parse();
 173                 }
 174
 175                 # 1. When switching accounts, it sucks to get automatically logged out
 176                 # 2. Do not return to PasswordReset after a successful password change
 177                 #    but goto Wiki start page (Main_Page) instead ( T35997 )
 178                 $returnToTitle = Title::newFromText( $this->mReturnTo );
 179                 if ( is_object( $returnToTitle )
 180                         && ( $returnToTitle->isSpecial( 'Userlogout' )
 181                                 || $returnToTitle->isSpecial( 'PasswordReset' ) )
 182                 ) {
 183                         $this->mReturnTo = '';
 184                         $this->mReturnToQuery = '';
 185                 }
 186         }
 187
 188         protected function getPreservedParams( $withToken = false ) {
 189                 global $wgSecureLogin;
 190
 191                 $params = parent::getPreservedParams( $withToken );
 192                 $params += [
 193                         'returnto' => $this->mReturnTo ?: null,
 194                         'returntoquery' => $this->mReturnToQuery ?: null,
 195                 ];
 196                 if ( $wgSecureLogin && !$this->isSignup() ) {
 197                         $params['fromhttp'] = $this->mFromHTTP ? '1' : null;
 198                 }
 199                 return $params;
 200         }
 201
 202         protected function beforeExecute( $subPage ) {
 203                 // finish initializing the class before processing the request - T135924
 204                 $this->loadRequestParameters();
 205                 return parent::beforeExecute( $subPage );
 206         }
 207
 208         /**
 209          * @param string|null $subPage
 210          * @suppress PhanTypeObjectUnsetDeclaredProperty
 211          */
 212         public function execute( $subPage ) {
 213                 if ( $this->mPosted ) {
 214                         $time = microtime( true );
 215                         $profilingScope = new ScopedCallback( function () use ( $time ) {
 216                                 $time = microtime( true ) - $time;
 217                                 $statsd = MediaWikiServices::getInstance()->getStatsdDataFactory();
 218                                 $statsd->timing( "timing.login.ui.{$this->authAction}", $time * 1000 );
 219                         } );
 220                 }
 221
 222                 $authManager = AuthManager::singleton();
 223                 $session = SessionManager::getGlobalSession();
 224
 225                 // Session data is used for various things in the authentication process, so we must make
 226                 // sure a session cookie or some equivalent mechanism is set.
 227                 $session->persist();
 228
 229                 $this->load( $subPage );
 230                 $this->setHeaders();
 231                 $this->checkPermissions();
 232
 233                 // Make sure the system configuration allows log in / sign up
 234                 if ( !$this->isSignup() && !$authManager->canAuthenticateNow() ) {
 235                         if ( !$session->canSetUser() ) {
 236                                 throw new ErrorPageError( 'cannotloginnow-title', 'cannotloginnow-text', [
 237                                         $session->getProvider()->describe( RequestContext::getMain()->getLanguage() )
 238                                 ] );
 239                         }
 240                         throw new ErrorPageError( 'cannotlogin-title', 'cannotlogin-text' );
 241                 } elseif ( $this->isSignup() && !$authManager->canCreateAccounts() ) {
 242                         throw new ErrorPageError( 'cannotcreateaccount-title', 'cannotcreateaccount-text' );
 243                 }
 244
 245                 /*
 246                  * In the case where the user is already logged in, and was redirected to
 247                  * the login form from a page that requires login, do not show the login
 248                  * page. The use case scenario for this is when a user opens a large number
 249                  * of tabs, is redirected to the login page on all of them, and then logs
 250                  * in on one, expecting all the others to work properly.
 251                  *
 252                  * However, do show the form if it was visited intentionally (no 'returnto'
 253                  * is present). People who often switch between several accounts have grown
 254                  * accustomed to this behavior.
 255                  *
 256                  * Also make an exception when force=<level> is set in the URL, which means the user must
 257                  * reauthenticate for security reasons.
 258                  */
 259                 if ( !$this->isSignup() && !$this->mPosted && !$this->securityLevel &&
 260                          ( $this->mReturnTo !== '' || $this->mReturnToQuery !== '' ) &&
 261                          $this->getUser()->isLoggedIn()
 262                 ) {
 263                         $this->successfulAction();
 264                         return;
 265                 }
 266
 267                 // If logging in and not on HTTPS, either redirect to it or offer a link.
 268                 global $wgSecureLogin;
 269                 if ( $this->getRequest()->getProtocol() !== 'https' ) {
 270                         $title = $this->getFullTitle();
 271                         $query = $this->getPreservedParams( false ) + [
 272                                         'title' => null,
 273                                         ( $this->mEntryErrorType === 'error' ? 'error'
 274                                                 : 'warning' ) => $this->mEntryError,
 275                                 ] + $this->getRequest()->getQueryValues();
 276                         $url = $title->getFullURL( $query, false, PROTO_HTTPS );
 277                         if ( $wgSecureLogin && !$this->mFromHTTP &&
 278                                  wfCanIPUseHTTPS( $this->getRequest()->getIP() )
 279                         ) {
 280                                 // Avoid infinite redirect
 281                                 $url = wfAppendQuery( $url, 'fromhttp=1' );
 282                                 $this->getOutput()->redirect( $url );
 283                                 // Since we only do this redir to change proto, always vary
 284                                 $this->getOutput()->addVaryHeader( 'X-Forwarded-Proto' );
 285
 286                                 return;
 287                         } else {
 288                                 // A wiki without HTTPS login support should set $wgServer to
 289                                 // http://somehost, in which case the secure URL generated
 290                                 // above won't actually start with https://
 291                                 if ( substr( $url, 0, 8 ) === 'https://' ) {
 292                                         $this->mSecureLoginUrl = $url;
 293                                 }
 294                         }
 295                 }
 296
 297                 if ( !$this->isActionAllowed( $this->authAction ) ) {
 298                         // FIXME how do we explain this to the user? can we handle session loss better?
 299                         // messages used: authpage-cannot-login, authpage-cannot-login-continue,
 300                         // authpage-cannot-create, authpage-cannot-create-continue
 301                         $this->mainLoginForm( [], 'authpage-cannot-' . $this->authAction );
 302                         return;
 303                 }
 304
 305                 if ( $this->canBypassForm( $button_name ) ) {
 306                         $this->setRequest( [], true );
 307                         $this->getRequest()->setVal( $this->getTokenName(), $this->getToken() );
 308                         if ( $button_name ) {
 309                                 $this->getRequest()->setVal( $button_name, true );
 310                         }
 311                 }
 312
 313                 $status = $this->trySubmit();
 314
 315                 if ( !$status || !$status->isGood() ) {
 316                         $this->mainLoginForm( $this->authRequests, $status ? $status->getMessage() : '', 'error' );
 317                         return;
 318                 }
 319
 320                 /** @var AuthenticationResponse $response */
 321                 $response = $status->getValue();
 322
 323                 $returnToUrl = $this->getPageTitle( 'return' )
 324                         ->getFullURL( $this->getPreservedParams( true ), false, PROTO_HTTPS );
 325                 switch ( $response->status ) {
 326                         case AuthenticationResponse::PASS:
 327                                 $this->logAuthResult( true );
 328                                 $this->proxyAccountCreation = $this->isSignup() && !$this->getUser()->isAnon();
 329                                 $this->targetUser = User::newFromName( $response->username );
 330
 331                                 if (
 332                                         !$this->proxyAccountCreation
 333                                         && $response->loginRequest
 334                                         && $authManager->canAuthenticateNow()
 335                                 ) {
 336                                         // successful registration; log the user in instantly
 337                                         $response2 = $authManager->beginAuthentication( [ $response->loginRequest ],
 338                                                 $returnToUrl );
 339                                         if ( $response2->status !== AuthenticationResponse::PASS ) {
 340                                                 LoggerFactory::getInstance( 'login' )
 341                                                         ->error( 'Could not log in after account creation' );
 342                                                 $this->successfulAction( true, Status::newFatal( 'createacct-loginerror' ) );
 343                                                 break;
 344                                         }
 345                                 }
 346
 347                                 if ( !$this->proxyAccountCreation ) {
 348                                         // Ensure that the context user is the same as the session user.
 349                                         $this->setSessionUserForCurrentRequest();
 350                                 }
 351
 352                                 $this->successfulAction( true );
 353                                 break;
 354                         case AuthenticationResponse::FAIL:
 355                                 // fall through
 356                         case AuthenticationResponse::RESTART:
 357                                 unset( $this->authForm );
 358                                 if ( $response->status === AuthenticationResponse::FAIL ) {
 359                                         $action = $this->getDefaultAction( $subPage );
 360                                         $messageType = 'error';
 361                                 } else {
 362                                         $action = $this->getContinueAction( $this->authAction );
 363                                         $messageType = 'warning';
 364                                 }
 365                                 $this->logAuthResult( false, $response->message ? $response->message->getKey() : '-' );
 366                                 $this->loadAuth( $subPage, $action, true );
 367                                 $this->mainLoginForm( $this->authRequests, $response->message, $messageType );
 368                                 break;
 369                         case AuthenticationResponse::REDIRECT:
 370                                 unset( $this->authForm );
 371                                 $this->getOutput()->redirect( $response->redirectTarget );
 372                                 break;
 373                         case AuthenticationResponse::UI:
 374                                 unset( $this->authForm );
 375                                 $this->authAction = $this->isSignup() ? AuthManager::ACTION_CREATE_CONTINUE
 376                                         : AuthManager::ACTION_LOGIN_CONTINUE;
 377                                 $this->authRequests = $response->neededRequests;
 378                                 $this->mainLoginForm( $response->neededRequests, $response->message, $response->messageType );
 379                                 break;
 380                         default:
 381                                 throw new LogicException( 'invalid AuthenticationResponse' );
 382                 }
 383         }
 384
 385         /**
 386          * Determine if the login form can be bypassed. This will be the case when no more than one
 387          * button is present and no other user input fields that are not marked as 'skippable' are
 388          * present. If the login form were not bypassed, the user would be presented with a
 389          * superfluous page on which they must press the single button to proceed with login.
 390          * Not only does this cause an additional mouse click and page load, it confuses users,
 391          * especially since there are a help link and forgotten password link that are
 392          * provided on the login page that do not apply to this situation.
 393          *
 394          * @param string|null &$button_name if the form has a single button, returns
 395          *   the name of the button; otherwise, returns null
 396          * @return bool
 397          */
 398         private function canBypassForm( &$button_name ) {
 399                 $button_name = null;
 400                 if ( $this->isContinued() ) {
 401                         return false;
 402                 }
 403                 $fields = AuthenticationRequest::mergeFieldInfo( $this->authRequests );
 404                 foreach ( $fields as $fieldname => $field ) {
 405                         if ( !isset( $field['type'] ) ) {
 406                                 return false;
 407                         }
 408                         if ( !empty( $field['skippable'] ) ) {
 409                                 continue;
 410                         }
 411                         if ( $field['type'] === 'button' ) {
 412                                 if ( $button_name !== null ) {
 413                                         $button_name = null;
 414                                         return false;
 415                                 } else {
 416                                         $button_name = $fieldname;
 417                                 }
 418                         } elseif ( $field['type'] !== 'null' ) {
 419                                 return false;
 420                         }
 421                 }
 422                 return true;
 423         }
 424
 425         /**
 426          * Show the success page.
 427          *
 428          * @param string $type Condition of return to; see `executeReturnTo`
 429          * @param string|Message $title Page's title
 430          * @param string $msgname
 431          * @param string $injected_html
 432          * @param StatusValue|null $extraMessages
 433          */
 434         protected function showSuccessPage(
 435                 $type, $title, $msgname, $injected_html, $extraMessages
 436         ) {
 437                 $out = $this->getOutput();
 438                 $out->setPageTitle( $title );
 439                 if ( $msgname ) {
 440                         $out->addWikiMsg( $msgname, wfEscapeWikiText( $this->getUser()->getName() ) );
 441                 }
 442                 if ( $extraMessages ) {
 443                         $extraMessages = Status::wrap( $extraMessages );
 444                         $out->addWikiTextAsInterface(
 445                                 $extraMessages->getWikiText( false, false, $this->getLanguage() )
 446                         );
 447                 }
 448
 449                 $out->addHTML( $injected_html );
 450
 451                 $helper = new LoginHelper( $this->getContext() );
 452                 $helper->showReturnToPage( $type, $this->mReturnTo, $this->mReturnToQuery, $this->mStickHTTPS );
 453         }
 454
 455         /**
 456          * Add a "return to" link or redirect to it.
 457          * Extensions can use this to reuse the "return to" logic after
 458          * inject steps (such as redirection) into the login process.
 459          *
 460          * @param string $type One of the following:
 461          *    - error: display a return to link ignoring $wgRedirectOnLogin
 462          *    - signup: display a return to link using $wgRedirectOnLogin if needed
 463          *    - success: display a return to link using $wgRedirectOnLogin if needed
 464          *    - successredirect: send an HTTP redirect using $wgRedirectOnLogin if needed
 465          * @param string $returnTo
 466          * @param array|string $returnToQuery
 467          * @param bool $stickHTTPS Keep redirect link on HTTPS
 468          * @since 1.22
 469          */
 470         public function showReturnToPage(
 471                 $type, $returnTo = '', $returnToQuery = '', $stickHTTPS = false
 472         ) {
 473                 $helper = new LoginHelper( $this->getContext() );
 474                 $helper->showReturnToPage( $type, $returnTo, $returnToQuery, $stickHTTPS );
 475         }
 476
 477         /**
 478          * Replace some globals to make sure the fact that the user has just been logged in is
 479          * reflected in the current request.
 480          */
 481         protected function setSessionUserForCurrentRequest() {
 482                 global $wgUser, $wgLang;
 483
 484                 $context = RequestContext::getMain();
 485                 $localContext = $this->getContext();
 486                 if ( $context !== $localContext ) {
 487                         // remove AuthManagerSpecialPage context hack
 488                         $this->setContext( $context );
 489                 }
 490
 491                 $user = $context->getRequest()->getSession()->getUser();
 492
 493                 $wgUser = $user;
 494                 $context->setUser( $user );
 495
 496                 $wgLang = $context->getLanguage();
 497         }
 498
 499         /**
 500          * @param AuthenticationRequest[] $requests A list of AuthorizationRequest objects,
 501          *   used to generate the form fields. An empty array means a fatal error
 502          *   (authentication cannot continue).
 503          * @param string|Message $msg
 504          * @param string $msgtype
 505          * @throws ErrorPageError
 506          * @throws Exception
 507          * @throws FatalError
 508          * @throws MWException
 509          * @throws PermissionsError
 510          * @throws ReadOnlyError
 511          * @private
 512          */
 513         protected function mainLoginForm( array $requests, $msg = '', $msgtype = 'error' ) {
 514                 $user = $this->getUser();
 515                 $out = $this->getOutput();
 516
 517                 // FIXME how to handle empty $requests - restart, or no form, just an error message?
 518                 // no form would be better for no session type errors, restart is better when can* fails.
 519                 if ( !$requests ) {
 520                         $this->authAction = $this->getDefaultAction( $this->subPage );
 521                         $this->authForm = null;
 522                         $requests = AuthManager::singleton()->getAuthenticationRequests( $this->authAction, $user );
 523                 }
 524
 525                 // Generic styles and scripts for both login and signup form
 526                 $out->addModuleStyles( [
 527                         'mediawiki.ui',
 528                         'mediawiki.ui.button',
 529                         'mediawiki.ui.checkbox',
 530                         'mediawiki.ui.input',
 531                         'mediawiki.special.userlogin.common.styles'
 532                 ] );
 533                 if ( $this->isSignup() ) {
 534                         // XXX hack pending RL or JS parse() support for complex content messages T27349
 535                         $out->addJsConfigVars( 'wgCreateacctImgcaptchaHelp',
 536                                 $this->msg( 'createacct-imgcaptcha-help' )->parse() );
 537
 538                         // Additional styles and scripts for signup form
 539                         $out->addModules( [
 540                                 'mediawiki.special.userlogin.signup.js'
 541                         ] );
 542                         $out->addModuleStyles( [
 543                                 'mediawiki.special.userlogin.signup.styles'
 544                         ] );
 545                 } else {
 546                         // Additional styles for login form
 547                         $out->addModuleStyles( [
 548                                 'mediawiki.special.userlogin.login.styles'
 549                         ] );
 550                 }
 551                 $out->disallowUserJs(); // just in case...
 552
 553                 $form = $this->getAuthForm( $requests, $this->authAction, $msg, $msgtype );
 554                 $form->prepareForm();
 555
 556                 $submitStatus = Status::newGood();
 557                 if ( $msg && $msgtype === 'warning' ) {
 558                         $submitStatus->warning( $msg );
 559                 } elseif ( $msg && $msgtype === 'error' ) {
 560                         $submitStatus->fatal( $msg );
 561                 }
 562
 563                 // warning header for non-standard workflows (e.g. security reauthentication)
 564                 if (
 565                         !$this->isSignup() &&
 566                         $this->getUser()->isLoggedIn() &&
 567                         $this->authAction !== AuthManager::ACTION_LOGIN_CONTINUE
 568                 ) {
 569                         $reauthMessage = $this->securityLevel ? 'userlogin-reauth' : 'userlogin-loggedin';
 570                         $submitStatus->warning( $reauthMessage, $this->getUser()->getName() );
 571                 }
 572
 573                 $formHtml = $form->getHTML( $submitStatus );
 574
 575                 $out->addHTML( $this->getPageHtml( $formHtml ) );
 576         }
 577
 578         /**
 579          * Add page elements which are outside the form.
 580          * FIXME this should probably be a template, but use a sane language (handlebars?)
 581          * @param string $formHtml
 582          * @return string
 583          */
 584         protected function getPageHtml( $formHtml ) {
 585                 global $wgLoginLanguageSelector;
 586
 587                 $loginPrompt = $this->isSignup() ? '' : Html::rawElement( 'div',
 588                         [ 'id' => 'userloginprompt' ], $this->msg( 'loginprompt' )->parseAsBlock() );
 589                 $languageLinks = $wgLoginLanguageSelector ? $this->makeLanguageSelector() : '';
 590                 $signupStartMsg = $this->msg( 'signupstart' );
 591                 $signupStart = ( $this->isSignup() && !$signupStartMsg->isDisabled() )
 592                         ? Html::rawElement( 'div', [ 'id' => 'signupstart' ], $signupStartMsg->parseAsBlock() ) : '';
 593                 if ( $languageLinks ) {
 594                         $languageLinks = Html::rawElement( 'div', [ 'id' => 'languagelinks' ],
 595                                 Html::rawElement( 'p', [], $languageLinks )
 596                         );
 597                 }
 598
 599                 $benefitsContainer = '';
 600                 if ( $this->isSignup() && $this->showExtraInformation() ) {
 601                         // messages used:
 602                         // createacct-benefit-icon1 createacct-benefit-head1 createacct-benefit-body1
 603                         // createacct-benefit-icon2 createacct-benefit-head2 createacct-benefit-body2
 604                         // createacct-benefit-icon3 createacct-benefit-head3 createacct-benefit-body3
 605                         $benefitCount = 3;
 606                         $benefitList = '';
 607                         for ( $benefitIdx = 1; $benefitIdx <= $benefitCount; $benefitIdx++ ) {
 608                                 $headUnescaped = $this->msg( "createacct-benefit-head$benefitIdx" )->text();
 609                                 $iconClass = $this->msg( "createacct-benefit-icon$benefitIdx" )->text();
 610                                 $benefitList .= Html::rawElement( 'div', [ 'class' => "mw-number-text $iconClass" ],
 611                                         Html::rawElement( 'h3', [],
 612                                                 $this->msg( "createacct-benefit-head$benefitIdx" )->escaped()
 613                                         )
 614                                         . Html::rawElement( 'p', [],
 615                                                 $this->msg( "createacct-benefit-body$benefitIdx" )->params( $headUnescaped )->escaped()
 616                                         )
 617                                 );
 618                         }
 619                         $benefitsContainer = Html::rawElement( 'div', [ 'class' => 'mw-createacct-benefits-container' ],
 620                                 Html::rawElement( 'h2', [], $this->msg( 'createacct-benefit-heading' )->escaped() )
 621                                 . Html::rawElement( 'div', [ 'class' => 'mw-createacct-benefits-list' ],
 622                                         $benefitList
 623                                 )
 624                         );
 625                 }
 626
 627                 $html = Html::rawElement( 'div', [ 'class' => 'mw-ui-container' ],
 628                         $loginPrompt
 629                         . $languageLinks
 630                         . $signupStart
 631                         . Html::rawElement( 'div', [ 'id' => 'userloginForm' ],
 632                                 $formHtml
 633                         )
 634                         . $benefitsContainer
 635                 );
 636
 637                 return $html;
 638         }
 639
 640         /**
 641          * Generates a form from the given request.
 642          * @param AuthenticationRequest[] $requests
 643          * @param string $action AuthManager action name
 644          * @param string|Message $msg
 645          * @param string $msgType
 646          * @return HTMLForm
 647          */
 648         protected function getAuthForm( array $requests, $action, $msg = '', $msgType = 'error' ) {
 649                 global $wgSecureLogin;
 650                 // FIXME merge this with parent
 651
 652                 if ( isset( $this->authForm ) ) {
 653                         return $this->authForm;
 654                 }
 655
 656                 $usingHTTPS = $this->getRequest()->getProtocol() === 'https';
 657
 658                 // get basic form description from the auth logic
 659                 $fieldInfo = AuthenticationRequest::mergeFieldInfo( $requests );
 660                 // this will call onAuthChangeFormFields()
 661                 $formDescriptor = static::fieldInfoToFormDescriptor( $requests, $fieldInfo, $this->authAction );
 662                 $this->postProcessFormDescriptor( $formDescriptor, $requests );
 663
 664                 $context = $this->getContext();
 665                 if ( $context->getRequest() !== $this->getRequest() ) {
 666                         // We have overridden the request, need to make sure the form uses that too.
 667                         $context = new DerivativeContext( $this->getContext() );
 668                         $context->setRequest( $this->getRequest() );
 669                 }
 670                 $form = HTMLForm::factory( 'vform', $formDescriptor, $context );
 671
 672                 $form->addHiddenField( 'authAction', $this->authAction );
 673                 if ( $this->mLanguage ) {
 674                         $form->addHiddenField( 'uselang', $this->mLanguage );
 675                 }
 676                 $form->addHiddenField( 'force', $this->securityLevel );
 677                 $form->addHiddenField( $this->getTokenName(), $this->getToken()->toString() );
 678                 if ( $wgSecureLogin ) {
 679                         // If using HTTPS coming from HTTP, then the 'fromhttp' parameter must be preserved
 680                         if ( !$this->isSignup() ) {
 681                                 $form->addHiddenField( 'wpForceHttps', (int)$this->mStickHTTPS );
 682                                 $form->addHiddenField( 'wpFromhttp', $usingHTTPS );
 683                         }
 684                 }
 685
 686                 // set properties of the form itself
 687                 $form->setAction( $this->getPageTitle()->getLocalURL( $this->getReturnToQueryStringFragment() ) );
 688                 $form->setName( 'userlogin' . ( $this->isSignup() ? '2' : '' ) );
 689                 if ( $this->isSignup() ) {
 690                         $form->setId( 'userlogin2' );
 691                 }
 692
 693                 $form->suppressDefaultSubmit();
 694
 695                 $this->authForm = $form;
 696
 697                 return $form;
 698         }
 699
 700         public function onAuthChangeFormFields(
 701                 array $requests, array $fieldInfo, array &$formDescriptor, $action
 702         ) {
 703                 $coreFieldDescriptors = $this->getFieldDefinitions();
 704
 705                 // keep the ordering from getCoreFieldDescriptors() where there is no explicit weight
 706                 foreach ( $coreFieldDescriptors as $fieldName => $coreField ) {
 707                         $requestField = $formDescriptor[$fieldName] ?? [];
 708
 709                         // remove everything that is not in the fieldinfo, is not marked as a supplemental field
 710                         // to something in the fieldinfo, and is not an info field or a submit button
 711                         if (
 712                                 !isset( $fieldInfo[$fieldName] )
 713                                 && (
 714                                         !isset( $coreField['baseField'] )
 715                                         || !isset( $fieldInfo[$coreField['baseField']] )
 716                                 )
 717                                 && (
 718                                         !isset( $coreField['type'] )
 719                                         || !in_array( $coreField['type'], [ 'submit', 'info' ], true )
 720                                 )
 721                         ) {
 722                                 $coreFieldDescriptors[$fieldName] = null;
 723                                 continue;
 724                         }
 725
 726                         // core message labels should always take priority
 727                         if (
 728                                 isset( $coreField['label'] )
 729                                 || isset( $coreField['label-message'] )
 730                                 || isset( $coreField['label-raw'] )
 731                         ) {
 732                                 unset( $requestField['label'], $requestField['label-message'], $coreField['label-raw'] );
 733                         }
 734
 735                         $coreFieldDescriptors[$fieldName] += $requestField;
 736                 }
 737
 738                 $formDescriptor = array_filter( $coreFieldDescriptors + $formDescriptor );
 739                 return true;
 740         }
 741
 742         /**
 743          * Show extra information such as password recovery information, link from login to signup,
 744          * CTA etc? Such information should only be shown on the "landing page", ie. when the user
 745          * is at the first step of the authentication process.
 746          * @return bool
 747          */
 748         protected function showExtraInformation() {
 749                 return $this->authAction !== $this->getContinueAction( $this->authAction )
 750                         && !$this->securityLevel;
 751         }
 752
 753         /**
 754          * Create a HTMLForm descriptor for the core login fields.
 755          * @return array
 756          */
 757         protected function getFieldDefinitions() {
 758                 global $wgEmailConfirmToEdit;
 759
 760                 $isLoggedIn = $this->getUser()->isLoggedIn();
 761                 $continuePart = $this->isContinued() ? 'continue-' : '';
 762                 $anotherPart = $isLoggedIn ? 'another-' : '';
 763                 // @phan-suppress-next-line PhanUndeclaredMethod
 764                 $expiration = $this->getRequest()->getSession()->getProvider()->getRememberUserDuration();
 765                 $expirationDays = ceil( $expiration / ( 3600 * 24 ) );
 766                 $secureLoginLink = '';
 767                 if ( $this->mSecureLoginUrl ) {
 768                         $secureLoginLink = Html::element( 'a', [
 769                                 'href' => $this->mSecureLoginUrl,
 770                                 'class' => 'mw-ui-flush-right mw-secure',
 771                         ], $this->msg( 'userlogin-signwithsecure' )->text() );
 772                 }
 773                 $usernameHelpLink = '';
 774                 if ( !$this->msg( 'createacct-helpusername' )->isDisabled() ) {
 775                         $usernameHelpLink = Html::rawElement( 'span', [
 776                                 'class' => 'mw-ui-flush-right',
 777                         ], $this->msg( 'createacct-helpusername' )->parse() );
 778                 }
 779
 780                 if ( $this->isSignup() ) {
 781                         $fieldDefinitions = [
 782                                 'statusarea' => [
 783                                         // used by the mediawiki.special.userlogin.signup.js module for error display
 784                                         // FIXME merge this with HTMLForm's normal status (error) area
 785                                         'type' => 'info',
 786                                         'raw' => true,
 787                                         'default' => Html::element( 'div', [ 'id' => 'mw-createacct-status-area' ] ),
 788                                         'weight' => -105,
 789                                 ],
 790                                 'username' => [
 791                                         'label-raw' => $this->msg( 'userlogin-yourname' )->escaped() . $usernameHelpLink,
 792                                         'id' => 'wpName2',
 793                                         'placeholder-message' => $isLoggedIn ? 'createacct-another-username-ph'
 794                                                 : 'userlogin-yourname-ph',
 795                                 ],
 796                                 'mailpassword' => [
 797                                         // create account without providing password, a temporary one will be mailed
 798                                         'type' => 'check',
 799                                         'label-message' => 'createaccountmail',
 800                                         'name' => 'wpCreateaccountMail',
 801                                         'id' => 'wpCreateaccountMail',
 802                                 ],
 803                                 'password' => [
 804                                         'id' => 'wpPassword2',
 805                                         'placeholder-message' => 'createacct-yourpassword-ph',
 806                                         'hide-if' => [ '===', 'wpCreateaccountMail', '1' ],
 807                                 ],
 808                                 'domain' => [],
 809                                 'retype' => [
 810                                         'baseField' => 'password',
 811                                         'type' => 'password',
 812                                         'label-message' => 'createacct-yourpasswordagain',
 813                                         'id' => 'wpRetype',
 814                                         'cssclass' => 'loginPassword',
 815                                         'size' => 20,
 816                                         'validation-callback' => function ( $value, $alldata ) {
 817                                                 if ( empty( $alldata['mailpassword'] ) && !empty( $alldata['password'] ) ) {
 818                                                         if ( !$value ) {
 819                                                                 return $this->msg( 'htmlform-required' );
 820                                                         } elseif ( $value !== $alldata['password'] ) {
 821                                                                 return $this->msg( 'badretype' );
 822                                                         }
 823                                                 }
 824                                                 return true;
 825                                         },
 826                                         'hide-if' => [ '===', 'wpCreateaccountMail', '1' ],
 827                                         'placeholder-message' => 'createacct-yourpasswordagain-ph',
 828                                 ],
 829                                 'email' => [
 830                                         'type' => 'email',
 831                                         'label-message' => $wgEmailConfirmToEdit ? 'createacct-emailrequired'
 832                                                 : 'createacct-emailoptional',
 833                                         'id' => 'wpEmail',
 834                                         'cssclass' => 'loginText',
 835                                         'size' => '20',
 836                                         // FIXME will break non-standard providers
 837                                         'required' => $wgEmailConfirmToEdit,
 838                                         'validation-callback' => function ( $value, $alldata ) {
 839                                                 global $wgEmailConfirmToEdit;
 840
 841                                                 // AuthManager will check most of these, but that will make the auth
 842                                                 // session fail and this won't, so nicer to do it this way
 843                                                 if ( !$value && $wgEmailConfirmToEdit ) {
 844                                                         // no point in allowing registration without email when email is
 845                                                         // required to edit
 846                                                         return $this->msg( 'noemailtitle' );
 847                                                 } elseif ( !$value && !empty( $alldata['mailpassword'] ) ) {
 848                                                         // cannot send password via email when there is no email address
 849                                                         return $this->msg( 'noemailcreate' );
 850                                                 } elseif ( $value && !Sanitizer::validateEmail( $value ) ) {
 851                                                         return $this->msg( 'invalidemailaddress' );
 852                                                 }
 853                                                 return true;
 854                                         },
 855                                         'placeholder-message' => 'createacct-' . $anotherPart . 'email-ph',
 856                                 ],
 857                                 'realname' => [
 858                                         'type' => 'text',
 859                                         'help-message' => $isLoggedIn ? 'createacct-another-realname-tip'
 860                                                 : 'prefs-help-realname',
 861                                         'label-message' => 'createacct-realname',
 862                                         'cssclass' => 'loginText',
 863                                         'size' => 20,
 864                                         'id' => 'wpRealName',
 865                                 ],
 866                                 'reason' => [
 867                                         // comment for the user creation log
 868                                         'type' => 'text',
 869                                         'label-message' => 'createacct-reason',
 870                                         'cssclass' => 'loginText',
 871                                         'id' => 'wpReason',
 872                                         'size' => '20',
 873                                         'placeholder-message' => 'createacct-reason-ph',
 874                                 ],
 875                                 'createaccount' => [
 876                                         // submit button
 877                                         'type' => 'submit',
 878                                         'default' => $this->msg( 'createacct-' . $anotherPart . $continuePart .
 879                                                 'submit' )->text(),
 880                                         'name' => 'wpCreateaccount',
 881                                         'id' => 'wpCreateaccount',
 882                                         'weight' => 100,
 883                                 ],
 884                         ];
 885                 } else {
 886                         $fieldDefinitions = [
 887                                 'username' => [
 888                                         'label-raw' => $this->msg( 'userlogin-yourname' )->escaped() . $secureLoginLink,
 889                                         'id' => 'wpName1',
 890                                         'placeholder-message' => 'userlogin-yourname-ph',
 891                                 ],
 892                                 'password' => [
 893                                         'id' => 'wpPassword1',
 894                                         'placeholder-message' => 'userlogin-yourpassword-ph',
 895                                 ],
 896                                 'domain' => [],
 897                                 'rememberMe' => [
 898                                         // option for saving the user token to a cookie
 899                                         'type' => 'check',
 900                                         'name' => 'wpRemember',
 901                                         'label-message' => $this->msg( 'userlogin-remembermypassword' )
 902                                                 ->numParams( $expirationDays ),
 903                                         'id' => 'wpRemember',
 904                                 ],
 905                                 'loginattempt' => [
 906                                         // submit button
 907                                         'type' => 'submit',
 908                                         'default' => $this->msg( 'pt-login-' . $continuePart . 'button' )->text(),
 909                                         'id' => 'wpLoginAttempt',
 910                                         'weight' => 100,
 911                                 ],
 912                                 'linkcontainer' => [
 913                                         // help link
 914                                         'type' => 'info',
 915                                         'cssclass' => 'mw-form-related-link-container mw-userlogin-help',
 916                                         // 'id' => 'mw-userlogin-help', // FIXME HTMLInfoField ignores this
 917                                         'raw' => true,
 918                                         'default' => Html::element( 'a', [
 919                                                 'href' => Skin::makeInternalOrExternalUrl( $this->msg( 'helplogin-url' )
 920                                                         ->inContentLanguage()
 921                                                         ->text() ),
 922                                         ], $this->msg( 'userlogin-helplink2' )->text() ),
 923                                         'weight' => 200,
 924                                 ],
 925                                 // button for ResetPasswordSecondaryAuthenticationProvider
 926                                 'skipReset' => [
 927                                         'weight' => 110,
 928                                         'flags' => [],
 929                                 ],
 930                         ];
 931                 }
 932
 933                 $fieldDefinitions['username'] += [
 934                         'type' => 'text',
 935                         'name' => 'wpName',
 936                         'cssclass' => 'loginText',
 937                         'size' => 20,
 938                         // 'required' => true,
 939                 ];
 940                 $fieldDefinitions['password'] += [
 941                         'type' => 'password',
 942                         // 'label-message' => 'userlogin-yourpassword', // would override the changepassword label
 943                         'name' => 'wpPassword',
 944                         'cssclass' => 'loginPassword',
 945                         'size' => 20,
 946                         // 'required' => true,
 947                 ];
 948
 949                 if ( $this->mEntryError ) {
 950                         $fieldDefinitions['entryError'] = [
 951                                 'type' => 'info',
 952                                 'default' => Html::rawElement( 'div', [ 'class' => $this->mEntryErrorType . 'box', ],
 953                                         $this->mEntryError ),
 954                                 'raw' => true,
 955                                 'rawrow' => true,
 956                                 'weight' => -100,
 957                         ];
 958                 }
 959                 if ( !$this->showExtraInformation() ) {
 960                         unset( $fieldDefinitions['linkcontainer'], $fieldDefinitions['signupend'] );
 961                 }
 962                 if ( $this->isSignup() && $this->showExtraInformation() ) {
 963                         // blank signup footer for site customization
 964                         // uses signupend-https for HTTPS requests if it's not blank, signupend otherwise
 965                         $signupendMsg = $this->msg( 'signupend' );
 966                         $signupendHttpsMsg = $this->msg( 'signupend-https' );
 967                         if ( !$signupendMsg->isDisabled() ) {
 968                                 $usingHTTPS = $this->getRequest()->getProtocol() === 'https';
 969                                 $signupendText = ( $usingHTTPS && !$signupendHttpsMsg->isBlank() )
 970                                         ? $signupendHttpsMsg->parse() : $signupendMsg->parse();
 971                                 $fieldDefinitions['signupend'] = [
 972                                         'type' => 'info',
 973                                         'raw' => true,
 974                                         'default' => Html::rawElement( 'div', [ 'id' => 'signupend' ], $signupendText ),
 975                                         'weight' => 225,
 976                                 ];
 977                         }
 978                 }
 979                 if ( !$this->isSignup() && $this->showExtraInformation() ) {
 980                         $passwordReset = new PasswordReset(
 981                                 $this->getConfig(),
 982                                 AuthManager::singleton(),
 983                                 MediaWikiServices::getInstance()->getPermissionManager()
 984                         );
 985                         if ( $passwordReset->isAllowed( $this->getUser() )->isGood() ) {
 986                                 $fieldDefinitions['passwordReset'] = [
 987                                         'type' => 'info',
 988                                         'raw' => true,
 989                                         'cssclass' => 'mw-form-related-link-container',
 990                                         'default' => $this->getLinkRenderer()->makeLink(
 991                                                 SpecialPage::getTitleFor( 'PasswordReset' ),
 992                                                 $this->msg( 'userlogin-resetpassword-link' )->text()
 993                                         ),
 994                                         'weight' => 230,
 995                                 ];
 996                         }
 997
 998                         // Don't show a "create account" link if the user can't.
 999                         if ( $this->showCreateAccountLink() ) {
1000                                 // link to the other action
1001                                 $linkTitle = $this->getTitleFor( $this->isSignup() ? 'Userlogin' : 'CreateAccount' );
1002                                 $linkq = $this->getReturnToQueryStringFragment();
1003                                 // Pass any language selection on to the mode switch link
1004                                 if ( $this->mLanguage ) {
1005                                         $linkq .= '&uselang=' . urlencode( $this->mLanguage );
1006                                 }
1007                                 $loggedIn = $this->getUser()->isLoggedIn();
1008
1009                                 $fieldDefinitions['createOrLogin'] = [
1010                                         'type' => 'info',
1011                                         'raw' => true,
1012                                         'linkQuery' => $linkq,
1013                                         'default' => function ( $params ) use ( $loggedIn, $linkTitle ) {
1014                                                 return Html::rawElement( 'div',
1015                                                         [ 'id' => 'mw-createaccount' . ( !$loggedIn ? '-cta' : '' ),
1016                                                                 'class' => ( $loggedIn ? 'mw-form-related-link-container' : 'mw-ui-vform-field' ) ],
1017                                                         ( $loggedIn ? '' : $this->msg( 'userlogin-noaccount' )->escaped() )
1018                                                         . Html::element( 'a',
1019                                                                 [
1020                                                                         'id' => 'mw-createaccount-join' . ( $loggedIn ? '-loggedin' : '' ),
1021                                                                         'href' => $linkTitle->getLocalURL( $params['linkQuery'] ),
1022                                                                         'class' => ( $loggedIn ? '' : 'mw-ui-button' ),
1023                                                                         'tabindex' => 100,
1024                                                                 ],
1025                                                                 $this->msg(
1026                                                                         $loggedIn ? 'userlogin-createanother' : 'userlogin-joinproject'
1027                                                                 )->text()
1028                                                         )
1029                                                 );
1030                                         },
1031                                         'weight' => 235,
1032                                 ];
1033                         }
1034                 }
1035
1036                 return $fieldDefinitions;
1037         }
1038
1039         /**
1040          * Check if a session cookie is present.
1041          *
1042          * This will not pick up a cookie set during _this_ request, but is meant
1043          * to ensure that the client is returning the cookie which was set on a
1044          * previous pass through the system.
1045          *
1046          * @return bool
1047          */
1048         protected function hasSessionCookie() {
1049                 global $wgDisableCookieCheck, $wgInitialSessionId;
1050
1051                 return $wgDisableCookieCheck || (
1052                         $wgInitialSessionId &&
1053                         $this->getRequest()->getSession()->getId() === (string)$wgInitialSessionId
1054                 );
1055         }
1056
1057         /**
1058          * Returns a string that can be appended to the URL (without encoding) to preserve the
1059          * return target. Does not include leading '?'/'&'.
1060          * @return string
1061          */
1062         protected function getReturnToQueryStringFragment() {
1063                 $returnto = '';
1064                 if ( $this->mReturnTo !== '' ) {
1065                         $returnto = 'returnto=' . wfUrlencode( $this->mReturnTo );
1066                         if ( $this->mReturnToQuery !== '' ) {
1067                                 $returnto .= '&returntoquery=' . wfUrlencode( $this->mReturnToQuery );
1068                         }
1069                 }
1070                 return $returnto;
1071         }
1072
1073         /**
1074          * Whether the login/create account form should display a link to the
1075          * other form (in addition to whatever the skin provides).
1076          * @return bool
1077          */
1078         private function showCreateAccountLink() {
1079                 if ( $this->isSignup() ) {
1080                         return true;
1081                 } elseif ( MediaWikiServices::getInstance()
1082                                         ->getPermissionManager()
1083                                         ->userHasRight( $this->getUser(), 'createaccount' )
1084                 ) {
1085                         return true;
1086                 } else {
1087                         return false;
1088                 }
1089         }
1090
1091         protected function getTokenName() {
1092                 return $this->isSignup() ? 'wpCreateaccountToken' : 'wpLoginToken';
1093         }
1094
1095         /**
1096          * Produce a bar of links which allow the user to select another language
1097          * during login/registration but retain "returnto"
1098          *
1099          * @return string
1100          */
1101         protected function makeLanguageSelector() {
1102                 $msg = $this->msg( 'loginlanguagelinks' )->inContentLanguage();
1103                 if ( $msg->isBlank() ) {
1104                         return '';
1105                 }
1106                 $langs = explode( "\n", $msg->text() );
1107                 $links = [];
1108                 foreach ( $langs as $lang ) {
1109                         $lang = trim( $lang, '* ' );
1110                         $parts = explode( '|', $lang );
1111                         if ( count( $parts ) >= 2 ) {
1112                                 $links[] = $this->makeLanguageSelectorLink( $parts[0], trim( $parts[1] ) );
1113                         }
1114                 }
1115
1116                 return count( $links ) > 0 ? $this->msg( 'loginlanguagelabel' )->rawParams(
1117                         $this->getLanguage()->pipeList( $links ) )->escaped() : '';
1118         }
1119
1120         /**
1121          * Create a language selector link for a particular language
1122          * Links back to this page preserving type and returnto
1123          *
1124          * @param string $text Link text
1125          * @param string $lang Language code
1126          * @return string
1127          */
1128         protected function makeLanguageSelectorLink( $text, $lang ) {
1129                 if ( $this->getLanguage()->getCode() == $lang ) {
1130                         // no link for currently used language
1131                         return htmlspecialchars( $text );
1132                 }
1133                 $query = [ 'uselang' => $lang ];
1134                 if ( $this->mReturnTo !== '' ) {
1135                         $query['returnto'] = $this->mReturnTo;
1136                         $query['returntoquery'] = $this->mReturnToQuery;
1137                 }
1138
1139                 $attr = [];
1140                 $targetLanguage = Language::factory( $lang );
1141                 $attr['lang'] = $attr['hreflang'] = $targetLanguage->getHtmlCode();
1142
1143                 return $this->getLinkRenderer()->makeKnownLink(
1144                         $this->getPageTitle(),
1145                         $text,
1146                         $attr,
1147                         $query
1148                 );
1149         }
1150
1151         protected function getGroupName() {
1152                 return 'login';
1153         }
1154
1155         /**
1156          * @param array &$formDescriptor
1157          * @param array $requests
1158          */
1159         protected function postProcessFormDescriptor( &$formDescriptor, $requests ) {
1160                 // Pre-fill username (if not creating an account, T46775).
1161                 if (
1162                         isset( $formDescriptor['username'] ) &&
1163                         !isset( $formDescriptor['username']['default'] ) &&
1164                         !$this->isSignup()
1165                 ) {
1166                         $user = $this->getUser();
1167                         if ( $user->isLoggedIn() ) {
1168                                 $formDescriptor['username']['default'] = $user->getName();
1169                         } else {
1170                                 $formDescriptor['username']['default'] =
1171                                         $this->getRequest()->getSession()->suggestLoginUsername();
1172                         }
1173                 }
1174
1175                 // don't show a submit button if there is nothing to submit (i.e. the only form content
1176                 // is other submit buttons, for redirect flows)
1177                 if ( !$this->needsSubmitButton( $requests ) ) {
1178                         unset( $formDescriptor['createaccount'], $formDescriptor['loginattempt'] );
1179                 }
1180
1181                 if ( !$this->isSignup() ) {
1182                         // FIXME HACK don't focus on non-empty field
1183                         // maybe there should be an autofocus-if similar to hide-if?
1184                         if (
1185                                 isset( $formDescriptor['username'] )
1186                                 && empty( $formDescriptor['username']['default'] )
1187                                 && !$this->getRequest()->getCheck( 'wpName' )
1188                         ) {
1189                                 $formDescriptor['username']['autofocus'] = true;
1190                         } elseif ( isset( $formDescriptor['password'] ) ) {
1191                                 $formDescriptor['password']['autofocus'] = true;
1192                         }
1193                 }
1194
1195                 $this->addTabIndex( $formDescriptor );
1196         }
1197 }