SpecialLinkSearch.php

Go to the documentation of this file.

<?php
class LinkSearchPage extends QueryPage {

    protected $linkRenderer = null;

    function setParams( $params ) {
        $this->mQuery = $params['query'];
        $this->mNs = $params['namespace'];
        $this->mProt = $params['protocol'];
    }

    function __construct( $name = 'LinkSearch' ) {
        parent::__construct( $name );

        // Since we don't control the constructor parameters, we can't inject services that way.
        // Instead, we initialize services in the execute() method, and allow them to be overridden
        // using the setServices() method.
    }

    public function setPageLinkRenderer(
        PageLinkRenderer $linkRenderer
    ) {
        $this->linkRenderer = $linkRenderer;
    }

    private function initServices() {
        if ( !$this->linkRenderer ) {
            $lang = $this->getContext()->getLanguage();
            $titleFormatter = new MediaWikiTitleCodec( $lang, GenderCache::singleton() );
            $this->linkRenderer = new MediaWikiPageLinkRenderer( $titleFormatter );
        }
    }

    function isCacheable() {
        return false;
    }

    function execute( $par ) {
        global $wgUrlProtocols, $wgMiserMode, $wgScript;

        $this->initServices();

        $this->setHeaders();
        $this->outputHeader();

        $out = $this->getOutput();
        $out->allowClickjacking();

        $request = $this->getRequest();
        $target = $request->getVal( 'target', $par );
        $namespace = $request->getIntorNull( 'namespace', null );

        $protocols_list = array();
        foreach ( $wgUrlProtocols as $prot ) {
            if ( $prot !== '//' ) {
                $protocols_list[] = $prot;
            }
        }

        $target2 = $target;
        // Get protocol, default is http://
        $protocol = 'http://';
        $bits = wfParseUrl( $target );
        if ( isset( $bits['scheme'] ) && isset( $bits['delimiter'] ) ) {
            $protocol = $bits['scheme'] . $bits['delimiter'];
            // Make sure wfParseUrl() didn't make some well-intended correction in the
            // protocol
            if ( strcasecmp( $protocol, substr( $target, 0, strlen( $protocol ) ) ) === 0 ) {
                $target2 = substr( $target, strlen( $protocol ) );
            } else {
                // If it did, let LinkFilter::makeLikeArray() handle this
                $protocol = '';
            }
        }

        $out->addWikiMsg(
            'linksearch-text',
            '<nowiki>' . $this->getLanguage()->commaList( $protocols_list ) . '</nowiki>',
            count( $protocols_list )
        );
        $s = Html::openElement(
            'form',
            array( 'id' => 'mw-linksearch-form', 'method' => 'get', 'action' => $wgScript )
        ) . "\n" .
            Html::hidden( 'title', $this->getPageTitle()->getPrefixedDBkey() ) . "\n" .
            Html::openElement( 'fieldset' ) . "\n" .
            Html::element( 'legend', array(), $this->msg( 'linksearch' )->text() ) . "\n" .
            Xml::inputLabel(
                $this->msg( 'linksearch-pat' )->text(),
                'target',
                'target',
                50,
                $target
            ) . "\n";

        if ( !$wgMiserMode ) {
            $s .= Html::namespaceSelector(
                array(
                    'selected' => $namespace,
                    'all' => '',
                    'label' => $this->msg( 'linksearch-ns' )->text()
                ), array(
                    'name' => 'namespace',
                    'id' => 'namespace',
                    'class' => 'namespaceselector',
                )
            );
        }

        $s .= Xml::submitButton( $this->msg( 'linksearch-ok' )->text() ) . "\n" .
            Html::closeElement( 'fieldset' ) . "\n" .
            Html::closeElement( 'form' ) . "\n";
        $out->addHTML( $s );

        if ( $target != '' ) {
            $this->setParams( array(
                'query' => $target2,
                'namespace' => $namespace,
                'protocol' => $protocol ) );
            parent::execute( $par );
            if ( $this->mMungedQuery === false ) {
                $out->addWikiMsg( 'linksearch-error' );
            }
        }
    }

    function isSyndicated() {
        return false;
    }

    static function mungeQuery( $query, $prot ) {
        $field = 'el_index';
        $dbr = wfGetDB( DB_SLAVE );

        if ( $query === '*' && $prot !== '' ) {
            // Allow queries like 'ftp://*' to find all ftp links
            $rv = array( $prot, $dbr->anyString() );
        } else {
            $rv = LinkFilter::makeLikeArray( $query, $prot );
        }

        if ( $rv === false ) {
            // LinkFilter doesn't handle wildcard in IP, so we'll have to munge here.
            $pattern = '/^(:?[0-9]{1,3}\.)+\*\s*$|^(:?[0-9]{1,3}\.){3}[0-9]{1,3}:[0-9]*\*\s*$/';
            if ( preg_match( $pattern, $query ) ) {
                $rv = array( $prot . rtrim( $query, " \t*" ), $dbr->anyString() );
                $field = 'el_to';
            }
        }

        return array( $rv, $field );
    }

    function linkParameters() {
        global $wgMiserMode;
        $params = array();
        $params['target'] = $this->mProt . $this->mQuery;
        if ( isset( $this->mNs ) && !$wgMiserMode ) {
            $params['namespace'] = $this->mNs;
        }

        return $params;
    }

    function getQueryInfo() {
        global $wgMiserMode;
        $dbr = wfGetDB( DB_SLAVE );
        // strip everything past first wildcard, so that
        // index-based-only lookup would be done
        list( $this->mMungedQuery, $clause ) = self::mungeQuery( $this->mQuery, $this->mProt );
        if ( $this->mMungedQuery === false ) {
            // Invalid query; return no results
            return array( 'tables' => 'page', 'fields' => 'page_id', 'conds' => '0=1' );
        }

        $stripped = LinkFilter::keepOneWildcard( $this->mMungedQuery );
        $like = $dbr->buildLike( $stripped );
        $retval = array(
            'tables' => array( 'page', 'externallinks' ),
            'fields' => array(
                'namespace' => 'page_namespace',
                'title' => 'page_title',
                'value' => 'el_index',
                'url' => 'el_to'
            ),
            'conds' => array(
                'page_id = el_from',
                "$clause $like"
            ),
            'options' => array( 'USE INDEX' => $clause )
        );

        if ( isset( $this->mNs ) && !$wgMiserMode ) {
            $retval['conds']['page_namespace'] = $this->mNs;
        }

        return $retval;
    }

    function formatResult( $skin, $result ) {
        $title = new TitleValue( (int)$result->namespace, $result->title );
        $pageLink = $this->linkRenderer->renderHtmlLink( $title );

        $url = $result->url;
        $urlLink = Linker::makeExternalLink( $url, $url );

        return $this->msg( 'linksearch-line' )->rawParams( $urlLink, $pageLink )->escaped();
    }

    function doQuery( $offset = false, $limit = false ) {
        list( $this->mMungedQuery, ) = LinkSearchPage::mungeQuery( $this->mQuery, $this->mProt );
        if ( $this->mMungedQuery === false ) {
            $this->getOutput()->addWikiMsg( 'linksearch-error' );
        } else {
            // For debugging
            // Generates invalid xhtml with patterns that contain --
            //$this->getOutput()->addHTML( "\n<!-- " . htmlspecialchars( $this->mMungedQuery ) . " -->\n" );
            parent::doQuery( $offset, $limit );
        }
    }

    function getOrderFields() {
        return array();
    }

    protected function getGroupName() {
        return 'redirects';
    }
}