Completed
Push — update/sync-sender-errors ( 4fee1b...25301f )
by
unknown
28:45 queued 20:45
created

class.jetpack.php (1 issue)

Upgrade to new PHP Analysis Engine

These results are based on our legacy PHP analysis, consider migrating to our new PHP analysis engine instead. Learn more

1
<?php
2
3
/*
4
Options:
5
jetpack_options (array)
6
	An array of options.
7
	@see Jetpack_Options::get_option_names()
8
9
jetpack_register (string)
10
	Temporary verification secrets.
11
12
jetpack_activated (int)
13
	1: the plugin was activated normally
14
	2: the plugin was activated on this site because of a network-wide activation
15
	3: the plugin was auto-installed
16
	4: the plugin was manually disconnected (but is still installed)
17
18
jetpack_active_modules (array)
19
	Array of active module slugs.
20
21
jetpack_do_activate (bool)
22
	Flag for "activating" the plugin on sites where the activation hook never fired (auto-installs)
23
*/
24
25
require_once( JETPACK__PLUGIN_DIR . '_inc/lib/class.media.php' );
26
27
class Jetpack {
28
	public $xmlrpc_server = null;
29
30
	private $xmlrpc_verification = null;
31
	private $rest_authentication_status = null;
32
33
	public $HTTP_RAW_POST_DATA = null; // copy of $GLOBALS['HTTP_RAW_POST_DATA']
34
35
	/**
36
	 * @var array The handles of styles that are concatenated into jetpack.css
37
	 */
38
	public $concatenated_style_handles = array(
39
		'jetpack-carousel',
40
		'grunion.css',
41
		'the-neverending-homepage',
42
		'jetpack_likes',
43
		'jetpack_related-posts',
44
		'sharedaddy',
45
		'jetpack-slideshow',
46
		'presentations',
47
		'jetpack-subscriptions',
48
		'jetpack-responsive-videos-style',
49
		'jetpack-social-menu',
50
		'tiled-gallery',
51
		'jetpack_display_posts_widget',
52
		'gravatar-profile-widget',
53
		'goodreads-widget',
54
		'jetpack_social_media_icons_widget',
55
		'jetpack-top-posts-widget',
56
		'jetpack_image_widget',
57
		'jetpack-my-community-widget',
58
		'wordads',
59
		'eu-cookie-law-style',
60
		'flickr-widget-style',
61
	);
62
63
	public $plugins_to_deactivate = array(
64
		'stats'               => array( 'stats/stats.php', 'WordPress.com Stats' ),
65
		'shortlinks'          => array( 'stats/stats.php', 'WordPress.com Stats' ),
66
		'sharedaddy'          => array( 'sharedaddy/sharedaddy.php', 'Sharedaddy' ),
67
		'twitter-widget'      => array( 'wickett-twitter-widget/wickett-twitter-widget.php', 'Wickett Twitter Widget' ),
68
		'after-the-deadline'  => array( 'after-the-deadline/after-the-deadline.php', 'After The Deadline' ),
69
		'contact-form'        => array( 'grunion-contact-form/grunion-contact-form.php', 'Grunion Contact Form' ),
70
		'contact-form'        => array( 'mullet/mullet-contact-form.php', 'Mullet Contact Form' ),
71
		'custom-css'          => array( 'safecss/safecss.php', 'WordPress.com Custom CSS' ),
72
		'random-redirect'     => array( 'random-redirect/random-redirect.php', 'Random Redirect' ),
73
		'videopress'          => array( 'video/video.php', 'VideoPress' ),
74
		'widget-visibility'   => array( 'jetpack-widget-visibility/widget-visibility.php', 'Jetpack Widget Visibility' ),
75
		'widget-visibility'   => array( 'widget-visibility-without-jetpack/widget-visibility-without-jetpack.php', 'Widget Visibility Without Jetpack' ),
76
		'sharedaddy'          => array( 'jetpack-sharing/sharedaddy.php', 'Jetpack Sharing' ),
77
		'omnisearch'          => array( 'jetpack-omnisearch/omnisearch.php', 'Jetpack Omnisearch' ),
78
		'gravatar-hovercards' => array( 'jetpack-gravatar-hovercards/gravatar-hovercards.php', 'Jetpack Gravatar Hovercards' ),
79
		'latex'               => array( 'wp-latex/wp-latex.php', 'WP LaTeX' )
80
	);
81
82
	static $capability_translations = array(
83
		'administrator' => 'manage_options',
84
		'editor'        => 'edit_others_posts',
85
		'author'        => 'publish_posts',
86
		'contributor'   => 'edit_posts',
87
		'subscriber'    => 'read',
88
	);
89
90
	/**
91
	 * Map of modules that have conflicts with plugins and should not be auto-activated
92
	 * if the plugins are active.  Used by filter_default_modules
93
	 *
94
	 * Plugin Authors: If you'd like to prevent a single module from auto-activating,
95
	 * change `module-slug` and add this to your plugin:
96
	 *
97
	 * add_filter( 'jetpack_get_default_modules', 'my_jetpack_get_default_modules' );
98
	 * function my_jetpack_get_default_modules( $modules ) {
99
	 *     return array_diff( $modules, array( 'module-slug' ) );
100
	 * }
101
	 *
102
	 * @var array
103
	 */
104
	private $conflicting_plugins = array(
105
		'comments'          => array(
106
			'Intense Debate'                       => 'intensedebate/intensedebate.php',
107
			'Disqus'                               => 'disqus-comment-system/disqus.php',
108
			'Livefyre'                             => 'livefyre-comments/livefyre.php',
109
			'Comments Evolved for WordPress'       => 'gplus-comments/comments-evolved.php',
110
			'Google+ Comments'                     => 'google-plus-comments/google-plus-comments.php',
111
			'WP-SpamShield Anti-Spam'              => 'wp-spamshield/wp-spamshield.php',
112
		),
113
		'contact-form'      => array(
114
			'Contact Form 7'                       => 'contact-form-7/wp-contact-form-7.php',
115
			'Gravity Forms'                        => 'gravityforms/gravityforms.php',
116
			'Contact Form Plugin'                  => 'contact-form-plugin/contact_form.php',
117
			'Easy Contact Forms'                   => 'easy-contact-forms/easy-contact-forms.php',
118
			'Fast Secure Contact Form'             => 'si-contact-form/si-contact-form.php',
119
			'Ninja Forms'                          => 'ninja-forms/ninja-forms.php',
120
		),
121
		'minileven'         => array(
122
			'WPtouch'                              => 'wptouch/wptouch.php',
123
		),
124
		'latex'             => array(
125
			'LaTeX for WordPress'                  => 'latex/latex.php',
126
			'Youngwhans Simple Latex'              => 'youngwhans-simple-latex/yw-latex.php',
127
			'Easy WP LaTeX'                        => 'easy-wp-latex-lite/easy-wp-latex-lite.php',
128
			'MathJax-LaTeX'                        => 'mathjax-latex/mathjax-latex.php',
129
			'Enable Latex'                         => 'enable-latex/enable-latex.php',
130
			'WP QuickLaTeX'                        => 'wp-quicklatex/wp-quicklatex.php',
131
		),
132
		'protect'           => array(
133
			'Limit Login Attempts'                 => 'limit-login-attempts/limit-login-attempts.php',
134
			'Captcha'                              => 'captcha/captcha.php',
135
			'Brute Force Login Protection'         => 'brute-force-login-protection/brute-force-login-protection.php',
136
			'Login Security Solution'              => 'login-security-solution/login-security-solution.php',
137
			'WPSecureOps Brute Force Protect'      => 'wpsecureops-bruteforce-protect/wpsecureops-bruteforce-protect.php',
138
			'BulletProof Security'                 => 'bulletproof-security/bulletproof-security.php',
139
			'SiteGuard WP Plugin'                  => 'siteguard/siteguard.php',
140
			'Security-protection'                  => 'security-protection/security-protection.php',
141
			'Login Security'                       => 'login-security/login-security.php',
142
			'Botnet Attack Blocker'                => 'botnet-attack-blocker/botnet-attack-blocker.php',
143
			'Wordfence Security'                   => 'wordfence/wordfence.php',
144
			'All In One WP Security & Firewall'    => 'all-in-one-wp-security-and-firewall/wp-security.php',
145
			'iThemes Security'                     => 'better-wp-security/better-wp-security.php',
146
		),
147
		'random-redirect'   => array(
148
			'Random Redirect 2'                    => 'random-redirect-2/random-redirect.php',
149
		),
150
		'related-posts'     => array(
151
			'YARPP'                                => 'yet-another-related-posts-plugin/yarpp.php',
152
			'WordPress Related Posts'              => 'wordpress-23-related-posts-plugin/wp_related_posts.php',
153
			'nrelate Related Content'              => 'nrelate-related-content/nrelate-related.php',
154
			'Contextual Related Posts'             => 'contextual-related-posts/contextual-related-posts.php',
155
			'Related Posts for WordPress'          => 'microkids-related-posts/microkids-related-posts.php',
156
			'outbrain'                             => 'outbrain/outbrain.php',
157
			'Shareaholic'                          => 'shareaholic/shareaholic.php',
158
			'Sexybookmarks'                        => 'sexybookmarks/shareaholic.php',
159
		),
160
		'sharedaddy'        => array(
161
			'AddThis'                              => 'addthis/addthis_social_widget.php',
162
			'Add To Any'                           => 'add-to-any/add-to-any.php',
163
			'ShareThis'                            => 'share-this/sharethis.php',
164
			'Shareaholic'                          => 'shareaholic/shareaholic.php',
165
		),
166
		'seo-tools' => array(
167
			'WordPress SEO by Yoast'               => 'wordpress-seo/wp-seo.php',
168
			'WordPress SEO Premium by Yoast'       => 'wordpress-seo-premium/wp-seo-premium.php',
169
			'All in One SEO Pack'                  => 'all-in-one-seo-pack/all_in_one_seo_pack.php',
170
			'All in One SEO Pack Pro'              => 'all-in-one-seo-pack-pro/all_in_one_seo_pack.php',
171
		),
172
		'verification-tools' => array(
173
			'WordPress SEO by Yoast'               => 'wordpress-seo/wp-seo.php',
174
			'WordPress SEO Premium by Yoast'       => 'wordpress-seo-premium/wp-seo-premium.php',
175
			'All in One SEO Pack'                  => 'all-in-one-seo-pack/all_in_one_seo_pack.php',
176
			'All in One SEO Pack Pro'              => 'all-in-one-seo-pack-pro/all_in_one_seo_pack.php',
177
		),
178
		'widget-visibility' => array(
179
			'Widget Logic'                         => 'widget-logic/widget_logic.php',
180
			'Dynamic Widgets'                      => 'dynamic-widgets/dynamic-widgets.php',
181
		),
182
		'sitemaps' => array(
183
			'Google XML Sitemaps'                  => 'google-sitemap-generator/sitemap.php',
184
			'Better WordPress Google XML Sitemaps' => 'bwp-google-xml-sitemaps/bwp-simple-gxs.php',
185
			'Google XML Sitemaps for qTranslate'   => 'google-xml-sitemaps-v3-for-qtranslate/sitemap.php',
186
			'XML Sitemap & Google News feeds'      => 'xml-sitemap-feed/xml-sitemap.php',
187
			'Google Sitemap by BestWebSoft'        => 'google-sitemap-plugin/google-sitemap-plugin.php',
188
			'WordPress SEO by Yoast'               => 'wordpress-seo/wp-seo.php',
189
			'WordPress SEO Premium by Yoast'       => 'wordpress-seo-premium/wp-seo-premium.php',
190
			'All in One SEO Pack'                  => 'all-in-one-seo-pack/all_in_one_seo_pack.php',
191
			'All in One SEO Pack Pro'              => 'all-in-one-seo-pack-pro/all_in_one_seo_pack.php',
192
			'Sitemap'                              => 'sitemap/sitemap.php',
193
			'Simple Wp Sitemap'                    => 'simple-wp-sitemap/simple-wp-sitemap.php',
194
			'Simple Sitemap'                       => 'simple-sitemap/simple-sitemap.php',
195
			'XML Sitemaps'                         => 'xml-sitemaps/xml-sitemaps.php',
196
			'MSM Sitemaps'                         => 'msm-sitemap/msm-sitemap.php',
197
		),
198
	);
199
200
	/**
201
	 * Plugins for which we turn off our Facebook OG Tags implementation.
202
	 *
203
	 * Note: All in One SEO Pack, All in one SEO Pack Pro, WordPress SEO by Yoast, and WordPress SEO Premium by Yoast automatically deactivate
204
	 * Jetpack's Open Graph tags via filter when their Social Meta modules are active.
205
	 *
206
	 * Plugin authors: If you'd like to prevent Jetpack's Open Graph tag generation in your plugin, you can do so via this filter:
207
	 * add_filter( 'jetpack_enable_open_graph', '__return_false' );
208
	 */
209
	private $open_graph_conflicting_plugins = array(
210
		'2-click-socialmedia-buttons/2-click-socialmedia-buttons.php',
211
		                                                         // 2 Click Social Media Buttons
212
		'add-link-to-facebook/add-link-to-facebook.php',         // Add Link to Facebook
213
		'add-meta-tags/add-meta-tags.php',                       // Add Meta Tags
214
		'autodescription/autodescription.php',                   // The SEO Framework
215
		'easy-facebook-share-thumbnails/esft.php',               // Easy Facebook Share Thumbnail
216
		'heateor-open-graph-meta-tags/heateor-open-graph-meta-tags.php',
217
		                                                         // Open Graph Meta Tags by Heateor
218
		'facebook/facebook.php',                                 // Facebook (official plugin)
219
		'facebook-awd/AWD_facebook.php',                         // Facebook AWD All in one
220
		'facebook-featured-image-and-open-graph-meta-tags/fb-featured-image.php',
221
		                                                         // Facebook Featured Image & OG Meta Tags
222
		'facebook-meta-tags/facebook-metatags.php',              // Facebook Meta Tags
223
		'wonderm00ns-simple-facebook-open-graph-tags/wonderm00n-open-graph.php',
224
		                                                         // Facebook Open Graph Meta Tags for WordPress
225
		'facebook-revised-open-graph-meta-tag/index.php',        // Facebook Revised Open Graph Meta Tag
226
		'facebook-thumb-fixer/_facebook-thumb-fixer.php',        // Facebook Thumb Fixer
227
		'facebook-and-digg-thumbnail-generator/facebook-and-digg-thumbnail-generator.php',
228
		                                                         // Fedmich's Facebook Open Graph Meta
229
		'network-publisher/networkpub.php',                      // Network Publisher
230
		'nextgen-facebook/nextgen-facebook.php',                 // NextGEN Facebook OG
231
		'social-networks-auto-poster-facebook-twitter-g/NextScripts_SNAP.php',
232
		                                                         // NextScripts SNAP
233
		'og-tags/og-tags.php',                                   // OG Tags
234
		'opengraph/opengraph.php',                               // Open Graph
235
		'open-graph-protocol-framework/open-graph-protocol-framework.php',
236
		                                                         // Open Graph Protocol Framework
237
		'seo-facebook-comments/seofacebook.php',                 // SEO Facebook Comments
238
		'seo-ultimate/seo-ultimate.php',                         // SEO Ultimate
239
		'sexybookmarks/sexy-bookmarks.php',                      // Shareaholic
240
		'shareaholic/sexy-bookmarks.php',                        // Shareaholic
241
		'sharepress/sharepress.php',                             // SharePress
242
		'simple-facebook-connect/sfc.php',                       // Simple Facebook Connect
243
		'social-discussions/social-discussions.php',             // Social Discussions
244
		'social-sharing-toolkit/social_sharing_toolkit.php',     // Social Sharing Toolkit
245
		'socialize/socialize.php',                               // Socialize
246
		'squirrly-seo/squirrly.php',                             // SEO by SQUIRRLY™
247
		'only-tweet-like-share-and-google-1/tweet-like-plusone.php',
248
		                                                         // Tweet, Like, Google +1 and Share
249
		'wordbooker/wordbooker.php',                             // Wordbooker
250
		'wpsso/wpsso.php',                                       // WordPress Social Sharing Optimization
251
		'wp-caregiver/wp-caregiver.php',                         // WP Caregiver
252
		'wp-facebook-like-send-open-graph-meta/wp-facebook-like-send-open-graph-meta.php',
253
		                                                         // WP Facebook Like Send & Open Graph Meta
254
		'wp-facebook-open-graph-protocol/wp-facebook-ogp.php',   // WP Facebook Open Graph protocol
255
		'wp-ogp/wp-ogp.php',                                     // WP-OGP
256
		'zoltonorg-social-plugin/zosp.php',                      // Zolton.org Social Plugin
257
		'wp-fb-share-like-button/wp_fb_share-like_widget.php'    // WP Facebook Like Button
258
	);
259
260
	/**
261
	 * Plugins for which we turn off our Twitter Cards Tags implementation.
262
	 */
263
	private $twitter_cards_conflicting_plugins = array(
264
	//	'twitter/twitter.php',                       // The official one handles this on its own.
265
	//	                                             // https://github.com/twitter/wordpress/blob/master/src/Twitter/WordPress/Cards/Compatibility.php
266
		'eewee-twitter-card/index.php',              // Eewee Twitter Card
267
		'ig-twitter-cards/ig-twitter-cards.php',     // IG:Twitter Cards
268
		'jm-twitter-cards/jm-twitter-cards.php',     // JM Twitter Cards
269
		'kevinjohn-gallagher-pure-web-brilliants-social-graph-twitter-cards-extention/kevinjohn_gallagher___social_graph_twitter_output.php',
270
		                                             // Pure Web Brilliant's Social Graph Twitter Cards Extension
271
		'twitter-cards/twitter-cards.php',           // Twitter Cards
272
		'twitter-cards-meta/twitter-cards-meta.php', // Twitter Cards Meta
273
		'wp-twitter-cards/twitter_cards.php',        // WP Twitter Cards
274
	);
275
276
	/**
277
	 * Message to display in admin_notice
278
	 * @var string
279
	 */
280
	public $message = '';
281
282
	/**
283
	 * Error to display in admin_notice
284
	 * @var string
285
	 */
286
	public $error = '';
287
288
	/**
289
	 * Modules that need more privacy description.
290
	 * @var string
291
	 */
292
	public $privacy_checks = '';
293
294
	/**
295
	 * Stats to record once the page loads
296
	 *
297
	 * @var array
298
	 */
299
	public $stats = array();
300
301
	/**
302
	 * Jetpack_Sync object
303
	 */
304
	public $sync;
305
306
	/**
307
	 * Verified data for JSON authorization request
308
	 */
309
	public $json_api_authorization_request = array();
310
311
	/**
312
	 * Holds the singleton instance of this class
313
	 * @since 2.3.3
314
	 * @var Jetpack
315
	 */
316
	static $instance = false;
317
318
	/**
319
	 * Singleton
320
	 * @static
321
	 */
322
	public static function init() {
323
		if ( ! self::$instance ) {
324
			self::$instance = new Jetpack;
325
326
			self::$instance->plugin_upgrade();
327
		}
328
329
		return self::$instance;
330
	}
331
332
	/**
333
	 * Must never be called statically
334
	 */
335
	function plugin_upgrade() {
336
		if ( Jetpack::is_active() ) {
337
			list( $version ) = explode( ':', Jetpack_Options::get_option( 'version' ) );
338
			if ( JETPACK__VERSION != $version ) {
339
340
				// check which active modules actually exist and remove others from active_modules list
341
				$unfiltered_modules = Jetpack::get_active_modules();
342
				$modules = array_filter( $unfiltered_modules, array( 'Jetpack', 'is_module' ) );
343
				if ( array_diff( $unfiltered_modules, $modules ) ) {
344
					Jetpack::update_active_modules( $modules );
345
				}
346
347
				add_action( 'init', array( __CLASS__, 'activate_new_modules' ) );
348
349
				// Upgrade to 4.3.0
350
				if ( Jetpack_Options::get_option( 'identity_crisis_whitelist' ) ) {
351
					Jetpack_Options::delete_option( 'identity_crisis_whitelist' );
352
				}
353
354
				// Make sure Markdown for posts gets turned back on
355
				if ( ! get_option( 'wpcom_publish_posts_with_markdown' ) ) {
356
					update_option( 'wpcom_publish_posts_with_markdown', true );
357
				}
358
359
				if ( did_action( 'wp_loaded' ) ) {
360
					self::upgrade_on_load();
361
				} else {
362
					add_action(
363
						'wp_loaded',
364
						array( __CLASS__, 'upgrade_on_load' )
365
					);
366
				}
367
			}
368
		}
369
	}
370
371
	/**
372
	 * Runs upgrade routines that need to have modules loaded.
373
	 */
374
	static function upgrade_on_load() {
375
376
		// Not attempting any upgrades if jetpack_modules_loaded did not fire.
377
		// This can happen in case Jetpack has been just upgraded and is
378
		// being initialized late during the page load. In this case we wait
379
		// until the next proper admin page load with Jetpack active.
380
		if ( ! did_action( 'jetpack_modules_loaded' ) ) {
381
			return;
382
		}
383
384
		Jetpack::maybe_set_version_option();
385
386
		if ( class_exists( 'Jetpack_Widget_Conditions' ) ) {
387
			Jetpack_Widget_Conditions::migrate_post_type_rules();
388
		}
389
	}
390
391
	static function activate_manage( ) {
392
		if ( did_action( 'init' ) || current_filter() == 'init' ) {
393
			self::activate_module( 'manage', false, false );
394
		} else if ( !  has_action( 'init' , array( __CLASS__, 'activate_manage' ) ) ) {
395
			add_action( 'init', array( __CLASS__, 'activate_manage' ) );
396
		}
397
	}
398
399
	static function update_active_modules( $modules ) {
400
		$current_modules = Jetpack_Options::get_option( 'active_modules', array() );
401
402
		$success = Jetpack_Options::update_option( 'active_modules', array_unique( $modules ) );
403
404
		if ( is_array( $modules ) && is_array( $current_modules ) ) {
405
			$new_active_modules = array_diff( $modules, $current_modules );
406
			foreach( $new_active_modules as $module ) {
407
				/**
408
				 * Fires when a specific module is activated.
409
				 *
410
				 * @since 1.9.0
411
				 *
412
				 * @param string $module Module slug.
413
				 * @param boolean $success whether the module was activated. @since 4.2
414
				 */
415
				do_action( 'jetpack_activate_module', $module, $success );
416
417
				/**
418
				 * Fires when a module is activated.
419
				 * The dynamic part of the filter, $module, is the module slug.
420
				 *
421
				 * @since 1.9.0
422
				 *
423
				 * @param string $module Module slug.
424
				 */
425
				do_action( "jetpack_activate_module_$module", $module );
426
			}
427
428
			$new_deactive_modules = array_diff( $current_modules, $modules );
429
			foreach( $new_deactive_modules as $module ) {
430
				/**
431
				 * Fired after a module has been deactivated.
432
				 *
433
				 * @since 4.2.0
434
				 *
435
				 * @param string $module Module slug.
436
				 * @param boolean $success whether the module was deactivated.
437
				 */
438
				do_action( 'jetpack_deactivate_module', $module, $success );
439
				/**
440
				 * Fires when a module is deactivated.
441
				 * The dynamic part of the filter, $module, is the module slug.
442
				 *
443
				 * @since 1.9.0
444
				 *
445
				 * @param string $module Module slug.
446
				 */
447
				do_action( "jetpack_deactivate_module_$module", $module );
448
			}
449
		}
450
451
		return $success;
452
	}
453
454
	static function delete_active_modules() {
455
		self::update_active_modules( array() );
456
	}
457
458
	/**
459
	 * Constructor.  Initializes WordPress hooks
460
	 */
461
	private function __construct() {
462
		/*
463
		 * Check for and alert any deprecated hooks
464
		 */
465
		add_action( 'init', array( $this, 'deprecated_hooks' ) );
466
467
		/*
468
		 * Load things that should only be in Network Admin.
469
		 *
470
		 * For now blow away everything else until a more full
471
		 * understanding of what is needed at the network level is
472
		 * available
473
		 */
474
		if( is_multisite() ) {
475
			Jetpack_Network::init();
476
		}
477
478
		add_action( 'set_user_role', array( $this, 'maybe_clear_other_linked_admins_transient' ), 10, 3 );
479
480
		// Unlink user before deleting the user from .com
481
		add_action( 'deleted_user', array( $this, 'unlink_user' ), 10, 1 );
482
		add_action( 'remove_user_from_blog', array( $this, 'unlink_user' ), 10, 1 );
483
484
		if ( defined( 'XMLRPC_REQUEST' ) && XMLRPC_REQUEST && isset( $_GET['for'] ) && 'jetpack' == $_GET['for'] ) {
485
			@ini_set( 'display_errors', false ); // Display errors can cause the XML to be not well formed.
486
487
			require_once JETPACK__PLUGIN_DIR . 'class.jetpack-xmlrpc-server.php';
488
			$this->xmlrpc_server = new Jetpack_XMLRPC_Server();
489
490
			$this->require_jetpack_authentication();
491
492
			if ( Jetpack::is_active() ) {
493
				// Hack to preserve $HTTP_RAW_POST_DATA
494
				add_filter( 'xmlrpc_methods', array( $this, 'xmlrpc_methods' ) );
495
496
				$signed = $this->verify_xml_rpc_signature();
497
				if ( $signed && ! is_wp_error( $signed ) ) {
498
					// The actual API methods.
499
					add_filter( 'xmlrpc_methods', array( $this->xmlrpc_server, 'xmlrpc_methods' ) );
500
				} else {
501
					// The jetpack.authorize method should be available for unauthenticated users on a site with an
502
					// active Jetpack connection, so that additional users can link their account.
503
					add_filter( 'xmlrpc_methods', array( $this->xmlrpc_server, 'authorize_xmlrpc_methods' ) );
504
				}
505
			} else {
506
				// The bootstrap API methods.
507
				add_filter( 'xmlrpc_methods', array( $this->xmlrpc_server, 'bootstrap_xmlrpc_methods' ) );
508
			}
509
510
			// Now that no one can authenticate, and we're whitelisting all XML-RPC methods, force enable_xmlrpc on.
511
			add_filter( 'pre_option_enable_xmlrpc', '__return_true' );
512
		} elseif (
513
			is_admin() &&
514
			isset( $_POST['action'] ) && (
515
				'jetpack_upload_file' == $_POST['action'] ||
516
				'jetpack_update_file' == $_POST['action']
517
			)
518
		) {
519
			$this->require_jetpack_authentication();
520
			$this->add_remote_request_handlers();
521
		} else {
522
			if ( Jetpack::is_active() ) {
523
				add_action( 'login_form_jetpack_json_api_authorization', array( &$this, 'login_form_json_api_authorization' ) );
524
				add_filter( 'xmlrpc_methods', array( $this, 'public_xmlrpc_methods' ) );
525
			}
526
		}
527
528
		if ( Jetpack::is_active() ) {
529
			Jetpack_Heartbeat::init();
530
		}
531
532
		add_filter( 'determine_current_user', array( $this, 'wp_rest_authenticate' ) );
533
		add_filter( 'rest_authentication_errors', array( $this, 'wp_rest_authentication_errors' ) );
534
535
		add_action( 'jetpack_clean_nonces', array( 'Jetpack', 'clean_nonces' ) );
536
		if ( ! wp_next_scheduled( 'jetpack_clean_nonces' ) ) {
537
			wp_schedule_event( time(), 'hourly', 'jetpack_clean_nonces' );
538
		}
539
540
		add_filter( 'xmlrpc_blog_options', array( $this, 'xmlrpc_options' ) );
541
542
		add_action( 'admin_init', array( $this, 'admin_init' ) );
543
		add_action( 'admin_init', array( $this, 'dismiss_jetpack_notice' ) );
544
545
		add_filter( 'admin_body_class', array( $this, 'admin_body_class' ) );
546
547
		add_action( 'wp_dashboard_setup', array( $this, 'wp_dashboard_setup' ) );
548
		// Filter the dashboard meta box order to swap the new one in in place of the old one.
549
		add_filter( 'get_user_option_meta-box-order_dashboard', array( $this, 'get_user_option_meta_box_order_dashboard' ) );
550
551
		// returns HTTPS support status
552
		add_action( 'wp_ajax_jetpack-recheck-ssl', array( $this, 'ajax_recheck_ssl' ) );
553
554
		// If any module option is updated before Jump Start is dismissed, hide Jump Start.
555
		add_action( 'update_option', array( $this, 'jumpstart_has_updated_module_option' ) );
556
557
		// JITM AJAX callback function
558
		add_action( 'wp_ajax_jitm_ajax',  array( $this, 'jetpack_jitm_ajax_callback' ) );
559
560
		// Universal ajax callback for all tracking events triggered via js
561
		add_action( 'wp_ajax_jetpack_tracks', array( $this, 'jetpack_admin_ajax_tracks_callback' ) );
562
563
		add_action( 'wp_loaded', array( $this, 'register_assets' ) );
564
		add_action( 'wp_enqueue_scripts', array( $this, 'devicepx' ) );
565
		add_action( 'customize_controls_enqueue_scripts', array( $this, 'devicepx' ) );
566
		add_action( 'admin_enqueue_scripts', array( $this, 'devicepx' ) );
567
568
		add_action( 'plugins_loaded', array( $this, 'extra_oembed_providers' ), 100 );
569
570
		/**
571
		 * These actions run checks to load additional files.
572
		 * They check for external files or plugins, so they need to run as late as possible.
573
		 */
574
		add_action( 'wp_head', array( $this, 'check_open_graph' ),       1 );
575
		add_action( 'plugins_loaded', array( $this, 'check_twitter_tags' ),     999 );
576
		add_action( 'plugins_loaded', array( $this, 'check_rest_api_compat' ), 1000 );
577
578
		add_filter( 'plugins_url',      array( 'Jetpack', 'maybe_min_asset' ),     1, 3 );
579
		add_filter( 'style_loader_tag', array( 'Jetpack', 'maybe_inline_style' ), 10, 2 );
580
581
		add_filter( 'map_meta_cap', array( $this, 'jetpack_custom_caps' ), 1, 4 );
582
583
		add_filter( 'jetpack_get_default_modules', array( $this, 'filter_default_modules' ) );
584
		add_filter( 'jetpack_get_default_modules', array( $this, 'handle_deprecated_modules' ), 99 );
585
586
		// A filter to control all just in time messages
587
		add_filter( 'jetpack_just_in_time_msgs', '__return_true' );
588
589
		// Update the Jetpack plan from API on heartbeats
590
		add_action( 'jetpack_heartbeat', array( $this, 'refresh_active_plan_from_wpcom' ) );
591
592
		/**
593
		 * This is the hack to concatinate all css files into one.
594
		 * For description and reasoning see the implode_frontend_css method
595
		 *
596
		 * Super late priority so we catch all the registered styles
597
		 */
598
		if( !is_admin() ) {
599
			add_action( 'wp_print_styles', array( $this, 'implode_frontend_css' ), -1 ); // Run first
600
			add_action( 'wp_print_footer_scripts', array( $this, 'implode_frontend_css' ), -1 ); // Run first to trigger before `print_late_styles`
601
		}
602
	}
603
604
	function jetpack_admin_ajax_tracks_callback() {
605
		// Check for nonce
606
		if ( ! isset( $_REQUEST['tracksNonce'] ) || ! wp_verify_nonce( $_REQUEST['tracksNonce'], 'jp-tracks-ajax-nonce' ) ) {
607
			wp_die( 'Permissions check failed.' );
608
		}
609
610
		if ( ! isset( $_REQUEST['tracksEventName'] ) || ! isset( $_REQUEST['tracksEventType'] )  ) {
611
			wp_die( 'No valid event name or type.' );
612
		}
613
614
		$tracks_data = array();
615
		if ( 'click' === $_REQUEST['tracksEventType'] && isset( $_REQUEST['tracksEventProp'] ) ) {
616
			$tracks_data = array( 'clicked' => $_REQUEST['tracksEventProp'] );
617
		}
618
619
		JetpackTracking::record_user_event( $_REQUEST['tracksEventName'], $tracks_data );
620
		wp_send_json_success();
621
		wp_die();
622
	}
623
624
	/**
625
	 * The callback for the JITM ajax requests.
626
	 */
627
	function jetpack_jitm_ajax_callback() {
628
		// Check for nonce
629
		if ( ! isset( $_REQUEST['jitmNonce'] ) || ! wp_verify_nonce( $_REQUEST['jitmNonce'], 'jetpack-jitm-nonce' ) ) {
630
			wp_die( 'Module activation failed due to lack of appropriate permissions' );
631
		}
632
		if ( isset( $_REQUEST['jitmActionToTake'] ) && 'activate' == $_REQUEST['jitmActionToTake'] ) {
633
			$module_slug = $_REQUEST['jitmModule'];
634
			Jetpack::log( 'activate', $module_slug );
635
			Jetpack::activate_module( $module_slug, false, false );
636
			Jetpack::state( 'message', 'no_message' );
637
638
			//A Jetpack module is being activated through a JITM, track it
639
			$this->stat( 'jitm', $module_slug.'-activated-' . JETPACK__VERSION );
640
			$this->do_stats( 'server_side' );
641
642
			wp_send_json_success();
643
		}
644
		if ( isset( $_REQUEST['jitmActionToTake'] ) && 'dismiss' == $_REQUEST['jitmActionToTake'] ) {
645
			// get the hide_jitm options array
646
			$jetpack_hide_jitm = Jetpack_Options::get_option( 'hide_jitm' );
647
			$module_slug = $_REQUEST['jitmModule'];
648
649
			if( ! $jetpack_hide_jitm ) {
650
				$jetpack_hide_jitm = array(
651
					$module_slug => 'hide'
652
				);
653
			} else {
654
				$jetpack_hide_jitm[$module_slug] = 'hide';
655
			}
656
657
			Jetpack_Options::update_option( 'hide_jitm', $jetpack_hide_jitm );
658
659
			//jitm is being dismissed forever, track it
660
			$this->stat( 'jitm', $module_slug.'-dismissed-' . JETPACK__VERSION );
661
			$this->do_stats( 'server_side' );
662
663
			wp_send_json_success();
664
		}
665 View Code Duplication
		if ( isset( $_REQUEST['jitmActionToTake'] ) && 'launch' == $_REQUEST['jitmActionToTake'] ) {
666
			$module_slug = $_REQUEST['jitmModule'];
667
668
			// User went to WordPress.com, track this
669
			$this->stat( 'jitm', $module_slug.'-wordpress-tools-' . JETPACK__VERSION );
670
			$this->do_stats( 'server_side' );
671
672
			wp_send_json_success();
673
		}
674 View Code Duplication
		if ( isset( $_REQUEST['jitmActionToTake'] ) && 'viewed' == $_REQUEST['jitmActionToTake'] ) {
675
			$track = $_REQUEST['jitmModule'];
676
677
			// User is viewing JITM, track it.
678
			$this->stat( 'jitm', $track . '-viewed-' . JETPACK__VERSION );
679
			$this->do_stats( 'server_side' );
680
681
			wp_send_json_success();
682
		}
683
	}
684
685
	/**
686
	 * If there are any stats that need to be pushed, but haven't been, push them now.
687
	 */
688
	function __destruct() {
689
		if ( ! empty( $this->stats ) ) {
690
			$this->do_stats( 'server_side' );
691
		}
692
	}
693
694
	function jetpack_custom_caps( $caps, $cap, $user_id, $args ) {
695
		switch( $cap ) {
696
			case 'jetpack_connect' :
697
			case 'jetpack_reconnect' :
698
				if ( Jetpack::is_development_mode() ) {
699
					$caps = array( 'do_not_allow' );
700
					break;
701
				}
702
				/**
703
				 * Pass through. If it's not development mode, these should match disconnect.
704
				 * Let users disconnect if it's development mode, just in case things glitch.
705
				 */
706
			case 'jetpack_disconnect' :
707
				/**
708
				 * In multisite, can individual site admins manage their own connection?
709
				 *
710
				 * Ideally, this should be extracted out to a separate filter in the Jetpack_Network class.
711
				 */
712
				if ( is_multisite() && ! is_super_admin() && is_plugin_active_for_network( 'jetpack/jetpack.php' ) ) {
713
					if ( ! Jetpack_Network::init()->get_option( 'sub-site-connection-override' ) ) {
714
						/**
715
						 * We need to update the option name -- it's terribly unclear which
716
						 * direction the override goes.
717
						 *
718
						 * @todo: Update the option name to `sub-sites-can-manage-own-connections`
719
						 */
720
						$caps = array( 'do_not_allow' );
721
						break;
722
					}
723
				}
724
725
				$caps = array( 'manage_options' );
726
				break;
727
			case 'jetpack_manage_modules' :
728
			case 'jetpack_activate_modules' :
729
			case 'jetpack_deactivate_modules' :
730
				$caps = array( 'manage_options' );
731
				break;
732
			case 'jetpack_configure_modules' :
733
				$caps = array( 'manage_options' );
734
				break;
735
			case 'jetpack_network_admin_page':
736
			case 'jetpack_network_settings_page':
737
				$caps = array( 'manage_network_plugins' );
738
				break;
739
			case 'jetpack_network_sites_page':
740
				$caps = array( 'manage_sites' );
741
				break;
742
			case 'jetpack_admin_page' :
743
				if ( Jetpack::is_development_mode() ) {
744
					$caps = array( 'manage_options' );
745
					break;
746
				} else {
747
					$caps = array( 'read' );
748
				}
749
				break;
750
			case 'jetpack_connect_user' :
751
				if ( Jetpack::is_development_mode() ) {
752
					$caps = array( 'do_not_allow' );
753
					break;
754
				}
755
				$caps = array( 'read' );
756
				break;
757
		}
758
		return $caps;
759
	}
760
761
	function require_jetpack_authentication() {
762
		// Don't let anyone authenticate
763
		$_COOKIE = array();
764
		remove_all_filters( 'authenticate' );
765
		remove_all_actions( 'wp_login_failed' );
766
767
		if ( Jetpack::is_active() ) {
768
			// Allow Jetpack authentication
769
			add_filter( 'authenticate', array( $this, 'authenticate_jetpack' ), 10, 3 );
770
		}
771
	}
772
773
	/**
774
	 * Load language files
775
	 * @action plugins_loaded
776
	 */
777
	public static function plugin_textdomain() {
778
		// Note to self, the third argument must not be hardcoded, to account for relocated folders.
779
		load_plugin_textdomain( 'jetpack', false, dirname( plugin_basename( JETPACK__PLUGIN_FILE ) ) . '/languages/' );
780
	}
781
782
	/**
783
	 * Register assets for use in various modules and the Jetpack admin page.
784
	 *
785
	 * @uses wp_script_is, wp_register_script, plugins_url
786
	 * @action wp_loaded
787
	 * @return null
788
	 */
789
	public function register_assets() {
790
		if ( ! wp_script_is( 'spin', 'registered' ) ) {
791
			wp_register_script( 'spin', plugins_url( '_inc/spin.js', JETPACK__PLUGIN_FILE ), false, '1.3' );
792
		}
793
794 View Code Duplication
		if ( ! wp_script_is( 'jquery.spin', 'registered' ) ) {
795
			wp_register_script( 'jquery.spin', plugins_url( '_inc/jquery.spin.js', JETPACK__PLUGIN_FILE ) , array( 'jquery', 'spin' ), '1.3' );
796
		}
797
798 View Code Duplication
		if ( ! wp_script_is( 'jetpack-gallery-settings', 'registered' ) ) {
799
			wp_register_script( 'jetpack-gallery-settings', plugins_url( '_inc/gallery-settings.js', JETPACK__PLUGIN_FILE ), array( 'media-views' ), '20121225' );
800
		}
801
802 View Code Duplication
		if ( ! wp_script_is( 'jetpack-twitter-timeline', 'registered' ) ) {
803
			wp_register_script( 'jetpack-twitter-timeline', plugins_url( '_inc/twitter-timeline.js', JETPACK__PLUGIN_FILE ) , array( 'jquery' ), '4.0.0', true );
804
		}
805
806
		if ( ! wp_script_is( 'jetpack-facebook-embed', 'registered' ) ) {
807
			wp_register_script( 'jetpack-facebook-embed', plugins_url( '_inc/facebook-embed.js', __FILE__ ), array( 'jquery' ), null, true );
808
809
			/** This filter is documented in modules/sharedaddy/sharing-sources.php */
810
			$fb_app_id = apply_filters( 'jetpack_sharing_facebook_app_id', '249643311490' );
811
			if ( ! is_numeric( $fb_app_id ) ) {
812
				$fb_app_id = '';
813
			}
814
			wp_localize_script(
815
				'jetpack-facebook-embed',
816
				'jpfbembed',
817
				array(
818
					'appid' => $fb_app_id,
819
					'locale' => $this->get_locale(),
820
				)
821
			);
822
		}
823
824
		/**
825
		 * As jetpack_register_genericons is by default fired off a hook,
826
		 * the hook may have already fired by this point.
827
		 * So, let's just trigger it manually.
828
		 */
829
		require_once( JETPACK__PLUGIN_DIR . '_inc/genericons.php' );
830
		jetpack_register_genericons();
831
832
		/**
833
		 * Register the social logos
834
		 */
835
		require_once( JETPACK__PLUGIN_DIR . '_inc/social-logos.php' );
836
		jetpack_register_social_logos();
837
838 View Code Duplication
		if ( ! wp_style_is( 'jetpack-icons', 'registered' ) )
839
			wp_register_style( 'jetpack-icons', plugins_url( 'css/jetpack-icons.min.css', JETPACK__PLUGIN_FILE ), false, JETPACK__VERSION );
840
	}
841
842
	/**
843
	 * Guess locale from language code.
844
	 *
845
	 * @param string $lang Language code.
846
	 * @return string|bool
847
	 */
848 View Code Duplication
	function guess_locale_from_lang( $lang ) {
849
		if ( 'en' === $lang || 'en_US' === $lang || ! $lang ) {
850
			return 'en_US';
851
		}
852
853
		if ( ! class_exists( 'GP_Locales' ) ) {
854
			if ( ! defined( 'JETPACK__GLOTPRESS_LOCALES_PATH' ) || ! file_exists( JETPACK__GLOTPRESS_LOCALES_PATH ) ) {
855
				return false;
856
			}
857
858
			require JETPACK__GLOTPRESS_LOCALES_PATH;
859
		}
860
861
		if ( defined( 'IS_WPCOM' ) && IS_WPCOM ) {
862
			// WP.com: get_locale() returns 'it'
863
			$locale = GP_Locales::by_slug( $lang );
864
		} else {
865
			// Jetpack: get_locale() returns 'it_IT';
866
			$locale = GP_Locales::by_field( 'facebook_locale', $lang );
867
		}
868
869
		if ( ! $locale ) {
870
			return false;
871
		}
872
873
		if ( empty( $locale->facebook_locale ) ) {
874
			if ( empty( $locale->wp_locale ) ) {
875
				return false;
876
			} else {
877
				// Facebook SDK is smart enough to fall back to en_US if a
878
				// locale isn't supported. Since supported Facebook locales
879
				// can fall out of sync, we'll attempt to use the known
880
				// wp_locale value and rely on said fallback.
881
				return $locale->wp_locale;
882
			}
883
		}
884
885
		return $locale->facebook_locale;
886
	}
887
888
	/**
889
	 * Get the locale.
890
	 *
891
	 * @return string|bool
892
	 */
893
	function get_locale() {
894
		$locale = $this->guess_locale_from_lang( get_locale() );
895
896
		if ( ! $locale ) {
897
			$locale = 'en_US';
898
		}
899
900
		return $locale;
901
	}
902
903
	/**
904
	 * Device Pixels support
905
	 * This improves the resolution of gravatars and wordpress.com uploads on hi-res and zoomed browsers.
906
	 */
907
	function devicepx() {
908
		if ( Jetpack::is_active() ) {
909
			wp_enqueue_script( 'devicepx', 'https://s0.wp.com/wp-content/js/devicepx-jetpack.js', array(), gmdate( 'oW' ), true );
910
		}
911
	}
912
913
	/**
914
	 * Return the network_site_url so that .com knows what network this site is a part of.
915
	 * @param  bool $option
916
	 * @return string
917
	 */
918
	public function jetpack_main_network_site_option( $option ) {
919
		return network_site_url();
920
	}
921
	/**
922
	 * Network Name.
923
	 */
924
	static function network_name( $option = null ) {
925
		global $current_site;
926
		return $current_site->site_name;
927
	}
928
	/**
929
	 * Does the network allow new user and site registrations.
930
	 * @return string
931
	 */
932
	static function network_allow_new_registrations( $option = null ) {
933
		return ( in_array( get_site_option( 'registration' ), array('none', 'user', 'blog', 'all' ) ) ? get_site_option( 'registration') : 'none' );
934
	}
935
	/**
936
	 * Does the network allow admins to add new users.
937
	 * @return boolian
938
	 */
939
	static function network_add_new_users( $option = null ) {
940
		return (bool) get_site_option( 'add_new_users' );
941
	}
942
	/**
943
	 * File upload psace left per site in MB.
944
	 *  -1 means NO LIMIT.
945
	 * @return number
946
	 */
947
	static function network_site_upload_space( $option = null ) {
948
		// value in MB
949
		return ( get_site_option( 'upload_space_check_disabled' ) ? -1 : get_space_allowed() );
950
	}
951
952
	/**
953
	 * Network allowed file types.
954
	 * @return string
955
	 */
956
	static function network_upload_file_types( $option = null ) {
957
		return get_site_option( 'upload_filetypes', 'jpg jpeg png gif' );
958
	}
959
960
	/**
961
	 * Maximum file upload size set by the network.
962
	 * @return number
963
	 */
964
	static function network_max_upload_file_size( $option = null ) {
965
		// value in KB
966
		return get_site_option( 'fileupload_maxk', 300 );
967
	}
968
969
	/**
970
	 * Lets us know if a site allows admins to manage the network.
971
	 * @return array
972
	 */
973
	static function network_enable_administration_menus( $option = null ) {
974
		return get_site_option( 'menu_items' );
975
	}
976
977
	/**
978
	 * If a user has been promoted to or demoted from admin, we need to clear the
979
	 * jetpack_other_linked_admins transient.
980
	 *
981
	 * @since 4.3.2
982
	 * @since 4.4.0  $old_roles is null by default and if it's not passed, the transient is cleared.
983
	 *
984
	 * @param int    $user_id   The user ID whose role changed.
985
	 * @param string $role      The new role.
986
	 * @param array  $old_roles An array of the user's previous roles.
987
	 */
988
	function maybe_clear_other_linked_admins_transient( $user_id, $role, $old_roles = null ) {
989
		if ( 'administrator' == $role
990
			|| ( is_array( $old_roles ) && in_array( 'administrator', $old_roles ) )
991
			|| is_null( $old_roles )
992
		) {
993
			delete_transient( 'jetpack_other_linked_admins' );
994
		}
995
	}
996
997
	/**
998
	 * Checks to see if there are any other users available to become primary
999
	 * Users must both:
1000
	 * - Be linked to wpcom
1001
	 * - Be an admin
1002
	 *
1003
	 * @return mixed False if no other users are linked, Int if there are.
1004
	 */
1005
	static function get_other_linked_admins() {
1006
		$other_linked_users = get_transient( 'jetpack_other_linked_admins' );
1007
1008
		if ( false === $other_linked_users ) {
1009
			$admins = get_users( array( 'role' => 'administrator' ) );
1010
			if ( count( $admins ) > 1 ) {
1011
				$available = array();
1012
				foreach ( $admins as $admin ) {
1013
					if ( Jetpack::is_user_connected( $admin->ID ) ) {
1014
						$available[] = $admin->ID;
1015
					}
1016
				}
1017
1018
				$count_connected_admins = count( $available );
1019
				if ( count( $available ) > 1 ) {
1020
					$other_linked_users = $count_connected_admins;
1021
				} else {
1022
					$other_linked_users = 0;
1023
				}
1024
			} else {
1025
				$other_linked_users = 0;
1026
			}
1027
1028
			set_transient( 'jetpack_other_linked_admins', $other_linked_users, HOUR_IN_SECONDS );
1029
		}
1030
1031
		return ( 0 === $other_linked_users ) ? false : $other_linked_users;
1032
	}
1033
1034
	/**
1035
	 * Return whether we are dealing with a multi network setup or not.
1036
	 * The reason we are type casting this is because we want to avoid the situation where
1037
	 * the result is false since when is_main_network_option return false it cases
1038
	 * the rest the get_option( 'jetpack_is_multi_network' ); to return the value that is set in the
1039
	 * database which could be set to anything as opposed to what this function returns.
1040
	 * @param  bool  $option
1041
	 *
1042
	 * @return boolean
1043
	 */
1044
	public function is_main_network_option( $option ) {
1045
		// return '1' or ''
1046
		return (string) (bool) Jetpack::is_multi_network();
1047
	}
1048
1049
	/**
1050
	 * Return true if we are with multi-site or multi-network false if we are dealing with single site.
1051
	 *
1052
	 * @param  string  $option
1053
	 * @return boolean
1054
	 */
1055
	public function is_multisite( $option ) {
1056
		return (string) (bool) is_multisite();
1057
	}
1058
1059
	/**
1060
	 * Implemented since there is no core is multi network function
1061
	 * Right now there is no way to tell if we which network is the dominant network on the system
1062
	 *
1063
	 * @since  3.3
1064
	 * @return boolean
1065
	 */
1066
	public static function is_multi_network() {
1067
		global  $wpdb;
1068
1069
		// if we don't have a multi site setup no need to do any more
1070
		if ( ! is_multisite() ) {
1071
			return false;
1072
		}
1073
1074
		$num_sites = $wpdb->get_var( "SELECT COUNT(*) FROM {$wpdb->site}" );
1075
		if ( $num_sites > 1 ) {
1076
			return true;
1077
		} else {
1078
			return false;
1079
		}
1080
	}
1081
1082
	/**
1083
	 * Trigger an update to the main_network_site when we update the siteurl of a site.
1084
	 * @return null
1085
	 */
1086
	function update_jetpack_main_network_site_option() {
1087
		_deprecated_function( __METHOD__, 'jetpack-4.2' );
1088
	}
1089
	/**
1090
	 * Triggered after a user updates the network settings via Network Settings Admin Page
1091
	 *
1092
	 */
1093
	function update_jetpack_network_settings() {
1094
		_deprecated_function( __METHOD__, 'jetpack-4.2' );
1095
		// Only sync this info for the main network site.
1096
	}
1097
1098
	/**
1099
	 * Get back if the current site is single user site.
1100
	 *
1101
	 * @return bool
1102
	 */
1103
	public static function is_single_user_site() {
1104
		global $wpdb;
1105
1106 View Code Duplication
		if ( false === ( $some_users = get_transient( 'jetpack_is_single_user' ) ) ) {
1107
			$some_users = $wpdb->get_var( "SELECT COUNT(*) FROM (SELECT user_id FROM $wpdb->usermeta WHERE meta_key = '{$wpdb->prefix}capabilities' LIMIT 2) AS someusers" );
1108
			set_transient( 'jetpack_is_single_user', (int) $some_users, 12 * HOUR_IN_SECONDS );
1109
		}
1110
		return 1 === (int) $some_users;
1111
	}
1112
1113
	/**
1114
	 * Returns true if the site has file write access false otherwise.
1115
	 * @return string ( '1' | '0' )
1116
	 **/
1117
	public static function file_system_write_access() {
1118
		if ( ! function_exists( 'get_filesystem_method' ) ) {
1119
			require_once( ABSPATH . 'wp-admin/includes/file.php' );
1120
		}
1121
1122
		require_once( ABSPATH . 'wp-admin/includes/template.php' );
1123
1124
		$filesystem_method = get_filesystem_method();
1125
		if ( $filesystem_method === 'direct' ) {
1126
			return 1;
1127
		}
1128
1129
		ob_start();
1130
		$filesystem_credentials_are_stored = request_filesystem_credentials( self_admin_url() );
1131
		ob_end_clean();
1132
		if ( $filesystem_credentials_are_stored ) {
1133
			return 1;
1134
		}
1135
		return 0;
1136
	}
1137
1138
	/**
1139
	 * Finds out if a site is using a version control system.
1140
	 * @return string ( '1' | '0' )
1141
	 **/
1142
	public static function is_version_controlled() {
1143
		_deprecated_function( __METHOD__, 'jetpack-4.2', 'Jetpack_Sync_Functions::is_version_controlled' );
1144
		return (string) (int) Jetpack_Sync_Functions::is_version_controlled();
1145
	}
1146
1147
	/**
1148
	 * Determines whether the current theme supports featured images or not.
1149
	 * @return string ( '1' | '0' )
1150
	 */
1151
	public static function featured_images_enabled() {
1152
		_deprecated_function( __METHOD__, 'jetpack-4.2' );
1153
		return current_theme_supports( 'post-thumbnails' ) ? '1' : '0';
1154
	}
1155
1156
	/**
1157
	 * Wrapper for core's get_avatar_url().  This one is deprecated.
1158
	 *
1159
	 * @deprecated 4.7 use get_avatar_url instead.
1160
	 * @param int|string|object $id_or_email A user ID,  email address, or comment object
1161
	 * @param int $size Size of the avatar image
1162
	 * @param string $default URL to a default image to use if no avatar is available
1163
	 * @param bool $force_display Whether to force it to return an avatar even if show_avatars is disabled
1164
	 *
1165
	 * @return array
1166
	 */
1167
	public static function get_avatar_url( $id_or_email, $size = 96, $default = '', $force_display = false ) {
1168
		_deprecated_function( __METHOD__, 'jetpack-4.7', 'get_avatar_url' );
1169
		return get_avatar_url( $id_or_email, array(
1170
			'size' => $size,
1171
			'default' => $default,
1172
			'force_default' => $force_display,
1173
		) );
1174
	}
1175
1176
	/**
1177
	 * jetpack_updates is saved in the following schema:
1178
	 *
1179
	 * array (
1180
	 *      'plugins'                       => (int) Number of plugin updates available.
1181
	 *      'themes'                        => (int) Number of theme updates available.
1182
	 *      'wordpress'                     => (int) Number of WordPress core updates available.
1183
	 *      'translations'                  => (int) Number of translation updates available.
1184
	 *      'total'                         => (int) Total of all available updates.
1185
	 *      'wp_update_version'             => (string) The latest available version of WordPress, only present if a WordPress update is needed.
1186
	 * )
1187
	 * @return array
1188
	 */
1189
	public static function get_updates() {
1190
		$update_data = wp_get_update_data();
1191
1192
		// Stores the individual update counts as well as the total count.
1193
		if ( isset( $update_data['counts'] ) ) {
1194
			$updates = $update_data['counts'];
1195
		}
1196
1197
		// If we need to update WordPress core, let's find the latest version number.
1198 View Code Duplication
		if ( ! empty( $updates['wordpress'] ) ) {
1199
			$cur = get_preferred_from_update_core();
1200
			if ( isset( $cur->response ) && 'upgrade' === $cur->response ) {
1201
				$updates['wp_update_version'] = $cur->current;
1202
			}
1203
		}
1204
		return isset( $updates ) ? $updates : array();
1205
	}
1206
1207
	public static function get_update_details() {
1208
		$update_details = array(
1209
			'update_core' => get_site_transient( 'update_core' ),
1210
			'update_plugins' => get_site_transient( 'update_plugins' ),
1211
			'update_themes' => get_site_transient( 'update_themes' ),
1212
		);
1213
		return $update_details;
1214
	}
1215
1216
	public static function refresh_update_data() {
1217
		_deprecated_function( __METHOD__, 'jetpack-4.2' );
1218
1219
	}
1220
1221
	public static function refresh_theme_data() {
1222
		_deprecated_function( __METHOD__, 'jetpack-4.2' );
1223
	}
1224
1225
	/**
1226
	 * Is Jetpack active?
1227
	 */
1228
	public static function is_active() {
1229
		return (bool) Jetpack_Data::get_access_token( JETPACK_MASTER_USER );
1230
	}
1231
1232
	/**
1233
	 * Make an API call to WordPress.com for plan status
1234
	 *
1235
	 * @uses Jetpack_Options::get_option()
1236
	 * @uses Jetpack_Client::wpcom_json_api_request_as_blog()
1237
	 * @uses update_option()
1238
	 *
1239
	 * @access public
1240
	 * @static
1241
	 *
1242
	 * @return bool True if plan is updated, false if no update
1243
	 */
1244
	public static function refresh_active_plan_from_wpcom() {
1245
		// Make the API request
1246
		$request = sprintf( '/sites/%d', Jetpack_Options::get_option( 'id' ) );
1247
		$response = Jetpack_Client::wpcom_json_api_request_as_blog( $request, '1.1' );
1248
1249
		// Bail if there was an error or malformed response
1250
		if ( is_wp_error( $response ) || ! is_array( $response ) || ! isset( $response['body'] ) ) {
1251
			return false;
1252
		}
1253
1254
		// Decode the results
1255
		$results = json_decode( $response['body'], true );
1256
1257
		// Bail if there were no results or plan details returned
1258
		if ( ! is_array( $results ) || ! isset( $results['plan'] ) ) {
1259
			return false;
1260
		}
1261
1262
		// Store the option and return true if updated
1263
		return update_option( 'jetpack_active_plan', $results['plan'] );
1264
	}
1265
1266
	/**
1267
	 * Get the plan that this Jetpack site is currently using
1268
	 *
1269
	 * @uses get_option()
1270
	 *
1271
	 * @access public
1272
	 * @static
1273
	 *
1274
	 * @return array Active Jetpack plan details
1275
	 */
1276
	public static function get_active_plan() {
1277
		$plan = get_option( 'jetpack_active_plan' );
1278
1279
		// Set the default options
1280
		if ( ! $plan ) {
1281
			$plan = array(
1282
				'product_slug' => 'jetpack_free',
1283
				'supports'     => array(),
1284
				'class'        => 'free',
1285
			);
1286
		}
1287
1288
		// Define what paid modules are supported by personal plans
1289
		$personal_plans = array(
1290
			'jetpack_personal',
1291
			'jetpack_personal_monthly',
1292
			'personal-bundle',
1293
		);
1294
1295
		if ( in_array( $plan['product_slug'], $personal_plans ) ) {
1296
			$plan['supports'] = array(
1297
				'akismet',
1298
			);
1299
			$plan['class'] = 'personal';
1300
		}
1301
1302
		// Define what paid modules are supported by premium plans
1303
		$premium_plans = array(
1304
			'jetpack_premium',
1305
			'jetpack_premium_monthly',
1306
			'value_bundle',
1307
		);
1308
1309 View Code Duplication
		if ( in_array( $plan['product_slug'], $premium_plans ) ) {
1310
			$plan['supports'] = array(
1311
				'videopress',
1312
				'akismet',
1313
				'vaultpress',
1314
				'wordads',
1315
			);
1316
			$plan['class'] = 'premium';
1317
		}
1318
1319
		// Define what paid modules are supported by professional plans
1320
		$business_plans = array(
1321
			'jetpack_business',
1322
			'jetpack_business_monthly',
1323
			'business-bundle',
1324
		);
1325
1326 View Code Duplication
		if ( in_array( $plan['product_slug'], $business_plans ) ) {
1327
			$plan['supports'] = array(
1328
				'videopress',
1329
				'akismet',
1330
				'vaultpress',
1331
				'seo-tools',
1332
				'google-analytics',
1333
				'wordads',
1334
			);
1335
			$plan['class'] = 'business';
1336
		}
1337
1338
		// Make sure we have an array here in the event database data is stale
1339
		if ( ! isset( $plan['supports'] ) ) {
1340
			$plan['supports'] = array();
1341
		}
1342
1343
		return $plan;
1344
	}
1345
1346
	/**
1347
	 * Determine whether the active plan supports a particular feature
1348
	 *
1349
	 * @uses Jetpack::get_active_plan()
1350
	 *
1351
	 * @access public
1352
	 * @static
1353
	 *
1354
	 * @return bool True if plan supports feature, false if not
1355
	 */
1356
	public static function active_plan_supports( $feature ) {
1357
		$plan = Jetpack::get_active_plan();
1358
1359
		if ( in_array( $feature, $plan['supports'] ) ) {
1360
			return true;
1361
		}
1362
1363
		return false;
1364
	}
1365
1366
	/**
1367
	 * Is Jetpack in development (offline) mode?
1368
	 */
1369
	public static function is_development_mode() {
1370
		$development_mode = false;
1371
1372
		if ( defined( 'JETPACK_DEV_DEBUG' ) ) {
1373
			$development_mode = JETPACK_DEV_DEBUG;
1374
		} elseif ( $site_url = site_url() ) {
1375
			$development_mode = false === strpos( $site_url, '.' );
1376
		}
1377
1378
		/**
1379
		 * Filters Jetpack's development mode.
1380
		 *
1381
		 * @see https://jetpack.com/support/development-mode/
1382
		 *
1383
		 * @since 2.2.1
1384
		 *
1385
		 * @param bool $development_mode Is Jetpack's development mode active.
1386
		 */
1387
		return apply_filters( 'jetpack_development_mode', $development_mode );
1388
	}
1389
1390
	/**
1391
	* Get Jetpack development mode notice text and notice class.
1392
	*
1393
	* Mirrors the checks made in Jetpack::is_development_mode
1394
	*
1395
	*/
1396
	public static function show_development_mode_notice() {
1397
		if ( Jetpack::is_development_mode() ) {
1398
			if ( defined( 'JETPACK_DEV_DEBUG' ) && JETPACK_DEV_DEBUG ) {
1399
				$notice = sprintf(
1400
					/* translators: %s is a URL */
1401
					__( 'In <a href="%s" target="_blank">Development Mode</a>, via the JETPACK_DEV_DEBUG constant being defined in wp-config.php or elsewhere.', 'jetpack' ),
1402
					'https://jetpack.com/support/development-mode/'
1403
				);
1404
			} elseif ( site_url() && false === strpos( site_url(), '.' ) ) {
1405
				$notice = sprintf(
1406
					/* translators: %s is a URL */
1407
					__( 'In <a href="%s" target="_blank">Development Mode</a>, via site URL lacking a dot (e.g. http://localhost).', 'jetpack' ),
1408
					'https://jetpack.com/support/development-mode/'
1409
				);
1410
			} else {
1411
				$notice = sprintf(
1412
					/* translators: %s is a URL */
1413
					__( 'In <a href="%s" target="_blank">Development Mode</a>, via the jetpack_development_mode filter.', 'jetpack' ),
1414
					'https://jetpack.com/support/development-mode/'
1415
				);
1416
			}
1417
1418
			echo '<div class="updated" style="border-color: #f0821e;"><p>' . $notice . '</p></div>';
1419
		}
1420
1421
		// Throw up a notice if using a development version and as for feedback.
1422
		if ( Jetpack::is_development_version() ) {
1423
			/* translators: %s is a URL */
1424
			$notice = sprintf( __( 'You are currently running a development version of Jetpack. <a href="%s" target="_blank">Submit your feedback</a>', 'jetpack' ), 'https://jetpack.com/contact-support/beta-group/' );
1425
1426
			echo '<div class="updated" style="border-color: #f0821e;"><p>' . $notice . '</p></div>';
1427
		}
1428
		// Throw up a notice if using staging mode
1429
		if ( Jetpack::is_staging_site() ) {
1430
			/* translators: %s is a URL */
1431
			$notice = sprintf( __( 'You are running Jetpack on a <a href="%s" target="_blank">staging server</a>.', 'jetpack' ), 'https://jetpack.com/support/staging-sites/' );
1432
1433
			echo '<div class="updated" style="border-color: #f0821e;"><p>' . $notice . '</p></div>';
1434
		}
1435
	}
1436
1437
	/**
1438
	 * Whether Jetpack's version maps to a public release, or a development version.
1439
	 */
1440
	public static function is_development_version() {
1441
		/**
1442
		 * Allows filtering whether this is a development version of Jetpack.
1443
		 *
1444
		 * This filter is especially useful for tests.
1445
		 *
1446
		 * @since 4.3.0
1447
		 *
1448
		 * @param bool $development_version Is this a develoment version of Jetpack?
1449
		 */
1450
		return (bool) apply_filters(
1451
			'jetpack_development_version',
1452
			! preg_match( '/^\d+(\.\d+)+$/', Jetpack_Constants::get_constant( 'JETPACK__VERSION' ) )
1453
		);
1454
	}
1455
1456
	/**
1457
	 * Is a given user (or the current user if none is specified) linked to a WordPress.com user?
1458
	 */
1459
	public static function is_user_connected( $user_id = false ) {
1460
		$user_id = false === $user_id ? get_current_user_id() : absint( $user_id );
1461
		if ( ! $user_id ) {
1462
			return false;
1463
		}
1464
1465
		return (bool) Jetpack_Data::get_access_token( $user_id );
1466
	}
1467
1468
	/**
1469
	 * Get the wpcom user data of the current|specified connected user.
1470
	 */
1471
	public static function get_connected_user_data( $user_id = null ) {
1472
		if ( ! $user_id ) {
1473
			$user_id = get_current_user_id();
1474
		}
1475
1476
		$transient_key = "jetpack_connected_user_data_$user_id";
1477
1478
		if ( $cached_user_data = get_transient( $transient_key ) ) {
1479
			return $cached_user_data;
1480
		}
1481
1482
		Jetpack::load_xml_rpc_client();
1483
		$xml = new Jetpack_IXR_Client( array(
1484
			'user_id' => $user_id,
1485
		) );
1486
		$xml->query( 'wpcom.getUser' );
1487
		if ( ! $xml->isError() ) {
1488
			$user_data = $xml->getResponse();
1489
			set_transient( $transient_key, $xml->getResponse(), DAY_IN_SECONDS );
1490
			return $user_data;
1491
		}
1492
1493
		return false;
1494
	}
1495
1496
	/**
1497
	 * Get the wpcom email of the current|specified connected user.
1498
	 */
1499 View Code Duplication
	public static function get_connected_user_email( $user_id = null ) {
1500
		if ( ! $user_id ) {
1501
			$user_id = get_current_user_id();
1502
		}
1503
		Jetpack::load_xml_rpc_client();
1504
		$xml = new Jetpack_IXR_Client( array(
1505
			'user_id' => $user_id,
1506
		) );
1507
		$xml->query( 'wpcom.getUserEmail' );
1508
		if ( ! $xml->isError() ) {
1509
			return $xml->getResponse();
1510
		}
1511
		return false;
1512
	}
1513
1514
	/**
1515
	 * Get the wpcom email of the master user.
1516
	 */
1517
	public static function get_master_user_email() {
1518
		$master_user_id = Jetpack_Options::get_option( 'master_user' );
1519
		if ( $master_user_id ) {
1520
			return self::get_connected_user_email( $master_user_id );
1521
		}
1522
		return '';
1523
	}
1524
1525
	function current_user_is_connection_owner() {
1526
		$user_token = Jetpack_Data::get_access_token( JETPACK_MASTER_USER );
1527
		return $user_token && is_object( $user_token ) && isset( $user_token->external_user_id ) && get_current_user_id() === $user_token->external_user_id;
1528
	}
1529
1530
	/**
1531
	 * Add any extra oEmbed providers that we know about and use on wpcom for feature parity.
1532
	 */
1533
	function extra_oembed_providers() {
1534
		// Cloudup: https://dev.cloudup.com/#oembed
1535
		wp_oembed_add_provider( 'https://cloudup.com/*' , 'https://cloudup.com/oembed' );
1536
		wp_oembed_add_provider( 'https://me.sh/*', 'https://me.sh/oembed?format=json' );
1537
		wp_oembed_add_provider( '#https?://(www\.)?gfycat\.com/.*#i', 'https://api.gfycat.com/v1/oembed', true );
1538
		wp_oembed_add_provider( '#https?://[^.]+\.(wistia\.com|wi\.st)/(medias|embed)/.*#', 'https://fast.wistia.com/oembed', true );
1539
		wp_oembed_add_provider( '#https?://sketchfab\.com/.*#i', 'https://sketchfab.com/oembed', true );
1540
		wp_oembed_add_provider( '#https?://(www\.)?icloud\.com/keynote/.*#i', 'https://iwmb.icloud.com/iwmb/oembed', true );
1541
	}
1542
1543
	/**
1544
	 * Synchronize connected user role changes
1545
	 */
1546
	function user_role_change( $user_id ) {
1547
		_deprecated_function( __METHOD__, 'jetpack-4.2', 'Jetpack_Sync_Users::user_role_change()' );
1548
		Jetpack_Sync_Users::user_role_change( $user_id );
1549
	}
1550
1551
	/**
1552
	 * Loads the currently active modules.
1553
	 */
1554
	public static function load_modules() {
1555
		if ( ! self::is_active() && !self::is_development_mode() ) {
1556
			if ( ! is_multisite() || ! get_site_option( 'jetpack_protect_active' ) ) {
1557
				return;
1558
			}
1559
		}
1560
1561
		$version = Jetpack_Options::get_option( 'version' );
1562 View Code Duplication
		if ( ! $version ) {
1563
			$version = $old_version = JETPACK__VERSION . ':' . time();
1564
			/** This action is documented in class.jetpack.php */
1565
			do_action( 'updating_jetpack_version', $version, false );
1566
			Jetpack_Options::update_options( compact( 'version', 'old_version' ) );
1567
		}
1568
		list( $version ) = explode( ':', $version );
1569
1570
		$modules = array_filter( Jetpack::get_active_modules(), array( 'Jetpack', 'is_module' ) );
1571
1572
		$modules_data = array();
1573
1574
		// Don't load modules that have had "Major" changes since the stored version until they have been deactivated/reactivated through the lint check.
1575
		if ( version_compare( $version, JETPACK__VERSION, '<' ) ) {
1576
			$updated_modules = array();
1577
			foreach ( $modules as $module ) {
1578
				$modules_data[ $module ] = Jetpack::get_module( $module );
1579
				if ( ! isset( $modules_data[ $module ]['changed'] ) ) {
1580
					continue;
1581
				}
1582
1583
				if ( version_compare( $modules_data[ $module ]['changed'], $version, '<=' ) ) {
1584
					continue;
1585
				}
1586
1587
				$updated_modules[] = $module;
1588
			}
1589
1590
			$modules = array_diff( $modules, $updated_modules );
1591
		}
1592
1593
		$is_development_mode = Jetpack::is_development_mode();
1594
1595
		foreach ( $modules as $index => $module ) {
1596
			// If we're in dev mode, disable modules requiring a connection
1597
			if ( $is_development_mode ) {
1598
				// Prime the pump if we need to
1599
				if ( empty( $modules_data[ $module ] ) ) {
1600
					$modules_data[ $module ] = Jetpack::get_module( $module );
1601
				}
1602
				// If the module requires a connection, but we're in local mode, don't include it.
1603
				if ( $modules_data[ $module ]['requires_connection'] ) {
1604
					continue;
1605
				}
1606
			}
1607
1608
			if ( did_action( 'jetpack_module_loaded_' . $module ) ) {
1609
				continue;
1610
			}
1611
1612
			if ( ! include_once( Jetpack::get_module_path( $module ) ) ) {
1613
				unset( $modules[ $index ] );
1614
				self::update_active_modules( array_values( $modules ) );
1615
				continue;
1616
			}
1617
1618
			/**
1619
			 * Fires when a specific module is loaded.
1620
			 * The dynamic part of the hook, $module, is the module slug.
1621
			 *
1622
			 * @since 1.1.0
1623
			 */
1624
			do_action( 'jetpack_module_loaded_' . $module );
1625
		}
1626
1627
		/**
1628
		 * Fires when all the modules are loaded.
1629
		 *
1630
		 * @since 1.1.0
1631
		 */
1632
		do_action( 'jetpack_modules_loaded' );
1633
1634
		// 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.
1635
		if ( Jetpack::is_active() || Jetpack::is_development_mode() )
1636
			require_once( JETPACK__PLUGIN_DIR . 'modules/module-extras.php' );
1637
	}
1638
1639
	/**
1640
	 * Check if Jetpack's REST API compat file should be included
1641
	 * @action plugins_loaded
1642
	 * @return null
1643
	 */
1644
	public function check_rest_api_compat() {
1645
		/**
1646
		 * Filters the list of REST API compat files to be included.
1647
		 *
1648
		 * @since 2.2.5
1649
		 *
1650
		 * @param array $args Array of REST API compat files to include.
1651
		 */
1652
		$_jetpack_rest_api_compat_includes = apply_filters( 'jetpack_rest_api_compat', array() );
1653
1654
		if ( function_exists( 'bbpress' ) )
1655
			$_jetpack_rest_api_compat_includes[] = JETPACK__PLUGIN_DIR . 'class.jetpack-bbpress-json-api-compat.php';
1656
1657
		foreach ( $_jetpack_rest_api_compat_includes as $_jetpack_rest_api_compat_include )
1658
			require_once $_jetpack_rest_api_compat_include;
1659
	}
1660
1661
	/**
1662
	 * Gets all plugins currently active in values, regardless of whether they're
1663
	 * traditionally activated or network activated.
1664
	 *
1665
	 * @todo Store the result in core's object cache maybe?
1666
	 */
1667
	public static function get_active_plugins() {
1668
		$active_plugins = (array) get_option( 'active_plugins', array() );
1669
1670
		if ( is_multisite() ) {
1671
			// Due to legacy code, active_sitewide_plugins stores them in the keys,
1672
			// whereas active_plugins stores them in the values.
1673
			$network_plugins = array_keys( get_site_option( 'active_sitewide_plugins', array() ) );
1674
			if ( $network_plugins ) {
1675
				$active_plugins = array_merge( $active_plugins, $network_plugins );
1676
			}
1677
		}
1678
1679
		sort( $active_plugins );
1680
1681
		return array_unique( $active_plugins );
1682
	}
1683
1684
	/**
1685
	 * Gets and parses additional plugin data to send with the heartbeat data
1686
	 *
1687
	 * @since 3.8.1
1688
	 *
1689
	 * @return array Array of plugin data
1690
	 */
1691
	public static function get_parsed_plugin_data() {
1692
		if ( ! function_exists( 'get_plugins' ) ) {
1693
			require_once( ABSPATH . 'wp-admin/includes/plugin.php' );
1694
		}
1695
		/** This filter is documented in wp-admin/includes/class-wp-plugins-list-table.php */
1696
		$all_plugins    = apply_filters( 'all_plugins', get_plugins() );
1697
		$active_plugins = Jetpack::get_active_plugins();
1698
1699
		$plugins = array();
1700
		foreach ( $all_plugins as $path => $plugin_data ) {
1701
			$plugins[ $path ] = array(
1702
					'is_active' => in_array( $path, $active_plugins ),
1703
					'file'      => $path,
1704
					'name'      => $plugin_data['Name'],
1705
					'version'   => $plugin_data['Version'],
1706
					'author'    => $plugin_data['Author'],
1707
			);
1708
		}
1709
1710
		return $plugins;
1711
	}
1712
1713
	/**
1714
	 * Gets and parses theme data to send with the heartbeat data
1715
	 *
1716
	 * @since 3.8.1
1717
	 *
1718
	 * @return array Array of theme data
1719
	 */
1720
	public static function get_parsed_theme_data() {
1721
		$all_themes = wp_get_themes( array( 'allowed' => true ) );
1722
		$header_keys = array( 'Name', 'Author', 'Version', 'ThemeURI', 'AuthorURI', 'Status', 'Tags' );
1723
1724
		$themes = array();
1725
		foreach ( $all_themes as $slug => $theme_data ) {
1726
			$theme_headers = array();
1727
			foreach ( $header_keys as $header_key ) {
1728
				$theme_headers[ $header_key ] = $theme_data->get( $header_key );
1729
			}
1730
1731
			$themes[ $slug ] = array(
1732
					'is_active_theme' => $slug == wp_get_theme()->get_template(),
1733
					'slug' => $slug,
1734
					'theme_root' => $theme_data->get_theme_root_uri(),
1735
					'parent' => $theme_data->parent(),
1736
					'headers' => $theme_headers
1737
			);
1738
		}
1739
1740
		return $themes;
1741
	}
1742
1743
	/**
1744
	 * Checks whether a specific plugin is active.
1745
	 *
1746
	 * We don't want to store these in a static variable, in case
1747
	 * there are switch_to_blog() calls involved.
1748
	 */
1749
	public static function is_plugin_active( $plugin = 'jetpack/jetpack.php' ) {
1750
		return in_array( $plugin, self::get_active_plugins() );
1751
	}
1752
1753
	/**
1754
	 * Check if Jetpack's Open Graph tags should be used.
1755
	 * If certain plugins are active, Jetpack's og tags are suppressed.
1756
	 *
1757
	 * @uses Jetpack::get_active_modules, add_filter, get_option, apply_filters
1758
	 * @action plugins_loaded
1759
	 * @return null
1760
	 */
1761
	public function check_open_graph() {
1762
		if ( in_array( 'publicize', Jetpack::get_active_modules() ) || in_array( 'sharedaddy', Jetpack::get_active_modules() ) ) {
1763
			add_filter( 'jetpack_enable_open_graph', '__return_true', 0 );
1764
		}
1765
1766
		$active_plugins = self::get_active_plugins();
1767
1768
		if ( ! empty( $active_plugins ) ) {
1769
			foreach ( $this->open_graph_conflicting_plugins as $plugin ) {
1770
				if ( in_array( $plugin, $active_plugins ) ) {
1771
					add_filter( 'jetpack_enable_open_graph', '__return_false', 99 );
1772
					break;
1773
				}
1774
			}
1775
		}
1776
1777
		/**
1778
		 * Allow the addition of Open Graph Meta Tags to all pages.
1779
		 *
1780
		 * @since 2.0.3
1781
		 *
1782
		 * @param bool false Should Open Graph Meta tags be added. Default to false.
1783
		 */
1784
		if ( apply_filters( 'jetpack_enable_open_graph', false ) ) {
1785
			require_once JETPACK__PLUGIN_DIR . 'functions.opengraph.php';
1786
		}
1787
	}
1788
1789
	/**
1790
	 * Check if Jetpack's Twitter tags should be used.
1791
	 * If certain plugins are active, Jetpack's twitter tags are suppressed.
1792
	 *
1793
	 * @uses Jetpack::get_active_modules, add_filter, get_option, apply_filters
1794
	 * @action plugins_loaded
1795
	 * @return null
1796
	 */
1797
	public function check_twitter_tags() {
1798
1799
		$active_plugins = self::get_active_plugins();
1800
1801
		if ( ! empty( $active_plugins ) ) {
1802
			foreach ( $this->twitter_cards_conflicting_plugins as $plugin ) {
1803
				if ( in_array( $plugin, $active_plugins ) ) {
1804
					add_filter( 'jetpack_disable_twitter_cards', '__return_true', 99 );
1805
					break;
1806
				}
1807
			}
1808
		}
1809
1810
		/**
1811
		 * Allow Twitter Card Meta tags to be disabled.
1812
		 *
1813
		 * @since 2.6.0
1814
		 *
1815
		 * @param bool true Should Twitter Card Meta tags be disabled. Default to true.
1816
		 */
1817
		if ( ! apply_filters( 'jetpack_disable_twitter_cards', false ) ) {
1818
			require_once JETPACK__PLUGIN_DIR . 'class.jetpack-twitter-cards.php';
1819
		}
1820
	}
1821
1822
	/**
1823
	 * Allows plugins to submit security reports.
1824
 	 *
1825
	 * @param string  $type         Report type (login_form, backup, file_scanning, spam)
1826
	 * @param string  $plugin_file  Plugin __FILE__, so that we can pull plugin data
1827
	 * @param array   $args         See definitions above
1828
	 */
1829
	public static function submit_security_report( $type = '', $plugin_file = '', $args = array() ) {
1830
		_deprecated_function( __FUNCTION__, 'jetpack-4.2', null );
1831
	}
1832
1833
/* Jetpack Options API */
1834
1835
	public static function get_option_names( $type = 'compact' ) {
1836
		return Jetpack_Options::get_option_names( $type );
1837
	}
1838
1839
	/**
1840
	 * Returns the requested option.  Looks in jetpack_options or jetpack_$name as appropriate.
1841
 	 *
1842
	 * @param string $name    Option name
1843
	 * @param mixed  $default (optional)
1844
	 */
1845
	public static function get_option( $name, $default = false ) {
1846
		return Jetpack_Options::get_option( $name, $default );
1847
	}
1848
1849
	/**
1850
	* Stores two secrets and a timestamp so WordPress.com can make a request back and verify an action
1851
	* Does some extra verification so urls (such as those to public-api, register, etc) can't just be crafted
1852
	* $name must be a registered option name.
1853
	*/
1854
	public static function create_nonce( $name ) {
1855
		$secret = wp_generate_password( 32, false ) . ':' . wp_generate_password( 32, false ) . ':' . ( time() + 600 );
1856
1857
		Jetpack_Options::update_option( $name, $secret );
1858
		@list( $secret_1, $secret_2, $eol ) = explode( ':', Jetpack_Options::get_option( $name ) );
1859
		if ( empty( $secret_1 ) || empty( $secret_2 ) || $eol < time() )
1860
			return new Jetpack_Error( 'missing_secrets' );
1861
1862
		return array(
1863
			'secret_1' => $secret_1,
1864
			'secret_2' => $secret_2,
1865
			'eol'      => $eol,
1866
		);
1867
	}
1868
1869
	/**
1870
	 * Updates the single given option.  Updates jetpack_options or jetpack_$name as appropriate.
1871
 	 *
1872
	 * @deprecated 3.4 use Jetpack_Options::update_option() instead.
1873
	 * @param string $name  Option name
1874
	 * @param mixed  $value Option value
1875
	 */
1876
	public static function update_option( $name, $value ) {
1877
		_deprecated_function( __METHOD__, 'jetpack-3.4', 'Jetpack_Options::update_option()' );
1878
		return Jetpack_Options::update_option( $name, $value );
1879
	}
1880
1881
	/**
1882
	 * Updates the multiple given options.  Updates jetpack_options and/or jetpack_$name as appropriate.
1883
 	 *
1884
	 * @deprecated 3.4 use Jetpack_Options::update_options() instead.
1885
	 * @param array $array array( option name => option value, ... )
1886
	 */
1887
	public static function update_options( $array ) {
1888
		_deprecated_function( __METHOD__, 'jetpack-3.4', 'Jetpack_Options::update_options()' );
1889
		return Jetpack_Options::update_options( $array );
1890
	}
1891
1892
	/**
1893
	 * Deletes the given option.  May be passed multiple option names as an array.
1894
	 * Updates jetpack_options and/or deletes jetpack_$name as appropriate.
1895
	 *
1896
	 * @deprecated 3.4 use Jetpack_Options::delete_option() instead.
1897
	 * @param string|array $names
1898
	 */
1899
	public static function delete_option( $names ) {
1900
		_deprecated_function( __METHOD__, 'jetpack-3.4', 'Jetpack_Options::delete_option()' );
1901
		return Jetpack_Options::delete_option( $names );
1902
	}
1903
1904
	/**
1905
	 * Enters a user token into the user_tokens option
1906
	 *
1907
	 * @param int $user_id
1908
	 * @param string $token
1909
	 * return bool
1910
	 */
1911
	public static function update_user_token( $user_id, $token, $is_master_user ) {
1912
		// not designed for concurrent updates
1913
		$user_tokens = Jetpack_Options::get_option( 'user_tokens' );
1914
		if ( ! is_array( $user_tokens ) )
1915
			$user_tokens = array();
1916
		$user_tokens[$user_id] = $token;
1917
		if ( $is_master_user ) {
1918
			$master_user = $user_id;
1919
			$options     = compact( 'user_tokens', 'master_user' );
1920
		} else {
1921
			$options = compact( 'user_tokens' );
1922
		}
1923
		return Jetpack_Options::update_options( $options );
1924
	}
1925
1926
	/**
1927
	 * Returns an array of all PHP files in the specified absolute path.
1928
	 * Equivalent to glob( "$absolute_path/*.php" ).
1929
	 *
1930
	 * @param string $absolute_path The absolute path of the directory to search.
1931
	 * @return array Array of absolute paths to the PHP files.
1932
	 */
1933
	public static function glob_php( $absolute_path ) {
1934
		if ( function_exists( 'glob' ) ) {
1935
			return glob( "$absolute_path/*.php" );
1936
		}
1937
1938
		$absolute_path = untrailingslashit( $absolute_path );
1939
		$files = array();
1940
		if ( ! $dir = @opendir( $absolute_path ) ) {
1941
			return $files;
1942
		}
1943
1944
		while ( false !== $file = readdir( $dir ) ) {
1945
			if ( '.' == substr( $file, 0, 1 ) || '.php' != substr( $file, -4 ) ) {
1946
				continue;
1947
			}
1948
1949
			$file = "$absolute_path/$file";
1950
1951
			if ( ! is_file( $file ) ) {
1952
				continue;
1953
			}
1954
1955
			$files[] = $file;
1956
		}
1957
1958
		closedir( $dir );
1959
1960
		return $files;
1961
	}
1962
1963
	public static function activate_new_modules( $redirect = false ) {
1964
		if ( ! Jetpack::is_active() && ! Jetpack::is_development_mode() ) {
1965
			return;
1966
		}
1967
1968
		$jetpack_old_version = Jetpack_Options::get_option( 'version' ); // [sic]
1969 View Code Duplication
		if ( ! $jetpack_old_version ) {
1970
			$jetpack_old_version = $version = $old_version = '1.1:' . time();
1971
			/** This action is documented in class.jetpack.php */
1972
			do_action( 'updating_jetpack_version', $version, false );
1973
			Jetpack_Options::update_options( compact( 'version', 'old_version' ) );
1974
		}
1975
1976
		list( $jetpack_version ) = explode( ':', $jetpack_old_version ); // [sic]
1977
1978
		if ( version_compare( JETPACK__VERSION, $jetpack_version, '<=' ) ) {
1979
			return;
1980
		}
1981
1982
		$active_modules     = Jetpack::get_active_modules();
1983
		$reactivate_modules = array();
1984
		foreach ( $active_modules as $active_module ) {
1985
			$module = Jetpack::get_module( $active_module );
1986
			if ( ! isset( $module['changed'] ) ) {
1987
				continue;
1988
			}
1989
1990
			if ( version_compare( $module['changed'], $jetpack_version, '<=' ) ) {
1991
				continue;
1992
			}
1993
1994
			$reactivate_modules[] = $active_module;
1995
			Jetpack::deactivate_module( $active_module );
1996
		}
1997
1998
		$new_version = JETPACK__VERSION . ':' . time();
1999
		/** This action is documented in class.jetpack.php */
2000
		do_action( 'updating_jetpack_version', $new_version, $jetpack_old_version );
2001
		Jetpack_Options::update_options(
2002
			array(
2003
				'version'     => $new_version,
2004
				'old_version' => $jetpack_old_version,
2005
			)
2006
		);
2007
2008
		Jetpack::state( 'message', 'modules_activated' );
2009
		Jetpack::activate_default_modules( $jetpack_version, JETPACK__VERSION, $reactivate_modules );
2010
2011
		if ( $redirect ) {
2012
			$page = 'jetpack'; // make sure we redirect to either settings or the jetpack page
2013
			if ( isset( $_GET['page'] ) && in_array( $_GET['page'], array( 'jetpack', 'jetpack_modules' ) ) ) {
2014
				$page = $_GET['page'];
2015
			}
2016
2017
			wp_safe_redirect( Jetpack::admin_url( 'page=' . $page ) );
2018
			exit;
2019
		}
2020
	}
2021
2022
	/**
2023
	 * List available Jetpack modules. Simply lists .php files in /modules/.
2024
	 * Make sure to tuck away module "library" files in a sub-directory.
2025
	 */
2026
	public static function get_available_modules( $min_version = false, $max_version = false ) {
2027
		static $modules = null;
2028
2029
		if ( ! isset( $modules ) ) {
2030
			$available_modules_option = Jetpack_Options::get_option( 'available_modules', array() );
2031
			// Use the cache if we're on the front-end and it's available...
2032
			if ( ! is_admin() && ! empty( $available_modules_option[ JETPACK__VERSION ] ) ) {
2033
				$modules = $available_modules_option[ JETPACK__VERSION ];
2034
			} else {
2035
				$files = Jetpack::glob_php( JETPACK__PLUGIN_DIR . 'modules' );
2036
2037
				$modules = array();
2038
2039
				foreach ( $files as $file ) {
2040
					if ( ! $headers = Jetpack::get_module( $file ) ) {
2041
						continue;
2042
					}
2043
2044
					$modules[ Jetpack::get_module_slug( $file ) ] = $headers['introduced'];
2045
				}
2046
2047
				Jetpack_Options::update_option( 'available_modules', array(
2048
					JETPACK__VERSION => $modules,
2049
				) );
2050
			}
2051
		}
2052
2053
		/**
2054
		 * Filters the array of modules available to be activated.
2055
		 *
2056
		 * @since 2.4.0
2057
		 *
2058
		 * @param array $modules Array of available modules.
2059
		 * @param string $min_version Minimum version number required to use modules.
2060
		 * @param string $max_version Maximum version number required to use modules.
2061
		 */
2062
		$mods = apply_filters( 'jetpack_get_available_modules', $modules, $min_version, $max_version );
2063
2064
		if ( ! $min_version && ! $max_version ) {
2065
			return array_keys( $mods );
2066
		}
2067
2068
		$r = array();
2069
		foreach ( $mods as $slug => $introduced ) {
2070
			if ( $min_version && version_compare( $min_version, $introduced, '>=' ) ) {
2071
				continue;
2072
			}
2073
2074
			if ( $max_version && version_compare( $max_version, $introduced, '<' ) ) {
2075
				continue;
2076
			}
2077
2078
			$r[] = $slug;
2079
		}
2080
2081
		return $r;
2082
	}
2083
2084
	/**
2085
	 * Default modules loaded on activation.
2086
	 */
2087
	public static function get_default_modules( $min_version = false, $max_version = false ) {
2088
		$return = array();
2089
2090
		foreach ( Jetpack::get_available_modules( $min_version, $max_version ) as $module ) {
2091
			$module_data = Jetpack::get_module( $module );
2092
2093
			switch ( strtolower( $module_data['auto_activate'] ) ) {
2094
				case 'yes' :
2095
					$return[] = $module;
2096
					break;
2097
				case 'public' :
2098
					if ( Jetpack_Options::get_option( 'public' ) ) {
2099
						$return[] = $module;
2100
					}
2101
					break;
2102
				case 'no' :
2103
				default :
2104
					break;
2105
			}
2106
		}
2107
		/**
2108
		 * Filters the array of default modules.
2109
		 *
2110
		 * @since 2.5.0
2111
		 *
2112
		 * @param array $return Array of default modules.
2113
		 * @param string $min_version Minimum version number required to use modules.
2114
		 * @param string $max_version Maximum version number required to use modules.
2115
		 */
2116
		return apply_filters( 'jetpack_get_default_modules', $return, $min_version, $max_version );
2117
	}
2118
2119
	/**
2120
	 * Checks activated modules during auto-activation to determine
2121
	 * if any of those modules are being deprecated.  If so, close
2122
	 * them out, and add any replacement modules.
2123
	 *
2124
	 * Runs at priority 99 by default.
2125
	 *
2126
	 * This is run late, so that it can still activate a module if
2127
	 * the new module is a replacement for another that the user
2128
	 * currently has active, even if something at the normal priority
2129
	 * would kibosh everything.
2130
	 *
2131
	 * @since 2.6
2132
	 * @uses jetpack_get_default_modules filter
2133
	 * @param array $modules
2134
	 * @return array
2135
	 */
2136
	function handle_deprecated_modules( $modules ) {
2137
		$deprecated_modules = array(
2138
			'debug'            => null,  // Closed out and moved to ./class.jetpack-debugger.php
2139
			'wpcc'             => 'sso', // Closed out in 2.6 -- SSO provides the same functionality.
2140
			'gplus-authorship' => null,  // Closed out in 3.2 -- Google dropped support.
2141
		);
2142
2143
		// Don't activate SSO if they never completed activating WPCC.
2144
		if ( Jetpack::is_module_active( 'wpcc' ) ) {
2145
			$wpcc_options = Jetpack_Options::get_option( 'wpcc_options' );
2146
			if ( empty( $wpcc_options ) || empty( $wpcc_options['client_id'] ) || empty( $wpcc_options['client_id'] ) ) {
2147
				$deprecated_modules['wpcc'] = null;
2148
			}
2149
		}
2150
2151
		foreach ( $deprecated_modules as $module => $replacement ) {
2152
			if ( Jetpack::is_module_active( $module ) ) {
2153
				self::deactivate_module( $module );
2154
				if ( $replacement ) {
2155
					$modules[] = $replacement;
2156
				}
2157
			}
2158
		}
2159
2160
		return array_unique( $modules );
2161
	}
2162
2163
	/**
2164
	 * Checks activated plugins during auto-activation to determine
2165
	 * if any of those plugins are in the list with a corresponding module
2166
	 * that is not compatible with the plugin. The module will not be allowed
2167
	 * to auto-activate.
2168
	 *
2169
	 * @since 2.6
2170
	 * @uses jetpack_get_default_modules filter
2171
	 * @param array $modules
2172
	 * @return array
2173
	 */
2174
	function filter_default_modules( $modules ) {
2175
2176
		$active_plugins = self::get_active_plugins();
2177
2178
		if ( ! empty( $active_plugins ) ) {
2179
2180
			// For each module we'd like to auto-activate...
2181
			foreach ( $modules as $key => $module ) {
2182
				// If there are potential conflicts for it...
2183
				if ( ! empty( $this->conflicting_plugins[ $module ] ) ) {
2184
					// For each potential conflict...
2185
					foreach ( $this->conflicting_plugins[ $module ] as $title => $plugin ) {
2186
						// If that conflicting plugin is active...
2187
						if ( in_array( $plugin, $active_plugins ) ) {
2188
							// Remove that item from being auto-activated.
2189
							unset( $modules[ $key ] );
2190
						}
2191
					}
2192
				}
2193
			}
2194
		}
2195
2196
		return $modules;
2197
	}
2198
2199
	/**
2200
	 * Extract a module's slug from its full path.
2201
	 */
2202
	public static function get_module_slug( $file ) {
2203
		return str_replace( '.php', '', basename( $file ) );
2204
	}
2205
2206
	/**
2207
	 * Generate a module's path from its slug.
2208
	 */
2209
	public static function get_module_path( $slug ) {
2210
		return JETPACK__PLUGIN_DIR . "modules/$slug.php";
2211
	}
2212
2213
	/**
2214
	 * Load module data from module file. Headers differ from WordPress
2215
	 * plugin headers to avoid them being identified as standalone
2216
	 * plugins on the WordPress plugins page.
2217
	 */
2218
	public static function get_module( $module ) {
2219
		$headers = array(
2220
			'name'                      => 'Module Name',
2221
			'description'               => 'Module Description',
2222
			'jumpstart_desc'            => 'Jumpstart Description',
2223
			'sort'                      => 'Sort Order',
2224
			'recommendation_order'      => 'Recommendation Order',
2225
			'introduced'                => 'First Introduced',
2226
			'changed'                   => 'Major Changes In',
2227
			'deactivate'                => 'Deactivate',
2228
			'free'                      => 'Free',
2229
			'requires_connection'       => 'Requires Connection',
2230
			'auto_activate'             => 'Auto Activate',
2231
			'module_tags'               => 'Module Tags',
2232
			'feature'                   => 'Feature',
2233
			'additional_search_queries' => 'Additional Search Queries',
2234
		);
2235
2236
		$file = Jetpack::get_module_path( Jetpack::get_module_slug( $module ) );
2237
2238
		$mod = Jetpack::get_file_data( $file, $headers );
2239
		if ( empty( $mod['name'] ) ) {
2240
			return false;
2241
		}
2242
2243
		$mod['sort']                    = empty( $mod['sort'] ) ? 10 : (int) $mod['sort'];
2244
		$mod['recommendation_order']    = empty( $mod['recommendation_order'] ) ? 20 : (int) $mod['recommendation_order'];
2245
		$mod['deactivate']              = empty( $mod['deactivate'] );
2246
		$mod['free']                    = empty( $mod['free'] );
2247
		$mod['requires_connection']     = ( ! empty( $mod['requires_connection'] ) && 'No' == $mod['requires_connection'] ) ? false : true;
2248
2249
		if ( empty( $mod['auto_activate'] ) || ! in_array( strtolower( $mod['auto_activate'] ), array( 'yes', 'no', 'public' ) ) ) {
2250
			$mod['auto_activate'] = 'No';
2251
		} else {
2252
			$mod['auto_activate'] = (string) $mod['auto_activate'];
2253
		}
2254
2255
		if ( $mod['module_tags'] ) {
2256
			$mod['module_tags'] = explode( ',', $mod['module_tags'] );
2257
			$mod['module_tags'] = array_map( 'trim', $mod['module_tags'] );
2258
			$mod['module_tags'] = array_map( array( __CLASS__, 'translate_module_tag' ), $mod['module_tags'] );
2259
		} else {
2260
			$mod['module_tags'] = array( self::translate_module_tag( 'Other' ) );
2261
		}
2262
2263
		if ( $mod['feature'] ) {
2264
			$mod['feature'] = explode( ',', $mod['feature'] );
2265
			$mod['feature'] = array_map( 'trim', $mod['feature'] );
2266
		} else {
2267
			$mod['feature'] = array( self::translate_module_tag( 'Other' ) );
2268
		}
2269
2270
		/**
2271
		 * Filters the feature array on a module.
2272
		 *
2273
		 * This filter allows you to control where each module is filtered: Recommended,
2274
		 * Jumpstart, and the default "Other" listing.
2275
		 *
2276
		 * @since 3.5.0
2277
		 *
2278
		 * @param array   $mod['feature'] The areas to feature this module:
2279
		 *     'Jumpstart' adds to the "Jumpstart" option to activate many modules at once.
2280
		 *     'Recommended' shows on the main Jetpack admin screen.
2281
		 *     'Other' should be the default if no other value is in the array.
2282
		 * @param string  $module The slug of the module, e.g. sharedaddy.
2283
		 * @param array   $mod All the currently assembled module data.
2284
		 */
2285
		$mod['feature'] = apply_filters( 'jetpack_module_feature', $mod['feature'], $module, $mod );
2286
2287
		/**
2288
		 * Filter the returned data about a module.
2289
		 *
2290
		 * This filter allows overriding any info about Jetpack modules. It is dangerous,
2291
		 * so please be careful.
2292
		 *
2293
		 * @since 3.6.0
2294
		 *
2295
		 * @param array   $mod    The details of the requested module.
2296
		 * @param string  $module The slug of the module, e.g. sharedaddy
2297
		 * @param string  $file   The path to the module source file.
2298
		 */
2299
		return apply_filters( 'jetpack_get_module', $mod, $module, $file );
2300
	}
2301
2302
	/**
2303
	 * Like core's get_file_data implementation, but caches the result.
2304
	 */
2305
	public static function get_file_data( $file, $headers ) {
2306
		//Get just the filename from $file (i.e. exclude full path) so that a consistent hash is generated
2307
		$file_name = basename( $file );
2308
		$file_data_option = Jetpack_Options::get_option( 'file_data', array() );
2309
		$key              = md5( $file_name . serialize( $headers ) );
2310
		$refresh_cache    = is_admin() && isset( $_GET['page'] ) && 'jetpack' === substr( $_GET['page'], 0, 7 );
2311
2312
		// If we don't need to refresh the cache, and already have the value, short-circuit!
2313
		if ( ! $refresh_cache && isset( $file_data_option[ JETPACK__VERSION ][ $key ] ) ) {
2314
			return $file_data_option[ JETPACK__VERSION ][ $key ];
2315
		}
2316
2317
		$data = get_file_data( $file, $headers );
2318
2319
		// Strip out any old Jetpack versions that are cluttering the option.
2320
		//
2321
		// We maintain the data for the current version of Jetpack plus the previous version
2322
		// to prevent repeated DB hits on large sites hosted with multiple web servers
2323
		// on a single database (since all web servers might not be updated simultaneously)
2324
2325
		$file_data_option[ JETPACK__VERSION ][ $key ] = $data;
2326
2327
		if ( count( $file_data_option ) > 2 ) {
2328
			$count = 0;
2329
			krsort( $file_data_option );
2330
			foreach ( $file_data_option as $version => $values ) {
2331
				$count++;
2332
				if ( $count > 2 && JETPACK__VERSION != $version ) {
2333
					unset( $file_data_option[ $version ] );
2334
				}
2335
			}
2336
		}
2337
2338
		Jetpack_Options::update_option( 'file_data', $file_data_option );
2339
2340
		return $data;
2341
	}
2342
2343
2344
	/**
2345
	 * Return translated module tag.
2346
	 *
2347
	 * @param string $tag Tag as it appears in each module heading.
2348
	 *
2349
	 * @return mixed
2350
	 */
2351
	public static function translate_module_tag( $tag ) {
2352
		return jetpack_get_module_i18n_tag( $tag );
2353
	}
2354
2355
	/**
2356
	 * Return module name translation. Uses matching string created in modules/module-headings.php.
2357
	 *
2358
	 * @since 3.9.2
2359
	 *
2360
	 * @param array $modules
2361
	 *
2362
	 * @return string|void
2363
	 */
2364
	public static function get_translated_modules( $modules ) {
2365
		foreach ( $modules as $index => $module ) {
2366
			$i18n_module = jetpack_get_module_i18n( $module['module'] );
2367
			if ( isset( $module['name'] ) ) {
2368
				$modules[ $index ]['name'] = $i18n_module['name'];
2369
			}
2370
			if ( isset( $module['description'] ) ) {
2371
				$modules[ $index ]['description'] = $i18n_module['description'];
2372
				$modules[ $index ]['short_description'] = $i18n_module['description'];
2373
			}
2374
		}
2375
		return $modules;
2376
	}
2377
2378
	/**
2379
	 * Get a list of activated modules as an array of module slugs.
2380
	 */
2381
	public static function get_active_modules() {
2382
		$active = Jetpack_Options::get_option( 'active_modules' );
2383
2384
		if ( ! is_array( $active ) ) {
2385
			$active = array();
2386
		}
2387
2388
		if ( class_exists( 'VaultPress' ) || function_exists( 'vaultpress_contact_service' ) ) {
2389
			$active[] = 'vaultpress';
2390
		} else {
2391
			$active = array_diff( $active, array( 'vaultpress' ) );
2392
		}
2393
2394
		//If protect is active on the main site of a multisite, it should be active on all sites.
2395
		if ( ! in_array( 'protect', $active ) && is_multisite() && get_site_option( 'jetpack_protect_active' ) ) {
2396
			$active[] = 'protect';
2397
		}
2398
2399
		return array_unique( $active );
2400
	}
2401
2402
	/**
2403
	 * Check whether or not a Jetpack module is active.
2404
	 *
2405
	 * @param string $module The slug of a Jetpack module.
2406
	 * @return bool
2407
	 *
2408
	 * @static
2409
	 */
2410
	public static function is_module_active( $module ) {
2411
		return in_array( $module, self::get_active_modules() );
2412
	}
2413
2414
	public static function is_module( $module ) {
2415
		return ! empty( $module ) && ! validate_file( $module, Jetpack::get_available_modules() );
2416
	}
2417
2418
	/**
2419
	 * Catches PHP errors.  Must be used in conjunction with output buffering.
2420
	 *
2421
	 * @param bool $catch True to start catching, False to stop.
2422
	 *
2423
	 * @static
2424
	 */
2425
	public static function catch_errors( $catch ) {
2426
		static $display_errors, $error_reporting;
2427
2428
		if ( $catch ) {
2429
			$display_errors  = @ini_set( 'display_errors', 1 );
2430
			$error_reporting = @error_reporting( E_ALL );
2431
			add_action( 'shutdown', array( 'Jetpack', 'catch_errors_on_shutdown' ), 0 );
2432
		} else {
2433
			@ini_set( 'display_errors', $display_errors );
2434
			@error_reporting( $error_reporting );
2435
			remove_action( 'shutdown', array( 'Jetpack', 'catch_errors_on_shutdown' ), 0 );
2436
		}
2437
	}
2438
2439
	/**
2440
	 * Saves any generated PHP errors in ::state( 'php_errors', {errors} )
2441
	 */
2442
	public static function catch_errors_on_shutdown() {
2443
		Jetpack::state( 'php_errors', self::alias_directories( ob_get_clean() ) );
2444
	}
2445
2446
	/**
2447
	 * Rewrite any string to make paths easier to read.
2448
	 *
2449
	 * Rewrites ABSPATH (eg `/home/jetpack/wordpress/`) to ABSPATH, and if WP_CONTENT_DIR
2450
	 * is located outside of ABSPATH, rewrites that to WP_CONTENT_DIR.
2451
	 *
2452
	 * @param $string
2453
	 * @return mixed
2454
	 */
2455
	public static function alias_directories( $string ) {
2456
		// ABSPATH has a trailing slash.
2457
		$string = str_replace( ABSPATH, 'ABSPATH/', $string );
2458
		// WP_CONTENT_DIR does not have a trailing slash.
2459
		$string = str_replace( WP_CONTENT_DIR, 'WP_CONTENT_DIR', $string );
2460
2461
		return $string;
2462
	}
2463
2464
	public static function activate_default_modules( $min_version = false, $max_version = false, $other_modules = array(), $redirect = true ) {
2465
		$jetpack = Jetpack::init();
2466
2467
		$modules = Jetpack::get_default_modules( $min_version, $max_version );
2468
		$modules = array_merge( $other_modules, $modules );
2469
2470
		// Look for standalone plugins and disable if active.
2471
2472
		$to_deactivate = array();
2473
		foreach ( $modules as $module ) {
2474
			if ( isset( $jetpack->plugins_to_deactivate[$module] ) ) {
2475
				$to_deactivate[$module] = $jetpack->plugins_to_deactivate[$module];
2476
			}
2477
		}
2478
2479
		$deactivated = array();
2480
		foreach ( $to_deactivate as $module => $deactivate_me ) {
2481
			list( $probable_file, $probable_title ) = $deactivate_me;
2482
			if ( Jetpack_Client_Server::deactivate_plugin( $probable_file, $probable_title ) ) {
2483
				$deactivated[] = $module;
2484
			}
2485
		}
2486
2487
		if ( $deactivated && $redirect ) {
2488
			Jetpack::state( 'deactivated_plugins', join( ',', $deactivated ) );
2489
2490
			$url = add_query_arg(
2491
				array(
2492
					'action'   => 'activate_default_modules',
2493
					'_wpnonce' => wp_create_nonce( 'activate_default_modules' ),
2494
				),
2495
				add_query_arg( compact( 'min_version', 'max_version', 'other_modules' ), Jetpack::admin_url( 'page=jetpack' ) )
2496
			);
2497
			wp_safe_redirect( $url );
2498
			exit;
2499
		}
2500
2501
		/**
2502
		 * Fires before default modules are activated.
2503
		 *
2504
		 * @since 1.9.0
2505
		 *
2506
		 * @param string $min_version Minimum version number required to use modules.
2507
		 * @param string $max_version Maximum version number required to use modules.
2508
		 * @param array $other_modules Array of other modules to activate alongside the default modules.
2509
		 */
2510
		do_action( 'jetpack_before_activate_default_modules', $min_version, $max_version, $other_modules );
2511
2512
		// Check each module for fatal errors, a la wp-admin/plugins.php::activate before activating
2513
		Jetpack::restate();
2514
		Jetpack::catch_errors( true );
2515
2516
		$active = Jetpack::get_active_modules();
2517
2518
		foreach ( $modules as $module ) {
2519
			if ( did_action( "jetpack_module_loaded_$module" ) ) {
2520
				$active[] = $module;
2521
				self::update_active_modules( $active );
2522
				continue;
2523
			}
2524
2525
			if ( in_array( $module, $active ) ) {
2526
				$module_info = Jetpack::get_module( $module );
2527
				if ( ! $module_info['deactivate'] ) {
2528
					$state = in_array( $module, $other_modules ) ? 'reactivated_modules' : 'activated_modules';
2529 View Code Duplication
					if ( $active_state = Jetpack::state( $state ) ) {
2530
						$active_state = explode( ',', $active_state );
2531
					} else {
2532
						$active_state = array();
2533
					}
2534
					$active_state[] = $module;
2535
					Jetpack::state( $state, implode( ',', $active_state ) );
2536
				}
2537
				continue;
2538
			}
2539
2540
			$file = Jetpack::get_module_path( $module );
2541
			if ( ! file_exists( $file ) ) {
2542
				continue;
2543
			}
2544
2545
			// we'll override this later if the plugin can be included without fatal error
2546
			if ( $redirect ) {
2547
				wp_safe_redirect( Jetpack::admin_url( 'page=jetpack' ) );
2548
			}
2549
			Jetpack::state( 'error', 'module_activation_failed' );
2550
			Jetpack::state( 'module', $module );
2551
			ob_start();
2552
			require $file;
2553
2554
			$active[] = $module;
2555
			$state    = in_array( $module, $other_modules ) ? 'reactivated_modules' : 'activated_modules';
2556 View Code Duplication
			if ( $active_state = Jetpack::state( $state ) ) {
2557
				$active_state = explode( ',', $active_state );
2558
			} else {
2559
				$active_state = array();
2560
			}
2561
			$active_state[] = $module;
2562
			Jetpack::state( $state, implode( ',', $active_state ) );
2563
			Jetpack::update_active_modules( $active );
2564
2565
			ob_end_clean();
2566
		}
2567
		Jetpack::state( 'error', false );
2568
		Jetpack::state( 'module', false );
2569
		Jetpack::catch_errors( false );
2570
		/**
2571
		 * Fires when default modules are activated.
2572
		 *
2573
		 * @since 1.9.0
2574
		 *
2575
		 * @param string $min_version Minimum version number required to use modules.
2576
		 * @param string $max_version Maximum version number required to use modules.
2577
		 * @param array $other_modules Array of other modules to activate alongside the default modules.
2578
		 */
2579
		do_action( 'jetpack_activate_default_modules', $min_version, $max_version, $other_modules );
2580
	}
2581
2582
	public static function activate_module( $module, $exit = true, $redirect = true ) {
2583
		/**
2584
		 * Fires before a module is activated.
2585
		 *
2586
		 * @since 2.6.0
2587
		 *
2588
		 * @param string $module Module slug.
2589
		 * @param bool $exit Should we exit after the module has been activated. Default to true.
2590
		 * @param bool $redirect Should the user be redirected after module activation? Default to true.
2591
		 */
2592
		do_action( 'jetpack_pre_activate_module', $module, $exit, $redirect );
2593
2594
		$jetpack = Jetpack::init();
2595
2596
		if ( ! strlen( $module ) )
2597
			return false;
2598
2599
		if ( ! Jetpack::is_module( $module ) )
2600
			return false;
2601
2602
		// If it's already active, then don't do it again
2603
		$active = Jetpack::get_active_modules();
2604
		foreach ( $active as $act ) {
2605
			if ( $act == $module )
2606
				return true;
2607
		}
2608
2609
		$module_data = Jetpack::get_module( $module );
2610
2611
		if ( ! Jetpack::is_active() ) {
2612
			if ( !Jetpack::is_development_mode() )
2613
				return false;
2614
2615
			// If we're not connected but in development mode, make sure the module doesn't require a connection
2616
			if ( Jetpack::is_development_mode() && $module_data['requires_connection'] )
2617
				return false;
2618
		}
2619
2620
		// Check and see if the old plugin is active
2621
		if ( isset( $jetpack->plugins_to_deactivate[ $module ] ) ) {
2622
			// Deactivate the old plugin
2623
			if ( Jetpack_Client_Server::deactivate_plugin( $jetpack->plugins_to_deactivate[ $module ][0], $jetpack->plugins_to_deactivate[ $module ][1] ) ) {
2624
				// If we deactivated the old plugin, remembere that with ::state() and redirect back to this page to activate the module
2625
				// We can't activate the module on this page load since the newly deactivated old plugin is still loaded on this page load.
2626
				Jetpack::state( 'deactivated_plugins', $module );
2627
				wp_safe_redirect( add_query_arg( 'jetpack_restate', 1 ) );
2628
				exit;
2629
			}
2630
		}
2631
2632
		// Protect won't work with mis-configured IPs
2633
		if ( 'protect' === $module ) {
2634
			include_once JETPACK__PLUGIN_DIR . 'modules/protect/shared-functions.php';
2635
			if ( ! jetpack_protect_get_ip() ) {
2636
				Jetpack::state( 'message', 'protect_misconfigured_ip' );
2637
				return false;
2638
			}
2639
		}
2640
2641
		// Check the file for fatal errors, a la wp-admin/plugins.php::activate
2642
		Jetpack::state( 'module', $module );
2643
		Jetpack::state( 'error', 'module_activation_failed' ); // we'll override this later if the plugin can be included without fatal error
2644
2645
		Jetpack::catch_errors( true );
2646
		ob_start();
2647
		require Jetpack::get_module_path( $module );
2648
		/** This action is documented in class.jetpack.php */
2649
		do_action( 'jetpack_activate_module', $module );
2650
		$active[] = $module;
2651
		Jetpack::update_active_modules( $active );
2652
2653
		Jetpack::state( 'error', false ); // the override
2654
		ob_end_clean();
2655
		Jetpack::catch_errors( false );
2656
2657
		// A flag for Jump Start so it's not shown again. Only set if it hasn't been yet.
2658 View Code Duplication
		if ( 'new_connection' === Jetpack_Options::get_option( 'jumpstart' ) ) {
2659
			Jetpack_Options::update_option( 'jumpstart', 'jetpack_action_taken' );
2660
2661
			//Jump start is being dismissed send data to MC Stats
2662
			$jetpack->stat( 'jumpstart', 'manual,'.$module );
2663
2664
			$jetpack->do_stats( 'server_side' );
2665
		}
2666
2667
		if ( $redirect ) {
2668
			wp_safe_redirect( Jetpack::admin_url( 'page=jetpack' ) );
2669
		}
2670
		if ( $exit ) {
2671
			exit;
2672
		}
2673
		return true;
2674
	}
2675
2676
	function activate_module_actions( $module ) {
2677
		_deprecated_function( __METHOD__, 'jeptack-4.2' );
2678
	}
2679
2680
	public static function deactivate_module( $module ) {
2681
		/**
2682
		 * Fires when a module is deactivated.
2683
		 *
2684
		 * @since 1.9.0
2685
		 *
2686
		 * @param string $module Module slug.
2687
		 */
2688
		do_action( 'jetpack_pre_deactivate_module', $module );
2689
2690
		$jetpack = Jetpack::init();
2691
2692
		$active = Jetpack::get_active_modules();
2693
		$new    = array_filter( array_diff( $active, (array) $module ) );
2694
2695
		// A flag for Jump Start so it's not shown again.
2696 View Code Duplication
		if ( 'new_connection' === Jetpack_Options::get_option( 'jumpstart' ) ) {
2697
			Jetpack_Options::update_option( 'jumpstart', 'jetpack_action_taken' );
2698
2699
			//Jump start is being dismissed send data to MC Stats
2700
			$jetpack->stat( 'jumpstart', 'manual,deactivated-'.$module );
2701
2702
			$jetpack->do_stats( 'server_side' );
2703
		}
2704
2705
		return self::update_active_modules( $new );
2706
	}
2707
2708
	public static function enable_module_configurable( $module ) {
2709
		$module = Jetpack::get_module_slug( $module );
2710
		add_filter( 'jetpack_module_configurable_' . $module, '__return_true' );
2711
	}
2712
2713
	public static function module_configuration_url( $module ) {
2714
		$module = Jetpack::get_module_slug( $module );
2715
		return Jetpack::admin_url( array( 'page' => 'jetpack', 'configure' => $module ) );
2716
	}
2717
2718
	public static function module_configuration_load( $module, $method ) {
2719
		$module = Jetpack::get_module_slug( $module );
2720
		add_action( 'jetpack_module_configuration_load_' . $module, $method );
2721
	}
2722
2723
	public static function module_configuration_head( $module, $method ) {
2724
		$module = Jetpack::get_module_slug( $module );
2725
		add_action( 'jetpack_module_configuration_head_' . $module, $method );
2726
	}
2727
2728
	public static function module_configuration_screen( $module, $method ) {
2729
		$module = Jetpack::get_module_slug( $module );
2730
		add_action( 'jetpack_module_configuration_screen_' . $module, $method );
2731
	}
2732
2733
	public static function module_configuration_activation_screen( $module, $method ) {
2734
		$module = Jetpack::get_module_slug( $module );
2735
		add_action( 'display_activate_module_setting_' . $module, $method );
2736
	}
2737
2738
/* Installation */
2739
2740
	public static function bail_on_activation( $message, $deactivate = true ) {
2741
?>
2742
<!doctype html>
2743
<html>
2744
<head>
2745
<meta charset="<?php bloginfo( 'charset' ); ?>">
2746
<style>
2747
* {
2748
	text-align: center;
2749
	margin: 0;
2750
	padding: 0;
2751
	font-family: "Lucida Grande",Verdana,Arial,"Bitstream Vera Sans",sans-serif;
2752
}
2753
p {
2754
	margin-top: 1em;
2755
	font-size: 18px;
2756
}
2757
</style>
2758
<body>
2759
<p><?php echo esc_html( $message ); ?></p>
2760
</body>
2761
</html>
2762
<?php
2763
		if ( $deactivate ) {
2764
			$plugins = get_option( 'active_plugins' );
2765
			$jetpack = plugin_basename( JETPACK__PLUGIN_DIR . 'jetpack.php' );
2766
			$update  = false;
2767
			foreach ( $plugins as $i => $plugin ) {
2768
				if ( $plugin === $jetpack ) {
2769
					$plugins[$i] = false;
2770
					$update = true;
2771
				}
2772
			}
2773
2774
			if ( $update ) {
2775
				update_option( 'active_plugins', array_filter( $plugins ) );
2776
			}
2777
		}
2778
		exit;
2779
	}
2780
2781
	/**
2782
	 * Attached to activate_{ plugin_basename( __FILES__ ) } by register_activation_hook()
2783
	 * @static
2784
	 */
2785
	public static function plugin_activation( $network_wide ) {
2786
		Jetpack_Options::update_option( 'activated', 1 );
2787
2788
		if ( version_compare( $GLOBALS['wp_version'], JETPACK__MINIMUM_WP_VERSION, '<' ) ) {
2789
			Jetpack::bail_on_activation( sprintf( __( 'Jetpack requires WordPress version %s or later.', 'jetpack' ), JETPACK__MINIMUM_WP_VERSION ) );
2790
		}
2791
2792
		if ( $network_wide )
2793
			Jetpack::state( 'network_nag', true );
2794
2795
		// For firing one-off events (notices) immediately after activation
2796
		set_transient( 'activated_jetpack', true, .1 * MINUTE_IN_SECONDS );
2797
2798
		Jetpack::plugin_initialize();
2799
	}
2800
	/**
2801
	 * Runs before bumping version numbers up to a new version
2802
	 * @param  (string) $version    Version:timestamp
2803
	 * @param  (string) $old_version Old Version:timestamp or false if not set yet.
2804
	 * @return null              [description]
2805
	 */
2806
	public static function do_version_bump( $version, $old_version ) {
2807
2808
		if ( ! $old_version ) { // For new sites
2809
			// Setting up jetpack manage
2810
			Jetpack::activate_manage();
2811
		}
2812
	}
2813
2814
	/**
2815
	 * Sets the internal version number and activation state.
2816
	 * @static
2817
	 */
2818
	public static function plugin_initialize() {
2819
		if ( ! Jetpack_Options::get_option( 'activated' ) ) {
2820
			Jetpack_Options::update_option( 'activated', 2 );
2821
		}
2822
2823 View Code Duplication
		if ( ! Jetpack_Options::get_option( 'version' ) ) {
2824
			$version = $old_version = JETPACK__VERSION . ':' . time();
2825
			/** This action is documented in class.jetpack.php */
2826
			do_action( 'updating_jetpack_version', $version, false );
2827
			Jetpack_Options::update_options( compact( 'version', 'old_version' ) );
2828
		}
2829
2830
		Jetpack::load_modules();
2831
2832
		Jetpack_Options::delete_option( 'do_activate' );
2833
	}
2834
2835
	/**
2836
	 * Removes all connection options
2837
	 * @static
2838
	 */
2839
	public static function plugin_deactivation( ) {
2840
		require_once( ABSPATH . '/wp-admin/includes/plugin.php' );
2841
		if( is_plugin_active_for_network( 'jetpack/jetpack.php' ) ) {
2842
			Jetpack_Network::init()->deactivate();
2843
		} else {
2844
			Jetpack::disconnect( false );
2845
			//Jetpack_Heartbeat::init()->deactivate();
2846
		}
2847
	}
2848
2849
	/**
2850
	 * Disconnects from the Jetpack servers.
2851
	 * Forgets all connection details and tells the Jetpack servers to do the same.
2852
	 * @static
2853
	 */
2854
	public static function disconnect( $update_activated_state = true ) {
2855
		wp_clear_scheduled_hook( 'jetpack_clean_nonces' );
2856
		Jetpack::clean_nonces( true );
2857
2858
		// If the site is in an IDC because sync is not allowed,
2859
		// let's make sure to not disconnect the production site.
2860
		if ( ! self::validate_sync_error_idc_option() ) {
2861
			JetpackTracking::record_user_event( 'disconnect_site', array() );
2862
			Jetpack::load_xml_rpc_client();
2863
			$xml = new Jetpack_IXR_Client();
2864
			$xml->query( 'jetpack.deregister' );
2865
		}
2866
2867
		Jetpack_Options::delete_option(
2868
			array(
2869
				'register',
2870
				'blog_token',
2871
				'user_token',
2872
				'user_tokens',
2873
				'master_user',
2874
				'time_diff',
2875
				'fallback_no_verify_ssl_certs',
2876
			)
2877
		);
2878
2879
		Jetpack_IDC::clear_all_idc_options();
2880
2881
		if ( $update_activated_state ) {
2882
			Jetpack_Options::update_option( 'activated', 4 );
2883
		}
2884
2885
		if ( $jetpack_unique_connection = Jetpack_Options::get_option( 'unique_connection' ) ) {
2886
			// Check then record unique disconnection if site has never been disconnected previously
2887
			if ( - 1 == $jetpack_unique_connection['disconnected'] ) {
2888
				$jetpack_unique_connection['disconnected'] = 1;
2889
			} else {
2890
				if ( 0 == $jetpack_unique_connection['disconnected'] ) {
2891
					//track unique disconnect
2892
					$jetpack = Jetpack::init();
2893
2894
					$jetpack->stat( 'connections', 'unique-disconnect' );
2895
					$jetpack->do_stats( 'server_side' );
2896
				}
2897
				// increment number of times disconnected
2898
				$jetpack_unique_connection['disconnected'] += 1;
2899
			}
2900
2901
			Jetpack_Options::update_option( 'unique_connection', $jetpack_unique_connection );
2902
		}
2903
2904
		// Delete cached connected user data
2905
		$transient_key = "jetpack_connected_user_data_" . get_current_user_id();
2906
		delete_transient( $transient_key );
2907
2908
		// Delete all the sync related data. Since it could be taking up space.
2909
		require_once JETPACK__PLUGIN_DIR . 'sync/class.jetpack-sync-sender.php';
2910
		Jetpack_Sync_Sender::get_instance()->uninstall();
2911
2912
		// Disable the Heartbeat cron
2913
		Jetpack_Heartbeat::init()->deactivate();
2914
	}
2915
2916
	/**
2917
	 * Unlinks the current user from the linked WordPress.com user
2918
	 */
2919
	public static function unlink_user( $user_id = null ) {
2920
		if ( ! $tokens = Jetpack_Options::get_option( 'user_tokens' ) )
2921
			return false;
2922
2923
		$user_id = empty( $user_id ) ? get_current_user_id() : intval( $user_id );
2924
2925
		if ( Jetpack_Options::get_option( 'master_user' ) == $user_id )
2926
			return false;
2927
2928
		if ( ! isset( $tokens[ $user_id ] ) )
2929
			return false;
2930
2931
		Jetpack::load_xml_rpc_client();
2932
		$xml = new Jetpack_IXR_Client( compact( 'user_id' ) );
2933
		$xml->query( 'jetpack.unlink_user', $user_id );
2934
2935
		unset( $tokens[ $user_id ] );
2936
2937
		Jetpack_Options::update_option( 'user_tokens', $tokens );
2938
2939
		/**
2940
		 * Fires after the current user has been unlinked from WordPress.com.
2941
		 *
2942
		 * @since 4.1.0
2943
		 *
2944
		 * @param int $user_id The current user's ID.
2945
		 */
2946
		do_action( 'jetpack_unlinked_user', $user_id );
2947
2948
		return true;
2949
	}
2950
2951
	/**
2952
	 * Attempts Jetpack registration.  If it fail, a state flag is set: @see ::admin_page_load()
2953
	 */
2954
	public static function try_registration() {
2955
		// Let's get some testing in beta versions and such.
2956
		if ( self::is_development_version() && defined( 'PHP_URL_HOST' ) ) {
2957
			// Before attempting to connect, let's make sure that the domains are viable.
2958
			$domains_to_check = array_unique( array(
2959
				'siteurl' => parse_url( get_site_url(), PHP_URL_HOST ),
2960
				'homeurl' => parse_url( get_home_url(), PHP_URL_HOST ),
2961
			) );
2962
			foreach ( $domains_to_check as $domain ) {
2963
				$result = Jetpack_Data::is_usable_domain( $domain );
2964
				if ( is_wp_error( $result ) ) {
2965
					return $result;
2966
				}
2967
			}
2968
		}
2969
2970
		$result = Jetpack::register();
2971
2972
		// If there was an error with registration and the site was not registered, record this so we can show a message.
2973
		if ( ! $result || is_wp_error( $result ) ) {
2974
			return $result;
2975
		} else {
2976
			return true;
2977
		}
2978
	}
2979
2980
	/**
2981
	 * Tracking an internal event log. Try not to put too much chaff in here.
2982
	 *
2983
	 * [Everyone Loves a Log!](https://www.youtube.com/watch?v=2C7mNr5WMjA)
2984
	 */
2985
	public static function log( $code, $data = null ) {
2986
		// only grab the latest 200 entries
2987
		$log = array_slice( Jetpack_Options::get_option( 'log', array() ), -199, 199 );
2988
2989
		// Append our event to the log
2990
		$log_entry = array(
2991
			'time'    => time(),
2992
			'user_id' => get_current_user_id(),
2993
			'blog_id' => Jetpack_Options::get_option( 'id' ),
2994
			'code'    => $code,
2995
		);
2996
		// Don't bother storing it unless we've got some.
2997
		if ( ! is_null( $data ) ) {
2998
			$log_entry['data'] = $data;
2999
		}
3000
		$log[] = $log_entry;
3001
3002
		// Try add_option first, to make sure it's not autoloaded.
3003
		// @todo: Add an add_option method to Jetpack_Options
3004
		if ( ! add_option( 'jetpack_log', $log, null, 'no' ) ) {
3005
			Jetpack_Options::update_option( 'log', $log );
3006
		}
3007
3008
		/**
3009
		 * Fires when Jetpack logs an internal event.
3010
		 *
3011
		 * @since 3.0.0
3012
		 *
3013
		 * @param array $log_entry {
3014
		 *	Array of details about the log entry.
3015
		 *
3016
		 *	@param string time Time of the event.
3017
		 *	@param int user_id ID of the user who trigerred the event.
3018
		 *	@param int blog_id Jetpack Blog ID.
3019
		 *	@param string code Unique name for the event.
3020
		 *	@param string data Data about the event.
3021
		 * }
3022
		 */
3023
		do_action( 'jetpack_log_entry', $log_entry );
3024
	}
3025
3026
	/**
3027
	 * Get the internal event log.
3028
	 *
3029
	 * @param $event (string) - only return the specific log events
3030
	 * @param $num   (int)    - get specific number of latest results, limited to 200
3031
	 *
3032
	 * @return array of log events || WP_Error for invalid params
3033
	 */
3034
	public static function get_log( $event = false, $num = false ) {
3035
		if ( $event && ! is_string( $event ) ) {
3036
			return new WP_Error( __( 'First param must be string or empty', 'jetpack' ) );
3037
		}
3038
3039
		if ( $num && ! is_numeric( $num ) ) {
3040
			return new WP_Error( __( 'Second param must be numeric or empty', 'jetpack' ) );
3041
		}
3042
3043
		$entire_log = Jetpack_Options::get_option( 'log', array() );
3044
3045
		// If nothing set - act as it did before, otherwise let's start customizing the output
3046
		if ( ! $num && ! $event ) {
3047
			return $entire_log;
3048
		} else {
3049
			$entire_log = array_reverse( $entire_log );
3050
		}
3051
3052
		$custom_log_output = array();
3053
3054
		if ( $event ) {
3055
			foreach ( $entire_log as $log_event ) {
3056
				if ( $event == $log_event[ 'code' ] ) {
3057
					$custom_log_output[] = $log_event;
3058
				}
3059
			}
3060
		} else {
3061
			$custom_log_output = $entire_log;
3062
		}
3063
3064
		if ( $num ) {
3065
			$custom_log_output = array_slice( $custom_log_output, 0, $num );
3066
		}
3067
3068
		return $custom_log_output;
3069
	}
3070
3071
	/**
3072
	 * Log modification of important settings.
3073
	 */
3074
	public static function log_settings_change( $option, $old_value, $value ) {
3075
		switch( $option ) {
3076
			case 'jetpack_sync_non_public_post_stati':
3077
				self::log( $option, $value );
3078
				break;
3079
		}
3080
	}
3081
3082
	/**
3083
	 * Return stat data for WPCOM sync
3084
	 */
3085
	public static function get_stat_data( $encode = true, $extended = true ) {
3086
		$data = Jetpack_Heartbeat::generate_stats_array();
3087
3088
		if ( $extended ) {
3089
			$additional_data = self::get_additional_stat_data();
3090
			$data = array_merge( $data, $additional_data );
3091
		}
3092
3093
		if ( $encode ) {
3094
			return json_encode( $data );
3095
		}
3096
3097
		return $data;
3098
	}
3099
3100
	/**
3101
	 * Get additional stat data to sync to WPCOM
3102
	 */
3103
	public static function get_additional_stat_data( $prefix = '' ) {
3104
		$return["{$prefix}themes"]         = Jetpack::get_parsed_theme_data();
3105
		$return["{$prefix}plugins-extra"]  = Jetpack::get_parsed_plugin_data();
3106
		$return["{$prefix}users"]          = (int) Jetpack::get_site_user_count();
3107
		$return["{$prefix}site-count"]     = 0;
3108
3109
		if ( function_exists( 'get_blog_count' ) ) {
3110
			$return["{$prefix}site-count"] = get_blog_count();
3111
		}
3112
		return $return;
3113
	}
3114
3115
	private static function get_site_user_count() {
3116
		global $wpdb;
3117
3118
		if ( function_exists( 'wp_is_large_network' ) ) {
3119
			if ( wp_is_large_network( 'users' ) ) {
3120
				return -1; // Not a real value but should tell us that we are dealing with a large network.
3121
			}
3122
		}
3123 View Code Duplication
		if ( false === ( $user_count = get_transient( 'jetpack_site_user_count' ) ) ) {
3124
			// It wasn't there, so regenerate the data and save the transient
3125
			$user_count = $wpdb->get_var( "SELECT COUNT(*) FROM $wpdb->usermeta WHERE meta_key = '{$wpdb->prefix}capabilities'" );
3126
			set_transient( 'jetpack_site_user_count', $user_count, DAY_IN_SECONDS );
3127
		}
3128
		return $user_count;
3129
	}
3130
3131
	/* Admin Pages */
3132
3133
	function admin_init() {
3134
		// If the plugin is not connected, display a connect message.
3135
		if (
3136
			// the plugin was auto-activated and needs its candy
3137
			Jetpack_Options::get_option_and_ensure_autoload( 'do_activate', '0' )
3138
		||
3139
			// the plugin is active, but was never activated.  Probably came from a site-wide network activation
3140
			! Jetpack_Options::get_option( 'activated' )
3141
		) {
3142
			Jetpack::plugin_initialize();
3143
		}
3144
3145
		if ( ! Jetpack::is_active() && ! Jetpack::is_development_mode() ) {
3146
			Jetpack_Connection_Banner::init();
3147
		} elseif ( false === Jetpack_Options::get_option( 'fallback_no_verify_ssl_certs' ) ) {
3148
			// Upgrade: 1.1 -> 1.1.1
3149
			// Check and see if host can verify the Jetpack servers' SSL certificate
3150
			$args = array();
3151
			Jetpack_Client::_wp_remote_request(
3152
				Jetpack::fix_url_for_bad_hosts( Jetpack::api_url( 'test' ) ),
3153
				$args,
3154
				true
3155
			);
3156
		} else if ( $this->can_display_jetpack_manage_notice() && ! Jetpack_Options::get_option( 'dismissed_manage_banner' ) ) {
3157
			// Show the notice on the Dashboard only for now
3158
			add_action( 'load-index.php', array( $this, 'prepare_manage_jetpack_notice' ) );
3159
		}
3160
3161
		if ( current_user_can( 'manage_options' ) && 'AUTO' == JETPACK_CLIENT__HTTPS && ! self::permit_ssl() ) {
3162
			add_action( 'jetpack_notices', array( $this, 'alert_auto_ssl_fail' ) );
3163
		}
3164
3165
		add_action( 'load-plugins.php', array( $this, 'intercept_plugin_error_scrape_init' ) );
3166
		add_action( 'admin_enqueue_scripts', array( $this, 'admin_menu_css' ) );
3167
		add_filter( 'plugin_action_links_' . plugin_basename( JETPACK__PLUGIN_DIR . 'jetpack.php' ), array( $this, 'plugin_action_links' ) );
3168
3169
		if ( Jetpack::is_active() || Jetpack::is_development_mode() ) {
3170
			// Artificially throw errors in certain whitelisted cases during plugin activation
3171
			add_action( 'activate_plugin', array( $this, 'throw_error_on_activate_plugin' ) );
3172
		}
3173
3174
		// Jetpack Manage Activation Screen from .com
3175
		Jetpack::module_configuration_activation_screen( 'manage', array( $this, 'manage_activate_screen' ) );
3176
3177
		// Add custom column in wp-admin/users.php to show whether user is linked.
3178
		add_filter( 'manage_users_columns',       array( $this, 'jetpack_icon_user_connected' ) );
3179
		add_action( 'manage_users_custom_column', array( $this, 'jetpack_show_user_connected_icon' ), 10, 3 );
3180
		add_action( 'admin_print_styles',         array( $this, 'jetpack_user_col_style' ) );
3181
	}
3182
3183
	function admin_body_class( $admin_body_class = '' ) {
3184
		$classes = explode( ' ', trim( $admin_body_class ) );
3185
3186
		$classes[] = self::is_active() ? 'jetpack-connected' : 'jetpack-disconnected';
3187
3188
		$admin_body_class = implode( ' ', array_unique( $classes ) );
3189
		return " $admin_body_class ";
3190
	}
3191
3192
	static function add_jetpack_pagestyles( $admin_body_class = '' ) {
3193
		return $admin_body_class . ' jetpack-pagestyles ';
3194
	}
3195
3196
	/**
3197
	 * Call this function if you want the Big Jetpack Manage Notice to show up.
3198
	 *
3199
	 * @return null
3200
	 */
3201
	function prepare_manage_jetpack_notice() {
3202
3203
		add_action( 'admin_print_styles', array( $this, 'admin_banner_styles' ) );
3204
		add_action( 'admin_notices', array( $this, 'admin_jetpack_manage_notice' ) );
3205
	}
3206
3207
	function manage_activate_screen() {
3208
		include ( JETPACK__PLUGIN_DIR . 'modules/manage/activate-admin.php' );
3209
	}
3210
	/**
3211
	 * Sometimes a plugin can activate without causing errors, but it will cause errors on the next page load.
3212
	 * This function artificially throws errors for such cases (whitelisted).
3213
	 *
3214
	 * @param string $plugin The activated plugin.
3215
	 */
3216
	function throw_error_on_activate_plugin( $plugin ) {
3217
		$active_modules = Jetpack::get_active_modules();
3218
3219
		// The Shortlinks module and the Stats plugin conflict, but won't cause errors on activation because of some function_exists() checks.
3220
		if ( function_exists( 'stats_get_api_key' ) && in_array( 'shortlinks', $active_modules ) ) {
3221
			$throw = false;
3222
3223
			// Try and make sure it really was the stats plugin
3224
			if ( ! class_exists( 'ReflectionFunction' ) ) {
3225
				if ( 'stats.php' == basename( $plugin ) ) {
3226
					$throw = true;
3227
				}
3228
			} else {
3229
				$reflection = new ReflectionFunction( 'stats_get_api_key' );
3230
				if ( basename( $plugin ) == basename( $reflection->getFileName() ) ) {
3231
					$throw = true;
3232
				}
3233
			}
3234
3235
			if ( $throw ) {
3236
				trigger_error( sprintf( __( 'Jetpack contains the most recent version of the old &#8220;%1$s&#8221; plugin.', 'jetpack' ), 'WordPress.com Stats' ), E_USER_ERROR );
3237
			}
3238
		}
3239
	}
3240
3241
	function intercept_plugin_error_scrape_init() {
3242
		add_action( 'check_admin_referer', array( $this, 'intercept_plugin_error_scrape' ), 10, 2 );
3243
	}
3244
3245
	function intercept_plugin_error_scrape( $action, $result ) {
3246
		if ( ! $result ) {
3247
			return;
3248
		}
3249
3250
		foreach ( $this->plugins_to_deactivate as $deactivate_me ) {
3251
			if ( "plugin-activation-error_{$deactivate_me[0]}" == $action ) {
3252
				Jetpack::bail_on_activation( sprintf( __( 'Jetpack contains the most recent version of the old &#8220;%1$s&#8221; plugin.', 'jetpack' ), $deactivate_me[1] ), false );
3253
			}
3254
		}
3255
	}
3256
3257
	function add_remote_request_handlers() {
3258
		add_action( 'wp_ajax_nopriv_jetpack_upload_file', array( $this, 'remote_request_handlers' ) );
3259
		add_action( 'wp_ajax_nopriv_jetpack_update_file', array( $this, 'remote_request_handlers' ) );
3260
	}
3261
3262
	function remote_request_handlers() {
3263
		$action = current_filter();
3264
3265
		switch ( current_filter() ) {
3266
		case 'wp_ajax_nopriv_jetpack_upload_file' :
3267
			$response = $this->upload_handler();
3268
			break;
3269
3270
		case 'wp_ajax_nopriv_jetpack_update_file' :
3271
			$response = $this->upload_handler( true );
3272
			break;
3273
		default :
3274
			$response = new Jetpack_Error( 'unknown_handler', 'Unknown Handler', 400 );
3275
			break;
3276
		}
3277
3278
		if ( ! $response ) {
3279
			$response = new Jetpack_Error( 'unknown_error', 'Unknown Error', 400 );
3280
		}
3281
3282
		if ( is_wp_error( $response ) ) {
3283
			$status_code       = $response->get_error_data();
3284
			$error             = $response->get_error_code();
3285
			$error_description = $response->get_error_message();
3286
3287
			if ( ! is_int( $status_code ) ) {
3288
				$status_code = 400;
3289
			}
3290
3291
			status_header( $status_code );
3292
			die( json_encode( (object) compact( 'error', 'error_description' ) ) );
3293
		}
3294
3295
		status_header( 200 );
3296
		if ( true === $response ) {
3297
			exit;
3298
		}
3299
3300
		die( json_encode( (object) $response ) );
3301
	}
3302
3303
	/**
3304
	 * Uploads a file gotten from the global $_FILES.
3305
	 * If `$update_media_item` is true and `post_id` is defined
3306
	 * the attachment file of the media item (gotten through of the post_id)
3307
	 * will be updated instead of add a new one.
3308
	 *
3309
	 * @param  boolean $update_media_item - update media attachment
3310
	 * @return array - An array describing the uploadind files process
3311
	 */
3312
	function upload_handler( $update_media_item = false ) {
3313
		if ( 'POST' !== strtoupper( $_SERVER['REQUEST_METHOD'] ) ) {
3314
			return new Jetpack_Error( 405, get_status_header_desc( 405 ), 405 );
3315
		}
3316
3317
		$user = wp_authenticate( '', '' );
3318
		if ( ! $user || is_wp_error( $user ) ) {
3319
			return new Jetpack_Error( 403, get_status_header_desc( 403 ), 403 );
3320
		}
3321
3322
		wp_set_current_user( $user->ID );
3323
3324
		if ( ! current_user_can( 'upload_files' ) ) {
3325
			return new Jetpack_Error( 'cannot_upload_files', 'User does not have permission to upload files', 403 );
3326
		}
3327
3328
		if ( empty( $_FILES ) ) {
3329
			return new Jetpack_Error( 'no_files_uploaded', 'No files were uploaded: nothing to process', 400 );
3330
		}
3331
3332
		foreach ( array_keys( $_FILES ) as $files_key ) {
3333
			if ( ! isset( $_POST["_jetpack_file_hmac_{$files_key}"] ) ) {
3334
				return new Jetpack_Error( 'missing_hmac', 'An HMAC for one or more files is missing', 400 );
3335
			}
3336
		}
3337
3338
		$media_keys = array_keys( $_FILES['media'] );
3339
3340
		$token = Jetpack_Data::get_access_token( get_current_user_id() );
3341
		if ( ! $token || is_wp_error( $token ) ) {
3342
			return new Jetpack_Error( 'unknown_token', 'Unknown Jetpack token', 403 );
3343
		}
3344
3345
		$uploaded_files = array();
3346
		$global_post    = isset( $GLOBALS['post'] ) ? $GLOBALS['post'] : null;
3347
		unset( $GLOBALS['post'] );
3348
		foreach ( $_FILES['media']['name'] as $index => $name ) {
3349
			$file = array();
3350
			foreach ( $media_keys as $media_key ) {
3351
				$file[$media_key] = $_FILES['media'][$media_key][$index];
3352
			}
3353
3354
			list( $hmac_provided, $salt ) = explode( ':', $_POST['_jetpack_file_hmac_media'][$index] );
3355
3356
			$hmac_file = hash_hmac_file( 'sha1', $file['tmp_name'], $salt . $token->secret );
3357
			if ( $hmac_provided !== $hmac_file ) {
3358
				$uploaded_files[$index] = (object) array( 'error' => 'invalid_hmac', 'error_description' => 'The corresponding HMAC for this file does not match' );
3359
				continue;
3360
			}
3361
3362
			$_FILES['.jetpack.upload.'] = $file;
3363
			$post_id = isset( $_POST['post_id'][$index] ) ? absint( $_POST['post_id'][$index] ) : 0;
3364
			if ( ! current_user_can( 'edit_post', $post_id ) ) {
3365
				$post_id = 0;
3366
			}
3367
3368
			if ( $update_media_item ) {
3369
				if ( ! isset( $post_id ) || $post_id === 0 ) {
3370
					return new Jetpack_Error( 'invalid_input', 'Media ID must be defined.', 400 );
3371
				}
3372
3373
				$media_array = $_FILES['media'];
3374
3375
				$file_array['name'] = $media_array['name'][0];
3376
				$file_array['type'] = $media_array['type'][0];
3377
				$file_array['tmp_name'] = $media_array['tmp_name'][0];
3378
				$file_array['error'] = $media_array['error'][0];
3379
				$file_array['size'] = $media_array['size'][0];
3380
3381
				$edited_media_item = Jetpack_Media::edit_media_file( $post_id, $file_array );
3382
3383
				if ( is_wp_error( $edited_media_item ) ) {
3384
					return $edited_media_item;
3385
				}
3386
3387
				$response = (object) array(
3388
					'id'   => (string) $post_id,
3389
					'file' => (string) $edited_media_item->post_title,
3390
					'url'  => (string) wp_get_attachment_url( $post_id ),
3391
					'type' => (string) $edited_media_item->post_mime_type,
3392
					'meta' => (array) wp_get_attachment_metadata( $post_id ),
3393
				);
3394
3395
				return (array) array( $response );
3396
			}
3397
3398
			$attachment_id = media_handle_upload(
3399
				'.jetpack.upload.',
3400
				$post_id,
3401
				array(),
3402
				array(
3403
					'action' => 'jetpack_upload_file',
3404
				)
3405
			);
3406
3407
			if ( ! $attachment_id ) {
3408
				$uploaded_files[$index] = (object) array( 'error' => 'unknown', 'error_description' => 'An unknown problem occurred processing the upload on the Jetpack site' );
3409
			} elseif ( is_wp_error( $attachment_id ) ) {
3410
				$uploaded_files[$index] = (object) array( 'error' => 'attachment_' . $attachment_id->get_error_code(), 'error_description' => $attachment_id->get_error_message() );
3411
			} else {
3412
				$attachment = get_post( $attachment_id );
3413
				$uploaded_files[$index] = (object) array(
3414
					'id'   => (string) $attachment_id,
3415
					'file' => $attachment->post_title,
3416
					'url'  => wp_get_attachment_url( $attachment_id ),
3417
					'type' => $attachment->post_mime_type,
3418
					'meta' => wp_get_attachment_metadata( $attachment_id ),
3419
				);
3420
				// Zip files uploads are not supported unless they are done for installation purposed
3421
				// lets delete them in case something goes wrong in this whole process
3422
				if ( 'application/zip' === $attachment->post_mime_type ) {
3423
					// Schedule a cleanup for 2 hours from now in case of failed install.
3424
					wp_schedule_single_event( time() + 2 * HOUR_IN_SECONDS, 'upgrader_scheduled_cleanup', array( $attachment_id ) );
3425
				}
3426
			}
3427
		}
3428
		if ( ! is_null( $global_post ) ) {
3429
			$GLOBALS['post'] = $global_post;
3430
		}
3431
3432
		return $uploaded_files;
3433
	}
3434
3435
	/**
3436
	 * Add help to the Jetpack page
3437
	 *
3438
	 * @since Jetpack (1.2.3)
3439
	 * @return false if not the Jetpack page
3440
	 */
3441
	function admin_help() {
3442
		$current_screen = get_current_screen();
3443
3444
		// Overview
3445
		$current_screen->add_help_tab(
3446
			array(
3447
				'id'		=> 'home',
3448
				'title'		=> __( 'Home', 'jetpack' ),
3449
				'content'	=>
3450
					'<p><strong>' . __( 'Jetpack by WordPress.com', 'jetpack' ) . '</strong></p>' .
3451
					'<p>' . __( 'Jetpack supercharges your self-hosted WordPress site with the awesome cloud power of WordPress.com.', 'jetpack' ) . '</p>' .
3452
					'<p>' . __( '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' ) . '</p>',
3453
			)
3454
		);
3455
3456
		// Screen Content
3457
		if ( current_user_can( 'manage_options' ) ) {
3458
			$current_screen->add_help_tab(
3459
				array(
3460
					'id'		=> 'settings',
3461
					'title'		=> __( 'Settings', 'jetpack' ),
3462
					'content'	=>
3463
						'<p><strong>' . __( 'Jetpack by WordPress.com',                                              'jetpack' ) . '</strong></p>' .
3464
						'<p>' . __( 'You can activate or deactivate individual Jetpack modules to suit your needs.', 'jetpack' ) . '</p>' .
3465
						'<ol>' .
3466
							'<li>' . __( 'Each module has an Activate or Deactivate link so you can toggle one individually.',														'jetpack' ) . '</li>' .
3467
							'<li>' . __( 'Using the checkboxes next to each module, you can select multiple modules to toggle via the Bulk Actions menu at the top of the list.',	'jetpack' ) . '</li>' .
3468
						'</ol>' .
3469
						'<p>' . __( 'Using the tools on the right, you can search for specific modules, filter by module categories or which are active, or change the sorting order.', 'jetpack' ) . '</p>'
3470
				)
3471
			);
3472
		}
3473
3474
		// Help Sidebar
3475
		$current_screen->set_help_sidebar(
3476
			'<p><strong>' . __( 'For more information:', 'jetpack' ) . '</strong></p>' .
3477
			'<p><a href="https://jetpack.com/faq/" target="_blank">'     . __( 'Jetpack FAQ',     'jetpack' ) . '</a></p>' .
3478
			'<p><a href="https://jetpack.com/support/" target="_blank">' . __( 'Jetpack Support', 'jetpack' ) . '</a></p>' .
3479
			'<p><a href="' . Jetpack::admin_url( array( 'page' => 'jetpack-debugger' )  ) .'">' . __( 'Jetpack Debugging Center', 'jetpack' ) . '</a></p>'
3480
		);
3481
	}
3482
3483
	function admin_menu_css() {
3484
		wp_enqueue_style( 'jetpack-icons' );
3485
	}
3486
3487
	function admin_menu_order() {
3488
		return true;
3489
	}
3490
3491 View Code Duplication
	function jetpack_menu_order( $menu_order ) {
3492
		$jp_menu_order = array();
3493
3494
		foreach ( $menu_order as $index => $item ) {
3495
			if ( $item != 'jetpack' ) {
3496
				$jp_menu_order[] = $item;
3497
			}
3498
3499
			if ( $index == 0 ) {
3500
				$jp_menu_order[] = 'jetpack';
3501
			}
3502
		}
3503
3504
		return $jp_menu_order;
3505
	}
3506
3507
	function admin_head() {
3508 View Code Duplication
		if ( isset( $_GET['configure'] ) && Jetpack::is_module( $_GET['configure'] ) && current_user_can( 'manage_options' ) )
3509
			/** This action is documented in class.jetpack-admin-page.php */
3510
			do_action( 'jetpack_module_configuration_head_' . $_GET['configure'] );
3511
	}
3512
3513
	function admin_banner_styles() {
3514
		$min = ( defined( 'SCRIPT_DEBUG' ) && SCRIPT_DEBUG ) ? '' : '.min';
3515
3516 View Code Duplication
		if ( ! wp_style_is( 'jetpack-dops-style' ) ) {
3517
			wp_register_style(
3518
				'jetpack-dops-style',
3519
				plugins_url( '_inc/build/admin.dops-style.css', JETPACK__PLUGIN_FILE ),
3520
				array(),
3521
				JETPACK__VERSION
3522
			);
3523
		}
3524
3525
		wp_enqueue_style(
3526
			'jetpack',
3527
			plugins_url( "css/jetpack-banners{$min}.css", JETPACK__PLUGIN_FILE ),
3528
			array( 'jetpack-dops-style' ),
3529
			 JETPACK__VERSION . '-20121016'
3530
		);
3531
		wp_style_add_data( 'jetpack', 'rtl', 'replace' );
3532
		wp_style_add_data( 'jetpack', 'suffix', $min );
3533
	}
3534
3535
	function plugin_action_links( $actions ) {
3536
3537
		$jetpack_home = array( 'jetpack-home' => sprintf( '<a href="%s">%s</a>', Jetpack::admin_url( 'page=jetpack' ), __( 'Jetpack', 'jetpack' ) ) );
3538
3539
		if( current_user_can( 'jetpack_manage_modules' ) && ( Jetpack::is_active() || Jetpack::is_development_mode() ) ) {
3540
			return array_merge(
3541
				$jetpack_home,
3542
				array( 'settings' => sprintf( '<a href="%s">%s</a>', Jetpack::admin_url( 'page=jetpack#/settings' ), __( 'Settings', 'jetpack' ) ) ),
3543
				array( 'support' => sprintf( '<a href="%s">%s</a>', Jetpack::admin_url( 'page=jetpack-debugger '), __( 'Support', 'jetpack' ) ) ),
3544
				$actions
3545
				);
3546
			}
3547
3548
		return array_merge( $jetpack_home, $actions );
3549
	}
3550
3551
	/**
3552
	 * This is the first banner
3553
	 * It should be visible only to user that can update the option
3554
	 * Are not connected
3555
	 *
3556
	 * @return null
3557
	 */
3558
	function admin_jetpack_manage_notice() {
3559
		$screen = get_current_screen();
3560
3561
		// Don't show the connect notice on the jetpack settings page.
3562
		if ( ! in_array( $screen->base, array( 'dashboard' ) ) || $screen->is_network || $screen->action ) {
3563
			return;
3564
		}
3565
3566
		$opt_out_url = $this->opt_out_jetpack_manage_url();
3567
		$opt_in_url  = $this->opt_in_jetpack_manage_url();
3568
		/**
3569
		 * I think it would be great to have different wordsing depending on where you are
3570
		 * for example if we show the notice on dashboard and a different one if we show it on Plugins screen
3571
		 * etc..
3572
		 */
3573
3574
		?>
3575
		<div id="message" class="updated jp-banner">
3576
				<a href="<?php echo esc_url( $opt_out_url ); ?>" class="notice-dismiss" title="<?php esc_attr_e( 'Dismiss this notice', 'jetpack' ); ?>"></a>
3577
				<div class="jp-banner__description-container">
3578
					<h2 class="jp-banner__header"><?php esc_html_e( 'Jetpack Centralized Site Management', 'jetpack' ); ?></h2>
3579
					<p class="jp-banner__description"><?php printf( __( 'Manage multiple Jetpack enabled sites from one single dashboard at wordpress.com. Allows all existing, connected Administrators to modify your site.', 'jetpack' ), 'https://jetpack.com/support/site-management' ); ?></p>
3580
					<p class="jp-banner__button-container">
3581
						<a href="<?php echo esc_url( $opt_in_url ); ?>" class="button button-primary" id="wpcom-connect"><?php _e( 'Activate Jetpack Manage', 'jetpack' ); ?></a>
3582
						<a href="https://jetpack.com/support/site-management" class="button" target="_blank" title="<?php esc_attr_e( 'Learn more about Jetpack Manage on Jetpack.com', 'jetpack' ); ?>"><?php _e( 'Learn more', 'jetpack' ); ?></a>
3583
					</p>
3584
				</div>
3585
		</div>
3586
		<?php
3587
	}
3588
3589
	/**
3590
	 * Returns the url that the user clicks to remove the notice for the big banner
3591
	 * @return (string)
3592
	 */
3593
	function opt_out_jetpack_manage_url() {
3594
		$referer = '&_wp_http_referer=' . add_query_arg( '_wp_http_referer', null );
3595
		return wp_nonce_url( Jetpack::admin_url( 'jetpack-notice=jetpack-manage-opt-out' . $referer ), 'jetpack_manage_banner_opt_out' );
3596
	}
3597
	/**
3598
	 * Returns the url that the user clicks to opt in to Jetpack Manage
3599
	 * @return (string)
3600
	 */
3601
	function opt_in_jetpack_manage_url() {
3602
		return wp_nonce_url( Jetpack::admin_url( 'jetpack-notice=jetpack-manage-opt-in' ), 'jetpack_manage_banner_opt_in' );
3603
	}
3604
3605
	function opt_in_jetpack_manage_notice() {
3606
		?>
3607
		<div class="wrap">
3608
			<div id="message" class="jetpack-message is-opt-in">
3609
				<?php echo sprintf( __( '<p><a href="%1$s" title="Opt in to WordPress.com Site Management" >Activate Site Management</a> to manage multiple sites from our centralized dashboard at wordpress.com/sites. <a href="%2$s" target="_blank">Learn more</a>.</p><a href="%1$s" class="jp-button">Activate Now</a>', 'jetpack' ), $this->opt_in_jetpack_manage_url(), 'https://jetpack.com/support/site-management' ); ?>
3610
			</div>
3611
		</div>
3612
		<?php
3613
3614
	}
3615
	/**
3616
	 * Determines whether to show the notice of not true = display notice
3617
	 * @return (bool)
3618
	 */
3619
	function can_display_jetpack_manage_notice() {
3620
		// never display the notice to users that can't do anything about it anyways
3621
		if( ! current_user_can( 'jetpack_manage_modules' ) )
3622
			return false;
3623
3624
		// don't display if we are in development more
3625
		if( Jetpack::is_development_mode() ) {
3626
			return false;
3627
		}
3628
		// don't display if the site is private
3629
		if(  ! Jetpack_Options::get_option( 'public' ) )
3630
			return false;
3631
3632
		/**
3633
		 * Should the Jetpack Remote Site Management notice be displayed.
3634
		 *
3635
		 * @since 3.3.0
3636
		 *
3637
		 * @param bool ! self::is_module_active( 'manage' ) Is the Manage module inactive.
3638
		 */
3639
		return apply_filters( 'can_display_jetpack_manage_notice', ! self::is_module_active( 'manage' ) );
3640
	}
3641
3642
	/*
3643
	 * Registration flow:
3644
	 * 1 - ::admin_page_load() action=register
3645
	 * 2 - ::try_registration()
3646
	 * 3 - ::register()
3647
	 *     - Creates jetpack_register option containing two secrets and a timestamp
3648
	 *     - Calls https://jetpack.wordpress.com/jetpack.register/1/ with
3649
	 *       siteurl, home, gmt_offset, timezone_string, site_name, secret_1, secret_2, site_lang, timeout, stats_id
3650
	 *     - That request to jetpack.wordpress.com does not immediately respond.  It first makes a request BACK to this site's
3651
	 *       xmlrpc.php?for=jetpack: RPC method: jetpack.verifyRegistration, Parameters: secret_1
3652
	 *     - The XML-RPC request verifies secret_1, deletes both secrets and responds with: secret_2
3653
	 *     - https://jetpack.wordpress.com/jetpack.register/1/ verifies that XML-RPC response (secret_2) then finally responds itself with
3654
	 *       jetpack_id, jetpack_secret, jetpack_public
3655
	 *     - ::register() then stores jetpack_options: id => jetpack_id, blog_token => jetpack_secret
3656
	 * 4 - redirect to https://wordpress.com/start/jetpack-connect
3657
	 * 5 - user logs in with WP.com account
3658
	 * 6 - remote request to this site's xmlrpc.php with action remoteAuthorize, Jetpack_XMLRPC_Server->remote_authorize
3659
	 *		- Jetpack_Client_Server::authorize()
3660
	 *		- Jetpack_Client_Server::get_token()
3661
	 *		- GET https://jetpack.wordpress.com/jetpack.token/1/ with
3662
	 *        client_id, client_secret, grant_type, code, redirect_uri:action=authorize, state, scope, user_email, user_login
3663
	 *			- which responds with access_token, token_type, scope
3664
	 *		- Jetpack_Client_Server::authorize() stores jetpack_options: user_token => access_token.$user_id
3665
	 *		- Jetpack::activate_default_modules()
3666
	 *     		- Deactivates deprecated plugins
3667
	 *     		- Activates all default modules
3668
	 *		- Responds with either error, or 'connected' for new connection, or 'linked' for additional linked users
3669
	 * 7 - For a new connection, user selects a Jetpack plan on wordpress.com
3670
	 * 8 - User is redirected back to wp-admin/index.php?page=jetpack with state:message=authorized
3671
	 *     Done!
3672
	 */
3673
3674
	/**
3675
	 * Handles the page load events for the Jetpack admin page
3676
	 */
3677
	function admin_page_load() {
3678
		$error = false;
3679
3680
		// Make sure we have the right body class to hook stylings for subpages off of.
3681
		add_filter( 'admin_body_class', array( __CLASS__, 'add_jetpack_pagestyles' ) );
3682
3683
		if ( ! empty( $_GET['jetpack_restate'] ) ) {
3684
			// Should only be used in intermediate redirects to preserve state across redirects
3685
			Jetpack::restate();
3686
		}
3687
3688
		if ( isset( $_GET['connect_url_redirect'] ) ) {
3689
			// User clicked in the iframe to link their accounts
3690
			if ( ! Jetpack::is_user_connected() ) {
3691
				$connect_url = $this->build_connect_url( true, false, 'iframe' );
3692
				if ( isset( $_GET['notes_iframe'] ) )
3693
					$connect_url .= '&notes_iframe';
3694
				wp_redirect( $connect_url );
3695
				exit;
3696
			} else {
3697
				if ( ! isset( $_GET['calypso_env'] ) ) {
3698
					Jetpack::state( 'message', 'already_authorized' );
3699
					wp_safe_redirect( Jetpack::admin_url() );
3700
				} else {
3701
					$connect_url = $this->build_connect_url( true, false, 'iframe' );
3702
					$connect_url .= '&already_authorized=true';
3703
					wp_redirect( $connect_url );
3704
				}
3705
			}
3706
		}
3707
3708
3709
		if ( isset( $_GET['action'] ) ) {
3710
			switch ( $_GET['action'] ) {
3711
			case 'authorize':
3712
				if ( Jetpack::is_active() && Jetpack::is_user_connected() ) {
3713
					Jetpack::state( 'message', 'already_authorized' );
3714
					wp_safe_redirect( Jetpack::admin_url() );
3715
					exit;
3716
				}
3717
				Jetpack::log( 'authorize' );
3718
				$client_server = new Jetpack_Client_Server;
3719
				$client_server->client_authorize();
3720
				exit;
3721
			case 'register' :
3722
				if ( ! current_user_can( 'jetpack_connect' ) ) {
3723
					$error = 'cheatin';
3724
					break;
3725
				}
3726
				check_admin_referer( 'jetpack-register' );
3727
				Jetpack::log( 'register' );
3728
				Jetpack::maybe_set_version_option();
3729
				$registered = Jetpack::try_registration();
3730
				if ( is_wp_error( $registered ) ) {
3731
					$error = $registered->get_error_code();
3732
					Jetpack::state( 'error', $error );
3733
					Jetpack::state( 'error', $registered->get_error_message() );
3734
					break;
3735
				}
3736
3737
				$from = isset( $_GET['from'] ) ? $_GET['from'] : false;
3738
3739
				wp_redirect( $this->build_connect_url( true, false, $from ) );
3740
				exit;
3741
			case 'activate' :
3742
				if ( ! current_user_can( 'jetpack_activate_modules' ) ) {
3743
					$error = 'cheatin';
3744
					break;
3745
				}
3746
3747
				$module = stripslashes( $_GET['module'] );
3748
				check_admin_referer( "jetpack_activate-$module" );
3749
				Jetpack::log( 'activate', $module );
3750
				Jetpack::activate_module( $module );
3751
				// The following two lines will rarely happen, as Jetpack::activate_module normally exits at the end.
3752
				wp_safe_redirect( Jetpack::admin_url( 'page=jetpack' ) );
3753
				exit;
3754
			case 'activate_default_modules' :
3755
				check_admin_referer( 'activate_default_modules' );
3756
				Jetpack::log( 'activate_default_modules' );
3757
				Jetpack::restate();
3758
				$min_version   = isset( $_GET['min_version'] ) ? $_GET['min_version'] : false;
3759
				$max_version   = isset( $_GET['max_version'] ) ? $_GET['max_version'] : false;
3760
				$other_modules = isset( $_GET['other_modules'] ) && is_array( $_GET['other_modules'] ) ? $_GET['other_modules'] : array();
3761
				Jetpack::activate_default_modules( $min_version, $max_version, $other_modules );
3762
				wp_safe_redirect( Jetpack::admin_url( 'page=jetpack' ) );
3763
				exit;
3764
			case 'disconnect' :
3765
				if ( ! current_user_can( 'jetpack_disconnect' ) ) {
3766
					$error = 'cheatin';
3767
					break;
3768
				}
3769
3770
				check_admin_referer( 'jetpack-disconnect' );
3771
				Jetpack::log( 'disconnect' );
3772
				Jetpack::disconnect();
3773
				wp_safe_redirect( Jetpack::admin_url( 'disconnected=true' ) );
3774
				exit;
3775
			case 'reconnect' :
3776
				if ( ! current_user_can( 'jetpack_reconnect' ) ) {
3777
					$error = 'cheatin';
3778
					break;
3779
				}
3780
3781
				check_admin_referer( 'jetpack-reconnect' );
3782
				Jetpack::log( 'reconnect' );
3783
				$this->disconnect();
3784
				wp_redirect( $this->build_connect_url( true, false, 'reconnect' ) );
3785
				exit;
3786 View Code Duplication
			case 'deactivate' :
3787
				if ( ! current_user_can( 'jetpack_deactivate_modules' ) ) {
3788
					$error = 'cheatin';
3789
					break;
3790
				}
3791
3792
				$modules = stripslashes( $_GET['module'] );
3793
				check_admin_referer( "jetpack_deactivate-$modules" );
3794
				foreach ( explode( ',', $modules ) as $module ) {
3795
					Jetpack::log( 'deactivate', $module );
3796
					Jetpack::deactivate_module( $module );
3797
					Jetpack::state( 'message', 'module_deactivated' );
3798
				}
3799
				Jetpack::state( 'module', $modules );
3800
				wp_safe_redirect( Jetpack::admin_url( 'page=jetpack' ) );
3801
				exit;
3802
			case 'unlink' :
3803
				$redirect = isset( $_GET['redirect'] ) ? $_GET['redirect'] : '';
3804
				check_admin_referer( 'jetpack-unlink' );
3805
				Jetpack::log( 'unlink' );
3806
				$this->unlink_user();
3807
				Jetpack::state( 'message', 'unlinked' );
3808
				if ( 'sub-unlink' == $redirect ) {
3809
					wp_safe_redirect( admin_url() );
3810
				} else {
3811
					wp_safe_redirect( Jetpack::admin_url( array( 'page' => $redirect ) ) );
3812
				}
3813
				exit;
3814
			default:
3815
				/**
3816
				 * Fires when a Jetpack admin page is loaded with an unrecognized parameter.
3817
				 *
3818
				 * @since 2.6.0
3819
				 *
3820
				 * @param string sanitize_key( $_GET['action'] ) Unrecognized URL parameter.
3821
				 */
3822
				do_action( 'jetpack_unrecognized_action', sanitize_key( $_GET['action'] ) );
3823
			}
3824
		}
3825
3826
		if ( ! $error = $error ? $error : Jetpack::state( 'error' ) ) {
3827
			self::activate_new_modules( true );
3828
		}
3829
3830
		$message_code = Jetpack::state( 'message' );
3831
		if ( Jetpack::state( 'optin-manage' ) ) {
3832
			$activated_manage = $message_code;
3833
			$message_code = 'jetpack-manage';
3834
		}
3835
3836
		switch ( $message_code ) {
3837
		case 'jetpack-manage':
3838
			$this->message = '<strong>' . sprintf( __( 'You are all set! Your site can now be managed from <a href="%s" target="_blank">wordpress.com/sites</a>.', 'jetpack' ), 'https://wordpress.com/sites' ) . '</strong>';
3839
			if ( $activated_manage ) {
3840
				$this->message .= '<br /><strong>' . __( 'Manage has been activated for you!', 'jetpack'  ) . '</strong>';
3841
			}
3842
			break;
3843
3844
		}
3845
3846
		$deactivated_plugins = Jetpack::state( 'deactivated_plugins' );
3847
3848
		if ( ! empty( $deactivated_plugins ) ) {
3849
			$deactivated_plugins = explode( ',', $deactivated_plugins );
3850
			$deactivated_titles  = array();
3851
			foreach ( $deactivated_plugins as $deactivated_plugin ) {
3852
				if ( ! isset( $this->plugins_to_deactivate[$deactivated_plugin] ) ) {
3853
					continue;
3854
				}
3855
3856
				$deactivated_titles[] = '<strong>' . str_replace( ' ', '&nbsp;', $this->plugins_to_deactivate[$deactivated_plugin][1] ) . '</strong>';
3857
			}
3858
3859
			if ( $deactivated_titles ) {
3860
				if ( $this->message ) {
3861
					$this->message .= "<br /><br />\n";
3862
				}
3863
3864
				$this->message .= wp_sprintf(
3865
					_n(
3866
						'Jetpack contains the most recent version of the old %l plugin.',
3867
						'Jetpack contains the most recent versions of the old %l plugins.',
3868
						count( $deactivated_titles ),
3869
						'jetpack'
3870
					),
3871
					$deactivated_titles
3872
				);
3873
3874
				$this->message .= "<br />\n";
3875
3876
				$this->message .= _n(
3877
					'The old version has been deactivated and can be removed from your site.',
3878
					'The old versions have been deactivated and can be removed from your site.',
3879
					count( $deactivated_titles ),
3880
					'jetpack'
3881
				);
3882
			}
3883
		}
3884
3885
		$this->privacy_checks = Jetpack::state( 'privacy_checks' );
3886
3887
		if ( $this->message || $this->error || $this->privacy_checks || $this->can_display_jetpack_manage_notice() ) {
3888
			add_action( 'jetpack_notices', array( $this, 'admin_notices' ) );
3889
		}
3890
3891 View Code Duplication
		if ( isset( $_GET['configure'] ) && Jetpack::is_module( $_GET['configure'] ) && current_user_can( 'manage_options' ) ) {
3892
			/**
3893
			 * Fires when a module configuration page is loaded.
3894
			 * The dynamic part of the hook is the configure parameter from the URL.
3895
			 *
3896
			 * @since 1.1.0
3897
			 */
3898
			do_action( 'jetpack_module_configuration_load_' . $_GET['configure'] );
3899
		}
3900
3901
		add_filter( 'jetpack_short_module_description', 'wptexturize' );
3902
	}
3903
3904
	function admin_notices() {
3905
3906
		if ( $this->error ) {
3907
?>
3908
<div id="message" class="jetpack-message jetpack-err">
3909
	<div class="squeezer">
3910
		<h2><?php echo wp_kses( $this->error, array( 'a' => array( 'href' => array() ), 'small' => true, 'code' => true, 'strong' => true, 'br' => true, 'b' => true ) ); ?></h2>
3911
<?php	if ( $desc = Jetpack::state( 'error_description' ) ) : ?>
3912
		<p><?php echo esc_html( stripslashes( $desc ) ); ?></p>
3913
<?php	endif; ?>
3914
	</div>
3915
</div>
3916
<?php
3917
		}
3918
3919
		if ( $this->message ) {
3920
?>
3921
<div id="message" class="jetpack-message">
3922
	<div class="squeezer">
3923
		<h2><?php echo wp_kses( $this->message, array( 'strong' => array(), 'a' => array( 'href' => true ), 'br' => true ) ); ?></h2>
3924
	</div>
3925
</div>
3926
<?php
3927
		}
3928
3929
		if ( $this->privacy_checks ) :
3930
			$module_names = $module_slugs = array();
3931
3932
			$privacy_checks = explode( ',', $this->privacy_checks );
3933
			$privacy_checks = array_filter( $privacy_checks, array( 'Jetpack', 'is_module' ) );
3934
			foreach ( $privacy_checks as $module_slug ) {
3935
				$module = Jetpack::get_module( $module_slug );
3936
				if ( ! $module ) {
3937
					continue;
3938
				}
3939
3940
				$module_slugs[] = $module_slug;
3941
				$module_names[] = "<strong>{$module['name']}</strong>";
3942
			}
3943
3944
			$module_slugs = join( ',', $module_slugs );
3945
?>
3946
<div id="message" class="jetpack-message jetpack-err">
3947
	<div class="squeezer">
3948
		<h2><strong><?php esc_html_e( 'Is this site private?', 'jetpack' ); ?></strong></h2><br />
3949
		<p><?php
3950
			echo wp_kses(
3951
				wptexturize(
3952
					wp_sprintf(
3953
						_nx(
3954
							"Like your site's RSS feeds, %l allows access to your posts and other content to third parties.",
3955
							"Like your site's RSS feeds, %l allow access to your posts and other content to third parties.",
3956
							count( $privacy_checks ),
3957
							'%l = list of Jetpack module/feature names',
3958
							'jetpack'
3959
						),
3960
						$module_names
3961
					)
3962
				),
3963
				array( 'strong' => true )
3964
			);
3965
3966
			echo "\n<br />\n";
3967
3968
			echo wp_kses(
3969
				sprintf(
3970
					_nx(
3971
						'If your site is not publicly accessible, consider <a href="%1$s" title="%2$s">deactivating this feature</a>.',
3972
						'If your site is not publicly accessible, consider <a href="%1$s" title="%2$s">deactivating these features</a>.',
3973
						count( $privacy_checks ),
3974
						'%1$s = deactivation URL, %2$s = "Deactivate {list of Jetpack module/feature names}',
3975
						'jetpack'
3976
					),
3977
					wp_nonce_url(
3978
						Jetpack::admin_url(
3979
							array(
3980
								'page'   => 'jetpack',
3981
								'action' => 'deactivate',
3982
								'module' => urlencode( $module_slugs ),
3983
							)
3984
						),
3985
						"jetpack_deactivate-$module_slugs"
3986
					),
3987
					esc_attr( wp_kses( wp_sprintf( _x( 'Deactivate %l', '%l = list of Jetpack module/feature names', 'jetpack' ), $module_names ), array() ) )
3988
				),
3989
				array( 'a' => array( 'href' => true, 'title' => true ) )
3990
			);
3991
		?></p>
3992
	</div>
3993
</div>
3994
<?php endif;
3995
	// only display the notice if the other stuff is not there
3996
	if( $this->can_display_jetpack_manage_notice() && !  $this->error && ! $this->message && ! $this->privacy_checks ) {
3997
		if( isset( $_GET['page'] ) && 'jetpack' != $_GET['page'] )
3998
			$this->opt_in_jetpack_manage_notice();
3999
		}
4000
	}
4001
4002
	/**
4003
	 * Record a stat for later output.  This will only currently output in the admin_footer.
4004
	 */
4005
	function stat( $group, $detail ) {
4006
		if ( ! isset( $this->stats[ $group ] ) )
4007
			$this->stats[ $group ] = array();
4008
		$this->stats[ $group ][] = $detail;
4009
	}
4010
4011
	/**
4012
	 * Load stats pixels. $group is auto-prefixed with "x_jetpack-"
4013
	 */
4014
	function do_stats( $method = '' ) {
4015
		if ( is_array( $this->stats ) && count( $this->stats ) ) {
4016
			foreach ( $this->stats as $group => $stats ) {
4017
				if ( is_array( $stats ) && count( $stats ) ) {
4018
					$args = array( "x_jetpack-{$group}" => implode( ',', $stats ) );
4019
					if ( 'server_side' === $method ) {
4020
						self::do_server_side_stat( $args );
4021
					} else {
4022
						echo '<img src="' . esc_url( self::build_stats_url( $args ) ) . '" width="1" height="1" style="display:none;" />';
4023
					}
4024
				}
4025
				unset( $this->stats[ $group ] );
4026
			}
4027
		}
4028
	}
4029
4030
	/**
4031
	 * Runs stats code for a one-off, server-side.
4032
	 *
4033
	 * @param $args array|string The arguments to append to the URL. Should include `x_jetpack-{$group}={$stats}` or whatever we want to store.
4034
	 *
4035
	 * @return bool If it worked.
4036
	 */
4037
	static function do_server_side_stat( $args ) {
4038
		$response = wp_remote_get( esc_url_raw( self::build_stats_url( $args ) ) );
4039
		if ( is_wp_error( $response ) )
4040
			return false;
4041
4042
		if ( 200 !== wp_remote_retrieve_response_code( $response ) )
4043
			return false;
4044
4045
		return true;
4046
	}
4047
4048
	/**
4049
	 * Builds the stats url.
4050
	 *
4051
	 * @param $args array|string The arguments to append to the URL.
4052
	 *
4053
	 * @return string The URL to be pinged.
4054
	 */
4055
	static function build_stats_url( $args ) {
4056
		$defaults = array(
4057
			'v'    => 'wpcom2',
4058
			'rand' => md5( mt_rand( 0, 999 ) . time() ),
4059
		);
4060
		$args     = wp_parse_args( $args, $defaults );
4061
		/**
4062
		 * Filter the URL used as the Stats tracking pixel.
4063
		 *
4064
		 * @since 2.3.2
4065
		 *
4066
		 * @param string $url Base URL used as the Stats tracking pixel.
4067
		 */
4068
		$base_url = apply_filters(
4069
			'jetpack_stats_base_url',
4070
			'https://pixel.wp.com/g.gif'
4071
		);
4072
		$url      = add_query_arg( $args, $base_url );
4073
		return $url;
4074
	}
4075
4076
	static function translate_current_user_to_role() {
4077
		foreach ( self::$capability_translations as $role => $cap ) {
4078
			if ( current_user_can( $role ) || current_user_can( $cap ) ) {
4079
				return $role;
4080
			}
4081
		}
4082
4083
		return false;
4084
	}
4085
4086
	static function translate_role_to_cap( $role ) {
4087
		if ( ! isset( self::$capability_translations[$role] ) ) {
4088
			return false;
4089
		}
4090
4091
		return self::$capability_translations[$role];
4092
	}
4093
4094
	static function sign_role( $role ) {
4095
		if ( ! $user_id = (int) get_current_user_id() ) {
4096
			return false;
4097
		}
4098
4099
		$token = Jetpack_Data::get_access_token();
4100
		if ( ! $token || is_wp_error( $token ) ) {
4101
			return false;
4102
		}
4103
4104
		return $role . ':' . hash_hmac( 'md5', "{$role}|{$user_id}", $token->secret );
4105
	}
4106
4107
4108
	/**
4109
	 * Builds a URL to the Jetpack connection auth page
4110
	 *
4111
	 * @since 3.9.5
4112
	 *
4113
	 * @param bool $raw If true, URL will not be escaped.
4114
	 * @param bool|string $redirect If true, will redirect back to Jetpack wp-admin landing page after connection.
4115
	 *                              If string, will be a custom redirect.
4116
	 * @param bool|string $from If not false, adds 'from=$from' param to the connect URL.
4117
	 * @param bool $register If true, will generate a register URL regardless of the existing token, since 4.9.0
4118
	 *
4119
	 * @return string Connect URL
4120
	 */
4121
	function build_connect_url( $raw = false, $redirect = false, $from = false, $register = false ) {
4122
		$site_id = Jetpack_Options::get_option( 'id' );
4123
		$token = Jetpack_Options::get_option( 'blog_token' );
4124
4125
		if ( $register || ! $token || ! $site_id ) {
4126
			$url = Jetpack::nonce_url_no_esc( Jetpack::admin_url( 'action=register' ), 'jetpack-register' );
4127
			if( is_network_admin() ) {
4128
				$url = add_query_arg( 'is_multisite', network_admin_url( 'admin.php?page=jetpack-settings' ), $url );
4129
			}
4130
		} else {
4131
4132
			// Checking existing token
4133
			$response = Jetpack_Client::wpcom_json_api_request_as_blog(
4134
				sprintf( '/sites/%d', $site_id ) .'?force=wpcom',
4135
				'1.1'
4136
			);
4137
4138
			if ( 200 !== wp_remote_retrieve_response_code( $response ) ) {
4139
				// Generating a register URL instead to refresh the existing token
4140
				return $this->build_connect_url( $raw, $redirect, $from, true );
4141
			}
4142
4143
			if ( defined( 'JETPACK__GLOTPRESS_LOCALES_PATH' ) && include_once JETPACK__GLOTPRESS_LOCALES_PATH ) {
4144
				$gp_locale = GP_Locales::by_field( 'wp_locale', get_locale() );
4145
			}
4146
4147
			$role = self::translate_current_user_to_role();
4148
			$signed_role = self::sign_role( $role );
4149
4150
			$user = wp_get_current_user();
4151
4152
			$jetpack_admin_page = esc_url_raw( admin_url( 'admin.php?page=jetpack' ) );
4153
			$redirect = $redirect
4154
				? wp_validate_redirect( esc_url_raw( $redirect ), $jetpack_admin_page )
4155
				: $jetpack_admin_page;
4156
4157
			if( isset( $_REQUEST['is_multisite'] ) ) {
4158
				$redirect = Jetpack_Network::init()->get_url( 'network_admin_page' );
4159
			}
4160
4161
			$secrets = Jetpack::init()->generate_secrets( 'authorize' );
4162
			@list( $secret ) = explode( ':', $secrets );
0 ignored issues
show
Security Best Practice introduced by
It seems like you do not handle an error condition here. This can introduce security issues, and is generally not recommended.

If you suppress an error, we recommend checking for the error condition explicitly:

// For example instead of
@mkdir($dir);

// Better use
if (@mkdir($dir) === false) {
    throw new \RuntimeException('The directory '.$dir.' could not be created.');
}
Loading history...
4163
4164
			$site_icon = ( function_exists( 'has_site_icon') && has_site_icon() )
4165
				? get_site_icon_url()
4166
				: false;
4167
4168
			/**
4169
			 * Filter the type of authorization.
4170
			 * 'calypso' completes authorization on wordpress.com/jetpack/connect
4171
			 * while 'jetpack' ( or any other value ) completes the authorization at jetpack.wordpress.com.
4172
			 *
4173
			 * @since 4.3.3
4174
			 *
4175
			 * @param string $auth_type Defaults to 'calypso', can also be 'jetpack'.
4176
			 */
4177
			$auth_type = apply_filters( 'jetpack_auth_type', 'calypso' );
4178
4179
			$args = urlencode_deep(
4180
				array(
4181
					'response_type' => 'code',
4182
					'client_id'     => Jetpack_Options::get_option( 'id' ),
4183
					'redirect_uri'  => add_query_arg(
4184
						array(
4185
							'action'   => 'authorize',
4186
							'_wpnonce' => wp_create_nonce( "jetpack-authorize_{$role}_{$redirect}" ),
4187
							'redirect' => urlencode( $redirect ),
4188
						),
4189
						esc_url( admin_url( 'admin.php?page=jetpack' ) )
4190
					),
4191
					'state'         => $user->ID,
4192
					'scope'         => $signed_role,
4193
					'user_email'    => $user->user_email,
4194
					'user_login'    => $user->user_login,
4195
					'is_active'     => Jetpack::is_active(),
4196
					'jp_version'    => JETPACK__VERSION,
4197
					'auth_type'     => $auth_type,
4198
					'secret'        => $secret,
4199
					'locale'        => ( isset( $gp_locale ) && isset( $gp_locale->slug ) ) ? $gp_locale->slug : '',
4200
					'blogname'      => get_option( 'blogname' ),
4201
					'site_url'      => site_url(),
4202
					'home_url'      => home_url(),
4203
					'site_icon'     => $site_icon,
4204
				)
4205
			);
4206
4207
			$url = add_query_arg( $args, Jetpack::api_url( 'authorize' ) );
4208
		}
4209
4210
		if ( $from ) {
4211
			$url = add_query_arg( 'from', $from, $url );
4212
		}
4213
4214
4215
		if ( isset( $_GET['calypso_env'] ) ) {
4216
			$url = add_query_arg( 'calypso_env', sanitize_key( $_GET['calypso_env'] ), $url );
4217
		}
4218
4219
		return $raw ? $url : esc_url( $url );
4220
	}
4221
4222
	function build_reconnect_url( $raw = false ) {
4223
		$url = wp_nonce_url( Jetpack::admin_url( 'action=reconnect' ), 'jetpack-reconnect' );
4224
		return $raw ? $url : esc_url( $url );
4225
	}
4226
4227
	public static function admin_url( $args = null ) {
4228
		$args = wp_parse_args( $args, array( 'page' => 'jetpack' ) );
4229
		$url = add_query_arg( $args, admin_url( 'admin.php' ) );
4230
		return $url;
4231
	}
4232
4233
	public static function nonce_url_no_esc( $actionurl, $action = -1, $name = '_wpnonce' ) {
4234
		$actionurl = str_replace( '&amp;', '&', $actionurl );
4235
		return add_query_arg( $name, wp_create_nonce( $action ), $actionurl );
4236
	}
4237
4238
	function dismiss_jetpack_notice() {
4239
4240
		if ( ! isset( $_GET['jetpack-notice'] ) ) {
4241
			return;
4242
		}
4243
4244
		switch( $_GET['jetpack-notice'] ) {
4245
			case 'dismiss':
4246
				if ( check_admin_referer( 'jetpack-deactivate' ) && ! is_plugin_active_for_network( plugin_basename( JETPACK__PLUGIN_DIR . 'jetpack.php' ) ) ) {
4247
4248
					require_once ABSPATH . 'wp-admin/includes/plugin.php';
4249
					deactivate_plugins( JETPACK__PLUGIN_DIR . 'jetpack.php', false, false );
4250
					wp_safe_redirect( admin_url() . 'plugins.php?deactivate=true&plugin_status=all&paged=1&s=' );
4251
				}
4252
				break;
4253 View Code Duplication
			case 'jetpack-manage-opt-out':
4254
4255
				if ( check_admin_referer( 'jetpack_manage_banner_opt_out' ) ) {
4256
					// Don't show the banner again
4257
4258
					Jetpack_Options::update_option( 'dismissed_manage_banner', true );
4259
					// redirect back to the page that had the notice
4260
					if ( wp_get_referer() ) {
4261
						wp_safe_redirect( wp_get_referer() );
4262
					} else {
4263
						// Take me to Jetpack
4264
						wp_safe_redirect( admin_url( 'admin.php?page=jetpack' ) );
4265
					}
4266
				}
4267
				break;
4268 View Code Duplication
			case 'jetpack-protect-multisite-opt-out':
4269
4270
				if ( check_admin_referer( 'jetpack_protect_multisite_banner_opt_out' ) ) {
4271
					// Don't show the banner again
4272
4273
					update_site_option( 'jetpack_dismissed_protect_multisite_banner', true );
4274
					// redirect back to the page that had the notice
4275
					if ( wp_get_referer() ) {
4276
						wp_safe_redirect( wp_get_referer() );
4277
					} else {
4278
						// Take me to Jetpack
4279
						wp_safe_redirect( admin_url( 'admin.php?page=jetpack' ) );
4280
					}
4281
				}
4282
				break;
4283
			case 'jetpack-manage-opt-in':
4284
				if ( check_admin_referer( 'jetpack_manage_banner_opt_in' ) ) {
4285
					// This makes sure that we are redirect to jetpack home so that we can see the Success Message.
4286
4287
					$redirection_url = Jetpack::admin_url();
4288
					remove_action( 'jetpack_pre_activate_module',   array( Jetpack_Admin::init(), 'fix_redirect' ) );
4289
4290
					// Don't redirect form the Jetpack Setting Page
4291
					$referer_parsed = parse_url ( wp_get_referer() );
4292
					// check that we do have a wp_get_referer and the query paramater is set orderwise go to the Jetpack Home
4293
					if ( isset( $referer_parsed['query'] ) && false !== strpos( $referer_parsed['query'], 'page=jetpack_modules' ) ) {
4294
						// Take the user to Jetpack home except when on the setting page
4295
						$redirection_url = wp_get_referer();
4296
						add_action( 'jetpack_pre_activate_module',   array( Jetpack_Admin::init(), 'fix_redirect' ) );
4297
					}
4298
					// Also update the JSON API FULL MANAGEMENT Option
4299
					Jetpack::activate_module( 'manage', false, false );
4300
4301
					// Special Message when option in.
4302
					Jetpack::state( 'optin-manage', 'true' );
4303
					// Activate the Module if not activated already
4304
4305
					// Redirect properly
4306
					wp_safe_redirect( $redirection_url );
4307
4308
				}
4309
				break;
4310
		}
4311
	}
4312
4313
	public static function admin_screen_configure_module( $module_id ) {
4314
4315
		// User that doesn't have 'jetpack_configure_modules' will never end up here since Jetpack Landing Page woun't let them.
4316
		if ( ! in_array( $module_id, Jetpack::get_active_modules() ) && current_user_can( 'manage_options' ) ) {
4317
			if ( has_action( 'display_activate_module_setting_' . $module_id ) ) {
4318
				/**
4319
				 * Fires to diplay a custom module activation screen.
4320
				 *
4321
				 * To add a module actionation screen use Jetpack::module_configuration_activation_screen method.
4322
				 * Example: Jetpack::module_configuration_activation_screen( 'manage', array( $this, 'manage_activate_screen' ) );
4323
				 *
4324
				 * @module manage
4325
				 *
4326
				 * @since 3.8.0
4327
				 *
4328
				 * @param int $module_id Module ID.
4329
				 */
4330
				do_action( 'display_activate_module_setting_' . $module_id );
4331
			} else {
4332
				self::display_activate_module_link( $module_id );
4333
			}
4334
4335
			return false;
4336
		} ?>
4337
4338
		<div id="jp-settings-screen" style="position: relative">
4339
			<h3>
4340
			<?php
4341
				$module = Jetpack::get_module( $module_id );
4342
				echo '<a href="' . Jetpack::admin_url( 'page=jetpack_modules' ) . '">' . __( 'Jetpack by WordPress.com', 'jetpack' ) . '</a> &rarr; ';
4343
				printf( __( 'Configure %s', 'jetpack' ), $module['name'] );
4344
			?>
4345
			</h3>
4346
			<?php
4347
				/**
4348
				 * Fires within the displayed message when a feature configuation is updated.
4349
				 *
4350
				 * @since 3.4.0
4351
				 *
4352
				 * @param int $module_id Module ID.
4353
				 */
4354
				do_action( 'jetpack_notices_update_settings', $module_id );
4355
				/**
4356
				 * Fires when a feature configuation screen is loaded.
4357
				 * The dynamic part of the hook, $module_id, is the module ID.
4358
				 *
4359
				 * @since 1.1.0
4360
				 */
4361
				do_action( 'jetpack_module_configuration_screen_' . $module_id );
4362
			?>
4363
		</div><?php
4364
	}
4365
4366
	/**
4367
	 * Display link to activate the module to see the settings screen.
4368
	 * @param  string $module_id
4369
	 * @return null
4370
	 */
4371
	public static function display_activate_module_link( $module_id ) {
4372
4373
		$info =  Jetpack::get_module( $module_id );
4374
		$extra = '';
4375
		$activate_url = wp_nonce_url(
4376
				Jetpack::admin_url(
4377
					array(
4378
						'page'   => 'jetpack',
4379
						'action' => 'activate',
4380
						'module' => $module_id,
4381
					)
4382
				),
4383
				"jetpack_activate-$module_id"
4384
			);
4385
4386
		?>
4387
4388
		<div class="wrap configure-module">
4389
			<div id="jp-settings-screen">
4390
				<?php
4391
				if ( $module_id == 'json-api' ) {
4392
4393
					$info['name'] = esc_html__( 'Activate Site Management and JSON API', 'jetpack' );
4394
4395
					$activate_url = Jetpack::init()->opt_in_jetpack_manage_url();
4396
4397
					$info['description'] = sprintf( __( 'Manage your multiple Jetpack sites from our centralized dashboard at wordpress.com/sites. <a href="%s" target="_blank">Learn more</a>.', 'jetpack' ), 'https://jetpack.com/support/site-management' );
4398
4399
					// $extra = __( 'To use Site Management, you need to first activate JSON API to allow remote management of your site. ', 'jetpack' );
4400
				} ?>
4401
4402
				<h3><?php echo esc_html( $info['name'] ); ?></h3>
4403
				<div class="narrow">
4404
					<p><?php echo  $info['description']; ?></p>
4405
					<?php if( $extra ) { ?>
4406
					<p><?php echo esc_html( $extra ); ?></p>
4407
					<?php } ?>
4408
					<p>
4409
						<?php
4410
						if( wp_get_referer() ) {
4411
							printf( __( '<a class="button-primary" href="%s">Activate Now</a> or <a href="%s" >return to previous page</a>.', 'jetpack' ) , $activate_url, wp_get_referer() );
4412
						} else {
4413
							printf( __( '<a class="button-primary" href="%s">Activate Now</a>', 'jetpack' ) , $activate_url  );
4414
						} ?>
4415
					</p>
4416
				</div>
4417
4418
			</div>
4419
		</div>
4420
4421
		<?php
4422
	}
4423
4424
	public static function sort_modules( $a, $b ) {
4425
		if ( $a['sort'] == $b['sort'] )
4426
			return 0;
4427
4428
		return ( $a['sort'] < $b['sort'] ) ? -1 : 1;
4429
	}
4430
4431
	function ajax_recheck_ssl() {
4432
		check_ajax_referer( 'recheck-ssl', 'ajax-nonce' );
4433
		$result = Jetpack::permit_ssl( true );
4434
		wp_send_json( array(
4435
			'enabled' => $result,
4436
			'message' => get_transient( 'jetpack_https_test_message' )
4437
		) );
4438
	}
4439
4440
/* Client API */
4441
4442
	/**
4443
	 * Returns the requested Jetpack API URL
4444
	 *
4445
	 * @return string
4446
	 */
4447
	public static function api_url( $relative_url ) {
4448
		return trailingslashit( JETPACK__API_BASE . $relative_url  ) . JETPACK__API_VERSION . '/';
4449
	}
4450
4451
	/**
4452
	 * Some hosts disable the OpenSSL extension and so cannot make outgoing HTTPS requsets
4453
	 */
4454
	public static function fix_url_for_bad_hosts( $url ) {
4455
		if ( 0 !== strpos( $url, 'https://' ) ) {
4456
			return $url;
4457
		}
4458
4459
		switch ( JETPACK_CLIENT__HTTPS ) {
4460
			case 'ALWAYS' :
4461
				return $url;
4462
			case 'NEVER' :
4463
				return set_url_scheme( $url, 'http' );
4464
			// default : case 'AUTO' :
4465
		}
4466
4467
		// we now return the unmodified SSL URL by default, as a security precaution
4468
		return $url;
4469
	}
4470
4471
	/**
4472
	 * Checks to see if the URL is using SSL to connect with Jetpack
4473
	 *
4474
	 * @since 2.3.3
4475
	 * @return boolean
4476
	 */
4477
	public static function permit_ssl( $force_recheck = false ) {
4478
		// Do some fancy tests to see if ssl is being supported
4479
		if ( $force_recheck || false === ( $ssl = get_transient( 'jetpack_https_test' ) ) ) {
4480
			$message = '';
4481
			if ( 'https' !== substr( JETPACK__API_BASE, 0, 5 ) ) {
4482
				$ssl = 0;
4483
			} else {
4484
				switch ( JETPACK_CLIENT__HTTPS ) {
4485
					case 'NEVER':
4486
						$ssl = 0;
4487
						$message = __( 'JETPACK_CLIENT__HTTPS is set to NEVER', 'jetpack' );
4488
						break;
4489
					case 'ALWAYS':
4490
					case 'AUTO':
4491
					default:
4492
						$ssl = 1;
4493
						break;
4494
				}
4495
4496
				// If it's not 'NEVER', test to see
4497
				if ( $ssl ) {
4498
					if ( ! wp_http_supports( array( 'ssl' => true ) ) ) {
4499
						$ssl = 0;
4500
						$message = __( 'WordPress reports no SSL support', 'jetpack' );
4501
					} else {
4502
						$response = wp_remote_get( JETPACK__API_BASE . 'test/1/' );
4503
						if ( is_wp_error( $response ) ) {
4504
							$ssl = 0;
4505
							$message = __( 'WordPress reports no SSL support', 'jetpack' );
4506
						} elseif ( 'OK' !== wp_remote_retrieve_body( $response ) ) {
4507
							$ssl = 0;
4508
							$message = __( 'Response was not OK: ', 'jetpack' ) . wp_remote_retrieve_body( $response );
4509
						}
4510
					}
4511
				}
4512
			}
4513
			set_transient( 'jetpack_https_test', $ssl, DAY_IN_SECONDS );
4514
			set_transient( 'jetpack_https_test_message', $message, DAY_IN_SECONDS );
4515
		}
4516
4517
		return (bool) $ssl;
4518
	}
4519
4520
	/*
4521
	 * Displays an admin_notice, alerting the user to their JETPACK_CLIENT__HTTPS constant being 'AUTO' but SSL isn't working.
4522
	 */
4523
	public function alert_auto_ssl_fail() {
4524
		if ( ! current_user_can( 'manage_options' ) )
4525
			return;
4526
4527
		$ajax_nonce = wp_create_nonce( 'recheck-ssl' );
4528
		?>
4529
4530
		<div id="jetpack-ssl-warning" class="error jp-identity-crisis">
4531
			<div class="jp-banner__content">
4532
				<h2><?php _e( 'Outbound HTTPS not working', 'jetpack' ); ?></h2>
4533
				<p><?php _e( 'Your site could not connect to WordPress.com via HTTPS. This could be due to any number of reasons, including faulty SSL certificates, misconfigured or missing SSL libraries, or network issues.', 'jetpack' ); ?></p>
4534
				<p>
4535
					<?php _e( 'Jetpack will re-test for HTTPS support once a day, but you can click here to try again immediately: ', 'jetpack' ); ?>
4536
					<a href="#" id="jetpack-recheck-ssl-button"><?php _e( 'Try again', 'jetpack' ); ?></a>
4537
					<span id="jetpack-recheck-ssl-output"><?php echo get_transient( 'jetpack_https_test_message' ); ?></span>
4538
				</p>
4539
				<p>
4540
					<?php printf( __( 'For more help, try our <a href="%1$s">connection debugger</a> or <a href="%2$s" target="_blank">troubleshooting tips</a>.', 'jetpack' ),
4541
							esc_url( Jetpack::admin_url( array( 'page' => 'jetpack-debugger' )  ) ),
4542
							esc_url( 'https://jetpack.com/support/getting-started-with-jetpack/troubleshooting-tips/' ) ); ?>
4543
				</p>
4544
			</div>
4545
		</div>
4546
		<style>
4547
			#jetpack-recheck-ssl-output { margin-left: 5px; color: red; }
4548
		</style>
4549
		<script type="text/javascript">
4550
			jQuery( document ).ready( function( $ ) {
4551
				$( '#jetpack-recheck-ssl-button' ).click( function( e ) {
4552
					var $this = $( this );
4553
					$this.html( <?php echo json_encode( __( 'Checking', 'jetpack' ) ); ?> );
4554
					$( '#jetpack-recheck-ssl-output' ).html( '' );
4555
					e.preventDefault();
4556
					var data = { action: 'jetpack-recheck-ssl', 'ajax-nonce': '<?php echo $ajax_nonce; ?>' };
4557
					$.post( ajaxurl, data )
4558
					  .done( function( response ) {
4559
					  	if ( response.enabled ) {
4560
					  		$( '#jetpack-ssl-warning' ).hide();
4561
					  	} else {
4562
					  		this.html( <?php echo json_encode( __( 'Try again', 'jetpack' ) ); ?> );
4563
					  		$( '#jetpack-recheck-ssl-output' ).html( 'SSL Failed: ' + response.message );
4564
					  	}
4565
					  }.bind( $this ) );
4566
				} );
4567
			} );
4568
		</script>
4569
4570
		<?php
4571
	}
4572
4573
	/**
4574
	 * Returns the Jetpack XML-RPC API
4575
	 *
4576
	 * @return string
4577
	 */
4578
	public static function xmlrpc_api_url() {
4579
		$base = preg_replace( '#(https?://[^?/]+)(/?.*)?$#', '\\1', JETPACK__API_BASE );
4580
		return untrailingslashit( $base ) . '/xmlrpc.php';
4581
	}
4582
4583
	/**
4584
	 * Creates two secret tokens and the end of life timestamp for them.
4585
	 *
4586
	 * Note these tokens are unique per call, NOT static per site for connecting.
4587
	 *
4588
	 * @since 2.6
4589
	 * @return array
4590
	 */
4591
	public function generate_secrets( $action, $exp = 600 ) {
4592
	    $secret = wp_generate_password( 32, false ) // secret_1
4593
	    		. ':' . wp_generate_password( 32, false ) // secret_2
4594
	    		. ':' . ( time() + $exp ) // eol ( End of Life )
4595
	    		. ':' . get_current_user_id(); // ties the secrets to the current user
4596
		Jetpack_Options::update_option( $action, $secret );
4597
	    return Jetpack_Options::get_option( $action );
4598
	}
4599
4600
	/**
4601
	 * Builds the timeout limit for queries talking with the wpcom servers.
4602
	 *
4603
	 * Based on local php max_execution_time in php.ini
4604
	 *
4605
	 * @since 2.6
4606
	 * @return int
4607
	 **/
4608
	public function get_remote_query_timeout_limit() {
4609
	    $timeout = (int) ini_get( 'max_execution_time' );
4610
	    if ( ! $timeout ) // Ensure exec time set in php.ini
4611
				$timeout = 30;
4612
	    return intval( $timeout / 2 );
4613
	}
4614
4615
4616
	/**
4617
	 * Takes the response from the Jetpack register new site endpoint and
4618
	 * verifies it worked properly.
4619
	 *
4620
	 * @since 2.6
4621
	 * @return string|Jetpack_Error A JSON object on success or Jetpack_Error on failures
4622
	 **/
4623
	public function validate_remote_register_response( $response ) {
4624
	  if ( is_wp_error( $response ) ) {
4625
			return new Jetpack_Error( 'register_http_request_failed', $response->get_error_message() );
4626
		}
4627
4628
		$code   = wp_remote_retrieve_response_code( $response );
4629
		$entity = wp_remote_retrieve_body( $response );
4630
		if ( $entity )
4631
			$registration_response = json_decode( $entity );
4632
		else
4633
			$registration_response = false;
4634
4635
		$code_type = intval( $code / 100 );
4636
		if ( 5 == $code_type ) {
4637
			return new Jetpack_Error( 'wpcom_5??', sprintf( __( 'Error Details: %s', 'jetpack' ), $code ), $code );
4638
		} elseif ( 408 == $code ) {
4639
			return new Jetpack_Error( 'wpcom_408', sprintf( __( 'Error Details: %s', 'jetpack' ), $code ), $code );
4640
		} elseif ( ! empty( $registration_response->error ) ) {
4641
			if ( 'xml_rpc-32700' == $registration_response->error && ! function_exists( 'xml_parser_create' ) ) {
4642
				$error_description = __( "PHP's XML extension is not available. Jetpack requires the XML extension to communicate with WordPress.com. Please contact your hosting provider to enable PHP's XML extension.", 'jetpack' );
4643
			} else {
4644
				$error_description = isset( $registration_response->error_description ) ? sprintf( __( 'Error Details: %s', 'jetpack' ), (string) $registration_response->error_description ) : '';
4645
			}
4646
4647
			return new Jetpack_Error( (string) $registration_response->error, $error_description, $code );
4648
		} elseif ( 200 != $code ) {
4649
			return new Jetpack_Error( 'wpcom_bad_response', sprintf( __( 'Error Details: %s', 'jetpack' ), $code ), $code );
4650
		}
4651
4652
		// Jetpack ID error block
4653
		if ( empty( $registration_response->jetpack_id ) ) {
4654
			return new Jetpack_Error( 'jetpack_id', sprintf( __( 'Error Details: Jetpack ID is empty. Do not publicly post this error message! %s', 'jetpack' ), $entity ), $entity );
4655
		} elseif ( ! is_scalar( $registration_response->jetpack_id ) ) {
4656
			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 );
4657
		} elseif ( preg_match( '/[^0-9]/', $registration_response->jetpack_id ) ) {
4658
			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 );
4659
		}
