RequestContext.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Context;
 
use BadMethodCallException;
use InvalidArgumentException;
use LogicException;
use MediaWiki\Config\Config;
use MediaWiki\HookContainer\HookRunner;
use MediaWiki\Language\Language;
use MediaWiki\Logger\LoggerFactory;
use MediaWiki\MainConfigNames;
use MediaWiki\MediaWikiServices;
use MediaWiki\Message\Message;
use MediaWiki\Output\OutputPage;
use MediaWiki\Page\WikiPage;
use MediaWiki\Permissions\Authority;
use MediaWiki\Request\FauxRequest;
use MediaWiki\Request\WebRequest;
use MediaWiki\Session\CsrfTokenSet;
use MediaWiki\Skin\Skin;
use MediaWiki\Title\Title;
use MediaWiki\User\User;
use MediaWiki\User\UserRigorOptions;
use RuntimeException;
use Wikimedia\Assert\Assert;
use Wikimedia\Bcp47Code\Bcp47Code;
use Wikimedia\IPUtils;
use Wikimedia\Message\MessageParam;
use Wikimedia\Message\MessageSpecifier;
use Wikimedia\NonSerializable\NonSerializableTrait;
use Wikimedia\ScopedCallback;
use Wikimedia\Timing\Timing;
 
class RequestContext implements IContextSource, MutableContext {
    use NonSerializableTrait;
 
    private $request;
 
    private $title;
 
    private $wikipage;
 
    private $action;
 
    private $output;
 
    private $user;
 
    private $authority;
 
    private $lang;
 
    private $skin;
 
    private $timing;
 
    private $config;
 
    private static ?self $instance = null;
 
    private $languageRecursion = false;
 
    private ?bool $langSetWhenUserWasSafeToLoad = null;
 
    private $skinFromHook;
 
    private $skinHookCalled = false;
 
    private $skinName;
 
    public function setConfig( Config $config ) {
        $this->config = $config;
    }
 
    public function getConfig() {
        // @todo In the future, we could move this to WebStart.php so
        // the Config object is ready for when initialization happens
        $this->config ??= MediaWikiServices::getInstance()->getMainConfig();
 
        return $this->config;
    }
 
    public function setRequest( WebRequest $request ) {
        $this->request = $request;
    }
 
    public function getRequest() {
        if ( $this->request === null ) {
            // create the WebRequest object on the fly
            if ( MW_ENTRY_POINT === 'cli' ) {
                // Don't use real WebRequest in CLI mode, it throws errors when trying to access
                // things that don't exist, e.g. "Unable to determine IP".
                $this->request = new FauxRequest( [] );
            } else {
                $this->request = new WebRequest();
            }
        }
 
        return $this->request;
    }
 
    public function getTiming() {
        $this->timing ??= new Timing( [
            'logger' => LoggerFactory::getInstance( 'Timing' )
        ] );
        return $this->timing;
    }
 
    public function setTitle( ?Title $title = null ) {
        $this->title = $title;
        // Clear cache of derived getters
        $this->wikipage = null;
        $this->clearActionName();
    }
 
    public function getTitle() {
        if ( $this->title === null ) {
            // phpcs:ignore MediaWiki.Usage.DeprecatedGlobalVariables.Deprecated$wgTitle
            global $wgTitle; # fallback to $wg till we can improve this
            $this->title = $wgTitle;
            $logger = LoggerFactory::getInstance( 'GlobalTitleFail' );
            $logger->info(
                __METHOD__ . ' called with no title set.',
                [ 'exception' => new RuntimeException ]
            );
        }
 
        return $this->title;
    }
 
    public function hasTitle() {
        return $this->title !== null;
    }
 
    public function canUseWikiPage() {
        if ( $this->wikipage ) {
            // If there's a WikiPage object set, we can for sure get it
            return true;
        }
        // Only pages with legitimate titles can have WikiPages.
        // That usually means pages in non-virtual namespaces.
        $title = $this->getTitle();
        return $title && $title->canExist();
    }
 
    public function setWikiPage( WikiPage $wikiPage ) {
        $pageTitle = $wikiPage->getTitle();
        if ( !$this->hasTitle() || !$pageTitle->equals( $this->getTitle() ) ) {
            $this->setTitle( $pageTitle );
        }
        // Defer this to the end since setTitle sets it to null.
        $this->wikipage = $wikiPage;
        // Clear cache of derived getter
        $this->clearActionName();
    }
 
