' . __( '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' ) . '
' .
'' . __( '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' ) . '
' .
'' . __( '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' ) . '
'
) );
// Screen Content
$current_screen->add_help_tab( array(
'id' => 'modules',
'title' => __( 'Modules', 'jetpack' ),
'content' =>
'' . __( 'You can activate or deactivate individual Jetpack modules to suit your needs.', 'jetpack' ) . '
' .
'
'deactivate',
'module' => $module
) ),
"jetpack_deactivate-$module"
);
} else {
$css = 'inactive';
$toggle = __( 'Activate', 'jetpack' );
$toggle_url = wp_nonce_url(
Jetpack::admin_url( array(
'action' => 'activate',
'module' => $module
) ),
"jetpack_activate-$module"
);
}
$file = Jetpack::get_module_path( $module );
$png = str_replace( '.php', '.png', $file );
if ( is_readable( dirname( __FILE__ ) . '/_inc/images/icons/' . basename( $png ) ) )
$module_img = plugins_url( basename( dirname( __FILE__ ) ) . '/_inc/images/icons/' . basename( $png ) );
else
$module_img = plugins_url( basename( dirname( __FILE__ ) ) . '/_inc/images/module-blank.png' );
if ( $counter % 4 == 0 ) {
$classes = $css . ' jetpack-newline';
$counter = 0;
} else {
$classes = $css;
}
$free_text = esc_html( $module_data['free'] ? __( 'Free', 'jetpack' ) : __( 'Purchase', 'jetpack' ) );
$free_text = apply_filters( 'jetpack_module_free_text_' . $module, $free_text );
$badge_text = $free_text;
if ( !$jetpack_connected ) {
$classes = 'x disabled';
} else if ( $jetpack_version_time + 604800 > $now ) { // 1 week
if ( version_compare( $module_data['introduced'], $jetpack_old_version, '>' ) ) {
$badge_text = esc_html__( 'New', 'jetpack' );
$classes .= ' jetpack-new-module';
} elseif ( isset( $module_data['changed'] ) && version_compare( $module_data['changed'], $jetpack_old_version, '>' ) ) {
$badge_text = esc_html__( 'Updated', 'jetpack' );
$classes .= ' jetpack-updated-module';
} else {
$badge_text = $free_text;
}
}
?>
' . __( 'Configure', 'jetpack' ) . '';
}
?>
8 - $counter ) echo ' style="display: none;"'; ?>>
';
}
function check_news_subscription() {
if ( !$this->current_user_is_connection_owner() ) {
exit;
}
$this->load_xml_rpc_client();
$xml = new Jetpack_IXR_Client( array(
'user_id' => $GLOBALS['current_user']->ID
) );
$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;
}
$this->load_xml_rpc_client();
$xml = new Jetpack_IXR_Client( array(
'user_id' => $GLOBALS['current_user']->ID
) );
$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
*
* @static
* @return string
*/
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
*/
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 substr_replace( $url, '', 4, 1 );
// default : case 'AUTO' :
}
$jetpack = Jetpack::init();
// Yay! Your host is good!
if ( wp_http_supports( array( 'ssl' => true ) ) ) {
return $url;
}
// Boo! Your host is bad and makes Jetpack cry!
return substr_replace( $url, '', 4, 1 );
}
/**
* Returns the Jetpack XML-RPC API
*
* @static
* @return string
*/
function xmlrpc_api_url() {
$base = preg_replace( '#(https?://[^?/]+)(/?.*)?$#', '\\1', JETPACK__API_BASE );
return untrailingslashit( $base ) . '/xmlrpc.php';
}
/**
* @static
* @return bool|WP_Error
*/
function register() {
Jetpack::update_option( 'register', wp_generate_password( 32, false ) . ':' . wp_generate_password( 32, false ) . ':' . ( time() + 600 ) );
@list( $secret_1, $secret_2, $secret_eol ) = explode( ':', Jetpack::get_option( 'register' ) );
if ( empty( $secret_1 ) || empty( $secret_2 ) || empty( $secret_eol ) || $secret_eol < time() )
return new Jetpack_Error( 'missing_secrets' );
$timeout = (int) ini_get( 'max_execution_time' );
if ( !$timeout )
$timeout = 30;
$timeout = intval( $timeout / 2 );
$gmt_offset = get_option( 'gmt_offset' );
if ( !$gmt_offset ) {
$gmt_offset = 0;
}
$stats_options = get_option( 'stats_options' );
$stats_id = isset($stats_options['blog_id']) ? $stats_options['blog_id'] : null;
$args = array(
'method' => '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 );
}
if ( empty( $json->jetpack_id ) || !is_scalar( $json->jetpack_id ) || preg_match( '/[^0-9]/', $json->jetpack_id ) )
return new Jetpack_Error( 'jetpack_id', '', $code );
if ( empty( $json->jetpack_secret ) || !is_string( $json->jetpack_secret ) )
return new Jetpack_Error( 'jetpack_secret', '', $code );
Jetpack::update_options( array(
'id' => (int) $json->jetpack_id,
'blog_token' => (string) $json->jetpack_secret,
) );
return true;
}
/* Client Server API */
/**
* Loads the Jetpack XML-RPC client
*/
function load_xml_rpc_client() {
require_once ABSPATH . WPINC . '/class-IXR.php';
require_once dirname( __FILE__ ) . '/class.jetpack-ixr-client.php';
}
/**
* Authenticates XML-RPC requests from the Jetpack Server
*
* We don't actually know who the real user is; we set it to the account that created the connection.
*/
function authenticate_xml_rpc( $user, $username, $password ) {
if ( is_a( $user, 'WP_User' ) ) {
return $user;
}
// It's not for us
if ( !isset( $_GET['for'] ) || 'jetpack' != $_GET['for'] || !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' ) );
$signature = $jetpack_signature->sign_current_request( array( 'body' => $this->HTTP_RAW_POST_DATA ) );
if ( !$signature ) {
return $user;
} else if ( is_wp_error( $signature ) ) {
return $signature;
} else if ( $signature !== $_GET['signature'] ) {
return $user;
}
if ( !$this->add_nonce( $_GET['timestamp'], $_GET['nonce'] ) ) {
return $user;
}
nocache_headers();
return new WP_User( $token->external_user_id );
}
function add_nonce( $timestamp, $nonce ) {
global $wpdb;
// This should always have gone through Jetpack_Signature::sign_request() first to check $timestamp an $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 );
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 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;
}
$wpdb->query( $wpdb->prepare( $sql, $sql_args ) );
}
/**
* 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
*
* @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 );
}
}
/**
* @static
*/
function restate() {
Jetpack::state( null, null, true );
}
/**
* Helper method for multicall XMLRPC.
*/
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' => get_current_user_id()
) );
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();
}
}
}
function staticize_subdomain( $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 );
}
}
class Jetpack_Client {
/**
* Makes an authorized remote request using Jetpack_Signature
*
* @static
* @return array|WP_Error WP HTTP response on success
*/
function remote_request( $args, $body = null ) {
$defaults = array(
'url' => '',
'user_id' => 0,
'blog_id' => 0,
'auth_location' => JETPACK_CLIENT__AUTH_LOCATION,
'method' => 'POST',
'timeout' => 10,
'redirection' => 0,
);
$args = wp_parse_args( $args, $defaults );
$args['user_id'] = (int) $args['user_id'];
$args['blog_id'] = (int) $args['blog_id'];
if ( 'header' != $args['auth_location'] ) {
$args['auth_location'] = 'query_string';
}
$token = Jetpack_Data::get_access_token( $args );
if ( !$token ) {
return new Jetpack_Error( 'missing_token' );
}
$method = strtoupper( $args['method'] );
$timeout = intval( $args['timeout'] );
$redirection = $args['redirection'];
$request = compact( 'method', 'body', 'timeout', 'redirection' );
@list( $token_key, $secret ) = explode( '.', $token->secret );
if ( empty( $token ) || empty( $secret ) ) {
return new Jetpack_Error( 'malformed_token' );
}
$token_key = sprintf( '%s:%d:%d', $token_key, JETPACK__API_VERSION, $token->external_user_id );
require_once dirname( __FILE__ ) . '/class.jetpack-signature.php';
$time_diff = (int) Jetpack::get_option( 'time_diff' );
$jetpack_signature = new Jetpack_Signature( $token->secret, $time_diff );
$timestamp = time() + $time_diff;
$nonce = wp_generate_password( 10, false );
// Kind of annoying. Maybe refactor Jetpack_Signature to handle body-hashing
if ( is_null( $body ) ) {
$body_hash = '';
} else {
if ( !is_string( $body ) ) {
return new Jetpack_Error( 'invalid_body', 'Body is malformed.' );
}
$body_hash = jetpack_sha1_base64( $body );
}
$auth = array(
'token' => $token_key,
'timestamp' => $timestamp,
'nonce' => $nonce,
'body-hash' => $body_hash,
);
if ( false !== strpos( $args['url'], 'xmlrpc.php' ) ) {
$url_args = array( 'for' => 'jetpack' );
} else {
$url_args = array();
}
if ( 'header' != $args['auth_location'] ) {
$url_args += $auth;
}
$url = add_query_arg( urlencode_deep( $url_args ), $args['url'] );
$url = Jetpack::fix_url_for_bad_hosts( $url, $request );
$signature = $jetpack_signature->sign_request( $token_key, $timestamp, $nonce, $body_hash, $method, $url, $body, false );
if ( !$signature || is_wp_error( $signature ) ) {
return $signature;
}
// Send an Authorization header so various caches/proxies do the right thing
$auth['signature'] = $signature;
$auth['version'] = JETPACK__VERSION;
$header_pieces = array();
foreach ( $auth as $key => $value ) {
$header_pieces[] = sprintf( '%s="%s"', $key, $value );
}
$request['headers'] = array(
'Authorization' => "X_JETPACK " . join( ' ', $header_pieces ),
);
if ( 'header' != $args['auth_location'] ) {
$url = add_query_arg( 'signature', urlencode( $signature ), $url );
}
return Jetpack_Client::_wp_remote_request( $url, $request );
}
/**
* Wrapper for wp_remote_request(). Turns off SSL verification for certain SSL errors.
* This is lame, but many, many, many hosts have misconfigured SSL.
*
* When Jetpack is registered, the jetpack_fallback_no_verify_ssl_certs option is set to the current time if:
* 1. a certificate error is found AND
* 2. not verifying the certificate works around the problem.
*
* The option is checked on each request.
*
* @internal
* @todo: Better fallbacks (bundled certs?), feedback, UI, ....
* @see Jetpack::fix_url_for_bad_hosts()
*
* @static
* @return array|WP_Error WP HTTP response on success
*/
function _wp_remote_request( $url, $args, $set_fallback = false ) {
$fallback = Jetpack::get_option( 'fallback_no_verify_ssl_certs' );
if ( false === $fallback ) {
Jetpack::update_option( 'fallback_no_verify_ssl_certs', 0 );
}
if ( (int) $fallback ) {
// We're flagged to fallback
$args['sslverify'] = false;
}
$response = wp_remote_request( $url, $args );
if (
!$set_fallback // We're not allowed to set the flag on this request, so whatever happens happens
||
isset( $args['sslverify'] ) && !$args['sslverify'] // No verification - no point in doing it again
||
!is_wp_error( $response ) // Let it ride
) {
Jetpack_Client::set_time_diff( $response, $set_fallback );
return $response;
}
// At this point, we're not flagged to fallback and we are allowed to set the flag on this request.
$message = $response->get_error_message();
// Is it an SSL Certificate verification error?
if (
false === strpos( $message, '14090086' ) // OpenSSL SSL3 certificate error
&&
false === strpos( $message, '1407E086' ) // OpenSSL SSL2 certificate error
&&
false === strpos( $message, 'error setting certificate verify locations' ) // cURL CA bundle not found
&&
false === strpos( $message, 'Peer certificate cannot be authenticated with' ) // cURL CURLE_SSL_CACERT: CA bundle found, but not helpful
// different versions of curl have different error messages
// this string should catch them all
&&
false === strpos( $message, 'Problem with the SSL CA cert' ) // cURL CURLE_SSL_CACERT_BADFILE: probably access rights
) {
// No, it is not.
return $response;
}
// Redo the request without SSL certificate verification.
$args['sslverify'] = false;
$response = wp_remote_request( $url, $args );
if ( !is_wp_error( $response ) ) {
// The request went through this time, flag for future fallbacks
Jetpack::update_option( 'fallback_no_verify_ssl_certs', time() );
Jetpack_Client::set_time_diff( $response, $set_fallback );
}
return $response;
}
function set_time_diff( &$response, $force_set = false ) {
$code = wp_remote_retrieve_response_code( $response );
// Only trust the Date header on some responses
if ( 200 != $code && 304 != $code && 400 != $code && 401 != $code ) {
return;
}
if ( !$date = wp_remote_retrieve_header( $response, 'date' ) ) {
return;
}
if ( 0 >= $time = (int) strtotime( $date ) ) {
return;
}
$time_diff = $time - time();
if ( $force_set ) { // during register
Jetpack::update_option( 'time_diff', $time_diff );
} else { // otherwise
$old_diff = Jetpack::get_option( 'time_diff' );
if ( false === $old_diff || abs( $time_diff - (int) $old_diff ) > 10 ) {
Jetpack::update_option( 'time_diff', $time_diff );
}
}
}
}
class Jetpack_Data {
/**
* Gets locally stored token
*
* @static
* @return object|false
*/
function get_access_token( $args ) {
if ( is_numeric( $args ) ) {
$args = array( 'user_id' => $args );
}
if ( $args['user_id'] ) {
if ( !$token = Jetpack::get_option( 'user_token' ) ) {
return false;
}
$token_chunks = explode( '.', $token );
if ( empty( $token_chunks[1] ) || empty( $token_chunks[2] ) ) {
return false;
}
$args['user_id'] = $token_chunks[2];
$token = "{$token_chunks[0]}.{$token_chunks[1]}";
} else {
$token = Jetpack::get_option( 'blog_token' );
if ( empty( $token ) ) {
return false;
}
}
return (object) array(
'secret' => $token,
'external_user_id' => (int) $args['user_id'],
);
}
}
/**
* Client = Plugin
* Client Server = API Methods the Plugin must respond to
*
* @todo Roll this into Jetpack? There's only one 'public' method now: ::authorize().
*/
class Jetpack_Client_Server {
function authorize() {
$data = stripslashes_deep( $_GET );
$args = array();
do {
$jetpack = Jetpack::init();
$role = $jetpack->translate_current_user_to_role();
if ( !$role ) {
Jetpack::state( 'error', 'no_role' );
break;
}
$cap = $jetpack->translate_role_to_cap( $role );
if ( !$cap ) {
Jetpack::state( 'error', 'no_cap' );
break;
}
check_admin_referer( "jetpack-authorize_$role" );
if ( !empty( $data['error'] ) ) {
Jetpack::state( 'error', $data['error'] );
break;
}
if ( empty( $data['state'] ) ) {
Jetpack::state( 'error', 'no_state' );
break;
}
if ( !ctype_digit( $data['state'] ) ) {
Jetpack::state( 'error', 'invalid_state' );
break;
}
$current_user_id = get_current_user_id();
if ( $current_user_id != $data['state'] ) {
Jetpack::state( 'error', 'wrong_state' );
break;
}
if ( empty( $data['code'] ) ) {
Jetpack::state( 'error', 'no_code' );
break;
}
$token = $this->get_token( $data );
if ( is_wp_error( $token ) ) {
if ( $error = $token->get_error_code() )
Jetpack::state( 'error', $error );
else
Jetpack::state( 'error', 'invalid_token' );
Jetpack::state( 'error_description', $token->get_error_message() );
break;
}
if ( !$token ) {
Jetpack::state( 'error', 'no_token' );
break;
}
Jetpack::update_option( 'user_token', sprintf( '%s.%d', $token, $current_user_id ), true );
Jetpack::state( 'message', 'authorized' );
if ( $active_modules = Jetpack::get_option( 'active_modules' ) ) {
Jetpack::delete_option( 'active_modules' );
Jetpack::activate_default_modules( 999, 1, $active_modules );
} else {
Jetpack::activate_default_modules();
}
// Start nonce cleaner
wp_clear_scheduled_hook( 'jetpack_clean_nonces' );
wp_schedule_event( time(), 'hourly', 'jetpack_clean_nonces' );
} while ( false );
wp_safe_redirect( Jetpack::admin_url() );
exit;
}
function deactivate_plugin( $probable_file, $probable_title ) {
if ( is_plugin_active( $probable_file ) ) {
deactivate_plugins( $probable_file );
return 1;
} else {
// If the plugin is not in the usual place, try looking through all active plugins.
$active_plugins = get_option( 'active_plugins', array() );
foreach ( $active_plugins as $plugin ) {
$data = get_plugin_data( WP_PLUGIN_DIR . '/' . $plugin );
if ( $data['Name'] == $probable_title ) {
deactivate_plugins( $plugin );
return 1;
}
}
}
return 0;
}
/**
* @return object|WP_Error
*/
function get_token( $data ) {
$jetpack = Jetpack::init();
$role = $jetpack->translate_current_user_to_role();
if ( !$role ) {
return new Jetpack_Error( 'role', __( 'An administrator for this blog must set up the Jetpack connection.', 'jetpack' ) );
}
$client_secret = Jetpack_Data::get_access_token( 0 );
if ( !$client_secret ) {
return new Jetpack_Error( 'client_secret', __( 'You need to register your Jetpack before connecting it.', 'jetpack' ) );
}
$body = array(
'client_id' => Jetpack::get_option( 'id' ),
'client_secret' => $client_secret->secret,
'grant_type' => 'authorization_code',
'code' => $data['code'],
'redirect_uri' => add_query_arg( array(
'action' => 'authorize',
'_wpnonce' => wp_create_nonce( "jetpack-authorize_$role" ),
), menu_page_url( 'jetpack', false ) ),
);
$args = array(
'method' => 'POST',
'body' => $body,
'headers' => array(
'Accept' => 'application/json',
),
);
$response = Jetpack_Client::_wp_remote_request( Jetpack::fix_url_for_bad_hosts( Jetpack::api_url( 'token' ), $args ), $args );
if ( is_wp_error( $response ) ) {
return new Jetpack_Error( 'token_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;
if ( 200 != $code || !empty( $json->error ) ) {
if ( empty( $json->error ) )
return new Jetpack_Error( 'unknown', '', $code );
$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 );
}
if ( empty( $json->access_token ) || !is_scalar( $json->access_token ) ) {
return new Jetpack_Error( 'access_token', '', $code );
}
if ( empty( $json->token_type ) || 'X_JETPACK' != strtoupper( $json->token_type ) ) {
return new Jetpack_Error( 'token_type', '', $code );
}
if ( empty( $json->scope ) ) {
return new Jetpack_Error( 'scope', 'No Scope', $code );
}
@list( $role, $hmac ) = explode( ':', $json->scope );
if ( empty( $role ) || empty( $hmac ) ) {
return new Jetpack_Error( 'scope', 'Malformed Scope', $code );
}
if ( $jetpack->sign_role( $role ) !== $json->scope ) {
return new Jetpack_Error( 'scope', 'Invalid Scope', $code );
}
if ( !$cap = $jetpack->translate_role_to_cap( $role ) )
return new Jetpack_Error( 'scope', 'No Cap', $code );
if ( !current_user_can( $cap ) )
return new Jetpack_Error( 'scope', 'current_user_cannot', $code );
return (string) $json->access_token;
}
}
/**
* Request that a piece of data on this WordPress install be synced back to the
* Jetpack server for remote processing/notifications/etc
*/
class Jetpack_Sync {
var $sync = array();
var $post_transitions = array();
function Jetpack_Sync() {
add_action( 'transition_post_status', array( $this, 'track_post_transition' ), 1, 3 );
}
function track_post_transition( $new_status, $old_status, $post ) {
if ( empty( $post->ID ) ) {
return;
}
if ( isset( $this->post_transitions[$post->ID] ) ) {
$this->post_transitions[$post->ID][0] = $new_status;
return;
}
$this->post_transitions[$post->ID] = array( $new_status, $old_status );
}
/**
* Create a sync object/request
*
* @param string $object Type of object to sync -- [ post | comment ]
* @param int $id Unique identifier
* @param array $specifics Specific fields/elements of that object to sync. Defaults to syncing all data for the $object
*/
function register( $object, $id = false, $specifics = true ) {
// Since we've registered something for sync, hook it up to execute on shutdown if we haven't already
if ( !$this->sync ) {
ignore_user_abort( true );
add_action( 'shutdown', array( $this, 'sync' ), 9 ); // Right before async XML-RPC
}
$this->add_to_array( $this->sync, $object, $id, $specifics );
return true;
}
function add_to_array( &$array, $object, $id, $data ) {
if ( !isset( $array[$object] ) ) {
$array[$object] = array( $id => $data );
} else if ( !isset( $array[$object][$id] ) ) {
$array[$object][$id] = $data;
} else {
if ( true === $array[$object][$id] || true === $data )
$array[$object][$id] = true;
else
$array[$object][$id] = array_merge( $array[$object][$id], $data );
}
}
/**
* Set up all the data and queue it for the outgoing XML-RPC request
*/
function sync() {
global $wpdb;
$jetpack = Jetpack::init();
$available_modules = Jetpack::get_available_modules();
$active_modules = Jetpack::get_active_modules();
$modules = array();
foreach ( $available_modules as $available_module ) {
$modules[$available_module] = in_array( $available_module, $active_modules );
}
$modules['vaultpress'] = class_exists( 'VaultPress' ) || function_exists( 'vaultpress_contact_service' );
$sync_data = compact( 'modules' );
if ( count( $this->sync ) ) {
foreach ( $this->sync as $obj => $data ) {
switch ( $obj ) {
case 'post':
$global_post = isset( $GLOBALS['post'] ) ? $GLOBALS['post'] : null;
$GLOBALS['post'] = null;
foreach ( $data as $post => $columns ) {
$sync_data['post'][$post] = $jetpack->get_post( $post, $columns );
if ( isset( $this->post_transitions[$post] ) ) {
$sync_data['post'][$post]['transitions'] = $this->post_transitions[$post];
} else {
$sync_data['post'][$post]['transitions'] = array( false, false );
}
}
$GLOBALS['post'] = $global_post;
unset( $global_post );
break;
case 'delete_post':
foreach ( $data as $post => $true ) {
$sync_data['delete_post'][$post] = true;
}
break;
case 'comment':
$global_comment = isset( $GLOBALS['comment'] ) ? $GLOBALS['comment'] : null;
unset( $GLOBALS['comment'] );
foreach ( $data as $comment => $columns ) {
$sync_data['comment'][$comment] = $jetpack->get_comment( $comment, $columns );
}
$GLOBALS['comment'] = $global_comment;
unset( $global_comment );
break;
case 'delete_comment':
foreach ( $data as $comment => $true ) {
$sync_data['delete_comment'][$comment] = true;
}
break;
case 'tag':
foreach ( $data as $taxonomy => $columns ) {
$sync_data['tag'][$taxonomy] = $jetpack->get_taxonomy( $taxonomy, $columns, 'post_tag' );
}
break;
case 'delete_tag':
foreach ( $data as $taxonomy => $columns ) {
$sync_data['delete_tag'][$taxonomy] = $columns;
}
break;
case 'category':
foreach ( $data as $taxonomy => $columns ) {
$sync_data['category'][$taxonomy] = $jetpack->get_taxonomy( $taxonomy, $columns, 'category' );
}
break;
case 'delete_category':
foreach ( $data as $taxonomy => $columns ) {
$sync_data['delete_category'][$taxonomy] = $columns;
}
break;
}
}
Jetpack::xmlrpc_async_call( 'jetpack.syncContent', $sync_data );
}
}
function taxonomy( $slug, $fields = true, $type ) {
if ( !get_term_by( 'slug', $slug, $type ) ) {
return false;
}
if ( 'post_tag' == $type )
return $this->register( 'tag', $slug, $fields );
else
return $this->register( 'category', $slug, $fields );
}
/**
* Request that a post be deleted remotely
*
* @param int $id The post_ID
*/
function delete_taxonomy( $slugs, $type ) {
if ( 'post_tag' == $type )
return $this->register( 'delete_tag', 1, $slugs );
else
return $this->register( 'delete_category', 1, $slugs );
}
/**
* Helper method for easily requesting a sync of a post.
*
* @param int $id wp_posts.ID
* @param array $fields Array containing field/column names to sync (optional, defaults to all fields)
*/
function post( $id, $fields = true ) {
if ( !$id = (int) $id ) {
return false;
}
if ( false === $fields ) {
$fields = array( '_jetpack_backfill' );
}
if ( is_array( $fields ) ) {
$fields = array_merge( $fields, array( 'ID', 'post_title', 'post_name', 'guid', 'post_date', 'post_date_gmt', 'post_parent', 'post_type', 'post_status' ) );
}
if ( !$post = get_post( $id ) ) {
return false;
}
if (
!empty( $post->post_password )
||
!in_array( $post->post_type, get_post_types( array( 'public' => true ) ) )
||
!in_array( $post->post_status, get_post_stati( array( 'public' => true ) ) )
) {
return false;
}
return $this->register( 'post', (int) $id, $fields );
}
/**
* Request that a post be deleted remotely
*
* @param int $id The post_ID
*/
function delete_post( $id ) {
return $this->register( 'delete_post', (int) $id, true );
}
/**
* Helper method for easily requesting a sync of a comment.
*
* @param int $id wp_comments.ID
* @param array $fields Array containing field/column names to sync (optional, defaults to all fields). Should always use default.
*/
function comment( $id, $fields = true ) {
if ( !$comment = get_comment( $id ) ) {
return false;
}
if ( !$comment->comment_post_ID ) {
return false;
}
if ( !$this->post( $comment->comment_post_ID, false ) ) {
return false;
}
return $this->register( 'comment', (int) $id, $fields );
}
/**
* Request that a comment be deleted remotely
*
* @param int $id The comment_ID
*/
function delete_comment( $id ) {
return $this->register( 'delete_comment', (int) $id, true );
}
}
class Jetpack_Error extends WP_Error {}
register_activation_hook( __FILE__, array( 'Jetpack', 'plugin_activation' ) );
register_deactivation_hook( __FILE__, array( 'Jetpack', 'plugin_deactivation' ) );
add_action( 'init', array( 'Jetpack', 'init' ) );
add_action( 'plugins_loaded', array( 'Jetpack', 'load_modules' ), 100 );
add_filter( 'jetpack_static_url', array( 'Jetpack', 'staticize_subdomain' ) );
 ? 'https' : 'http' ) . '://stats.wordpress.com/g.gif?v=wpcom2&x_jetpack-' . esc_attr( $group ) . '=' . esc_attr( implode( ',', $stats ) ) . '&rand=' . md5( mt_rand( 0, 999 ) . time() ) . '){kind=small}