4660
4661
	    return $registration_response;
4662
	}
4663
	/**
4664
	 * @return bool|WP_Error
4665
	 */
4666
	public static function register() {
4667
		add_action( 'pre_update_jetpack_option_register', array( 'Jetpack_Options', 'delete_option' ) );
4668
		$secrets = Jetpack::init()->generate_secrets( 'register' );
4669
4670
		@list( $secret_1, $secret_2, $secret_eol ) = explode( ':', $secrets );
4671 View Code Duplication
		if ( empty( $secret_1 ) || empty( $secret_2 ) || empty( $secret_eol ) || $secret_eol < time() ) {
4672
			return new Jetpack_Error( 'missing_secrets' );
4673
		}
4674
4675
		$timeout = Jetpack::init()->get_remote_query_timeout_limit();
4676
4677
		$gmt_offset = get_option( 'gmt_offset' );
4678
		if ( ! $gmt_offset ) {
4679
			$gmt_offset = 0;
4680
		}
4681
4682
		$stats_options = get_option( 'stats_options' );
4683
		$stats_id = isset($stats_options['blog_id']) ? $stats_options['blog_id'] : null;
4684
4685
		$args = array(
4686
			'method'  => 'POST',
4687
			'body'    => array(
4688
				'siteurl'         => site_url(),
4689
				'home'            => home_url(),
4690
				'gmt_offset'      => $gmt_offset,
4691
				'timezone_string' => (string) get_option( 'timezone_string' ),
4692
				'site_name'       => (string) get_option( 'blogname' ),
4693
				'secret_1'        => $secret_1,
4694
				'secret_2'        => $secret_2,
4695
				'site_lang'       => get_locale(),
4696
				'timeout'         => $timeout,
4697
				'stats_id'        => $stats_id,
4698
				'state'           => get_current_user_id(),
4699
			),
4700
			'headers' => array(
4701
				'Accept' => 'application/json',
4702
			),
4703
			'timeout' => $timeout,
4704
		);
4705
		$response = Jetpack_Client::_wp_remote_request( Jetpack::fix_url_for_bad_hosts( Jetpack::api_url( 'register' ) ), $args, true );
4706
4707
		// Make sure the response is valid and does not contain any Jetpack errors
4708
		$registration_details = Jetpack::init()->validate_remote_register_response( $response );
4709
		if ( is_wp_error( $registration_details ) ) {
4710
		    return $registration_details;
4711
		} elseif ( ! $registration_details ) {
4712
			return new Jetpack_Error( 'unknown_error', __( 'Unknown error registering your Jetpack site', 'jetpack' ), wp_remote_retrieve_response_code( $response ) );
4713
		}
4714
4715 View Code Duplication
		if ( empty( $registration_details->jetpack_secret ) || ! is_string( $registration_details->jetpack_secret ) ) {
4716
			return new Jetpack_Error( 'jetpack_secret', '', wp_remote_retrieve_response_code( $response ) );
4717
		}
4718
4719
		if ( isset( $registration_details->jetpack_public ) ) {
4720
			$jetpack_public = (int) $registration_details->jetpack_public;
4721
		} else {
4722
			$jetpack_public = false;
4723
		}
4724
4725
		Jetpack_Options::update_options(
4726
			array(
4727
				'id'         => (int)    $registration_details->jetpack_id,
4728
				'blog_token' => (string) $registration_details->jetpack_secret,
4729
				'public'     => $jetpack_public,
4730
			)
4731
		);
4732
4733
		/**
4734
		 * Fires when a site is registered on WordPress.com.
4735
		 *
4736
		 * @since 3.7.0
4737
		 *
4738
		 * @param int $json->jetpack_id Jetpack Blog ID.
4739
		 * @param string $json->jetpack_secret Jetpack Blog Token.
4740
		 * @param int|bool $jetpack_public Is the site public.
4741
		 */
4742
		do_action( 'jetpack_site_registered', $registration_details->jetpack_id, $registration_details->jetpack_secret, $jetpack_public );
4743
4744
		// Initialize Jump Start for the first and only time.
4745
		if ( ! Jetpack_Options::get_option( 'jumpstart' ) ) {
4746
			Jetpack_Options::update_option( 'jumpstart', 'new_connection' );
4747
4748
			$jetpack = Jetpack::init();
4749
4750
			$jetpack->stat( 'jumpstart', 'unique-views' );
4751
			$jetpack->do_stats( 'server_side' );
4752
		};
4753
4754
		return true;
4755
	}