    public function getWikiPage() {
        if ( $this->wikipage === null ) {
            $title = $this->getTitle();
            if ( $title === null ) {
                throw new BadMethodCallException( __METHOD__ . ' called without Title object set' );
            }
            $this->wikipage = MediaWikiServices::getInstance()->getWikiPageFactory()->newFromTitle( $title );
        }
 
        return $this->wikipage;
    }
 
    public function setActionName( string $action ): void {
        $this->action = $action;
    }
 
    public function getActionName(): string {
        // Optimisation: This is cached to avoid repeated running of the
        // expensive operations to compute this. The computation involves creation
        // of Article, WikiPage, and ContentHandler objects (and the various
        // database queries these classes require to be instantiated), as well
        // as potentially slow extension hooks in these classes.
        //
        // This value is frequently needed in OutputPage and in various
        // Skin-related methods and classes.
        $this->action ??= MediaWikiServices::getInstance()
            ->getActionFactory()
            ->getActionName( $this );
 
        return $this->action;
    }
 
    private function clearActionName(): void {
        if ( $this->action !== null ) {
            // If we're clearing after something else has actually already computed the action,
            // emit a warning.
            //
            // Doing so is unstable, given the first caller got something that turns out to be
            // incomplete or incorrect. Even if we end up re-creating an instance of the same
            // class, we may now be acting on a different title/skin/user etc.
            //
            // Re-computing the action is expensive and can be a performance problem (T302623).
            trigger_error( 'Unexpected clearActionName after getActionName already called' );
            $this->action = null;
        }
    }
 
    public function setOutput( OutputPage $output ) {
        $this->output = $output;
    }
 
    public function getOutput() {
        $this->output ??= new OutputPage( $this );
 
        return $this->output;
    }
 
    public function setUser( User $user ) {
        $this->user = $user;
        // Keep authority consistent
        $this->authority = $user;
        // Invalidate cached user interface language and skin
        $this->lang = null;
        $this->skin = null;
        $this->skinName = null;
    }
 
    public function getUser() {
        if ( $this->user === null ) {
            if ( $this->authority !== null ) {
                // Keep user consistent by using a possible set authority
                $this->user = MediaWikiServices::getInstance()
                    ->getUserFactory()
                    ->newFromAuthority( $this->authority );
            } else {
                $this->user = User::newFromSession( $this->getRequest() );
            }
        }
 
        return $this->user;
    }
 
    public function hasUser(): bool {
        if ( !defined( 'MW_PHPUNIT_TEST' ) ) {
            throw new LogicException( __METHOD__ . '() should be called only from tests!' );
        }
        return $this->user !== null;
    }
 
    public function setAuthority( Authority $authority ) {
        $this->authority = $authority;
        // If needed, a User object is constructed from this authority
        $this->user = null;
        // Invalidate cached user interface language and skin
        $this->lang = null;
        $this->skin = null;
        $this->skinName = null;
    }
 
    public function getAuthority(): Authority {
        return $this->authority ?: $this->getUser();
    }
 
    public static function sanitizeLangCode( $code ) {
        global $wgLanguageCode;
 
        if ( !$code ) {
            return $wgLanguageCode;
        }
 
        // BCP 47 - letter case MUST NOT carry meaning
        $code = strtolower( $code );
 
        # Validate $code
        if ( !MediaWikiServices::getInstance()->getLanguageNameUtils()
                ->isValidCode( $code )
            || $code === 'qqq'
        ) {
            $code = $wgLanguageCode;
        }
 
        return $code;
    }
 
    public function setLanguage( $language ) {
        Assert::parameterType( [ Language::class, 'string' ], $language, '$language' );
        if ( $language instanceof Language ) {
            $this->lang = $language;
        } else {
            $language = self::sanitizeLangCode( $language );
            $obj = MediaWikiServices::getInstance()->getLanguageFactory()->getLanguage( $language );
            $this->lang = $obj;
        }
        $this->langSetWhenUserWasSafeToLoad = null;
        OutputPage::resetOOUI();
    }
 
