Title.php

Go to the documentation of this file.

<?php

// patched: alex, 30.4.2019: Added missing defines

define('NS_MAIN', "nsmain");
define('NS_SPECIAL', "nsspecial");

define('GAID_FOR_UPDATE', 1);

# Title::newFromTitle maintains a cache to avoid
# expensive re-normalization of commonly used titles.
# On a batch operation this can become a memory leak
# if not bounded. After hitting this many titles,
# reset the cache.
define('MW_TITLECACHE_MAX', 1000);

# Constants for pr_cascade bitfield
define('CASCADE', 1);

class Title
{
    private static $titleCache = array();
    private static $interwikiCache = array();
    protected bool $mOldRestrictions;

    public $mTextform;                  # Text form (spaces not underscores) of the main part
    public $mUrlform;                   # URL-encoded form of the main part
    public $mDbkeyform;                 # Main part with underscores
    public $mNamespace;                 # Namespace index, i.e. one of the NS_xxxx constants
    public $mInterwiki;                 # Interwiki prefix (or null string)
    public $mFragment;                  # Title fragment (i.e. the bit after the #)
    public $mArticleID;                 # Article ID, fetched from the link cache on demand
    public $mLatestID;          # ID of most recent revision
    public $mRestrictions;              # Array of groups allowed to edit this article
    public $mCascadeRestriction;        # Cascade restrictions on this page to included templates and images?
    public $mRestrictionsExpiry;        # When do the restrictions on this page expire?
    public $mHasCascadingRestrictions;  # Are cascading restrictions in effect on this page?
    public $mCascadeRestrictionSources;# Where are the cascading restrictions coming from on this page?
    public $mRestrictionsLoaded;        # Boolean for initialisation on demand
    public $mPrefixedText;              # Text form including namespace/interwiki, initialised on demand
    public $mDefaultNamespace;          # Namespace index when there is no namespace
    # Zero except in {{transclusion}} tags
    public $mWatched;                   # Is $wgUser watching this page? NULL if unfilled, accessed through userIsWatching()
    /* private */ public function __construct()
    {
        $this->mInterwiki = $this->mUrlform =
        $this->mTextform = $this->mDbkeyform = '';
        $this->mArticleID = -1;
        $this->mNamespace = NS_MAIN;
        $this->mRestrictionsLoaded = false;
        $this->mRestrictions = array();
        # Dont change the following, NS_MAIN is hardcoded in several place
        # See bug #696
        $this->mDefaultNamespace = NS_MAIN;
        $this->mWatched = null;
        $this->mLatestID = false;
        $this->mOldRestrictions = false;
    }


    public static function newFromText($text, $defaultNamespace = NS_MAIN)
    {
        if ($defaultNamespace == NS_MAIN && isset(Title::$titleCache[$text])) {
            return Title::$titleCache[$text];
        }

        $filteredText = Sanitizer::decodeCharReferences($text);

        $t = new Title();
        $t->mDbkeyform = str_replace(' ', '_', $filteredText);
        $t->mDefaultNamespace = $defaultNamespace;

        static $cachedcount = 0 ;
        if ($t->secureAndSplit()) {
            if ($defaultNamespace == NS_MAIN) {
                if ($cachedcount >= MW_TITLECACHE_MAX) {
                    # Avoid memory leaks on mass operations...
                    Title::$titleCache = array();
                    $cachedcount = 0;
                }
                $cachedcount++;
                Title::$titleCache[$text] = &$t;
            }
            return $t;
        } else {
            $ret = null;
            return $ret;
        }
    }


    #----------------------------------------------------------------------------
    #   Static functions
    #----------------------------------------------------------------------------


    public static function legalChars()
    {
        global $wgLegalTitleChars;

        $wgLegalTitleChars = " %!\"$&'()*,\\-.\\/0-9:;=?@A-Z\\\\^_`a-z~\\x80-\\xFF+";

        return $wgLegalTitleChars;
    }


    public function getInterwikiLink($key)
    {
        return "";
    }

    #----------------------------------------------------------------------------
    #   Other stuff
    #----------------------------------------------------------------------------

    public function getText()
    {
        return $this->mTextform;
    }

    public function getDBkey()
    {
        return $this->mDbkeyform;
    }
    public function getNamespace()
    {
        return $this->mNamespace;
    }
    public function getNsText()
    {
        global $wgContLang, $wgCanonicalNamespaceNames;

        if ('' != $this->mInterwiki) {
            // This probably shouldn't even happen. ohh man, oh yuck.
            // But for interwiki transclusion it sometimes does.
            // Shit. Shit shit shit.
            //
            // Use the canonical namespaces if possible to try to
            // resolve a foreign namespace.
            if (isset($wgCanonicalNamespaceNames[$this->mNamespace])) {
                return $wgCanonicalNamespaceNames[$this->mNamespace];
            }
        }
        return $wgContLang->getNsText($this->mNamespace);
    }
    public function getInterwiki()
    {
        return $this->mInterwiki;
    }
    public function getFragment()
    {
        return $this->mFragment;
    }

    /* private */ public function prefix($name)
    {
        $p = '';
        if ('' != $this->mInterwiki) {
            $p = $this->mInterwiki . ':';
        }
        if (0 != $this->mNamespace) {
            $p .= $this->getNsText() . ':';
        }
        return $p . $name;
    }