4756
4757
	/**
4758
	 * If the db version is showing something other that what we've got now, bump it to current.
4759
	 *
4760
	 * @return bool: True if the option was incorrect and updated, false if nothing happened.
4761
	 */
4762
	public static function maybe_set_version_option() {
4763
		list( $version ) = explode( ':', Jetpack_Options::get_option( 'version' ) );
4764
		if ( JETPACK__VERSION != $version ) {
4765
			Jetpack_Options::update_option( 'version', JETPACK__VERSION . ':' . time() );
4766
4767
			if ( version_compare( JETPACK__VERSION, $version, '>' ) ) {
4768
				/** This action is documented in class.jetpack.php */
4769
				do_action( 'updating_jetpack_version', JETPACK__VERSION, $version );
4770
			}
4771
4772
			return true;
4773
		}
4774
		return false;
4775
	}
4776
4777
/* Client Server API */
4778
4779
	/**
4780
	 * Loads the Jetpack XML-RPC client
4781
	 */
4782
	public static function load_xml_rpc_client() {
4783
		require_once ABSPATH . WPINC . '/class-IXR.php';
4784
		require_once JETPACK__PLUGIN_DIR . 'class.jetpack-ixr-client.php';
4785
	}
4786
4787
	/**
4788
	 * Resets the saved authentication state in between testing requests.
4789
	 */
