RequestContext.php

Go to the documentation of this file.

<?php
use MediaWiki\Logger\LoggerFactory;
use MediaWiki\MediaWikiServices;
use Wikimedia\ScopedCallback;
 
class RequestContext implements IContextSource, MutableContext {
    private $request;
 
    private $title;
 
    private $wikipage;
 
    private $output;
 
    private $user;
 
    private $lang;
 
    private $skin;
 
    private $timing;
 
    private $config;
 
    private static $instance = null;
 
    public function setConfig( Config $config ) {
        $this->config = $config;
    }
 
    public function getConfig() {
        if ( $this->config === null ) {
            // @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 ) {
            global $wgCommandLineMode;
            // create the WebRequest object on the fly
            if ( $wgCommandLineMode ) {
                $this->request = new FauxRequest( [] );
            } else {
                $this->request = new WebRequest();
            }
        }
 
        return $this->request;
    }
 
    public function getStats() {
        return MediaWikiServices::getInstance()->getStatsdDataFactory();
    }
 
    public function getTiming() {
        if ( $this->timing === null ) {
            $this->timing = new Timing( [
                'logger' => LoggerFactory::getInstance( 'Timing' )
            ] );
        }
        return $this->timing;
    }
 
    public function setTitle( Title $title = null ) {
        $this->title = $title;
        // Erase the WikiPage so a new one with the new title gets created.
        $this->wikipage = null;
    }
 
