SpecialLinkSearch.php

Go to the documentation of this file.

<?php
class LinkSearchPage extends QueryPage {
    private $mungedQuery = false;

    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.
    }

    function isCacheable() {
        return false;
    }

    public function execute( $par ) {
        $this->setHeaders();
        $this->outputHeader();

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

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

        $protocols_list = [];
        foreach ( $this->getConfig()->get( 'UrlProtocols' ) 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 )
        );
        $fields = [
            'target' => [
                'type' => 'text',
                'name' => 'target',
                'id' => 'target',
                'size' => 50,
                'label-message' => 'linksearch-pat',
                'default' => $target,
                'dir' => 'ltr',
            ]
        ];
        if ( !$this->getConfig()->get( 'MiserMode' ) ) {
            $fields += [
                'namespace' => [
                    'type' => 'namespaceselect',
                    'name' => 'namespace',
                    'label-message' => 'linksearch-ns',
                    'default' => $namespace,
                    'id' => 'namespace',
                    'all' => '',
                    'cssclass' => 'namespaceselector',
                ],
            ];
        }
        $hiddenFields = [
            'title' => $this->getPageTitle()->getPrefixedDBkey(),
        ];
        $htmlForm = HTMLForm::factory( 'ooui', $fields, $this->getContext() );
        $htmlForm->addHiddenFields( $hiddenFields );
        $htmlForm->setSubmitTextMsg( 'linksearch-ok' );
        $htmlForm->setWrapperLegendMsg( 'linksearch' );
        $htmlForm->setAction( wfScript() );
        $htmlForm->setMethod( 'get' );
        $htmlForm->prepareForm()->displayForm( false );
        $this->addHelpLink( 'Help:Linksearch' );

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

    function isSyndicated() {
        return false;
    }

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

        if ( $query === '*' && $prot !== '' ) {
            // Allow queries like 'ftp://*' to find all ftp links
            $rv = [ $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 = [ $prot . rtrim( $query, " \t*" ), $dbr->anyString() ];
                $field = 'el_to';
            }
        }

        return [ $rv, $field ];
    }

    function linkParameters() {
        $params = [];
        $params['target'] = $this->mProt . $this->mQuery;
        if ( $this->mNs !== null && !$this->getConfig()->get( 'MiserMode' ) ) {
            $params['namespace'] = $this->mNs;
        }

        return $params;
    }

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

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

        if ( $this->mNs !== null && !$this->getConfig()->get( 'MiserMode' ) ) {
            $retval['conds']['page_namespace'] = $this->mNs;
        }

        return $retval;
    }

    function preprocessResults( $db, $res ) {
        if ( $res->numRows() > 0 ) {
            $linkBatch = new LinkBatch();

            foreach ( $res as $row ) {
                $linkBatch->add( $row->namespace, $row->title );
            }

            $res->seek( 0 );
            $linkBatch->execute();
        }
    }

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

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

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

    function getOrderFields() {
        return [];
    }

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

    protected function getMaxResults() {
        return max( parent::getMaxResults(), 60000 );
    }
}