RequestContext.php

Go to the documentation of this file.

<?php
class RequestContext implements IContextSource {
    private $request;

    private $title;

    private $wikipage;

    private $output;

    private $user;

    private $lang;

    private $skin;

    private $config;

    public function setConfig( Config $c ) {
        $this->config = $c;
    }

    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 = ConfigFactory::getDefaultInstance()->makeConfig( 'main' );
        }

        return $this->config;
    }

    public function setRequest( WebRequest $r ) {
        $this->request = $r;
    }

    public function getRequest() {
        if ( $this->request === null ) {
            global $wgRequest; # fallback to $wg till we can improve this
            $this->request = $wgRequest;
        }

        return $this->request;
    }

    public function setTitle( $t ) {
        if ( $t !== null && !$t instanceof Title ) {
            throw new MWException( __METHOD__ . " expects an instance of Title" );
        }
        $this->title = $t;
        // 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;
        }

        return $this->title;
    }

    public function canUseWikiPage() {
        if ( $this->wikipage !== null ) {
            # If there's a WikiPage object set, we can for sure get it
            return true;
        }
        $title = $this->getTitle();
        if ( $title === null ) {
            # No Title, no WikiPage
            return false;
        } else {
            # Only namespaces whose pages are stored in the database can have WikiPage
            return $title->canExist();
        }
    }

    public function setWikiPage( WikiPage $p ) {
        $contextTitle = $this->getTitle();
        $pageTitle = $p->getTitle();
        if ( !$contextTitle || !$pageTitle->equals( $contextTitle ) ) {
            $this->setTitle( $pageTitle );
        }
        // Defer this to the end since setTitle sets it to null.
        $this->wikipage = $p;
    }

    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 $o ) {
        $this->output = $o;
    }

    public function getOutput() {
        if ( $this->output === null ) {
            $this->output = new OutputPage( $this );
        }

        return $this->output;
    }

    public function setUser( User $u ) {
        $this->user = $u;
    }

    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 ( empty( $code ) || !Language::isValidCode( $code ) || ( $code === 'qqq' ) ) {
            wfDebug( "Invalid user language code\n" );
            $code = $wgLanguageCode;
        }

        return $code;
    }

    public function setLang( $l ) {
        wfDeprecated( __METHOD__, '1.19' );
        $this->setLanguage( $l );
    }

    public function setLanguage( $l ) {
        if ( $l instanceof Language ) {
            $this->lang = $l;
        } elseif ( is_string( $l ) ) {
            $l = self::sanitizeLangCode( $l );
            $obj = Language::factory( $l );
            $this->lang = $obj;
        } else {
            throw new MWException( __METHOD__ . " was passed an invalid type of data." );
        }
    }

    public function getLang() {
        wfDeprecated( __METHOD__, '1.19' );

        return $this->getLanguage();
    }

    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() );

            global $wgLanguageCode;
            $code = ( $wgLanguageCode ) ? $wgLanguageCode : 'en';
            $this->lang = Language::factory( $code );
        } elseif ( $this->lang === null ) {
            $this->recursion = true;

            global $wgLanguageCode, $wgContLang;

            $request = $this->getRequest();
            $user = $this->getUser();

            $code = $request->getVal( 'uselang', $user->getOption( 'language' ) );
            $code = self::sanitizeLangCode( $code );

            wfRunHooks( 'UserGetLanguageObject', array( $user, &$code, $this ) );

            if ( $code === $wgLanguageCode ) {
                $this->lang = $wgContLang;
            } else {
                $obj = Language::factory( $code );
                $this->lang = $obj;
            }

            unset( $this->recursion );
        }

        return $this->lang;
    }

    public function setSkin( Skin $s ) {
        $this->skin = clone $s;
        $this->skin->setContext( $this );
    }

    public function getSkin() {
        if ( $this->skin === null ) {
            wfProfileIn( __METHOD__ . '-createskin' );

            $skin = null;
            wfRunHooks( 'RequestContextCreateSkin', array( $this, &$skin ) );

            // If the hook worked try to set a skin from it
            if ( $skin instanceof Skin ) {
                $this->skin = $skin;
            } elseif ( is_string( $skin ) ) {
                $this->skin = Skin::newFromKey( $skin );
            }

            // 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 ) {
                global $wgHiddenPrefs;
                if ( !in_array( 'skin', $wgHiddenPrefs ) ) {
                    # 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
                    global $wgDefaultSkin;
                    $userSkin = $wgDefaultSkin;
                }

                $this->skin = Skin::newFromKey( $userSkin );
            }

            // After all that set a context on whatever skin got created
            $this->skin->setContext( $this );
            wfProfileOut( __METHOD__ . '-createskin' );
        }

        return $this->skin;
    }

    public function msg() {
        $args = func_get_args();

        return call_user_func_array( 'wfMessage', $args )->setContext( $this );
    }

    public static function getMain() {
        static $instance = null;
        if ( $instance === null ) {
            $instance = new self;
        }

        return $instance;
    }

    public function exportSession() {
        return array(
            'ip' => $this->getRequest()->getIP(),
            'headers' => $this->getRequest()->getAllHeaders(),
            'sessionId' => session_id(),
            'userId' => $this->getUser()->getId()
        );
    }

    public static function importScopedSession( array $params ) {
        if ( PHP_SAPI !== 'cli' ) {
            // Don't send random private cookies or turn $wgRequest into FauxRequest
            throw new MWException( "Sessions can only be imported in cli mode." );
        } elseif ( !strlen( $params['sessionId'] ) ) {
            throw new MWException( "No session ID was specified." );
        }

        if ( $params['userId'] ) { // logged-in user
            $user = User::newFromId( $params['userId'] );
            if ( !$user ) {
                throw new MWException( "No user with ID '{$params['userId']}'." );
            }
        } elseif ( !IP::isValid( $params['ip'] ) ) {
            throw new MWException( "Could not load user '{$params['ip']}'." );
        } else { // anon user
            $user = User::newFromName( $params['ip'], false );
        }

        $importSessionFunction = function ( User $user, array $params ) {
            global $wgRequest, $wgUser;

            $context = RequestContext::getMain();
            // Commit and close any current session
            session_write_close(); // persist
            session_id( '' ); // detach
            $_SESSION = array(); // clear in-memory array
            // Remove any user IP or agent information
            $context->setRequest( new FauxRequest() );
            $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 ( strlen( $params['sessionId'] ) ) { // don't make a new random ID
                wfSetupSession( $params['sessionId'] ); // sets $_SESSION
            }
            $request = new FauxRequest( array(), 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();
        $importSessionFunction( $user, $params );

        // Set callback to save and close the new session and reload the old one
        return new ScopedCallback( function () use ( $importSessionFunction, $oUser, $oParams ) {
            $importSessionFunction( $oUser, $oParams );
        } );
    }

    public static function newExtraneousContext( Title $title, $request = array() ) {
        $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;
    }
}