+
+
+
+
+
+ get_error_code() || 'blog_taken' == $result->get_error_code() ) {
+ $signup = $result->get_error_data();
+ ?>
+
+ domain . $signup->path == '' ) {
+ printf(__('
Your account has been activated. You may now login to the site using your chosen username of "%2$s". Please check your email inbox at %3$s for your password and login instructions. If you do not receive an email, please check your junk or spam folder. If you still do not receive an email within an hour, you can reset your password .
'), 'http://' . $current_site->domain . $current_site->path . 'wp-login.php', $signup->user_login, $signup->user_email, 'http://' . $current_site->domain . $current_site->path . 'wp-login.php?action=lostpassword');
+ } else {
+ printf(__('
Your blog at %2$s is active. You may now login to your blog using your chosen username of "%3$s". Please check your email inbox at %4$s for your password and login instructions. If you do not receive an email, please check your junk or spam folder. If you still do not receive an email within an hour, you can reset your password .
'), 'http://' . $signup->domain, $signup->domain, $signup->user_login, $signup->user_email, 'http://' . $current_site->domain . $current_site->path . 'wp-login.php?action=lostpassword');
+ }
+ } else {
+ ?>
+
+ '.$result->get_error_message().'';
+ }
+ } else {
+ extract($result);
+ $url = get_blogaddress_by_id( (int) $blog_id);
+ $user = new WP_User( (int) $user_id);
+ ?>
+
+
+
+
+ domain . $current_site->path ) : ?>
+
View your site or Login '), $url, $url . 'wp-login.php' ); ?>
+
+
Login or go back to the homepage .' ), 'http://' . $current_site->domain . $current_site->path . 'wp-login.php', 'http://' . $current_site->domain . $current_site->path ); ?>
+
+
' . __( 'Transfer posts before deleting users:' ) . '
';
+
+ echo '" . sprintf( __( "Your email address has not been updated yet. Please check your inbox at %s for a confirmation email." ), $email[ 'newemail' ] ) . "
";
+}
+add_action( 'admin_notices', 'new_user_email_admin_notice' );
+
+function get_site_allowed_themes() {
+ $themes = get_themes();
+ $allowed_themes = get_site_option( 'allowedthemes' );
+ if( !is_array( $allowed_themes ) || empty( $allowed_themes ) ) {
+ $allowed_themes = get_site_option( "allowed_themes" ); // convert old allowed_themes format
+ if( !is_array( $allowed_themes ) ) {
+ $allowed_themes = array();
+ } else {
+ foreach( (array) $themes as $key => $theme ) {
+ $theme_key = wp_specialchars( $theme[ 'Stylesheet' ] );
+ if( isset( $allowed_themes[ $key ] ) == true ) {
+ $allowedthemes[ $theme_key ] = 1;
+ }
+ }
+ $allowed_themes = $allowedthemes;
+ }
+ }
+ return $allowed_themes;
+}
+
+function get_space_allowed() {
+ $spaceAllowed = get_option("blog_upload_space");
+ if( $spaceAllowed == false )
+ $spaceAllowed = get_site_option("blog_upload_space");
+ if( empty($spaceAllowed) || !is_numeric($spaceAllowed) )
+ $spaceAllowed = 50;
+
+ return $spaceAllowed;
+}
+
+function display_space_usage() {
+ $space = get_space_allowed();
+ $used = get_dirsize( BLOGUPLOADDIR )/1024/1024;
+
+ if ($used > $space) $percentused = '100';
+ else $percentused = ( $used / $space ) * 100;
+
+ if( $space > 1000 ) {
+ $space = number_format( $space / 1024 );
+ $space .= __('GB');
+ } else {
+ $space .= __('MB');
+ }
+ ?>
+ " . __("Your feed at %s is empty.") . "
", wp_specialchars( $url ));
+ }
+}
+add_action( 'admin_notices', 'admin_notice_feed' );
+
+function site_admin_notice() {
+ global $current_user, $wp_db_version;
+ if( !is_site_admin() )
+ return false;
+ printf("" . __("Hi %s! You're logged in as a site administrator.") . "
", $current_user->user_login);
+ if ( get_site_option( 'wpmu_upgrade_site' ) != $wp_db_version ) {
+ echo "' . __( 'Warning! Only site administrators may see this page. Everyone else will see a page disabled message. Enable it again on the options page .' ) . '
';
+ } else {
+ wp_die( __('Page disabled by the administrator') );
+ }
+ }
+
+ $pages = array( 'theme-editor.php', 'plugin-editor.php' );
+ foreach( $pages as $page ) {
+ if ( strpos( $_SERVER['PHP_SELF'], $page ) ) {
+ wp_die( __('Page disabled by the administrator') );
+ }
+ }
+
+ $pages = array( 'theme-install.php', 'plugin-install.php' );
+ foreach( $pages as $page ) {
+ if ( strpos( $_SERVER['PHP_SELF'], $page ) && !is_site_admin() ) {
+ wp_die( __( "Sorry, you're not allowed here." ) );
+ }
+ }
+
+}
+add_action( 'admin_init', 'disable_some_pages' );
+
+function blogs_listing_post() {
+ if ( !isset( $_POST[ 'action' ] ) ) {
+ return false;
+ }
+ switch( $_POST[ 'action' ] ) {
+ case "updateblogsettings":
+ do_action( 'myblogs_update' );
+ wp_redirect( admin_url( 'index.php?page=myblogs&updated=1' ) );
+ die();
+ break;
+ }
+}
+add_action( 'admin_init', 'blogs_listing_post' );
+
+function blogs_listing() {
+ global $current_user;
+
+ $blogs = get_blogs_of_user( $current_user->ID );
+ if( !$blogs || ( is_array( $blogs ) && empty( $blogs ) ) ) {
+ wp_die( __( 'You must be a member of at least one blog to use this page.' ) );
+ }
+
+ if ( empty($title) )
+ $title = apply_filters( 'my_blogs_title', __( 'My Blogs' ) );
+ ?>
+
+ * @package WordPress
+ * @subpackage Administration
+ */
+
+/** Load WordPress Administration Bootstrap */
+require_once('admin.php');
+$parent_file = 'edit.php';
+$title = __('Import Blogroll');
+
+$step = $_POST['step'];
+if (!$step) $step = 0;
+?>
+
+
+
+
+
+
+
+ false, 'test_type' => false);
+ $file = wp_handle_upload($_FILES['userfile'], $overrides);
+
+ if ( isset($file['error']) )
+ wp_die($file['error']);
+
+ $url = $file['url'];
+ $opml_url = $file['file'];
+ $blogrolling = false;
+ }
+
+ if ( isset($opml_url) && $opml_url != '' ) {
+ if ( $blogrolling === true ) {
+ $opml = wp_remote_fopen($opml_url);
+ } else {
+ $opml = file_get_contents($opml_url);
+ }
+
+ /** Load OPML Parser */
+ include_once('link-parse-opml.php');
+
+ $link_count = count($names);
+ for ( $i = 0; $i < $link_count; $i++ ) {
+ if ('Last' == substr($titles[$i], 0, 4))
+ $titles[$i] = '';
+ if ( 'http' == substr($titles[$i], 0, 4) )
+ $titles[$i] = '';
+ $link = array( 'link_url' => $urls[$i], 'link_name' => $wpdb->escape($names[$i]), 'link_category' => array($cat_id), 'link_description' => $wpdb->escape($descriptions[$i]), 'link_owner' => $user_ID, 'link_rss' => $feeds[$i]);
+ wp_insert_link($link);
+ echo sprintf('
'.__('Inserted %s ').'
', $names[$i]);
+ }
+?>
+
+
manage those links.'), $link_count, $cat_id, 'link-manager.php') ?>
+
+" . __("You need to supply your OPML url. Press back on your browser and try again") . "\n";
+} // end else
+
+if ( ! $blogrolling )
+ do_action( 'wp_delete_file', $opml_url);
+ @unlink($opml_url);
+?>
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
blogs page ') );
+
+ // themes
+ if( is_array( $_POST[ 'theme' ] ) ) {
+ $_POST[ 'option' ][ 'allowedthemes' ] = $_POST[ 'theme' ];
+ } else {
+ $_POST[ 'option' ][ 'allowedthemes' ] = '';
+ }
+
+ switch_to_blog( $id );
+ if( is_array( $_POST[ 'option' ] ) ) {
+ $c = 1;
+ $count = count( $_POST[ 'option' ] );
+ foreach ( (array) $_POST['option'] as $key => $val ) {
+ if( $key === 0 )
+ continue; // Avoids "0 is a protected WP option and may not be modified" error when edit blog options
+ if( $c == $count ) {
+ update_option( $key, $val );
+ } else {
+ update_option( $key, $val, false ); // no need to refresh blog details yet
+ }
+ $c++;
+ }
+ }
+
+ if( $_POST['update_home_url'] == 'update' ) {
+ if( get_option( 'siteurl' ) != 'http://' . $_POST['blog']['domain'] . $_POST['blog']['path'] )
+ update_option( 'siteurl', 'http://' . $_POST['blog']['domain'] . $_POST['blog']['path'] );
+
+ if( get_option( 'home' ) != 'http://' . $_POST['blog']['domain'] . $_POST['blog']['path'] )
+ update_option( 'home', 'http://' . $_POST['blog']['domain'] . $_POST['blog']['path'] );
+ }
+
+ $wp_rewrite->flush_rules();
+
+ // update blogs table
+ $result = $wpdb->query( "UPDATE {$wpdb->blogs} SET
+ domain = '".$_POST[ 'blog' ][ 'domain' ]."',
+ path = '".$_POST[ 'blog' ][ 'path' ]."',
+ registered = '".$_POST[ 'blog' ][ 'registered' ]."',
+ public = '".$_POST[ 'blog' ][ 'public' ]."',
+ archived = '".$_POST[ 'blog' ][ 'archived' ]."',
+ mature = '".$_POST[ 'blog' ][ 'mature' ]."',
+ deleted = '".$_POST[ 'blog' ][ 'deleted' ]."',
+ spam = '".$_POST[ 'blog' ][ 'spam' ]."'
+ WHERE blog_id = '$id'" );
+
+ update_blog_status( $id, 'spam', $_POST[ 'blog' ][ 'spam' ] );
+ update_option( 'blog_public', $_POST[ 'blog' ][ 'public' ] );
+
+ // get blog prefix
+ $blog_prefix = $wpdb->get_blog_prefix( $id );
+ // user roles
+ if( is_array( $_POST[ 'role' ] ) == true ) {
+ $newroles = $_POST[ 'role' ];
+ reset( $newroles );
+ foreach ( (array) $newroles as $userid => $role ) {
+ $role_len = strlen( $role );
+ $existing_role = $wpdb->get_var( "SELECT meta_value FROM $wpdb->usermeta WHERE user_id = '$userid' AND meta_key = '" . $blog_prefix. "capabilities'" );
+ if( false == $existing_role ) {
+ $wpdb->query( "INSERT INTO " . $wpdb->usermeta . "( `umeta_id` , `user_id` , `meta_key` , `meta_value` ) VALUES ( NULL, '$userid', '" . $blog_prefix . "capabilities', 'a:1:{s:" . strlen( $role ) . ":\"" . $role . "\";b:1;}')" );
+ } elseif( $existing_role != "a:1:{s:" . strlen( $role ) . ":\"" . $role . "\";b:1;}" ) {
+ $wpdb->query( "UPDATE $wpdb->usermeta SET meta_value = 'a:1:{s:" . strlen( $role ) . ":\"" . $role . "\";b:1;}' WHERE user_id = '$userid' AND meta_key = '" . $blog_prefix . "capabilities'" );
+ }
+
+ }
+ }
+
+ // remove user
+ if( is_array( $_POST[ 'blogusers' ] ) ) {
+ reset( $_POST[ 'blogusers' ] );
+ foreach ( (array) $_POST[ 'blogusers' ] as $key => $val )
+ remove_user_from_blog( $key, $id );
+ }
+
+ // change password
+ if( is_array( $_POST[ 'user_password' ] ) ) {
+ reset( $_POST[ 'user_password' ] );
+ $newroles = $_POST[ 'role' ];
+ foreach ( (array) $_POST[ 'user_password' ] as $userid => $pass ) {
+ unset( $_POST[ 'role' ] );
+ $_POST[ 'role' ] = $newroles[ $userid ];
+ if( $pass != '' ) {
+ $cap = $wpdb->get_var( "SELECT meta_value FROM {$wpdb->usermeta} WHERE user_id = '{$userid}' AND meta_key = '{$blog_prefix}capabilities' AND meta_value = 'a:0:{}'" );
+ $userdata = get_userdata($userid);
+ $_POST[ 'pass1' ] = $_POST[ 'pass2' ] = $pass;
+ $_POST[ 'email' ] = $userdata->user_email;
+ $_POST[ 'rich_editing' ] = $userdata->rich_editing;
+ edit_user( $userid );
+ if( $cap == null )
+ $wpdb->query( "DELETE FROM {$wpdb->usermeta} WHERE user_id = '{$userid}' AND meta_key = '{$blog_prefix}capabilities' AND meta_value = 'a:0:{}'" );
+ }
+ }
+ unset( $_POST[ 'role' ] );
+ $_POST[ 'role' ] = $newroles;
+ }
+
+ // add user?
+ if( $_POST[ 'newuser' ] != '' ) {
+ $newuser = $_POST[ 'newuser' ];
+ $userid = $wpdb->get_var( $wpdb->prepare( "SELECT ID FROM " . $wpdb->users . " WHERE user_login = %s", $newuser ) );
+ if( $userid ) {
+ $user = $wpdb->get_var( "SELECT user_id FROM " . $wpdb->usermeta . " WHERE user_id='$userid' AND meta_key='wp_" . $id . "_capabilities'" );
+ if( $user == false )
+ add_user_to_blog($id, $userid, $_POST[ 'new_role' ]);
+ }
+ }
+ do_action( 'wpmu_update_blog_options' );
+ restore_current_blog();
+ wpmu_admin_do_redirect( "wpmu-blogs.php?action=editblog&updated=true&id=".$id );
+ break;
+
+ case "deleteblog":
+ check_admin_referer('deleteblog');
+ if( $id != '0' && $id != $current_site->blog_id )
+ wpmu_delete_blog( $id, true );
+
+ wp_redirect( add_query_arg( array('updated' => 'true', 'action' => 'delete'), $_POST[ 'ref' ] ) );
+ exit();
+ break;
+
+ case "allblogs":
+ check_admin_referer('allblogs');
+ foreach ( (array) $_POST[ 'allblogs' ] as $key => $val ) {
+ if( $val != '0' && $val != $current_site->blog_id ) {
+ if ( isset($_POST['allblog_delete']) ) {
+ $blogfunction = 'all_delete';
+ wpmu_delete_blog( $val, true );
+ } elseif ( isset($_POST['allblog_spam']) ) {
+ $blogfunction = 'all_spam';
+ update_blog_status( $val, "spam", '1', 0 );
+ set_time_limit(60);
+ } elseif ( isset($_POST['allblog_notspam']) ) {
+ $blogfunction = 'all_notspam';
+ update_blog_status( $val, "spam", '0', 0 );
+ set_time_limit(60);
+ }
+ }
+ }
+
+ wp_redirect( add_query_arg( array('updated' => 'true', 'action' => $blogfunction), $_SERVER['HTTP_REFERER'] ) );
+ exit();
+ break;
+
+ case "archiveblog":
+ check_admin_referer('archiveblog');
+ update_blog_status( $id, "archived", '1' );
+ do_action( "archive_blog", $id );
+ wp_redirect( add_query_arg( array('updated' => 'true', 'action' => 'archive'), $_POST['ref'] ) );
+ exit();
+ break;
+
+ case "unarchiveblog":
+ check_admin_referer('unarchiveblog');
+ do_action( "unarchive_blog", $id );
+ update_blog_status( $id, "archived", '0' );
+ wp_redirect( add_query_arg( array('updated' => 'true', 'action' => 'unarchive'), $_POST['ref'] ) );
+ exit();
+ break;
+
+ case "activateblog":
+ check_admin_referer('activateblog');
+ update_blog_status( $id, "deleted", '0' );
+ do_action( "activate_blog", $id );
+ wp_redirect( add_query_arg( "updated", array('updated' => 'true', 'action' => 'activate'), $_POST['ref'] ) );
+ exit();
+ break;
+
+ case "deactivateblog":
+ check_admin_referer('deactivateblog');
+ do_action( "deactivate_blog", $id );
+ update_blog_status( $id, "deleted", '1' );
+ wp_redirect( add_query_arg( array('updated' => 'true', 'action' => 'deactivate'), $_POST['ref'] ) );
+ exit();
+ break;
+
+ case "unspamblog":
+ check_admin_referer('unspamblog');
+ update_blog_status( $id, "spam", '0' );
+ wp_redirect( add_query_arg( array('updated' => 'true', 'action' => 'unspam'), $_POST['ref'] ) );
+ exit();
+ break;
+
+ case "spamblog":
+ check_admin_referer('spamblog');
+ update_blog_status( $id, "spam", '1' );
+ wp_redirect( add_query_arg( array('updated' => 'true', 'action' => 'spam'), $_POST['ref'] ) );
+ exit();
+ break;
+
+ case "mature":
+ update_blog_status( $id, 'mature', '1' );
+ do_action( 'mature_blog', $id );
+ wp_redirect( add_query_arg( array('updated' => 'true', 'action' => 'mature'), $_POST['ref'] ) );
+ exit();
+ break;
+
+ case "unmature":
+ update_blog_status( $id, 'mature', '0' );
+ do_action( 'unmature_blog', $id );
+
+ wp_redirect( add_query_arg( array('updated' => 'true', 'action' => 'umature'), $_POST['ref'] ) );
+ exit();
+ break;
+
+ // Themes
+ case "updatethemes":
+ if( is_array( $_POST['theme'] ) ) {
+ $themes = get_themes();
+ reset( $themes );
+ foreach( (array) $themes as $key => $theme ) {
+ if( $_POST['theme'][ wp_specialchars( $theme['Stylesheet'] ) ] == 'enabled' )
+ $allowed_themes[ wp_specialchars( $theme['Stylesheet'] ) ] = true;
+ }
+ update_site_option( 'allowedthemes', $allowed_themes );
+ }
+ wp_redirect( add_query_arg( array('updated' => 'true', 'action' => 'themes'), $_SERVER['HTTP_REFERER'] ) );
+ exit();
+ break;
+
+ // Common
+ case "confirm":
+ $referrer = ( isset($_GET['ref']) ) ? stripslashes($_GET['ref']) : $_SERVER['HTTP_REFERER'];
+ $referrer = clean_url($referrer);
+ if( !headers_sent() ){
+ nocache_headers();
+ header( 'Content-Type: text/html; charset=utf-8' );
+ }
+ ?>
+
+ >
+
+ <?php _e("WordPress MU › Confirm your action"); ?>
+
+ ';
+ confirm_delete_users( $_POST['allusers'] );
+ echo '
';
+ } elseif( isset( $_POST[ 'alluser_transfer_delete' ] ) ) {
+ if( is_array( $_POST[ 'blog' ] ) && !empty( $_POST[ 'blog' ] ) ) {
+ foreach( $_POST[ 'blog' ] as $id => $users ) {
+ foreach( $users as $blogid => $user_id ) {
+ remove_user_from_blog( $id, $blogid, $user_id );
+ }
+ }
+ }
+ if( is_array( $_POST[ 'user' ] ) && !empty( $_POST[ 'user' ] ) )
+ foreach( $_POST[ 'user' ] as $id )
+ wpmu_delete_user( $id );
+
+ wp_redirect( add_query_arg( array('updated' => 'true', 'action' => 'all_delete'), 'wpmu-users.php' ) );
+ } else {
+ foreach ( (array) $_POST['allusers'] as $key => $val ) {
+ if( $val == '' || $val == '0' ) {
+ continue;
+ }
+ $user = new WP_User( $val );
+ if ( in_array( $user->user_login, get_site_option( 'site_admins', array( 'admin' ) ) ) ) {
+ wp_die( sprintf( __( 'Warning! User cannot be modified. The user %s is a site admnistrator.' ), $user->user_login ) );
+ }
+ if ( isset($_POST['alluser_spam']) ) {
+ $userfunction = 'all_spam';
+ $blogs = get_blogs_of_user( $val, true );
+ foreach ( (array) $blogs as $key => $details ) {
+ if ( $details->userblog_id == $current_site->blog_id ) { continue; } // main blog not a spam !
+ update_blog_status( $details->userblog_id, "spam", '1' );
+ }
+ update_user_status( $val, "spam", '1', 1 );
+ } elseif ( isset($_POST['alluser_notspam']) ) {
+ $userfunction = 'all_notspam';
+ $blogs = get_blogs_of_user( $val, true );
+ foreach ( (array) $blogs as $key => $details ) {
+ update_blog_status( $details->userblog_id, "spam", '0' );
+ }
+ update_user_status( $val, "spam", '0', 1 );
+ }
+ }
+ wp_redirect( add_query_arg( array('updated' => 'true', 'action' => $userfunction), $_SERVER['HTTP_REFERER'] ) );
+ }
+ exit();
+ break;
+
+ case "adduser":
+ check_admin_referer('add-user');
+
+ if( is_array( $_POST[ 'user' ] ) == false ) {
+ wp_die( __( "Cannot create an empty user." ) );
+ }
+ $user = $_POST['user'];
+ if ( empty($user['username']) && empty($user['email']) ) {
+ wp_die( __('Missing username and email.') );
+ } elseif ( empty($user['username']) ) {
+ wp_die( __('Missing username.') );
+ } elseif ( empty($user['email']) ) {
+ wp_die( __('Missing email.') );
+ }
+
+ $password = generate_random_password();
+ $user_id = wpmu_create_user(wp_specialchars( strtolower( $user['username'] ) ), $password, wp_specialchars( $user['email'] ) );
+
+ if( false == $user_id ) {
+ wp_die( __('Duplicated username or email address.') );
+ } else {
+ wp_new_user_notification($user_id, $password);
+ }
+ if ( get_site_option( 'dashboard_blog' ) == false ) {
+ add_user_to_blog( $current_site->blog_id, $user_id, get_site_option( 'default_user_role', 'subscriber' ) );
+ } else {
+ add_user_to_blog( get_site_option( 'dashboard_blog' ), $user_id, get_site_option( 'default_user_role', 'subscriber' ) );
+ }
+
+ wp_redirect( add_query_arg( array('updated' => 'true', 'action' => 'add'), $_SERVER['HTTP_REFERER'] ) );
+ exit();
+ break;
+
+ default:
+ wpmu_admin_do_redirect( "wpmu-admin.php" );
+ break;
+}
+?>
diff --git a/wp-admin/ms-options.php b/wp-admin/ms-options.php
new file mode 100755
index 000000000..7be014f8b
--- /dev/null
+++ b/wp-admin/ms-options.php
@@ -0,0 +1,294 @@
+
+
+
+
+
+
+
diff --git a/wp-admin/ms-sites.php b/wp-admin/ms-sites.php
new file mode 100755
index 000000000..b9871fb0c
--- /dev/null
+++ b/wp-admin/ms-sites.php
@@ -0,0 +1,613 @@
+
+
+ get_blog_prefix( $id );
+ $options = $wpdb->get_results( "SELECT * FROM {$blog_prefix}options WHERE option_name NOT LIKE '_transient_rss%' AND option_name NOT LIKE '%user_roles'", ARRAY_A );
+ $details = $wpdb->get_row( "SELECT * FROM {$wpdb->blogs} WHERE blog_id = '{$id}'", ARRAY_A );
+ $editblog_roles = get_blog_option( $id, "{$blog_prefix}user_roles" );
+ ?>
+
+
+
+
+
+ blogs} WHERE site_id = '{$wpdb->siteid}' ";
+
+ if( isset($_GET['blog_name']) ) {
+ $query .= " AND ( {$wpdb->blogs}.domain LIKE '%{$s}%' OR {$wpdb->blogs}.path LIKE '%{$s}%' ) ";
+ } elseif( isset($_GET['blog_id']) ) {
+ $query .= " AND blog_id = '".intval($_GET['s'])."' ";
+ } elseif( isset($_GET['blog_ip']) ) {
+ $query = "SELECT *
+ FROM {$wpdb->blogs}, {$wpdb->registration_log}
+ WHERE site_id = '{$wpdb->siteid}'
+ AND {$wpdb->blogs}.blog_id = {$wpdb->registration_log}.blog_id
+ AND {$wpdb->registration_log}.IP LIKE ('%{$s}%')";
+ }
+
+ if( isset( $_GET['sortby'] ) == false ) {
+ $_GET['sortby'] = 'id';
+ }
+
+ if( $_GET['sortby'] == 'registered' ) {
+ $query .= ' ORDER BY registered ';
+ } elseif( $_GET['sortby'] == 'id' ) {
+ $query .= ' ORDER BY ' . $wpdb->blogs . '.blog_id ';
+ } elseif( $_GET['sortby'] == 'lastupdated' ) {
+ $query .= ' ORDER BY last_updated ';
+ } elseif( $_GET['sortby'] == 'blogname' ) {
+ $query .= ' ORDER BY domain ';
+ }
+
+ $query .= ( $_GET['order'] == 'DESC' ) ? 'DESC' : 'ASC';
+
+ if( !empty($s) ) {
+ $total = $wpdb->get_var( str_replace('SELECT *', 'SELECT COUNT(blog_id)', $query) );
+ } else {
+ $total = $wpdb->get_var( "SELECT COUNT(blog_id) FROM {$wpdb->blogs} WHERE site_id = '{$wpdb->siteid}' ");
+ }
+
+ $query .= " LIMIT " . intval( ( $apage - 1 ) * $num) . ", " . intval( $num );
+ $blog_list = $wpdb->get_results( $query, ARRAY_A );
+
+ // Pagination
+ $url2 = "&order=" . $_GET['order'] . "&sortby=" . $_GET['sortby'] . "&s=";
+ if( $_GET[ 'blog_ip' ] ) {
+ $url2 .= "&ip_address=" . urlencode( $s );
+ } else {
+ $url2 .= $s . "&ip_address=" . urlencode( $s );
+ }
+ $blog_navigation = paginate_links( array(
+ 'base' => add_query_arg( 'apage', '%#%' ).$url2,
+ 'format' => '',
+ 'total' => ceil($total / $num),
+ 'current' => $apage
+ ));
+ ?>
+
+
+
+
+
+
+ 'display name'
+ $blogname_columns = ( constant( "VHOST" ) == 'yes' ) ? __('Domain') : __('Path');
+ $posts_columns = array(
+ 'id' => __('ID'),
+ 'blogname' => $blogname_columns,
+ 'lastupdated' => __('Last Updated'),
+ 'registered' => __('Registered'),
+ 'users' => __('Users')
+ );
+
+ if( has_filter( 'wpmublogsaction' ) )
+ $posts_columns['plugins'] = __('Actions');
+
+ $posts_columns = apply_filters('wpmu_blogs_columns', $posts_columns);
+
+ $sortby_url = "s=";
+ if( $_GET[ 'blog_ip' ] ) {
+ $sortby_url .= "&ip_address=" . urlencode( $s );
+ } else {
+ $sortby_url .= urlencode( $s ) . "&ip_address=" . urlencode( $s );
+ }
+ ?>
+
+
+
+
+
+
+
+
+ "#fee", "spam" => "#faa", "deleted" => "#f55" );
+ foreach ($blog_list as $blog) {
+ $class = ('alternate' == $class) ? '' : 'alternate';
+ reset( $status_list );
+
+ $bgcolour = "";
+ foreach ( $status_list as $status => $col ) {
+ if( get_blog_status( $blog['blog_id'], $status ) == 1 ) {
+ $bgcolour = "style='background: $col'";
+ }
+ }
+ echo "";
+
+ $blogname = ( constant( "VHOST" ) == 'yes' ) ? str_replace('.'.$current_site->domain, '', $blog['domain']) : $blog['path'];
+ foreach( $posts_columns as $column_name=>$column_display_name ) {
+ switch($column_name) {
+ case 'id': ?>
+
+
+
+
+
+
+
+ " . __('Backend') . ' ';
+
+ if( get_blog_status( $blog['blog_id'], "deleted" ) == '1' )
+ $controlActions[] = '' . __('Activate') . ' ';
+ else
+ $controlActions[] = '' . __('Deactivate') . ' ';
+
+ if( get_blog_status( $blog['blog_id'], "archived" ) == '1' )
+ $controlActions[] = '' . __('Unarchive') . ' ';
+ else
+ $controlActions[] = '' . __('Archive') . ' ';
+
+ if( get_blog_status( $blog['blog_id'], "spam" ) == '1' )
+ $controlActions[] = '' . __('Not Spam') . ' ';
+ else
+ $controlActions[] = '' . __("Spam") . ' ';
+
+ $controlActions[] = '' . __("Delete") . ' ';
+
+ $controlActions[] = "" . __('Visit') . ' ';
+ ?>
+
+
+
+
+
+
+
+
+
+ g:i:s a'), $blog['last_updated']); ?>
+
+
+
+ g:i:s a'), $blog['registered']); ?>
+
+
+
+ 5 ) {
+ $blogusers = array_slice( $blogusers, 0, 5 );
+ $blogusers_warning = __( 'Only showing first 5 users.' ) . ' ' . __( 'More' ) . ' ';
+ }
+ foreach ( $blogusers as $key => $val ) {
+ echo '' . $val->user_login . ' ('.$val->user_email.')' . $blogusers_warning . '
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/wp-admin/ms-upgrade-site.php b/wp-admin/ms-upgrade-site.php
new file mode 100755
index 000000000..f37985173
--- /dev/null
+++ b/wp-admin/ms-upgrade-site.php
@@ -0,0 +1,62 @@
+';
+echo ''.__('Upgrade Site').' ';
+switch( $_GET['action'] ) {
+ case "upgrade":
+ $n = ( isset($_GET['n']) ) ? intval($_GET['n']) : 0;
+
+ if ( $n < 5 ) {
+ global $wp_db_version;
+ update_site_option( 'wpmu_upgrade_site', $wp_db_version );
+ }
+
+ $blogs = $wpdb->get_results( "SELECT * FROM {$wpdb->blogs} WHERE site_id = '{$wpdb->siteid}' AND spam = '0' AND deleted = '0' AND archived = '0' ORDER BY registered DESC LIMIT {$n}, 5", ARRAY_A );
+ if( is_array( $blogs ) ) {
+ echo "";
+ foreach( (array) $blogs as $details ) {
+ if( $details['spam'] == 0 && $details['deleted'] == 0 && $details['archived'] == 0 ) {
+ $siteurl = $wpdb->get_var("SELECT option_value from {$wpdb->base_prefix}{$details['blog_id']}_options WHERE option_name = 'siteurl'");
+ echo "$siteurl ";
+ $response = wp_remote_get( trailingslashit( $siteurl ) . "wp-admin/upgrade.php?step=1", array( 'timeout' => 120, 'httpversion' => '1.1' ) );
+ if( is_wp_error( $response ) ) {
+ wp_die( "Warning! Problem upgrading {$siteurl}. Your server may not be able to connect to blogs running on it." . $response->get_error_message() ." " );
+ }
+ do_action( 'after_mu_upgrade', $response );
+ do_action( 'wpmu_upgrade_site', $details[ 'blog_id' ] );
+ }
+ }
+ echo " ";
+ ?>
+ '.__('All Done!').'';
+ }
+ break;
+ default:
+ ?>
+
+
+
+
diff --git a/wp-admin/ms-users.php b/wp-admin/ms-users.php
new file mode 100755
index 000000000..a866eee9f
--- /dev/null
+++ b/wp-admin/ms-users.php
@@ -0,0 +1,301 @@
+
+
+
+
+
+ users}";
+
+ if( !empty( $s ) ) {
+ $search = '%' . trim( $s ) . '%';
+ $query .= " WHERE user_login LIKE '$search' OR user_email LIKE '$search'";
+ }
+
+ if( !isset($_GET['sortby']) ) {
+ $_GET['sortby'] = 'id';
+ }
+
+ if( $_GET['sortby'] == 'email' ) {
+ $query .= ' ORDER BY user_email ';
+ } elseif( $_GET['sortby'] == 'id' ) {
+ $query .= ' ORDER BY ID ';
+ } elseif( $_GET['sortby'] == 'login' ) {
+ $query .= ' ORDER BY user_login ';
+ } elseif( $_GET['sortby'] == 'name' ) {
+ $query .= ' ORDER BY display_name ';
+ } elseif( $_GET['sortby'] == 'registered' ) {
+ $query .= ' ORDER BY user_registered ';
+ }
+
+ $query .= ( $_GET['order'] == 'DESC' ) ? 'DESC' : 'ASC';
+
+ if( !empty( $s )) {
+ $total = $wpdb->get_var( str_replace('SELECT *', 'SELECT COUNT(ID)', $query) );
+ } else {
+ $total = $wpdb->get_var( "SELECT COUNT(ID) FROM {$wpdb->users}");
+ }
+
+ $query .= " LIMIT " . intval( ( $apage - 1 ) * $num) . ", " . intval( $num );
+
+ $user_list = $wpdb->get_results( $query, ARRAY_A );
+
+ // Pagination
+ $user_navigation = paginate_links( array(
+ 'total' => ceil($total / $num),
+ 'current' => $apage,
+ 'base' => add_query_arg( 'apage', '%#%' ),
+ 'format' => ''
+ ));
+
+ if ( $user_navigation ) {
+ $user_navigation = sprintf( '
' . __( 'Displaying %s–%s of %s' ) . ' %s',
+ number_format_i18n( ( $apage - 1 ) * $num + 1 ),
+ number_format_i18n( min( $apage * $num, $total ) ),
+ number_format_i18n( $total ),
+ $user_navigation
+ );
+ }
+
+ ?>
+
+
+
+
+
+ 'display name'
+ $posts_columns = array(
+ 'checkbox' => '',
+ 'login' => __('Username'),
+ 'name' => __('Name'),
+ 'email' => __('E-mail'),
+ 'registered' => __('Registered'),
+ 'blogs' => ''
+ );
+ $posts_columns = apply_filters('wpmu_users_columns', $posts_columns);
+ ?>
+
+
+
+ $user_navigation
"; ?>
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/wp-content/blogs.php b/wp-content/blogs.php
new file mode 100755
index 000000000..70afdc1d7
--- /dev/null
+++ b/wp-content/blogs.php
@@ -0,0 +1,129 @@
+archived == '1' || $current_blog->spam == '1' || $current_blog->deleted == '1' ) {
+ status_header( 404 );
+ die('404 — File not found.');
+}
+
+if ( !function_exists('wp_check_filetype') ) :
+function wp_check_filetype($filename, $mimes = null) {
+ // Accepted MIME types are set here as PCRE unless provided.
+ $mimes = is_array($mimes) ? $mimes : array (
+ 'jpg|jpeg|jpe' => 'image/jpeg',
+ 'gif' => 'image/gif',
+ 'png' => 'image/png',
+ 'bmp' => 'image/bmp',
+ 'tif|tiff' => 'image/tiff',
+ 'ico' => 'image/x-icon',
+ 'asf|asx|wax|wmv|wmx' => 'video/asf',
+ 'avi' => 'video/avi',
+ 'mov|qt' => 'video/quicktime',
+ 'mpeg|mpg|mpe' => 'video/mpeg',
+ 'txt|c|cc|h' => 'text/plain',
+ 'rtx' => 'text/richtext',
+ 'css' => 'text/css',
+ 'htm|html' => 'text/html',
+ 'mp3|mp4' => 'audio/mpeg',
+ 'ra|ram' => 'audio/x-realaudio',
+ 'wav' => 'audio/wav',
+ 'ogg' => 'audio/ogg',
+ 'mid|midi' => 'audio/midi',
+ 'wma' => 'audio/wma',
+ 'rtf' => 'application/rtf',
+ 'js' => 'application/javascript',
+ 'pdf' => 'application/pdf',
+ 'doc' => 'application/msword',
+ 'pot|pps|ppt' => 'application/vnd.ms-powerpoint',
+ 'wri' => 'application/vnd.ms-write',
+ 'xla|xls|xlt|xlw' => 'application/vnd.ms-excel',
+ 'mdb' => 'application/vnd.ms-access',
+ 'mpp' => 'application/vnd.ms-project',
+ 'swf' => 'application/x-shockwave-flash',
+ 'class' => 'application/java',
+ 'tar' => 'application/x-tar',
+ 'zip' => 'application/zip',
+ 'gz|gzip' => 'application/x-gzip',
+ 'exe' => 'application/x-msdownload'
+ );
+
+ $type = false;
+ $ext = false;
+
+ foreach ( (array)$mimes as $ext_preg => $mime_match ) {
+ $ext_preg = '!\.(' . $ext_preg . ')$!i';
+ if ( preg_match($ext_preg, $filename, $ext_matches) ) {
+ $type = $mime_match;
+ $ext = $ext_matches[1];
+ break;
+ }
+ }
+
+ return compact('ext', 'type');
+}
+endif;
+
+
+$file = BLOGUPLOADDIR . str_replace( '..', '', $_GET[ 'file' ] );
+if ( !is_file( $file ) ) {
+ status_header( 404 );
+ die('404 — File not found.');
+}
+
+$mime = wp_check_filetype( $_SERVER[ 'REQUEST_URI' ] );
+if( $mime[ 'type' ] === false && function_exists( 'mime_content_type' ) )
+ $mime[ 'type' ] = mime_content_type( $file );
+
+if( $mime[ 'type' ] != false ) {
+ $mimetype = $mime[ 'type' ];
+} else {
+ $ext = substr( $_SERVER[ 'REQUEST_URI' ], strrpos( $_SERVER[ 'REQUEST_URI' ], '.' ) + 1 );
+ $mimetype = "image/$ext";
+}
+@header( 'Content-type: ' . $mimetype ); // always send this
+if ( false === strpos( $_SERVER['SERVER_SOFTWARE'], 'Microsoft-IIS' ) )
+ @header( 'Content-Length: ' . filesize( $file ) );
+
+// Optional support for X-Sendfile and X-Accel-Redirect
+if ( defined('WPMU_ACCEL_REDIRECT') && WPMU_ACCEL_REDIRECT ) {
+ @header( 'X-Accel-Redirect: ' . str_replace( WP_CONTENT_DIR, '', $file ) );
+ exit;
+} elseif ( defined('WPMU_SENDFILE') && WPMU_SENDFILE ) {
+ @header( 'X-Sendfile: ' . $file );
+ exit;
+}
+
+$last_modified = gmdate('D, d M Y H:i:s', filemtime( $file ));
+$etag = '"' . md5($last_modified) . '"';
+@header( "Last-Modified: $last_modified GMT" );
+@header( 'ETag: ' . $etag );
+@header( 'Expires: ' . gmdate('D, d M Y H:i:s', time() + 100000000) . ' GMT' );
+
+// Support for Conditional GET
+if (isset($_SERVER['HTTP_IF_NONE_MATCH']))
+ $client_etag = stripslashes($_SERVER['HTTP_IF_NONE_MATCH']);
+else
+ $client_etag = false;
+
+if( !isset( $_SERVER['HTTP_IF_MODIFIED_SINCE'] ) )
+ $_SERVER['HTTP_IF_MODIFIED_SINCE'] = false;
+$client_last_modified = trim( $_SERVER['HTTP_IF_MODIFIED_SINCE']);
+// If string is empty, return 0. If not, attempt to parse into a timestamp
+$client_modified_timestamp = $client_last_modified ? strtotime($client_last_modified) : 0;
+
+// Make a timestamp for our most recent modification...
+$modified_timestamp = strtotime($last_modified);
+
+if ( ($client_last_modified && $client_etag) ?
+ (($client_modified_timestamp >= $modified_timestamp) && ($client_etag == $etag)) :
+ (($client_modified_timestamp >= $modified_timestamp) || ($client_etag == $etag)) ) {
+ status_header( 304 );
+ exit;
+}
+
+// If we made it this far, just serve the file
+
+readfile( $file );
+
+?>
diff --git a/wp-includes/gettext.php b/wp-includes/gettext.php
new file mode 100755
index 000000000..26a6daed4
--- /dev/null
+++ b/wp-includes/gettext.php
@@ -0,0 +1,400 @@
+.
+ Copyright (c) 2005 Nico Kaiser
+
+ This file is part of PHP-gettext.
+
+ PHP-gettext is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ PHP-gettext is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with PHP-gettext; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+*/
+
+/**
+ * Provides a simple gettext replacement that works independently from
+ * the system's gettext abilities.
+ * It can read MO files and use them for translating strings.
+ * The files are passed to gettext_reader as a Stream (see streams.php)
+ *
+ * This version has the ability to cache all strings and translations to
+ * speed up the string lookup.
+ * While the cache is enabled by default, it can be switched off with the
+ * second parameter in the constructor (e.g. whenusing very large MO files
+ * that you don't want to keep in memory)
+ */
+class gettext_reader {
+ //public:
+ var $error = 0; // public variable that holds error code (0 if no error)
+
+ //private:
+ var $BYTEORDER = 0; // 0: low endian, 1: big endian
+ var $STREAM = NULL;
+ var $short_circuit = false;
+ var $enable_cache = false;
+ var $originals = NULL; // offset of original table
+ var $translations = NULL; // offset of translation table
+ var $pluralheader = NULL; // cache header field for plural forms
+ var $select_string_function = NULL; // cache function, which chooses plural forms
+ var $total = 0; // total string count
+ var $table_originals = NULL; // table for original strings (offsets)
+ var $table_translations = NULL; // table for translated strings (offsets)
+ var $cache_translations = NULL; // original -> translation mapping
+
+
+ /* Methods */
+
+
+ /**
+ * Reads a 32bit Integer from the Stream
+ *
+ * @access private
+ * @return Integer from the Stream
+ */
+ function readint() {
+ if ($this->BYTEORDER == 0) {
+ // low endian
+ $low_end = unpack('V', $this->STREAM->read(4));
+ return array_shift($low_end);
+ } else {
+ // big endian
+ $big_end = unpack('N', $this->STREAM->read(4));
+ return array_shift($big_end);
+ }
+ }
+
+ /**
+ * Reads an array of Integers from the Stream
+ *
+ * @param int count How many elements should be read
+ * @return Array of Integers
+ */
+ function readintarray($count) {
+ if ($this->BYTEORDER == 0) {
+ // low endian
+ return unpack('V'.$count, $this->STREAM->read(4 * $count));
+ } else {
+ // big endian
+ return unpack('N'.$count, $this->STREAM->read(4 * $count));
+ }
+ }
+
+ /**
+ * Constructor
+ *
+ * @param object Reader the StreamReader object
+ * @param boolean enable_cache Enable or disable caching of strings (default on)
+ */
+ function gettext_reader($Reader, $enable_cache = true) {
+ // If there isn't a StreamReader, turn on short circuit mode.
+ if (! $Reader || isset($Reader->error) ) {
+ $this->short_circuit = true;
+ return;
+ }
+
+ // Caching can be turned off
+ $this->enable_cache = $enable_cache;
+
+ // $MAGIC1 = (int)0x950412de; //bug in PHP 5.0.2, see https://savannah.nongnu.org/bugs/?func=detailitem&item_id=10565
+ $MAGIC1 = (int) - 1794895138;
+ // $MAGIC2 = (int)0xde120495; //bug
+ $MAGIC2 = (int) - 569244523;
+ // 64-bit fix
+ $MAGIC3 = (int) 2500072158;
+
+ $this->STREAM = $Reader;
+ $magic = $this->readint();
+ if ($magic == $MAGIC1 || $magic == $MAGIC3) { // to make sure it works for 64-bit platforms
+ $this->BYTEORDER = 0;
+ } elseif ($magic == ($MAGIC2 & 0xFFFFFFFF)) {
+ $this->BYTEORDER = 1;
+ } else {
+ $this->error = 1; // not MO file
+ return false;
+ }
+
+ // FIXME: Do we care about revision? We should.
+ $revision = $this->readint();
+
+ $this->total = $this->readint();
+ $this->originals = $this->readint();
+ $this->translations = $this->readint();
+ }
+
+ /**
+ * Loads the translation tables from the MO file into the cache
+ * If caching is enabled, also loads all strings into a cache
+ * to speed up translation lookups
+ *
+ * @access private
+ */
+ function load_tables() {
+ if (is_array($this->cache_translations) &&
+ is_array($this->table_originals) &&
+ is_array($this->table_translations))
+ return;
+
+ /* get original and translations tables */
+ $this->STREAM->seekto($this->originals);
+ $this->table_originals = $this->readintarray($this->total * 2);
+ $this->STREAM->seekto($this->translations);
+ $this->table_translations = $this->readintarray($this->total * 2);
+
+ if ($this->enable_cache) {
+ $this->cache_translations = array ();
+ /* read all strings in the cache */
+ for ($i = 0; $i < $this->total; $i++) {
+ $this->STREAM->seekto($this->table_originals[$i * 2 + 2]);
+ $original = $this->STREAM->read($this->table_originals[$i * 2 + 1]);
+ $this->STREAM->seekto($this->table_translations[$i * 2 + 2]);
+ $translation = $this->STREAM->read($this->table_translations[$i * 2 + 1]);
+ $this->cache_translations[$original] = $translation;
+ }
+ }
+ }
+
+ /**
+ * Returns a string from the "originals" table
+ *
+ * @access private
+ * @param int num Offset number of original string
+ * @return string Requested string if found, otherwise ''
+ */
+ function get_original_string($num) {
+ $length = $this->table_originals[$num * 2 + 1];
+ $offset = $this->table_originals[$num * 2 + 2];
+ if (! $length)
+ return '';
+ $this->STREAM->seekto($offset);
+ $data = $this->STREAM->read($length);
+ return (string)$data;
+ }
+
+ /**
+ * Returns a string from the "translations" table
+ *
+ * @access private
+ * @param int num Offset number of original string
+ * @return string Requested string if found, otherwise ''
+ */
+ function get_translation_string($num) {
+ $length = $this->table_translations[$num * 2 + 1];
+ $offset = $this->table_translations[$num * 2 + 2];
+ if (! $length)
+ return '';
+ $this->STREAM->seekto($offset);
+ $data = $this->STREAM->read($length);
+ return (string)$data;
+ }
+
+ /**
+ * Binary search for string
+ *
+ * @access private
+ * @param string string
+ * @param int start (internally used in recursive function)
+ * @param int end (internally used in recursive function)
+ * @return int string number (offset in originals table)
+ */
+ function find_string($string, $start = -1, $end = -1) {
+ if (($start == -1) or ($end == -1)) {
+ // find_string is called with only one parameter, set start end end
+ $start = 0;
+ $end = $this->total;
+ }
+ if (abs($start - $end) <= 1) {
+ // We're done, now we either found the string, or it doesn't exist
+ $txt = $this->get_original_string($start);
+ if ($string == $txt)
+ return $start;
+ else
+ return -1;
+ } else if ($start > $end) {
+ // start > end -> turn around and start over
+ return $this->find_string($string, $end, $start);
+ } else {
+ // Divide table in two parts
+ $half = (int)(($start + $end) / 2);
+ $cmp = strcmp($string, $this->get_original_string($half));
+ if ($cmp == 0)
+ // string is exactly in the middle => return it
+ return $half;
+ else if ($cmp < 0)
+ // The string is in the upper half
+ return $this->find_string($string, $start, $half);
+ else
+ // The string is in the lower half
+ return $this->find_string($string, $half, $end);
+ }
+ }
+
+ /**
+ * Translates a string
+ *
+ * @access public
+ * @param string string to be translated
+ * @return string translated string (or original, if not found)
+ */
+ function translate($string) {
+ if ($this->short_circuit)
+ return $string;
+ $this->load_tables();
+
+ if ($this->enable_cache) {
+ // Caching enabled, get translated string from cache
+ if (array_key_exists($string, $this->cache_translations))
+ return $this->cache_translations[$string];
+ else
+ return $string;
+ } else {
+ // Caching not enabled, try to find string
+ $num = $this->find_string($string);
+ if ($num == -1)
+ return $string;
+ else
+ return $this->get_translation_string($num);
+ }
+ }
+
+ /**
+ * Get possible plural forms from MO header
+ *
+ * @access private
+ * @return string plural form header
+ */
+ function get_plural_forms() {
+ // lets assume message number 0 is header
+ // this is true, right?
+ $this->load_tables();
+
+ // cache header field for plural forms
+ if (! is_string($this->pluralheader)) {
+ if ($this->enable_cache) {
+ $header = $this->cache_translations[""];
+ } else {
+ $header = $this->get_translation_string(0);
+ }
+ $header .= "\n"; //make sure our regex matches
+ if (eregi("plural-forms: ([^\n]*)\n", $header, $regs))
+ $expr = $regs[1];
+ else
+ $expr = "nplurals=2; plural=n == 1 ? 0 : 1;";
+
+ // add parentheses
+ // important since PHP's ternary evaluates from left to right
+ $expr.= ';';
+ $res= '';
+ $p= 0;
+ for ($i= 0; $i < strlen($expr); $i++) {
+ $ch= $expr[$i];
+ switch ($ch) {
+ case '?':
+ $res.= ' ? (';
+ $p++;
+ break;
+ case ':':
+ $res.= ') : (';
+ break;
+ case ';':
+ $res.= str_repeat( ')', $p) . ';';
+ $p= 0;
+ break;
+ default:
+ $res.= $ch;
+ }
+ }
+ $this->pluralheader = $res;
+ }
+
+ return $this->pluralheader;
+ }
+
+ /**
+ * Detects which plural form to take
+ *
+ * @access private
+ * @param n count
+ * @return int array index of the right plural form
+ */
+ function select_string($n) {
+ if (is_null($this->select_string_function)) {
+ $string = $this->get_plural_forms();
+ if (preg_match("/nplurals\s*=\s*(\d+)\s*\;\s*plural\s*=\s*(.*?)\;+/", $string, $matches)) {
+ $nplurals = $matches[1];
+ $expression = $matches[2];
+ $expression = str_replace("n", '$n', $expression);
+ } else {
+ $nplurals = 2;
+ $expression = ' $n == 1 ? 0 : 1 ';
+ }
+ $func_body = "
+ \$plural = ($expression);
+ return (\$plural <= $nplurals)? \$plural : \$plural - 1;";
+ $this->select_string_function = create_function('$n', $func_body);
+ }
+ return call_user_func($this->select_string_function, $n);
+ }
+
+ /**
+ * Plural version of gettext
+ *
+ * @access public
+ * @param string single
+ * @param string plural
+ * @param string number
+ * @return translated plural form
+ */
+ function ngettext($single, $plural, $number) {
+ if ($this->short_circuit) {
+ if ($number != 1)
+ return $plural;
+ else
+ return $single;
+ }
+
+ // find out the appropriate form
+ $select = $this->select_string($number);
+
+ // this should contains all strings separated by NULLs
+ $key = $single.chr(0).$plural;
+
+
+ if ($this->enable_cache) {
+ if (! array_key_exists($key, $this->cache_translations)) {
+ return ($number != 1) ? $plural : $single;
+ } else {
+ $result = $this->cache_translations[$key];
+ $list = explode(chr(0), $result);
+ return $list[$select];
+ }
+ } else {
+ $num = $this->find_string($key);
+ if ($num == -1) {
+ return ($number != 1) ? $plural : $single;
+ } else {
+ $result = $this->get_translation_string($num);
+ $list = explode(chr(0), $result);
+ return $list[$select];
+ }
+ }
+ }
+
+}
+
+?>
diff --git a/wp-includes/ms-default-filters.php b/wp-includes/ms-default-filters.php
new file mode 100755
index 000000000..d7775c55e
--- /dev/null
+++ b/wp-includes/ms-default-filters.php
@@ -0,0 +1,46 @@
+
diff --git a/wp-includes/ms-functions.php b/wp-includes/ms-functions.php
new file mode 100755
index 000000000..4c8e19e15
--- /dev/null
+++ b/wp-includes/ms-functions.php
@@ -0,0 +1,2407 @@
+update( $wpdb->blogs, array('last_updated' => current_time('mysql', true)), array('blog_id' => $wpdb->blogid) );
+ refresh_blog_details( $wpdb->blogid );
+
+ do_action( 'wpmu_blog_updated', $wpdb->blogid );
+}
+
+function get_blogaddress_by_id( $blog_id ) {
+ $bloginfo = get_blog_details( (int) $blog_id, false ); // only get bare details!
+ return clean_url("http://" . $bloginfo->domain . $bloginfo->path);
+}
+
+function get_blogaddress_by_name( $blogname ) {
+ global $current_site;
+
+ if( defined( "VHOST" ) && constant( "VHOST" ) == 'yes' ) {
+ if( $blogname == 'main' )
+ $blogname = 'www';
+ return clean_url( "http://" . $blogname . "." . $current_site->domain . $current_site->path );
+ } else {
+ return clean_url( "http://" . $current_site->domain . $current_site->path . $blogname . '/' );
+ }
+}
+
+function get_blogaddress_by_domain( $domain, $path ){
+ if( defined( "VHOST" ) && constant( "VHOST" ) == 'yes' ) {
+ $url = "http://".$domain.$path;
+ } else {
+ if( $domain != $_SERVER['HTTP_HOST'] ) {
+ $blogname = substr( $domain, 0, strpos( $domain, '.' ) );
+ if( $blogname != 'www.' ) {
+ $url = 'http://' . substr( $domain, strpos( $domain, '.' ) + 1 ) . $path . $blogname . '/';
+ } else { // we're installing the main blog
+ $url = 'http://' . substr( $domain, strpos( $domain, '.' ) + 1 ) . $path;
+ }
+ } else { // main blog
+ $url = 'http://' . $domain . $path;
+ }
+ }
+ return clean_url($url);
+}
+
+function get_sitestats() {
+ global $wpdb;
+
+ $stats['blogs'] = get_blog_count();
+
+ $count_ts = get_site_option( "get_user_count_ts" );
+ if( time() - $count_ts > 3600 ) {
+ $count = $wpdb->get_var( "SELECT COUNT(ID) FROM {$wpdb->users}" );
+ update_site_option( "user_count", $count );
+ update_site_option( "user_count_ts", time() );
+ } else {
+ $count = get_site_option( "user_count" );
+ }
+ $stats['users'] = $count;
+ return $stats;
+}
+
+function get_admin_users_for_domain( $sitedomain = '', $path = '' ) {
+ global $wpdb;
+
+ if( $sitedomain == '' ) {
+ $site_id = $wpdb->siteid;
+ } else {
+ $site_id = $wpdb->get_var( $wpdb->prepare("SELECT id FROM $wpdb->site WHERE domain = %s AND path = %s", $sitedomain, $path) );
+ }
+
+ if( $site_id != false ) {
+ return $wpdb->get_results( $wpdb->prepare("SELECT u.ID, u.user_login, u.user_pass FROM $wpdb->users AS u, $wpdb->sitemeta AS sm WHERE sm.meta_key = 'admin_user_id' AND u.ID = sm.meta_value AND sm.site_id = %d", $site_id), ARRAY_A );
+ }
+ return false;
+}
+
+function get_user_details( $username ) {
+ global $wpdb;
+ return $wpdb->get_row( $wpdb->prepare("SELECT * FROM $wpdb->users WHERE user_login = %s", $username) );
+}
+
+function is_main_blog() {
+ global $current_blog, $current_site;
+ if( $current_blog->domain == $current_site->domain && $current_blog->path == $current_site->path )
+ return true;
+ return false;
+}
+
+function get_id_from_blogname( $name ) {
+ global $wpdb, $current_site;
+ $blog_id = wp_cache_get( "get_id_from_blogname_" . $name, 'blog-details' );
+ if( $blog_id )
+ return $blog_id;
+
+ if( constant( 'VHOST' ) == 'yes' ) {
+ $domain = $name . '.' . $current_site->domain;
+ $path = $current_site->path;
+ } else {
+ $domain = $current_site->domain;
+ $path = $current_site->path . $name . '/';
+ }
+ $blog_id = $wpdb->get_var( $wpdb->prepare("SELECT blog_id FROM {$wpdb->blogs} WHERE domain = %s AND path = %s", $domain, $path) );
+ wp_cache_set( 'get_id_from_blogname_' . $name, $blog_id, 'blog-details' );
+ return $blog_id;
+}
+
+function get_blog_details( $id, $getall = true ) {
+ global $wpdb;
+
+ if( !is_numeric( $id ) ) {
+ $id = get_id_from_blogname( $id );
+ }
+ $all = $getall == true ? '' : 'short';
+ $details = wp_cache_get( $id . $all, 'blog-details' );
+
+ if ( $details ) {
+ if ( $details == -1 )
+ return false;
+ elseif ( !is_object($details) ) // Clear old pre-serialized objects. Cache clients do better with that.
+ wp_cache_delete( $id . $all, 'blog-details' );
+ else
+ return $details;
+ }
+
+ $details = $wpdb->get_row( $wpdb->prepare("SELECT * FROM $wpdb->blogs WHERE blog_id = %d /* get_blog_details */", $id) );
+ if ( !$details ) {
+ wp_cache_set( $id . $all, -1, 'blog-details' );
+ return false;
+ }
+
+ if ( !$getall ) {
+ wp_cache_set( $id . $all, $details, 'blog-details' );
+ return $details;
+ }
+
+ $wpdb->suppress_errors();
+ switch_to_blog( $id );
+ $details->blogname = get_option( 'blogname' );
+ $details->siteurl = get_option( 'siteurl' );
+ $details->post_count = get_option( 'post_count' );
+ restore_current_blog();
+ $wpdb->suppress_errors( false );
+
+ $details = apply_filters('blog_details', $details);
+
+ wp_cache_set( $id . $all, $details, 'blog-details' );
+
+ $key = md5( $details->domain . $details->path );
+ wp_cache_set( $key, $details, 'blog-lookup' );
+
+ return $details;
+}
+
+function refresh_blog_details( $id ) {
+ $id = (int) $id;
+ $details = get_blog_details( $id, false );
+
+ wp_cache_delete( $id , 'blog-details' );
+ wp_cache_delete( $id . 'short' , 'blog-details' );
+ wp_cache_delete( md5( $details->domain . $details->path ) , 'blog-lookup' );
+ wp_cache_delete( 'current_blog_' . $details->domain, 'site-options' );
+ wp_cache_delete( 'current_blog_' . $details->domain . $details->path, 'site-options' );
+}
+
+function get_current_user_id() {
+ global $current_user;
+ return $current_user->ID;
+}
+
+function is_site_admin( $user_login = false ) {
+ global $current_user;
+
+ if ( !$current_user && !$user_login )
+ return false;
+
+ if ( $user_login ) {
+ $user_login = sanitize_user( $user_login );
+ } elseif( isset( $current_user->user_login ) ) {
+ $user_login = $current_user->user_login;
+ } else {
+ return false;
+ }
+
+ $site_admins = get_site_option( 'site_admins', array('admin') );
+ if( is_array( $site_admins ) && in_array( $user_login, $site_admins ) )
+ return true;
+
+ return false;
+}
+
+/**
+ * Retrieve option value based on setting name and blog_id.
+ *
+ * If the option does not exist or does not have a value, then the return value
+ * will be false. This is useful to check whether you need to install an option
+ * and is commonly used during installation of plugin options and to test
+ * whether upgrading is required.
+ *
+ * There is a filter called 'blog_option_$option' with the $option being
+ * replaced with the option name. The filter takes two parameters. $value and
+ * $blog_id. It returns $value.
+ * The 'option_$option' filter in get_option() is not called.
+ *
+ * @since NA
+ * @package WordPress MU
+ * @subpackage Option
+ * @uses apply_filters() Calls 'blog_option_$optionname' with the option name value.
+ *
+ * @param int $blog_id is the id of the blog.
+ * @param string $setting Name of option to retrieve. Should already be SQL-escaped
+ * @param string $default (optional) Default value returned if option not found.
+ * @return mixed Value set for the option.
+ */
+function get_blog_option( $blog_id, $setting, $default = false ) {
+ global $wpdb;
+
+ $key = $blog_id."-".$setting."-blog_option";
+ $value = wp_cache_get( $key, "site-options" );
+ if ( $value == null ) {
+ $blog_prefix = $wpdb->get_blog_prefix( $blog_id );
+ $row = $wpdb->get_row( $wpdb->prepare( "SELECT * FROM {$blog_prefix}options WHERE option_name = %s", $setting ) );
+ if ( is_object( $row ) ) { // Has to be get_row instead of get_var because of funkiness with 0, false, null values
+ $value = $row->option_value;
+ if ( $value == false ) {
+ wp_cache_set( $key, 'falsevalue', 'site-options' );
+ } else {
+ wp_cache_set( $key, $value, 'site-options' );
+ }
+ } else { // option does not exist, so we must cache its non-existence
+ wp_cache_set( $key, 'noop', 'site-options' );
+ $value = $default;
+ }
+ } elseif( $value == 'noop' ) {
+ $value = $default;
+ } elseif( $value == 'falsevalue' ) {
+ $value = false;
+ }
+ // If home is not set use siteurl.
+ if ( 'home' == $setting && '' == $value )
+ return get_blog_option( $blog_id, 'siteurl' );
+
+ if ( 'siteurl' == $setting || 'home' == $setting || 'category_base' == $setting )
+ $value = preg_replace( '|/+$|', '', $value );
+
+ if (! @unserialize( $value ) )
+ $value = stripslashes( $value );
+
+ return apply_filters( 'blog_option_' . $setting, maybe_unserialize( $value ), $blog_id );
+}
+
+function add_blog_option( $id, $key, $value ) {
+ $id = (int) $id;
+
+ switch_to_blog($id);
+ add_option( $key, $value );
+ restore_current_blog();
+ wp_cache_set( $id."-".$key."-blog_option", $value, 'site-options' );
+}
+
+function delete_blog_option( $id, $key ) {
+ $id = (int) $id;
+
+ switch_to_blog($id);
+ delete_option( $key );
+ restore_current_blog();
+ wp_cache_set( $id."-".$key."-blog_option", '', 'site-options' );
+}
+
+function update_blog_option( $id, $key, $value, $refresh = true ) {
+ $id = (int) $id;
+
+ switch_to_blog($id);
+ update_option( $key, $value );
+ restore_current_blog();
+
+ if( $refresh == true )
+ refresh_blog_details( $id );
+ wp_cache_set( $id."-".$key."-blog_option", $value, 'site-options');
+}
+
+function switch_to_blog( $new_blog ) {
+ global $wpdb, $table_prefix, $blog_id, $switched, $switched_stack, $wp_roles, $current_user, $wp_object_cache;
+
+ if ( empty($new_blog) )
+ $new_blog = $blog_id;
+
+ if ( empty($switched_stack) )
+ $switched_stack = array();
+
+ $switched_stack[] = $blog_id;
+
+ /* If we're switching to the same blog id that we're on,
+ * set the right vars, do the associated actions, but skip
+ * the extra unnecessary work */
+ if ( $blog_id == $new_blog ) {
+ do_action( 'switch_blog', $blog_id, $blog_id );
+ $switched = true;
+ return true;
+ }
+
+ $wpdb->set_blog_id($new_blog);
+ $table_prefix = $wpdb->prefix;
+ $prev_blog_id = $blog_id;
+ $blog_id = $new_blog;
+
+ if( is_object( $wp_roles ) ) {
+ $wpdb->suppress_errors();
+ if ( method_exists( $wp_roles ,'_init' ) ) {
+ $wp_roles->_init();
+ } elseif( method_exists( $wp_roles, '__construct' ) ) {
+ $wp_roles->__construct();
+ }
+ $wpdb->suppress_errors( false );
+ }
+
+ if ( is_object( $current_user ) )
+ $current_user->_init_caps();
+
+ if ( is_object( $wp_object_cache ) ) {
+ $global_groups = $wp_object_cache->global_groups;
+ } else {
+ $global_groups = false;
+ }
+ wp_cache_init();
+ if ( function_exists('wp_cache_add_global_groups') ) {
+ if ( is_array( $global_groups ) ) {
+ wp_cache_add_global_groups( $global_groups );
+ } else {
+ wp_cache_add_global_groups( array( 'users', 'userlogins', 'usermeta', 'site-options', 'site-lookup', 'blog-lookup', 'blog-details', 'rss', 'site-transient', 'global-posts' ) );
+ }
+ wp_cache_add_non_persistent_groups(array( 'comment', 'counts', 'plugins' ));
+ }
+
+ do_action('switch_blog', $blog_id, $prev_blog_id);
+ $switched = true;
+ return true;
+}
+
+function restore_current_blog() {
+ global $table_prefix, $wpdb, $blog_id, $switched, $switched_stack, $wp_roles, $current_user, $wp_object_cache;
+
+ if ( !$switched )
+ return false;
+
+ if ( !is_array( $switched_stack ) )
+ return false;
+
+ $blog = array_pop( $switched_stack );
+ if ( $blog_id == $blog ) {
+ do_action( 'switch_blog', $blog, $blog );
+ /* If we still have items in the switched stack, consider ourselves still 'switched' */
+ $switched = ( is_array( $switched_stack ) && count( $switched_stack ) > 0 );
+ return true;
+ }
+
+ $wpdb->set_blog_id($blog);
+ $prev_blog_id = $blog_id;
+ $blog_id = $blog;
+ $table_prefix = $wpdb->prefix;
+
+ if( is_object( $wp_roles ) ) {
+ $wpdb->suppress_errors();
+ if ( method_exists( $wp_roles ,'_init' ) ) {
+ $wp_roles->_init();
+ } elseif( method_exists( $wp_roles, '__construct' ) ) {
+ $wp_roles->__construct();
+ }
+ $wpdb->suppress_errors( false );
+ }
+
+ if ( is_object( $current_user ) )
+ $current_user->_init_caps();
+
+ if ( is_object( $wp_object_cache ) ) {
+ $global_groups = $wp_object_cache->global_groups;
+ } else {
+ $global_groups = false;
+ }
+ wp_cache_init();
+ if ( function_exists('wp_cache_add_global_groups') ) {
+ if ( is_array( $global_groups ) ) {
+ wp_cache_add_global_groups( $global_groups );
+ } else {
+ wp_cache_add_global_groups( array( 'users', 'userlogins', 'usermeta', 'site-options', 'site-lookup', 'blog-lookup', 'blog-details', 'rss', 'site-transient' ) );
+ }
+ wp_cache_add_non_persistent_groups(array( 'comment', 'counts', 'plugins' ));
+ }
+
+ do_action('switch_blog', $blog_id, $prev_blog_id);
+
+ /* If we still have items in the switched stack, consider ourselves still 'switched' */
+ $switched = ( is_array( $switched_stack ) && count( $switched_stack ) > 0 );
+ return true;
+}
+
+function get_blogs_of_user( $id, $all = false ) {
+ global $wpdb;
+
+ $cache_suffix = $all ? '_all' : '_short';
+ $return = wp_cache_get( 'blogs_of_user_' . $id . $cache_suffix, 'users' );
+ if ( $return ) {
+ return apply_filters( 'get_blogs_of_user', $return, $id, $all );
+ }
+
+ $user = get_userdata( (int) $id );
+ if ( !$user )
+ return false;
+
+ $blogs = $match = array();
+ foreach ( (array) $user as $key => $value ) {
+ if ( false !== strpos( $key, '_capabilities') && 0 === strpos( $key, $wpdb->base_prefix ) && preg_match( '/' . $wpdb->base_prefix . '(\d+)_capabilities/', $key, $match ) ) {
+ $blog = get_blog_details( $match[1] );
+ if ( $blog && isset( $blog->domain ) && ( $all == true || $all == false && ( $blog->archived == 0 && $blog->spam == 0 && $blog->deleted == 0 ) ) ) {
+ $blogs[$match[1]]->userblog_id = $match[1];
+ $blogs[$match[1]]->blogname = $blog->blogname;
+ $blogs[$match[1]]->domain = $blog->domain;
+ $blogs[$match[1]]->path = $blog->path;
+ $blogs[$match[1]]->site_id = $blog->site_id;
+ $blogs[$match[1]]->siteurl = $blog->siteurl;
+ }
+ }
+ }
+
+ wp_cache_add( 'blogs_of_user_' . $id . $cache_suffix, $blogs, 'users', 5 );
+ return apply_filters( 'get_blogs_of_user', $blogs, $id, $all );
+}
+
+function get_active_blog_for_user( $user_id ) { // get an active blog for user - either primary blog or from blogs list
+ global $wpdb;
+ $blogs = get_blogs_of_user( $user_id );
+ if ( empty( $blogs ) ) {
+ $details = get_dashboard_blog();
+ add_user_to_blog( $details->blog_id, $user_id, 'subscriber' );
+ update_usermeta( $user_id, 'primary_blog', $details->blog_id );
+ wp_cache_delete( $user_id, 'users' );
+ return $details;
+ }
+
+ $primary_blog = get_usermeta( $user_id, "primary_blog" );
+ $details = get_dashboard_blog();
+ if ( $primary_blog ) {
+ $blogs = get_blogs_of_user( $user_id );
+ if ( isset( $blogs[ $primary_blog ] ) == false ) {
+ add_user_to_blog( $details->blog_id, $user_id, 'subscriber' );
+ update_usermeta( $user_id, 'primary_blog', $details->blog_id );
+ wp_cache_delete( $user_id, 'users' );
+ } else {
+ $details = get_blog_details( $primary_blog );
+ }
+ } else {
+ add_user_to_blog( $details->blog_id, $user_id, 'subscriber' ); // Add subscriber permission for dashboard blog
+ update_usermeta( $user_id, 'primary_blog', $details->blog_id );
+ }
+
+ if ( ( is_object( $details ) == false ) || ( is_object( $details ) && $details->archived == 1 || $details->spam == 1 || $details->deleted == 1 ) ) {
+ $blogs = get_blogs_of_user( $user_id, true ); // if a user's primary blog is shut down, check their other blogs.
+ $ret = false;
+ if ( is_array( $blogs ) && count( $blogs ) > 0 ) {
+ foreach( (array) $blogs as $blog_id => $blog ) {
+ if ( $blog->site_id != $wpdb->siteid )
+ continue;
+ $details = get_blog_details( $blog_id );
+ if ( is_object( $details ) && $details->archived == 0 && $details->spam == 0 && $details->deleted == 0 ) {
+ $ret = $blog;
+ $changed = false;
+ if ( get_usermeta( $user_id , 'primary_blog' ) != $blog_id ) {
+ update_usermeta( $user_id, 'primary_blog', $blog_id );
+ $changed = true;
+ }
+ if ( !get_usermeta($user_id , 'source_domain') ) {
+ update_usermeta( $user_id, 'source_domain', $blog->domain );
+ $changed = true;
+ }
+ if ( $changed )
+ wp_cache_delete( $user_id, 'users' );
+ break;
+ }
+ }
+ } else {
+ // Should never get here
+ $dashboard_blog = get_dashboard_blog();
+ add_user_to_blog( $dashboard_blog->blog_id, $user_id, 'subscriber' ); // Add subscriber permission for dashboard blog
+ update_usermeta( $user_id, 'primary_blog', $dashboard_blog->blog_id );
+ return $dashboard_blog;
+ }
+ return $ret;
+ } else {
+ return $details;
+ }
+}
+
+function is_user_member_of_blog( $user_id, $blog_id = 0 ) {
+ $user_id = (int) $user_id;
+ $blog_id = (int) $blog_id;
+
+ if( $blog_id == 0 ) {
+ global $wpdb;
+ $blog_id = $wpdb->blogid;
+ }
+
+ $blogs = get_blogs_of_user( $user_id );
+ if( is_array( $blogs ) ) {
+ return array_key_exists( $blog_id, $blogs );
+ } else {
+ return false;
+ }
+}
+
+function is_archived( $id ) {
+ return get_blog_status($id, 'archived');
+}
+
+function update_archived( $id, $archived ) {
+ update_blog_status($id, 'archived', $archived);
+ return $archived;
+}
+
+function update_blog_status( $id, $pref, $value, $refresh = 1 ) {
+ global $wpdb;
+
+ if ( !in_array( $pref, array( 'site_id', 'domain', 'path', 'registered', 'last_updated', 'public', 'archived', 'mature', 'spam', 'deleted', 'lang_id') ) )
+ return $value;
+
+ $wpdb->update( $wpdb->blogs, array($pref => $value, 'last_updated' => current_time('mysql', true)), array('blog_id' => $id) );
+ if( $refresh == 1 )
+ refresh_blog_details($id);
+
+ if( $pref == 'spam' ) {
+ if( $value == 1 ) {
+ do_action( "make_spam_blog", $id );
+ } else {
+ do_action( "make_ham_blog", $id );
+ }
+ }
+
+ return $value;
+}
+
+function get_blog_status( $id, $pref ) {
+ global $wpdb;
+
+ $details = get_blog_details( $id, false );
+ if( $details ) {
+ return $details->$pref;
+ }
+ return $wpdb->get_var( $wpdb->prepare("SELECT $pref FROM {$wpdb->blogs} WHERE blog_id = %d", $id) );
+}
+
+function get_last_updated( $deprecated = '', $start = 0, $quantity = 40 ) {
+ global $wpdb;
+ return $wpdb->get_results( $wpdb->prepare("SELECT blog_id, domain, path FROM $wpdb->blogs WHERE site_id = %d AND public = '1' AND archived = '0' AND mature = '0' AND spam = '0' AND deleted = '0' AND last_updated != '0000-00-00 00:00:00' ORDER BY last_updated DESC limit %d, %d", $wpdb->siteid, $start, $quantity ) , ARRAY_A );
+}
+
+function get_most_active_blogs( $num = 10, $display = true ) {
+ $most_active = get_site_option( "most_active" );
+ $update = false;
+ if( is_array( $most_active ) ) {
+ if( ( $most_active['time'] + 60 ) < time() ) { // cache for 60 seconds.
+ $update = true;
+ }
+ } else {
+ $update = true;
+ }
+
+ if( $update == true ) {
+ unset( $most_active );
+ $blogs = get_blog_list( 0, 'all', false ); // $blog_id -> $details
+ if( is_array( $blogs ) ) {
+ reset( $blogs );
+ foreach ( (array) $blogs as $key => $details ) {
+ $most_active[ $details['blog_id'] ] = $details['postcount'];
+ $blog_list[ $details['blog_id'] ] = $details; // array_slice() removes keys!!
+ }
+ arsort( $most_active );
+ reset( $most_active );
+ foreach ( (array) $most_active as $key => $details ) {
+ $t[ $key ] = $blog_list[ $key ];
+ }
+ unset( $most_active );
+ $most_active = $t;
+ }
+ update_site_option( "most_active", $most_active );
+ }
+
+ if( $display == true ) {
+ if( is_array( $most_active ) ) {
+ reset( $most_active );
+ foreach ( (array) $most_active as $key => $details ) {
+ $url = clean_url("http://" . $details['domain'] . $details['path']);
+ echo "" . $details['postcount'] . " $url ";
+ }
+ }
+ }
+ return array_slice( $most_active, 0, $num );
+}
+
+function get_blog_list( $start = 0, $num = 10, $deprecated = '' ) {
+ global $wpdb;
+
+ $blogs = get_site_option( "blog_list" );
+ $update = false;
+ if( is_array( $blogs ) ) {
+ if( ( $blogs['time'] + 60 ) < time() ) { // cache for 60 seconds.
+ $update = true;
+ }
+ } else {
+ $update = true;
+ }
+
+ if( $update == true ) {
+ unset( $blogs );
+ $blogs = $wpdb->get_results( $wpdb->prepare("SELECT blog_id, domain, path FROM $wpdb->blogs WHERE site_id = %d AND public = '1' AND archived = '0' AND mature = '0' AND spam = '0' AND deleted = '0' ORDER BY registered DESC", $wpdb->siteid), ARRAY_A );
+
+ foreach ( (array) $blogs as $details ) {
+ $blog_list[ $details['blog_id'] ] = $details;
+ $blog_list[ $details['blog_id'] ]['postcount'] = $wpdb->get_var( "SELECT COUNT(ID) FROM " . $wpdb->base_prefix . $details['blog_id'] . "_posts WHERE post_status='publish' AND post_type='post'" );
+ }
+ unset( $blogs );
+ $blogs = $blog_list;
+ update_site_option( "blog_list", $blogs );
+ }
+
+ if( false == is_array( $blogs ) )
+ return array();
+
+ if( $num == 'all' ) {
+ return array_slice( $blogs, $start, count( $blogs ) );
+ } else {
+ return array_slice( $blogs, $start, $num );
+ }
+}
+
+function get_user_count() {
+ global $wpdb;
+
+ $count_ts = get_site_option( "user_count_ts" );
+ if( time() - $count_ts > 3600 ) {
+ $count = $wpdb->get_var( $wpdb->prepare("SELECT COUNT(ID) as c FROM $wpdb->users WHERE spam = '0' AND deleted = '0'") );
+ update_site_option( "user_count", $count );
+ update_site_option( "user_count_ts", time() );
+ }
+
+ $count = get_site_option( "user_count" );
+
+ return $count;
+}
+
+function get_blog_count( $id = 0 ) {
+ global $wpdb;
+
+ if( $id == 0 )
+ $id = $wpdb->siteid;
+
+ $count_ts = get_site_option( "blog_count_ts" );
+ if( time() - $count_ts > 3600 ) {
+ $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'", $id) );
+ update_site_option( "blog_count", $count );
+ update_site_option( "blog_count_ts", time() );
+ }
+
+ $count = get_site_option( "blog_count" );
+
+ return $count;
+}
+
+function get_blog_post( $blog_id, $post_id ) {
+ global $wpdb;
+
+ $key = $blog_id . "-" . $post_id;
+ $post = wp_cache_get( $key, "global-posts" );
+ if( $post == false ) {
+ $post = $wpdb->get_row( $wpdb->prepare( "SELECT * FROM " . $wpdb->get_blog_prefix( $blog_id ) . "posts WHERE ID = %d", $post_id ) );
+ wp_cache_add( $key, $post, "global-posts" );
+ }
+
+ return $post;
+}
+
+function clear_global_post_cache( $post_id ) {
+ global $wpdb;
+
+ wp_cache_delete( $wpdb->blogid . '-' . $post_id, 'global-posts' );
+}
+add_action( 'publish_post', 'clear_global_post_cache' );
+add_action( 'delete_post', 'clear_global_post_cache' );
+
+function add_user_to_blog( $blog_id, $user_id, $role ) {
+ switch_to_blog($blog_id);
+
+ $user = new WP_User($user_id);
+
+ if ( empty($user) )
+ return new WP_Error('user_does_not_exist', __('That user does not exist.'));
+
+ if ( !get_usermeta($user_id, 'primary_blog') ) {
+ update_usermeta($user_id, 'primary_blog', $blog_id);
+ $details = get_blog_details($blog_id);
+ update_usermeta($user_id, 'source_domain', $details->domain);
+ }
+
+ $user->set_role($role);
+
+ do_action('add_user_to_blog', $user_id, $role, $blog_id);
+ wp_cache_delete( $user_id, 'users' );
+ restore_current_blog();
+ return true;
+}
+
+function remove_user_from_blog($user_id, $blog_id = '', $reassign = '') {
+ global $wpdb;
+ switch_to_blog($blog_id);
+ $user_id = (int) $user_id;
+ do_action('remove_user_from_blog', $user_id, $blog_id);
+
+ // If being removed from the primary blog, set a new primary if the user is assigned
+ // to multiple blogs.
+ $primary_blog = get_usermeta($user_id, 'primary_blog');
+ if ( $primary_blog == $blog_id ) {
+ $new_id = '';
+ $new_domain = '';
+ $blogs = get_blogs_of_user($user_id);
+ foreach ( (array) $blogs as $blog ) {
+ if ( $blog->userblog_id == $blog_id )
+ continue;
+ $new_id = $blog->userblog_id;
+ $new_domain = $blog->domain;
+ break;
+ }
+
+ update_usermeta($user_id, 'primary_blog', $new_id);
+ update_usermeta($user_id, 'source_domain', $new_domain);
+ }
+
+ // wp_revoke_user($user_id);
+ $user = new WP_User($user_id);
+ $user->remove_all_caps();
+
+ $blogs = get_blogs_of_user($user_id);
+ if ( count($blogs) == 0 ) {
+ update_usermeta($user_id, 'primary_blog', '');
+ update_usermeta($user_id, 'source_domain', '');
+ }
+
+ if( $reassign != '' ) {
+ $reassign = (int) $reassign;
+ $wpdb->query( $wpdb->prepare("UPDATE $wpdb->posts SET post_author = %d WHERE post_author = %d", $reassign, $user_id) );
+ $wpdb->query( $wpdb->prepare("UPDATE $wpdb->links SET link_owner = %d WHERE link_owner = %d", $reassign, $user_id) );
+ }
+
+ restore_current_blog();
+}
+
+function create_empty_blog( $domain, $path, $weblog_title, $site_id = 1 ) {
+ $domain = addslashes( $domain );
+ $weblog_title = addslashes( $weblog_title );
+
+ if( empty($path) )
+ $path = '/';
+
+ // Check if the domain has been used already. We should return an error message.
+ if ( domain_exists($domain, $path, $site_id) )
+ return __('error: Blog URL already taken.');
+
+ // Need to backup wpdb table names, and create a new wp_blogs entry for new blog.
+ // Need to get blog_id from wp_blogs, and create new table names.
+ // Must restore table names at the end of function.
+
+ if ( ! $blog_id = insert_blog($domain, $path, $site_id) )
+ return __('error: problem creating blog entry');
+
+ switch_to_blog($blog_id);
+ install_blog($blog_id);
+ restore_current_blog();
+
+ return $blog_id;
+}
+
+function get_blog_permalink( $_blog_id, $post_id ) {
+ $key = "{$_blog_id}-{$post_id}-blog_permalink";
+ $link = wp_cache_get( $key, 'site-options' );
+ if( $link == false ) {
+ switch_to_blog( $_blog_id );
+ $link = get_permalink( $post_id );
+ restore_current_blog();
+ wp_cache_add( $key, $link, 'site-options', 360 );
+ }
+ return $link;
+}
+
+function get_blog_id_from_url( $domain, $path = '/' ) {
+ global $wpdb;
+
+ $domain = strtolower( $wpdb->escape( $domain ) );
+ $path = strtolower( $wpdb->escape( $path ) );
+ $id = wp_cache_get( md5( $domain . $path ), 'blog-id-cache' );
+
+ if( $id == -1 ) { // blog does not exist
+ return 0;
+ } elseif( $id ) {
+ return (int)$id;
+ }
+
+ $id = $wpdb->get_var( "SELECT blog_id FROM $wpdb->blogs WHERE domain = '$domain' and path = '$path' /* get_blog_id_from_url */" );
+
+ if ( !$id ) {
+ wp_cache_set( md5( $domain . $path ), -1, 'blog-id-cache' );
+ return false;
+ }
+ wp_cache_set( md5( $domain . $path ), $id, 'blog-id-cache' );
+
+ return $id;
+}
+
+// wpmu admin functions
+
+function wpmu_admin_do_redirect( $url = '' ) {
+ $ref = '';
+ if ( isset( $_GET['ref'] ) )
+ $ref = $_GET['ref'];
+ if ( isset( $_POST['ref'] ) )
+ $ref = $_POST['ref'];
+
+ if( $ref ) {
+ $ref = wpmu_admin_redirect_add_updated_param( $ref );
+ wp_redirect( $ref );
+ exit();
+ }
+ if( empty( $_SERVER['HTTP_REFERER'] ) == false ) {
+ wp_redirect( $_SERVER['HTTP_REFERER'] );
+ exit();
+ }
+
+ $url = wpmu_admin_redirect_add_updated_param( $url );
+ if( isset( $_GET['redirect'] ) ) {
+ if( substr( $_GET['redirect'], 0, 2 ) == 's_' ) {
+ $url .= "&action=blogs&s=". wp_specialchars( substr( $_GET['redirect'], 2 ) );
+ }
+ } elseif( isset( $_POST['redirect'] ) ) {
+ $url = wpmu_admin_redirect_add_updated_param( $_POST['redirect'] );
+ }
+ wp_redirect( $url );
+ exit();
+}
+
+function wpmu_admin_redirect_add_updated_param( $url = '' ) {
+ if( strpos( $url, 'updated=true' ) === false ) {
+ if( strpos( $url, '?' ) === false ) {
+ return $url . '?updated=true';
+ } else {
+ return $url . '&updated=true';
+ }
+ }
+ return $url;
+}
+
+function is_blog_user( $blog_id = 0 ) {
+ global $current_user, $wpdb;
+
+ if ( !$blog_id )
+ $blog_id = $wpdb->blogid;
+
+ $cap_key = $wpdb->base_prefix . $blog_id . '_capabilities';
+
+ if ( is_array($current_user->$cap_key) && in_array(1, $current_user->$cap_key) )
+ return true;
+
+ return false;
+}
+
+function validate_email( $email, $check_domain = true) {
+ if (ereg('^[-!#$%&\'*+\\./0-9=?A-Z^_`a-z{|}~]+'.'@'.
+ '[-!#$%&\'*+\\/0-9=?A-Z^_`a-z{|}~]+\.'.
+ '[-!#$%&\'*+\\./0-9=?A-Z^_`a-z{|}~]+$', $email))
+ {
+ if ($check_domain && function_exists('checkdnsrr')) {
+ list (, $domain) = explode('@', $email);
+
+ if (checkdnsrr($domain.'.', 'MX') || checkdnsrr($domain.'.', 'A')) {
+ return true;
+ }
+ return false;
+ }
+ return true;
+ }
+ return false;
+}
+
+function is_email_address_unsafe( $user_email ) {
+ $banned_names = get_site_option( "banned_email_domains" );
+ if ($banned_names && !is_array( $banned_names )) {
+ $banned_names = explode( "\n", $banned_names);
+ }
+ if ( is_array( $banned_names ) && empty( $banned_names ) == false ) {
+ $email_domain = strtolower( substr( $user_email, 1 + strpos( $user_email, '@' ) ) );
+ foreach( (array) $banned_names as $banned_domain ) {
+ if( $banned_domain == '' )
+ continue;
+ if (
+ strstr( $email_domain, $banned_domain ) ||
+ (
+ strstr( $banned_domain, '/' ) &&
+ preg_match( $banned_domain, $email_domain )
+ )
+ )
+ return true;
+ }
+ }
+ return false;
+}
+
+function wpmu_validate_user_signup($user_name, $user_email) {
+ global $wpdb;
+
+ $errors = new WP_Error();
+
+ $user_name = preg_replace( "/\s+/", '', sanitize_user( $user_name, true ) );
+ $user_email = sanitize_email( $user_email );
+
+ if ( empty( $user_name ) )
+ $errors->add('user_name', __("Please enter a username"));
+
+ $maybe = array();
+ preg_match( "/[a-z0-9]+/", $user_name, $maybe );
+
+ if( $user_name != $maybe[0] ) {
+ $errors->add('user_name', __("Only lowercase letters and numbers allowed"));
+ }
+
+ $illegal_names = get_site_option( "illegal_names" );
+ if( is_array( $illegal_names ) == false ) {
+ $illegal_names = array( "www", "web", "root", "admin", "main", "invite", "administrator" );
+ add_site_option( "illegal_names", $illegal_names );
+ }
+ if( in_array( $user_name, $illegal_names ) == true ) {
+ $errors->add('user_name', __("That username is not allowed"));
+ }
+
+ if( is_email_address_unsafe( $user_email ) )
+ $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."));
+
+ if( strlen( $user_name ) < 4 ) {
+ $errors->add('user_name', __("Username must be at least 4 characters"));
+ }
+
+ if ( strpos( " " . $user_name, "_" ) != false )
+ $errors->add('user_name', __("Sorry, usernames may not contain the character '_'!"));
+
+ // all numeric?
+ $match = array();
+ preg_match( '/[0-9]*/', $user_name, $match );
+ if ( $match[0] == $user_name )
+ $errors->add('user_name', __("Sorry, usernames must have letters too!"));
+
+ if ( !is_email( $user_email ) )
+ $errors->add('user_email', __("Please enter a correct email address"));
+
+ if ( !validate_email( $user_email ) )
+ $errors->add('user_email', __("Please check your email address."));
+
+ $limited_email_domains = get_site_option( 'limited_email_domains' );
+ if ( is_array( $limited_email_domains ) && empty( $limited_email_domains ) == false ) {
+ $emaildomain = substr( $user_email, 1 + strpos( $user_email, '@' ) );
+ if( in_array( $emaildomain, $limited_email_domains ) == false ) {
+ $errors->add('user_email', __("Sorry, that email address is not allowed!"));
+ }
+ }
+
+ // Check if the username has been used already.
+ if ( username_exists($user_name) )
+ $errors->add('user_name', __("Sorry, that username already exists!"));
+
+ // Check if the email address has been used already.
+ if ( email_exists($user_email) )
+ $errors->add('user_email', __("Sorry, that email address is already used!"));
+
+ // Has someone already signed up for this username?
+ $signup = $wpdb->get_row( $wpdb->prepare("SELECT * FROM $wpdb->signups WHERE user_login = %s", $user_name) );
+ if ( $signup != null ) {
+ $registered_at = mysql2date('U', $signup->registered);
+ $now = current_time( 'timestamp', true );
+ $diff = $now - $registered_at;
+ // If registered more than two days ago, cancel registration and let this signup go through.
+ if ( $diff > 172800 ) {
+ $wpdb->query( $wpdb->prepare("DELETE FROM $wpdb->signups WHERE user_login = %s", $user_name) );
+ } else {
+ $errors->add('user_name', __("That username is currently reserved but may be available in a couple of days."));
+ }
+ if( $signup->active == 0 && $signup->user_email == $user_email )
+ $errors->add('user_email_used', __("username and email used"));
+ }
+
+ $signup = $wpdb->get_row( $wpdb->prepare("SELECT * FROM $wpdb->signups WHERE user_email = %s", $user_email) );
+ if ( $signup != null ) {
+ $diff = current_time( 'timestamp', true ) - mysql2date('U', $signup->registered);
+ // If registered more than two days ago, cancel registration and let this signup go through.
+ if ( $diff > 172800 ) {
+ $wpdb->query( $wpdb->prepare("DELETE FROM $wpdb->signups WHERE user_email = %s", $user_email) );
+ } else {
+ $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."));
+ }
+ }
+
+ $result = array('user_name' => $user_name, 'user_email' => $user_email, 'errors' => $errors);
+
+ return apply_filters('wpmu_validate_user_signup', $result);
+}
+
+function wpmu_validate_blog_signup($blogname, $blog_title, $user = '') {
+ global $wpdb, $domain, $base, $current_site;
+
+ $blogname = preg_replace( "/\s+/", '', sanitize_user( $blogname, true ) );
+ $blog_title = strip_tags( $blog_title );
+ $blog_title = substr( $blog_title, 0, 50 );
+
+ $errors = new WP_Error();
+ $illegal_names = get_site_option( "illegal_names" );
+ if( $illegal_names == false ) {
+ $illegal_names = array( "www", "web", "root", "admin", "main", "invite", "administrator" );
+ add_site_option( "illegal_names", $illegal_names );
+ }
+
+ if ( empty( $blogname ) )
+ $errors->add('blogname', __("Please enter a blog name"));
+
+ $maybe = array();
+ preg_match( "/[a-z0-9]+/", $blogname, $maybe );
+ if( $blogname != $maybe[0] ) {
+ $errors->add('blogname', __("Only lowercase letters and numbers allowed"));
+ }
+ if( in_array( $blogname, $illegal_names ) == true ) {
+ $errors->add('blogname', __("That name is not allowed"));
+ }
+ if( strlen( $blogname ) < 4 && !is_site_admin() ) {
+ $errors->add('blogname', __("Blog name must be at least 4 characters"));
+ }
+
+ if ( strpos( " " . $blogname, "_" ) != false )
+ $errors->add('blogname', __("Sorry, blog names may not contain the character '_'!"));
+
+ // do not allow users to create a blog that conflicts with a page on the main blog.
+ if ( constant( "VHOST" ) == 'no' && $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 ) ) ) {
+ $errors->add( 'blogname', __( "Sorry, you may not use that blog name" ) );
+ }
+
+ // all numeric?
+ $match = array();
+ preg_match( '/[0-9]*/', $blogname, $match );
+ if ( $match[0] == $blogname )
+ $errors->add('blogname', __("Sorry, blog names must have letters too!"));
+
+ $blogname = apply_filters( "newblogname", $blogname );
+
+ $blog_title = stripslashes( $blog_title );
+
+ if ( empty( $blog_title ) )
+ $errors->add('blog_title', __("Please enter a blog title"));
+
+ // Check if the domain/path has been used already.
+ if( constant( "VHOST" ) == 'yes' ) {
+ $mydomain = "$blogname.$domain";
+ $path = $base;
+ } else {
+ $mydomain = "$domain";
+ $path = $base.$blogname.'/';
+ }
+ if ( domain_exists($mydomain, $path) )
+ $errors->add('blogname', __("Sorry, that blog already exists!"));
+
+ if ( username_exists( $blogname ) ) {
+ if ( is_object( $user ) == false || ( is_object($user) && ( $user->user_login != $blogname ) ) )
+ $errors->add( 'blogname', __( "Sorry, that blog is reserved!" ) );
+ }
+
+ // Has someone already signed up for this domain?
+ $signup = $wpdb->get_row( $wpdb->prepare("SELECT * FROM $wpdb->signups WHERE domain = %s AND path = %s", $mydomain, $path) ); // TODO: Check email too?
+ if ( ! empty($signup) ) {
+ $diff = current_time( 'timestamp', true ) - mysql2date('U', $signup->registered);
+ // If registered more than two days ago, cancel registration and let this signup go through.
+ if ( $diff > 172800 ) {
+ $wpdb->query( $wpdb->prepare("DELETE FROM $wpdb->signups WHERE domain = %s AND path = %s", $mydomain, $path) );
+ } else {
+ $errors->add('blogname', __("That blog is currently reserved but may be available in a couple days."));
+ }
+ }
+
+ $result = array('domain' => $mydomain, 'path' => $path, 'blogname' => $blogname, 'blog_title' => $blog_title, 'errors' => $errors);
+ return apply_filters('wpmu_validate_blog_signup', $result);
+}
+
+// Record signup information for future activation. wpmu_validate_signup() should be run
+// on the inputs before calling wpmu_signup().
+function wpmu_signup_blog($domain, $path, $title, $user, $user_email, $meta = '') {
+ global $wpdb;
+
+ $key = substr( md5( time() . rand() . $domain ), 0, 16 );
+ $meta = serialize($meta);
+ $domain = $wpdb->escape($domain);
+ $path = $wpdb->escape($path);
+ $title = $wpdb->escape($title);
+
+ $wpdb->insert( $wpdb->signups, array(
+ 'domain' => $domain,
+ 'path' => $path,
+ 'title' => $title,
+ 'user_login' => $user,
+ 'user_email' => $user_email,
+ 'registered' => current_time('mysql', true),
+ 'activation_key' => $key,
+ 'meta' => $meta
+ ) );
+
+ wpmu_signup_blog_notification($domain, $path, $title, $user, $user_email, $key, $meta);
+}
+
+function wpmu_signup_user($user, $user_email, $meta = '') {
+ global $wpdb;
+
+ // Format data
+ $user = preg_replace( "/\s+/", '', sanitize_user( $user, true ) );
+ $user_email = sanitize_email( $user_email );
+ $key = substr( md5( time() . rand() . $user_email ), 0, 16 );
+ $meta = serialize($meta);
+
+ $wpdb->insert( $wpdb->signups, array(
+ 'domain' => '',
+ 'path' => '',
+ 'title' => '',
+ 'user_login' => $user,
+ 'user_email' => $user_email,
+ 'registered' => current_time('mysql', true),
+ 'activation_key' => $key,
+ 'meta' => $meta
+ ) );
+
+ wpmu_signup_user_notification($user, $user_email, $key, $meta);
+}
+
+// Notify user of signup success.
+function wpmu_signup_blog_notification($domain, $path, $title, $user, $user_email, $key, $meta = '') {
+ global $current_site;
+
+ if( !apply_filters('wpmu_signup_blog_notification', $domain, $path, $title, $user, $user_email, $key, $meta) )
+ return false;
+
+ // Send email with activation link.
+ if( constant( "VHOST" ) == 'no' || $current_site->id != 1 ) {
+ $activate_url = "http://" . $current_site->domain . $current_site->path . "wp-activate.php?key=$key";
+ } else {
+ $activate_url = "http://{$domain}{$path}wp-activate.php?key=$key";
+ }
+ $activate_url = clean_url($activate_url);
+ $admin_email = get_site_option( "admin_email" );
+ if( $admin_email == '' )
+ $admin_email = 'support@' . $_SERVER['SERVER_NAME'];
+ $from_name = get_site_option( "site_name" ) == '' ? 'WordPress' : wp_specialchars( get_site_option( "site_name" ) );
+ $message_headers = "MIME-Version: 1.0\n" . "From: \"{$from_name}\" <{$admin_email}>\n" . "Content-Type: text/plain; charset=\"" . get_option('blog_charset') . "\"\n";
+ $message = sprintf( apply_filters( 'wpmu_signup_blog_notification_email', __( "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 blog here:\n\n%s" ) ), $activate_url, clean_url( "http://{$domain}{$path}" ), $key );
+ // TODO: Don't hard code activation link.
+ $subject = sprintf( apply_filters( 'wpmu_signup_blog_notification_subject', __( '[%1s] Activate %2s' ) ), $from_name, clean_url( 'http://' . $domain . $path ) );
+ wp_mail($user_email, $subject, $message, $message_headers);
+ return true;
+}
+
+function wpmu_signup_user_notification($user, $user_email, $key, $meta = '') {
+ global $current_site;
+
+ if( !apply_filters('wpmu_signup_user_notification', $user, $user_email, $key, $meta) )
+ return false;
+
+ // Send email with activation link.
+ $admin_email = get_site_option( "admin_email" );
+ if( $admin_email == '' )
+ $admin_email = 'support@' . $_SERVER['SERVER_NAME'];
+ $from_name = get_site_option( "site_name" ) == '' ? 'WordPress' : wp_specialchars( get_site_option( "site_name" ) );
+ $message_headers = "MIME-Version: 1.0\n" . "From: \"{$from_name}\" <{$admin_email}>\n" . "Content-Type: text/plain; charset=\"" . get_option('blog_charset') . "\"\n";
+ $message = sprintf( apply_filters( 'wpmu_signup_user_notification_email', __( "To activate your user, please click the following link:\n\n%s\n\nAfter you activate, you will receive *another email* with your login.\n\n" ) ), site_url( "wp-activate.php?key=$key" ), $key );
+ // TODO: Don't hard code activation link.
+ $subject = sprintf( __( apply_filters( 'wpmu_signup_user_notification_subject', '[%1s] Activate %2s' ) ), $from_name, $user);
+ wp_mail($user_email, $subject, $message, $message_headers);
+ return true;
+}
+
+function wpmu_activate_signup($key) {
+ global $wpdb, $current_site;
+
+ $signup = $wpdb->get_row( $wpdb->prepare("SELECT * FROM $wpdb->signups WHERE activation_key = %s", $key) );
+
+ if ( empty($signup) )
+ return new WP_Error('invalid_key', __('Invalid activation key.'));
+
+ if ( $signup->active )
+ return new WP_Error('already_active', __('The blog is already active.'), $signup);
+
+ $meta = unserialize($signup->meta);
+ $user_login = $wpdb->escape($signup->user_login);
+ $user_email = $wpdb->escape($signup->user_email);
+ wpmu_validate_user_signup($user_login, $user_email);
+ $password = generate_random_password();
+
+ $user_id = username_exists($user_login);
+
+ if ( ! $user_id )
+ $user_id = wpmu_create_user($user_login, $password, $user_email);
+ else
+ $user_already_exists = true;
+
+ if ( ! $user_id )
+ return new WP_Error('create_user', __('Could not create user'), $signup);
+
+ $now = current_time('mysql', true);
+
+ if ( empty($signup->domain) ) {
+ $wpdb->update( $wpdb->signups, array('active' => 1, 'activated' => $now), array('activation_key' => $key) );
+ if ( isset( $user_already_exists ) )
+ return new WP_Error( 'user_already_exists', __( 'That username is already activated.' ), $signup);
+ wpmu_welcome_user_notification($user_id, $password, $meta);
+ $user_site = get_site_option( 'dashboard_blog', $current_site->blog_id );
+ if ( $user_site == false ) {
+ add_user_to_blog( '1', $user_id, get_site_option( 'default_user_role', 'subscriber' ) );
+ } else {
+ add_user_to_blog( $user_site, $user_id, get_site_option( 'default_user_role', 'subscriber' ) );
+ }
+ add_new_user_to_blog( $user_id, $user_email, $meta );
+ do_action('wpmu_activate_user', $user_id, $password, $meta);
+ return array('user_id' => $user_id, 'password' => $password, 'meta' => $meta);
+ }
+
+ wpmu_validate_blog_signup($signup->domain, $signup->title);
+ $blog_id = wpmu_create_blog( $signup->domain, $signup->path, $signup->title, $user_id, $meta, $wpdb->siteid );
+
+ // TODO: What to do if we create a user but cannot create a blog?
+ if ( is_wp_error($blog_id) ) {
+ // If blog is taken, that means a previous attempt to activate this blog failed in between creating the blog and
+ // setting the activation flag. Let's just set the active flag and instruct the user to reset their password.
+ if ( 'blog_taken' == $blog_id->get_error_code() ) {
+ $blog_id->add_data( $signup );
+ $wpdb->update( $wpdb->signups, array( 'active' => 1, 'activated' => $now ), array( 'activation_key' => $key ) );
+ }
+
+ return $blog_id;
+ }
+
+ $wpdb->update( $wpdb->signups, array('active' => 1, 'activated' => $now), array('activation_key' => $key) );
+
+ wpmu_welcome_notification($blog_id, $user_id, $password, $signup->title, $meta);
+
+ do_action('wpmu_activate_blog', $blog_id, $user_id, $password, $signup->title, $meta);
+
+ return array('blog_id' => $blog_id, 'user_id' => $user_id, 'password' => $password, 'title' => $signup->title, 'meta' => $meta);
+}
+
+function generate_random_password( $len = 8 ) {
+ $random_password = substr(md5(uniqid(microtime())), 0, intval( $len ) );
+ $random_password = apply_filters('random_password', $random_password);
+ return $random_password;
+}
+
+function wpmu_create_user( $user_name, $password, $email) {
+ $user_name = preg_replace( "/\s+/", '', sanitize_user( $user_name, true ) );
+ if ( username_exists($user_name) )
+ return false;
+
+ // Check if the email address has been used already.
+ if ( email_exists($email) )
+ return false;
+
+ $user_id = wp_create_user( $user_name, $password, $email );
+ $user = new WP_User($user_id);
+
+ // Newly created users have no roles or caps until they are added to a blog.
+ update_user_option($user_id, 'capabilities', '');
+ update_user_option($user_id, 'user_level', '');
+
+ do_action( 'wpmu_new_user', $user_id );
+
+ return $user_id;
+}
+
+function wpmu_create_blog($domain, $path, $title, $user_id, $meta = '', $site_id = 1) {
+ $domain = preg_replace( "/\s+/", '', sanitize_user( $domain, true ) );
+ if( constant( 'VHOST' ) == 'yes' )
+ $domain = str_replace( '@', '', $domain );
+ $title = strip_tags( $title );
+ $user_id = (int) $user_id;
+
+ if( empty($path) )
+ $path = '/';
+
+ // Check if the domain has been used already. We should return an error message.
+ if ( domain_exists($domain, $path, $site_id) )
+ return new WP_Error('blog_taken', __('Blog already exists.'));
+
+ if ( !defined("WP_INSTALLING") )
+ define( "WP_INSTALLING", true );
+
+ if ( ! $blog_id = insert_blog($domain, $path, $site_id) )
+ return new WP_Error('insert_blog', __('Could not create blog.'));
+
+ switch_to_blog($blog_id);
+
+ install_blog($blog_id, $title);
+
+ install_blog_defaults($blog_id, $user_id);
+
+ add_user_to_blog($blog_id, $user_id, 'administrator');
+
+ if ( is_array($meta) ) foreach ($meta as $key => $value) {
+ if( $key == 'public' || $key == 'archived' || $key == 'mature' || $key == 'spam' || $key == 'deleted' || $key == 'lang_id' ) {
+ update_blog_status( $blog_id, $key, $value );
+ } else {
+ update_option( $key, $value );
+ }
+ }
+
+ add_option( 'WPLANG', get_site_option( 'WPLANG' ) );
+
+ update_option( 'blog_public', $meta['public'] );
+
+ if ( !is_site_admin() && get_usermeta( $user_id, 'primary_blog' ) == get_site_option( 'dashboard_blog', 1 ) )
+ update_usermeta( $user_id, 'primary_blog', $blog_id );
+
+ restore_current_blog();
+
+ do_action( 'wpmu_new_blog', $blog_id, $user_id );
+
+ return $blog_id;
+}
+
+function newblog_notify_siteadmin( $blog_id, $deprecated = '' ) {
+ global $current_site;
+ if( get_site_option( 'registrationnotification' ) != 'yes' )
+ return false;
+
+ $email = get_site_option( 'admin_email' );
+ if( is_email($email) == false )
+ return false;
+
+ $options_site_url = clean_url("http://{$current_site->domain}{$current_site->path}wp-admin/wpmu-options.php");
+
+ switch_to_blog( $blog_id );
+ $blogname = get_option( 'blogname' );
+ $siteurl = get_option( 'siteurl' );
+ restore_current_blog();
+
+ $msg = sprintf( __( "New Blog: %1s
+URL: %2s
+Remote IP: %3s
+
+Disable these notifications: %4s"), $blogname, $siteurl, $_SERVER['REMOTE_ADDR'], $options_site_url);
+ $msg = apply_filters( 'newblog_notify_siteadmin', $msg );
+
+ wp_mail( $email, sprintf( __( "New Blog Registration: %s" ), $siteurl ), $msg );
+ return true;
+}
+
+function newuser_notify_siteadmin( $user_id ) {
+ global $current_site;
+ if( get_site_option( 'registrationnotification' ) != 'yes' )
+ return false;
+
+ $email = get_site_option( 'admin_email' );
+ if( is_email($email) == false )
+ return false;
+ $user = new WP_User($user_id);
+
+ $options_site_url = clean_url("http://{$current_site->domain}{$current_site->path}wp-admin/wpmu-options.php");
+ $msg = sprintf(__("New User: %1s
+Remote IP: %2s
+
+Disable these notifications: %3s"), $user->user_login, $_SERVER['REMOTE_ADDR'], $options_site_url);
+
+ $msg = apply_filters( 'newuser_notify_siteadmin', $msg );
+ wp_mail( $email, sprintf(__("New User Registration: %s"), $user->user_login), $msg );
+ return true;
+}
+
+function domain_exists($domain, $path, $site_id = 1) {
+ global $wpdb;
+ return $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) );
+}
+
+function insert_blog($domain, $path, $site_id) {
+ global $wpdb;
+
+ $path = trailingslashit($path);
+ $site_id = (int) $site_id;
+
+ $result = $wpdb->insert( $wpdb->blogs, array('site_id' => $site_id, 'domain' => $domain, 'path' => $path, 'registered' => current_time('mysql')) );
+ if ( ! $result )
+ return false;
+
+ refresh_blog_details($wpdb->insert_id);
+ return $wpdb->insert_id;
+}
+
+// Install an empty blog. wpdb should already be switched.
+function install_blog($blog_id, $blog_title = '') {
+ global $wpdb, $table_prefix, $wp_roles;
+ $wpdb->suppress_errors();
+
+ // Cast for security
+ $blog_id = (int) $blog_id;
+
+ require_once( ABSPATH . 'wp-admin/includes/upgrade.php');
+
+ if ( $wpdb->get_results("SELECT ID FROM $wpdb->posts") )
+ die(__('Already Installed You appear to have already installed WordPress. To reinstall please clear your old database tables first.
') . ' 
