dépôts / lhc / web / wiklou.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Merge "mediawiki.jqueryMsg: Use load urls instead of file urls for debug"
[lhc/web/wiklou.git] / includes / User.php
1 <?php
2 /**
3 * Implements the User class for the %MediaWiki software.
4 *
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.
9 *
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.
14 *
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
19 *
20 * @file
21 */
22
23 /**
24 * String Some punctuation to prevent editing from broken text-mangling proxies.
25 * @ingroup Constants
26 */
27 define( 'EDIT_TOKEN_SUFFIX', '+\\' );
28
29 /**
30 * The User object encapsulates all of the user-specific settings (user_id,
31 * name, rights, password, email address, options, last login time). Client
32 * classes use the getXXX() functions to access these fields. These functions
33 * do all the work of determining whether the user is logged in,
34 * whether the requested option can be satisfied from cookies or
35 * whether a database query is needed. Most of the settings needed
36 * for rendering normal pages are set in the cookie to minimize use
37 * of the database.
38 */
39 class User implements IDBAccessObject {
40 /**
41 * @const int Number of characters in user_token field.
42 */
43 const TOKEN_LENGTH = 32;
44
45 /**
46 * Global constant made accessible as class constants so that autoloader
47 * magic can be used.
48 */
49 const EDIT_TOKEN_SUFFIX = EDIT_TOKEN_SUFFIX;
50
51 /**
52 * @const int Serialized record version.
53 */
54 const VERSION = 10;
55
56 /**
57 * Maximum items in $mWatchedItems
58 */
59 const MAX_WATCHED_ITEMS_CACHE = 100;
60
61 /**
62 * Exclude user options that are set to their default value.
63 * @since 1.25
64 */
65 const GETOPTIONS_EXCLUDE_DEFAULTS = 1;
66
67 /**
68 * @var PasswordFactory Lazily loaded factory object for passwords
69 */
70 private static $mPasswordFactory = null;
71
72 /**
73 * Array of Strings List of member variables which are saved to the
74 * shared cache (memcached). Any operation which changes the
75 * corresponding database fields must call a cache-clearing function.
76 * @showinitializer
77 */
78 protected static $mCacheVars = array(
79 // user table
80 'mId',
81 'mName',
82 'mRealName',
83 'mEmail',
84 'mTouched',
85 'mToken',
86 'mEmailAuthenticated',
87 'mEmailToken',
88 'mEmailTokenExpires',
89 'mRegistration',
90 'mEditCount',
91 // user_groups table
92 'mGroups',
93 // user_properties table
94 'mOptionOverrides',
95 );
96
97 /**
98 * Array of Strings Core rights.
99 * Each of these should have a corresponding message of the form
100 * "right-$right".
101 * @showinitializer
102 */
103 protected static $mCoreRights = array(
104 'apihighlimits',
105 'applychangetags',
106 'autoconfirmed',
107 'autopatrol',
108 'bigdelete',
109 'block',
110 'blockemail',
111 'bot',
112 'browsearchive',
113 'changetags',
114 'createaccount',
115 'createpage',
116 'createtalk',
117 'delete',
118 'deletedhistory',
119 'deletedtext',
120 'deletelogentry',
121 'deleterevision',
122 'edit',
123 'editcontentmodel',
124 'editinterface',
125 'editprotected',
126 'editmyoptions',
127 'editmyprivateinfo',
128 'editmyusercss',
129 'editmyuserjs',
130 'editmywatchlist',
131 'editsemiprotected',
132 'editusercssjs', #deprecated
133 'editusercss',
134 'edituserjs',
135 'hideuser',
136 'import',
137 'importupload',
138 'ipblock-exempt',
139 'managechangetags',
140 'markbotedits',
141 'mergehistory',
142 'minoredit',
143 'move',
144 'movefile',
145 'move-categorypages',
146 'move-rootuserpages',
147 'move-subpages',
148 'nominornewtalk',
149 'noratelimit',
150 'override-export-depth',
151 'pagelang',
152 'passwordreset',
153 'patrol',
154 'patrolmarks',
155 'protect',
156 'proxyunbannable',
157 'purge',
158 'read',
159 'reupload',
160 'reupload-own',
161 'reupload-shared',
162 'rollback',
163 'sendemail',
164 'siteadmin',
165 'suppressionlog',
166 'suppressredirect',
167 'suppressrevision',
168 'unblockself',
169 'undelete',
170 'unwatchedpages',
171 'upload',
172 'upload_by_url',
173 'userrights',
174 'userrights-interwiki',
175 'viewmyprivateinfo',
176 'viewmywatchlist',
177 'viewsuppressed',
178 'writeapi',
179 );
180
181 /**
182 * String Cached results of getAllRights()
183 */
184 protected static $mAllRights = false;
185
186 /** Cache variables */
187 //@{
188 public $mId;
189 /** @var string */
190 public $mName;
191 /** @var string */
192 public $mRealName;
193 /**
194 * @todo Make this actually private
195 * @private
196 * @var Password
197 */
198 public $mPassword;
199 /**
200 * @todo Make this actually private
201 * @private
202 * @var Password
203 */
204 public $mNewpassword;
205 /** @var string */
206 public $mNewpassTime;
207 /** @var string */
208 public $mEmail;
209 /** @var string TS_MW timestamp from the DB */
210 public $mTouched;
211 /** @var string TS_MW timestamp from cache */
212 protected $mQuickTouched;
213 /** @var string */
214 protected $mToken;
215 /** @var string */
216 public $mEmailAuthenticated;
217 /** @var string */
218 protected $mEmailToken;
219 /** @var string */
220 protected $mEmailTokenExpires;
221 /** @var string */
222 protected $mRegistration;
223 /** @var int */
224 protected $mEditCount;
225 /** @var array */
226 public $mGroups;
227 /** @var array */
228 protected $mOptionOverrides;
229 /** @var string */
230 protected $mPasswordExpires;
231 //@}
232
233 /**
234 * Bool Whether the cache variables have been loaded.
235 */
236 //@{
237 public $mOptionsLoaded;
238
239 /**
240 * Array with already loaded items or true if all items have been loaded.
241 */
242 protected $mLoadedItems = array();
243 //@}
244
245 /**
246 * String Initialization data source if mLoadedItems!==true. May be one of:
247 * - 'defaults' anonymous user initialised from class defaults
248 * - 'name' initialise from mName
249 * - 'id' initialise from mId
250 * - 'session' log in from cookies or session if possible
251 *
252 * Use the User::newFrom*() family of functions to set this.
253 */
254 public $mFrom;
255
256 /**
257 * Lazy-initialized variables, invalidated with clearInstanceCache
258 */
259 protected $mNewtalk;
260 /** @var string */
261 protected $mDatePreference;
262 /** @var string */
263 public $mBlockedby;
264 /** @var string */
265 protected $mHash;
266 /** @var array */
267 public $mRights;
268 /** @var string */
269 protected $mBlockreason;
270 /** @var array */
271 protected $mEffectiveGroups;
272 /** @var array */
273 protected $mImplicitGroups;
274 /** @var array */
275 protected $mFormerGroups;
276 /** @var bool */
277 protected $mBlockedGlobally;
278 /** @var bool */
279 protected $mLocked;
280 /** @var bool */
281 public $mHideName;
282 /** @var array */
283 public $mOptions;
284
285 /**
286 * @var WebRequest
287 */
288 private $mRequest;
289
290 /** @var Block */
291 public $mBlock;
292
293 /** @var bool */
294 protected $mAllowUsertalk;
295
296 /** @var Block */
297 private $mBlockedFromCreateAccount = false;
298
299 /** @var array */
300 private $mWatchedItems = array();
301
302 /** @var integer User::READ_* constant bitfield used to load data */
303 protected $queryFlagsUsed = self::READ_NORMAL;
304
305 public static $idCacheByName = array();
306
307 /**
308 * Lightweight constructor for an anonymous user.
309 * Use the User::newFrom* factory functions for other kinds of users.
310 *
311 * @see newFromName()
312 * @see newFromId()
313 * @see newFromConfirmationCode()
314 * @see newFromSession()
315 * @see newFromRow()
316 */
317 public function __construct() {
318 $this->clearInstanceCache( 'defaults' );
319 }
320
321 /**
322 * @return string
323 */
324 public function __toString() {
325 return $this->getName();
326 }
327
328 /**
329 * Load the user table data for this object from the source given by mFrom.
330 *
331 * @param integer $flags User::READ_* constant bitfield
332 */
333 public function load( $flags = self::READ_NORMAL ) {
334 if ( $this->mLoadedItems === true ) {
335 return;
336 }
337
338 // Set it now to avoid infinite recursion in accessors
339 $this->mLoadedItems = true;
340 $this->queryFlagsUsed = $flags;
341
342 switch ( $this->mFrom ) {
343 case 'defaults':
344 $this->loadDefaults();
345 break;
346 case 'name':
347 // Make sure this thread sees its own changes
348 if ( wfGetLB()->hasOrMadeRecentMasterChanges() ) {
349 $flags |= self::READ_LATEST;
350 $this->queryFlagsUsed = $flags;
351 }
352
353 $this->mId = self::idFromName( $this->mName, $flags );
354 if ( !$this->mId ) {
355 // Nonexistent user placeholder object
356 $this->loadDefaults( $this->mName );
357 } else {
358 $this->loadFromId( $flags );
359 }
360 break;
361 case 'id':
362 $this->loadFromId( $flags );
363 break;
364 case 'session':
365 if ( !$this->loadFromSession() ) {
366 // Loading from session failed. Load defaults.
367 $this->loadDefaults();
368 }
369 Hooks::run( 'UserLoadAfterLoadFromSession', array( $this ) );
370 break;
371 default:
372 throw new UnexpectedValueException(
373 "Unrecognised value for User->mFrom: \"{$this->mFrom}\"" );
374 }
375 }
376
377 /**
378 * Load user table data, given mId has already been set.
379 * @param integer $flags User::READ_* constant bitfield
380 * @return bool False if the ID does not exist, true otherwise
381 */
382 public function loadFromId( $flags = self::READ_NORMAL ) {
383 if ( $this->mId == 0 ) {
384 $this->loadDefaults();
385 return false;
386 }
387
388 // Try cache (unless this needs to lock the DB).
389 // NOTE: if this thread called saveSettings(), the cache was cleared.
390 $locking = ( ( $flags & self::READ_LOCKING ) == self::READ_LOCKING );
391 if ( $locking || !$this->loadFromCache() ) {
392 wfDebug( "User: cache miss for user {$this->mId}\n" );
393 // Load from DB (make sure this thread sees its own changes)
394 if ( wfGetLB()->hasOrMadeRecentMasterChanges() ) {
395 $flags |= self::READ_LATEST;
396 }
397 if ( !$this->loadFromDatabase( $flags ) ) {
398 // Can't load from ID, user is anonymous
399 return false;
400 }
401 $this->saveToCache();
402 }
403
404 $this->mLoadedItems = true;
405 $this->queryFlagsUsed = $flags;
406
407 return true;
408 }
409
410 /**
411 * Load user data from shared cache, given mId has already been set.
412 *
413 * @return bool false if the ID does not exist or data is invalid, true otherwise
414 * @since 1.25
415 */
416 protected function loadFromCache() {
417 if ( $this->mId == 0 ) {
418 $this->loadDefaults();
419 return false;
420 }
421
422 $key = wfMemcKey( 'user', 'id', $this->mId );
423 $data = ObjectCache::getMainWANInstance()->get( $key );
424 if ( !is_array( $data ) || $data['mVersion'] < self::VERSION ) {
425 // Object is expired
426 return false;
427 }
428
429 wfDebug( "User: got user {$this->mId} from cache\n" );
430
431 // Restore from cache
432 foreach ( self::$mCacheVars as $name ) {
433 $this->$name = $data[$name];
434 }
435
436 return true;
437 }
438
439 /**
440 * Save user data to the shared cache
441 *
442 * This method should not be called outside the User class
443 */
444 public function saveToCache() {
445 $this->load();
446 $this->loadGroups();
447 $this->loadOptions();
448
449 if ( $this->isAnon() ) {
450 // Anonymous users are uncached
451 return;
452 }
453
454 $data = array();
455 foreach ( self::$mCacheVars as $name ) {
456 $data[$name] = $this->$name;
457 }
458 $data['mVersion'] = self::VERSION;
459 $key = wfMemcKey( 'user', 'id', $this->mId );
460
461 ObjectCache::getMainWANInstance()->set( $key, $data, 3600 );
462 }
463
464 /** @name newFrom*() static factory methods */
465 //@{
466
467 /**
468 * Static factory method for creation from username.
469 *
470 * This is slightly less efficient than newFromId(), so use newFromId() if
471 * you have both an ID and a name handy.
472 *
473 * @param string $name Username, validated by Title::newFromText()
474 * @param string|bool $validate Validate username. Takes the same parameters as
475 * User::getCanonicalName(), except that true is accepted as an alias
476 * for 'valid', for BC.
477 *
478 * @return User|bool User object, or false if the username is invalid
479 * (e.g. if it contains illegal characters or is an IP address). If the
480 * username is not present in the database, the result will be a user object
481 * with a name, zero user ID and default settings.
482 */
483 public static function newFromName( $name, $validate = 'valid' ) {
484 if ( $validate === true ) {
485 $validate = 'valid';
486 }
487 $name = self::getCanonicalName( $name, $validate );
488 if ( $name === false ) {
489 return false;
490 } else {
491 // Create unloaded user object
492 $u = new User;
493 $u->mName = $name;
494 $u->mFrom = 'name';
495 $u->setItemLoaded( 'name' );
496 return $u;
497 }
498 }
499
500 /**
501 * Static factory method for creation from a given user ID.
502 *
503 * @param int $id Valid user ID
504 * @return User The corresponding User object
505 */
506 public static function newFromId( $id ) {
507 $u = new User;
508 $u->mId = $id;
509 $u->mFrom = 'id';
510 $u->setItemLoaded( 'id' );
511 return $u;
512 }
513
514 /**
515 * Factory method to fetch whichever user has a given email confirmation code.
516 * This code is generated when an account is created or its e-mail address
517 * has changed.
518 *
519 * If the code is invalid or has expired, returns NULL.
520 *
521 * @param string $code Confirmation code
522 * @return User|null
523 */
524 public static function newFromConfirmationCode( $code ) {
525 $dbr = wfGetDB( DB_SLAVE );
526 $id = $dbr->selectField( 'user', 'user_id', array(
527 'user_email_token' => md5( $code ),
528 'user_email_token_expires > ' . $dbr->addQuotes( $dbr->timestamp() ),
529 ) );
530 if ( $id !== false ) {
531 return User::newFromId( $id );
532 } else {
533 return null;
534 }
535 }
536
537 /**
538 * Create a new user object using data from session or cookies. If the
539 * login credentials are invalid, the result is an anonymous user.
540 *
541 * @param WebRequest|null $request Object to use; $wgRequest will be used if omitted.
542 * @return User
543 */
544 public static function newFromSession( WebRequest $request = null ) {
545 $user = new User;
546 $user->mFrom = 'session';
547 $user->mRequest = $request;
548 return $user;
549 }
550
551 /**
552 * Create a new user object from a user row.
553 * The row should have the following fields from the user table in it:
554 * - either user_name or user_id to load further data if needed (or both)
555 * - user_real_name
556 * - all other fields (email, password, etc.)
557 * It is useless to provide the remaining fields if either user_id,
558 * user_name and user_real_name are not provided because the whole row
559 * will be loaded once more from the database when accessing them.
560 *
561 * @param stdClass $row A row from the user table
562 * @param array $data Further data to load into the object (see User::loadFromRow for valid keys)
563 * @return User
564 */
565 public static function newFromRow( $row, $data = null ) {
566 $user = new User;
567 $user->loadFromRow( $row, $data );
568 return $user;
569 }
570
571 //@}
572
573 /**
574 * Get the username corresponding to a given user ID
575 * @param int $id User ID
576 * @return string|bool The corresponding username
577 */
578 public static function whoIs( $id ) {
579 return UserCache::singleton()->getProp( $id, 'name' );
580 }
581
582 /**
583 * Get the real name of a user given their user ID
584 *
585 * @param int $id User ID
586 * @return string|bool The corresponding user's real name
587 */
588 public static function whoIsReal( $id ) {
589 return UserCache::singleton()->getProp( $id, 'real_name' );
590 }
591
592 /**
593 * Get database id given a user name
594 * @param string $name Username
595 * @param integer $flags User::READ_* constant bitfield
596 * @return int|null The corresponding user's ID, or null if user is nonexistent
597 */
598 public static function idFromName( $name, $flags = self::READ_NORMAL ) {
599 $nt = Title::makeTitleSafe( NS_USER, $name );
600 if ( is_null( $nt ) ) {
601 // Illegal name
602 return null;
603 }
604
605 if ( isset( self::$idCacheByName[$name] ) ) {
606 return self::$idCacheByName[$name];
607 }
608
609 $db = ( $flags & self::READ_LATEST )
610 ? wfGetDB( DB_MASTER )
611 : wfGetDB( DB_SLAVE );
612
613 $s = $db->selectRow(
614 'user',
615 array( 'user_id' ),
616 array( 'user_name' => $nt->getText() ),
617 __METHOD__
618 );
619
620 if ( $s === false ) {
621 $result = null;
622 } else {
623 $result = $s->user_id;
624 }
625
626 self::$idCacheByName[$name] = $result;
627
628 if ( count( self::$idCacheByName ) > 1000 ) {
629 self::$idCacheByName = array();
630 }
631
632 return $result;
633 }
634
635 /**
636 * Reset the cache used in idFromName(). For use in tests.
637 */
638 public static function resetIdByNameCache() {
639 self::$idCacheByName = array();
640 }
641
642 /**
643 * Does the string match an anonymous IPv4 address?
644 *
645 * This function exists for username validation, in order to reject
646 * usernames which are similar in form to IP addresses. Strings such
647 * as 300.300.300.300 will return true because it looks like an IP
648 * address, despite not being strictly valid.
649 *
650 * We match "\d{1,3}\.\d{1,3}\.\d{1,3}\.xxx" as an anonymous IP
651 * address because the usemod software would "cloak" anonymous IP
652 * addresses like this, if we allowed accounts like this to be created
653 * new users could get the old edits of these anonymous users.
654 *
655 * @param string $name Name to match
656 * @return bool
657 */
658 public static function isIP( $name ) {
659 return preg_match( '/^\d{1,3}\.\d{1,3}\.\d{1,3}\.(?:xxx|\d{1,3})$/', $name )
660 || IP::isIPv6( $name );
661 }
662
663 /**
664 * Is the input a valid username?
665 *
666 * Checks if the input is a valid username, we don't want an empty string,
667 * an IP address, anything that contains slashes (would mess up subpages),
668 * is longer than the maximum allowed username size or doesn't begin with
669 * a capital letter.
670 *
671 * @param string $name Name to match
672 * @return bool
673 */
674 public static function isValidUserName( $name ) {
675 global $wgContLang, $wgMaxNameChars;
676
677 if ( $name == ''
678 || User::isIP( $name )
679 || strpos( $name, '/' ) !== false
680 || strlen( $name ) > $wgMaxNameChars
681 || $name != $wgContLang->ucfirst( $name )
682 ) {
683 wfDebugLog( 'username', __METHOD__ .
684 ": '$name' invalid due to empty, IP, slash, length, or lowercase" );
685 return false;
686 }
687
688 // Ensure that the name can't be misresolved as a different title,
689 // such as with extra namespace keys at the start.
690 $parsed = Title::newFromText( $name );
691 if ( is_null( $parsed )
692 || $parsed->getNamespace()
693 || strcmp( $name, $parsed->getPrefixedText() ) ) {
694 wfDebugLog( 'username', __METHOD__ .
695 ": '$name' invalid due to ambiguous prefixes" );
696 return false;
697 }
698
699 // Check an additional blacklist of troublemaker characters.
700 // Should these be merged into the title char list?
701 $unicodeBlacklist = '/[' .
702 '\x{0080}-\x{009f}' . # iso-8859-1 control chars
703 '\x{00a0}' . # non-breaking space
704 '\x{2000}-\x{200f}' . # various whitespace
705 '\x{2028}-\x{202f}' . # breaks and control chars
706 '\x{3000}' . # ideographic space
707 '\x{e000}-\x{f8ff}' . # private use
708 ']/u';
709 if ( preg_match( $unicodeBlacklist, $name ) ) {
710 wfDebugLog( 'username', __METHOD__ .
711 ": '$name' invalid due to blacklisted characters" );
712 return false;
713 }
714
715 return true;
716 }
717
718 /**
719 * Usernames which fail to pass this function will be blocked
720 * from user login and new account registrations, but may be used
721 * internally by batch processes.
722 *
723 * If an account already exists in this form, login will be blocked
724 * by a failure to pass this function.
725 *
726 * @param string $name Name to match
727 * @return bool
728 */
729 public static function isUsableName( $name ) {
730 global $wgReservedUsernames;
731 // Must be a valid username, obviously ;)
732 if ( !self::isValidUserName( $name ) ) {
733 return false;
734 }
735
736 static $reservedUsernames = false;
737 if ( !$reservedUsernames ) {
738 $reservedUsernames = $wgReservedUsernames;
739 Hooks::run( 'UserGetReservedNames', array( &$reservedUsernames ) );
740 }
741
742 // Certain names may be reserved for batch processes.
743 foreach ( $reservedUsernames as $reserved ) {
744 if ( substr( $reserved, 0, 4 ) == 'msg:' ) {
745 $reserved = wfMessage( substr( $reserved, 4 ) )->inContentLanguage()->text();
746 }
747 if ( $reserved == $name ) {
748 return false;
749 }
750 }
751 return true;
752 }
753
754 /**
755 * Usernames which fail to pass this function will be blocked
756 * from new account registrations, but may be used internally
757 * either by batch processes or by user accounts which have
758 * already been created.
759 *
760 * Additional blacklisting may be added here rather than in
761 * isValidUserName() to avoid disrupting existing accounts.
762 *
763 * @param string $name String to match
764 * @return bool
765 */
766 public static function isCreatableName( $name ) {
767 global $wgInvalidUsernameCharacters;
768
769 // Ensure that the username isn't longer than 235 bytes, so that
770 // (at least for the builtin skins) user javascript and css files
771 // will work. (bug 23080)
772 if ( strlen( $name ) > 235 ) {
773 wfDebugLog( 'username', __METHOD__ .
774 ": '$name' invalid due to length" );
775 return false;
776 }
777
778 // Preg yells if you try to give it an empty string
779 if ( $wgInvalidUsernameCharacters !== '' ) {
780 if ( preg_match( '/[' . preg_quote( $wgInvalidUsernameCharacters, '/' ) . ']/', $name ) ) {
781 wfDebugLog( 'username', __METHOD__ .
782 ": '$name' invalid due to wgInvalidUsernameCharacters" );
783 return false;
784 }
785 }
786
787 return self::isUsableName( $name );
788 }
789
790 /**
791 * Is the input a valid password for this user?
792 *
793 * @param string $password Desired password
794 * @return bool
795 */
796 public function isValidPassword( $password ) {
797 //simple boolean wrapper for getPasswordValidity
798 return $this->getPasswordValidity( $password ) === true;
799 }
800
801
802 /**
803 * Given unvalidated password input, return error message on failure.
804 *
805 * @param string $password Desired password
806 * @return bool|string|array True on success, string or array of error message on failure
807 */
808 public function getPasswordValidity( $password ) {
809 $result = $this->checkPasswordValidity( $password );
810 if ( $result->isGood() ) {
811 return true;
812 } else {
813 $messages = array();
814 foreach ( $result->getErrorsByType( 'error' ) as $error ) {
815 $messages[] = $error['message'];
816 }
817 foreach ( $result->getErrorsByType( 'warning' ) as $warning ) {
818 $messages[] = $warning['message'];
819 }
820 if ( count( $messages ) === 1 ) {
821 return $messages[0];
822 }
823 return $messages;
824 }
825 }
826
827 /**
828 * Check if this is a valid password for this user
829 *
830 * Create a Status object based on the password's validity.
831 * The Status should be set to fatal if the user should not
832 * be allowed to log in, and should have any errors that
833 * would block changing the password.
834 *
835 * If the return value of this is not OK, the password
836 * should not be checked. If the return value is not Good,
837 * the password can be checked, but the user should not be
838 * able to set their password to this.
839 *
840 * @param string $password Desired password
841 * @param string $purpose one of 'login', 'create', 'reset'
842 * @return Status
843 * @since 1.23
844 */
845 public function checkPasswordValidity( $password, $purpose = 'login' ) {
846 global $wgPasswordPolicy;
847
848 $upp = new UserPasswordPolicy(
849 $wgPasswordPolicy['policies'],
850 $wgPasswordPolicy['checks']
851 );
852
853 $status = Status::newGood();
854 $result = false; //init $result to false for the internal checks
855
856 if ( !Hooks::run( 'isValidPassword', array( $password, &$result, $this ) ) ) {
857 $status->error( $result );
858 return $status;
859 }
860
861 if ( $result === false ) {
862 $status->merge( $upp->checkUserPassword( $this, $password, $purpose ) );
863 return $status;
864 } elseif ( $result === true ) {
865 return $status;
866 } else {
867 $status->error( $result );
868 return $status; //the isValidPassword hook set a string $result and returned true
869 }
870 }
871
872 /**
873 * Expire a user's password
874 * @since 1.23
875 * @param int $ts Optional timestamp to convert, default 0 for the current time
876 */
877 public function expirePassword( $ts = 0 ) {
878 $this->loadPasswords();
879 $timestamp = wfTimestamp( TS_MW, $ts );
880 $this->mPasswordExpires = $timestamp;
881 $this->saveSettings();
882 }
883
884 /**
885 * Clear the password expiration for a user
886 * @since 1.23
887 * @param bool $load Ensure user object is loaded first
888 */
889 public function resetPasswordExpiration( $load = true ) {
890 global $wgPasswordExpirationDays;
891 if ( $load ) {
892 $this->load();
893 }
894 $newExpire = null;
895 if ( $wgPasswordExpirationDays ) {
896 $newExpire = wfTimestamp(
897 TS_MW,
898 time() + ( $wgPasswordExpirationDays * 24 * 3600 )
899 );
900 }
901 // Give extensions a chance to force an expiration
902 Hooks::run( 'ResetPasswordExpiration', array( $this, &$newExpire ) );
903 $this->mPasswordExpires = $newExpire;
904 }
905
906 /**
907 * Check if the user's password is expired.
908 * TODO: Put this and password length into a PasswordPolicy object
909 * @since 1.23
910 * @return string|bool The expiration type, or false if not expired
911 * hard: A password change is required to login
912 * soft: Allow login, but encourage password change
913 * false: Password is not expired
914 */
915 public function getPasswordExpired() {
916 global $wgPasswordExpireGrace;
917 $expired = false;
918 $now = wfTimestamp();
919 $expiration = $this->getPasswordExpireDate();
920 $expUnix = wfTimestamp( TS_UNIX, $expiration );
921 if ( $expiration !== null && $expUnix < $now ) {
922 $expired = ( $expUnix + $wgPasswordExpireGrace < $now ) ? 'hard' : 'soft';
923 }
924 return $expired;
925 }
926
927 /**
928 * Get this user's password expiration date. Since this may be using
929 * the cached User object, we assume that whatever mechanism is setting
930 * the expiration date is also expiring the User cache.
931 * @since 1.23
932 * @return string|bool The datestamp of the expiration, or null if not set
933 */
934 public function getPasswordExpireDate() {
935 $this->load();
936 return $this->mPasswordExpires;
937 }
938
939 /**
940 * Given unvalidated user input, return a canonical username, or false if
941 * the username is invalid.
942 * @param string $name User input
943 * @param string|bool $validate Type of validation to use:
944 * - false No validation
945 * - 'valid' Valid for batch processes
946 * - 'usable' Valid for batch processes and login
947 * - 'creatable' Valid for batch processes, login and account creation
948 *
949 * @throws InvalidArgumentException
950 * @return bool|string
951 */
952 public static function getCanonicalName( $name, $validate = 'valid' ) {
953 // Force usernames to capital
954 global $wgContLang;
955 $name = $wgContLang->ucfirst( $name );
956
957 # Reject names containing '#'; these will be cleaned up
958 # with title normalisation, but then it's too late to
959 # check elsewhere
960 if ( strpos( $name, '#' ) !== false ) {
961 return false;
962 }
963
964 // Clean up name according to title rules,
965 // but only when validation is requested (bug 12654)
966 $t = ( $validate !== false ) ?
967 Title::newFromText( $name ) : Title::makeTitle( NS_USER, $name );
968 // Check for invalid titles
969 if ( is_null( $t ) ) {
970 return false;
971 }
972
973 // Reject various classes of invalid names
974 global $wgAuth;
975 $name = $wgAuth->getCanonicalName( $t->getText() );
976
977 switch ( $validate ) {
978 case false:
979 break;
980 case 'valid':
981 if ( !User::isValidUserName( $name ) ) {
982 $name = false;
983 }
984 break;
985 case 'usable':
986 if ( !User::isUsableName( $name ) ) {
987 $name = false;
988 }
989 break;
990 case 'creatable':
991 if ( !User::isCreatableName( $name ) ) {
992 $name = false;
993 }
994 break;
995 default:
996 throw new InvalidArgumentException(
997 'Invalid parameter value for $validate in ' . __METHOD__ );
998 }
999 return $name;
1000 }
1001
1002 /**
1003 * Count the number of edits of a user
1004 *
1005 * @param int $uid User ID to check
1006 * @return int The user's edit count
1007 *
1008 * @deprecated since 1.21 in favour of User::getEditCount
1009 */
1010 public static function edits( $uid ) {
1011 wfDeprecated( __METHOD__, '1.21' );
1012 $user = self::newFromId( $uid );
1013 return $user->getEditCount();
1014 }
1015
1016 /**
1017 * Return a random password.
1018 *
1019 * @return string New random password
1020 */
1021 public static function randomPassword() {
1022 global $wgMinimalPasswordLength;
1023 // Decide the final password length based on our min password length,
1024 // stopping at a minimum of 10 chars.
1025 $length = max( 10, $wgMinimalPasswordLength );
1026 // Multiply by 1.25 to get the number of hex characters we need
1027 $length = $length * 1.25;
1028 // Generate random hex chars
1029 $hex = MWCryptRand::generateHex( $length );
1030 // Convert from base 16 to base 32 to get a proper password like string
1031 return wfBaseConvert( $hex, 16, 32 );
1032 }
1033
1034 /**
1035 * Set cached properties to default.
1036 *
1037 * @note This no longer clears uncached lazy-initialised properties;
1038 * the constructor does that instead.
1039 *
1040 * @param string|bool $name
1041 */
1042 public function loadDefaults( $name = false ) {
1043
1044 $passwordFactory = self::getPasswordFactory();
1045
1046 $this->mId = 0;
1047 $this->mName = $name;
1048 $this->mRealName = '';
1049 $this->mPassword = $passwordFactory->newFromCiphertext( null );
1050 $this->mNewpassword = $passwordFactory->newFromCiphertext( null );
1051 $this->mNewpassTime = null;
1052 $this->mEmail = '';
1053 $this->mOptionOverrides = null;
1054 $this->mOptionsLoaded = false;
1055
1056 $loggedOut = $this->getRequest()->getCookie( 'LoggedOut' );
1057 if ( $loggedOut !== null ) {
1058 $this->mTouched = wfTimestamp( TS_MW, $loggedOut );
1059 } else {
1060 $this->mTouched = '1'; # Allow any pages to be cached
1061 }
1062
1063 $this->mToken = null; // Don't run cryptographic functions till we need a token
1064 $this->mEmailAuthenticated = null;
1065 $this->mEmailToken = '';
1066 $this->mEmailTokenExpires = null;
1067 $this->mPasswordExpires = null;
1068 $this->resetPasswordExpiration( false );
1069 $this->mRegistration = wfTimestamp( TS_MW );
1070 $this->mGroups = array();
1071
1072 Hooks::run( 'UserLoadDefaults', array( $this, $name ) );
1073 }
1074
1075 /**
1076 * Return whether an item has been loaded.
1077 *
1078 * @param string $item Item to check. Current possibilities:
1079 * - id
1080 * - name
1081 * - realname
1082 * @param string $all 'all' to check if the whole object has been loaded
1083 * or any other string to check if only the item is available (e.g.
1084 * for optimisation)
1085 * @return bool
1086 */
1087 public function isItemLoaded( $item, $all = 'all' ) {
1088 return ( $this->mLoadedItems === true && $all === 'all' ) ||
1089 ( isset( $this->mLoadedItems[$item] ) && $this->mLoadedItems[$item] === true );
1090 }
1091
1092 /**
1093 * Set that an item has been loaded
1094 *
1095 * @param string $item
1096 */
1097 protected function setItemLoaded( $item ) {
1098 if ( is_array( $this->mLoadedItems ) ) {
1099 $this->mLoadedItems[$item] = true;
1100 }
1101 }
1102
1103 /**
1104 * Load user data from the session or login cookie.
1105 *
1106 * @return bool True if the user is logged in, false otherwise.
1107 */
1108 private function loadFromSession() {
1109 $result = null;
1110 Hooks::run( 'UserLoadFromSession', array( $this, &$result ) );
1111 if ( $result !== null ) {
1112 return $result;
1113 }
1114
1115 $request = $this->getRequest();
1116
1117 $cookieId = $request->getCookie( 'UserID' );
1118 $sessId = $request->getSessionData( 'wsUserID' );
1119
1120 if ( $cookieId !== null ) {
1121 $sId = intval( $cookieId );
1122 if ( $sessId !== null && $cookieId != $sessId ) {
1123 wfDebugLog( 'loginSessions', "Session user ID ($sessId) and
1124 cookie user ID ($sId) don't match!" );
1125 return false;
1126 }
1127 $request->setSessionData( 'wsUserID', $sId );
1128 } elseif ( $sessId !== null && $sessId != 0 ) {
1129 $sId = $sessId;
1130 } else {
1131 return false;
1132 }
1133
1134 if ( $request->getSessionData( 'wsUserName' ) !== null ) {
1135 $sName = $request->getSessionData( 'wsUserName' );
1136 } elseif ( $request->getCookie( 'UserName' ) !== null ) {
1137 $sName = $request->getCookie( 'UserName' );
1138 $request->setSessionData( 'wsUserName', $sName );
1139 } else {
1140 return false;
1141 }
1142
1143 $proposedUser = User::newFromId( $sId );
1144 if ( !$proposedUser->isLoggedIn() ) {
1145 // Not a valid ID
1146 return false;
1147 }
1148
1149 global $wgBlockDisablesLogin;
1150 if ( $wgBlockDisablesLogin && $proposedUser->isBlocked() ) {
1151 // User blocked and we've disabled blocked user logins
1152 return false;
1153 }
1154
1155 if ( $request->getSessionData( 'wsToken' ) ) {
1156 $passwordCorrect =
1157 ( $proposedUser->getToken( false ) === $request->getSessionData( 'wsToken' ) );
1158 $from = 'session';
1159 } elseif ( $request->getCookie( 'Token' ) ) {
1160 # Get the token from DB/cache and clean it up to remove garbage padding.
1161 # This deals with historical problems with bugs and the default column value.
1162 $token = rtrim( $proposedUser->getToken( false ) ); // correct token
1163 // Make comparison in constant time (bug 61346)
1164 $passwordCorrect = strlen( $token )
1165 && hash_equals( $token, $request->getCookie( 'Token' ) );
1166 $from = 'cookie';
1167 } else {
1168 // No session or persistent login cookie
1169 return false;
1170 }
1171
1172 if ( ( $sName === $proposedUser->getName() ) && $passwordCorrect ) {
1173 $this->loadFromUserObject( $proposedUser );
1174 $request->setSessionData( 'wsToken', $this->mToken );
1175 wfDebug( "User: logged in from $from\n" );
1176 return true;
1177 } else {
1178 // Invalid credentials
1179 wfDebug( "User: can't log in from $from, invalid credentials\n" );
1180 return false;
1181 }
1182 }
1183
1184 /**
1185 * Load user and user_group data from the database.
1186 * $this->mId must be set, this is how the user is identified.
1187 *
1188 * @param integer $flags User::READ_* constant bitfield
1189 * @return bool True if the user exists, false if the user is anonymous
1190 */
1191 public function loadFromDatabase( $flags = self::READ_LATEST ) {
1192 // Paranoia
1193 $this->mId = intval( $this->mId );
1194
1195 // Anonymous user
1196 if ( !$this->mId ) {
1197 $this->loadDefaults();
1198 return false;
1199 }
1200
1201 $db = ( $flags & self::READ_LATEST )
1202 ? wfGetDB( DB_MASTER )
1203 : wfGetDB( DB_SLAVE );
1204
1205 $s = $db->selectRow(
1206 'user',
1207 self::selectFields(),
1208 array( 'user_id' => $this->mId ),
1209 __METHOD__,
1210 ( ( $flags & self::READ_LOCKING ) == self::READ_LOCKING )
1211 ? array( 'LOCK IN SHARE MODE' )
1212 : array()
1213 );
1214
1215 $this->queryFlagsUsed = $flags;
1216 Hooks::run( 'UserLoadFromDatabase', array( $this, &$s ) );
1217
1218 if ( $s !== false ) {
1219 // Initialise user table data
1220 $this->loadFromRow( $s );
1221 $this->mGroups = null; // deferred
1222 $this->getEditCount(); // revalidation for nulls
1223 return true;
1224 } else {
1225 // Invalid user_id
1226 $this->mId = 0;
1227 $this->loadDefaults();
1228 return false;
1229 }
1230 }
1231
1232 /**
1233 * Initialize this object from a row from the user table.
1234 *
1235 * @param stdClass $row Row from the user table to load.
1236 * @param array $data Further user data to load into the object
1237 *
1238 * user_groups Array with groups out of the user_groups table
1239 * user_properties Array with properties out of the user_properties table
1240 */
1241 protected function loadFromRow( $row, $data = null ) {
1242 $all = true;
1243 $passwordFactory = self::getPasswordFactory();
1244
1245 $this->mGroups = null; // deferred
1246
1247 if ( isset( $row->user_name ) ) {
1248 $this->mName = $row->user_name;
1249 $this->mFrom = 'name';
1250 $this->setItemLoaded( 'name' );
1251 } else {
1252 $all = false;
1253 }
1254
1255 if ( isset( $row->user_real_name ) ) {
1256 $this->mRealName = $row->user_real_name;
1257 $this->setItemLoaded( 'realname' );
1258 } else {
1259 $all = false;
1260 }
1261
1262 if ( isset( $row->user_id ) ) {
1263 $this->mId = intval( $row->user_id );
1264 $this->mFrom = 'id';
1265 $this->setItemLoaded( 'id' );
1266 } else {
1267 $all = false;
1268 }
1269
1270 if ( isset( $row->user_id ) && isset( $row->user_name ) ) {
1271 self::$idCacheByName[$row->user_name] = $row->user_id;
1272 }
1273
1274 if ( isset( $row->user_editcount ) ) {
1275 $this->mEditCount = $row->user_editcount;
1276 } else {
1277 $all = false;
1278 }
1279
1280 if ( isset( $row->user_password ) ) {
1281 // Check for *really* old password hashes that don't even have a type
1282 // The old hash format was just an md5 hex hash, with no type information
1283 if ( preg_match( '/^[0-9a-f]{32}$/', $row->user_password ) ) {
1284 $row->user_password = ":A:{$this->mId}:{$row->user_password}";
1285 }
1286
1287 try {
1288 $this->mPassword = $passwordFactory->newFromCiphertext( $row->user_password );
1289 } catch ( PasswordError $e ) {
1290 wfDebug( 'Invalid password hash found in database.' );
1291 $this->mPassword = $passwordFactory->newFromCiphertext( null );
1292 }
1293
1294 try {
1295 $this->mNewpassword = $passwordFactory->newFromCiphertext( $row->user_newpassword );
1296 } catch ( PasswordError $e ) {
1297 wfDebug( 'Invalid password hash found in database.' );
1298 $this->mNewpassword = $passwordFactory->newFromCiphertext( null );
1299 }
1300
1301 $this->mNewpassTime = wfTimestampOrNull( TS_MW, $row->user_newpass_time );
1302 $this->mPasswordExpires = wfTimestampOrNull( TS_MW, $row->user_password_expires );
1303 }
1304
1305 if ( isset( $row->user_email ) ) {
1306 $this->mEmail = $row->user_email;
1307 $this->mTouched = wfTimestamp( TS_MW, $row->user_touched );
1308 $this->mToken = $row->user_token;
1309 if ( $this->mToken == '' ) {
1310 $this->mToken = null;
1311 }
1312 $this->mEmailAuthenticated = wfTimestampOrNull( TS_MW, $row->user_email_authenticated );
1313 $this->mEmailToken = $row->user_email_token;
1314 $this->mEmailTokenExpires = wfTimestampOrNull( TS_MW, $row->user_email_token_expires );
1315 $this->mRegistration = wfTimestampOrNull( TS_MW, $row->user_registration );
1316 } else {
1317 $all = false;
1318 }
1319
1320 if ( $all ) {
1321 $this->mLoadedItems = true;
1322 }
1323
1324 if ( is_array( $data ) ) {
1325 if ( isset( $data['user_groups'] ) && is_array( $data['user_groups'] ) ) {
1326 $this->mGroups = $data['user_groups'];
1327 }
1328 if ( isset( $data['user_properties'] ) && is_array( $data['user_properties'] ) ) {
1329 $this->loadOptions( $data['user_properties'] );
1330 }
1331 }
1332 }
1333
1334 /**
1335 * Load the data for this user object from another user object.
1336 *
1337 * @param User $user
1338 */
1339 protected function loadFromUserObject( $user ) {
1340 $user->load();
1341 $user->loadGroups();
1342 $user->loadOptions();
1343 foreach ( self::$mCacheVars as $var ) {
1344 $this->$var = $user->$var;
1345 }
1346 }
1347
1348 /**
1349 * Load the groups from the database if they aren't already loaded.
1350 */
1351 private function loadGroups() {
1352 if ( is_null( $this->mGroups ) ) {
1353 $db = ( $this->queryFlagsUsed & self::READ_LATEST )
1354 ? wfGetDB( DB_MASTER )
1355 : wfGetDB( DB_SLAVE );
1356 $res = $db->select( 'user_groups',
1357 array( 'ug_group' ),
1358 array( 'ug_user' => $this->mId ),
1359 __METHOD__ );
1360 $this->mGroups = array();
1361 foreach ( $res as $row ) {
1362 $this->mGroups[] = $row->ug_group;
1363 }
1364 }
1365 }
1366
1367 /**
1368 * Load the user's password hashes from the database
1369 *
1370 * This is usually called in a scenario where the actual User object was
1371 * loaded from the cache, and then password comparison needs to be performed.
1372 * Password hashes are not stored in memcached.
1373 *
1374 * @since 1.24
1375 */
1376 private function loadPasswords() {
1377 if ( $this->getId() !== 0 &&
1378 ( $this->mPassword === null || $this->mNewpassword === null )
1379 ) {
1380 $db = ( $this->queryFlagsUsed & self::READ_LATEST )
1381 ? wfGetDB( DB_MASTER )
1382 : wfGetDB( DB_SLAVE );
1383
1384 $this->loadFromRow( $db->selectRow(
1385 'user',
1386 array( 'user_password', 'user_newpassword',
1387 'user_newpass_time', 'user_password_expires' ),
1388 array( 'user_id' => $this->getId() ),
1389 __METHOD__
1390 ) );
1391 }
1392 }
1393
1394 /**
1395 * Add the user to the group if he/she meets given criteria.
1396 *
1397 * Contrary to autopromotion by \ref $wgAutopromote, the group will be
1398 * possible to remove manually via Special:UserRights. In such case it
1399 * will not be re-added automatically. The user will also not lose the
1400 * group if they no longer meet the criteria.
1401 *
1402 * @param string $event Key in $wgAutopromoteOnce (each one has groups/criteria)
1403 *
1404 * @return array Array of groups the user has been promoted to.
1405 *
1406 * @see $wgAutopromoteOnce
1407 */
1408 public function addAutopromoteOnceGroups( $event ) {
1409 global $wgAutopromoteOnceLogInRC, $wgAuth;
1410
1411 if ( wfReadOnly() || !$this->getId() ) {
1412 return array();
1413 }
1414
1415 $toPromote = Autopromote::getAutopromoteOnceGroups( $this, $event );
1416 if ( !count( $toPromote ) ) {
1417 return array();
1418 }
1419
1420 if ( !$this->checkAndSetTouched() ) {
1421 return array(); // raced out (bug T48834)
1422 }
1423
1424 $oldGroups = $this->getGroups(); // previous groups
1425 foreach ( $toPromote as $group ) {
1426 $this->addGroup( $group );
1427 }
1428
1429 // update groups in external authentication database
1430 $wgAuth->updateExternalDBGroups( $this, $toPromote );
1431
1432 $newGroups = array_merge( $oldGroups, $toPromote ); // all groups
1433
1434 $logEntry = new ManualLogEntry( 'rights', 'autopromote' );
1435 $logEntry->setPerformer( $this );
1436 $logEntry->setTarget( $this->getUserPage() );
1437 $logEntry->setParameters( array(
1438 '4::oldgroups' => $oldGroups,
1439 '5::newgroups' => $newGroups,
1440 ) );
1441 $logid = $logEntry->insert();
1442 if ( $wgAutopromoteOnceLogInRC ) {
1443 $logEntry->publish( $logid );
1444 }
1445
1446 return $toPromote;
1447 }
1448
1449 /**
1450 * Bump user_touched if it didn't change since this object was loaded
1451 *
1452 * On success, the mTouched field is updated.
1453 * The user serialization cache is always cleared.
1454 *
1455 * @return bool Whether user_touched was actually updated
1456 * @since 1.26
1457 */
1458 protected function checkAndSetTouched() {
1459 $this->load();
1460
1461 if ( !$this->mId ) {
1462 return false; // anon
1463 }
1464
1465 // Get a new user_touched that is higher than the old one
1466 $oldTouched = $this->mTouched;
1467 $newTouched = $this->newTouchedTimestamp();
1468
1469 $dbw = wfGetDB( DB_MASTER );
1470 $dbw->update( 'user',
1471 array( 'user_touched' => $dbw->timestamp( $newTouched ) ),
1472 array(
1473 'user_id' => $this->mId,
1474 'user_touched' => $dbw->timestamp( $oldTouched ) // CAS check
1475 ),
1476 __METHOD__
1477 );
1478 $success = ( $dbw->affectedRows() > 0 );
1479
1480 if ( $success ) {
1481 $this->mTouched = $newTouched;
1482 }
1483
1484 // Clears on failure too since that is desired if the cache is stale
1485 $this->clearSharedCache();
1486
1487 return $success;
1488 }
1489
1490 /**
1491 * Clear various cached data stored in this object. The cache of the user table
1492 * data (i.e. self::$mCacheVars) is not cleared unless $reloadFrom is given.
1493 *
1494 * @param bool|string $reloadFrom Reload user and user_groups table data from a
1495 * given source. May be "name", "id", "defaults", "session", or false for no reload.
1496 */
1497 public function clearInstanceCache( $reloadFrom = false ) {
1498 $this->mNewtalk = -1;
1499 $this->mDatePreference = null;
1500 $this->mBlockedby = -1; # Unset
1501 $this->mHash = false;
1502 $this->mRights = null;
1503 $this->mEffectiveGroups = null;
1504 $this->mImplicitGroups = null;
1505 $this->mGroups = null;
1506 $this->mOptions = null;
1507 $this->mOptionsLoaded = false;
1508 $this->mEditCount = null;
1509
1510 if ( $reloadFrom ) {
1511 $this->mLoadedItems = array();
1512 $this->mFrom = $reloadFrom;
1513 }
1514 }
1515
1516 /**
1517 * Combine the language default options with any site-specific options
1518 * and add the default language variants.
1519 *
1520 * @return array Array of String options
1521 */
1522 public static function getDefaultOptions() {
1523 global $wgNamespacesToBeSearchedDefault, $wgDefaultUserOptions, $wgContLang, $wgDefaultSkin;
1524
1525 static $defOpt = null;
1526 if ( !defined( 'MW_PHPUNIT_TEST' ) && $defOpt !== null ) {
1527 // Disabling this for the unit tests, as they rely on being able to change $wgContLang
1528 // mid-request and see that change reflected in the return value of this function.
1529 // Which is insane and would never happen during normal MW operation
1530 return $defOpt;
1531 }
1532
1533 $defOpt = $wgDefaultUserOptions;
1534 // Default language setting
1535 $defOpt['language'] = $wgContLang->getCode();
1536 foreach ( LanguageConverter::$languagesWithVariants as $langCode ) {
1537 $defOpt[$langCode == $wgContLang->getCode() ? 'variant' : "variant-$langCode"] = $langCode;
1538 }
1539 foreach ( SearchEngine::searchableNamespaces() as $nsnum => $nsname ) {
1540 $defOpt['searchNs' . $nsnum] = !empty( $wgNamespacesToBeSearchedDefault[$nsnum] );
1541 }
1542 $defOpt['skin'] = Skin::normalizeKey( $wgDefaultSkin );
1543
1544 Hooks::run( 'UserGetDefaultOptions', array( &$defOpt ) );
1545
1546 return $defOpt;
1547 }
1548
1549 /**
1550 * Get a given default option value.
1551 *
1552 * @param string $opt Name of option to retrieve
1553 * @return string Default option value
1554 */
1555 public static function getDefaultOption( $opt ) {
1556 $defOpts = self::getDefaultOptions();
1557 if ( isset( $defOpts[$opt] ) ) {
1558 return $defOpts[$opt];
1559 } else {
1560 return null;
1561 }
1562 }
1563
1564 /**
1565 * Get blocking information
1566 * @param bool $bFromSlave Whether to check the slave database first.
1567 * To improve performance, non-critical checks are done against slaves.
1568 * Check when actually saving should be done against master.
1569 */
1570 private function getBlockedStatus( $bFromSlave = true ) {
1571 global $wgProxyWhitelist, $wgUser, $wgApplyIpBlocksToXff;
1572
1573 if ( -1 != $this->mBlockedby ) {
1574 return;
1575 }
1576
1577 wfDebug( __METHOD__ . ": checking...\n" );
1578
1579 // Initialize data...
1580 // Otherwise something ends up stomping on $this->mBlockedby when
1581 // things get lazy-loaded later, causing false positive block hits
1582 // due to -1 !== 0. Probably session-related... Nothing should be
1583 // overwriting mBlockedby, surely?
1584 $this->load();
1585
1586 # We only need to worry about passing the IP address to the Block generator if the
1587 # user is not immune to autoblocks/hardblocks, and they are the current user so we
1588 # know which IP address they're actually coming from
1589 if ( !$this->isAllowed( 'ipblock-exempt' ) && $this->getID() == $wgUser->getID() ) {
1590 $ip = $this->getRequest()->getIP();
1591 } else {
1592 $ip = null;
1593 }
1594
1595 // User/IP blocking
1596 $block = Block::newFromTarget( $this, $ip, !$bFromSlave );
1597
1598 // Proxy blocking
1599 if ( !$block instanceof Block && $ip !== null && !$this->isAllowed( 'proxyunbannable' )
1600 && !in_array( $ip, $wgProxyWhitelist )
1601 ) {
1602 // Local list
1603 if ( self::isLocallyBlockedProxy( $ip ) ) {
1604 $block = new Block;
1605 $block->setBlocker( wfMessage( 'proxyblocker' )->text() );
1606 $block->mReason = wfMessage( 'proxyblockreason' )->text();
1607 $block->setTarget( $ip );
1608 } elseif ( $this->isAnon() && $this->isDnsBlacklisted( $ip ) ) {
1609 $block = new Block;
1610 $block->setBlocker( wfMessage( 'sorbs' )->text() );
1611 $block->mReason = wfMessage( 'sorbsreason' )->text();
1612 $block->setTarget( $ip );
1613 }
1614 }
1615
1616 // (bug 23343) Apply IP blocks to the contents of XFF headers, if enabled
1617 if ( !$block instanceof Block
1618 && $wgApplyIpBlocksToXff
1619 && $ip !== null
1620 && !$this->isAllowed( 'proxyunbannable' )
1621 && !in_array( $ip, $wgProxyWhitelist )
1622 ) {
1623 $xff = $this->getRequest()->getHeader( 'X-Forwarded-For' );
1624 $xff = array_map( 'trim', explode( ',', $xff ) );
1625 $xff = array_diff( $xff, array( $ip ) );
1626 $xffblocks = Block::getBlocksForIPList( $xff, $this->isAnon(), !$bFromSlave );
1627 $block = Block::chooseBlock( $xffblocks, $xff );
1628 if ( $block instanceof Block ) {
1629 # Mangle the reason to alert the user that the block
1630 # originated from matching the X-Forwarded-For header.
1631 $block->mReason = wfMessage( 'xffblockreason', $block->mReason )->text();
1632 }
1633 }
1634
1635 if ( $block instanceof Block ) {
1636 wfDebug( __METHOD__ . ": Found block.\n" );
1637 $this->mBlock = $block;
1638 $this->mBlockedby = $block->getByName();
1639 $this->mBlockreason = $block->mReason;
1640 $this->mHideName = $block->mHideName;
1641 $this->mAllowUsertalk = !$block->prevents( 'editownusertalk' );
1642 } else {
1643 $this->mBlockedby = '';
1644 $this->mHideName = 0;
1645 $this->mAllowUsertalk = false;
1646 }
1647
1648 // Extensions
1649 Hooks::run( 'GetBlockedStatus', array( &$this ) );
1650
1651 }
1652
1653 /**
1654 * Whether the given IP is in a DNS blacklist.
1655 *
1656 * @param string $ip IP to check
1657 * @param bool $checkWhitelist Whether to check the whitelist first
1658 * @return bool True if blacklisted.
1659 */
1660 public function isDnsBlacklisted( $ip, $checkWhitelist = false ) {
1661 global $wgEnableDnsBlacklist, $wgDnsBlacklistUrls, $wgProxyWhitelist;
1662
1663 if ( !$wgEnableDnsBlacklist ) {
1664 return false;
1665 }
1666
1667 if ( $checkWhitelist && in_array( $ip, $wgProxyWhitelist ) ) {
1668 return false;
1669 }
1670
1671 return $this->inDnsBlacklist( $ip, $wgDnsBlacklistUrls );
1672 }
1673
1674 /**
1675 * Whether the given IP is in a given DNS blacklist.
1676 *
1677 * @param string $ip IP to check
1678 * @param string|array $bases Array of Strings: URL of the DNS blacklist
1679 * @return bool True if blacklisted.
1680 */
1681 public function inDnsBlacklist( $ip, $bases ) {
1682
1683 $found = false;
1684 // @todo FIXME: IPv6 ??? (http://bugs.php.net/bug.php?id=33170)
1685 if ( IP::isIPv4( $ip ) ) {
1686 // Reverse IP, bug 21255
1687 $ipReversed = implode( '.', array_reverse( explode( '.', $ip ) ) );
1688
1689 foreach ( (array)$bases as $base ) {
1690 // Make hostname
1691 // If we have an access key, use that too (ProjectHoneypot, etc.)
1692 if ( is_array( $base ) ) {
1693 if ( count( $base ) >= 2 ) {
1694 // Access key is 1, base URL is 0
1695 $host = "{$base[1]}.$ipReversed.{$base[0]}";
1696 } else {
1697 $host = "$ipReversed.{$base[0]}";
1698 }
1699 } else {
1700 $host = "$ipReversed.$base";
1701 }
1702
1703 // Send query
1704 $ipList = gethostbynamel( $host );
1705
1706 if ( $ipList ) {
1707 wfDebugLog( 'dnsblacklist', "Hostname $host is {$ipList[0]}, it's a proxy says $base!" );
1708 $found = true;
1709 break;
1710 } else {
1711 wfDebugLog( 'dnsblacklist', "Requested $host, not found in $base." );
1712 }
1713 }
1714 }
1715
1716 return $found;
1717 }
1718
1719 /**
1720 * Check if an IP address is in the local proxy list
1721 *
1722 * @param string $ip
1723 *
1724 * @return bool
1725 */
1726 public static function isLocallyBlockedProxy( $ip ) {
1727 global $wgProxyList;
1728
1729 if ( !$wgProxyList ) {
1730 return false;
1731 }
1732
1733 if ( !is_array( $wgProxyList ) ) {
1734 // Load from the specified file
1735 $wgProxyList = array_map( 'trim', file( $wgProxyList ) );
1736 }
1737
1738 if ( !is_array( $wgProxyList ) ) {
1739 $ret = false;
1740 } elseif ( array_search( $ip, $wgProxyList ) !== false ) {
1741 $ret = true;
1742 } elseif ( array_key_exists( $ip, $wgProxyList ) ) {
1743 // Old-style flipped proxy list
1744 $ret = true;
1745 } else {
1746 $ret = false;
1747 }
1748 return $ret;
1749 }
1750
1751 /**
1752 * Is this user subject to rate limiting?
1753 *
1754 * @return bool True if rate limited
1755 */
1756 public function isPingLimitable() {
1757 global $wgRateLimitsExcludedIPs;
1758 if ( in_array( $this->getRequest()->getIP(), $wgRateLimitsExcludedIPs ) ) {
1759 // No other good way currently to disable rate limits
1760 // for specific IPs. :P
1761 // But this is a crappy hack and should die.
1762 return false;
1763 }
1764 return !$this->isAllowed( 'noratelimit' );
1765 }
1766
1767 /**
1768 * Primitive rate limits: enforce maximum actions per time period
1769 * to put a brake on flooding.
1770 *
1771 * The method generates both a generic profiling point and a per action one
1772 * (suffix being "-$action".
1773 *
1774 * @note When using a shared cache like memcached, IP-address
1775 * last-hit counters will be shared across wikis.
1776 *
1777 * @param string $action Action to enforce; 'edit' if unspecified
1778 * @param int $incrBy Positive amount to increment counter by [defaults to 1]
1779 * @return bool True if a rate limiter was tripped
1780 */
1781 public function pingLimiter( $action = 'edit', $incrBy = 1 ) {
1782 // Call the 'PingLimiter' hook
1783 $result = false;
1784 if ( !Hooks::run( 'PingLimiter', array( &$this, $action, &$result, $incrBy ) ) ) {
1785 return $result;
1786 }
1787
1788 global $wgRateLimits;
1789 if ( !isset( $wgRateLimits[$action] ) ) {
1790 return false;
1791 }
1792
1793 // Some groups shouldn't trigger the ping limiter, ever
1794 if ( !$this->isPingLimitable() ) {
1795 return false;
1796 }
1797
1798 global $wgMemc;
1799
1800 $limits = $wgRateLimits[$action];
1801 $keys = array();
1802 $id = $this->getId();
1803 $userLimit = false;
1804
1805 if ( isset( $limits['anon'] ) && $id == 0 ) {
1806 $keys[wfMemcKey( 'limiter', $action, 'anon' )] = $limits['anon'];
1807 }
1808
1809 if ( isset( $limits['user'] ) && $id != 0 ) {
1810 $userLimit = $limits['user'];
1811 }
1812 if ( $this->isNewbie() ) {
1813 if ( isset( $limits['newbie'] ) && $id != 0 ) {
1814 $keys[wfMemcKey( 'limiter', $action, 'user', $id )] = $limits['newbie'];
1815 }
1816 if ( isset( $limits['ip'] ) ) {
1817 $ip = $this->getRequest()->getIP();
1818 $keys["mediawiki:limiter:$action:ip:$ip"] = $limits['ip'];
1819 }
1820 if ( isset( $limits['subnet'] ) ) {
1821 $ip = $this->getRequest()->getIP();
1822 $matches = array();
1823 $subnet = false;
1824 if ( IP::isIPv6( $ip ) ) {
1825 $parts = IP::parseRange( "$ip/64" );
1826 $subnet = $parts[0];
1827 } elseif ( preg_match( '/^(\d+\.\d+\.\d+)\.\d+$/', $ip, $matches ) ) {
1828 // IPv4
1829 $subnet = $matches[1];
1830 }
1831 if ( $subnet !== false ) {
1832 $keys["mediawiki:limiter:$action:subnet:$subnet"] = $limits['subnet'];
1833 }
1834 }
1835 }
1836 // Check for group-specific permissions
1837 // If more than one group applies, use the group with the highest limit
1838 foreach ( $this->getGroups() as $group ) {
1839 if ( isset( $limits[$group] ) ) {
1840 if ( $userLimit === false
1841 || $limits[$group][0] / $limits[$group][1] > $userLimit[0] / $userLimit[1]
1842 ) {
1843 $userLimit = $limits[$group];
1844 }
1845 }
1846 }
1847 // Set the user limit key
1848 if ( $userLimit !== false ) {
1849 list( $max, $period ) = $userLimit;
1850 wfDebug( __METHOD__ . ": effective user limit: $max in {$period}s\n" );
1851 $keys[wfMemcKey( 'limiter', $action, 'user', $id )] = $userLimit;
1852 }
1853
1854 $triggered = false;
1855 foreach ( $keys as $key => $limit ) {
1856 list( $max, $period ) = $limit;
1857 $summary = "(limit $max in {$period}s)";
1858 $count = $wgMemc->get( $key );
1859 // Already pinged?
1860 if ( $count ) {
1861 if ( $count >= $max ) {
1862 wfDebugLog( 'ratelimit', "User '{$this->getName()}' " .
1863 "(IP {$this->getRequest()->getIP()}) tripped $key at $count $summary" );
1864 $triggered = true;
1865 } else {
1866 wfDebug( __METHOD__ . ": ok. $key at $count $summary\n" );
1867 }
1868 } else {
1869 wfDebug( __METHOD__ . ": adding record for $key $summary\n" );
1870 if ( $incrBy > 0 ) {
1871 $wgMemc->add( $key, 0, intval( $period ) ); // first ping
1872 }
1873 }
1874 if ( $incrBy > 0 ) {
1875 $wgMemc->incr( $key, $incrBy );
1876 }
1877 }
1878
1879 return $triggered;
1880 }
1881
1882 /**
1883 * Check if user is blocked
1884 *
1885 * @param bool $bFromSlave Whether to check the slave database instead of
1886 * the master. Hacked from false due to horrible probs on site.
1887 * @return bool True if blocked, false otherwise
1888 */
1889 public function isBlocked( $bFromSlave = true ) {
1890 return $this->getBlock( $bFromSlave ) instanceof Block && $this->getBlock()->prevents( 'edit' );
1891 }
1892
1893 /**
1894 * Get the block affecting the user, or null if the user is not blocked
1895 *
1896 * @param bool $bFromSlave Whether to check the slave database instead of the master
1897 * @return Block|null
1898 */
1899 public function getBlock( $bFromSlave = true ) {
1900 $this->getBlockedStatus( $bFromSlave );
1901 return $this->mBlock instanceof Block ? $this->mBlock : null;
1902 }
1903
1904 /**
1905 * Check if user is blocked from editing a particular article
1906 *
1907 * @param Title $title Title to check
1908 * @param bool $bFromSlave Whether to check the slave database instead of the master
1909 * @return bool
1910 */
1911 public function isBlockedFrom( $title, $bFromSlave = false ) {
1912 global $wgBlockAllowsUTEdit;
1913
1914 $blocked = $this->isBlocked( $bFromSlave );
1915 $allowUsertalk = ( $wgBlockAllowsUTEdit ? $this->mAllowUsertalk : false );
1916 // If a user's name is suppressed, they cannot make edits anywhere
1917 if ( !$this->mHideName && $allowUsertalk && $title->getText() === $this->getName()
1918 && $title->getNamespace() == NS_USER_TALK ) {
1919 $blocked = false;
1920 wfDebug( __METHOD__ . ": self-talk page, ignoring any blocks\n" );
1921 }
1922
1923 Hooks::run( 'UserIsBlockedFrom', array( $this, $title, &$blocked, &$allowUsertalk ) );
1924
1925 return $blocked;
1926 }
1927
1928 /**
1929 * If user is blocked, return the name of the user who placed the block
1930 * @return string Name of blocker
1931 */
1932 public function blockedBy() {
1933 $this->getBlockedStatus();
1934 return $this->mBlockedby;
1935 }
1936
1937 /**
1938 * If user is blocked, return the specified reason for the block
1939 * @return string Blocking reason
1940 */
1941 public function blockedFor() {
1942 $this->getBlockedStatus();
1943 return $this->mBlockreason;
1944 }
1945
1946 /**
1947 * If user is blocked, return the ID for the block
1948 * @return int Block ID
1949 */
1950 public function getBlockId() {
1951 $this->getBlockedStatus();
1952 return ( $this->mBlock ? $this->mBlock->getId() : false );
1953 }
1954
1955 /**
1956 * Check if user is blocked on all wikis.
1957 * Do not use for actual edit permission checks!
1958 * This is intended for quick UI checks.
1959 *
1960 * @param string $ip IP address, uses current client if none given
1961 * @return bool True if blocked, false otherwise
1962 */
1963 public function isBlockedGlobally( $ip = '' ) {
1964 if ( $this->mBlockedGlobally !== null ) {
1965 return $this->mBlockedGlobally;
1966 }
1967 // User is already an IP?
1968 if ( IP::isIPAddress( $this->getName() ) ) {
1969 $ip = $this->getName();
1970 } elseif ( !$ip ) {
1971 $ip = $this->getRequest()->getIP();
1972 }
1973 $blocked = false;
1974 Hooks::run( 'UserIsBlockedGlobally', array( &$this, $ip, &$blocked ) );
1975 $this->mBlockedGlobally = (bool)$blocked;
1976 return $this->mBlockedGlobally;
1977 }
1978
1979 /**
1980 * Check if user account is locked
1981 *
1982 * @return bool True if locked, false otherwise
1983 */
1984 public function isLocked() {
1985 if ( $this->mLocked !== null ) {
1986 return $this->mLocked;
1987 }
1988 global $wgAuth;
1989 $authUser = $wgAuth->getUserInstance( $this );
1990 $this->mLocked = (bool)$authUser->isLocked();
1991 return $this->mLocked;
1992 }
1993
1994 /**
1995 * Check if user account is hidden
1996 *
1997 * @return bool True if hidden, false otherwise
1998 */
1999 public function isHidden() {
2000 if ( $this->mHideName !== null ) {
2001 return $this->mHideName;
2002 }
2003 $this->getBlockedStatus();
2004 if ( !$this->mHideName ) {
2005 global $wgAuth;
2006 $authUser = $wgAuth->getUserInstance( $this );
2007 $this->mHideName = (bool)$authUser->isHidden();
2008 }
2009 return $this->mHideName;
2010 }
2011
2012 /**
2013 * Get the user's ID.
2014 * @return int The user's ID; 0 if the user is anonymous or nonexistent
2015 */
2016 public function getId() {
2017 if ( $this->mId === null && $this->mName !== null && User::isIP( $this->mName ) ) {
2018 // Special case, we know the user is anonymous
2019 return 0;
2020 } elseif ( !$this->isItemLoaded( 'id' ) ) {
2021 // Don't load if this was initialized from an ID
2022 $this->load();
2023 }
2024 return $this->mId;
2025 }
2026
2027 /**
2028 * Set the user and reload all fields according to a given ID
2029 * @param int $v User ID to reload
2030 */
2031 public function setId( $v ) {
2032 $this->mId = $v;
2033 $this->clearInstanceCache( 'id' );
2034 }
2035
2036 /**
2037 * Get the user name, or the IP of an anonymous user
2038 * @return string User's name or IP address
2039 */
2040 public function getName() {
2041 if ( $this->isItemLoaded( 'name', 'only' ) ) {
2042 // Special case optimisation
2043 return $this->mName;
2044 } else {
2045 $this->load();
2046 if ( $this->mName === false ) {
2047 // Clean up IPs
2048 $this->mName = IP::sanitizeIP( $this->getRequest()->getIP() );
2049 }
2050 return $this->mName;
2051 }
2052 }
2053
2054 /**
2055 * Set the user name.
2056 *
2057 * This does not reload fields from the database according to the given
2058 * name. Rather, it is used to create a temporary "nonexistent user" for
2059 * later addition to the database. It can also be used to set the IP
2060 * address for an anonymous user to something other than the current
2061 * remote IP.
2062 *
2063 * @note User::newFromName() has roughly the same function, when the named user
2064 * does not exist.
2065 * @param string $str New user name to set
2066 */
2067 public function setName( $str ) {
2068 $this->load();
2069 $this->mName = $str;
2070 }
2071
2072 /**
2073 * Get the user's name escaped by underscores.
2074 * @return string Username escaped by underscores.
2075 */
2076 public function getTitleKey() {
2077 return str_replace( ' ', '_', $this->getName() );
2078 }
2079
2080 /**
2081 * Check if the user has new messages.
2082 * @return bool True if the user has new messages
2083 */
2084 public function getNewtalk() {
2085 $this->load();
2086
2087 // Load the newtalk status if it is unloaded (mNewtalk=-1)
2088 if ( $this->mNewtalk === -1 ) {
2089 $this->mNewtalk = false; # reset talk page status
2090
2091 // Check memcached separately for anons, who have no
2092 // entire User object stored in there.
2093 if ( !$this->mId ) {
2094 global $wgDisableAnonTalk;
2095 if ( $wgDisableAnonTalk ) {
2096 // Anon newtalk disabled by configuration.
2097 $this->mNewtalk = false;
2098 } else {
2099 $this->mNewtalk = $this->checkNewtalk( 'user_ip', $this->getName() );
2100 }
2101 } else {
2102 $this->mNewtalk = $this->checkNewtalk( 'user_id', $this->mId );
2103 }
2104 }
2105
2106 return (bool)$this->mNewtalk;
2107 }
2108
2109 /**
2110 * Return the data needed to construct links for new talk page message
2111 * alerts. If there are new messages, this will return an associative array
2112 * with the following data:
2113 * wiki: The database name of the wiki
2114 * link: Root-relative link to the user's talk page
2115 * rev: The last talk page revision that the user has seen or null. This
2116 * is useful for building diff links.
2117 * If there are no new messages, it returns an empty array.
2118 * @note This function was designed to accomodate multiple talk pages, but
2119 * currently only returns a single link and revision.
2120 * @return array
2121 */
2122 public function getNewMessageLinks() {
2123 $talks = array();
2124 if ( !Hooks::run( 'UserRetrieveNewTalks', array( &$this, &$talks ) ) ) {
2125 return $talks;
2126 } elseif ( !$this->getNewtalk() ) {
2127 return array();
2128 }
2129 $utp = $this->getTalkPage();
2130 $dbr = wfGetDB( DB_SLAVE );
2131 // Get the "last viewed rev" timestamp from the oldest message notification
2132 $timestamp = $dbr->selectField( 'user_newtalk',
2133 'MIN(user_last_timestamp)',
2134 $this->isAnon() ? array( 'user_ip' => $this->getName() ) : array( 'user_id' => $this->getID() ),
2135 __METHOD__ );
2136 $rev = $timestamp ? Revision::loadFromTimestamp( $dbr, $utp, $timestamp ) : null;
2137 return array( array( 'wiki' => wfWikiID(), 'link' => $utp->getLocalURL(), 'rev' => $rev ) );
2138 }
2139
2140 /**
2141 * Get the revision ID for the last talk page revision viewed by the talk
2142 * page owner.
2143 * @return int|null Revision ID or null
2144 */
2145 public function getNewMessageRevisionId() {
2146 $newMessageRevisionId = null;
2147 $newMessageLinks = $this->getNewMessageLinks();
2148 if ( $newMessageLinks ) {
2149 // Note: getNewMessageLinks() never returns more than a single link
2150 // and it is always for the same wiki, but we double-check here in
2151 // case that changes some time in the future.
2152 if ( count( $newMessageLinks ) === 1
2153 && $newMessageLinks[0]['wiki'] === wfWikiID()
2154 && $newMessageLinks[0]['rev']
2155 ) {
2156 /** @var Revision $newMessageRevision */
2157 $newMessageRevision = $newMessageLinks[0]['rev'];
2158 $newMessageRevisionId = $newMessageRevision->getId();
2159 }
2160 }
2161 return $newMessageRevisionId;
2162 }
2163
2164 /**
2165 * Internal uncached check for new messages
2166 *
2167 * @see getNewtalk()
2168 * @param string $field 'user_ip' for anonymous users, 'user_id' otherwise
2169 * @param string|int $id User's IP address for anonymous users, User ID otherwise
2170 * @return bool True if the user has new messages
2171 */
2172 protected function checkNewtalk( $field, $id ) {
2173 $dbr = wfGetDB( DB_SLAVE );
2174
2175 $ok = $dbr->selectField( 'user_newtalk', $field, array( $field => $id ), __METHOD__ );
2176
2177 return $ok !== false;
2178 }
2179
2180 /**
2181 * Add or update the new messages flag
2182 * @param string $field 'user_ip' for anonymous users, 'user_id' otherwise
2183 * @param string|int $id User's IP address for anonymous users, User ID otherwise
2184 * @param Revision|null $curRev New, as yet unseen revision of the user talk page. Ignored if null.
2185 * @return bool True if successful, false otherwise
2186 */
2187 protected function updateNewtalk( $field, $id, $curRev = null ) {
2188 // Get timestamp of the talk page revision prior to the current one
2189 $prevRev = $curRev ? $curRev->getPrevious() : false;
2190 $ts = $prevRev ? $prevRev->getTimestamp() : null;
2191 // Mark the user as having new messages since this revision
2192 $dbw = wfGetDB( DB_MASTER );
2193 $dbw->insert( 'user_newtalk',
2194 array( $field => $id, 'user_last_timestamp' => $dbw->timestampOrNull( $ts ) ),
2195 __METHOD__,
2196 'IGNORE' );
2197 if ( $dbw->affectedRows() ) {
2198 wfDebug( __METHOD__ . ": set on ($field, $id)\n" );
2199 return true;
2200 } else {
2201 wfDebug( __METHOD__ . " already set ($field, $id)\n" );
2202 return false;
2203 }
2204 }
2205
2206 /**
2207 * Clear the new messages flag for the given user
2208 * @param string $field 'user_ip' for anonymous users, 'user_id' otherwise
2209 * @param string|int $id User's IP address for anonymous users, User ID otherwise
2210 * @return bool True if successful, false otherwise
2211 */
2212 protected function deleteNewtalk( $field, $id ) {
2213 $dbw = wfGetDB( DB_MASTER );
2214 $dbw->delete( 'user_newtalk',
2215 array( $field => $id ),
2216 __METHOD__ );
2217 if ( $dbw->affectedRows() ) {
2218 wfDebug( __METHOD__ . ": killed on ($field, $id)\n" );
2219 return true;
2220 } else {
2221 wfDebug( __METHOD__ . ": already gone ($field, $id)\n" );
2222 return false;
2223 }
2224 }
2225
2226 /**
2227 * Update the 'You have new messages!' status.
2228 * @param bool $val Whether the user has new messages
2229 * @param Revision $curRev New, as yet unseen revision of the user talk
2230 * page. Ignored if null or !$val.
2231 */
2232 public function setNewtalk( $val, $curRev = null ) {
2233 if ( wfReadOnly() ) {
2234 return;
2235 }
2236
2237 $this->load();
2238 $this->mNewtalk = $val;
2239
2240 if ( $this->isAnon() ) {
2241 $field = 'user_ip';
2242 $id = $this->getName();
2243 } else {
2244 $field = 'user_id';
2245 $id = $this->getId();
2246 }
2247
2248 if ( $val ) {
2249 $changed = $this->updateNewtalk( $field, $id, $curRev );
2250 } else {
2251 $changed = $this->deleteNewtalk( $field, $id );
2252 }
2253
2254 if ( $changed ) {
2255 $this->invalidateCache();
2256 }
2257 }
2258
2259 /**
2260 * Generate a current or new-future timestamp to be stored in the
2261 * user_touched field when we update things.
2262 * @return string Timestamp in TS_MW format
2263 */
2264 private function newTouchedTimestamp() {
2265 global $wgClockSkewFudge;
2266
2267 $time = wfTimestamp( TS_MW, time() + $wgClockSkewFudge );
2268 if ( $this->mTouched && $time <= $this->mTouched ) {
2269 $time = wfTimestamp( TS_MW, wfTimestamp( TS_UNIX, $this->mTouched ) + 1 );
2270 }
2271
2272 return $time;
2273 }
2274
2275 /**
2276 * Clear user data from memcached.
2277 * Use after applying fun updates to the database; caller's
2278 * responsibility to update user_touched if appropriate.
2279 *
2280 * Called implicitly from invalidateCache() and saveSettings().
2281 */
2282 public function clearSharedCache() {
2283 $id = $this->getId();
2284 if ( $id ) {
2285 $key = wfMemcKey( 'user', 'id', $id );
2286 ObjectCache::getMainWANInstance()->delete( $key );
2287 }
2288 }
2289
2290 /**
2291 * Immediately touch the user data cache for this account
2292 *
2293 * Calls touch() and removes account data from memcached
2294 */
2295 public function invalidateCache() {
2296 $this->touch();
2297 $this->clearSharedCache();
2298 }
2299
2300 /**
2301 * Update the "touched" timestamp for the user
2302 *
2303 * This is useful on various login/logout events when making sure that
2304 * a browser or proxy that has multiple tenants does not suffer cache
2305 * pollution where the new user sees the old users content. The value
2306 * of getTouched() is checked when determining 304 vs 200 responses.
2307 * Unlike invalidateCache(), this preserves the User object cache and
2308 * avoids database writes.
2309 *
2310 * @since 1.25
2311 */
2312 public function touch() {
2313 $id = $this->getId();
2314 if ( $id ) {
2315 $key = wfMemcKey( 'user-quicktouched', 'id', $id );
2316 ObjectCache::getMainWANInstance()->touchCheckKey( $key );
2317 $this->mQuickTouched = null;
2318 }
2319 }
2320
2321 /**
2322 * Validate the cache for this account.
2323 * @param string $timestamp A timestamp in TS_MW format
2324 * @return bool
2325 */
2326 public function validateCache( $timestamp ) {
2327 return ( $timestamp >= $this->getTouched() );
2328 }
2329
2330 /**
2331 * Get the user touched timestamp
2332 *
2333 * Use this value only to validate caches via inequalities
2334 * such as in the case of HTTP If-Modified-Since response logic
2335 *
2336 * @return string TS_MW Timestamp
2337 */
2338 public function getTouched() {
2339 $this->load();
2340
2341 if ( $this->mId ) {
2342 if ( $this->mQuickTouched === null ) {
2343 $key = wfMemcKey( 'user-quicktouched', 'id', $this->mId );
2344 $cache = ObjectCache::getMainWANInstance();
2345
2346 $this->mQuickTouched = wfTimestamp( TS_MW, $cache->getCheckKeyTime( $key ) );
2347 }
2348
2349 return max( $this->mTouched, $this->mQuickTouched );
2350 }
2351
2352 return $this->mTouched;
2353 }
2354
2355 /**
2356 * Get the user_touched timestamp field (time of last DB updates)
2357 * @return string TS_MW Timestamp
2358 * @since 1.26
2359 */
2360 public function getDBTouched() {
2361 $this->load();
2362
2363 return $this->mTouched;
2364 }
2365
2366 /**
2367 * @return Password
2368 * @since 1.24
2369 */
2370 public function getPassword() {
2371 $this->loadPasswords();
2372
2373 return $this->mPassword;
2374 }
2375
2376 /**
2377 * @return Password
2378 * @since 1.24
2379 */
2380 public function getTemporaryPassword() {
2381 $this->loadPasswords();
2382
2383 return $this->mNewpassword;
2384 }
2385
2386 /**
2387 * Set the password and reset the random token.
2388 * Calls through to authentication plugin if necessary;
2389 * will have no effect if the auth plugin refuses to
2390 * pass the change through or if the legal password
2391 * checks fail.
2392 *
2393 * As a special case, setting the password to null
2394 * wipes it, so the account cannot be logged in until
2395 * a new password is set, for instance via e-mail.
2396 *
2397 * @param string $str New password to set
2398 * @throws PasswordError On failure
2399 *
2400 * @return bool
2401 */
2402 public function setPassword( $str ) {
2403 global $wgAuth;
2404
2405 $this->loadPasswords();
2406
2407 if ( $str !== null ) {
2408 if ( !$wgAuth->allowPasswordChange() ) {
2409 throw new PasswordError( wfMessage( 'password-change-forbidden' )->text() );
2410 }
2411
2412 $status = $this->checkPasswordValidity( $str );
2413 if ( !$status->isGood() ) {
2414 throw new PasswordError( $status->getMessage()->text() );
2415 }
2416 }
2417
2418 if ( !$wgAuth->setPassword( $this, $str ) ) {
2419 throw new PasswordError( wfMessage( 'externaldberror' )->text() );
2420 }
2421
2422 $this->setInternalPassword( $str );
2423
2424 return true;
2425 }
2426
2427 /**
2428 * Set the password and reset the random token unconditionally.
2429 *
2430 * @param string|null $str New password to set or null to set an invalid
2431 * password hash meaning that the user will not be able to log in
2432 * through the web interface.
2433 */
2434 public function setInternalPassword( $str ) {
2435 $this->setToken();
2436
2437 $passwordFactory = self::getPasswordFactory();
2438 $this->mPassword = $passwordFactory->newFromPlaintext( $str );
2439
2440 $this->mNewpassword = $passwordFactory->newFromCiphertext( null );
2441 $this->mNewpassTime = null;
2442 }
2443
2444 /**
2445 * Get the user's current token.
2446 * @param bool $forceCreation Force the generation of a new token if the
2447 * user doesn't have one (default=true for backwards compatibility).
2448 * @return string Token
2449 */
2450 public function getToken( $forceCreation = true ) {
2451 $this->load();
2452 if ( !$this->mToken && $forceCreation ) {
2453 $this->setToken();
2454 }
2455 return $this->mToken;
2456 }
2457
2458 /**
2459 * Set the random token (used for persistent authentication)
2460 * Called from loadDefaults() among other places.
2461 *
2462 * @param string|bool $token If specified, set the token to this value
2463 */
2464 public function setToken( $token = false ) {
2465 $this->load();
2466 if ( !$token ) {
2467 $this->mToken = MWCryptRand::generateHex( self::TOKEN_LENGTH );
2468 } else {
2469 $this->mToken = $token;
2470 }
2471 }
2472
2473 /**
2474 * Set the password for a password reminder or new account email
2475 *
2476 * @param string $str New password to set or null to set an invalid
2477 * password hash meaning that the user will not be able to use it
2478 * @param bool $throttle If true, reset the throttle timestamp to the present
2479 */
2480 public function setNewpassword( $str, $throttle = true ) {
2481 $this->loadPasswords();
2482
2483 $this->mNewpassword = self::getPasswordFactory()->newFromPlaintext( $str );
2484 if ( $str === null ) {
2485 $this->mNewpassTime = null;
2486 } elseif ( $throttle ) {
2487 $this->mNewpassTime = wfTimestampNow();
2488 }
2489 }
2490
2491 /**
2492 * Has password reminder email been sent within the last
2493 * $wgPasswordReminderResendTime hours?
2494 * @return bool
2495 */
2496 public function isPasswordReminderThrottled() {
2497 global $wgPasswordReminderResendTime;
2498 $this->load();
2499 if ( !$this->mNewpassTime || !$wgPasswordReminderResendTime ) {
2500 return false;
2501 }
2502 $expiry = wfTimestamp( TS_UNIX, $this->mNewpassTime ) + $wgPasswordReminderResendTime * 3600;
2503 return time() < $expiry;
2504 }
2505
2506 /**
2507 * Get the user's e-mail address
2508 * @return string User's email address
2509 */
2510 public function getEmail() {
2511 $this->load();
2512 Hooks::run( 'UserGetEmail', array( $this, &$this->mEmail ) );
2513 return $this->mEmail;
2514 }
2515
2516 /**
2517 * Get the timestamp of the user's e-mail authentication
2518 * @return string TS_MW timestamp
2519 */
2520 public function getEmailAuthenticationTimestamp() {
2521 $this->load();
2522 Hooks::run( 'UserGetEmailAuthenticationTimestamp', array( $this, &$this->mEmailAuthenticated ) );
2523 return $this->mEmailAuthenticated;
2524 }
2525
2526 /**
2527 * Set the user's e-mail address
2528 * @param string $str New e-mail address
2529 */
2530 public function setEmail( $str ) {
2531 $this->load();
2532 if ( $str == $this->mEmail ) {
2533 return;
2534 }
2535 $this->invalidateEmail();
2536 $this->mEmail = $str;
2537 Hooks::run( 'UserSetEmail', array( $this, &$this->mEmail ) );
2538 }
2539
2540 /**
2541 * Set the user's e-mail address and a confirmation mail if needed.
2542 *
2543 * @since 1.20
2544 * @param string $str New e-mail address
2545 * @return Status
2546 */
2547 public function setEmailWithConfirmation( $str ) {
2548 global $wgEnableEmail, $wgEmailAuthentication;
2549
2550 if ( !$wgEnableEmail ) {
2551 return Status::newFatal( 'emaildisabled' );
2552 }
2553
2554 $oldaddr = $this->getEmail();
2555 if ( $str === $oldaddr ) {
2556 return Status::newGood( true );
2557 }
2558
2559 $this->setEmail( $str );
2560
2561 if ( $str !== '' && $wgEmailAuthentication ) {
2562 // Send a confirmation request to the new address if needed
2563 $type = $oldaddr != '' ? 'changed' : 'set';
2564 $result = $this->sendConfirmationMail( $type );
2565 if ( $result->isGood() ) {
2566 // Say to the caller that a confirmation mail has been sent
2567 $result->value = 'eauth';
2568 }
2569 } else {
2570 $result = Status::newGood( true );
2571 }
2572
2573 return $result;
2574 }
2575
2576 /**
2577 * Get the user's real name
2578 * @return string User's real name
2579 */
2580 public function getRealName() {
2581 if ( !$this->isItemLoaded( 'realname' ) ) {
2582 $this->load();
2583 }
2584
2585 return $this->mRealName;
2586 }
2587
2588 /**
2589 * Set the user's real name
2590 * @param string $str New real name
2591 */
2592 public function setRealName( $str ) {
2593 $this->load();
2594 $this->mRealName = $str;
2595 }
2596
2597 /**
2598 * Get the user's current setting for a given option.
2599 *
2600 * @param string $oname The option to check
2601 * @param string $defaultOverride A default value returned if the option does not exist
2602 * @param bool $ignoreHidden Whether to ignore the effects of $wgHiddenPrefs
2603 * @return string User's current value for the option
2604 * @see getBoolOption()
2605 * @see getIntOption()
2606 */
2607 public function getOption( $oname, $defaultOverride = null, $ignoreHidden = false ) {
2608 global $wgHiddenPrefs;
2609 $this->loadOptions();
2610
2611 # We want 'disabled' preferences to always behave as the default value for
2612 # users, even if they have set the option explicitly in their settings (ie they
2613 # set it, and then it was disabled removing their ability to change it). But
2614 # we don't want to erase the preferences in the database in case the preference
2615 # is re-enabled again. So don't touch $mOptions, just override the returned value
2616 if ( !$ignoreHidden && in_array( $oname, $wgHiddenPrefs ) ) {
2617 return self::getDefaultOption( $oname );
2618 }
2619
2620 if ( array_key_exists( $oname, $this->mOptions ) ) {
2621 return $this->mOptions[$oname];
2622 } else {
2623 return $defaultOverride;
2624 }
2625 }
2626
2627 /**
2628 * Get all user's options
2629 *
2630 * @param int $flags Bitwise combination of:
2631 * User::GETOPTIONS_EXCLUDE_DEFAULTS Exclude user options that are set
2632 * to the default value. (Since 1.25)
2633 * @return array
2634 */
2635 public function getOptions( $flags = 0 ) {
2636 global $wgHiddenPrefs;
2637 $this->loadOptions();
2638 $options = $this->mOptions;
2639
2640 # We want 'disabled' preferences to always behave as the default value for
2641 # users, even if they have set the option explicitly in their settings (ie they
2642 # set it, and then it was disabled removing their ability to change it). But
2643 # we don't want to erase the preferences in the database in case the preference
2644 # is re-enabled again. So don't touch $mOptions, just override the returned value
2645 foreach ( $wgHiddenPrefs as $pref ) {
2646 $default = self::getDefaultOption( $pref );
2647 if ( $default !== null ) {
2648 $options[$pref] = $default;
2649 }
2650 }
2651
2652 if ( $flags & self::GETOPTIONS_EXCLUDE_DEFAULTS ) {
2653 $options = array_diff_assoc( $options, self::getDefaultOptions() );
2654 }
2655
2656 return $options;
2657 }
2658
2659 /**
2660 * Get the user's current setting for a given option, as a boolean value.
2661 *
2662 * @param string $oname The option to check
2663 * @return bool User's current value for the option
2664 * @see getOption()
2665 */
2666 public function getBoolOption( $oname ) {
2667 return (bool)$this->getOption( $oname );
2668 }
2669
2670 /**
2671 * Get the user's current setting for a given option, as an integer value.
2672 *
2673 * @param string $oname The option to check
2674 * @param int $defaultOverride A default value returned if the option does not exist
2675 * @return int User's current value for the option
2676 * @see getOption()
2677 */
2678 public function getIntOption( $oname, $defaultOverride = 0 ) {
2679 $val = $this->getOption( $oname );
2680 if ( $val == '' ) {
2681 $val = $defaultOverride;
2682 }
2683 return intval( $val );
2684 }
2685
2686 /**
2687 * Set the given option for a user.
2688 *
2689 * You need to call saveSettings() to actually write to the database.
2690 *
2691 * @param string $oname The option to set
2692 * @param mixed $val New value to set
2693 */
2694 public function setOption( $oname, $val ) {
2695 $this->loadOptions();
2696
2697 // Explicitly NULL values should refer to defaults
2698 if ( is_null( $val ) ) {
2699 $val = self::getDefaultOption( $oname );
2700 }
2701
2702 $this->mOptions[$oname] = $val;
2703 }
2704
2705 /**
2706 * Get a token stored in the preferences (like the watchlist one),
2707 * resetting it if it's empty (and saving changes).
2708 *
2709 * @param string $oname The option name to retrieve the token from
2710 * @return string|bool User's current value for the option, or false if this option is disabled.
2711 * @see resetTokenFromOption()
2712 * @see getOption()
2713 */
2714 public function getTokenFromOption( $oname ) {
2715 global $wgHiddenPrefs;
2716 if ( in_array( $oname, $wgHiddenPrefs ) ) {
2717 return false;
2718 }
2719
2720 $token = $this->getOption( $oname );
2721 if ( !$token ) {
2722 $token = $this->resetTokenFromOption( $oname );
2723 if ( !wfReadOnly() ) {
2724 $this->saveSettings();
2725 }
2726 }
2727 return $token;
2728 }
2729
2730 /**
2731 * Reset a token stored in the preferences (like the watchlist one).
2732 * *Does not* save user's preferences (similarly to setOption()).
2733 *
2734 * @param string $oname The option name to reset the token in
2735 * @return string|bool New token value, or false if this option is disabled.
2736 * @see getTokenFromOption()
2737 * @see setOption()
2738 */
2739 public function resetTokenFromOption( $oname ) {
2740 global $wgHiddenPrefs;
2741 if ( in_array( $oname, $wgHiddenPrefs ) ) {
2742 return false;
2743 }
2744
2745 $token = MWCryptRand::generateHex( 40 );
2746 $this->setOption( $oname, $token );
2747 return $token;
2748 }
2749
2750 /**
2751 * Return a list of the types of user options currently returned by
2752 * User::getOptionKinds().
2753 *
2754 * Currently, the option kinds are:
2755 * - 'registered' - preferences which are registered in core MediaWiki or
2756 * by extensions using the UserGetDefaultOptions hook.
2757 * - 'registered-multiselect' - as above, using the 'multiselect' type.
2758 * - 'registered-checkmatrix' - as above, using the 'checkmatrix' type.
2759 * - 'userjs' - preferences with names starting with 'userjs-', intended to
2760 * be used by user scripts.
2761 * - 'special' - "preferences" that are not accessible via User::getOptions
2762 * or User::setOptions.
2763 * - 'unused' - preferences about which MediaWiki doesn't know anything.
2764 * These are usually legacy options, removed in newer versions.
2765 *
2766 * The API (and possibly others) use this function to determine the possible
2767 * option types for validation purposes, so make sure to update this when a
2768 * new option kind is added.
2769 *
2770 * @see User::getOptionKinds
2771 * @return array Option kinds
2772 */
2773 public static function listOptionKinds() {
2774 return array(
2775 'registered',
2776 'registered-multiselect',
2777 'registered-checkmatrix',
2778 'userjs',
2779 'special',
2780 'unused'
2781 );
2782 }
2783
2784 /**
2785 * Return an associative array mapping preferences keys to the kind of a preference they're
2786 * used for. Different kinds are handled differently when setting or reading preferences.
2787 *
2788 * See User::listOptionKinds for the list of valid option types that can be provided.
2789 *
2790 * @see User::listOptionKinds
2791 * @param IContextSource $context
2792 * @param array $options Assoc. array with options keys to check as keys.
2793 * Defaults to $this->mOptions.
2794 * @return array The key => kind mapping data
2795 */
2796 public function getOptionKinds( IContextSource $context, $options = null ) {
2797 $this->loadOptions();
2798 if ( $options === null ) {
2799 $options = $this->mOptions;
2800 }
2801
2802 $prefs = Preferences::getPreferences( $this, $context );
2803 $mapping = array();
2804
2805 // Pull out the "special" options, so they don't get converted as
2806 // multiselect or checkmatrix.
2807 $specialOptions = array_fill_keys( Preferences::getSaveBlacklist(), true );
2808 foreach ( $specialOptions as $name => $value ) {
2809 unset( $prefs[$name] );
2810 }
2811
2812 // Multiselect and checkmatrix options are stored in the database with
2813 // one key per option, each having a boolean value. Extract those keys.
2814 $multiselectOptions = array();
2815 foreach ( $prefs as $name => $info ) {
2816 if ( ( isset( $info['type'] ) && $info['type'] == 'multiselect' ) ||
2817 ( isset( $info['class'] ) && $info['class'] == 'HTMLMultiSelectField' ) ) {
2818 $opts = HTMLFormField::flattenOptions( $info['options'] );
2819 $prefix = isset( $info['prefix'] ) ? $info['prefix'] : $name;
2820
2821 foreach ( $opts as $value ) {
2822 $multiselectOptions["$prefix$value"] = true;
2823 }
2824
2825 unset( $prefs[$name] );
2826 }
2827 }
2828 $checkmatrixOptions = array();
2829 foreach ( $prefs as $name => $info ) {
2830 if ( ( isset( $info['type'] ) && $info['type'] == 'checkmatrix' ) ||
2831 ( isset( $info['class'] ) && $info['class'] == 'HTMLCheckMatrix' ) ) {
2832 $columns = HTMLFormField::flattenOptions( $info['columns'] );
2833 $rows = HTMLFormField::flattenOptions( $info['rows'] );
2834 $prefix = isset( $info['prefix'] ) ? $info['prefix'] : $name;
2835
2836 foreach ( $columns as $column ) {
2837 foreach ( $rows as $row ) {
2838 $checkmatrixOptions["$prefix$column-$row"] = true;
2839 }
2840 }
2841
2842 unset( $prefs[$name] );
2843 }
2844 }
2845
2846 // $value is ignored
2847 foreach ( $options as $key => $value ) {
2848 if ( isset( $prefs[$key] ) ) {
2849 $mapping[$key] = 'registered';
2850 } elseif ( isset( $multiselectOptions[$key] ) ) {
2851 $mapping[$key] = 'registered-multiselect';
2852 } elseif ( isset( $checkmatrixOptions[$key] ) ) {
2853 $mapping[$key] = 'registered-checkmatrix';
2854 } elseif ( isset( $specialOptions[$key] ) ) {
2855 $mapping[$key] = 'special';
2856 } elseif ( substr( $key, 0, 7 ) === 'userjs-' ) {
2857 $mapping[$key] = 'userjs';
2858 } else {
2859 $mapping[$key] = 'unused';
2860 }
2861 }
2862
2863 return $mapping;
2864 }
2865
2866 /**
2867 * Reset certain (or all) options to the site defaults
2868 *
2869 * The optional parameter determines which kinds of preferences will be reset.
2870 * Supported values are everything that can be reported by getOptionKinds()
2871 * and 'all', which forces a reset of *all* preferences and overrides everything else.
2872 *
2873 * @param array|string $resetKinds Which kinds of preferences to reset. Defaults to
2874 * array( 'registered', 'registered-multiselect', 'registered-checkmatrix', 'unused' )
2875 * for backwards-compatibility.
2876 * @param IContextSource|null $context Context source used when $resetKinds
2877 * does not contain 'all', passed to getOptionKinds().
2878 * Defaults to RequestContext::getMain() when null.
2879 */
2880 public function resetOptions(
2881 $resetKinds = array( 'registered', 'registered-multiselect', 'registered-checkmatrix', 'unused' ),
2882 IContextSource $context = null
2883 ) {
2884 $this->load();
2885 $defaultOptions = self::getDefaultOptions();
2886
2887 if ( !is_array( $resetKinds ) ) {
2888 $resetKinds = array( $resetKinds );
2889 }
2890
2891 if ( in_array( 'all', $resetKinds ) ) {
2892 $newOptions = $defaultOptions;
2893 } else {
2894 if ( $context === null ) {
2895 $context = RequestContext::getMain();
2896 }
2897
2898 $optionKinds = $this->getOptionKinds( $context );
2899 $resetKinds = array_intersect( $resetKinds, self::listOptionKinds() );
2900 $newOptions = array();
2901
2902 // Use default values for the options that should be deleted, and
2903 // copy old values for the ones that shouldn't.
2904 foreach ( $this->mOptions as $key => $value ) {
2905 if ( in_array( $optionKinds[$key], $resetKinds ) ) {
2906 if ( array_key_exists( $key, $defaultOptions ) ) {
2907 $newOptions[$key] = $defaultOptions[$key];
2908 }
2909 } else {
2910 $newOptions[$key] = $value;
2911 }
2912 }
2913 }
2914
2915 Hooks::run( 'UserResetAllOptions', array( $this, &$newOptions, $this->mOptions, $resetKinds ) );
2916
2917 $this->mOptions = $newOptions;
2918 $this->mOptionsLoaded = true;
2919 }
2920
2921 /**
2922 * Get the user's preferred date format.
2923 * @return string User's preferred date format
2924 */
2925 public function getDatePreference() {
2926 // Important migration for old data rows
2927 if ( is_null( $this->mDatePreference ) ) {
2928 global $wgLang;
2929 $value = $this->getOption( 'date' );
2930 $map = $wgLang->getDatePreferenceMigrationMap();
2931 if ( isset( $map[$value] ) ) {
2932 $value = $map[$value];
2933 }
2934 $this->mDatePreference = $value;
2935 }
2936 return $this->mDatePreference;
2937 }
2938
2939 /**
2940 * Determine based on the wiki configuration and the user's options,
2941 * whether this user must be over HTTPS no matter what.
2942 *
2943 * @return bool
2944 */
2945 public function requiresHTTPS() {
2946 global $wgSecureLogin;
2947 if ( !$wgSecureLogin ) {
2948 return false;
2949 } else {
2950 $https = $this->getBoolOption( 'prefershttps' );
2951 Hooks::run( 'UserRequiresHTTPS', array( $this, &$https ) );
2952 if ( $https ) {
2953 $https = wfCanIPUseHTTPS( $this->getRequest()->getIP() );
2954 }
2955 return $https;
2956 }
2957 }
2958
2959 /**
2960 * Get the user preferred stub threshold
2961 *
2962 * @return int
2963 */
2964 public function getStubThreshold() {
2965 global $wgMaxArticleSize; # Maximum article size, in Kb
2966 $threshold = $this->getIntOption( 'stubthreshold' );
2967 if ( $threshold > $wgMaxArticleSize * 1024 ) {
2968 // If they have set an impossible value, disable the preference
2969 // so we can use the parser cache again.
2970 $threshold = 0;
2971 }
2972 return $threshold;
2973 }
2974
2975 /**
2976 * Get the permissions this user has.
2977 * @return array Array of String permission names
2978 */
2979 public function getRights() {
2980 if ( is_null( $this->mRights ) ) {
2981 $this->mRights = self::getGroupPermissions( $this->getEffectiveGroups() );
2982 Hooks::run( 'UserGetRights', array( $this, &$this->mRights ) );
2983 // Force reindexation of rights when a hook has unset one of them
2984 $this->mRights = array_values( array_unique( $this->mRights ) );
2985 }
2986 return $this->mRights;
2987 }
2988
2989 /**
2990 * Get the list of explicit group memberships this user has.
2991 * The implicit * and user groups are not included.
2992 * @return array Array of String internal group names
2993 */
2994 public function getGroups() {
2995 $this->load();
2996 $this->loadGroups();
2997 return $this->mGroups;
2998 }
2999
3000 /**
3001 * Get the list of implicit group memberships this user has.
3002 * This includes all explicit groups, plus 'user' if logged in,
3003 * '*' for all accounts, and autopromoted groups
3004 * @param bool $recache Whether to avoid the cache
3005 * @return array Array of String internal group names
3006 */
3007 public function getEffectiveGroups( $recache = false ) {
3008 if ( $recache || is_null( $this->mEffectiveGroups ) ) {
3009 $this->mEffectiveGroups = array_unique( array_merge(
3010 $this->getGroups(), // explicit groups
3011 $this->getAutomaticGroups( $recache ) // implicit groups
3012 ) );
3013 // Hook for additional groups
3014 Hooks::run( 'UserEffectiveGroups', array( &$this, &$this->mEffectiveGroups ) );
3015 // Force reindexation of groups when a hook has unset one of them
3016 $this->mEffectiveGroups = array_values( array_unique( $this->mEffectiveGroups ) );
3017 }
3018 return $this->mEffectiveGroups;
3019 }
3020
3021 /**
3022 * Get the list of implicit group memberships this user has.
3023 * This includes 'user' if logged in, '*' for all accounts,
3024 * and autopromoted groups
3025 * @param bool $recache Whether to avoid the cache
3026 * @return array Array of String internal group names
3027 */
3028 public function getAutomaticGroups( $recache = false ) {
3029 if ( $recache || is_null( $this->mImplicitGroups ) ) {
3030 $this->mImplicitGroups = array( '*' );
3031 if ( $this->getId() ) {
3032 $this->mImplicitGroups[] = 'user';
3033
3034 $this->mImplicitGroups = array_unique( array_merge(
3035 $this->mImplicitGroups,
3036 Autopromote::getAutopromoteGroups( $this )
3037 ) );
3038 }
3039 if ( $recache ) {
3040 // Assure data consistency with rights/groups,
3041 // as getEffectiveGroups() depends on this function
3042 $this->mEffectiveGroups = null;
3043 }
3044 }
3045 return $this->mImplicitGroups;
3046 }
3047
3048 /**
3049 * Returns the groups the user has belonged to.
3050 *
3051 * The user may still belong to the returned groups. Compare with getGroups().
3052 *
3053 * The function will not return groups the user had belonged to before MW 1.17
3054 *
3055 * @return array Names of the groups the user has belonged to.
3056 */
3057 public function getFormerGroups() {
3058 $this->load();
3059
3060 if ( is_null( $this->mFormerGroups ) ) {
3061 $db = ( $this->queryFlagsUsed & self::READ_LATEST )
3062 ? wfGetDB( DB_MASTER )
3063 : wfGetDB( DB_SLAVE );
3064 $res = $db->select( 'user_former_groups',
3065 array( 'ufg_group' ),
3066 array( 'ufg_user' => $this->mId ),
3067 __METHOD__ );
3068 $this->mFormerGroups = array();
3069 foreach ( $res as $row ) {
3070 $this->mFormerGroups[] = $row->ufg_group;
3071 }
3072 }
3073
3074 return $this->mFormerGroups;
3075 }
3076
3077 /**
3078 * Get the user's edit count.
3079 * @return int|null Null for anonymous users
3080 */
3081 public function getEditCount() {
3082 if ( !$this->getId() ) {
3083 return null;
3084 }
3085
3086 if ( $this->mEditCount === null ) {
3087 /* Populate the count, if it has not been populated yet */
3088 $dbr = wfGetDB( DB_SLAVE );
3089 // check if the user_editcount field has been initialized
3090 $count = $dbr->selectField(
3091 'user', 'user_editcount',
3092 array( 'user_id' => $this->mId ),
3093 __METHOD__
3094 );
3095
3096 if ( $count === null ) {
3097 // it has not been initialized. do so.
3098 $count = $this->initEditCount();
3099 }
3100 $this->mEditCount = $count;
3101 }
3102 return (int)$this->mEditCount;
3103 }
3104
3105 /**
3106 * Add the user to the given group.
3107 * This takes immediate effect.
3108 * @param string $group Name of the group to add
3109 * @return bool
3110 */
3111 public function addGroup( $group ) {
3112 $this->load();
3113
3114 if ( !Hooks::run( 'UserAddGroup', array( $this, &$group ) ) ) {
3115 return false;
3116 }
3117
3118 $dbw = wfGetDB( DB_MASTER );
3119 if ( $this->getId() ) {
3120 $dbw->insert( 'user_groups',
3121 array(
3122 'ug_user' => $this->getID(),
3123 'ug_group' => $group,
3124 ),
3125 __METHOD__,
3126 array( 'IGNORE' ) );
3127 }
3128
3129 $this->loadGroups();
3130 $this->mGroups[] = $group;
3131 // In case loadGroups was not called before, we now have the right twice.
3132 // Get rid of the duplicate.
3133 $this->mGroups = array_unique( $this->mGroups );
3134
3135 // Refresh the groups caches, and clear the rights cache so it will be
3136 // refreshed on the next call to $this->getRights().
3137 $this->getEffectiveGroups( true );
3138 $this->mRights = null;
3139
3140 $this->invalidateCache();
3141
3142 return true;
3143 }
3144
3145 /**
3146 * Remove the user from the given group.
3147 * This takes immediate effect.
3148 * @param string $group Name of the group to remove
3149 * @return bool
3150 */
3151 public function removeGroup( $group ) {
3152 $this->load();
3153 if ( !Hooks::run( 'UserRemoveGroup', array( $this, &$group ) ) ) {
3154 return false;
3155 }
3156
3157 $dbw = wfGetDB( DB_MASTER );
3158 $dbw->delete( 'user_groups',
3159 array(
3160 'ug_user' => $this->getID(),
3161 'ug_group' => $group,
3162 ), __METHOD__
3163 );
3164 // Remember that the user was in this group
3165 $dbw->insert( 'user_former_groups',
3166 array(
3167 'ufg_user' => $this->getID(),
3168 'ufg_group' => $group,
3169 ),
3170 __METHOD__,
3171 array( 'IGNORE' )
3172 );
3173
3174 $this->loadGroups();
3175 $this->mGroups = array_diff( $this->mGroups, array( $group ) );
3176
3177 // Refresh the groups caches, and clear the rights cache so it will be
3178 // refreshed on the next call to $this->getRights().
3179 $this->getEffectiveGroups( true );
3180 $this->mRights = null;
3181
3182 $this->invalidateCache();
3183
3184 return true;
3185 }
3186
3187 /**
3188 * Get whether the user is logged in
3189 * @return bool
3190 */
3191 public function isLoggedIn() {
3192 return $this->getID() != 0;
3193 }
3194
3195 /**
3196 * Get whether the user is anonymous
3197 * @return bool
3198 */
3199 public function isAnon() {
3200 return !$this->isLoggedIn();
3201 }
3202
3203 /**
3204 * Check if user is allowed to access a feature / make an action
3205 *
3206 * @param string $permissions,... Permissions to test
3207 * @return bool True if user is allowed to perform *any* of the given actions
3208 */
3209 public function isAllowedAny( /*...*/ ) {
3210 $permissions = func_get_args();
3211 foreach ( $permissions as $permission ) {
3212 if ( $this->isAllowed( $permission ) ) {
3213 return true;
3214 }
3215 }
3216 return false;
3217 }
3218
3219 /**
3220 *
3221 * @param string $permissions,... Permissions to test
3222 * @return bool True if the user is allowed to perform *all* of the given actions
3223 */
3224 public function isAllowedAll( /*...*/ ) {
3225 $permissions = func_get_args();
3226 foreach ( $permissions as $permission ) {
3227 if ( !$this->isAllowed( $permission ) ) {
3228 return false;
3229 }
3230 }
3231 return true;
3232 }
3233
3234 /**
3235 * Internal mechanics of testing a permission
3236 * @param string $action
3237 * @return bool
3238 */
3239 public function isAllowed( $action = '' ) {
3240 if ( $action === '' ) {
3241 return true; // In the spirit of DWIM
3242 }
3243 // Patrolling may not be enabled
3244 if ( $action === 'patrol' || $action === 'autopatrol' ) {
3245 global $wgUseRCPatrol, $wgUseNPPatrol;
3246 if ( !$wgUseRCPatrol && !$wgUseNPPatrol ) {
3247 return false;
3248 }
3249 }
3250 // Use strict parameter to avoid matching numeric 0 accidentally inserted
3251 // by misconfiguration: 0 == 'foo'
3252 return in_array( $action, $this->getRights(), true );
3253 }
3254
3255 /**
3256 * Check whether to enable recent changes patrol features for this user
3257 * @return bool True or false
3258 */
3259 public function useRCPatrol() {
3260 global $wgUseRCPatrol;
3261 return $wgUseRCPatrol && $this->isAllowedAny( 'patrol', 'patrolmarks' );
3262 }
3263
3264 /**
3265 * Check whether to enable new pages patrol features for this user
3266 * @return bool True or false
3267 */
3268 public function useNPPatrol() {
3269 global $wgUseRCPatrol, $wgUseNPPatrol;
3270 return (
3271 ( $wgUseRCPatrol || $wgUseNPPatrol )
3272 && ( $this->isAllowedAny( 'patrol', 'patrolmarks' ) )
3273 );
3274 }
3275
3276 /**
3277 * Get the WebRequest object to use with this object
3278 *
3279 * @return WebRequest
3280 */
3281 public function getRequest() {
3282 if ( $this->mRequest ) {
3283 return $this->mRequest;
3284 } else {
3285 global $wgRequest;
3286 return $wgRequest;
3287 }
3288 }
3289
3290 /**
3291 * Get the current skin, loading it if required
3292 * @return Skin The current skin
3293 * @todo FIXME: Need to check the old failback system [AV]
3294 * @deprecated since 1.18 Use ->getSkin() in the most relevant outputting context you have
3295 */
3296 public function getSkin() {
3297 wfDeprecated( __METHOD__, '1.18' );
3298 return RequestContext::getMain()->getSkin();
3299 }
3300
3301 /**
3302 * Get a WatchedItem for this user and $title.
3303 *
3304 * @since 1.22 $checkRights parameter added
3305 * @param Title $title
3306 * @param int $checkRights Whether to check 'viewmywatchlist'/'editmywatchlist' rights.
3307 * Pass WatchedItem::CHECK_USER_RIGHTS or WatchedItem::IGNORE_USER_RIGHTS.
3308 * @return WatchedItem
3309 */
3310 public function getWatchedItem( $title, $checkRights = WatchedItem::CHECK_USER_RIGHTS ) {
3311 $key = $checkRights . ':' . $title->getNamespace() . ':' . $title->getDBkey();
3312
3313 if ( isset( $this->mWatchedItems[$key] ) ) {
3314 return $this->mWatchedItems[$key];
3315 }
3316
3317 if ( count( $this->mWatchedItems ) >= self::MAX_WATCHED_ITEMS_CACHE ) {
3318 $this->mWatchedItems = array();
3319 }
3320
3321 $this->mWatchedItems[$key] = WatchedItem::fromUserTitle( $this, $title, $checkRights );
3322 return $this->mWatchedItems[$key];
3323 }
3324
3325 /**
3326 * Check the watched status of an article.
3327 * @since 1.22 $checkRights parameter added
3328 * @param Title $title Title of the article to look at
3329 * @param int $checkRights Whether to check 'viewmywatchlist'/'editmywatchlist' rights.
3330 * Pass WatchedItem::CHECK_USER_RIGHTS or WatchedItem::IGNORE_USER_RIGHTS.
3331 * @return bool
3332 */
3333 public function isWatched( $title, $checkRights = WatchedItem::CHECK_USER_RIGHTS ) {
3334 return $this->getWatchedItem( $title, $checkRights )->isWatched();
3335 }
3336
3337 /**
3338 * Watch an article.
3339 * @since 1.22 $checkRights parameter added
3340 * @param Title $title Title of the article to look at
3341 * @param int $checkRights Whether to check 'viewmywatchlist'/'editmywatchlist' rights.
3342 * Pass WatchedItem::CHECK_USER_RIGHTS or WatchedItem::IGNORE_USER_RIGHTS.
3343 */
3344 public function addWatch( $title, $checkRights = WatchedItem::CHECK_USER_RIGHTS ) {
3345 $this->getWatchedItem( $title, $checkRights )->addWatch();
3346 $this->invalidateCache();
3347 }
3348
3349 /**
3350 * Stop watching an article.
3351 * @since 1.22 $checkRights parameter added
3352 * @param Title $title Title of the article to look at
3353 * @param int $checkRights Whether to check 'viewmywatchlist'/'editmywatchlist' rights.
3354 * Pass WatchedItem::CHECK_USER_RIGHTS or WatchedItem::IGNORE_USER_RIGHTS.
3355 */
3356 public function removeWatch( $title, $checkRights = WatchedItem::CHECK_USER_RIGHTS ) {
3357 $this->getWatchedItem( $title, $checkRights )->removeWatch();
3358 $this->invalidateCache();
3359 }
3360
3361 /**
3362 * Clear the user's notification timestamp for the given title.
3363 * If e-notif e-mails are on, they will receive notification mails on
3364 * the next change of the page if it's watched etc.
3365 * @note If the user doesn't have 'editmywatchlist', this will do nothing.
3366 * @param Title $title Title of the article to look at
3367 * @param int $oldid The revision id being viewed. If not given or 0, latest revision is assumed.
3368 */
3369 public function clearNotification( &$title, $oldid = 0 ) {
3370 global $wgUseEnotif, $wgShowUpdatedMarker;
3371
3372 // Do nothing if the database is locked to writes
3373 if ( wfReadOnly() ) {
3374 return;
3375 }
3376
3377 // Do nothing if not allowed to edit the watchlist
3378 if ( !$this->isAllowed( 'editmywatchlist' ) ) {
3379 return;
3380 }
3381
3382 // If we're working on user's talk page, we should update the talk page message indicator
3383 if ( $title->getNamespace() == NS_USER_TALK && $title->getText() == $this->getName() ) {
3384 if ( !Hooks::run( 'UserClearNewTalkNotification', array( &$this, $oldid ) ) ) {
3385 return;
3386 }
3387
3388 $nextid = $oldid ? $title->getNextRevisionID( $oldid ) : null;
3389
3390 if ( !$oldid || !$nextid ) {
3391 // If we're looking at the latest revision, we should definitely clear it
3392 $this->setNewtalk( false );
3393 } else {
3394 // Otherwise we should update its revision, if it's present
3395 if ( $this->getNewtalk() ) {
3396 // Naturally the other one won't clear by itself
3397 $this->setNewtalk( false );
3398 $this->setNewtalk( true, Revision::newFromId( $nextid ) );
3399 }
3400 }
3401 }
3402
3403 if ( !$wgUseEnotif && !$wgShowUpdatedMarker ) {
3404 return;
3405 }
3406
3407 if ( $this->isAnon() ) {
3408 // Nothing else to do...
3409 return;
3410 }
3411
3412 // Only update the timestamp if the page is being watched.
3413 // The query to find out if it is watched is cached both in memcached and per-invocation,
3414 // and when it does have to be executed, it can be on a slave
3415 // If this is the user's newtalk page, we always update the timestamp
3416 $force = '';
3417 if ( $title->getNamespace() == NS_USER_TALK && $title->getText() == $this->getName() ) {
3418 $force = 'force';
3419 }
3420
3421 $this->getWatchedItem( $title )->resetNotificationTimestamp(
3422 $force, $oldid, WatchedItem::DEFERRED
3423 );
3424 }
3425
3426 /**
3427 * Resets all of the given user's page-change notification timestamps.
3428 * If e-notif e-mails are on, they will receive notification mails on
3429 * the next change of any watched page.
3430 * @note If the user doesn't have 'editmywatchlist', this will do nothing.
3431 */
3432 public function clearAllNotifications() {
3433 if ( wfReadOnly() ) {
3434 return;
3435 }
3436
3437 // Do nothing if not allowed to edit the watchlist
3438 if ( !$this->isAllowed( 'editmywatchlist' ) ) {
3439 return;
3440 }
3441
3442 global $wgUseEnotif, $wgShowUpdatedMarker;
3443 if ( !$wgUseEnotif && !$wgShowUpdatedMarker ) {
3444 $this->setNewtalk( false );
3445 return;
3446 }
3447 $id = $this->getId();
3448 if ( $id != 0 ) {
3449 $dbw = wfGetDB( DB_MASTER );
3450 $dbw->update( 'watchlist',
3451 array( /* SET */ 'wl_notificationtimestamp' => null ),
3452 array( /* WHERE */ 'wl_user' => $id ),
3453 __METHOD__
3454 );
3455 // We also need to clear here the "you have new message" notification for the own user_talk page;
3456 // it's cleared one page view later in WikiPage::doViewUpdates().
3457 }
3458 }
3459
3460 /**
3461 * Set a cookie on the user's client. Wrapper for
3462 * WebResponse::setCookie
3463 * @param string $name Name of the cookie to set
3464 * @param string $value Value to set
3465 * @param int $exp Expiration time, as a UNIX time value;
3466 * if 0 or not specified, use the default $wgCookieExpiration
3467 * @param bool $secure
3468 * true: Force setting the secure attribute when setting the cookie
3469 * false: Force NOT setting the secure attribute when setting the cookie
3470 * null (default): Use the default ($wgCookieSecure) to set the secure attribute
3471 * @param array $params Array of options sent passed to WebResponse::setcookie()
3472 * @param WebRequest|null $request WebRequest object to use; $wgRequest will be used if null
3473 * is passed.
3474 */
3475 protected function setCookie(
3476 $name, $value, $exp = 0, $secure = null, $params = array(), $request = null
3477 ) {
3478 if ( $request === null ) {
3479 $request = $this->getRequest();
3480 }
3481 $params['secure'] = $secure;
3482 $request->response()->setcookie( $name, $value, $exp, $params );
3483 }
3484
3485 /**
3486 * Clear a cookie on the user's client
3487 * @param string $name Name of the cookie to clear
3488 * @param bool $secure
3489 * true: Force setting the secure attribute when setting the cookie
3490 * false: Force NOT setting the secure attribute when setting the cookie
3491 * null (default): Use the default ($wgCookieSecure) to set the secure attribute
3492 * @param array $params Array of options sent passed to WebResponse::setcookie()
3493 */
3494 protected function clearCookie( $name, $secure = null, $params = array() ) {
3495 $this->setCookie( $name, '', time() - 86400, $secure, $params );
3496 }
3497
3498 /**
3499 * Set an extended login cookie on the user's client. The expiry of the cookie
3500 * is controlled by the $wgExtendedLoginCookieExpiration configuration
3501 * variable.
3502 *
3503 * @see User::setCookie
3504 *
3505 * @param string $name Name of the cookie to set
3506 * @param string $value Value to set
3507 * @param bool $secure
3508 * true: Force setting the secure attribute when setting the cookie
3509 * false: Force NOT setting the secure attribute when setting the cookie
3510 * null (default): Use the default ($wgCookieSecure) to set the secure attribute
3511 */
3512 protected function setExtendedLoginCookie( $name, $value, $secure ) {
3513 global $wgExtendedLoginCookieExpiration, $wgCookieExpiration;
3514
3515 $exp = time();
3516 $exp += $wgExtendedLoginCookieExpiration !== null
3517 ? $wgExtendedLoginCookieExpiration
3518 : $wgCookieExpiration;
3519
3520 $this->setCookie( $name, $value, $exp, $secure );
3521 }
3522
3523 /**
3524 * Set the default cookies for this session on the user's client.
3525 *
3526 * @param WebRequest|null $request WebRequest object to use; $wgRequest will be used if null
3527 * is passed.
3528 * @param bool $secure Whether to force secure/insecure cookies or use default
3529 * @param bool $rememberMe Whether to add a Token cookie for elongated sessions
3530 */
3531 public function setCookies( $request = null, $secure = null, $rememberMe = false ) {
3532 global $wgExtendedLoginCookies;
3533
3534 if ( $request === null ) {
3535 $request = $this->getRequest();
3536 }
3537
3538 $this->load();
3539 if ( 0 == $this->mId ) {
3540 return;
3541 }
3542 if ( !$this->mToken ) {
3543 // When token is empty or NULL generate a new one and then save it to the database
3544 // This allows a wiki to re-secure itself after a leak of it's user table or $wgSecretKey
3545 // Simply by setting every cell in the user_token column to NULL and letting them be
3546 // regenerated as users log back into the wiki.
3547 $this->setToken();
3548 if ( !wfReadOnly() ) {
3549 $this->saveSettings();
3550 }
3551 }
3552 $session = array(
3553 'wsUserID' => $this->mId,
3554 'wsToken' => $this->mToken,
3555 'wsUserName' => $this->getName()
3556 );
3557 $cookies = array(
3558 'UserID' => $this->mId,
3559 'UserName' => $this->getName(),
3560 );
3561 if ( $rememberMe ) {
3562 $cookies['Token'] = $this->mToken;
3563 } else {
3564 $cookies['Token'] = false;
3565 }
3566
3567 Hooks::run( 'UserSetCookies', array( $this, &$session, &$cookies ) );
3568
3569 foreach ( $session as $name => $value ) {
3570 $request->setSessionData( $name, $value );
3571 }
3572 foreach ( $cookies as $name => $value ) {
3573 if ( $value === false ) {
3574 $this->clearCookie( $name );
3575 } elseif ( $rememberMe && in_array( $name, $wgExtendedLoginCookies ) ) {
3576 $this->setExtendedLoginCookie( $name, $value, $secure );
3577 } else {
3578 $this->setCookie( $name, $value, 0, $secure, array(), $request );
3579 }
3580 }
3581
3582 /**
3583 * If wpStickHTTPS was selected, also set an insecure cookie that
3584 * will cause the site to redirect the user to HTTPS, if they access
3585 * it over HTTP. Bug 29898. Use an un-prefixed cookie, so it's the same
3586 * as the one set by centralauth (bug 53538). Also set it to session, or
3587 * standard time setting, based on if rememberme was set.
3588 */
3589 if ( $request->getCheck( 'wpStickHTTPS' ) || $this->requiresHTTPS() ) {
3590 $this->setCookie(
3591 'forceHTTPS',
3592 'true',
3593 $rememberMe ? 0 : null,
3594 false,
3595 array( 'prefix' => '' ) // no prefix
3596 );
3597 }
3598 }
3599
3600 /**
3601 * Log this user out.
3602 */
3603 public function logout() {
3604 if ( Hooks::run( 'UserLogout', array( &$this ) ) ) {
3605 $this->doLogout();
3606 }
3607 }
3608
3609 /**
3610 * Clear the user's cookies and session, and reset the instance cache.
3611 * @see logout()
3612 */
3613 public function doLogout() {
3614 $this->clearInstanceCache( 'defaults' );
3615
3616 $this->getRequest()->setSessionData( 'wsUserID', 0 );
3617
3618 $this->clearCookie( 'UserID' );
3619 $this->clearCookie( 'Token' );
3620 $this->clearCookie( 'forceHTTPS', false, array( 'prefix' => '' ) );
3621
3622 // Remember when user logged out, to prevent seeing cached pages
3623 $this->setCookie( 'LoggedOut', time(), time() + 86400 );
3624 }
3625
3626 /**
3627 * Save this user's settings into the database.
3628 * @todo Only rarely do all these fields need to be set!
3629 */
3630 public function saveSettings() {
3631 global $wgAuth;
3632
3633 if ( wfReadOnly() ) {
3634 // @TODO: caller should deal with this instead!
3635 // This should really just be an exception.
3636 MWExceptionHandler::logException( new DBExpectedError(
3637 null,
3638 "Could not update user with ID '{$this->mId}'; DB is read-only."
3639 ) );
3640 return;
3641 }
3642
3643 $this->load();
3644 $this->loadPasswords();
3645 if ( 0 == $this->mId ) {
3646 return; // anon
3647 }
3648
3649 // Get a new user_touched that is higher than the old one.
3650 // This will be used for a CAS check as a last-resort safety
3651 // check against race conditions and slave lag.
3652 $oldTouched = $this->mTouched;
3653 $newTouched = $this->newTouchedTimestamp();
3654
3655 if ( !$wgAuth->allowSetLocalPassword() ) {
3656 $this->mPassword = self::getPasswordFactory()->newFromCiphertext( null );
3657 }
3658
3659 $dbw = wfGetDB( DB_MASTER );
3660 $dbw->update( 'user',
3661 array( /* SET */
3662 'user_name' => $this->mName,
3663 'user_password' => $this->mPassword->toString(),
3664 'user_newpassword' => $this->mNewpassword->toString(),
3665 'user_newpass_time' => $dbw->timestampOrNull( $this->mNewpassTime ),
3666 'user_real_name' => $this->mRealName,
3667 'user_email' => $this->mEmail,
3668 'user_email_authenticated' => $dbw->timestampOrNull( $this->mEmailAuthenticated ),
3669 'user_touched' => $dbw->timestamp( $newTouched ),
3670 'user_token' => strval( $this->mToken ),
3671 'user_email_token' => $this->mEmailToken,
3672 'user_email_token_expires' => $dbw->timestampOrNull( $this->mEmailTokenExpires ),
3673 'user_password_expires' => $dbw->timestampOrNull( $this->mPasswordExpires ),
3674 ), array( /* WHERE */
3675 'user_id' => $this->mId,
3676 'user_touched' => $dbw->timestamp( $oldTouched ) // CAS check
3677 ), __METHOD__
3678 );
3679
3680 if ( !$dbw->affectedRows() ) {
3681 // Maybe the problem was a missed cache update; clear it to be safe
3682 $this->clearSharedCache();
3683 // User was changed in the meantime or loaded with stale data
3684 $from = ( $this->queryFlagsUsed & self::READ_LATEST ) ? 'master' : 'slave';
3685 throw new MWException(
3686 "CAS update failed on user_touched for user ID '{$this->mId}' (read from $from);" .
3687 "the version of the user to be saved is older than the current version."
3688 );
3689 }
3690
3691 $this->mTouched = $newTouched;
3692 $this->saveOptions();
3693
3694 Hooks::run( 'UserSaveSettings', array( $this ) );
3695 $this->clearSharedCache();
3696 $this->getUserPage()->invalidateCache();
3697
3698 // T95839: clear the cache again post-commit to reduce race conditions
3699 // where stale values are written back to the cache by other threads.
3700 // Note: this *still* doesn't deal with REPEATABLE-READ snapshot lag...
3701 $that = $this;
3702 $dbw->onTransactionIdle( function() use ( $that ) {
3703 $that->clearSharedCache();
3704 } );
3705 }
3706
3707 /**
3708 * If only this user's username is known, and it exists, return the user ID.
3709 *
3710 * @param int $flags Bitfield of User:READ_* constants; useful for existence checks
3711 * @return int
3712 */
3713 public function idForName( $flags = 0 ) {
3714 $s = trim( $this->getName() );
3715 if ( $s === '' ) {
3716 return 0;
3717 }
3718
3719 $db = ( ( $flags & self::READ_LATEST ) == self::READ_LATEST )
3720 ? wfGetDB( DB_MASTER )
3721 : wfGetDB( DB_SLAVE );
3722
3723 $options = ( ( $flags & self::READ_LOCKING ) == self::READ_LOCKING )
3724 ? array( 'FOR UPDATE' )
3725 : array();
3726
3727 $id = $db->selectField( 'user', 'user_id', array( 'user_name' => $s ), __METHOD__, $options );
3728 if ( $id === false ) {
3729 $id = 0;
3730 }
3731
3732 return $id;
3733 }
3734
3735 /**
3736 * Add a user to the database, return the user object
3737 *
3738 * @param string $name Username to add
3739 * @param array $params Array of Strings Non-default parameters to save to
3740 * the database as user_* fields:
3741 * - password: The user's password hash. Password logins will be disabled
3742 * if this is omitted.
3743 * - newpassword: Hash for a temporary password that has been mailed to
3744 * the user.
3745 * - email: The user's email address.
3746 * - email_authenticated: The email authentication timestamp.
3747 * - real_name: The user's real name.
3748 * - options: An associative array of non-default options.
3749 * - token: Random authentication token. Do not set.
3750 * - registration: Registration timestamp. Do not set.
3751 *
3752 * @return User|null User object, or null if the username already exists.
3753 */
3754 public static function createNew( $name, $params = array() ) {
3755 $user = new User;
3756 $user->load();
3757 $user->loadPasswords();
3758 $user->setToken(); // init token
3759 if ( isset( $params['options'] ) ) {
3760 $user->mOptions = $params['options'] + (array)$user->mOptions;
3761 unset( $params['options'] );
3762 }
3763 $dbw = wfGetDB( DB_MASTER );
3764 $seqVal = $dbw->nextSequenceValue( 'user_user_id_seq' );
3765
3766 $fields = array(
3767 'user_id' => $seqVal,
3768 'user_name' => $name,
3769 'user_password' => $user->mPassword->toString(),
3770 'user_newpassword' => $user->mNewpassword->toString(),
3771 'user_newpass_time' => $dbw->timestampOrNull( $user->mNewpassTime ),
3772 'user_email' => $user->mEmail,
3773 'user_email_authenticated' => $dbw->timestampOrNull( $user->mEmailAuthenticated ),
3774 'user_real_name' => $user->mRealName,
3775 'user_token' => strval( $user->mToken ),
3776 'user_registration' => $dbw->timestamp( $user->mRegistration ),
3777 'user_editcount' => 0,
3778 'user_touched' => $dbw->timestamp( $user->newTouchedTimestamp() ),
3779 );
3780 foreach ( $params as $name => $value ) {
3781 $fields["user_$name"] = $value;
3782 }
3783 $dbw->insert( 'user', $fields, __METHOD__, array( 'IGNORE' ) );
3784 if ( $dbw->affectedRows() ) {
3785 $newUser = User::newFromId( $dbw->insertId() );
3786 } else {
3787 $newUser = null;
3788 }
3789 return $newUser;
3790 }
3791
3792 /**
3793 * Add this existing user object to the database. If the user already
3794 * exists, a fatal status object is returned, and the user object is
3795 * initialised with the data from the database.
3796 *
3797 * Previously, this function generated a DB error due to a key conflict
3798 * if the user already existed. Many extension callers use this function
3799 * in code along the lines of:
3800 *
3801 * $user = User::newFromName( $name );
3802 * if ( !$user->isLoggedIn() ) {
3803 * $user->addToDatabase();
3804 * }
3805 * // do something with $user...
3806 *
3807 * However, this was vulnerable to a race condition (bug 16020). By
3808 * initialising the user object if the user exists, we aim to support this
3809 * calling sequence as far as possible.
3810 *
3811 * Note that if the user exists, this function will acquire a write lock,
3812 * so it is still advisable to make the call conditional on isLoggedIn(),
3813 * and to commit the transaction after calling.
3814 *
3815 * @throws MWException
3816 * @return Status
3817 */
3818 public function addToDatabase() {
3819 $this->load();
3820 $this->loadPasswords();
3821 if ( !$this->mToken ) {
3822 $this->setToken(); // init token
3823 }
3824
3825 $this->mTouched = $this->newTouchedTimestamp();
3826
3827 $dbw = wfGetDB( DB_MASTER );
3828 $inWrite = $dbw->writesOrCallbacksPending();
3829 $seqVal = $dbw->nextSequenceValue( 'user_user_id_seq' );
3830 $dbw->insert( 'user',
3831 array(
3832 'user_id' => $seqVal,
3833 'user_name' => $this->mName,
3834 'user_password' => $this->mPassword->toString(),
3835 'user_newpassword' => $this->mNewpassword->toString(),
3836 'user_newpass_time' => $dbw->timestampOrNull( $this->mNewpassTime ),
3837 'user_email' => $this->mEmail,
3838 'user_email_authenticated' => $dbw->timestampOrNull( $this->mEmailAuthenticated ),
3839 'user_real_name' => $this->mRealName,
3840 'user_token' => strval( $this->mToken ),
3841 'user_registration' => $dbw->timestamp( $this->mRegistration ),
3842 'user_editcount' => 0,
3843 'user_touched' => $dbw->timestamp( $this->mTouched ),
3844 ), __METHOD__,
3845 array( 'IGNORE' )
3846 );
3847 if ( !$dbw->affectedRows() ) {
3848 // The queries below cannot happen in the same REPEATABLE-READ snapshot.
3849 // Handle this by COMMIT, if possible, or by LOCK IN SHARE MODE otherwise.
3850 if ( $inWrite ) {
3851 // Can't commit due to pending writes that may need atomicity.
3852 // This may cause some lock contention unlike the case below.
3853 $options = array( 'LOCK IN SHARE MODE' );
3854 $flags = self::READ_LOCKING;
3855 } else {
3856 // Often, this case happens early in views before any writes when
3857 // using CentralAuth. It's should be OK to commit and break the snapshot.
3858 $dbw->commit( __METHOD__, 'flush' );
3859 $options = array();
3860 $flags = self::READ_LATEST;
3861 }
3862 $this->mId = $dbw->selectField( 'user', 'user_id',
3863 array( 'user_name' => $this->mName ), __METHOD__, $options );
3864 $loaded = false;
3865 if ( $this->mId ) {
3866 if ( $this->loadFromDatabase( $flags ) ) {
3867 $loaded = true;
3868 }
3869 }
3870 if ( !$loaded ) {
3871 throw new MWException( __METHOD__ . ": hit a key conflict attempting " .
3872 "to insert user '{$this->mName}' row, but it was not present in select!" );
3873 }
3874 return Status::newFatal( 'userexists' );
3875 }
3876 $this->mId = $dbw->insertId();
3877
3878 // Clear instance cache other than user table data, which is already accurate
3879 $this->clearInstanceCache();
3880
3881 $this->saveOptions();
3882 return Status::newGood();
3883 }
3884
3885 /**
3886 * If this user is logged-in and blocked,
3887 * block any IP address they've successfully logged in from.
3888 * @return bool A block was spread
3889 */
3890 public function spreadAnyEditBlock() {
3891 if ( $this->isLoggedIn() && $this->isBlocked() ) {
3892 return $this->spreadBlock();
3893 }
3894 return false;
3895 }
3896
3897 /**
3898 * If this (non-anonymous) user is blocked,
3899 * block the IP address they've successfully logged in from.
3900 * @return bool A block was spread
3901 */
3902 protected function spreadBlock() {
3903 wfDebug( __METHOD__ . "()\n" );
3904 $this->load();
3905 if ( $this->mId == 0 ) {
3906 return false;
3907 }
3908
3909 $userblock = Block::newFromTarget( $this->getName() );
3910 if ( !$userblock ) {
3911 return false;
3912 }
3913
3914 return (bool)$userblock->doAutoblock( $this->getRequest()->getIP() );
3915 }
3916
3917 /**
3918 * Get whether the user is explicitly blocked from account creation.
3919 * @return bool|Block
3920 */
3921 public function isBlockedFromCreateAccount() {
3922 $this->getBlockedStatus();
3923 if ( $this->mBlock && $this->mBlock->prevents( 'createaccount' ) ) {
3924 return $this->mBlock;
3925 }
3926
3927 # bug 13611: if the IP address the user is trying to create an account from is
3928 # blocked with createaccount disabled, prevent new account creation there even
3929 # when the user is logged in
3930 if ( $this->mBlockedFromCreateAccount === false && !$this->isAllowed( 'ipblock-exempt' ) ) {
3931 $this->mBlockedFromCreateAccount = Block::newFromTarget( null, $this->getRequest()->getIP() );
3932 }
3933 return $this->mBlockedFromCreateAccount instanceof Block
3934 && $this->mBlockedFromCreateAccount->prevents( 'createaccount' )
3935 ? $this->mBlockedFromCreateAccount
3936 : false;
3937 }
3938
3939 /**
3940 * Get whether the user is blocked from using Special:Emailuser.
3941 * @return bool
3942 */
3943 public function isBlockedFromEmailuser() {
3944 $this->getBlockedStatus();
3945 return $this->mBlock && $this->mBlock->prevents( 'sendemail' );
3946 }
3947
3948 /**
3949 * Get whether the user is allowed to create an account.
3950 * @return bool
3951 */
3952 public function isAllowedToCreateAccount() {
3953 return $this->isAllowed( 'createaccount' ) && !$this->isBlockedFromCreateAccount();
3954 }
3955
3956 /**
3957 * Get this user's personal page title.
3958 *
3959 * @return Title User's personal page title
3960 */
3961 public function getUserPage() {
3962 return Title::makeTitle( NS_USER, $this->getName() );
3963 }
3964
3965 /**
3966 * Get this user's talk page title.
3967 *
3968 * @return Title User's talk page title
3969 */
3970 public function getTalkPage() {
3971 $title = $this->getUserPage();
3972 return $title->getTalkPage();
3973 }
3974
3975 /**
3976 * Determine whether the user is a newbie. Newbies are either
3977 * anonymous IPs, or the most recently created accounts.
3978 * @return bool
3979 */
3980 public function isNewbie() {
3981 return !$this->isAllowed( 'autoconfirmed' );
3982 }
3983
3984 /**
3985 * Check to see if the given clear-text password is one of the accepted passwords
3986 * @param string $password User password
3987 * @return bool True if the given password is correct, otherwise False
3988 */
3989 public function checkPassword( $password ) {
3990 global $wgAuth, $wgLegacyEncoding;
3991
3992 $this->loadPasswords();
3993
3994 // Some passwords will give a fatal Status, which means there is
3995 // some sort of technical or security reason for this password to
3996 // be completely invalid and should never be checked (e.g., T64685)
3997 if ( !$this->checkPasswordValidity( $password )->isOK() ) {
3998 return false;
3999 }
4000
4001 // Certain authentication plugins do NOT want to save
4002 // domain passwords in a mysql database, so we should
4003 // check this (in case $wgAuth->strict() is false).
4004 if ( $wgAuth->authenticate( $this->getName(), $password ) ) {
4005 return true;
4006 } elseif ( $wgAuth->strict() ) {
4007 // Auth plugin doesn't allow local authentication
4008 return false;
4009 } elseif ( $wgAuth->strictUserAuth( $this->getName() ) ) {
4010 // Auth plugin doesn't allow local authentication for this user name
4011 return false;
4012 }
4013
4014 if ( !$this->mPassword->equals( $password ) ) {
4015 if ( $wgLegacyEncoding ) {
4016 // Some wikis were converted from ISO 8859-1 to UTF-8, the passwords can't be converted
4017 // Check for this with iconv
4018 $cp1252Password = iconv( 'UTF-8', 'WINDOWS-1252//TRANSLIT', $password );
4019 if ( $cp1252Password === $password || !$this->mPassword->equals( $cp1252Password ) ) {
4020 return false;
4021 }
4022 } else {
4023 return false;
4024 }
4025 }
4026
4027 $passwordFactory = self::getPasswordFactory();
4028 if ( $passwordFactory->needsUpdate( $this->mPassword ) && !wfReadOnly() ) {
4029 $this->mPassword = $passwordFactory->newFromPlaintext( $password );
4030 $this->saveSettings();
4031 }
4032
4033 return true;
4034 }
4035
4036 /**
4037 * Check if the given clear-text password matches the temporary password
4038 * sent by e-mail for password reset operations.
4039 *
4040 * @param string $plaintext
4041 *
4042 * @return bool True if matches, false otherwise
4043 */
4044 public function checkTemporaryPassword( $plaintext ) {
4045 global $wgNewPasswordExpiry;
4046
4047 $this->load();
4048 $this->loadPasswords();
4049 if ( $this->mNewpassword->equals( $plaintext ) ) {
4050 if ( is_null( $this->mNewpassTime ) ) {
4051 return true;
4052 }
4053 $expiry = wfTimestamp( TS_UNIX, $this->mNewpassTime ) + $wgNewPasswordExpiry;
4054 return ( time() < $expiry );
4055 } else {
4056 return false;
4057 }
4058 }
4059
4060 /**
4061 * Alias for getEditToken.
4062 * @deprecated since 1.19, use getEditToken instead.
4063 *
4064 * @param string|array $salt Array of Strings Optional function-specific data for hashing
4065 * @param WebRequest|null $request WebRequest object to use or null to use $wgRequest
4066 * @return string The new edit token
4067 */
4068 public function editToken( $salt = '', $request = null ) {
4069 wfDeprecated( __METHOD__, '1.19' );
4070 return $this->getEditToken( $salt, $request );
4071 }
4072
4073 /**
4074 * Internal implementation for self::getEditToken() and
4075 * self::matchEditToken().
4076 *
4077 * @param string|array $salt
4078 * @param WebRequest $request
4079 * @param string|int $timestamp
4080 * @return string
4081 */
4082 private function getEditTokenAtTimestamp( $salt, $request, $timestamp ) {
4083 if ( $this->isAnon() ) {
4084 return self::EDIT_TOKEN_SUFFIX;
4085 } else {
4086 $token = $request->getSessionData( 'wsEditToken' );
4087 if ( $token === null ) {
4088 $token = MWCryptRand::generateHex( 32 );
4089 $request->setSessionData( 'wsEditToken', $token );
4090 }
4091 if ( is_array( $salt ) ) {
4092 $salt = implode( '|', $salt );
4093 }
4094 return hash_hmac( 'md5', $timestamp . $salt, $token, false ) .
4095 dechex( $timestamp ) .
4096 self::EDIT_TOKEN_SUFFIX;
4097 }
4098 }
4099
4100 /**
4101 * Initialize (if necessary) and return a session token value
4102 * which can be used in edit forms to show that the user's
4103 * login credentials aren't being hijacked with a foreign form
4104 * submission.
4105 *
4106 * @since 1.19
4107 *
4108 * @param string|array $salt Array of Strings Optional function-specific data for hashing
4109 * @param WebRequest|null $request WebRequest object to use or null to use $wgRequest
4110 * @return string The new edit token
4111 */
4112 public function getEditToken( $salt = '', $request = null ) {
4113 return $this->getEditTokenAtTimestamp(
4114 $salt, $request ?: $this->getRequest(), wfTimestamp()
4115 );
4116 }
4117
4118 /**
4119 * Generate a looking random token for various uses.
4120 *
4121 * @return string The new random token
4122 * @deprecated since 1.20: Use MWCryptRand for secure purposes or
4123 * wfRandomString for pseudo-randomness.
4124 */
4125 public static function generateToken() {
4126 return MWCryptRand::generateHex( 32 );
4127 }
4128
4129 /**
4130 * Get the embedded timestamp from a token.
4131 * @param string $val Input token
4132 * @return int|null
4133 */
4134 public static function getEditTokenTimestamp( $val ) {
4135 $suffixLen = strlen( self::EDIT_TOKEN_SUFFIX );
4136 if ( strlen( $val ) <= 32 + $suffixLen ) {
4137 return null;
4138 }
4139
4140 return hexdec( substr( $val, 32, -$suffixLen ) );
4141 }
4142
4143 /**
4144 * Check given value against the token value stored in the session.
4145 * A match should confirm that the form was submitted from the
4146 * user's own login session, not a form submission from a third-party
4147 * site.
4148 *
4149 * @param string $val Input value to compare
4150 * @param string $salt Optional function-specific data for hashing
4151 * @param WebRequest|null $request Object to use or null to use $wgRequest
4152 * @param int $maxage Fail tokens older than this, in seconds
4153 * @return bool Whether the token matches
4154 */
4155 public function matchEditToken( $val, $salt = '', $request = null, $maxage = null ) {
4156 if ( $this->isAnon() ) {
4157 return $val === self::EDIT_TOKEN_SUFFIX;
4158 }
4159
4160 $timestamp = self::getEditTokenTimestamp( $val );
4161 if ( $timestamp === null ) {
4162 return false;
4163 }
4164 if ( $maxage !== null && $timestamp < wfTimestamp() - $maxage ) {
4165 // Expired token
4166 return false;
4167 }
4168
4169 $sessionToken = $this->getEditTokenAtTimestamp(
4170 $salt, $request ?: $this->getRequest(), $timestamp
4171 );
4172
4173 if ( $val != $sessionToken ) {
4174 wfDebug( "User::matchEditToken: broken session data\n" );
4175 }
4176
4177 return hash_equals( $sessionToken, $val );
4178 }
4179
4180 /**
4181 * Check given value against the token value stored in the session,
4182 * ignoring the suffix.
4183 *
4184 * @param string $val Input value to compare
4185 * @param string $salt Optional function-specific data for hashing
4186 * @param WebRequest|null $request Object to use or null to use $wgRequest
4187 * @param int $maxage Fail tokens older than this, in seconds
4188 * @return bool Whether the token matches
4189 */
4190 public function matchEditTokenNoSuffix( $val, $salt = '', $request = null, $maxage = null ) {
4191 $val = substr( $val, 0, strspn( $val, '0123456789abcdef' ) ) . self::EDIT_TOKEN_SUFFIX;
4192 return $this->matchEditToken( $val, $salt, $request, $maxage );
4193 }
4194
4195 /**
4196 * Generate a new e-mail confirmation token and send a confirmation/invalidation
4197 * mail to the user's given address.
4198 *
4199 * @param string $type Message to send, either "created", "changed" or "set"
4200 * @return Status
4201 */
4202 public function sendConfirmationMail( $type = 'created' ) {
4203 global $wgLang;
4204 $expiration = null; // gets passed-by-ref and defined in next line.
4205 $token = $this->confirmationToken( $expiration );
4206 $url = $this->confirmationTokenUrl( $token );
4207 $invalidateURL = $this->invalidationTokenUrl( $token );
4208 $this->saveSettings();
4209
4210 if ( $type == 'created' || $type === false ) {
4211 $message = 'confirmemail_body';
4212 } elseif ( $type === true ) {
4213 $message = 'confirmemail_body_changed';
4214 } else {
4215 // Messages: confirmemail_body_changed, confirmemail_body_set
4216 $message = 'confirmemail_body_' . $type;
4217 }
4218
4219 return $this->sendMail( wfMessage( 'confirmemail_subject' )->text(),
4220 wfMessage( $message,
4221 $this->getRequest()->getIP(),
4222 $this->getName(),
4223 $url,
4224 $wgLang->timeanddate( $expiration, false ),
4225 $invalidateURL,
4226 $wgLang->date( $expiration, false ),
4227 $wgLang->time( $expiration, false ) )->text() );
4228 }
4229
4230 /**
4231 * Send an e-mail to this user's account. Does not check for
4232 * confirmed status or validity.
4233 *
4234 * @param string $subject Message subject
4235 * @param string $body Message body
4236 * @param User|null $from Optional sending user; if unspecified, default
4237 * $wgPasswordSender will be used.
4238 * @param string $replyto Reply-To address
4239 * @return Status
4240 */
4241 public function sendMail( $subject, $body, $from = null, $replyto = null ) {
4242 global $wgPasswordSender;
4243
4244 if ( $from instanceof User ) {
4245 $sender = MailAddress::newFromUser( $from );
4246 } else {
4247 $sender = new MailAddress( $wgPasswordSender,
4248 wfMessage( 'emailsender' )->inContentLanguage()->text() );
4249 }
4250 $to = MailAddress::newFromUser( $this );
4251
4252 return UserMailer::send( $to, $sender, $subject, $body, $replyto );
4253 }
4254
4255 /**
4256 * Generate, store, and return a new e-mail confirmation code.
4257 * A hash (unsalted, since it's used as a key) is stored.
4258 *
4259 * @note Call saveSettings() after calling this function to commit
4260 * this change to the database.
4261 *
4262 * @param string &$expiration Accepts the expiration time
4263 * @return string New token
4264 */
4265 protected function confirmationToken( &$expiration ) {
4266 global $wgUserEmailConfirmationTokenExpiry;
4267 $now = time();
4268 $expires = $now + $wgUserEmailConfirmationTokenExpiry;
4269 $expiration = wfTimestamp( TS_MW, $expires );
4270 $this->load();
4271 $token = MWCryptRand::generateHex( 32 );
4272 $hash = md5( $token );
4273 $this->mEmailToken = $hash;
4274 $this->mEmailTokenExpires = $expiration;
4275 return $token;
4276 }
4277
4278 /**
4279 * Return a URL the user can use to confirm their email address.
4280 * @param string $token Accepts the email confirmation token
4281 * @return string New token URL
4282 */
4283 protected function confirmationTokenUrl( $token ) {
4284 return $this->getTokenUrl( 'ConfirmEmail', $token );
4285 }
4286
4287 /**
4288 * Return a URL the user can use to invalidate their email address.
4289 * @param string $token Accepts the email confirmation token
4290 * @return string New token URL
4291 */
4292 protected function invalidationTokenUrl( $token ) {
4293 return $this->getTokenUrl( 'InvalidateEmail', $token );
4294 }
4295
4296 /**
4297 * Internal function to format the e-mail validation/invalidation URLs.
4298 * This uses a quickie hack to use the
4299 * hardcoded English names of the Special: pages, for ASCII safety.
4300 *
4301 * @note Since these URLs get dropped directly into emails, using the
4302 * short English names avoids insanely long URL-encoded links, which
4303 * also sometimes can get corrupted in some browsers/mailers
4304 * (bug 6957 with Gmail and Internet Explorer).
4305 *
4306 * @param string $page Special page
4307 * @param string $token Token
4308 * @return string Formatted URL
4309 */
4310 protected function getTokenUrl( $page, $token ) {
4311 // Hack to bypass localization of 'Special:'
4312 $title = Title::makeTitle( NS_MAIN, "Special:$page/$token" );
4313 return $title->getCanonicalURL();
4314 }
4315
4316 /**
4317 * Mark the e-mail address confirmed.
4318 *
4319 * @note Call saveSettings() after calling this function to commit the change.
4320 *
4321 * @return bool
4322 */
4323 public function confirmEmail() {
4324 // Check if it's already confirmed, so we don't touch the database
4325 // and fire the ConfirmEmailComplete hook on redundant confirmations.
4326 if ( !$this->isEmailConfirmed() ) {
4327 $this->setEmailAuthenticationTimestamp( wfTimestampNow() );
4328 Hooks::run( 'ConfirmEmailComplete', array( $this ) );
4329 }
4330 return true;
4331 }
4332
4333 /**
4334 * Invalidate the user's e-mail confirmation, and unauthenticate the e-mail
4335 * address if it was already confirmed.
4336 *
4337 * @note Call saveSettings() after calling this function to commit the change.
4338 * @return bool Returns true
4339 */
4340 public function invalidateEmail() {
4341 $this->load();
4342 $this->mEmailToken = null;
4343 $this->mEmailTokenExpires = null;
4344 $this->setEmailAuthenticationTimestamp( null );
4345 $this->mEmail = '';
4346 Hooks::run( 'InvalidateEmailComplete', array( $this ) );
4347 return true;
4348 }
4349
4350 /**
4351 * Set the e-mail authentication timestamp.
4352 * @param string $timestamp TS_MW timestamp
4353 */
4354 public function setEmailAuthenticationTimestamp( $timestamp ) {
4355 $this->load();
4356 $this->mEmailAuthenticated = $timestamp;
4357 Hooks::run( 'UserSetEmailAuthenticationTimestamp', array( $this, &$this->mEmailAuthenticated ) );
4358 }
4359
4360 /**
4361 * Is this user allowed to send e-mails within limits of current
4362 * site configuration?
4363 * @return bool
4364 */
4365 public function canSendEmail() {
4366 global $wgEnableEmail, $wgEnableUserEmail;
4367 if ( !$wgEnableEmail || !$wgEnableUserEmail || !$this->isAllowed( 'sendemail' ) ) {
4368 return false;
4369 }
4370 $canSend = $this->isEmailConfirmed();
4371 Hooks::run( 'UserCanSendEmail', array( &$this, &$canSend ) );
4372 return $canSend;
4373 }
4374
4375 /**
4376 * Is this user allowed to receive e-mails within limits of current
4377 * site configuration?
4378 * @return bool
4379 */
4380 public function canReceiveEmail() {
4381 return $this->isEmailConfirmed() && !$this->getOption( 'disablemail' );
4382 }
4383
4384 /**
4385 * Is this user's e-mail address valid-looking and confirmed within
4386 * limits of the current site configuration?
4387 *
4388 * @note If $wgEmailAuthentication is on, this may require the user to have
4389 * confirmed their address by returning a code or using a password
4390 * sent to the address from the wiki.
4391 *
4392 * @return bool
4393 */
4394 public function isEmailConfirmed() {
4395 global $wgEmailAuthentication;
4396 $this->load();
4397 $confirmed = true;
4398 if ( Hooks::run( 'EmailConfirmed', array( &$this, &$confirmed ) ) ) {
4399 if ( $this->isAnon() ) {
4400 return false;
4401 }
4402 if ( !Sanitizer::validateEmail( $this->mEmail ) ) {
4403 return false;
4404 }
4405 if ( $wgEmailAuthentication && !$this->getEmailAuthenticationTimestamp() ) {
4406 return false;
4407 }
4408 return true;
4409 } else {
4410 return $confirmed;
4411 }
4412 }
4413
4414 /**
4415 * Check whether there is an outstanding request for e-mail confirmation.
4416 * @return bool
4417 */
4418 public function isEmailConfirmationPending() {
4419 global $wgEmailAuthentication;
4420 return $wgEmailAuthentication &&
4421 !$this->isEmailConfirmed() &&
4422 $this->mEmailToken &&
4423 $this->mEmailTokenExpires > wfTimestamp();
4424 }
4425
4426 /**
4427 * Get the timestamp of account creation.
4428 *
4429 * @return string|bool|null Timestamp of account creation, false for
4430 * non-existent/anonymous user accounts, or null if existing account
4431 * but information is not in database.
4432 */
4433 public function getRegistration() {
4434 if ( $this->isAnon() ) {
4435 return false;
4436 }
4437 $this->load();
4438 return $this->mRegistration;
4439 }
4440
4441 /**
4442 * Get the timestamp of the first edit
4443 *
4444 * @return string|bool Timestamp of first edit, or false for
4445 * non-existent/anonymous user accounts.
4446 */
4447 public function getFirstEditTimestamp() {
4448 if ( $this->getId() == 0 ) {
4449 return false; // anons
4450 }
4451 $dbr = wfGetDB( DB_SLAVE );
4452 $time = $dbr->selectField( 'revision', 'rev_timestamp',
4453 array( 'rev_user' => $this->getId() ),
4454 __METHOD__,
4455 array( 'ORDER BY' => 'rev_timestamp ASC' )
4456 );
4457 if ( !$time ) {
4458 return false; // no edits
4459 }
4460 return wfTimestamp( TS_MW, $time );
4461 }
4462
4463 /**
4464 * Get the permissions associated with a given list of groups
4465 *
4466 * @param array $groups Array of Strings List of internal group names
4467 * @return array Array of Strings List of permission key names for given groups combined
4468 */
4469 public static function getGroupPermissions( $groups ) {
4470 global $wgGroupPermissions, $wgRevokePermissions;
4471 $rights = array();
4472 // grant every granted permission first
4473 foreach ( $groups as $group ) {
4474 if ( isset( $wgGroupPermissions[$group] ) ) {
4475 $rights = array_merge( $rights,
4476 // array_filter removes empty items
4477 array_keys( array_filter( $wgGroupPermissions[$group] ) ) );
4478 }
4479 }
4480 // now revoke the revoked permissions
4481 foreach ( $groups as $group ) {
4482 if ( isset( $wgRevokePermissions[$group] ) ) {
4483 $rights = array_diff( $rights,
4484 array_keys( array_filter( $wgRevokePermissions[$group] ) ) );
4485 }
4486 }
4487 return array_unique( $rights );
4488 }
4489
4490 /**
4491 * Get all the groups who have a given permission
4492 *
4493 * @param string $role Role to check
4494 * @return array Array of Strings List of internal group names with the given permission
4495 */
4496 public static function getGroupsWithPermission( $role ) {
4497 global $wgGroupPermissions;
4498 $allowedGroups = array();
4499 foreach ( array_keys( $wgGroupPermissions ) as $group ) {
4500 if ( self::groupHasPermission( $group, $role ) ) {
4501 $allowedGroups[] = $group;
4502 }
4503 }
4504 return $allowedGroups;
4505 }
4506
4507 /**
4508 * Check, if the given group has the given permission
4509 *
4510 * If you're wanting to check whether all users have a permission, use
4511 * User::isEveryoneAllowed() instead. That properly checks if it's revoked
4512 * from anyone.
4513 *
4514 * @since 1.21
4515 * @param string $group Group to check
4516 * @param string $role Role to check
4517 * @return bool
4518 */
4519 public static function groupHasPermission( $group, $role ) {
4520 global $wgGroupPermissions, $wgRevokePermissions;
4521 return isset( $wgGroupPermissions[$group][$role] ) && $wgGroupPermissions[$group][$role]
4522 && !( isset( $wgRevokePermissions[$group][$role] ) && $wgRevokePermissions[$group][$role] );
4523 }
4524
4525 /**
4526 * Check if all users have the given permission
4527 *
4528 * @since 1.22
4529 * @param string $right Right to check
4530 * @return bool
4531 */
4532 public static function isEveryoneAllowed( $right ) {
4533 global $wgGroupPermissions, $wgRevokePermissions;
4534 static $cache = array();
4535
4536 // Use the cached results, except in unit tests which rely on
4537 // being able change the permission mid-request
4538 if ( isset( $cache[$right] ) && !defined( 'MW_PHPUNIT_TEST' ) ) {
4539 return $cache[$right];
4540 }
4541
4542 if ( !isset( $wgGroupPermissions['*'][$right] ) || !$wgGroupPermissions['*'][$right] ) {
4543 $cache[$right] = false;
4544 return false;
4545 }
4546
4547 // If it's revoked anywhere, then everyone doesn't have it
4548 foreach ( $wgRevokePermissions as $rights ) {
4549 if ( isset( $rights[$right] ) && $rights[$right] ) {
4550 $cache[$right] = false;
4551 return false;
4552 }
4553 }
4554
4555 // Allow extensions (e.g. OAuth) to say false
4556 if ( !Hooks::run( 'UserIsEveryoneAllowed', array( $right ) ) ) {
4557 $cache[$right] = false;
4558 return false;
4559 }
4560
4561 $cache[$right] = true;
4562 return true;
4563 }
4564
4565 /**
4566 * Get the localized descriptive name for a group, if it exists
4567 *
4568 * @param string $group Internal group name
4569 * @return string Localized descriptive group name
4570 */
4571 public static function getGroupName( $group ) {
4572 $msg = wfMessage( "group-$group" );
4573 return $msg->isBlank() ? $group : $msg->text();
4574 }
4575
4576 /**
4577 * Get the localized descriptive name for a member of a group, if it exists
4578 *
4579 * @param string $group Internal group name
4580 * @param string $username Username for gender (since 1.19)
4581 * @return string Localized name for group member
4582 */
4583 public static function getGroupMember( $group, $username = '#' ) {
4584 $msg = wfMessage( "group-$group-member", $username );
4585 return $msg->isBlank() ? $group : $msg->text();
4586 }
4587
4588 /**
4589 * Return the set of defined explicit groups.
4590 * The implicit groups (by default *, 'user' and 'autoconfirmed')
4591 * are not included, as they are defined automatically, not in the database.
4592 * @return array Array of internal group names
4593 */
4594 public static function getAllGroups() {
4595 global $wgGroupPermissions, $wgRevokePermissions;
4596 return array_diff(
4597 array_merge( array_keys( $wgGroupPermissions ), array_keys( $wgRevokePermissions ) ),
4598 self::getImplicitGroups()
4599 );
4600 }
4601
4602 /**
4603 * Get a list of all available permissions.
4604 * @return string[] Array of permission names
4605 */
4606 public static function getAllRights() {
4607 if ( self::$mAllRights === false ) {
4608 global $wgAvailableRights;
4609 if ( count( $wgAvailableRights ) ) {
4610 self::$mAllRights = array_unique( array_merge( self::$mCoreRights, $wgAvailableRights ) );
4611 } else {
4612 self::$mAllRights = self::$mCoreRights;
4613 }
4614 Hooks::run( 'UserGetAllRights', array( &self::$mAllRights ) );
4615 }
4616 return self::$mAllRights;
4617 }
4618
4619 /**
4620 * Get a list of implicit groups
4621 * @return array Array of Strings Array of internal group names
4622 */
4623 public static function getImplicitGroups() {
4624 global $wgImplicitGroups;
4625
4626 $groups = $wgImplicitGroups;
4627 # Deprecated, use $wgImplicitGroups instead
4628 Hooks::run( 'UserGetImplicitGroups', array( &$groups ), '1.25' );
4629
4630 return $groups;
4631 }
4632
4633 /**
4634 * Get the title of a page describing a particular group
4635 *
4636 * @param string $group Internal group name
4637 * @return Title|bool Title of the page if it exists, false otherwise
4638 */
4639 public static function getGroupPage( $group ) {
4640 $msg = wfMessage( 'grouppage-' . $group )->inContentLanguage();
4641 if ( $msg->exists() ) {
4642 $title = Title::newFromText( $msg->text() );
4643 if ( is_object( $title ) ) {
4644 return $title;
4645 }
4646 }
4647 return false;
4648 }
4649
4650 /**
4651 * Create a link to the group in HTML, if available;
4652 * else return the group name.
4653 *
4654 * @param string $group Internal name of the group
4655 * @param string $text The text of the link
4656 * @return string HTML link to the group
4657 */
4658 public static function makeGroupLinkHTML( $group, $text = '' ) {
4659 if ( $text == '' ) {
4660 $text = self::getGroupName( $group );
4661 }
4662 $title = self::getGroupPage( $group );
4663 if ( $title ) {
4664 return Linker::link( $title, htmlspecialchars( $text ) );
4665 } else {
4666 return htmlspecialchars( $text );
4667 }
4668 }
4669
4670 /**
4671 * Create a link to the group in Wikitext, if available;
4672 * else return the group name.
4673 *
4674 * @param string $group Internal name of the group
4675 * @param string $text The text of the link
4676 * @return string Wikilink to the group
4677 */
4678 public static function makeGroupLinkWiki( $group, $text = '' ) {
4679 if ( $text == '' ) {
4680 $text = self::getGroupName( $group );
4681 }
4682 $title = self::getGroupPage( $group );
4683 if ( $title ) {
4684 $page = $title->getFullText();
4685 return "[[$page|$text]]";
4686 } else {
4687 return $text;
4688 }
4689 }
4690
4691 /**
4692 * Returns an array of the groups that a particular group can add/remove.
4693 *
4694 * @param string $group The group to check for whether it can add/remove
4695 * @return array Array( 'add' => array( addablegroups ),
4696 * 'remove' => array( removablegroups ),
4697 * 'add-self' => array( addablegroups to self),
4698 * 'remove-self' => array( removable groups from self) )
4699 */
4700 public static function changeableByGroup( $group ) {
4701 global $wgAddGroups, $wgRemoveGroups, $wgGroupsAddToSelf, $wgGroupsRemoveFromSelf;
4702
4703 $groups = array(
4704 'add' => array(),
4705 'remove' => array(),
4706 'add-self' => array(),
4707 'remove-self' => array()
4708 );
4709
4710 if ( empty( $wgAddGroups[$group] ) ) {
4711 // Don't add anything to $groups
4712 } elseif ( $wgAddGroups[$group] === true ) {
4713 // You get everything
4714 $groups['add'] = self::getAllGroups();
4715 } elseif ( is_array( $wgAddGroups[$group] ) ) {
4716 $groups['add'] = $wgAddGroups[$group];
4717 }
4718
4719 // Same thing for remove
4720 if ( empty( $wgRemoveGroups[$group] ) ) {
4721 // Do nothing
4722 } elseif ( $wgRemoveGroups[$group] === true ) {
4723 $groups['remove'] = self::getAllGroups();
4724 } elseif ( is_array( $wgRemoveGroups[$group] ) ) {
4725 $groups['remove'] = $wgRemoveGroups[$group];
4726 }
4727
4728 // Re-map numeric keys of AddToSelf/RemoveFromSelf to the 'user' key for backwards compatibility
4729 if ( empty( $wgGroupsAddToSelf['user'] ) || $wgGroupsAddToSelf['user'] !== true ) {
4730 foreach ( $wgGroupsAddToSelf as $key => $value ) {
4731 if ( is_int( $key ) ) {
4732 $wgGroupsAddToSelf['user'][] = $value;
4733 }
4734 }
4735 }
4736
4737 if ( empty( $wgGroupsRemoveFromSelf['user'] ) || $wgGroupsRemoveFromSelf['user'] !== true ) {
4738 foreach ( $wgGroupsRemoveFromSelf as $key => $value ) {
4739 if ( is_int( $key ) ) {
4740 $wgGroupsRemoveFromSelf['user'][] = $value;
4741 }
4742 }
4743 }
4744
4745 // Now figure out what groups the user can add to him/herself
4746 if ( empty( $wgGroupsAddToSelf[$group] ) ) {
4747 // Do nothing
4748 } elseif ( $wgGroupsAddToSelf[$group] === true ) {
4749 // No idea WHY this would be used, but it's there
4750 $groups['add-self'] = User::getAllGroups();
4751 } elseif ( is_array( $wgGroupsAddToSelf[$group] ) ) {
4752 $groups['add-self'] = $wgGroupsAddToSelf[$group];
4753 }
4754
4755 if ( empty( $wgGroupsRemoveFromSelf[$group] ) ) {
4756 // Do nothing
4757 } elseif ( $wgGroupsRemoveFromSelf[$group] === true ) {
4758 $groups['remove-self'] = User::getAllGroups();
4759 } elseif ( is_array( $wgGroupsRemoveFromSelf[$group] ) ) {
4760 $groups['remove-self'] = $wgGroupsRemoveFromSelf[$group];
4761 }
4762
4763 return $groups;
4764 }
4765
4766 /**
4767 * Returns an array of groups that this user can add and remove
4768 * @return array Array( 'add' => array( addablegroups ),
4769 * 'remove' => array( removablegroups ),
4770 * 'add-self' => array( addablegroups to self),
4771 * 'remove-self' => array( removable groups from self) )
4772 */
4773 public function changeableGroups() {
4774 if ( $this->isAllowed( 'userrights' ) ) {
4775 // This group gives the right to modify everything (reverse-
4776 // compatibility with old "userrights lets you change
4777 // everything")
4778 // Using array_merge to make the groups reindexed
4779 $all = array_merge( User::getAllGroups() );
4780 return array(
4781 'add' => $all,
4782 'remove' => $all,
4783 'add-self' => array(),
4784 'remove-self' => array()
4785 );
4786 }
4787
4788 // Okay, it's not so simple, we will have to go through the arrays
4789 $groups = array(
4790 'add' => array(),
4791 'remove' => array(),
4792 'add-self' => array(),
4793 'remove-self' => array()
4794 );
4795 $addergroups = $this->getEffectiveGroups();
4796
4797 foreach ( $addergroups as $addergroup ) {
4798 $groups = array_merge_recursive(
4799 $groups, $this->changeableByGroup( $addergroup )
4800 );
4801 $groups['add'] = array_unique( $groups['add'] );
4802 $groups['remove'] = array_unique( $groups['remove'] );
4803 $groups['add-self'] = array_unique( $groups['add-self'] );
4804 $groups['remove-self'] = array_unique( $groups['remove-self'] );
4805 }
4806 return $groups;
4807 }
4808
4809 /**
4810 * Deferred version of incEditCountImmediate()
4811 */
4812 public function incEditCount() {
4813 $that = $this;
4814 wfGetDB( DB_MASTER )->onTransactionPreCommitOrIdle( function() use ( $that ) {
4815 $that->incEditCountImmediate();
4816 } );
4817 }
4818
4819 /**
4820 * Increment the user's edit-count field.
4821 * Will have no effect for anonymous users.
4822 * @since 1.26
4823 */
4824 public function incEditCountImmediate() {
4825 if ( $this->isAnon() ) {
4826 return;
4827 }
4828
4829 $dbw = wfGetDB( DB_MASTER );
4830 // No rows will be "affected" if user_editcount is NULL
4831 $dbw->update(
4832 'user',
4833 array( 'user_editcount=user_editcount+1' ),
4834 array( 'user_id' => $this->getId() ),
4835 __METHOD__
4836 );
4837 // Lazy initialization check...
4838 if ( $dbw->affectedRows() == 0 ) {
4839 // Now here's a goddamn hack...
4840 $dbr = wfGetDB( DB_SLAVE );
4841 if ( $dbr !== $dbw ) {
4842 // If we actually have a slave server, the count is
4843 // at least one behind because the current transaction
4844 // has not been committed and replicated.
4845 $this->initEditCount( 1 );
4846 } else {
4847 // But if DB_SLAVE is selecting the master, then the
4848 // count we just read includes the revision that was
4849 // just added in the working transaction.
4850 $this->initEditCount();
4851 }
4852 }
4853 // Edit count in user cache too
4854 $this->invalidateCache();
4855 }
4856
4857 /**
4858 * Initialize user_editcount from data out of the revision table
4859 *
4860 * @param int $add Edits to add to the count from the revision table
4861 * @return int Number of edits
4862 */
4863 protected function initEditCount( $add = 0 ) {
4864 // Pull from a slave to be less cruel to servers
4865 // Accuracy isn't the point anyway here
4866 $dbr = wfGetDB( DB_SLAVE );
4867 $count = (int)$dbr->selectField(
4868 'revision',
4869 'COUNT(rev_user)',
4870 array( 'rev_user' => $this->getId() ),
4871 __METHOD__
4872 );
4873 $count = $count + $add;
4874
4875 $dbw = wfGetDB( DB_MASTER );
4876 $dbw->update(
4877 'user',
4878 array( 'user_editcount' => $count ),
4879 array( 'user_id' => $this->getId() ),
4880 __METHOD__
4881 );
4882
4883 return $count;
4884 }
4885
4886 /**
4887 * Get the description of a given right
4888 *
4889 * @param string $right Right to query
4890 * @return string Localized description of the right
4891 */
4892 public static function getRightDescription( $right ) {
4893 $key = "right-$right";
4894 $msg = wfMessage( $key );
4895 return $msg->isBlank() ? $right : $msg->text();
4896 }
4897
4898 /**
4899 * Make a new-style password hash
4900 *
4901 * @param string $password Plain-text password
4902 * @param bool|string $salt Optional salt, may be random or the user ID.
4903 * If unspecified or false, will generate one automatically
4904 * @return string Password hash
4905 * @deprecated since 1.24, use Password class
4906 */
4907 public static function crypt( $password, $salt = false ) {
4908 wfDeprecated( __METHOD__, '1.24' );
4909 $hash = self::getPasswordFactory()->newFromPlaintext( $password );
4910 return $hash->toString();
4911 }
4912
4913 /**
4914 * Compare a password hash with a plain-text password. Requires the user
4915 * ID if there's a chance that the hash is an old-style hash.
4916 *
4917 * @param string $hash Password hash
4918 * @param string $password Plain-text password to compare
4919 * @param string|bool $userId User ID for old-style password salt
4920 *
4921 * @return bool
4922 * @deprecated since 1.24, use Password class
4923 */
4924 public static function comparePasswords( $hash, $password, $userId = false ) {
4925 wfDeprecated( __METHOD__, '1.24' );
4926
4927 // Check for *really* old password hashes that don't even have a type
4928 // The old hash format was just an md5 hex hash, with no type information
4929 if ( preg_match( '/^[0-9a-f]{32}$/', $hash ) ) {
4930 global $wgPasswordSalt;
4931 if ( $wgPasswordSalt ) {
4932 $password = ":B:{$userId}:{$hash}";
4933 } else {
4934 $password = ":A:{$hash}";
4935 }
4936 }
4937
4938 $hash = self::getPasswordFactory()->newFromCiphertext( $hash );
4939 return $hash->equals( $password );
4940 }
4941
4942 /**
4943 * Add a newuser log entry for this user.
4944 * Before 1.19 the return value was always true.
4945 *
4946 * @param string|bool $action Account creation type.
4947 * - String, one of the following values:
4948 * - 'create' for an anonymous user creating an account for himself.
4949 * This will force the action's performer to be the created user itself,
4950 * no matter the value of $wgUser
4951 * - 'create2' for a logged in user creating an account for someone else
4952 * - 'byemail' when the created user will receive its password by e-mail
4953 * - 'autocreate' when the user is automatically created (such as by CentralAuth).
4954 * - Boolean means whether the account was created by e-mail (deprecated):
4955 * - true will be converted to 'byemail'
4956 * - false will be converted to 'create' if this object is the same as
4957 * $wgUser and to 'create2' otherwise
4958 *
4959 * @param string $reason User supplied reason
4960 *
4961 * @return int|bool True if not $wgNewUserLog; otherwise ID of log item or 0 on failure
4962 */
4963 public function addNewUserLogEntry( $action = false, $reason = '' ) {
4964 global $wgUser, $wgNewUserLog;
4965 if ( empty( $wgNewUserLog ) ) {
4966 return true; // disabled
4967 }
4968
4969 if ( $action === true ) {
4970 $action = 'byemail';
4971 } elseif ( $action === false ) {
4972 if ( $this->equals( $wgUser ) ) {
4973 $action = 'create';
4974 } else {
4975 $action = 'create2';
4976 }
4977 }
4978
4979 if ( $action === 'create' || $action === 'autocreate' ) {
4980 $performer = $this;
4981 } else {
4982 $performer = $wgUser;
4983 }
4984
4985 $logEntry = new ManualLogEntry( 'newusers', $action );
4986 $logEntry->setPerformer( $performer );
4987 $logEntry->setTarget( $this->getUserPage() );
4988 $logEntry->setComment( $reason );
4989 $logEntry->setParameters( array(
4990 '4::userid' => $this->getId(),
4991 ) );
4992 $logid = $logEntry->insert();
4993
4994 if ( $action !== 'autocreate' ) {
4995 $logEntry->publish( $logid );
4996 }
4997
4998 return (int)$logid;
4999 }
5000
5001 /**
5002 * Add an autocreate newuser log entry for this user
5003 * Used by things like CentralAuth and perhaps other authplugins.
5004 * Consider calling addNewUserLogEntry() directly instead.
5005 *
5006 * @return bool
5007 */
5008 public function addNewUserLogEntryAutoCreate() {
5009 $this->addNewUserLogEntry( 'autocreate' );
5010
5011 return true;
5012 }
5013
5014 /**
5015 * Load the user options either from cache, the database or an array
5016 *
5017 * @param array $data Rows for the current user out of the user_properties table
5018 */
5019 protected function loadOptions( $data = null ) {
5020 global $wgContLang;
5021
5022 $this->load();
5023
5024 if ( $this->mOptionsLoaded ) {
5025 return;
5026 }
5027
5028 $this->mOptions = self::getDefaultOptions();
5029
5030 if ( !$this->getId() ) {
5031 // For unlogged-in users, load language/variant options from request.
5032 // There's no need to do it for logged-in users: they can set preferences,
5033 // and handling of page content is done by $pageLang->getPreferredVariant() and such,
5034 // so don't override user's choice (especially when the user chooses site default).
5035 $variant = $wgContLang->getDefaultVariant();
5036 $this->mOptions['variant'] = $variant;
5037 $this->mOptions['language'] = $variant;
5038 $this->mOptionsLoaded = true;
5039 return;
5040 }
5041
5042 // Maybe load from the object
5043 if ( !is_null( $this->mOptionOverrides ) ) {
5044 wfDebug( "User: loading options for user " . $this->getId() . " from override cache.\n" );
5045 foreach ( $this->mOptionOverrides as $key => $value ) {
5046 $this->mOptions[$key] = $value;
5047 }
5048 } else {
5049 if ( !is_array( $data ) ) {
5050 wfDebug( "User: loading options for user " . $this->getId() . " from database.\n" );
5051 // Load from database
5052 $dbr = ( $this->queryFlagsUsed & self::READ_LATEST )
5053 ? wfGetDB( DB_MASTER )
5054 : wfGetDB( DB_SLAVE );
5055
5056 $res = $dbr->select(
5057 'user_properties',
5058 array( 'up_property', 'up_value' ),
5059 array( 'up_user' => $this->getId() ),
5060 __METHOD__
5061 );
5062
5063 $this->mOptionOverrides = array();
5064 $data = array();
5065 foreach ( $res as $row ) {
5066 $data[$row->up_property] = $row->up_value;
5067 }
5068 }
5069 foreach ( $data as $property => $value ) {
5070 $this->mOptionOverrides[$property] = $value;
5071 $this->mOptions[$property] = $value;
5072 }
5073 }
5074
5075 $this->mOptionsLoaded = true;
5076
5077 Hooks::run( 'UserLoadOptions', array( $this, &$this->mOptions ) );
5078 }
5079
5080 /**
5081 * Saves the non-default options for this user, as previously set e.g. via
5082 * setOption(), in the database's "user_properties" (preferences) table.
5083 * Usually used via saveSettings().
5084 */
5085 protected function saveOptions() {
5086 $this->loadOptions();
5087
5088 // Not using getOptions(), to keep hidden preferences in database
5089 $saveOptions = $this->mOptions;
5090
5091 // Allow hooks to abort, for instance to save to a global profile.
5092 // Reset options to default state before saving.
5093 if ( !Hooks::run( 'UserSaveOptions', array( $this, &$saveOptions ) ) ) {
5094 return;
5095 }
5096
5097 $userId = $this->getId();
5098
5099 $insert_rows = array(); // all the new preference rows
5100 foreach ( $saveOptions as $key => $value ) {
5101 // Don't bother storing default values
5102 $defaultOption = self::getDefaultOption( $key );
5103 if ( ( $defaultOption === null && $value !== false && $value !== null )
5104 || $value != $defaultOption
5105 ) {
5106 $insert_rows[] = array(
5107 'up_user' => $userId,
5108 'up_property' => $key,
5109 'up_value' => $value,
5110 );
5111 }
5112 }
5113
5114 $dbw = wfGetDB( DB_MASTER );
5115
5116 $res = $dbw->select( 'user_properties',
5117 array( 'up_property', 'up_value' ), array( 'up_user' => $userId ), __METHOD__ );
5118
5119 // Find prior rows that need to be removed or updated. These rows will
5120 // all be deleted (the later so that INSERT IGNORE applies the new values).
5121 $keysDelete = array();
5122 foreach ( $res as $row ) {
5123 if ( !isset( $saveOptions[$row->up_property] )
5124 || strcmp( $saveOptions[$row->up_property], $row->up_value ) != 0
5125 ) {
5126 $keysDelete[] = $row->up_property;
5127 }
5128 }
5129
5130 if ( count( $keysDelete ) ) {
5131 // Do the DELETE by PRIMARY KEY for prior rows.
5132 // In the past a very large portion of calls to this function are for setting
5133 // 'rememberpassword' for new accounts (a preference that has since been removed).
5134 // Doing a blanket per-user DELETE for new accounts with no rows in the table
5135 // caused gap locks on [max user ID,+infinity) which caused high contention since
5136 // updates would pile up on each other as they are for higher (newer) user IDs.
5137 // It might not be necessary these days, but it shouldn't hurt either.
5138 $dbw->delete( 'user_properties',
5139 array( 'up_user' => $userId, 'up_property' => $keysDelete ), __METHOD__ );
5140 }
5141 // Insert the new preference rows
5142 $dbw->insert( 'user_properties', $insert_rows, __METHOD__, array( 'IGNORE' ) );
5143 }
5144
5145 /**
5146 * Lazily instantiate and return a factory object for making passwords
5147 *
5148 * @return PasswordFactory
5149 */
5150 public static function getPasswordFactory() {
5151 if ( self::$mPasswordFactory === null ) {
5152 self::$mPasswordFactory = new PasswordFactory();
5153 self::$mPasswordFactory->init( RequestContext::getMain()->getConfig() );
5154 }
5155
5156 return self::$mPasswordFactory;
5157 }
5158
5159 /**
5160 * Provide an array of HTML5 attributes to put on an input element
5161 * intended for the user to enter a new password. This may include
5162 * required, title, and/or pattern, depending on $wgMinimalPasswordLength.
5163 *
5164 * Do *not* use this when asking the user to enter his current password!
5165 * Regardless of configuration, users may have invalid passwords for whatever
5166 * reason (e.g., they were set before requirements were tightened up).
5167 * Only use it when asking for a new password, like on account creation or
5168 * ResetPass.
5169 *
5170 * Obviously, you still need to do server-side checking.
5171 *
5172 * NOTE: A combination of bugs in various browsers means that this function
5173 * actually just returns array() unconditionally at the moment. May as
5174 * well keep it around for when the browser bugs get fixed, though.
5175 *
5176 * @todo FIXME: This does not belong here; put it in Html or Linker or somewhere
5177 *
5178 * @return array Array of HTML attributes suitable for feeding to
5179 * Html::element(), directly or indirectly. (Don't feed to Xml::*()!
5180 * That will get confused by the boolean attribute syntax used.)
5181 */
5182 public static function passwordChangeInputAttribs() {
5183 global $wgMinimalPasswordLength;
5184
5185 if ( $wgMinimalPasswordLength == 0 ) {
5186 return array();
5187 }
5188
5189 # Note that the pattern requirement will always be satisfied if the
5190 # input is empty, so we need required in all cases.
5191 #
5192 # @todo FIXME: Bug 23769: This needs to not claim the password is required
5193 # if e-mail confirmation is being used. Since HTML5 input validation
5194 # is b0rked anyway in some browsers, just return nothing. When it's
5195 # re-enabled, fix this code to not output required for e-mail
5196 # registration.
5197 #$ret = array( 'required' );
5198 $ret = array();
5199
5200 # We can't actually do this right now, because Opera 9.6 will print out
5201 # the entered password visibly in its error message! When other
5202 # browsers add support for this attribute, or Opera fixes its support,
5203 # we can add support with a version check to avoid doing this on Opera
5204 # versions where it will be a problem. Reported to Opera as
5205 # DSK-262266, but they don't have a public bug tracker for us to follow.
5206 /*
5207 if ( $wgMinimalPasswordLength > 1 ) {
5208 $ret['pattern'] = '.{' . intval( $wgMinimalPasswordLength ) . ',}';
5209 $ret['title'] = wfMessage( 'passwordtooshort' )
5210 ->numParams( $wgMinimalPasswordLength )->text();
5211 }
5212 */
5213
5214 return $ret;
5215 }
5216
5217 /**
5218 * Return the list of user fields that should be selected to create
5219 * a new user object.
5220 * @return array
5221 */
5222 public static function selectFields() {
5223 return array(
5224 'user_id',
5225 'user_name',
5226 'user_real_name',
5227 'user_email',
5228 'user_touched',
5229 'user_token',
5230 'user_email_authenticated',
5231 'user_email_token',
5232 'user_email_token_expires',
5233 'user_registration',
5234 'user_editcount',
5235 );
5236 }
5237
5238 /**
5239 * Factory function for fatal permission-denied errors
5240 *
5241 * @since 1.22
5242 * @param string $permission User right required
5243 * @return Status
5244 */
5245 static function newFatalPermissionDeniedStatus( $permission ) {
5246 global $wgLang;
5247
5248 $groups = array_map(
5249 array( 'User', 'makeGroupLinkWiki' ),
5250 User::getGroupsWithPermission( $permission )
5251 );
5252
5253 if ( $groups ) {
5254 return Status::newFatal( 'badaccess-groups', $wgLang->commaList( $groups ), count( $groups ) );
5255 } else {
5256 return Status::newFatal( 'badaccess-group0' );
5257 }
5258 }
5259
5260 /**
5261 * Checks if two user objects point to the same user.
5262 *
5263 * @since 1.25
5264 * @param User $user
5265 * @return bool
5266 */
5267 public function equals( User $user ) {
5268 return $this->getName() === $user->getName();
5269 }
5270 }
Wiklou, le Wiki du Wiklou