    public function getLanguage() {
        if ( $this->languageRecursion === true ) {
            throw new LogicException( 'Recursion detected' );
        }
 
        $this->languageRecursion = true;
 
        try {
            // Generate the lang value if not generated, or if the current value was generated
            // when User::isSafeToLoad returned false and ::isSafeToLoad now returns true.
            if (
                $this->lang === null ||
                ( $this->langSetWhenUserWasSafeToLoad === false && $this->getUser()->isSafeToLoad() )
            ) {
                $user = $this->getUser();
                $request = $this->getRequest();
                $services = MediaWikiServices::getInstance();
 
                // Optimisation: Avoid slow getVal(), this isn't user-generated content.
                $code = $request->getRawVal( 'uselang' ) ?? 'user';
                if ( $code === 'user' ) {
                    // If the RequestContext user is not safe to load,
                    // then default to the site language as we cannot get user options
                    if ( $user->isSafeToLoad() ) {
                        $userOptionsLookup = $services->getUserOptionsLookup();
                        $code = $userOptionsLookup->getOption( $user, 'language' );
                    } else {
                        $code = $this->getConfig()->get( MainConfigNames::LanguageCode );
                    }
                }
 
                // There are certain characters we don't allow in language code strings,
                // but by and large almost any valid UTF-8 string will makes it past
                // this check and the LanguageNameUtils::isValidCode method it uses.
                // This is to support on-wiki interface message overrides for
                // non-existent language codes. Also known as "Uselang hacks".
                // See <https://www.mediawiki.org/wiki/Manual:Uselang_hack>
                // For something like "en-whatever" or "de-whatever" it will end up
                // with a mostly "en" or "de" interface, but with an extra layer of
                // possible MessageCache overrides from `MediaWiki:*/<code>` titles.
                // While non-ASCII works here, it is required that they are in
                // NFC form given this will not convert to normalised form.
                $code = self::sanitizeLangCode( $code );
 
                ( new HookRunner( $services->getHookContainer() ) )->onUserGetLanguageObject( $user, $code, $this );
 
                $this->langSetWhenUserWasSafeToLoad = $user->isSafeToLoad();
                if ( $code === $this->getConfig()->get( MainConfigNames::LanguageCode ) ) {
                    $this->lang = $services->getContentLanguage();
                } else {
                    $obj = $services->getLanguageFactory()
                        ->getLanguage( $code );
                    $this->lang = $obj;
                }
            }
        } finally {
            $this->languageRecursion = false;
        }
 
        return $this->lang;
    }
 
    public function getLanguageCode() {
        return $this->getLanguage();
    }
 
    public function setSkin( Skin $skin ) {
        $this->skin = clone $skin;
        $this->skin->setContext( $this );
        $this->skinName = $skin->getSkinName();
        OutputPage::resetOOUI();
    }
 
    public function getSkinName() {
        if ( $this->skinName === null ) {
            $this->skinName = $this->fetchSkinName();
        }
        return $this->skinName;
    }
 
    private function fetchSkinName() {
        $skinFromHook = $this->getSkinFromHook();
        if ( $skinFromHook instanceof Skin ) {
            // The hook provided a skin object
            return $skinFromHook->getSkinName();
        } elseif ( is_string( $skinFromHook ) ) {
            // The hook provided a skin name
            $skinName = $skinFromHook;
        } elseif ( !in_array( 'skin', $this->getConfig()->get( MainConfigNames::HiddenPrefs ) ) ) {
            // The normal case
            $userOptionsLookup = MediaWikiServices::getInstance()->getUserOptionsLookup();
            $userSkin = $userOptionsLookup->getOption( $this->getUser(), 'skin' );
            // Optimisation: Avoid slow getVal(), this isn't user-generated content.
            $skinName = $this->getRequest()->getRawVal( 'useskin' ) ?? $userSkin;
        } else {
            // User preference disabled
            $skinName = $this->getConfig()->get( MainConfigNames::DefaultSkin );
        }
        return Skin::normalizeKey( $skinName );
    }
 
    private function getSkinFromHook() {
        if ( !$this->skinHookCalled ) {
            $this->skinHookCalled = true;
            ( new HookRunner( MediaWikiServices::getInstance()->getHookContainer() ) )
                ->onRequestContextCreateSkin( $this, $this->skinFromHook );
        }
        return $this->skinFromHook;
    }
 
    public function getSkin() {
        if ( $this->skin === null ) {
            $skinFromHook = $this->getSkinFromHook();
            if ( $skinFromHook instanceof Skin ) {
                $this->skin = $skinFromHook;
            } else {
                $skinName = is_string( $skinFromHook )
                    ? Skin::normalizeKey( $skinFromHook )
                    : $this->getSkinName();
                $factory = MediaWikiServices::getInstance()->getSkinFactory();
                $this->skin = $factory->makeSkin( $skinName );
            }
            $this->skin->setContext( $this );
        }
        return $this->skin;
    }
 
    public function msg( $key, ...$params ) {
        return wfMessage( $key, ...$params )->setContext( $this );
    }
 
    public static function getMain(): self {
        self::$instance ??= new self;
        return self::$instance;
    }
 
    public static function getMainAndWarn( $func = __METHOD__ ) {
        wfDebug( $func . ' called without context. ' .
            "Using RequestContext::getMain()" );
 
        return self::getMain();
    }
 