    private function secureAndSplit()
    {
        global $wgContLang, $wgLocalInterwiki, $wgCapitalLinks;

        # Initialisation
        static $rxTc = false;
        if (!$rxTc) {
            # % is needed as well
            $rxTc = '/[^' . Title::legalChars() . ']|%[0-9A-Fa-f]{2}/S';
        }

        $this->mInterwiki = $this->mFragment = '';
        $this->mNamespace = $this->mDefaultNamespace; # Usually NS_MAIN

        $dbkey = $this->mDbkeyform;

        # Strip Unicode bidi override characters.
        # Sometimes they slip into cut-n-pasted page titles, where the
        # override chars get included in list displays.
        $dbkey = str_replace("\xE2\x80\x8E", '', $dbkey); // 200E LEFT-TO-RIGHT MARK
        $dbkey = str_replace("\xE2\x80\x8F", '', $dbkey); // 200F RIGHT-TO-LEFT MARK

        # Clean up whitespace
        #
        $dbkey = preg_replace('/[ _]+/', '_', $dbkey);
        $dbkey = trim($dbkey, '_');

        if ('' == $dbkey) {
            return false;
        }

        if (false !== strpos($dbkey, UTF8_REPLACEMENT)) {
            # Contained illegal UTF-8 sequences or forbidden Unicode chars.
            return false;
        }

        $this->mDbkeyform = $dbkey;

        # Initial colon indicates main namespace rather than specified default
        # but should not create invalid {ns,title} pairs such as {0,Project:Foo}
        if (':' == $dbkey[0]) {
            $this->mNamespace = NS_MAIN;
            $dbkey = substr($dbkey, 1); # remove the colon but continue processing
            $dbkey = trim($dbkey, '_'); # remove any subsequent whitespace
        }

        # Namespace or interwiki prefix
        $firstPass = true;
        do {
            $m = array();
            if (preg_match("/^(.+?)_*:_*(.*)$/S", $dbkey, $m)) {
                $p = $m[1];
                if ($ns = $wgContLang->getNsIndex($p)) {
                    # Ordinary namespace
                    $dbkey = $m[2];
                    $this->mNamespace = $ns;
                } elseif ($this->getInterwikiLink($p)) {
                    if (!$firstPass) {
                        # Can't make a local interwiki link to an interwiki link.
                        # That's just crazy!
                        return false;
                    }

                    # Interwiki link
                    $dbkey = $m[2];
                    $this->mInterwiki = $wgContLang->lc($p);

                    # Redundant interwiki prefix to the local wiki
                    if (0 == strcasecmp($this->mInterwiki, $wgLocalInterwiki)) {
                        if ($dbkey == '') {
                            # Can't have an empty self-link
                            return false;
                        }
                        $this->mInterwiki = '';
                        $firstPass = false;
                        # Do another namespace split...
                        continue;
                    }

                    # If there's an initial colon after the interwiki, that also
                    # resets the default namespace
                    if ($dbkey !== '' && $dbkey[0] == ':') {
                        $this->mNamespace = NS_MAIN;
                        $dbkey = substr($dbkey, 1);
                    }
                }
                # If there's no recognized interwiki or namespace,
                # then let the colon expression be part of the title.
            }
            break;
        } while (true);

        # We already know that some pages won't be in the database!
        #
        if ('' != $this->mInterwiki || NS_SPECIAL == $this->mNamespace) {
            $this->mArticleID = 0;
        }
        $fragment = strstr($dbkey, '#');
        if (false !== $fragment) {
            $this->setFragment($fragment);
            $dbkey = substr($dbkey, 0, strlen($dbkey) - strlen($fragment));
            # remove whitespace again: prevents "Foo_bar_#"
            # becoming "Foo_bar_"
            $dbkey = preg_replace('/_*$/', '', $dbkey);
        }

        # Reject illegal characters.
        #
        if (preg_match($rxTc, $dbkey)) {
            return false;
        }

        if (strpos($dbkey, '.') !== false &&
             ($dbkey === '.' || $dbkey === '..' ||
               strpos($dbkey, './') === 0 ||
               strpos($dbkey, '../') === 0 ||
               strpos($dbkey, '/./') !== false ||
               strpos($dbkey, '/../') !== false)) {
            return false;
        }

        if (strpos($dbkey, '~~~') !== false) {
            return false;
        }

        if (($this->mNamespace != NS_SPECIAL && strlen($dbkey) > 255) ||
          strlen($dbkey) > 512) {
            return false;
        }

        if ($wgCapitalLinks && $this->mInterwiki == '') {
            $dbkey = $wgContLang->ucfirst($dbkey);
        }

        if ($dbkey == '' &&
            $this->mInterwiki == '' &&
            $this->mNamespace != NS_MAIN) {
            return false;
        }

        // Any remaining initial :s are illegal.
        if ($dbkey !== '' && ':' == $dbkey[0]) {
            return false;
        }

        # Fill fields
        $this->mDbkeyform = $dbkey;
        $this->mUrlform = ilWikiUtil::wfUrlencode($dbkey);

        $this->mTextform = str_replace('_', ' ', $dbkey);

        return true;
    }

    public function setFragment($fragment)
    {
        $this->mFragment = str_replace('_', ' ', substr($fragment, 1));
    }

    public function equals($title)
    {
        // Note: === is necessary for proper matching of number-like titles.
        return $this->getInterwiki() === $title->getInterwiki()
            && $this->getNamespace() == $title->getNamespace()
            && $this->getDBkey() === $title->getDBkey();
    }
}