Refactor diffs
[mediawiki.git] / includes / User.php
blobc86b966ffed293713cd4873ca62e514094686721
1 <?php
2 /**
3 * Implements the User class for the %MediaWiki software.
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License along
16 * with this program; if not, write to the Free Software Foundation, Inc.,
17 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
18 * http://www.gnu.org/copyleft/gpl.html
20 * @file
23 /**
24 * Int Number of characters in user_token field.
25 * @ingroup Constants
27 define( 'USER_TOKEN_LENGTH', 32 );
29 /**
30 * Int Serialized record version.
31 * @ingroup Constants
33 define( 'MW_USER_VERSION', 8 );
35 /**
36 * String Some punctuation to prevent editing from broken text-mangling proxies.
37 * @ingroup Constants
39 define( 'EDIT_TOKEN_SUFFIX', '+\\' );
41 /**
42 * Thrown by User::setPassword() on error.
43 * @ingroup Exception
45 class PasswordError extends MWException {
46 // NOP
49 /**
50 * The User object encapsulates all of the user-specific settings (user_id,
51 * name, rights, password, email address, options, last login time). Client
52 * classes use the getXXX() functions to access these fields. These functions
53 * do all the work of determining whether the user is logged in,
54 * whether the requested option can be satisfied from cookies or
55 * whether a database query is needed. Most of the settings needed
56 * for rendering normal pages are set in the cookie to minimize use
57 * of the database.
59 class User {
60 /**
61 * Global constants made accessible as class constants so that autoloader
62 * magic can be used.
64 const USER_TOKEN_LENGTH = USER_TOKEN_LENGTH;
65 const MW_USER_VERSION = MW_USER_VERSION;
66 const EDIT_TOKEN_SUFFIX = EDIT_TOKEN_SUFFIX;
68 /**
69 * Maximum items in $mWatchedItems
71 const MAX_WATCHED_ITEMS_CACHE = 100;
73 /**
74 * Array of Strings List of member variables which are saved to the
75 * shared cache (memcached). Any operation which changes the
76 * corresponding database fields must call a cache-clearing function.
77 * @showinitializer
79 static $mCacheVars = array(
80 // user table
81 'mId',
82 'mName',
83 'mRealName',
84 'mPassword',
85 'mNewpassword',
86 'mNewpassTime',
87 'mEmail',
88 'mTouched',
89 'mToken',
90 'mEmailAuthenticated',
91 'mEmailToken',
92 'mEmailTokenExpires',
93 'mRegistration',
94 'mEditCount',
95 // user_groups table
96 'mGroups',
97 // user_properties table
98 'mOptionOverrides',
102 * Array of Strings Core rights.
103 * Each of these should have a corresponding message of the form
104 * "right-$right".
105 * @showinitializer
107 static $mCoreRights = array(
108 'apihighlimits',
109 'autoconfirmed',
110 'autopatrol',
111 'bigdelete',
112 'block',
113 'blockemail',
114 'bot',
115 'browsearchive',
116 'createaccount',
117 'createpage',
118 'createtalk',
119 'delete',
120 'deletedhistory',
121 'deletedtext',
122 'deletelogentry',
123 'deleterevision',
124 'edit',
125 'editinterface',
126 'editprotected',
127 'editmyoptions',
128 'editmyprivateinfo',
129 'editmyusercss',
130 'editmyuserjs',
131 'editmywatchlist',
132 'editsemiprotected',
133 'editusercssjs', #deprecated
134 'editusercss',
135 'edituserjs',
136 'hideuser',
137 'import',
138 'importupload',
139 'ipblock-exempt',
140 'markbotedits',
141 'mergehistory',
142 'minoredit',
143 'move',
144 'movefile',
145 'move-rootuserpages',
146 'move-subpages',
147 'nominornewtalk',
148 'noratelimit',
149 'override-export-depth',
150 'passwordreset',
151 'patrol',
152 'patrolmarks',
153 'protect',
154 'proxyunbannable',
155 'purge',
156 'read',
157 'reupload',
158 'reupload-own',
159 'reupload-shared',
160 'rollback',
161 'sendemail',
162 'siteadmin',
163 'suppressionlog',
164 'suppressredirect',
165 'suppressrevision',
166 'unblockself',
167 'undelete',
168 'unwatchedpages',
169 'upload',
170 'upload_by_url',
171 'userrights',
172 'userrights-interwiki',
173 'viewmyprivateinfo',
174 'viewmywatchlist',
175 'writeapi',
178 * String Cached results of getAllRights()
180 static $mAllRights = false;
182 /** @name Cache variables */
183 //@{
184 var $mId, $mName, $mRealName, $mPassword, $mNewpassword, $mNewpassTime,
185 $mEmail, $mTouched, $mToken, $mEmailAuthenticated,
186 $mEmailToken, $mEmailTokenExpires, $mRegistration, $mEditCount,
187 $mGroups, $mOptionOverrides;
188 //@}
191 * Bool Whether the cache variables have been loaded.
193 //@{
194 var $mOptionsLoaded;
197 * Array with already loaded items or true if all items have been loaded.
199 private $mLoadedItems = array();
200 //@}
203 * String Initialization data source if mLoadedItems!==true. May be one of:
204 * - 'defaults' anonymous user initialised from class defaults
205 * - 'name' initialise from mName
206 * - 'id' initialise from mId
207 * - 'session' log in from cookies or session if possible
209 * Use the User::newFrom*() family of functions to set this.
211 var $mFrom;
214 * Lazy-initialized variables, invalidated with clearInstanceCache
216 var $mNewtalk, $mDatePreference, $mBlockedby, $mHash, $mRights,
217 $mBlockreason, $mEffectiveGroups, $mImplicitGroups, $mFormerGroups, $mBlockedGlobally,
218 $mLocked, $mHideName, $mOptions;
221 * @var WebRequest
223 private $mRequest;
226 * @var Block
228 var $mBlock;
231 * @var bool
233 var $mAllowUsertalk;
236 * @var Block
238 private $mBlockedFromCreateAccount = false;
241 * @var Array
243 private $mWatchedItems = array();
245 static $idCacheByName = array();
248 * Lightweight constructor for an anonymous user.
249 * Use the User::newFrom* factory functions for other kinds of users.
251 * @see newFromName()
252 * @see newFromId()
253 * @see newFromConfirmationCode()
254 * @see newFromSession()
255 * @see newFromRow()
257 function __construct() {
258 $this->clearInstanceCache( 'defaults' );
262 * @return string
264 function __toString() {
265 return $this->getName();
269 * Load the user table data for this object from the source given by mFrom.
271 public function load() {
272 if ( $this->mLoadedItems === true ) {
273 return;
275 wfProfileIn( __METHOD__ );
277 // Set it now to avoid infinite recursion in accessors
278 $this->mLoadedItems = true;
280 switch ( $this->mFrom ) {
281 case 'defaults':
282 $this->loadDefaults();
283 break;
284 case 'name':
285 $this->mId = self::idFromName( $this->mName );
286 if ( !$this->mId ) {
287 // Nonexistent user placeholder object
288 $this->loadDefaults( $this->mName );
289 } else {
290 $this->loadFromId();
292 break;
293 case 'id':
294 $this->loadFromId();
295 break;
296 case 'session':
297 if ( !$this->loadFromSession() ) {
298 // Loading from session failed. Load defaults.
299 $this->loadDefaults();
301 wfRunHooks( 'UserLoadAfterLoadFromSession', array( $this ) );
302 break;
303 default:
304 wfProfileOut( __METHOD__ );
305 throw new MWException( "Unrecognised value for User->mFrom: \"{$this->mFrom}\"" );
307 wfProfileOut( __METHOD__ );
311 * Load user table data, given mId has already been set.
312 * @return bool false if the ID does not exist, true otherwise
314 public function loadFromId() {
315 global $wgMemc;
316 if ( $this->mId == 0 ) {
317 $this->loadDefaults();
318 return false;
321 // Try cache
322 $key = wfMemcKey( 'user', 'id', $this->mId );
323 $data = $wgMemc->get( $key );
324 if ( !is_array( $data ) || $data['mVersion'] < MW_USER_VERSION ) {
325 // Object is expired, load from DB
326 $data = false;
329 if ( !$data ) {
330 wfDebug( "User: cache miss for user {$this->mId}\n" );
331 // Load from DB
332 if ( !$this->loadFromDatabase() ) {
333 // Can't load from ID, user is anonymous
334 return false;
336 $this->saveToCache();
337 } else {
338 wfDebug( "User: got user {$this->mId} from cache\n" );
339 // Restore from cache
340 foreach ( self::$mCacheVars as $name ) {
341 $this->$name = $data[$name];
345 $this->mLoadedItems = true;
347 return true;
351 * Save user data to the shared cache
353 public function saveToCache() {
354 $this->load();
355 $this->loadGroups();
356 $this->loadOptions();
357 if ( $this->isAnon() ) {
358 // Anonymous users are uncached
359 return;
361 $data = array();
362 foreach ( self::$mCacheVars as $name ) {
363 $data[$name] = $this->$name;
365 $data['mVersion'] = MW_USER_VERSION;
366 $key = wfMemcKey( 'user', 'id', $this->mId );
367 global $wgMemc;
368 $wgMemc->set( $key, $data );
371 /** @name newFrom*() static factory methods */
372 //@{
375 * Static factory method for creation from username.
377 * This is slightly less efficient than newFromId(), so use newFromId() if
378 * you have both an ID and a name handy.
380 * @param string $name Username, validated by Title::newFromText()
381 * @param string|bool $validate Validate username. Takes the same parameters as
382 * User::getCanonicalName(), except that true is accepted as an alias
383 * for 'valid', for BC.
385 * @return User|bool User object, or false if the username is invalid
386 * (e.g. if it contains illegal characters or is an IP address). If the
387 * username is not present in the database, the result will be a user object
388 * with a name, zero user ID and default settings.
390 public static function newFromName( $name, $validate = 'valid' ) {
391 if ( $validate === true ) {
392 $validate = 'valid';
394 $name = self::getCanonicalName( $name, $validate );
395 if ( $name === false ) {
396 return false;
397 } else {
398 // Create unloaded user object
399 $u = new User;
400 $u->mName = $name;
401 $u->mFrom = 'name';
402 $u->setItemLoaded( 'name' );
403 return $u;
408 * Static factory method for creation from a given user ID.
410 * @param int $id Valid user ID
411 * @return User The corresponding User object
413 public static function newFromId( $id ) {
414 $u = new User;
415 $u->mId = $id;
416 $u->mFrom = 'id';
417 $u->setItemLoaded( 'id' );
418 return $u;
422 * Factory method to fetch whichever user has a given email confirmation code.
423 * This code is generated when an account is created or its e-mail address
424 * has changed.
426 * If the code is invalid or has expired, returns NULL.
428 * @param string $code Confirmation code
429 * @return User|null
431 public static function newFromConfirmationCode( $code ) {
432 $dbr = wfGetDB( DB_SLAVE );
433 $id = $dbr->selectField( 'user', 'user_id', array(
434 'user_email_token' => md5( $code ),
435 'user_email_token_expires > ' . $dbr->addQuotes( $dbr->timestamp() ),
436 ) );
437 if ( $id !== false ) {
438 return User::newFromId( $id );
439 } else {
440 return null;
445 * Create a new user object using data from session or cookies. If the
446 * login credentials are invalid, the result is an anonymous user.
448 * @param WebRequest $request Object to use; $wgRequest will be used if omitted.
449 * @return User object
451 public static function newFromSession( WebRequest $request = null ) {
452 $user = new User;
453 $user->mFrom = 'session';
454 $user->mRequest = $request;
455 return $user;
459 * Create a new user object from a user row.
460 * The row should have the following fields from the user table in it:
461 * - either user_name or user_id to load further data if needed (or both)
462 * - user_real_name
463 * - all other fields (email, password, etc.)
464 * It is useless to provide the remaining fields if either user_id,
465 * user_name and user_real_name are not provided because the whole row
466 * will be loaded once more from the database when accessing them.
468 * @param array $row A row from the user table
469 * @param array $data Further data to load into the object (see User::loadFromRow for valid keys)
470 * @return User
472 public static function newFromRow( $row, $data = null ) {
473 $user = new User;
474 $user->loadFromRow( $row, $data );
475 return $user;
478 //@}
481 * Get the username corresponding to a given user ID
482 * @param int $id User ID
483 * @return string|bool The corresponding username
485 public static function whoIs( $id ) {
486 return UserCache::singleton()->getProp( $id, 'name' );
490 * Get the real name of a user given their user ID
492 * @param int $id User ID
493 * @return string|bool The corresponding user's real name
495 public static function whoIsReal( $id ) {
496 return UserCache::singleton()->getProp( $id, 'real_name' );
500 * Get database id given a user name
501 * @param string $name Username
502 * @return int|null The corresponding user's ID, or null if user is nonexistent
504 public static function idFromName( $name ) {
505 $nt = Title::makeTitleSafe( NS_USER, $name );
506 if ( is_null( $nt ) ) {
507 // Illegal name
508 return null;
511 if ( isset( self::$idCacheByName[$name] ) ) {
512 return self::$idCacheByName[$name];
515 $dbr = wfGetDB( DB_SLAVE );
516 $s = $dbr->selectRow( 'user', array( 'user_id' ), array( 'user_name' => $nt->getText() ), __METHOD__ );
518 if ( $s === false ) {
519 $result = null;
520 } else {
521 $result = $s->user_id;
524 self::$idCacheByName[$name] = $result;
526 if ( count( self::$idCacheByName ) > 1000 ) {
527 self::$idCacheByName = array();
530 return $result;
534 * Reset the cache used in idFromName(). For use in tests.
536 public static function resetIdByNameCache() {
537 self::$idCacheByName = array();
541 * Does the string match an anonymous IPv4 address?
543 * This function exists for username validation, in order to reject
544 * usernames which are similar in form to IP addresses. Strings such
545 * as 300.300.300.300 will return true because it looks like an IP
546 * address, despite not being strictly valid.
548 * We match "\d{1,3}\.\d{1,3}\.\d{1,3}\.xxx" as an anonymous IP
549 * address because the usemod software would "cloak" anonymous IP
550 * addresses like this, if we allowed accounts like this to be created
551 * new users could get the old edits of these anonymous users.
553 * @param string $name Name to match
554 * @return bool
556 public static function isIP( $name ) {
557 return preg_match( '/^\d{1,3}\.\d{1,3}\.\d{1,3}\.(?:xxx|\d{1,3})$/', $name ) || IP::isIPv6( $name );
561 * Is the input a valid username?
563 * Checks if the input is a valid username, we don't want an empty string,
564 * an IP address, anything that contains slashes (would mess up subpages),
565 * is longer than the maximum allowed username size or doesn't begin with
566 * a capital letter.
568 * @param string $name Name to match
569 * @return bool
571 public static function isValidUserName( $name ) {
572 global $wgContLang, $wgMaxNameChars;
574 if ( $name == ''
575 || User::isIP( $name )
576 || strpos( $name, '/' ) !== false
577 || strlen( $name ) > $wgMaxNameChars
578 || $name != $wgContLang->ucfirst( $name ) ) {
579 wfDebugLog( 'username', __METHOD__ .
580 ": '$name' invalid due to empty, IP, slash, length, or lowercase" );
581 return false;
584 // Ensure that the name can't be misresolved as a different title,
585 // such as with extra namespace keys at the start.
586 $parsed = Title::newFromText( $name );
587 if ( is_null( $parsed )
588 || $parsed->getNamespace()
589 || strcmp( $name, $parsed->getPrefixedText() ) ) {
590 wfDebugLog( 'username', __METHOD__ .
591 ": '$name' invalid due to ambiguous prefixes" );
592 return false;
595 // Check an additional blacklist of troublemaker characters.
596 // Should these be merged into the title char list?
597 $unicodeBlacklist = '/[' .
598 '\x{0080}-\x{009f}' . # iso-8859-1 control chars
599 '\x{00a0}' . # non-breaking space
600 '\x{2000}-\x{200f}' . # various whitespace
601 '\x{2028}-\x{202f}' . # breaks and control chars
602 '\x{3000}' . # ideographic space
603 '\x{e000}-\x{f8ff}' . # private use
604 ']/u';
605 if ( preg_match( $unicodeBlacklist, $name ) ) {
606 wfDebugLog( 'username', __METHOD__ .
607 ": '$name' invalid due to blacklisted characters" );
608 return false;
611 return true;
615 * Usernames which fail to pass this function will be blocked
616 * from user login and new account registrations, but may be used
617 * internally by batch processes.
619 * If an account already exists in this form, login will be blocked
620 * by a failure to pass this function.
622 * @param string $name Name to match
623 * @return bool
625 public static function isUsableName( $name ) {
626 global $wgReservedUsernames;
627 // Must be a valid username, obviously ;)
628 if ( !self::isValidUserName( $name ) ) {
629 return false;
632 static $reservedUsernames = false;
633 if ( !$reservedUsernames ) {
634 $reservedUsernames = $wgReservedUsernames;
635 wfRunHooks( 'UserGetReservedNames', array( &$reservedUsernames ) );
638 // Certain names may be reserved for batch processes.
639 foreach ( $reservedUsernames as $reserved ) {
640 if ( substr( $reserved, 0, 4 ) == 'msg:' ) {
641 $reserved = wfMessage( substr( $reserved, 4 ) )->inContentLanguage()->text();
643 if ( $reserved == $name ) {
644 return false;
647 return true;
651 * Usernames which fail to pass this function will be blocked
652 * from new account registrations, but may be used internally
653 * either by batch processes or by user accounts which have
654 * already been created.
656 * Additional blacklisting may be added here rather than in
657 * isValidUserName() to avoid disrupting existing accounts.
659 * @param string $name to match
660 * @return bool
662 public static function isCreatableName( $name ) {
663 global $wgInvalidUsernameCharacters;
665 // Ensure that the username isn't longer than 235 bytes, so that
666 // (at least for the builtin skins) user javascript and css files
667 // will work. (bug 23080)
668 if ( strlen( $name ) > 235 ) {
669 wfDebugLog( 'username', __METHOD__ .
670 ": '$name' invalid due to length" );
671 return false;
674 // Preg yells if you try to give it an empty string
675 if ( $wgInvalidUsernameCharacters !== '' ) {
676 if ( preg_match( '/[' . preg_quote( $wgInvalidUsernameCharacters, '/' ) . ']/', $name ) ) {
677 wfDebugLog( 'username', __METHOD__ .
678 ": '$name' invalid due to wgInvalidUsernameCharacters" );
679 return false;
683 return self::isUsableName( $name );
687 * Is the input a valid password for this user?
689 * @param string $password Desired password
690 * @return bool
692 public function isValidPassword( $password ) {
693 //simple boolean wrapper for getPasswordValidity
694 return $this->getPasswordValidity( $password ) === true;
698 * Given unvalidated password input, return error message on failure.
700 * @param string $password Desired password
701 * @return mixed: true on success, string or array of error message on failure
703 public function getPasswordValidity( $password ) {
704 global $wgMinimalPasswordLength, $wgContLang;
706 static $blockedLogins = array(
707 'Useruser' => 'Passpass', 'Useruser1' => 'Passpass1', # r75589
708 'Apitestsysop' => 'testpass', 'Apitestuser' => 'testpass' # r75605
711 $result = false; //init $result to false for the internal checks
713 if ( !wfRunHooks( 'isValidPassword', array( $password, &$result, $this ) ) ) {
714 return $result;
717 if ( $result === false ) {
718 if ( strlen( $password ) < $wgMinimalPasswordLength ) {
719 return 'passwordtooshort';
720 } elseif ( $wgContLang->lc( $password ) == $wgContLang->lc( $this->mName ) ) {
721 return 'password-name-match';
722 } elseif ( isset( $blockedLogins[$this->getName()] ) && $password == $blockedLogins[$this->getName()] ) {
723 return 'password-login-forbidden';
724 } else {
725 //it seems weird returning true here, but this is because of the
726 //initialization of $result to false above. If the hook is never run or it
727 //doesn't modify $result, then we will likely get down into this if with
728 //a valid password.
729 return true;
731 } elseif ( $result === true ) {
732 return true;
733 } else {
734 return $result; //the isValidPassword hook set a string $result and returned true
739 * Does a string look like an e-mail address?
741 * This validates an email address using an HTML5 specification found at:
742 * http://www.whatwg.org/html/states-of-the-type-attribute.html#valid-e-mail-address
743 * Which as of 2011-01-24 says:
745 * A valid e-mail address is a string that matches the ABNF production
746 * 1*( atext / "." ) "@" ldh-str *( "." ldh-str ) where atext is defined
747 * in RFC 5322 section 3.2.3, and ldh-str is defined in RFC 1034 section
748 * 3.5.
750 * This function is an implementation of the specification as requested in
751 * bug 22449.
753 * Client-side forms will use the same standard validation rules via JS or
754 * HTML 5 validation; additional restrictions can be enforced server-side
755 * by extensions via the 'isValidEmailAddr' hook.
757 * Note that this validation doesn't 100% match RFC 2822, but is believed
758 * to be liberal enough for wide use. Some invalid addresses will still
759 * pass validation here.
761 * @param string $addr E-mail address
762 * @return bool
763 * @deprecated since 1.18 call Sanitizer::isValidEmail() directly
765 public static function isValidEmailAddr( $addr ) {
766 wfDeprecated( __METHOD__, '1.18' );
767 return Sanitizer::validateEmail( $addr );
771 * Given unvalidated user input, return a canonical username, or false if
772 * the username is invalid.
773 * @param string $name User input
774 * @param string|bool $validate type of validation to use:
775 * - false No validation
776 * - 'valid' Valid for batch processes
777 * - 'usable' Valid for batch processes and login
778 * - 'creatable' Valid for batch processes, login and account creation
780 * @throws MWException
781 * @return bool|string
783 public static function getCanonicalName( $name, $validate = 'valid' ) {
784 // Force usernames to capital
785 global $wgContLang;
786 $name = $wgContLang->ucfirst( $name );
788 # Reject names containing '#'; these will be cleaned up
789 # with title normalisation, but then it's too late to
790 # check elsewhere
791 if ( strpos( $name, '#' ) !== false ) {
792 return false;
795 // Clean up name according to title rules
796 $t = ( $validate === 'valid' ) ?
797 Title::newFromText( $name ) : Title::makeTitle( NS_USER, $name );
798 // Check for invalid titles
799 if ( is_null( $t ) ) {
800 return false;
803 // Reject various classes of invalid names
804 global $wgAuth;
805 $name = $wgAuth->getCanonicalName( $t->getText() );
807 switch ( $validate ) {
808 case false:
809 break;
810 case 'valid':
811 if ( !User::isValidUserName( $name ) ) {
812 $name = false;
814 break;
815 case 'usable':
816 if ( !User::isUsableName( $name ) ) {
817 $name = false;
819 break;
820 case 'creatable':
821 if ( !User::isCreatableName( $name ) ) {
822 $name = false;
824 break;
825 default:
826 throw new MWException( 'Invalid parameter value for $validate in ' . __METHOD__ );
828 return $name;
832 * Count the number of edits of a user
834 * @param int $uid User ID to check
835 * @return int The user's edit count
837 * @deprecated since 1.21 in favour of User::getEditCount
839 public static function edits( $uid ) {
840 wfDeprecated( __METHOD__, '1.21' );
841 $user = self::newFromId( $uid );
842 return $user->getEditCount();
846 * Return a random password.
848 * @return string New random password
850 public static function randomPassword() {
851 global $wgMinimalPasswordLength;
852 // Decide the final password length based on our min password length, stopping at a minimum of 10 chars
853 $length = max( 10, $wgMinimalPasswordLength );
854 // Multiply by 1.25 to get the number of hex characters we need
855 $length = $length * 1.25;
856 // Generate random hex chars
857 $hex = MWCryptRand::generateHex( $length );
858 // Convert from base 16 to base 32 to get a proper password like string
859 return wfBaseConvert( $hex, 16, 32 );
863 * Set cached properties to default.
865 * @note This no longer clears uncached lazy-initialised properties;
866 * the constructor does that instead.
868 * @param $name string|bool
870 public function loadDefaults( $name = false ) {
871 wfProfileIn( __METHOD__ );
873 $this->mId = 0;
874 $this->mName = $name;
875 $this->mRealName = '';
876 $this->mPassword = $this->mNewpassword = '';
877 $this->mNewpassTime = null;
878 $this->mEmail = '';
879 $this->mOptionOverrides = null;
880 $this->mOptionsLoaded = false;
882 $loggedOut = $this->getRequest()->getCookie( 'LoggedOut' );
883 if ( $loggedOut !== null ) {
884 $this->mTouched = wfTimestamp( TS_MW, $loggedOut );
885 } else {
886 $this->mTouched = '1'; # Allow any pages to be cached
889 $this->mToken = null; // Don't run cryptographic functions till we need a token
890 $this->mEmailAuthenticated = null;
891 $this->mEmailToken = '';
892 $this->mEmailTokenExpires = null;
893 $this->mRegistration = wfTimestamp( TS_MW );
894 $this->mGroups = array();
896 wfRunHooks( 'UserLoadDefaults', array( $this, $name ) );
898 wfProfileOut( __METHOD__ );
902 * Return whether an item has been loaded.
904 * @param string $item item to check. Current possibilities:
905 * - id
906 * - name
907 * - realname
908 * @param string $all 'all' to check if the whole object has been loaded
909 * or any other string to check if only the item is available (e.g.
910 * for optimisation)
911 * @return boolean
913 public function isItemLoaded( $item, $all = 'all' ) {
914 return ( $this->mLoadedItems === true && $all === 'all' ) ||
915 ( isset( $this->mLoadedItems[$item] ) && $this->mLoadedItems[$item] === true );
919 * Set that an item has been loaded
921 * @param string $item
923 protected function setItemLoaded( $item ) {
924 if ( is_array( $this->mLoadedItems ) ) {
925 $this->mLoadedItems[$item] = true;
930 * Load user data from the session or login cookie.
931 * @return bool True if the user is logged in, false otherwise.
933 private function loadFromSession() {
934 $result = null;
935 wfRunHooks( 'UserLoadFromSession', array( $this, &$result ) );
936 if ( $result !== null ) {
937 return $result;
940 $request = $this->getRequest();
942 $cookieId = $request->getCookie( 'UserID' );
943 $sessId = $request->getSessionData( 'wsUserID' );
945 if ( $cookieId !== null ) {
946 $sId = intval( $cookieId );
947 if ( $sessId !== null && $cookieId != $sessId ) {
948 wfDebugLog( 'loginSessions', "Session user ID ($sessId) and
949 cookie user ID ($sId) don't match!" );
950 return false;
952 $request->setSessionData( 'wsUserID', $sId );
953 } elseif ( $sessId !== null && $sessId != 0 ) {
954 $sId = $sessId;
955 } else {
956 return false;
959 if ( $request->getSessionData( 'wsUserName' ) !== null ) {
960 $sName = $request->getSessionData( 'wsUserName' );
961 } elseif ( $request->getCookie( 'UserName' ) !== null ) {
962 $sName = $request->getCookie( 'UserName' );
963 $request->setSessionData( 'wsUserName', $sName );
964 } else {
965 return false;
968 $proposedUser = User::newFromId( $sId );
969 if ( !$proposedUser->isLoggedIn() ) {
970 // Not a valid ID
971 return false;
974 global $wgBlockDisablesLogin;
975 if ( $wgBlockDisablesLogin && $proposedUser->isBlocked() ) {
976 // User blocked and we've disabled blocked user logins
977 return false;
980 if ( $request->getSessionData( 'wsToken' ) ) {
981 $passwordCorrect = ( $proposedUser->getToken( false ) === $request->getSessionData( 'wsToken' ) );
982 $from = 'session';
983 } elseif ( $request->getCookie( 'Token' ) ) {
984 # Get the token from DB/cache and clean it up to remove garbage padding.
985 # This deals with historical problems with bugs and the default column value.
986 $token = rtrim( $proposedUser->getToken( false ) ); // correct token
987 $passwordCorrect = ( strlen( $token ) && $token === $request->getCookie( 'Token' ) );
988 $from = 'cookie';
989 } else {
990 // No session or persistent login cookie
991 return false;
994 if ( ( $sName === $proposedUser->getName() ) && $passwordCorrect ) {
995 $this->loadFromUserObject( $proposedUser );
996 $request->setSessionData( 'wsToken', $this->mToken );
997 wfDebug( "User: logged in from $from\n" );
998 return true;
999 } else {
1000 // Invalid credentials
1001 wfDebug( "User: can't log in from $from, invalid credentials\n" );
1002 return false;
1007 * Load user and user_group data from the database.
1008 * $this->mId must be set, this is how the user is identified.
1010 * @return bool True if the user exists, false if the user is anonymous
1012 public function loadFromDatabase() {
1013 // Paranoia
1014 $this->mId = intval( $this->mId );
1016 // Anonymous user
1017 if ( !$this->mId ) {
1018 $this->loadDefaults();
1019 return false;
1022 $dbr = wfGetDB( DB_MASTER );
1023 $s = $dbr->selectRow( 'user', self::selectFields(), array( 'user_id' => $this->mId ), __METHOD__ );
1025 wfRunHooks( 'UserLoadFromDatabase', array( $this, &$s ) );
1027 if ( $s !== false ) {
1028 // Initialise user table data
1029 $this->loadFromRow( $s );
1030 $this->mGroups = null; // deferred
1031 $this->getEditCount(); // revalidation for nulls
1032 return true;
1033 } else {
1034 // Invalid user_id
1035 $this->mId = 0;
1036 $this->loadDefaults();
1037 return false;
1042 * Initialize this object from a row from the user table.
1044 * @param array $row Row from the user table to load.
1045 * @param array $data Further user data to load into the object
1047 * user_groups Array with groups out of the user_groups table
1048 * user_properties Array with properties out of the user_properties table
1050 public function loadFromRow( $row, $data = null ) {
1051 $all = true;
1053 $this->mGroups = null; // deferred
1055 if ( isset( $row->user_name ) ) {
1056 $this->mName = $row->user_name;
1057 $this->mFrom = 'name';
1058 $this->setItemLoaded( 'name' );
1059 } else {
1060 $all = false;
1063 if ( isset( $row->user_real_name ) ) {
1064 $this->mRealName = $row->user_real_name;
1065 $this->setItemLoaded( 'realname' );
1066 } else {
1067 $all = false;
1070 if ( isset( $row->user_id ) ) {
1071 $this->mId = intval( $row->user_id );
1072 $this->mFrom = 'id';
1073 $this->setItemLoaded( 'id' );
1074 } else {
1075 $all = false;
1078 if ( isset( $row->user_editcount ) ) {
1079 $this->mEditCount = $row->user_editcount;
1080 } else {
1081 $all = false;
1084 if ( isset( $row->user_password ) ) {
1085 $this->mPassword = $row->user_password;
1086 $this->mNewpassword = $row->user_newpassword;
1087 $this->mNewpassTime = wfTimestampOrNull( TS_MW, $row->user_newpass_time );
1088 $this->mEmail = $row->user_email;
1089 if ( isset( $row->user_options ) ) {
1090 $this->decodeOptions( $row->user_options );
1092 $this->mTouched = wfTimestamp( TS_MW, $row->user_touched );
1093 $this->mToken = $row->user_token;
1094 if ( $this->mToken == '' ) {
1095 $this->mToken = null;
1097 $this->mEmailAuthenticated = wfTimestampOrNull( TS_MW, $row->user_email_authenticated );
1098 $this->mEmailToken = $row->user_email_token;
1099 $this->mEmailTokenExpires = wfTimestampOrNull( TS_MW, $row->user_email_token_expires );
1100 $this->mRegistration = wfTimestampOrNull( TS_MW, $row->user_registration );
1101 } else {
1102 $all = false;
1105 if ( $all ) {
1106 $this->mLoadedItems = true;
1109 if ( is_array( $data ) ) {
1110 if ( isset( $data['user_groups'] ) && is_array( $data['user_groups'] ) ) {
1111 $this->mGroups = $data['user_groups'];
1113 if ( isset( $data['user_properties'] ) && is_array( $data['user_properties'] ) ) {
1114 $this->loadOptions( $data['user_properties'] );
1120 * Load the data for this user object from another user object.
1122 * @param $user User
1124 protected function loadFromUserObject( $user ) {
1125 $user->load();
1126 $user->loadGroups();
1127 $user->loadOptions();
1128 foreach ( self::$mCacheVars as $var ) {
1129 $this->$var = $user->$var;
1134 * Load the groups from the database if they aren't already loaded.
1136 private function loadGroups() {
1137 if ( is_null( $this->mGroups ) ) {
1138 $dbr = wfGetDB( DB_MASTER );
1139 $res = $dbr->select( 'user_groups',
1140 array( 'ug_group' ),
1141 array( 'ug_user' => $this->mId ),
1142 __METHOD__ );
1143 $this->mGroups = array();
1144 foreach ( $res as $row ) {
1145 $this->mGroups[] = $row->ug_group;
1151 * Add the user to the group if he/she meets given criteria.
1153 * Contrary to autopromotion by \ref $wgAutopromote, the group will be
1154 * possible to remove manually via Special:UserRights. In such case it
1155 * will not be re-added automatically. The user will also not lose the
1156 * group if they no longer meet the criteria.
1158 * @param string $event key in $wgAutopromoteOnce (each one has groups/criteria)
1160 * @return array Array of groups the user has been promoted to.
1162 * @see $wgAutopromoteOnce
1164 public function addAutopromoteOnceGroups( $event ) {
1165 global $wgAutopromoteOnceLogInRC, $wgAuth;
1167 $toPromote = array();
1168 if ( $this->getId() ) {
1169 $toPromote = Autopromote::getAutopromoteOnceGroups( $this, $event );
1170 if ( count( $toPromote ) ) {
1171 $oldGroups = $this->getGroups(); // previous groups
1173 foreach ( $toPromote as $group ) {
1174 $this->addGroup( $group );
1176 // update groups in external authentication database
1177 $wgAuth->updateExternalDBGroups( $this, $toPromote );
1179 $newGroups = array_merge( $oldGroups, $toPromote ); // all groups
1181 $logEntry = new ManualLogEntry( 'rights', 'autopromote' );
1182 $logEntry->setPerformer( $this );
1183 $logEntry->setTarget( $this->getUserPage() );
1184 $logEntry->setParameters( array(
1185 '4::oldgroups' => $oldGroups,
1186 '5::newgroups' => $newGroups,
1187 ) );
1188 $logid = $logEntry->insert();
1189 if ( $wgAutopromoteOnceLogInRC ) {
1190 $logEntry->publish( $logid );
1194 return $toPromote;
1198 * Clear various cached data stored in this object. The cache of the user table
1199 * data (i.e. self::$mCacheVars) is not cleared unless $reloadFrom is given.
1201 * @param bool|string $reloadFrom Reload user and user_groups table data from a
1202 * given source. May be "name", "id", "defaults", "session", or false for
1203 * no reload.
1205 public function clearInstanceCache( $reloadFrom = false ) {
1206 $this->mNewtalk = -1;
1207 $this->mDatePreference = null;
1208 $this->mBlockedby = -1; # Unset
1209 $this->mHash = false;
1210 $this->mRights = null;
1211 $this->mEffectiveGroups = null;
1212 $this->mImplicitGroups = null;
1213 $this->mGroups = null;
1214 $this->mOptions = null;
1215 $this->mOptionsLoaded = false;
1216 $this->mEditCount = null;
1218 if ( $reloadFrom ) {
1219 $this->mLoadedItems = array();
1220 $this->mFrom = $reloadFrom;
1225 * Combine the language default options with any site-specific options
1226 * and add the default language variants.
1228 * @return Array of String options
1230 public static function getDefaultOptions() {
1231 global $wgNamespacesToBeSearchedDefault, $wgDefaultUserOptions, $wgContLang, $wgDefaultSkin;
1233 static $defOpt = null;
1234 if ( !defined( 'MW_PHPUNIT_TEST' ) && $defOpt !== null ) {
1235 // Disabling this for the unit tests, as they rely on being able to change $wgContLang
1236 // mid-request and see that change reflected in the return value of this function.
1237 // Which is insane and would never happen during normal MW operation
1238 return $defOpt;
1241 $defOpt = $wgDefaultUserOptions;
1242 // Default language setting
1243 $defOpt['language'] = $wgContLang->getCode();
1244 foreach ( LanguageConverter::$languagesWithVariants as $langCode ) {
1245 $defOpt[$langCode == $wgContLang->getCode() ? 'variant' : "variant-$langCode"] = $langCode;
1247 foreach ( SearchEngine::searchableNamespaces() as $nsnum => $nsname ) {
1248 $defOpt['searchNs' . $nsnum] = !empty( $wgNamespacesToBeSearchedDefault[$nsnum] );
1250 $defOpt['skin'] = $wgDefaultSkin;
1252 wfRunHooks( 'UserGetDefaultOptions', array( &$defOpt ) );
1254 return $defOpt;
1258 * Get a given default option value.
1260 * @param string $opt Name of option to retrieve
1261 * @return string Default option value
1263 public static function getDefaultOption( $opt ) {
1264 $defOpts = self::getDefaultOptions();
1265 if ( isset( $defOpts[$opt] ) ) {
1266 return $defOpts[$opt];
1267 } else {
1268 return null;
1273 * Get blocking information
1274 * @param bool $bFromSlave Whether to check the slave database first. To
1275 * improve performance, non-critical checks are done
1276 * against slaves. Check when actually saving should be
1277 * done against master.
1279 private function getBlockedStatus( $bFromSlave = true ) {
1280 global $wgProxyWhitelist, $wgUser, $wgApplyIpBlocksToXff;
1282 if ( -1 != $this->mBlockedby ) {
1283 return;
1286 wfProfileIn( __METHOD__ );
1287 wfDebug( __METHOD__ . ": checking...\n" );
1289 // Initialize data...
1290 // Otherwise something ends up stomping on $this->mBlockedby when
1291 // things get lazy-loaded later, causing false positive block hits
1292 // due to -1 !== 0. Probably session-related... Nothing should be
1293 // overwriting mBlockedby, surely?
1294 $this->load();
1296 # We only need to worry about passing the IP address to the Block generator if the
1297 # user is not immune to autoblocks/hardblocks, and they are the current user so we
1298 # know which IP address they're actually coming from
1299 if ( !$this->isAllowed( 'ipblock-exempt' ) && $this->getID() == $wgUser->getID() ) {
1300 $ip = $this->getRequest()->getIP();
1301 } else {
1302 $ip = null;
1305 // User/IP blocking
1306 $block = Block::newFromTarget( $this, $ip, !$bFromSlave );
1308 // Proxy blocking
1309 if ( !$block instanceof Block && $ip !== null && !$this->isAllowed( 'proxyunbannable' )
1310 && !in_array( $ip, $wgProxyWhitelist ) )
1312 // Local list
1313 if ( self::isLocallyBlockedProxy( $ip ) ) {
1314 $block = new Block;
1315 $block->setBlocker( wfMessage( 'proxyblocker' )->text() );
1316 $block->mReason = wfMessage( 'proxyblockreason' )->text();
1317 $block->setTarget( $ip );
1318 } elseif ( $this->isAnon() && $this->isDnsBlacklisted( $ip ) ) {
1319 $block = new Block;
1320 $block->setBlocker( wfMessage( 'sorbs' )->text() );
1321 $block->mReason = wfMessage( 'sorbsreason' )->text();
1322 $block->setTarget( $ip );
1326 // (bug 23343) Apply IP blocks to the contents of XFF headers, if enabled
1327 if ( !$block instanceof Block
1328 && $wgApplyIpBlocksToXff
1329 && $ip !== null
1330 && !$this->isAllowed( 'proxyunbannable' )
1331 && !in_array( $ip, $wgProxyWhitelist )
1333 $xff = $this->getRequest()->getHeader( 'X-Forwarded-For' );
1334 $xff = array_map( 'trim', explode( ',', $xff ) );
1335 $xff = array_diff( $xff, array( $ip ) );
1336 $xffblocks = Block::getBlocksForIPList( $xff, $this->isAnon(), !$bFromSlave );
1337 $block = Block::chooseBlock( $xffblocks, $xff );
1338 if ( $block instanceof Block ) {
1339 # Mangle the reason to alert the user that the block
1340 # originated from matching the X-Forwarded-For header.
1341 $block->mReason = wfMessage( 'xffblockreason', $block->mReason )->text();
1345 if ( $block instanceof Block ) {
1346 wfDebug( __METHOD__ . ": Found block.\n" );
1347 $this->mBlock = $block;
1348 $this->mBlockedby = $block->getByName();
1349 $this->mBlockreason = $block->mReason;
1350 $this->mHideName = $block->mHideName;
1351 $this->mAllowUsertalk = !$block->prevents( 'editownusertalk' );
1352 } else {
1353 $this->mBlockedby = '';
1354 $this->mHideName = 0;
1355 $this->mAllowUsertalk = false;
1358 // Extensions
1359 wfRunHooks( 'GetBlockedStatus', array( &$this ) );
1361 wfProfileOut( __METHOD__ );
1365 * Whether the given IP is in a DNS blacklist.
1367 * @param string $ip IP to check
1368 * @param bool $checkWhitelist whether to check the whitelist first
1369 * @return bool True if blacklisted.
1371 public function isDnsBlacklisted( $ip, $checkWhitelist = false ) {
1372 global $wgEnableSorbs, $wgEnableDnsBlacklist,
1373 $wgSorbsUrl, $wgDnsBlacklistUrls, $wgProxyWhitelist;
1375 if ( !$wgEnableDnsBlacklist && !$wgEnableSorbs ) {
1376 return false;
1379 if ( $checkWhitelist && in_array( $ip, $wgProxyWhitelist ) ) {
1380 return false;
1383 $urls = array_merge( $wgDnsBlacklistUrls, (array)$wgSorbsUrl );
1384 return $this->inDnsBlacklist( $ip, $urls );
1388 * Whether the given IP is in a given DNS blacklist.
1390 * @param string $ip IP to check
1391 * @param string|array $bases of Strings: URL of the DNS blacklist
1392 * @return bool True if blacklisted.
1394 public function inDnsBlacklist( $ip, $bases ) {
1395 wfProfileIn( __METHOD__ );
1397 $found = false;
1398 // @todo FIXME: IPv6 ??? (http://bugs.php.net/bug.php?id=33170)
1399 if ( IP::isIPv4( $ip ) ) {
1400 // Reverse IP, bug 21255
1401 $ipReversed = implode( '.', array_reverse( explode( '.', $ip ) ) );
1403 foreach ( (array)$bases as $base ) {
1404 // Make hostname
1405 // If we have an access key, use that too (ProjectHoneypot, etc.)
1406 if ( is_array( $base ) ) {
1407 if ( count( $base ) >= 2 ) {
1408 // Access key is 1, base URL is 0
1409 $host = "{$base[1]}.$ipReversed.{$base[0]}";
1410 } else {
1411 $host = "$ipReversed.{$base[0]}";
1413 } else {
1414 $host = "$ipReversed.$base";
1417 // Send query
1418 $ipList = gethostbynamel( $host );
1420 if ( $ipList ) {
1421 wfDebugLog( 'dnsblacklist', "Hostname $host is {$ipList[0]}, it's a proxy says $base!\n" );
1422 $found = true;
1423 break;
1424 } else {
1425 wfDebugLog( 'dnsblacklist', "Requested $host, not found in $base.\n" );
1430 wfProfileOut( __METHOD__ );
1431 return $found;
1435 * Check if an IP address is in the local proxy list
1437 * @param $ip string
1439 * @return bool
1441 public static function isLocallyBlockedProxy( $ip ) {
1442 global $wgProxyList;
1444 if ( !$wgProxyList ) {
1445 return false;
1447 wfProfileIn( __METHOD__ );
1449 if ( !is_array( $wgProxyList ) ) {
1450 // Load from the specified file
1451 $wgProxyList = array_map( 'trim', file( $wgProxyList ) );
1454 if ( !is_array( $wgProxyList ) ) {
1455 $ret = false;
1456 } elseif ( array_search( $ip, $wgProxyList ) !== false ) {
1457 $ret = true;
1458 } elseif ( array_key_exists( $ip, $wgProxyList ) ) {
1459 // Old-style flipped proxy list
1460 $ret = true;
1461 } else {
1462 $ret = false;
1464 wfProfileOut( __METHOD__ );
1465 return $ret;
1469 * Is this user subject to rate limiting?
1471 * @return bool True if rate limited
1473 public function isPingLimitable() {
1474 global $wgRateLimitsExcludedIPs;
1475 if ( in_array( $this->getRequest()->getIP(), $wgRateLimitsExcludedIPs ) ) {
1476 // No other good way currently to disable rate limits
1477 // for specific IPs. :P
1478 // But this is a crappy hack and should die.
1479 return false;
1481 return !$this->isAllowed( 'noratelimit' );
1485 * Primitive rate limits: enforce maximum actions per time period
1486 * to put a brake on flooding.
1488 * @note When using a shared cache like memcached, IP-address
1489 * last-hit counters will be shared across wikis.
1491 * @param string $action Action to enforce; 'edit' if unspecified
1492 * @param integer $incrBy Positive amount to increment counter by [defaults to 1]
1493 * @return bool True if a rate limiter was tripped
1495 public function pingLimiter( $action = 'edit', $incrBy = 1 ) {
1496 // Call the 'PingLimiter' hook
1497 $result = false;
1498 if ( !wfRunHooks( 'PingLimiter', array( &$this, $action, &$result, $incrBy ) ) ) {
1499 return $result;
1502 global $wgRateLimits;
1503 if ( !isset( $wgRateLimits[$action] ) ) {
1504 return false;
1507 // Some groups shouldn't trigger the ping limiter, ever
1508 if ( !$this->isPingLimitable() ) {
1509 return false;
1512 global $wgMemc, $wgRateLimitLog;
1513 wfProfileIn( __METHOD__ );
1515 $limits = $wgRateLimits[$action];
1516 $keys = array();
1517 $id = $this->getId();
1518 $userLimit = false;
1520 if ( isset( $limits['anon'] ) && $id == 0 ) {
1521 $keys[wfMemcKey( 'limiter', $action, 'anon' )] = $limits['anon'];
1524 if ( isset( $limits['user'] ) && $id != 0 ) {
1525 $userLimit = $limits['user'];
1527 if ( $this->isNewbie() ) {
1528 if ( isset( $limits['newbie'] ) && $id != 0 ) {
1529 $keys[wfMemcKey( 'limiter', $action, 'user', $id )] = $limits['newbie'];
1531 if ( isset( $limits['ip'] ) ) {
1532 $ip = $this->getRequest()->getIP();
1533 $keys["mediawiki:limiter:$action:ip:$ip"] = $limits['ip'];
1535 if ( isset( $limits['subnet'] ) ) {
1536 $ip = $this->getRequest()->getIP();
1537 $matches = array();
1538 $subnet = false;
1539 if ( IP::isIPv6( $ip ) ) {
1540 $parts = IP::parseRange( "$ip/64" );
1541 $subnet = $parts[0];
1542 } elseif ( preg_match( '/^(\d+\.\d+\.\d+)\.\d+$/', $ip, $matches ) ) {
1543 // IPv4
1544 $subnet = $matches[1];
1546 if ( $subnet !== false ) {
1547 $keys["mediawiki:limiter:$action:subnet:$subnet"] = $limits['subnet'];
1551 // Check for group-specific permissions
1552 // If more than one group applies, use the group with the highest limit
1553 foreach ( $this->getGroups() as $group ) {
1554 if ( isset( $limits[$group] ) ) {
1555 if ( $userLimit === false || $limits[$group] > $userLimit ) {
1556 $userLimit = $limits[$group];
1560 // Set the user limit key
1561 if ( $userLimit !== false ) {
1562 list( $max, $period ) = $userLimit;
1563 wfDebug( __METHOD__ . ": effective user limit: $max in {$period}s\n" );
1564 $keys[wfMemcKey( 'limiter', $action, 'user', $id )] = $userLimit;
1567 $triggered = false;
1568 foreach ( $keys as $key => $limit ) {
1569 list( $max, $period ) = $limit;
1570 $summary = "(limit $max in {$period}s)";
1571 $count = $wgMemc->get( $key );
1572 // Already pinged?
1573 if ( $count ) {
1574 if ( $count >= $max ) {
1575 wfDebug( __METHOD__ . ": tripped! $key at $count $summary\n" );
1576 if ( $wgRateLimitLog ) {
1577 wfSuppressWarnings();
1578 file_put_contents( $wgRateLimitLog, wfTimestamp( TS_MW ) . ' ' . wfWikiID() . ': ' . $this->getName() . " tripped $key at $count $summary\n", FILE_APPEND );
1579 wfRestoreWarnings();
1581 $triggered = true;
1582 } else {
1583 wfDebug( __METHOD__ . ": ok. $key at $count $summary\n" );
1585 } else {
1586 wfDebug( __METHOD__ . ": adding record for $key $summary\n" );
1587 if ( $incrBy > 0 ) {
1588 $wgMemc->add( $key, 0, intval( $period ) ); // first ping
1591 if ( $incrBy > 0 ) {
1592 $wgMemc->incr( $key, $incrBy );
1596 wfProfileOut( __METHOD__ );
1597 return $triggered;
1601 * Check if user is blocked
1603 * @param bool $bFromSlave Whether to check the slave database instead of the master
1604 * @return bool True if blocked, false otherwise
1606 public function isBlocked( $bFromSlave = true ) { // hacked from false due to horrible probs on site
1607 return $this->getBlock( $bFromSlave ) instanceof Block && $this->getBlock()->prevents( 'edit' );
1611 * Get the block affecting the user, or null if the user is not blocked
1613 * @param bool $bFromSlave Whether to check the slave database instead of the master
1614 * @return Block|null
1616 public function getBlock( $bFromSlave = true ) {
1617 $this->getBlockedStatus( $bFromSlave );
1618 return $this->mBlock instanceof Block ? $this->mBlock : null;
1622 * Check if user is blocked from editing a particular article
1624 * @param Title $title Title to check
1625 * @param bool $bFromSlave whether to check the slave database instead of the master
1626 * @return bool
1628 function isBlockedFrom( $title, $bFromSlave = false ) {
1629 global $wgBlockAllowsUTEdit;
1630 wfProfileIn( __METHOD__ );
1632 $blocked = $this->isBlocked( $bFromSlave );
1633 $allowUsertalk = ( $wgBlockAllowsUTEdit ? $this->mAllowUsertalk : false );
1634 // If a user's name is suppressed, they cannot make edits anywhere
1635 if ( !$this->mHideName && $allowUsertalk && $title->getText() === $this->getName() &&
1636 $title->getNamespace() == NS_USER_TALK ) {
1637 $blocked = false;
1638 wfDebug( __METHOD__ . ": self-talk page, ignoring any blocks\n" );
1641 wfRunHooks( 'UserIsBlockedFrom', array( $this, $title, &$blocked, &$allowUsertalk ) );
1643 wfProfileOut( __METHOD__ );
1644 return $blocked;
1648 * If user is blocked, return the name of the user who placed the block
1649 * @return string Name of blocker
1651 public function blockedBy() {
1652 $this->getBlockedStatus();
1653 return $this->mBlockedby;
1657 * If user is blocked, return the specified reason for the block
1658 * @return string Blocking reason
1660 public function blockedFor() {
1661 $this->getBlockedStatus();
1662 return $this->mBlockreason;
1666 * If user is blocked, return the ID for the block
1667 * @return int Block ID
1669 public function getBlockId() {
1670 $this->getBlockedStatus();
1671 return ( $this->mBlock ? $this->mBlock->getId() : false );
1675 * Check if user is blocked on all wikis.
1676 * Do not use for actual edit permission checks!
1677 * This is intended for quick UI checks.
1679 * @param string $ip IP address, uses current client if none given
1680 * @return bool True if blocked, false otherwise
1682 public function isBlockedGlobally( $ip = '' ) {
1683 if ( $this->mBlockedGlobally !== null ) {
1684 return $this->mBlockedGlobally;
1686 // User is already an IP?
1687 if ( IP::isIPAddress( $this->getName() ) ) {
1688 $ip = $this->getName();
1689 } elseif ( !$ip ) {
1690 $ip = $this->getRequest()->getIP();
1692 $blocked = false;
1693 wfRunHooks( 'UserIsBlockedGlobally', array( &$this, $ip, &$blocked ) );
1694 $this->mBlockedGlobally = (bool)$blocked;
1695 return $this->mBlockedGlobally;
1699 * Check if user account is locked
1701 * @return bool True if locked, false otherwise
1703 public function isLocked() {
1704 if ( $this->mLocked !== null ) {
1705 return $this->mLocked;
1707 global $wgAuth;
1708 StubObject::unstub( $wgAuth );
1709 $authUser = $wgAuth->getUserInstance( $this );
1710 $this->mLocked = (bool)$authUser->isLocked();
1711 return $this->mLocked;
1715 * Check if user account is hidden
1717 * @return bool True if hidden, false otherwise
1719 public function isHidden() {
1720 if ( $this->mHideName !== null ) {
1721 return $this->mHideName;
1723 $this->getBlockedStatus();
1724 if ( !$this->mHideName ) {
1725 global $wgAuth;
1726 StubObject::unstub( $wgAuth );
1727 $authUser = $wgAuth->getUserInstance( $this );
1728 $this->mHideName = (bool)$authUser->isHidden();
1730 return $this->mHideName;
1734 * Get the user's ID.
1735 * @return int The user's ID; 0 if the user is anonymous or nonexistent
1737 public function getId() {
1738 if ( $this->mId === null && $this->mName !== null && User::isIP( $this->mName ) ) {
1739 // Special case, we know the user is anonymous
1740 return 0;
1741 } elseif ( !$this->isItemLoaded( 'id' ) ) {
1742 // Don't load if this was initialized from an ID
1743 $this->load();
1745 return $this->mId;
1749 * Set the user and reload all fields according to a given ID
1750 * @param int $v User ID to reload
1752 public function setId( $v ) {
1753 $this->mId = $v;
1754 $this->clearInstanceCache( 'id' );
1758 * Get the user name, or the IP of an anonymous user
1759 * @return string User's name or IP address
1761 public function getName() {
1762 if ( $this->isItemLoaded( 'name', 'only' ) ) {
1763 // Special case optimisation
1764 return $this->mName;
1765 } else {
1766 $this->load();
1767 if ( $this->mName === false ) {
1768 // Clean up IPs
1769 $this->mName = IP::sanitizeIP( $this->getRequest()->getIP() );
1771 return $this->mName;
1776 * Set the user name.
1778 * This does not reload fields from the database according to the given
1779 * name. Rather, it is used to create a temporary "nonexistent user" for
1780 * later addition to the database. It can also be used to set the IP
1781 * address for an anonymous user to something other than the current
1782 * remote IP.
1784 * @note User::newFromName() has roughly the same function, when the named user
1785 * does not exist.
1786 * @param string $str New user name to set
1788 public function setName( $str ) {
1789 $this->load();
1790 $this->mName = $str;
1794 * Get the user's name escaped by underscores.
1795 * @return string Username escaped by underscores.
1797 public function getTitleKey() {
1798 return str_replace( ' ', '_', $this->getName() );
1802 * Check if the user has new messages.
1803 * @return bool True if the user has new messages
1805 public function getNewtalk() {
1806 $this->load();
1808 // Load the newtalk status if it is unloaded (mNewtalk=-1)
1809 if ( $this->mNewtalk === -1 ) {
1810 $this->mNewtalk = false; # reset talk page status
1812 // Check memcached separately for anons, who have no
1813 // entire User object stored in there.
1814 if ( !$this->mId ) {
1815 global $wgDisableAnonTalk;
1816 if ( $wgDisableAnonTalk ) {
1817 // Anon newtalk disabled by configuration.
1818 $this->mNewtalk = false;
1819 } else {
1820 global $wgMemc;
1821 $key = wfMemcKey( 'newtalk', 'ip', $this->getName() );
1822 $newtalk = $wgMemc->get( $key );
1823 if ( strval( $newtalk ) !== '' ) {
1824 $this->mNewtalk = (bool)$newtalk;
1825 } else {
1826 // Since we are caching this, make sure it is up to date by getting it
1827 // from the master
1828 $this->mNewtalk = $this->checkNewtalk( 'user_ip', $this->getName(), true );
1829 $wgMemc->set( $key, (int)$this->mNewtalk, 1800 );
1832 } else {
1833 $this->mNewtalk = $this->checkNewtalk( 'user_id', $this->mId );
1837 return (bool)$this->mNewtalk;
1841 * Return the data needed to construct links for new talk page message
1842 * alerts. If there are new messages, this will return an associative array
1843 * with the following data:
1844 * wiki: The database name of the wiki
1845 * link: Root-relative link to the user's talk page
1846 * rev: The last talk page revision that the user has seen or null. This
1847 * is useful for building diff links.
1848 * If there are no new messages, it returns an empty array.
1849 * @note This function was designed to accomodate multiple talk pages, but
1850 * currently only returns a single link and revision.
1851 * @return Array
1853 public function getNewMessageLinks() {
1854 $talks = array();
1855 if ( !wfRunHooks( 'UserRetrieveNewTalks', array( &$this, &$talks ) ) ) {
1856 return $talks;
1857 } elseif ( !$this->getNewtalk() ) {
1858 return array();
1860 $utp = $this->getTalkPage();
1861 $dbr = wfGetDB( DB_SLAVE );
1862 // Get the "last viewed rev" timestamp from the oldest message notification
1863 $timestamp = $dbr->selectField( 'user_newtalk',
1864 'MIN(user_last_timestamp)',
1865 $this->isAnon() ? array( 'user_ip' => $this->getName() ) : array( 'user_id' => $this->getID() ),
1866 __METHOD__ );
1867 $rev = $timestamp ? Revision::loadFromTimestamp( $dbr, $utp, $timestamp ) : null;
1868 return array( array( 'wiki' => wfWikiID(), 'link' => $utp->getLocalURL(), 'rev' => $rev ) );
1872 * Get the revision ID for the last talk page revision viewed by the talk
1873 * page owner.
1874 * @return int|null Revision ID or null
1876 public function getNewMessageRevisionId() {
1877 $newMessageRevisionId = null;
1878 $newMessageLinks = $this->getNewMessageLinks();
1879 if ( $newMessageLinks ) {
1880 // Note: getNewMessageLinks() never returns more than a single link
1881 // and it is always for the same wiki, but we double-check here in
1882 // case that changes some time in the future.
1883 if ( count( $newMessageLinks ) === 1
1884 && $newMessageLinks[0]['wiki'] === wfWikiID()
1885 && $newMessageLinks[0]['rev']
1887 $newMessageRevision = $newMessageLinks[0]['rev'];
1888 $newMessageRevisionId = $newMessageRevision->getId();
1891 return $newMessageRevisionId;
1895 * Internal uncached check for new messages
1897 * @see getNewtalk()
1898 * @param string $field 'user_ip' for anonymous users, 'user_id' otherwise
1899 * @param string|int $id User's IP address for anonymous users, User ID otherwise
1900 * @param bool $fromMaster true to fetch from the master, false for a slave
1901 * @return bool True if the user has new messages
1903 protected function checkNewtalk( $field, $id, $fromMaster = false ) {
1904 if ( $fromMaster ) {
1905 $db = wfGetDB( DB_MASTER );
1906 } else {
1907 $db = wfGetDB( DB_SLAVE );
1909 $ok = $db->selectField( 'user_newtalk', $field,
1910 array( $field => $id ), __METHOD__ );
1911 return $ok !== false;
1915 * Add or update the new messages flag
1916 * @param string $field 'user_ip' for anonymous users, 'user_id' otherwise
1917 * @param string|int $id User's IP address for anonymous users, User ID otherwise
1918 * @param $curRev Revision new, as yet unseen revision of the user talk page. Ignored if null.
1919 * @return bool True if successful, false otherwise
1921 protected function updateNewtalk( $field, $id, $curRev = null ) {
1922 // Get timestamp of the talk page revision prior to the current one
1923 $prevRev = $curRev ? $curRev->getPrevious() : false;
1924 $ts = $prevRev ? $prevRev->getTimestamp() : null;
1925 // Mark the user as having new messages since this revision
1926 $dbw = wfGetDB( DB_MASTER );
1927 $dbw->insert( 'user_newtalk',
1928 array( $field => $id, 'user_last_timestamp' => $dbw->timestampOrNull( $ts ) ),
1929 __METHOD__,
1930 'IGNORE' );
1931 if ( $dbw->affectedRows() ) {
1932 wfDebug( __METHOD__ . ": set on ($field, $id)\n" );
1933 return true;
1934 } else {
1935 wfDebug( __METHOD__ . " already set ($field, $id)\n" );
1936 return false;
1941 * Clear the new messages flag for the given user
1942 * @param string $field 'user_ip' for anonymous users, 'user_id' otherwise
1943 * @param string|int $id User's IP address for anonymous users, User ID otherwise
1944 * @return bool True if successful, false otherwise
1946 protected function deleteNewtalk( $field, $id ) {
1947 $dbw = wfGetDB( DB_MASTER );
1948 $dbw->delete( 'user_newtalk',
1949 array( $field => $id ),
1950 __METHOD__ );
1951 if ( $dbw->affectedRows() ) {
1952 wfDebug( __METHOD__ . ": killed on ($field, $id)\n" );
1953 return true;
1954 } else {
1955 wfDebug( __METHOD__ . ": already gone ($field, $id)\n" );
1956 return false;
1961 * Update the 'You have new messages!' status.
1962 * @param bool $val Whether the user has new messages
1963 * @param $curRev Revision new, as yet unseen revision of the user talk page. Ignored if null or !$val.
1965 public function setNewtalk( $val, $curRev = null ) {
1966 if ( wfReadOnly() ) {
1967 return;
1970 $this->load();
1971 $this->mNewtalk = $val;
1973 if ( $this->isAnon() ) {
1974 $field = 'user_ip';
1975 $id = $this->getName();
1976 } else {
1977 $field = 'user_id';
1978 $id = $this->getId();
1980 global $wgMemc;
1982 if ( $val ) {
1983 $changed = $this->updateNewtalk( $field, $id, $curRev );
1984 } else {
1985 $changed = $this->deleteNewtalk( $field, $id );
1988 if ( $this->isAnon() ) {
1989 // Anons have a separate memcached space, since
1990 // user records aren't kept for them.
1991 $key = wfMemcKey( 'newtalk', 'ip', $id );
1992 $wgMemc->set( $key, $val ? 1 : 0, 1800 );
1994 if ( $changed ) {
1995 $this->invalidateCache();
2000 * Generate a current or new-future timestamp to be stored in the
2001 * user_touched field when we update things.
2002 * @return string Timestamp in TS_MW format
2004 private static function newTouchedTimestamp() {
2005 global $wgClockSkewFudge;
2006 return wfTimestamp( TS_MW, time() + $wgClockSkewFudge );
2010 * Clear user data from memcached.
2011 * Use after applying fun updates to the database; caller's
2012 * responsibility to update user_touched if appropriate.
2014 * Called implicitly from invalidateCache() and saveSettings().
2016 private function clearSharedCache() {
2017 $this->load();
2018 if ( $this->mId ) {
2019 global $wgMemc;
2020 $wgMemc->delete( wfMemcKey( 'user', 'id', $this->mId ) );
2025 * Immediately touch the user data cache for this account.
2026 * Updates user_touched field, and removes account data from memcached
2027 * for reload on the next hit.
2029 public function invalidateCache() {
2030 if ( wfReadOnly() ) {
2031 return;
2033 $this->load();
2034 if ( $this->mId ) {
2035 $this->mTouched = self::newTouchedTimestamp();
2037 $dbw = wfGetDB( DB_MASTER );
2038 $userid = $this->mId;
2039 $touched = $this->mTouched;
2040 $method = __METHOD__;
2041 $dbw->onTransactionIdle( function() use ( $dbw, $userid, $touched, $method ) {
2042 // Prevent contention slams by checking user_touched first
2043 $encTouched = $dbw->addQuotes( $dbw->timestamp( $touched ) );
2044 $needsPurge = $dbw->selectField( 'user', '1',
2045 array( 'user_id' => $userid, 'user_touched < ' . $encTouched ) );
2046 if ( $needsPurge ) {
2047 $dbw->update( 'user',
2048 array( 'user_touched' => $dbw->timestamp( $touched ) ),
2049 array( 'user_id' => $userid, 'user_touched < ' . $encTouched ),
2050 $method
2053 } );
2054 $this->clearSharedCache();
2059 * Validate the cache for this account.
2060 * @param string $timestamp A timestamp in TS_MW format
2061 * @return bool
2063 public function validateCache( $timestamp ) {
2064 $this->load();
2065 return ( $timestamp >= $this->mTouched );
2069 * Get the user touched timestamp
2070 * @return string timestamp
2072 public function getTouched() {
2073 $this->load();
2074 return $this->mTouched;
2078 * Set the password and reset the random token.
2079 * Calls through to authentication plugin if necessary;
2080 * will have no effect if the auth plugin refuses to
2081 * pass the change through or if the legal password
2082 * checks fail.
2084 * As a special case, setting the password to null
2085 * wipes it, so the account cannot be logged in until
2086 * a new password is set, for instance via e-mail.
2088 * @param string $str New password to set
2089 * @throws PasswordError on failure
2091 * @return bool
2093 public function setPassword( $str ) {
2094 global $wgAuth;
2096 if ( $str !== null ) {
2097 if ( !$wgAuth->allowPasswordChange() ) {
2098 throw new PasswordError( wfMessage( 'password-change-forbidden' )->text() );
2101 if ( !$this->isValidPassword( $str ) ) {
2102 global $wgMinimalPasswordLength;
2103 $valid = $this->getPasswordValidity( $str );
2104 if ( is_array( $valid ) ) {
2105 $message = array_shift( $valid );
2106 $params = $valid;
2107 } else {
2108 $message = $valid;
2109 $params = array( $wgMinimalPasswordLength );
2111 throw new PasswordError( wfMessage( $message, $params )->text() );
2115 if ( !$wgAuth->setPassword( $this, $str ) ) {
2116 throw new PasswordError( wfMessage( 'externaldberror' )->text() );
2119 $this->setInternalPassword( $str );
2121 return true;
2125 * Set the password and reset the random token unconditionally.
2127 * @param string|null $str New password to set or null to set an invalid
2128 * password hash meaning that the user will not be able to log in
2129 * through the web interface.
2131 public function setInternalPassword( $str ) {
2132 $this->load();
2133 $this->setToken();
2135 if ( $str === null ) {
2136 // Save an invalid hash...
2137 $this->mPassword = '';
2138 } else {
2139 $this->mPassword = self::crypt( $str );
2141 $this->mNewpassword = '';
2142 $this->mNewpassTime = null;
2146 * Get the user's current token.
2147 * @param bool $forceCreation Force the generation of a new token if the user doesn't have one (default=true for backwards compatibility)
2148 * @return string Token
2150 public function getToken( $forceCreation = true ) {
2151 $this->load();
2152 if ( !$this->mToken && $forceCreation ) {
2153 $this->setToken();
2155 return $this->mToken;
2159 * Set the random token (used for persistent authentication)
2160 * Called from loadDefaults() among other places.
2162 * @param string|bool $token If specified, set the token to this value
2164 public function setToken( $token = false ) {
2165 $this->load();
2166 if ( !$token ) {
2167 $this->mToken = MWCryptRand::generateHex( USER_TOKEN_LENGTH );
2168 } else {
2169 $this->mToken = $token;
2174 * Set the password for a password reminder or new account email
2176 * @param string $str New password to set
2177 * @param bool $throttle If true, reset the throttle timestamp to the present
2179 public function setNewpassword( $str, $throttle = true ) {
2180 $this->load();
2181 $this->mNewpassword = self::crypt( $str );
2182 if ( $throttle ) {
2183 $this->mNewpassTime = wfTimestampNow();
2188 * Has password reminder email been sent within the last
2189 * $wgPasswordReminderResendTime hours?
2190 * @return bool
2192 public function isPasswordReminderThrottled() {
2193 global $wgPasswordReminderResendTime;
2194 $this->load();
2195 if ( !$this->mNewpassTime || !$wgPasswordReminderResendTime ) {
2196 return false;
2198 $expiry = wfTimestamp( TS_UNIX, $this->mNewpassTime ) + $wgPasswordReminderResendTime * 3600;
2199 return time() < $expiry;
2203 * Get the user's e-mail address
2204 * @return string User's email address
2206 public function getEmail() {
2207 $this->load();
2208 wfRunHooks( 'UserGetEmail', array( $this, &$this->mEmail ) );
2209 return $this->mEmail;
2213 * Get the timestamp of the user's e-mail authentication
2214 * @return string TS_MW timestamp
2216 public function getEmailAuthenticationTimestamp() {
2217 $this->load();
2218 wfRunHooks( 'UserGetEmailAuthenticationTimestamp', array( $this, &$this->mEmailAuthenticated ) );
2219 return $this->mEmailAuthenticated;
2223 * Set the user's e-mail address
2224 * @param string $str New e-mail address
2226 public function setEmail( $str ) {
2227 $this->load();
2228 if ( $str == $this->mEmail ) {
2229 return;
2231 $this->mEmail = $str;
2232 $this->invalidateEmail();
2233 wfRunHooks( 'UserSetEmail', array( $this, &$this->mEmail ) );
2237 * Set the user's e-mail address and a confirmation mail if needed.
2239 * @since 1.20
2240 * @param string $str New e-mail address
2241 * @return Status
2243 public function setEmailWithConfirmation( $str ) {
2244 global $wgEnableEmail, $wgEmailAuthentication;
2246 if ( !$wgEnableEmail ) {
2247 return Status::newFatal( 'emaildisabled' );
2250 $oldaddr = $this->getEmail();
2251 if ( $str === $oldaddr ) {
2252 return Status::newGood( true );
2255 $this->setEmail( $str );
2257 if ( $str !== '' && $wgEmailAuthentication ) {
2258 // Send a confirmation request to the new address if needed
2259 $type = $oldaddr != '' ? 'changed' : 'set';
2260 $result = $this->sendConfirmationMail( $type );
2261 if ( $result->isGood() ) {
2262 // Say the the caller that a confirmation mail has been sent
2263 $result->value = 'eauth';
2265 } else {
2266 $result = Status::newGood( true );
2269 return $result;
2273 * Get the user's real name
2274 * @return string User's real name
2276 public function getRealName() {
2277 if ( !$this->isItemLoaded( 'realname' ) ) {
2278 $this->load();
2281 return $this->mRealName;
2285 * Set the user's real name
2286 * @param string $str New real name
2288 public function setRealName( $str ) {
2289 $this->load();
2290 $this->mRealName = $str;
2294 * Get the user's current setting for a given option.
2296 * @param string $oname The option to check
2297 * @param string $defaultOverride A default value returned if the option does not exist
2298 * @param bool $ignoreHidden Whether to ignore the effects of $wgHiddenPrefs
2299 * @return string User's current value for the option
2300 * @see getBoolOption()
2301 * @see getIntOption()
2303 public function getOption( $oname, $defaultOverride = null, $ignoreHidden = false ) {
2304 global $wgHiddenPrefs;
2305 $this->loadOptions();
2307 # We want 'disabled' preferences to always behave as the default value for
2308 # users, even if they have set the option explicitly in their settings (ie they
2309 # set it, and then it was disabled removing their ability to change it). But
2310 # we don't want to erase the preferences in the database in case the preference
2311 # is re-enabled again. So don't touch $mOptions, just override the returned value
2312 if ( !$ignoreHidden && in_array( $oname, $wgHiddenPrefs ) ) {
2313 return self::getDefaultOption( $oname );
2316 if ( array_key_exists( $oname, $this->mOptions ) ) {
2317 return $this->mOptions[$oname];
2318 } else {
2319 return $defaultOverride;
2324 * Get all user's options
2326 * @return array
2328 public function getOptions() {
2329 global $wgHiddenPrefs;
2330 $this->loadOptions();
2331 $options = $this->mOptions;
2333 # We want 'disabled' preferences to always behave as the default value for
2334 # users, even if they have set the option explicitly in their settings (ie they
2335 # set it, and then it was disabled removing their ability to change it). But
2336 # we don't want to erase the preferences in the database in case the preference
2337 # is re-enabled again. So don't touch $mOptions, just override the returned value
2338 foreach ( $wgHiddenPrefs as $pref ) {
2339 $default = self::getDefaultOption( $pref );
2340 if ( $default !== null ) {
2341 $options[$pref] = $default;
2345 return $options;
2349 * Get the user's current setting for a given option, as a boolean value.
2351 * @param string $oname The option to check
2352 * @return bool User's current value for the option
2353 * @see getOption()
2355 public function getBoolOption( $oname ) {
2356 return (bool)$this->getOption( $oname );
2360 * Get the user's current setting for a given option, as an integer value.
2362 * @param string $oname The option to check
2363 * @param int $defaultOverride A default value returned if the option does not exist
2364 * @return int User's current value for the option
2365 * @see getOption()
2367 public function getIntOption( $oname, $defaultOverride = 0 ) {
2368 $val = $this->getOption( $oname );
2369 if ( $val == '' ) {
2370 $val = $defaultOverride;
2372 return intval( $val );
2376 * Set the given option for a user.
2378 * @param string $oname The option to set
2379 * @param mixed $val New value to set
2381 public function setOption( $oname, $val ) {
2382 $this->loadOptions();
2384 // Explicitly NULL values should refer to defaults
2385 if ( is_null( $val ) ) {
2386 $val = self::getDefaultOption( $oname );
2389 $this->mOptions[$oname] = $val;
2393 * Get a token stored in the preferences (like the watchlist one),
2394 * resetting it if it's empty (and saving changes).
2396 * @param string $oname The option name to retrieve the token from
2397 * @return string|bool User's current value for the option, or false if this option is disabled.
2398 * @see resetTokenFromOption()
2399 * @see getOption()
2401 public function getTokenFromOption( $oname ) {
2402 global $wgHiddenPrefs;
2403 if ( in_array( $oname, $wgHiddenPrefs ) ) {
2404 return false;
2407 $token = $this->getOption( $oname );
2408 if ( !$token ) {
2409 $token = $this->resetTokenFromOption( $oname );
2410 $this->saveSettings();
2412 return $token;
2416 * Reset a token stored in the preferences (like the watchlist one).
2417 * *Does not* save user's preferences (similarly to setOption()).
2419 * @param string $oname The option name to reset the token in
2420 * @return string|bool New token value, or false if this option is disabled.
2421 * @see getTokenFromOption()
2422 * @see setOption()
2424 public function resetTokenFromOption( $oname ) {
2425 global $wgHiddenPrefs;
2426 if ( in_array( $oname, $wgHiddenPrefs ) ) {
2427 return false;
2430 $token = MWCryptRand::generateHex( 40 );
2431 $this->setOption( $oname, $token );
2432 return $token;
2436 * Return a list of the types of user options currently returned by
2437 * User::getOptionKinds().
2439 * Currently, the option kinds are:
2440 * - 'registered' - preferences which are registered in core MediaWiki or
2441 * by extensions using the UserGetDefaultOptions hook.
2442 * - 'registered-multiselect' - as above, using the 'multiselect' type.
2443 * - 'registered-checkmatrix' - as above, using the 'checkmatrix' type.
2444 * - 'userjs' - preferences with names starting with 'userjs-', intended to
2445 * be used by user scripts.
2446 * - 'unused' - preferences about which MediaWiki doesn't know anything.
2447 * These are usually legacy options, removed in newer versions.
2449 * The API (and possibly others) use this function to determine the possible
2450 * option types for validation purposes, so make sure to update this when a
2451 * new option kind is added.
2453 * @see User::getOptionKinds
2454 * @return array Option kinds
2456 public static function listOptionKinds() {
2457 return array(
2458 'registered',
2459 'registered-multiselect',
2460 'registered-checkmatrix',
2461 'userjs',
2462 'unused'
2467 * Return an associative array mapping preferences keys to the kind of a preference they're
2468 * used for. Different kinds are handled differently when setting or reading preferences.
2470 * See User::listOptionKinds for the list of valid option types that can be provided.
2472 * @see User::listOptionKinds
2473 * @param $context IContextSource
2474 * @param array $options assoc. array with options keys to check as keys. Defaults to $this->mOptions.
2475 * @return array the key => kind mapping data
2477 public function getOptionKinds( IContextSource $context, $options = null ) {
2478 $this->loadOptions();
2479 if ( $options === null ) {
2480 $options = $this->mOptions;
2483 $prefs = Preferences::getPreferences( $this, $context );
2484 $mapping = array();
2486 // Multiselect and checkmatrix options are stored in the database with
2487 // one key per option, each having a boolean value. Extract those keys.
2488 $multiselectOptions = array();
2489 foreach ( $prefs as $name => $info ) {
2490 if ( ( isset( $info['type'] ) && $info['type'] == 'multiselect' ) ||
2491 ( isset( $info['class'] ) && $info['class'] == 'HTMLMultiSelectField' ) ) {
2492 $opts = HTMLFormField::flattenOptions( $info['options'] );
2493 $prefix = isset( $info['prefix'] ) ? $info['prefix'] : $name;
2495 foreach ( $opts as $value ) {
2496 $multiselectOptions["$prefix$value"] = true;
2499 unset( $prefs[$name] );
2502 $checkmatrixOptions = array();
2503 foreach ( $prefs as $name => $info ) {
2504 if ( ( isset( $info['type'] ) && $info['type'] == 'checkmatrix' ) ||
2505 ( isset( $info['class'] ) && $info['class'] == 'HTMLCheckMatrix' ) ) {
2506 $columns = HTMLFormField::flattenOptions( $info['columns'] );
2507 $rows = HTMLFormField::flattenOptions( $info['rows'] );
2508 $prefix = isset( $info['prefix'] ) ? $info['prefix'] : $name;
2510 foreach ( $columns as $column ) {
2511 foreach ( $rows as $row ) {
2512 $checkmatrixOptions["$prefix-$column-$row"] = true;
2516 unset( $prefs[$name] );
2520 // $value is ignored
2521 foreach ( $options as $key => $value ) {
2522 if ( isset( $prefs[$key] ) ) {
2523 $mapping[$key] = 'registered';
2524 } elseif ( isset( $multiselectOptions[$key] ) ) {
2525 $mapping[$key] = 'registered-multiselect';
2526 } elseif ( isset( $checkmatrixOptions[$key] ) ) {
2527 $mapping[$key] = 'registered-checkmatrix';
2528 } elseif ( substr( $key, 0, 7 ) === 'userjs-' ) {
2529 $mapping[$key] = 'userjs';
2530 } else {
2531 $mapping[$key] = 'unused';
2535 return $mapping;
2539 * Reset certain (or all) options to the site defaults
2541 * The optional parameter determines which kinds of preferences will be reset.
2542 * Supported values are everything that can be reported by getOptionKinds()
2543 * and 'all', which forces a reset of *all* preferences and overrides everything else.
2545 * @param array|string $resetKinds which kinds of preferences to reset. Defaults to
2546 * array( 'registered', 'registered-multiselect', 'registered-checkmatrix', 'unused' )
2547 * for backwards-compatibility.
2548 * @param $context IContextSource|null context source used when $resetKinds
2549 * does not contain 'all', passed to getOptionKinds().
2550 * Defaults to RequestContext::getMain() when null.
2552 public function resetOptions(
2553 $resetKinds = array( 'registered', 'registered-multiselect', 'registered-checkmatrix', 'unused' ),
2554 IContextSource $context = null
2556 $this->load();
2557 $defaultOptions = self::getDefaultOptions();
2559 if ( !is_array( $resetKinds ) ) {
2560 $resetKinds = array( $resetKinds );
2563 if ( in_array( 'all', $resetKinds ) ) {
2564 $newOptions = $defaultOptions;
2565 } else {
2566 if ( $context === null ) {
2567 $context = RequestContext::getMain();
2570 $optionKinds = $this->getOptionKinds( $context );
2571 $resetKinds = array_intersect( $resetKinds, self::listOptionKinds() );
2572 $newOptions = array();
2574 // Use default values for the options that should be deleted, and
2575 // copy old values for the ones that shouldn't.
2576 foreach ( $this->mOptions as $key => $value ) {
2577 if ( in_array( $optionKinds[$key], $resetKinds ) ) {
2578 if ( array_key_exists( $key, $defaultOptions ) ) {
2579 $newOptions[$key] = $defaultOptions[$key];
2581 } else {
2582 $newOptions[$key] = $value;
2587 $this->mOptions = $newOptions;
2588 $this->mOptionsLoaded = true;
2592 * Get the user's preferred date format.
2593 * @return string User's preferred date format
2595 public function getDatePreference() {
2596 // Important migration for old data rows
2597 if ( is_null( $this->mDatePreference ) ) {
2598 global $wgLang;
2599 $value = $this->getOption( 'date' );
2600 $map = $wgLang->getDatePreferenceMigrationMap();
2601 if ( isset( $map[$value] ) ) {
2602 $value = $map[$value];
2604 $this->mDatePreference = $value;
2606 return $this->mDatePreference;
2610 * Determine based on the wiki configuration and the user's options,
2611 * whether this user must be over HTTPS no matter what.
2613 * @return bool
2615 public function requiresHTTPS() {
2616 global $wgSecureLogin;
2617 if ( !$wgSecureLogin ) {
2618 return false;
2619 } else {
2620 $https = $this->getBoolOption( 'prefershttps' );
2621 wfRunHooks( 'UserRequiresHTTPS', array( $this, &$https ) );
2622 if ( $https ) {
2623 $https = wfCanIPUseHTTPS( $this->getRequest()->getIP() );
2625 return $https;
2630 * Get the user preferred stub threshold
2632 * @return int
2634 public function getStubThreshold() {
2635 global $wgMaxArticleSize; # Maximum article size, in Kb
2636 $threshold = $this->getIntOption( 'stubthreshold' );
2637 if ( $threshold > $wgMaxArticleSize * 1024 ) {
2638 // If they have set an impossible value, disable the preference
2639 // so we can use the parser cache again.
2640 $threshold = 0;
2642 return $threshold;
2646 * Get the permissions this user has.
2647 * @return Array of String permission names
2649 public function getRights() {
2650 if ( is_null( $this->mRights ) ) {
2651 $this->mRights = self::getGroupPermissions( $this->getEffectiveGroups() );
2652 wfRunHooks( 'UserGetRights', array( $this, &$this->mRights ) );
2653 // Force reindexation of rights when a hook has unset one of them
2654 $this->mRights = array_values( array_unique( $this->mRights ) );
2656 return $this->mRights;
2660 * Get the list of explicit group memberships this user has.
2661 * The implicit * and user groups are not included.
2662 * @return Array of String internal group names
2664 public function getGroups() {
2665 $this->load();
2666 $this->loadGroups();
2667 return $this->mGroups;
2671 * Get the list of implicit group memberships this user has.
2672 * This includes all explicit groups, plus 'user' if logged in,
2673 * '*' for all accounts, and autopromoted groups
2674 * @param bool $recache Whether to avoid the cache
2675 * @return Array of String internal group names
2677 public function getEffectiveGroups( $recache = false ) {
2678 if ( $recache || is_null( $this->mEffectiveGroups ) ) {
2679 wfProfileIn( __METHOD__ );
2680 $this->mEffectiveGroups = array_unique( array_merge(
2681 $this->getGroups(), // explicit groups
2682 $this->getAutomaticGroups( $recache ) // implicit groups
2683 ) );
2684 // Hook for additional groups
2685 wfRunHooks( 'UserEffectiveGroups', array( &$this, &$this->mEffectiveGroups ) );
2686 // Force reindexation of groups when a hook has unset one of them
2687 $this->mEffectiveGroups = array_values( array_unique( $this->mEffectiveGroups ) );
2688 wfProfileOut( __METHOD__ );
2690 return $this->mEffectiveGroups;
2694 * Get the list of implicit group memberships this user has.
2695 * This includes 'user' if logged in, '*' for all accounts,
2696 * and autopromoted groups
2697 * @param bool $recache Whether to avoid the cache
2698 * @return Array of String internal group names
2700 public function getAutomaticGroups( $recache = false ) {
2701 if ( $recache || is_null( $this->mImplicitGroups ) ) {
2702 wfProfileIn( __METHOD__ );
2703 $this->mImplicitGroups = array( '*' );
2704 if ( $this->getId() ) {
2705 $this->mImplicitGroups[] = 'user';
2707 $this->mImplicitGroups = array_unique( array_merge(
2708 $this->mImplicitGroups,
2709 Autopromote::getAutopromoteGroups( $this )
2710 ) );
2712 if ( $recache ) {
2713 // Assure data consistency with rights/groups,
2714 // as getEffectiveGroups() depends on this function
2715 $this->mEffectiveGroups = null;
2717 wfProfileOut( __METHOD__ );
2719 return $this->mImplicitGroups;
2723 * Returns the groups the user has belonged to.
2725 * The user may still belong to the returned groups. Compare with getGroups().
2727 * The function will not return groups the user had belonged to before MW 1.17
2729 * @return array Names of the groups the user has belonged to.
2731 public function getFormerGroups() {
2732 if ( is_null( $this->mFormerGroups ) ) {
2733 $dbr = wfGetDB( DB_MASTER );
2734 $res = $dbr->select( 'user_former_groups',
2735 array( 'ufg_group' ),
2736 array( 'ufg_user' => $this->mId ),
2737 __METHOD__ );
2738 $this->mFormerGroups = array();
2739 foreach ( $res as $row ) {
2740 $this->mFormerGroups[] = $row->ufg_group;
2743 return $this->mFormerGroups;
2747 * Get the user's edit count.
2748 * @return int, null for anonymous users
2750 public function getEditCount() {
2751 if ( !$this->getId() ) {
2752 return null;
2755 if ( !isset( $this->mEditCount ) ) {
2756 /* Populate the count, if it has not been populated yet */
2757 wfProfileIn( __METHOD__ );
2758 $dbr = wfGetDB( DB_SLAVE );
2759 // check if the user_editcount field has been initialized
2760 $count = $dbr->selectField(
2761 'user', 'user_editcount',
2762 array( 'user_id' => $this->mId ),
2763 __METHOD__
2766 if ( $count === null ) {
2767 // it has not been initialized. do so.
2768 $count = $this->initEditCount();
2770 $this->mEditCount = $count;
2771 wfProfileOut( __METHOD__ );
2773 return (int)$this->mEditCount;
2777 * Add the user to the given group.
2778 * This takes immediate effect.
2779 * @param string $group Name of the group to add
2781 public function addGroup( $group ) {
2782 if ( wfRunHooks( 'UserAddGroup', array( $this, &$group ) ) ) {
2783 $dbw = wfGetDB( DB_MASTER );
2784 if ( $this->getId() ) {
2785 $dbw->insert( 'user_groups',
2786 array(
2787 'ug_user' => $this->getID(),
2788 'ug_group' => $group,
2790 __METHOD__,
2791 array( 'IGNORE' ) );
2794 $this->loadGroups();
2795 $this->mGroups[] = $group;
2796 // In case loadGroups was not called before, we now have the right twice.
2797 // Get rid of the duplicate.
2798 $this->mGroups = array_unique( $this->mGroups );
2800 // Refresh the groups caches, and clear the rights cache so it will be
2801 // refreshed on the next call to $this->getRights().
2802 $this->getEffectiveGroups( true );
2803 $this->mRights = null;
2805 $this->invalidateCache();
2809 * Remove the user from the given group.
2810 * This takes immediate effect.
2811 * @param string $group Name of the group to remove
2813 public function removeGroup( $group ) {
2814 $this->load();
2815 if ( wfRunHooks( 'UserRemoveGroup', array( $this, &$group ) ) ) {
2816 $dbw = wfGetDB( DB_MASTER );
2817 $dbw->delete( 'user_groups',
2818 array(
2819 'ug_user' => $this->getID(),
2820 'ug_group' => $group,
2821 ), __METHOD__ );
2822 // Remember that the user was in this group
2823 $dbw->insert( 'user_former_groups',
2824 array(
2825 'ufg_user' => $this->getID(),
2826 'ufg_group' => $group,
2828 __METHOD__,
2829 array( 'IGNORE' ) );
2831 $this->loadGroups();
2832 $this->mGroups = array_diff( $this->mGroups, array( $group ) );
2834 // Refresh the groups caches, and clear the rights cache so it will be
2835 // refreshed on the next call to $this->getRights().
2836 $this->getEffectiveGroups( true );
2837 $this->mRights = null;
2839 $this->invalidateCache();
2843 * Get whether the user is logged in
2844 * @return bool
2846 public function isLoggedIn() {
2847 return $this->getID() != 0;
2851 * Get whether the user is anonymous
2852 * @return bool
2854 public function isAnon() {
2855 return !$this->isLoggedIn();
2859 * Check if user is allowed to access a feature / make an action
2861 * @internal param \String $varargs permissions to test
2862 * @return boolean: True if user is allowed to perform *any* of the given actions
2864 * @return bool
2866 public function isAllowedAny( /*...*/ ) {
2867 $permissions = func_get_args();
2868 foreach ( $permissions as $permission ) {
2869 if ( $this->isAllowed( $permission ) ) {
2870 return true;
2873 return false;
2878 * @internal param $varargs string
2879 * @return bool True if the user is allowed to perform *all* of the given actions
2881 public function isAllowedAll( /*...*/ ) {
2882 $permissions = func_get_args();
2883 foreach ( $permissions as $permission ) {
2884 if ( !$this->isAllowed( $permission ) ) {
2885 return false;
2888 return true;
2892 * Internal mechanics of testing a permission
2893 * @param string $action
2894 * @return bool
2896 public function isAllowed( $action = '' ) {
2897 if ( $action === '' ) {
2898 return true; // In the spirit of DWIM
2900 // Patrolling may not be enabled
2901 if ( $action === 'patrol' || $action === 'autopatrol' ) {
2902 global $wgUseRCPatrol, $wgUseNPPatrol;
2903 if ( !$wgUseRCPatrol && !$wgUseNPPatrol ) {
2904 return false;
2907 // Use strict parameter to avoid matching numeric 0 accidentally inserted
2908 // by misconfiguration: 0 == 'foo'
2909 return in_array( $action, $this->getRights(), true );
2913 * Check whether to enable recent changes patrol features for this user
2914 * @return boolean: True or false
2916 public function useRCPatrol() {
2917 global $wgUseRCPatrol;
2918 return $wgUseRCPatrol && $this->isAllowedAny( 'patrol', 'patrolmarks' );
2922 * Check whether to enable new pages patrol features for this user
2923 * @return bool True or false
2925 public function useNPPatrol() {
2926 global $wgUseRCPatrol, $wgUseNPPatrol;
2927 return (
2928 ( $wgUseRCPatrol || $wgUseNPPatrol )
2929 && ( $this->isAllowedAny( 'patrol', 'patrolmarks' ) )
2934 * Get the WebRequest object to use with this object
2936 * @return WebRequest
2938 public function getRequest() {
2939 if ( $this->mRequest ) {
2940 return $this->mRequest;
2941 } else {
2942 global $wgRequest;
2943 return $wgRequest;
2948 * Get the current skin, loading it if required
2949 * @return Skin The current skin
2950 * @todo FIXME: Need to check the old failback system [AV]
2951 * @deprecated since 1.18 Use ->getSkin() in the most relevant outputting context you have
2953 public function getSkin() {
2954 wfDeprecated( __METHOD__, '1.18' );
2955 return RequestContext::getMain()->getSkin();
2959 * Get a WatchedItem for this user and $title.
2961 * @since 1.22 $checkRights parameter added
2962 * @param $title Title
2963 * @param $checkRights int Whether to check 'viewmywatchlist'/'editmywatchlist' rights.
2964 * Pass WatchedItem::CHECK_USER_RIGHTS or WatchedItem::IGNORE_USER_RIGHTS.
2965 * @return WatchedItem
2967 public function getWatchedItem( $title, $checkRights = WatchedItem::CHECK_USER_RIGHTS ) {
2968 $key = $checkRights . ':' . $title->getNamespace() . ':' . $title->getDBkey();
2970 if ( isset( $this->mWatchedItems[$key] ) ) {
2971 return $this->mWatchedItems[$key];
2974 if ( count( $this->mWatchedItems ) >= self::MAX_WATCHED_ITEMS_CACHE ) {
2975 $this->mWatchedItems = array();
2978 $this->mWatchedItems[$key] = WatchedItem::fromUserTitle( $this, $title, $checkRights );
2979 return $this->mWatchedItems[$key];
2983 * Check the watched status of an article.
2984 * @since 1.22 $checkRights parameter added
2985 * @param $title Title of the article to look at
2986 * @param $checkRights int Whether to check 'viewmywatchlist'/'editmywatchlist' rights.
2987 * Pass WatchedItem::CHECK_USER_RIGHTS or WatchedItem::IGNORE_USER_RIGHTS.
2988 * @return bool
2990 public function isWatched( $title, $checkRights = WatchedItem::CHECK_USER_RIGHTS ) {
2991 return $this->getWatchedItem( $title, $checkRights )->isWatched();
2995 * Watch an article.
2996 * @since 1.22 $checkRights parameter added
2997 * @param $title Title of the article to look at
2998 * @param $checkRights int Whether to check 'viewmywatchlist'/'editmywatchlist' rights.
2999 * Pass WatchedItem::CHECK_USER_RIGHTS or WatchedItem::IGNORE_USER_RIGHTS.
3001 public function addWatch( $title, $checkRights = WatchedItem::CHECK_USER_RIGHTS ) {
3002 $this->getWatchedItem( $title, $checkRights )->addWatch();
3003 $this->invalidateCache();
3007 * Stop watching an article.
3008 * @since 1.22 $checkRights parameter added
3009 * @param $title Title of the article to look at
3010 * @param $checkRights int Whether to check 'viewmywatchlist'/'editmywatchlist' rights.
3011 * Pass WatchedItem::CHECK_USER_RIGHTS or WatchedItem::IGNORE_USER_RIGHTS.
3013 public function removeWatch( $title, $checkRights = WatchedItem::CHECK_USER_RIGHTS ) {
3014 $this->getWatchedItem( $title, $checkRights )->removeWatch();
3015 $this->invalidateCache();
3019 * Clear the user's notification timestamp for the given title.
3020 * If e-notif e-mails are on, they will receive notification mails on
3021 * the next change of the page if it's watched etc.
3022 * @note If the user doesn't have 'editmywatchlist', this will do nothing.
3023 * @param $title Title of the article to look at
3024 * @param int $oldid The revision id being viewed. If not given or 0, latest revision is assumed.
3026 public function clearNotification( &$title, $oldid = 0 ) {
3027 global $wgUseEnotif, $wgShowUpdatedMarker;
3029 // Do nothing if the database is locked to writes
3030 if ( wfReadOnly() ) {
3031 return;
3034 // Do nothing if not allowed to edit the watchlist
3035 if ( !$this->isAllowed( 'editmywatchlist' ) ) {
3036 return;
3039 // If we're working on user's talk page, we should update the talk page message indicator
3040 if ( $title->getNamespace() == NS_USER_TALK && $title->getText() == $this->getName() ) {
3041 if ( !wfRunHooks( 'UserClearNewTalkNotification', array( &$this, $oldid ) ) ) {
3042 return;
3045 $nextid = $oldid ? $title->getNextRevisionID( $oldid ) : null;
3047 if ( !$oldid || !$nextid ) {
3048 // If we're looking at the latest revision, we should definitely clear it
3049 $this->setNewtalk( false );
3050 } else {
3051 // Otherwise we should update its revision, if it's present
3052 if ( $this->getNewtalk() ) {
3053 // Naturally the other one won't clear by itself
3054 $this->setNewtalk( false );
3055 $this->setNewtalk( true, Revision::newFromId( $nextid ) );
3060 if ( !$wgUseEnotif && !$wgShowUpdatedMarker ) {
3061 return;
3064 if ( $this->isAnon() ) {
3065 // Nothing else to do...
3066 return;
3069 // Only update the timestamp if the page is being watched.
3070 // The query to find out if it is watched is cached both in memcached and per-invocation,
3071 // and when it does have to be executed, it can be on a slave
3072 // If this is the user's newtalk page, we always update the timestamp
3073 $force = '';
3074 if ( $title->getNamespace() == NS_USER_TALK &&
3075 $title->getText() == $this->getName() )
3077 $force = 'force';
3080 $this->getWatchedItem( $title )->resetNotificationTimestamp( $force, $oldid );
3084 * Resets all of the given user's page-change notification timestamps.
3085 * If e-notif e-mails are on, they will receive notification mails on
3086 * the next change of any watched page.
3087 * @note If the user doesn't have 'editmywatchlist', this will do nothing.
3089 public function clearAllNotifications() {
3090 if ( wfReadOnly() ) {
3091 return;
3094 // Do nothing if not allowed to edit the watchlist
3095 if ( !$this->isAllowed( 'editmywatchlist' ) ) {
3096 return;
3099 global $wgUseEnotif, $wgShowUpdatedMarker;
3100 if ( !$wgUseEnotif && !$wgShowUpdatedMarker ) {
3101 $this->setNewtalk( false );
3102 return;
3104 $id = $this->getId();
3105 if ( $id != 0 ) {
3106 $dbw = wfGetDB( DB_MASTER );
3107 $dbw->update( 'watchlist',
3108 array( /* SET */ 'wl_notificationtimestamp' => null ),
3109 array( /* WHERE */ 'wl_user' => $id ),
3110 __METHOD__
3112 // We also need to clear here the "you have new message" notification for the own user_talk page;
3113 // it's cleared one page view later in WikiPage::doViewUpdates().
3118 * Set this user's options from an encoded string
3119 * @param string $str Encoded options to import
3121 * @deprecated in 1.19 due to removal of user_options from the user table
3123 private function decodeOptions( $str ) {
3124 wfDeprecated( __METHOD__, '1.19' );
3125 if ( !$str ) {
3126 return;
3129 $this->mOptionsLoaded = true;
3130 $this->mOptionOverrides = array();
3132 // If an option is not set in $str, use the default value
3133 $this->mOptions = self::getDefaultOptions();
3135 $a = explode( "\n", $str );
3136 foreach ( $a as $s ) {
3137 $m = array();
3138 if ( preg_match( "/^(.[^=]*)=(.*)$/", $s, $m ) ) {
3139 $this->mOptions[$m[1]] = $m[2];
3140 $this->mOptionOverrides[$m[1]] = $m[2];
3146 * Set a cookie on the user's client. Wrapper for
3147 * WebResponse::setCookie
3148 * @param string $name Name of the cookie to set
3149 * @param string $value Value to set
3150 * @param int $exp Expiration time, as a UNIX time value;
3151 * if 0 or not specified, use the default $wgCookieExpiration
3152 * @param bool $secure
3153 * true: Force setting the secure attribute when setting the cookie
3154 * false: Force NOT setting the secure attribute when setting the cookie
3155 * null (default): Use the default ($wgCookieSecure) to set the secure attribute
3156 * @param array $params Array of options sent passed to WebResponse::setcookie()
3158 protected function setCookie( $name, $value, $exp = 0, $secure = null, $params = array() ) {
3159 $params['secure'] = $secure;
3160 $this->getRequest()->response()->setcookie( $name, $value, $exp, $params );
3164 * Clear a cookie on the user's client
3165 * @param string $name Name of the cookie to clear
3166 * @param bool $secure
3167 * true: Force setting the secure attribute when setting the cookie
3168 * false: Force NOT setting the secure attribute when setting the cookie
3169 * null (default): Use the default ($wgCookieSecure) to set the secure attribute
3170 * @param array $params Array of options sent passed to WebResponse::setcookie()
3172 protected function clearCookie( $name, $secure = null, $params = array() ) {
3173 $this->setCookie( $name, '', time() - 86400, $secure, $params );
3177 * Set the default cookies for this session on the user's client.
3179 * @param $request WebRequest object to use; $wgRequest will be used if null
3180 * is passed.
3181 * @param bool $secure Whether to force secure/insecure cookies or use default
3183 public function setCookies( $request = null, $secure = null ) {
3184 if ( $request === null ) {
3185 $request = $this->getRequest();
3188 $this->load();
3189 if ( 0 == $this->mId ) {
3190 return;
3192 if ( !$this->mToken ) {
3193 // When token is empty or NULL generate a new one and then save it to the database
3194 // This allows a wiki to re-secure itself after a leak of it's user table or $wgSecretKey
3195 // Simply by setting every cell in the user_token column to NULL and letting them be
3196 // regenerated as users log back into the wiki.
3197 $this->setToken();
3198 $this->saveSettings();
3200 $session = array(
3201 'wsUserID' => $this->mId,
3202 'wsToken' => $this->mToken,
3203 'wsUserName' => $this->getName()
3205 $cookies = array(
3206 'UserID' => $this->mId,
3207 'UserName' => $this->getName(),
3209 if ( 1 == $this->getOption( 'rememberpassword' ) ) {
3210 $cookies['Token'] = $this->mToken;
3211 } else {
3212 $cookies['Token'] = false;
3215 wfRunHooks( 'UserSetCookies', array( $this, &$session, &$cookies ) );
3217 foreach ( $session as $name => $value ) {
3218 $request->setSessionData( $name, $value );
3220 foreach ( $cookies as $name => $value ) {
3221 if ( $value === false ) {
3222 $this->clearCookie( $name );
3223 } else {
3224 $this->setCookie( $name, $value, 0, $secure );
3229 * If wpStickHTTPS was selected, also set an insecure cookie that
3230 * will cause the site to redirect the user to HTTPS, if they access
3231 * it over HTTP. Bug 29898. Use an un-prefixed cookie, so it's the same
3232 * as the one set by centralauth (bug 53538). Also set it to session, or
3233 * standard time setting, based on if rememberme was set.
3235 if ( $request->getCheck( 'wpStickHTTPS' ) || $this->requiresHTTPS() ) {
3236 $time = null;
3237 if ( ( 1 == $this->getOption( 'rememberpassword' ) ) ) {
3238 $time = 0; // set to $wgCookieExpiration
3240 $this->setCookie(
3241 'forceHTTPS',
3242 'true',
3243 $time,
3244 false,
3245 array( 'prefix' => '' ) // no prefix
3251 * Log this user out.
3253 public function logout() {
3254 if ( wfRunHooks( 'UserLogout', array( &$this ) ) ) {
3255 $this->doLogout();
3260 * Clear the user's cookies and session, and reset the instance cache.
3261 * @see logout()
3263 public function doLogout() {
3264 $this->clearInstanceCache( 'defaults' );
3266 $this->getRequest()->setSessionData( 'wsUserID', 0 );
3268 $this->clearCookie( 'UserID' );
3269 $this->clearCookie( 'Token' );
3270 $this->clearCookie( 'forceHTTPS', false, array( 'prefix' => '' ) );
3272 // Remember when user logged out, to prevent seeing cached pages
3273 $this->setCookie( 'LoggedOut', time(), time() + 86400 );
3277 * Save this user's settings into the database.
3278 * @todo Only rarely do all these fields need to be set!
3280 public function saveSettings() {
3281 global $wgAuth;
3283 $this->load();
3284 if ( wfReadOnly() ) {
3285 return;
3287 if ( 0 == $this->mId ) {
3288 return;
3291 $this->mTouched = self::newTouchedTimestamp();
3292 if ( !$wgAuth->allowSetLocalPassword() ) {
3293 $this->mPassword = '';
3296 $dbw = wfGetDB( DB_MASTER );
3297 $dbw->update( 'user',
3298 array( /* SET */
3299 'user_name' => $this->mName,
3300 'user_password' => $this->mPassword,
3301 'user_newpassword' => $this->mNewpassword,
3302 'user_newpass_time' => $dbw->timestampOrNull( $this->mNewpassTime ),
3303 'user_real_name' => $this->mRealName,
3304 'user_email' => $this->mEmail,
3305 'user_email_authenticated' => $dbw->timestampOrNull( $this->mEmailAuthenticated ),
3306 'user_touched' => $dbw->timestamp( $this->mTouched ),
3307 'user_token' => strval( $this->mToken ),
3308 'user_email_token' => $this->mEmailToken,
3309 'user_email_token_expires' => $dbw->timestampOrNull( $this->mEmailTokenExpires ),
3310 ), array( /* WHERE */
3311 'user_id' => $this->mId
3312 ), __METHOD__
3315 $this->saveOptions();
3317 wfRunHooks( 'UserSaveSettings', array( $this ) );
3318 $this->clearSharedCache();
3319 $this->getUserPage()->invalidateCache();
3323 * If only this user's username is known, and it exists, return the user ID.
3324 * @return int
3326 public function idForName() {
3327 $s = trim( $this->getName() );
3328 if ( $s === '' ) {
3329 return 0;
3332 $dbr = wfGetDB( DB_SLAVE );
3333 $id = $dbr->selectField( 'user', 'user_id', array( 'user_name' => $s ), __METHOD__ );
3334 if ( $id === false ) {
3335 $id = 0;
3337 return $id;
3341 * Add a user to the database, return the user object
3343 * @param string $name Username to add
3344 * @param array $params of Strings Non-default parameters to save to the database as user_* fields:
3345 * - password The user's password hash. Password logins will be disabled if this is omitted.
3346 * - newpassword Hash for a temporary password that has been mailed to the user
3347 * - email The user's email address
3348 * - email_authenticated The email authentication timestamp
3349 * - real_name The user's real name
3350 * - options An associative array of non-default options
3351 * - token Random authentication token. Do not set.
3352 * - registration Registration timestamp. Do not set.
3354 * @return User object, or null if the username already exists
3356 public static function createNew( $name, $params = array() ) {
3357 $user = new User;
3358 $user->load();
3359 $user->setToken(); // init token
3360 if ( isset( $params['options'] ) ) {
3361 $user->mOptions = $params['options'] + (array)$user->mOptions;
3362 unset( $params['options'] );
3364 $dbw = wfGetDB( DB_MASTER );
3365 $seqVal = $dbw->nextSequenceValue( 'user_user_id_seq' );
3367 $fields = array(
3368 'user_id' => $seqVal,
3369 'user_name' => $name,
3370 'user_password' => $user->mPassword,
3371 'user_newpassword' => $user->mNewpassword,
3372 'user_newpass_time' => $dbw->timestampOrNull( $user->mNewpassTime ),
3373 'user_email' => $user->mEmail,
3374 'user_email_authenticated' => $dbw->timestampOrNull( $user->mEmailAuthenticated ),
3375 'user_real_name' => $user->mRealName,
3376 'user_token' => strval( $user->mToken ),
3377 'user_registration' => $dbw->timestamp( $user->mRegistration ),
3378 'user_editcount' => 0,
3379 'user_touched' => $dbw->timestamp( self::newTouchedTimestamp() ),
3381 foreach ( $params as $name => $value ) {
3382 $fields["user_$name"] = $value;
3384 $dbw->insert( 'user', $fields, __METHOD__, array( 'IGNORE' ) );
3385 if ( $dbw->affectedRows() ) {
3386 $newUser = User::newFromId( $dbw->insertId() );
3387 } else {
3388 $newUser = null;
3390 return $newUser;
3394 * Add this existing user object to the database. If the user already
3395 * exists, a fatal status object is returned, and the user object is
3396 * initialised with the data from the database.
3398 * Previously, this function generated a DB error due to a key conflict
3399 * if the user already existed. Many extension callers use this function
3400 * in code along the lines of:
3402 * $user = User::newFromName( $name );
3403 * if ( !$user->isLoggedIn() ) {
3404 * $user->addToDatabase();
3406 * // do something with $user...
3408 * However, this was vulnerable to a race condition (bug 16020). By
3409 * initialising the user object if the user exists, we aim to support this
3410 * calling sequence as far as possible.
3412 * Note that if the user exists, this function will acquire a write lock,
3413 * so it is still advisable to make the call conditional on isLoggedIn(),
3414 * and to commit the transaction after calling.
3416 * @throws MWException
3417 * @return Status
3419 public function addToDatabase() {
3420 $this->load();
3421 if ( !$this->mToken ) {
3422 $this->setToken(); // init token
3425 $this->mTouched = self::newTouchedTimestamp();
3427 $dbw = wfGetDB( DB_MASTER );
3428 $inWrite = $dbw->writesOrCallbacksPending();
3429 $seqVal = $dbw->nextSequenceValue( 'user_user_id_seq' );
3430 $dbw->insert( 'user',
3431 array(
3432 'user_id' => $seqVal,
3433 'user_name' => $this->mName,
3434 'user_password' => $this->mPassword,
3435 'user_newpassword' => $this->mNewpassword,
3436 'user_newpass_time' => $dbw->timestampOrNull( $this->mNewpassTime ),
3437 'user_email' => $this->mEmail,
3438 'user_email_authenticated' => $dbw->timestampOrNull( $this->mEmailAuthenticated ),
3439 'user_real_name' => $this->mRealName,
3440 'user_token' => strval( $this->mToken ),
3441 'user_registration' => $dbw->timestamp( $this->mRegistration ),
3442 'user_editcount' => 0,
3443 'user_touched' => $dbw->timestamp( $this->mTouched ),
3444 ), __METHOD__,
3445 array( 'IGNORE' )
3447 if ( !$dbw->affectedRows() ) {
3448 if ( !$inWrite ) {
3449 // XXX: Get out of REPEATABLE-READ so the SELECT below works.
3450 // Often this case happens early in views before any writes.
3451 // This shows up at least with CentralAuth.
3452 $dbw->commit( __METHOD__, 'flush' );
3454 $this->mId = $dbw->selectField( 'user', 'user_id',
3455 array( 'user_name' => $this->mName ), __METHOD__ );
3456 $loaded = false;
3457 if ( $this->mId ) {
3458 if ( $this->loadFromDatabase() ) {
3459 $loaded = true;
3462 if ( !$loaded ) {
3463 throw new MWException( __METHOD__ . ": hit a key conflict attempting " .
3464 "to insert user '{$this->mName}' row, but it was not present in select!" );
3466 return Status::newFatal( 'userexists' );
3468 $this->mId = $dbw->insertId();
3470 // Clear instance cache other than user table data, which is already accurate
3471 $this->clearInstanceCache();
3473 $this->saveOptions();
3474 return Status::newGood();
3478 * If this user is logged-in and blocked,
3479 * block any IP address they've successfully logged in from.
3480 * @return bool A block was spread
3482 public function spreadAnyEditBlock() {
3483 if ( $this->isLoggedIn() && $this->isBlocked() ) {
3484 return $this->spreadBlock();
3486 return false;
3490 * If this (non-anonymous) user is blocked,
3491 * block the IP address they've successfully logged in from.
3492 * @return bool A block was spread
3494 protected function spreadBlock() {
3495 wfDebug( __METHOD__ . "()\n" );
3496 $this->load();
3497 if ( $this->mId == 0 ) {
3498 return false;
3501 $userblock = Block::newFromTarget( $this->getName() );
3502 if ( !$userblock ) {
3503 return false;
3506 return (bool)$userblock->doAutoblock( $this->getRequest()->getIP() );
3510 * Generate a string which will be different for any combination of
3511 * user options which would produce different parser output.
3512 * This will be used as part of the hash key for the parser cache,
3513 * so users with the same options can share the same cached data
3514 * safely.
3516 * Extensions which require it should install 'PageRenderingHash' hook,
3517 * which will give them a chance to modify this key based on their own
3518 * settings.
3520 * @deprecated since 1.17 use the ParserOptions object to get the relevant options
3521 * @return string Page rendering hash
3523 public function getPageRenderingHash() {
3524 wfDeprecated( __METHOD__, '1.17' );
3526 global $wgRenderHashAppend, $wgLang, $wgContLang;
3527 if ( $this->mHash ) {
3528 return $this->mHash;
3531 // stubthreshold is only included below for completeness,
3532 // since it disables the parser cache, its value will always
3533 // be 0 when this function is called by parsercache.
3535 $confstr = $this->getOption( 'math' );
3536 $confstr .= '!' . $this->getStubThreshold();
3537 $confstr .= '!' . ( $this->getOption( 'numberheadings' ) ? '1' : '' );
3538 $confstr .= '!' . $wgLang->getCode();
3539 $confstr .= '!' . $this->getOption( 'thumbsize' );
3540 // add in language specific options, if any
3541 $extra = $wgContLang->getExtraHashOptions();
3542 $confstr .= $extra;
3544 // Since the skin could be overloading link(), it should be
3545 // included here but in practice, none of our skins do that.
3547 $confstr .= $wgRenderHashAppend;
3549 // Give a chance for extensions to modify the hash, if they have
3550 // extra options or other effects on the parser cache.
3551 wfRunHooks( 'PageRenderingHash', array( &$confstr ) );
3553 // Make it a valid memcached key fragment
3554 $confstr = str_replace( ' ', '_', $confstr );
3555 $this->mHash = $confstr;
3556 return $confstr;
3560 * Get whether the user is explicitly blocked from account creation.
3561 * @return bool|Block
3563 public function isBlockedFromCreateAccount() {
3564 $this->getBlockedStatus();
3565 if ( $this->mBlock && $this->mBlock->prevents( 'createaccount' ) ) {
3566 return $this->mBlock;
3569 # bug 13611: if the IP address the user is trying to create an account from is
3570 # blocked with createaccount disabled, prevent new account creation there even
3571 # when the user is logged in
3572 if ( $this->mBlockedFromCreateAccount === false && !$this->isAllowed( 'ipblock-exempt' ) ) {
3573 $this->mBlockedFromCreateAccount = Block::newFromTarget( null, $this->getRequest()->getIP() );
3575 return $this->mBlockedFromCreateAccount instanceof Block && $this->mBlockedFromCreateAccount->prevents( 'createaccount' )
3576 ? $this->mBlockedFromCreateAccount
3577 : false;
3581 * Get whether the user is blocked from using Special:Emailuser.
3582 * @return bool
3584 public function isBlockedFromEmailuser() {
3585 $this->getBlockedStatus();
3586 return $this->mBlock && $this->mBlock->prevents( 'sendemail' );
3590 * Get whether the user is allowed to create an account.
3591 * @return bool
3593 function isAllowedToCreateAccount() {
3594 return $this->isAllowed( 'createaccount' ) && !$this->isBlockedFromCreateAccount();
3598 * Get this user's personal page title.
3600 * @return Title: User's personal page title
3602 public function getUserPage() {
3603 return Title::makeTitle( NS_USER, $this->getName() );
3607 * Get this user's talk page title.
3609 * @return Title: User's talk page title
3611 public function getTalkPage() {
3612 $title = $this->getUserPage();
3613 return $title->getTalkPage();
3617 * Determine whether the user is a newbie. Newbies are either
3618 * anonymous IPs, or the most recently created accounts.
3619 * @return bool
3621 public function isNewbie() {
3622 return !$this->isAllowed( 'autoconfirmed' );
3626 * Check to see if the given clear-text password is one of the accepted passwords
3627 * @param string $password user password.
3628 * @return boolean: True if the given password is correct, otherwise False.
3630 public function checkPassword( $password ) {
3631 global $wgAuth, $wgLegacyEncoding;
3632 $this->load();
3634 // Even though we stop people from creating passwords that
3635 // are shorter than this, doesn't mean people wont be able
3636 // to. Certain authentication plugins do NOT want to save
3637 // domain passwords in a mysql database, so we should
3638 // check this (in case $wgAuth->strict() is false).
3639 if ( !$this->isValidPassword( $password ) ) {
3640 return false;
3643 if ( $wgAuth->authenticate( $this->getName(), $password ) ) {
3644 return true;
3645 } elseif ( $wgAuth->strict() ) {
3646 // Auth plugin doesn't allow local authentication
3647 return false;
3648 } elseif ( $wgAuth->strictUserAuth( $this->getName() ) ) {
3649 // Auth plugin doesn't allow local authentication for this user name
3650 return false;
3652 if ( self::comparePasswords( $this->mPassword, $password, $this->mId ) ) {
3653 return true;
3654 } elseif ( $wgLegacyEncoding ) {
3655 // Some wikis were converted from ISO 8859-1 to UTF-8, the passwords can't be converted
3656 // Check for this with iconv
3657 $cp1252Password = iconv( 'UTF-8', 'WINDOWS-1252//TRANSLIT', $password );
3658 if ( $cp1252Password != $password &&
3659 self::comparePasswords( $this->mPassword, $cp1252Password, $this->mId ) )
3661 return true;
3664 return false;
3668 * Check if the given clear-text password matches the temporary password
3669 * sent by e-mail for password reset operations.
3671 * @param $plaintext string
3673 * @return boolean: True if matches, false otherwise
3675 public function checkTemporaryPassword( $plaintext ) {
3676 global $wgNewPasswordExpiry;
3678 $this->load();
3679 if ( self::comparePasswords( $this->mNewpassword, $plaintext, $this->getId() ) ) {
3680 if ( is_null( $this->mNewpassTime ) ) {
3681 return true;
3683 $expiry = wfTimestamp( TS_UNIX, $this->mNewpassTime ) + $wgNewPasswordExpiry;
3684 return ( time() < $expiry );
3685 } else {
3686 return false;
3691 * Alias for getEditToken.
3692 * @deprecated since 1.19, use getEditToken instead.
3694 * @param string|array $salt of Strings Optional function-specific data for hashing
3695 * @param $request WebRequest object to use or null to use $wgRequest
3696 * @return string The new edit token
3698 public function editToken( $salt = '', $request = null ) {
3699 wfDeprecated( __METHOD__, '1.19' );
3700 return $this->getEditToken( $salt, $request );
3704 * Initialize (if necessary) and return a session token value
3705 * which can be used in edit forms to show that the user's
3706 * login credentials aren't being hijacked with a foreign form
3707 * submission.
3709 * @since 1.19
3711 * @param string|array $salt of Strings Optional function-specific data for hashing
3712 * @param $request WebRequest object to use or null to use $wgRequest
3713 * @return string The new edit token
3715 public function getEditToken( $salt = '', $request = null ) {
3716 if ( $request == null ) {
3717 $request = $this->getRequest();
3720 if ( $this->isAnon() ) {
3721 return EDIT_TOKEN_SUFFIX;
3722 } else {
3723 $token = $request->getSessionData( 'wsEditToken' );
3724 if ( $token === null ) {
3725 $token = MWCryptRand::generateHex( 32 );
3726 $request->setSessionData( 'wsEditToken', $token );
3728 if ( is_array( $salt ) ) {
3729 $salt = implode( '|', $salt );
3731 return md5( $token . $salt ) . EDIT_TOKEN_SUFFIX;
3736 * Generate a looking random token for various uses.
3738 * @return string The new random token
3739 * @deprecated since 1.20: Use MWCryptRand for secure purposes or wfRandomString for pseudo-randomness
3741 public static function generateToken() {
3742 return MWCryptRand::generateHex( 32 );
3746 * Check given value against the token value stored in the session.
3747 * A match should confirm that the form was submitted from the
3748 * user's own login session, not a form submission from a third-party
3749 * site.
3751 * @param string $val Input value to compare
3752 * @param string $salt Optional function-specific data for hashing
3753 * @param WebRequest $request Object to use or null to use $wgRequest
3754 * @return boolean: Whether the token matches
3756 public function matchEditToken( $val, $salt = '', $request = null ) {
3757 $sessionToken = $this->getEditToken( $salt, $request );
3758 if ( $val != $sessionToken ) {
3759 wfDebug( "User::matchEditToken: broken session data\n" );
3761 return $val == $sessionToken;
3765 * Check given value against the token value stored in the session,
3766 * ignoring the suffix.
3768 * @param string $val Input value to compare
3769 * @param string $salt Optional function-specific data for hashing
3770 * @param WebRequest $request object to use or null to use $wgRequest
3771 * @return boolean: Whether the token matches
3773 public function matchEditTokenNoSuffix( $val, $salt = '', $request = null ) {
3774 $sessionToken = $this->getEditToken( $salt, $request );
3775 return substr( $sessionToken, 0, 32 ) == substr( $val, 0, 32 );
3779 * Generate a new e-mail confirmation token and send a confirmation/invalidation
3780 * mail to the user's given address.
3782 * @param string $type message to send, either "created", "changed" or "set"
3783 * @return Status object
3785 public function sendConfirmationMail( $type = 'created' ) {
3786 global $wgLang;
3787 $expiration = null; // gets passed-by-ref and defined in next line.
3788 $token = $this->confirmationToken( $expiration );
3789 $url = $this->confirmationTokenUrl( $token );
3790 $invalidateURL = $this->invalidationTokenUrl( $token );
3791 $this->saveSettings();
3793 if ( $type == 'created' || $type === false ) {
3794 $message = 'confirmemail_body';
3795 } elseif ( $type === true ) {
3796 $message = 'confirmemail_body_changed';
3797 } else {
3798 // Messages: confirmemail_body_changed, confirmemail_body_set
3799 $message = 'confirmemail_body_' . $type;
3802 return $this->sendMail( wfMessage( 'confirmemail_subject' )->text(),
3803 wfMessage( $message,
3804 $this->getRequest()->getIP(),
3805 $this->getName(),
3806 $url,
3807 $wgLang->timeanddate( $expiration, false ),
3808 $invalidateURL,
3809 $wgLang->date( $expiration, false ),
3810 $wgLang->time( $expiration, false ) )->text() );
3814 * Send an e-mail to this user's account. Does not check for
3815 * confirmed status or validity.
3817 * @param string $subject Message subject
3818 * @param string $body Message body
3819 * @param string $from Optional From address; if unspecified, default $wgPasswordSender will be used
3820 * @param string $replyto Reply-To address
3821 * @return Status
3823 public function sendMail( $subject, $body, $from = null, $replyto = null ) {
3824 if ( is_null( $from ) ) {
3825 global $wgPasswordSender, $wgPasswordSenderName;
3826 $sender = new MailAddress( $wgPasswordSender, $wgPasswordSenderName );
3827 } else {
3828 $sender = new MailAddress( $from );
3831 $to = new MailAddress( $this );
3832 return UserMailer::send( $to, $sender, $subject, $body, $replyto );
3836 * Generate, store, and return a new e-mail confirmation code.
3837 * A hash (unsalted, since it's used as a key) is stored.
3839 * @note Call saveSettings() after calling this function to commit
3840 * this change to the database.
3842 * @param &$expiration \mixed Accepts the expiration time
3843 * @return string New token
3845 protected function confirmationToken( &$expiration ) {
3846 global $wgUserEmailConfirmationTokenExpiry;
3847 $now = time();
3848 $expires = $now + $wgUserEmailConfirmationTokenExpiry;
3849 $expiration = wfTimestamp( TS_MW, $expires );
3850 $this->load();
3851 $token = MWCryptRand::generateHex( 32 );
3852 $hash = md5( $token );
3853 $this->mEmailToken = $hash;
3854 $this->mEmailTokenExpires = $expiration;
3855 return $token;
3859 * Return a URL the user can use to confirm their email address.
3860 * @param string $token Accepts the email confirmation token
3861 * @return string New token URL
3863 protected function confirmationTokenUrl( $token ) {
3864 return $this->getTokenUrl( 'ConfirmEmail', $token );
3868 * Return a URL the user can use to invalidate their email address.
3869 * @param string $token Accepts the email confirmation token
3870 * @return string New token URL
3872 protected function invalidationTokenUrl( $token ) {
3873 return $this->getTokenUrl( 'InvalidateEmail', $token );
3877 * Internal function to format the e-mail validation/invalidation URLs.
3878 * This uses a quickie hack to use the
3879 * hardcoded English names of the Special: pages, for ASCII safety.
3881 * @note Since these URLs get dropped directly into emails, using the
3882 * short English names avoids insanely long URL-encoded links, which
3883 * also sometimes can get corrupted in some browsers/mailers
3884 * (bug 6957 with Gmail and Internet Explorer).
3886 * @param string $page Special page
3887 * @param string $token Token
3888 * @return string Formatted URL
3890 protected function getTokenUrl( $page, $token ) {
3891 // Hack to bypass localization of 'Special:'
3892 $title = Title::makeTitle( NS_MAIN, "Special:$page/$token" );
3893 return $title->getCanonicalURL();
3897 * Mark the e-mail address confirmed.
3899 * @note Call saveSettings() after calling this function to commit the change.
3901 * @return bool
3903 public function confirmEmail() {
3904 // Check if it's already confirmed, so we don't touch the database
3905 // and fire the ConfirmEmailComplete hook on redundant confirmations.
3906 if ( !$this->isEmailConfirmed() ) {
3907 $this->setEmailAuthenticationTimestamp( wfTimestampNow() );
3908 wfRunHooks( 'ConfirmEmailComplete', array( $this ) );
3910 return true;
3914 * Invalidate the user's e-mail confirmation, and unauthenticate the e-mail
3915 * address if it was already confirmed.
3917 * @note Call saveSettings() after calling this function to commit the change.
3918 * @return bool Returns true
3920 function invalidateEmail() {
3921 $this->load();
3922 $this->mEmailToken = null;
3923 $this->mEmailTokenExpires = null;
3924 $this->setEmailAuthenticationTimestamp( null );
3925 wfRunHooks( 'InvalidateEmailComplete', array( $this ) );
3926 return true;
3930 * Set the e-mail authentication timestamp.
3931 * @param string $timestamp TS_MW timestamp
3933 function setEmailAuthenticationTimestamp( $timestamp ) {
3934 $this->load();
3935 $this->mEmailAuthenticated = $timestamp;
3936 wfRunHooks( 'UserSetEmailAuthenticationTimestamp', array( $this, &$this->mEmailAuthenticated ) );
3940 * Is this user allowed to send e-mails within limits of current
3941 * site configuration?
3942 * @return bool
3944 public function canSendEmail() {
3945 global $wgEnableEmail, $wgEnableUserEmail;
3946 if ( !$wgEnableEmail || !$wgEnableUserEmail || !$this->isAllowed( 'sendemail' ) ) {
3947 return false;
3949 $canSend = $this->isEmailConfirmed();
3950 wfRunHooks( 'UserCanSendEmail', array( &$this, &$canSend ) );
3951 return $canSend;
3955 * Is this user allowed to receive e-mails within limits of current
3956 * site configuration?
3957 * @return bool
3959 public function canReceiveEmail() {
3960 return $this->isEmailConfirmed() && !$this->getOption( 'disablemail' );
3964 * Is this user's e-mail address valid-looking and confirmed within
3965 * limits of the current site configuration?
3967 * @note If $wgEmailAuthentication is on, this may require the user to have
3968 * confirmed their address by returning a code or using a password
3969 * sent to the address from the wiki.
3971 * @return bool
3973 public function isEmailConfirmed() {
3974 global $wgEmailAuthentication;
3975 $this->load();
3976 $confirmed = true;
3977 if ( wfRunHooks( 'EmailConfirmed', array( &$this, &$confirmed ) ) ) {
3978 if ( $this->isAnon() ) {
3979 return false;
3981 if ( !Sanitizer::validateEmail( $this->mEmail ) ) {
3982 return false;
3984 if ( $wgEmailAuthentication && !$this->getEmailAuthenticationTimestamp() ) {
3985 return false;
3987 return true;
3988 } else {
3989 return $confirmed;
3994 * Check whether there is an outstanding request for e-mail confirmation.
3995 * @return bool
3997 public function isEmailConfirmationPending() {
3998 global $wgEmailAuthentication;
3999 return $wgEmailAuthentication &&
4000 !$this->isEmailConfirmed() &&
4001 $this->mEmailToken &&
4002 $this->mEmailTokenExpires > wfTimestamp();
4006 * Get the timestamp of account creation.
4008 * @return string|bool|null Timestamp of account creation, false for
4009 * non-existent/anonymous user accounts, or null if existing account
4010 * but information is not in database.
4012 public function getRegistration() {
4013 if ( $this->isAnon() ) {
4014 return false;
4016 $this->load();
4017 return $this->mRegistration;
4021 * Get the timestamp of the first edit
4023 * @return string|bool Timestamp of first edit, or false for
4024 * non-existent/anonymous user accounts.
4026 public function getFirstEditTimestamp() {
4027 if ( $this->getId() == 0 ) {
4028 return false; // anons
4030 $dbr = wfGetDB( DB_SLAVE );
4031 $time = $dbr->selectField( 'revision', 'rev_timestamp',
4032 array( 'rev_user' => $this->getId() ),
4033 __METHOD__,
4034 array( 'ORDER BY' => 'rev_timestamp ASC' )
4036 if ( !$time ) {
4037 return false; // no edits
4039 return wfTimestamp( TS_MW, $time );
4043 * Get the permissions associated with a given list of groups
4045 * @param array $groups of Strings List of internal group names
4046 * @return Array of Strings List of permission key names for given groups combined
4048 public static function getGroupPermissions( $groups ) {
4049 global $wgGroupPermissions, $wgRevokePermissions;
4050 $rights = array();
4051 // grant every granted permission first
4052 foreach ( $groups as $group ) {
4053 if ( isset( $wgGroupPermissions[$group] ) ) {
4054 $rights = array_merge( $rights,
4055 // array_filter removes empty items
4056 array_keys( array_filter( $wgGroupPermissions[$group] ) ) );
4059 // now revoke the revoked permissions
4060 foreach ( $groups as $group ) {
4061 if ( isset( $wgRevokePermissions[$group] ) ) {
4062 $rights = array_diff( $rights,
4063 array_keys( array_filter( $wgRevokePermissions[$group] ) ) );
4066 return array_unique( $rights );
4070 * Get all the groups who have a given permission
4072 * @param string $role Role to check
4073 * @return Array of Strings List of internal group names with the given permission
4075 public static function getGroupsWithPermission( $role ) {
4076 global $wgGroupPermissions;
4077 $allowedGroups = array();
4078 foreach ( array_keys( $wgGroupPermissions ) as $group ) {
4079 if ( self::groupHasPermission( $group, $role ) ) {
4080 $allowedGroups[] = $group;
4083 return $allowedGroups;
4087 * Check, if the given group has the given permission
4089 * If you're wanting to check whether all users have a permission, use
4090 * User::isEveryoneAllowed() instead. That properly checks if it's revoked
4091 * from anyone.
4093 * @since 1.21
4094 * @param string $group Group to check
4095 * @param string $role Role to check
4096 * @return bool
4098 public static function groupHasPermission( $group, $role ) {
4099 global $wgGroupPermissions, $wgRevokePermissions;
4100 return isset( $wgGroupPermissions[$group][$role] ) && $wgGroupPermissions[$group][$role]
4101 && !( isset( $wgRevokePermissions[$group][$role] ) && $wgRevokePermissions[$group][$role] );
4105 * Check if all users have the given permission
4107 * @since 1.22
4108 * @param string $right Right to check
4109 * @return bool
4111 public static function isEveryoneAllowed( $right ) {
4112 global $wgGroupPermissions, $wgRevokePermissions;
4113 static $cache = array();
4115 // Use the cached results, except in unit tests which rely on
4116 // being able change the permission mid-request
4117 if ( isset( $cache[$right] ) && !defined( 'MW_PHPUNIT_TEST' ) ) {
4118 return $cache[$right];
4121 if ( !isset( $wgGroupPermissions['*'][$right] ) || !$wgGroupPermissions['*'][$right] ) {
4122 $cache[$right] = false;
4123 return false;
4126 // If it's revoked anywhere, then everyone doesn't have it
4127 foreach ( $wgRevokePermissions as $rights ) {
4128 if ( isset( $rights[$right] ) && $rights[$right] ) {
4129 $cache[$right] = false;
4130 return false;
4134 // Allow extensions (e.g. OAuth) to say false
4135 if ( !wfRunHooks( 'UserIsEveryoneAllowed', array( $right ) ) ) {
4136 $cache[$right] = false;
4137 return false;
4140 $cache[$right] = true;
4141 return true;
4145 * Get the localized descriptive name for a group, if it exists
4147 * @param string $group Internal group name
4148 * @return string Localized descriptive group name
4150 public static function getGroupName( $group ) {
4151 $msg = wfMessage( "group-$group" );
4152 return $msg->isBlank() ? $group : $msg->text();
4156 * Get the localized descriptive name for a member of a group, if it exists
4158 * @param string $group Internal group name
4159 * @param string $username Username for gender (since 1.19)
4160 * @return string Localized name for group member
4162 public static function getGroupMember( $group, $username = '#' ) {
4163 $msg = wfMessage( "group-$group-member", $username );
4164 return $msg->isBlank() ? $group : $msg->text();
4168 * Return the set of defined explicit groups.
4169 * The implicit groups (by default *, 'user' and 'autoconfirmed')
4170 * are not included, as they are defined automatically, not in the database.
4171 * @return Array of internal group names
4173 public static function getAllGroups() {
4174 global $wgGroupPermissions, $wgRevokePermissions;
4175 return array_diff(
4176 array_merge( array_keys( $wgGroupPermissions ), array_keys( $wgRevokePermissions ) ),
4177 self::getImplicitGroups()
4182 * Get a list of all available permissions.
4183 * @return Array of permission names
4185 public static function getAllRights() {
4186 if ( self::$mAllRights === false ) {
4187 global $wgAvailableRights;
4188 if ( count( $wgAvailableRights ) ) {
4189 self::$mAllRights = array_unique( array_merge( self::$mCoreRights, $wgAvailableRights ) );
4190 } else {
4191 self::$mAllRights = self::$mCoreRights;
4193 wfRunHooks( 'UserGetAllRights', array( &self::$mAllRights ) );
4195 return self::$mAllRights;
4199 * Get a list of implicit groups
4200 * @return Array of Strings Array of internal group names
4202 public static function getImplicitGroups() {
4203 global $wgImplicitGroups;
4204 $groups = $wgImplicitGroups;
4205 wfRunHooks( 'UserGetImplicitGroups', array( &$groups ) ); #deprecated, use $wgImplictGroups instead
4206 return $groups;
4210 * Get the title of a page describing a particular group
4212 * @param string $group Internal group name
4213 * @return Title|bool Title of the page if it exists, false otherwise
4215 public static function getGroupPage( $group ) {
4216 $msg = wfMessage( 'grouppage-' . $group )->inContentLanguage();
4217 if ( $msg->exists() ) {
4218 $title = Title::newFromText( $msg->text() );
4219 if ( is_object( $title ) ) {
4220 return $title;
4223 return false;
4227 * Create a link to the group in HTML, if available;
4228 * else return the group name.
4230 * @param string $group Internal name of the group
4231 * @param string $text The text of the link
4232 * @return string HTML link to the group
4234 public static function makeGroupLinkHTML( $group, $text = '' ) {
4235 if ( $text == '' ) {
4236 $text = self::getGroupName( $group );
4238 $title = self::getGroupPage( $group );
4239 if ( $title ) {
4240 return Linker::link( $title, htmlspecialchars( $text ) );
4241 } else {
4242 return $text;
4247 * Create a link to the group in Wikitext, if available;
4248 * else return the group name.
4250 * @param string $group Internal name of the group
4251 * @param string $text The text of the link
4252 * @return string Wikilink to the group
4254 public static function makeGroupLinkWiki( $group, $text = '' ) {
4255 if ( $text == '' ) {
4256 $text = self::getGroupName( $group );
4258 $title = self::getGroupPage( $group );
4259 if ( $title ) {
4260 $page = $title->getPrefixedText();
4261 return "[[$page|$text]]";
4262 } else {
4263 return $text;
4268 * Returns an array of the groups that a particular group can add/remove.
4270 * @param string $group the group to check for whether it can add/remove
4271 * @return Array array( 'add' => array( addablegroups ),
4272 * 'remove' => array( removablegroups ),
4273 * 'add-self' => array( addablegroups to self),
4274 * 'remove-self' => array( removable groups from self) )
4276 public static function changeableByGroup( $group ) {
4277 global $wgAddGroups, $wgRemoveGroups, $wgGroupsAddToSelf, $wgGroupsRemoveFromSelf;
4279 $groups = array( 'add' => array(), 'remove' => array(), 'add-self' => array(), 'remove-self' => array() );
4280 if ( empty( $wgAddGroups[$group] ) ) {
4281 // Don't add anything to $groups
4282 } elseif ( $wgAddGroups[$group] === true ) {
4283 // You get everything
4284 $groups['add'] = self::getAllGroups();
4285 } elseif ( is_array( $wgAddGroups[$group] ) ) {
4286 $groups['add'] = $wgAddGroups[$group];
4289 // Same thing for remove
4290 if ( empty( $wgRemoveGroups[$group] ) ) {
4291 } elseif ( $wgRemoveGroups[$group] === true ) {
4292 $groups['remove'] = self::getAllGroups();
4293 } elseif ( is_array( $wgRemoveGroups[$group] ) ) {
4294 $groups['remove'] = $wgRemoveGroups[$group];
4297 // Re-map numeric keys of AddToSelf/RemoveFromSelf to the 'user' key for backwards compatibility
4298 if ( empty( $wgGroupsAddToSelf['user'] ) || $wgGroupsAddToSelf['user'] !== true ) {
4299 foreach ( $wgGroupsAddToSelf as $key => $value ) {
4300 if ( is_int( $key ) ) {
4301 $wgGroupsAddToSelf['user'][] = $value;
4306 if ( empty( $wgGroupsRemoveFromSelf['user'] ) || $wgGroupsRemoveFromSelf['user'] !== true ) {
4307 foreach ( $wgGroupsRemoveFromSelf as $key => $value ) {
4308 if ( is_int( $key ) ) {
4309 $wgGroupsRemoveFromSelf['user'][] = $value;
4314 // Now figure out what groups the user can add to him/herself
4315 if ( empty( $wgGroupsAddToSelf[$group] ) ) {
4316 } elseif ( $wgGroupsAddToSelf[$group] === true ) {
4317 // No idea WHY this would be used, but it's there
4318 $groups['add-self'] = User::getAllGroups();
4319 } elseif ( is_array( $wgGroupsAddToSelf[$group] ) ) {
4320 $groups['add-self'] = $wgGroupsAddToSelf[$group];
4323 if ( empty( $wgGroupsRemoveFromSelf[$group] ) ) {
4324 } elseif ( $wgGroupsRemoveFromSelf[$group] === true ) {
4325 $groups['remove-self'] = User::getAllGroups();
4326 } elseif ( is_array( $wgGroupsRemoveFromSelf[$group] ) ) {
4327 $groups['remove-self'] = $wgGroupsRemoveFromSelf[$group];
4330 return $groups;
4334 * Returns an array of groups that this user can add and remove
4335 * @return Array array( 'add' => array( addablegroups ),
4336 * 'remove' => array( removablegroups ),
4337 * 'add-self' => array( addablegroups to self),
4338 * 'remove-self' => array( removable groups from self) )
4340 public function changeableGroups() {
4341 if ( $this->isAllowed( 'userrights' ) ) {
4342 // This group gives the right to modify everything (reverse-
4343 // compatibility with old "userrights lets you change
4344 // everything")
4345 // Using array_merge to make the groups reindexed
4346 $all = array_merge( User::getAllGroups() );
4347 return array(
4348 'add' => $all,
4349 'remove' => $all,
4350 'add-self' => array(),
4351 'remove-self' => array()
4355 // Okay, it's not so simple, we will have to go through the arrays
4356 $groups = array(
4357 'add' => array(),
4358 'remove' => array(),
4359 'add-self' => array(),
4360 'remove-self' => array()
4362 $addergroups = $this->getEffectiveGroups();
4364 foreach ( $addergroups as $addergroup ) {
4365 $groups = array_merge_recursive(
4366 $groups, $this->changeableByGroup( $addergroup )
4368 $groups['add'] = array_unique( $groups['add'] );
4369 $groups['remove'] = array_unique( $groups['remove'] );
4370 $groups['add-self'] = array_unique( $groups['add-self'] );
4371 $groups['remove-self'] = array_unique( $groups['remove-self'] );
4373 return $groups;
4377 * Increment the user's edit-count field.
4378 * Will have no effect for anonymous users.
4380 public function incEditCount() {
4381 if ( !$this->isAnon() ) {
4382 $dbw = wfGetDB( DB_MASTER );
4383 $dbw->update(
4384 'user',
4385 array( 'user_editcount=user_editcount+1' ),
4386 array( 'user_id' => $this->getId() ),
4387 __METHOD__
4390 // Lazy initialization check...
4391 if ( $dbw->affectedRows() == 0 ) {
4392 // Now here's a goddamn hack...
4393 $dbr = wfGetDB( DB_SLAVE );
4394 if ( $dbr !== $dbw ) {
4395 // If we actually have a slave server, the count is
4396 // at least one behind because the current transaction
4397 // has not been committed and replicated.
4398 $this->initEditCount( 1 );
4399 } else {
4400 // But if DB_SLAVE is selecting the master, then the
4401 // count we just read includes the revision that was
4402 // just added in the working transaction.
4403 $this->initEditCount();
4407 // edit count in user cache too
4408 $this->invalidateCache();
4412 * Initialize user_editcount from data out of the revision table
4414 * @param $add Integer Edits to add to the count from the revision table
4415 * @return integer Number of edits
4417 protected function initEditCount( $add = 0 ) {
4418 // Pull from a slave to be less cruel to servers
4419 // Accuracy isn't the point anyway here
4420 $dbr = wfGetDB( DB_SLAVE );
4421 $count = (int)$dbr->selectField(
4422 'revision',
4423 'COUNT(rev_user)',
4424 array( 'rev_user' => $this->getId() ),
4425 __METHOD__
4427 $count = $count + $add;
4429 $dbw = wfGetDB( DB_MASTER );
4430 $dbw->update(
4431 'user',
4432 array( 'user_editcount' => $count ),
4433 array( 'user_id' => $this->getId() ),
4434 __METHOD__
4437 return $count;
4441 * Get the description of a given right
4443 * @param string $right Right to query
4444 * @return string Localized description of the right
4446 public static function getRightDescription( $right ) {
4447 $key = "right-$right";
4448 $msg = wfMessage( $key );
4449 return $msg->isBlank() ? $right : $msg->text();
4453 * Make an old-style password hash
4455 * @param string $password Plain-text password
4456 * @param string $userId User ID
4457 * @return string Password hash
4459 public static function oldCrypt( $password, $userId ) {
4460 global $wgPasswordSalt;
4461 if ( $wgPasswordSalt ) {
4462 return md5( $userId . '-' . md5( $password ) );
4463 } else {
4464 return md5( $password );
4469 * Make a new-style password hash
4471 * @param string $password Plain-text password
4472 * @param bool|string $salt Optional salt, may be random or the user ID.
4473 * If unspecified or false, will generate one automatically
4474 * @return string Password hash
4476 public static function crypt( $password, $salt = false ) {
4477 global $wgPasswordSalt;
4479 $hash = '';
4480 if ( !wfRunHooks( 'UserCryptPassword', array( &$password, &$salt, &$wgPasswordSalt, &$hash ) ) ) {
4481 return $hash;
4484 if ( $wgPasswordSalt ) {
4485 if ( $salt === false ) {
4486 $salt = MWCryptRand::generateHex( 8 );
4488 return ':B:' . $salt . ':' . md5( $salt . '-' . md5( $password ) );
4489 } else {
4490 return ':A:' . md5( $password );
4495 * Compare a password hash with a plain-text password. Requires the user
4496 * ID if there's a chance that the hash is an old-style hash.
4498 * @param string $hash Password hash
4499 * @param string $password Plain-text password to compare
4500 * @param string|bool $userId User ID for old-style password salt
4502 * @return boolean
4504 public static function comparePasswords( $hash, $password, $userId = false ) {
4505 $type = substr( $hash, 0, 3 );
4507 $result = false;
4508 if ( !wfRunHooks( 'UserComparePasswords', array( &$hash, &$password, &$userId, &$result ) ) ) {
4509 return $result;
4512 if ( $type == ':A:' ) {
4513 // Unsalted
4514 return md5( $password ) === substr( $hash, 3 );
4515 } elseif ( $type == ':B:' ) {
4516 // Salted
4517 list( $salt, $realHash ) = explode( ':', substr( $hash, 3 ), 2 );
4518 return md5( $salt . '-' . md5( $password ) ) === $realHash;
4519 } else {
4520 // Old-style
4521 return self::oldCrypt( $password, $userId ) === $hash;
4526 * Add a newuser log entry for this user.
4527 * Before 1.19 the return value was always true.
4529 * @param string|bool $action account creation type.
4530 * - String, one of the following values:
4531 * - 'create' for an anonymous user creating an account for himself.
4532 * This will force the action's performer to be the created user itself,
4533 * no matter the value of $wgUser
4534 * - 'create2' for a logged in user creating an account for someone else
4535 * - 'byemail' when the created user will receive its password by e-mail
4536 * - 'autocreate' when the user is automatically created (such as by CentralAuth).
4537 * - Boolean means whether the account was created by e-mail (deprecated):
4538 * - true will be converted to 'byemail'
4539 * - false will be converted to 'create' if this object is the same as
4540 * $wgUser and to 'create2' otherwise
4542 * @param string $reason user supplied reason
4544 * @return int|bool True if not $wgNewUserLog; otherwise ID of log item or 0 on failure
4546 public function addNewUserLogEntry( $action = false, $reason = '' ) {
4547 global $wgUser, $wgNewUserLog;
4548 if ( empty( $wgNewUserLog ) ) {
4549 return true; // disabled
4552 if ( $action === true ) {
4553 $action = 'byemail';
4554 } elseif ( $action === false ) {
4555 if ( $this->getName() == $wgUser->getName() ) {
4556 $action = 'create';
4557 } else {
4558 $action = 'create2';
4562 if ( $action === 'create' || $action === 'autocreate' ) {
4563 $performer = $this;
4564 } else {
4565 $performer = $wgUser;
4568 $logEntry = new ManualLogEntry( 'newusers', $action );
4569 $logEntry->setPerformer( $performer );
4570 $logEntry->setTarget( $this->getUserPage() );
4571 $logEntry->setComment( $reason );
4572 $logEntry->setParameters( array(
4573 '4::userid' => $this->getId(),
4574 ) );
4575 $logid = $logEntry->insert();
4577 if ( $action !== 'autocreate' ) {
4578 $logEntry->publish( $logid );
4581 return (int)$logid;
4585 * Add an autocreate newuser log entry for this user
4586 * Used by things like CentralAuth and perhaps other authplugins.
4587 * Consider calling addNewUserLogEntry() directly instead.
4589 * @return bool
4591 public function addNewUserLogEntryAutoCreate() {
4592 $this->addNewUserLogEntry( 'autocreate' );
4594 return true;
4598 * Load the user options either from cache, the database or an array
4600 * @param array $data Rows for the current user out of the user_properties table
4602 protected function loadOptions( $data = null ) {
4603 global $wgContLang;
4605 $this->load();
4607 if ( $this->mOptionsLoaded ) {
4608 return;
4611 $this->mOptions = self::getDefaultOptions();
4613 if ( !$this->getId() ) {
4614 // For unlogged-in users, load language/variant options from request.
4615 // There's no need to do it for logged-in users: they can set preferences,
4616 // and handling of page content is done by $pageLang->getPreferredVariant() and such,
4617 // so don't override user's choice (especially when the user chooses site default).
4618 $variant = $wgContLang->getDefaultVariant();
4619 $this->mOptions['variant'] = $variant;
4620 $this->mOptions['language'] = $variant;
4621 $this->mOptionsLoaded = true;
4622 return;
4625 // Maybe load from the object
4626 if ( !is_null( $this->mOptionOverrides ) ) {
4627 wfDebug( "User: loading options for user " . $this->getId() . " from override cache.\n" );
4628 foreach ( $this->mOptionOverrides as $key => $value ) {
4629 $this->mOptions[$key] = $value;
4631 } else {
4632 if ( !is_array( $data ) ) {
4633 wfDebug( "User: loading options for user " . $this->getId() . " from database.\n" );
4634 // Load from database
4635 $dbr = wfGetDB( DB_SLAVE );
4637 $res = $dbr->select(
4638 'user_properties',
4639 array( 'up_property', 'up_value' ),
4640 array( 'up_user' => $this->getId() ),
4641 __METHOD__
4644 $this->mOptionOverrides = array();
4645 $data = array();
4646 foreach ( $res as $row ) {
4647 $data[$row->up_property] = $row->up_value;
4650 foreach ( $data as $property => $value ) {
4651 $this->mOptionOverrides[$property] = $value;
4652 $this->mOptions[$property] = $value;
4656 $this->mOptionsLoaded = true;
4658 wfRunHooks( 'UserLoadOptions', array( $this, &$this->mOptions ) );
4662 * @todo document
4664 protected function saveOptions() {
4665 $this->loadOptions();
4667 // Not using getOptions(), to keep hidden preferences in database
4668 $saveOptions = $this->mOptions;
4670 // Allow hooks to abort, for instance to save to a global profile.
4671 // Reset options to default state before saving.
4672 if ( !wfRunHooks( 'UserSaveOptions', array( $this, &$saveOptions ) ) ) {
4673 return;
4676 $userId = $this->getId();
4677 $insert_rows = array();
4678 foreach ( $saveOptions as $key => $value ) {
4679 // Don't bother storing default values
4680 $defaultOption = self::getDefaultOption( $key );
4681 if ( ( is_null( $defaultOption ) &&
4682 !( $value === false || is_null( $value ) ) ) ||
4683 $value != $defaultOption ) {
4684 $insert_rows[] = array(
4685 'up_user' => $userId,
4686 'up_property' => $key,
4687 'up_value' => $value,
4692 $dbw = wfGetDB( DB_MASTER );
4693 $hasRows = $dbw->selectField( 'user_properties', '1',
4694 array( 'up_user' => $userId ), __METHOD__ );
4696 if ( $hasRows ) {
4697 // Only do this delete if there is something there. A very large portion of
4698 // calls to this function are for setting 'rememberpassword' for new accounts.
4699 // Doing this delete for new accounts with no rows in the table rougly causes
4700 // gap locks on [max user ID,+infinity) which causes high contention since many
4701 // updates will pile up on each other since they are for higher (newer) user IDs.
4702 $dbw->delete( 'user_properties', array( 'up_user' => $userId ), __METHOD__ );
4704 $dbw->insert( 'user_properties', $insert_rows, __METHOD__, array( 'IGNORE' ) );
4708 * Provide an array of HTML5 attributes to put on an input element
4709 * intended for the user to enter a new password. This may include
4710 * required, title, and/or pattern, depending on $wgMinimalPasswordLength.
4712 * Do *not* use this when asking the user to enter his current password!
4713 * Regardless of configuration, users may have invalid passwords for whatever
4714 * reason (e.g., they were set before requirements were tightened up).
4715 * Only use it when asking for a new password, like on account creation or
4716 * ResetPass.
4718 * Obviously, you still need to do server-side checking.
4720 * NOTE: A combination of bugs in various browsers means that this function
4721 * actually just returns array() unconditionally at the moment. May as
4722 * well keep it around for when the browser bugs get fixed, though.
4724 * @todo FIXME: This does not belong here; put it in Html or Linker or somewhere
4726 * @return array Array of HTML attributes suitable for feeding to
4727 * Html::element(), directly or indirectly. (Don't feed to Xml::*()!
4728 * That will get confused by the boolean attribute syntax used.)
4730 public static function passwordChangeInputAttribs() {
4731 global $wgMinimalPasswordLength;
4733 if ( $wgMinimalPasswordLength == 0 ) {
4734 return array();
4737 # Note that the pattern requirement will always be satisfied if the
4738 # input is empty, so we need required in all cases.
4740 # @todo FIXME: Bug 23769: This needs to not claim the password is required
4741 # if e-mail confirmation is being used. Since HTML5 input validation
4742 # is b0rked anyway in some browsers, just return nothing. When it's
4743 # re-enabled, fix this code to not output required for e-mail
4744 # registration.
4745 #$ret = array( 'required' );
4746 $ret = array();
4748 # We can't actually do this right now, because Opera 9.6 will print out
4749 # the entered password visibly in its error message! When other
4750 # browsers add support for this attribute, or Opera fixes its support,
4751 # we can add support with a version check to avoid doing this on Opera
4752 # versions where it will be a problem. Reported to Opera as
4753 # DSK-262266, but they don't have a public bug tracker for us to follow.
4755 if ( $wgMinimalPasswordLength > 1 ) {
4756 $ret['pattern'] = '.{' . intval( $wgMinimalPasswordLength ) . ',}';
4757 $ret['title'] = wfMessage( 'passwordtooshort' )
4758 ->numParams( $wgMinimalPasswordLength )->text();
4762 return $ret;
4766 * Return the list of user fields that should be selected to create
4767 * a new user object.
4768 * @return array
4770 public static function selectFields() {
4771 return array(
4772 'user_id',
4773 'user_name',
4774 'user_real_name',
4775 'user_password',
4776 'user_newpassword',
4777 'user_newpass_time',
4778 'user_email',
4779 'user_touched',
4780 'user_token',
4781 'user_email_authenticated',
4782 'user_email_token',
4783 'user_email_token_expires',
4784 'user_registration',
4785 'user_editcount',
4790 * Factory function for fatal permission-denied errors
4792 * @since 1.22
4793 * @param string $permission User right required
4794 * @return Status
4796 static function newFatalPermissionDeniedStatus( $permission ) {
4797 global $wgLang;
4799 $groups = array_map(
4800 array( 'User', 'makeGroupLinkWiki' ),
4801 User::getGroupsWithPermission( $permission )
4804 if ( $groups ) {
4805 return Status::newFatal( 'badaccess-groups', $wgLang->commaList( $groups ), count( $groups ) );
4806 } else {
4807 return Status::newFatal( 'badaccess-group0' );