4790
	public function reset_saved_auth_state() {
4791
		$this->xmlrpc_verification = null;
4792
		$this->rest_authentication_status = null;
4793
	}
4794
4795
	function verify_xml_rpc_signature() {
4796
		if ( $this->xmlrpc_verification ) {
4797
			return $this->xmlrpc_verification;
4798
		}
4799
4800
		// It's not for us
4801
		if ( ! isset( $_GET['token'] ) || empty( $_GET['signature'] ) ) {
4802
			return false;
4803
		}
4804
4805
		@list( $token_key, $version, $user_id ) = explode( ':', $_GET['token'] );
4806
		if (
4807
			empty( $token_key )
4808
		||
4809
			empty( $version ) || strval( JETPACK__API_VERSION ) !== $version
4810
		) {
4811
			return false;
4812
		}
4813
4814
		if ( '0' === $user_id ) {
4815
			$token_type = 'blog';
4816
			$user_id = 0;
4817
		} else {
4818
			$token_type = 'user';
4819
			if ( empty( $user_id ) || ! ctype_digit( $user_id ) ) {
4820
				return false;
4821
			}
4822
			$user_id = (int) $user_id;
4823
4824
			$user = new WP_User( $user_id );
4825
			if ( ! $user || ! $user->exists() ) {
4826
				return false;
4827
			}
4828
		}
4829
4830
		$token = Jetpack_Data::get_access_token( $user_id );
4831
		if ( ! $token ) {
4832
			return false;
4833
		}
4834
4835
		$token_check = "$token_key.";
4836
		if ( ! hash_equals( substr( $token->secret, 0, strlen( $token_check ) ), $token_check ) ) {
4837
			return false;
4838
		}
4839
4840
		require_once JETPACK__PLUGIN_DIR . 'class.jetpack-signature.php';
4841
4842
		$jetpack_signature = new Jetpack_Signature( $token->secret, (int) Jetpack_Options::get_option( 'time_diff' ) );
4843
		if ( isset( $_POST['_jetpack_is_multipart'] ) ) {
4844
			$post_data   = $_POST;
4845
			$file_hashes = array();
4846
			foreach ( $post_data as $post_data_key => $post_data_value ) {
4847
				if ( 0 !== strpos( $post_data_key, '_jetpack_file_hmac_' ) ) {
4848
					continue;
4849
				}
4850
				$post_data_key = substr( $post_data_key, strlen( '_jetpack_file_hmac_' ) );
4851
				$file_hashes[$post_data_key] = $post_data_value;
4852
			}
4853
4854
			foreach ( $file_hashes as $post_data_key => $post_data_value ) {
4855
				unset( $post_data["_jetpack_file_hmac_{$post_data_key}"] );
4856
				$post_data[$post_data_key] = $post_data_value;
4857
			}
4858
4859
			ksort( $post_data );
4860
4861
			$body = http_build_query( stripslashes_deep( $post_data ) );
4862
		} elseif ( is_null( $this->HTTP_RAW_POST_DATA ) ) {
4863
			$body = file_get_contents( 'php://input' );
4864
		} else {
4865
			$body = null;
4866
		}
4867
4868
		$signature = $jetpack_signature->sign_current_request(
4869
			array( 'body' => is_null( $body ) ? $this->HTTP_RAW_POST_DATA : $body, )
4870
		);
4871
4872
		if ( ! $signature ) {
4873
			return false;
4874
		} else if ( is_wp_error( $signature ) ) {
4875
			return $signature;
4876
		} else if ( ! hash_equals( $signature, $_GET['signature'] ) ) {
4877
			return false;
4878
		}
4879
4880
		$timestamp = (int) $_GET['timestamp'];
4881
		$nonce     = stripslashes( (string) $_GET['nonce'] );
4882
4883
		if ( ! $this->add_nonce( $timestamp, $nonce ) ) {
4884
			return false;
4885
		}
4886
4887
		$this->xmlrpc_verification = array(
4888
			'type'    => $token_type,
4889
			'user_id' => $token->external_user_id,
4890
		);
4891
4892
		return $this->xmlrpc_verification;
4893
	}
