TitleBlacklist.php

Go to the documentation of this file.

<?php
use MediaWiki\MediaWikiServices;
 
class TitleBlacklist {
    private $mBlacklist = null;
 
    private $mWhitelist = null;
 
    protected static $instance = null;
 
    const VERSION = 3;  // Blacklist format
 
    public static function singleton() {
        if ( self::$instance === null ) {
            self::$instance = new self;
        }
        return self::$instance;
    }
 
    public static function destroySingleton() {
        if ( !defined( 'MW_PHPUNIT_TEST' ) ) {
            throw new MWException(
                'Can not invoke ' . __METHOD__ . '() ' .
                'out of tests (MW_PHPUNIT_TEST not set).'
            );
        }
 
        self::$instance = null;
    }
 
    public function load() {
        global $wgTitleBlacklistSources, $wgTitleBlacklistCaching;
 
        $cache = MediaWikiServices::getInstance()->getMainWANObjectCache();
        // Try to find something in the cache
        $cachedBlacklist = $cache->get( $cache->makeKey( 'title_blacklist_entries' ) );
        if ( is_array( $cachedBlacklist ) && count( $cachedBlacklist ) > 0
            && ( $cachedBlacklist[0]->getFormatVersion() == self::VERSION )
        ) {
            $this->mBlacklist = $cachedBlacklist;
            return;
        }
 
        $sources = $wgTitleBlacklistSources;
        $sources['local'] = [ 'type' => 'message' ];
        $this->mBlacklist = [];
        foreach ( $sources as $sourceName => $source ) {
            $this->mBlacklist = array_merge(
                $this->mBlacklist,
                self::parseBlacklist( self::getBlacklistText( $source ), $sourceName )
            );
        }
        $cache->set( $cache->makeKey( 'title_blacklist_entries' ),
            $this->mBlacklist, $wgTitleBlacklistCaching['expiry'] );
        wfDebugLog( 'TitleBlacklist-cache', 'Updated ' . $cache->makeKey( 'title_blacklist_entries' )
            . ' with ' . count( $this->mBlacklist ) . ' entries.' );
    }
 
    public function loadWhitelist() {
        global $wgTitleBlacklistCaching;
 
        $cache = MediaWikiServices::getInstance()->getMainWANObjectCache();
        $cachedWhitelist = $cache->get( $cache->makeKey( 'title_whitelist_entries' ) );
        if ( is_array( $cachedWhitelist ) && count( $cachedWhitelist ) > 0
            && ( $cachedWhitelist[0]->getFormatVersion() != self::VERSION )
        ) {
            $this->mWhitelist = $cachedWhitelist;
            return;
        }
        $this->mWhitelist = self::parseBlacklist( wfMessage( 'titlewhitelist' )
                ->inContentLanguage()->text(), 'whitelist' );
        $cache->set( $cache->makeKey( 'title_whitelist_entries' ),
            $this->mWhitelist, $wgTitleBlacklistCaching['expiry'] );
    }
 
    private static function getBlacklistText( $source ) {
        if ( !is_array( $source ) || count( $source ) <= 0 ) {
            return '';  // Return empty string in error case
        }
 
        if ( $source['type'] == 'message' ) {
            return wfMessage( 'titleblacklist' )->inContentLanguage()->text();
        } elseif ( $source['type'] == 'localpage' && count( $source ) >= 2 ) {
            $title = Title::newFromText( $source['src'] );
            if ( is_null( $title ) ) {
                return '';
            }
            if ( $title->getNamespace() == NS_MEDIAWIKI ) {
                $msg = wfMessage( $title->getText() )->inContentLanguage();
                if ( !$msg->isDisabled() ) {
                    return $msg->text();
                } else {
                    return '';
                }
            } else {
                $page = WikiPage::factory( $title );
                if ( $page->exists() ) {
                    return ContentHandler::getContentText( $page->getContent() );
                }
            }
        } elseif ( $source['type'] == 'url' && count( $source ) >= 2 ) {
            return self::getHttp( $source['src'] );
        } elseif ( $source['type'] == 'file' && count( $source ) >= 2 ) {
            if ( file_exists( $source['src'] ) ) {
                return file_get_contents( $source['src'] );
            } else {
                return '';
            }
        }
 
        return '';
    }
 
