dépôts / lhc / web / wiklou.git / blob
? search:


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