Aktualisierung auf MediaWiki 1.9.0

1 files changed, 820 insertions, 443 deletions

diff --git a/includes/User.php b/includes/User.php
index aa964d22..35ff8299 100644
--- a/includes/User.php
+++ b/includes/User.php
@@ -9,43 +9,31 @@
 define( 'USER_TOKEN_LENGTH', 32 );
 
 # Serialized record version
-define( 'MW_USER_VERSION', 3 );
+define( 'MW_USER_VERSION', 4 );
+
+# Some punctuation to prevent editing from broken text-mangling proxies.
+# FIXME: this is embedded unescaped into HTML attributes in various
+# places, so we can't safely include ' or " even though we really should.
+define( 'EDIT_TOKEN_SUFFIX', '\\' );
+
+/**
+ * Thrown by User::setPassword() on error
+ */
+class PasswordError extends MWException {
+	// NOP
+}
 
 /**
  *
  * @package MediaWiki
  */
 class User {
-	/*
-	 * When adding a new private variable, dont forget to add it to __sleep()
-	 */
-	/**@{{
-	 * @private
-	 */
-	var $mBlockedby;	//!<
-	var $mBlockreason;	//!<
-	var $mBlock;        //!<
-	var $mDataLoaded;	//!<
-	var $mEmail;		//!<
-	var $mEmailAuthenticated; //!<
-	var $mGroups;		//!<
-	var $mHash;			//!<
-	var $mId;			//!<
-	var $mName;			//!<
-	var $mNewpassword;	//!<
-	var $mNewtalk;		//!<
-	var $mOptions;		//!<
-	var $mPassword;		//!<
-	var $mRealName;		//!<
-	var $mRegistration;	//!<
-	var $mRights;		//!<
-	var $mSkin;			//!<
-	var $mToken;		//!<
-	var $mTouched;		//!<
-	var $mDatePreference; // !<
-	var $mVersion;		//!< serialized version
-	/**@}} */
 
+	/**
+	 * 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 $wgContLang->getExtraUserToggles().
+	 */
 	static public $mToggles = array(
 		'highlightbroken',
 		'justify',
@@ -62,6 +50,8 @@ class User {
 		'editwidth',
 		'watchcreations',
 		'watchdefault',
+		'watchmoves',
+		'watchdeletion',
 		'minordefault',
 		'previewontop',
 		'previewonfirst',
@@ -76,53 +66,200 @@ class User {
 		'externaldiff',
 		'showjumplinks',
 		'uselivepreview',
-		'autopatrol',
 		'forceeditsummary',
 		'watchlisthideown',
 		'watchlisthidebots',
-	);		
+		'watchlisthideminor',
+		'ccmeonemails',
+	);
+
+	/**
+	 * 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.
+	 */
+	static $mCacheVars = array(
+		# user table
+		'mId',
+		'mName',
+		'mRealName',
+		'mPassword',
+		'mNewpassword',
+		'mNewpassTime',
+		'mEmail',
+		'mOptions',
+		'mTouched',
+		'mToken',
+		'mEmailAuthenticated',
+		'mEmailToken',
+		'mEmailTokenExpires',
+		'mRegistration',
+		
+		# user_group table
+		'mGroups',
+	);
+
+	/**
+	 * The cache variable declarations
+	 */
+	var $mId, $mName, $mRealName, $mPassword, $mNewpassword, $mNewpassTime, 
+		$mEmail, $mOptions, $mTouched, $mToken, $mEmailAuthenticated, 
+		$mEmailToken, $mEmailTokenExpires, $mRegistration, $mGroups;
 
-	/** Constructor using User:loadDefaults() */
-	function User()	{
-		$this->loadDefaults();
-		$this->mVersion = MW_USER_VERSION;
+	/**
+	 * Whether the cache variables have been loaded
+	 */
+	var $mDataLoaded;
+
+	/**
+	 * Initialisation data source if mDataLoaded==false. May be one of:
+	 *    defaults      anonymous user initialised from class defaults
+	 *    name          initialise from mName
+	 *    id            initialise from mId
+	 *    session       log in from cookies or session if possible
+	 *
+	 * Use the User::newFrom*() family of functions to set this.
+	 */
+	var $mFrom;
+
+	/**
+	 * Lazy-initialised variables, invalidated with clearInstanceCache
+	 */
+	var $mNewtalk, $mDatePreference, $mBlockedby, $mHash, $mSkin, $mRights,
+		$mBlockreason, $mBlock, $mEffectiveGroups;
+
+	/** 
+	 * Lightweight constructor for anonymous user
+	 * Use the User::newFrom* factory functions for other kinds of users
+	 */
+	function User() {
+		$this->clearInstanceCache( 'defaults' );
 	}
 
 	/**
-	 * Static factory method
-	 * @param string $name Username, validated by Title:newFromText()
-	 * @param bool $validate Validate username
-	 * @return User
-	 * @static
+	 * Load the user table data for this object from the source given by mFrom
 	 */
-	function newFromName( $name, $validate = true ) {
-		# Force usernames to capital
-		global $wgContLang;
-		$name = $wgContLang->ucfirst( $name );
+	function load() {
+		if ( $this->mDataLoaded ) {
+			return;
+		}
+		wfProfileIn( __METHOD__ );
 
-		# Clean up name according to title rules
-		$t = Title::newFromText( $name );
-		if( is_null( $t ) ) {
-			return null;
+		# Set it now to avoid infinite recursion in accessors
+		$this->mDataLoaded = true;
+
+		switch ( $this->mFrom ) {
+			case 'defaults':
+				$this->loadDefaults();
+				break;
+			case 'name':
+				$this->mId = self::idFromName( $this->mName );
+				if ( !$this->mId ) {
+					# Nonexistent user placeholder object
+					$this->loadDefaults( $this->mName );
+				} else {
+					$this->loadFromId();
+				}
+				break;
+			case 'id':
+				$this->loadFromId();
+				break;
+			case 'session':
+				$this->loadFromSession();
+				break;
+			default:
+				throw new MWException( "Unrecognised value for User->mFrom: \"{$this->mFrom}\"" );
 		}
+		wfProfileOut( __METHOD__ );
+	}
 
-		# Reject various classes of invalid names
-		$canonicalName = $t->getText();
-		global $wgAuth;
-		$canonicalName = $wgAuth->getCanonicalName( $t->getText() );
+	/**
+	 * Load user table data given mId
+	 * @return false if the ID does not exist, true otherwise
+	 * @private
+	 */
+	function loadFromId() {
+		global $wgMemc;
+		if ( $this->mId == 0 ) {
+			$this->loadDefaults();
+			return false;
+		} 
+
+		# Try cache
+		$key = wfMemcKey( 'user', 'id', $this->mId );
+		$data = $wgMemc->get( $key );
+		
+		if ( !is_array( $data ) || $data['mVersion'] < MW_USER_VERSION ) {
+			# Object is expired, load from DB
+			$data = false;
+		}
+		
+		if ( !$data ) {
+			wfDebug( "Cache miss for user {$this->mId}\n" );
+			# Load from DB
+			if ( !$this->loadFromDatabase() ) {
+				# Can't load from ID, user is anonymous
+				return false;
+			}
+
+			# Save to cache
+			$data = array();
+			foreach ( self::$mCacheVars as $name ) {
+				$data[$name] = $this->$name;
+			}
+			$data['mVersion'] = MW_USER_VERSION;
+			$wgMemc->set( $key, $data );
+		} else {
+			wfDebug( "Got user {$this->mId} from cache\n" );
+			# Restore from cache
+			foreach ( self::$mCacheVars as $name ) {
+				$this->$name = $data[$name];
+			}
+		}
+		return true;
+	}
 
-		if( $validate && !User::isValidUserName( $canonicalName ) ) {
+	/**
+	 * Static factory method for creation from username.
+	 *
+	 * This is slightly less efficient than newFromId(), so use newFromId() if
+	 * you have both an ID and a name handy. 
+	 *
+	 * @param string $name Username, validated by Title:newFromText()
+	 * @param mixed $validate Validate username. Takes the same parameters as 
+	 *    User::getCanonicalName(), except that true is accepted as an alias 
+	 *    for 'valid', for BC.
+	 * 
+	 * @return 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 with
+	 *    a name, zero user ID and default settings. 
+	 * @static
+	 */
+	static function newFromName( $name, $validate = 'valid' ) {
+		if ( $validate === true ) {
+			$validate = 'valid';
+		}
+		$name = self::getCanonicalName( $name, $validate );
+		if ( $name === false ) {
 			return null;
+		} else {
+			# Create unloaded user object
+			$u = new User;
+			$u->mName = $name;
+			$u->mFrom = 'name';
+			return $u;
 		}
+	}
 
-		$u = new User();
-		$u->setName( $canonicalName );
-		$u->setId( $u->idFromName( $canonicalName ) );
+	static function newFromId( $id ) {
+		$u = new User;
+		$u->mId = $id;
+		$u->mFrom = 'id';
 		return $u;
 	}
 
 	/**
-	 * Factory method to fetch whichever use has a given email confirmation code.
+	 * Factory method to fetch whichever user has a given email confirmation code.
 	 * This code is generated when an account is created or its e-mail address
 	 * has changed.
 	 *
@@ -132,44 +269,30 @@ class User {
 	 * @return User
 	 * @static
 	 */
-	function newFromConfirmationCode( $code ) {
+	static function newFromConfirmationCode( $code ) {
 		$dbr =& wfGetDB( DB_SLAVE );
-		$name = $dbr->selectField( 'user', 'user_name', array(
+		$id = $dbr->selectField( 'user', 'user_id', array(
 			'user_email_token' => md5( $code ),
 			'user_email_token_expires > ' . $dbr->addQuotes( $dbr->timestamp() ),
 			) );
-		if( is_string( $name ) ) {
-			return User::newFromName( $name );
+		if( $id !== false ) {
+			return User::newFromId( $id );
 		} else {
 			return null;
 		}
 	}
-
+	
 	/**
-	 * Serialze sleep function, for better cache efficiency and avoidance of
-	 * silly "incomplete type" errors when skins are cached. The array should
-	 * contain names of private variables (see at top of User.php).
+	 * Create a new user object using data from session or cookies. If the
+	 * login credentials are invalid, the result is an anonymous user.
+	 *
+	 * @return User
+	 * @static
 	 */
-	function __sleep() {
-		return array(
-'mDataLoaded',
-'mEmail',
-'mEmailAuthenticated',
-'mGroups',
-'mHash',
-'mId',
-'mName',
-'mNewpassword',
-'mNewtalk',
-'mOptions',
-'mPassword',
-'mRealName',
-'mRegistration',
-'mRights',
-'mToken',
-'mTouched',
-'mVersion',
-);
+	static function newFromSession() {
+		$user = new User;
+		$user->mFrom = 'session';
+		return $user;
 	}
 
 	/**
@@ -178,7 +301,7 @@ class User {
 	 * @return string Nickname of a user
 	 * @static
 	 */
-	function whoIs( $id )	{
+	static function whoIs( $id ) {
 		$dbr =& wfGetDB( DB_SLAVE );
 		return $dbr->selectField( 'user', 'user_name', array( 'user_id' => $id ), 'User::whoIs' );
 	}
@@ -189,7 +312,7 @@ class User {
 	 * @return string Realname of a user
 	 * @static
 	 */
-	function whoIsReal( $id )	{
+	static function whoIsReal( $id ) {
 		$dbr =& wfGetDB( DB_SLAVE );
 		return $dbr->selectField( 'user', 'user_real_name', array( 'user_id' => $id ), 'User::whoIsReal' );
 	}
@@ -200,16 +323,14 @@ class User {
 	 * @return integer|null Database user id (null: if non existent
 	 * @static
 	 */
-	function idFromName( $name ) {
-		$fname = "User::idFromName";
-
+	static function idFromName( $name ) {
 		$nt = Title::newFromText( $name );
 		if( is_null( $nt ) ) {
 			# Illegal name
 			return null;
 		}
 		$dbr =& wfGetDB( DB_SLAVE );
-		$s = $dbr->selectRow( 'user', array( 'user_id' ), array( 'user_name' => $nt->getText() ), $fname );
+		$s = $dbr->selectRow( 'user', array( 'user_id' ), array( 'user_name' => $nt->getText() ), __METHOD__ );
 
 		if ( $s === false ) {
 			return 0;
@@ -237,8 +358,8 @@ class User {
 	 * @param string $name Nickname of a user
 	 * @return bool
 	 */
-	function isIP( $name ) {
-		return preg_match("/^\d{1,3}\.\d{1,3}\.\d{1,3}\.(?:xxx|\d{1,3})$/",$name);
+	static function isIP( $name ) {
+		return preg_match('/^\d{1,3}\.\d{1,3}\.\d{1,3}\.(?:xxx|\d{1,3})$/',$name);
 		/*return preg_match("/^
 			(?:[01]?\d{1,2}|2(:?[0-4]\d|5[0-5]))\.
 			(?:[01]?\d{1,2}|2(:?[0-4]\d|5[0-5]))\.
@@ -259,7 +380,7 @@ class User {
 	 * @return bool
 	 * @static
 	 */
-	function isValidUserName( $name ) {
+	static function isValidUserName( $name ) {
 		global $wgContLang, $wgMaxNameChars;
 
 		if ( $name == ''
@@ -343,7 +464,7 @@ class User {
 	 * @return bool
 	 * @static
 	 */
-	function isValidPassword( $password ) {
+	static function isValidPassword( $password ) {
 		global $wgMinimalPasswordLength;
 		return strlen( $password ) >= $wgMinimalPasswordLength;
 	}
@@ -362,35 +483,85 @@ class User {
 	 * @static
 	 * @return bool
 	 */
-	function isValidEmailAddr ( $addr ) {
+	static function isValidEmailAddr ( $addr ) {
 		return ( trim( $addr ) != '' ) &&
 			(false !== strpos( $addr, '@' ) );
 	}
 
 	/**
+	 * Given unvalidated user input, return a canonical username, or false if 
+	 * the username is invalid.
+	 * @param string $name
+	 * @param mixed $validate Type of validation to use:
+	 *                         false        No validation
+	 *                         'valid'      Valid for batch processes
+	 *                         'usable'     Valid for batch processes and login
+	 *                         'creatable'  Valid for batch processes, login and account creation
+	 */
+	static function getCanonicalName( $name, $validate = 'valid' ) {
+		# Force usernames to capital
+		global $wgContLang;
+		$name = $wgContLang->ucfirst( $name );
+
+		# Clean up name according to title rules
+		$t = Title::newFromText( $name );
+		if( is_null( $t ) ) {
+			return false;
+		}
+
+		# Reject various classes of invalid names
+		$name = $t->getText();
+		global $wgAuth;
+		$name = $wgAuth->getCanonicalName( $t->getText() );
+
+		switch ( $validate ) {
+			case false:
+				break;
+			case 'valid':
+				if ( !User::isValidUserName( $name ) ) {
+					$name = false;
+				}
+				break;
+			case 'usable':
+				if ( !User::isUsableName( $name ) ) {
+					$name = false;
+				}
+				break;
+			case 'creatable':
+				if ( !User::isCreatableName( $name ) ) {
+					$name = false;
+				}
+				break;
+			default:
+				throw new MWException( 'Invalid parameter value for $validate in '.__METHOD__ );
+		}
+		return $name;
+	}
+
+	/**
 	 * Count the number of edits of a user
 	 *
 	 * @param int $uid The user ID to check
 	 * @return int
+	 * @static
 	 */
-	function edits( $uid ) {
-		$fname = 'User::edits';
-
+	static function edits( $uid ) {
 		$dbr =& wfGetDB( DB_SLAVE );
 		return $dbr->selectField(
 			'revision', 'count(*)',
 			array( 'rev_user' => $uid ),
-			$fname
+			__METHOD__
 		);
 	}
 
 	/**
-	 * probably return a random password
-	 * @return string probably a random password
+	 * Return a random password. Sourced from mt_rand, so it's not particularly secure.
+	 * @todo: hash random numbers to improve security, like generateToken()
+	 *
+	 * @return string
 	 * @static
-	 * @todo Check what is doing really [AV]
 	 */
-	function randomPassword() {
+	static function randomPassword() {
 		global $wgMinimalPasswordLength;
 		$pwchars = 'ABCDEFGHJKLMNPQRSTUVWXYZabcdefghjkmnpqrstuvwxyz';
 		$l = strlen( $pwchars ) - 1;
@@ -405,57 +576,196 @@ class User {
 	}
 
 	/**
-	 * Set properties to default
-	 * Used at construction. It will load per language default settings only
-	 * if we have an available language object.
+	 * Set cached properties to default. Note: this no longer clears 
+	 * uncached lazy-initialised properties. The constructor does that instead.
+	 *
+	 * @private
 	 */
-	function loadDefaults() {
-		static $n=0;
-		$n++;
-		$fname = 'User::loadDefaults' . $n;
-		wfProfileIn( $fname );
+	function loadDefaults( $name = false ) {
+		wfProfileIn( __METHOD__ );
 
 		global $wgCookiePrefix;
-		global $wgNamespacesToBeSearchedDefault;
 
 		$this->mId = 0;
-		$this->mNewtalk = -1;
-		$this->mName = false;
-		$this->mRealName = $this->mEmail = '';
-		$this->mEmailAuthenticated = null;
+		$this->mName = $name;
+		$this->mRealName = '';
 		$this->mPassword = $this->mNewpassword = '';
-		$this->mRights = array();
-		$this->mGroups = array();
-		$this->mOptions = null;
-		$this->mDatePreference = null;
-
-		unset( $this->mSkin );
-		$this->mDataLoaded = false;
-		$this->mBlockedby = -1; # Unset
-		$this->setToken(); # Random
-		$this->mHash = false;
+		$this->mNewpassTime = null;
+		$this->mEmail = '';
+		$this->mOptions = null; # Defer init
 
 		if ( isset( $_COOKIE[$wgCookiePrefix.'LoggedOut'] ) ) {
 			$this->mTouched = wfTimestamp( TS_MW, $_COOKIE[$wgCookiePrefix.'LoggedOut'] );
-		}
-		else {
+		} else {
 			$this->mTouched = '0'; # Allow any pages to be cached
 		}
 
+		$this->setToken(); # Random
+		$this->mEmailAuthenticated = null;
+		$this->mEmailToken = '';
+		$this->mEmailTokenExpires = null;
 		$this->mRegistration = wfTimestamp( TS_MW );
+		$this->mGroups = array();
+
+		wfProfileOut( __METHOD__ );
+	}
+	
+	/**
+	 * Initialise php session
+	 * @deprecated use wfSetupSession()
+	 */
+	function SetupSession() {
+		wfSetupSession();
+	}
+
+	/**
+	 * Load user data from the session or login cookie. If there are no valid
+	 * credentials, initialises the user as an anon.
+	 * @return true if the user is logged in, false otherwise
+	 * 
+	 * @private
+	 */
+	function loadFromSession() {
+		global $wgMemc, $wgCookiePrefix;
+
+		if ( isset( $_SESSION['wsUserID'] ) ) {
+			if ( 0 != $_SESSION['wsUserID'] ) {
+				$sId = $_SESSION['wsUserID'];
+			} else {
+				$this->loadDefaults();
+				return false;
+			}
+		} else if ( isset( $_COOKIE["{$wgCookiePrefix}UserID"] ) ) {
+			$sId = intval( $_COOKIE["{$wgCookiePrefix}UserID"] );
+			$_SESSION['wsUserID'] = $sId;
+		} else {
+			$this->loadDefaults();
+			return false;
+		}
+		if ( isset( $_SESSION['wsUserName'] ) ) {
+			$sName = $_SESSION['wsUserName'];
+		} else if ( isset( $_COOKIE["{$wgCookiePrefix}UserName"] ) ) {
+			$sName = $_COOKIE["{$wgCookiePrefix}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
+			return false;
+		}
+		
+		if ( isset( $_SESSION['wsToken'] ) ) {
+			$passwordCorrect = $_SESSION['wsToken'] == $this->mToken;
+			$from = 'session';
+		} else if ( isset( $_COOKIE["{$wgCookiePrefix}Token"] ) ) {
+			$passwordCorrect = $this->mToken == $_COOKIE["{$wgCookiePrefix}Token"];
+			$from = 'cookie';
+		} else {
+			# No session or persistent login cookie
+			$this->loadDefaults();
+			return false;
+		}
+
+		if ( ( $sName == $this->mName ) && $passwordCorrect ) {
+			wfDebug( "Logged in from $from\n" );
+			return true;
+		} else {
+			# Invalid credentials
+			wfDebug( "Can't log in from $from, invalid credentials\n" );
+			$this->loadDefaults();
+			return false;
+		}
+	}
+	
+	/**
+	 * Load user and user_group data from the database
+	 * $this->mId must be set, this is how the user is identified.
+	 * 
+	 * @return true if the user exists, false if the user is anonymous
+	 * @private
+	 */
+	function loadFromDatabase() {
+		# Paranoia
+		$this->mId = intval( $this->mId );
+
+		/** Anonymous user */
+		if( !$this->mId ) {
+			$this->loadDefaults();
+			return false;
+		}
 
-		wfProfileOut( $fname );
+		$dbr =& wfGetDB( DB_MASTER );
+		$s = $dbr->selectRow( 'user', '*', array( 'user_id' => $this->mId ), __METHOD__ );
+
+		if ( $s !== false ) {
+			# Initialise user table data
+			$this->mName = $s->user_name;
+			$this->mRealName = $s->user_real_name;
+			$this->mPassword = $s->user_password;
+			$this->mNewpassword = $s->user_newpassword;
+			$this->mNewpassTime = wfTimestampOrNull( TS_MW, $s->user_newpass_time );
+			$this->mEmail = $s->user_email;
+			$this->decodeOptions( $s->user_options );
+			$this->mTouched = wfTimestamp(TS_MW,$s->user_touched);
+			$this->mToken = $s->user_token;
+			$this->mEmailAuthenticated = wfTimestampOrNull( TS_MW, $s->user_email_authenticated );
+			$this->mEmailToken = $s->user_email_token;
+			$this->mEmailTokenExpires = wfTimestampOrNull( TS_MW, $s->user_email_token_expires );
+			$this->mRegistration = wfTimestampOrNull( TS_MW, $s->user_registration );
+
+			# Load group data
+			$res = $dbr->select( 'user_groups',
+				array( 'ug_group' ),
+				array( 'ug_user' => $this->mId ),
+				__METHOD__ );
+			$this->mGroups = array();
+			while( $row = $dbr->fetchObject( $res ) ) {
+				$this->mGroups[] = $row->ug_group;
+			}
+			return true;
+		} else {
+			# Invalid user_id
+			$this->mId = 0;
+			$this->loadDefaults();
+			return false;
+		}
+	}
+
+	/**
+	 * Clear various cached data stored in this object. 
+	 * @param string $reloadFrom Reload user and user_groups table data from a 
+	 *   given source. May be "name", "id", "defaults", "session" or false for 
+	 *   no reload.
+	 */
+	function clearInstanceCache( $reloadFrom = false ) {
+		$this->mNewtalk = -1;
+		$this->mDatePreference = null;
+		$this->mBlockedby = -1; # Unset
+		$this->mHash = false;
+		$this->mSkin = null;
+		$this->mRights = null;
+		$this->mEffectiveGroups = null;
+
+		if ( $reloadFrom ) {
+			$this->mDataLoaded = false;
+			$this->mFrom = $reloadFrom;
+		}
 	}
 
 	/**
 	 * Combine the language default options with any site-specific options
 	 * and add the default language variants.
-	 *
+	 * Not really private cause it's called by Language class
 	 * @return array
 	 * @static
 	 * @private
 	 */
-	function getDefaultOptions() {
+	static function getDefaultOptions() {
 		global $wgNamespacesToBeSearchedDefault;
 		/**
 		 * Site defaults will override the global/language defaults
@@ -520,18 +830,22 @@ class User {
 			return;
 		}
 
-		$fname = 'User::getBlockedStatus';
-		wfProfileIn( $fname );
-		wfDebug( "$fname: checking...\n" );
+		wfProfileIn( __METHOD__ );
+		wfDebug( __METHOD__.": checking...\n" );
 
 		$this->mBlockedby = 0;
 		$ip = wfGetIP();
 
+		if ($this->isAllowed( 'ipblock-exempt' ) ) {
+			# Exempt from all types of IP-block
+			$ip = '';
+		}
+
 		# User/IP blocking
 		$this->mBlock = new Block();
 		$this->mBlock->fromMaster( !$bFromSlave );
 		if ( $this->mBlock->load( $ip , $this->mId ) ) {
-			wfDebug( "$fname: Found block.\n" );
+			wfDebug( __METHOD__.": Found block.\n" );
 			$this->mBlockedby = $this->mBlock->mBy;
 			$this->mBlockreason = $this->mBlock->mReason;
 			if ( $this->isLoggedIn() ) {
@@ -539,7 +853,7 @@ class User {
 			}
 		} else {
 			$this->mBlock = null;
-			wfDebug( "$fname: No block.\n" );
+			wfDebug( __METHOD__.": No block.\n" );
 		}
 
 		# Proxy blocking
@@ -563,22 +877,23 @@ class User {
 		# Extensions
 		wfRunHooks( 'GetBlockedStatus', array( &$this ) );
 
-		wfProfileOut( $fname );
+		wfProfileOut( __METHOD__ );
 	}
 
 	function inSorbsBlacklist( $ip ) {
-		global $wgEnableSorbs;
+		global $wgEnableSorbs, $wgSorbsUrl;
+
 		return $wgEnableSorbs &&
-			$this->inDnsBlacklist( $ip, 'http.dnsbl.sorbs.net.' );
+			$this->inDnsBlacklist( $ip, $wgSorbsUrl );
 	}
 
 	function inDnsBlacklist( $ip, $base ) {
-		$fname = 'User::inDnsBlacklist';
-		wfProfileIn( $fname );
+		wfProfileIn( __METHOD__ );
 
 		$found = false;
 		$host = '';
 
+		$m = array();
 		if ( preg_match( '/^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/', $ip, $m ) ) {
 			# Make hostname
 			for ( $i=4; $i>=1; $i-- ) {
@@ -597,7 +912,7 @@ class User {
 			}
 		}
 
-		wfProfileOut( $fname );
+		wfProfileOut( __METHOD__ );
 		return $found;
 	}
 
@@ -612,6 +927,13 @@ class User {
 	 * @public
 	 */
 	function pingLimiter( $action='edit' ) {
+	
+		# Call the 'PingLimiter' hook
+		$result = false;
+		if( !wfRunHooks( 'PingLimiter', array( &$this, $action, $result ) ) ) {
+			return $result;
+		}
+		
 		global $wgRateLimits, $wgRateLimitsExcludedGroups;
 		if( !isset( $wgRateLimits[$action] ) ) {
 			return false;
@@ -624,8 +946,7 @@ class User {
 		}
 		
 		global $wgMemc, $wgRateLimitLog;
-		$fname = 'User::pingLimiter';
-		wfProfileIn( $fname );
+		wfProfileIn( __METHOD__ );
 
 		$limits = $wgRateLimits[$action];
 		$keys = array();
@@ -646,6 +967,7 @@ class User {
 			if( isset( $limits['ip'] ) ) {
 				$keys["mediawiki:limiter:$action:ip:$ip"] = $limits['ip'];
 			}
+			$matches = array();
 			if( isset( $limits['subnet'] ) && preg_match( '/^(\d+\.\d+\.\d+)\.\d+$/', $ip, $matches ) ) {
 				$subnet = $matches[1];
 				$keys["mediawiki:limiter:$action:subnet:$subnet"] = $limits['subnet'];
@@ -659,22 +981,22 @@ class User {
 			$count = $wgMemc->get( $key );
 			if( $count ) {
 				if( $count > $max ) {
-					wfDebug( "$fname: 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( "$fname: ok. $key at $count $summary\n" );
+					wfDebug( __METHOD__.": ok. $key at $count $summary\n" );
 				}
 			} else {
-				wfDebug( "$fname: adding record for $key $summary\n" );
+				wfDebug( __METHOD__.": adding record for $key $summary\n" );
 				$wgMemc->add( $key, 1, intval( $period ) );
 			}
 			$wgMemc->incr( $key );
 		}
 
-		wfProfileOut( $fname );
+		wfProfileOut( __METHOD__ );
 		return $triggered;
 	}
 
@@ -693,20 +1015,19 @@ class User {
 	 */
 	function isBlockedFrom( $title, $bFromSlave = false ) {
 		global $wgBlockAllowsUTEdit;
-		$fname = 'User::isBlockedFrom';
-		wfProfileIn( $fname );
-		wfDebug( "$fname: enter\n" );
+		wfProfileIn( __METHOD__ );
+		wfDebug( __METHOD__.": enter\n" );
 
 		if ( $wgBlockAllowsUTEdit && $title->getText() === $this->getName() &&
 		  $title->getNamespace() == NS_USER_TALK )
 		{
 			$blocked = false;
-			wfDebug( "$fname: self-talk page, ignoring any blocks\n" );
+			wfDebug( __METHOD__.": self-talk page, ignoring any blocks\n" );
 		} else {
-			wfDebug( "$fname: asking isBlocked()\n" );
+			wfDebug( __METHOD__.": asking isBlocked()\n" );
 			$blocked = $this->isBlocked( $bFromSlave );
 		}
-		wfProfileOut( $fname );
+		wfProfileOut( __METHOD__ );
 		return $blocked;
 	}
 
@@ -729,174 +1050,55 @@ class User {
 	}
 
 	/**
-	 * Initialise php session
-	 * @deprecated use wfSetupSession()
+	 * Get the user ID. Returns 0 if the user is anonymous or nonexistent.
 	 */
-	function SetupSession() {
-		wfSetupSession();
-	}
-
-	/**
-	 * Create a new user object using data from session
-	 * @static
-	 */
-	function loadFromSession() {
-		global $wgMemc, $wgCookiePrefix;
-
-		if ( isset( $_SESSION['wsUserID'] ) ) {
-			if ( 0 != $_SESSION['wsUserID'] ) {
-				$sId = $_SESSION['wsUserID'];
-			} else {
-				return new User();
-			}
-		} else if ( isset( $_COOKIE["{$wgCookiePrefix}UserID"] ) ) {
-			$sId = intval( $_COOKIE["{$wgCookiePrefix}UserID"] );
-			$_SESSION['wsUserID'] = $sId;
-		} else {
-			return new User();
-		}
-		if ( isset( $_SESSION['wsUserName'] ) ) {
-			$sName = $_SESSION['wsUserName'];
-		} else if ( isset( $_COOKIE["{$wgCookiePrefix}UserName"] ) ) {
-			$sName = $_COOKIE["{$wgCookiePrefix}UserName"];
-			$_SESSION['wsUserName'] = $sName;
-		} else {
-			return new User();
-		}
-
-		$passwordCorrect = FALSE;
-		$user = $wgMemc->get( $key = wfMemcKey( 'user', 'id', $sId ) );
-		if( !is_object( $user ) || $user->mVersion < MW_USER_VERSION ) {
-			# Expire old serialized objects; they may be corrupt.
-			$user = false;
-		}
-		if($makenew = !$user) {
-			wfDebug( "User::loadFromSession() unable to load from memcached\n" );
-			$user = new User();
-			$user->mId = $sId;
-			$user->loadFromDatabase();
-		} else {
-			wfDebug( "User::loadFromSession() got from cache!\n" );
-			# Set block status to unloaded, that should be loaded every time
-			$user->mBlockedby = -1;
-		}
-
-		if ( isset( $_SESSION['wsToken'] ) ) {
-			$passwordCorrect = $_SESSION['wsToken'] == $user->mToken;
-		} else if ( isset( $_COOKIE["{$wgCookiePrefix}Token"] ) ) {
-			$passwordCorrect = $user->mToken == $_COOKIE["{$wgCookiePrefix}Token"];
-		} else {
-			return new User(); # Can't log in from session
-		}
-
-		if ( ( $sName == $user->mName ) && $passwordCorrect ) {
-			if($makenew) {
-				if($wgMemc->set( $key, $user ))
-					wfDebug( "User::loadFromSession() successfully saved user\n" );
-				else
-					wfDebug( "User::loadFromSession() unable to save to memcached\n" );
-			}
-			return $user;
-		}
-		return new User(); # Can't log in from session
+	function getID() { 
+		$this->load();
+		return $this->mId; 
 	}
 
 	/**
-	 * Load a user from the database
+	 * Set the user and reload all fields according to that ID
+	 * @deprecated use User::newFromId()
 	 */
-	function loadFromDatabase() {
-		$fname = "User::loadFromDatabase";
-
-		# Counter-intuitive, breaks various things, use User::setLoaded() if you want to suppress
-		# loading in a command line script, don't assume all command line scripts need it like this
-		#if ( $this->mDataLoaded || $wgCommandLineMode ) {
-		if ( $this->mDataLoaded ) {
-			return;
-		}
-
-		# Paranoia
-		$this->mId = intval( $this->mId );
-
-		/** Anonymous user */
-		if( !$this->mId ) {
-			/** Get rights */
-			$this->mRights = $this->getGroupPermissions( array( '*' ) );
-			$this->mDataLoaded = true;
-			return;
-		} # the following stuff is for non-anonymous users only
-
-		$dbr =& wfGetDB( DB_SLAVE );
-		$s = $dbr->selectRow( 'user', array( 'user_name','user_password','user_newpassword','user_email',
-		  'user_email_authenticated',
-		  'user_real_name','user_options','user_touched', 'user_token', 'user_registration' ),
-		  array( 'user_id' => $this->mId ), $fname );
-
-		if ( $s !== false ) {
-			$this->mName = $s->user_name;
-			$this->mEmail = $s->user_email;
-			$this->mEmailAuthenticated = wfTimestampOrNull( TS_MW, $s->user_email_authenticated );
-			$this->mRealName = $s->user_real_name;
-			$this->mPassword = $s->user_password;
-			$this->mNewpassword = $s->user_newpassword;
-			$this->decodeOptions( $s->user_options );
-			$this->mTouched = wfTimestamp(TS_MW,$s->user_touched);
-			$this->mToken = $s->user_token;
-			$this->mRegistration = wfTimestampOrNull( TS_MW, $s->user_registration );
-
-			$res = $dbr->select( 'user_groups',
-				array( 'ug_group' ),
-				array( 'ug_user' => $this->mId ),
-				$fname );
-			$this->mGroups = array();
-			while( $row = $dbr->fetchObject( $res ) ) {
-				$this->mGroups[] = $row->ug_group;
-			}
-			$implicitGroups = array( '*', 'user' );
-
-			global $wgAutoConfirmAge;
-			$accountAge = time() - wfTimestampOrNull( TS_UNIX, $this->mRegistration );
-			if( $accountAge >= $wgAutoConfirmAge ) {
-				$implicitGroups[] = 'autoconfirmed';
-			}
-			
-			# Implicit group for users whose email addresses are confirmed
-			global $wgEmailAuthentication;
-			if( $this->isValidEmailAddr( $this->mEmail ) ) {
-				if( $wgEmailAuthentication ) {
-					if( $this->mEmailAuthenticated )
-						$implicitGroups[] = 'emailconfirmed';
-				} else {
-					$implicitGroups[] = 'emailconfirmed';
-				}
-			}
-
-			$effectiveGroups = array_merge( $implicitGroups, $this->mGroups );
-			$this->mRights = $this->getGroupPermissions( $effectiveGroups );
-		}
-
-		$this->mDataLoaded = true;
-	}
-
-	function getID() { return $this->mId; }
 	function setID( $v ) {
 		$this->mId = $v;
-		$this->mDataLoaded = false;
+		$this->clearInstanceCache( 'id' );
 	}
 
+	/**
+	 * Get the user name, or the IP for anons
+	 */
 	function getName() {
-		$this->loadFromDatabase();
-		if ( $this->mName === false ) {
-			$this->mName = wfGetIP();
+		if ( !$this->mDataLoaded && $this->mFrom == 'name' ) {
+			# Special case optimisation
+			return $this->mName;
+		} else {
+			$this->load();
+			if ( $this->mName === false ) {
+				$this->mName = wfGetIP();
+			}
+			return $this->mName;
 		}
-		return $this->mName;
 	}
 
+	/**
+	 * Set the user name. 
+	 *
+	 * This does not reload fields from the database according to the given 
+	 * name. Rather, it is used to create a temporary "nonexistent user" for
+	 * later addition to the database. It can also be used to set the IP 
+	 * address for an anonymous user to something other than the current 
+	 * remote IP.
+	 *
+	 * User::newFromName() has rougly the same function, when the named user
+	 * does not exist.
+	 */
 	function setName( $str ) {
-		$this->loadFromDatabase();
+		$this->load();
 		$this->mName = $str;
 	}
 
-
 	/**
 	 * Return the title dbkey form of the name, for eg user pages.
 	 * @return string
@@ -907,7 +1109,7 @@ class User {
 	}
 
 	function getNewtalk() {
-		$this->loadFromDatabase();
+		$this->load();
 
 		# Load the newtalk status if it is unloaded (mNewtalk=-1)
 		if( $this->mNewtalk === -1 ) {
@@ -960,10 +1162,9 @@ class User {
 	 * @private
 	 */
 	function checkNewtalk( $field, $id ) {
-		$fname = 'User::checkNewtalk';
 		$dbr =& wfGetDB( DB_SLAVE );
 		$ok = $dbr->selectField( 'user_newtalk', $field,
-			array( $field => $id ), $fname );
+			array( $field => $id ), __METHOD__ );
 		return $ok !== false;
 	}
 
@@ -974,17 +1175,16 @@ class User {
 	 * @private
 	 */
 	function updateNewtalk( $field, $id ) {
-		$fname = 'User::updateNewtalk';
 		if( $this->checkNewtalk( $field, $id ) ) {
-			wfDebug( "$fname already set ($field, $id), ignoring\n" );
+			wfDebug( __METHOD__." already set ($field, $id), ignoring\n" );
 			return false;
 		}
 		$dbw =& wfGetDB( DB_MASTER );
 		$dbw->insert( 'user_newtalk',
 			array( $field => $id ),
-			$fname,
+			__METHOD__,
 			'IGNORE' );
-		wfDebug( "$fname: set on ($field, $id)\n" );
+		wfDebug( __METHOD__.": set on ($field, $id)\n" );
 		return true;
 	}
 
@@ -995,16 +1195,15 @@ class User {
 	 * @private
 	 */
 	function deleteNewtalk( $field, $id ) {
-		$fname = 'User::deleteNewtalk';
 		if( !$this->checkNewtalk( $field, $id ) ) {
-			wfDebug( "$fname: already gone ($field, $id), ignoring\n" );
+			wfDebug( __METHOD__.": already gone ($field, $id), ignoring\n" );
 			return false;
 		}
 		$dbw =& wfGetDB( DB_MASTER );
 		$dbw->delete( 'user_newtalk',
 			array( $field => $id ),
-			$fname );
-		wfDebug( "$fname: killed on ($field, $id)\n" );
+			__METHOD__ );
+		wfDebug( __METHOD__.": killed on ($field, $id)\n" );
 		return true;
 	}
 
@@ -1017,11 +1216,9 @@ class User {
 			return;
 		}
 
-		$this->loadFromDatabase();
+		$this->load();
 		$this->mNewtalk = $val;
 
-		$fname = 'User::setNewtalk';
-
 		if( $this->isAnon() ) {
 			$field = 'user_ip';
 			$id = $this->getName();
@@ -1070,7 +1267,7 @@ class User {
 	 *
 	 * Called implicitly from invalidateCache() and saveSettings().
 	 */
-	private function clearUserCache() {
+	private function clearSharedCache() {
 		if( $this->mId ) {
 			global $wgMemc;
 			$wgMemc->delete( wfMemcKey( 'user', 'id', $this->mId ) );
@@ -1083,6 +1280,7 @@ class User {
 	 * for reload on the next hit.
 	 */
 	function invalidateCache() {
+		$this->load();
 		if( $this->mId ) {
 			$this->mTouched = self::newTouchedTimestamp();
 			
@@ -1092,12 +1290,12 @@ class User {
 				array( 'user_id' => $this->mId ),
 				__METHOD__ );
 			
-			$this->clearUserCache();
+			$this->clearSharedCache();
 		}
 	}
 
 	function validateCache( $timestamp ) {
-		$this->loadFromDatabase();
+		$this->load();
 		return ($timestamp >= $this->mTouched);
 	}
 
@@ -1108,20 +1306,66 @@ class User {
 	 * @return string Encrypted password.
 	 */
 	function encryptPassword( $p ) {
+		$this->load();
 		return wfEncryptPassword( $this->mId, $p );
 	}
 
-	# Set the password and reset the random token
+	/**
+	 * Set the password and reset the random token
+	 * Calls through to authentication plugin if necessary;
+	 * will have no effect if the auth plugin refuses to
+	 * pass the change through or if the legal password
+	 * checks fail.
+	 *
+	 * As a special case, setting the password to null
+	 * wipes it, so the account cannot be logged in until
+	 * a new password is set, for instance via e-mail.
+	 *
+	 * @param string $str
+	 * @throws PasswordError on failure
+	 */
 	function setPassword( $str ) {
-		$this->loadFromDatabase();
+		global $wgAuth;
+		
+		if( $str !== null ) {
+			if( !$wgAuth->allowPasswordChange() ) {
+				throw new PasswordError( wfMsg( 'password-change-forbidden' ) );
+			}
+		
+			if( !$this->isValidPassword( $str ) ) {
+				global $wgMinimalPasswordLength;
+				throw new PasswordError( wfMsg( 'passwordtooshort',
+					$wgMinimalPasswordLength ) );
+			}
+		}
+		
+		if( !$wgAuth->setPassword( $this, $str ) ) {
+			throw new PasswordError( wfMsg( 'externaldberror' ) );
+		}
+		
+		$this->load();
 		$this->setToken();
-		$this->mPassword = $this->encryptPassword( $str );
+		
+		if( $str === null ) {
+			// Save an invalid hash...
+			$this->mPassword = '';
+		} else {
+			$this->mPassword = $this->encryptPassword( $str );
+		}
 		$this->mNewpassword = '';
+		$this->mNewpassTime = null;
+		
+		return true;
 	}
 
-	# Set the random token (used for persistent authentication)
+	/**
+	 * Set the random token (used for persistent authentication)
+	 * Called from loadDefaults() among other places.
+	 * @private
+	 */
 	function setToken( $token = false ) {
 		global $wgSecretKey, $wgProxyKey;
+		$this->load();
 		if ( !$token ) {
 			if ( $wgSecretKey ) {
 				$key = $wgSecretKey;
@@ -1136,55 +1380,81 @@ class User {
 		}
 	}
 
-
 	function setCookiePassword( $str ) {
-		$this->loadFromDatabase();
+		$this->load();
 		$this->mCookiePassword = md5( $str );
 	}
 
-	function setNewpassword( $str ) {
-		$this->loadFromDatabase();
+	/**
+	 * Set the password for a password reminder or new account email
+	 * Sets the user_newpass_time field if $throttle is true
+	 */
+	function setNewpassword( $str, $throttle = true ) {
+		$this->load();
 		$this->mNewpassword = $this->encryptPassword( $str );
+		if ( $throttle ) {
+			$this->mNewpassTime = wfTimestampNow();
+		}
 	}
 
+	/**
+	 * Returns true if a password reminder email has already been sent within
+	 * the last $wgPasswordReminderResendTime hours
+	 */
+	function isPasswordReminderThrottled() {
+		global $wgPasswordReminderResendTime;
+		$this->load();
+		if ( !$this->mNewpassTime || !$wgPasswordReminderResendTime ) {
+			return false;
+		}
+		$expiry = wfTimestamp( TS_UNIX, $this->mNewpassTime ) + $wgPasswordReminderResendTime * 3600;
+		return time() < $expiry;
+	}
+	
 	function getEmail() {
-		$this->loadFromDatabase();
+		$this->load();
 		return $this->mEmail;
 	}
 
 	function getEmailAuthenticationTimestamp() {
-		$this->loadFromDatabase();
+		$this->load();
 		return $this->mEmailAuthenticated;
 	}
 
 	function setEmail( $str ) {
-		$this->loadFromDatabase();
+		$this->load();
 		$this->mEmail = $str;
 	}
 
 	function getRealName() {
-		$this->loadFromDatabase();
+		$this->load();
 		return $this->mRealName;
 	}
 
 	function setRealName( $str ) {
-		$this->loadFromDatabase();
+		$this->load();
 		$this->mRealName = $str;
 	}
 
 	/**
 	 * @param string $oname The option to check
+	 * @param string $defaultOverride A default value returned if the option does not exist
 	 * @return string
 	 */
-	function getOption( $oname ) {
-		$this->loadFromDatabase();
+	function getOption( $oname, $defaultOverride = '' ) {
+		$this->load();
+
 		if ( is_null( $this->mOptions ) ) {
+			if($defaultOverride != '') {
+				return $defaultOverride;
+			}
 			$this->mOptions = User::getDefaultOptions();
 		}
+
 		if ( array_key_exists( $oname, $this->mOptions ) ) {
 			return trim( $this->mOptions[$oname] );
 		} else {
-			return '';
+			return $defaultOverride;
 		}
 	}
 
@@ -1228,7 +1498,7 @@ class User {
 	}
 
 	function setOption( $oname, $val ) {
-		$this->loadFromDatabase();
+		$this->load();
 		if ( is_null( $this->mOptions ) ) {
 			$this->mOptions = User::getDefaultOptions();
 		}
@@ -1245,7 +1515,9 @@ class User {
 	}
 
 	function getRights() {
-		$this->loadFromDatabase();
+		if ( is_null( $this->mRights ) ) {
+			$this->mRights = self::getGroupPermissions( $this->getEffectiveGroups() );
+		}
 		return $this->mRights;
 	}
 
@@ -1255,7 +1527,7 @@ class User {
 	 * @return array of strings
 	 */
 	function getGroups() {
-		$this->loadFromDatabase();
+		$this->load();
 		return $this->mGroups;
 	}
 
@@ -1263,14 +1535,36 @@ class User {
 	 * Get the list of implicit group memberships this user has.
 	 * This includes all explicit groups, plus 'user' if logged in
 	 * and '*' for all accounts.
+	 * @param boolean $recache Don't use the cache
 	 * @return array of strings
 	 */
-	function getEffectiveGroups() {
-		$base = array( '*' );
-		if( $this->isLoggedIn() ) {
-			$base[] = 'user';
+	function getEffectiveGroups( $recache = false ) {
+		if ( $recache || is_null( $this->mEffectiveGroups ) ) {
+			$this->load();
+			$this->mEffectiveGroups = $this->mGroups;
+			$this->mEffectiveGroups[] = '*';
+			if( $this->mId ) {
+				$this->mEffectiveGroups[] = 'user';
+				
+				global $wgAutoConfirmAge;
+				$accountAge = time() - wfTimestampOrNull( TS_UNIX, $this->mRegistration );
+				if( $accountAge >= $wgAutoConfirmAge ) {
+					$this->mEffectiveGroups[] = 'autoconfirmed';
+				}
+				
+				# Implicit group for users whose email addresses are confirmed
+				global $wgEmailAuthentication;
+				if( self::isValidEmailAddr( $this->mEmail ) ) {
+					if( $wgEmailAuthentication ) {
+						if( $this->mEmailAuthenticated )
+							$this->mEffectiveGroups[] = 'emailconfirmed';
+					} else {
+						$this->mEffectiveGroups[] = 'emailconfirmed';
+					}
+				}
+			}
 		}
-		return array_merge( $base, $this->getGroups() );
+		return $this->mEffectiveGroups;
 	}
 
 	/**
@@ -1279,17 +1573,20 @@ class User {
 	 * @string $group
 	 */
 	function addGroup( $group ) {
+		$this->load();
 		$dbw =& wfGetDB( DB_MASTER );
-		$dbw->insert( 'user_groups',
-			array(
-				'ug_user'  => $this->getID(),
-				'ug_group' => $group,
-			),
-			'User::addGroup',
-			array( 'IGNORE' ) );
+		if( $this->getId() ) {
+			$dbw->insert( 'user_groups',
+				array(
+					'ug_user'  => $this->getID(),
+					'ug_group' => $group,
+				),
+				'User::addGroup',
+				array( 'IGNORE' ) );
+		}
 
-		$this->mGroups = array_merge( $this->mGroups, array( $group ) );
-		$this->mRights = User::getGroupPermissions( $this->getEffectiveGroups() );
+		$this->mGroups[] = $group;
+		$this->mRights = User::getGroupPermissions( $this->getEffectiveGroups( true ) );
 
 		$this->invalidateCache();
 	}
@@ -1300,6 +1597,7 @@ class User {
 	 * @string $group
 	 */
 	function removeGroup( $group ) {
+		$this->load();
 		$dbw =& wfGetDB( DB_MASTER );
 		$dbw->delete( 'user_groups',
 			array(
@@ -1309,7 +1607,7 @@ class User {
 			'User::removeGroup' );
 
 		$this->mGroups = array_diff( $this->mGroups, array( $group ) );
-		$this->mRights = User::getGroupPermissions( $this->getEffectiveGroups() );
+		$this->mRights = User::getGroupPermissions( $this->getEffectiveGroups( true ) );
 
 		$this->invalidateCache();
 	}
@@ -1353,8 +1651,7 @@ class User {
 			// In the spirit of DWIM
 			return true;
 
-		$this->loadFromDatabase();
-		return in_array( $action , $this->mRights );
+		return in_array( $action, $this->getRights() );
 	}
 
 	/**
@@ -1362,17 +1659,16 @@ class User {
 	 * @todo FIXME : need to check the old failback system [AV]
 	 */
 	function &getSkin() {
-		global $IP, $wgRequest;
+		global $wgRequest;
 		if ( ! isset( $this->mSkin ) ) {
-			$fname = 'User::getSkin';
-			wfProfileIn( $fname );
+			wfProfileIn( __METHOD__ );
 
 			# get the user skin
 			$userSkin = $this->getOption( 'skin' );
 			$userSkin = $wgRequest->getVal('useskin', $userSkin);
 
 			$this->mSkin =& Skin::newFromKey( $userSkin );
-			wfProfileOut( $fname );
+			wfProfileOut( __METHOD__ );
 		}
 		return $this->mSkin;
 	}
@@ -1416,6 +1712,10 @@ class User {
 	function clearNotification( &$title ) {
 		global $wgUser, $wgUseEnotif;
 
+		# Do nothing if the database is locked to writes
+		if( wfReadOnly() ) {
+			return;
+		}
 
 		if ($title->getNamespace() == NS_USER_TALK &&
 			$title->getText() == $this->getName() ) {
@@ -1451,7 +1751,7 @@ class User {
 		// any matching rows
 		if ( $watched ) {
 			$dbw =& wfGetDB( DB_MASTER );
-			$success = $dbw->update( 'watchlist',
+			$dbw->update( 'watchlist',
 					array( /* SET */
 						'wl_notificationtimestamp' => NULL
 					), array( /* WHERE */
@@ -1482,7 +1782,7 @@ class User {
 		if( $currentUser != 0 )  {
 
 			$dbw =& wfGetDB( DB_MASTER );
-			$success = $dbw->update( 'watchlist',
+			$dbw->update( 'watchlist',
 				array( /* SET */
 					'wl_notificationtimestamp' => NULL
 				), array( /* WHERE */
@@ -1500,6 +1800,7 @@ class User {
 	 * @return string Encoding options
 	 */
 	function encodeOptions() {
+		$this->load();
 		if ( is_null( $this->mOptions ) ) {
 			$this->mOptions = User::getDefaultOptions();
 		}
@@ -1515,11 +1816,10 @@ class User {
 	 * @private
 	 */
 	function decodeOptions( $str ) {
-		global $wgLang;
-		
 		$this->mOptions = array();
 		$a = explode( "\n", $str );
 		foreach ( $a as $s ) {
+			$m = array();
 			if ( preg_match( "/^(.[^=]*)=(.*)$/", $s, $m ) ) {
 				$this->mOptions[$m[1]] = $m[2];
 			}
@@ -1528,8 +1828,8 @@ class User {
 
 	function setCookies() {
 		global $wgCookieExpiration, $wgCookiePath, $wgCookieDomain, $wgCookieSecure, $wgCookiePrefix;
+		$this->load();
 		if ( 0 == $this->mId ) return;
-		$this->loadFromDatabase();
 		$exp = time() + $wgCookieExpiration;
 
 		$_SESSION['wsUserID'] = $this->mId;
@@ -1548,12 +1848,11 @@ class User {
 
 	/**
 	 * Logout user
-	 * It will clean the session cookie
+	 * Clears the cookies and session, resets the instance cache
 	 */
 	function logout() {
 		global $wgCookiePath, $wgCookieDomain, $wgCookieSecure, $wgCookiePrefix;
-		$this->loadDefaults();
-		$this->setLoaded( true );
+		$this->clearInstanceCache( 'defaults' );
 
 		$_SESSION['wsUserID'] = 0;
 
@@ -1569,8 +1868,7 @@ class User {
 	 * @fixme Only rarely do all these fields need to be set!
 	 */
 	function saveSettings() {
-		$fname = 'User::saveSettings';
-
+		$this->load();
 		if ( wfReadOnly() ) { return; }
 		if ( 0 == $this->mId ) { return; }
 		
@@ -1582,6 +1880,7 @@ class User {
 				'user_name' => $this->mName,
 				'user_password' => $this->mPassword,
 				'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 ),
@@ -1590,9 +1889,9 @@ class User {
 				'user_token' => $this->mToken
 			), array( /* WHERE */
 				'user_id' => $this->mId
-			), $fname
+			), __METHOD__
 		);
-		$this->clearUserCache();
+		$this->clearSharedCache();
 	}
 
 
@@ -1600,14 +1899,11 @@ class User {
 	 * Checks if a user with the given name exists, returns the ID
 	 */
 	function idForName() {
-		$fname = 'User::idForName';
-
-		$gotid = 0;
 		$s = trim( $this->getName() );
 		if ( 0 == strcmp( '', $s ) ) return 0;
 
 		$dbr =& wfGetDB( DB_SLAVE );
-		$id = $dbr->selectField( 'user', 'user_id', array( 'user_name' => $s ), $fname );
+		$id = $dbr->selectField( 'user', 'user_id', array( 'user_name' => $s ), __METHOD__ );
 		if ( $id === false ) {
 			$id = 0;
 		}
@@ -1615,10 +1911,61 @@ class User {
 	}
 
 	/**
-	 * Add user object to the database
+	 * Add a user to the database, return the user object
+	 *
+	 * @param string $name The user's name
+	 * @param array $params Associative array of non-default parameters to save to the database:
+	 *     password             The user's password. Password logins will be disabled if this is omitted.
+	 *     newpassword          A temporary password mailed to the user
+	 *     email                The user's email address
+	 *     email_authenticated  The email authentication timestamp
+	 *     real_name            The user's real name
+	 *     options              An associative array of non-default options
+	 *     token                Random authentication token. Do not set.
+	 *     registration         Registration timestamp. Do not set.
+	 *
+	 * @return User object, or null if the username already exists
+	 */
+	static function createNew( $name, $params = array() ) {
+		$user = new User;
+		$user->load();
+		if ( isset( $params['options'] ) ) {
+			$user->mOptions = $params['options'] + $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_email' => $user->mEmail,
+			'user_email_authenticated' => $dbw->timestampOrNull( $user->mEmailAuthenticated ),
+			'user_real_name' => $user->mRealName,
+			'user_options' => $user->encodeOptions(),
+			'user_token' => $user->mToken,
+			'user_registration' => $dbw->timestamp( $user->mRegistration ),
+			'user_editcount' => 0,
+		);
+		foreach ( $params as $name => $value ) {
+			$fields["user_$name"] = $value;
+		}
+		$dbw->insert( 'user', $fields, __METHOD__, array( 'IGNORE' ) );
+		if ( $dbw->affectedRows() ) {
+			$newUser = User::newFromId( $dbw->insertId() );
+		} else {
+			$newUser = null;
+		}
+		return $newUser;
+	}
+	
+	/**
+	 * Add an existing user object to the database
 	 */
 	function addToDatabase() {
-		$fname = 'User::addToDatabase';
+		$this->load();
 		$dbw =& wfGetDB( DB_MASTER );
 		$seqVal = $dbw->nextSequenceValue( 'user_user_id_seq' );
 		$dbw->insert( 'user',
@@ -1627,23 +1974,29 @@ class User {
 				'user_name' => $this->mName,
 				'user_password' => $this->mPassword,
 				'user_newpassword' => $this->mNewpassword,
+				'user_newpass_time' => $dbw->timestamp( $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_registration' => $dbw->timestamp( $this->mRegistration ),
-			), $fname
+				'user_editcount' => 0,
+			), __METHOD__
 		);
 		$this->mId = $dbw->insertId();
+
+		# Clear instance cache other than user table data, which is already accurate
+		$this->clearInstanceCache();
 	}
 
+	/**
+	 * If the (non-anonymous) user is blocked, this function will block any IP address
+	 * that they successfully log on from.
+	 */
 	function spreadBlock() {
-		# If the (non-anonymous) user is blocked, this function will block any IP address
-		# that they successfully log on from.
-		$fname = 'User::spreadBlock';
-
-		wfDebug( "User:spreadBlock()\n" );
+		wfDebug( __METHOD__."()\n" );
+		$this->load();
 		if ( $this->mId == 0 ) {
 			return;
 		}
@@ -1653,41 +2006,7 @@ class User {
 			return;
 		}
 
-		# Check if this IP address is already blocked
-		$ipblock = Block::newFromDB( wfGetIP() );
-		if ( $ipblock ) {
-			# If the user is already blocked. Then check if the autoblock would
-			# excede the user block. If it would excede, then do nothing, else
-			# prolong block time
-			if ($userblock->mExpiry &&
-				($userblock->mExpiry < Block::getAutoblockExpiry($ipblock->mTimestamp))) {
-				return;
-			}
-			# Just update the timestamp
-			$ipblock->updateTimestamp();
-			return;
-		} else {
-			$ipblock = new Block;
-		}
-
-		# Make a new block object with the desired properties
-		wfDebug( "Autoblocking {$this->mName}@" . wfGetIP() . "\n" );
-		$ipblock->mAddress = wfGetIP();
-		$ipblock->mUser = 0;
-		$ipblock->mBy = $userblock->mBy;
-		$ipblock->mReason = wfMsg( 'autoblocker', $this->getName(), $userblock->mReason );
-		$ipblock->mTimestamp = wfTimestampNow();
-		$ipblock->mAuto = 1;
-		# If the user is already blocked with an expiry date, we don't
-		# want to pile on top of that!
-		if($userblock->mExpiry) {
-			$ipblock->mExpiry = min ( $userblock->mExpiry, Block::getAutoblockExpiry( $ipblock->mTimestamp ));
-		} else {
-			$ipblock->mExpiry = Block::getAutoblockExpiry( $ipblock->mTimestamp );
-		}
-
-		# Insert it
-		$ipblock->insert();
+		$userblock->doAutoblock( wfGetIp() );
 
 	}
 
@@ -1705,7 +2024,7 @@ class User {
 	 * @return string
 	 */
 	function getPageRenderingHash() {
-		global $wgContLang, $wgUseDynamicDates;
+		global $wgContLang, $wgUseDynamicDates, $wgLang;
 		if( $this->mHash ){
 			return $this->mHash;
 		}
@@ -1719,7 +2038,7 @@ class User {
 			$confstr .= '!' . $this->getDatePreference();
 		}
 		$confstr .= '!' . ($this->getOption( 'numberheadings' ) ? '1' : '');
-		$confstr .= '!' . $this->getOption( 'language' );
+		$confstr .= '!' . $wgLang->getCode();
 		$confstr .= '!' . $this->getOption( 'thumbsize' );
 		// add in language specific options, if any
 		$extra = $wgContLang->getExtraHashOptions();
@@ -1743,12 +2062,9 @@ class User {
 	}
 
 	/**
-	 * Set mDataLoaded, return previous value
-	 * Use this to prevent DB access in command-line scripts or similar situations
+	 * @deprecated
 	 */
-	function setLoaded( $loaded ) {
-		return wfSetVar( $this->mDataLoaded, $loaded );
-	}
+	function setLoaded( $loaded ) {}
 
 	/**
 	 * Get this user's personal page title.
@@ -1800,15 +2116,15 @@ class User {
 	 * @return bool True if the given password is correct otherwise False.
 	 */
 	function checkPassword( $password ) {
-		global $wgAuth, $wgMinimalPasswordLength;
-		$this->loadFromDatabase();
+		global $wgAuth;
+		$this->load();
 
 		// Even though we stop people from creating passwords that
 		// 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).
-		if( strlen( $password ) < $wgMinimalPasswordLength ) {
+		if( !$this->isValidPassword( $password ) ) {
 			return false;
 		}
 
@@ -1821,8 +2137,6 @@ class User {
 		$ep = $this->encryptPassword( $password );
 		if ( 0 == strcmp( $ep, $this->mPassword ) ) {
 			return true;
-		} elseif ( ($this->mNewpassword != '') && (0 == strcmp( $ep, $this->mNewpassword )) ) {
-			return true;
 		} elseif ( function_exists( 'iconv' ) ) {
 			# Some wikis were converted from ISO 8859-1 to UTF-8, the passwords can't be converted
 			# Check for this with iconv
@@ -1833,6 +2147,16 @@ class User {
 		}
 		return false;
 	}
+	
+	/**
+	 * Check if the given clear-text password matches the temporary password
+	 * sent by e-mail for password reset operations.
+	 * @return bool
+	 */
+	function checkTemporaryPassword( $plaintext ) {
+		$hash = $this->encryptPassword( $plaintext );
+		return $hash === $this->mNewpassword;
+	}
 
 	/**
 	 * Initialize (if necessary) and return a session token value
@@ -1855,7 +2179,7 @@ class User {
 		if( is_array( $salt ) ) {
 			$salt = implode( '|', $salt );
 		}
-		return md5( $token . $salt );
+		return md5( $token . $salt ) . EDIT_TOKEN_SUFFIX;
 	}
 
 	/**
@@ -1896,6 +2220,7 @@ class User {
 	 */
 	function sendConfirmationMail() {
 		global $wgContLang;
+		$expiration = null; // gets passed-by-ref and defined in next line.
 		$url = $this->confirmationTokenUrl( $expiration );
 		return $this->sendMail( wfMsg( 'confirmemail_subject' ),
 			wfMsg( 'confirmemail_body',
@@ -1940,8 +2265,6 @@ class User {
 	 * @private
 	 */
 	function confirmationToken( &$expiration ) {
-		$fname = 'User::confirmationToken';
-
 		$now = time();
 		$expires = $now + 7 * 24 * 60 * 60;
 		$expiration = wfTimestamp( TS_MW, $expires );
@@ -1954,7 +2277,7 @@ class User {
 			array( 'user_email_token'         => $hash,
 			       'user_email_token_expires' => $dbw->timestamp( $expires ) ),
 			array( 'user_id'                  => $this->mId ),
-			$fname );
+			__METHOD__ );
 
 		return $token;
 	}
@@ -1968,7 +2291,7 @@ class User {
 	 */
 	function confirmationTokenUrl( &$expiration ) {
 		$token = $this->confirmationToken( $expiration );
-		$title = Title::makeTitle( NS_SPECIAL, 'Confirmemail/' . $token );
+		$title = SpecialPage::getTitleFor( 'Confirmemail', $token );
 		return $title->getFullUrl();
 	}
 
@@ -1976,7 +2299,7 @@ class User {
 	 * Mark the e-mail address confirmed and save.
 	 */
 	function confirmEmail() {
-		$this->loadFromDatabase();
+		$this->load();
 		$this->mEmailAuthenticated = wfTimestampNow();
 		$this->saveSettings();
 		return true;
@@ -2012,12 +2335,12 @@ class User {
 	 */
 	function isEmailConfirmed() {
 		global $wgEmailAuthentication;
-		$this->loadFromDatabase();
+		$this->load();
 		$confirmed = true;
 		if( wfRunHooks( 'EmailConfirmed', array( &$this, &$confirmed ) ) ) {
 			if( $this->isAnon() )
 				return false;
-			if( !$this->isValidEmailAddr( $this->mEmail ) )
+			if( !self::isValidEmailAddr( $this->mEmail ) )
 				return false;
 			if( $wgEmailAuthentication && !$this->getEmailAuthenticationTimestamp() )
 				return false;
@@ -2026,6 +2349,18 @@ class User {
 			return $confirmed;
 		}
 	}
+	
+	/**
+	 * Return true if there is an outstanding request for e-mail confirmation.
+	 * @return bool
+	 */
+	function isEmailConfirmationPending() {
+		global $wgEmailAuthentication;
+		return $wgEmailAuthentication &&
+			!$this->isEmailConfirmed() &&
+			$this->mEmailToken &&
+			$this->mEmailTokenExpires > wfTimestamp();
+	}
 
 	/**
 	 * @param array $groups list of groups
@@ -2145,6 +2480,48 @@ class User {
 			return $text;
 		}
 	}
+	
+	/**
+	 * Increment the user's edit-count field.
+	 * Will have no effect for anonymous users.
+	 */
+	function incEditCount() {
+		if( !$this->isAnon() ) {
+			$dbw = wfGetDB( DB_MASTER );
+			$dbw->update( 'user',
+				array( 'user_editcount=user_editcount+1' ),
+				array( 'user_id' => $this->getId() ),
+				__METHOD__ );
+			
+			// Lazy initialization check...
+			if( $dbw->affectedRows() == 0 ) {
+				// Pull from a slave to be less cruel to servers
+				// Accuracy isn't the point anyway here
+				$dbr = wfGetDB( DB_SLAVE );
+				$count = $dbr->selectField( 'revision',
+					'COUNT(rev_user)',
+					array( 'rev_user' => $this->getId() ),
+					__METHOD__ );
+				
+				// Now here's a goddamn hack...
+				if( $dbr !== $dbw ) {
+					// If we actually have a slave server, the count is
+					// at least one behind because the current transaction
+					// has not been committed and replicated.
+					$count++;
+				} else {
+					// But if DB_SLAVE is selecting the master, then the
+					// count we just read includes the revision that was
+					// just added in the working transaction.
+				}
+				
+				$dbw->update( 'user',
+					array( 'user_editcount' => $count ),
+					array( 'user_id' => $this->getId() ),
+					__METHOD__ );
+			}
+		}
+	}
 }
 
 ?>