    public static function parseBlacklist( $list, $sourceName ) {
        $lines = preg_split( "/\r?\n/", $list );
        $result = [];
        foreach ( $lines as $line ) {
            $entry = TitleBlacklistEntry::newFromString( $line, $sourceName );
            if ( $entry ) {
                $result[] = $entry;
            }
        }
 
        return $result;
    }
 
    public function userCannot( $title, $user, $action = 'edit', $override = true ) {
        $entry = $this->isBlacklisted( $title, $action );
        if ( !$entry ) {
            return false;
        }
        $params = $entry->getParams();
        if ( isset( $params['autoconfirmed'] ) && $user->isAllowed( 'autoconfirmed' ) ) {
            return false;
        }
        if ( $override && self::userCanOverride( $user, $action ) ) {
            return false;
        }
        return $entry;
    }
 
    public function isBlacklisted( $title, $action = 'edit' ) {
        if ( !( $title instanceof Title ) ) {
            $title = Title::newFromText( $title );
            if ( !( $title instanceof Title ) ) {
                // The fact that the page name is invalid will stop whatever
                // action is going through. No sense in doing more work here.
                return false;
            }
        }
        $blacklist = $this->getBlacklist();
        $autoconfirmedItem = false;
        foreach ( $blacklist as $item ) {
            if ( $item->matches( $title->getFullText(), $action ) ) {
                if ( $this->isWhitelisted( $title, $action ) ) {
                    return false;
                }
                $params = $item->getParams();
                if ( !isset( $params['autoconfirmed'] ) ) {
                    return $item;
                }
                if ( !$autoconfirmedItem ) {
                    $autoconfirmedItem = $item;
                }
            }
        }
        return $autoconfirmedItem;
    }
 
    public function isWhitelisted( $title, $action = 'edit' ) {
        if ( !( $title instanceof Title ) ) {
            $title = Title::newFromText( $title );
        }
        $whitelist = $this->getWhitelist();
        foreach ( $whitelist as $item ) {
            if ( $item->matches( $title->getFullText(), $action ) ) {
                return true;
            }
        }
        return false;
    }
 
    public function getBlacklist() {
        if ( is_null( $this->mBlacklist ) ) {
            $this->load();
        }
        return $this->mBlacklist;
    }
 
    public function getWhitelist() {
        if ( is_null( $this->mWhitelist ) ) {
            $this->loadWhitelist();
        }
        return $this->mWhitelist;
    }
 
    private static function getHttp( $url ) {
        global $messageMemc, $wgTitleBlacklistCaching;
 
        $key = 'title_blacklist_source:' . md5( $url ); // Global shared
        $warnkey = $messageMemc->makeKey( 'titleblacklistwarning', md5( $url ) );
        $result = $messageMemc->get( $key );
        $warn = $messageMemc->get( $warnkey );
 
        if ( !is_string( $result )
            || ( !$warn && !mt_rand( 0, $wgTitleBlacklistCaching['warningchance'] ) )
        ) {
            $result = Http::get( $url );
            $messageMemc->set( $warnkey, 1, $wgTitleBlacklistCaching['warningexpiry'] );
            $messageMemc->set( $key, $result, $wgTitleBlacklistCaching['expiry'] );
        }
 
        return $result;
    }
 
    public function invalidate() {
        $cache = MediaWikiServices::getInstance()->getMainWANObjectCache();
        $cache->delete( $cache->makeKey( 'title_blacklist_entries' ) );
    }
 
    public function validate( array $blacklist ) {
        $badEntries = [];
        foreach ( $blacklist as $e ) {
            Wikimedia\suppressWarnings();
            $regex = $e->getRegex();
            if ( preg_match( "/{$regex}/u", '' ) === false ) {
                $badEntries[] = $e->getRaw();
            }
            Wikimedia\restoreWarnings();
        }
        return $badEntries;
    }
 
    public static function userCanOverride( $user, $action ) {
        return $user->isAllowed( 'tboverride' ) ||
            ( $action == 'new-account' && $user->isAllowed( 'tboverride-account' ) );
    }
}