X-Git-Url: https://scripts.mit.edu/gitweb/autoinstalls/mediawiki.git/blobdiff_plain/74c929b24b048c9f1e31e17db757ae4195cd7673..19e297c21b10b1b8a3acad5e73fc71dcb35db44a:/includes/User.php

diff --git a/includes/User.php b/includes/User.php
index 9fee089c..c0de2023 100644
--- a/includes/User.php
+++ b/includes/User.php
@@ -14,7 +14,7 @@ define( 'USER_TOKEN_LENGTH', 32 );
  * \int Serialized record version.
  * @ingroup Constants
  */
-define( 'MW_USER_VERSION', 6 );
+define( 'MW_USER_VERSION', 8 );
 
 /**
  * \string Some punctuation to prevent editing from broken text-mangling proxies.
@@ -41,62 +41,17 @@ class PasswordError extends MWException {
  * of the database.
  */
 class User {
-
 	/**
-	 * \type{\arrayof{\string}} A list of default user toggles, i.e., boolean user 
-         * preferences that are displayed by Special:Preferences as checkboxes.
-	 * This list can be extended via the UserToggles hook or by
-	 * $wgContLang::getExtraUserToggles().
-	 * @showinitializer
+	 * Global constants made accessible as class constants so that autoloader
+	 * magic can be used.
 	 */
-	public static $mToggles = array(
-		'highlightbroken',
-		'justify',
-		'hideminor',
-		'extendwatchlist',
-		'usenewrc',
-		'numberheadings',
-		'showtoolbar',
-		'editondblclick',
-		'editsection',
-		'editsectiononrightclick',
-		'showtoc',
-		'rememberpassword',
-		'editwidth',
-		'watchcreations',
-		'watchdefault',
-		'watchmoves',
-		'watchdeletion',
-		'minordefault',
-		'previewontop',
-		'previewonfirst',
-		'nocache',
-		'enotifwatchlistpages',
-		'enotifusertalkpages',
-		'enotifminoredits',
-		'enotifrevealaddr',
-		'shownumberswatching',
-		'fancysig',
-		'externaleditor',
-		'externaldiff',
-		'showjumplinks',
-		'uselivepreview',
-		'forceeditsummary',
-		'watchlisthideminor',
-		'watchlisthidebots',
-		'watchlisthideown',
-		'watchlisthideanons',
-		'watchlisthideliu',
-		'ccmeonemails',
-		'diffonly',
-		'showhiddencats',
-		'noconvertlink',
-		'norollbackdiff',
-	);
+	const USER_TOKEN_LENGTH = USER_TOKEN_LENGTH;
+	const MW_USER_VERSION = MW_USER_VERSION;
+	const EDIT_TOKEN_SUFFIX = EDIT_TOKEN_SUFFIX;
 
 	/**
-	 * \type{\arrayof{\string}} List of member variables which are saved to the 
-	 * shared cache (memcached). Any operation which changes the 
+	 * \type{\arrayof{\string}} List of member variables which are saved to the
+	 * shared cache (memcached). Any operation which changes the
 	 * corresponding database fields must call a cache-clearing function.
 	 * @showinitializer
 	 */
@@ -109,7 +64,6 @@ class User {
 		'mNewpassword',
 		'mNewpassTime',
 		'mEmail',
-		'mOptions',
 		'mTouched',
 		'mToken',
 		'mEmailAuthenticated',
@@ -119,11 +73,13 @@ class User {
 		'mEditCount',
 		// user_group table
 		'mGroups',
+		// user_properties table
+		'mOptionOverrides',
 	);
 
 	/**
 	 * \type{\arrayof{\string}} Core rights.
-	 * Each of these should have a corresponding message of the form 
+	 * Each of these should have a corresponding message of the form
 	 * "right-$right".
 	 * @showinitializer
 	 */
@@ -141,13 +97,19 @@ class User {
 		'createtalk',
 		'delete',
 		'deletedhistory',
+		'deletedtext',
+		'deleterevision',
 		'edit',
 		'editinterface',
-		'editusercssjs',
+		'editusercssjs', #deprecated
+		'editusercss',
+		'edituserjs',
+		'hideuser',
 		'import',
 		'importupload',
 		'ipblock-exempt',
 		'markbotedits',
+		'mergehistory',
 		'minoredit',
 		'move',
 		'movefile',
@@ -155,6 +117,7 @@ class User {
 		'move-subpages',
 		'nominornewtalk',
 		'noratelimit',
+		'override-export-depth',
 		'patrol',
 		'protect',
 		'proxyunbannable',
@@ -163,14 +126,21 @@ class User {
 		'reupload',
 		'reupload-shared',
 		'rollback',
+		'selenium',
+		'sendemail',
 		'siteadmin',
+		'suppressionlog',
 		'suppressredirect',
+		'suppressrevision',
 		'trackback',
+		'unblockself',
 		'undelete',
 		'unwatchedpages',
 		'upload',
 		'upload_by_url',
 		'userrights',
+		'userrights-interwiki',
+		'writeapi',
 	);
 	/**
 	 * \string Cached results of getAllRights()
@@ -180,14 +150,14 @@ class User {
 	/** @name Cache variables */
 	//@{
 	var $mId, $mName, $mRealName, $mPassword, $mNewpassword, $mNewpassTime,
-		$mEmail, $mOptions, $mTouched, $mToken, $mEmailAuthenticated,
-		$mEmailToken, $mEmailTokenExpires, $mRegistration, $mGroups;
+		$mEmail, $mTouched, $mToken, $mEmailAuthenticated,
+		$mEmailToken, $mEmailTokenExpires, $mRegistration, $mGroups, $mOptionOverrides;
 	//@}
 
 	/**
 	 * \bool Whether the cache variables have been loaded.
 	 */
-	var $mDataLoaded, $mAuthLoaded;
+	var $mDataLoaded, $mAuthLoaded, $mOptionsLoaded;
 
 	/**
 	 * \string Initialization data source if mDataLoaded==false. May be one of:
@@ -203,21 +173,23 @@ class User {
 	/** @name Lazy-initialized variables, invalidated with clearInstanceCache */
 	//@{
 	var $mNewtalk, $mDatePreference, $mBlockedby, $mHash, $mSkin, $mRights,
-		$mBlockreason, $mBlock, $mEffectiveGroups, $mBlockedGlobally, 
-		$mLocked, $mHideName;
+		$mBlockreason, $mBlock, $mEffectiveGroups, $mBlockedGlobally,
+		$mLocked, $mHideName, $mOptions;
 	//@}
 
+	static $idCacheByName = array();
+
 	/**
 	 * Lightweight constructor for an anonymous user.
 	 * Use the User::newFrom* factory functions for other kinds of users.
-	 * 
+	 *
 	 * @see newFromName()
 	 * @see newFromId()
 	 * @see newFromConfirmationCode()
 	 * @see newFromSession()
 	 * @see newFromRow()
 	 */
-	function User() {
+	function __construct() {
 		$this->clearInstanceCache( 'defaults' );
 	}
 
@@ -280,7 +252,7 @@ class User {
 		}
 
 		if ( !$data ) {
-			wfDebug( "Cache miss for user {$this->mId}\n" );
+			wfDebug( "User: cache miss for user {$this->mId}\n" );
 			# Load from DB
 			if ( !$this->loadFromDatabase() ) {
 				# Can't load from ID, user is anonymous
@@ -288,7 +260,7 @@ class User {
 			}
 			$this->saveToCache();
 		} else {
-			wfDebug( "Got user {$this->mId} from cache\n" );
+			wfDebug( "User: got user {$this->mId} from cache\n" );
 			# Restore from cache
 			foreach ( self::$mCacheVars as $name ) {
 				$this->$name = $data[$name];
@@ -303,6 +275,7 @@ class User {
 	function saveToCache() {
 		$this->load();
 		$this->loadGroups();
+		$this->loadOptions();
 		if ( $this->isAnon() ) {
 			// Anonymous users are uncached
 			return;
@@ -316,8 +289,8 @@ class User {
 		global $wgMemc;
 		$wgMemc->set( $key, $data );
 	}
-	
-	
+
+
 	/** @name newFrom*() static factory methods */
 	//@{
 
@@ -332,8 +305,9 @@ class User {
 	 *    User::getCanonicalName(), except that true is accepted as an alias
 	 *    for 'valid', for BC.
 	 *
-	 * @return \type{User} The User object, or null if the username is invalid. If the 
-	 *    username is not present in the database, the result will be a user object 
+	 * @return User The User object, or false if the username is invalid
+	 *    (e.g. if it contains illegal characters or is an IP address). If the
+	 *    username is not present in the database, the result will be a user object
 	 *    with a name, zero user ID and default settings.
 	 */
 	static function newFromName( $name, $validate = 'valid' ) {
@@ -342,7 +316,7 @@ class User {
 		}
 		$name = self::getCanonicalName( $name, $validate );
 		if ( $name === false ) {
-			return null;
+			return false;
 		} else {
 			# Create unloaded user object
 			$u = new User;
@@ -411,9 +385,9 @@ class User {
 		$user->loadFromRow( $row );
 		return $user;
 	}
-	
+
 	//@}
-	
+
 
 	/**
 	 * Get the username corresponding to a given user ID
@@ -422,7 +396,7 @@ class User {
 	 */
 	static function whoIs( $id ) {
 		$dbr = wfGetDB( DB_SLAVE );
-		return $dbr->selectField( 'user', 'user_name', array( 'user_id' => $id ), 'User::whoIs' );
+		return $dbr->selectField( 'user', 'user_name', array( 'user_id' => $id ), __METHOD__ );
 	}
 
 	/**
@@ -447,14 +421,27 @@ class User {
 			# Illegal name
 			return null;
 		}
+
+		if ( isset( self::$idCacheByName[$name] ) ) {
+			return self::$idCacheByName[$name];
+		}
+
 		$dbr = wfGetDB( DB_SLAVE );
 		$s = $dbr->selectRow( 'user', array( 'user_id' ), array( 'user_name' => $nt->getText() ), __METHOD__ );
 
 		if ( $s === false ) {
-			return 0;
+			$result = null;
 		} else {
-			return $s->user_id;
+			$result = $s->user_id;
+		}
+
+		self::$idCacheByName[$name] = $result;
+
+		if ( count( self::$idCacheByName ) > 1000 ) {
+			self::$idCacheByName = array();
 		}
+
+		return $result;
 	}
 
 	/**
@@ -573,52 +560,112 @@ class User {
 	 * either by batch processes or by user accounts which have
 	 * already been created.
 	 *
-	 * Additional character blacklisting may be added here
-	 * rather than in isValidUserName() to avoid disrupting
-	 * existing accounts.
+	 * Additional blacklisting may be added here rather than in
+	 * isValidUserName() to avoid disrupting existing accounts.
 	 *
 	 * @param $name \string String to match
 	 * @return \bool True or false
 	 */
 	static function isCreatableName( $name ) {
-		return
-			self::isUsableName( $name ) &&
+		global $wgInvalidUsernameCharacters;
+
+		// Ensure that the username isn't longer than 235 bytes, so that
+		// (at least for the builtin skins) user javascript and css files
+		// will work. (bug 23080)
+		if( strlen( $name ) > 235 ) {
+			wfDebugLog( 'username', __METHOD__ .
+				": '$name' invalid due to length" );
+			return false;
+		}
 
-			// Registration-time character blacklisting...
-			strpos( $name, '@' ) === false;
+		// Preg yells if you try to give it an empty string
+		if( $wgInvalidUsernameCharacters ) {
+			if( preg_match( '/[' . preg_quote( $wgInvalidUsernameCharacters, '/' ) . ']/', $name ) ) {
+				wfDebugLog( 'username', __METHOD__ .
+					": '$name' invalid due to wgInvalidUsernameCharacters" );
+				return false;
+			}
+		}
+
+		return self::isUsableName( $name );
 	}
 
 	/**
 	 * Is the input a valid password for this user?
 	 *
-	 * @param $password \string Desired password
-	 * @return \bool True or false
+	 * @param $password String Desired password
+	 * @return bool True or false
 	 */
 	function isValidPassword( $password ) {
+		//simple boolean wrapper for getPasswordValidity
+		return $this->getPasswordValidity( $password ) === true;
+	}
+
+	/**
+	 * Given unvalidated password input, return error message on failure.
+	 *
+	 * @param $password String Desired password
+	 * @return mixed: true on success, string of error message on failure
+	 */
+	function getPasswordValidity( $password ) {
 		global $wgMinimalPasswordLength, $wgContLang;
+		
+		static $blockedLogins = array(
+			'Useruser' => 'Passpass', 'Useruser1' => 'Passpass1', # r75589
+			'Apitestsysop' => 'testpass', 'Apitestuser' => 'testpass' # r75605
+		);
+
+		$result = false; //init $result to false for the internal checks
 
-		$result = null;
 		if( !wfRunHooks( 'isValidPassword', array( $password, &$result, $this ) ) )
 			return $result;
-		if( $result === false )
-			return false;
 
-		// Password needs to be long enough, and can't be the same as the username
-		return strlen( $password ) >= $wgMinimalPasswordLength
-			&& $wgContLang->lc( $password ) !== $wgContLang->lc( $this->mName );
+		if ( $result === false ) {
+			if( strlen( $password ) < $wgMinimalPasswordLength ) {
+				return 'passwordtooshort';
+			} elseif ( $wgContLang->lc( $password ) == $wgContLang->lc( $this->mName ) ) {
+				return 'password-name-match';
+			} elseif ( isset( $blockedLogins[ $this->getName() ] ) && $password == $blockedLogins[ $this->getName() ] ) {
+				return 'password-login-forbidden';
+			} else {
+				//it seems weird returning true here, but this is because of the
+				//initialization of $result to false above. If the hook is never run or it
+				//doesn't modify $result, then we will likely get down into this if with
+				//a valid password.
+				return true;
+			}
+		} elseif( $result === true ) {
+			return true;
+		} else {
+			return $result; //the isValidPassword hook set a string $result and returned true
+		}
 	}
 
 	/**
 	 * Does a string look like an e-mail address?
 	 *
-	 * There used to be a regular expression here, it got removed because it
-	 * rejected valid addresses. Actually just check if there is '@' somewhere
-	 * in the given address.
+	 * This validates an email address using an HTML5 specification found at:
+	 * http://www.whatwg.org/specs/web-apps/current-work/multipage/states-of-the-type-attribute.html#valid-e-mail-address
+	 * Which as of 2011-01-24 says:
 	 *
-	 * @todo Check for RFC 2822 compilance (bug 959)
+	 *     A valid e-mail address is a string that matches the ABNF production
+	 *   1*( atext / "." ) "@" ldh-str *( "." ldh-str ) where atext is defined
+	 *   in RFC 5322 section 3.2.3, and ldh-str is defined in RFC 1034 section
+	 *   3.5.
 	 *
-	 * @param $addr \string E-mail address
-	 * @return \bool True or false
+	 * This function is an implementation of the specification as requested in
+	 * bug 22449.
+	 *
+	 * Client-side forms will use the same standard validation rules via JS or
+	 * HTML 5 validation; additional restrictions can be enforced server-side
+	 * by extensions via the 'isValidEmailAddr' hook.
+	 *
+	 * Note that this validation doesn't 100% match RFC 2822, but is believed
+	 * to be liberal enough for wide use. Some invalid addresses will still
+	 * pass validation here.
+	 *
+	 * @param $addr String E-mail address
+	 * @return Bool
 	 */
 	public static function isValidEmailAddr( $addr ) {
 		$result = null;
@@ -626,7 +673,22 @@ class User {
 			return $result;
 		}
 
-		return strpos( $addr, '@' ) !== false;
+		// Please note strings below are enclosed in brackets [], this make the
+		// hyphen "-" a range indicator. Hence it is double backslashed below.
+		// See bug 26948
+		$rfc5322_atext   = "a-z0-9!#$%&'*+\\-\/=?^_`{|}~" ;
+		$rfc1034_ldh_str = "a-z0-9\\-" ;
+
+		$HTML5_email_regexp = "/
+		^                      # start of string
+		[$rfc5322_atext\\.]+    # user part which is liberal :p
+		@                      # 'apostrophe'
+		[$rfc1034_ldh_str]+       # First domain part
+		(\\.[$rfc1034_ldh_str]+)*  # Following part prefixed with a dot
+		$                      # End of string
+		/ix" ; // case Insensitive, eXtended
+
+		return (bool) preg_match( $HTML5_email_regexp, $addr );
 	}
 
 	/**
@@ -651,7 +713,7 @@ class User {
 			return false;
 
 		# Clean up name according to title rules
-		$t = ($validate === 'valid') ? 
+		$t = ( $validate === 'valid' ) ?
 			Title::newFromText( $name ) : Title::makeTitle( NS_USER, $name );
 		# Check for invalid titles
 		if( is_null( $t ) ) {
@@ -659,7 +721,6 @@ class User {
 		}
 
 		# Reject various classes of invalid names
-		$name = $t->getText();
 		global $wgAuth;
 		$name = $wgAuth->getCanonicalName( $t->getText() );
 
@@ -682,7 +743,7 @@ class User {
 				}
 				break;
 			default:
-				throw new MWException( 'Invalid parameter value for $validate in '.__METHOD__ );
+				throw new MWException( 'Invalid parameter value for $validate in ' . __METHOD__ );
 		}
 		return $name;
 	}
@@ -725,36 +786,33 @@ class User {
 	}
 
 	/**
-	 * Return a random password. Sourced from mt_rand, so it's not particularly secure.
-	 * @todo hash random numbers to improve security, like generateToken()
+	 * Return a random password.
 	 *
 	 * @return \string New random password
 	 */
 	static function randomPassword() {
-		global $wgMinimalPasswordLength;
-		$pwchars = 'ABCDEFGHJKLMNPQRSTUVWXYZabcdefghjkmnpqrstuvwxyz';
-		$l = strlen( $pwchars ) - 1;
-
-		$pwlength = max( 7, $wgMinimalPasswordLength );
-		$digit = mt_rand(0, $pwlength - 1);
-		$np = '';
-		for ( $i = 0; $i < $pwlength; $i++ ) {
-			$np .= $i == $digit ? chr( mt_rand(48, 57) ) : $pwchars{ mt_rand(0, $l)};
-		}
-		return $np;
+  		global $wgMinimalPasswordLength;
+ 		// Decide the final password length based on our min password length, stopping at a minimum of 10 chars
+ 		$length = max( 10, $wgMinimalPasswordLength );
+ 		// Multiply by 1.25 to get the number of hex characters we need
+ 		$length = $length * 1.25;
+ 		// Generate random hex chars
+ 		$hex = MWCryptRand::generateHex( $length );
+ 		// Convert from base 16 to base 32 to get a proper password like string
+ 		return wfBaseConvert( $hex, 16, 32 );
 	}
 
 	/**
-	 * Set cached properties to default. 
+	 * Set cached properties to default.
 	 *
-	 * @note This no longer clears uncached lazy-initialised properties; 
+	 * @note This no longer clears uncached lazy-initialised properties;
 	 *       the constructor does that instead.
 	 * @private
 	 */
 	function loadDefaults( $name = false ) {
 		wfProfileIn( __METHOD__ );
 
-		global $wgCookiePrefix;
+		global $wgRequest;
 
 		$this->mId = 0;
 		$this->mName = $name;
@@ -762,15 +820,16 @@ class User {
 		$this->mPassword = $this->mNewpassword = '';
 		$this->mNewpassTime = null;
 		$this->mEmail = '';
-		$this->mOptions = null; # Defer init
+		$this->mOptionOverrides = null;
+		$this->mOptionsLoaded = false;
 
-		if ( isset( $_COOKIE[$wgCookiePrefix.'LoggedOut'] ) ) {
-			$this->mTouched = wfTimestamp( TS_MW, $_COOKIE[$wgCookiePrefix.'LoggedOut'] );
+		if( $wgRequest->getCookie( 'LoggedOut' ) !== null ) {
+			$this->mTouched = wfTimestamp( TS_MW, $wgRequest->getCookie( 'LoggedOut' ) );
 		} else {
 			$this->mTouched = '0'; # Allow any pages to be cached
 		}
 
-		$this->setToken(); # Random
+		$this->mToken = null; // Don't run cryptographic functions till we need a token
 		$this->mEmailAuthenticated = null;
 		$this->mEmailToken = '';
 		$this->mEmailTokenExpires = null;
@@ -796,7 +855,7 @@ class User {
 	 * @return \bool True if the user is logged in, false otherwise.
 	 */
 	private function loadFromSession() {
-		global $wgMemc, $wgCookiePrefix;
+		global $wgRequest, $wgExternalAuthType, $wgAutocreatePolicy;
 
 		$result = null;
 		wfRunHooks( 'UserLoadFromSession', array( $this, &$result ) );
@@ -804,11 +863,19 @@ class User {
 			return $result;
 		}
 
-		if ( isset( $_COOKIE["{$wgCookiePrefix}UserID"] ) ) {
-			$sId = intval( $_COOKIE["{$wgCookiePrefix}UserID"] );
+		if ( $wgExternalAuthType && $wgAutocreatePolicy == 'view' ) {
+			$extUser = ExternalUser::newFromCookie();
+			if ( $extUser ) {
+				# TODO: Automatically create the user here (or probably a bit
+				# lower down, in fact)
+			}
+		}
+
+		if ( $wgRequest->getCookie( 'UserID' ) !== null ) {
+			$sId = intval( $wgRequest->getCookie( 'UserID' ) );
 			if( isset( $_SESSION['wsUserID'] ) && $sId != $_SESSION['wsUserID'] ) {
 				$this->loadDefaults(); // Possible collision!
-				wfDebugLog( 'loginSessions', "Session user ID ({$_SESSION['wsUserID']}) and 
+				wfDebugLog( 'loginSessions', "Session user ID ({$_SESSION['wsUserID']}) and
 					cookie user ID ($sId) don't match!" );
 				return false;
 			}
@@ -827,26 +894,33 @@ class User {
 
 		if ( isset( $_SESSION['wsUserName'] ) ) {
 			$sName = $_SESSION['wsUserName'];
-		} else if ( isset( $_COOKIE["{$wgCookiePrefix}UserName"] ) ) {
-			$sName = $_COOKIE["{$wgCookiePrefix}UserName"];
+		} else if ( $wgRequest->getCookie('UserName') !== null ) {
+			$sName = $wgRequest->getCookie('UserName');
 			$_SESSION['wsUserName'] = $sName;
 		} else {
 			$this->loadDefaults();
 			return false;
 		}
 
-		$passwordCorrect = FALSE;
-		$this->mId = $sId;
-		if ( !$this->loadFromId() ) {
-			# Not a valid ID, loadFromId has switched the object to anon for us
+		$proposedUser = User::newFromId( $sId );
+		if ( !$proposedUser->isLoggedIn() ) {
+			# Not a valid ID
+			$this->loadDefaults();
 			return false;
 		}
 
-		if ( isset( $_SESSION['wsToken'] ) ) {
-			$passwordCorrect = $_SESSION['wsToken'] == $this->mToken;
+		global $wgBlockDisablesLogin;
+		if( $wgBlockDisablesLogin && $proposedUser->isBlocked() ) {
+			# User blocked and we've disabled blocked user logins
+			$this->loadDefaults();
+			return false;
+		}
+
+		if ( isset( $_SESSION['wsToken'] ) && $_SESSION['wsToken'] ) {
+			$passwordCorrect = $proposedUser->getToken( false ) === $_SESSION['wsToken'];
 			$from = 'session';
-		} else if ( isset( $_COOKIE["{$wgCookiePrefix}Token"] ) ) {
-			$passwordCorrect = $this->mToken == $_COOKIE["{$wgCookiePrefix}Token"];
+		} elseif ( $wgRequest->getCookie( 'Token' ) ) {
+			$passwordCorrect = $proposedUser->getToken( false ) === $wgRequest->getCookie( 'Token' );
 			$from = 'cookie';
 		} else {
 			# No session or persistent login cookie
@@ -854,18 +928,31 @@ class User {
 			return false;
 		}
 
-		if ( ( $sName == $this->mName ) && $passwordCorrect ) {
+		if ( ( $sName === $proposedUser->getName() ) && $passwordCorrect ) {
+			$this->loadFromUserObject( $proposedUser );
 			$_SESSION['wsToken'] = $this->mToken;
-			wfDebug( "Logged in from $from\n" );
+			wfDebug( "User: logged in from $from\n" );
 			return true;
 		} else {
 			# Invalid credentials
-			wfDebug( "Can't log in from $from, invalid credentials\n" );
+			wfDebug( "User: can't log in from $from, invalid credentials\n" );
 			$this->loadDefaults();
 			return false;
 		}
 	}
 
+	/**
+	 * Load the data for this user object from another user object. 
+	 */
+	protected function loadFromUserObject( $user ) {
+		$user->load();
+		$user->loadGroups();
+		$user->loadOptions();
+		foreach ( self::$mCacheVars as $var ) {
+			$this->$var = $user->$var;
+		}
+	}
+
 	/**
 	 * Load user and user_group data from the database.
 	 * $this::mId must be set, this is how the user is identified.
@@ -886,6 +973,8 @@ class User {
 		$dbr = wfGetDB( DB_MASTER );
 		$s = $dbr->selectRow( 'user', '*', array( 'user_id' => $this->mId ), __METHOD__ );
 
+		wfRunHooks( 'UserLoadFromDatabase', array( $this, &$s ) );
+
 		if ( $s !== false ) {
 			# Initialise user table data
 			$this->loadFromRow( $s );
@@ -909,7 +998,7 @@ class User {
 		$this->mDataLoaded = true;
 
 		if ( isset( $row->user_id ) ) {
-			$this->mId = $row->user_id;
+			$this->mId = intval( $row->user_id );
 		}
 		$this->mName = $row->user_name;
 		$this->mRealName = $row->user_real_name;
@@ -920,11 +1009,14 @@ class User {
 		$this->decodeOptions( $row->user_options );
 		$this->mTouched = wfTimestamp(TS_MW,$row->user_touched);
 		$this->mToken = $row->user_token;
+		if ( $this->mToken == '' ) {
+			$this->mToken = null;
+		}
 		$this->mEmailAuthenticated = wfTimestampOrNull( TS_MW, $row->user_email_authenticated );
 		$this->mEmailToken = $row->user_email_token;
 		$this->mEmailTokenExpires = wfTimestampOrNull( TS_MW, $row->user_email_token_expires );
 		$this->mRegistration = wfTimestampOrNull( TS_MW, $row->user_registration );
-		$this->mEditCount = $row->user_editcount; 
+		$this->mEditCount = $row->user_editcount;
 	}
 
 	/**
@@ -939,7 +1031,7 @@ class User {
 				array( 'ug_user' => $this->mId ),
 				__METHOD__ );
 			$this->mGroups = array();
-			while( $row = $dbr->fetchObject( $res ) ) {
+			foreach ( $res as $row ) {
 				$this->mGroups[] = $row->ug_group;
 			}
 		}
@@ -959,6 +1051,7 @@ class User {
 		$this->mSkin = null;
 		$this->mRights = null;
 		$this->mEffectiveGroups = null;
+		$this->mOptions = null;
 
 		if ( $reloadFrom ) {
 			$this->mDataLoaded = false;
@@ -977,19 +1070,20 @@ class User {
 		/**
 		 * Site defaults will override the global/language defaults
 		 */
-		global $wgDefaultUserOptions, $wgContLang;
+		global $wgDefaultUserOptions, $wgContLang, $wgDefaultSkin;
 		$defOpt = $wgDefaultUserOptions + $wgContLang->getDefaultUserOptionOverrides();
 
 		/**
 		 * default language setting
 		 */
-		$variant = $wgContLang->getPreferredVariant( false );
+		$variant = $wgContLang->getDefaultVariant();
 		$defOpt['variant'] = $variant;
 		$defOpt['language'] = $variant;
-
-		foreach( $wgNamespacesToBeSearchedDefault as $nsnum => $val ) {
-			$defOpt['searchNs'.$nsnum] = $val;
+		foreach( SearchEngine::searchableNamespaces() as $nsnum => $nsname ) {
+			$defOpt['searchNs'.$nsnum] = !empty( $wgNamespacesToBeSearchedDefault[$nsnum] );
 		}
+		$defOpt['skin'] = $wgDefaultSkin;
+
 		return $defOpt;
 	}
 
@@ -1004,21 +1098,10 @@ class User {
 		if( isset( $defOpts[$opt] ) ) {
 			return $defOpts[$opt];
 		} else {
-			return '';
+			return null;
 		}
 	}
 
-	/**
-	 * Get a list of user toggle names
-	 * @return \type{\arrayof{\string}} Array of user toggle names
-	 */
-	static function getToggles() {
-		global $wgContLang;
-		$extraToggles = array();
-		wfRunHooks( 'UserToggles', array( &$extraToggles ) );
-		return array_merge( self::$mToggles, $extraToggles, $wgContLang->getExtraUserToggles() );
-	}
-
 
 	/**
 	 * Get blocking information
@@ -1029,7 +1112,7 @@ class User {
 	 *                    done against master.
 	 */
 	function getBlockedStatus( $bFromSlave = true ) {
-		global $wgEnableSorbs, $wgProxyWhitelist;
+		global $wgProxyWhitelist, $wgUser;
 
 		if ( -1 != $this->mBlockedby ) {
 			wfDebug( "User::getBlockedStatus: already loaded.\n" );
@@ -1045,13 +1128,27 @@ class User {
 		// due to -1 !== 0. Probably session-related... Nothing should be
 		// overwriting mBlockedby, surely?
 		$this->load();
-		
+
 		$this->mBlockedby = 0;
 		$this->mHideName = 0;
 		$this->mAllowUsertalk = 0;
-		$ip = wfGetIP();
 
-		if ($this->isAllowed( 'ipblock-exempt' ) ) {
+		# Check if we are looking at an IP or a logged-in user
+		if ( $this->isIP( $this->getName() ) ) {
+			$ip = $this->getName();
+		} else {
+			# Check if we are looking at the current user
+			# If we don't, and the user is logged in, we don't know about
+			# his IP / autoblock status, so ignore autoblock of current user's IP
+			if ( $this->getID() != $wgUser->getID() ) {
+				$ip = '';
+			} else {
+				# Get IP of current user
+				$ip = wfGetIP();
+			}
+		}
+
+		if ( $this->isAllowed( 'ipblock-exempt' ) ) {
 			# Exempt from all types of IP-block
 			$ip = '';
 		}
@@ -1060,22 +1157,24 @@ class User {
 		$this->mBlock = new Block();
 		$this->mBlock->fromMaster( !$bFromSlave );
 		if ( $this->mBlock->load( $ip , $this->mId ) ) {
-			wfDebug( __METHOD__.": Found block.\n" );
+			wfDebug( __METHOD__ . ": Found block.\n" );
 			$this->mBlockedby = $this->mBlock->mBy;
+			if( $this->mBlockedby == 0 )
+				$this->mBlockedby = $this->mBlock->mByName;
 			$this->mBlockreason = $this->mBlock->mReason;
 			$this->mHideName = $this->mBlock->mHideName;
 			$this->mAllowUsertalk = $this->mBlock->mAllowUsertalk;
-			if ( $this->isLoggedIn() ) {
+			if ( $this->isLoggedIn() && $wgUser->getID() == $this->getID() ) {
 				$this->spreadBlock();
 			}
 		} else {
-			// Bug 13611: don't remove mBlock here, to allow account creation blocks to 
-			// apply to users. Note that the existence of $this->mBlock is not used to 
+			// Bug 13611: don't remove mBlock here, to allow account creation blocks to
+			// apply to users. Note that the existence of $this->mBlock is not used to
 			// check for edit blocks, $this->mBlockedby is instead.
 		}
 
 		# Proxy blocking
-		if ( !$this->isAllowed('proxyunbannable') && !in_array( $ip, $wgProxyWhitelist ) ) {
+		if ( !$this->isAllowed( 'proxyunbannable' ) && !in_array( $ip, $wgProxyWhitelist ) ) {
 			# Local list
 			if ( wfIsLocallyBlockedProxy( $ip ) ) {
 				$this->mBlockedby = wfMsg( 'proxyblocker' );
@@ -1083,8 +1182,8 @@ class User {
 			}
 
 			# DNSBL
-			if ( !$this->mBlockedby && $wgEnableSorbs && !$this->getID() ) {
-				if ( $this->inSorbsBlacklist( $ip ) ) {
+			if ( !$this->mBlockedby && !$this->getID() ) {
+				if ( $this->isDnsBlacklisted( $ip ) ) {
 					$this->mBlockedby = wfMsg( 'sorbs' );
 					$this->mBlockreason = wfMsg( 'sorbsreason' );
 				}
@@ -1098,43 +1197,56 @@ class User {
 	}
 
 	/**
-	 * Whether the given IP is in the SORBS blacklist.
+	 * Whether the given IP is in a DNS blacklist.
 	 *
 	 * @param $ip \string IP to check
+	 * @param $checkWhitelist Boolean: whether to check the whitelist first
 	 * @return \bool True if blacklisted.
 	 */
-	function inSorbsBlacklist( $ip ) {
-		global $wgEnableSorbs, $wgSorbsUrl;
+	function isDnsBlacklisted( $ip, $checkWhitelist = false ) {
+		global $wgEnableSorbs, $wgEnableDnsBlacklist,
+			$wgSorbsUrl, $wgDnsBlacklistUrls, $wgProxyWhitelist;
 
-		return $wgEnableSorbs &&
-			$this->inDnsBlacklist( $ip, $wgSorbsUrl );
+		if ( !$wgEnableDnsBlacklist && !$wgEnableSorbs )
+			return false;
+
+		if ( $checkWhitelist && in_array( $ip, $wgProxyWhitelist ) )
+			return false;
+
+		$urls = array_merge( $wgDnsBlacklistUrls, (array)$wgSorbsUrl );
+		return $this->inDnsBlacklist( $ip, $urls );
 	}
 
 	/**
 	 * Whether the given IP is in a given DNS blacklist.
 	 *
 	 * @param $ip \string IP to check
-	 * @param $base \string URL of the DNS blacklist
+	 * @param $bases \string or Array of Strings: URL of the DNS blacklist
 	 * @return \bool True if blacklisted.
 	 */
-	function inDnsBlacklist( $ip, $base ) {
+	function inDnsBlacklist( $ip, $bases ) {
 		wfProfileIn( __METHOD__ );
 
 		$found = false;
-		$host = '';
 		// FIXME: IPv6 ???  (http://bugs.php.net/bug.php?id=33170)
-		if( IP::isIPv4($ip) ) {
-			# Make hostname
-			$host = "$ip.$base";
+		if( IP::isIPv4( $ip ) ) {
+			# Reverse IP, bug 21255
+			$ipReversed = implode( '.', array_reverse( explode( '.', $ip ) ) );
 
-			# Send query
-			$ipList = gethostbynamel( $host );
+			foreach( (array)$bases as $base ) {
+				# Make hostname
+				$host = "$ipReversed.$base";
 
-			if( $ipList ) {
-				wfDebug( "Hostname $host is {$ipList[0]}, it's a proxy says $base!\n" );
-				$found = true;
-			} else {
-				wfDebug( "Requested $host, not found in $base.\n" );
+				# Send query
+				$ipList = gethostbynamel( $host );
+
+				if( $ipList ) {
+					wfDebug( "Hostname $host is {$ipList[0]}, it's a proxy says $base!\n" );
+					$found = true;
+					break;
+				} else {
+					wfDebug( "Requested $host, not found in $base.\n" );
+				}
 			}
 		}
 
@@ -1149,10 +1261,17 @@ class User {
 	 */
 	public function isPingLimitable() {
 		global $wgRateLimitsExcludedGroups;
+		global $wgRateLimitsExcludedIPs;
 		if( array_intersect( $this->getEffectiveGroups(), $wgRateLimitsExcludedGroups ) ) {
 			// Deprecated, but kept for backwards-compatibility config
 			return false;
 		}
+		if( in_array( wfGetIP(), $wgRateLimitsExcludedIPs ) ) {
+			// No other good way currently to disable rate limits
+			// for specific IPs. :P
+			// But this is a crappy hack and should die.
+			return false;
+		}
 		return !$this->isAllowed('noratelimit');
 	}
 
@@ -1166,8 +1285,7 @@ class User {
 	 * @param $action \string Action to enforce; 'edit' if unspecified
 	 * @return \bool True if a rate limiter was tripped
 	 */
-	function pingLimiter( $action='edit' ) {
-
+	function pingLimiter( $action = 'edit' ) {
 		# Call the 'PingLimiter' hook
 		$result = false;
 		if( !wfRunHooks( 'PingLimiter', array( &$this, $action, $result ) ) ) {
@@ -1223,7 +1341,7 @@ class User {
 		}
 		// Set the user limit key
 		if ( $userLimit !== false ) {
-			wfDebug( __METHOD__.": effective user limit: $userLimit\n" );
+			wfDebug( __METHOD__ . ": effective user limit: $userLimit\n" );
 			$keys[ wfMemcKey( 'limiter', $action, 'user', $id ) ] = $userLimit;
 		}
 
@@ -1232,19 +1350,20 @@ class User {
 			list( $max, $period ) = $limit;
 			$summary = "(limit $max in {$period}s)";
 			$count = $wgMemc->get( $key );
+			// Already pinged?
 			if( $count ) {
 				if( $count > $max ) {
-					wfDebug( __METHOD__.": tripped! $key at $count $summary\n" );
+					wfDebug( __METHOD__ . ": tripped! $key at $count $summary\n" );
 					if( $wgRateLimitLog ) {
 						@error_log( wfTimestamp( TS_MW ) . ' ' . wfWikiID() . ': ' . $this->getName() . " tripped $key at $count $summary\n", 3, $wgRateLimitLog );
 					}
 					$triggered = true;
 				} else {
-					wfDebug( __METHOD__.": ok. $key at $count $summary\n" );
+					wfDebug( __METHOD__ . ": ok. $key at $count $summary\n" );
 				}
 			} else {
-				wfDebug( __METHOD__.": adding record for $key $summary\n" );
-				$wgMemc->add( $key, 1, intval( $period ) );
+				wfDebug( __METHOD__ . ": adding record for $key $summary\n" );
+				$wgMemc->add( $key, 0, intval( $period ) ); // first ping
 			}
 			$wgMemc->incr( $key );
 		}
@@ -1255,7 +1374,7 @@ class User {
 
 	/**
 	 * Check if user is blocked
-	 * 
+	 *
 	 * @param $bFromSlave \bool Whether to check the slave database instead of the master
 	 * @return \bool True if blocked, false otherwise
 	 */
@@ -1267,7 +1386,7 @@ class User {
 
 	/**
 	 * Check if user is blocked from editing a particular article
-	 * 
+	 *
 	 * @param $title      \string Title to check
 	 * @param $bFromSlave \bool   Whether to check the slave database instead of the master
 	 * @return \bool True if blocked, false otherwise
@@ -1275,17 +1394,20 @@ class User {
 	function isBlockedFrom( $title, $bFromSlave = false ) {
 		global $wgBlockAllowsUTEdit;
 		wfProfileIn( __METHOD__ );
-		wfDebug( __METHOD__.": enter\n" );
+		wfDebug( __METHOD__ . ": enter\n" );
 
-		wfDebug( __METHOD__.": asking isBlocked()\n" );
+		wfDebug( __METHOD__ . ": asking isBlocked()\n" );
 		$blocked = $this->isBlocked( $bFromSlave );
-		$allowUsertalk = ($wgBlockAllowsUTEdit ? $this->mAllowUsertalk : false);
+		$allowUsertalk = ( $wgBlockAllowsUTEdit ? $this->mAllowUsertalk : false );
 		# If a user's name is suppressed, they cannot make edits anywhere
 		if ( !$this->mHideName && $allowUsertalk && $title->getText() === $this->getName() &&
 		  $title->getNamespace() == NS_USER_TALK ) {
 			$blocked = false;
-			wfDebug( __METHOD__.": self-talk page, ignoring any blocks\n" );
+			wfDebug( __METHOD__ . ": self-talk page, ignoring any blocks\n" );
 		}
+
+		wfRunHooks( 'UserIsBlockedFrom', array( $this, $title, &$blocked, &$allowUsertalk ) );
+
 		wfProfileOut( __METHOD__ );
 		return $blocked;
 	}
@@ -1307,12 +1429,21 @@ class User {
 		$this->getBlockedStatus();
 		return $this->mBlockreason;
 	}
-	
+
+	/**
+	 * If user is blocked, return the ID for the block
+	 * @return \int Block ID
+	 */
+	function getBlockId() {
+		$this->getBlockedStatus();
+		return ( $this->mBlock ? $this->mBlock->mId : false );
+	}
+
 	/**
 	 * Check if user is blocked on all wikis.
 	 * Do not use for actual edit permission checks!
 	 * This is intented for quick UI checks.
-	 * 
+	 *
 	 * @param $ip \type{\string} IP address, uses current client if none given
 	 * @return \type{\bool} True if blocked, false otherwise
 	 */
@@ -1331,10 +1462,10 @@ class User {
 		$this->mBlockedGlobally = (bool)$blocked;
 		return $this->mBlockedGlobally;
 	}
-	
+
 	/**
 	 * Check if user account is locked
-	 * 
+	 *
 	 * @return \type{\bool} True if locked, false otherwise
 	 */
 	function isLocked() {
@@ -1346,10 +1477,10 @@ class User {
 		$this->mLocked = (bool)$authUser->isLocked();
 		return $this->mLocked;
 	}
-	
+
 	/**
 	 * Check if user account is hidden
-	 * 
+	 *
 	 * @return \type{\bool} True if hidden, false otherwise
 	 */
 	function isHidden() {
@@ -1367,7 +1498,7 @@ class User {
 
 	/**
 	 * Get the user's ID.
-	 * @return \int The user's ID; 0 if the user is anonymous or nonexistent
+	 * @return Integer The user's ID; 0 if the user is anonymous or nonexistent
 	 */
 	function getId() {
 		if( $this->mId === null and $this->mName !== null
@@ -1473,17 +1604,16 @@ class User {
 	 */
 	function getNewMessageLinks() {
 		$talks = array();
-		if (!wfRunHooks('UserRetrieveNewTalks', array(&$this, &$talks)))
+		if( !wfRunHooks( 'UserRetrieveNewTalks', array( &$this, &$talks ) ) )
 			return $talks;
 
-		if (!$this->getNewtalk())
+		if( !$this->getNewtalk() )
 			return array();
 		$up = $this->getUserPage();
 		$utp = $up->getTalkPage();
-		return array(array("wiki" => wfWikiID(), "link" => $utp->getLocalURL()));
+		return array( array( 'wiki' => wfWikiID(), 'link' => $utp->getLocalURL() ) );
 	}
 
-
 	/**
 	 * Internal uncached check for new messages
 	 *
@@ -1519,10 +1649,10 @@ class User {
 			__METHOD__,
 			'IGNORE' );
 		if ( $dbw->affectedRows() ) {
-			wfDebug( __METHOD__.": set on ($field, $id)\n" );
+			wfDebug( __METHOD__ . ": set on ($field, $id)\n" );
 			return true;
 		} else {
-			wfDebug( __METHOD__." already set ($field, $id)\n" );
+			wfDebug( __METHOD__ . " already set ($field, $id)\n" );
 			return false;
 		}
 	}
@@ -1540,10 +1670,10 @@ class User {
 			array( $field => $id ),
 			__METHOD__ );
 		if ( $dbw->affectedRows() ) {
-			wfDebug( __METHOD__.": killed on ($field, $id)\n" );
+			wfDebug( __METHOD__ . ": killed on ($field, $id)\n" );
 			return true;
 		} else {
-			wfDebug( __METHOD__.": already gone ($field, $id)\n" );
+			wfDebug( __METHOD__ . ": already gone ($field, $id)\n" );
 			return false;
 		}
 	}
@@ -1617,6 +1747,9 @@ class User {
 	 * for reload on the next hit.
 	 */
 	function invalidateCache() {
+		if( wfReadOnly() ) {
+			return;
+		}
 		$this->load();
 		if( $this->mId ) {
 			$this->mTouched = self::newTouchedTimestamp();
@@ -1637,7 +1770,7 @@ class User {
 	 */
 	function validateCache( $timestamp ) {
 		$this->load();
-		return ($timestamp >= $this->mTouched);
+		return ( $timestamp >= $this->mTouched );
 	}
 
 	/**
@@ -1672,7 +1805,8 @@ class User {
 
 			if( !$this->isValidPassword( $str ) ) {
 				global $wgMinimalPasswordLength;
-				throw new PasswordError( wfMsgExt( 'passwordtooshort', array( 'parsemag' ),
+				$valid = $this->getPasswordValidity( $str );
+				throw new PasswordError( wfMsgExt( $valid, array( 'parsemag' ),
 					$wgMinimalPasswordLength ) );
 			}
 		}
@@ -1704,16 +1838,20 @@ class User {
 		$this->mNewpassword = '';
 		$this->mNewpassTime = null;
 	}
-	
+
 	/**
 	 * Get the user's current token.
+	 * @param $forceCreation Force the generation of a new token if the user doesn't have one (default=true for backwards compatibility)
 	 * @return \string Token
 	 */
-	function getToken() {
+	function getToken( $forceCreation = true ) {
 		$this->load();
+ 		if ( !$this->mToken && $forceCreation ) {
+ 			$this->setToken();
+ 		}
 		return $this->mToken;
 	}
-	
+
 	/**
 	 * Set the random token (used for persistent authentication)
 	 * Called from loadDefaults() among other places.
@@ -1725,19 +1863,12 @@ class User {
 		global $wgSecretKey, $wgProxyKey;
 		$this->load();
 		if ( !$token ) {
-			if ( $wgSecretKey ) {
-				$key = $wgSecretKey;
-			} elseif ( $wgProxyKey ) {
-				$key = $wgProxyKey;
-			} else {
-				$key = microtime();
-			}
-			$this->mToken = md5( $key . mt_rand( 0, 0x7fffffff ) . wfWikiID() . $this->mId );
+			$this->mToken = MWCryptRand::generateHex( USER_TOKEN_LENGTH );
 		} else {
 			$this->mToken = $token;
 		}
 	}
-	
+
 	/**
 	 * Set the cookie password
 	 *
@@ -1764,7 +1895,7 @@ class User {
 	}
 
 	/**
-	 * Has password reminder email been sent within the last 
+	 * Has password reminder email been sent within the last
 	 * $wgPasswordReminderResendTime hours?
 	 * @return \bool True or false
 	 */
@@ -1835,8 +1966,8 @@ class User {
 	 * @see getBoolOption()
 	 * @see getIntOption()
 	 */
-	function getOption( $oname, $defaultOverride = '' ) {
-		$this->load();
+	function getOption( $oname, $defaultOverride = null ) {
+		$this->loadOptions();
 
 		if ( is_null( $this->mOptions ) ) {
 			if($defaultOverride != '') {
@@ -1846,12 +1977,22 @@ class User {
 		}
 
 		if ( array_key_exists( $oname, $this->mOptions ) ) {
-			return trim( $this->mOptions[$oname] );
+			return $this->mOptions[$oname];
 		} else {
 			return $defaultOverride;
 		}
 	}
-	
+
+	/**
+	 * Get all user's options
+	 *
+	 * @return array
+	 */
+	public function getOptions() {
+		$this->loadOptions();
+		return $this->mOptions;
+	}
+
 	/**
 	 * Get the user's current setting for a given option, as a boolean value.
 	 *
@@ -1863,7 +2004,7 @@ class User {
 		return (bool)$this->getOption( $oname );
 	}
 
-	
+
 	/**
 	 * Get the user's current setting for a given option, as a boolean value.
 	 *
@@ -1888,28 +2029,29 @@ class User {
 	 */
 	function setOption( $oname, $val ) {
 		$this->load();
-		if ( is_null( $this->mOptions ) ) {
-			$this->mOptions = User::getDefaultOptions();
-		}
+		$this->loadOptions();
+
 		if ( $oname == 'skin' ) {
 			# Clear cached skin, so the new one displays immediately in Special:Preferences
-			unset( $this->mSkin );
-		}
-		// Filter out any newlines that may have passed through input validation.
-		// Newlines are used to separate items in the options blob.
-		if( $val ) {
-			$val = str_replace( "\r\n", "\n", $val );
-			$val = str_replace( "\r", "\n", $val );
-			$val = str_replace( "\n", " ", $val );
+			$this->mSkin = null;
 		}
+
 		// Explicitly NULL values should refer to defaults
 		global $wgDefaultUserOptions;
-		if( is_null($val) && isset($wgDefaultUserOptions[$oname]) ) {
+		if( is_null( $val ) && isset( $wgDefaultUserOptions[$oname] ) ) {
 			$val = $wgDefaultUserOptions[$oname];
 		}
+
 		$this->mOptions[$oname] = $val;
 	}
 
+	/**
+	 * Reset all options to the site defaults
+	 */
+	function resetOptions() {
+		$this->mOptions = User::getDefaultOptions();
+	}
+
 	/**
 	 * Get the user's preferred date format.
 	 * @return \string User's preferred date format
@@ -1928,6 +2070,20 @@ class User {
 		return $this->mDatePreference;
 	}
 
+	/**
+	 * Get the user preferred stub threshold
+	 */
+	function getStubThreshold() {
+		global $wgMaxArticleSize; # Maximum article size, in Kb
+		$threshold = intval( $this->getOption( 'stubthreshold' ) );
+		if ( $threshold > $wgMaxArticleSize * 1024 ) {
+			# If they have set an impossible value, disable the preference
+			# so we can use the parser cache again.
+			$threshold = 0;
+		}
+		return $threshold;
+	}
+
 	/**
 	 * Get the permissions this user has.
 	 * @return \type{\arrayof{\string}} Array of permission names
@@ -1961,6 +2117,7 @@ class User {
 	 */
 	function getEffectiveGroups( $recache = false ) {
 		if ( $recache || is_null( $this->mEffectiveGroups ) ) {
+			wfProfileIn( __METHOD__ );
 			$this->mEffectiveGroups = $this->getGroups();
 			$this->mEffectiveGroups[] = '*';
 			if( $this->getId() ) {
@@ -1974,6 +2131,7 @@ class User {
 				# Hook for additional groups
 				wfRunHooks( 'UserEffectiveGroups', array( &$this, &$this->mEffectiveGroups ) );
 			}
+			wfProfileOut( __METHOD__ );
 		}
 		return $this->mEffectiveGroups;
 	}
@@ -1983,10 +2141,10 @@ class User {
 	 * @return \int User'e edit count
 	 */
 	function getEditCount() {
-		if ($this->mId) {
+		if( $this->getId() ) {
 			if ( !isset( $this->mEditCount ) ) {
 				/* Populate the count, if it has not been populated yet */
-				$this->mEditCount = User::edits($this->mId);
+				$this->mEditCount = User::edits( $this->mId );
 			}
 			return $this->mEditCount;
 		} else {
@@ -2008,7 +2166,7 @@ class User {
 					'ug_user'  => $this->getID(),
 					'ug_group' => $group,
 				),
-				'User::addGroup',
+				__METHOD__,
 				array( 'IGNORE' ) );
 		}
 
@@ -2031,8 +2189,7 @@ class User {
 			array(
 				'ug_user'  => $this->getID(),
 				'ug_group' => $group,
-			),
-			'User::removeGroup' );
+			), __METHOD__ );
 
 		$this->loadGroups();
 		$this->mGroups = array_diff( $this->mGroups, array( $group ) );
@@ -2041,7 +2198,6 @@ class User {
 		$this->invalidateCache();
 	}
 
-
 	/**
 	 * Get whether the user is logged in
 	 * @return \bool True or false
@@ -2071,59 +2227,82 @@ class User {
 	/**
 	 * Check if user is allowed to access a feature / make an action
 	 * @param $action \string action to be checked
-	 * @return \bool True if action is allowed, else false
+	 * @return Boolean: True if action is allowed, else false
 	 */
-	function isAllowed($action='') {
-		if ( $action === '' )
-			// In the spirit of DWIM
-			return true;
-
-		# Use strict parameter to avoid matching numeric 0 accidentally inserted 
+	function isAllowed( $action = '' ) {
+		if ( $action === '' ) {
+			return true; // In the spirit of DWIM
+		}
+		# Patrolling may not be enabled
+		if( $action === 'patrol' || $action === 'autopatrol' ) {
+			global $wgUseRCPatrol, $wgUseNPPatrol;
+			if( !$wgUseRCPatrol && !$wgUseNPPatrol )
+				return false;
+		}
+		# Use strict parameter to avoid matching numeric 0 accidentally inserted
 		# by misconfiguration: 0 == 'foo'
 		return in_array( $action, $this->getRights(), true );
 	}
 
 	/**
-	* Check whether to enable recent changes patrol features for this user
-	* @return \bool True or false
-	*/
+	 * Check whether to enable recent changes patrol features for this user
+	 * @return Boolean: True or false
+	 */
 	public function useRCPatrol() {
 		global $wgUseRCPatrol;
-		return( $wgUseRCPatrol && ($this->isAllowed('patrol') || $this->isAllowed('patrolmarks')) );
+		return( $wgUseRCPatrol && ( $this->isAllowed( 'patrol' ) || $this->isAllowed( 'patrolmarks' ) ) );
 	}
 
 	/**
-	* Check whether to enable new pages patrol features for this user
-	* @return \bool True or false
-	*/
+	 * Check whether to enable new pages patrol features for this user
+	 * @return \bool True or false
+	 */
 	public function useNPPatrol() {
 		global $wgUseRCPatrol, $wgUseNPPatrol;
-		return( ($wgUseRCPatrol || $wgUseNPPatrol) && ($this->isAllowed('patrol') || $this->isAllowed('patrolmarks')) );
+		return( ( $wgUseRCPatrol || $wgUseNPPatrol ) && ( $this->isAllowed( 'patrol' ) || $this->isAllowed( 'patrolmarks' ) ) );
 	}
 
 	/**
-	 * Get the current skin, loading it if required
-	 * @return \type{Skin} Current skin
+	 * Get the current skin, loading it if required, and setting a title
+	 * @param $t Title: the title to use in the skin
+	 * @return Skin The current skin
 	 * @todo FIXME : need to check the old failback system [AV]
 	 */
-	function &getSkin() {
-		global $wgRequest, $wgAllowUserSkin, $wgDefaultSkin;
-		if ( ! isset( $this->mSkin ) ) {
-			wfProfileIn( __METHOD__ );
+	function getSkin( $t = null ) {
+		if( !$this->mSkin ) {
+			global $wgOut;
+			$this->mSkin = $this->createSkinObject();
+			$this->mSkin->setTitle( $wgOut->getTitle() );
+		}
+		if ( $t && ( !$this->mSkin->getTitle() || !$t->equals( $this->mSkin->getTitle() ) ) ) {
+			$skin = $this->createSkinObject();
+			$skin->setTitle( $t );
+			return $skin;
+		} else {
+			return $this->mSkin;
+		}
+	}
 
-			if( $wgAllowUserSkin ) {
-				# get the user skin
-				$userSkin = $this->getOption( 'skin' );
-				$userSkin = $wgRequest->getVal('useskin', $userSkin);
-			} else {
-				# if we're not allowing users to override, then use the default
-				$userSkin = $wgDefaultSkin;
-			}
-			
-			$this->mSkin =& Skin::newFromKey( $userSkin );
-			wfProfileOut( __METHOD__ );
+	// Creates a Skin object, for getSkin()
+	private function createSkinObject() {
+		wfProfileIn( __METHOD__ );
+
+		global $wgHiddenPrefs;
+		if( !in_array( 'skin', $wgHiddenPrefs ) ) {
+			global $wgRequest;
+			# get the user skin
+			$userSkin = $this->getOption( 'skin' );
+			$userSkin = $wgRequest->getVal( 'useskin', $userSkin );
+		} else {
+			# if we're not allowing users to override, then use the default
+			global $wgDefaultSkin;
+			$userSkin = $wgDefaultSkin;
 		}
-		return $this->mSkin;
+
+		$skin = Skin::newFromKey( $userSkin );
+		wfProfileOut( __METHOD__ );
+
+		return $skin;
 	}
 
 	/**
@@ -2170,9 +2349,9 @@ class User {
 			return;
 		}
 
-		if ($title->getNamespace() == NS_USER_TALK &&
+		if( $title->getNamespace() == NS_USER_TALK &&
 			$title->getText() == $this->getName() ) {
-			if (!wfRunHooks('UserClearNewTalkNotification', array(&$this)))
+			if( !wfRunHooks( 'UserClearNewTalkNotification', array( &$this ) ) )
 				return;
 			$this->setNewtalk( false );
 		}
@@ -2190,8 +2369,8 @@ class User {
 		// The query to find out if it is watched is cached both in memcached and per-invocation,
 		// and when it does have to be executed, it can be on a slave
 		// If this is the user's newtalk page, we always update the timestamp
-		if ($title->getNamespace() == NS_USER_TALK &&
-			$title->getText() == $wgUser->getName())
+		if( $title->getNamespace() == NS_USER_TALK &&
+			$title->getText() == $wgUser->getName() )
 		{
 			$watched = true;
 		} elseif ( $this->getId() == $wgUser->getId() ) {
@@ -2206,7 +2385,7 @@ class User {
 			$dbw = wfGetDB( DB_MASTER );
 			$dbw->update( 'watchlist',
 					array( /* SET */
-						'wl_notificationtimestamp' => NULL
+						'wl_notificationtimestamp' => null
 					), array( /* WHERE */
 						'wl_title' => $title->getDBkey(),
 						'wl_namespace' => $title->getNamespace(),
@@ -2233,7 +2412,7 @@ class User {
 			$dbw = wfGetDB( DB_MASTER );
 			$dbw->update( 'watchlist',
 				array( /* SET */
-					'wl_notificationtimestamp' => NULL
+					'wl_notificationtimestamp' => null
 				), array( /* WHERE */
 					'wl_user' => $currentUser
 				), __METHOD__
@@ -2243,53 +2422,44 @@ class User {
 		}
 	}
 
-	/**
-	 * Encode this user's options as a string
-	 * @return \string Encoded options
-	 * @private
-	 */
-	function encodeOptions() {
-		$this->load();
-		if ( is_null( $this->mOptions ) ) {
-			$this->mOptions = User::getDefaultOptions();
-		}
-		$a = array();
-		foreach ( $this->mOptions as $oname => $oval ) {
-			array_push( $a, $oname.'='.$oval );
-		}
-		$s = implode( "\n", $a );
-		return $s;
-	}
-
 	/**
 	 * Set this user's options from an encoded string
 	 * @param $str \string Encoded options to import
 	 * @private
 	 */
 	function decodeOptions( $str ) {
-		$this->mOptions = array();
+		if( !$str )
+			return;
+
+		$this->mOptionsLoaded = true;
+		$this->mOptionOverrides = array();
+
+		// If an option is not set in $str, use the default value
+		$this->mOptions = self::getDefaultOptions();
+
 		$a = explode( "\n", $str );
 		foreach ( $a as $s ) {
 			$m = array();
 			if ( preg_match( "/^(.[^=]*)=(.*)$/", $s, $m ) ) {
 				$this->mOptions[$m[1]] = $m[2];
+				$this->mOptionOverrides[$m[1]] = $m[2];
 			}
 		}
 	}
-	
+
 	/**
-	 * Set a cookie on the user's client. Wrapper for 
+	 * Set a cookie on the user's client. Wrapper for
 	 * WebResponse::setCookie
 	 * @param $name \string Name of the cookie to set
 	 * @param $value \string Value to set
-	 * @param $exp \int Expiration time, as a UNIX time value; 
+	 * @param $exp \int Expiration time, as a UNIX time value;
 	 *                   if 0 or not specified, use the default $wgCookieExpiration
 	 */
-	protected function setCookie( $name, $value, $exp=0 ) {
+	protected function setCookie( $name, $value, $exp = 0 ) {
 		global $wgRequest;
 		$wgRequest->response()->setcookie( $name, $value, $exp );
 	}
-	
+
 	/**
 	 * Clear a cookie on the user's client
 	 * @param $name \string Name of the cookie to clear
@@ -2304,7 +2474,15 @@ class User {
 	function setCookies() {
 		$this->load();
 		if ( 0 == $this->mId ) return;
-		$session = array( 
+		if ( !$this->mToken ) {
+			// When token is empty or NULL generate a new one and then save it to the database
+			// This allows a wiki to re-secure itself after a leak of it's user table or $wgSecretKey
+			// Simply by setting every cell in the user_token column to NULL and letting them be
+			// regenerated as users log back into the wiki.
+			$this->setToken();
+			$this->saveSettings();
+		}
+		$session = array(
 			'wsUserID' => $this->mId,
 			'wsToken' => $this->mToken,
 			'wsUserName' => $this->getName()
@@ -2318,9 +2496,9 @@ class User {
 		} else {
 			$cookies['Token'] = false;
 		}
-		
+
 		wfRunHooks( 'UserSetCookies', array( $this, &$session, &$cookies ) );
-		#check for null, since the hook could cause a null value 
+		#check for null, since the hook could cause a null value
 		if ( !is_null( $session ) && isset( $_SESSION ) ){
 			$_SESSION = $session + $_SESSION;
 		}
@@ -2337,8 +2515,7 @@ class User {
 	 * Log this user out.
 	 */
 	function logout() {
-		global $wgUser;
-		if( wfRunHooks( 'UserLogout', array(&$this) ) ) {
+		if( wfRunHooks( 'UserLogout', array( &$this ) ) ) {
 			$this->doLogout();
 		}
 	}
@@ -2379,17 +2556,20 @@ class User {
 				'user_newpassword' => $this->mNewpassword,
 				'user_newpass_time' => $dbw->timestampOrNull( $this->mNewpassTime ),
 				'user_real_name' => $this->mRealName,
-		 		'user_email' => $this->mEmail,
-		 		'user_email_authenticated' => $dbw->timestampOrNull( $this->mEmailAuthenticated ),
-				'user_options' => $this->encodeOptions(),
-				'user_touched' => $dbw->timestamp($this->mTouched),
-				'user_token' => $this->mToken,
+				'user_email' => $this->mEmail,
+				'user_email_authenticated' => $dbw->timestampOrNull( $this->mEmailAuthenticated ),
+				'user_options' => '',
+				'user_touched' => $dbw->timestamp( $this->mTouched ),
+				'user_token' => strval( $this->mToken ),
 				'user_email_token' => $this->mEmailToken,
 				'user_email_token_expires' => $dbw->timestampOrNull( $this->mEmailTokenExpires ),
 			), array( /* WHERE */
 				'user_id' => $this->mId
 			), __METHOD__
 		);
+
+		$this->saveOptions();
+
 		wfRunHooks( 'UserSaveSettings', array( $this ) );
 		$this->clearSharedCache();
 		$this->getUserPage()->invalidateCache();
@@ -2430,22 +2610,23 @@ class User {
 		$user = new User;
 		$user->load();
 		if ( isset( $params['options'] ) ) {
-			$user->mOptions = $params['options'] + $user->mOptions;
+			$user->mOptions = $params['options'] + (array)$user->mOptions;
 			unset( $params['options'] );
 		}
 		$dbw = wfGetDB( DB_MASTER );
 		$seqVal = $dbw->nextSequenceValue( 'user_user_id_seq' );
+
 		$fields = array(
 			'user_id' => $seqVal,
 			'user_name' => $name,
 			'user_password' => $user->mPassword,
 			'user_newpassword' => $user->mNewpassword,
-			'user_newpass_time' => $dbw->timestamp( $user->mNewpassTime ),
+			'user_newpass_time' => $dbw->timestampOrNull( $user->mNewpassTime ),
 			'user_email' => $user->mEmail,
 			'user_email_authenticated' => $dbw->timestampOrNull( $user->mEmailAuthenticated ),
 			'user_real_name' => $user->mRealName,
-			'user_options' => $user->encodeOptions(),
-			'user_token' => $user->mToken,
+			'user_options' => '',
+			'user_token' => strval( $user->mToken ),
 			'user_registration' => $dbw->timestamp( $user->mRegistration ),
 			'user_editcount' => 0,
 		);
@@ -2474,12 +2655,12 @@ class User {
 				'user_name' => $this->mName,
 				'user_password' => $this->mPassword,
 				'user_newpassword' => $this->mNewpassword,
-				'user_newpass_time' => $dbw->timestamp( $this->mNewpassTime ),
+				'user_newpass_time' => $dbw->timestampOrNull( $this->mNewpassTime ),
 				'user_email' => $this->mEmail,
 				'user_email_authenticated' => $dbw->timestampOrNull( $this->mEmailAuthenticated ),
 				'user_real_name' => $this->mRealName,
-				'user_options' => $this->encodeOptions(),
-				'user_token' => $this->mToken,
+				'user_options' => '',
+				'user_token' => strval( $this->mToken ),
 				'user_registration' => $dbw->timestamp( $this->mRegistration ),
 				'user_editcount' => 0,
 			), __METHOD__
@@ -2488,6 +2669,8 @@ class User {
 
 		// Clear instance cache other than user table data, which is already accurate
 		$this->clearInstanceCache();
+
+		$this->saveOptions();
 	}
 
 	/**
@@ -2495,7 +2678,7 @@ class User {
 	 * they've successfully logged in from.
 	 */
 	function spreadBlock() {
-		wfDebug( __METHOD__."()\n" );
+		wfDebug( __METHOD__ . "()\n" );
 		$this->load();
 		if ( $this->mId == 0 ) {
 			return;
@@ -2506,21 +2689,21 @@ class User {
 			return;
 		}
 
-		$userblock->doAutoblock( wfGetIp() );
-
+		$userblock->doAutoblock( wfGetIP() );
 	}
 
 	/**
 	 * Generate a string which will be different for any combination of
 	 * user options which would produce different parser output.
 	 * This will be used as part of the hash key for the parser cache,
-	 * so users will the same options can share the same cached data
+	 * so users with the same options can share the same cached data
 	 * safely.
 	 *
 	 * Extensions which require it should install 'PageRenderingHash' hook,
 	 * which will give them a chance to modify this key based on their own
 	 * settings.
 	 *
+	 * @deprecated use the ParserOptions object to get the relevant options
 	 * @return \string Page rendering hash
 	 */
 	function getPageRenderingHash() {
@@ -2528,22 +2711,27 @@ class User {
 		if( $this->mHash ){
 			return $this->mHash;
 		}
+		wfDeprecated( __METHOD__ );
 
 		// stubthreshold is only included below for completeness,
-		// it will always be 0 when this function is called by parsercache.
+		// since it disables the parser cache, its value will always
+		// be 0 when this function is called by parsercache.
 
 		$confstr =        $this->getOption( 'math' );
-		$confstr .= '!' . $this->getOption( 'stubthreshold' );
-		if ( $wgUseDynamicDates ) {
+		$confstr .= '!' . $this->getStubThreshold();
+		if ( $wgUseDynamicDates ) { # This is wrong (bug 24714)
 			$confstr .= '!' . $this->getDatePreference();
 		}
-		$confstr .= '!' . ($this->getOption( 'numberheadings' ) ? '1' : '');
+		$confstr .= '!' . ( $this->getOption( 'numberheadings' ) ? '1' : '' );
 		$confstr .= '!' . $wgLang->getCode();
 		$confstr .= '!' . $this->getOption( 'thumbsize' );
 		// add in language specific options, if any
 		$extra = $wgContLang->getExtraHashOptions();
 		$confstr .= $extra;
 
+		// Since the skin could be overloading link(), it should be
+		// included here but in practice, none of our skins do that.
+
 		$confstr .= $wgRenderHashAppend;
 
 		// Give a chance for extensions to modify the hash, if they have
@@ -2567,7 +2755,7 @@ class User {
 
 	/**
 	 * Get whether the user is blocked from using Special:Emailuser.
-	 * @return \bool True if blocked
+	 * @return Boolean: True if blocked
 	 */
 	function isBlockedFromEmailuser() {
 		$this->getBlockedStatus();
@@ -2576,23 +2764,16 @@ class User {
 
 	/**
 	 * Get whether the user is allowed to create an account.
-	 * @return \bool True if allowed
+	 * @return Boolean: True if allowed
 	 */
 	function isAllowedToCreateAccount() {
 		return $this->isAllowed( 'createaccount' ) && !$this->isBlockedFromCreateAccount();
 	}
 
-	/**
-	 * @deprecated
-	 */
-	function setLoaded( $loaded ) {
-		wfDeprecated( __METHOD__ );
-	}
-
 	/**
 	 * Get this user's personal page title.
 	 *
-	 * @return \type{Title} User's personal page title
+	 * @return Title: User's personal page title
 	 */
 	function getUserPage() {
 		return Title::makeTitle( NS_USER, $this->getName() );
@@ -2601,7 +2782,7 @@ class User {
 	/**
 	 * Get this user's talk page title.
 	 *
-	 * @return \type{Title} User's talk page title
+	 * @return Title: User's talk page title
 	 */
 	function getTalkPage() {
 		$title = $this->getUserPage();
@@ -2610,59 +2791,33 @@ class User {
 
 	/**
 	 * Get the maximum valid user ID.
-	 * @return \int User ID
+	 * @return Integer: User ID
 	 * @static
 	 */
 	function getMaxID() {
 		static $res; // cache
 
-		if ( isset( $res ) )
+		if ( isset( $res ) ) {
 			return $res;
-		else {
+		} else {
 			$dbr = wfGetDB( DB_SLAVE );
-			return $res = $dbr->selectField( 'user', 'max(user_id)', false, 'User::getMaxID' );
+			return $res = $dbr->selectField( 'user', 'max(user_id)', false, __METHOD__ );
 		}
 	}
 
 	/**
 	 * Determine whether the user is a newbie. Newbies are either
 	 * anonymous IPs, or the most recently created accounts.
-	 * @return \bool True if the user is a newbie
+	 * @return Boolean: True if the user is a newbie
 	 */
 	function isNewbie() {
 		return !$this->isAllowed( 'autoconfirmed' );
 	}
-	
-	/**
-	 * Is the user active? We check to see if they've made at least
-	 * X number of edits in the last Y days.
-	 * 
-	 * @return \bool True if the user is active, false if not.
-	 */
-	public function isActiveEditor() {
-		global $wgActiveUserEditCount, $wgActiveUserDays;
-		$dbr = wfGetDB( DB_SLAVE );
-		
-		// Stolen without shame from RC
-		$cutoff_unixtime = time() - ( $wgActiveUserDays * 86400 );
-		$cutoff_unixtime = $cutoff_unixtime - ( $cutoff_unixtime % 86400 );
-		$oldTime = $dbr->addQuotes( $dbr->timestamp( $cutoff_unixtime ) );
-		
-		$res = $dbr->select( 'revision', '1',
-				array( 'rev_user_text' => $this->getName(), "rev_timestamp > $oldTime"),
-				__METHOD__,
-				array('LIMIT' => $wgActiveUserEditCount ) );
-		
-		$count = $dbr->numRows($res);
-		$dbr->freeResult($res);
-
-		return $count == $wgActiveUserEditCount;
-	}
 
 	/**
 	 * Check to see if the given clear-text password is one of the accepted passwords
-	 * @param $password \string user password.
-	 * @return \bool True if the given password is correct, otherwise False.
+	 * @param $password String: user password.
+	 * @return Boolean: True if the given password is correct, otherwise False.
 	 */
 	function checkPassword( $password ) {
 		global $wgAuth;
@@ -2672,7 +2827,7 @@ class User {
 		// are shorter than this, doesn't mean people wont be able
 		// to. Certain authentication plugins do NOT want to save
 		// domain passwords in a mysql database, so we should
-		// check this (incase $wgAuth->strict() is false).
+		// check this (in case $wgAuth->strict() is false).
 		if( !$this->isValidPassword( $password ) ) {
 			return false;
 		}
@@ -2702,10 +2857,19 @@ class User {
 	/**
 	 * Check if the given clear-text password matches the temporary password
 	 * sent by e-mail for password reset operations.
-	 * @return \bool True if matches, false otherwise
+	 * @return Boolean: True if matches, false otherwise
 	 */
 	function checkTemporaryPassword( $plaintext ) {
-		return self::comparePasswords( $this->mNewpassword, $plaintext, $this->getId() );
+		global $wgNewPasswordExpiry;
+		if( self::comparePasswords( $this->mNewpassword, $plaintext, $this->getId() ) ) {
+			if ( is_null( $this->mNewpassTime ) ) {
+				return true;
+			}
+			$expiry = wfTimestamp( TS_UNIX, $this->mNewpassTime ) + $wgNewPasswordExpiry;
+			return ( time() < $expiry );
+		} else {
+			return false;
+		}
 	}
 
 	/**
@@ -2722,7 +2886,7 @@ class User {
 			return EDIT_TOKEN_SUFFIX;
 		} else {
 			if( !isset( $_SESSION['wsEditToken'] ) ) {
-				$token = $this->generateToken();
+				$token = MWCryptRand::generateHex( 32 );
 				$_SESSION['wsEditToken'] = $token;
 			} else {
 				$token = $_SESSION['wsEditToken'];
@@ -2740,9 +2904,8 @@ class User {
 	 * @param $salt \string Optional salt value
 	 * @return \string The new random token
 	 */
-	function generateToken( $salt = '' ) {
-		$token = dechex( mt_rand() ) . dechex( mt_rand() );
-		return md5( $token . $salt );
+	public static function generateToken( $salt = '' ) {
+		return MWCryptRand::generateHex( 32 );
 	}
 
 	/**
@@ -2753,7 +2916,7 @@ class User {
 	 *
 	 * @param $val \string Input value to compare
 	 * @param $salt \string Optional function-specific data for hashing
-	 * @return \bool Whether the token matches
+	 * @return Boolean: Whether the token matches
 	 */
 	function matchEditToken( $val, $salt = '' ) {
 		$sessionToken = $this->editToken( $salt );
@@ -2769,7 +2932,7 @@ class User {
 	 *
 	 * @param $val \string Input value to compare
 	 * @param $salt \string Optional function-specific data for hashing
-	 * @return \bool Whether the token matches
+	 * @return Boolean: Whether the token matches
 	 */
 	function matchEditTokenNoSuffix( $val, $salt = '' ) {
 		$sessionToken = $this->editToken( $salt );
@@ -2780,23 +2943,34 @@ class User {
 	 * Generate a new e-mail confirmation token and send a confirmation/invalidation
 	 * mail to the user's given address.
 	 *
-	 * @return \types{\bool,\type{WikiError}} True on success, a WikiError object on failure.
+	 * @param $type String: message to send, either "created", "changed" or "set"
+	 * @return Status object
 	 */
-	function sendConfirmationMail() {
+	function sendConfirmationMail( $type = 'created' ) {
 		global $wgLang;
 		$expiration = null; // gets passed-by-ref and defined in next line.
 		$token = $this->confirmationToken( $expiration );
 		$url = $this->confirmationTokenUrl( $token );
 		$invalidateURL = $this->invalidationTokenUrl( $token );
 		$this->saveSettings();
-		
+
+		if ( $type == 'created' || $type === false ) {
+			$message = 'confirmemail_body';
+		} elseif ( $type === true ) {
+			$message = 'confirmemail_body_changed';
+		} else {
+			$message = 'confirmemail_body_' . $type;
+		}
+
 		return $this->sendMail( wfMsg( 'confirmemail_subject' ),
-			wfMsg( 'confirmemail_body',
+			wfMsg( $message,
 				wfGetIP(),
 				$this->getName(),
 				$url,
 				$wgLang->timeanddate( $expiration, false ),
-				$invalidateURL ) );
+				$invalidateURL,
+				$wgLang->date( $expiration, false ),
+				$wgLang->time( $expiration, false ) ) );
 	}
 
 	/**
@@ -2807,16 +2981,17 @@ class User {
 	 * @param $body \string Message body
 	 * @param $from \string Optional From address; if unspecified, default $wgPasswordSender will be used
 	 * @param $replyto \string Reply-To address
-	 * @return \types{\bool,\type{WikiError}} True on success, a WikiError object on failure
+	 * @return Status object
 	 */
 	function sendMail( $subject, $body, $from = null, $replyto = null ) {
 		if( is_null( $from ) ) {
-			global $wgPasswordSender;
-			$from = $wgPasswordSender;
+			global $wgPasswordSender, $wgPasswordSenderName;
+			$sender = new MailAddress( $wgPasswordSender, $wgPasswordSenderName );
+		} else {
+			$sender = new MailAddress( $from );
 		}
 
 		$to = new MailAddress( $this );
-		$sender = new MailAddress( $from );
 		return UserMailer::send( $to, $sender, $subject, $body, $replyto );
 	}
 
@@ -2835,7 +3010,7 @@ class User {
 		$now = time();
 		$expires = $now + 7 * 24 * 60 * 60;
 		$expiration = wfTimestamp( TS_MW, $expires );
-		$token = $this->generateToken( $this->mId . $this->mEmail . $expires );
+		$token = MWCryptRand::generateHex( 32 );
 		$hash = md5( $token );
 		$this->load();
 		$this->mEmailToken = $hash;
@@ -2852,6 +3027,7 @@ class User {
 	function confirmationTokenUrl( $token ) {
 		return $this->getTokenUrl( 'ConfirmEmail', $token );
 	}
+
 	/**
 	 * Return a URL the user can use to invalidate their email address.
 	 * @param $token \string Accepts the email confirmation token
@@ -2861,7 +3037,7 @@ class User {
 	function invalidationTokenUrl( $token ) {
 		return $this->getTokenUrl( 'Invalidateemail', $token );
 	}
-	
+
 	/**
 	 * Internal function to format the e-mail validation/invalidation URLs.
 	 * This uses $wgArticlePath directly as a quickie hack to use the
@@ -2892,6 +3068,7 @@ class User {
 	 */
 	function confirmEmail() {
 		$this->setEmailAuthenticationTimestamp( wfTimestampNow() );
+		wfRunHooks( 'ConfirmEmailComplete', array( $this ) );
 		return true;
 	}
 
@@ -2906,6 +3083,7 @@ class User {
 		$this->mEmailToken = null;
 		$this->mEmailTokenExpires = null;
 		$this->setEmailAuthenticationTimestamp( null );
+		wfRunHooks( 'InvalidateEmailComplete', array( $this ) );
 		return true;
 	}
 
@@ -2922,11 +3100,11 @@ class User {
 	/**
 	 * Is this user allowed to send e-mails within limits of current
 	 * site configuration?
-	 * @return \bool True if allowed
+	 * @return Boolean: True if allowed
 	 */
 	function canSendEmail() {
 		global $wgEnableEmail, $wgEnableUserEmail;
-		if( !$wgEnableEmail || !$wgEnableUserEmail ) {
+		if( !$wgEnableEmail || !$wgEnableUserEmail || !$this->isAllowed( 'sendemail' ) ) {
 			return false;
 		}
 		$canSend = $this->isEmailConfirmed();
@@ -2937,7 +3115,7 @@ class User {
 	/**
 	 * Is this user allowed to receive e-mails within limits of current
 	 * site configuration?
-	 * @return \bool True if allowed
+	 * @return Boolean: True if allowed
 	 */
 	function canReceiveEmail() {
 		return $this->isEmailConfirmed() && !$this->getOption( 'disablemail' );
@@ -2951,7 +3129,7 @@ class User {
 	 * confirmed their address by returning a code or using a password
 	 * sent to the address from the wiki.
 	 *
-	 * @return \bool True if confirmed
+	 * @return Boolean: True if confirmed
 	 */
 	function isEmailConfirmed() {
 		global $wgEmailAuthentication;
@@ -2972,7 +3150,7 @@ class User {
 
 	/**
 	 * Check whether there is an outstanding request for e-mail confirmation.
-	 * @return \bool True if pending
+	 * @return Boolean: True if pending
 	 */
 	function isEmailConfirmationPending() {
 		global $wgEmailAuthentication;
@@ -2993,7 +3171,7 @@ class User {
 			? $this->mRegistration
 			: false;
 	}
-	
+
 	/**
 	 * Get the timestamp of the first edit
 	 *
@@ -3010,7 +3188,7 @@ class User {
 		);
 		if( !$time ) return false; // no edits
 		return wfTimestamp( TS_MW, $time );
-	}	
+	}
 
 	/**
 	 * Get the permissions associated with a given list of groups
@@ -3019,8 +3197,9 @@ class User {
 	 * @return \type{\arrayof{\string}} List of permission key names for given groups combined
 	 */
 	static function getGroupPermissions( $groups ) {
-		global $wgGroupPermissions;
+		global $wgGroupPermissions, $wgRevokePermissions;
 		$rights = array();
+		// grant every granted permission first
 		foreach( $groups as $group ) {
 			if( isset( $wgGroupPermissions[$group] ) ) {
 				$rights = array_merge( $rights,
@@ -3028,12 +3207,19 @@ class User {
 					array_keys( array_filter( $wgGroupPermissions[$group] ) ) );
 			}
 		}
-		return array_unique($rights);
+		// now revoke the revoked permissions
+		foreach( $groups as $group ) {
+			if( isset( $wgRevokePermissions[$group] ) ) {
+				$rights = array_diff( $rights,
+					array_keys( array_filter( $wgRevokePermissions[$group] ) ) );
+			}
+		}
+		return array_unique( $rights );
 	}
-	
+
 	/**
 	 * Get all the groups who have a given permission
-	 * 
+	 *
 	 * @param $role \string Role to check
 	 * @return \type{\arrayof{\string}} List of internal group names with the given permission
 	 */
@@ -3055,8 +3241,6 @@ class User {
 	 * @return \string Localized descriptive group name
 	 */
 	static function getGroupName( $group ) {
-		global $wgMessageCache;
-		$wgMessageCache->loadAllMessages();
 		$key = "group-$group";
 		$name = wfMsg( $key );
 		return $name == '' || wfEmptyMsg( $key, $name )
@@ -3071,8 +3255,6 @@ class User {
 	 * @return \string Localized name for group member
 	 */
 	static function getGroupMember( $group ) {
-		global $wgMessageCache;
-		$wgMessageCache->loadAllMessages();
 		$key = "group-$group-member";
 		$name = wfMsg( $key );
 		return $name == '' || wfEmptyMsg( $key, $name )
@@ -3084,19 +3266,19 @@ class User {
 	 * Return the set of defined explicit groups.
 	 * The implicit groups (by default *, 'user' and 'autoconfirmed')
 	 * are not included, as they are defined automatically, not in the database.
-	 * @return \type{\arrayof{\string}} Array of internal group names
+	 * @return Array of internal group names
 	 */
 	static function getAllGroups() {
-		global $wgGroupPermissions;
+		global $wgGroupPermissions, $wgRevokePermissions;
 		return array_diff(
-			array_keys( $wgGroupPermissions ),
+			array_merge( array_keys( $wgGroupPermissions ), array_keys( $wgRevokePermissions ) ),
 			self::getImplicitGroups()
 		);
 	}
 
 	/**
 	 * Get a list of all available permissions.
-	 * @return \type{\arrayof{\string}} Array of permission names
+	 * @return Array of permission names
 	 */
 	static function getAllRights() {
 		if ( self::$mAllRights === false ) {
@@ -3129,8 +3311,6 @@ class User {
 	 * @return \types{\type{Title},\bool} Title of the page if it exists, false otherwise
 	 */
 	static function getGroupPage( $group ) {
-		global $wgMessageCache;
-		$wgMessageCache->loadAllMessages();
 		$page = wfMsgForContent( 'grouppage-' . $group );
 		if( !wfEmptyMsg( 'grouppage-' . $group, $page ) ) {
 			$title = Title::newFromText( $page );
@@ -3141,7 +3321,7 @@ class User {
 	}
 
 	/**
-	 * Create a link to the group in HTML, if available; 
+	 * Create a link to the group in HTML, if available;
 	 * else return the group name.
 	 *
 	 * @param $group \string Internal name of the group
@@ -3156,14 +3336,14 @@ class User {
 		if( $title ) {
 			global $wgUser;
 			$sk = $wgUser->getSkin();
-			return $sk->makeLinkObj( $title, htmlspecialchars( $text ) );
+			return $sk->link( $title, htmlspecialchars( $text ) );
 		} else {
 			return $text;
 		}
 	}
 
 	/**
-	 * Create a link to the group in Wikitext, if available; 
+	 * Create a link to the group in Wikitext, if available;
 	 * else return the group name.
 	 *
 	 * @param $group \string Internal name of the group
@@ -3183,6 +3363,115 @@ class User {
 		}
 	}
 
+	/**
+	 * Returns an array of the groups that a particular group can add/remove.
+	 *
+	 * @param $group String: the group to check for whether it can add/remove
+	 * @return Array array( 'add' => array( addablegroups ),
+	 *  'remove' => array( removablegroups ),
+	 *  'add-self' => array( addablegroups to self),
+	 *  'remove-self' => array( removable groups from self) )
+	 */
+	static function changeableByGroup( $group ) {
+		global $wgAddGroups, $wgRemoveGroups, $wgGroupsAddToSelf, $wgGroupsRemoveFromSelf;
+
+		$groups = array( 'add' => array(), 'remove' => array(), 'add-self' => array(), 'remove-self' => array() );
+		if( empty( $wgAddGroups[$group] ) ) {
+			// Don't add anything to $groups
+		} elseif( $wgAddGroups[$group] === true ) {
+			// You get everything
+			$groups['add'] = self::getAllGroups();
+		} elseif( is_array( $wgAddGroups[$group] ) ) {
+			$groups['add'] = $wgAddGroups[$group];
+		}
+
+		// Same thing for remove
+		if( empty( $wgRemoveGroups[$group] ) ) {
+		} elseif( $wgRemoveGroups[$group] === true ) {
+			$groups['remove'] = self::getAllGroups();
+		} elseif( is_array( $wgRemoveGroups[$group] ) ) {
+			$groups['remove'] = $wgRemoveGroups[$group];
+		}
+
+		// Re-map numeric keys of AddToSelf/RemoveFromSelf to the 'user' key for backwards compatibility
+		if( empty( $wgGroupsAddToSelf['user']) || $wgGroupsAddToSelf['user'] !== true ) {
+			foreach( $wgGroupsAddToSelf as $key => $value ) {
+				if( is_int( $key ) ) {
+					$wgGroupsAddToSelf['user'][] = $value;
+				}
+			}
+		}
+
+		if( empty( $wgGroupsRemoveFromSelf['user']) || $wgGroupsRemoveFromSelf['user'] !== true ) {
+			foreach( $wgGroupsRemoveFromSelf as $key => $value ) {
+				if( is_int( $key ) ) {
+					$wgGroupsRemoveFromSelf['user'][] = $value;
+				}
+			}
+		}
+
+		// Now figure out what groups the user can add to him/herself
+		if( empty( $wgGroupsAddToSelf[$group] ) ) {
+		} elseif( $wgGroupsAddToSelf[$group] === true ) {
+			// No idea WHY this would be used, but it's there
+			$groups['add-self'] = User::getAllGroups();
+		} elseif( is_array( $wgGroupsAddToSelf[$group] ) ) {
+			$groups['add-self'] = $wgGroupsAddToSelf[$group];
+		}
+
+		if( empty( $wgGroupsRemoveFromSelf[$group] ) ) {
+		} elseif( $wgGroupsRemoveFromSelf[$group] === true ) {
+			$groups['remove-self'] = User::getAllGroups();
+		} elseif( is_array( $wgGroupsRemoveFromSelf[$group] ) ) {
+			$groups['remove-self'] = $wgGroupsRemoveFromSelf[$group];
+		}
+
+		return $groups;
+	}
+
+	/**
+	 * Returns an array of groups that this user can add and remove
+	 * @return Array array( 'add' => array( addablegroups ),
+	 *  'remove' => array( removablegroups ),
+	 *  'add-self' => array( addablegroups to self),
+	 *  'remove-self' => array( removable groups from self) )
+	 */
+	function changeableGroups() {
+		if( $this->isAllowed( 'userrights' ) ) {
+			// This group gives the right to modify everything (reverse-
+			// compatibility with old "userrights lets you change
+			// everything")
+			// Using array_merge to make the groups reindexed
+			$all = array_merge( User::getAllGroups() );
+			return array(
+				'add' => $all,
+				'remove' => $all,
+				'add-self' => array(),
+				'remove-self' => array()
+			);
+		}
+
+		// Okay, it's not so simple, we will have to go through the arrays
+		$groups = array(
+			'add' => array(),
+			'remove' => array(),
+			'add-self' => array(),
+			'remove-self' => array()
+		);
+		$addergroups = $this->getEffectiveGroups();
+
+		foreach( $addergroups as $addergroup ) {
+			$groups = array_merge_recursive(
+				$groups, $this->changeableByGroup( $addergroup )
+			);
+			$groups['add']    = array_unique( $groups['add'] );
+			$groups['remove'] = array_unique( $groups['remove'] );
+			$groups['add-self'] = array_unique( $groups['add-self'] );
+			$groups['remove-self'] = array_unique( $groups['remove-self'] );
+		}
+		return $groups;
+	}
+
 	/**
 	 * Increment the user's edit-count field.
 	 * Will have no effect for anonymous users.
@@ -3226,7 +3515,7 @@ class User {
 		// edit count in user cache too
 		$this->invalidateCache();
 	}
-	
+
 	/**
 	 * Get the description of a given right
 	 *
@@ -3234,8 +3523,6 @@ class User {
 	 * @return \string Localized description of the right
 	 */
 	static function getRightDescription( $right ) {
-		global $wgMessageCache;
-		$wgMessageCache->loadAllMessages();
 		$key = "right-$right";
 		$name = wfMsg( $key );
 		return $name == '' || wfEmptyMsg( $key, $name )
@@ -3263,7 +3550,7 @@ class User {
 	 * Make a new-style password hash
 	 *
 	 * @param $password \string Plain-text password
-	 * @param $salt \string Optional salt, may be random or the user ID. 
+	 * @param $salt \string Optional salt, may be random or the user ID.
 	 *                     If unspecified or false, will generate one automatically
 	 * @return \string Password hash
 	 */
@@ -3274,10 +3561,10 @@ class User {
 		if( !wfRunHooks( 'UserCryptPassword', array( &$password, &$salt, &$wgPasswordSalt, &$hash ) ) ) {
 			return $hash;
 		}
-		
+
 		if( $wgPasswordSalt ) {
 			if ( $salt === false ) {
-				$salt = substr( wfGenerateToken(), 0, 8 );
+				$salt = MWCryptRand::generateHex( 8 );
 			}
 			return ':B:' . $salt . ':' . md5( $salt . '-' . md5( $password ) );
 		} else {
@@ -3292,49 +3579,61 @@ class User {
 	 * @param $hash \string Password hash
 	 * @param $password \string Plain-text password to compare
 	 * @param $userId \string User ID for old-style password salt
-	 * @return \bool
+	 * @return Boolean:
 	 */
 	static function comparePasswords( $hash, $password, $userId = false ) {
-		$m = false;
 		$type = substr( $hash, 0, 3 );
-		
+
 		$result = false;
 		if( !wfRunHooks( 'UserComparePasswords', array( &$hash, &$password, &$userId, &$result ) ) ) {
 			return $result;
 		}
-		
+
 		if ( $type == ':A:' ) {
 			# Unsalted
 			return md5( $password ) === substr( $hash, 3 );
 		} elseif ( $type == ':B:' ) {
 			# Salted
 			list( $salt, $realHash ) = explode( ':', substr( $hash, 3 ), 2 );
-			return md5( $salt.'-'.md5( $password ) ) == $realHash;
+			return md5( $salt.'-'.md5( $password ) ) === $realHash;
 		} else {
 			# Old-style
 			return self::oldCrypt( $password, $userId ) === $hash;
 		}
 	}
-	
+
 	/**
 	 * Add a newuser log entry for this user
+	 *
 	 * @param $byEmail Boolean: account made by email?
+	 * @param $reason String: user supplied reason
 	 */
-	public function addNewUserLogEntry( $byEmail = false ) {
+	public function addNewUserLogEntry( $byEmail = false, $reason = '' ) {
 		global $wgUser, $wgContLang, $wgNewUserLog;
-		if( empty($wgNewUserLog) ) {
+		if( empty( $wgNewUserLog ) ) {
 			return true; // disabled
 		}
-		$talk = $wgContLang->getFormattedNsText( NS_TALK );
+
 		if( $this->getName() == $wgUser->getName() ) {
 			$action = 'create';
-			$message = '';
 		} else {
 			$action = 'create2';
-			$message = $byEmail ? wfMsgForContent( 'newuserlog-byemail' ) : '';
+			if ( $byEmail ) {
+				if ( $reason === '' ) {
+					$reason = wfMsgForContent( 'newuserlog-byemail' );
+				} else {
+					$reason = $wgContLang->commaList( array(
+						$reason, wfMsgForContent( 'newuserlog-byemail' ) ) );
+				}
+			}
 		}
 		$log = new LogPage( 'newusers' );
-		$log->addEntry( $action, $this->getUserPage(), $message, array( $this->getId() ) );
+		$log->addEntry(
+			$action,
+			$this->getUserPage(),
+			$reason,
+			array( $this->getId() )
+		);
 		return true;
 	}
 
@@ -3343,8 +3642,8 @@ class User {
 	 * Used by things like CentralAuth and perhaps other authplugins.
 	 */
 	public function addNewUserLogEntryAutoCreate() {
-		global $wgNewUserLog;
-		if( empty($wgNewUserLog) ) {
+		global $wgNewUserLog, $wgLogAutocreatedAccounts;
+		if( !$wgNewUserLog || !$wgLogAutocreatedAccounts ) {
 			return true; // disabled
 		}
 		$log = new LogPage( 'newusers', false );
@@ -3352,4 +3651,230 @@ class User {
 		return true;
 	}
 
+	protected function loadOptions() {
+		$this->load();
+		if ( $this->mOptionsLoaded || !$this->getId() )
+			return;
+
+		$this->mOptions = self::getDefaultOptions();
+
+		// Maybe load from the object
+		if ( !is_null( $this->mOptionOverrides ) ) {
+			wfDebug( "User: loading options for user " . $this->getId() . " from override cache.\n" );
+			foreach( $this->mOptionOverrides as $key => $value ) {
+				$this->mOptions[$key] = $value;
+			}
+		} else {
+			wfDebug( "User: loading options for user " . $this->getId() . " from database.\n" );
+			// Load from database
+			$dbr = wfGetDB( DB_SLAVE );
+
+			$res = $dbr->select(
+				'user_properties',
+				'*',
+				array( 'up_user' => $this->getId() ),
+				__METHOD__
+			);
+
+			foreach ( $res as $row ) {
+				$this->mOptionOverrides[$row->up_property] = $row->up_value;
+				$this->mOptions[$row->up_property] = $row->up_value;
+			}
+		}
+
+		$this->mOptionsLoaded = true;
+
+		wfRunHooks( 'UserLoadOptions', array( $this, &$this->mOptions ) );
+	}
+
+	protected function saveOptions() {
+		global $wgAllowPrefChange;
+
+		$extuser = ExternalUser::newFromUser( $this );
+
+		$this->loadOptions();
+		$dbw = wfGetDB( DB_MASTER );
+
+		$insert_rows = array();
+
+		$saveOptions = $this->mOptions;
+
+		// Allow hooks to abort, for instance to save to a global profile.
+		// Reset options to default state before saving.
+		if( !wfRunHooks( 'UserSaveOptions', array( $this, &$saveOptions ) ) )
+			return;
+
+		foreach( $saveOptions as $key => $value ) {
+			# Don't bother storing default values
+			if ( ( is_null( self::getDefaultOption( $key ) ) &&
+					!( $value === false || is_null($value) ) ) ||
+					$value != self::getDefaultOption( $key ) ) {
+				$insert_rows[] = array(
+						'up_user' => $this->getId(),
+						'up_property' => $key,
+						'up_value' => $value,
+					);
+			}
+			if ( $extuser && isset( $wgAllowPrefChange[$key] ) ) {
+				switch ( $wgAllowPrefChange[$key] ) {
+					case 'local':
+					case 'message':
+						break;
+					case 'semiglobal':
+					case 'global':
+						$extuser->setPref( $key, $value );
+				}
+			}
+		}
+
+		$dbw->begin();
+		$dbw->delete( 'user_properties', array( 'up_user' => $this->getId() ), __METHOD__ );
+		$dbw->insert( 'user_properties', $insert_rows, __METHOD__ );
+		$dbw->commit();
+	}
+
+	/**
+	 * Provide an array of HTML5 attributes to put on an input element
+	 * intended for the user to enter a new password.  This may include
+	 * required, title, and/or pattern, depending on $wgMinimalPasswordLength.
+	 *
+	 * Do *not* use this when asking the user to enter his current password!
+	 * Regardless of configuration, users may have invalid passwords for whatever
+	 * reason (e.g., they were set before requirements were tightened up).
+	 * Only use it when asking for a new password, like on account creation or
+	 * ResetPass.
+	 *
+	 * Obviously, you still need to do server-side checking.
+	 *
+	 * NOTE: A combination of bugs in various browsers means that this function
+	 * actually just returns array() unconditionally at the moment.  May as
+	 * well keep it around for when the browser bugs get fixed, though.
+	 *
+	 * @return array Array of HTML attributes suitable for feeding to
+	 *   Html::element(), directly or indirectly.  (Don't feed to Xml::*()!
+	 *   That will potentially output invalid XHTML 1.0 Transitional, and will
+	 *   get confused by the boolean attribute syntax used.)
+	 */
+	public static function passwordChangeInputAttribs() {
+		global $wgMinimalPasswordLength;
+
+		if ( $wgMinimalPasswordLength == 0 ) {
+			return array();
+		}
+
+		# Note that the pattern requirement will always be satisfied if the
+		# input is empty, so we need required in all cases.
+		#
+		# FIXME (bug 23769): This needs to not claim the password is required
+		# if e-mail confirmation is being used.  Since HTML5 input validation
+		# is b0rked anyway in some browsers, just return nothing.  When it's
+		# re-enabled, fix this code to not output required for e-mail
+		# registration.
+		#$ret = array( 'required' );
+		$ret = array();
+
+		# We can't actually do this right now, because Opera 9.6 will print out
+		# the entered password visibly in its error message!  When other
+		# browsers add support for this attribute, or Opera fixes its support,
+		# we can add support with a version check to avoid doing this on Opera
+		# versions where it will be a problem.  Reported to Opera as
+		# DSK-262266, but they don't have a public bug tracker for us to follow.
+		/*
+		if ( $wgMinimalPasswordLength > 1 ) {
+			$ret['pattern'] = '.{' . intval( $wgMinimalPasswordLength ) . ',}';
+			$ret['title'] = wfMsgExt( 'passwordtooshort', 'parsemag',
+				$wgMinimalPasswordLength );
+		}
+		*/
+
+		return $ret;
+	}
+
+	/**
+	 * Format the user message using a hook, a template, or, failing these, a static format.
+	 * @param $subject   String the subject of the message
+	 * @param $text      String the content of the message
+	 * @param $signature String the signature, if provided.
+	 */
+	static protected function formatUserMessage( $subject, $text, $signature ) {
+		if ( wfRunHooks( 'FormatUserMessage',
+				array( $subject, &$text, $signature ) ) ) {
+
+			$signature = empty($signature) ? "~~~~~" : "{$signature} ~~~~~";
+
+			$template = Title::newFromText( wfMsgForContent( 'usermessage-template' ) );
+			if ( !$template
+					|| $template->getNamespace() !== NS_TEMPLATE
+					|| !$template->exists() ) {
+				$text = "\n== $subject ==\n\n$text\n\n-- $signature";
+			} else {
+				$text = '{{'. $template->getText()
+					. " | subject=$subject | body=$text | signature=$signature }}";
+			}
+		}
+
+		return $text;
+	}
+
+	/**
+	 * Leave a user a message
+	 * @param $subject String the subject of the message
+	 * @param $text String the message to leave
+	 * @param $signature String Text to leave in the signature
+	 * @param $summary String the summary for this change, defaults to
+	 *                        "Leave system message."
+	 * @param $editor User The user leaving the message, defaults to
+	 *                        "{{MediaWiki:usermessage-editor}}"
+	 * @param $flags Int default edit flags
+	 *
+	 * @return boolean true if it was successful
+	 */
+	public function leaveUserMessage( $subject, $text, $signature = "",
+			$summary = null, $editor = null, $flags = 0 ) {
+		if ( !isset( $summary ) ) {
+			$summary = wfMsgForContent( 'usermessage-summary' );
+		}
+
+		if ( !isset( $editor ) ) {
+			$editor = User::newFromName( wfMsgForContent( 'usermessage-editor' ) );
+			if ( !$editor->isLoggedIn() ) {
+				$editor->addToDatabase();
+			}
+		}
+
+		$article = new Article( $this->getTalkPage() );
+		wfRunHooks( 'SetupUserMessageArticle',
+			array( $this, &$article, $subject, $text, $signature, $summary, $editor ) );
+
+
+		$text = self::formatUserMessage( $subject, $text, $signature );
+		$flags = $article->checkFlags( $flags );
+
+		if ( $flags & EDIT_UPDATE ) {
+			$text = $article->getContent() . $text;
+		}
+
+		$dbw = wfGetDB( DB_MASTER );
+		$dbw->begin();
+
+		try {
+			$status = $article->doEdit( $text, $summary, $flags, false, $editor );
+		} catch ( DBQueryError $e ) {
+			$status = Status::newFatal("DB Error");
+		}
+
+		if ( $status->isGood() ) {
+			// Set newtalk with the right user ID
+			$this->setNewtalk( true );
+			wfRunHooks( 'AfterUserMessage',
+				array( $this, $article, $summary, $text, $signature, $summary, $editor ) );
+			$dbw->commit();
+		} else {
+			// The article was concurrently created
+			wfDebug( __METHOD__ . ": Error ".$status->getWikiText() );
+			$dbw->rollback();
+		}
+
+		return $status->isGood();
+	}
 }