    public static function resetMain() {
        if ( !defined( 'MW_PHPUNIT_TEST' ) ) {
            throw new LogicException( __METHOD__ . '() should be called only from unit tests!' );
        }
        self::$instance = null;
    }
 
    public function exportSession() {
        $session = $this->getRequest()->getSession();
        return [
            'ip' => $this->getRequest()->getIP(),
            'headers' => $this->getRequest()->getAllHeaders(),
            'sessionId' => $session->isPersistent() ? $session->getId() : '',
            'userId' => $this->getUser()->getId()
        ];
    }
 
    public function getCsrfTokenSet(): CsrfTokenSet {
        return new CsrfTokenSet( $this->getRequest() );
    }
 
    #[\NoDiscard]
    public static function importScopedSession( array $params ): ScopedCallback {
        if ( $params['sessionId'] !== '' &&
            self::getMain()->getRequest()->getSession()->isPersistent()
        ) {
            // Check to avoid sending random cookies for the wrong users.
            // This method should only be called by CLI scripts or by HTTP job runners.
            throw new BadMethodCallException( "Sessions can only be imported when none is active." );
        } elseif ( !IPUtils::isValid( $params['ip'] ) ) {
            throw new InvalidArgumentException( "Invalid client IP address '{$params['ip']}'." );
        }
 
        $services = MediaWikiServices::getInstance();
        $userFactory = $services->getUserFactory();
 
        if ( $params['userId'] ) { // logged-in user
            $user = $userFactory->newFromId( (int)$params['userId'] );
            $user->load();
            if ( !$user->isRegistered() ) {
                throw new InvalidArgumentException( "No user with ID '{$params['userId']}'." );
            }
        } else { // anon user
            $user = $userFactory->newFromName( $params['ip'], UserRigorOptions::RIGOR_NONE );
        }
 
        $importSessionFunc = static function ( User $user, array $params ) use ( $services ) {
            global $wgRequest;
 
            $context = self::getMain();
 
            // Get new session, if applicable
            $session = null;
            if ( $params['sessionId'] !== '' ) { // don't make a new random ID
                $manager = $services->getSessionManager();
                $session = $manager->getSessionById( $params['sessionId'], true )
                    ?: $manager->getEmptySession();
            }
 
            // Remove any user IP or agent information, and attach the request
            // with the new session.
            $context->setRequest( new FauxRequest( [], false, $session ) );
            $wgRequest = $context->getRequest(); // b/c
 
            // Now that all private information is detached from the user, it should
            // be safe to load the new user. If errors occur or an exception is thrown
            // and caught (leaving the main context in a mixed state), there is no risk
            // of the User object being attached to the wrong IP, headers, or session.
            $context->setUser( $user );
            $request = new FauxRequest( [], false, $session );
            $request->setIP( $params['ip'] );
            foreach ( $params['headers'] as $name => $value ) {
                $request->setHeader( $name, $value );
            }
            // Set the current context to use the new WebRequest
            $context->setRequest( $request );
            $wgRequest = $context->getRequest(); // b/c
        };
 
        // Stash the old session and load in the new one
        $oUser = self::getMain()->getUser();
        $oParams = self::getMain()->exportSession();
        $oRequest = self::getMain()->getRequest();
        // @phan-suppress-next-line PhanTypeMismatchArgumentNullable exceptions triggered above prevent the null case
        $importSessionFunc( $user, $params );
 
        // Set callback to save and close the new session and reload the old one
        return new ScopedCallback(
            static function () use ( $importSessionFunc, $oUser, $oParams, $oRequest ) {
                global $wgRequest;
                $importSessionFunc( $oUser, $oParams );
                // Restore the exact previous Request object (instead of leaving MediaWiki\Request\FauxRequest)
                self::getMain()->setRequest( $oRequest );
                $wgRequest = self::getMain()->getRequest(); // b/c
            }
        );
    }
 
    public static function newExtraneousContext( Title $title, $request = [] ) {
        $context = new self;
        $context->setTitle( $title );
        if ( $request instanceof WebRequest ) {
            $context->setRequest( $request );
        } else {
            $context->setRequest( new FauxRequest( $request ) );
        }
        $context->user = MediaWikiServices::getInstance()->getUserFactory()->newFromName(
            '127.0.0.1',
            UserRigorOptions::RIGOR_NONE
        );
 
        return $context;
    }
 
    public function __clone() {
        throw new LogicException(
            __CLASS__ . ' should not be cloned, use DerivativeContext instead.'
        );
    }
 
}
 
class_alias( RequestContext::class, 'RequestContext' );