4894
4895
	/**
4896
	 * Authenticates XML-RPC and other requests from the Jetpack Server
4897
	 */
4898
	function authenticate_jetpack( $user, $username, $password ) {
4899
		if ( is_a( $user, 'WP_User' ) ) {
4900
			return $user;
4901
		}
4902
4903
		$token_details = $this->verify_xml_rpc_signature();
4904
4905
		if ( ! $token_details || is_wp_error( $token_details ) ) {
4906
			return $user;
4907
		}
4908
4909
		if ( 'user' !== $token_details['type'] ) {
4910
			return $user;
4911
		}
4912
4913
		if ( ! $token_details['user_id'] ) {
4914
			return $user;
4915
		}
4916
4917
		nocache_headers();
4918
4919
		return new WP_User( $token_details['user_id'] );
4920
	}
4921
4922
	// Authenticates requests from Jetpack server to WP REST API endpoints.
4923
	// Uses the existing XMLRPC request signing implementation.
4924
	function wp_rest_authenticate( $user ) {
4925
		if ( ! empty( $user ) ) {
4926
			// Another authentication method is in effect.
4927
			return $user;
4928
		}
4929
4930
		if ( ! isset( $_GET['_for'] ) || $_GET['_for'] !== 'jetpack' ) {
4931
			// Nothing to do for this authentication method.
4932
			return null;
4933
		}
4934
4935
		if ( ! isset( $_GET['token'] ) && ! isset( $_GET['signature'] ) ) {
4936
			// Nothing to do for this authentication method.
4937
			return null;
4938
		}
4939
4940
		// Ensure that we always have the request body available.  At this
4941
		// point, the WP REST API code to determine the request body has not
4942
		// run yet.  That code may try to read from 'php://input' later, but
4943
		// this can only be done once per request in PHP versions prior to 5.6.
4944
		// So we will go ahead and perform this read now if needed, and save
4945
		// the request body where both the Jetpack signature verification code
4946
		// and the WP REST API code can see it.
4947
		if ( ! isset( $GLOBALS['HTTP_RAW_POST_DATA'] ) ) {
4948
			$GLOBALS['HTTP_RAW_POST_DATA'] = file_get_contents( 'php://input' );
4949
		}
4950
		$this->HTTP_RAW_POST_DATA = $GLOBALS['HTTP_RAW_POST_DATA'];
4951
4952
		// Only support specific request parameters that have been tested and
4953
		// are known to work with signature verification.  A different method
4954
		// can be passed to the WP REST API via the '?_method=' parameter if
4955
		// needed.
4956
		if ( $_SERVER['REQUEST_METHOD'] !== 'GET' && $_SERVER['REQUEST_METHOD'] !== 'POST' ) {
4957
			$this->rest_authentication_status = new WP_Error(
4958
				'rest_invalid_request',
4959
				__( 'This request method is not supported.', 'jetpack' ),
4960
				array( 'status' => 400 )
4961
			);
4962
			return null;
4963
		}
4964
		if ( $_SERVER['REQUEST_METHOD'] !== 'POST' && ! empty( $this->HTTP_RAW_POST_DATA ) ) {
4965
			$this->rest_authentication_status = new WP_Error(
4966
				'rest_invalid_request',
4967
				__( 'This request method does not support body parameters.', 'jetpack' ),
4968
				array( 'status' => 400 )
4969
			);
4970
			return null;
4971
		}
4972
4973
		if ( ! empty( $_SERVER['CONTENT_TYPE'] ) ) {
4974
			$content_type = $_SERVER['CONTENT_TYPE'];
4975
		} elseif ( ! empty( $_SERVER['HTTP_CONTENT_TYPE'] ) ) {
4976
			$content_type = $_SERVER['HTTP_CONTENT_TYPE'];
4977
		}
4978
4979
		if (
4980
			isset( $content_type ) &&
4981
			$content_type !== 'application/x-www-form-urlencoded' &&
4982
			$content_type !== 'application/json'
4983
		) {
4984
			$this->rest_authentication_status = new WP_Error(
4985
				'rest_invalid_request',
4986
				__( 'This Content-Type is not supported.', 'jetpack' ),
4987
				array( 'status' => 400 )
4988
			);
4989
			return null;
4990
		}
4991
4992
		$verified = $this->verify_xml_rpc_signature();
4993
4994
		if ( is_wp_error( $verified ) ) {
4995
			$this->rest_authentication_status = $verified;
4996
			return null;
4997
		}
4998
4999
		if (
5000
			$verified &&
5001
			isset( $verified['type'] ) &&
5002
			'user' === $verified['type'] &&
5003
			! empty( $verified['user_id'] )
5004
		) {
5005
			// Authentication successful.
5006
			$this->rest_authentication_status = true;
5007
			return $verified['user_id'];
5008
		}
5009
5010
		// Something else went wrong.  Probably a signature error.
5011
		$this->rest_authentication_status = new WP_Error(
5012
			'rest_invalid_signature',
5013
			__( 'The request is not signed correctly.', 'jetpack' ),
5014
			array( 'status' => 400 )
5015
		);
5016
		return null;
5017
	}
