TitleBlacklist.list.php

Go to the documentation of this file.

<?php
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 = ObjectCache::getMainWANInstance();
        // Try to find something in the cache
        $cachedBlacklist = $cache->get( wfMemcKey( "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,
                $this->parseBlacklist( $this->getBlacklistText( $source ), $sourceName )
            );
        }
        $cache->set( wfMemcKey( "title_blacklist_entries" ),
            $this->mBlacklist, $wgTitleBlacklistCaching['expiry'] );
        wfDebugLog( 'TitleBlacklist-cache', 'Updated ' . wfMemcKey( "title_blacklist_entries" )
            . ' with ' . count( $this->mBlacklist ) . ' entries.' );
    }
 
    public function loadWhitelist() {
        global $wgTitleBlacklistCaching;
 
        $cache = ObjectCache::getMainWANInstance();
        $cachedWhitelist = $cache->get( wfMemcKey( "title_whitelist_entries" ) );
        if ( is_array( $cachedWhitelist ) && count( $cachedWhitelist ) > 0
            && ( $cachedWhitelist[0]->getFormatVersion() != self::VERSION )
        ) {
            $this->mWhitelist = $cachedWhitelist;
            return;
        }
        $this->mWhitelist = $this->parseBlacklist( wfMessage( 'titlewhitelist' )
                ->inContentLanguage()->text(), 'whitelist' );
        $cache->set( wfMemcKey( "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 ) {
            $line = TitleBlacklistEntry::newFromString( $line, $sourceName );
            if ( $line ) {
                $result[] = $line;
            }
        }
 
        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 = wfMemcKey( "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 = ObjectCache::getMainWANInstance();
        $cache->delete( wfMemcKey( "title_blacklist_entries" ) );
    }
 
    public function validate( $blacklist ) {
        $badEntries = [];
        foreach ( $blacklist as $e ) {
            wfSuppressWarnings();
            $regex = $e->getRegex();
            if ( preg_match( "/{$regex}/u", '' ) === false ) {
                $badEntries[] = $e->getRaw();
            }
            wfRestoreWarnings();
        }
        return $badEntries;
    }
 
    public static function userCanOverride( $user, $action ) {
        return $user->isAllowed( 'tboverride' ) ||
            ( $action == 'new-account' && $user->isAllowed( 'tboverride-account' ) );
    }
}
 
class TitleBlacklistEntry {
    private $mRaw;
 
    private $mRegex;
 
    private $mParams;
 
    private $mFormatVersion;
 
    private $mSource;
 
    private function __construct( $regex, $params, $raw, $source ) {
        $this->mRaw = $raw;
        $this->mRegex = $regex;
        $this->mParams = $params;
        $this->mFormatVersion = TitleBlacklist::VERSION;
        $this->mSource = $source;
    }
 
    private function filtersNewAccounts() {
        global $wgTitleBlacklistUsernameSources;
 
        if ( $wgTitleBlacklistUsernameSources === '*' ) {
            return true;
        }
 
        if ( !$wgTitleBlacklistUsernameSources ) {
            return false;
        }
 
        if ( !is_array( $wgTitleBlacklistUsernameSources ) ) {
            throw new Exception(
                '$wgTitleBlacklistUsernameSources must be "*", false or an array' );
        }
 
        return in_array( $this->mSource, $wgTitleBlacklistUsernameSources, true );
    }
 
    public function matches( $title, $action ) {
        if ( $title == '' ) {
            return false;
        }
 
        if ( $action === 'new-account' && !$this->filtersNewAccounts() ) {
            return false;
        }
 
        if ( isset( $this->mParams['antispoof'] )
            && is_callable( 'AntiSpoof::checkUnicodeString' )
        ) {
            if ( $action === 'edit' ) {
                // Use process cache for frequently edited pages
                $cache = ObjectCache::getMainWANInstance();
                list( $ok, $norm ) = $cache->getWithSetCallback(
                    $cache->makeKey( 'titleblacklist', 'normalized-unicode', md5( $title ) ),
                    $cache::TTL_MONTH,
                    function () use ( $title ) {
                        return AntiSpoof::checkUnicodeString( $title );
                    },
                    [ 'pcTTL' => $cache::TTL_PROC_LONG ]
                );
            } else {
                list( $ok, $norm ) = AntiSpoof::checkUnicodeString( $title );
            }
 
            if ( $ok === "OK" ) {
                list( $ver, $title ) = explode( ':', $norm, 2 );
            } else {
                wfDebugLog( 'TitleBlacklist', 'AntiSpoof could not normalize "' . $title . '".' );
            }
        }
 
        wfSuppressWarnings();
        $match = preg_match(
            "/^(?:{$this->mRegex})$/us" . ( isset( $this->mParams['casesensitive'] ) ? '' : 'i' ),
            $title
        );
        wfRestoreWarnings();
 
        if ( $match ) {
            if ( isset( $this->mParams['moveonly'] ) && $action != 'move' ) {
                return false;
            }
            if ( isset( $this->mParams['newaccountonly'] ) && $action != 'new-account' ) {
                return false;
            }
            if ( !isset( $this->mParams['noedit'] ) && $action == 'edit' ) {
                return false;
            }
            if ( isset( $this->mParams['reupload'] ) && $action == 'upload' ) {
                // Special:Upload also checks 'create' permissions when not reuploading
                return false;
            }
            return true;
        }
 
        return false;
    }
 
    public static function newFromString( $line, $source ) {
        $raw = $line; // Keep line for raw data
        $options = [];
        // Strip comments
        $line = preg_replace( "/^\\s*([^#]*)\\s*((.*)?)$/", "\\1", $line );
        $line = trim( $line );
        // A blank string causes problems later on
        if ( $line === '' ) {
            return null;
        }
        // Parse the rest of message
        $pockets = [];
        if ( !preg_match( '/^(.*?)(\s*<([^<>]*)>)?$/', $line, $pockets ) ) {
            return null;
        }
        $regex = trim( $pockets[1] );
        $regex = str_replace( '_', ' ', $regex ); // We'll be matching against text form
        $opts_str = isset( $pockets[3] ) ? trim( $pockets[3] ) : '';
        // Parse opts
        $opts = preg_split( '/\s*\|\s*/', $opts_str );
        foreach ( $opts as $opt ) {
            $opt2 = strtolower( $opt );
            if ( $opt2 == 'autoconfirmed' ) {
                $options['autoconfirmed'] = true;
            }
            if ( $opt2 == 'moveonly' ) {
                $options['moveonly'] = true;
            }
            if ( $opt2 == 'newaccountonly' ) {
                $options['newaccountonly'] = true;
            }
            if ( $opt2 == 'noedit' ) {
                $options['noedit'] = true;
            }
            if ( $opt2 == 'casesensitive' ) {
                $options['casesensitive'] = true;
            }
            if ( $opt2 == 'reupload' ) {
                $options['reupload'] = true;
            }
            if ( preg_match( '/errmsg\s*=\s*(.+)/i', $opt, $matches ) ) {
                $options['errmsg'] = $matches[1];
            }
            if ( $opt2 == 'antispoof' ) {
                $options['antispoof'] = true;
            }
        }
        // Process magic words
        preg_match_all( '/{{\s*([a-z]+)\s*:\s*(.+?)\s*}}/', $regex, $magicwords, PREG_SET_ORDER );
        foreach ( $magicwords as $mword ) {
            global $wgParser;   // Functions we're calling don't need, nevertheless let's use it
            switch ( strtolower( $mword[1] ) ) {
                case 'ns':
                    $cpf_result = CoreParserFunctions::ns( $wgParser, $mword[2] );
                    if ( is_string( $cpf_result ) ) {
                        // All result will have the same value, so we can just use str_seplace()
                        $regex = str_replace( $mword[0], $cpf_result, $regex );
                    }
                    break;
                case 'int':
                    $cpf_result = wfMessage( $mword[2] )->inContentLanguage()->text();
                    if ( is_string( $cpf_result ) ) {
                        $regex = str_replace( $mword[0], $cpf_result, $regex );
                    }
            }
        }
        // Return result
        if ( $regex ) {
            return new TitleBlacklistEntry( $regex, $options, $raw, $source );
        } else {
            return null;
        }
    }
 
    public function getRegex() {
        return $this->mRegex;
    }
 
    public function getRaw() {
        return $this->mRaw;
    }
 
    public function getParams() {
        return $this->mParams;
    }
 
    public function getCustomMessage() {
        return isset( $this->mParams['errmsg'] ) ? $this->mParams['errmsg'] : null;
    }
 
    public function getFormatVersion() {
        return $this->mFormatVersion;
    }
 
    public function setFormatVersion( $v ) {
        $this->mFormatVersion = $v;
    }
 
    public function getErrorMessage( $operation ) {
        $message = $this->getCustomMessage();
        // For grep:
        // titleblacklist-forbidden-edit, titleblacklist-forbidden-move,
        // titleblacklist-forbidden-upload, titleblacklist-forbidden-new-account
        return $message ? $message : "titleblacklist-forbidden-{$operation}";
    }
}