array( 'stats/stats.php', 'WordPress.com Stats' ),
'shortlinks' => array( 'stats/stats.php', 'WordPress.com Stats' ),
'sharedaddy' => array( 'sharedaddy/sharedaddy.php', 'Sharedaddy' ),
'twitter-widget' => array( 'wickett-twitter-widget/wickett-twitter-widget.php', 'Wickett Twitter Widget' ),
'after-the-deadline' => array( 'after-the-deadline/after-the-deadline.php', 'After The Deadline' ),
'contact-form' => array( 'grunion-contact-form/grunion-contact-form.php', 'Grunion Contact Form' ),
'custom-css' => array( 'safecss/safecss.php', 'WordPress.com Custom CSS' ),
);
var $capability_translations = array(
'administrator' => 'manage_options',
'editor' => 'edit_others_posts',
'author' => 'publish_posts',
'contributor' => 'edit_posts',
'subscriber' => 'read',
);
/**
* Message to display in admin_notice
* @var string
*/
var $message = '';
/**
* Error to display in admin_notice
* @var string
*/
var $error = '';
/**
* Modules that need more privacy description.
* @var string
*/
var $privacy_checks = '';
/**
* Stats to record once the page loads
*
* @var array
*/
var $stats = array();
/**
* Jetpack_Sync object
*/
var $sync;
/**
* Verified data for JSON authorization request
*/
var $json_api_authorization_request = array();
/**
* Holds the singleton instance of this class
* @since 2.3.3
* @var Jetpack
*/
static $instance = false;
/**
* Singleton
* @static
*/
public static function init() {
if ( ! self::$instance ) {
if ( did_action( 'plugins_loaded' ) )
self::plugin_textdomain();
else
add_action( 'plugins_loaded', array( __CLASS__, 'plugin_textdomain' ) );
self::$instance = new Jetpack;
self::$instance->plugin_upgrade();
}
return self::$instance;
}
/**
* Must never be called statically
*/
function plugin_upgrade() {
// Upgrade: 1.1 -> 1.2
if ( get_option( 'jetpack_id' ) ) {
// Move individual jetpack options to single array of options
$options = array();
foreach ( Jetpack::get_option_names() as $option ) {
if ( false !== $value = get_option( "jetpack_$option" ) ) {
$options[$option] = $value;
}
}
if ( $options ) {
Jetpack::update_options( $options );
foreach ( array_keys( $options ) as $option ) {
delete_option( "jetpack_$option" );
}
}
// Add missing version and old_version options
if ( !$version = Jetpack::get_option( 'version' ) ) {
$version = $old_version = '1.1:' . time();
Jetpack::update_options( compact( 'version', 'old_version' ) );
}
}
// Upgrade from a single user token to a user_id-indexed array and a master_user ID
if ( !Jetpack::get_option( 'user_tokens' ) ) {
if ( $user_token = Jetpack::get_option( 'user_token' ) ) {
$token_parts = explode( '.', $user_token );
if ( isset( $token_parts[2] ) ) {
$master_user = $token_parts[2];
$user_tokens = array( $master_user => $user_token );
Jetpack::update_options( compact( 'master_user', 'user_tokens' ) );
Jetpack::delete_option( 'user_token' );
} else {
// @todo: is this even possible?
trigger_error( sprintf( 'Jetpack::plugin_upgrade found no user_id in user_token "%s"', $user_token ), E_USER_WARNING );
}
}
}
}
/**
* Constructor. Initializes WordPress hooks
*/
private function Jetpack() {
$this->sync = new Jetpack_Sync;
// Modules should do Jetpack_Sync::sync_options( __FILE__, $option, ... ); instead
// We access the "internal" method here only because the Jetpack object isn't instantiated yet
$this->sync->options( __FILE__,
'home',
'siteurl',
'blogname',
'gmt_offset',
'timezone_string'
);
if ( defined( 'XMLRPC_REQUEST' ) && XMLRPC_REQUEST && isset( $_GET['for'] ) && 'jetpack' == $_GET['for'] ) {
@ini_set( 'display_errors', false ); // Display errors can cause the XML to be not well formed.
require_once dirname( __FILE__ ) . '/class.jetpack-xmlrpc-server.php';
$this->xmlrpc_server = new Jetpack_XMLRPC_Server();
$this->require_jetpack_authentication();
if ( Jetpack::is_active() ) {
// Hack to preserve $HTTP_RAW_POST_DATA
add_filter( 'xmlrpc_methods', array( $this, 'xmlrpc_methods' ) );
// The actual API methods.
add_filter( 'xmlrpc_methods', array( $this->xmlrpc_server, 'xmlrpc_methods' ) );
} else {
// The bootstrap API methods.
add_filter( 'xmlrpc_methods', array( $this->xmlrpc_server, 'bootstrap_xmlrpc_methods' ) );
}
// Now that no one can authenticate, and we're whitelisting all XML-RPC methods, force enable_xmlrpc on.
add_filter( 'pre_option_enable_xmlrpc', '__return_true' );
} elseif ( is_admin() && isset( $_POST['action'] ) && 'jetpack_upload_file' == $_POST['action'] ) {
$this->require_jetpack_authentication();
$this->add_remote_request_handlers();
} else {
if ( Jetpack::is_active() ) {
add_action( 'login_form_jetpack_json_api_authorization', array( &$this, 'login_form_json_api_authorization' ) );
}
}
add_action( 'jetpack_clean_nonces', array( 'Jetpack', 'clean_nonces' ) );
if ( !wp_next_scheduled( 'jetpack_clean_nonces' ) ) {
wp_schedule_event( time(), 'hourly', 'jetpack_clean_nonces' );
}
add_filter( 'xmlrpc_blog_options', array( $this, 'xmlrpc_options' ) );
add_action( 'admin_menu', array( $this, 'admin_menu' ), 999 ); // run late so that other plugins hooking into this menu don't get left out
add_action( 'admin_init', array( $this, 'admin_init' ) );
add_action( 'admin_init', array( $this, 'dismiss_jetpack_notice' ) );
add_filter( 'admin_body_class', array( $this, 'admin_body_class' ) );
add_action( 'wp_ajax_jetpack-check-news-subscription', array( $this, 'check_news_subscription' ) );
add_action( 'wp_ajax_jetpack-subscribe-to-news', array( $this, 'subscribe_to_news' ) );
add_action( 'wp_loaded', array( $this, 'register_assets' ) );
add_action( 'wp_enqueue_scripts', array( $this, 'devicepx' ) );
add_action( 'customize_controls_enqueue_scripts', array( $this, 'devicepx' ) );
add_action( 'admin_enqueue_scripts', array( $this, 'devicepx' ) );
// add_action( 'jetpack_admin_menu', array( $this, 'admin_menu_modules' ) );
add_action( 'jetpack_activate_module', array( $this, 'activate_module_actions' ) );
/**
* These actions run checks to load additional files.
* They check for external files or plugins, so thef need to run as late as possible.
*/
add_action( 'plugins_loaded', array( $this, 'check_open_graph' ), 999 );
add_action( 'plugins_loaded', array( $this, 'check_rest_api_compat' ), 1000 );
}
/**
* If there are any stats that need to be pushed, but haven't been, push them now.
*/
function __destruct() {
if ( ! empty( $this->stats ) ) {
$this->do_stats( 'server_side' );
}
}
function require_jetpack_authentication() {
// Don't let anyone authenticate
$_COOKIE = array();
remove_all_filters( 'authenticate' );
if ( Jetpack::is_active() ) {
// Allow Jetpack authentication
add_filter( 'authenticate', array( $this, 'authenticate_jetpack' ), 10, 3 );
}
}
/**
* Load language files
*/
public static function plugin_textdomain() {
load_plugin_textdomain( 'jetpack', false, dirname( plugin_basename( __FILE__ ) ) . '/languages/' );
}
/**
* Register assets for use in various modules and the Jetpack admin page.
*
* @uses wp_script_is, wp_register_script, plugins_url
* @action wp_loaded
* @return null
*/
public function register_assets() {
if ( ! wp_script_is( 'spin', 'registered' ) )
wp_register_script( 'spin', plugins_url( '_inc/spin.js', __FILE__ ), false, '1.3' );
if ( ! wp_script_is( 'jquery.spin', 'registered' ) )
wp_register_script( 'jquery.spin', plugins_url( '_inc/jquery.spin.js', __FILE__ ) , array( 'jquery', 'spin' ), '1.3' );
if ( ! wp_script_is( 'jetpack-gallery-settings', 'registered' ) )
wp_register_script( 'jetpack-gallery-settings', plugins_url( '_inc/gallery-settings.js', __FILE__ ), array( 'media-views' ), '20121225' );
if ( ! wp_style_is( 'genericons', 'registered' ) )
wp_register_style( 'genericons', plugins_url( '_inc/genericons.css', __FILE__ ), false, JETPACK__VERSION );
}
/**
* Device Pixels support
* This improves the resolution of gravatars and wordpress.com uploads on hi-res and zoomed browsers.
*/
function devicepx() {
wp_enqueue_script( 'devicepx', ( is_ssl() ? 'https' : 'http' ) . '://s0.wp.com/wp-content/js/devicepx-jetpack.js', array(), gmdate('oW'), true );
}
/**
* Is Jetpack active?
*/
public static function is_active() {
return (bool) Jetpack_Data::get_access_token( JETPACK_MASTER_USER );
}
/**
* Is Jetpack in development (offline) mode?
*/
public static function is_development_mode() {
$development_mode = false;
if ( defined( 'JETPACK_DEV_DEBUG' ) ) {
$development_mode = JETPACK_DEV_DEBUG;
}
elseif ( site_url() && false === strpos( site_url(), '.' ) ) {
$development_mode = true;
}
return apply_filters( 'jetpack_development_mode', $development_mode );
}
/**
* Is a given user (or the current user if none is specified) linked to a WordPress.com user?
*/
public static function is_user_connected( $user_id = false ) {
$user_id = false === $user_id ? get_current_user_id() : absint( $user_id );
if ( !$user_id ) {
return false;
}
return (bool) Jetpack_Data::get_access_token( $user_id );
}
function current_user_is_connection_owner() {
$user_token = Jetpack_Data::get_access_token( JETPACK_MASTER_USER );
return $user_token && is_object( $user_token ) && isset( $user_token->external_user_id ) && get_current_user_id() === $user_token->external_user_id;
}
/**
* Synchronize connected user role changes
*/
function user_role_change( $user_id ) {
if ( Jetpack::is_active() && Jetpack::is_user_connected( $user_id ) ) {
$current_user_id = get_current_user_id();
wp_set_current_user( $user_id );
$role = $this->translate_current_user_to_role();
$signed_role = $this->sign_role( $role );
wp_set_current_user( $current_user_id );
$master_token = Jetpack_Data::get_access_token( JETPACK_MASTER_USER );
$master_user_id = absint( $master_token->external_user_id );
if ( !$master_user_id )
return; // this shouldn't happen
Jetpack::xmlrpc_async_call( 'jetpack.updateRole', $user_id, $signed_role );
//@todo retry on failure
//try to choose a new master if we're demoting the current one
if ( $user_id == $master_user_id && 'administrator' != $role ) {
$query = new WP_User_Query( array(
'fields' => array( 'id' ),
'role' => 'administrator',
'orderby' => 'id',
'exclude' => array( $master_user_id ),
)
);
$new_master = false;
foreach ( $query->results as $result ) {
$uid = absint( $result->id );
if ( $uid && Jetpack::is_user_connected( $uid ) ) {
$new_master = $uid;
break;
}
}
if ( $new_master ) {
Jetpack::update_option( 'master_user', $new_master );
}
// else disconnect..?
}
}
}
/**
* Loads the currently active modules.
*/
public static function load_modules() {
/*
if ( ! Jetpack::is_active() && ! Jetpack::is_development_mode() ) {
return;
}
*/
$version = Jetpack::get_option( 'version' );
if ( !$version ) {
$version = $old_version = JETPACK__VERSION . ':' . time();
Jetpack::update_options( compact( 'version', 'old_version' ) );
}
list( $version ) = explode( ':', $version );
$modules = array_filter( Jetpack::get_active_modules(), array( 'Jetpack', 'is_module' ) );
$modules_data = array();
// Don't load modules that have had "Major" changes since the stored version until they have been deactivated/reactivated through the lint check.
if ( version_compare( $version, JETPACK__VERSION, '<' ) ) {
$updated_modules = array();
foreach ( $modules as $module ) {
$modules_data[ $module ] = Jetpack::get_module( $module );
if ( ! isset( $modules_data[ $module ]['changed'] ) ) {
continue;
}
if ( version_compare( $modules_data[ $module ]['changed'], $version, '<=' ) ) {
continue;
}
$updated_modules[] = $module;
}
$modules = array_diff( $modules, $updated_modules );
}
foreach ( $modules as $module ) {
// If not connected and we're in dev mode, disable modules requiring a connection
if ( ! Jetpack::is_active() ) {
if ( empty( $modules_data[ $module ] ) ) {
$modules_data[ $module ] = Jetpack::get_module( $module );
}
if ( $modules_data[ $module ]['requires_connection'] || ! Jetpack::is_development_mode() ) {
continue;
}
}
if ( did_action( 'jetpack_module_loaded_' . $module ) ) {
continue;
}
require Jetpack::get_module_path( $module );
do_action( 'jetpack_module_loaded_' . $module );
}
do_action( 'jetpack_modules_loaded' );
// Load module-specific code that is needed even when a module isn't active. Loaded here because code contained therein may need actions such as setup_theme.
require_once( dirname( __FILE__ ) . '/modules/module-extras.php' );
}
/**
* Check if Jetpack's REST API compat file should be included
* @action plugins_loaded
* @return null
*/
public function check_rest_api_compat() {
$_jetpack_rest_api_compat_includes = apply_filters( 'jetpack_rest_api_compat', array() );
if ( function_exists( 'bbpress' ) )
$_jetpack_rest_api_compat_includes[] = dirname( __FILE__ ) . '/class.jetpack-bbpress-json-api-compat.php';
foreach ( $_jetpack_rest_api_compat_includes as $_jetpack_rest_api_compat_include )
require_once $_jetpack_rest_api_compat_include;
}
/**
* Check if Jetpack's Open Graph tags should be used.
* If certain plugins are active, Jetpack's og tags are suppressed.
*
* @uses Jetpack::get_active_modules, add_filter, get_option, apply_filters
* @action plugins_loaded
* @return null
*/
public function check_open_graph() {
if ( in_array( 'publicize', Jetpack::get_active_modules() ) || in_array( 'sharedaddy', Jetpack::get_active_modules() ) )
add_filter( 'jetpack_enable_open_graph', '__return_true', 0 );
$active_plugins = get_option( 'active_plugins', array() );
if ( is_multisite() ) {
// Due to legacy code, active_sitewide_plugins stores them in the keys,
// whereas active_plugins stores them in the values.
$network_plugins = array_keys( get_site_option( 'active_sitewide_plugins', array() ) );
if ( $network_plugins ) {
$active_plugins = array_merge( $active_plugins, $network_plugins );
}
}
$conflicting_plugins = array(
'facebook/facebook.php', // Official Facebook plugin
'wordpress-seo/wp-seo.php', // WordPress SEO by Yoast
'add-link-to-facebook/add-link-to-facebook.php', // Add Link to Facebook
'facebook-awd/AWD_facebook.php', // Facebook AWD All in one
'header-footer/plugin.php', // Header and Footer
'nextgen-facebook/nextgen-facebook.php', // NextGEN Facebook OG
'seo-facebook-comments/seofacebook.php', // SEO Facebook Comments
'seo-ultimate/seo-ultimate.php', // SEO Ultimate
'sexybookmarks/sexy-bookmarks.php', // Shareaholic
'shareaholic/sexy-bookmarks.php', // Shareaholic
'social-discussions/social-discussions.php', // Social Discussions
'social-networks-auto-poster-facebook-twitter-g/NextScripts_SNAP.php', // NextScripts SNAP
'wordbooker/wordbooker.php', // Wordbooker
'socialize/socialize.php', // Socialize
'simple-facebook-connect/sfc.php', // Simple Facebook Connect
'social-sharing-toolkit/social_sharing_toolkit.php', // Social Sharing Toolkit
'wp-facebook-open-graph-protocol/wp-facebook-ogp.php', // WP Facebook Open Graph protocol
'opengraph/opengraph.php', // Open Graph
'sharepress/sharepress.php', // SharePress
'wp-facebook-like-send-open-graph-meta/wp-facebook-like-send-open-graph-meta.php', // WP Facebook Like Send & Open Graph Meta
'network-publisher/networkpub.php', // Network Publisher
'wp-ogp/wp-ogp.php', // WP-OGP
);
foreach ( $conflicting_plugins as $plugin ) {
if ( in_array( $plugin, $active_plugins ) ) {
add_filter( 'jetpack_enable_open_graph', '__return_false', 99 );
break;
}
}
if ( apply_filters( 'jetpack_enable_open_graph', false ) )
require_once dirname( __FILE__ ) . '/functions.opengraph.php';
}
/* Jetpack Options API */
public static function get_option_names( $type = 'compact' ) {
return Jetpack_Options::get_option_names( $type );
}
/**
* Returns the requested option. Looks in jetpack_options or jetpack_$name as appropriate.
*
* @param string $name Option name
* @param mixed $default (optional)
*/
public static function get_option( $name, $default = false ) {
return Jetpack_Options::get_option( $name, $default );
}
/**
* Stores two secrets and a timestamp so WordPress.com can make a request back and verify an action
* Does some extra verification so urls (such as those to public-api, register, etc) cant just be crafted
* $name must be a registered option name.
*/
public static function create_nonce( $name ) {
$secret = wp_generate_password( 32, false ) . ':' . wp_generate_password( 32, false ) . ':' . ( time() + 600 );
Jetpack::update_option( $name, $secret );
@list( $secret_1, $secret_2, $eol ) = explode( ':', Jetpack::get_option( $name ) );
if ( empty( $secret_1 ) || empty( $secret_2 ) || $eol < time() )
return new Jetpack_Error( 'missing_secrets' );
return array(
'secret_1' => $secret_1,
'secret_2' => $secret_2,
'eol' => $eol,
);
}
/**
* Updates the single given option. Updates jetpack_options or jetpack_$name as appropriate.
*
* @param string $name Option name
* @param mixed $value Option value
*/
public static function update_option( $name, $value ) {
return Jetpack_Options::update_option( $name, $value );
}
/**
* Updates the multiple given options. Updates jetpack_options and/or jetpack_$name as appropriate.
*
* @param array $array array( option name => option value, ... )
*/
public static function update_options( $array ) {
return Jetpack_Options::update_options( $array );
}
/**
* Deletes the given option. May be passed multiple option names as an array.
* Updates jetpack_options and/or deletes jetpack_$name as appropriate.
*
* @param string|array $names
*/
public static function delete_option( $names ) {
return Jetpack_Options::delete_option( $names );
}
/**
* Enters a user token into the user_tokens option
*
* @param int $user_id
* @param string $token
* return bool
*/
public static function update_user_token( $user_id, $token, $is_master_user ) {
// not designed for concurrent updates
$user_tokens = Jetpack::get_option( 'user_tokens' );
if ( ! is_array( $user_tokens ) )
$user_tokens = array();
$user_tokens[$user_id] = $token;
if ( $is_master_user ) {
$master_user = $user_id;
$options = compact('user_tokens', 'master_user');
} else {
$options = compact('user_tokens');
}
return Jetpack::update_options( $options );
}
/**
* Returns an array of all PHP files in the specified absolute path.
* Equivalent to glob( "$absolute_path/*.php" ).
*
* @param string $absolute_path The absolute path of the directory to search.
* @return array Array of absolute paths to the PHP files.
*/
public static function glob_php( $absolute_path ) {
$absolute_path = untrailingslashit( $absolute_path );
$files = array();
if ( !$dir = @opendir( $absolute_path ) ) {
return $files;
}
while ( false !== $file = readdir( $dir ) ) {
if ( '.' == substr( $file, 0, 1 ) || '.php' != substr( $file, -4 ) ) {
continue;
}
$file = "$absolute_path/$file";
if ( !is_file( $file ) ) {
continue;
}
$files[] = $file;
}
closedir( $dir );
return $files;
}
public function activate_new_modules() {
if ( ! Jetpack::is_active() && ! Jetpack::is_development_mode() ) {
return;
}
$jetpack_old_version = Jetpack::get_option( 'version' ); // [sic]
if ( !$jetpack_old_version ) {
$jetpack_old_version = $version = $old_version = '1.1:' . time();
Jetpack::update_options( compact( 'version', 'old_version' ) );
}
list( $jetpack_version ) = explode( ':', $jetpack_old_version ); // [sic]
if ( version_compare( JETPACK__VERSION, $jetpack_version, '<=' ) ) {
return;
}
$active_modules = Jetpack::get_active_modules();
$reactivate_modules = array();
foreach ( $active_modules as $active_module ) {
$module = Jetpack::get_module( $active_module );
if ( !isset( $module['changed'] ) ) {
continue;
}
if ( version_compare( $module['changed'], $jetpack_version, '<=' ) ) {
continue;
}
$reactivate_modules[] = $active_module;
Jetpack::deactivate_module( $active_module );
}
if ( version_compare( $jetpack_version, '1.9.2', '<' ) && version_compare( '1.9-something', JETPACK__VERSION, '<' ) ) {
add_action( 'jetpack_activate_default_modules', array( $this->sync, 'sync_all_registered_options' ), 1000 );
}
Jetpack::update_options( array(
'version' => JETPACK__VERSION . ':' . time(),
'old_version' => $jetpack_old_version,
) );
Jetpack::state( 'message', 'modules_activated' );
Jetpack::activate_default_modules( $jetpack_version, JETPACK__VERSION, $reactivate_modules );
wp_safe_redirect( Jetpack::admin_url( 'page=jetpack' ) );
exit;
}
/**
* List available Jetpack modules. Simply lists .php files in /modules/.
* Make sure to tuck away module "library" files in a sub-directory.
*/
public static function get_available_modules( $min_version = false, $max_version = false ) {
static $modules = null;
if ( !isset( $modules ) ) {
$files = Jetpack::glob_php( dirname( __FILE__ ) . '/modules' );
$modules = array();
foreach ( $files as $file ) {
if ( !$headers = Jetpack::get_module( $file ) ) {
continue;
}
$modules[ Jetpack::get_module_slug( $file ) ] = $headers['introduced'];
}
}
if ( !$min_version && !$max_version ) {
return array_keys( $modules );
}
$r = array();
foreach ( $modules as $slug => $introduced ) {
if ( $min_version && version_compare( $min_version, $introduced, '>=' ) ) {
continue;
}
if ( $max_version && version_compare( $max_version, $introduced, '<' ) ) {
continue;
}
$r[] = $slug;
}
return $r;
}
/**
* Default modules loaded on activation.
*/
public static function get_default_modules( $min_version = false, $max_version = false ) {
$return = array();
foreach ( Jetpack::get_available_modules( $min_version, $max_version ) as $module ) {
// Add special cases here for modules to avoid auto-activation
switch ( $module ) {
// These modules are default off: they change things blog-side
case 'comments' :
case 'carousel' :
case 'minileven':
case 'infinite-scroll' :
case 'photon' :
case 'tiled-gallery' :
case 'likes' :
break;
// These modules are default off if we think the site is a private one
case 'enhanced-distribution' :
case 'json-api' :
if ( !Jetpack::get_option( 'public' ) ) {
break;
}
// else no break
// The rest are default on
default :
$return[] = $module;
}
}
return $return;
}
/**
* Extract a module's slug from its full path.
*/
public static function get_module_slug( $file ) {
return str_replace( '.php', '', basename( $file ) );
}
/**
* Generate a module's path from its slug.
*/
public static function get_module_path( $slug ) {
return dirname( __FILE__ ) . "/modules/$slug.php";
}
/**
* Load module data from module file. Headers differ from WordPress
* plugin headers to avoid them being identified as standalone
* plugins on the WordPress plugins page.
*/
public static function get_module( $module ) {
$headers = array(
'name' => 'Module Name',
'description' => 'Module Description',
'sort' => 'Sort Order',
'introduced' => 'First Introduced',
'changed' => 'Major Changes In',
'deactivate' => 'Deactivate',
'free' => 'Free',
'requires_connection' => 'Requires Connection',
);
$file = Jetpack::get_module_path( Jetpack::get_module_slug( $module ) );
if ( !file_exists( $file ) )
return false;
$mod = get_file_data( $file, $headers );
if ( empty( $mod['name'] ) )
return false;
$mod['name'] = translate( $mod['name'], 'jetpack' );
$mod['description'] = translate( $mod['description'], 'jetpack' );
if ( empty( $mod['sort'] ) )
$mod['sort'] = 10;
$mod['deactivate'] = empty( $mod['deactivate'] );
$mod['free'] = empty( $mod['free'] );
$mod['requires_connection'] = ( ! empty( $mod['requires_connection'] ) && 'No' == $mod['requires_connection'] ) ? false : true;
return $mod;
}
/**
* Get a list of activated modules as an array of module slugs.
*/
public static function get_active_modules() {
$active = Jetpack::get_option( 'active_modules' );
if ( !is_array( $active ) )
$active = array();
if ( is_admin() ) {
$active[] = 'vaultpress';
} else {
$active = array_diff( $active, array( 'vaultpress' ) );
}
return array_unique( $active );
}
/**
* Check whether or not a Jetpack module is active.
*
* @param string $module The slug of a Jetpack module.
* @return bool
*
* @static
*/
public static function is_module_active( $module ) {
return in_array( $module, self::get_active_modules() );
}
public static function is_module( $module ) {
return !empty( $module ) && !validate_file( $module, Jetpack::get_available_modules() );
}
/**
* Catches PHP errors. Must be used in conjunction with output buffering.
*
* @param bool $catch True to start catching, False to stop.
*
* @static
*/
public static function catch_errors( $catch ) {
static $display_errors, $error_reporting;
if ( $catch ) {
$display_errors = @ini_set( 'display_errors', 1 );
$error_reporting = @error_reporting( E_ALL );
add_action( 'shutdown', array( 'Jetpack', 'catch_errors_on_shutdown' ), 0 );
} else {
@ini_set( 'display_errors', $display_errors );
@error_reporting( $error_reporting );
remove_action( 'shutdown', array( 'Jetpack', 'catch_errors_on_shutdown' ), 1 );
}
}
/**
* Saves any generated PHP errors in ::state( 'php_errors', {errors} )
*/
public static function catch_errors_on_shutdown() {
Jetpack::state( 'php_errors', ob_get_clean() );
}
public static function activate_default_modules( $min_version = false, $max_version = false, $other_modules = array() ) {
$jetpack = Jetpack::init();
$modules = Jetpack::get_default_modules( $min_version, $max_version );
$modules = array_merge( $other_modules, $modules );
// Look for standalone plugins and disable if active.
$to_deactivate = array();
foreach ( $modules as $module ) {
if ( isset( $jetpack->plugins_to_deactivate[$module] ) ) {
$to_deactivate[$module] = $jetpack->plugins_to_deactivate[$module];
}
}
$deactivated = array();
foreach ( $to_deactivate as $module => $deactivate_me ) {
list( $probable_file, $probable_title ) = $deactivate_me;
if ( Jetpack_Client_Server::deactivate_plugin( $probable_file, $probable_title ) ) {
$deactivated[] = $module;
}
}
if ( $deactivated ) {
Jetpack::state( 'deactivated_plugins', join( ',', $deactivated ) );
$url = add_query_arg( array(
'action' => 'activate_default_modules',
'_wpnonce' => wp_create_nonce( 'activate_default_modules' ),
), add_query_arg( compact( 'min_version', 'max_version', 'other_modules' ), Jetpack::admin_url( 'page=jetpack' ) ) );
wp_safe_redirect( $url );
exit;
}
do_action( 'jetpack_before_activate_default_modules', $min_version, $max_version, $other_modules );
// Check each module for fatal errors, a la wp-admin/plugins.php::activate before activating
$redirect = menu_page_url( 'jetpack', false );
Jetpack::restate();
Jetpack::catch_errors( true );
foreach ( $modules as $module ) {
if ( did_action( "jetpack_module_loaded_$module" ) ) {
$active[] = $module;
Jetpack::update_option( 'active_modules', array_unique( $active ) );
continue;
}
$active = Jetpack::get_active_modules();
if ( in_array( $module, $active ) ) {
$module_info = Jetpack::get_module( $module );
if ( !$module_info['deactivate'] ) {
$state = in_array( $module, $other_modules ) ? 'reactivated_modules' : 'activated_modules';
if ( $active_state = Jetpack::state( $state ) ) {
$active_state = explode( ',', $active_state );
} else {
$active_state = array();
}
$active_state[] = $module;
Jetpack::state( $state, implode( ',', $active_state ) );
}
continue;
}
$file = Jetpack::get_module_path( $module );
if ( !file_exists( $file ) ) {
continue;
}
// we'll override this later if the plugin can be included without fatal error
wp_safe_redirect( Jetpack::admin_url( 'page=jetpack' ) );
Jetpack::state( 'error', 'module_activation_failed' );
Jetpack::state( 'module', $module );
ob_start();
require $file;
do_action( 'jetpack_activate_module', $module );
$active[] = $module;
$state = in_array( $module, $other_modules ) ? 'reactivated_modules' : 'activated_modules';
if ( $active_state = Jetpack::state( $state ) ) {
$active_state = explode( ',', $active_state );
} else {
$active_state = array();
}
$active_state[] = $module;
Jetpack::state( $state, implode( ',', $active_state ) );
Jetpack::update_option( 'active_modules', array_unique( $active ) );
ob_end_clean();
}
Jetpack::state( 'error', false );
Jetpack::state( 'module', false );
Jetpack::catch_errors( false );
do_action( 'jetpack_activate_default_modules', $min_version, $max_version, $other_modules );
}
public static function activate_module( $module, $exit = true ) {
$jetpack = Jetpack::init();
if ( ! strlen( $module ) )
return false;
if ( ! Jetpack::is_module( $module ) )
return false;
// If it's already active, then don't do it again
$active = Jetpack::get_active_modules();
foreach ( $active as $act ) {
if ( $act == $module )
return true;
}
$module_data = Jetpack::get_module( $module );
if ( ! Jetpack::is_active() ) {
if ( ! Jetpack::is_development_mode() )
return false;
// If we're not connected but in development mode, make sure the module doesn't require a connection
if ( Jetpack::is_development_mode() && $module_data['requires_connection'] )
return false;
}
// Check and see if the old plugin is active
if ( isset( $jetpack->plugins_to_deactivate[$module] ) ) {
// Deactivate the old plugin
if ( Jetpack_Client_Server::deactivate_plugin( $jetpack->plugins_to_deactivate[$module][0], $jetpack->plugins_to_deactivate[$module][1] ) ) {
// If we deactivated the old plugin, remembere that with ::state() and redirect back to this page to activate the module
// We can't activate the module on this page load since the newly deactivated old plugin is still loaded on this page load.
Jetpack::state( 'deactivated_plugins', $module );
wp_safe_redirect( add_query_arg( 'jetpack_restate', 1 ) );
exit;
}
}
// Check the file for fatal errors, a la wp-admin/plugins.php::activate
Jetpack::state( 'module', $module );
Jetpack::state( 'error', 'module_activation_failed' ); // we'll override this later if the plugin can be included without fatal error
wp_safe_redirect( Jetpack::admin_url( 'page=jetpack' ) );
Jetpack::catch_errors( true );
ob_start();
require Jetpack::get_module_path( $module );
do_action( 'jetpack_activate_module', $module );
$active[] = $module;
Jetpack::update_option( 'active_modules', array_unique( $active ) );
Jetpack::state( 'error', false ); // the override
Jetpack::state( 'message', 'module_activated' );
Jetpack::state( 'module', $module );
ob_end_clean();
Jetpack::catch_errors( false );
if ( $exit ) {
exit;
}
}
function activate_module_actions( $module ) {
do_action( "jetpack_activate_module_$module" );
$this->sync->sync_all_module_options( $module );
}
public static function deactivate_module( $module ) {
$active = Jetpack::get_active_modules();
$new = array();
foreach ( $active as $check ) {
if ( !empty( $check ) && $module != $check )
$new[] = $check;
}
do_action( "jetpack_deactivate_module_$module" );
return Jetpack::update_option( 'active_modules', array_unique( $new ) );
}
public static function enable_module_configurable( $module ) {
$module = Jetpack::get_module_slug( $module );
add_filter( 'jetpack_module_configurable_' . $module, '__return_true' );
}
public static function module_configuration_url( $module ) {
$module = Jetpack::get_module_slug( $module );
return Jetpack::admin_url( array( 'page' => 'jetpack', 'configure' => $module ) );
}
public static function module_configuration_load( $module, $method ) {
$module = Jetpack::get_module_slug( $module );
add_action( 'jetpack_module_configuration_load_' . $module, $method );
}
public static function module_configuration_head( $module, $method ) {
$module = Jetpack::get_module_slug( $module );
add_action( 'jetpack_module_configuration_head_' . $module, $method );
}
public static function module_configuration_screen( $module, $method ) {
$module = Jetpack::get_module_slug( $module );
add_action( 'jetpack_module_configuration_screen_' . $module, $method );
}
/* Installation */
public static function bail_on_activation( $message, $deactivate = true ) {
?>
$plugin ) {
if ( $plugin === $jetpack ) {
$plugins[$i] = false;
$update = true;
}
}
if ( $update ) {
update_option( 'active_plugins', array_filter( $plugins ) );
}
}
exit;
}
/**
* Attached to activate_{ plugin_basename( __FILES__ ) } by register_activation_hook()
* @static
*/
public static function plugin_activation( $network_wide ) {
Jetpack::update_option( 'activated', 1 );
if ( version_compare( $GLOBALS['wp_version'], JETPACK__MINIMUM_WP_VERSION, '<' ) ) {
Jetpack::bail_on_activation( sprintf( __( 'Jetpack requires WordPress version %s or later.', 'jetpack' ), JETPACK__MINIMUM_WP_VERSION ) );
}
if ( $network_wide )
Jetpack::state( 'network_nag', true );
Jetpack::plugin_initialize();
}
/**
* Sets the internal version number and activation state.
* @static
*/
public static function plugin_initialize() {
if ( !Jetpack::get_option( 'activated' ) ) {
Jetpack::update_option( 'activated', 2 );
}
if ( !Jetpack::get_option( 'version' ) ) {
$version = $old_version = JETPACK__VERSION . ':' . time();
Jetpack::update_options( compact( 'version', 'old_version' ) );
}
Jetpack::load_modules();
Jetpack::delete_option( 'do_activate' );
}
/**
* Removes all connection options
* @static
*/
public static function plugin_deactivation( ) {
Jetpack::disconnect( false );
Jetpack_Heartbeat::init()->deactivate();
}
/**
* Disconnects from the Jetpack servers.
* Forgets all connection details and tells the Jetpack servers to do the same.
* @static
*/
public static function disconnect( $update_activated_state = true ) {
wp_clear_scheduled_hook( 'jetpack_clean_nonces' );
Jetpack::clean_nonces( true );
Jetpack::load_xml_rpc_client();
$xml = new Jetpack_IXR_Client();
$xml->query( 'jetpack.deregister' );
Jetpack::delete_option( array(
'register',
'blog_token',
'user_token',
'user_tokens',
'master_user',
'time_diff',
'fallback_no_verify_ssl_certs',
) );
if ( $update_activated_state ) {
Jetpack::update_option( 'activated', 4 );
}
}
/**
* Unlinks the current user from the linked WordPress.com user
*/
function unlink_user() {
if ( !$tokens = Jetpack::get_option( 'user_tokens' ) )
return false;
$user_id = get_current_user_id();
if ( Jetpack::get_option( 'master_user' ) == $user_id )
return false;
if ( !isset( $tokens[$user_id] ) )
return false;
Jetpack::load_xml_rpc_client();
$xml = new Jetpack_IXR_Client( compact( 'user_id' ) );
$xml->query( 'jetpack.unlink_user', $user_id );
unset( $tokens[$user_id] );
Jetpack::update_option( 'user_tokens', $tokens );
return true;
}
/**
* Attempts Jetpack registration. If it fail, a state flag is set: @see ::admin_page_load()
*/
public static function try_registration() {
$result = Jetpack::register();
// If there was an error with registration and the site was not registered, record this so we can show a message.
if ( !$result || is_wp_error( $result ) ) {
return $result;
} else {
return true;
}
}
/* Admin Pages */
function admin_init() {
// If the plugin is not connected, display a connect message.
if (
// the plugin was auto-activated and needs its candy
Jetpack::get_option( 'do_activate' )
||
// the plugin is active, but was never activated. Probably came from a site-wide network activation
!Jetpack::get_option( 'activated' )
) {
Jetpack::plugin_initialize();
}
if ( !Jetpack::is_active() && ! Jetpack::is_development_mode() ) {
if ( 4 != Jetpack::get_option( 'activated' ) ) {
// Show connect notice on dashboard and plugins pages
add_action( 'load-index.php', array( $this, 'prepare_connect_notice' ) );
add_action( 'load-plugins.php', array( $this, 'prepare_connect_notice' ) );
}
} elseif ( false === Jetpack::get_option( 'fallback_no_verify_ssl_certs' ) ) {
// Upgrade: 1.1 -> 1.1.1
// Check and see if host can verify the Jetpack servers' SSL certificate
$args = array();
Jetpack_Client::_wp_remote_request(
Jetpack::fix_url_for_bad_hosts( Jetpack::api_url( 'test' ), $args ),
$args,
true
);
}
/* Toggle this off as it's not ready for prime time just yet.
if( current_user_can( 'manage_options' ) && self::check_identity_crisis() ) {
add_action( 'admin_notices', array( $this, 'alert_identity_crisis' ) );
}
/**/
if ( current_user_can( 'manage_options' ) && 'ALWAYS' == JETPACK_CLIENT__HTTPS && ! self::permit_ssl() ) {
add_action( 'admin_notices', array( $this, 'alert_required_ssl_fail' ) );
}
add_action( 'load-plugins.php', array( $this, 'intercept_plugin_error_scrape_init' ) );
add_action( 'admin_head', array( $this, 'admin_menu_css' ) );
add_filter( 'plugin_action_links_' . plugin_basename( __FILE__ ), array( $this, 'plugin_action_links' ) );
if ( Jetpack::is_active() || Jetpack::is_development_mode() ) {
// Artificially throw errors in certain whitelisted cases during plugin activation
add_action( 'activate_plugin', array( $this, 'throw_error_on_activate_plugin' ) );
// Kick off synchronization of user role when it changes
add_action( 'set_user_role', array( $this, 'user_role_change' ) );
// Add retina images hotfix to admin
global $wp_db_version;
if ( ( $wp_db_version > 19470 ) && ( $wp_db_version < 22441 ) ) {
// WP 3.4.x
// DB Version 22441 = WP 3.5
add_action( 'admin_enqueue_scripts', array( $this, 'enqueue_retina_scripts' ) );
// /wp-admin/customize.php omits the action above.
add_action( 'customize_controls_enqueue_scripts', array( $this, 'enqueue_retina_scripts' ) );
}
}
}
function admin_body_class( $admin_body_class = '' ) {
if ( self::is_active() ) {
$admin_body_class .= ' jetpack-connected';
} else {
$admin_body_class .= ' jetpack-disconnected';
}
return $admin_body_class;
}
function prepare_connect_notice() {
add_action( 'admin_print_styles', array( $this, 'admin_styles' ) );
add_action( 'admin_notices', array( $this, 'admin_connect_notice' ) );
if ( Jetpack::state( 'network_nag' ) )
add_action( 'network_admin_notices', array( $this, 'network_connect_notice' ) );
}
/**
* Sometimes a plugin can activate without causing errors, but it will cause errors on the next page load.
* This function artificially throws errors for such cases (whitelisted).
*
* @param string $plugin The activated plugin.
*/
function throw_error_on_activate_plugin( $plugin ) {
$active_modules = Jetpack::get_active_modules();
// The Shortlinks module and the Stats plugin conflict, but won't cause errors on activation because of some function_exists() checks.
if ( function_exists( 'stats_get_api_key' ) && in_array( 'shortlinks', $active_modules ) ) {
$throw = false;
// Try and make sure it really was the stats plugin
if ( !class_exists( 'ReflectionFunction' ) ) {
if ( 'stats.php' == basename( $plugin ) ) {
$throw = true;
}
} else {
$reflection = new ReflectionFunction( 'stats_get_api_key' );
if ( basename( $plugin ) == basename( $reflection->getFileName() ) ) {
$throw = true;
}
}
if ( $throw ) {
trigger_error( sprintf( __( 'Jetpack contains the most recent version of the old “%1$s” plugin.', 'jetpack' ), 'WordPress.com Stats' ), E_USER_ERROR );
}
}
}
function intercept_plugin_error_scrape_init() {
add_action( 'check_admin_referer', array( $this, 'intercept_plugin_error_scrape' ), 10, 2 );
}
function intercept_plugin_error_scrape( $action, $result ) {
if ( !$result ) {
return;
}
foreach ( $this->plugins_to_deactivate as $module => $deactivate_me ) {
if ( "plugin-activation-error_{$deactivate_me[0]}" == $action ) {
Jetpack::bail_on_activation( sprintf( __( 'Jetpack contains the most recent version of the old “%1$s” plugin.', 'jetpack' ), $deactivate_me[1] ), false );
}
}
}
function admin_menu() {
list( $jetpack_version ) = explode( ':', Jetpack::get_option( 'version' ) );
if (
$jetpack_version
&&
$jetpack_version != JETPACK__VERSION
&&
( $new_modules = Jetpack::get_default_modules( $jetpack_version, JETPACK__VERSION ) )
&&
is_array( $new_modules )
&&
( $new_modules_count = count( $new_modules ) )
&&
( Jetpack::is_active() || Jetpack::is_development_mode() )
) {
$new_modules_count_i18n = number_format_i18n( $new_modules_count );
$span_title = esc_attr( sprintf( _n( 'One New Jetpack Module', '%s New Jetpack Modules', $new_modules_count, 'jetpack' ), $new_modules_count_i18n ) );
$title = sprintf( 'Jetpack %s', "$new_modules_count_i18n" );
} else {
$title = __( 'Jetpack', 'jetpack' );
}
$hook = add_menu_page( 'Jetpack', $title, 'read', 'jetpack', array( $this, 'admin_page' ), 'div' );
$debugger_hook = add_submenu_page( 'jetpack', 'Jetpack Debugging Center', '', 'manage_options', 'jetpack-debugger', array( $this, 'debugger_page' ) );
add_action( "admin_head-$debugger_hook", 'jetpack_debug_admin_head' );
add_action( "load-$hook", array( $this, 'admin_page_load' ) );
if ( version_compare( $GLOBALS['wp_version'], '3.3', '<' ) ) {
if ( isset( $_GET['page'] ) && 'jetpack' == $_GET['page'] ) {
add_contextual_help( $hook, $this->jetpack_help() );
}
} else {
add_action( "load-$hook", array( $this, 'admin_help' ) );
}
add_action( "admin_head-$hook", array( $this, 'admin_head' ) );
add_filter( 'custom_menu_order', array( $this, 'admin_menu_order' ) );
add_filter( 'menu_order', array( $this, 'jetpack_menu_order' ) );
add_action( "admin_print_styles-$hook", array( $this, 'admin_styles' ) );
add_action( "admin_print_scripts-$hook", array( $this, 'admin_scripts' ) );
do_action( 'jetpack_admin_menu' );
}
/*
function admin_menu_modules() {
$hook = add_submenu_page( 'jetpack', __( 'Jetpack Modules', 'jetpack' ), __( 'Modules', 'jetpack' ), 'edit_posts', 'jetpack_modules', array( $this, 'admin_page_modules' ) );
add_action( "load-$hook", array( $this, 'admin_page_load' ) );
add_action( "load-$hook", array( $this, 'admin_help' ) );
add_action( "admin_head-$hook", array( $this, 'admin_head' ) );
add_action( "admin_print_styles-$hook", array( $this, 'admin_styles' ) );
add_action( "admin_print_scripts-$hook", array( $this, 'admin_scripts' ) );
}
/**/
function add_remote_request_handlers() {
add_action( 'wp_ajax_nopriv_jetpack_upload_file', array( $this, 'remote_request_handlers' ) );
}
function remote_request_handlers() {
switch ( current_filter() ) {
case 'wp_ajax_nopriv_jetpack_upload_file' :
$response = $this->upload_handler();
break;
default :
$response = new Jetpack_Error( 'unknown_handler', 'Unknown Handler', 400 );
break;
}
if ( !$response ) {
$response = new Jetpack_Error( 'unknown_error', 'Unknown Error', 400 );
}
if ( is_wp_error( $response ) ) {
$status_code = $response->get_error_data();
$error = $response->get_error_code();
$error_description = $response->get_error_message();
if ( !is_int( $status_code ) ) {
$status_code = 400;
}
status_header( $status_code );
die( json_encode( (object) compact( 'error', 'error_description' ) ) );
}
status_header( 200 );
if ( true === $response ) {
exit;
}
die( json_encode( (object) $response ) );
}
function upload_handler() {
if ( 'POST' !== strtoupper( $_SERVER['REQUEST_METHOD'] ) ) {
return new Jetpack_Error( 405, get_status_header_desc( 405 ), 405 );
}
$user = wp_authenticate( '', '' );
if ( !$user || is_wp_error( $user ) ) {
return new Jetpack_Error( 403, get_status_header_desc( 403 ), 403 );
}
wp_set_current_user( $user->ID );
if ( !current_user_can( 'upload_files' ) ) {
return new Jetpack_Error( 'cannot_upload_files', 'User does not have permission to upload files', 403 );
}
if ( empty( $_FILES ) ) {
return new Jetpack_Error( 'no_files_uploaded', 'No files were uploaded: nothing to process', 400 );
}
foreach ( array_keys( $_FILES ) as $files_key ) {
if ( !isset( $_POST["_jetpack_file_hmac_{$files_key}"] ) ) {
return new Jetpack_Error( 'missing_hmac', 'An HMAC for one or more files is missing', 400 );
}
}
$media_keys = array_keys( $_FILES['media'] );
$token = Jetpack_Data::get_access_token( get_current_user_id() );
if ( !$token || is_wp_error( $token ) ) {
return new Jetpack_Error( 'unknown_token', 'Unknown Jetpack token', 403 );
}
$uploaded_files = array();
$global_post = isset( $GLOBALS['post'] ) ? $GLOBALS['post'] : null;
unset( $GLOBALS['post'] );
foreach ( $_FILES['media']['name'] as $index => $name ) {
$file = array();
foreach ( $media_keys as $media_key ) {
$file[$media_key] = $_FILES['media'][$media_key][$index];
}
list( $hmac_provided, $salt ) = explode( ':', $_POST['_jetpack_file_hmac_media'][$index] );
$hmac_file = hash_hmac_file( 'sha1', $file['tmp_name'], $salt . $token->secret );
if ( $hmac_provided !== $hmac_file ) {
$uploaded_files[$index] = (object) array( 'error' => 'invalid_hmac', 'error_description' => 'The corresponding HMAC for this file does not match' );
continue;
}
$_FILES['.jetpack.upload.'] = $file;
$post_id = isset( $_POST['post_id'][$index] ) ? absint( $_POST['post_id'][$index] ) : 0;
if ( !current_user_can( 'edit_post', $post_id ) ) {
$post_id = 0;
}
$attachment_id = media_handle_upload( '.jetpack.upload.', $post_id, array(), array(
'action' => 'jetpack_upload_file',
) );
if ( !$attachment_id ) {
$uploaded_files[$index] = (object) array( 'error' => 'unknown', 'error_description' => 'An unknown problem occurred processing the upload on the Jetpack site' );
} elseif ( is_wp_error( $attachment_id ) ) {
$uploaded_files[$index] = (object) array( 'error' => 'attachment_' . $attachment_id->get_error_code(), 'error_description' => $attachment_id->get_error_message() );
} else {
$attachment = get_post( $attachment_id );
$uploaded_files[$index] = (object) array(
'id' => (string) $attachment_id,
'file' => $attachment->post_title,
'url' => wp_get_attachment_url( $attachment_id ),
'type' => $attachment->post_mime_type,
'meta' => wp_get_attachment_metadata( $attachment_id ),
);
}
}
if ( !is_null( $global_post ) ) {
$GLOBALS['post'] = $global_post;
}
return $uploaded_files;
}
/**
* Add help to the Jetpack page
*
* Deprecated. Remove when Jetpack requires WP 3.3+
*/
function jetpack_help() {
return
'
' . __( 'Jetpack by WordPress.com', 'jetpack' ) . '
' .
'
' . __( 'Jetpack supercharges your self-hosted WordPress site with the awesome cloud power of WordPress.com.', 'jetpack' ) . '
' .
'
' . __( 'On this page, you are able to view the modules available within Jetpack, learn more about them, and activate or deactivate them as needed.', 'jetpack' ) . '
' .
'
' . __( 'Jetpack Module Options', 'jetpack' ) . '
' .
'
' . __( 'To Activate/Deactivate a Module - Click on Learn More. An Activate or Deactivate button will now appear next to the Learn More button. Click the Activate/Deactivate button.', 'jetpack' ) . '
';
}
/**
* Add help to the Jetpack page
*
* @since Jetpack (1.2.3)
* @return false if not the Jetpack page
*/
function admin_help() {
$current_screen = get_current_screen();
// Overview
$current_screen->add_help_tab( array(
'id' => 'overview',
'title' => __( 'Overview', 'jetpack' ),
'content' =>
'
' . __( 'Jetpack by WordPress.com', 'jetpack' ) . '
' .
'
' . __( 'Jetpack supercharges your self-hosted WordPress site with the awesome cloud power of WordPress.com.', 'jetpack' ) . '
' .
'
' . __( 'On this page, you are able to view the modules available within Jetpack, learn more about them, and activate or deactivate them as needed.', 'jetpack' ) . '
'
);
}
function admin_menu_css() { ?>
$item ) {
if ( $item != 'jetpack' )
$jp_menu_order[] = $item;
if ( $index == 0 )
$jp_menu_order[] = 'jetpack';
}
return $jp_menu_order;
}
function admin_head() {
if ( isset( $_GET['configure'] ) && Jetpack::is_module( $_GET['configure'] ) && current_user_can( 'manage_options' ) )
do_action( 'jetpack_module_configuration_head_' . $_GET['configure'] );
}
function admin_styles() {
global $wp_styles;
wp_enqueue_style( 'jetpack', plugins_url( basename( dirname( __FILE__ ) ) . '/_inc/jetpack.css' ), false, JETPACK__VERSION . '-20121016' );
$wp_styles->add_data( 'jetpack', 'rtl', true );
}
function admin_scripts() {
wp_enqueue_script( 'jetpack-js', plugins_url( basename( dirname( __FILE__ ) ) ) . '/_inc/jetpack.js', array( 'jquery' ), JETPACK__VERSION . '-20121111' );
wp_localize_script( 'jetpack-js', 'jetpackL10n', array(
'ays_disconnect' => "This will deactivate all Jetpack modules.\nAre you sure you want to disconnect?",
'ays_unlink' => "This will prevent user-specific modules such as Publicize, Notifications and Post By Email from working.\nAre you sure you want to unlink?",
'ays_dismiss' => "This will deactivate Jetpack.\nAre you sure you want to deactivate Jetpack?",
) );
add_action( 'admin_footer', array( $this, 'do_stats' ) );
}
function enqueue_retina_scripts() {
wp_enqueue_style( 'jetpack-retina', plugins_url( basename( dirname( __FILE__ ) ) . '/_inc/jetpack-retina.css' ), false, JETPACK__VERSION . '-20120730' );
}
function plugin_action_links( $actions ) {
return array_merge(
array( 'settings' => sprintf( '%s', Jetpack::admin_url(), __( 'Settings', 'jetpack' ) ) ),
$actions
);
return $actions;
}
function admin_connect_notice() {
// Don't show the connect notice on the jetpack settings page. @todo: must be a better way?
if ( false !== strpos( $_SERVER['QUERY_STRING'], 'page=jetpack' ) )
return;
if ( !current_user_can( 'manage_options' ) )
return;
?>
Your Jetpack is almost ready – A connection to WordPress.com is needed to enable features like Stats, Contact Forms, and Subscriptions. Connect now to get fueled up!', 'jetpack' ); ?>
Jetpack is installed and ready to bring awesome, WordPress.com cloud-powered features to your site.', 'jetpack' ) ?>
Jetpack is activated! Each site on your network must be connected individually by an admin on that site.', 'jetpack' ) ?>
' . sprintf(
__( 'Jetpack now includes Jetpack Comments, which enables your visitors to use their WordPress.com, Twitter, or Facebook accounts when commenting on your site. To activate Jetpack Comments, %s.', 'jetpack' ),
wp_nonce_url(
Jetpack::admin_url( array(
'page' => 'jetpack',
'action' => 'activate',
'module' => 'comments',
) ),
"jetpack_activate-comments"
),
__( 'click here', 'jetpack' )
);
}
/*
* Registration flow:
* 1 - ::admin_page_load() action=register
* 2 - ::try_registration()
* 3 - ::register()
* - Creates jetpack_register option containing two secrets and a timestamp
* - Calls https://jetpack.wordpress.com/jetpack.register/1/ with
* siteurl, home, gmt_offset, timezone_string, site_name, secret_1, secret_2, site_lang, timeout, stats_id
* - That request to jetpack.wordpress.com does not immediately respond. It first makes a request BACK to this site's
* xmlrpc.php?for=jetpack: RPC method: jetpack.verifyRegistration, Parameters: secret_1
* - The XML-RPC request verifies secret_1, deletes both secrets and responds with: secret_2
* - https://jetpack.wordpress.com/jetpack.register/1/ verifies that XML-RPC response (secret_2) then finally responds itself with
* jetpack_id, jetpack_secret, jetpack_public
* - ::register() then stores jetpack_options: id => jetpack_id, blog_token => jetpack_secret
* 4 - redirect to https://jetpack.wordpress.com/jetpack.authorize/1/
* 5 - user logs in with WP.com account
* 6 - redirect to this site's wp-admin/index.php?page=jetpack&action=authorize with
* code <-- OAuth2 style authorization code
* 7 - ::admin_page_load() action=authorize
* 8 - Jetpack_Client_Server::authorize()
* 9 - Jetpack_Client_Server::get_token()
* 10- GET https://jetpack.wordpress.com/jetpack.token/1/ with
* client_id, client_secret, grant_type, code, redirect_uri:action=authorize, state, scope, user_email, user_login
* 11- which responds with
* access_token, token_type, scope
* 12- Jetpack_Client_Server::authorize() stores jetpack_options: user_token => access_token.$user_id
* 13- Jetpack::activate_default_modules()
* Deactivates deprecated plugins
* Activates all default modules
* Catches errors: redirects to wp-admin/index.php?page=jetpack state:error=something
* 14- redirect to this site's wp-admin/index.php?page=jetpack with state:message=authorized
* Done!
*/
/**
* Handles the page load events for the Jetpack admin page
*/
function admin_page_load() {
$error = false;
if ( !empty( $_GET['jetpack_restate'] ) ) {
// Should only be used in intermediate redirects to preserve state across redirects
Jetpack::restate();
}
if ( isset( $_GET['connect_url_redirect'] ) ) {
// User clicked in the iframe to link their accounts
if ( ! Jetpack::is_user_connected() ) {
$connect_url = $this->build_connect_url( true );
if ( isset( $_GET['notes_iframe'] ) )
$connect_url .= '¬es_iframe';
wp_redirect( $connect_url );
exit;
} else {
Jetpack::state( 'message', 'already_authorized' );
wp_safe_redirect( Jetpack::admin_url() );
exit;
}
}
if ( isset( $_GET['action'] ) ) {
switch ( $_GET['action'] ) {
case 'authorize' :
if ( Jetpack::is_active() && Jetpack::is_user_connected() ) {
Jetpack::state( 'message', 'already_authorized' );
wp_safe_redirect( Jetpack::admin_url() );
exit;
}
$client_server = new Jetpack_Client_Server;
$client_server->authorize();
exit;
case 'register' :
check_admin_referer( 'jetpack-register' );
$registered = Jetpack::try_registration();
if ( is_wp_error( $registered ) ) {
$error = $registered->get_error_code();
Jetpack::state( 'error_description', $registered->get_error_message() );
break;
}
wp_redirect( $this->build_connect_url( true ) );
exit;
case 'activate' :
if ( ! current_user_can( 'activate_plugins' ) ) {
$error = 'cheatin';
break;
}
$module = stripslashes( $_GET['module'] );
check_admin_referer( "jetpack_activate-$module" );
Jetpack::activate_module( $module );
// The following two lines will rarely happen, as Jetpack::activate_module normally exits at the end.
wp_safe_redirect( Jetpack::admin_url( 'page=jetpack' ) );
exit;
case 'activate_default_modules' :
check_admin_referer( 'activate_default_modules' );
Jetpack::restate();
$min_version = isset( $_GET['min_version'] ) ? $_GET['min_version'] : false;
$max_version = isset( $_GET['max_version'] ) ? $_GET['max_version'] : false;
$other_modules = isset( $_GET['other_modules'] ) && is_array( $_GET['other_modules'] ) ? $_GET['other_modules'] : array();
Jetpack::activate_default_modules( $min_version, $max_version, $other_modules );
wp_safe_redirect( Jetpack::admin_url( 'page=jetpack' ) );
exit;
case 'disconnect' :
check_admin_referer( 'jetpack-disconnect' );
Jetpack::disconnect();
wp_safe_redirect( Jetpack::admin_url() );
exit;
case 'reconnect' :
if ( ! current_user_can( 'manage_options' ) ) {
$error = 'cheatin';
break;
}
check_admin_referer( 'jetpack-reconnect' );
$this->disconnect();
wp_redirect( $this->build_connect_url( true ) );
exit;
case 'deactivate' :
if ( ! current_user_can( 'activate_plugins' ) ) {
$error = 'cheatin';
break;
}
$modules = stripslashes( $_GET['module'] );
check_admin_referer( "jetpack_deactivate-$modules" );
foreach ( explode( ',', $modules ) as $module ) {
Jetpack::deactivate_module( $module );
Jetpack::state( 'message', 'module_deactivated' );
}
Jetpack::state( 'module', $modules );
wp_safe_redirect( Jetpack::admin_url( 'page=jetpack' ) );
exit;
case 'unlink' :
check_admin_referer( 'jetpack-unlink' );
$this->unlink_user();
Jetpack::state( 'message', 'unlinked' );
wp_safe_redirect( Jetpack::admin_url() );
exit;
}
}
if ( !$error = $error ? $error : Jetpack::state( 'error' ) ) {
$this->activate_new_modules();
}
switch ( $error ) {
case 'cheatin' :
$this->error = __( 'Cheatin’ uh?', 'jetpack' );
break;
case 'access_denied' :
$this->error = __( 'You need to authorize the Jetpack connection between your site and WordPress.com to enable the awesome features.', 'jetpack' );
break;
case 'wrong_state' :
$this->error = __( "Don’t cross the streams! You need to stay logged in to your WordPress blog while you authorize Jetpack.", 'jetpack' );
break;
case 'invalid_client' :
// @todo re-register instead of deactivate/reactivate
$this->error = __( 'Return to sender. Whoops! It looks like you got the wrong Jetpack in the mail; deactivate then reactivate the Jetpack plugin to get a new one.', 'jetpack' );
break;
case 'invalid_grant' :
$this->error = __( "Wrong size. Hm… it seems your Jetpack doesn’t quite fit. Have you lost weight? Click “Connect to WordPress.com” again to get your Jetpack adjusted.", 'jetpack' );
break;
case 'site_inaccessible' :
case 'site_requires_authorization' :
$this->error = sprintf( __( 'Your website needs to be publicly accessible to use Jetpack: %s', 'jetpack' ), "$error" );
break;
case 'module_activation_failed' :
$module = Jetpack::state( 'module' );
if ( !empty( $module ) && $mod = Jetpack::get_module( $module ) ) {
$this->error = sprintf( __( '%s could not be activated because it triggered a fatal error. Perhaps there is a conflict with another plugin you have installed?', 'jetpack' ), $mod['name'] );
if ( isset( $this->plugins_to_deactivate[$module] ) ) {
$this->error .= ' ' . sprintf( __( 'Do you still have the %s plugin installed?', 'jetpack' ), $this->plugins_to_deactivate[$module][1] );
}
} else {
$this->error = __( 'Module could not be activated because it triggered a fatal error. Perhaps there is a conflict with another plugin you have installed?', 'jetpack' );
}
if ( $php_errors = Jetpack::state( 'php_errors' ) ) {
$this->error .= " \n";
$this->error .= $php_errors;
}
break;
case 'not_public' :
$this->error = __( "Your Jetpack has a glitch. Connecting this site with WordPress.com is not possible. This usually means your site is not publicly accessible (localhost).", 'jetpack' );
break;
case 'wpcom_408' :
case 'wpcom_5??' :
case 'wpcom_bad_response' :
case 'wpcom_outage' :
$this->error = __( 'WordPress.com is currently having problems and is unable to fuel up your Jetpack. Please try again later.', 'jetpack' );
break;
case 'register_http_request_failed' :
case 'token_http_request_failed' :
$this->error = sprintf( __( 'Jetpack could not contact WordPress.com: %s. This usually means something is incorrectly configured on your web host.', 'jetpack' ), "$error" );
break;
default :
if ( empty( $error ) ) {
break;
}
$error = trim( substr( strip_tags( $error ), 0, 20 ) );
// no break: fall through
case 'no_role' :
case 'no_cap' :
case 'no_code' :
case 'no_state' :
case 'invalid_state' :
case 'invalid_request' :
case 'invalid_scope' :
case 'unsupported_response_type' :
case 'invalid_token' :
case 'no_token' :
case 'missing_secrets' :
case 'home_missing' :
case 'siteurl_missing' :
case 'gmt_offset_missing' :
case 'site_name_missing' :
case 'secret_1_missing' :
case 'secret_2_missing' :
case 'site_lang_missing' :
case 'home_malformed' :
case 'siteurl_malformed' :
case 'gmt_offset_malformed' :
case 'timezone_string_malformed' :
case 'site_name_malformed' :
case 'secret_1_malformed' :
case 'secret_2_malformed' :
case 'site_lang_malformed' :
case 'secrets_mismatch' :
case 'verify_secret_1_missing' :
case 'verify_secret_1_malformed' :
case 'verify_secrets_missing' :
case 'verify_secrets_mismatch' :
$error = esc_html( $error );
$this->error = sprintf( __( "Your Jetpack has a glitch. Something went wrong that’s never supposed to happen. Guess you’re just lucky: %s", 'jetpack' ), "$error" );
if ( !Jetpack::is_active() ) {
$this->error .= ' ';
$this->error .= sprintf( __( 'Try connecting again.', 'jetpack' ) );
}
break;
}
$message_code = Jetpack::state( 'message' );
$active_state = Jetpack::state( 'activated_modules' );
if ( !empty( $active_state ) ) {
$available = Jetpack::get_available_modules();
$active_state = explode( ',', $active_state );
$active_state = array_intersect( $active_state, $available );
if ( count( $active_state ) ) {
foreach ( $active_state as $mod ) {
$this->stat( 'module-activated', $mod );
}
} else {
$active_state = false;
}
}
switch ( $message_code ) {
case 'modules_activated' :
$this->message = sprintf(
__( 'Welcome to Jetpack %s!', 'jetpack' ),
JETPACK__VERSION
);
if ( $active_state ) {
$titles = array();
foreach ( $active_state as $mod ) {
if ( $mod_headers = Jetpack::get_module( $mod ) ) {
$titles[] = '' . preg_replace( '/\s+(?![^<>]++>)/', ' ', $mod_headers['name'] ) . '';
}
}
if ( $titles ) {
$this->message .= '
' . wp_sprintf( __( 'The following new modules have been activated: %l.', 'jetpack' ), $titles );
}
}
if ( $reactive_state = Jetpack::state( 'reactivated_modules' ) ) {
$titles = array();
foreach ( explode( ',', $reactive_state ) as $mod ) {
if ( $mod_headers = Jetpack::get_module( $mod ) ) {
$titles[] = '' . preg_replace( '/\s+(?![^<>]++>)/', ' ', $mod_headers['name'] ) . '';
}
}
if ( $titles ) {
$this->message .= '
' . wp_sprintf( __( 'The following modules have been updated: %l.', 'jetpack' ), $titles );
}
}
$this->message .= Jetpack::jetpack_comment_notice();
break;
case 'module_activated' :
if ( $module = Jetpack::get_module( Jetpack::state( 'module' ) ) ) {
$this->message = sprintf( __( '%s Activated! You can deactivate at any time by clicking Learn More and then Deactivate on the module card.', 'jetpack' ), $module['name'] );
$this->stat( 'module-activated', Jetpack::state( 'module' ) );
}
break;
case 'module_deactivated' :
$modules = Jetpack::state( 'module' );
if ( !$modules ) {
break;
}
$module_names = array();
foreach ( explode( ',', $modules ) as $module_slug ) {
$module = Jetpack::get_module( $module_slug );
if ( $module ) {
$module_names[] = $module['name'];
}
$this->stat( 'module-deactivated', $module_slug );
}
if ( !$module_names ) {
break;
}
$this->message = wp_sprintf(
_nx(
'%l Deactivated! You can activate it again at any time using the activate button on the module card.',
'%l Deactivated! You can activate them again at any time using the activate buttons on their module cards.',
count( $module_names ),
'%l = list of Jetpack module/feature names',
'jetpack'
),
$module_names
);
break;
case 'module_configured' :
$this->message = __( 'Module settings were saved. ', 'jetpack' );
break;
case 'already_authorized' :
$this->message = __( 'Your Jetpack is already connected. ', 'jetpack' );
break;
case 'authorized' :
$this->message = __( "You’re fueled up and ready to go. ", 'jetpack' );
$this->message .= " \n";
$this->message .= __( 'The features below are now active. Click the learn more buttons to explore each feature.', 'jetpack' );
$this->message .= Jetpack::jetpack_comment_notice();
break;
case 'linked' :
$this->message = __( "You’re fueled up and ready to go. ", 'jetpack' );
$this->message .= Jetpack::jetpack_comment_notice();
break;
case 'unlinked' :
$user = wp_get_current_user();
$this->message = sprintf( __( 'You have unlinked your account (%s) from WordPress.com.', 'jetpack' ), $user->user_login );
break;
}
$deactivated_plugins = Jetpack::state( 'deactivated_plugins' );
if ( !empty( $deactivated_plugins ) ) {
$deactivated_plugins = explode( ',', $deactivated_plugins );
$deactivated_titles = array();
foreach ( $deactivated_plugins as $deactivated_plugin ) {
if ( !isset( $this->plugins_to_deactivate[$deactivated_plugin] ) ) {
continue;
}
$deactivated_titles[] = '' . str_replace( ' ', ' ', $this->plugins_to_deactivate[$deactivated_plugin][1] ) . '';
}
if ( $deactivated_titles ) {
if ( $this->message ) {
$this->message .= "
\n";
}
$this->message .= wp_sprintf( _n(
'Jetpack contains the most recent version of the old %l plugin.',
'Jetpack contains the most recent versions of the old %l plugins.',
count( $deactivated_titles ),
'jetpack'
), $deactivated_titles );
$this->message .= " \n";
$this->message .= _n(
'The old version has been deactivated and can be removed from your site.',
'The old versions have been deactivated and can be removed from your site.',
count( $deactivated_titles ),
'jetpack'
);
}
}
$this->privacy_checks = Jetpack::state( 'privacy_checks' );
if ( $this->message || $this->error || $this->privacy_checks ) {
add_action( 'jetpack_notices', array( $this, 'admin_notices' ) );
}
if ( isset( $_GET['configure'] ) && Jetpack::is_module( $_GET['configure'] ) && current_user_can( 'manage_options' ) ) {
do_action( 'jetpack_module_configuration_load_' . $_GET['configure'] );
}
add_filter( 'jetpack_short_module_description', 'wptexturize' );
}
function admin_notices() {
if ( $this->error ) {
?>
';
}
function check_news_subscription() {
if ( !$this->current_user_is_connection_owner() ) {
exit;
}
Jetpack::load_xml_rpc_client();
$xml = new Jetpack_IXR_Client( array(
'user_id' => JETPACK_MASTER_USER,
) );
$xml->query( 'jetpack.checkNewsSubscription' );
if ( $xml->isError() ) {
printf( '%s: %s', $xml->getErrorCode(), $xml->getErrorMessage() );
} else {
print_r( $xml->getResponse() );
}
exit;
}
function subscribe_to_news() {
if ( !$this->current_user_is_connection_owner() ) {
exit;
}
Jetpack::load_xml_rpc_client();
$xml = new Jetpack_IXR_Client( array(
'user_id' => JETPACK_MASTER_USER,
) );
$xml->query( 'jetpack.subscribeToNews' );
if ( $xml->isError() ) {
printf( '%s: %s', $xml->getErrorCode(), $xml->getErrorMessage() );
} else {
print_r( $xml->getResponse() );
}
exit;
}
/* Client API */
/**
* Returns the requested Jetpack API URL
*
* @return string
*/
public static function api_url( $relative_url ) {
return trailingslashit( JETPACK__API_BASE . $relative_url ) . JETPACK__API_VERSION . '/';
}
/**
* Some hosts disable the OpenSSL extension and so cannot make outgoing HTTPS requsets
*/
public static function fix_url_for_bad_hosts( $url, &$args ) {
if ( 0 !== strpos( $url, 'https://' ) ) {
return $url;
}
switch ( JETPACK_CLIENT__HTTPS ) {
case 'ALWAYS' :
return $url;
case 'NEVER' :
return self::force_url_to_non_ssl( $url );
// default : case 'AUTO' :
}
$jetpack = Jetpack::init();
// Yay! Your host is good!
if ( self::permit_ssl() && wp_http_supports( array( 'ssl' => true ) ) ) {
return $url;
}
// Boo! Your host is bad and makes Jetpack cry!
return self::force_url_to_non_ssl( $url );
}
/**
* Checks to see if the URL is using SSL to connect with Jetpack
*
* @since 2.3.3
* @return boolean
*/
public static function permit_ssl( $force_recheck = false ) {
// Do some fancy tests to see if ssl is being supported
if ( $force_recheck || false === ( $ssl = get_transient( 'jetpack_https_test' ) ) ) {
if ( 'https' !== substr( JETPACK__API_BASE, 0, 5 ) ) {
$ssl = 0;
} else {
switch ( JETPACK_CLIENT__HTTPS ) {
case 'NEVER':
$ssl = 0;
break;
case 'ALWAYS':
case 'AUTO':
default:
$ssl = 1;
break;
}
// If it's not 'NEVER', test to see
if ( $ssl ) {
$response = wp_remote_get( JETPACK__API_BASE . 'test/1/' );
if ( is_wp_error( $response ) || ( 'OK' !== wp_remote_retrieve_body( $response ) ) ) {
$ssl = 0;
}
}
}
set_transient( 'jetpack_https_test', $ssl, DAY_IN_SECONDS );
}
return (bool) $ssl;
}
/**
* Take any URL, and if it starts with https:// change it to http://
*/
public static function force_url_to_non_ssl( $url ) {
return preg_replace( '#^https://#i', 'http://', $url );
}
/*
* Displays an admin_notice, alerting the user to their JETPACK_CLIENT__HTTPS constant being 'ALWAYS' but SSL isn't working.
*/
public function alert_required_ssl_fail() {
if ( ! current_user_can( 'manage_options' ) )
return;
?>
'POST',
'body' => array(
'siteurl' => site_url(),
'home' => home_url(),
'gmt_offset' => $gmt_offset,
'timezone_string' => (string) get_option( 'timezone_string' ),
'site_name' => (string) get_option( 'blogname' ),
'secret_1' => $secret_1,
'secret_2' => $secret_2,
'site_lang' => get_locale(),
'timeout' => $timeout,
'stats_id' => $stats_id,
),
'headers' => array(
'Accept' => 'application/json',
),
'timeout' => $timeout,
);
$response = Jetpack_Client::_wp_remote_request( Jetpack::fix_url_for_bad_hosts( Jetpack::api_url( 'register' ), $args ), $args, true );
if ( is_wp_error( $response ) ) {
return new Jetpack_Error( 'register_http_request_failed', $response->get_error_message() );
}
$code = wp_remote_retrieve_response_code( $response );
$entity = wp_remote_retrieve_body( $response );
if ( $entity )
$json = json_decode( $entity );
else
$json = false;
$code_type = intval( $code / 100 );
if ( 5 == $code_type ) {
return new Jetpack_Error( 'wpcom_5??', sprintf( __( 'Error Details: %s', 'jetpack' ), $code ), $code );
} elseif ( 408 == $code ) {
return new Jetpack_Error( 'wpcom_408', sprintf( __( 'Error Details: %s', 'jetpack' ), $code ), $code );
} elseif ( !empty( $json->error ) ) {
$error_description = isset( $json->error_description ) ? sprintf( __( 'Error Details: %s', 'jetpack' ), (string) $json->error_description ) : '';
return new Jetpack_Error( (string) $json->error, $error_description, $code );
} elseif ( 200 != $code ) {
return new Jetpack_Error( 'wpcom_bad_response', sprintf( __( 'Error Details: %s', 'jetpack' ), $code ), $code );
}
// Jetpack ID error block
if ( empty( $json->jetpack_id ) ) {
return new Jetpack_Error( 'jetpack_id', sprintf( __( 'Error Details: Jetpack ID is empty. Do not publicly post this error message! %s', 'jetpack' ), $entity ), $entity );
} elseif ( ! is_scalar( $json->jetpack_id ) ) {
return new Jetpack_Error( 'jetpack_id', sprintf( __( 'Error Details: Jetpack ID is not a scalar. Do not publicly post this error message! %s', 'jetpack' ) , $entity ), $entity );
} elseif ( preg_match( '/[^0-9]/', $json->jetpack_id ) ) {
return new Jetpack_Error( 'jetpack_id', sprintf( __( 'Error Details: Jetpack ID begins with a numeral. Do not publicly post this error message! %s', 'jetpack' ) , $entity ), $entity);
}
if ( empty( $json->jetpack_secret ) || !is_string( $json->jetpack_secret ) )
return new Jetpack_Error( 'jetpack_secret', '', $code );
if ( isset( $json->jetpack_public ) ) {
$jetpack_public = (int) $json->jetpack_public;
} else {
$jetpack_public = false;
}
Jetpack::update_options( array(
'id' => (int) $json->jetpack_id,
'blog_token' => (string) $json->jetpack_secret,
'public' => $jetpack_public,
) );
return true;
}
/* Client Server API */
/**
* Loads the Jetpack XML-RPC client
*/
public static function load_xml_rpc_client() {
require_once ABSPATH . WPINC . '/class-IXR.php';
require_once dirname( __FILE__ ) . '/class.jetpack-ixr-client.php';
}
/**
* Authenticates XML-RPC and other requests from the Jetpack Server
*/
function authenticate_jetpack( $user, $username, $password ) {
if ( is_a( $user, 'WP_User' ) ) {
return $user;
}
// It's not for us
if ( !isset( $_GET['token'] ) || empty( $_GET['signature'] ) ) {
return $user;
}
@list( $token_key, $version, $user_id ) = explode( ':', $_GET['token'] );
if (
empty( $token_key )
||
empty( $version ) || strval( JETPACK__API_VERSION ) !== $version
||
empty( $user_id ) || !ctype_digit( $user_id ) || !get_userdata( $user_id ) // only handle user_tokens for now, not blog_tokens
) {
return $user;
}
$token = Jetpack_Data::get_access_token( $user_id );
if ( !$token ) {
return $user;
}
if ( 0 !== strpos( $token->secret, "$token_key." ) ) {
return $user;
}
require_once dirname( __FILE__ ) . '/class.jetpack-signature.php';
$jetpack_signature = new Jetpack_Signature( $token->secret, (int) Jetpack::get_option( 'time_diff' ) );
if ( isset( $_POST['_jetpack_is_multipart'] ) ) {
$post_data = $_POST;
$file_hashes = array();
foreach ( $post_data as $post_data_key => $post_data_value ) {
if ( 0 !== strpos( $post_data_key, '_jetpack_file_hmac_' ) ) {
continue;
}
$post_data_key = substr( $post_data_key, strlen( '_jetpack_file_hmac_' ) );
$file_hashes[$post_data_key] = $post_data_value;
}
foreach ( $file_hashes as $post_data_key => $post_data_value ) {
unset( $post_data["_jetpack_file_hmac_{$post_data_key}"] );
$post_data[$post_data_key] = $post_data_value;
}
ksort( $post_data );
$body = http_build_query( stripslashes_deep( $post_data ) );
} elseif ( is_null( $this->HTTP_RAW_POST_DATA ) ) {
$body = file_get_contents( 'php://input' );
} else {
$body = null;
}
$signature = $jetpack_signature->sign_current_request( array(
'body' => is_null( $body ) ? $this->HTTP_RAW_POST_DATA : $body
) );
if ( !$signature ) {
return $user;
} else if ( is_wp_error( $signature ) ) {
return $signature;
} else if ( $signature !== $_GET['signature'] ) {
return $user;
}
$timestamp = (int) $_GET['timestamp'];
$nonce = stripslashes( (string) $_GET['nonce'] );
if ( !$this->add_nonce( $timestamp, $nonce ) ) {
return $user;
}
nocache_headers();
return new WP_User( $token->external_user_id );
}
function add_nonce( $timestamp, $nonce ) {
global $wpdb;
static $nonces_used_this_request = array();
if ( isset( $nonces_used_this_request["$timestamp:$nonce"] ) ) {
return $nonces_used_this_request["$timestamp:$nonce"];
}
// This should always have gone through Jetpack_Signature::sign_request() first to check $timestamp an $nonce
$timestamp = (int) $timestamp;
$nonce = $wpdb->escape( $nonce );
// Raw query so we can avoid races: add_option will also update
$show_errors = $wpdb->show_errors( false );
$return = $wpdb->query( $wpdb->prepare(
"INSERT INTO `$wpdb->options` (`option_name`, `option_value`, `autoload`) VALUES (%s, %s, %s)",
"jetpack_nonce_{$timestamp}_{$nonce}",
time(),
'no'
) );
$wpdb->show_errors( $show_errors );
$nonces_used_this_request["$timestamp:$nonce"] = $return;
return $return;
}
/**
* In some setups, $HTTP_RAW_POST_DATA can be emptied during some IXR_Server paths since it is passed by reference to various methods.
* Capture it here so we can verify the signature later.
*/
function xmlrpc_methods( $methods ) {
$this->HTTP_RAW_POST_DATA = $GLOBALS['HTTP_RAW_POST_DATA'];
return $methods;
}
function xmlrpc_options( $options ) {
$options['jetpack_version'] = array(
'desc' => __( 'Jetpack Plugin Version' , 'jetpack'),
'readonly' => true,
'value' => JETPACK__VERSION,
);
$options['jetpack_client_id'] = array(
'desc' => __( 'The Client ID/WP.com Blog ID of this site' , 'jetpack'),
'readonly' => true,
'value' => Jetpack::get_option( 'id' ),
);
return $options;
}
public static function clean_nonces( $all = false ) {
global $wpdb;
$sql = "DELETE FROM `$wpdb->options` WHERE `option_name` LIKE %s";
$sql_args = array( like_escape( 'jetpack_nonce_' ) . '%' );
if ( true !== $all ) {
$sql .= ' AND CAST( `option_value` AS UNSIGNED ) < %d';
$sql_args[] = time() - 3600;
}
$sql .= ' LIMIT 100';
$sql = $wpdb->prepare( $sql, $sql_args );
for ( $i = 0; $i < 1000; $i++ ) {
if ( !$wpdb->query( $sql ) ) {
break;
}
}
}
/**
* State is passed via cookies from one request to the next, but never to subsequent requests.
* SET: state( $key, $value );
* GET: $value = state( $key );
*
* @param string $key
* @param string $value
* @param bool $restate private
*/
public static function state( $key = null, $value = null, $restate = false ) {
static $state = array();
static $path, $domain;
if ( !isset( $path ) ) {
require_once( ABSPATH . 'wp-admin/includes/plugin.php' );
$admin_url = Jetpack::admin_url();
$bits = parse_url( $admin_url );
if ( is_array( $bits ) ) {
$path = ( isset( $bits['path'] ) ) ? dirname( $bits['path'] ) : null;
$domain = ( isset( $bits['host'] ) ) ? $bits['host'] : null;
} else {
$path = $domain = null;
}
}
// Extract state from cookies and delete cookies
if ( isset( $_COOKIE[ 'jetpackState' ] ) && is_array( $_COOKIE[ 'jetpackState' ] ) ) {
$yum = $_COOKIE[ 'jetpackState' ];
unset( $_COOKIE[ 'jetpackState' ] );
foreach ( $yum as $k => $v ) {
if ( strlen( $v ) )
$state[ $k ] = $v;
setcookie( "jetpackState[$k]", false, 0, $path, $domain );
}
}
if ( $restate ) {
foreach ( $state as $k => $v ) {
setcookie( "jetpackState[$k]", $v, 0, $path, $domain );
}
return;
}
// Get a state variable
if ( isset( $key ) && !isset( $value ) ) {
if ( array_key_exists( $key, $state ) )
return $state[ $key ];
return null;
}
// Set a state variable
if ( isset ( $key ) && isset( $value ) ) {
$state[ $key ] = $value;
setcookie( "jetpackState[$key]", $value, 0, $path, $domain );
}
}
public static function restate() {
Jetpack::state( null, null, true );
}
public static function check_privacy( $file ) {
static $is_site_publicly_accessible = null;
if ( is_null( $is_site_publicly_accessible ) ) {
$is_site_publicly_accessible = false;
Jetpack::load_xml_rpc_client();
$rpc = new Jetpack_IXR_Client();
$success = $rpc->query( 'jetpack.isSitePubliclyAccessible', home_url() );
if ( $success ) {
$response = $rpc->getResponse();
if ( $response ) {
$is_site_publicly_accessible = true;
}
}
Jetpack::update_option( 'public', (int) $is_site_publicly_accessible );
}
if ( $is_site_publicly_accessible ) {
return;
}
$module_slug = self::get_module_slug( $file );
$privacy_checks = Jetpack::state( 'privacy_checks' );
if ( !$privacy_checks ) {
$privacy_checks = $module_slug;
} else {
$privacy_checks .= ",$module_slug";
}
Jetpack::state( 'privacy_checks', $privacy_checks );
}
/**
* Helper method for multicall XMLRPC.
*/
public static function xmlrpc_async_call() {
global $blog_id;
static $clients = array();
$client_blog_id = is_multisite() ? $blog_id : 0;
if ( !isset( $clients[$client_blog_id] ) ) {
Jetpack::load_xml_rpc_client();
$clients[$client_blog_id] = new Jetpack_IXR_ClientMulticall( array(
'user_id' => JETPACK_MASTER_USER,
) );
ignore_user_abort( true );
add_action( 'shutdown', array( 'Jetpack', 'xmlrpc_async_call' ) );
}
$args = func_get_args();
if ( !empty( $args[0] ) ) {
call_user_func_array( array( $clients[$client_blog_id], 'addCall' ), $args );
} elseif ( is_multisite() ) {
foreach ( $clients as $client_blog_id => $client ) {
if ( !$client_blog_id || empty( $client->calls ) ) {
continue;
}
$switch_success = switch_to_blog( $client_blog_id, true );
if ( !$switch_success ) {
continue;
}
flush();
$client->query();
restore_current_blog();
}
} else {
if ( isset( $clients[0] ) && !empty( $clients[0]->calls ) ) {
flush();
$clients[0]->query();
}
}
}
public static function staticize_subdomain( $url ) {
$host = parse_url( $url, PHP_URL_HOST );
if ( !preg_match( '/.?(?:wordpress|wp)\.com$/', $host ) ) {
return $url;
}
if ( is_ssl() ) {
return preg_replace( '|https?://[^/]++/|', 'https://s-ssl.wordpress.com/', $url );
}
srand( crc32( basename( $url ) ) );
$static_counter = rand( 0, 2 );
srand(); // this resets everything that relies on this, like array_rand() and shuffle()
return preg_replace( '|://[^/]+?/|', "://s$static_counter.wp.com/", $url );
}
/* JSON API Authorization */
/**
* Handles the login action for Authorizing the JSON API
*/
function login_form_json_api_authorization() {
$this->verify_json_api_authorization_request();
add_action( 'wp_login', array( &$this, 'store_json_api_authorization_token' ), 10, 2 );
add_action( 'login_message', array( &$this, 'login_message_json_api_authorization' ) );
add_action( 'login_form', array( &$this, 'preserve_action_in_login_form_for_json_api_authorization' ) );
add_filter( 'site_url', array( &$this, 'post_login_form_to_signed_url' ), 10, 3 );
}
// Make sure the login form is POSTed to the signed URL so we can reverify the request
function post_login_form_to_signed_url( $url, $path, $scheme ) {
if ( 'wp-login.php' !== $path || 'login_post' !== $scheme ) {
return $url;
}
return "$url?{$_SERVER['QUERY_STRING']}";
}
// Make sure the POSTed request is handled by the same action
function preserve_action_in_login_form_for_json_api_authorization() {
echo "\n";
}
// If someone logs in to approve API access, store the Access Code in usermeta
function store_json_api_authorization_token( $user_login, $user ) {
add_filter( 'login_redirect', array( &$this, 'add_token_to_login_redirect_json_api_authorization' ), 10, 3 );
add_filter( 'allowed_redirect_hosts', array( &$this, 'allow_wpcom_public_api_domain' ) );
$token = wp_generate_password( 32, false );
update_user_meta( $user->ID, 'jetpack_json_api_' . $this->json_api_authorization_request['client_id'], $token );
}
// Add public-api.wordpress.com to the safe redirect whitelist - only added when someone allows API access
function allow_wpcom_public_api_domain( $domains ) {
$domains[] = 'public-api.wordpress.com';
return $domains;
}
// Add the Access Code details to the public-api.wordpress.com redirect
function add_token_to_login_redirect_json_api_authorization( $redirect_to, $original_redirect_to, $user ) {
return add_query_arg( urlencode_deep( array(
'jetpack-code' => get_user_meta( $user->ID, 'jetpack_json_api_' . $this->json_api_authorization_request['client_id'], true ),
'jetpack-user-id' => (int) $user->ID,
'jetpack-state' => $this->json_api_authorization_request['state'],
) ), $redirect_to );
}
// Verifies the request by checking the signature
function verify_json_api_authorization_request() {
require_once dirname( __FILE__ ) . '/class.jetpack-signature.php';
$token = Jetpack_Data::get_access_token( JETPACK_MASTER_USER );
if ( !$token || empty( $token->secret ) ) {
wp_die( __( 'You must connect your Jetpack plugin to WordPress.com to use this feature.' , 'jetpack') );
}
$die_error = __( 'Someone may be trying to trick you into giving them access to your site. Or it could be you just encountered a bug :). Either way, please close this window.', 'jetpack' );
$jetpack_signature = new Jetpack_Signature( $token->secret, (int) Jetpack::get_option( 'time_diff' ) );
$signature = $jetpack_signature->sign_current_request( array( 'body' => null, 'method' => 'GET' ) );
if ( !$signature ) {
wp_die( $die_error );
} else if ( is_wp_error( $signature ) ) {
wp_die( $die_error );
} else if ( $signature !== $_GET['signature'] ) {
if ( is_ssl() ) {
// If we signed an HTTP request on the Jetpack Servers, but got redirected to HTTPS by the local blog, check the HTTP signature as well
$signature = $jetpack_signature->sign_current_request( array( 'scheme' => 'http', 'body' => null, 'method' => 'GET' ) );
if ( !$signature || is_wp_error( $signature ) || $signature !== $_GET['signature'] ) {
wp_die( $die_error );
}
} else {
wp_die( $die_error );
}
}
$timestamp = (int) $_GET['timestamp'];
$nonce = stripslashes( (string) $_GET['nonce'] );
if ( !$this->add_nonce( $timestamp, $nonce ) ) {
// De-nonce the nonce, at least for 5 minutes.
// We have to reuse this nonce at least once (used the first time when the initial request is made, used a second time when the login form is POSTed)
$old_nonce_time = get_option( "jetpack_nonce_{$timestamp}_{$nonce}" );
if ( $old_nonce_time < time() - 300 ) {
wp_die( __( 'The authorization process expired. Please go back and try again.' , 'jetpack') );
}
}
$data = json_decode( base64_decode( stripslashes( $_GET['data'] ) ) );
$data_filters = array(
'state' => 'opaque',
'client_id' => 'int',
'client_title' => 'string',
'client_image' => 'url',
);
foreach ( $data_filters as $key => $sanitation ) {
if ( !isset( $data->$key ) ) {
wp_die( $die_error );
}
switch ( $sanitation ) {
case 'int' :
$this->json_api_authorization_request[$key] = (int) $data->$key;
break;
case 'opaque' :
$this->json_api_authorization_request[$key] = (string) $data->$key;
break;
case 'string' :
$this->json_api_authorization_request[$key] = wp_kses( (string) $data->$key, array() );
break;
case 'url' :
$this->json_api_authorization_request[$key] = esc_url_raw( (string) $data->$key );
break;
}
}
if ( empty( $this->json_api_authorization_request['client_id'] ) ) {
wp_die( $die_error );
}
}
function login_message_json_api_authorization( $message ) {
return '
' . sprintf(
esc_html__( '%s wants to access your site’s data. Log in to authorize that access.' , 'jetpack'),
'' . esc_html( $this->json_api_authorization_request['client_title'] ) . ''
) . '
';
}
/**
* Get $content_width, but with a twist filter.
*/
public static function get_content_width() {
return apply_filters( 'jetpack_content_width', $GLOBALS['content_width'] );
}
/**
* Centralize the function here until it gets added to core.
*
* @param int|string|object $id_or_email A user ID, email address, or comment object
* @param int $size Size of the avatar image
* @param string $default URL to a default image to use if no avatar is available
* @param bool $force_display Whether to force it to return an avatar even if show_avatars is disabled
*
* @return array First element is the URL, second is the class.
*/
public static function get_avatar_url( $id_or_email, $size = 96, $default = '', $force_display = false ) {
// Don't bother adding the __return_true filter if it's already there.
$has_filter = has_filter( 'pre_option_show_avatars', '__return_true' );
if ( $force_display && ! $has_filter )
add_filter( 'pre_option_show_avatars', '__return_true' );
$avatar = get_avatar( $id_or_email, $size, $default );
if ( $force_display && ! $has_filter )
remove_filter( 'pre_option_show_avatars', '__return_true' );
// If no data, fail out.
if ( is_wp_error( $avatar ) || ! $avatar )
return array( null, null );
// Pull out the URL. If it's not there, fail out.
if ( ! preg_match( '/src=["\']([^"\']+)["\']/', $avatar, $url_matches ) )
return array( null, null );
$url = wp_specialchars_decode( $url_matches[1], ENT_QUOTES );
// Pull out the class, but it's not a big deal if it's missing.
$class = '';
if ( preg_match( '/class=["\']([^"\']+)["\']/', $avatar, $class_matches ) )
$class = wp_specialchars_decode( $class_matches[1], ENT_QUOTES );
return array( $url, $class );
}
/*
* Pings the WordPress.com Mirror Site for the specified options.
*
* @param string|array $option_names The option names to request from the WordPress.com Mirror Site
*
* @return array An associative array of the option values as stored in the WordPress.com Mirror Site
*/
public static function get_cloud_site_options( $option_names ) {
$option_names = array_filter( (array) $option_names, 'is_string' );
Jetpack::load_xml_rpc_client();
$xml = new Jetpack_IXR_Client( array(
'user_id' => get_current_user_id(),
) );
$xml->query( 'jetpack.fetchSiteOptions', $option_names );
if ( $xml->isError() ) {
return array_flip( $option_names );
}
$cloud_site_options = $xml->getResponse();
// If we want to intentionally jumble the results to test it ...
if( isset( $_GET['spoof_identity_crisis'] ) ) {
foreach( $cloud_site_options as $key => $value ) {
$cloud_site_options[ $key ] = wp_generate_password();
}
}
return $cloud_site_options;
}
/*
* Checks to make sure that local options have the same values as remote options. Will cache the results for up to 24 hours.
*
* @param bool $force_recheck Whether to ignore any cached transient and manually re-check.
*
* @return array An array of options that do not match. If everything is good, it will evaluate to false.
*/
public static function check_identity_crisis( $force_recheck = false ) {
if ( ! current_user_can( 'manage_options' ) )
return false;
if ( ! Jetpack::is_active() || Jetpack::is_development_mode() )
return false;
if ( isset( $_GET['spoof_identity_crisis'] ) )
$force_recheck = true;
if ( $force_recheck || false === ( $errors = get_transient( 'jetpack_has_identity_crisis' ) ) ) {
$options_to_check = array(
'siteurl',
'home',
);
$cloud_options = self::get_cloud_site_options( $options_to_check );
$errors = array();
foreach ( $cloud_options as $cloud_key => $cloud_value ) {
if ( $cloud_value !== get_option( $cloud_key ) ) {
$errors[ $cloud_key ] = $cloud_value;
}
}
// Make sure if we're spoofing it, that we don't let the spoof spill over.
if ( ! isset( $_GET['spoof_identity_crisis'] ) ) {
set_transient( 'jetpack_has_identity_crisis', $errors, DAY_IN_SECONDS );
}
}
return apply_filters( 'jetpack_has_identity_crisis', $errors, $force_recheck );
}
/*
* Displays an admin_notice, alerting the user to an identity crisis.
*/
public function alert_identity_crisis() {
if ( ! current_user_can( 'manage_options' ) )
return;
if ( ! $errors = self::check_identity_crisis() )
return;
?>
$value ) : ?>
%1$s option is set up as %2$s, but your WordPress.com connection lists it as %3$s!', 'jetpack' ), $key, (string) get_option( $key ), $value ); ?>
 ); ?>){kind=small}