3 * Multisite WordPress API
6 * @subpackage Multisite
11 * Gets the network's site and user counts.
15 * @return array Site and user count for the network.
17 function get_sitestats() {
19 'blogs' => get_blog_count(),
20 'users' => get_user_count(),
27 * Get one of a user's active blogs
29 * Returns the user's primary blog, if they have one and
30 * it is active. If it's inactive, function returns another
31 * active blog of the user. If none are found, the user
32 * is added as a Subscriber to the Dashboard Blog and that blog
37 * @global wpdb $wpdb WordPress database abstraction object.
39 * @param int $user_id The unique ID of the user
40 * @return object|void The blog object
42 function get_active_blog_for_user( $user_id ) {
44 $blogs = get_blogs_of_user( $user_id );
45 if ( empty( $blogs ) )
48 if ( !is_multisite() )
49 return $blogs[$wpdb->blogid];
51 $primary_blog = get_user_meta( $user_id, 'primary_blog', true );
52 $first_blog = current($blogs);
53 if ( false !== $primary_blog ) {
54 if ( ! isset( $blogs[ $primary_blog ] ) ) {
55 update_user_meta( $user_id, 'primary_blog', $first_blog->userblog_id );
56 $primary = get_blog_details( $first_blog->userblog_id );
58 $primary = get_blog_details( $primary_blog );
61 //TODO Review this call to add_user_to_blog too - to get here the user must have a role on this blog?
62 add_user_to_blog( $first_blog->userblog_id, $user_id, 'subscriber' );
63 update_user_meta( $user_id, 'primary_blog', $first_blog->userblog_id );
64 $primary = $first_blog;
67 if ( ( ! is_object( $primary ) ) || ( $primary->archived == 1 || $primary->spam == 1 || $primary->deleted == 1 ) ) {
68 $blogs = get_blogs_of_user( $user_id, true ); // if a user's primary blog is shut down, check their other blogs.
70 if ( is_array( $blogs ) && count( $blogs ) > 0 ) {
71 foreach ( (array) $blogs as $blog_id => $blog ) {
72 if ( $blog->site_id != $wpdb->siteid )
74 $details = get_blog_details( $blog_id );
75 if ( is_object( $details ) && $details->archived == 0 && $details->spam == 0 && $details->deleted == 0 ) {
77 if ( get_user_meta( $user_id , 'primary_blog', true ) != $blog_id )
78 update_user_meta( $user_id, 'primary_blog', $blog_id );
79 if ( !get_user_meta($user_id , 'source_domain', true) )
80 update_user_meta( $user_id, 'source_domain', $blog->domain );
94 * The number of active users in your installation.
96 * The count is cached and updated twice daily. This is not a live count.
102 function get_user_count() {
103 return get_site_option( 'user_count' );
107 * The number of active sites on your installation.
109 * The count is cached and updated twice daily. This is not a live count.
113 * @param int $network_id Deprecated, not supported.
116 function get_blog_count( $network_id = 0 ) {
117 if ( func_num_args() )
118 _deprecated_argument( __FUNCTION__, '3.1' );
120 return get_site_option( 'blog_count' );
124 * Get a blog post from any site on the network.
128 * @param int $blog_id ID of the blog.
129 * @param int $post_id ID of the post you're looking for.
130 * @return WP_Post|null WP_Post on success or null on failure
132 function get_blog_post( $blog_id, $post_id ) {
133 switch_to_blog( $blog_id );
134 $post = get_post( $post_id );
135 restore_current_blog();
141 * Add a user to a blog.
143 * Use the 'add_user_to_blog' action to fire an event when
144 * users are added to a blog.
148 * @param int $blog_id ID of the blog you're adding the user to.
149 * @param int $user_id ID of the user you're adding.
150 * @param string $role The role you want the user to have
151 * @return true|WP_Error
153 function add_user_to_blog( $blog_id, $user_id, $role ) {
154 switch_to_blog($blog_id);
156 $user = get_userdata( $user_id );
159 restore_current_blog();
160 return new WP_Error( 'user_does_not_exist', __( 'The requested user does not exist.' ) );
163 if ( !get_user_meta($user_id, 'primary_blog', true) ) {
164 update_user_meta($user_id, 'primary_blog', $blog_id);
165 $details = get_blog_details($blog_id);
166 update_user_meta($user_id, 'source_domain', $details->domain);
169 $user->set_role($role);
172 * Fires immediately after a user is added to a site.
176 * @param int $user_id User ID.
177 * @param string $role User role.
178 * @param int $blog_id Blog ID.
180 do_action( 'add_user_to_blog', $user_id, $role, $blog_id );
181 wp_cache_delete( $user_id, 'users' );
182 wp_cache_delete( $blog_id . '_user_count', 'blog-details' );
183 restore_current_blog();
188 * Remove a user from a blog.
190 * Use the 'remove_user_from_blog' action to fire an event when
191 * users are removed from a blog.
193 * Accepts an optional $reassign parameter, if you want to
194 * reassign the user's blog posts to another user upon removal.
198 * @global wpdb $wpdb WordPress database abstraction object.
200 * @param int $user_id ID of the user you're removing.
201 * @param int $blog_id ID of the blog you're removing the user from.
202 * @param string $reassign Optional. A user to whom to reassign posts.
203 * @return true|WP_Error
205 function remove_user_from_blog($user_id, $blog_id = '', $reassign = '') {
207 switch_to_blog($blog_id);
208 $user_id = (int) $user_id;
210 * Fires before a user is removed from a site.
214 * @param int $user_id User ID.
215 * @param int $blog_id Blog ID.
217 do_action( 'remove_user_from_blog', $user_id, $blog_id );
219 // If being removed from the primary blog, set a new primary if the user is assigned
220 // to multiple blogs.
221 $primary_blog = get_user_meta($user_id, 'primary_blog', true);
222 if ( $primary_blog == $blog_id ) {
225 $blogs = get_blogs_of_user($user_id);
226 foreach ( (array) $blogs as $blog ) {
227 if ( $blog->userblog_id == $blog_id )
229 $new_id = $blog->userblog_id;
230 $new_domain = $blog->domain;
234 update_user_meta($user_id, 'primary_blog', $new_id);
235 update_user_meta($user_id, 'source_domain', $new_domain);
238 // wp_revoke_user($user_id);
239 $user = get_userdata( $user_id );
241 restore_current_blog();
242 return new WP_Error('user_does_not_exist', __('That user does not exist.'));
245 $user->remove_all_caps();
247 $blogs = get_blogs_of_user($user_id);
248 if ( count($blogs) == 0 ) {
249 update_user_meta($user_id, 'primary_blog', '');
250 update_user_meta($user_id, 'source_domain', '');
253 if ( $reassign != '' ) {
254 $reassign = (int) $reassign;
255 $post_ids = $wpdb->get_col( $wpdb->prepare( "SELECT ID FROM $wpdb->posts WHERE post_author = %d", $user_id ) );
256 $link_ids = $wpdb->get_col( $wpdb->prepare( "SELECT link_id FROM $wpdb->links WHERE link_owner = %d", $user_id ) );
258 if ( ! empty( $post_ids ) ) {
259 $wpdb->query( $wpdb->prepare( "UPDATE $wpdb->posts SET post_author = %d WHERE post_author = %d", $reassign, $user_id ) );
260 array_walk( $post_ids, 'clean_post_cache' );
263 if ( ! empty( $link_ids ) ) {
264 $wpdb->query( $wpdb->prepare( "UPDATE $wpdb->links SET link_owner = %d WHERE link_owner = %d", $reassign, $user_id ) );
265 array_walk( $link_ids, 'clean_bookmark_cache' );
269 restore_current_blog();
275 * Get the permalink for a post on another blog.
279 * @param int $blog_id ID of the source blog.
280 * @param int $post_id ID of the desired post.
281 * @return string The post's permalink
283 function get_blog_permalink( $blog_id, $post_id ) {
284 switch_to_blog( $blog_id );
285 $link = get_permalink( $post_id );
286 restore_current_blog();
292 * Get a blog's numeric ID from its URL.
294 * On a subdirectory installation like example.com/blog1/,
295 * $domain will be the root 'example.com' and $path the
296 * subdirectory '/blog1/'. With subdomains like blog1.example.com,
297 * $domain is 'blog1.example.com' and $path is '/'.
301 * @global wpdb $wpdb WordPress database abstraction object.
303 * @param string $domain
304 * @param string $path Optional. Not required for subdomain installations.
305 * @return int 0 if no blog found, otherwise the ID of the matching blog
307 function get_blog_id_from_url( $domain, $path = '/' ) {
310 $domain = strtolower( $domain );
311 $path = strtolower( $path );
312 $id = wp_cache_get( md5( $domain . $path ), 'blog-id-cache' );
314 if ( $id == -1 ) // blog does not exist
319 $id = $wpdb->get_var( $wpdb->prepare( "SELECT blog_id FROM $wpdb->blogs WHERE domain = %s and path = %s /* get_blog_id_from_url */", $domain, $path ) );
322 wp_cache_set( md5( $domain . $path ), -1, 'blog-id-cache' );
326 wp_cache_set( md5( $domain . $path ), $id, 'blog-id-cache' );
334 * Checks an email address against a list of banned domains.
336 * This function checks against the Banned Email Domains list
337 * at wp-admin/network/settings.php. The check is only run on
338 * self-registrations; user creation at wp-admin/network/users.php
339 * bypasses this check.
343 * @param string $user_email The email provided by the user at registration.
344 * @return bool Returns true when the email address is banned.
346 function is_email_address_unsafe( $user_email ) {
347 $banned_names = get_site_option( 'banned_email_domains' );
348 if ( $banned_names && ! is_array( $banned_names ) )
349 $banned_names = explode( "\n", $banned_names );
351 $is_email_address_unsafe = false;
353 if ( $banned_names && is_array( $banned_names ) ) {
354 $banned_names = array_map( 'strtolower', $banned_names );
355 $normalized_email = strtolower( $user_email );
357 list( $email_local_part, $email_domain ) = explode( '@', $normalized_email );
359 foreach ( $banned_names as $banned_domain ) {
360 if ( ! $banned_domain )
363 if ( $email_domain == $banned_domain ) {
364 $is_email_address_unsafe = true;
368 $dotted_domain = ".$banned_domain";
369 if ( $dotted_domain === substr( $normalized_email, -strlen( $dotted_domain ) ) ) {
370 $is_email_address_unsafe = true;
377 * Filter whether an email address is unsafe.
381 * @param bool $is_email_address_unsafe Whether the email address is "unsafe". Default false.
382 * @param string $user_email User email address.
384 return apply_filters( 'is_email_address_unsafe', $is_email_address_unsafe, $user_email );
388 * Sanitize and validate data required for a user sign-up.
390 * Verifies the validity and uniqueness of user names and user email addresses,
391 * and checks email addresses against admin-provided domain whitelists and blacklists.
393 * The {@see 'wpmu_validate_user_signup'} hook provides an easy way to modify the sign-up
394 * process. The value $result, which is passed to the hook, contains both the user-provided
395 * info and the error messages created by the function. {@see 'wpmu_validate_user_signup'}
396 * allows you to process the data in any way you'd like, and unset the relevant errors if
401 * @global wpdb $wpdb WordPress database abstraction object.
403 * @param string $user_name The login name provided by the user.
404 * @param string $user_email The email provided by the user.
405 * @return array Contains username, email, and error messages.
407 function wpmu_validate_user_signup($user_name, $user_email) {
410 $errors = new WP_Error();
412 $orig_username = $user_name;
413 $user_name = preg_replace( '/\s+/', '', sanitize_user( $user_name, true ) );
415 if ( $user_name != $orig_username || preg_match( '/[^a-z0-9]/', $user_name ) ) {
416 $errors->add( 'user_name', __( 'Usernames can only contain lowercase letters (a-z) and numbers.' ) );
417 $user_name = $orig_username;
420 $user_email = sanitize_email( $user_email );
422 if ( empty( $user_name ) )
423 $errors->add('user_name', __( 'Please enter a username.' ) );
425 $illegal_names = get_site_option( 'illegal_names' );
426 if ( ! is_array( $illegal_names ) ) {
427 $illegal_names = array( 'www', 'web', 'root', 'admin', 'main', 'invite', 'administrator' );
428 add_site_option( 'illegal_names', $illegal_names );
430 if ( in_array( $user_name, $illegal_names ) ) {
431 $errors->add( 'user_name', __( 'Sorry, that username is not allowed.' ) );
434 /** This filter is documented in wp-includes/user.php */
435 $illegal_logins = (array) apply_filters( 'illegal_user_logins', array() );
437 if ( in_array( strtolower( $user_name ), array_map( 'strtolower', $illegal_logins ) ) ) {
438 $errors->add( 'user_name', __( 'Sorry, that username is not allowed.' ) );
441 if ( is_email_address_unsafe( $user_email ) )
442 $errors->add('user_email', __('You cannot use that email address to signup. We are having problems with them blocking some of our email. Please use another email provider.'));
444 if ( strlen( $user_name ) < 4 )
445 $errors->add('user_name', __( 'Username must be at least 4 characters.' ) );
447 if ( strlen( $user_name ) > 60 ) {
448 $errors->add( 'user_name', __( 'Username may not be longer than 60 characters.' ) );
452 if ( preg_match( '/^[0-9]*$/', $user_name ) )
453 $errors->add('user_name', __('Sorry, usernames must have letters too!'));
455 if ( !is_email( $user_email ) )
456 $errors->add('user_email', __( 'Please enter a valid email address.' ) );
458 $limited_email_domains = get_site_option( 'limited_email_domains' );
459 if ( is_array( $limited_email_domains ) && ! empty( $limited_email_domains ) ) {
460 $emaildomain = substr( $user_email, 1 + strpos( $user_email, '@' ) );
461 if ( ! in_array( $emaildomain, $limited_email_domains ) ) {
462 $errors->add('user_email', __('Sorry, that email address is not allowed!'));
466 // Check if the username has been used already.
467 if ( username_exists($user_name) )
468 $errors->add( 'user_name', __( 'Sorry, that username already exists!' ) );
470 // Check if the email address has been used already.
471 if ( email_exists($user_email) )
472 $errors->add( 'user_email', __( 'Sorry, that email address is already used!' ) );
474 // Has someone already signed up for this username?
475 $signup = $wpdb->get_row( $wpdb->prepare("SELECT * FROM $wpdb->signups WHERE user_login = %s", $user_name) );
476 if ( $signup != null ) {
477 $registered_at = mysql2date('U', $signup->registered);
478 $now = current_time( 'timestamp', true );
479 $diff = $now - $registered_at;
480 // If registered more than two days ago, cancel registration and let this signup go through.
481 if ( $diff > 2 * DAY_IN_SECONDS )
482 $wpdb->delete( $wpdb->signups, array( 'user_login' => $user_name ) );
484 $errors->add('user_name', __('That username is currently reserved but may be available in a couple of days.'));
487 $signup = $wpdb->get_row( $wpdb->prepare("SELECT * FROM $wpdb->signups WHERE user_email = %s", $user_email) );
488 if ( $signup != null ) {
489 $diff = current_time( 'timestamp', true ) - mysql2date('U', $signup->registered);
490 // If registered more than two days ago, cancel registration and let this signup go through.
491 if ( $diff > 2 * DAY_IN_SECONDS )
492 $wpdb->delete( $wpdb->signups, array( 'user_email' => $user_email ) );
494 $errors->add('user_email', __('That email address has already been used. Please check your inbox for an activation email. It will become available in a couple of days if you do nothing.'));
497 $result = array('user_name' => $user_name, 'orig_username' => $orig_username, 'user_email' => $user_email, 'errors' => $errors);
500 * Filter the validated user registration details.
502 * This does not allow you to override the username or email of the user during
503 * registration. The values are solely used for validation and error handling.
507 * @param array $result {
508 * The array of user name, email and the error messages.
510 * @type string $user_name Sanitized and unique username.
511 * @type string $orig_username Original username.
512 * @type string $user_email User email address.
513 * @type WP_Error $errors WP_Error object containing any errors found.
516 return apply_filters( 'wpmu_validate_user_signup', $result );
520 * Processes new site registrations.
522 * Checks the data provided by the user during blog signup. Verifies
523 * the validity and uniqueness of blog paths and domains.
525 * This function prevents the current user from registering a new site
526 * with a blogname equivalent to another user's login name. Passing the
527 * $user parameter to the function, where $user is the other user, is
528 * effectively an override of this limitation.
530 * Filter 'wpmu_validate_blog_signup' if you want to modify
531 * the way that WordPress validates new site signups.
536 * @global string $domain
538 * @param string $blogname The blog name provided by the user. Must be unique.
539 * @param string $blog_title The blog title provided by the user.
540 * @param WP_User|string $user Optional. The user object to check against the new site name.
541 * @return array Contains the new site data and error messages.
543 function wpmu_validate_blog_signup( $blogname, $blog_title, $user = '' ) {
544 global $wpdb, $domain;
546 $current_site = get_current_site();
547 $base = $current_site->path;
549 $blog_title = strip_tags( $blog_title );
551 $errors = new WP_Error();
552 $illegal_names = get_site_option( 'illegal_names' );
553 if ( $illegal_names == false ) {
554 $illegal_names = array( 'www', 'web', 'root', 'admin', 'main', 'invite', 'administrator' );
555 add_site_option( 'illegal_names', $illegal_names );
559 * On sub dir installs, some names are so illegal, only a filter can
560 * spring them from jail.
562 if ( ! is_subdomain_install() ) {
563 $illegal_names = array_merge( $illegal_names, get_subdirectory_reserved_names() );
566 if ( empty( $blogname ) )
567 $errors->add('blogname', __( 'Please enter a site name.' ) );
569 if ( preg_match( '/[^a-z0-9]+/', $blogname ) ) {
570 $errors->add( 'blogname', __( 'Site names can only contain lowercase letters (a-z) and numbers.' ) );
573 if ( in_array( $blogname, $illegal_names ) )
574 $errors->add('blogname', __( 'That name is not allowed.' ) );
576 if ( strlen( $blogname ) < 4 && !is_super_admin() )
577 $errors->add('blogname', __( 'Site name must be at least 4 characters.' ) );
579 // do not allow users to create a blog that conflicts with a page on the main blog.
580 if ( !is_subdomain_install() && $wpdb->get_var( $wpdb->prepare( "SELECT post_name FROM " . $wpdb->get_blog_prefix( $current_site->blog_id ) . "posts WHERE post_type = 'page' AND post_name = %s", $blogname ) ) )
581 $errors->add( 'blogname', __( 'Sorry, you may not use that site name.' ) );
584 if ( preg_match( '/^[0-9]*$/', $blogname ) )
585 $errors->add('blogname', __('Sorry, site names must have letters too!'));
588 * Filter the new site name during registration.
590 * The name is the site's subdomain or the site's subdirectory
591 * path depending on the network settings.
595 * @param string $blogname Site name.
597 $blogname = apply_filters( 'newblogname', $blogname );
599 $blog_title = wp_unslash( $blog_title );
601 if ( empty( $blog_title ) )
602 $errors->add('blog_title', __( 'Please enter a site title.' ) );
604 // Check if the domain/path has been used already.
605 if ( is_subdomain_install() ) {
606 $mydomain = $blogname . '.' . preg_replace( '|^www\.|', '', $domain );
609 $mydomain = "$domain";
610 $path = $base.$blogname.'/';
612 if ( domain_exists($mydomain, $path, $current_site->id) )
613 $errors->add( 'blogname', __( 'Sorry, that site already exists!' ) );
615 if ( username_exists( $blogname ) ) {
616 if ( ! is_object( $user ) || ( is_object($user) && ( $user->user_login != $blogname ) ) )
617 $errors->add( 'blogname', __( 'Sorry, that site is reserved!' ) );
620 // Has someone already signed up for this domain?
621 $signup = $wpdb->get_row( $wpdb->prepare("SELECT * FROM $wpdb->signups WHERE domain = %s AND path = %s", $mydomain, $path) ); // TODO: Check email too?
622 if ( ! empty($signup) ) {
623 $diff = current_time( 'timestamp', true ) - mysql2date('U', $signup->registered);
624 // If registered more than two days ago, cancel registration and let this signup go through.
625 if ( $diff > 2 * DAY_IN_SECONDS )
626 $wpdb->delete( $wpdb->signups, array( 'domain' => $mydomain , 'path' => $path ) );
628 $errors->add('blogname', __('That site is currently reserved but may be available in a couple days.'));
631 $result = array('domain' => $mydomain, 'path' => $path, 'blogname' => $blogname, 'blog_title' => $blog_title, 'user' => $user, 'errors' => $errors);
634 * Filter site details and error messages following registration.
638 * @param array $result {
639 * Array of domain, path, blog name, blog title, user and error messages.
641 * @type string $domain Domain for the site.
642 * @type string $path Path for the site. Used in subdirectory installs.
643 * @type string $blogname The unique site name (slug).
644 * @type string $blog_title Blog title.
645 * @type string|WP_User $user By default, an empty string. A user object if provided.
646 * @type WP_Error $errors WP_Error containing any errors found.
649 return apply_filters( 'wpmu_validate_blog_signup', $result );
653 * Record site signup information for future activation.
657 * @global wpdb $wpdb WordPress database abstraction object.
659 * @param string $domain The requested domain.
660 * @param string $path The requested path.
661 * @param string $title The requested site title.
662 * @param string $user The user's requested login name.
663 * @param string $user_email The user's email address.
664 * @param array $meta By default, contains the requested privacy setting and lang_id.
666 function wpmu_signup_blog( $domain, $path, $title, $user, $user_email, $meta = array() ) {
669 $key = substr( md5( time() . rand() . $domain ), 0, 16 );
670 $meta = serialize($meta);
672 $wpdb->insert( $wpdb->signups, array(
676 'user_login' => $user,
677 'user_email' => $user_email,
678 'registered' => current_time('mysql', true),
679 'activation_key' => $key,
684 * Fires after site signup information has been written to the database.
688 * @param string $domain The requested domain.
689 * @param string $path The requested path.
690 * @param string $title The requested site title.
691 * @param string $user The user's requested login name.
692 * @param string $user_email The user's email address.
693 * @param string $key The user's activation key
694 * @param array $meta By default, contains the requested privacy setting and lang_id.
696 do_action( 'after_signup_site', $domain, $path, $title, $user, $user_email, $key, $meta );
700 * Record user signup information for future activation.
702 * This function is used when user registration is open but
703 * new site registration is not.
707 * @global wpdb $wpdb WordPress database abstraction object.
709 * @param string $user The user's requested login name.
710 * @param string $user_email The user's email address.
711 * @param array $meta By default, this is an empty array.
713 function wpmu_signup_user( $user, $user_email, $meta = array() ) {
717 $user = preg_replace( '/\s+/', '', sanitize_user( $user, true ) );
718 $user_email = sanitize_email( $user_email );
719 $key = substr( md5( time() . rand() . $user_email ), 0, 16 );
720 $meta = serialize($meta);
722 $wpdb->insert( $wpdb->signups, array(
726 'user_login' => $user,
727 'user_email' => $user_email,
728 'registered' => current_time('mysql', true),
729 'activation_key' => $key,
734 * Fires after a user's signup information has been written to the database.
738 * @param string $user The user's requested login name.
739 * @param string $user_email The user's email address.
740 * @param string $key The user's activation key
741 * @param array $meta Additional signup meta. By default, this is an empty array.
743 do_action( 'after_signup_user', $user, $user_email, $key, $meta );
747 * Notify user of signup success.
749 * This is the notification function used when site registration
752 * Filter 'wpmu_signup_blog_notification' to bypass this function or
753 * replace it with your own notification behavior.
755 * Filter 'wpmu_signup_blog_notification_email' and
756 * 'wpmu_signup_blog_notification_subject' to change the content
757 * and subject line of the email sent to newly registered users.
761 * @param string $domain The new blog domain.
762 * @param string $path The new blog path.
763 * @param string $title The site title.
764 * @param string $user The user's login name.
765 * @param string $user_email The user's email address.
766 * @param string $key The activation key created in wpmu_signup_blog()
767 * @param array $meta By default, contains the requested privacy setting and lang_id.
770 function wpmu_signup_blog_notification( $domain, $path, $title, $user, $user_email, $key, $meta = array() ) {
772 * Filter whether to bypass the new site email notification.
776 * @param string|bool $domain Site domain.
777 * @param string $path Site path.
778 * @param string $title Site title.
779 * @param string $user User login name.
780 * @param string $user_email User email address.
781 * @param string $key Activation key created in wpmu_signup_blog().
782 * @param array $meta By default, contains the requested privacy setting and lang_id.
784 if ( ! apply_filters( 'wpmu_signup_blog_notification', $domain, $path, $title, $user, $user_email, $key, $meta ) ) {
788 // Send email with activation link.
789 if ( !is_subdomain_install() || get_current_site()->id != 1 )
790 $activate_url = network_site_url("wp-activate.php?key=$key");
792 $activate_url = "http://{$domain}{$path}wp-activate.php?key=$key"; // @todo use *_url() API
794 $activate_url = esc_url($activate_url);
795 $admin_email = get_site_option( 'admin_email' );
796 if ( $admin_email == '' )
797 $admin_email = 'support@' . $_SERVER['SERVER_NAME'];
798 $from_name = get_site_option( 'site_name' ) == '' ? 'WordPress' : esc_html( get_site_option( 'site_name' ) );
799 $message_headers = "From: \"{$from_name}\" <{$admin_email}>\n" . "Content-Type: text/plain; charset=\"" . get_option('blog_charset') . "\"\n";
802 * Filter the message content of the new blog notification email.
804 * Content should be formatted for transmission via wp_mail().
808 * @param string $content Content of the notification email.
809 * @param string $domain Site domain.
810 * @param string $path Site path.
811 * @param string $title Site title.
812 * @param string $user User login name.
813 * @param string $user_email User email address.
814 * @param string $key Activation key created in wpmu_signup_blog().
815 * @param array $meta By default, contains the requested privacy setting and lang_id.
817 apply_filters( 'wpmu_signup_blog_notification_email',
818 __( "To activate your blog, please click the following link:\n\n%s\n\nAfter you activate, you will receive *another email* with your login.\n\nAfter you activate, you can visit your site here:\n\n%s" ),
819 $domain, $path, $title, $user, $user_email, $key, $meta
822 esc_url( "http://{$domain}{$path}" ),
825 // TODO: Don't hard code activation link.
828 * Filter the subject of the new blog notification email.
832 * @param string $subject Subject of the notification email.
833 * @param string $domain Site domain.
834 * @param string $path Site path.
835 * @param string $title Site title.
836 * @param string $user User login name.
837 * @param string $user_email User email address.
838 * @param string $key Activation key created in wpmu_signup_blog().
839 * @param array $meta By default, contains the requested privacy setting and lang_id.
841 apply_filters( 'wpmu_signup_blog_notification_subject',
842 __( '[%1$s] Activate %2$s' ),
843 $domain, $path, $title, $user, $user_email, $key, $meta
846 esc_url( 'http://' . $domain . $path )
848 wp_mail( $user_email, wp_specialchars_decode( $subject ), $message, $message_headers );
853 * Notify user of signup success.
855 * This is the notification function used when no new site has
858 * Filter 'wpmu_signup_user_notification' to bypass this function or
859 * replace it with your own notification behavior.
861 * Filter 'wpmu_signup_user_notification_email' and
862 * 'wpmu_signup_user_notification_subject' to change the content
863 * and subject line of the email sent to newly registered users.
867 * @param string $user The user's login name.
868 * @param string $user_email The user's email address.
869 * @param string $key The activation key created in wpmu_signup_user()
870 * @param array $meta By default, an empty array.
873 function wpmu_signup_user_notification( $user, $user_email, $key, $meta = array() ) {
875 * Filter whether to bypass the email notification for new user sign-up.
879 * @param string $user User login name.
880 * @param string $user_email User email address.
881 * @param string $key Activation key created in wpmu_signup_user().
882 * @param array $meta Signup meta data.
884 if ( ! apply_filters( 'wpmu_signup_user_notification', $user, $user_email, $key, $meta ) )
887 // Send email with activation link.
888 $admin_email = get_site_option( 'admin_email' );
889 if ( $admin_email == '' )
890 $admin_email = 'support@' . $_SERVER['SERVER_NAME'];
891 $from_name = get_site_option( 'site_name' ) == '' ? 'WordPress' : esc_html( get_site_option( 'site_name' ) );
892 $message_headers = "From: \"{$from_name}\" <{$admin_email}>\n" . "Content-Type: text/plain; charset=\"" . get_option('blog_charset') . "\"\n";
895 * Filter the content of the notification email for new user sign-up.
897 * Content should be formatted for transmission via wp_mail().
901 * @param string $content Content of the notification email.
902 * @param string $user User login name.
903 * @param string $user_email User email address.
904 * @param string $key Activation key created in wpmu_signup_user().
905 * @param array $meta Signup meta data.
907 apply_filters( 'wpmu_signup_user_notification_email',
908 __( "To activate your user, please click the following link:\n\n%s\n\nAfter you activate, you will receive *another email* with your login." ),
909 $user, $user_email, $key, $meta
911 site_url( "wp-activate.php?key=$key" )
913 // TODO: Don't hard code activation link.
916 * Filter the subject of the notification email of new user signup.
920 * @param string $subject Subject of the notification email.
921 * @param string $user User login name.
922 * @param string $user_email User email address.
923 * @param string $key Activation key created in wpmu_signup_user().
924 * @param array $meta Signup meta data.
926 apply_filters( 'wpmu_signup_user_notification_subject',
927 __( '[%1$s] Activate %2$s' ),
928 $user, $user_email, $key, $meta
933 wp_mail( $user_email, wp_specialchars_decode( $subject ), $message, $message_headers );
940 * Hook to 'wpmu_activate_user' or 'wpmu_activate_blog' for events
941 * that should happen only when users or sites are self-created (since
942 * those actions are not called when users and sites are created
947 * @global wpdb $wpdb WordPress database abstraction object.
949 * @param string $key The activation key provided to the user.
950 * @return array|WP_Error An array containing information about the activated user and/or blog
952 function wpmu_activate_signup($key) {
955 $signup = $wpdb->get_row( $wpdb->prepare("SELECT * FROM $wpdb->signups WHERE activation_key = %s", $key) );
957 if ( empty( $signup ) )
958 return new WP_Error( 'invalid_key', __( 'Invalid activation key.' ) );
960 if ( $signup->active ) {
961 if ( empty( $signup->domain ) )
962 return new WP_Error( 'already_active', __( 'The user is already active.' ), $signup );
964 return new WP_Error( 'already_active', __( 'The site is already active.' ), $signup );
967 $meta = maybe_unserialize($signup->meta);
968 $password = wp_generate_password( 12, false );
970 $user_id = username_exists($signup->user_login);
973 $user_id = wpmu_create_user($signup->user_login, $password, $signup->user_email);
975 $user_already_exists = true;
978 return new WP_Error('create_user', __('Could not create user'), $signup);
980 $now = current_time('mysql', true);
982 if ( empty($signup->domain) ) {
983 $wpdb->update( $wpdb->signups, array('active' => 1, 'activated' => $now), array('activation_key' => $key) );
985 if ( isset( $user_already_exists ) )
986 return new WP_Error( 'user_already_exists', __( 'That username is already activated.' ), $signup);
989 * Fires immediately after a new user is activated.
993 * @param int $user_id User ID.
994 * @param int $password User password.
995 * @param array $meta Signup meta data.
997 do_action( 'wpmu_activate_user', $user_id, $password, $meta );
998 return array( 'user_id' => $user_id, 'password' => $password, 'meta' => $meta );
1001 $blog_id = wpmu_create_blog( $signup->domain, $signup->path, $signup->title, $user_id, $meta, $wpdb->siteid );
1003 // TODO: What to do if we create a user but cannot create a blog?
1004 if ( is_wp_error($blog_id) ) {
1005 // If blog is taken, that means a previous attempt to activate this blog failed in between creating the blog and
1006 // setting the activation flag. Let's just set the active flag and instruct the user to reset their password.
1007 if ( 'blog_taken' == $blog_id->get_error_code() ) {
1008 $blog_id->add_data( $signup );
1009 $wpdb->update( $wpdb->signups, array( 'active' => 1, 'activated' => $now ), array( 'activation_key' => $key ) );
1014 $wpdb->update( $wpdb->signups, array('active' => 1, 'activated' => $now), array('activation_key' => $key) );
1016 * Fires immediately after a site is activated.
1020 * @param int $blog_id Blog ID.
1021 * @param int $user_id User ID.
1022 * @param int $password User password.
1023 * @param string $signup_title Site title.
1024 * @param array $meta Signup meta data.
1026 do_action( 'wpmu_activate_blog', $blog_id, $user_id, $password, $signup->title, $meta );
1028 return array('blog_id' => $blog_id, 'user_id' => $user_id, 'password' => $password, 'title' => $signup->title, 'meta' => $meta);
1034 * This function runs when a user self-registers as well as when
1035 * a Super Admin creates a new user. Hook to 'wpmu_new_user' for events
1036 * that should affect all new users, but only on Multisite (otherwise
1037 * use 'user_register').
1041 * @param string $user_name The new user's login name.
1042 * @param string $password The new user's password.
1043 * @param string $email The new user's email address.
1044 * @return int|false Returns false on failure, or int $user_id on success
1046 function wpmu_create_user( $user_name, $password, $email ) {
1047 $user_name = preg_replace( '/\s+/', '', sanitize_user( $user_name, true ) );
1049 $user_id = wp_create_user( $user_name, $password, $email );
1050 if ( is_wp_error( $user_id ) )
1053 // Newly created users have no roles or caps until they are added to a blog.
1054 delete_user_option( $user_id, 'capabilities' );
1055 delete_user_option( $user_id, 'user_level' );
1058 * Fires immediately after a new user is created.
1062 * @param int $user_id User ID.
1064 do_action( 'wpmu_new_user', $user_id );
1072 * This function runs when a user self-registers a new site as well
1073 * as when a Super Admin creates a new site. Hook to 'wpmu_new_blog'
1074 * for events that should affect all new sites.
1076 * On subdirectory installs, $domain is the same as the main site's
1077 * domain, and the path is the subdirectory name (eg 'example.com'
1078 * and '/blog1/'). On subdomain installs, $domain is the new subdomain +
1079 * root domain (eg 'blog1.example.com'), and $path is '/'.
1083 * @param string $domain The new site's domain.
1084 * @param string $path The new site's path.
1085 * @param string $title The new site's title.
1086 * @param int $user_id The user ID of the new site's admin.
1087 * @param array $meta Optional. Used to set initial site options.
1088 * @param int $site_id Optional. Only relevant on multi-network installs.
1089 * @return int|WP_Error Returns WP_Error object on failure, int $blog_id on success
1091 function wpmu_create_blog( $domain, $path, $title, $user_id, $meta = array(), $site_id = 1 ) {
1092 $defaults = array( 'public' => 0 );
1093 $meta = wp_parse_args( $meta, $defaults );
1095 $domain = preg_replace( '/\s+/', '', sanitize_user( $domain, true ) );
1097 if ( is_subdomain_install() )
1098 $domain = str_replace( '@', '', $domain );
1100 $title = strip_tags( $title );
1101 $user_id = (int) $user_id;
1106 // Check if the domain has been used already. We should return an error message.
1107 if ( domain_exists($domain, $path, $site_id) )
1108 return new WP_Error( 'blog_taken', __( 'Sorry, that site already exists!' ) );
1110 if ( ! wp_installing() ) {
1111 wp_installing( true );
1114 if ( ! $blog_id = insert_blog($domain, $path, $site_id) )
1115 return new WP_Error('insert_blog', __('Could not create site.'));
1117 switch_to_blog($blog_id);
1118 install_blog($blog_id, $title);
1119 wp_install_defaults($user_id);
1121 add_user_to_blog($blog_id, $user_id, 'administrator');
1123 foreach ( $meta as $key => $value ) {
1124 if ( in_array( $key, array( 'public', 'archived', 'mature', 'spam', 'deleted', 'lang_id' ) ) )
1125 update_blog_status( $blog_id, $key, $value );
1127 update_option( $key, $value );
1130 add_option( 'WPLANG', get_site_option( 'WPLANG' ) );
1131 update_option( 'blog_public', (int) $meta['public'] );
1133 if ( ! is_super_admin( $user_id ) && ! get_user_meta( $user_id, 'primary_blog', true ) )
1134 update_user_meta( $user_id, 'primary_blog', $blog_id );
1136 restore_current_blog();
1138 * Fires immediately after a new site is created.
1142 * @param int $blog_id Blog ID.
1143 * @param int $user_id User ID.
1144 * @param string $domain Site domain.
1145 * @param string $path Site path.
1146 * @param int $site_id Site ID. Only relevant on multi-network installs.
1147 * @param array $meta Meta data. Used to set initial site options.
1149 do_action( 'wpmu_new_blog', $blog_id, $user_id, $domain, $path, $site_id, $meta );
1155 * Notifies the network admin that a new site has been activated.
1157 * Filter 'newblog_notify_siteadmin' to change the content of
1158 * the notification email.
1162 * @param int $blog_id The new site's ID.
1165 function newblog_notify_siteadmin( $blog_id, $deprecated = '' ) {
1166 if ( get_site_option( 'registrationnotification' ) != 'yes' )
1169 $email = get_site_option( 'admin_email' );
1170 if ( is_email($email) == false )
1173 $options_site_url = esc_url(network_admin_url('settings.php'));
1175 switch_to_blog( $blog_id );
1176 $blogname = get_option( 'blogname' );
1177 $siteurl = site_url();
1178 restore_current_blog();
1180 $msg = sprintf( __( 'New Site: %1$s
1184 Disable these notifications: %4$s' ), $blogname, $siteurl, wp_unslash( $_SERVER['REMOTE_ADDR'] ), $options_site_url);
1186 * Filter the message body of the new site activation email sent
1187 * to the network administrator.
1191 * @param string $msg Email body.
1193 $msg = apply_filters( 'newblog_notify_siteadmin', $msg );
1195 wp_mail( $email, sprintf( __( 'New Site Registration: %s' ), $siteurl ), $msg );
1200 * Notifies the network admin that a new user has been activated.
1202 * Filter 'newuser_notify_siteadmin' to change the content of
1203 * the notification email.
1207 * @param int $user_id The new user's ID.
1210 function newuser_notify_siteadmin( $user_id ) {
1211 if ( get_site_option( 'registrationnotification' ) != 'yes' )
1214 $email = get_site_option( 'admin_email' );
1216 if ( is_email($email) == false )
1219 $user = get_userdata( $user_id );
1221 $options_site_url = esc_url(network_admin_url('settings.php'));
1222 $msg = sprintf(__('New User: %1$s
1225 Disable these notifications: %3$s'), $user->user_login, wp_unslash( $_SERVER['REMOTE_ADDR'] ), $options_site_url);
1228 * Filter the message body of the new user activation email sent
1229 * to the network administrator.
1233 * @param string $msg Email body.
1234 * @param WP_User $user WP_User instance of the new user.
1236 $msg = apply_filters( 'newuser_notify_siteadmin', $msg, $user );
1237 wp_mail( $email, sprintf(__('New User Registration: %s'), $user->user_login), $msg );
1242 * Check whether a blogname is already taken.
1244 * Used during the new site registration process to ensure
1245 * that each blogname is unique.
1249 * @global wpdb $wpdb WordPress database abstraction object.
1251 * @param string $domain The domain to be checked.
1252 * @param string $path The path to be checked.
1253 * @param int $site_id Optional. Relevant only on multi-network installs.
1256 function domain_exists($domain, $path, $site_id = 1) {
1258 $path = trailingslashit( $path );
1259 $result = $wpdb->get_var( $wpdb->prepare("SELECT blog_id FROM $wpdb->blogs WHERE domain = %s AND path = %s AND site_id = %d", $domain, $path, $site_id) );
1262 * Filter whether a blogname is taken.
1266 * @param int|null $result The blog_id if the blogname exists, null otherwise.
1267 * @param string $domain Domain to be checked.
1268 * @param string $path Path to be checked.
1269 * @param int $site_id Site ID. Relevant only on multi-network installs.
1271 return apply_filters( 'domain_exists', $result, $domain, $path, $site_id );
1275 * Store basic site info in the blogs table.
1277 * This function creates a row in the wp_blogs table and returns
1278 * the new blog's ID. It is the first step in creating a new blog.
1282 * @global wpdb $wpdb WordPress database abstraction object.
1284 * @param string $domain The domain of the new site.
1285 * @param string $path The path of the new site.
1286 * @param int $site_id Unless you're running a multi-network install, be sure to set this value to 1.
1287 * @return int|false The ID of the new row
1289 function insert_blog($domain, $path, $site_id) {
1292 $path = trailingslashit($path);
1293 $site_id = (int) $site_id;
1295 $result = $wpdb->insert( $wpdb->blogs, array('site_id' => $site_id, 'domain' => $domain, 'path' => $path, 'registered' => current_time('mysql')) );
1299 $blog_id = $wpdb->insert_id;
1300 refresh_blog_details( $blog_id );
1302 wp_maybe_update_network_site_counts();
1308 * Install an empty blog.
1310 * Creates the new blog tables and options. If calling this function
1311 * directly, be sure to use switch_to_blog() first, so that $wpdb
1312 * points to the new blog.
1316 * @global wpdb $wpdb
1317 * @global WP_Roles $wp_roles
1319 * @param int $blog_id The value returned by insert_blog().
1320 * @param string $blog_title The title of the new site.
1322 function install_blog( $blog_id, $blog_title = '' ) {
1323 global $wpdb, $wp_roles, $current_site;
1325 // Cast for security
1326 $blog_id = (int) $blog_id;
1328 require_once( ABSPATH . 'wp-admin/includes/upgrade.php' );
1330 $suppress = $wpdb->suppress_errors();
1331 if ( $wpdb->get_results( "DESCRIBE {$wpdb->posts}" ) )
1332 die( '<h1>' . __( 'Already Installed' ) . '</h1><p>' . __( 'You appear to have already installed WordPress. To reinstall please clear your old database tables first.' ) . '</p></body></html>' );
1333 $wpdb->suppress_errors( $suppress );
1335 $url = get_blogaddress_by_id( $blog_id );
1337 // Set everything up
1338 make_db_current_silent( 'blog' );
1342 // populate_roles() clears previous role definitions so we start over.
1343 $wp_roles = new WP_Roles();
1345 $siteurl = $home = untrailingslashit( $url );
1347 if ( ! is_subdomain_install() ) {
1349 if ( 'https' === parse_url( get_site_option( 'siteurl' ), PHP_URL_SCHEME ) ) {
1350 $siteurl = set_url_scheme( $siteurl, 'https' );
1352 if ( 'https' === parse_url( get_home_url( $current_site->blog_id ), PHP_URL_SCHEME ) ) {
1353 $home = set_url_scheme( $home, 'https' );
1358 update_option( 'siteurl', $siteurl );
1359 update_option( 'home', $home );
1361 if ( get_site_option( 'ms_files_rewriting' ) )
1362 update_option( 'upload_path', UPLOADBLOGSDIR . "/$blog_id/files" );
1364 update_option( 'upload_path', get_blog_option( get_current_site()->blog_id, 'upload_path' ) );
1366 update_option( 'blogname', wp_unslash( $blog_title ) );
1367 update_option( 'admin_email', '' );
1370 $table_prefix = $wpdb->get_blog_prefix();
1371 delete_metadata( 'user', 0, $table_prefix . 'user_level', null, true ); // delete all
1372 delete_metadata( 'user', 0, $table_prefix . 'capabilities', null, true ); // delete all
1376 * Set blog defaults.
1378 * This function creates a row in the wp_blogs table.
1382 * @deprecated Use wp_install_defaults()
1384 * @global wpdb $wpdb WordPress database abstraction object.
1386 * @param int $blog_id Ignored in this function.
1387 * @param int $user_id
1389 function install_blog_defaults($blog_id, $user_id) {
1392 require_once( ABSPATH . 'wp-admin/includes/upgrade.php' );
1394 $suppress = $wpdb->suppress_errors();
1396 wp_install_defaults($user_id);
1398 $wpdb->suppress_errors( $suppress );
1402 * Notify a user that their blog activation has been successful.
1404 * Filter 'wpmu_welcome_notification' to disable or bypass.
1406 * Filter 'update_welcome_email' and 'update_welcome_subject' to
1407 * modify the content and subject line of the notification email.
1411 * @param int $blog_id
1412 * @param int $user_id
1413 * @param string $password
1414 * @param string $title The new blog's title
1415 * @param array $meta Optional. Not used in the default function, but is passed along to hooks for customization.
1418 function wpmu_welcome_notification( $blog_id, $user_id, $password, $title, $meta = array() ) {
1419 $current_site = get_current_site();
1422 * Filter whether to bypass the welcome email after site activation.
1424 * Returning false disables the welcome email.
1428 * @param int|bool $blog_id Blog ID.
1429 * @param int $user_id User ID.
1430 * @param string $password User password.
1431 * @param string $title Site title.
1432 * @param array $meta Signup meta data.
1434 if ( ! apply_filters( 'wpmu_welcome_notification', $blog_id, $user_id, $password, $title, $meta ) )
1437 $welcome_email = get_site_option( 'welcome_email' );
1438 if ( $welcome_email == false ) {
1439 /* translators: Do not translate USERNAME, SITE_NAME, BLOG_URL, PASSWORD: those are placeholders. */
1440 $welcome_email = __( 'Howdy USERNAME,
1442 Your new SITE_NAME site has been successfully set up at:
1445 You can log in to the administrator account with the following information:
1449 Log in here: BLOG_URLwp-login.php
1451 We hope you enjoy your new site. Thanks!
1453 --The Team @ SITE_NAME' );
1456 $url = get_blogaddress_by_id($blog_id);
1457 $user = get_userdata( $user_id );
1459 $welcome_email = str_replace( 'SITE_NAME', $current_site->site_name, $welcome_email );
1460 $welcome_email = str_replace( 'BLOG_TITLE', $title, $welcome_email );
1461 $welcome_email = str_replace( 'BLOG_URL', $url, $welcome_email );
1462 $welcome_email = str_replace( 'USERNAME', $user->user_login, $welcome_email );
1463 $welcome_email = str_replace( 'PASSWORD', $password, $welcome_email );
1466 * Filter the content of the welcome email after site activation.
1468 * Content should be formatted for transmission via wp_mail().
1472 * @param string $welcome_email Message body of the email.
1473 * @param int $blog_id Blog ID.
1474 * @param int $user_id User ID.
1475 * @param string $password User password.
1476 * @param string $title Site title.
1477 * @param array $meta Signup meta data.
1479 $welcome_email = apply_filters( 'update_welcome_email', $welcome_email, $blog_id, $user_id, $password, $title, $meta );
1480 $admin_email = get_site_option( 'admin_email' );
1482 if ( $admin_email == '' )
1483 $admin_email = 'support@' . $_SERVER['SERVER_NAME'];
1485 $from_name = get_site_option( 'site_name' ) == '' ? 'WordPress' : esc_html( get_site_option( 'site_name' ) );
1486 $message_headers = "From: \"{$from_name}\" <{$admin_email}>\n" . "Content-Type: text/plain; charset=\"" . get_option('blog_charset') . "\"\n";
1487 $message = $welcome_email;
1489 if ( empty( $current_site->site_name ) )
1490 $current_site->site_name = 'WordPress';
1493 * Filter the subject of the welcome email after site activation.
1497 * @param string $subject Subject of the email.
1499 $subject = apply_filters( 'update_welcome_subject', sprintf( __( 'New %1$s Site: %2$s' ), $current_site->site_name, wp_unslash( $title ) ) );
1500 wp_mail( $user->user_email, wp_specialchars_decode( $subject ), $message, $message_headers );
1505 * Notify a user that their account activation has been successful.
1507 * Filter 'wpmu_welcome_user_notification' to disable or bypass.
1509 * Filter 'update_welcome_user_email' and 'update_welcome_user_subject' to
1510 * modify the content and subject line of the notification email.
1514 * @param int $user_id
1515 * @param string $password
1516 * @param array $meta Optional. Not used in the default function, but is passed along to hooks for customization.
1519 function wpmu_welcome_user_notification( $user_id, $password, $meta = array() ) {
1520 $current_site = get_current_site();
1523 * Filter whether to bypass the welcome email after user activation.
1525 * Returning false disables the welcome email.
1529 * @param int $user_id User ID.
1530 * @param string $password User password.
1531 * @param array $meta Signup meta data.
1533 if ( ! apply_filters( 'wpmu_welcome_user_notification', $user_id, $password, $meta ) )
1536 $welcome_email = get_site_option( 'welcome_user_email' );
1538 $user = get_userdata( $user_id );
1541 * Filter the content of the welcome email after user activation.
1543 * Content should be formatted for transmission via wp_mail().
1547 * @param type $welcome_email The message body of the account activation success email.
1548 * @param int $user_id User ID.
1549 * @param string $password User password.
1550 * @param array $meta Signup meta data.
1552 $welcome_email = apply_filters( 'update_welcome_user_email', $welcome_email, $user_id, $password, $meta );
1553 $welcome_email = str_replace( 'SITE_NAME', $current_site->site_name, $welcome_email );
1554 $welcome_email = str_replace( 'USERNAME', $user->user_login, $welcome_email );
1555 $welcome_email = str_replace( 'PASSWORD', $password, $welcome_email );
1556 $welcome_email = str_replace( 'LOGINLINK', wp_login_url(), $welcome_email );
1558 $admin_email = get_site_option( 'admin_email' );
1560 if ( $admin_email == '' )
1561 $admin_email = 'support@' . $_SERVER['SERVER_NAME'];
1563 $from_name = get_site_option( 'site_name' ) == '' ? 'WordPress' : esc_html( get_site_option( 'site_name' ) );
1564 $message_headers = "From: \"{$from_name}\" <{$admin_email}>\n" . "Content-Type: text/plain; charset=\"" . get_option('blog_charset') . "\"\n";
1565 $message = $welcome_email;
1567 if ( empty( $current_site->site_name ) )
1568 $current_site->site_name = 'WordPress';
1571 * Filter the subject of the welcome email after user activation.
1575 * @param string $subject Subject of the email.
1577 $subject = apply_filters( 'update_welcome_user_subject', sprintf( __( 'New %1$s User: %2$s' ), $current_site->site_name, $user->user_login) );
1578 wp_mail( $user->user_email, wp_specialchars_decode( $subject ), $message, $message_headers );
1583 * Get the current site info.
1585 * Returns an object containing the 'id', 'domain', 'path', and 'site_name'
1586 * properties of the site being viewed.
1588 * @see wpmu_current_site()
1592 * @global object $current_site
1596 function get_current_site() {
1597 global $current_site;
1598 return $current_site;
1602 * Get a user's most recent post.
1604 * Walks through each of a user's blogs to find the post with
1605 * the most recent post_date_gmt.
1609 * @global wpdb $wpdb WordPress database abstraction object.
1611 * @param int $user_id
1612 * @return array Contains the blog_id, post_id, post_date_gmt, and post_gmt_ts
1614 function get_most_recent_post_of_user( $user_id ) {
1617 $user_blogs = get_blogs_of_user( (int) $user_id );
1618 $most_recent_post = array();
1620 // Walk through each blog and get the most recent post
1621 // published by $user_id
1622 foreach ( (array) $user_blogs as $blog ) {
1623 $prefix = $wpdb->get_blog_prefix( $blog->userblog_id );
1624 $recent_post = $wpdb->get_row( $wpdb->prepare("SELECT ID, post_date_gmt FROM {$prefix}posts WHERE post_author = %d AND post_type = 'post' AND post_status = 'publish' ORDER BY post_date_gmt DESC LIMIT 1", $user_id ), ARRAY_A);
1626 // Make sure we found a post
1627 if ( isset($recent_post['ID']) ) {
1628 $post_gmt_ts = strtotime($recent_post['post_date_gmt']);
1630 // If this is the first post checked or if this post is
1631 // newer than the current recent post, make it the new
1632 // most recent post.
1633 if ( !isset($most_recent_post['post_gmt_ts']) || ( $post_gmt_ts > $most_recent_post['post_gmt_ts'] ) ) {
1634 $most_recent_post = array(
1635 'blog_id' => $blog->userblog_id,
1636 'post_id' => $recent_post['ID'],
1637 'post_date_gmt' => $recent_post['post_date_gmt'],
1638 'post_gmt_ts' => $post_gmt_ts
1644 return $most_recent_post;
1650 * Get the size of a directory.
1652 * A helper function that is used primarily to check whether
1653 * a blog has exceeded its allowed upload space.
1657 * @param string $directory Full path of a directory.
1658 * @return int Size of the directory in MB.
1660 function get_dirsize( $directory ) {
1661 $dirsize = get_transient( 'dirsize_cache' );
1662 if ( is_array( $dirsize ) && isset( $dirsize[ $directory ][ 'size' ] ) )
1663 return $dirsize[ $directory ][ 'size' ];
1665 if ( ! is_array( $dirsize ) )
1668 // Exclude individual site directories from the total when checking the main site,
1669 // as they are subdirectories and should not be counted.
1670 if ( is_main_site() ) {
1671 $dirsize[ $directory ][ 'size' ] = recurse_dirsize( $directory, $directory . '/sites' );
1673 $dirsize[ $directory ][ 'size' ] = recurse_dirsize( $directory );
1676 set_transient( 'dirsize_cache', $dirsize, HOUR_IN_SECONDS );
1677 return $dirsize[ $directory ][ 'size' ];
1681 * Get the size of a directory recursively.
1683 * Used by get_dirsize() to get a directory's size when it contains
1684 * other directories.
1687 * @since 4.3.0 $exclude parameter added.
1689 * @param string $directory Full path of a directory.
1690 * @param string $exclude Optional. Full path of a subdirectory to exclude from the total.
1691 * @return int|false Size in MB if a valid directory. False if not.
1693 function recurse_dirsize( $directory, $exclude = null ) {
1696 $directory = untrailingslashit( $directory );
1698 if ( ! file_exists( $directory ) || ! is_dir( $directory ) || ! is_readable( $directory ) || $directory === $exclude ) {
1702 if ($handle = opendir($directory)) {
1703 while(($file = readdir($handle)) !== false) {
1704 $path = $directory.'/'.$file;
1705 if ($file != '.' && $file != '..') {
1706 if (is_file($path)) {
1707 $size += filesize($path);
1708 } elseif (is_dir($path)) {
1709 $handlesize = recurse_dirsize( $path, $exclude );
1710 if ($handlesize > 0)
1711 $size += $handlesize;
1721 * Check an array of MIME types against a whitelist.
1723 * WordPress ships with a set of allowed upload filetypes,
1724 * which is defined in wp-includes/functions.php in
1725 * get_allowed_mime_types(). This function is used to filter
1726 * that list against the filetype whitelist provided by Multisite
1727 * Super Admins at wp-admin/network/settings.php.
1731 * @param array $mimes
1734 function check_upload_mimes( $mimes ) {
1735 $site_exts = explode( ' ', get_site_option( 'upload_filetypes', 'jpg jpeg png gif' ) );
1736 $site_mimes = array();
1737 foreach ( $site_exts as $ext ) {
1738 foreach ( $mimes as $ext_pattern => $mime ) {
1739 if ( $ext != '' && strpos( $ext_pattern, $ext ) !== false )
1740 $site_mimes[$ext_pattern] = $mime;
1747 * Update a blog's post count.
1749 * WordPress MS stores a blog's post count as an option so as
1750 * to avoid extraneous COUNTs when a blog's details are fetched
1751 * with get_blog_details(). This function is called when posts
1752 * are published or unpublished to make sure the count stays current.
1756 * @global wpdb $wpdb WordPress database abstraction object.
1758 function update_posts_count( $deprecated = '' ) {
1760 update_option( 'post_count', (int) $wpdb->get_var( "SELECT COUNT(ID) FROM {$wpdb->posts} WHERE post_status = 'publish' and post_type = 'post'" ) );
1764 * Logs user registrations.
1768 * @global wpdb $wpdb WordPress database abstraction object.
1770 * @param int $blog_id
1771 * @param int $user_id
1773 function wpmu_log_new_registrations( $blog_id, $user_id ) {
1775 $user = get_userdata( (int) $user_id );
1777 $wpdb->insert( $wpdb->registration_log, array('email' => $user->user_email, 'IP' => preg_replace( '/[^0-9., ]/', '', wp_unslash( $_SERVER['REMOTE_ADDR'] ) ), 'blog_id' => $blog_id, 'date_registered' => current_time('mysql')) );
1781 * Maintains a canonical list of terms by syncing terms created for each blog with the global terms table.
1785 * @see term_id_filter
1787 * @global wpdb $wpdb WordPress database abstraction object.
1788 * @staticvar int $global_terms_recurse
1790 * @param int $term_id An ID for a term on the current blog.
1791 * @return int An ID from the global terms table mapped from $term_id.
1793 function global_terms( $term_id, $deprecated = '' ) {
1795 static $global_terms_recurse = null;
1797 if ( !global_terms_enabled() )
1800 // prevent a race condition
1801 $recurse_start = false;
1802 if ( $global_terms_recurse === null ) {
1803 $recurse_start = true;
1804 $global_terms_recurse = 1;
1805 } elseif ( 10 < $global_terms_recurse++ ) {
1809 $term_id = intval( $term_id );
1810 $c = $wpdb->get_row( $wpdb->prepare( "SELECT * FROM $wpdb->terms WHERE term_id = %d", $term_id ) );
1812 $global_id = $wpdb->get_var( $wpdb->prepare( "SELECT cat_ID FROM $wpdb->sitecategories WHERE category_nicename = %s", $c->slug ) );
1813 if ( $global_id == null ) {
1814 $used_global_id = $wpdb->get_var( $wpdb->prepare( "SELECT cat_ID FROM $wpdb->sitecategories WHERE cat_ID = %d", $c->term_id ) );
1815 if ( null == $used_global_id ) {
1816 $wpdb->insert( $wpdb->sitecategories, array( 'cat_ID' => $term_id, 'cat_name' => $c->name, 'category_nicename' => $c->slug ) );
1817 $global_id = $wpdb->insert_id;
1818 if ( empty( $global_id ) )
1821 $max_global_id = $wpdb->get_var( "SELECT MAX(cat_ID) FROM $wpdb->sitecategories" );
1822 $max_local_id = $wpdb->get_var( "SELECT MAX(term_id) FROM $wpdb->terms" );
1823 $new_global_id = max( $max_global_id, $max_local_id ) + mt_rand( 100, 400 );
1824 $wpdb->insert( $wpdb->sitecategories, array( 'cat_ID' => $new_global_id, 'cat_name' => $c->name, 'category_nicename' => $c->slug ) );
1825 $global_id = $wpdb->insert_id;
1827 } elseif ( $global_id != $term_id ) {
1828 $local_id = $wpdb->get_var( $wpdb->prepare( "SELECT term_id FROM $wpdb->terms WHERE term_id = %d", $global_id ) );
1829 if ( null != $local_id ) {
1830 global_terms( $local_id );
1831 if ( 10 < $global_terms_recurse ) {
1832 $global_id = $term_id;
1837 if ( $global_id != $term_id ) {
1838 if ( get_option( 'default_category' ) == $term_id )
1839 update_option( 'default_category', $global_id );
1841 $wpdb->update( $wpdb->terms, array('term_id' => $global_id), array('term_id' => $term_id) );
1842 $wpdb->update( $wpdb->term_taxonomy, array('term_id' => $global_id), array('term_id' => $term_id) );
1843 $wpdb->update( $wpdb->term_taxonomy, array('parent' => $global_id), array('parent' => $term_id) );
1845 clean_term_cache($term_id);
1847 if ( $recurse_start )
1848 $global_terms_recurse = null;
1854 * Ensure that the current site's domain is listed in the allowed redirect host list.
1856 * @see wp_validate_redirect()
1859 * @return array The current site's domain
1861 function redirect_this_site( $deprecated = '' ) {
1862 return array( get_current_site()->domain );
1866 * Check whether an upload is too big.
1872 * @param array $upload
1873 * @return string|array If the upload is under the size limit, $upload is returned. Otherwise returns an error message.
1875 function upload_is_file_too_big( $upload ) {
1876 if ( ! is_array( $upload ) || defined( 'WP_IMPORTING' ) || get_site_option( 'upload_space_check_disabled' ) )
1879 if ( strlen( $upload['bits'] ) > ( KB_IN_BYTES * get_site_option( 'fileupload_maxk', 1500 ) ) ) {
1880 return sprintf( __( 'This file is too big. Files must be less than %d KB in size.' ) . '<br />', get_site_option( 'fileupload_maxk', 1500 ) );
1887 * Add a nonce field to the signup page.
1891 function signup_nonce_fields() {
1893 echo "<input type='hidden' name='signup_form_id' value='{$id}' />";
1894 wp_nonce_field('signup_form_' . $id, '_signup_form', false);
1898 * Process the signup nonce created in signup_nonce_fields().
1902 * @param array $result
1905 function signup_nonce_check( $result ) {
1906 if ( !strpos( $_SERVER[ 'PHP_SELF' ], 'wp-signup.php' ) )
1909 if ( wp_create_nonce('signup_form_' . $_POST[ 'signup_form_id' ]) != $_POST['_signup_form'] )
1910 wp_die( __( 'Please try again.' ) );
1916 * Correct 404 redirects when NOBLOGREDIRECT is defined.
1920 function maybe_redirect_404() {
1922 * Filter the redirect URL for 404s on the main site.
1924 * The filter is only evaluated if the NOBLOGREDIRECT constant is defined.
1928 * @param string $no_blog_redirect The redirect URL defined in NOBLOGREDIRECT.
1930 if ( is_main_site() && is_404() && defined( 'NOBLOGREDIRECT' ) && ( $destination = apply_filters( 'blog_redirect_404', NOBLOGREDIRECT ) ) ) {
1931 if ( $destination == '%siteurl%' )
1932 $destination = network_home_url();
1933 wp_redirect( $destination );
1939 * Add a new user to a blog by visiting /newbloguser/username/.
1941 * This will only work when the user's details are saved as an option
1942 * keyed as 'new_user_x', where 'x' is the username of the user to be
1943 * added, as when a user is invited through the regular WP Add User interface.
1947 function maybe_add_existing_user_to_blog() {
1948 if ( false === strpos( $_SERVER[ 'REQUEST_URI' ], '/newbloguser/' ) )
1951 $parts = explode( '/', $_SERVER[ 'REQUEST_URI' ] );
1952 $key = array_pop( $parts );
1955 $key = array_pop( $parts );
1957 $details = get_option( 'new_user_' . $key );
1958 if ( !empty( $details ) )
1959 delete_option( 'new_user_' . $key );
1961 if ( empty( $details ) || is_wp_error( add_existing_user_to_blog( $details ) ) )
1962 wp_die( sprintf(__('An error occurred adding you to this site. Back to the <a href="%s">homepage</a>.'), home_url() ) );
1964 wp_die( sprintf( __( 'You have been added to this site. Please visit the <a href="%s">homepage</a> or <a href="%s">log in</a> using your username and password.' ), home_url(), admin_url() ), __( 'WordPress › Success' ), array( 'response' => 200 ) );
1968 * Add a user to a blog based on details from maybe_add_existing_user_to_blog().
1972 * @global int $blog_id
1974 * @param array $details
1975 * @return true|WP_Error|void
1977 function add_existing_user_to_blog( $details = false ) {
1980 if ( is_array( $details ) ) {
1981 $result = add_user_to_blog( $blog_id, $details[ 'user_id' ], $details[ 'role' ] );
1983 * Fires immediately after an existing user is added to a site.
1987 * @param int $user_id User ID.
1988 * @param mixed $result True on success or a WP_Error object if the user doesn't exist.
1990 do_action( 'added_existing_user', $details['user_id'], $result );
1996 * Add a newly created user to the appropriate blog
1998 * To add a user in general, use add_user_to_blog(). This function
1999 * is specifically hooked into the wpmu_activate_user action.
2002 * @see add_user_to_blog()
2004 * @param int $user_id
2005 * @param mixed $password Ignored.
2006 * @param array $meta
2008 function add_new_user_to_blog( $user_id, $password, $meta ) {
2009 if ( !empty( $meta[ 'add_to_blog' ] ) ) {
2010 $blog_id = $meta[ 'add_to_blog' ];
2011 $role = $meta[ 'new_role' ];
2012 remove_user_from_blog($user_id, get_current_site()->blog_id); // remove user from main blog.
2013 add_user_to_blog( $blog_id, $user_id, $role );
2014 update_user_meta( $user_id, 'primary_blog', $blog_id );
2019 * Correct From host on outgoing mail to match the site domain
2023 function fix_phpmailer_messageid( $phpmailer ) {
2024 $phpmailer->Hostname = get_current_site()->domain;
2028 * Check to see whether a user is marked as a spammer, based on user login.
2032 * @param string|WP_User $user Optional. Defaults to current user. WP_User object,
2033 * or user login name as a string.
2036 function is_user_spammy( $user = null ) {
2037 if ( ! ( $user instanceof WP_User ) ) {
2039 $user = get_user_by( 'login', $user );
2041 $user = wp_get_current_user();
2045 return $user && isset( $user->spam ) && 1 == $user->spam;
2049 * Update this blog's 'public' setting in the global blogs table.
2051 * Public blogs have a setting of 1, private blogs are 0.
2055 * @param int $old_value
2056 * @param int $value The new public value
2058 function update_blog_public( $old_value, $value ) {
2059 update_blog_status( get_current_blog_id(), 'public', (int) $value );
2063 * Check whether a usermeta key has to do with the current blog.
2067 * @global wpdb $wpdb WordPress database abstraction object.
2069 * @param string $key
2070 * @param int $user_id Optional. Defaults to current user.
2071 * @param int $blog_id Optional. Defaults to current blog.
2074 function is_user_option_local( $key, $user_id = 0, $blog_id = 0 ) {
2077 $current_user = wp_get_current_user();
2078 if ( $blog_id == 0 ) {
2079 $blog_id = $wpdb->blogid;
2081 $local_key = $wpdb->get_blog_prefix( $blog_id ) . $key;
2083 return isset( $current_user->$local_key );
2087 * Check whether users can self-register, based on Network settings.
2093 function users_can_register_signup_filter() {
2094 $registration = get_site_option('registration');
2095 return ( $registration == 'all' || $registration == 'user' );
2099 * Ensure that the welcome message is not empty. Currently unused.
2103 * @param string $text
2106 function welcome_user_msg_filter( $text ) {
2108 remove_filter( 'site_option_welcome_user_email', 'welcome_user_msg_filter' );
2110 /* translators: Do not translate USERNAME, PASSWORD, LOGINLINK, SITE_NAME: those are placeholders. */
2111 $text = __( 'Howdy USERNAME,
2113 Your new account is set up.
2115 You can log in with the following information:
2122 --The Team @ SITE_NAME' );
2123 update_site_option( 'welcome_user_email', $text );
2129 * Whether to force SSL on content.
2133 * @staticvar bool $forced_content
2135 * @param bool $force
2136 * @return bool True if forced, false if not forced.
2138 function force_ssl_content( $force = '' ) {
2139 static $forced_content = false;
2141 if ( '' != $force ) {
2142 $old_forced = $forced_content;
2143 $forced_content = $force;
2147 return $forced_content;
2151 * Formats a URL to use https.
2153 * Useful as a filter.
2158 * @return string URL with https as the scheme
2160 function filter_SSL( $url ) {
2161 if ( ! is_string( $url ) )
2162 return get_bloginfo( 'url' ); // Return home blog url with proper scheme
2164 if ( force_ssl_content() && is_ssl() )
2165 $url = set_url_scheme( $url, 'https' );
2171 * Schedule update of the network-wide counts for the current network.
2175 function wp_schedule_update_network_counts() {
2176 if ( !is_main_site() )
2179 if ( ! wp_next_scheduled('update_network_counts') && ! wp_installing() )
2180 wp_schedule_event(time(), 'twicedaily', 'update_network_counts');
2184 * Update the network-wide counts for the current network.
2188 function wp_update_network_counts() {
2189 wp_update_network_user_counts();
2190 wp_update_network_site_counts();
2194 * Update the count of sites for the current network.
2196 * If enabled through the 'enable_live_network_counts' filter, update the sites count
2197 * on a network when a site is created or its status is updated.
2201 function wp_maybe_update_network_site_counts() {
2202 $is_small_network = ! wp_is_large_network( 'sites' );
2205 * Filter whether to update network site or user counts when a new site is created.
2209 * @see wp_is_large_network()
2211 * @param bool $small_network Whether the network is considered small.
2212 * @param string $context Context. Either 'users' or 'sites'.
2214 if ( ! apply_filters( 'enable_live_network_counts', $is_small_network, 'sites' ) )
2217 wp_update_network_site_counts();
2221 * Update the network-wide users count.
2223 * If enabled through the 'enable_live_network_counts' filter, update the users count
2224 * on a network when a user is created or its status is updated.
2228 function wp_maybe_update_network_user_counts() {
2229 $is_small_network = ! wp_is_large_network( 'users' );
2231 /** This filter is documented in wp-includes/ms-functions.php */
2232 if ( ! apply_filters( 'enable_live_network_counts', $is_small_network, 'users' ) )
2235 wp_update_network_user_counts();
2239 * Update the network-wide site count.
2243 * @global wpdb $wpdb WordPress database abstraction object.
2245 function wp_update_network_site_counts() {
2248 $count = $wpdb->get_var( $wpdb->prepare("SELECT COUNT(blog_id) as c FROM $wpdb->blogs WHERE site_id = %d AND spam = '0' AND deleted = '0' and archived = '0'", $wpdb->siteid) );
2249 update_site_option( 'blog_count', $count );
2253 * Update the network-wide user count.
2257 * @global wpdb $wpdb WordPress database abstraction object.
2259 function wp_update_network_user_counts() {
2262 $count = $wpdb->get_var( "SELECT COUNT(ID) as c FROM $wpdb->users WHERE spam = '0' AND deleted = '0'" );
2263 update_site_option( 'user_count', $count );
2267 * Returns the space used by the current blog.
2271 * @return int Used space in megabytes
2273 function get_space_used() {
2275 * Filter the amount of storage space used by the current site.
2279 * @param int|bool $space_used The amount of used space, in megabytes. Default false.
2281 $space_used = apply_filters( 'pre_get_space_used', false );
2282 if ( false === $space_used ) {
2283 $upload_dir = wp_upload_dir();
2284 $space_used = get_dirsize( $upload_dir['basedir'] ) / MB_IN_BYTES;
2291 * Returns the upload quota for the current blog.
2295 * @return int Quota in megabytes
2297 function get_space_allowed() {
2298 $space_allowed = get_option( 'blog_upload_space' );
2300 if ( ! is_numeric( $space_allowed ) )
2301 $space_allowed = get_site_option( 'blog_upload_space' );
2303 if ( ! is_numeric( $space_allowed ) )
2304 $space_allowed = 100;
2307 * Filter the upload quota for the current site.
2311 * @param int $space_allowed Upload quota in megabytes for the current blog.
2313 return apply_filters( 'get_space_allowed', $space_allowed );
2317 * Determines if there is any upload space left in the current blog's quota.
2321 * @return int of upload space available in bytes
2323 function get_upload_space_available() {
2324 $allowed = get_space_allowed();
2325 if ( $allowed < 0 ) {
2328 $space_allowed = $allowed * MB_IN_BYTES;
2329 if ( get_site_option( 'upload_space_check_disabled' ) )
2330 return $space_allowed;
2332 $space_used = get_space_used() * MB_IN_BYTES;
2334 if ( ( $space_allowed - $space_used ) <= 0 )
2337 return $space_allowed - $space_used;
2341 * Determines if there is any upload space left in the current blog's quota.
2344 * @return bool True if space is available, false otherwise.
2346 function is_upload_space_available() {
2347 if ( get_site_option( 'upload_space_check_disabled' ) )
2350 return (bool) get_upload_space_available();
2356 * @return int of upload size limit in bytes
2358 function upload_size_limit_filter( $size ) {
2359 $fileupload_maxk = KB_IN_BYTES * get_site_option( 'fileupload_maxk', 1500 );
2360 if ( get_site_option( 'upload_space_check_disabled' ) )
2361 return min( $size, $fileupload_maxk );
2363 return min( $size, $fileupload_maxk, get_upload_space_available() );
2367 * Whether or not we have a large network.
2369 * The default criteria for a large network is either more than 10,000 users or more than 10,000 sites.
2370 * Plugins can alter this criteria using the 'wp_is_large_network' filter.
2373 * @param string $using 'sites or 'users'. Default is 'sites'.
2374 * @return bool True if the network meets the criteria for large. False otherwise.
2376 function wp_is_large_network( $using = 'sites' ) {
2377 if ( 'users' == $using ) {
2378 $count = get_user_count();
2380 * Filter whether the network is considered large.
2384 * @param bool $is_large_network Whether the network has more than 10000 users or sites.
2385 * @param string $component The component to count. Accepts 'users', or 'sites'.
2386 * @param int $count The count of items for the component.
2388 return apply_filters( 'wp_is_large_network', $count > 10000, 'users', $count );
2391 $count = get_blog_count();
2392 /** This filter is documented in wp-includes/ms-functions.php */
2393 return apply_filters( 'wp_is_large_network', $count > 10000, 'sites', $count );
2398 * Return an array of sites for a network or networks.
2402 * @global wpdb $wpdb WordPress database abstraction object.
2404 * @param array $args {
2405 * Array of default arguments. Optional.
2407 * @type int|array $network_id A network ID or array of network IDs. Set to null to retrieve sites
2408 * from all networks. Defaults to current network ID.
2409 * @type int $public Retrieve public or non-public sites. Default null, for any.
2410 * @type int $archived Retrieve archived or non-archived sites. Default null, for any.
2411 * @type int $mature Retrieve mature or non-mature sites. Default null, for any.
2412 * @type int $spam Retrieve spam or non-spam sites. Default null, for any.
2413 * @type int $deleted Retrieve deleted or non-deleted sites. Default null, for any.
2414 * @type int $limit Number of sites to limit the query to. Default 100.
2415 * @type int $offset Exclude the first x sites. Used in combination with the $limit parameter. Default 0.
2417 * @return array An empty array if the install is considered "large" via wp_is_large_network(). Otherwise,
2418 * an associative array of site data arrays, each containing the site (network) ID, blog ID,
2419 * site domain and path, dates registered and modified, and the language ID. Also, boolean
2420 * values for whether the site is public, archived, mature, spam, and/or deleted.
2422 function wp_get_sites( $args = array() ) {
2425 if ( wp_is_large_network() )
2429 'network_id' => $wpdb->siteid,
2439 $args = wp_parse_args( $args, $defaults );
2441 $query = "SELECT * FROM $wpdb->blogs WHERE 1=1 ";
2443 if ( isset( $args['network_id'] ) && ( is_array( $args['network_id'] ) || is_numeric( $args['network_id'] ) ) ) {
2444 $network_ids = implode( ',', wp_parse_id_list( $args['network_id'] ) );
2445 $query .= "AND site_id IN ($network_ids) ";
2448 if ( isset( $args['public'] ) )
2449 $query .= $wpdb->prepare( "AND public = %d ", $args['public'] );
2451 if ( isset( $args['archived'] ) )
2452 $query .= $wpdb->prepare( "AND archived = %d ", $args['archived'] );
2454 if ( isset( $args['mature'] ) )
2455 $query .= $wpdb->prepare( "AND mature = %d ", $args['mature'] );
2457 if ( isset( $args['spam'] ) )
2458 $query .= $wpdb->prepare( "AND spam = %d ", $args['spam'] );
2460 if ( isset( $args['deleted'] ) )
2461 $query .= $wpdb->prepare( "AND deleted = %d ", $args['deleted'] );
2463 if ( isset( $args['limit'] ) && $args['limit'] ) {
2464 if ( isset( $args['offset'] ) && $args['offset'] )
2465 $query .= $wpdb->prepare( "LIMIT %d , %d ", $args['offset'], $args['limit'] );
2467 $query .= $wpdb->prepare( "LIMIT %d ", $args['limit'] );
2470 $site_results = $wpdb->get_results( $query, ARRAY_A );
2472 return $site_results;
2476 * Retrieves a list of reserved site on a sub-directory Multisite install.
2480 * @return array $names Array of reserved subdirectory names.
2482 function get_subdirectory_reserved_names() {
2484 'page', 'comments', 'blog', 'files', 'feed', 'wp-admin',
2485 'wp-content', 'wp-includes', 'wp-json', 'embed'
2489 * Filter reserved site names on a sub-directory Multisite install.
2492 * @since 4.4.0 'wp-admin', 'wp-content', 'wp-includes', 'wp-json', and 'embed' were added
2493 * to the reserved names list.
2495 * @param array $subdirectory_reserved_names Array of reserved names.
2497 return apply_filters( 'subdirectory_reserved_names', $names );