5018
5019
	/**
5020
	 * Report authentication status to the WP REST API.
5021
	 *
5022
	 * @param  WP_Error|mixed $result Error from another authentication handler, null if we should handle it, or another value if not
5023
	 * @return WP_Error|boolean|null {@see WP_JSON_Server::check_authentication}
5024
	 */
5025
	public function wp_rest_authentication_errors( $value ) {
5026
		if ( $value !== null ) {
5027
			return $value;
5028
		}
5029
		return $this->rest_authentication_status;
5030
	}
5031
5032
	function add_nonce( $timestamp, $nonce ) {
5033
		global $wpdb;
5034
		static $nonces_used_this_request = array();
5035
5036
		if ( isset( $nonces_used_this_request["$timestamp:$nonce"] ) ) {
5037
			return $nonces_used_this_request["$timestamp:$nonce"];
5038
		}
5039
5040
		// This should always have gone through Jetpack_Signature::sign_request() first to check $timestamp an $nonce
5041
		$timestamp = (int) $timestamp;
5042
		$nonce     = esc_sql( $nonce );
5043
5044
		// Raw query so we can avoid races: add_option will also update
5045
		$show_errors = $wpdb->show_errors( false );
5046
5047
		$old_nonce = $wpdb->get_row(
5048
			$wpdb->prepare( "SELECT * FROM `$wpdb->options` WHERE option_name = %s", "jetpack_nonce_{$timestamp}_{$nonce}" )
5049
		);
5050
5051
		if ( is_null( $old_nonce ) ) {
5052
			$return = $wpdb->query(
5053
				$wpdb->prepare(
5054
					"INSERT INTO `$wpdb->options` (`option_name`, `option_value`, `autoload`) VALUES (%s, %s, %s)",
5055
					"jetpack_nonce_{$timestamp}_{$nonce}",
5056
					time(),
5057
					'no'
5058
				)
5059
			);
5060
		} else {
5061
			$return = false;
5062
		}
5063
5064
		$wpdb->show_errors( $show_errors );
5065
5066
		$nonces_used_this_request["$timestamp:$nonce"] = $return;
5067
5068
		return $return;
5069
	}
