SpecialLinkSearch.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Specials;
 
use MediaWiki\Deferred\LinksUpdate\ExternalLinksTable;
use MediaWiki\ExternalLinks\LinkFilter;
use MediaWiki\HTMLForm\HTMLForm;
use MediaWiki\MainConfigNames;
use MediaWiki\Message\Message;
use MediaWiki\Page\LinkBatchFactory;
use MediaWiki\Parser\Parser;
use MediaWiki\Skin\Skin;
use MediaWiki\SpecialPage\QueryPage;
use MediaWiki\Title\TitleValue;
use MediaWiki\Utils\UrlUtils;
use stdClass;
use Wikimedia\Rdbms\IConnectionProvider;
use Wikimedia\Rdbms\IExpression;
use Wikimedia\Rdbms\IReadableDatabase;
use Wikimedia\Rdbms\IResultWrapper;
use Wikimedia\Rdbms\LikeValue;
 
class SpecialLinkSearch extends QueryPage {
    private $mungedQuery = false;
    private $mQuery;
    private $mNs;
    private $mProt;
 
    private function setParams( array $params ) {
        $this->mQuery = $params['query'];
        $this->mNs = $params['namespace'];
        $this->mProt = $params['protocol'];
    }
 
    public function __construct(
        IConnectionProvider $dbProvider,
        LinkBatchFactory $linkBatchFactory,
        private readonly UrlUtils $urlUtils,
    ) {
        parent::__construct( 'LinkSearch' );
        $this->setDatabaseProvider( $dbProvider );
        $this->setLinkBatchFactory( $linkBatchFactory );
    }
 
    public function isCacheable() {
        return false;
    }
 