';
}
}
}
function translate_current_user_to_role() {
foreach ( $this->capability_translations as $role => $cap ) {
if ( current_user_can( $role ) || current_user_can( $cap ) ) {
return $role;
}
}
return false;
}
function translate_role_to_cap( $role ) {
if ( !isset( $this->capability_translations[$role] ) ) {
return false;
}
return $this->capability_translations[$role];
}
function sign_role( $role ) {
if ( !$user_id = (int) get_current_user_id() ) {
return false;
}
$token = Jetpack_Data::get_access_token( 0 );
if ( !$token || is_wp_error( $token ) ) {
return false;
}
return $role . ':' . hash_hmac( 'md5', "{$role}|{$user_id}", $token->secret );
}
function build_connect_url( $raw = false ) {
if ( !Jetpack::get_option( 'blog_token' ) ) {
$url = wp_nonce_url( add_query_arg( 'action', 'register', menu_page_url( 'jetpack', false ) ), 'jetpack-register' );
} else {
$role = $this->translate_current_user_to_role();
$signed_role = $this->sign_role( $role );
$user = wp_get_current_user();
$args = urlencode_deep( array(
'response_type' => 'code',
'client_id' => Jetpack::get_option( 'id' ),
'redirect_uri' => add_query_arg( array(
'action' => 'authorize',
'_wpnonce' => wp_create_nonce( "jetpack-authorize_$role" ),
), menu_page_url( 'jetpack', false ) ),
'state' => $user->ID,
'scope' => $signed_role,
'user_email' => $user->user_email,
) );
$url = add_query_arg( $args, Jetpack::api_url( 'authorize' ) );
}
return $raw ? $url : esc_url( $url );
}
function admin_url( $args = null ) {
$url = menu_page_url( 'jetpack', false );
if ( is_array( $args ) )
$url = add_query_arg( $args, $url );
return $url;
}
function dismiss_jetpack_notice() {
if ( isset( $_GET['jetpack-notice'] ) && 'dismiss' == $_GET['jetpack-notice'] && ! is_plugin_active_for_network( plugin_basename( __FILE__ ) ) ) {
require_once ABSPATH . 'wp-admin/includes/plugin.php';
deactivate_plugins( plugin_basename( __FILE__ ), false, false );
wp_safe_redirect( admin_url() . 'plugins.php?deactivate=true&plugin_status=all&paged=1&s=' );
exit;
}
}
function admin_page() {
global $current_user;
$role = $this->translate_current_user_to_role();
$is_connected = Jetpack::is_active();
$module = false;
?>
 ); ?>)