5070
5071
	/**
5072
	 * In some setups, $HTTP_RAW_POST_DATA can be emptied during some IXR_Server paths since it is passed by reference to various methods.
5073
	 * Capture it here so we can verify the signature later.
5074
	 */
5075
	function xmlrpc_methods( $methods ) {
5076
		$this->HTTP_RAW_POST_DATA = $GLOBALS['HTTP_RAW_POST_DATA'];
5077
		return $methods;
5078
	}
5079
5080
	function public_xmlrpc_methods( $methods ) {
5081
		if ( array_key_exists( 'wp.getOptions', $methods ) ) {
5082
			$methods['wp.getOptions'] = array( $this, 'jetpack_getOptions' );
5083
		}
5084
		return $methods;
5085
	}
5086
5087
	function jetpack_getOptions( $args ) {
5088
		global $wp_xmlrpc_server;
5089
5090
		$wp_xmlrpc_server->escape( $args );
5091
5092
		$username	= $args[1];
5093
		$password	= $args[2];
5094
5095
		if ( !$user = $wp_xmlrpc_server->login($username, $password) ) {
5096
			return $wp_xmlrpc_server->error;
5097
		}
5098
5099
		$options = array();
5100
		$user_data = $this->get_connected_user_data();
5101
		if ( is_array( $user_data ) ) {
5102
			$options['jetpack_user_id'] = array(
5103
				'desc'          => __( 'The WP.com user ID of the connected user', 'jetpack' ),
5104
				'readonly'      => true,
5105
				'value'         => $user_data['ID'],
5106
			);
5107
			$options['jetpack_user_login'] = array(
5108
				'desc'          => __( 'The WP.com username of the connected user', 'jetpack' ),
5109
				'readonly'      => true,
5110
				'value'         => $user_data['login'],
5111
			);
5112
			$options['jetpack_user_email'] = array(
5113
				'desc'          => __( 'The WP.com user email of the connected user', 'jetpack' ),
5114
				'readonly'      => true,
5115
				'value'         => $user_data['email'],
5116
			);
5117
			$options['jetpack_user_site_count'] = array(
5118
				'desc'          => __( 'The number of sites of the connected WP.com user', 'jetpack' ),
5119
				'readonly'      => true,
5120
				'value'         => $user_data['site_count'],
5121
			);
5122
		}
5123
		$wp_xmlrpc_server->blog_options = array_merge( $wp_xmlrpc_server->blog_options, $options );
5124
		$args = stripslashes_deep( $args );
5125
		return $wp_xmlrpc_server->wp_getOptions( $args );
5126
	}
5127
5128
	function xmlrpc_options( $options ) {
5129
		$jetpack_client_id = false;
5130
		if ( self::is_active() ) {
5131
			$jetpack_client_id = Jetpack_Options::get_option( 'id' );
5132
		}
5133
		$options['jetpack_version'] = array(
5134
				'desc'          => __( 'Jetpack Plugin Version', 'jetpack' ),
5135
				'readonly'      => true,
5136
				'value'         => JETPACK__VERSION,
5137
		);
5138
5139
		$options['jetpack_client_id'] = array(
5140
				'desc'          => __( 'The Client ID/WP.com Blog ID of this site', 'jetpack' ),
5141
				'readonly'      => true,
5142
				'value'         => $jetpack_client_id,
5143
		);
5144
		return $options;
5145
	}
5146
5147
	public static function clean_nonces( $all = false ) {
5148
		global $wpdb;
5149
5150
		$sql = "DELETE FROM `$wpdb->options` WHERE `option_name` LIKE %s";
5151
		$sql_args = array( $wpdb->esc_like( 'jetpack_nonce_' ) . '%' );
5152
5153
		if ( true !== $all ) {
5154
			$sql .= ' AND CAST( `option_value` AS UNSIGNED ) < %d';
5155
			$sql_args[] = time() - 3600;
5156
		}
5157
5158
		$sql .= ' ORDER BY `option_id` LIMIT 100';
5159
5160
		$sql = $wpdb->prepare( $sql, $sql_args );
5161
5162
		for ( $i = 0; $i < 1000; $i++ ) {
5163
			if ( ! $wpdb->query( $sql ) ) {
5164
				break;
5165
			}
5166
		}
5167
	}
5168
5169
	/**
5170
	 * State is passed via cookies from one request to the next, but never to subsequent requests.
5171
	 * SET: state( $key, $value );
5172
	 * GET: $value = state( $key );
5173
	 *
5174
	 * @param string $key
5175
	 * @param string $value
5176
	 * @param bool $restate private
5177
	 */
5178
	public static function state( $key = null, $value = null, $restate = false ) {
5179
		static $state = array();
5180
		static $path, $domain;
5181
		if ( ! isset( $path ) ) {
5182
			require_once( ABSPATH . 'wp-admin/includes/plugin.php' );
5183
			$admin_url = Jetpack::admin_url();
5184
			$bits      = parse_url( $admin_url );
5185
5186
			if ( is_array( $bits ) ) {
5187
				$path   = ( isset( $bits['path'] ) ) ? dirname( $bits['path'] ) : null;
5188
				$domain = ( isset( $bits['host'] ) ) ? $bits['host'] : null;
5189
			} else {
5190
				$path = $domain = null;
5191
			}
5192
		}
5193
5194
		// Extract state from cookies and delete cookies
5195
		if ( isset( $_COOKIE[ 'jetpackState' ] ) && is_array( $_COOKIE[ 'jetpackState' ] ) ) {
5196
			$yum = $_COOKIE[ 'jetpackState' ];
5197
			unset( $_COOKIE[ 'jetpackState' ] );
5198
			foreach ( $yum as $k => $v ) {
5199
				if ( strlen( $v ) )
5200
					$state[ $k ] = $v;
5201
				setcookie( "jetpackState[$k]", false, 0, $path, $domain );
5202
			}
5203
		}
5204
5205
		if ( $restate ) {
5206
			foreach ( $state as $k => $v ) {
5207
				setcookie( "jetpackState[$k]", $v, 0, $path, $domain );
5208
			}
5209
			return;
5210
		}
5211
5212
		// Get a state variable
5213
		if ( isset( $key ) && ! isset( $value ) ) {
5214
			if ( array_key_exists( $key, $state ) )
5215
				return $state[ $key ];
5216
			return null;
5217
		}
5218
5219
		// Set a state variable
5220
		if ( isset ( $key ) && isset( $value ) ) {
5221
			if( is_array( $value ) && isset( $value[0] ) ) {
5222
				$value = $value[0];
5223
			}
5224
			$state[ $key ] = $value;
5225
			setcookie( "jetpackState[$key]", $value, 0, $path, $domain );
5226
		}
5227
	}
5228
5229
	public static function restate() {
5230
		Jetpack::state( null, null, true );
5231
	}
5232
5233
	public static function check_privacy( $file ) {
5234
		static $is_site_publicly_accessible = null;
5235
5236
		if ( is_null( $is_site_publicly_accessible ) ) {
5237
			$is_site_publicly_accessible = false;
5238
5239
			Jetpack::load_xml_rpc_client();
5240
			$rpc = new Jetpack_IXR_Client();
5241
5242
			$success = $rpc->query( 'jetpack.isSitePubliclyAccessible', home_url() );
5243
			if ( $success ) {
5244
				$response = $rpc->getResponse();
5245
				if ( $response ) {
5246
					$is_site_publicly_accessible = true;
5247
				}
5248
			}
5249
5250
			Jetpack_Options::update_option( 'public', (int) $is_site_publicly_accessible );
5251
		}
5252
5253
		if ( $is_site_publicly_accessible ) {
5254
			return;
5255
		}
5256
5257
		$module_slug = self::get_module_slug( $file );
5258
5259
		$privacy_checks = Jetpack::state( 'privacy_checks' );
5260
		if ( ! $privacy_checks ) {
5261
			$privacy_checks = $module_slug;
5262
		} else {
5263
			$privacy_checks .= ",$module_slug";
5264
		}
5265
5266
		Jetpack::state( 'privacy_checks', $privacy_checks );
5267
	}
5268
5269
	/**
5270
	 * Helper method for multicall XMLRPC.
5271
	 */
5272
	public static function xmlrpc_async_call() {
5273
		global $blog_id;
5274
		static $clients = array();
5275
5276
		$client_blog_id = is_multisite() ? $blog_id : 0;
5277
5278
		if ( ! isset( $clients[$client_blog_id] ) ) {
5279
			Jetpack::load_xml_rpc_client();
5280
			$clients[$client_blog_id] = new Jetpack_IXR_ClientMulticall( array( 'user_id' => JETPACK_MASTER_USER, ) );
5281
			if ( function_exists( 'ignore_user_abort' ) ) {
5282
				ignore_user_abort( true );
5283
			}
5284
			add_action( 'shutdown', array( 'Jetpack', 'xmlrpc_async_call' ) );
5285
		}
5286
5287
		$args = func_get_args();
5288
5289
		if ( ! empty( $args[0] ) ) {
5290
			call_user_func_array( array( $clients[$client_blog_id], 'addCall' ), $args );
5291
		} elseif ( is_multisite() ) {
5292
			foreach ( $clients as $client_blog_id => $client ) {
5293
				if ( ! $client_blog_id || empty( $client->calls ) ) {
5294
					continue;
5295
				}
5296
5297
				$switch_success = switch_to_blog( $client_blog_id, true );
5298
				if ( ! $switch_success ) {
5299
					continue;
5300
				}
5301
5302
				flush();
5303
				$client->query();
5304
5305
				restore_current_blog();
5306
			}
5307
		} else {
5308
			if ( isset( $clients[0] ) && ! empty( $clients[0]->calls ) ) {
5309
				flush();
5310
				$clients[0]->query();
5311
			}
5312
		}
5313
	}
5314
5315
	public static function staticize_subdomain( $url ) {
5316
5317
		// Extract hostname from URL
5318
		$host = parse_url( $url, PHP_URL_HOST );
5319
5320
		// Explode hostname on '.'
5321
		$exploded_host = explode( '.', $host );
5322
5323
		// Retrieve the name and TLD
5324
		if ( count( $exploded_host ) > 1 ) {
5325
			$name = $exploded_host[ count( $exploded_host ) - 2 ];
5326
			$tld = $exploded_host[ count( $exploded_host ) - 1 ];
5327
			// Rebuild domain excluding subdomains
5328
			$domain = $name . '.' . $tld;
5329
		} else {
5330
			$domain = $host;
5331
		}
5332
		// Array of Automattic domains
5333
		$domain_whitelist = array( 'wordpress.com', 'wp.com' );
5334
5335
		// Return $url if not an Automattic domain
5336
		if ( ! in_array( $domain, $domain_whitelist ) ) {
5337
			return $url;
5338
		}
5339
5340
		if ( is_ssl() ) {
5341
			return preg_replace( '|https?://[^/]++/|', 'https://s-ssl.wordpress.com/', $url );
5342
		}
5343
5344
		srand( crc32( basename( $url ) ) );
5345
		$static_counter = rand( 0, 2 );
5346
		srand(); // this resets everything that relies on this, like array_rand() and shuffle()
5347
5348
		return preg_replace( '|://[^/]+?/|', "://s$static_counter.wp.com/", $url );
5349
	}
5350
5351
/* JSON API Authorization */
5352
5353
	/**
5354
	 * Handles the login action for Authorizing the JSON API
5355
	 */
5356
	function login_form_json_api_authorization() {
5357
		$this->verify_json_api_authorization_request();
5358
5359
		add_action( 'wp_login', array( &$this, 'store_json_api_authorization_token' ), 10, 2 );
5360
5361
		add_action( 'login_message', array( &$this, 'login_message_json_api_authorization' ) );
5362
		add_action( 'login_form', array( &$this, 'preserve_action_in_login_form_for_json_api_authorization' ) );
5363
		add_filter( 'site_url', array( &$this, 'post_login_form_to_signed_url' ), 10, 3 );
5364
	}
5365
5366
	// Make sure the login form is POSTed to the signed URL so we can reverify the request
5367
	function post_login_form_to_signed_url( $url, $path, $scheme ) {
5368
		if ( 'wp-login.php' !== $path || ( 'login_post' !== $scheme && 'login' !== $scheme ) ) {
5369
			return $url;
5370
		}
5371
5372
		$parsed_url = parse_url( $url );
5373
		$url = strtok( $url, '?' );
5374
		$url = "$url?{$_SERVER['QUERY_STRING']}";
5375
		if ( ! empty( $parsed_url['query'] ) )
5376
			$url .= "&{$parsed_url['query']}";
5377
5378
		return $url;
5379
	}
5380
5381
	// Make sure the POSTed request is handled by the same action
5382
	function preserve_action_in_login_form_for_json_api_authorization() {
5383
		echo "<input type='hidden' name='action' value='jetpack_json_api_authorization' />\n";
5384
		echo "<input type='hidden' name='jetpack_json_api_original_query' value='" . esc_url( set_url_scheme( $_SERVER['HTTP_HOST'] . $_SERVER['REQUEST_URI'] ) ) . "' />\n";
5385
	}
5386
5387
	// If someone logs in to approve API access, store the Access Code in usermeta
5388
	function store_json_api_authorization_token( $user_login, $user ) {
5389
		add_filter( 'login_redirect', array( &$this, 'add_token_to_login_redirect_json_api_authorization' ), 10, 3 );
5390
		add_filter( 'allowed_redirect_hosts', array( &$this, 'allow_wpcom_public_api_domain' ) );
5391
		$token = wp_generate_password( 32, false );
5392
		update_user_meta( $user->ID, 'jetpack_json_api_' . $this->json_api_authorization_request['client_id'], $token );
5393
	}
5394
5395
	// Add public-api.wordpress.com to the safe redirect whitelist - only added when someone allows API access
5396
	function allow_wpcom_public_api_domain( $domains ) {
5397
		$domains[] = 'public-api.wordpress.com';
5398
		return $domains;
5399
	}
5400
5401
	// Add the Access Code details to the public-api.wordpress.com redirect
5402
	function add_token_to_login_redirect_json_api_authorization( $redirect_to, $original_redirect_to, $user ) {
5403
		return add_query_arg(
5404
			urlencode_deep(
5405
				array(
5406
					'jetpack-code'    => get_user_meta( $user->ID, 'jetpack_json_api_' . $this->json_api_authorization_request['client_id'], true ),
5407
					'jetpack-user-id' => (int) $user->ID,
5408
					'jetpack-state'   => $this->json_api_authorization_request['state'],
5409
				)
5410
			),
5411
			$redirect_to
5412
		);
5413
	}
5414
5415
5416
	/**
5417
	 * Verifies the request by checking the signature
5418
	 *
5419
	 * @since 4.6.0 Method was updated to use `$_REQUEST` instead of `$_GET` and `$_POST`. Method also updated to allow
5420
	 * passing in an `$environment` argument that overrides `$_REQUEST`. This was useful for integrating with SSO.
5421
	 *
5422
	 * @param null|array $environment
5423
	 */
5424
	function verify_json_api_authorization_request( $environment = null ) {
5425
		require_once JETPACK__PLUGIN_DIR . 'class.jetpack-signature.php';
5426
5427
		$environment = is_null( $environment )
5428
			? $_REQUEST
5429
			: $environment;
5430
5431
		list( $envToken, $envVersion, $envUserId ) = explode( ':', $environment['token'] );
5432
		$token = Jetpack_Data::get_access_token( $envUserId );
5433
		if ( ! $token || empty( $token->secret ) ) {
5434
			wp_die( __( 'You must connect your Jetpack plugin to WordPress.com to use this feature.' , 'jetpack' ) );
5435
		}
5436
5437
		$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' );
5438
5439
		$jetpack_signature = new Jetpack_Signature( $token->secret, (int) Jetpack_Options::get_option( 'time_diff' ) );
5440
5441
		if ( isset( $environment['jetpack_json_api_original_query'] ) ) {
5442
			$signature = $jetpack_signature->sign_request(
5443
				$environment['token'],
5444
				$environment['timestamp'],
5445
				$environment['nonce'],
5446
				'',
5447
				'GET',
5448
				$environment['jetpack_json_api_original_query'],
5449
				null,
5450
				true
5451
			);
5452
		} else {
5453
			$signature = $jetpack_signature->sign_current_request( array( 'body' => null, 'method' => 'GET' ) );
5454
		}
5455
5456
		if ( ! $signature ) {
5457
			wp_die( $die_error );
5458
		} else if ( is_wp_error( $signature ) ) {
5459
			wp_die( $die_error );
5460
		} else if ( ! hash_equals( $signature, $environment['signature'] ) ) {
5461
			if ( is_ssl() ) {
5462
				// 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
5463
				$signature = $jetpack_signature->sign_current_request( array( 'scheme' => 'http', 'body' => null, 'method' => 'GET' ) );
5464
				if ( ! $signature || is_wp_error( $signature ) || ! hash_equals( $signature, $environment['signature'] ) ) {
5465
					wp_die( $die_error );
5466
				}
5467
			} else {
5468
				wp_die( $die_error );
5469
			}
5470
		}
5471
5472
		$timestamp = (int) $environment['timestamp'];
5473
		$nonce     = stripslashes( (string) $environment['nonce'] );
5474
5475
		if ( ! $this->add_nonce( $timestamp, $nonce ) ) {
5476
			// De-nonce the nonce, at least for 5 minutes.
5477
			// 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)
5478
			$old_nonce_time = get_option( "jetpack_nonce_{$timestamp}_{$nonce}" );
5479
			if ( $old_nonce_time < time() - 300 ) {
5480
				wp_die( __( 'The authorization process expired.  Please go back and try again.' , 'jetpack' ) );
5481
			}
5482
		}
5483
5484
		$data = json_decode( base64_decode( stripslashes( $environment['data'] ) ) );
5485
		$data_filters = array(
5486
			'state'        => 'opaque',
5487
			'client_id'    => 'int',
5488
			'client_title' => 'string',
5489
			'client_image' => 'url',
5490
		);
5491
5492
		foreach ( $data_filters as $key => $sanitation ) {
5493
			if ( ! isset( $data->$key ) ) {
5494
				wp_die( $die_error );
5495
			}
5496
5497
			switch ( $sanitation ) {
5498
			case 'int' :
5499
				$this->json_api_authorization_request[$key] = (int) $data->$key;
5500
				break;
5501
			case 'opaque' :
5502
				$this->json_api_authorization_request[$key] = (string) $data->$key;
5503
				break;
5504
			case 'string' :
5505
				$this->json_api_authorization_request[$key] = wp_kses( (string) $data->$key, array() );
5506
				break;
5507
			case 'url' :
5508
				$this->json_api_authorization_request[$key] = esc_url_raw( (string) $data->$key );
5509
				break;
5510
			}
5511
		}
5512
5513
		if ( empty( $this->json_api_authorization_request['client_id'] ) ) {
5514
			wp_die( $die_error );
5515
		}
5516
	}
5517
5518
	function login_message_json_api_authorization( $message ) {
5519
		return '<p class="message">' . sprintf(
5520
			esc_html__( '%s wants to access your site&#8217;s data.  Log in to authorize that access.' , 'jetpack' ),
5521
			'<strong>' . esc_html( $this->json_api_authorization_request['client_title'] ) . '</strong>'
5522
		) . '<img src="' . esc_url( $this->json_api_authorization_request['client_image'] ) . '" /></p>';
5523
	}
5524
5525
	/**
5526
	 * Get $content_width, but with a <s>twist</s> filter.
5527
	 */
5528
	public static function get_content_width() {
5529
		$content_width = isset( $GLOBALS['content_width'] ) ? $GLOBALS['content_width'] : false;
5530
		/**
5531
		 * Filter the Content Width value.
5532
		 *
5533
		 * @since 2.2.3
5534
		 *
5535
		 * @param string $content_width Content Width value.
5536
		 */
5537
		return apply_filters( 'jetpack_content_width', $content_width );
5538
	}
5539
5540
	/**
5541
	 * Pings the WordPress.com Mirror Site for the specified options.
5542
	 *
5543
	 * @param string|array $option_names The option names to request from the WordPress.com Mirror Site
5544
	 *
5545
	 * @return array An associative array of the option values as stored in the WordPress.com Mirror Site
5546
	 */
5547
	public function get_cloud_site_options( $option_names ) {
5548
		$option_names = array_filter( (array) $option_names, 'is_string' );
5549
5550
		Jetpack::load_xml_rpc_client();
5551
		$xml = new Jetpack_IXR_Client( array( 'user_id' => JETPACK_MASTER_USER, ) );
5552
		$xml->query( 'jetpack.fetchSiteOptions', $option_names );
5553
		if ( $xml->isError() ) {
5554
			return array(
5555
				'error_code' => $xml->getErrorCode(),
5556
				'error_msg'  => $xml->getErrorMessage(),
5557
			);
5558
		}
5559
		$cloud_site_options = $xml->getResponse();
5560
5561
		return $cloud_site_options;
5562
	}
5563
5564
	/**
5565
	 * Checks if the site is currently in an identity crisis.
5566
	 *
5567
	 * @return array|bool Array of options that are in a crisis, or false if everything is OK.
5568
	 */
5569
	public static function check_identity_crisis() {
5570
		if ( ! Jetpack::is_active() || Jetpack::is_development_mode() || ! self::validate_sync_error_idc_option() ) {
5571
			return false;
5572
		}
5573
5574
		return Jetpack_Options::get_option( 'sync_error_idc' );
5575
	}
5576
5577
	/**
5578
	 * Checks whether the home and siteurl specifically are whitelisted
5579
	 * Written so that we don't have re-check $key and $value params every time
5580
	 * we want to check if this site is whitelisted, for example in footer.php
5581
	 *
5582
	 * @since  3.8.0
5583
	 * @return bool True = already whitelisted False = not whitelisted
5584
	 */
5585
	public static function is_staging_site() {
5586
		$is_staging = false;
5587
5588
		$known_staging = array(
5589
			'urls' => array(
5590
				'#\.staging\.wpengine\.com$#i', // WP Engine
5591
				'#\.staging\.kinsta\.com$#i',   // Kinsta.com
5592
				),
5593
			'constants' => array(
5594
				'IS_WPE_SNAPSHOT',      // WP Engine
5595
				'KINSTA_DEV_ENV',       // Kinsta.com
5596
				'WPSTAGECOACH_STAGING', // WP Stagecoach
5597
				'JETPACK_STAGING_MODE', // Generic
5598
				)
5599
			);
5600
		/**
5601
		 * Filters the flags of known staging sites.
5602
		 *
5603
		 * @since 3.9.0
5604
		 *
5605
		 * @param array $known_staging {
5606
		 *     An array of arrays that each are used to check if the current site is staging.
5607
		 *     @type array $urls      URLs of staging sites in regex to check against site_url.
5608
		 *     @type array $constants PHP constants of known staging/developement environments.
5609
		 *  }
5610
		 */
5611
		$known_staging = apply_filters( 'jetpack_known_staging', $known_staging );
5612
5613
		if ( isset( $known_staging['urls'] ) ) {
5614
			foreach ( $known_staging['urls'] as $url ){
5615
				if ( preg_match( $url, site_url() ) ) {
5616
					$is_staging = true;
5617
					break;
5618
				}
5619
			}
5620
		}
5621
5622
		if ( isset( $known_staging['constants'] ) ) {
5623
			foreach ( $known_staging['constants'] as $constant ) {
5624
				if ( defined( $constant ) && constant( $constant ) ) {
5625
					$is_staging = true;
5626
				}
5627
			}
5628
		}
5629
5630
		// Last, let's check if sync is erroring due to an IDC. If so, set the site to staging mode.
5631
		if ( ! $is_staging && self::validate_sync_error_idc_option() ) {
5632
			$is_staging = true;
5633
		}
5634
5635
		/**
5636
		 * Filters is_staging_site check.
5637
		 *
5638
		 * @since 3.9.0
5639
		 *
5640
		 * @param bool $is_staging If the current site is a staging site.
5641
		 */
5642
		return apply_filters( 'jetpack_is_staging_site', $is_staging );
5643
	}
5644
5645
	/**
5646
	 * Checks whether the sync_error_idc option is valid or not, and if not, will do cleanup.
5647
	 *
5648
	 * @return bool
5649
	 */
5650
	public static function validate_sync_error_idc_option() {
5651
		$is_valid = false;
5652
5653
		$idc_allowed = get_transient( 'jetpack_idc_allowed' );
5654
		if ( false === $idc_allowed ) {
5655
			$response = wp_remote_get( 'https://jetpack.com/is-idc-allowed/' );
5656
			if ( 200 === (int) wp_remote_retrieve_response_code( $response ) ) {
5657
				$json = json_decode( wp_remote_retrieve_body( $response ) );
5658
				$idc_allowed = isset( $json, $json->result ) && $json->result ? '1' : '0';
5659
				$transient_duration = HOUR_IN_SECONDS;
5660
			} else {
5661
				// If the request failed for some reason, then assume IDC is allowed and set shorter transient.
5662
				$idc_allowed = '1';
5663
				$transient_duration = 5 * MINUTE_IN_SECONDS;
5664
			}
5665
5666
			set_transient( 'jetpack_idc_allowed', $idc_allowed, $transient_duration );
5667
		}
5668
5669
		// Is the site opted in and does the stored sync_error_idc option match what we now generate?
5670
		$sync_error = Jetpack_Options::get_option( 'sync_error_idc' );
5671
		$local_options = self::get_sync_error_idc_option();
5672
		if ( $idc_allowed && $sync_error && self::sync_idc_optin() ) {
5673
			if ( $sync_error['home'] === $local_options['home'] && $sync_error['siteurl'] === $local_options['siteurl'] ) {
5674
				$is_valid = true;
5675
			}
5676
		}
5677
5678
		/**
5679
		 * Filters whether the sync_error_idc option is valid.
5680
		 *
5681
		 * @since 4.4.0
5682
		 *
5683
		 * @param bool $is_valid If the sync_error_idc is valid or not.
5684
		 */
5685
		$is_valid = (bool) apply_filters( 'jetpack_sync_error_idc_validation', $is_valid );
5686
5687
		if ( ! $idc_allowed || ( ! $is_valid && $sync_error ) ) {
5688
			// Since the option exists, and did not validate, delete it
5689
			Jetpack_Options::delete_option( 'sync_error_idc' );
5690
		}
5691
5692
		return $is_valid;
5693
	}
5694
5695
	/**
5696
	 * Normalizes a url by doing three things:
5697
	 *  - Strips protocol
5698
	 *  - Strips www
5699
	 *  - Adds a trailing slash
5700
	 *
5701
	 * @since 4.4.0
5702
	 * @param string $url
5703
	 * @return WP_Error|string
5704
	 */
