WordPress 4.5
[autoinstalls/wordpress.git] / wp-includes / user.php
1 <?php
2 /**
3  * Core User API
4  *
5  * @package WordPress
6  * @subpackage Users
7  */
8
9 /**
10  * Authenticates and logs a user in with 'remember' capability.
11  *
12  * The credentials is an array that has 'user_login', 'user_password', and
13  * 'remember' indices. If the credentials is not given, then the log in form
14  * will be assumed and used if set.
15  *
16  * The various authentication cookies will be set by this function and will be
17  * set for a longer period depending on if the 'remember' credential is set to
18  * true.
19  *
20  * @since 2.5.0
21  *
22  * @global string $auth_secure_cookie
23  *
24  * @param array       $credentials   Optional. User info in order to sign on.
25  * @param string|bool $secure_cookie Optional. Whether to use secure cookie.
26  * @return WP_User|WP_Error WP_User on success, WP_Error on failure.
27  */
28 function wp_signon( $credentials = array(), $secure_cookie = '' ) {
29         if ( empty($credentials) ) {
30                 if ( ! empty($_POST['log']) )
31                         $credentials['user_login'] = $_POST['log'];
32                 if ( ! empty($_POST['pwd']) )
33                         $credentials['user_password'] = $_POST['pwd'];
34                 if ( ! empty($_POST['rememberme']) )
35                         $credentials['remember'] = $_POST['rememberme'];
36         }
37
38         if ( !empty($credentials['remember']) )
39                 $credentials['remember'] = true;
40         else
41                 $credentials['remember'] = false;
42
43         /**
44          * Fires before the user is authenticated.
45          *
46          * The variables passed to the callbacks are passed by reference,
47          * and can be modified by callback functions.
48          *
49          * @since 1.5.1
50          *
51          * @todo Decide whether to deprecate the wp_authenticate action.
52          *
53          * @param string $user_login    Username, passed by reference.
54          * @param string $user_password User password, passed by reference.
55          */
56         do_action_ref_array( 'wp_authenticate', array( &$credentials['user_login'], &$credentials['user_password'] ) );
57
58         if ( '' === $secure_cookie )
59                 $secure_cookie = is_ssl();
60
61         /**
62          * Filter whether to use a secure sign-on cookie.
63          *
64          * @since 3.1.0
65          *
66          * @param bool  $secure_cookie Whether to use a secure sign-on cookie.
67          * @param array $credentials {
68          *     Array of entered sign-on data.
69          *
70          *     @type string $user_login    Username.
71          *     @type string $user_password Password entered.
72          *     @type bool   $remember      Whether to 'remember' the user. Increases the time
73          *                                 that the cookie will be kept. Default false.
74          * }
75          */
76         $secure_cookie = apply_filters( 'secure_signon_cookie', $secure_cookie, $credentials );
77
78         global $auth_secure_cookie; // XXX ugly hack to pass this to wp_authenticate_cookie
79         $auth_secure_cookie = $secure_cookie;
80
81         add_filter('authenticate', 'wp_authenticate_cookie', 30, 3);
82
83         $user = wp_authenticate($credentials['user_login'], $credentials['user_password']);
84
85         if ( is_wp_error($user) ) {
86                 if ( $user->get_error_codes() == array('empty_username', 'empty_password') ) {
87                         $user = new WP_Error('', '');
88                 }
89
90                 return $user;
91         }
92
93         wp_set_auth_cookie($user->ID, $credentials['remember'], $secure_cookie);
94         /**
95          * Fires after the user has successfully logged in.
96          *
97          * @since 1.5.0
98          *
99          * @param string  $user_login Username.
100          * @param WP_User $user       WP_User object of the logged-in user.
101          */
102         do_action( 'wp_login', $user->user_login, $user );
103         return $user;
104 }
105
106 /**
107  * Authenticate a user, confirming the username and password are valid.
108  *
109  * @since 2.8.0
110  *
111  * @param WP_User|WP_Error|null $user     WP_User or WP_Error object from a previous callback. Default null.
112  * @param string                $username Username for authentication.
113  * @param string                $password Password for authentication.
114  * @return WP_User|WP_Error WP_User on success, WP_Error on failure.
115  */
116 function wp_authenticate_username_password($user, $username, $password) {
117         if ( $user instanceof WP_User ) {
118                 return $user;
119         }
120
121         if ( empty($username) || empty($password) ) {
122                 if ( is_wp_error( $user ) )
123                         return $user;
124
125                 $error = new WP_Error();
126
127                 if ( empty($username) )
128                         $error->add('empty_username', __('<strong>ERROR</strong>: The username field is empty.'));
129
130                 if ( empty($password) )
131                         $error->add('empty_password', __('<strong>ERROR</strong>: The password field is empty.'));
132
133                 return $error;
134         }
135
136         $user = get_user_by('login', $username);
137
138         if ( !$user ) {
139                 return new WP_Error( 'invalid_username',
140                         __( '<strong>ERROR</strong>: Invalid username.' ) .
141                         ' <a href="' . wp_lostpassword_url() . '">' .
142                         __( 'Lost your password?' ) .
143                         '</a>'
144                 );
145         }
146
147         /**
148          * Filter whether the given user can be authenticated with the provided $password.
149          *
150          * @since 2.5.0
151          *
152          * @param WP_User|WP_Error $user     WP_User or WP_Error object if a previous
153          *                                   callback failed authentication.
154          * @param string           $password Password to check against the user.
155          */
156         $user = apply_filters( 'wp_authenticate_user', $user, $password );
157         if ( is_wp_error($user) )
158                 return $user;
159
160         if ( ! wp_check_password( $password, $user->user_pass, $user->ID ) ) {
161                 return new WP_Error( 'incorrect_password',
162                         sprintf(
163                                 /* translators: %s: user name */
164                                 __( '<strong>ERROR</strong>: The password you entered for the username %s is incorrect.' ),
165                                 '<strong>' . $username . '</strong>'
166                         ) .
167                         ' <a href="' . wp_lostpassword_url() . '">' .
168                         __( 'Lost your password?' ) .
169                         '</a>'
170                 );
171         }
172
173         return $user;
174 }
175
176 /**
177  * Authenticates a user using the email and password.
178  *
179  * @since 4.5.0
180  *
181  * @param WP_User|WP_Error|null $user     WP_User or WP_Error object if a previous
182  *                                        callback failed authentication.
183  * @param string                $email    Email address for authentication.
184  * @param string                $password Password for authentication.
185  * @return WP_User|WP_Error WP_User on success, WP_Error on failure.
186  */
187 function wp_authenticate_email_password( $user, $email, $password ) {
188         if ( $user instanceof WP_User ) {
189                 return $user;
190         }
191
192         if ( empty( $email ) || empty( $password ) ) {
193                 if ( is_wp_error( $user ) ) {
194                         return $user;
195                 }
196
197                 $error = new WP_Error();
198
199                 if ( empty( $email ) ) {
200                         $error->add( 'empty_username', __( '<strong>ERROR</strong>: The email field is empty.' ) ); // Uses 'empty_username' for back-compat with wp_signon()
201                 }
202
203                 if ( empty( $password ) ) {
204                         $error->add( 'empty_password', __( '<strong>ERROR</strong>: The password field is empty.' ) );
205                 }
206
207                 return $error;
208         }
209
210         if ( ! is_email( $email ) ) {
211                 return $user;
212         }
213
214         $user = get_user_by( 'email', $email );
215
216         if ( ! $user ) {
217                 return new WP_Error( 'invalid_email',
218                         __( '<strong>ERROR</strong>: Invalid email address.' ) .
219                         ' <a href="' . wp_lostpassword_url() . '">' .
220                         __( 'Lost your password?' ) .
221                         '</a>'
222                 );
223         }
224
225         /** This filter is documented in wp-includes/user.php */
226         $user = apply_filters( 'wp_authenticate_user', $user, $password );
227
228         if ( is_wp_error( $user ) ) {
229                 return $user;
230         }
231
232         if ( ! wp_check_password( $password, $user->user_pass, $user->ID ) ) {
233                 return new WP_Error( 'incorrect_password',
234                         sprintf(
235                                 /* translators: %s: email address */
236                                 __( '<strong>ERROR</strong>: The password you entered for the email address %s is incorrect.' ),
237                                 '<strong>' . $email . '</strong>'
238                         ) .
239                         ' <a href="' . wp_lostpassword_url() . '">' .
240                         __( 'Lost your password?' ) .
241                         '</a>'
242                 );
243         }
244
245         return $user;
246 }
247
248 /**
249  * Authenticate the user using the WordPress auth cookie.
250  *
251  * @since 2.8.0
252  *
253  * @global string $auth_secure_cookie
254  *
255  * @param WP_User|WP_Error|null $user     WP_User or WP_Error object from a previous callback. Default null.
256  * @param string                $username Username. If not empty, cancels the cookie authentication.
257  * @param string                $password Password. If not empty, cancels the cookie authentication.
258  * @return WP_User|WP_Error WP_User on success, WP_Error on failure.
259  */
260 function wp_authenticate_cookie($user, $username, $password) {
261         if ( $user instanceof WP_User ) {
262                 return $user;
263         }
264
265         if ( empty($username) && empty($password) ) {
266                 $user_id = wp_validate_auth_cookie();
267                 if ( $user_id )
268                         return new WP_User($user_id);
269
270                 global $auth_secure_cookie;
271
272                 if ( $auth_secure_cookie )
273                         $auth_cookie = SECURE_AUTH_COOKIE;
274                 else
275                         $auth_cookie = AUTH_COOKIE;
276
277                 if ( !empty($_COOKIE[$auth_cookie]) )
278                         return new WP_Error('expired_session', __('Please log in again.'));
279
280                 // If the cookie is not set, be silent.
281         }
282
283         return $user;
284 }
285
286 /**
287  * For Multisite blogs, check if the authenticated user has been marked as a
288  * spammer, or if the user's primary blog has been marked as spam.
289  *
290  * @since 3.7.0
291  *
292  * @param WP_User|WP_Error|null $user WP_User or WP_Error object from a previous callback. Default null.
293  * @return WP_User|WP_Error WP_User on success, WP_Error if the user is considered a spammer.
294  */
295 function wp_authenticate_spam_check( $user ) {
296         if ( $user instanceof WP_User && is_multisite() ) {
297                 /**
298                  * Filter whether the user has been marked as a spammer.
299                  *
300                  * @since 3.7.0
301                  *
302                  * @param bool    $spammed Whether the user is considered a spammer.
303                  * @param WP_User $user    User to check against.
304                  */
305                 $spammed = apply_filters( 'check_is_user_spammed', is_user_spammy(), $user );
306
307                 if ( $spammed )
308                         return new WP_Error( 'spammer_account', __( '<strong>ERROR</strong>: Your account has been marked as a spammer.' ) );
309         }
310         return $user;
311 }
312
313 /**
314  * Validate the logged-in cookie.
315  *
316  * Checks the logged-in cookie if the previous auth cookie could not be
317  * validated and parsed.
318  *
319  * This is a callback for the determine_current_user filter, rather than API.
320  *
321  * @since 3.9.0
322  *
323  * @param int|bool $user_id The user ID (or false) as received from the
324  *                       determine_current_user filter.
325  * @return int|false User ID if validated, false otherwise. If a user ID from
326  *                   an earlier filter callback is received, that value is returned.
327  */
328 function wp_validate_logged_in_cookie( $user_id ) {
329         if ( $user_id ) {
330                 return $user_id;
331         }
332
333         if ( is_blog_admin() || is_network_admin() || empty( $_COOKIE[LOGGED_IN_COOKIE] ) ) {
334                 return false;
335         }
336
337         return wp_validate_auth_cookie( $_COOKIE[LOGGED_IN_COOKIE], 'logged_in' );
338 }
339
340 /**
341  * Number of posts user has written.
342  *
343  * @since 3.0.0
344  * @since 4.1.0 Added `$post_type` argument.
345  * @since 4.3.0 Added `$public_only` argument. Added the ability to pass an array
346  *              of post types to `$post_type`.
347  *
348  * @global wpdb $wpdb WordPress database abstraction object.
349  *
350  * @param int          $userid      User ID.
351  * @param array|string $post_type   Optional. Single post type or array of post types to count the number of posts for. Default 'post'.
352  * @param bool         $public_only Optional. Whether to only return counts for public posts. Default false.
353  * @return string Number of posts the user has written in this post type.
354  */
355 function count_user_posts( $userid, $post_type = 'post', $public_only = false ) {
356         global $wpdb;
357
358         $where = get_posts_by_author_sql( $post_type, true, $userid, $public_only );
359
360         $count = $wpdb->get_var( "SELECT COUNT(*) FROM $wpdb->posts $where" );
361
362         /**
363          * Filter the number of posts a user has written.
364          *
365          * @since 2.7.0
366          * @since 4.1.0 Added `$post_type` argument.
367          * @since 4.3.1 Added `$public_only` argument.
368          *
369          * @param int          $count       The user's post count.
370          * @param int          $userid      User ID.
371          * @param string|array $post_type   Single post type or array of post types to count the number of posts for.
372          * @param bool         $public_only Whether to limit counted posts to public posts.
373          */
374         return apply_filters( 'get_usernumposts', $count, $userid, $post_type, $public_only );
375 }
376
377 /**
378  * Number of posts written by a list of users.
379  *
380  * @since 3.0.0
381  *
382  * @global wpdb $wpdb WordPress database abstraction object.
383  *
384  * @param array        $users       Array of user IDs.
385  * @param string|array $post_type   Optional. Single post type or array of post types to check. Defaults to 'post'.
386  * @param bool         $public_only Optional. Only return counts for public posts.  Defaults to false.
387  * @return array Amount of posts each user has written.
388  */
389 function count_many_users_posts( $users, $post_type = 'post', $public_only = false ) {
390         global $wpdb;
391
392         $count = array();
393         if ( empty( $users ) || ! is_array( $users ) )
394                 return $count;
395
396         $userlist = implode( ',', array_map( 'absint', $users ) );
397         $where = get_posts_by_author_sql( $post_type, true, null, $public_only );
398
399         $result = $wpdb->get_results( "SELECT post_author, COUNT(*) FROM $wpdb->posts $where AND post_author IN ($userlist) GROUP BY post_author", ARRAY_N );
400         foreach ( $result as $row ) {
401                 $count[ $row[0] ] = $row[1];
402         }
403
404         foreach ( $users as $id ) {
405                 if ( ! isset( $count[ $id ] ) )
406                         $count[ $id ] = 0;
407         }
408
409         return $count;
410 }
411
412 //
413 // User option functions
414 //
415
416 /**
417  * Get the current user's ID
418  *
419  * @since MU
420  *
421  * @return int The current user's ID
422  */
423 function get_current_user_id() {
424         if ( ! function_exists( 'wp_get_current_user' ) )
425                 return 0;
426         $user = wp_get_current_user();
427         return ( isset( $user->ID ) ? (int) $user->ID : 0 );
428 }
429
430 /**
431  * Retrieve user option that can be either per Site or per Network.
432  *
433  * If the user ID is not given, then the current user will be used instead. If
434  * the user ID is given, then the user data will be retrieved. The filter for
435  * the result, will also pass the original option name and finally the user data
436  * object as the third parameter.
437  *
438  * The option will first check for the per site name and then the per Network name.
439  *
440  * @since 2.0.0
441  *
442  * @global wpdb $wpdb WordPress database abstraction object.
443  *
444  * @param string $option     User option name.
445  * @param int    $user       Optional. User ID.
446  * @param string $deprecated Use get_option() to check for an option in the options table.
447  * @return mixed User option value on success, false on failure.
448  */
449 function get_user_option( $option, $user = 0, $deprecated = '' ) {
450         global $wpdb;
451
452         if ( !empty( $deprecated ) )
453                 _deprecated_argument( __FUNCTION__, '3.0' );
454
455         if ( empty( $user ) )
456                 $user = get_current_user_id();
457
458         if ( ! $user = get_userdata( $user ) )
459                 return false;
460
461         $prefix = $wpdb->get_blog_prefix();
462         if ( $user->has_prop( $prefix . $option ) ) // Blog specific
463                 $result = $user->get( $prefix . $option );
464         elseif ( $user->has_prop( $option ) ) // User specific and cross-blog
465                 $result = $user->get( $option );
466         else
467                 $result = false;
468
469         /**
470          * Filter a specific user option value.
471          *
472          * The dynamic portion of the hook name, `$option`, refers to the user option name.
473          *
474          * @since 2.5.0
475          *
476          * @param mixed   $result Value for the user's option.
477          * @param string  $option Name of the option being retrieved.
478          * @param WP_User $user   WP_User object of the user whose option is being retrieved.
479          */
480         return apply_filters( "get_user_option_{$option}", $result, $option, $user );
481 }
482
483 /**
484  * Update user option with global blog capability.
485  *
486  * User options are just like user metadata except that they have support for
487  * global blog options. If the 'global' parameter is false, which it is by default
488  * it will prepend the WordPress table prefix to the option name.
489  *
490  * Deletes the user option if $newvalue is empty.
491  *
492  * @since 2.0.0
493  *
494  * @global wpdb $wpdb WordPress database abstraction object.
495  *
496  * @param int    $user_id     User ID.
497  * @param string $option_name User option name.
498  * @param mixed  $newvalue    User option value.
499  * @param bool   $global      Optional. Whether option name is global or blog specific.
500  *                            Default false (blog specific).
501  * @return int|bool User meta ID if the option didn't exist, true on successful update,
502  *                  false on failure.
503  */
504 function update_user_option( $user_id, $option_name, $newvalue, $global = false ) {
505         global $wpdb;
506
507         if ( !$global )
508                 $option_name = $wpdb->get_blog_prefix() . $option_name;
509
510         return update_user_meta( $user_id, $option_name, $newvalue );
511 }
512
513 /**
514  * Delete user option with global blog capability.
515  *
516  * User options are just like user metadata except that they have support for
517  * global blog options. If the 'global' parameter is false, which it is by default
518  * it will prepend the WordPress table prefix to the option name.
519  *
520  * @since 3.0.0
521  *
522  * @global wpdb $wpdb WordPress database abstraction object.
523  *
524  * @param int    $user_id     User ID
525  * @param string $option_name User option name.
526  * @param bool   $global      Optional. Whether option name is global or blog specific.
527  *                            Default false (blog specific).
528  * @return bool True on success, false on failure.
529  */
530 function delete_user_option( $user_id, $option_name, $global = false ) {
531         global $wpdb;
532
533         if ( !$global )
534                 $option_name = $wpdb->get_blog_prefix() . $option_name;
535         return delete_user_meta( $user_id, $option_name );
536 }
537
538 /**
539  * Retrieve list of users matching criteria.
540  *
541  * @since 3.1.0
542  *
543  * @see WP_User_Query
544  *
545  * @param array $args Optional. Arguments to retrieve users. See {@see WP_User_Query::prepare_query()}
546  *                    for more information on accepted arguments.
547  * @return array List of users.
548  */
549 function get_users( $args = array() ) {
550
551         $args = wp_parse_args( $args );
552         $args['count_total'] = false;
553
554         $user_search = new WP_User_Query($args);
555
556         return (array) $user_search->get_results();
557 }
558
559 /**
560  * Get the blogs a user belongs to.
561  *
562  * @since 3.0.0
563  *
564  * @global wpdb $wpdb WordPress database abstraction object.
565  *
566  * @param int  $user_id User ID
567  * @param bool $all     Whether to retrieve all blogs, or only blogs that are not
568  *                      marked as deleted, archived, or spam.
569  * @return array A list of the user's blogs. An empty array if the user doesn't exist
570  *               or belongs to no blogs.
571  */
572 function get_blogs_of_user( $user_id, $all = false ) {
573         global $wpdb;
574
575         $user_id = (int) $user_id;
576
577         // Logged out users can't have blogs
578         if ( empty( $user_id ) )
579                 return array();
580
581         $keys = get_user_meta( $user_id );
582         if ( empty( $keys ) )
583                 return array();
584
585         if ( ! is_multisite() ) {
586                 $blog_id = get_current_blog_id();
587                 $blogs = array( $blog_id => new stdClass );
588                 $blogs[ $blog_id ]->userblog_id = $blog_id;
589                 $blogs[ $blog_id ]->blogname = get_option('blogname');
590                 $blogs[ $blog_id ]->domain = '';
591                 $blogs[ $blog_id ]->path = '';
592                 $blogs[ $blog_id ]->site_id = 1;
593                 $blogs[ $blog_id ]->siteurl = get_option('siteurl');
594                 $blogs[ $blog_id ]->archived = 0;
595                 $blogs[ $blog_id ]->spam = 0;
596                 $blogs[ $blog_id ]->deleted = 0;
597                 return $blogs;
598         }
599
600         $blogs = array();
601
602         if ( isset( $keys[ $wpdb->base_prefix . 'capabilities' ] ) && defined( 'MULTISITE' ) ) {
603                 $blog = get_blog_details( 1 );
604                 if ( $blog && isset( $blog->domain ) && ( $all || ( ! $blog->archived && ! $blog->spam && ! $blog->deleted ) ) ) {
605                         $blogs[ 1 ] = (object) array(
606                                 'userblog_id' => 1,
607                                 'blogname'    => $blog->blogname,
608                                 'domain'      => $blog->domain,
609                                 'path'        => $blog->path,
610                                 'site_id'     => $blog->site_id,
611                                 'siteurl'     => $blog->siteurl,
612                                 'archived'    => $blog->archived,
613                                 'mature'      => $blog->mature,
614                                 'spam'        => $blog->spam,
615                                 'deleted'     => $blog->deleted,
616                         );
617                 }
618                 unset( $keys[ $wpdb->base_prefix . 'capabilities' ] );
619         }
620
621         $keys = array_keys( $keys );
622
623         foreach ( $keys as $key ) {
624                 if ( 'capabilities' !== substr( $key, -12 ) )
625                         continue;
626                 if ( $wpdb->base_prefix && 0 !== strpos( $key, $wpdb->base_prefix ) )
627                         continue;
628                 $blog_id = str_replace( array( $wpdb->base_prefix, '_capabilities' ), '', $key );
629                 if ( ! is_numeric( $blog_id ) )
630                         continue;
631
632                 $blog_id = (int) $blog_id;
633                 $blog = get_blog_details( $blog_id );
634                 if ( $blog && isset( $blog->domain ) && ( $all || ( ! $blog->archived && ! $blog->spam && ! $blog->deleted ) ) ) {
635                         $blogs[ $blog_id ] = (object) array(
636                                 'userblog_id' => $blog_id,
637                                 'blogname'    => $blog->blogname,
638                                 'domain'      => $blog->domain,
639                                 'path'        => $blog->path,
640                                 'site_id'     => $blog->site_id,
641                                 'siteurl'     => $blog->siteurl,
642                                 'archived'    => $blog->archived,
643                                 'mature'      => $blog->mature,
644                                 'spam'        => $blog->spam,
645                                 'deleted'     => $blog->deleted,
646                         );
647                 }
648         }
649
650         /**
651          * Filter the list of blogs a user belongs to.
652          *
653          * @since MU
654          *
655          * @param array $blogs   An array of blog objects belonging to the user.
656          * @param int   $user_id User ID.
657          * @param bool  $all     Whether the returned blogs array should contain all blogs, including
658          *                       those marked 'deleted', 'archived', or 'spam'. Default false.
659          */
660         return apply_filters( 'get_blogs_of_user', $blogs, $user_id, $all );
661 }
662
663 /**
664  * Find out whether a user is a member of a given blog.
665  *
666  * @since MU 1.1
667  *
668  * @param int $user_id Optional. The unique ID of the user. Defaults to the current user.
669  * @param int $blog_id Optional. ID of the blog to check. Defaults to the current site.
670  * @return bool
671  */
672 function is_user_member_of_blog( $user_id = 0, $blog_id = 0 ) {
673         global $wpdb;
674
675         $user_id = (int) $user_id;
676         $blog_id = (int) $blog_id;
677
678         if ( empty( $user_id ) ) {
679                 $user_id = get_current_user_id();
680         }
681
682         // Technically not needed, but does save calls to get_blog_details and get_user_meta
683         // in the event that the function is called when a user isn't logged in
684         if ( empty( $user_id ) ) {
685                 return false;
686         } else {
687                 $user = get_userdata( $user_id );
688                 if ( ! $user instanceof WP_User ) {
689                         return false;
690                 }
691         }
692
693         if ( ! is_multisite() ) {
694                 return true;
695         }
696
697         if ( empty( $blog_id ) ) {
698                 $blog_id = get_current_blog_id();
699         }
700
701         $blog = get_blog_details( $blog_id );
702
703         if ( ! $blog || ! isset( $blog->domain ) || $blog->archived || $blog->spam || $blog->deleted ) {
704                 return false;
705         }
706
707         $keys = get_user_meta( $user_id );
708         if ( empty( $keys ) ) {
709                 return false;
710         }
711
712         // no underscore before capabilities in $base_capabilities_key
713         $base_capabilities_key = $wpdb->base_prefix . 'capabilities';
714         $site_capabilities_key = $wpdb->base_prefix . $blog_id . '_capabilities';
715
716         if ( isset( $keys[ $base_capabilities_key ] ) && $blog_id == 1 ) {
717                 return true;
718         }
719
720         if ( isset( $keys[ $site_capabilities_key ] ) ) {
721                 return true;
722         }
723
724         return false;
725 }
726
727 /**
728  * Add meta data field to a user.
729  *
730  * Post meta data is called "Custom Fields" on the Administration Screens.
731  *
732  * @since 3.0.0
733  * @link https://codex.wordpress.org/Function_Reference/add_user_meta
734  *
735  * @param int    $user_id    User ID.
736  * @param string $meta_key   Metadata name.
737  * @param mixed  $meta_value Metadata value.
738  * @param bool   $unique     Optional, default is false. Whether the same key should not be added.
739  * @return int|false Meta ID on success, false on failure.
740  */
741 function add_user_meta($user_id, $meta_key, $meta_value, $unique = false) {
742         return add_metadata('user', $user_id, $meta_key, $meta_value, $unique);
743 }
744
745 /**
746  * Remove metadata matching criteria from a user.
747  *
748  * You can match based on the key, or key and value. Removing based on key and
749  * value, will keep from removing duplicate metadata with the same key. It also
750  * allows removing all metadata matching key, if needed.
751  *
752  * @since 3.0.0
753  * @link https://codex.wordpress.org/Function_Reference/delete_user_meta
754  *
755  * @param int    $user_id    User ID
756  * @param string $meta_key   Metadata name.
757  * @param mixed  $meta_value Optional. Metadata value.
758  * @return bool True on success, false on failure.
759  */
760 function delete_user_meta($user_id, $meta_key, $meta_value = '') {
761         return delete_metadata('user', $user_id, $meta_key, $meta_value);
762 }
763
764 /**
765  * Retrieve user meta field for a user.
766  *
767  * @since 3.0.0
768  * @link https://codex.wordpress.org/Function_Reference/get_user_meta
769  *
770  * @param int    $user_id User ID.
771  * @param string $key     Optional. The meta key to retrieve. By default, returns data for all keys.
772  * @param bool   $single  Whether to return a single value.
773  * @return mixed Will be an array if $single is false. Will be value of meta data field if $single is true.
774  */
775 function get_user_meta($user_id, $key = '', $single = false) {
776         return get_metadata('user', $user_id, $key, $single);
777 }
778
779 /**
780  * Update user meta field based on user ID.
781  *
782  * Use the $prev_value parameter to differentiate between meta fields with the
783  * same key and user ID.
784  *
785  * If the meta field for the user does not exist, it will be added.
786  *
787  * @since 3.0.0
788  * @link https://codex.wordpress.org/Function_Reference/update_user_meta
789  *
790  * @param int    $user_id    User ID.
791  * @param string $meta_key   Metadata key.
792  * @param mixed  $meta_value Metadata value.
793  * @param mixed  $prev_value Optional. Previous value to check before removing.
794  * @return int|bool Meta ID if the key didn't exist, true on successful update, false on failure.
795  */
796 function update_user_meta($user_id, $meta_key, $meta_value, $prev_value = '') {
797         return update_metadata('user', $user_id, $meta_key, $meta_value, $prev_value);
798 }
799
800 /**
801  * Count number of users who have each of the user roles.
802  *
803  * Assumes there are neither duplicated nor orphaned capabilities meta_values.
804  * Assumes role names are unique phrases. Same assumption made by WP_User_Query::prepare_query()
805  * Using $strategy = 'time' this is CPU-intensive and should handle around 10^7 users.
806  * Using $strategy = 'memory' this is memory-intensive and should handle around 10^5 users, but see WP Bug #12257.
807  *
808  * @since 3.0.0
809  * @since 4.4.0 The number of users with no role is now included in the `none` element.
810  *
811  * @global wpdb $wpdb WordPress database abstraction object.
812  *
813  * @param string $strategy 'time' or 'memory'
814  * @return array Includes a grand total and an array of counts indexed by role strings.
815  */
816 function count_users($strategy = 'time') {
817         global $wpdb;
818
819         // Initialize
820         $id = get_current_blog_id();
821         $blog_prefix = $wpdb->get_blog_prefix($id);
822         $result = array();
823
824         if ( 'time' == $strategy ) {
825                 $avail_roles = wp_roles()->get_names();
826
827                 // Build a CPU-intensive query that will return concise information.
828                 $select_count = array();
829                 foreach ( $avail_roles as $this_role => $name ) {
830                         $select_count[] = $wpdb->prepare( "COUNT(NULLIF(`meta_value` LIKE %s, false))", '%' . $wpdb->esc_like( '"' . $this_role . '"' ) . '%');
831                 }
832                 $select_count[] = "COUNT(NULLIF(`meta_value` = 'a:0:{}', false))";
833                 $select_count = implode(', ', $select_count);
834
835                 // Add the meta_value index to the selection list, then run the query.
836                 $row = $wpdb->get_row( "SELECT $select_count, COUNT(*) FROM $wpdb->usermeta WHERE meta_key = '{$blog_prefix}capabilities'", ARRAY_N );
837
838                 // Run the previous loop again to associate results with role names.
839                 $col = 0;
840                 $role_counts = array();
841                 foreach ( $avail_roles as $this_role => $name ) {
842                         $count = (int) $row[$col++];
843                         if ($count > 0) {
844                                 $role_counts[$this_role] = $count;
845                         }
846                 }
847
848                 $role_counts['none'] = (int) $row[$col++];
849
850                 // Get the meta_value index from the end of the result set.
851                 $total_users = (int) $row[$col];
852
853                 $result['total_users'] = $total_users;
854                 $result['avail_roles'] =& $role_counts;
855         } else {
856                 $avail_roles = array(
857                         'none' => 0,
858                 );
859
860                 $users_of_blog = $wpdb->get_col( "SELECT meta_value FROM $wpdb->usermeta WHERE meta_key = '{$blog_prefix}capabilities'" );
861
862                 foreach ( $users_of_blog as $caps_meta ) {
863                         $b_roles = maybe_unserialize($caps_meta);
864                         if ( ! is_array( $b_roles ) )
865                                 continue;
866                         if ( empty( $b_roles ) ) {
867                                 $avail_roles['none']++;
868                         }
869                         foreach ( $b_roles as $b_role => $val ) {
870                                 if ( isset($avail_roles[$b_role]) ) {
871                                         $avail_roles[$b_role]++;
872                                 } else {
873                                         $avail_roles[$b_role] = 1;
874                                 }
875                         }
876                 }
877
878                 $result['total_users'] = count( $users_of_blog );
879                 $result['avail_roles'] =& $avail_roles;
880         }
881
882         if ( is_multisite() ) {
883                 $result['avail_roles']['none'] = 0;
884         }
885
886         return $result;
887 }
888
889 //
890 // Private helper functions
891 //
892
893 /**
894  * Set up global user vars.
895  *
896  * Used by wp_set_current_user() for back compat. Might be deprecated in the future.
897  *
898  * @since 2.0.4
899  *
900  * @global string $user_login    The user username for logging in
901  * @global object $userdata      User data.
902  * @global int    $user_level    The level of the user
903  * @global int    $user_ID       The ID of the user
904  * @global string $user_email    The email address of the user
905  * @global string $user_url      The url in the user's profile
906  * @global string $user_identity The display name of the user
907  *
908  * @param int $for_user_id Optional. User ID to set up global data.
909  */
910 function setup_userdata($for_user_id = '') {
911         global $user_login, $userdata, $user_level, $user_ID, $user_email, $user_url, $user_identity;
912
913         if ( '' == $for_user_id )
914                 $for_user_id = get_current_user_id();
915         $user = get_userdata( $for_user_id );
916
917         if ( ! $user ) {
918                 $user_ID = 0;
919                 $user_level = 0;
920                 $userdata = null;
921                 $user_login = $user_email = $user_url = $user_identity = '';
922                 return;
923         }
924
925         $user_ID    = (int) $user->ID;
926         $user_level = (int) $user->user_level;
927         $userdata   = $user;
928         $user_login = $user->user_login;
929         $user_email = $user->user_email;
930         $user_url   = $user->user_url;
931         $user_identity = $user->display_name;
932 }
933
934 /**
935  * Create dropdown HTML content of users.
936  *
937  * The content can either be displayed, which it is by default or retrieved by
938  * setting the 'echo' argument. The 'include' and 'exclude' arguments do not
939  * need to be used; all users will be displayed in that case. Only one can be
940  * used, either 'include' or 'exclude', but not both.
941  *
942  * The available arguments are as follows:
943  *
944  * @since 2.3.0
945  * @since 4.5.0 Added the 'display_name_with_login' value for 'show'.
946  *
947  * @global int  $blog_id
948  *
949  * @param array|string $args {
950  *     Optional. Array or string of arguments to generate a drop-down of users.
951  *     {@see WP_User_Query::prepare_query() for additional available arguments.
952  *
953  *     @type string       $show_option_all         Text to show as the drop-down default (all).
954  *                                                 Default empty.
955  *     @type string       $show_option_none        Text to show as the drop-down default when no
956  *                                                 users were found. Default empty.
957  *     @type int|string   $option_none_value       Value to use for $show_option_non when no users
958  *                                                 were found. Default -1.
959  *     @type string       $hide_if_only_one_author Whether to skip generating the drop-down
960  *                                                 if only one user was found. Default empty.
961  *     @type string       $orderby                 Field to order found users by. Accepts user fields.
962  *                                                 Default 'display_name'.
963  *     @type string       $order                   Whether to order users in ascending or descending
964  *                                                 order. Accepts 'ASC' (ascending) or 'DESC' (descending).
965  *                                                 Default 'ASC'.
966  *     @type array|string $include                 Array or comma-separated list of user IDs to include.
967  *                                                 Default empty.
968  *     @type array|string $exclude                 Array or comma-separated list of user IDs to exclude.
969  *                                                 Default empty.
970  *     @type bool|int     $multi                   Whether to skip the ID attribute on the 'select' element.
971  *                                                 Accepts 1|true or 0|false. Default 0|false.
972  *     @type string       $show                    User data to display. If the selected item is empty
973  *                                                 then the 'user_login' will be displayed in parentheses.
974  *                                                 Accepts any user field, or 'display_name_with_login' to show
975  *                                                 the display name with user_login in parentheses.
976  *                                                 Default 'display_name'.
977  *     @type int|bool     $echo                    Whether to echo or return the drop-down. Accepts 1|true (echo)
978  *                                                 or 0|false (return). Default 1|true.
979  *     @type int          $selected                Which user ID should be selected. Default 0.
980  *     @type bool         $include_selected        Whether to always include the selected user ID in the drop-
981  *                                                 down. Default false.
982  *     @type string       $name                    Name attribute of select element. Default 'user'.
983  *     @type string       $id                      ID attribute of the select element. Default is the value of $name.
984  *     @type string       $class                   Class attribute of the select element. Default empty.
985  *     @type int          $blog_id                 ID of blog (Multisite only). Default is ID of the current blog.
986  *     @type string       $who                     Which type of users to query. Accepts only an empty string or
987  *                                                 'authors'. Default empty.
988  * }
989  * @return string String of HTML content.
990  */
991 function wp_dropdown_users( $args = '' ) {
992         $defaults = array(
993                 'show_option_all' => '', 'show_option_none' => '', 'hide_if_only_one_author' => '',
994                 'orderby' => 'display_name', 'order' => 'ASC',
995                 'include' => '', 'exclude' => '', 'multi' => 0,
996                 'show' => 'display_name', 'echo' => 1,
997                 'selected' => 0, 'name' => 'user', 'class' => '', 'id' => '',
998                 'blog_id' => $GLOBALS['blog_id'], 'who' => '', 'include_selected' => false,
999                 'option_none_value' => -1
1000         );
1001
1002         $defaults['selected'] = is_author() ? get_query_var( 'author' ) : 0;
1003
1004         $r = wp_parse_args( $args, $defaults );
1005
1006         $query_args = wp_array_slice_assoc( $r, array( 'blog_id', 'include', 'exclude', 'orderby', 'order', 'who' ) );
1007
1008         $fields = array( 'ID', 'user_login' );
1009
1010         $show = ! empty( $r['show'] ) ? $r['show'] : 'display_name';
1011         if ( 'display_name_with_login' === $show ) {
1012                 $fields[] = 'display_name';
1013         } else {
1014                 $fields[] = $show;
1015         }
1016
1017         $query_args['fields'] = $fields;
1018
1019         $show_option_all = $r['show_option_all'];
1020         $show_option_none = $r['show_option_none'];
1021         $option_none_value = $r['option_none_value'];
1022
1023         /**
1024          * Filter the query arguments for the user drop-down.
1025          *
1026          * @since 4.4.0
1027          *
1028          * @param array $query_args The query arguments for wp_dropdown_users().
1029          * @param array $r          The default arguments for wp_dropdown_users().
1030          */
1031         $query_args = apply_filters( 'wp_dropdown_users_args', $query_args, $r );
1032
1033         $users = get_users( $query_args );
1034
1035         $output = '';
1036         if ( ! empty( $users ) && ( empty( $r['hide_if_only_one_author'] ) || count( $users ) > 1 ) ) {
1037                 $name = esc_attr( $r['name'] );
1038                 if ( $r['multi'] && ! $r['id'] ) {
1039                         $id = '';
1040                 } else {
1041                         $id = $r['id'] ? " id='" . esc_attr( $r['id'] ) . "'" : " id='$name'";
1042                 }
1043                 $output = "<select name='{$name}'{$id} class='" . $r['class'] . "'>\n";
1044
1045                 if ( $show_option_all ) {
1046                         $output .= "\t<option value='0'>$show_option_all</option>\n";
1047                 }
1048
1049                 if ( $show_option_none ) {
1050                         $_selected = selected( $option_none_value, $r['selected'], false );
1051                         $output .= "\t<option value='" . esc_attr( $option_none_value ) . "'$_selected>$show_option_none</option>\n";
1052                 }
1053
1054                 if ( $r['include_selected'] && ( $r['selected'] > 0 ) ) {
1055                         $found_selected = false;
1056                         $r['selected'] = (int) $r['selected'];
1057                         foreach ( (array) $users as $user ) {
1058                                 $user->ID = (int) $user->ID;
1059                                 if ( $user->ID === $r['selected'] ) {
1060                                         $found_selected = true;
1061                                 }
1062                         }
1063
1064                         if ( ! $found_selected ) {
1065                                 $users[] = get_userdata( $r['selected'] );
1066                         }
1067                 }
1068
1069                 foreach ( (array) $users as $user ) {
1070                         if ( 'display_name_with_login' === $show ) {
1071                                 /* translators: 1: display name, 2: user_login */
1072                                 $display = sprintf( _x( '%1$s (%2$s)', 'user dropdown' ), $user->display_name, $user->user_login );
1073                         } elseif ( ! empty( $user->$show ) ) {
1074                                 $display = $user->$show;
1075                         } else {
1076                                 $display = '(' . $user->user_login . ')';
1077                         }
1078
1079                         $_selected = selected( $user->ID, $r['selected'], false );
1080                         $output .= "\t<option value='$user->ID'$_selected>" . esc_html( $display ) . "</option>\n";
1081                 }
1082
1083                 $output .= "</select>";
1084         }
1085
1086         /**
1087          * Filter the wp_dropdown_users() HTML output.
1088          *
1089          * @since 2.3.0
1090          *
1091          * @param string $output HTML output generated by wp_dropdown_users().
1092          */
1093         $html = apply_filters( 'wp_dropdown_users', $output );
1094
1095         if ( $r['echo'] ) {
1096                 echo $html;
1097         }
1098         return $html;
1099 }
1100
1101 /**
1102  * Sanitize user field based on context.
1103  *
1104  * Possible context values are:  'raw', 'edit', 'db', 'display', 'attribute' and 'js'. The
1105  * 'display' context is used by default. 'attribute' and 'js' contexts are treated like 'display'
1106  * when calling filters.
1107  *
1108  * @since 2.3.0
1109  *
1110  * @param string $field   The user Object field name.
1111  * @param mixed  $value   The user Object value.
1112  * @param int    $user_id User ID.
1113  * @param string $context How to sanitize user fields. Looks for 'raw', 'edit', 'db', 'display',
1114  *                        'attribute' and 'js'.
1115  * @return mixed Sanitized value.
1116  */
1117 function sanitize_user_field($field, $value, $user_id, $context) {
1118         $int_fields = array('ID');
1119         if ( in_array($field, $int_fields) )
1120                 $value = (int) $value;
1121
1122         if ( 'raw' == $context )
1123                 return $value;
1124
1125         if ( !is_string($value) && !is_numeric($value) )
1126                 return $value;
1127
1128         $prefixed = false !== strpos( $field, 'user_' );
1129
1130         if ( 'edit' == $context ) {
1131                 if ( $prefixed ) {
1132
1133                         /** This filter is documented in wp-includes/post.php */
1134                         $value = apply_filters( "edit_{$field}", $value, $user_id );
1135                 } else {
1136
1137                         /**
1138                          * Filter a user field value in the 'edit' context.
1139                          *
1140                          * The dynamic portion of the hook name, `$field`, refers to the prefixed user
1141                          * field being filtered, such as 'user_login', 'user_email', 'first_name', etc.
1142                          *
1143                          * @since 2.9.0
1144                          *
1145                          * @param mixed $value   Value of the prefixed user field.
1146                          * @param int   $user_id User ID.
1147                          */
1148                         $value = apply_filters( "edit_user_{$field}", $value, $user_id );
1149                 }
1150
1151                 if ( 'description' == $field )
1152                         $value = esc_html( $value ); // textarea_escaped?
1153                 else
1154                         $value = esc_attr($value);
1155         } elseif ( 'db' == $context ) {
1156                 if ( $prefixed ) {
1157                         /** This filter is documented in wp-includes/post.php */
1158                         $value = apply_filters( "pre_{$field}", $value );
1159                 } else {
1160
1161                         /**
1162                          * Filter the value of a user field in the 'db' context.
1163                          *
1164                          * The dynamic portion of the hook name, `$field`, refers to the prefixed user
1165                          * field being filtered, such as 'user_login', 'user_email', 'first_name', etc.
1166                          *
1167                          * @since 2.9.0
1168                          *
1169                          * @param mixed $value Value of the prefixed user field.
1170                          */
1171                         $value = apply_filters( "pre_user_{$field}", $value );
1172                 }
1173         } else {
1174                 // Use display filters by default.
1175                 if ( $prefixed ) {
1176
1177                         /** This filter is documented in wp-includes/post.php */
1178                         $value = apply_filters( $field, $value, $user_id, $context );
1179                 } else {
1180
1181                         /**
1182                          * Filter the value of a user field in a standard context.
1183                          *
1184                          * The dynamic portion of the hook name, `$field`, refers to the prefixed user
1185                          * field being filtered, such as 'user_login', 'user_email', 'first_name', etc.
1186                          *
1187                          * @since 2.9.0
1188                          *
1189                          * @param mixed  $value   The user object value to sanitize.
1190                          * @param int    $user_id User ID.
1191                          * @param string $context The context to filter within.
1192                          */
1193                         $value = apply_filters( "user_{$field}", $value, $user_id, $context );
1194                 }
1195         }
1196
1197         if ( 'user_url' == $field )
1198                 $value = esc_url($value);
1199
1200         if ( 'attribute' == $context ) {
1201                 $value = esc_attr( $value );
1202         } elseif ( 'js' == $context ) {
1203                 $value = esc_js( $value );
1204         }
1205         return $value;
1206 }
1207
1208 /**
1209  * Update all user caches
1210  *
1211  * @since 3.0.0
1212  *
1213  * @param object|WP_User $user User object to be cached
1214  * @return bool|null Returns false on failure.
1215  */
1216 function update_user_caches( $user ) {
1217         if ( $user instanceof WP_User ) {
1218                 if ( ! $user->exists() ) {
1219                         return false;
1220                 }
1221
1222                 $user = $user->data;
1223         }
1224
1225         wp_cache_add($user->ID, $user, 'users');
1226         wp_cache_add($user->user_login, $user->ID, 'userlogins');
1227         wp_cache_add($user->user_email, $user->ID, 'useremail');
1228         wp_cache_add($user->user_nicename, $user->ID, 'userslugs');
1229 }
1230
1231 /**
1232  * Clean all user caches
1233  *
1234  * @since 3.0.0
1235  * @since 4.4.0 'clean_user_cache' action was added.
1236  *
1237  * @param WP_User|int $user User object or ID to be cleaned from the cache
1238  */
1239 function clean_user_cache( $user ) {
1240         if ( is_numeric( $user ) )
1241                 $user = new WP_User( $user );
1242
1243         if ( ! $user->exists() )
1244                 return;
1245
1246         wp_cache_delete( $user->ID, 'users' );
1247         wp_cache_delete( $user->user_login, 'userlogins' );
1248         wp_cache_delete( $user->user_email, 'useremail' );
1249         wp_cache_delete( $user->user_nicename, 'userslugs' );
1250
1251         /**
1252          * Fires immediately after the given user's cache is cleaned.
1253          *
1254          * @since 4.4.0
1255          *
1256          * @param int     $user_id User ID.
1257          * @param WP_User $user    User object.
1258          */
1259         do_action( 'clean_user_cache', $user->ID, $user );
1260 }
1261
1262 /**
1263  * Checks whether the given username exists.
1264  *
1265  * @since 2.0.0
1266  *
1267  * @param string $username Username.
1268  * @return int|false The user's ID on success, and false on failure.
1269  */
1270 function username_exists( $username ) {
1271         if ( $user = get_user_by( 'login', $username ) ) {
1272                 return $user->ID;
1273         }
1274         return false;
1275 }
1276
1277 /**
1278  * Checks whether the given email exists.
1279  *
1280  * @since 2.1.0
1281  *
1282  * @param string $email Email.
1283  * @return int|false The user's ID on success, and false on failure.
1284  */
1285 function email_exists( $email ) {
1286         if ( $user = get_user_by( 'email', $email) ) {
1287                 return $user->ID;
1288         }
1289         return false;
1290 }
1291
1292 /**
1293  * Checks whether a username is valid.
1294  *
1295  * @since 2.0.1
1296  * @since 4.4.0 Empty sanitized usernames are now considered invalid
1297  *
1298  * @param string $username Username.
1299  * @return bool Whether username given is valid
1300  */
1301 function validate_username( $username ) {
1302         $sanitized = sanitize_user( $username, true );
1303         $valid = ( $sanitized == $username && ! empty( $sanitized ) );
1304
1305         /**
1306          * Filter whether the provided username is valid or not.
1307          *
1308          * @since 2.0.1
1309          *
1310          * @param bool   $valid    Whether given username is valid.
1311          * @param string $username Username to check.
1312          */
1313         return apply_filters( 'validate_username', $valid, $username );
1314 }
1315
1316 /**
1317  * Insert a user into the database.
1318  *
1319  * Most of the `$userdata` array fields have filters associated with the values. Exceptions are
1320  * 'ID', 'rich_editing', 'comment_shortcuts', 'admin_color', 'use_ssl',
1321  * 'user_registered', and 'role'. The filters have the prefix 'pre_user_' followed by the field
1322  * name. An example using 'description' would have the filter called, 'pre_user_description' that
1323  * can be hooked into.
1324  *
1325  * @since 2.0.0
1326  * @since 3.6.0 The `aim`, `jabber`, and `yim` fields were removed as default user contact
1327  *              methods for new installs. See wp_get_user_contact_methods().
1328  *
1329  * @global wpdb $wpdb WordPress database abstraction object.
1330  *
1331  * @param array|object|WP_User $userdata {
1332  *     An array, object, or WP_User object of user data arguments.
1333  *
1334  *     @type int         $ID                   User ID. If supplied, the user will be updated.
1335  *     @type string      $user_pass            The plain-text user password.
1336  *     @type string      $user_login           The user's login username.
1337  *     @type string      $user_nicename        The URL-friendly user name.
1338  *     @type string      $user_url             The user URL.
1339  *     @type string      $user_email           The user email address.
1340  *     @type string      $display_name         The user's display name.
1341  *                                             Default is the user's username.
1342  *     @type string      $nickname             The user's nickname.
1343  *                                             Default is the user's username.
1344  *     @type string      $first_name           The user's first name. For new users, will be used
1345  *                                             to build the first part of the user's display name
1346  *                                             if `$display_name` is not specified.
1347  *     @type string      $last_name            The user's last name. For new users, will be used
1348  *                                             to build the second part of the user's display name
1349  *                                             if `$display_name` is not specified.
1350  *     @type string      $description          The user's biographical description.
1351  *     @type string|bool $rich_editing         Whether to enable the rich-editor for the user.
1352  *                                             False if not empty.
1353  *     @type string|bool $comment_shortcuts    Whether to enable comment moderation keyboard
1354  *                                             shortcuts for the user. Default false.
1355  *     @type string      $admin_color          Admin color scheme for the user. Default 'fresh'.
1356  *     @type bool        $use_ssl              Whether the user should always access the admin over
1357  *                                             https. Default false.
1358  *     @type string      $user_registered      Date the user registered. Format is 'Y-m-d H:i:s'.
1359  *     @type string|bool $show_admin_bar_front Whether to display the Admin Bar for the user on the
1360  *                                             site's front end. Default true.
1361  *     @type string      $role                 User's role.
1362  * }
1363  * @return int|WP_Error The newly created user's ID or a WP_Error object if the user could not
1364  *                      be created.
1365  */
1366 function wp_insert_user( $userdata ) {
1367         global $wpdb;
1368
1369         if ( $userdata instanceof stdClass ) {
1370                 $userdata = get_object_vars( $userdata );
1371         } elseif ( $userdata instanceof WP_User ) {
1372                 $userdata = $userdata->to_array();
1373         }
1374
1375         // Are we updating or creating?
1376         if ( ! empty( $userdata['ID'] ) ) {
1377                 $ID = (int) $userdata['ID'];
1378                 $update = true;
1379                 $old_user_data = get_userdata( $ID );
1380
1381                 if ( ! $old_user_data ) {
1382                         return new WP_Error( 'invalid_user_id', __( 'Invalid user ID.' ) );
1383                 }
1384
1385                 // hashed in wp_update_user(), plaintext if called directly
1386                 $user_pass = ! empty( $userdata['user_pass'] ) ? $userdata['user_pass'] : $old_user_data->user_pass;
1387         } else {
1388                 $update = false;
1389                 // Hash the password
1390                 $user_pass = wp_hash_password( $userdata['user_pass'] );
1391         }
1392
1393         $sanitized_user_login = sanitize_user( $userdata['user_login'], true );
1394
1395         /**
1396          * Filter a username after it has been sanitized.
1397          *
1398          * This filter is called before the user is created or updated.
1399          *
1400          * @since 2.0.3
1401          *
1402          * @param string $sanitized_user_login Username after it has been sanitized.
1403          */
1404         $pre_user_login = apply_filters( 'pre_user_login', $sanitized_user_login );
1405
1406         //Remove any non-printable chars from the login string to see if we have ended up with an empty username
1407         $user_login = trim( $pre_user_login );
1408
1409         // user_login must be between 0 and 60 characters.
1410         if ( empty( $user_login ) ) {
1411                 return new WP_Error('empty_user_login', __('Cannot create a user with an empty login name.') );
1412         } elseif ( mb_strlen( $user_login ) > 60 ) {
1413                 return new WP_Error( 'user_login_too_long', __( 'Username may not be longer than 60 characters.' ) );
1414         }
1415
1416         if ( ! $update && username_exists( $user_login ) ) {
1417                 return new WP_Error( 'existing_user_login', __( 'Sorry, that username already exists!' ) );
1418         }
1419
1420         /**
1421          * Filter the list of blacklisted usernames.
1422          *
1423          * @since 4.4.0
1424          *
1425          * @param array $usernames Array of blacklisted usernames.
1426          */
1427         $illegal_logins = (array) apply_filters( 'illegal_user_logins', array() );
1428
1429         if ( in_array( strtolower( $user_login ), array_map( 'strtolower', $illegal_logins ) ) ) {
1430                 return new WP_Error( 'invalid_username', __( 'Sorry, that username is not allowed.' ) );
1431         }
1432
1433         /*
1434          * If a nicename is provided, remove unsafe user characters before using it.
1435          * Otherwise build a nicename from the user_login.
1436          */
1437         if ( ! empty( $userdata['user_nicename'] ) ) {
1438                 $user_nicename = sanitize_user( $userdata['user_nicename'], true );
1439                 if ( mb_strlen( $user_nicename ) > 50 ) {
1440                         return new WP_Error( 'user_nicename_too_long', __( 'Nicename may not be longer than 50 characters.' ) );
1441                 }
1442         } else {
1443                 $user_nicename = mb_substr( $user_login, 0, 50 );
1444         }
1445
1446         $user_nicename = sanitize_title( $user_nicename );
1447
1448         // Store values to save in user meta.
1449         $meta = array();
1450
1451         /**
1452          * Filter a user's nicename before the user is created or updated.
1453          *
1454          * @since 2.0.3
1455          *
1456          * @param string $user_nicename The user's nicename.
1457          */
1458         $user_nicename = apply_filters( 'pre_user_nicename', $user_nicename );
1459
1460         $raw_user_url = empty( $userdata['user_url'] ) ? '' : $userdata['user_url'];
1461
1462         /**
1463          * Filter a user's URL before the user is created or updated.
1464          *
1465          * @since 2.0.3
1466          *
1467          * @param string $raw_user_url The user's URL.
1468          */
1469         $user_url = apply_filters( 'pre_user_url', $raw_user_url );
1470
1471         $raw_user_email = empty( $userdata['user_email'] ) ? '' : $userdata['user_email'];
1472
1473         /**
1474          * Filter a user's email before the user is created or updated.
1475          *
1476          * @since 2.0.3
1477          *
1478          * @param string $raw_user_email The user's email.
1479          */
1480         $user_email = apply_filters( 'pre_user_email', $raw_user_email );
1481
1482         /*
1483          * If there is no update, just check for `email_exists`. If there is an update,
1484          * check if current email and new email are the same, or not, and check `email_exists`
1485          * accordingly.
1486          */
1487         if ( ( ! $update || ( ! empty( $old_user_data ) && 0 !== strcasecmp( $user_email, $old_user_data->user_email ) ) )
1488                 && ! defined( 'WP_IMPORTING' )
1489                 && email_exists( $user_email )
1490         ) {
1491                 return new WP_Error( 'existing_user_email', __( 'Sorry, that email address is already used!' ) );
1492         }
1493         $nickname = empty( $userdata['nickname'] ) ? $user_login : $userdata['nickname'];
1494
1495         /**
1496          * Filter a user's nickname before the user is created or updated.
1497          *
1498          * @since 2.0.3
1499          *
1500          * @param string $nickname The user's nickname.
1501          */
1502         $meta['nickname'] = apply_filters( 'pre_user_nickname', $nickname );
1503
1504         $first_name = empty( $userdata['first_name'] ) ? '' : $userdata['first_name'];
1505
1506         /**
1507          * Filter a user's first name before the user is created or updated.
1508          *
1509          * @since 2.0.3
1510          *
1511          * @param string $first_name The user's first name.
1512          */
1513         $meta['first_name'] = apply_filters( 'pre_user_first_name', $first_name );
1514
1515         $last_name = empty( $userdata['last_name'] ) ? '' : $userdata['last_name'];
1516
1517         /**
1518          * Filter a user's last name before the user is created or updated.
1519          *
1520          * @since 2.0.3
1521          *
1522          * @param string $last_name The user's last name.
1523          */
1524         $meta['last_name'] = apply_filters( 'pre_user_last_name', $last_name );
1525
1526         if ( empty( $userdata['display_name'] ) ) {
1527                 if ( $update ) {
1528                         $display_name = $user_login;
1529                 } elseif ( $meta['first_name'] && $meta['last_name'] ) {
1530                         /* translators: 1: first name, 2: last name */
1531                         $display_name = sprintf( _x( '%1$s %2$s', 'Display name based on first name and last name' ), $meta['first_name'], $meta['last_name'] );
1532                 } elseif ( $meta['first_name'] ) {
1533                         $display_name = $meta['first_name'];
1534                 } elseif ( $meta['last_name'] ) {
1535                         $display_name = $meta['last_name'];
1536                 } else {
1537                         $display_name = $user_login;
1538                 }
1539         } else {
1540                 $display_name = $userdata['display_name'];
1541         }
1542
1543         /**
1544          * Filter a user's display name before the user is created or updated.
1545          *
1546          * @since 2.0.3
1547          *
1548          * @param string $display_name The user's display name.
1549          */
1550         $display_name = apply_filters( 'pre_user_display_name', $display_name );
1551
1552         $description = empty( $userdata['description'] ) ? '' : $userdata['description'];
1553
1554         /**
1555          * Filter a user's description before the user is created or updated.
1556          *
1557          * @since 2.0.3
1558          *
1559          * @param string $description The user's description.
1560          */
1561         $meta['description'] = apply_filters( 'pre_user_description', $description );
1562
1563         $meta['rich_editing'] = empty( $userdata['rich_editing'] ) ? 'true' : $userdata['rich_editing'];
1564
1565         $meta['comment_shortcuts'] = empty( $userdata['comment_shortcuts'] ) || 'false' === $userdata['comment_shortcuts'] ? 'false' : 'true';
1566
1567         $admin_color = empty( $userdata['admin_color'] ) ? 'fresh' : $userdata['admin_color'];
1568         $meta['admin_color'] = preg_replace( '|[^a-z0-9 _.\-@]|i', '', $admin_color );
1569
1570         $meta['use_ssl'] = empty( $userdata['use_ssl'] ) ? 0 : $userdata['use_ssl'];
1571
1572         $user_registered = empty( $userdata['user_registered'] ) ? gmdate( 'Y-m-d H:i:s' ) : $userdata['user_registered'];
1573
1574         $meta['show_admin_bar_front'] = empty( $userdata['show_admin_bar_front'] ) ? 'true' : $userdata['show_admin_bar_front'];
1575
1576         $user_nicename_check = $wpdb->get_var( $wpdb->prepare("SELECT ID FROM $wpdb->users WHERE user_nicename = %s AND user_login != %s LIMIT 1" , $user_nicename, $user_login));
1577
1578         if ( $user_nicename_check ) {
1579                 $suffix = 2;
1580                 while ($user_nicename_check) {
1581                         // user_nicename allows 50 chars. Subtract one for a hyphen, plus the length of the suffix.
1582                         $base_length = 49 - mb_strlen( $suffix );
1583                         $alt_user_nicename = mb_substr( $user_nicename, 0, $base_length ) . "-$suffix";
1584                         $user_nicename_check = $wpdb->get_var( $wpdb->prepare("SELECT ID FROM $wpdb->users WHERE user_nicename = %s AND user_login != %s LIMIT 1" , $alt_user_nicename, $user_login));
1585                         $suffix++;
1586                 }
1587                 $user_nicename = $alt_user_nicename;
1588         }
1589
1590         $compacted = compact( 'user_pass', 'user_email', 'user_url', 'user_nicename', 'display_name', 'user_registered' );
1591         $data = wp_unslash( $compacted );
1592
1593         if ( $update ) {
1594                 if ( $user_email !== $old_user_data->user_email ) {
1595                         $data['user_activation_key'] = '';
1596                 }
1597                 $wpdb->update( $wpdb->users, $data, compact( 'ID' ) );
1598                 $user_id = (int) $ID;
1599         } else {
1600                 $wpdb->insert( $wpdb->users, $data + compact( 'user_login' ) );
1601                 $user_id = (int) $wpdb->insert_id;
1602         }
1603
1604         $user = new WP_User( $user_id );
1605
1606         /**
1607          * Filter a user's meta values and keys before the user is created or updated.
1608          *
1609          * Does not include contact methods. These are added using `wp_get_user_contact_methods( $user )`.
1610          *
1611          * @since 4.4.0
1612          *
1613          * @param array $meta {
1614          *     Default meta values and keys for the user.
1615          *
1616          *     @type string   $nickname             The user's nickname. Default is the user's username.
1617          *     @type string   $first_name           The user's first name.
1618          *     @type string   $last_name            The user's last name.
1619          *     @type string   $description          The user's description.
1620          *     @type bool     $rich_editing         Whether to enable the rich-editor for the user. False if not empty.
1621          *     @type bool     $comment_shortcuts    Whether to enable keyboard shortcuts for the user. Default false.
1622          *     @type string   $admin_color          The color scheme for a user's admin screen. Default 'fresh'.
1623          *     @type int|bool $use_ssl              Whether to force SSL on the user's admin area. 0|false if SSL is
1624          *                                          not forced.
1625          *     @type bool     $show_admin_bar_front Whether to show the admin bar on the front end for the user.
1626          *                                          Default true.
1627          * }
1628          * @param WP_User $user   User object.
1629          * @param bool    $update Whether the user is being updated rather than created.
1630          */
1631         $meta = apply_filters( 'insert_user_meta', $meta, $user, $update );
1632
1633         // Update user meta.
1634         foreach ( $meta as $key => $value ) {
1635                 update_user_meta( $user_id, $key, $value );
1636         }
1637
1638         foreach ( wp_get_user_contact_methods( $user ) as $key => $value ) {
1639                 if ( isset( $userdata[ $key ] ) ) {
1640                         update_user_meta( $user_id, $key, $userdata[ $key ] );
1641                 }
1642         }
1643
1644         if ( isset( $userdata['role'] ) ) {
1645                 $user->set_role( $userdata['role'] );
1646         } elseif ( ! $update ) {
1647                 $user->set_role(get_option('default_role'));
1648         }
1649         wp_cache_delete( $user_id, 'users' );
1650         wp_cache_delete( $user_login, 'userlogins' );
1651
1652         if ( $update ) {
1653                 /**
1654                  * Fires immediately after an existing user is updated.
1655                  *
1656                  * @since 2.0.0
1657                  *
1658                  * @param int    $user_id       User ID.
1659                  * @param object $old_user_data Object containing user's data prior to update.
1660                  */
1661                 do_action( 'profile_update', $user_id, $old_user_data );
1662         } else {
1663                 /**
1664                  * Fires immediately after a new user is registered.
1665                  *
1666                  * @since 1.5.0
1667                  *
1668                  * @param int $user_id User ID.
1669                  */
1670                 do_action( 'user_register', $user_id );
1671         }
1672
1673         return $user_id;
1674 }
1675
1676 /**
1677  * Update a user in the database.
1678  *
1679  * It is possible to update a user's password by specifying the 'user_pass'
1680  * value in the $userdata parameter array.
1681  *
1682  * If current user's password is being updated, then the cookies will be
1683  * cleared.
1684  *
1685  * @since 2.0.0
1686  *
1687  * @see wp_insert_user() For what fields can be set in $userdata.
1688  *
1689  * @param mixed $userdata An array of user data or a user object of type stdClass or WP_User.
1690  * @return int|WP_Error The updated user's ID or a WP_Error object if the user could not be updated.
1691  */
1692 function wp_update_user($userdata) {
1693         if ( $userdata instanceof stdClass ) {
1694                 $userdata = get_object_vars( $userdata );
1695         } elseif ( $userdata instanceof WP_User ) {
1696                 $userdata = $userdata->to_array();
1697         }
1698
1699         $ID = isset( $userdata['ID'] ) ? (int) $userdata['ID'] : 0;
1700         if ( ! $ID ) {
1701                 return new WP_Error( 'invalid_user_id', __( 'Invalid user ID.' ) );
1702         }
1703
1704         // First, get all of the original fields
1705         $user_obj = get_userdata( $ID );
1706         if ( ! $user_obj ) {
1707                 return new WP_Error( 'invalid_user_id', __( 'Invalid user ID.' ) );
1708         }
1709
1710         $user = $user_obj->to_array();
1711
1712         // Add additional custom fields
1713         foreach ( _get_additional_user_keys( $user_obj ) as $key ) {
1714                 $user[ $key ] = get_user_meta( $ID, $key, true );
1715         }
1716
1717         // Escape data pulled from DB.
1718         $user = add_magic_quotes( $user );
1719
1720         if ( ! empty( $userdata['user_pass'] ) && $userdata['user_pass'] !== $user_obj->user_pass ) {
1721                 // If password is changing, hash it now
1722                 $plaintext_pass = $userdata['user_pass'];
1723                 $userdata['user_pass'] = wp_hash_password( $userdata['user_pass'] );
1724
1725                 /**
1726                  * Filter whether to send the password change email.
1727                  *
1728                  * @since 4.3.0
1729                  *
1730                  * @see wp_insert_user() For `$user` and `$userdata` fields.
1731                  *
1732                  * @param bool  $send     Whether to send the email.
1733                  * @param array $user     The original user array.
1734                  * @param array $userdata The updated user array.
1735                  *
1736                  */
1737                 $send_password_change_email = apply_filters( 'send_password_change_email', true, $user, $userdata );
1738         }
1739
1740         if ( isset( $userdata['user_email'] ) && $user['user_email'] !== $userdata['user_email'] ) {
1741                 /**
1742                  * Filter whether to send the email change email.
1743                  *
1744                  * @since 4.3.0
1745                  *
1746                  * @see wp_insert_user() For `$user` and `$userdata` fields.
1747                  *
1748                  * @param bool  $send     Whether to send the email.
1749                  * @param array $user     The original user array.
1750                  * @param array $userdata The updated user array.
1751                  *
1752                  */
1753                 $send_email_change_email = apply_filters( 'send_email_change_email', true, $user, $userdata );
1754         }
1755
1756         wp_cache_delete( $user['user_email'], 'useremail' );
1757         wp_cache_delete( $user['user_nicename'], 'userslugs' );
1758
1759         // Merge old and new fields with new fields overwriting old ones.
1760         $userdata = array_merge( $user, $userdata );
1761         $user_id = wp_insert_user( $userdata );
1762
1763         if ( ! is_wp_error( $user_id ) ) {
1764
1765                 $blog_name = wp_specialchars_decode( get_option( 'blogname' ), ENT_QUOTES );
1766
1767                 if ( ! empty( $send_password_change_email ) ) {
1768
1769                         /* translators: Do not translate USERNAME, ADMIN_EMAIL, EMAIL, SITENAME, SITEURL: those are placeholders. */
1770                         $pass_change_text = __( 'Hi ###USERNAME###,
1771
1772 This notice confirms that your password was changed on ###SITENAME###.
1773
1774 If you did not change your password, please contact the Site Administrator at
1775 ###ADMIN_EMAIL###
1776
1777 This email has been sent to ###EMAIL###
1778
1779 Regards,
1780 All at ###SITENAME###
1781 ###SITEURL###' );
1782
1783                         $pass_change_email = array(
1784                                 'to'      => $user['user_email'],
1785                                 'subject' => __( '[%s] Notice of Password Change' ),
1786                                 'message' => $pass_change_text,
1787                                 'headers' => '',
1788                         );
1789
1790                         /**
1791                          * Filter the contents of the email sent when the user's password is changed.
1792                          *
1793                          * @since 4.3.0
1794                          *
1795                          * @param array $pass_change_email {
1796                          *            Used to build wp_mail().
1797                          *            @type string $to      The intended recipients. Add emails in a comma separated string.
1798                          *            @type string $subject The subject of the email.
1799                          *            @type string $message The content of the email.
1800                          *                The following strings have a special meaning and will get replaced dynamically:
1801                          *                - ###USERNAME###    The current user's username.
1802                          *                - ###ADMIN_EMAIL### The admin email in case this was unexpected.
1803                          *                - ###EMAIL###       The old email.
1804                          *                - ###SITENAME###    The name of the site.
1805                          *                - ###SITEURL###     The URL to the site.
1806                          *            @type string $headers Headers. Add headers in a newline (\r\n) separated string.
1807                          *        }
1808                          * @param array $user     The original user array.
1809                          * @param array $userdata The updated user array.
1810                          *
1811                          */
1812                         $pass_change_email = apply_filters( 'password_change_email', $pass_change_email, $user, $userdata );
1813
1814                         $pass_change_email['message'] = str_replace( '###USERNAME###', $user['user_login'], $pass_change_email['message'] );
1815                         $pass_change_email['message'] = str_replace( '###ADMIN_EMAIL###', get_option( 'admin_email' ), $pass_change_email['message'] );
1816                         $pass_change_email['message'] = str_replace( '###EMAIL###', $user['user_email'], $pass_change_email['message'] );
1817                         $pass_change_email['message'] = str_replace( '###SITENAME###', $blog_name, $pass_change_email['message'] );
1818                         $pass_change_email['message'] = str_replace( '###SITEURL###', home_url(), $pass_change_email['message'] );
1819
1820                         wp_mail( $pass_change_email['to'], sprintf( $pass_change_email['subject'], $blog_name ), $pass_change_email['message'], $pass_change_email['headers'] );
1821                 }
1822
1823                 if ( ! empty( $send_email_change_email ) ) {
1824                         /* translators: Do not translate USERNAME, ADMIN_EMAIL, EMAIL, SITENAME, SITEURL: those are placeholders. */
1825                         $email_change_text = __( 'Hi ###USERNAME###,
1826
1827 This notice confirms that your email was changed on ###SITENAME###.
1828
1829 If you did not change your email, please contact the Site Administrator at
1830 ###ADMIN_EMAIL###
1831
1832 This email has been sent to ###EMAIL###
1833
1834 Regards,
1835 All at ###SITENAME###
1836 ###SITEURL###' );
1837
1838                         $email_change_email = array(
1839                                 'to'      => $user['user_email'],
1840                                 'subject' => __( '[%s] Notice of Email Change' ),
1841                                 'message' => $email_change_text,
1842                                 'headers' => '',
1843                         );
1844
1845                         /**
1846                          * Filter the contents of the email sent when the user's email is changed.
1847                          *
1848                          * @since 4.3.0
1849                          *
1850                          * @param array $email_change_email {
1851                          *            Used to build wp_mail().
1852                          *            @type string $to      The intended recipients.
1853                          *            @type string $subject The subject of the email.
1854                          *            @type string $message The content of the email.
1855                          *                The following strings have a special meaning and will get replaced dynamically:
1856                          *                - ###USERNAME###    The current user's username.
1857                          *                - ###ADMIN_EMAIL### The admin email in case this was unexpected.
1858                          *                - ###EMAIL###       The old email.
1859                          *                - ###SITENAME###    The name of the site.
1860                          *                - ###SITEURL###     The URL to the site.
1861                          *            @type string $headers Headers.
1862                          *        }
1863                          * @param array $user The original user array.
1864                          * @param array $userdata The updated user array.
1865                          */
1866                         $email_change_email = apply_filters( 'email_change_email', $email_change_email, $user, $userdata );
1867
1868                         $email_change_email['message'] = str_replace( '###USERNAME###', $user['user_login'], $email_change_email['message'] );
1869                         $email_change_email['message'] = str_replace( '###ADMIN_EMAIL###', get_option( 'admin_email' ), $email_change_email['message'] );
1870                         $email_change_email['message'] = str_replace( '###EMAIL###', $user['user_email'], $email_change_email['message'] );
1871                         $email_change_email['message'] = str_replace( '###SITENAME###', $blog_name, $email_change_email['message'] );
1872                         $email_change_email['message'] = str_replace( '###SITEURL###', home_url(), $email_change_email['message'] );
1873
1874                         wp_mail( $email_change_email['to'], sprintf( $email_change_email['subject'], $blog_name ), $email_change_email['message'], $email_change_email['headers'] );
1875                 }
1876         }
1877
1878         // Update the cookies if the password changed.
1879         $current_user = wp_get_current_user();
1880         if ( $current_user->ID == $ID ) {
1881                 if ( isset($plaintext_pass) ) {
1882                         wp_clear_auth_cookie();
1883
1884                         // Here we calculate the expiration length of the current auth cookie and compare it to the default expiration.
1885                         // If it's greater than this, then we know the user checked 'Remember Me' when they logged in.
1886                         $logged_in_cookie    = wp_parse_auth_cookie( '', 'logged_in' );
1887                         /** This filter is documented in wp-includes/pluggable.php */
1888                         $default_cookie_life = apply_filters( 'auth_cookie_expiration', ( 2 * DAY_IN_SECONDS ), $ID, false );
1889                         $remember            = ( ( $logged_in_cookie['expiration'] - time() ) > $default_cookie_life );
1890
1891                         wp_set_auth_cookie( $ID, $remember );
1892                 }
1893         }
1894
1895         return $user_id;
1896 }
1897
1898 /**
1899  * A simpler way of inserting a user into the database.
1900  *
1901  * Creates a new user with just the username, password, and email. For more
1902  * complex user creation use {@see wp_insert_user()} to specify more information.
1903  *
1904  * @since 2.0.0
1905  * @see wp_insert_user() More complete way to create a new user
1906  *
1907  * @param string $username The user's username.
1908  * @param string $password The user's password.
1909  * @param string $email    Optional. The user's email. Default empty.
1910  * @return int|WP_Error The newly created user's ID or a WP_Error object if the user could not
1911  *                      be created.
1912  */
1913 function wp_create_user($username, $password, $email = '') {
1914         $user_login = wp_slash( $username );
1915         $user_email = wp_slash( $email    );
1916         $user_pass = $password;
1917
1918         $userdata = compact('user_login', 'user_email', 'user_pass');
1919         return wp_insert_user($userdata);
1920 }
1921
1922 /**
1923  * Returns a list of meta keys to be (maybe) populated in wp_update_user().
1924  *
1925  * The list of keys returned via this function are dependent on the presence
1926  * of those keys in the user meta data to be set.
1927  *
1928  * @since 3.3.0
1929  * @access private
1930  *
1931  * @param WP_User $user WP_User instance.
1932  * @return array List of user keys to be populated in wp_update_user().
1933  */
1934 function _get_additional_user_keys( $user ) {
1935         $keys = array( 'first_name', 'last_name', 'nickname', 'description', 'rich_editing', 'comment_shortcuts', 'admin_color', 'use_ssl', 'show_admin_bar_front' );
1936         return array_merge( $keys, array_keys( wp_get_user_contact_methods( $user ) ) );
1937 }
1938
1939 /**
1940  * Set up the user contact methods.
1941  *
1942  * Default contact methods were removed in 3.6. A filter dictates contact methods.
1943  *
1944  * @since 3.7.0
1945  *
1946  * @param WP_User $user Optional. WP_User object.
1947  * @return array Array of contact methods and their labels.
1948  */
1949 function wp_get_user_contact_methods( $user = null ) {
1950         $methods = array();
1951         if ( get_site_option( 'initial_db_version' ) < 23588 ) {
1952                 $methods = array(
1953                         'aim'    => __( 'AIM' ),
1954                         'yim'    => __( 'Yahoo IM' ),
1955                         'jabber' => __( 'Jabber / Google Talk' )
1956                 );
1957         }
1958
1959         /**
1960          * Filter the user contact methods.
1961          *
1962          * @since 2.9.0
1963          *
1964          * @param array   $methods Array of contact methods and their labels.
1965          * @param WP_User $user    WP_User object.
1966          */
1967         return apply_filters( 'user_contactmethods', $methods, $user );
1968 }
1969
1970 /**
1971  * The old private function for setting up user contact methods.
1972  *
1973  * Use wp_get_user_contact_methods() instead.
1974  *
1975  * @since 2.9.0
1976  * @access private
1977  *
1978  * @param WP_User $user Optional. WP_User object. Default null.
1979  * @return array Array of contact methods and their labels.
1980  */
1981 function _wp_get_user_contactmethods( $user = null ) {
1982         return wp_get_user_contact_methods( $user );
1983 }
1984
1985 /**
1986  * Gets the text suggesting how to create strong passwords.
1987  *
1988  * @since 4.1.0
1989  *
1990  * @return string The password hint text.
1991  */
1992 function wp_get_password_hint() {
1993         $hint = __( 'Hint: The password should be at least twelve characters long. To make it stronger, use upper and lower case letters, numbers, and symbols like ! " ? $ % ^ &amp; ).' );
1994
1995         /**
1996          * Filter the text describing the site's password complexity policy.
1997          *
1998          * @since 4.1.0
1999          *
2000          * @param string $hint The password hint text.
2001          */
2002         return apply_filters( 'password_hint', $hint );
2003 }
2004
2005 /**
2006  * Creates, stores, then returns a password reset key for user.
2007  *
2008  * @since 4.4.0
2009  *
2010  * @global wpdb         $wpdb      WordPress database abstraction object.
2011  * @global PasswordHash $wp_hasher Portable PHP password hashing framework.
2012  *
2013  * @param WP_User $user User to retrieve password reset key for.
2014  *
2015  * @return string|WP_Error Password reset key on success. WP_Error on error.
2016  */
2017 function get_password_reset_key( $user ) {
2018         global $wpdb, $wp_hasher;
2019
2020         /**
2021          * Fires before a new password is retrieved.
2022          *
2023          * @since 1.5.0
2024          * @deprecated 1.5.1 Misspelled. Use 'retrieve_password' hook instead.
2025          *
2026          * @param string $user_login The user login name.
2027          */
2028         do_action( 'retreive_password', $user->user_login );
2029
2030         /**
2031          * Fires before a new password is retrieved.
2032          *
2033          * @since 1.5.1
2034          *
2035          * @param string $user_login The user login name.
2036          */
2037         do_action( 'retrieve_password', $user->user_login );
2038
2039         /**
2040          * Filter whether to allow a password to be reset.
2041          *
2042          * @since 2.7.0
2043          *
2044          * @param bool $allow         Whether to allow the password to be reset. Default true.
2045          * @param int  $user_data->ID The ID of the user attempting to reset a password.
2046          */
2047         $allow = apply_filters( 'allow_password_reset', true, $user->ID );
2048
2049         if ( ! $allow ) {
2050                 return new WP_Error( 'no_password_reset', __( 'Password reset is not allowed for this user' ) );
2051         } elseif ( is_wp_error( $allow ) ) {
2052                 return $allow;
2053         }
2054
2055         // Generate something random for a password reset key.
2056         $key = wp_generate_password( 20, false );
2057
2058         /**
2059          * Fires when a password reset key is generated.
2060          *
2061          * @since 2.5.0
2062          *
2063          * @param string $user_login The username for the user.
2064          * @param string $key        The generated password reset key.
2065          */
2066         do_action( 'retrieve_password_key', $user->user_login, $key );
2067
2068         // Now insert the key, hashed, into the DB.
2069         if ( empty( $wp_hasher ) ) {
2070                 require_once ABSPATH . WPINC . '/class-phpass.php';
2071                 $wp_hasher = new PasswordHash( 8, true );
2072         }
2073         $hashed = time() . ':' . $wp_hasher->HashPassword( $key );
2074         $key_saved = $wpdb->update( $wpdb->users, array( 'user_activation_key' => $hashed ), array( 'user_login' => $user->user_login ) );
2075         if ( false === $key_saved ) {
2076                 return new WP_Error( 'no_password_key_update', __( 'Could not save password reset key to database.' ) );
2077         }
2078
2079         return $key;
2080 }
2081
2082 /**
2083  * Retrieves a user row based on password reset key and login
2084  *
2085  * A key is considered 'expired' if it exactly matches the value of the
2086  * user_activation_key field, rather than being matched after going through the
2087  * hashing process. This field is now hashed; old values are no longer accepted
2088  * but have a different WP_Error code so good user feedback can be provided.
2089  *
2090  * @since 3.1.0
2091  *
2092  * @global wpdb         $wpdb      WordPress database object for queries.
2093  * @global PasswordHash $wp_hasher Portable PHP password hashing framework instance.
2094  *
2095  * @param string $key       Hash to validate sending user's password.
2096  * @param string $login     The user login.
2097  * @return WP_User|WP_Error WP_User object on success, WP_Error object for invalid or expired keys.
2098  */
2099 function check_password_reset_key($key, $login) {
2100         global $wpdb, $wp_hasher;
2101
2102         $key = preg_replace('/[^a-z0-9]/i', '', $key);
2103
2104         if ( empty( $key ) || !is_string( $key ) )
2105                 return new WP_Error('invalid_key', __('Invalid key'));
2106
2107         if ( empty($login) || !is_string($login) )
2108                 return new WP_Error('invalid_key', __('Invalid key'));
2109
2110         $row = $wpdb->get_row( $wpdb->prepare( "SELECT ID, user_activation_key FROM $wpdb->users WHERE user_login = %s", $login ) );
2111         if ( ! $row )
2112                 return new WP_Error('invalid_key', __('Invalid key'));
2113
2114         if ( empty( $wp_hasher ) ) {
2115                 require_once ABSPATH . WPINC . '/class-phpass.php';
2116                 $wp_hasher = new PasswordHash( 8, true );
2117         }
2118
2119         /**
2120          * Filter the expiration time of password reset keys.
2121          *
2122          * @since 4.3.0
2123          *
2124          * @param int $expiration The expiration time in seconds.
2125          */
2126         $expiration_duration = apply_filters( 'password_reset_expiration', DAY_IN_SECONDS );
2127
2128         if ( false !== strpos( $row->user_activation_key, ':' ) ) {
2129                 list( $pass_request_time, $pass_key ) = explode( ':', $row->user_activation_key, 2 );
2130                 $expiration_time = $pass_request_time + $expiration_duration;
2131         } else {
2132                 $pass_key = $row->user_activation_key;
2133                 $expiration_time = false;
2134         }
2135
2136         if ( ! $pass_key ) {
2137                 return new WP_Error( 'invalid_key', __( 'Invalid key' ) );
2138         }
2139
2140         $hash_is_correct = $wp_hasher->CheckPassword( $key, $pass_key );
2141
2142         if ( $hash_is_correct && $expiration_time && time() < $expiration_time ) {
2143                 return get_userdata( $row->ID );
2144         } elseif ( $hash_is_correct && $expiration_time ) {
2145                 // Key has an expiration time that's passed
2146                 return new WP_Error( 'expired_key', __( 'Invalid key' ) );
2147         }
2148
2149         if ( hash_equals( $row->user_activation_key, $key ) || ( $hash_is_correct && ! $expiration_time ) ) {
2150                 $return = new WP_Error( 'expired_key', __( 'Invalid key' ) );
2151                 $user_id = $row->ID;
2152
2153                 /**
2154                  * Filter the return value of check_password_reset_key() when an
2155                  * old-style key is used.
2156                  *
2157                  * @since 3.7.0 Previously plain-text keys were stored in the database.
2158                  * @since 4.3.0 Previously key hashes were stored without an expiration time.
2159                  *
2160                  * @param WP_Error $return  A WP_Error object denoting an expired key.
2161                  *                          Return a WP_User object to validate the key.
2162                  * @param int      $user_id The matched user ID.
2163                  */
2164                 return apply_filters( 'password_reset_key_expired', $return, $user_id );
2165         }
2166
2167         return new WP_Error( 'invalid_key', __( 'Invalid key' ) );
2168 }
2169
2170 /**
2171  * Handles resetting the user's password.
2172  *
2173  * @since 2.5.0
2174  *
2175  * @param object $user     The user
2176  * @param string $new_pass New password for the user in plaintext
2177  */
2178 function reset_password( $user, $new_pass ) {
2179         /**
2180          * Fires before the user's password is reset.
2181          *
2182          * @since 1.5.0
2183          *
2184          * @param object $user     The user.
2185          * @param string $new_pass New user password.
2186          */
2187         do_action( 'password_reset', $user, $new_pass );
2188
2189         wp_set_password( $new_pass, $user->ID );
2190         update_user_option( $user->ID, 'default_password_nag', false, true );
2191
2192         /**
2193          * Fires after the user's password is reset.
2194          *
2195          * @since 4.4.0
2196          *
2197          * @param object $user     The user.
2198          * @param string $new_pass New user password.
2199          */
2200         do_action( 'after_password_reset', $user, $new_pass );
2201 }
2202
2203 /**
2204  * Handles registering a new user.
2205  *
2206  * @since 2.5.0
2207  *
2208  * @param string $user_login User's username for logging in
2209  * @param string $user_email User's email address to send password and add
2210  * @return int|WP_Error Either user's ID or error on failure.
2211  */
2212 function register_new_user( $user_login, $user_email ) {
2213         $errors = new WP_Error();
2214
2215         $sanitized_user_login = sanitize_user( $user_login );
2216         /**
2217          * Filter the email address of a user being registered.
2218          *
2219          * @since 2.1.0
2220          *
2221          * @param string $user_email The email address of the new user.
2222          */
2223         $user_email = apply_filters( 'user_registration_email', $user_email );
2224
2225         // Check the username
2226         if ( $sanitized_user_login == '' ) {
2227                 $errors->add( 'empty_username', __( '<strong>ERROR</strong>: Please enter a username.' ) );
2228         } elseif ( ! validate_username( $user_login ) ) {
2229                 $errors->add( 'invalid_username', __( '<strong>ERROR</strong>: This username is invalid because it uses illegal characters. Please enter a valid username.' ) );
2230                 $sanitized_user_login = '';
2231         } elseif ( username_exists( $sanitized_user_login ) ) {
2232                 $errors->add( 'username_exists', __( '<strong>ERROR</strong>: This username is already registered. Please choose another one.' ) );
2233
2234         } else {
2235                 /** This filter is documented in wp-includes/user.php */
2236                 $illegal_user_logins = array_map( 'strtolower', (array) apply_filters( 'illegal_user_logins', array() ) );
2237                 if ( in_array( strtolower( $sanitized_user_login ), $illegal_user_logins ) ) {
2238                         $errors->add( 'invalid_username', __( '<strong>ERROR</strong>: Sorry, that username is not allowed.' ) );
2239                 }
2240         }
2241
2242         // Check the email address
2243         if ( $user_email == '' ) {
2244                 $errors->add( 'empty_email', __( '<strong>ERROR</strong>: Please type your email address.' ) );
2245         } elseif ( ! is_email( $user_email ) ) {
2246                 $errors->add( 'invalid_email', __( '<strong>ERROR</strong>: The email address isn&#8217;t correct.' ) );
2247                 $user_email = '';
2248         } elseif ( email_exists( $user_email ) ) {
2249                 $errors->add( 'email_exists', __( '<strong>ERROR</strong>: This email is already registered, please choose another one.' ) );
2250         }
2251
2252         /**
2253          * Fires when submitting registration form data, before the user is created.
2254          *
2255          * @since 2.1.0
2256          *
2257          * @param string   $sanitized_user_login The submitted username after being sanitized.
2258          * @param string   $user_email           The submitted email.
2259          * @param WP_Error $errors               Contains any errors with submitted username and email,
2260          *                                       e.g., an empty field, an invalid username or email,
2261          *                                       or an existing username or email.
2262          */
2263         do_action( 'register_post', $sanitized_user_login, $user_email, $errors );
2264
2265         /**
2266          * Filter the errors encountered when a new user is being registered.
2267          *
2268          * The filtered WP_Error object may, for example, contain errors for an invalid
2269          * or existing username or email address. A WP_Error object should always returned,
2270          * but may or may not contain errors.
2271          *
2272          * If any errors are present in $errors, this will abort the user's registration.
2273          *
2274          * @since 2.1.0
2275          *
2276          * @param WP_Error $errors               A WP_Error object containing any errors encountered
2277          *                                       during registration.
2278          * @param string   $sanitized_user_login User's username after it has been sanitized.
2279          * @param string   $user_email           User's email.
2280          */
2281         $errors = apply_filters( 'registration_errors', $errors, $sanitized_user_login, $user_email );
2282
2283         if ( $errors->get_error_code() )
2284                 return $errors;
2285
2286         $user_pass = wp_generate_password( 12, false );
2287         $user_id = wp_create_user( $sanitized_user_login, $user_pass, $user_email );
2288         if ( ! $user_id || is_wp_error( $user_id ) ) {
2289                 $errors->add( 'registerfail', sprintf( __( '<strong>ERROR</strong>: Couldn&#8217;t register you&hellip; please contact the <a href="mailto:%s">webmaster</a> !' ), get_option( 'admin_email' ) ) );
2290                 return $errors;
2291         }
2292
2293         update_user_option( $user_id, 'default_password_nag', true, true ); //Set up the Password change nag.
2294
2295         /**
2296          * Fires after a new user registration has been recorded.
2297          *
2298          * @since 4.4.0
2299          *
2300          * @param int $user_id ID of the newly registered user.
2301          */
2302         do_action( 'register_new_user', $user_id );
2303
2304         return $user_id;
2305 }
2306
2307 /**
2308  * Initiate email notifications related to the creation of new users.
2309  *
2310  * Notifications are sent both to the site admin and to the newly created user.
2311  *
2312  * @since 4.4.0
2313  *
2314  * @param int    $user_id ID of the newly created user.
2315  * @param string $notify  Optional. Type of notification that should happen. Accepts 'admin' or an empty string
2316  *                        (admin only), or 'both' (admin and user). Default 'both'.
2317  */
2318 function wp_send_new_user_notifications( $user_id, $notify = 'both' ) {
2319         wp_new_user_notification( $user_id, null, $notify );
2320 }
2321
2322 /**
2323  * Retrieve the current session token from the logged_in cookie.
2324  *
2325  * @since 4.0.0
2326  *
2327  * @return string Token.
2328  */
2329 function wp_get_session_token() {
2330         $cookie = wp_parse_auth_cookie( '', 'logged_in' );
2331         return ! empty( $cookie['token'] ) ? $cookie['token'] : '';
2332 }
2333
2334 /**
2335  * Retrieve a list of sessions for the current user.
2336  *
2337  * @since 4.0.0
2338  * @return array Array of sessions.
2339  */
2340 function wp_get_all_sessions() {
2341         $manager = WP_Session_Tokens::get_instance( get_current_user_id() );
2342         return $manager->get_all();
2343 }
2344
2345 /**
2346  * Remove the current session token from the database.
2347  *
2348  * @since 4.0.0
2349  */
2350 function wp_destroy_current_session() {
2351         $token = wp_get_session_token();
2352         if ( $token ) {
2353                 $manager = WP_Session_Tokens::get_instance( get_current_user_id() );
2354                 $manager->destroy( $token );
2355         }
2356 }
2357
2358 /**
2359  * Remove all but the current session token for the current user for the database.
2360  *
2361  * @since 4.0.0
2362  */
2363 function wp_destroy_other_sessions() {
2364         $token = wp_get_session_token();
2365         if ( $token ) {
2366                 $manager = WP_Session_Tokens::get_instance( get_current_user_id() );
2367                 $manager->destroy_others( $token );
2368         }
2369 }
2370
2371 /**
2372  * Remove all session tokens for the current user from the database.
2373  *
2374  * @since 4.0.0
2375  */
2376 function wp_destroy_all_sessions() {
2377         $manager = WP_Session_Tokens::get_instance( get_current_user_id() );
2378         $manager->destroy_all();
2379 }
2380
2381 /**
2382  * Get the user IDs of all users with no role on this site.
2383  *
2384  * This function returns an empty array when used on Multisite.
2385  *
2386  * @since 4.4.0
2387  *
2388  * @return array Array of user IDs.
2389  */
2390 function wp_get_users_with_no_role() {
2391         global $wpdb;
2392
2393         if ( is_multisite() ) {
2394                 return array();
2395         }
2396
2397         $prefix = $wpdb->get_blog_prefix();
2398         $regex  = implode( '|', wp_roles()->get_names() );
2399         $regex  = preg_replace( '/[^a-zA-Z_\|-]/', '', $regex );
2400         $users  = $wpdb->get_col( $wpdb->prepare( "
2401                 SELECT user_id
2402                 FROM $wpdb->usermeta
2403                 WHERE meta_key = '{$prefix}capabilities'
2404                 AND meta_value NOT REGEXP %s
2405         ", $regex ) );
2406
2407         return $users;
2408 }
2409
2410 /**
2411  * Retrieves the current user object.
2412  *
2413  * Will set the current user, if the current user is not set. The current user
2414  * will be set to the logged-in person. If no user is logged-in, then it will
2415  * set the current user to 0, which is invalid and won't have any permissions.
2416  *
2417  * This function is used by the pluggable functions wp_get_current_user() and
2418  * get_currentuserinfo(), the latter of which is deprecated but used for backward
2419  * compatibility.
2420  *
2421  * @since 4.5.0
2422  * @access private
2423  *
2424  * @see wp_get_current_user()
2425  * @global WP_User $current_user Checks if the current user is set.
2426  *
2427  * @return WP_User Current WP_User instance.
2428  */
2429 function _wp_get_current_user() {
2430         global $current_user;
2431
2432         if ( ! empty( $current_user ) ) {
2433                 if ( $current_user instanceof WP_User ) {
2434                         return $current_user;
2435                 }
2436
2437                 // Upgrade stdClass to WP_User
2438                 if ( is_object( $current_user ) && isset( $current_user->ID ) ) {
2439                         $cur_id = $current_user->ID;
2440                         $current_user = null;
2441                         wp_set_current_user( $cur_id );
2442                         return $current_user;
2443                 }
2444
2445                 // $current_user has a junk value. Force to WP_User with ID 0.
2446                 $current_user = null;
2447                 wp_set_current_user( 0 );
2448                 return $current_user;
2449         }
2450
2451         if ( defined('XMLRPC_REQUEST') && XMLRPC_REQUEST ) {
2452                 wp_set_current_user( 0 );
2453                 return $current_user;
2454         }
2455
2456         /**
2457          * Filter the current user.
2458          *
2459          * The default filters use this to determine the current user from the
2460          * request's cookies, if available.
2461          *
2462          * Returning a value of false will effectively short-circuit setting
2463          * the current user.
2464          *
2465          * @since 3.9.0
2466          *
2467          * @param int|bool $user_id User ID if one has been determined, false otherwise.
2468          */
2469         $user_id = apply_filters( 'determine_current_user', false );
2470         if ( ! $user_id ) {
2471                 wp_set_current_user( 0 );
2472                 return $current_user;
2473         }
2474
2475         wp_set_current_user( $user_id );
2476
2477         return $current_user;
2478 }