    public function execute( $par ) {
        $this->setHeaders();
        $this->outputHeader();
 
        $out = $this->getOutput();
        $out->getMetadata()->setPreventClickjacking( false );
 
        $request = $this->getRequest();
        $target = $request->getVal( 'target', $par ?? '' );
        $namespace = $request->getIntOrNull( 'namespace' );
 
        $protocols_list = [];
        foreach ( $this->getConfig()->get( MainConfigNames::UrlProtocols ) as $prot ) {
            if ( $prot !== '//' ) {
                $protocols_list[] = $prot;
            }
        }
 
        $target2 = Parser::normalizeLinkUrl( $target );
        $protocol = null;
        $bits = $this->urlUtils->parse( $target );
        if ( isset( $bits['scheme'] ) && isset( $bits['delimiter'] ) ) {
            $protocol = $bits['scheme'] . $bits['delimiter'];
            // Make sure UrlUtils::parse() didn't make some well-intended correction in the protocol
            if ( str_starts_with( strtolower( $target ), strtolower( $protocol ) ) ) {
                $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( MainConfigNames::MiserMode ) ) {
            $fields += [
                'namespace' => [
                    'type' => 'namespaceselect',
                    'name' => 'namespace',
                    'label-message' => 'linksearch-ns',
                    'default' => $namespace,
                    'id' => 'namespace',
                    'all' => '',
                    'cssclass' => 'namespaceselector',
                ],
            ];
        }
        $htmlForm = HTMLForm::factory( 'ooui', $fields, $this->getContext() );
        $htmlForm->setSubmitTextMsg( 'linksearch-ok' );
        $htmlForm->setWrapperLegendMsg( 'linksearch' );
        $htmlForm->setTitle( $this->getPageTitle() );
        $htmlForm->setMethod( 'get' );
        $htmlForm->prepareForm()->displayForm( false );
        $this->addHelpLink( 'Help:Linksearch' );
 
        if ( $target != '' ) {
            $this->setParams( [
                'query' => $target2,
                'namespace' => $namespace,
                'protocol' => $protocol ] );
            parent::execute( $par );
            if ( $this->mungedQuery === false ) {
                $out->addWikiMsg( 'linksearch-error' );
            }
        }
        $ignoredDomains = $this->getConfig()->get( MainConfigNames::ExternalLinksIgnoreDomains );
        if ( $ignoredDomains ) {
            $out->addWikiMsg(
                'linksearch-text-ignored-domains',
                Message::listParam(
                    array_map( static fn ( $domain ) => "<code>$domain</code>", $ignoredDomains )
                ),
                count( $ignoredDomains )
            );
        }
    }
 
    public function isSyndicated() {
        return false;
    }
 
    protected function linkParameters() {
        $params = [];
        $params['target'] = $this->mProt . $this->mQuery;
        if ( $this->mNs !== null && !$this->getConfig()->get( MainConfigNames::MiserMode ) ) {
            $params['namespace'] = $this->mNs;
        }
 
        return $params;
    }
 
    public function getQueryInfo() {
        $dbr = $this->getDatabaseProvider()->getReplicaDatabase( ExternalLinksTable::VIRTUAL_DOMAIN );
 
        $field = 'el_to_domain_index';
        $extraFields = [
            'urldomain' => 'el_to_domain_index',
            'urlpath' => 'el_to_path'
        ];
        if ( $this->mQuery === '*' && $this->mProt !== '' ) {
            if ( $this->mProt !== null ) {
                $this->mungedQuery = [
                    $dbr->expr( $field, IExpression::LIKE, new LikeValue( $this->mProt, $dbr->anyString() ) ),
                ];
            } else {
                $this->mungedQuery = [
                    $dbr->expr( $field, IExpression::LIKE, new LikeValue( 'http://', $dbr->anyString() ) )
                        ->or( $field, IExpression::LIKE, new LikeValue( 'https://', $dbr->anyString() ) ),
                ];
            }
        } else {
            $this->mungedQuery = LinkFilter::getQueryConditions( $this->mQuery, [
                'protocol' => $this->mProt,
                'oneWildcard' => true,
                'db' => $dbr
            ] );
            if ( $this->mungedQuery === false ) {
                // Invalid query; return no results
                return [ 'tables' => 'page', 'fields' => 'page_id', 'conds' => '0=1' ];
            }
        }
        $orderBy = [ 'el_id' ];
 
        $retval = [
            'tables' => [ 'page', 'externallinks' ],
            'fields' => [
                'namespace' => 'page_namespace',
                'title' => 'page_title',
                ...$extraFields,
            ],
            'conds' => [
                'page_id = el_from',
                ...$this->mungedQuery,
            ],
            'options' => [ 'ORDER BY' => $orderBy ]
        ];
 
        if ( $this->mNs !== null && !$this->getConfig()->get( MainConfigNames::MiserMode ) ) {
            $retval['conds']['page_namespace'] = $this->mNs;
        }
 
        return $retval;
    }
 
    public function preprocessResults( $db, $res ) {
        $this->executeLBFromResultWrapper( $res );
    }
 
    public function formatResult( $skin, $result ) {
        $title = new TitleValue( (int)$result->namespace, $result->title );
        $pageLink = $this->getLinkRenderer()->makeLink( $title );
        $url = LinkFilter::reverseIndexes( $result->urldomain ) . $result->urlpath;
 
        $urlLink = $this->getLinkRenderer()->makeExternalLink( $url, $url, $this->getFullTitle() );
 
        return $this->msg( 'linksearch-line' )->rawParams( $urlLink, $pageLink )->escaped();
    }
 
    protected function getOrderFields() {
        return [];
    }
 
    protected function getGroupName() {
        return 'pages';
    }
 
    protected function getMaxResults() {
        return max( parent::getMaxResults(), 60000 );
    }
 
    protected function getRecacheDB() {
        return $this->getDatabaseProvider()->getReplicaDatabase(
            ExternalLinksTable::VIRTUAL_DOMAIN,
            'vslow'
        );
    }
}
 
class_alias( SpecialLinkSearch::class, 'SpecialLinkSearch' );