5705
	public static function normalize_url_protocol_agnostic( $url ) {
5706
		$parsed_url = wp_parse_url( trailingslashit( esc_url_raw( $url ) ) );
5707
		if ( ! $parsed_url ) {
5708
			return new WP_Error( 'cannot_parse_url', sprintf( esc_html__( 'Cannot parse URL %s', 'jetpack' ), $url ) );
5709
		}
5710
5711
		// Strip www and protocols
5712
		$url = preg_replace( '/^www\./i', '', $parsed_url['host'] . $parsed_url['path'] );
5713
		return $url;
5714
	}
5715
5716
	/**
5717
	 * Gets the value that is to be saved in the jetpack_sync_error_idc option.
5718
	 *
5719
	 * @since 4.4.0
5720
	 *
5721
	 * @param array $response
5722
	 * @return array Array of the local urls, wpcom urls, and error code
5723
	 */
5724
	public static function get_sync_error_idc_option( $response = array() ) {
5725
		$local_options = array(
5726
			'home' => get_home_url(),
5727
			'siteurl' => get_site_url(),
5728
		);
5729
5730
		$options = array_merge( $local_options, $response );
5731
5732
		$returned_values = array();
5733
		foreach( $options as $key => $option ) {
5734
			if ( 'error_code' === $key ) {
5735
				$returned_values[ $key ] = $option;
5736
				continue;
5737
			}
5738
5739
			if ( is_wp_error( $normalized_url = self::normalize_url_protocol_agnostic( $option ) ) ) {
5740
				continue;
5741
			}
5742
5743
			$returned_values[ $key ] = $normalized_url;
5744
		}
5745
5746
		return $returned_values;
5747
	}
5748
5749
	/**
5750
	 * Returns the value of the jetpack_sync_idc_optin filter, or constant.
5751
	 * If set to true, the site will be put into staging mode.
5752
	 *
5753
	 * @since 4.3.2
5754
	 * @return bool
5755
	 */
5756
	public static function sync_idc_optin() {
5757
		if ( Jetpack_Constants::is_defined( 'JETPACK_SYNC_IDC_OPTIN' ) ) {
5758
			$default = Jetpack_Constants::get_constant( 'JETPACK_SYNC_IDC_OPTIN' );
5759
		} else {
5760
			$default = ! Jetpack_Constants::is_defined( 'SUNRISE' ) && ! is_multisite();
5761
		}
5762
5763
		/**
5764
		 * Allows sites to optin to IDC mitigation which blocks the site from syncing to WordPress.com when the home
5765
		 * URL or site URL do not match what WordPress.com expects. The default value is either false, or the value of
5766
		 * JETPACK_SYNC_IDC_OPTIN constant if set.
5767
		 *
5768
		 * @since 4.3.2
5769
		 *
5770
		 * @param bool $default Whether the site is opted in to IDC mitigation.
5771
		 */
5772
		return (bool) apply_filters( 'jetpack_sync_idc_optin', $default );
5773
	}
5774
5775
	/**
5776
	 * Maybe Use a .min.css stylesheet, maybe not.
5777
	 *
5778
	 * Hooks onto `plugins_url` filter at priority 1, and accepts all 3 args.
5779
	 */
5780
	public static function maybe_min_asset( $url, $path, $plugin ) {
5781
		// Short out on things trying to find actual paths.
5782
		if ( ! $path || empty( $plugin ) ) {
5783
			return $url;
5784
		}
5785
5786
		// Strip out the abspath.
5787
		$base = dirname( plugin_basename( $plugin ) );
5788
5789
		// Short out on non-Jetpack assets.
5790
		if ( 'jetpack/' !== substr( $base, 0, 8 ) ) {
5791
			return $url;
5792
		}
5793
5794
		// File name parsing.
5795
		$file              = "{$base}/{$path}";
5796
		$full_path         = JETPACK__PLUGIN_DIR . substr( $file, 8 );
5797
		$file_name         = substr( $full_path, strrpos( $full_path, '/' ) + 1 );
5798
		$file_name_parts_r = array_reverse( explode( '.', $file_name ) );
5799
		$extension         = array_shift( $file_name_parts_r );
5800
5801
		if ( in_array( strtolower( $extension ), array( 'css', 'js' ) ) ) {
5802
			// Already pointing at the minified version.
5803
			if ( 'min' === $file_name_parts_r[0] ) {
5804
				return $url;
5805
			}
5806
5807
			$min_full_path = preg_replace( "#\.{$extension}$#", ".min.{$extension}", $full_path );
5808
			if ( file_exists( $min_full_path ) ) {
5809
				$url = preg_replace( "#\.{$extension}$#", ".min.{$extension}", $url );
5810
			}
5811
		}
5812
5813
		return $url;
5814
	}
5815
5816
	/**
5817
	 * Maybe inlines a stylesheet.
5818
	 *
5819
	 * If you'd like to inline a stylesheet instead of printing a link to it,
5820
	 * wp_style_add_data( 'handle', 'jetpack-inline', true );
5821
	 *
5822
	 * Attached to `style_loader_tag` filter.
5823
	 *
5824
	 * @param string $tag The tag that would link to the external asset.
5825
	 * @param string $handle The registered handle of the script in question.
5826
	 *
5827
	 * @return string
5828
	 */
5829
	public static function maybe_inline_style( $tag, $handle ) {
5830
		global $wp_styles;
5831
		$item = $wp_styles->registered[ $handle ];
5832
5833
		if ( ! isset( $item->extra['jetpack-inline'] ) || ! $item->extra['jetpack-inline'] ) {
5834
			return $tag;
5835
		}
5836
5837
		if ( preg_match( '# href=\'([^\']+)\' #i', $tag, $matches ) ) {
5838
			$href = $matches[1];
5839
			// Strip off query string
5840
			if ( $pos = strpos( $href, '?' ) ) {
5841
				$href = substr( $href, 0, $pos );
5842
			}
5843
			// Strip off fragment
5844
			if ( $pos = strpos( $href, '#' ) ) {
5845
				$href = substr( $href, 0, $pos );
5846
			}
5847
		} else {
5848
			return $tag;
5849
		}
5850
5851
		$plugins_dir = plugin_dir_url( JETPACK__PLUGIN_FILE );
5852
		if ( $plugins_dir !== substr( $href, 0, strlen( $plugins_dir ) ) ) {
5853
			return $tag;
5854
		}
5855
5856
		// If this stylesheet has a RTL version, and the RTL version replaces normal...
5857
		if ( isset( $item->extra['rtl'] ) && 'replace' === $item->extra['rtl'] && is_rtl() ) {
5858
			// And this isn't the pass that actually deals with the RTL version...
5859
			if ( false === strpos( $tag, " id='$handle-rtl-css' " ) ) {
5860
				// Short out, as the RTL version will deal with it in a moment.
5861
				return $tag;
5862
			}
5863
		}
5864
5865
		$file = JETPACK__PLUGIN_DIR . substr( $href, strlen( $plugins_dir ) );
5866
		$css  = Jetpack::absolutize_css_urls( file_get_contents( $file ), $href );
5867
		if ( $css ) {
5868
			$tag = "<!-- Inline {$item->handle} -->\r\n";
5869
			if ( empty( $item->extra['after'] ) ) {
5870
				wp_add_inline_style( $handle, $css );
5871
			} else {
5872
				array_unshift( $item->extra['after'], $css );
5873
				wp_style_add_data( $handle, 'after', $item->extra['after'] );
5874
			}
5875
		}
5876
5877
		return $tag;
5878
	}
5879
5880
	/**
5881
	 * Loads a view file from the views
5882
	 *
5883
	 * Data passed in with the $data parameter will be available in the
5884
	 * template file as $data['value']
5885
	 *
5886
	 * @param string $template - Template file to load
5887
	 * @param array $data - Any data to pass along to the template
5888
	 * @return boolean - If template file was found
5889
	 **/
5890
	public function load_view( $template, $data = array() ) {
5891
		$views_dir = JETPACK__PLUGIN_DIR . 'views/';
5892
5893
		if( file_exists( $views_dir . $template ) ) {
5894
			require_once( $views_dir . $template );
5895
			return true;
5896
		}
5897
5898
		error_log( "Jetpack: Unable to find view file $views_dir$template" );
5899
		return false;
5900
	}
5901
5902
	/**
5903
	 * Throws warnings for deprecated hooks to be removed from Jetpack
5904
	 */
5905
	public function deprecated_hooks() {
5906
		global $wp_filter;
5907
5908
		/*
5909
		 * Format:
5910
		 * deprecated_filter_name => replacement_name
5911
		 *
5912
		 * If there is no replacement, use null for replacement_name
5913
		 */
5914
		$deprecated_list = array(
5915
			'jetpack_bail_on_shortcode'                              => 'jetpack_shortcodes_to_include',
5916
			'wpl_sharing_2014_1'                                     => null,
5917
			'jetpack-tools-to-include'                               => 'jetpack_tools_to_include',
5918
			'jetpack_identity_crisis_options_to_check'               => null,
5919
			'update_option_jetpack_single_user_site'                 => null,
5920
			'audio_player_default_colors'                            => null,
5921
			'add_option_jetpack_featured_images_enabled'             => null,
5922
			'add_option_jetpack_update_details'                      => null,
5923
			'add_option_jetpack_updates'                             => null,
5924
			'add_option_jetpack_network_name'                        => null,
5925
			'add_option_jetpack_network_allow_new_registrations'     => null,
5926
			'add_option_jetpack_network_add_new_users'               => null,
5927
			'add_option_jetpack_network_site_upload_space'           => null,
5928
			'add_option_jetpack_network_upload_file_types'           => null,
5929
			'add_option_jetpack_network_enable_administration_menus' => null,
5930
			'add_option_jetpack_is_multi_site'                       => null,
5931
			'add_option_jetpack_is_main_network'                     => null,
5932
			'add_option_jetpack_main_network_site'                   => null,
5933
			'jetpack_sync_all_registered_options'                    => null,
5934
			'jetpack_has_identity_crisis'                            => 'jetpack_sync_error_idc_validation',
5935
			'jetpack_is_post_mailable'                               => null,
5936
		);
5937
5938
		// This is a silly loop depth. Better way?
5939
		foreach( $deprecated_list AS $hook => $hook_alt ) {
5940
			if ( has_action( $hook ) ) {
5941
				foreach( $wp_filter[ $hook ] AS $func => $values ) {
5942
					foreach( $values AS $hooked ) {
5943
						if ( is_callable( $hooked['function'] ) ) {
5944
							$function_name = 'an anonymous function';
5945
						} else {
5946
							$function_name = $hooked['function'];
5947
						}
5948
						_deprecated_function( $hook . ' used for ' . $function_name, null, $hook_alt );
5949
					}
5950
				}
5951
			}
5952
		}
5953
	}
5954
5955
	/**
5956
	 * Converts any url in a stylesheet, to the correct absolute url.
5957
	 *
5958
	 * Considerations:
5959
	 *  - Normal, relative URLs     `feh.png`
5960
	 *  - Data URLs                 `data:image/gif;base64,eh129ehiuehjdhsa==`
5961
	 *  - Schema-agnostic URLs      `//domain.com/feh.png`
5962
	 *  - Absolute URLs             `http://domain.com/feh.png`
5963
	 *  - Domain root relative URLs `/feh.png`
5964
	 *
5965
	 * @param $css string: The raw CSS -- should be read in directly from the file.
5966
	 * @param $css_file_url : The URL that the file can be accessed at, for calculating paths from.
5967
	 *
5968
	 * @return mixed|string
5969
	 */
5970
	public static function absolutize_css_urls( $css, $css_file_url ) {
5971
		$pattern = '#url\((?P<path>[^)]*)\)#i';
5972
		$css_dir = dirname( $css_file_url );
5973
		$p       = parse_url( $css_dir );
5974
		$domain  = sprintf(
5975
					'%1$s//%2$s%3$s%4$s',
5976
					isset( $p['scheme'] )           ? "{$p['scheme']}:" : '',
5977
					isset( $p['user'], $p['pass'] ) ? "{$p['user']}:{$p['pass']}@" : '',
5978
					$p['host'],
5979
					isset( $p['port'] )             ? ":{$p['port']}" : ''
5980
				);
5981
5982
		if ( preg_match_all( $pattern, $css, $matches, PREG_SET_ORDER ) ) {
5983
			$find = $replace = array();
5984
			foreach ( $matches as $match ) {
5985
				$url = trim( $match['path'], "'\" \t" );
5986
5987
				// If this is a data url, we don't want to mess with it.
5988
				if ( 'data:' === substr( $url, 0, 5 ) ) {
5989
					continue;
5990
				}
5991
5992
				// If this is an absolute or protocol-agnostic url,
5993
				// we don't want to mess with it.
5994
				if ( preg_match( '#^(https?:)?//#i', $url ) ) {
5995
					continue;
5996
				}
5997
5998
				switch ( substr( $url, 0, 1 ) ) {
5999
					case '/':
6000
						$absolute = $domain . $url;
6001
						break;
6002
					default:
6003
						$absolute = $css_dir . '/' . $url;
6004
				}
6005
6006
				$find[]    = $match[0];
6007
				$replace[] = sprintf( 'url("%s")', $absolute );
6008
			}
6009
			$css = str_replace( $find, $replace, $css );
6010
		}
6011
6012
		return $css;
6013
	}
6014
6015
	/**
6016
	 * This methods removes all of the registered css files on the front end
6017
	 * from Jetpack in favor of using a single file. In effect "imploding"
6018
	 * all the files into one file.
6019
	 *
6020
	 * Pros:
6021
	 * - Uses only ONE css asset connection instead of 15
6022
	 * - Saves a minimum of 56k
6023
	 * - Reduces server load
6024
	 * - Reduces time to first painted byte
6025
	 *
6026
	 * Cons:
6027
	 * - Loads css for ALL modules. However all selectors are prefixed so it
6028
	 *		should not cause any issues with themes.
6029
	 * - Plugins/themes dequeuing styles no longer do anything. See
6030
	 *		jetpack_implode_frontend_css filter for a workaround
6031
	 *
6032
	 * For some situations developers may wish to disable css imploding and
6033
	 * instead operate in legacy mode where each file loads seperately and
6034
	 * can be edited individually or dequeued. This can be accomplished with
6035
	 * the following line:
6036
	 *
6037
	 * add_filter( 'jetpack_implode_frontend_css', '__return_false' );
6038
	 *
6039
	 * @since 3.2
6040
	 **/
6041
	public function implode_frontend_css( $travis_test = false ) {
6042
		$do_implode = true;
6043
		if ( defined( 'SCRIPT_DEBUG' ) && SCRIPT_DEBUG ) {
6044
			$do_implode = false;
6045
		}
6046
6047
		/**
6048
		 * Allow CSS to be concatenated into a single jetpack.css file.
6049
		 *
6050
		 * @since 3.2.0
6051
		 *
6052
		 * @param bool $do_implode Should CSS be concatenated? Default to true.
6053
		 */
6054
		$do_implode = apply_filters( 'jetpack_implode_frontend_css', $do_implode );
6055
6056
		// Do not use the imploded file when default behaviour was altered through the filter
6057
		if ( ! $do_implode ) {
6058
			return;
6059
		}
6060
6061
		// We do not want to use the imploded file in dev mode, or if not connected
6062
		if ( Jetpack::is_development_mode() || ! self::is_active() ) {
6063
			if ( ! $travis_test ) {
6064
				return;
6065
			}
6066
		}
6067
6068
		// Do not use the imploded file if sharing css was dequeued via the sharing settings screen
6069
		if ( get_option( 'sharedaddy_disable_resources' ) ) {
6070
			return;
6071
		}
6072
6073
		/*
6074
		 * Now we assume Jetpack is connected and able to serve the single
6075
		 * file.
6076
		 *
6077
		 * In the future there will be a check here to serve the file locally
6078
		 * or potentially from the Jetpack CDN
6079
		 *
6080
		 * For now:
6081
		 * - Enqueue a single imploded css file
6082
		 * - Zero out the style_loader_tag for the bundled ones
6083
		 * - Be happy, drink scotch
6084
		 */
6085
6086
		add_filter( 'style_loader_tag', array( $this, 'concat_remove_style_loader_tag' ), 10, 2 );
6087
6088
		$version = Jetpack::is_development_version() ? filemtime( JETPACK__PLUGIN_DIR . 'css/jetpack.css' ) : JETPACK__VERSION;
6089
6090
		wp_enqueue_style( 'jetpack_css', plugins_url( 'css/jetpack.css', __FILE__ ), array(), $version );
6091
		wp_style_add_data( 'jetpack_css', 'rtl', 'replace' );
6092
	}
6093
6094
	function concat_remove_style_loader_tag( $tag, $handle ) {
6095
		if ( in_array( $handle, $this->concatenated_style_handles ) ) {
6096
			$tag = '';
6097
			if ( defined( 'WP_DEBUG' ) && WP_DEBUG ) {
6098
				$tag = "<!-- `" . esc_html( $handle ) . "` is included in the concatenated jetpack.css -->\r\n";
6099
			}
6100
		}
6101
6102
		return $tag;
6103
	}
6104
6105
	/*
6106
	 * Check the heartbeat data
6107
	 *
6108
	 * Organizes the heartbeat data by severity.  For example, if the site
6109
	 * is in an ID crisis, it will be in the $filtered_data['bad'] array.
6110
	 *
6111
	 * Data will be added to "caution" array, if it either:
6112
	 *  - Out of date Jetpack version
6113
	 *  - Out of date WP version
6114
	 *  - Out of date PHP version
6115
	 *
6116
	 * $return array $filtered_data
6117
	 */
6118
	public static function jetpack_check_heartbeat_data() {
6119
		$raw_data = Jetpack_Heartbeat::generate_stats_array();
6120
6121
		$good    = array();
6122
		$caution = array();
6123
		$bad     = array();
6124
6125
		foreach ( $raw_data as $stat => $value ) {
6126
6127
			// Check jetpack version
6128
			if ( 'version' == $stat ) {
6129
				if ( version_compare( $value, JETPACK__VERSION, '<' ) ) {
6130
					$caution[ $stat ] = $value . " - min supported is " . JETPACK__VERSION;
6131
					continue;
6132
				}
6133
			}
6134
6135
			// Check WP version
6136
			if ( 'wp-version' == $stat ) {
6137
				if ( version_compare( $value, JETPACK__MINIMUM_WP_VERSION, '<' ) ) {
6138
					$caution[ $stat ] = $value . " - min supported is " . JETPACK__MINIMUM_WP_VERSION;
6139
					continue;
6140
				}
6141
			}
6142
6143
			// Check PHP version
6144
			if ( 'php-version' == $stat ) {
6145
				if ( version_compare( PHP_VERSION, '5.2.4', '<' ) ) {
6146
					$caution[ $stat ] = $value . " - min supported is 5.2.4";
6147
					continue;
6148
				}
6149
			}
6150
6151
			// Check ID crisis
6152
			if ( 'identitycrisis' == $stat ) {
6153
				if ( 'yes' == $value ) {
6154
					$bad[ $stat ] = $value;
6155
					continue;
6156
				}
6157
			}
6158
6159
			// The rest are good :)
6160
			$good[ $stat ] = $value;
6161
		}
6162
6163
		$filtered_data = array(
6164
			'good'    => $good,
6165
			'caution' => $caution,
6166
			'bad'     => $bad
6167
		);
6168
6169
		return $filtered_data;
6170
	}
6171
6172
6173
	/*
6174
	 * This method is used to organize all options that can be reset
6175
	 * without disconnecting Jetpack.
6176
	 *
6177
	 * It is used in class.jetpack-cli.php to reset options
6178
	 *
6179
	 * @return array of options to delete.
6180
	 */
6181
	public static function get_jetpack_options_for_reset() {
6182
		$jetpack_options            = Jetpack_Options::get_option_names();
6183
		$jetpack_options_non_compat = Jetpack_Options::get_option_names( 'non_compact' );
6184
		$jetpack_options_private    = Jetpack_Options::get_option_names( 'private' );
6185
6186
		$all_jp_options = array_merge( $jetpack_options, $jetpack_options_non_compat, $jetpack_options_private );
6187
6188
		// A manual build of the wp options
6189
		$wp_options = array(
6190
			'sharing-options',
6191
			'disabled_likes',
6192
			'disabled_reblogs',
6193
			'jetpack_comments_likes_enabled',
6194
			'wp_mobile_excerpt',
6195
			'wp_mobile_featured_images',
6196
			'wp_mobile_app_promos',
6197
			'stats_options',
6198
			'stats_dashboard_widget',
6199
			'safecss_preview_rev',
6200
			'safecss_rev',
6201
			'safecss_revision_migrated',
6202
			'nova_menu_order',
6203
			'jetpack_portfolio',
6204
			'jetpack_portfolio_posts_per_page',
6205
			'jetpack_testimonial',
6206
			'jetpack_testimonial_posts_per_page',
6207
			'wp_mobile_custom_css',
6208
			'sharedaddy_disable_resources',
6209
			'sharing-options',
6210
			'sharing-services',
6211
			'site_icon_temp_data',
6212
			'featured-content',
6213
			'site_logo',
6214
			'jetpack_dismissed_notices',
6215
		);
6216
6217
		// Flag some Jetpack options as unsafe
6218
		$unsafe_options = array(
6219
			'id',                           // (int)    The Client ID/WP.com Blog ID of this site.
6220
			'master_user',                  // (int)    The local User ID of the user who connected this site to jetpack.wordpress.com.
6221
			'version',                      // (string) Used during upgrade procedure to auto-activate new modules. version:time
6222
			'jumpstart',                    // (string) A flag for whether or not to show the Jump Start.  Accepts: new_connection, jumpstart_activated, jetpack_action_taken, jumpstart_dismissed.
6223
6224
			// non_compact
6225
			'activated',
6226
6227
			// private
6228
			'register',
6229
			'blog_token',                  // (string) The Client Secret/Blog Token of this site.
6230
			'user_token',                  // (string) The User Token of this site. (deprecated)
6231
			'user_tokens'
6232
		);
6233
6234
		// Remove the unsafe Jetpack options
6235
		foreach ( $unsafe_options as $unsafe_option ) {
6236
			if ( false !== ( $key = array_search( $unsafe_option, $all_jp_options ) ) ) {
6237
				unset( $all_jp_options[ $key ] );
6238
			}
6239
		}
6240
6241
		$options = array(
6242
			'jp_options' => $all_jp_options,
6243
			'wp_options' => $wp_options
6244
		);
6245
6246
		return $options;
6247
	}
6248
6249
	/**
6250
	 * Check if an option of a Jetpack module has been updated.
6251
	 *
6252
	 * If any module option has been updated before Jump Start has been dismissed,
6253
	 * update the 'jumpstart' option so we can hide Jump Start.
6254
	 *
6255
	 * @param string $option_name
6256
	 *
6257
	 * @return bool
6258
	 */
6259
	public static function jumpstart_has_updated_module_option( $option_name = '' ) {
6260
		// Bail if Jump Start has already been dismissed
6261
		if ( 'new_connection' !== Jetpack_Options::get_option( 'jumpstart' ) ) {
6262
			return false;
6263
		}
6264
6265
		$jetpack = Jetpack::init();
6266
6267
		// Manual build of module options
6268
		$option_names = self::get_jetpack_options_for_reset();
6269
6270
		if ( in_array( $option_name, $option_names['wp_options'] ) ) {
6271
			Jetpack_Options::update_option( 'jumpstart', 'jetpack_action_taken' );
6272
6273
			//Jump start is being dismissed send data to MC Stats
6274
			$jetpack->stat( 'jumpstart', 'manual,'.$option_name );
6275
6276
			$jetpack->do_stats( 'server_side' );
6277
		}
6278
6279
	}
6280
6281
	/*
6282
	 * Strip http:// or https:// from a url, replaces forward slash with ::,
6283
	 * so we can bring them directly to their site in calypso.
6284
	 *
6285
	 * @param string | url
6286
	 * @return string | url without the guff
6287
	 */
6288
	public static function build_raw_urls( $url ) {
6289
		$strip_http = '/.*?:\/\//i';
6290
		$url = preg_replace( $strip_http, '', $url  );
6291
		$url = str_replace( '/', '::', $url );
6292
		return $url;
6293
	}
6294
6295
	/**
6296
	 * Stores and prints out domains to prefetch for page speed optimization.
6297
	 *
6298
	 * @param mixed $new_urls
6299
	 */
6300
	public static function dns_prefetch( $new_urls = null ) {
6301
		static $prefetch_urls = array();
6302
		if ( empty( $new_urls ) && ! empty( $prefetch_urls ) ) {
6303
			echo "\r\n";
6304
			foreach ( $prefetch_urls as $this_prefetch_url ) {
6305
				printf( "<link rel='dns-prefetch' href='%s'>\r\n", esc_attr( $this_prefetch_url ) );
6306
			}
6307
		} elseif ( ! empty( $new_urls ) ) {
6308
			if ( ! has_action( 'wp_head', array( __CLASS__, __FUNCTION__ ) ) ) {
6309
				add_action( 'wp_head', array( __CLASS__, __FUNCTION__ ) );
6310
			}
6311
			foreach ( (array) $new_urls as $this_new_url ) {
6312
				$prefetch_urls[] = strtolower( untrailingslashit( preg_replace( '#^https?://#i', '//', $this_new_url ) ) );
6313
			}
6314
			$prefetch_urls = array_unique( $prefetch_urls );
6315
		}
6316
	}
6317
6318
	public function wp_dashboard_setup() {
6319
		if ( self::is_active() ) {
6320
			add_action( 'jetpack_dashboard_widget', array( __CLASS__, 'dashboard_widget_footer' ), 999 );
6321
			$widget_title = __( 'Site Stats', 'jetpack' );
6322
		} elseif ( ! self::is_development_mode() && current_user_can( 'jetpack_connect' ) ) {
6323
			add_action( 'jetpack_dashboard_widget', array( $this, 'dashboard_widget_connect_to_wpcom' ) );
6324
			$widget_title = __( 'Please Connect Jetpack', 'jetpack' );
6325
		}
6326
6327
		if ( has_action( 'jetpack_dashboard_widget' ) ) {
6328
			wp_add_dashboard_widget(
6329
				'jetpack_summary_widget',
6330
				$widget_title,
6331
				array( __CLASS__, 'dashboard_widget' )
6332
			);
6333
			wp_enqueue_style( 'jetpack-dashboard-widget', plugins_url( 'css/dashboard-widget.css', JETPACK__PLUGIN_FILE ), array(), JETPACK__VERSION );
6334
6335
			// If we're inactive and not in development mode, sort our box to the top.
6336
			if ( ! self::is_active() && ! self::is_development_mode() ) {
6337
				global $wp_meta_boxes;
6338
6339
				$dashboard = $wp_meta_boxes['dashboard']['normal']['core'];
6340
				$ours      = array( 'jetpack_summary_widget' => $dashboard['jetpack_summary_widget'] );
6341
6342
				$wp_meta_boxes['dashboard']['normal']['core'] = array_merge( $ours, $dashboard );
6343
			}
6344
		}
6345
	}
6346
6347
	/**
6348
	 * @param mixed $result Value for the user's option
6349
	 * @return mixed
6350
	 */
6351
	function get_user_option_meta_box_order_dashboard( $sorted ) {
6352
		if ( ! is_array( $sorted ) ) {
6353
			return $sorted;
6354
		}
6355
6356
		foreach ( $sorted as $box_context => $ids ) {
6357
			if ( false === strpos( $ids, 'dashboard_stats' ) ) {
6358
				// If the old id isn't anywhere in the ids, don't bother exploding and fail out.
6359
				continue;
6360
			}
6361
6362
			$ids_array = explode( ',', $ids );
6363
			$key = array_search( 'dashboard_stats', $ids_array );
6364
6365
			if ( false !== $key ) {
6366
				// If we've found that exact value in the option (and not `google_dashboard_stats` for example)
6367
				$ids_array[ $key ] = 'jetpack_summary_widget';
6368
				$sorted[ $box_context ] = implode( ',', $ids_array );
6369
				// We've found it, stop searching, and just return.
6370
				break;
6371
			}
6372
		}
6373
6374
		return $sorted;
6375
	}
6376
6377
	public static function dashboard_widget() {
6378
		/**
6379
		 * Fires when the dashboard is loaded.
6380
		 *
6381
		 * @since 3.4.0
6382
		 */
6383
		do_action( 'jetpack_dashboard_widget' );
6384
	}
6385
6386
	public static function dashboard_widget_footer() {
6387
		?>
6388
		<footer>
6389
6390
		<div class="protect">
6391
			<?php if ( Jetpack::is_module_active( 'protect' ) ) : ?>
6392
				<h3><?php echo number_format_i18n( get_site_option( 'jetpack_protect_blocked_attempts', 0 ) ); ?></h3>
6393
				<p><?php echo esc_html_x( 'Blocked malicious login attempts', '{#} Blocked malicious login attempts -- number is on a prior line, text is a caption.', 'jetpack' ); ?></p>
6394
			<?php elseif ( current_user_can( 'jetpack_activate_modules' ) && ! self::is_development_mode() ) : ?>
6395
				<a href="<?php echo esc_url( wp_nonce_url( Jetpack::admin_url( array( 'action' => 'activate', 'module' => 'protect' ) ), 'jetpack_activate-protect' ) ); ?>" class="button button-jetpack" title="<?php esc_attr_e( 'Protect helps to keep you secure from brute-force login attacks.', 'jetpack' ); ?>">
6396
					<?php esc_html_e( 'Activate Protect', 'jetpack' ); ?>
6397
				</a>
6398
			<?php else : ?>
6399
				<?php esc_html_e( 'Protect is inactive.', 'jetpack' ); ?>
6400
			<?php endif; ?>
6401
		</div>
6402
6403
		<div class="akismet">
6404
			<?php if ( is_plugin_active( 'akismet/akismet.php' ) ) : ?>
6405
				<h3><?php echo number_format_i18n( get_option( 'akismet_spam_count', 0 ) ); ?></h3>
6406
				<p><?php echo esc_html_x( 'Spam comments blocked by Akismet.', '{#} Spam comments blocked by Akismet -- number is on a prior line, text is a caption.', 'jetpack' ); ?></p>
6407
			<?php elseif ( current_user_can( 'activate_plugins' ) && ! is_wp_error( validate_plugin( 'akismet/akismet.php' ) ) ) : ?>
6408
				<a href="<?php echo esc_url( wp_nonce_url( add_query_arg( array( 'action' => 'activate', 'plugin' => 'akismet/akismet.php' ), admin_url( 'plugins.php' ) ), 'activate-plugin_akismet/akismet.php' ) ); ?>" class="button button-jetpack">
6409
					<?php esc_html_e( 'Activate Akismet', 'jetpack' ); ?>
6410
				</a>
6411
			<?php else : ?>
6412
				<p><a href="<?php echo esc_url( 'https://akismet.com/?utm_source=jetpack&utm_medium=link&utm_campaign=Jetpack%20Dashboard%20Widget%20Footer%20Link' ); ?>"><?php esc_html_e( 'Akismet can help to keep your blog safe from spam!', 'jetpack' ); ?></a></p>
6413
			<?php endif; ?>
6414
		</div>
6415
6416
		</footer>
6417
		<?php
6418
	}
6419
6420
	public function dashboard_widget_connect_to_wpcom() {
6421
		if ( Jetpack::is_active() || Jetpack::is_development_mode() || ! current_user_can( 'jetpack_connect' ) ) {
6422
			return;
6423
		}
6424
		?>
6425
		<div class="wpcom-connect">
6426
			<div class="jp-emblem">
6427
			<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" version="1.1" id="Layer_1" x="0" y="0" viewBox="0 0 172.9 172.9" enable-background="new 0 0 172.9 172.9" xml:space="preserve">
6428
				<path d="M86.4 0C38.7 0 0 38.7 0 86.4c0 47.7 38.7 86.4 86.4 86.4s86.4-38.7 86.4-86.4C172.9 38.7 134.2 0 86.4 0zM83.1 106.6l-27.1-6.9C49 98 45.7 90.1 49.3 84l33.8-58.5V106.6zM124.9 88.9l-33.8 58.5V66.3l27.1 6.9C125.1 74.9 128.4 82.8 124.9 88.9z"/>
6429
			</svg>
6430
			</div>
6431
			<h3><?php esc_html_e( 'Please Connect Jetpack', 'jetpack' ); ?></h3>
6432
			<p><?php echo wp_kses( __( 'Connecting Jetpack will show you <strong>stats</strong> about your traffic, <strong>protect</strong> you from brute force attacks, <strong>speed up</strong> your images and photos, and enable other <strong>traffic and security</strong> features.', 'jetpack' ), 'jetpack' ) ?></p>
6433
6434
			<div class="actions">
6435
				<a href="<?php echo $this->build_connect_url( false, false, 'widget-btn' ); ?>" class="button button-primary">
6436
					<?php esc_html_e( 'Connect Jetpack', 'jetpack' ); ?>
6437
				</a>
6438
			</div>
6439
		</div>
6440
		<?php
6441
	}
6442
6443
	/**
6444
	 * Return string containing the Jetpack logo.
6445
	 *
6446
	 * @since 3.9.0
6447
	 *
6448
	 * @return string
6449
	 */
6450
	public static function get_jp_emblem() {
6451
		return '<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" version="1.1" id="Layer_1" x="0" y="0" viewBox="0 0 172.9 172.9" enable-background="new 0 0 172.9 172.9" xml:space="preserve">	<path d="M86.4 0C38.7 0 0 38.7 0 86.4c0 47.7 38.7 86.4 86.4 86.4s86.4-38.7 86.4-86.4C172.9 38.7 134.2 0 86.4 0zM83.1 106.6l-27.1-6.9C49 98 45.7 90.1 49.3 84l33.8-58.5V106.6zM124.9 88.9l-33.8 58.5V66.3l27.1 6.9C125.1 74.9 128.4 82.8 124.9 88.9z" /></svg>';
6452
	}
6453
6454
	/*
6455
	 * Adds a "blank" column in the user admin table to display indication of user connection.
6456
	 */
6457
	function jetpack_icon_user_connected( $columns ) {
6458
		$columns['user_jetpack'] = '';
6459
		return $columns;
6460
	}
6461
6462
	/*
6463
	 * Show Jetpack icon if the user is linked.
6464
	 */
6465
	function jetpack_show_user_connected_icon( $val, $col, $user_id ) {
6466
		if ( 'user_jetpack' == $col && Jetpack::is_user_connected( $user_id ) ) {
6467
			$emblem_html = sprintf(
6468
				'<a title="%1$s" class="jp-emblem-user-admin">%2$s</a>',
6469
				esc_attr__( 'This user is linked and ready to fly with Jetpack.', 'jetpack' ),
6470
				Jetpack::get_jp_emblem()
6471
			);
6472
			return $emblem_html;
6473
		}
6474
6475
		return $val;
6476
	}
6477
6478
	/*
6479
	 * Style the Jetpack user column
6480
	 */
6481
	function jetpack_user_col_style() {
6482
		global $current_screen;
6483
		if ( ! empty( $current_screen->base ) && 'users' == $current_screen->base ) { ?>
6484
			<style>
6485
				.fixed .column-user_jetpack {
6486
					width: 21px;
6487
				}
6488
				.jp-emblem-user-admin svg {
6489
					width: 20px;
6490
					height: 20px;
6491
				}
6492
				.jp-emblem-user-admin path {
6493
					fill: #8cc258;
6494
				}
6495
			</style>
6496
		<?php }
6497
	}
6498
}
6499