    public function getTitle() {
        if ( $this->title === null ) {
            global $wgTitle; # fallback to $wg till we can improve this
            $this->title = $wgTitle;
            wfDebugLog(
                'GlobalTitleFail',
                __METHOD__ . ' called by ' . wfGetAllCallers( 5 ) . ' with no title set.'
            );
        }
 
        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() : false;
    }
 
    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;
    }
 
    public function getWikiPage() {
        if ( $this->wikipage === null ) {
            $title = $this->getTitle();
            if ( $title === null ) {
                throw new MWException( __METHOD__ . ' called without Title object set' );
            }
            $this->wikipage = WikiPage::factory( $title );
        }
 
        return $this->wikipage;
    }
 
    public function setOutput( OutputPage $output ) {
        $this->output = $output;
    }
 
    public function getOutput() {
        if ( $this->output === null ) {
            $this->output = new OutputPage( $this );
        }
 
        return $this->output;
    }
 
    public function setUser( User $user ) {
        $this->user = $user;
        // Invalidate cached user interface language
        $this->lang = null;
    }
 
    public function getUser() {
        if ( $this->user === null ) {
            $this->user = User::newFromSession( $this->getRequest() );
        }
 
        return $this->user;
    }
 
    public static function sanitizeLangCode( $code ) {
        global $wgLanguageCode;
 
        // BCP 47 - letter case MUST NOT carry meaning
        $code = strtolower( $code );
 
        # Validate $code
        if ( !$code || !Language::isValidCode( $code ) || $code === 'qqq' ) {
            $code = $wgLanguageCode;
        }
 
        return $code;
    }
 
    public function setLanguage( $language ) {
        if ( $language instanceof Language ) {
            $this->lang = $language;
        } elseif ( is_string( $language ) ) {
            $language = self::sanitizeLangCode( $language );
            $obj = Language::factory( $language );
            $this->lang = $obj;
        } else {
            throw new MWException( __METHOD__ . " was passed an invalid type of data." );
        }
    }
 
    public function getLanguage() {
        if ( isset( $this->recursion ) ) {
            trigger_error( "Recursion detected in " . __METHOD__, E_USER_WARNING );
            $e = new Exception;
            wfDebugLog( 'recursion-guard', "Recursion detected:\n" . $e->getTraceAsString() );
 
            $code = $this->getConfig()->get( 'LanguageCode' ) ?: 'en';
            $this->lang = Language::factory( $code );
        } elseif ( $this->lang === null ) {
            $this->recursion = true;
 
            try {
                $request = $this->getRequest();
                $user = $this->getUser();
 
                $code = $request->getVal( 'uselang', 'user' );
                if ( $code === 'user' ) {
                    $code = $user->getOption( 'language' );
                }
                $code = self::sanitizeLangCode( $code );
 
                Hooks::run( 'UserGetLanguageObject', [ $user, &$code, $this ] );
 
                if ( $code === $this->getConfig()->get( 'LanguageCode' ) ) {
                    $this->lang = MediaWikiServices::getInstance()->getContentLanguage();
                } else {
                    $obj = Language::factory( $code );
                    $this->lang = $obj;
                }
            } finally {
                unset( $this->recursion );
            }
        }
 
        return $this->lang;
    }
 
    public function setSkin( Skin $skin ) {
        $this->skin = clone $skin;
        $this->skin->setContext( $this );
    }
 
    public function getSkin() {
        if ( $this->skin === null ) {
            $skin = null;
            Hooks::run( 'RequestContextCreateSkin', [ $this, &$skin ] );
            $factory = SkinFactory::getDefaultInstance();
 
            // If the hook worked try to set a skin from it
            if ( $skin instanceof Skin ) {
                $this->skin = $skin;
            } elseif ( is_string( $skin ) ) {
                // Normalize the key, just in case the hook did something weird.
                $normalized = Skin::normalizeKey( $skin );
                $this->skin = $factory->makeSkin( $normalized );
            }
 
            // If this is still null (the hook didn't run or didn't work)
            // then go through the normal processing to load a skin
            if ( $this->skin === null ) {
                if ( !in_array( 'skin', $this->getConfig()->get( 'HiddenPrefs' ) ) ) {
                    # get the user skin
                    $userSkin = $this->getUser()->getOption( 'skin' );
                    $userSkin = $this->getRequest()->getVal( 'useskin', $userSkin );
                } else {
                    # if we're not allowing users to override, then use the default
                    $userSkin = $this->getConfig()->get( 'DefaultSkin' );
                }
 
                // Normalize the key in case the user is passing gibberish
                // or has old preferences (T71566).
                $normalized = Skin::normalizeKey( $userSkin );
 
                // Skin::normalizeKey will also validate it, so
                // this won't throw an exception
                $this->skin = $factory->makeSkin( $normalized );
            }
 
            // After all that set a context on whatever skin got created
            $this->skin->setContext( $this );
        }
 
        return $this->skin;
    }
 
    public function msg( $key ) {
        $args = func_get_args();
 
        return wfMessage( ...$args )->setContext( $this );
    }
 
    public static function getMain() {
        if ( self::$instance === null ) {
            self::$instance = new self;
        }
 
        return self::$instance;
    }
 
    public static function getMainAndWarn( $func = __METHOD__ ) {
        wfDebug( $func . ' called without context. ' .
            "Using RequestContext::getMain() for sanity\n" );
 
        return self::getMain();
    }
 
    public static function resetMain() {
        if ( !( defined( 'MW_PHPUNIT_TEST' ) || defined( 'MW_PARSER_TEST' ) ) ) {
            throw new MWException( __METHOD__ . '() should be called only from unit tests!' );
        }
        self::$instance = null;
    }
 
    public function exportSession() {
        $session = MediaWiki\Session\SessionManager::getGlobalSession();
        return [
            'ip' => $this->getRequest()->getIP(),
            'headers' => $this->getRequest()->getAllHeaders(),
            'sessionId' => $session->isPersistent() ? $session->getId() : '',
            'userId' => $this->getUser()->getId()
        ];
    }
 
    public static function importScopedSession( array $params ) {
        if ( strlen( $params['sessionId'] ) &&
            MediaWiki\Session\SessionManager::getGlobalSession()->isPersistent()
        ) {
            // Sanity check to avoid sending random cookies for the wrong users.
            // This method should only called by CLI scripts or by HTTP job runners.
            throw new MWException( "Sessions can only be imported when none is active." );
        } elseif ( !IP::isValid( $params['ip'] ) ) {
            throw new MWException( "Invalid client IP address '{$params['ip']}'." );
        }
 
        if ( $params['userId'] ) { // logged-in user
            $user = User::newFromId( $params['userId'] );
            $user->load();
            if ( !$user->getId() ) {
                throw new MWException( "No user with ID '{$params['userId']}'." );
            }
        } else { // anon user
            $user = User::newFromName( $params['ip'], false );
        }
 
        $importSessionFunc = function ( User $user, array $params ) {
            global $wgRequest, $wgUser;
 
            $context = RequestContext::getMain();
 
            // Commit and close any current session
            if ( MediaWiki\Session\PHPSessionHandler::isEnabled() ) {
                session_write_close(); // persist
                session_id( '' ); // detach
                $_SESSION = []; // clear in-memory array
            }
 
            // Get new session, if applicable
            $session = null;
            if ( strlen( $params['sessionId'] ) ) { // don't make a new random ID
                $manager = MediaWiki\Session\SessionManager::singleton();
                $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 );
            $wgUser = $context->getUser(); // b/c
            if ( $session && MediaWiki\Session\PHPSessionHandler::isEnabled() ) {
                session_id( $session->getId() );
                Wikimedia\quietCall( 'session_start' );
            }
            $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();
        $importSessionFunc( $user, $params );
 
        // Set callback to save and close the new session and reload the old one
        return new ScopedCallback(
            function () use ( $importSessionFunc, $oUser, $oParams, $oRequest ) {
                global $wgRequest;
                $importSessionFunc( $oUser, $oParams );
                // Restore the exact previous Request object (instead of leaving FauxRequest)
                RequestContext::getMain()->setRequest( $oRequest );
                $wgRequest = RequestContext::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 = User::newFromName( '127.0.0.1', false );
 
        return $context;
    }
}