Completed
Push — add/jetpack-icon-gutenberg ( b0ee9a...546ac6 )
by
unknown
21:27 queued 10:33
created

class.jetpack.php (2 issues)

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
		'jetpack-search-widget'
62
	);
63
64
	/**
65
	 * Contains all assets that have had their URL rewritten to minified versions.
66
	 *
67
	 * @var array
68
	 */
69
	static $min_assets = array();
70
71
	public $plugins_to_deactivate = array(
72
		'stats'               => array( 'stats/stats.php', 'WordPress.com Stats' ),
73
		'shortlinks'          => array( 'stats/stats.php', 'WordPress.com Stats' ),
74
		'sharedaddy'          => array( 'sharedaddy/sharedaddy.php', 'Sharedaddy' ),
75
		'twitter-widget'      => array( 'wickett-twitter-widget/wickett-twitter-widget.php', 'Wickett Twitter Widget' ),
76
		'after-the-deadline'  => array( 'after-the-deadline/after-the-deadline.php', 'After The Deadline' ),
77
		'contact-form'        => array( 'grunion-contact-form/grunion-contact-form.php', 'Grunion Contact Form' ),
78
		'contact-form'        => array( 'mullet/mullet-contact-form.php', 'Mullet Contact Form' ),
79
		'custom-css'          => array( 'safecss/safecss.php', 'WordPress.com Custom CSS' ),
80
		'random-redirect'     => array( 'random-redirect/random-redirect.php', 'Random Redirect' ),
81
		'videopress'          => array( 'video/video.php', 'VideoPress' ),
82
		'widget-visibility'   => array( 'jetpack-widget-visibility/widget-visibility.php', 'Jetpack Widget Visibility' ),
83
		'widget-visibility'   => array( 'widget-visibility-without-jetpack/widget-visibility-without-jetpack.php', 'Widget Visibility Without Jetpack' ),
84
		'sharedaddy'          => array( 'jetpack-sharing/sharedaddy.php', 'Jetpack Sharing' ),
85
		'gravatar-hovercards' => array( 'jetpack-gravatar-hovercards/gravatar-hovercards.php', 'Jetpack Gravatar Hovercards' ),
86
		'latex'               => array( 'wp-latex/wp-latex.php', 'WP LaTeX' )
87
	);
88
89
	static $capability_translations = array(
90
		'administrator' => 'manage_options',
91
		'editor'        => 'edit_others_posts',
92
		'author'        => 'publish_posts',
93
		'contributor'   => 'edit_posts',
94
		'subscriber'    => 'read',
95
	);
96
97
	/**
98
	 * Map of modules that have conflicts with plugins and should not be auto-activated
99
	 * if the plugins are active.  Used by filter_default_modules
100
	 *
101
	 * Plugin Authors: If you'd like to prevent a single module from auto-activating,
102
	 * change `module-slug` and add this to your plugin:
103
	 *
104
	 * add_filter( 'jetpack_get_default_modules', 'my_jetpack_get_default_modules' );
105
	 * function my_jetpack_get_default_modules( $modules ) {
106
	 *     return array_diff( $modules, array( 'module-slug' ) );
107
	 * }
108
	 *
109
	 * @var array
110
	 */
111
	private $conflicting_plugins = array(
112
		'comments'          => array(
113
			'Intense Debate'                       => 'intensedebate/intensedebate.php',
114
			'Disqus'                               => 'disqus-comment-system/disqus.php',
115
			'Livefyre'                             => 'livefyre-comments/livefyre.php',
116
			'Comments Evolved for WordPress'       => 'gplus-comments/comments-evolved.php',
117
			'Google+ Comments'                     => 'google-plus-comments/google-plus-comments.php',
118
			'WP-SpamShield Anti-Spam'              => 'wp-spamshield/wp-spamshield.php',
119
		),
120
		'comment-likes' => array(
121
			'Epoch'                                => 'epoch/plugincore.php',
122
		),
123
		'contact-form'      => array(
124
			'Contact Form 7'                       => 'contact-form-7/wp-contact-form-7.php',
125
			'Gravity Forms'                        => 'gravityforms/gravityforms.php',
126
			'Contact Form Plugin'                  => 'contact-form-plugin/contact_form.php',
127
			'Easy Contact Forms'                   => 'easy-contact-forms/easy-contact-forms.php',
128
			'Fast Secure Contact Form'             => 'si-contact-form/si-contact-form.php',
129
			'Ninja Forms'                          => 'ninja-forms/ninja-forms.php',
130
		),
131
		'minileven'         => array(
132
			'WPtouch'                              => 'wptouch/wptouch.php',
133
		),
134
		'latex'             => array(
135
			'LaTeX for WordPress'                  => 'latex/latex.php',
136
			'Youngwhans Simple Latex'              => 'youngwhans-simple-latex/yw-latex.php',
137
			'Easy WP LaTeX'                        => 'easy-wp-latex-lite/easy-wp-latex-lite.php',
138
			'MathJax-LaTeX'                        => 'mathjax-latex/mathjax-latex.php',
139
			'Enable Latex'                         => 'enable-latex/enable-latex.php',
140
			'WP QuickLaTeX'                        => 'wp-quicklatex/wp-quicklatex.php',
141
		),
142
		'protect'           => array(
143
			'Limit Login Attempts'                 => 'limit-login-attempts/limit-login-attempts.php',
144
			'Captcha'                              => 'captcha/captcha.php',
145
			'Brute Force Login Protection'         => 'brute-force-login-protection/brute-force-login-protection.php',
146
			'Login Security Solution'              => 'login-security-solution/login-security-solution.php',
147
			'WPSecureOps Brute Force Protect'      => 'wpsecureops-bruteforce-protect/wpsecureops-bruteforce-protect.php',
148
			'BulletProof Security'                 => 'bulletproof-security/bulletproof-security.php',
149
			'SiteGuard WP Plugin'                  => 'siteguard/siteguard.php',
150
			'Security-protection'                  => 'security-protection/security-protection.php',
151
			'Login Security'                       => 'login-security/login-security.php',
152
			'Botnet Attack Blocker'                => 'botnet-attack-blocker/botnet-attack-blocker.php',
153
			'Wordfence Security'                   => 'wordfence/wordfence.php',
154
			'All In One WP Security & Firewall'    => 'all-in-one-wp-security-and-firewall/wp-security.php',
155
			'iThemes Security'                     => 'better-wp-security/better-wp-security.php',
156
		),
157
		'random-redirect'   => array(
158
			'Random Redirect 2'                    => 'random-redirect-2/random-redirect.php',
159
		),
160
		'related-posts'     => array(
161
			'YARPP'                                => 'yet-another-related-posts-plugin/yarpp.php',
162
			'WordPress Related Posts'              => 'wordpress-23-related-posts-plugin/wp_related_posts.php',
163
			'nrelate Related Content'              => 'nrelate-related-content/nrelate-related.php',
164
			'Contextual Related Posts'             => 'contextual-related-posts/contextual-related-posts.php',
165
			'Related Posts for WordPress'          => 'microkids-related-posts/microkids-related-posts.php',
166
			'outbrain'                             => 'outbrain/outbrain.php',
167
			'Shareaholic'                          => 'shareaholic/shareaholic.php',
168
			'Sexybookmarks'                        => 'sexybookmarks/shareaholic.php',
169
		),
170
		'sharedaddy'        => array(
171
			'AddThis'                              => 'addthis/addthis_social_widget.php',
172
			'Add To Any'                           => 'add-to-any/add-to-any.php',
173
			'ShareThis'                            => 'share-this/sharethis.php',
174
			'Shareaholic'                          => 'shareaholic/shareaholic.php',
175
		),
176
		'seo-tools' => array(
177
			'WordPress SEO by Yoast'               => 'wordpress-seo/wp-seo.php',
178
			'WordPress SEO Premium by Yoast'       => 'wordpress-seo-premium/wp-seo-premium.php',
179
			'All in One SEO Pack'                  => 'all-in-one-seo-pack/all_in_one_seo_pack.php',
180
			'All in One SEO Pack Pro'              => 'all-in-one-seo-pack-pro/all_in_one_seo_pack.php',
181
		),
182
		'verification-tools' => array(
183
			'WordPress SEO by Yoast'               => 'wordpress-seo/wp-seo.php',
184
			'WordPress SEO Premium by Yoast'       => 'wordpress-seo-premium/wp-seo-premium.php',
185
			'All in One SEO Pack'                  => 'all-in-one-seo-pack/all_in_one_seo_pack.php',
186
			'All in One SEO Pack Pro'              => 'all-in-one-seo-pack-pro/all_in_one_seo_pack.php',
187
		),
188
		'widget-visibility' => array(
189
			'Widget Logic'                         => 'widget-logic/widget_logic.php',
190
			'Dynamic Widgets'                      => 'dynamic-widgets/dynamic-widgets.php',
191
		),
192
		'sitemaps' => array(
193
			'Google XML Sitemaps'                  => 'google-sitemap-generator/sitemap.php',
194
			'Better WordPress Google XML Sitemaps' => 'bwp-google-xml-sitemaps/bwp-simple-gxs.php',
195
			'Google XML Sitemaps for qTranslate'   => 'google-xml-sitemaps-v3-for-qtranslate/sitemap.php',
196
			'XML Sitemap & Google News feeds'      => 'xml-sitemap-feed/xml-sitemap.php',
197
			'Google Sitemap by BestWebSoft'        => 'google-sitemap-plugin/google-sitemap-plugin.php',
198
			'WordPress SEO by Yoast'               => 'wordpress-seo/wp-seo.php',
199
			'WordPress SEO Premium by Yoast'       => 'wordpress-seo-premium/wp-seo-premium.php',
200
			'All in One SEO Pack'                  => 'all-in-one-seo-pack/all_in_one_seo_pack.php',
201
			'All in One SEO Pack Pro'              => 'all-in-one-seo-pack-pro/all_in_one_seo_pack.php',
202
			'Sitemap'                              => 'sitemap/sitemap.php',
203
			'Simple Wp Sitemap'                    => 'simple-wp-sitemap/simple-wp-sitemap.php',
204
			'Simple Sitemap'                       => 'simple-sitemap/simple-sitemap.php',
205
			'XML Sitemaps'                         => 'xml-sitemaps/xml-sitemaps.php',
206
			'MSM Sitemaps'                         => 'msm-sitemap/msm-sitemap.php',
207
		),
208
		'lazy-images' => array(
209
			'Lazy Load'              => 'lazy-load/lazy-load.php',
210
			'BJ Lazy Load'           => 'bj-lazy-load/bj-lazy-load.php',
211
			'Lazy Load by WP Rocket' => 'rocket-lazy-load/rocket-lazy-load.php',
212
		),
213
	);
214
215
	/**
216
	 * Plugins for which we turn off our Facebook OG Tags implementation.
217
	 *
218
	 * Note: All in One SEO Pack, All in one SEO Pack Pro, WordPress SEO by Yoast, and WordPress SEO Premium by Yoast automatically deactivate
219
	 * Jetpack's Open Graph tags via filter when their Social Meta modules are active.
220
	 *
221
	 * Plugin authors: If you'd like to prevent Jetpack's Open Graph tag generation in your plugin, you can do so via this filter:
222
	 * add_filter( 'jetpack_enable_open_graph', '__return_false' );
223
	 */
224
	private $open_graph_conflicting_plugins = array(
225
		'2-click-socialmedia-buttons/2-click-socialmedia-buttons.php',
226
		                                                         // 2 Click Social Media Buttons
227
		'add-link-to-facebook/add-link-to-facebook.php',         // Add Link to Facebook
228
		'add-meta-tags/add-meta-tags.php',                       // Add Meta Tags
229
		'autodescription/autodescription.php',                   // The SEO Framework
230
		'easy-facebook-share-thumbnails/esft.php',               // Easy Facebook Share Thumbnail
231
		'heateor-open-graph-meta-tags/heateor-open-graph-meta-tags.php',
232
		                                                         // Open Graph Meta Tags by Heateor
233
		'facebook/facebook.php',                                 // Facebook (official plugin)
234
		'facebook-awd/AWD_facebook.php',                         // Facebook AWD All in one
235
		'facebook-featured-image-and-open-graph-meta-tags/fb-featured-image.php',
236
		                                                         // Facebook Featured Image & OG Meta Tags
237
		'facebook-meta-tags/facebook-metatags.php',              // Facebook Meta Tags
238
		'wonderm00ns-simple-facebook-open-graph-tags/wonderm00n-open-graph.php',
239
		                                                         // Facebook Open Graph Meta Tags for WordPress
240
		'facebook-revised-open-graph-meta-tag/index.php',        // Facebook Revised Open Graph Meta Tag
241
		'facebook-thumb-fixer/_facebook-thumb-fixer.php',        // Facebook Thumb Fixer
242
		'facebook-and-digg-thumbnail-generator/facebook-and-digg-thumbnail-generator.php',
243
		                                                         // Fedmich's Facebook Open Graph Meta
244
		'network-publisher/networkpub.php',                      // Network Publisher
245
		'nextgen-facebook/nextgen-facebook.php',                 // NextGEN Facebook OG
246
		'social-networks-auto-poster-facebook-twitter-g/NextScripts_SNAP.php',
247
		                                                         // NextScripts SNAP
248
		'og-tags/og-tags.php',                                   // OG Tags
249
		'opengraph/opengraph.php',                               // Open Graph
250
		'open-graph-protocol-framework/open-graph-protocol-framework.php',
251
		                                                         // Open Graph Protocol Framework
252
		'seo-facebook-comments/seofacebook.php',                 // SEO Facebook Comments
253
		'seo-ultimate/seo-ultimate.php',                         // SEO Ultimate
254
		'sexybookmarks/sexy-bookmarks.php',                      // Shareaholic
255
		'shareaholic/sexy-bookmarks.php',                        // Shareaholic
256
		'sharepress/sharepress.php',                             // SharePress
257
		'simple-facebook-connect/sfc.php',                       // Simple Facebook Connect
258
		'social-discussions/social-discussions.php',             // Social Discussions
259
		'social-sharing-toolkit/social_sharing_toolkit.php',     // Social Sharing Toolkit
260
		'socialize/socialize.php',                               // Socialize
261
		'squirrly-seo/squirrly.php',                             // SEO by SQUIRRLY™
262
		'only-tweet-like-share-and-google-1/tweet-like-plusone.php',
263
		                                                         // Tweet, Like, Google +1 and Share
264
		'wordbooker/wordbooker.php',                             // Wordbooker
265
		'wpsso/wpsso.php',                                       // WordPress Social Sharing Optimization
266
		'wp-caregiver/wp-caregiver.php',                         // WP Caregiver
267
		'wp-facebook-like-send-open-graph-meta/wp-facebook-like-send-open-graph-meta.php',
268
		                                                         // WP Facebook Like Send & Open Graph Meta
269
		'wp-facebook-open-graph-protocol/wp-facebook-ogp.php',   // WP Facebook Open Graph protocol
270
		'wp-ogp/wp-ogp.php',                                     // WP-OGP
271
		'zoltonorg-social-plugin/zosp.php',                      // Zolton.org Social Plugin
272
		'wp-fb-share-like-button/wp_fb_share-like_widget.php',   // WP Facebook Like Button
273
		'open-graph-metabox/open-graph-metabox.php'              // Open Graph Metabox
274
	);
275
276
	/**
277
	 * Plugins for which we turn off our Twitter Cards Tags implementation.
278
	 */
279
	private $twitter_cards_conflicting_plugins = array(
280
	//	'twitter/twitter.php',                       // The official one handles this on its own.
281
	//	                                             // https://github.com/twitter/wordpress/blob/master/src/Twitter/WordPress/Cards/Compatibility.php
282
		'eewee-twitter-card/index.php',              // Eewee Twitter Card
283
		'ig-twitter-cards/ig-twitter-cards.php',     // IG:Twitter Cards
284
		'jm-twitter-cards/jm-twitter-cards.php',     // JM Twitter Cards
285
		'kevinjohn-gallagher-pure-web-brilliants-social-graph-twitter-cards-extention/kevinjohn_gallagher___social_graph_twitter_output.php',
286
		                                             // Pure Web Brilliant's Social Graph Twitter Cards Extension
287
		'twitter-cards/twitter-cards.php',           // Twitter Cards
288
		'twitter-cards-meta/twitter-cards-meta.php', // Twitter Cards Meta
289
		'wp-twitter-cards/twitter_cards.php',        // WP Twitter Cards
290
	);
291
292
	/**
293
	 * Message to display in admin_notice
294
	 * @var string
295
	 */
296
	public $message = '';
297
298
	/**
299
	 * Error to display in admin_notice
300
	 * @var string
301
	 */
302
	public $error = '';
303
304
	/**
305
	 * Modules that need more privacy description.
306
	 * @var string
307
	 */
308
	public $privacy_checks = '';
309
310
	/**
311
	 * Stats to record once the page loads
312
	 *
313
	 * @var array
314
	 */
315
	public $stats = array();
316
317
	/**
318
	 * Jetpack_Sync object
319
	 */
320
	public $sync;
321
322
	/**
323
	 * Verified data for JSON authorization request
324
	 */
325
	public $json_api_authorization_request = array();
326
327
	/**
328
	 * @var string Transient key used to prevent multiple simultaneous plugin upgrades
329
	 */
330
	public static $plugin_upgrade_lock_key = 'jetpack_upgrade_lock';
331
332
	/**
333
	 * Holds the singleton instance of this class
334
	 * @since 2.3.3
335
	 * @var Jetpack
336
	 */
337
	static $instance = false;
338
339
	/**
340
	 * Singleton
341
	 * @static
342
	 */
343
	public static function init() {
344
		if ( ! self::$instance ) {
345
			self::$instance = new Jetpack;
346
347
			self::$instance->plugin_upgrade();
348
		}
349
350
		return self::$instance;
351
	}
352
353
	/**
354
	 * Must never be called statically
355
	 */
356
	function plugin_upgrade() {
357
		if ( Jetpack::is_active() ) {
358
			list( $version ) = explode( ':', Jetpack_Options::get_option( 'version' ) );
359
			if ( JETPACK__VERSION != $version ) {
360
				// Prevent multiple upgrades at once - only a single process should trigger
361
				// an upgrade to avoid stampedes
362
				if ( false !== get_transient( self::$plugin_upgrade_lock_key ) ) {
363
					return;
364
				}
365
366
				// Set a short lock to prevent multiple instances of the upgrade
367
				set_transient( self::$plugin_upgrade_lock_key, 1, 10 );
368
369
				// check which active modules actually exist and remove others from active_modules list
370
				$unfiltered_modules = Jetpack::get_active_modules();
371
				$modules = array_filter( $unfiltered_modules, array( 'Jetpack', 'is_module' ) );
372
				if ( array_diff( $unfiltered_modules, $modules ) ) {
373
					Jetpack::update_active_modules( $modules );
374
				}
375
376
				add_action( 'init', array( __CLASS__, 'activate_new_modules' ) );
377
378
				// Upgrade to 4.3.0
379
				if ( Jetpack_Options::get_option( 'identity_crisis_whitelist' ) ) {
380
					Jetpack_Options::delete_option( 'identity_crisis_whitelist' );
381
				}
382
383
				// Make sure Markdown for posts gets turned back on
384
				if ( ! get_option( 'wpcom_publish_posts_with_markdown' ) ) {
385
					update_option( 'wpcom_publish_posts_with_markdown', true );
386
				}
387
388
				if ( did_action( 'wp_loaded' ) ) {
389
					self::upgrade_on_load();
390
				} else {
391
					add_action(
392
						'wp_loaded',
393
						array( __CLASS__, 'upgrade_on_load' )
394
					);
395
				}
396
			}
397
		}
398
	}
399
400
	/**
401
	 * Runs upgrade routines that need to have modules loaded.
402
	 */
403
	static function upgrade_on_load() {
404
405
		// Not attempting any upgrades if jetpack_modules_loaded did not fire.
406
		// This can happen in case Jetpack has been just upgraded and is
407
		// being initialized late during the page load. In this case we wait
408
		// until the next proper admin page load with Jetpack active.
409
		if ( ! did_action( 'jetpack_modules_loaded' ) ) {
410
			delete_transient( self::$plugin_upgrade_lock_key );
411
412
			return;
413
		}
414
415
		Jetpack::maybe_set_version_option();
416
417
		if ( class_exists( 'Jetpack_Widget_Conditions' ) ) {
418
			Jetpack_Widget_Conditions::migrate_post_type_rules();
419
		}
420
421
		if (
422
			class_exists( 'Jetpack_Sitemap_Manager' )
423
			&& version_compare( JETPACK__VERSION, '5.3', '>=' )
424
		) {
425
			do_action( 'jetpack_sitemaps_purge_data' );
426
		}
427
428
		delete_transient( self::$plugin_upgrade_lock_key );
429
	}
430
431
	static function activate_manage( ) {
432
		if ( did_action( 'init' ) || current_filter() == 'init' ) {
433
			self::activate_module( 'manage', false, false );
434
		} else if ( !  has_action( 'init' , array( __CLASS__, 'activate_manage' ) ) ) {
435
			add_action( 'init', array( __CLASS__, 'activate_manage' ) );
436
		}
437
	}
438
439
	static function update_active_modules( $modules ) {
440
		$current_modules = Jetpack_Options::get_option( 'active_modules', array() );
441
442
		$success = Jetpack_Options::update_option( 'active_modules', array_unique( $modules ) );
443
444
		if ( is_array( $modules ) && is_array( $current_modules ) ) {
445
			$new_active_modules = array_diff( $modules, $current_modules );
446
			foreach( $new_active_modules as $module ) {
447
				/**
448
				 * Fires when a specific module is activated.
449
				 *
450
				 * @since 1.9.0
451
				 *
452
				 * @param string $module Module slug.
453
				 * @param boolean $success whether the module was activated. @since 4.2
454
				 */
455
				do_action( 'jetpack_activate_module', $module, $success );
456
457
				/**
458
				 * Fires when a module is activated.
459
				 * The dynamic part of the filter, $module, is the module slug.
460
				 *
461
				 * @since 1.9.0
462
				 *
463
				 * @param string $module Module slug.
464
				 */
465
				do_action( "jetpack_activate_module_$module", $module );
466
			}
467
468
			$new_deactive_modules = array_diff( $current_modules, $modules );
469
			foreach( $new_deactive_modules as $module ) {
470
				/**
471
				 * Fired after a module has been deactivated.
472
				 *
473
				 * @since 4.2.0
474
				 *
475
				 * @param string $module Module slug.
476
				 * @param boolean $success whether the module was deactivated.
477
				 */
478
				do_action( 'jetpack_deactivate_module', $module, $success );
479
				/**
480
				 * Fires when a module is deactivated.
481
				 * The dynamic part of the filter, $module, is the module slug.
482
				 *
483
				 * @since 1.9.0
484
				 *
485
				 * @param string $module Module slug.
486
				 */
487
				do_action( "jetpack_deactivate_module_$module", $module );
488
			}
489
		}
490
491
		return $success;
492
	}
493
494
	static function delete_active_modules() {
495
		self::update_active_modules( array() );
496
	}
497
498
	/**
499
	 * Constructor.  Initializes WordPress hooks
500
	 */
501
	private function __construct() {
502
		/*
503
		 * Check for and alert any deprecated hooks
504
		 */
505
		add_action( 'init', array( $this, 'deprecated_hooks' ) );
506
507
		/*
508
		 * Enable enhanced handling of previewing sites in Calypso
509
		 */
510
		if ( Jetpack::is_active() ) {
511
			require_once JETPACK__PLUGIN_DIR . '_inc/lib/class.jetpack-iframe-embed.php';
512
			add_action( 'init', array( 'Jetpack_Iframe_Embed', 'init' ), 9, 0 );
513
		}
514
515
		/*
516
		 * Load things that should only be in Network Admin.
517
		 *
518
		 * For now blow away everything else until a more full
519
		 * understanding of what is needed at the network level is
520
		 * available
521
		 */
522
		if( is_multisite() ) {
523
			Jetpack_Network::init();
524
		}
525
526
		add_action( 'set_user_role', array( $this, 'maybe_clear_other_linked_admins_transient' ), 10, 3 );
527
528
		// Unlink user before deleting the user from .com
529
		add_action( 'deleted_user', array( $this, 'unlink_user' ), 10, 1 );
530
		add_action( 'remove_user_from_blog', array( $this, 'unlink_user' ), 10, 1 );
531
532
		if ( defined( 'XMLRPC_REQUEST' ) && XMLRPC_REQUEST && isset( $_GET['for'] ) && 'jetpack' == $_GET['for'] ) {
533
			@ini_set( 'display_errors', false ); // Display errors can cause the XML to be not well formed.
534
535
			require_once JETPACK__PLUGIN_DIR . 'class.jetpack-xmlrpc-server.php';
536
			$this->xmlrpc_server = new Jetpack_XMLRPC_Server();
537
538
			$this->require_jetpack_authentication();
539
540
			if ( Jetpack::is_active() ) {
541
				// Hack to preserve $HTTP_RAW_POST_DATA
542
				add_filter( 'xmlrpc_methods', array( $this, 'xmlrpc_methods' ) );
543
544
				$signed = $this->verify_xml_rpc_signature();
545 View Code Duplication
				if ( $signed && ! is_wp_error( $signed ) ) {
546
					// The actual API methods.
547
					add_filter( 'xmlrpc_methods', array( $this->xmlrpc_server, 'xmlrpc_methods' ) );
548
				} else {
549
					// The jetpack.authorize method should be available for unauthenticated users on a site with an
550
					// active Jetpack connection, so that additional users can link their account.
551
					add_filter( 'xmlrpc_methods', array( $this->xmlrpc_server, 'authorize_xmlrpc_methods' ) );
552
				}
553 View Code Duplication
			} else {
554
				// The bootstrap API methods.
555
				add_filter( 'xmlrpc_methods', array( $this->xmlrpc_server, 'bootstrap_xmlrpc_methods' ) );
556
				$signed = $this->verify_xml_rpc_signature();
557
				if ( $signed && ! is_wp_error( $signed ) ) {
558
					// the jetpack Provision method is available for blog-token-signed requests
559
					add_filter( 'xmlrpc_methods', array( $this->xmlrpc_server, 'provision_xmlrpc_methods' ) );
560
				}
561
			}
562
563
			// Now that no one can authenticate, and we're whitelisting all XML-RPC methods, force enable_xmlrpc on.
564
			add_filter( 'pre_option_enable_xmlrpc', '__return_true' );
565
		} elseif (
566
			is_admin() &&
567
			isset( $_POST['action'] ) && (
568
				'jetpack_upload_file' == $_POST['action'] ||
569
				'jetpack_update_file' == $_POST['action']
570
			)
571
		) {
572
			$this->require_jetpack_authentication();
573
			$this->add_remote_request_handlers();
574
		} else {
575
			if ( Jetpack::is_active() ) {
576
				add_action( 'login_form_jetpack_json_api_authorization', array( &$this, 'login_form_json_api_authorization' ) );
577
				add_filter( 'xmlrpc_methods', array( $this, 'public_xmlrpc_methods' ) );
578
			}
579
		}
580
581
		if ( Jetpack::is_active() ) {
582
			Jetpack_Heartbeat::init();
583
			require_once JETPACK__PLUGIN_DIR . '_inc/lib/class.jetpack-search-performance-logger.php';
584
			Jetpack_Search_Performance_Logger::init();
585
		}
586
587
		add_filter( 'determine_current_user', array( $this, 'wp_rest_authenticate' ) );
588
		add_filter( 'rest_authentication_errors', array( $this, 'wp_rest_authentication_errors' ) );
589
590
		add_action( 'jetpack_clean_nonces', array( 'Jetpack', 'clean_nonces' ) );
591
		if ( ! wp_next_scheduled( 'jetpack_clean_nonces' ) ) {
592
			wp_schedule_event( time(), 'hourly', 'jetpack_clean_nonces' );
593
		}
594
595
		add_filter( 'xmlrpc_blog_options', array( $this, 'xmlrpc_options' ) );
596
597
		add_action( 'admin_init', array( $this, 'admin_init' ) );
598
		add_action( 'admin_init', array( $this, 'dismiss_jetpack_notice' ) );
599
600
		add_filter( 'admin_body_class', array( $this, 'admin_body_class' ) );
601
602
		add_action( 'wp_dashboard_setup', array( $this, 'wp_dashboard_setup' ) );
603
		// Filter the dashboard meta box order to swap the new one in in place of the old one.
604
		add_filter( 'get_user_option_meta-box-order_dashboard', array( $this, 'get_user_option_meta_box_order_dashboard' ) );
605
606
		// returns HTTPS support status
607
		add_action( 'wp_ajax_jetpack-recheck-ssl', array( $this, 'ajax_recheck_ssl' ) );
608
609
		// If any module option is updated before Jump Start is dismissed, hide Jump Start.
610
		add_action( 'update_option', array( $this, 'jumpstart_has_updated_module_option' ) );
611
612
		// JITM AJAX callback function
613
		add_action( 'wp_ajax_jitm_ajax',  array( $this, 'jetpack_jitm_ajax_callback' ) );
614
615
		// Universal ajax callback for all tracking events triggered via js
616
		add_action( 'wp_ajax_jetpack_tracks', array( $this, 'jetpack_admin_ajax_tracks_callback' ) );
617
618
		add_action( 'wp_ajax_jetpack_connection_banner', array( $this, 'jetpack_connection_banner_callback' ) );
619
620
		add_action( 'wp_loaded', array( $this, 'register_assets' ) );
621
		add_action( 'wp_enqueue_scripts', array( $this, 'devicepx' ) );
622
		add_action( 'customize_controls_enqueue_scripts', array( $this, 'devicepx' ) );
623
		add_action( 'admin_enqueue_scripts', array( $this, 'devicepx' ) );
624
625
		// gutenberg locale
626
		add_action( 'enqueue_block_editor_assets', array( $this, 'enqueue_gutenberg_assets' ) );
627
628
		add_action( 'plugins_loaded', array( $this, 'extra_oembed_providers' ), 100 );
629
630
		/**
631
		 * These actions run checks to load additional files.
632
		 * They check for external files or plugins, so they need to run as late as possible.
633
		 */
634
		add_action( 'wp_head', array( $this, 'check_open_graph' ),       1 );
635
		add_action( 'plugins_loaded', array( $this, 'check_twitter_tags' ),     999 );
636
		add_action( 'plugins_loaded', array( $this, 'check_rest_api_compat' ), 1000 );
637
638
		add_filter( 'plugins_url',      array( 'Jetpack', 'maybe_min_asset' ),     1, 3 );
639
		add_action( 'style_loader_src', array( 'Jetpack', 'set_suffix_on_min' ), 10, 2  );
640
		add_filter( 'style_loader_tag', array( 'Jetpack', 'maybe_inline_style' ), 10, 2 );
641
642
		add_filter( 'map_meta_cap', array( $this, 'jetpack_custom_caps' ), 1, 4 );
643
644
		add_filter( 'jetpack_get_default_modules', array( $this, 'filter_default_modules' ) );
645
		add_filter( 'jetpack_get_default_modules', array( $this, 'handle_deprecated_modules' ), 99 );
646
647
		// A filter to control all just in time messages
648
		add_filter( 'jetpack_just_in_time_msgs', '__return_true', 9 );
649
		add_filter( 'jetpack_just_in_time_msg_cache', '__return_true', 9);
650
651
		// If enabled, point edit post, page, and comment links to Calypso instead of WP-Admin.
652
		// We should make sure to only do this for front end links.
653
		if ( Jetpack::get_option( 'edit_links_calypso_redirect' ) && ! is_admin() ) {
654
			add_filter( 'get_edit_post_link', array( $this, 'point_edit_post_links_to_calypso' ), 1, 2 );
655
			add_filter( 'get_edit_comment_link', array( $this, 'point_edit_comment_links_to_calypso' ), 1 );
656
657
			//we'll override wp_notify_postauthor and wp_notify_moderator pluggable functions
658
			//so they point moderation links on emails to Calypso
659
			jetpack_require_lib( 'functions.wp-notify' );
660
		}
661
662
		// Update the Jetpack plan from API on heartbeats
663
		add_action( 'jetpack_heartbeat', array( $this, 'refresh_active_plan_from_wpcom' ) );
664
665
		/**
666
		 * This is the hack to concatenate all css files into one.
667
		 * For description and reasoning see the implode_frontend_css method
668
		 *
669
		 * Super late priority so we catch all the registered styles
670
		 */
671
		if( !is_admin() ) {
672
			add_action( 'wp_print_styles', array( $this, 'implode_frontend_css' ), -1 ); // Run first
673
			add_action( 'wp_print_footer_scripts', array( $this, 'implode_frontend_css' ), -1 ); // Run first to trigger before `print_late_styles`
674
		}
675
676
		/**
677
		 * These are sync actions that we need to keep track of for jitms
678
		 */
679
		add_filter( 'jetpack_sync_before_send_updated_option', array( $this, 'jetpack_track_last_sync_callback' ), 99 );
680
681
		// Actually push the stats on shutdown.
682
		if ( ! has_action( 'shutdown', array( $this, 'push_stats' ) ) ) {
683
			add_action( 'shutdown', array( $this, 'push_stats' ) );
684
		}
685
	}
686
687
	function point_edit_post_links_to_calypso( $default_url, $post_id ) {
688
		$post = get_post( $post_id );
689
690
		if ( empty( $post ) ) {
691
			return $default_url;
692
		}
693
694
		$post_type = $post->post_type;
695
696
		// Mapping the allowed CPTs on WordPress.com to corresponding paths in Calypso.
697
		// https://en.support.wordpress.com/custom-post-types/
698
		$allowed_post_types = array(
699
			'post' => 'post',
700
			'page' => 'page',
701
			'jetpack-portfolio' => 'edit/jetpack-portfolio',
702
			'jetpack-testimonial' => 'edit/jetpack-testimonial',
703
		);
704
705
		if ( ! in_array( $post_type, array_keys( $allowed_post_types ) ) ) {
706
			return $default_url;
707
		}
708
709
		$path_prefix = $allowed_post_types[ $post_type ];
710
711
		$site_slug  = Jetpack::build_raw_urls( get_home_url() );
712
713
		return esc_url( sprintf( 'https://wordpress.com/%s/%s/%d', $path_prefix, $site_slug, $post_id ) );
714
	}
715
716
	function point_edit_comment_links_to_calypso( $url ) {
717
		// Take the `query` key value from the URL, and parse its parts to the $query_args. `amp;c` matches the comment ID.
718
		wp_parse_str( wp_parse_url( $url, PHP_URL_QUERY ), $query_args );
719
		return esc_url( sprintf( 'https://wordpress.com/comment/%s/%d',
720
			Jetpack::build_raw_urls( get_home_url() ),
721
			$query_args['amp;c']
722
		) );
723
	}
724
725
	function jetpack_track_last_sync_callback( $params ) {
726
		/**
727
		 * Filter to turn off jitm caching
728
		 *
729
		 * @since 5.4.0
730
		 *
731
		 * @param bool false Whether to cache just in time messages
732
		 */
733
		if ( ! apply_filters( 'jetpack_just_in_time_msg_cache', false ) ) {
734
			return $params;
735
		}
736
737
		if ( is_array( $params ) && isset( $params[0] ) ) {
738
			$option = $params[0];
739
			if ( 'active_plugins' === $option ) {
740
				// use the cache if we can, but not terribly important if it gets evicted
741
				set_transient( 'jetpack_last_plugin_sync', time(), HOUR_IN_SECONDS );
742
			}
743
		}
744
745
		return $params;
746
	}
747
748
	function jetpack_connection_banner_callback() {
749
		check_ajax_referer( 'jp-connection-banner-nonce', 'nonce' );
750
751
		if ( isset( $_REQUEST['dismissBanner'] ) ) {
752
			Jetpack_Options::update_option( 'dismissed_connection_banner', 1 );
753
			wp_send_json_success();
754
		}
755
756
		wp_die();
757
	}
758
759
	function jetpack_admin_ajax_tracks_callback() {
760
		// Check for nonce
761
		if ( ! isset( $_REQUEST['tracksNonce'] ) || ! wp_verify_nonce( $_REQUEST['tracksNonce'], 'jp-tracks-ajax-nonce' ) ) {
762
			wp_die( 'Permissions check failed.' );
763
		}
764
765
		if ( ! isset( $_REQUEST['tracksEventName'] ) || ! isset( $_REQUEST['tracksEventType'] )  ) {
766
			wp_die( 'No valid event name or type.' );
767
		}
768
769
		$tracks_data = array();
770
		if ( 'click' === $_REQUEST['tracksEventType'] && isset( $_REQUEST['tracksEventProp'] ) ) {
771
			if ( is_array( $_REQUEST['tracksEventProp'] ) ) {
772
				$tracks_data = $_REQUEST['tracksEventProp'];
773
			} else {
774
				$tracks_data = array( 'clicked' => $_REQUEST['tracksEventProp'] );
775
			}
776
		}
777
778
		JetpackTracking::record_user_event( $_REQUEST['tracksEventName'], $tracks_data );
779
		wp_send_json_success();
780
		wp_die();
781
	}
782
783
	/**
784
	 * The callback for the JITM ajax requests.
785
	 */
786
	function jetpack_jitm_ajax_callback() {
787
		// Check for nonce
788
		if ( ! isset( $_REQUEST['jitmNonce'] ) || ! wp_verify_nonce( $_REQUEST['jitmNonce'], 'jetpack-jitm-nonce' ) ) {
789
			wp_die( 'Module activation failed due to lack of appropriate permissions' );
790
		}
791
		if ( isset( $_REQUEST['jitmActionToTake'] ) && 'activate' == $_REQUEST['jitmActionToTake'] ) {
792
			$module_slug = $_REQUEST['jitmModule'];
793
			Jetpack::log( 'activate', $module_slug );
794
			Jetpack::activate_module( $module_slug, false, false );
795
			Jetpack::state( 'message', 'no_message' );
796
797
			//A Jetpack module is being activated through a JITM, track it
798
			$this->stat( 'jitm', $module_slug.'-activated-' . JETPACK__VERSION );
799
			$this->do_stats( 'server_side' );
800
801
			wp_send_json_success();
802
		}
803
		if ( isset( $_REQUEST['jitmActionToTake'] ) && 'dismiss' == $_REQUEST['jitmActionToTake'] ) {
804
			// get the hide_jitm options array
805
			$jetpack_hide_jitm = Jetpack_Options::get_option( 'hide_jitm' );
806
			$module_slug = $_REQUEST['jitmModule'];
807
808
			if( ! $jetpack_hide_jitm ) {
809
				$jetpack_hide_jitm = array(
810
					$module_slug => 'hide'
811
				);
812
			} else {
813
				$jetpack_hide_jitm[$module_slug] = 'hide';
814
			}
815
816
			Jetpack_Options::update_option( 'hide_jitm', $jetpack_hide_jitm );
817
818
			//jitm is being dismissed forever, track it
819
			$this->stat( 'jitm', $module_slug.'-dismissed-' . JETPACK__VERSION );
820
			$this->do_stats( 'server_side' );
821
822
			wp_send_json_success();
823
		}
824 View Code Duplication
		if ( isset( $_REQUEST['jitmActionToTake'] ) && 'launch' == $_REQUEST['jitmActionToTake'] ) {
825
			$module_slug = $_REQUEST['jitmModule'];
826
827
			// User went to WordPress.com, track this
828
			$this->stat( 'jitm', $module_slug.'-wordpress-tools-' . JETPACK__VERSION );
829
			$this->do_stats( 'server_side' );
830
831
			wp_send_json_success();
832
		}
833 View Code Duplication
		if ( isset( $_REQUEST['jitmActionToTake'] ) && 'viewed' == $_REQUEST['jitmActionToTake'] ) {
834
			$track = $_REQUEST['jitmModule'];
835
836
			// User is viewing JITM, track it.
837
			$this->stat( 'jitm', $track . '-viewed-' . JETPACK__VERSION );
838
			$this->do_stats( 'server_side' );
839
840
			wp_send_json_success();
841
		}
842
	}
843
844
	/**
845
	 * If there are any stats that need to be pushed, but haven't been, push them now.
846
	 */
847
	function push_stats() {
848
		if ( ! empty( $this->stats ) ) {
849
			$this->do_stats( 'server_side' );
850
		}
851
	}
852
853
	function jetpack_custom_caps( $caps, $cap, $user_id, $args ) {
854
		switch( $cap ) {
855
			case 'jetpack_connect' :
856
			case 'jetpack_reconnect' :
857
				if ( Jetpack::is_development_mode() ) {
858
					$caps = array( 'do_not_allow' );
859
					break;
860
				}
861
				/**
862
				 * Pass through. If it's not development mode, these should match disconnect.
863
				 * Let users disconnect if it's development mode, just in case things glitch.
864
				 */
865
			case 'jetpack_disconnect' :
866
				/**
867
				 * In multisite, can individual site admins manage their own connection?
868
				 *
869
				 * Ideally, this should be extracted out to a separate filter in the Jetpack_Network class.
870
				 */
871
				if ( is_multisite() && ! is_super_admin() && is_plugin_active_for_network( 'jetpack/jetpack.php' ) ) {
872
					if ( ! Jetpack_Network::init()->get_option( 'sub-site-connection-override' ) ) {
873
						/**
874
						 * We need to update the option name -- it's terribly unclear which
875
						 * direction the override goes.
876
						 *
877
						 * @todo: Update the option name to `sub-sites-can-manage-own-connections`
878
						 */
879
						$caps = array( 'do_not_allow' );
880
						break;
881
					}
882
				}
883
884
				$caps = array( 'manage_options' );
885
				break;
886
			case 'jetpack_manage_modules' :
887
			case 'jetpack_activate_modules' :
888
			case 'jetpack_deactivate_modules' :
889
				$caps = array( 'manage_options' );
890
				break;
891
			case 'jetpack_configure_modules' :
892
				$caps = array( 'manage_options' );
893
				break;
894
			case 'jetpack_network_admin_page':
895
			case 'jetpack_network_settings_page':
896
				$caps = array( 'manage_network_plugins' );
897
				break;
898
			case 'jetpack_network_sites_page':
899
				$caps = array( 'manage_sites' );
900
				break;
901
			case 'jetpack_admin_page' :
902
				if ( Jetpack::is_development_mode() ) {
903
					$caps = array( 'manage_options' );
904
					break;
905
				} else {
906
					$caps = array( 'read' );
907
				}
908
				break;
909
			case 'jetpack_connect_user' :
910
				if ( Jetpack::is_development_mode() ) {
911
					$caps = array( 'do_not_allow' );
912
					break;
913
				}
914
				$caps = array( 'read' );
915
				break;
916
		}
917
		return $caps;
918
	}
919
920
	function require_jetpack_authentication() {
921
		// Don't let anyone authenticate
922
		$_COOKIE = array();
923
		remove_all_filters( 'authenticate' );
924
		remove_all_actions( 'wp_login_failed' );
925
926
		if ( Jetpack::is_active() ) {
927
			// Allow Jetpack authentication
928
			add_filter( 'authenticate', array( $this, 'authenticate_jetpack' ), 10, 3 );
929
		}
930
	}
931
932
	/**
933
	 * Load language files
934
	 * @action plugins_loaded
935
	 */
936
	public static function plugin_textdomain() {
937
		// Note to self, the third argument must not be hardcoded, to account for relocated folders.
938
		load_plugin_textdomain( 'jetpack', false, dirname( plugin_basename( JETPACK__PLUGIN_FILE ) ) . '/languages/' );
939
	}
940
941
	/**
942
	 * Register assets for use in various modules and the Jetpack admin page.
943
	 *
944
	 * @uses wp_script_is, wp_register_script, plugins_url
945
	 * @action wp_loaded
946
	 * @return null
947
	 */
948
	public function register_assets() {
949
		if ( ! wp_script_is( 'spin', 'registered' ) ) {
950
			wp_register_script(
951
				'spin',
952
				self::get_file_url_for_environment( '_inc/build/spin.min.js', '_inc/spin.js' ),
953
				false,
954
				'1.3'
955
			);
956
		}
957
958
		if ( ! wp_script_is( 'jquery.spin', 'registered' ) ) {
959
			wp_register_script(
960
				'jquery.spin',
961
				self::get_file_url_for_environment( '_inc/build/jquery.spin.min.js', '_inc/jquery.spin.js' ),
962
				array( 'jquery', 'spin' ),
963
				'1.3'
964
			);
965
		}
966
967 View Code Duplication
		if ( ! wp_script_is( 'jetpack-gallery-settings', 'registered' ) ) {
968
			wp_register_script(
969
				'jetpack-gallery-settings',
970
				self::get_file_url_for_environment( '_inc/build/gallery-settings.min.js', '_inc/gallery-settings.js' ),
971
				array( 'media-views' ),
972
				'20121225'
973
			);
974
		}
975
976
		if ( ! wp_script_is( 'jetpack-twitter-timeline', 'registered' ) ) {
977
			wp_register_script(
978
				'jetpack-twitter-timeline',
979
				self::get_file_url_for_environment( '_inc/build/twitter-timeline.min.js', '_inc/twitter-timeline.js' ),
980
				array( 'jquery' ),
981
				'4.0.0',
982
				true
983
			);
984
		}
985
986
		if ( ! wp_script_is( 'jetpack-facebook-embed', 'registered' ) ) {
987
			wp_register_script(
988
				'jetpack-facebook-embed',
989
				self::get_file_url_for_environment( '_inc/build/facebook-embed.min.js', '_inc/facebook-embed.js' ),
990
				array( 'jquery' ),
991
				null,
992
				true
993
			);
994
995
			/** This filter is documented in modules/sharedaddy/sharing-sources.php */
996
			$fb_app_id = apply_filters( 'jetpack_sharing_facebook_app_id', '249643311490' );
997
			if ( ! is_numeric( $fb_app_id ) ) {
998
				$fb_app_id = '';
999
			}
1000
			wp_localize_script(
1001
				'jetpack-facebook-embed',
1002
				'jpfbembed',
1003
				array(
1004
					'appid' => $fb_app_id,
1005
					'locale' => $this->get_locale(),
1006
				)
1007
			);
1008
		}
1009
1010
		/**
1011
		 * As jetpack_register_genericons is by default fired off a hook,
1012
		 * the hook may have already fired by this point.
1013
		 * So, let's just trigger it manually.
1014
		 */
1015
		require_once( JETPACK__PLUGIN_DIR . '_inc/genericons.php' );
1016
		jetpack_register_genericons();
1017
1018
		/**
1019
		 * Register the social logos
1020
		 */
1021
		require_once( JETPACK__PLUGIN_DIR . '_inc/social-logos.php' );
1022
		jetpack_register_social_logos();
1023
1024 View Code Duplication
		if ( ! wp_style_is( 'jetpack-icons', 'registered' ) )
1025
			wp_register_style( 'jetpack-icons', plugins_url( 'css/jetpack-icons.min.css', JETPACK__PLUGIN_FILE ), false, JETPACK__VERSION );
1026
	}
1027
1028
	/**
1029
	 * Guess locale from language code.
1030
	 *
1031
	 * @param string $lang Language code.
1032
	 * @return string|bool
1033
	 */
1034 View Code Duplication
	function guess_locale_from_lang( $lang ) {
1035
		if ( 'en' === $lang || 'en_US' === $lang || ! $lang ) {
1036
			return 'en_US';
1037
		}
1038
1039
		if ( ! class_exists( 'GP_Locales' ) ) {
1040
			if ( ! defined( 'JETPACK__GLOTPRESS_LOCALES_PATH' ) || ! file_exists( JETPACK__GLOTPRESS_LOCALES_PATH ) ) {
1041
				return false;
1042
			}
1043
1044
			require JETPACK__GLOTPRESS_LOCALES_PATH;
1045
		}
1046
1047
		if ( defined( 'IS_WPCOM' ) && IS_WPCOM ) {
1048
			// WP.com: get_locale() returns 'it'
1049
			$locale = GP_Locales::by_slug( $lang );
1050
		} else {
1051
			// Jetpack: get_locale() returns 'it_IT';
1052
			$locale = GP_Locales::by_field( 'facebook_locale', $lang );
1053
		}
1054
1055
		if ( ! $locale ) {
1056
			return false;
1057
		}
1058
1059
		if ( empty( $locale->facebook_locale ) ) {
1060
			if ( empty( $locale->wp_locale ) ) {
1061
				return false;
1062
			} else {
1063
				// Facebook SDK is smart enough to fall back to en_US if a
1064
				// locale isn't supported. Since supported Facebook locales
1065
				// can fall out of sync, we'll attempt to use the known
1066
				// wp_locale value and rely on said fallback.
1067
				return $locale->wp_locale;
1068
			}
1069
		}
1070
1071
		return $locale->facebook_locale;
1072
	}
1073
1074
	/**
1075
	 * Get the locale.
1076
	 *
1077
	 * @return string|bool
1078
	 */
1079
	function get_locale() {
1080
		$locale = $this->guess_locale_from_lang( get_locale() );
1081
1082
		if ( ! $locale ) {
1083
			$locale = 'en_US';
1084
		}
1085
1086
		return $locale;
1087
	}
1088
1089
	/**
1090
	 * Device Pixels support
1091
	 * This improves the resolution of gravatars and wordpress.com uploads on hi-res and zoomed browsers.
1092
	 */
1093
	function devicepx() {
1094
		if ( Jetpack::is_active() && ! Jetpack_AMP_Support::is_amp_request() ) {
1095
			wp_enqueue_script( 'devicepx', 'https://s0.wp.com/wp-content/js/devicepx-jetpack.js', array(), gmdate( 'oW' ), true );
1096
		}
1097
	}
1098
1099
	/**
1100
	 * Return the network_site_url so that .com knows what network this site is a part of.
1101
	 * @param  bool $option
1102
	 * @return string
1103
	 */
1104
	public function jetpack_main_network_site_option( $option ) {
1105
		return network_site_url();
1106
	}
1107
	/**
1108
	 * Network Name.
1109
	 */
1110
	static function network_name( $option = null ) {
1111
		global $current_site;
1112
		return $current_site->site_name;
1113
	}
1114
	/**
1115
	 * Does the network allow new user and site registrations.
1116
	 * @return string
1117
	 */
1118
	static function network_allow_new_registrations( $option = null ) {
1119
		return ( in_array( get_site_option( 'registration' ), array('none', 'user', 'blog', 'all' ) ) ? get_site_option( 'registration') : 'none' );
1120
	}
1121
	/**
1122
	 * Does the network allow admins to add new users.
1123
	 * @return boolian
1124
	 */
1125
	static function network_add_new_users( $option = null ) {
1126
		return (bool) get_site_option( 'add_new_users' );
1127
	}
1128
	/**
1129
	 * File upload psace left per site in MB.
1130
	 *  -1 means NO LIMIT.
1131
	 * @return number
1132
	 */
1133
	static function network_site_upload_space( $option = null ) {
1134
		// value in MB
1135
		return ( get_site_option( 'upload_space_check_disabled' ) ? -1 : get_space_allowed() );
1136
	}
1137
1138
	/**
1139
	 * Network allowed file types.
1140
	 * @return string
1141
	 */
1142
	static function network_upload_file_types( $option = null ) {
1143
		return get_site_option( 'upload_filetypes', 'jpg jpeg png gif' );
1144
	}
1145
1146
	/**
1147
	 * Maximum file upload size set by the network.
1148
	 * @return number
1149
	 */
1150
	static function network_max_upload_file_size( $option = null ) {
1151
		// value in KB
1152
		return get_site_option( 'fileupload_maxk', 300 );
1153
	}
1154
1155
	/**
1156
	 * Lets us know if a site allows admins to manage the network.
1157
	 * @return array
1158
	 */
1159
	static function network_enable_administration_menus( $option = null ) {
1160
		return get_site_option( 'menu_items' );
1161
	}
1162
1163
	/**
1164
	 * If a user has been promoted to or demoted from admin, we need to clear the
1165
	 * jetpack_other_linked_admins transient.
1166
	 *
1167
	 * @since 4.3.2
1168
	 * @since 4.4.0  $old_roles is null by default and if it's not passed, the transient is cleared.
1169
	 *
1170
	 * @param int    $user_id   The user ID whose role changed.
1171
	 * @param string $role      The new role.
1172
	 * @param array  $old_roles An array of the user's previous roles.
1173
	 */
1174
	function maybe_clear_other_linked_admins_transient( $user_id, $role, $old_roles = null ) {
1175
		if ( 'administrator' == $role
1176
			|| ( is_array( $old_roles ) && in_array( 'administrator', $old_roles ) )
1177
			|| is_null( $old_roles )
1178
		) {
1179
			delete_transient( 'jetpack_other_linked_admins' );
1180
		}
1181
	}
1182
1183
	/**
1184
	 * Checks to see if there are any other users available to become primary
1185
	 * Users must both:
1186
	 * - Be linked to wpcom
1187
	 * - Be an admin
1188
	 *
1189
	 * @return mixed False if no other users are linked, Int if there are.
1190
	 */
1191
	static function get_other_linked_admins() {
1192
		$other_linked_users = get_transient( 'jetpack_other_linked_admins' );
1193
1194
		if ( false === $other_linked_users ) {
1195
			$admins = get_users( array( 'role' => 'administrator' ) );
1196
			if ( count( $admins ) > 1 ) {
1197
				$available = array();
1198
				foreach ( $admins as $admin ) {
1199
					if ( Jetpack::is_user_connected( $admin->ID ) ) {
1200
						$available[] = $admin->ID;
1201
					}
1202
				}
1203
1204
				$count_connected_admins = count( $available );
1205
				if ( count( $available ) > 1 ) {
1206
					$other_linked_users = $count_connected_admins;
1207
				} else {
1208
					$other_linked_users = 0;
1209
				}
1210
			} else {
1211
				$other_linked_users = 0;
1212
			}
1213
1214
			set_transient( 'jetpack_other_linked_admins', $other_linked_users, HOUR_IN_SECONDS );
1215
		}
1216
1217
		return ( 0 === $other_linked_users ) ? false : $other_linked_users;
1218
	}
1219
1220
	/**
1221
	 * Return whether we are dealing with a multi network setup or not.
1222
	 * The reason we are type casting this is because we want to avoid the situation where
1223
	 * the result is false since when is_main_network_option return false it cases
1224
	 * the rest the get_option( 'jetpack_is_multi_network' ); to return the value that is set in the
1225
	 * database which could be set to anything as opposed to what this function returns.
1226
	 * @param  bool  $option
1227
	 *
1228
	 * @return boolean
1229
	 */
1230
	public function is_main_network_option( $option ) {
1231
		// return '1' or ''
1232
		return (string) (bool) Jetpack::is_multi_network();
1233
	}
1234
1235
	/**
1236
	 * Return true if we are with multi-site or multi-network false if we are dealing with single site.
1237
	 *
1238
	 * @param  string  $option
1239
	 * @return boolean
1240
	 */
1241
	public function is_multisite( $option ) {
1242
		return (string) (bool) is_multisite();
1243
	}
1244
1245
	/**
1246
	 * Implemented since there is no core is multi network function
1247
	 * Right now there is no way to tell if we which network is the dominant network on the system
1248
	 *
1249
	 * @since  3.3
1250
	 * @return boolean
1251
	 */
1252
	public static function is_multi_network() {
1253
		global  $wpdb;
1254
1255
		// if we don't have a multi site setup no need to do any more
1256
		if ( ! is_multisite() ) {
1257
			return false;
1258
		}
1259
1260
		$num_sites = $wpdb->get_var( "SELECT COUNT(*) FROM {$wpdb->site}" );
1261
		if ( $num_sites > 1 ) {
1262
			return true;
1263
		} else {
1264
			return false;
1265
		}
1266
	}
1267
1268
	/**
1269
	 * Trigger an update to the main_network_site when we update the siteurl of a site.
1270
	 * @return null
1271
	 */
1272
	function update_jetpack_main_network_site_option() {
1273
		_deprecated_function( __METHOD__, 'jetpack-4.2' );
1274
	}
1275
	/**
1276
	 * Triggered after a user updates the network settings via Network Settings Admin Page
1277
	 *
1278
	 */
1279
	function update_jetpack_network_settings() {
1280
		_deprecated_function( __METHOD__, 'jetpack-4.2' );
1281
		// Only sync this info for the main network site.
1282
	}
1283
1284
	/**
1285
	 * Get back if the current site is single user site.
1286
	 *
1287
	 * @return bool
1288
	 */
1289
	public static function is_single_user_site() {
1290
		global $wpdb;
1291
1292 View Code Duplication
		if ( false === ( $some_users = get_transient( 'jetpack_is_single_user' ) ) ) {
1293
			$some_users = $wpdb->get_var( "SELECT COUNT(*) FROM (SELECT user_id FROM $wpdb->usermeta WHERE meta_key = '{$wpdb->prefix}capabilities' LIMIT 2) AS someusers" );
1294
			set_transient( 'jetpack_is_single_user', (int) $some_users, 12 * HOUR_IN_SECONDS );
1295
		}
1296
		return 1 === (int) $some_users;
1297
	}
1298
1299
	/**
1300
	 * Returns true if the site has file write access false otherwise.
1301
	 * @return string ( '1' | '0' )
1302
	 **/
1303
	public static function file_system_write_access() {
1304
		if ( ! function_exists( 'get_filesystem_method' ) ) {
1305
			require_once( ABSPATH . 'wp-admin/includes/file.php' );
1306
		}
1307
1308
		require_once( ABSPATH . 'wp-admin/includes/template.php' );
1309
1310
		$filesystem_method = get_filesystem_method();
1311
		if ( $filesystem_method === 'direct' ) {
1312
			return 1;
1313
		}
1314
1315
		ob_start();
1316
		$filesystem_credentials_are_stored = request_filesystem_credentials( self_admin_url() );
1317
		ob_end_clean();
1318
		if ( $filesystem_credentials_are_stored ) {
1319
			return 1;
1320
		}
1321
		return 0;
1322
	}
1323
1324
	/**
1325
	 * Finds out if a site is using a version control system.
1326
	 * @return string ( '1' | '0' )
1327
	 **/
1328
	public static function is_version_controlled() {
1329
		_deprecated_function( __METHOD__, 'jetpack-4.2', 'Jetpack_Sync_Functions::is_version_controlled' );
1330
		return (string) (int) Jetpack_Sync_Functions::is_version_controlled();
1331
	}
1332
1333
	/**
1334
	 * Determines whether the current theme supports featured images or not.
1335
	 * @return string ( '1' | '0' )
1336
	 */
1337
	public static function featured_images_enabled() {
1338
		_deprecated_function( __METHOD__, 'jetpack-4.2' );
1339
		return current_theme_supports( 'post-thumbnails' ) ? '1' : '0';
1340
	}
1341
1342
	/**
1343
	 * Wrapper for core's get_avatar_url().  This one is deprecated.
1344
	 *
1345
	 * @deprecated 4.7 use get_avatar_url instead.
1346
	 * @param int|string|object $id_or_email A user ID,  email address, or comment object
1347
	 * @param int $size Size of the avatar image
1348
	 * @param string $default URL to a default image to use if no avatar is available
1349
	 * @param bool $force_display Whether to force it to return an avatar even if show_avatars is disabled
1350
	 *
1351
	 * @return array
1352
	 */
1353
	public static function get_avatar_url( $id_or_email, $size = 96, $default = '', $force_display = false ) {
1354
		_deprecated_function( __METHOD__, 'jetpack-4.7', 'get_avatar_url' );
1355
		return get_avatar_url( $id_or_email, array(
1356
			'size' => $size,
1357
			'default' => $default,
1358
			'force_default' => $force_display,
1359
		) );
1360
	}
1361
1362
	/**
1363
	 * jetpack_updates is saved in the following schema:
1364
	 *
1365
	 * array (
1366
	 *      'plugins'                       => (int) Number of plugin updates available.
1367
	 *      'themes'                        => (int) Number of theme updates available.
1368
	 *      'wordpress'                     => (int) Number of WordPress core updates available.
1369
	 *      'translations'                  => (int) Number of translation updates available.
1370
	 *      'total'                         => (int) Total of all available updates.
1371
	 *      'wp_update_version'             => (string) The latest available version of WordPress, only present if a WordPress update is needed.
1372
	 * )
1373
	 * @return array
1374
	 */
1375
	public static function get_updates() {
1376
		$update_data = wp_get_update_data();
1377
1378
		// Stores the individual update counts as well as the total count.
1379
		if ( isset( $update_data['counts'] ) ) {
1380
			$updates = $update_data['counts'];
1381
		}
1382
1383
		// If we need to update WordPress core, let's find the latest version number.
1384 View Code Duplication
		if ( ! empty( $updates['wordpress'] ) ) {
1385
			$cur = get_preferred_from_update_core();
1386
			if ( isset( $cur->response ) && 'upgrade' === $cur->response ) {
1387
				$updates['wp_update_version'] = $cur->current;
1388
			}
1389
		}
1390
		return isset( $updates ) ? $updates : array();
1391
	}
1392
1393
	public static function get_update_details() {
1394
		$update_details = array(
1395
			'update_core' => get_site_transient( 'update_core' ),
1396
			'update_plugins' => get_site_transient( 'update_plugins' ),
1397
			'update_themes' => get_site_transient( 'update_themes' ),
1398
		);
1399
		return $update_details;
1400
	}
1401
1402
	public static function refresh_update_data() {
1403
		_deprecated_function( __METHOD__, 'jetpack-4.2' );
1404
1405
	}
1406
1407
	public static function refresh_theme_data() {
1408
		_deprecated_function( __METHOD__, 'jetpack-4.2' );
1409
	}
1410
1411
	/**
1412
	 * Is Jetpack active?
1413
	 */
1414
	public static function is_active() {
1415
		return (bool) Jetpack_Data::get_access_token( JETPACK_MASTER_USER );
1416
	}
1417
1418
	/**
1419
	 * Make an API call to WordPress.com for plan status
1420
	 *
1421
	 * @uses Jetpack_Options::get_option()
1422
	 * @uses Jetpack_Client::wpcom_json_api_request_as_blog()
1423
	 * @uses update_option()
1424
	 *
1425
	 * @access public
1426
	 * @static
1427
	 *
1428
	 * @return bool True if plan is updated, false if no update
1429
	 */
1430
	public static function refresh_active_plan_from_wpcom() {
1431
		// Make the API request
1432
		$request = sprintf( '/sites/%d', Jetpack_Options::get_option( 'id' ) );
1433
		$response = Jetpack_Client::wpcom_json_api_request_as_blog( $request, '1.1' );
1434
1435
		// Bail if there was an error or malformed response
1436
		if ( is_wp_error( $response ) || ! is_array( $response ) || ! isset( $response['body'] ) ) {
1437
			return false;
1438
		}
1439
1440
		// Decode the results
1441
		$results = json_decode( $response['body'], true );
1442
1443
		// Bail if there were no results or plan details returned
1444
		if ( ! is_array( $results ) || ! isset( $results['plan'] ) ) {
1445
			return false;
1446
		}
1447
1448
		// Store the option and return true if updated
1449
		return update_option( 'jetpack_active_plan', $results['plan'] );
1450
	}
1451
1452
	/**
1453
	 * Get the plan that this Jetpack site is currently using
1454
	 *
1455
	 * @uses get_option()
1456
	 *
1457
	 * @access public
1458
	 * @static
1459
	 *
1460
	 * @return array Active Jetpack plan details
1461
	 */
1462
	public static function get_active_plan() {
1463
		global $active_plan_cache;
1464
1465
		// this can be expensive to compute so we cache for the duration of a request
1466
		if ( is_array( $active_plan_cache ) && ! empty( $active_plan_cache ) ) {
1467
			return $active_plan_cache;
1468
		}
1469
1470
		$plan = get_option( 'jetpack_active_plan', array() );
1471
1472
		// Set the default options
1473
		$plan = wp_parse_args( $plan, array(
1474
			'product_slug' => 'jetpack_free',
1475
			'class'        => 'free',
1476
			'features'     => array(
1477
				'active' => array()
1478
			),
1479
		) );
1480
1481
		$supports = array();
1482
1483
		// Define what paid modules are supported by personal plans
1484
		$personal_plans = array(
1485
			'jetpack_personal',
1486
			'jetpack_personal_monthly',
1487
			'personal-bundle',
1488
		);
1489
1490
		if ( in_array( $plan['product_slug'], $personal_plans ) ) {
1491
			// special support value, not a module but a separate plugin
1492
			$supports[] = 'akismet';
1493
			$plan['class'] = 'personal';
1494
		}
1495
1496
		// Define what paid modules are supported by premium plans
1497
		$premium_plans = array(
1498
			'jetpack_premium',
1499
			'jetpack_premium_monthly',
1500
			'value_bundle',
1501
		);
1502
1503 View Code Duplication
		if ( in_array( $plan['product_slug'], $premium_plans ) ) {
1504
			$supports[] = 'akismet';
1505
			$supports[] = 'vaultpress';
1506
			$plan['class'] = 'premium';
1507
		}
1508
1509
		// Define what paid modules are supported by professional plans
1510
		$business_plans = array(
1511
			'jetpack_business',
1512
			'jetpack_business_monthly',
1513
			'business-bundle',
1514
			'vip',
1515
		);
1516
1517 View Code Duplication
		if ( in_array( $plan['product_slug'], $business_plans ) ) {
1518
			$supports[] = 'akismet';
1519
			$supports[] = 'vaultpress';
1520
			$plan['class'] = 'business';
1521
		}
1522
1523
		// get available features
1524
		foreach ( self::get_available_modules() as $module_slug ) {
1525
			$module = self::get_module( $module_slug );
1526
			if ( ! isset( $module ) || ! is_array( $module ) ) {
1527
				continue;
1528
			}
1529
			if ( in_array( 'free', $module['plan_classes'] ) || in_array( $plan['class'], $module['plan_classes'] ) ) {
1530
				$supports[] = $module_slug;
1531
			}
1532
		}
1533
1534
		$plan['supports'] = $supports;
1535
1536
		$active_plan_cache = $plan;
1537
1538
		return $plan;
1539
	}
1540
1541
	/**
1542
	 * Determine whether the active plan supports a particular feature
1543
	 *
1544
	 * @uses Jetpack::get_active_plan()
1545
	 *
1546
	 * @access public
1547
	 * @static
1548
	 *
1549
	 * @return bool True if plan supports feature, false if not
1550
	 */
1551
	public static function active_plan_supports( $feature ) {
1552
		$plan = Jetpack::get_active_plan();
1553
1554
		// Manually mapping WordPress.com features to Jetpack module slugs
1555
		foreach ( $plan['features']['active'] as $wpcom_feature ) {
1556
			switch ( $wpcom_feature ) {
1557
				case 'wordads-jetpack';
1558
1559
				// WordAds are supported for this site
1560
				if ( 'wordads' === $feature ) {
1561
					return true;
1562
				}
1563
				break;
1564
			}
1565
		}
1566
1567
		if (
1568
			in_array( $feature, $plan['supports'] )
1569
			|| in_array( $feature, $plan['features']['active'] )
1570
		) {
1571
			return true;
1572
		}
1573
1574
		return false;
1575
	}
1576
1577
	/**
1578
	 * Is Jetpack in development (offline) mode?
1579
	 */
1580
	public static function is_development_mode() {
1581
		$development_mode = false;
1582
1583
		if ( defined( 'JETPACK_DEV_DEBUG' ) ) {
1584
			$development_mode = JETPACK_DEV_DEBUG;
1585
		} elseif ( $site_url = site_url() ) {
1586
			$development_mode = false === strpos( $site_url, '.' );
1587
		}
1588
1589
		/**
1590
		 * Filters Jetpack's development mode.
1591
		 *
1592
		 * @see https://jetpack.com/support/development-mode/
1593
		 *
1594
		 * @since 2.2.1
1595
		 *
1596
		 * @param bool $development_mode Is Jetpack's development mode active.
1597
		 */
1598
		$development_mode = ( bool ) apply_filters( 'jetpack_development_mode', $development_mode );
1599
		return $development_mode;
1600
	}
1601
1602
	/**
1603
	 * Whether the site is currently onboarding or not.
1604
	 * A site is considered as being onboarded if it currently has an onboarding token.
1605
	 *
1606
	 * @since 5.8
1607
	 *
1608
	 * @access public
1609
	 * @static
1610
	 *
1611
	 * @return bool True if the site is currently onboarding, false otherwise
1612
	 */
1613
	public static function is_onboarding() {
1614
		return Jetpack_Options::get_option( 'onboarding' ) !== false;
1615
	}
1616
1617
	/**
1618
	* Get Jetpack development mode notice text and notice class.
1619
	*
1620
	* Mirrors the checks made in Jetpack::is_development_mode
1621
	*
1622
	*/
1623
	public static function show_development_mode_notice() {
1624
		if ( Jetpack::is_development_mode() ) {
1625
			if ( defined( 'JETPACK_DEV_DEBUG' ) && JETPACK_DEV_DEBUG ) {
1626
				$notice = sprintf(
1627
					/* translators: %s is a URL */
1628
					__( 'In <a href="%s" target="_blank">Development Mode</a>, via the JETPACK_DEV_DEBUG constant being defined in wp-config.php or elsewhere.', 'jetpack' ),
1629
					'https://jetpack.com/support/development-mode/'
1630
				);
1631
			} elseif ( site_url() && false === strpos( site_url(), '.' ) ) {
1632
				$notice = sprintf(
1633
					/* translators: %s is a URL */
1634
					__( 'In <a href="%s" target="_blank">Development Mode</a>, via site URL lacking a dot (e.g. http://localhost).', 'jetpack' ),
1635
					'https://jetpack.com/support/development-mode/'
1636
				);
1637
			} else {
1638
				$notice = sprintf(
1639
					/* translators: %s is a URL */
1640
					__( 'In <a href="%s" target="_blank">Development Mode</a>, via the jetpack_development_mode filter.', 'jetpack' ),
1641
					'https://jetpack.com/support/development-mode/'
1642
				);
1643
			}
1644
1645
			echo '<div class="updated" style="border-color: #f0821e;"><p>' . $notice . '</p></div>';
1646
		}
1647
1648
		// Throw up a notice if using a development version and as for feedback.
1649
		if ( Jetpack::is_development_version() ) {
1650
			/* translators: %s is a URL */
1651
			$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/' );
1652
1653
			echo '<div class="updated" style="border-color: #f0821e;"><p>' . $notice . '</p></div>';
1654
		}
1655
		// Throw up a notice if using staging mode
1656
		if ( Jetpack::is_staging_site() ) {
1657
			/* translators: %s is a URL */
1658
			$notice = sprintf( __( 'You are running Jetpack on a <a href="%s" target="_blank">staging server</a>.', 'jetpack' ), 'https://jetpack.com/support/staging-sites/' );
1659
1660
			echo '<div class="updated" style="border-color: #f0821e;"><p>' . $notice . '</p></div>';
1661
		}
1662
	}
1663
1664
	/**
1665
	 * Whether Jetpack's version maps to a public release, or a development version.
1666
	 */
1667
	public static function is_development_version() {
1668
		/**
1669
		 * Allows filtering whether this is a development version of Jetpack.
1670
		 *
1671
		 * This filter is especially useful for tests.
1672
		 *
1673
		 * @since 4.3.0
1674
		 *
1675
		 * @param bool $development_version Is this a develoment version of Jetpack?
1676
		 */
1677
		return (bool) apply_filters(
1678
			'jetpack_development_version',
1679
			! preg_match( '/^\d+(\.\d+)+$/', Jetpack_Constants::get_constant( 'JETPACK__VERSION' ) )
1680
		);
1681
	}
1682
1683
	/**
1684
	 * Is a given user (or the current user if none is specified) linked to a WordPress.com user?
1685
	 */
1686
	public static function is_user_connected( $user_id = false ) {
1687
		$user_id = false === $user_id ? get_current_user_id() : absint( $user_id );
1688
		if ( ! $user_id ) {
1689
			return false;
1690
		}
1691
1692
		return (bool) Jetpack_Data::get_access_token( $user_id );
1693
	}
1694
1695
	/**
1696
	 * Get the wpcom user data of the current|specified connected user.
1697
	 */
1698
	public static function get_connected_user_data( $user_id = null ) {
1699
		if ( ! $user_id ) {
1700
			$user_id = get_current_user_id();
1701
		}
1702
1703
		$transient_key = "jetpack_connected_user_data_$user_id";
1704
1705
		if ( $cached_user_data = get_transient( $transient_key ) ) {
1706
			return $cached_user_data;
1707
		}
1708
1709
		Jetpack::load_xml_rpc_client();
1710
		$xml = new Jetpack_IXR_Client( array(
1711
			'user_id' => $user_id,
1712
		) );
1713
		$xml->query( 'wpcom.getUser' );
1714
		if ( ! $xml->isError() ) {
1715
			$user_data = $xml->getResponse();
1716
			set_transient( $transient_key, $xml->getResponse(), DAY_IN_SECONDS );
1717
			return $user_data;
1718
		}
1719
1720
		return false;
1721
	}
1722
1723
	/**
1724
	 * Get the wpcom email of the current|specified connected user.
1725
	 */
1726 View Code Duplication
	public static function get_connected_user_email( $user_id = null ) {
1727
		if ( ! $user_id ) {
1728
			$user_id = get_current_user_id();
1729
		}
1730
		Jetpack::load_xml_rpc_client();
1731
		$xml = new Jetpack_IXR_Client( array(
1732
			'user_id' => $user_id,
1733
		) );
1734
		$xml->query( 'wpcom.getUserEmail' );
1735
		if ( ! $xml->isError() ) {
1736
			return $xml->getResponse();
1737
		}
1738
		return false;
1739
	}
1740
1741
	/**
1742
	 * Get the wpcom email of the master user.
1743
	 */
1744
	public static function get_master_user_email() {
1745
		$master_user_id = Jetpack_Options::get_option( 'master_user' );
1746
		if ( $master_user_id ) {
1747
			return self::get_connected_user_email( $master_user_id );
1748
		}
1749
		return '';
1750
	}
1751
1752
	function current_user_is_connection_owner() {
1753
		$user_token = Jetpack_Data::get_access_token( JETPACK_MASTER_USER );
1754
		return $user_token && is_object( $user_token ) && isset( $user_token->external_user_id ) && get_current_user_id() === $user_token->external_user_id;
1755
	}
1756
1757
	/**
1758
	 * Gets current user IP address.
1759
	 *
1760
	 * @param  bool $check_all_headers Check all headers? Default is `false`.
1761
	 *
1762
	 * @return string                  Current user IP address.
1763
	 */
1764
	public static function current_user_ip( $check_all_headers = false ) {
1765
		if ( $check_all_headers ) {
1766
			foreach ( array(
1767
				'HTTP_CF_CONNECTING_IP',
1768
				'HTTP_CLIENT_IP',
1769
				'HTTP_X_FORWARDED_FOR',
1770
				'HTTP_X_FORWARDED',
1771
				'HTTP_X_CLUSTER_CLIENT_IP',
1772
				'HTTP_FORWARDED_FOR',
1773
				'HTTP_FORWARDED',
1774
				'HTTP_VIA',
1775
			) as $key ) {
1776
				if ( ! empty( $_SERVER[ $key ] ) ) {
1777
					return $_SERVER[ $key ];
1778
				}
1779
			}
1780
		}
1781
1782
		return ! empty( $_SERVER['REMOTE_ADDR'] ) ? $_SERVER['REMOTE_ADDR'] : '';
1783
	}
1784
1785
	/**
1786
	 * Add any extra oEmbed providers that we know about and use on wpcom for feature parity.
1787
	 */
1788
	function extra_oembed_providers() {
1789
		// Cloudup: https://dev.cloudup.com/#oembed
1790
		wp_oembed_add_provider( 'https://cloudup.com/*' , 'https://cloudup.com/oembed' );
1791
		wp_oembed_add_provider( 'https://me.sh/*', 'https://me.sh/oembed?format=json' );
1792
		wp_oembed_add_provider( '#https?://(www\.)?gfycat\.com/.*#i', 'https://api.gfycat.com/v1/oembed', true );
1793
		wp_oembed_add_provider( '#https?://[^.]+\.(wistia\.com|wi\.st)/(medias|embed)/.*#', 'https://fast.wistia.com/oembed', true );
1794
		wp_oembed_add_provider( '#https?://sketchfab\.com/.*#i', 'https://sketchfab.com/oembed', true );
1795
		wp_oembed_add_provider( '#https?://(www\.)?icloud\.com/keynote/.*#i', 'https://iwmb.icloud.com/iwmb/oembed', true );
1796
	}
1797
1798
	/**
1799
	 * Synchronize connected user role changes
1800
	 */
1801
	function user_role_change( $user_id ) {
1802
		_deprecated_function( __METHOD__, 'jetpack-4.2', 'Jetpack_Sync_Users::user_role_change()' );
1803
		Jetpack_Sync_Users::user_role_change( $user_id );
1804
	}
1805
1806
	/**
1807
	 * Loads the currently active modules.
1808
	 */
1809
	public static function load_modules() {
1810
		if (
1811
			! self::is_active()
1812
			&& ! self::is_development_mode()
1813
			&& ! self::is_onboarding()
1814
			&& (
1815
				! is_multisite()
1816
				|| ! get_site_option( 'jetpack_protect_active' )
1817
			)
1818
		) {
1819
			return;
1820
		}
1821
1822
		$version = Jetpack_Options::get_option( 'version' );
1823 View Code Duplication
		if ( ! $version ) {
1824
			$version = $old_version = JETPACK__VERSION . ':' . time();
1825
			/** This action is documented in class.jetpack.php */
1826
			do_action( 'updating_jetpack_version', $version, false );
1827
			Jetpack_Options::update_options( compact( 'version', 'old_version' ) );
1828
		}
1829
		list( $version ) = explode( ':', $version );
1830
1831
		$modules = array_filter( Jetpack::get_active_modules(), array( 'Jetpack', 'is_module' ) );
1832
1833
		$modules_data = array();
1834
1835
		// Don't load modules that have had "Major" changes since the stored version until they have been deactivated/reactivated through the lint check.
1836
		if ( version_compare( $version, JETPACK__VERSION, '<' ) ) {
1837
			$updated_modules = array();
1838
			foreach ( $modules as $module ) {
1839
				$modules_data[ $module ] = Jetpack::get_module( $module );
1840
				if ( ! isset( $modules_data[ $module ]['changed'] ) ) {
1841
					continue;
1842
				}
1843
1844
				if ( version_compare( $modules_data[ $module ]['changed'], $version, '<=' ) ) {
1845
					continue;
1846
				}
1847
1848
				$updated_modules[] = $module;
1849
			}
1850
1851
			$modules = array_diff( $modules, $updated_modules );
1852
		}
1853
1854
		$is_development_mode = Jetpack::is_development_mode();
1855
1856
		foreach ( $modules as $index => $module ) {
1857
			// If we're in dev mode, disable modules requiring a connection
1858
			if ( $is_development_mode ) {
1859
				// Prime the pump if we need to
1860
				if ( empty( $modules_data[ $module ] ) ) {
1861
					$modules_data[ $module ] = Jetpack::get_module( $module );
1862
				}
1863
				// If the module requires a connection, but we're in local mode, don't include it.
1864
				if ( $modules_data[ $module ]['requires_connection'] ) {
1865
					continue;
1866
				}
1867
			}
1868
1869
			if ( did_action( 'jetpack_module_loaded_' . $module ) ) {
1870
				continue;
1871
			}
1872
1873
			if ( ! include_once( Jetpack::get_module_path( $module ) ) ) {
1874
				unset( $modules[ $index ] );
1875
				self::update_active_modules( array_values( $modules ) );
1876
				continue;
1877
			}
1878
1879
			/**
1880
			 * Fires when a specific module is loaded.
1881
			 * The dynamic part of the hook, $module, is the module slug.
1882
			 *
1883
			 * @since 1.1.0
1884
			 */
1885
			do_action( 'jetpack_module_loaded_' . $module );
1886
		}
1887
1888
		/**
1889
		 * Fires when all the modules are loaded.
1890
		 *
1891
		 * @since 1.1.0
1892
		 */
1893
		do_action( 'jetpack_modules_loaded' );
1894
1895
		// 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.
1896
		require_once( JETPACK__PLUGIN_DIR . 'modules/module-extras.php' );
1897
	}
1898
1899
	/**
1900
	 * Check if Jetpack's REST API compat file should be included
1901
	 * @action plugins_loaded
1902
	 * @return null
1903
	 */
1904
	public function check_rest_api_compat() {
1905
		/**
1906
		 * Filters the list of REST API compat files to be included.
1907
		 *
1908
		 * @since 2.2.5
1909
		 *
1910
		 * @param array $args Array of REST API compat files to include.
1911
		 */
1912
		$_jetpack_rest_api_compat_includes = apply_filters( 'jetpack_rest_api_compat', array() );
1913
1914
		if ( function_exists( 'bbpress' ) )
1915
			$_jetpack_rest_api_compat_includes[] = JETPACK__PLUGIN_DIR . 'class.jetpack-bbpress-json-api-compat.php';
1916
1917
		foreach ( $_jetpack_rest_api_compat_includes as $_jetpack_rest_api_compat_include )
1918
			require_once $_jetpack_rest_api_compat_include;
1919
	}
1920
1921
	/**
1922
	 * Gets all plugins currently active in values, regardless of whether they're
1923
	 * traditionally activated or network activated.
1924
	 *
1925
	 * @todo Store the result in core's object cache maybe?
1926
	 */
1927
	public static function get_active_plugins() {
1928
		$active_plugins = (array) get_option( 'active_plugins', array() );
1929
1930
		if ( is_multisite() ) {
1931
			// Due to legacy code, active_sitewide_plugins stores them in the keys,
1932
			// whereas active_plugins stores them in the values.
1933
			$network_plugins = array_keys( get_site_option( 'active_sitewide_plugins', array() ) );
1934
			if ( $network_plugins ) {
1935
				$active_plugins = array_merge( $active_plugins, $network_plugins );
1936
			}
1937
		}
1938
1939
		sort( $active_plugins );
1940
1941
		return array_unique( $active_plugins );
1942
	}
1943
1944
	/**
1945
	 * Gets and parses additional plugin data to send with the heartbeat data
1946
	 *
1947
	 * @since 3.8.1
1948
	 *
1949
	 * @return array Array of plugin data
1950
	 */
1951
	public static function get_parsed_plugin_data() {
1952
		if ( ! function_exists( 'get_plugins' ) ) {
1953
			require_once( ABSPATH . 'wp-admin/includes/plugin.php' );
1954
		}
1955
		/** This filter is documented in wp-admin/includes/class-wp-plugins-list-table.php */
1956
		$all_plugins    = apply_filters( 'all_plugins', get_plugins() );
1957
		$active_plugins = Jetpack::get_active_plugins();
1958
1959
		$plugins = array();
1960
		foreach ( $all_plugins as $path => $plugin_data ) {
1961
			$plugins[ $path ] = array(
1962
					'is_active' => in_array( $path, $active_plugins ),
1963
					'file'      => $path,
1964
					'name'      => $plugin_data['Name'],
1965
					'version'   => $plugin_data['Version'],
1966
					'author'    => $plugin_data['Author'],
1967
			);
1968
		}
1969
1970
		return $plugins;
1971
	}
1972
1973
	/**
1974
	 * Gets and parses theme data to send with the heartbeat data
1975
	 *
1976
	 * @since 3.8.1
1977
	 *
1978
	 * @return array Array of theme data
1979
	 */
1980
	public static function get_parsed_theme_data() {
1981
		$all_themes = wp_get_themes( array( 'allowed' => true ) );
1982
		$header_keys = array( 'Name', 'Author', 'Version', 'ThemeURI', 'AuthorURI', 'Status', 'Tags' );
1983
1984
		$themes = array();
1985
		foreach ( $all_themes as $slug => $theme_data ) {
1986
			$theme_headers = array();
1987
			foreach ( $header_keys as $header_key ) {
1988
				$theme_headers[ $header_key ] = $theme_data->get( $header_key );
1989
			}
1990
1991
			$themes[ $slug ] = array(
1992
					'is_active_theme' => $slug == wp_get_theme()->get_template(),
1993
					'slug' => $slug,
1994
					'theme_root' => $theme_data->get_theme_root_uri(),
1995
					'parent' => $theme_data->parent(),
1996
					'headers' => $theme_headers
1997
			);
1998
		}
1999
2000
		return $themes;
2001
	}
2002
2003
	/**
2004
	 * Checks whether a specific plugin is active.
2005
	 *
2006
	 * We don't want to store these in a static variable, in case
2007
	 * there are switch_to_blog() calls involved.
2008
	 */
2009
	public static function is_plugin_active( $plugin = 'jetpack/jetpack.php' ) {
2010
		return in_array( $plugin, self::get_active_plugins() );
2011
	}
2012
2013
	/**
2014
	 * Check if Jetpack's Open Graph tags should be used.
2015
	 * If certain plugins are active, Jetpack's og tags are suppressed.
2016
	 *
2017
	 * @uses Jetpack::get_active_modules, add_filter, get_option, apply_filters
2018
	 * @action plugins_loaded
2019
	 * @return null
2020
	 */
2021
	public function check_open_graph() {
2022
		if ( in_array( 'publicize', Jetpack::get_active_modules() ) || in_array( 'sharedaddy', Jetpack::get_active_modules() ) ) {
2023
			add_filter( 'jetpack_enable_open_graph', '__return_true', 0 );
2024
		}
2025
2026
		$active_plugins = self::get_active_plugins();
2027
2028
		if ( ! empty( $active_plugins ) ) {
2029
			foreach ( $this->open_graph_conflicting_plugins as $plugin ) {
2030
				if ( in_array( $plugin, $active_plugins ) ) {
2031
					add_filter( 'jetpack_enable_open_graph', '__return_false', 99 );
2032
					break;
2033
				}
2034
			}
2035
		}
2036
2037
		/**
2038
		 * Allow the addition of Open Graph Meta Tags to all pages.
2039
		 *
2040
		 * @since 2.0.3
2041
		 *
2042
		 * @param bool false Should Open Graph Meta tags be added. Default to false.
2043
		 */
2044
		if ( apply_filters( 'jetpack_enable_open_graph', false ) ) {
2045
			require_once JETPACK__PLUGIN_DIR . 'functions.opengraph.php';
2046
		}
2047
	}
2048
2049
	/**
2050
	 * Check if Jetpack's Twitter tags should be used.
2051
	 * If certain plugins are active, Jetpack's twitter tags are suppressed.
2052
	 *
2053
	 * @uses Jetpack::get_active_modules, add_filter, get_option, apply_filters
2054
	 * @action plugins_loaded
2055
	 * @return null
2056
	 */
2057
	public function check_twitter_tags() {
2058
2059
		$active_plugins = self::get_active_plugins();
2060
2061
		if ( ! empty( $active_plugins ) ) {
2062
			foreach ( $this->twitter_cards_conflicting_plugins as $plugin ) {
2063
				if ( in_array( $plugin, $active_plugins ) ) {
2064
					add_filter( 'jetpack_disable_twitter_cards', '__return_true', 99 );
2065
					break;
2066
				}
2067
			}
2068
		}
2069
2070
		/**
2071
		 * Allow Twitter Card Meta tags to be disabled.
2072
		 *
2073
		 * @since 2.6.0
2074
		 *
2075
		 * @param bool true Should Twitter Card Meta tags be disabled. Default to true.
2076
		 */
2077
		if ( ! apply_filters( 'jetpack_disable_twitter_cards', false ) ) {
2078
			require_once JETPACK__PLUGIN_DIR . 'class.jetpack-twitter-cards.php';
2079
		}
2080
	}
2081
2082
	/**
2083
	 * Allows plugins to submit security reports.
2084
 	 *
2085
	 * @param string  $type         Report type (login_form, backup, file_scanning, spam)
2086
	 * @param string  $plugin_file  Plugin __FILE__, so that we can pull plugin data
2087
	 * @param array   $args         See definitions above
2088
	 */
2089
	public static function submit_security_report( $type = '', $plugin_file = '', $args = array() ) {
2090
		_deprecated_function( __FUNCTION__, 'jetpack-4.2', null );
2091
	}
2092
2093
/* Jetpack Options API */
2094
2095
	public static function get_option_names( $type = 'compact' ) {
2096
		return Jetpack_Options::get_option_names( $type );
2097
	}
2098
2099
	/**
2100
	 * Returns the requested option.  Looks in jetpack_options or jetpack_$name as appropriate.
2101
 	 *
2102
	 * @param string $name    Option name
2103
	 * @param mixed  $default (optional)
2104
	 */
2105
	public static function get_option( $name, $default = false ) {
2106
		return Jetpack_Options::get_option( $name, $default );
2107
	}
2108
2109
	/**
2110
	 * Updates the single given option.  Updates jetpack_options or jetpack_$name as appropriate.
2111
 	 *
2112
	 * @deprecated 3.4 use Jetpack_Options::update_option() instead.
2113
	 * @param string $name  Option name
2114
	 * @param mixed  $value Option value
2115
	 */
2116
	public static function update_option( $name, $value ) {
2117
		_deprecated_function( __METHOD__, 'jetpack-3.4', 'Jetpack_Options::update_option()' );
2118
		return Jetpack_Options::update_option( $name, $value );
2119
	}
2120
2121
	/**
2122
	 * Updates the multiple given options.  Updates jetpack_options and/or jetpack_$name as appropriate.
2123
 	 *
2124
	 * @deprecated 3.4 use Jetpack_Options::update_options() instead.
2125
	 * @param array $array array( option name => option value, ... )
2126
	 */
2127
	public static function update_options( $array ) {
2128
		_deprecated_function( __METHOD__, 'jetpack-3.4', 'Jetpack_Options::update_options()' );
2129
		return Jetpack_Options::update_options( $array );
2130
	}
2131
2132
	/**
2133
	 * Deletes the given option.  May be passed multiple option names as an array.
2134
	 * Updates jetpack_options and/or deletes jetpack_$name as appropriate.
2135
	 *
2136
	 * @deprecated 3.4 use Jetpack_Options::delete_option() instead.
2137
	 * @param string|array $names
2138
	 */
2139
	public static function delete_option( $names ) {
2140
		_deprecated_function( __METHOD__, 'jetpack-3.4', 'Jetpack_Options::delete_option()' );
2141
		return Jetpack_Options::delete_option( $names );
2142
	}
2143
2144
	/**
2145
	 * Enters a user token into the user_tokens option
2146
	 *
2147
	 * @param int $user_id
2148
	 * @param string $token
2149
	 * return bool
2150
	 */
2151
	public static function update_user_token( $user_id, $token, $is_master_user ) {
2152
		// not designed for concurrent updates
2153
		$user_tokens = Jetpack_Options::get_option( 'user_tokens' );
2154
		if ( ! is_array( $user_tokens ) )
2155
			$user_tokens = array();
2156
		$user_tokens[$user_id] = $token;
2157
		if ( $is_master_user ) {
2158
			$master_user = $user_id;
2159
			$options     = compact( 'user_tokens', 'master_user' );
2160
		} else {
2161
			$options = compact( 'user_tokens' );
2162
		}
2163
		return Jetpack_Options::update_options( $options );
2164
	}
2165
2166
	/**
2167
	 * Returns an array of all PHP files in the specified absolute path.
2168
	 * Equivalent to glob( "$absolute_path/*.php" ).
2169
	 *
2170
	 * @param string $absolute_path The absolute path of the directory to search.
2171
	 * @return array Array of absolute paths to the PHP files.
2172
	 */
2173
	public static function glob_php( $absolute_path ) {
2174
		if ( function_exists( 'glob' ) ) {
2175
			return glob( "$absolute_path/*.php" );
2176
		}
2177
2178
		$absolute_path = untrailingslashit( $absolute_path );
2179
		$files = array();
2180
		if ( ! $dir = @opendir( $absolute_path ) ) {
2181
			return $files;
2182
		}
2183
2184
		while ( false !== $file = readdir( $dir ) ) {
2185
			if ( '.' == substr( $file, 0, 1 ) || '.php' != substr( $file, -4 ) ) {
2186
				continue;
2187
			}
2188
2189
			$file = "$absolute_path/$file";
2190
2191
			if ( ! is_file( $file ) ) {
2192
				continue;
2193
			}
2194
2195
			$files[] = $file;
2196
		}
2197
2198
		closedir( $dir );
2199
2200
		return $files;
2201
	}
2202
2203
	public static function activate_new_modules( $redirect = false ) {
2204
		if ( ! Jetpack::is_active() && ! Jetpack::is_development_mode() ) {
2205
			return;
2206
		}
2207
2208
		$jetpack_old_version = Jetpack_Options::get_option( 'version' ); // [sic]
2209 View Code Duplication
		if ( ! $jetpack_old_version ) {
2210
			$jetpack_old_version = $version = $old_version = '1.1:' . time();
2211
			/** This action is documented in class.jetpack.php */
2212
			do_action( 'updating_jetpack_version', $version, false );
2213
			Jetpack_Options::update_options( compact( 'version', 'old_version' ) );
2214
		}
2215
2216
		list( $jetpack_version ) = explode( ':', $jetpack_old_version ); // [sic]
2217
2218
		if ( version_compare( JETPACK__VERSION, $jetpack_version, '<=' ) ) {
2219
			return;
2220
		}
2221
2222
		$active_modules     = Jetpack::get_active_modules();
2223
		$reactivate_modules = array();
2224
		foreach ( $active_modules as $active_module ) {
2225
			$module = Jetpack::get_module( $active_module );
2226
			if ( ! isset( $module['changed'] ) ) {
2227
				continue;
2228
			}
2229
2230
			if ( version_compare( $module['changed'], $jetpack_version, '<=' ) ) {
2231
				continue;
2232
			}
2233
2234
			$reactivate_modules[] = $active_module;
2235
			Jetpack::deactivate_module( $active_module );
2236
		}
2237
2238
		$new_version = JETPACK__VERSION . ':' . time();
2239
		/** This action is documented in class.jetpack.php */
2240
		do_action( 'updating_jetpack_version', $new_version, $jetpack_old_version );
2241
		Jetpack_Options::update_options(
2242
			array(
2243
				'version'     => $new_version,
2244
				'old_version' => $jetpack_old_version,
2245
			)
2246
		);
2247
2248
		Jetpack::state( 'message', 'modules_activated' );
2249
		Jetpack::activate_default_modules( $jetpack_version, JETPACK__VERSION, $reactivate_modules );
2250
2251
		if ( $redirect ) {
2252
			$page = 'jetpack'; // make sure we redirect to either settings or the jetpack page
2253
			if ( isset( $_GET['page'] ) && in_array( $_GET['page'], array( 'jetpack', 'jetpack_modules' ) ) ) {
2254
				$page = $_GET['page'];
2255
			}
2256
2257
			wp_safe_redirect( Jetpack::admin_url( 'page=' . $page ) );
2258
			exit;
2259
		}
2260
	}
2261
2262
	/**
2263
	 * List available Jetpack modules. Simply lists .php files in /modules/.
2264
	 * Make sure to tuck away module "library" files in a sub-directory.
2265
	 */
2266
	public static function get_available_modules( $min_version = false, $max_version = false ) {
2267
		static $modules = null;
2268
2269
		if ( ! isset( $modules ) ) {
2270
			$available_modules_option = Jetpack_Options::get_option( 'available_modules', array() );
2271
			// Use the cache if we're on the front-end and it's available...
2272
			if ( ! is_admin() && ! empty( $available_modules_option[ JETPACK__VERSION ] ) ) {
2273
				$modules = $available_modules_option[ JETPACK__VERSION ];
2274
			} else {
2275
				$files = Jetpack::glob_php( JETPACK__PLUGIN_DIR . 'modules' );
2276
2277
				$modules = array();
2278
2279
				foreach ( $files as $file ) {
2280
					if ( ! $headers = Jetpack::get_module( $file ) ) {
2281
						continue;
2282
					}
2283
2284
					$modules[ Jetpack::get_module_slug( $file ) ] = $headers['introduced'];
2285
				}
2286
2287
				Jetpack_Options::update_option( 'available_modules', array(
2288
					JETPACK__VERSION => $modules,
2289
				) );
2290
			}
2291
		}
2292
2293
		/**
2294
		 * Filters the array of modules available to be activated.
2295
		 *
2296
		 * @since 2.4.0
2297
		 *
2298
		 * @param array $modules Array of available modules.
2299
		 * @param string $min_version Minimum version number required to use modules.
2300
		 * @param string $max_version Maximum version number required to use modules.
2301
		 */
2302
		$mods = apply_filters( 'jetpack_get_available_modules', $modules, $min_version, $max_version );
2303
2304
		if ( ! $min_version && ! $max_version ) {
2305
			return array_keys( $mods );
2306
		}
2307
2308
		$r = array();
2309
		foreach ( $mods as $slug => $introduced ) {
2310
			if ( $min_version && version_compare( $min_version, $introduced, '>=' ) ) {
2311
				continue;
2312
			}
2313
2314
			if ( $max_version && version_compare( $max_version, $introduced, '<' ) ) {
2315
				continue;
2316
			}
2317
2318
			$r[] = $slug;
2319
		}
2320
2321
		return $r;
2322
	}
2323
2324
	/**
2325
	 * Default modules loaded on activation.
2326
	 */
2327
	public static function get_default_modules( $min_version = false, $max_version = false ) {
2328
		$return = array();
2329
2330
		foreach ( Jetpack::get_available_modules( $min_version, $max_version ) as $module ) {
2331
			$module_data = Jetpack::get_module( $module );
2332
2333
			switch ( strtolower( $module_data['auto_activate'] ) ) {
2334
				case 'yes' :
2335
					$return[] = $module;
2336
					break;
2337
				case 'public' :
2338
					if ( Jetpack_Options::get_option( 'public' ) ) {
2339
						$return[] = $module;
2340
					}
2341
					break;
2342
				case 'no' :
2343
				default :
2344
					break;
2345
			}
2346
		}
2347
		/**
2348
		 * Filters the array of default modules.
2349
		 *
2350
		 * @since 2.5.0
2351
		 *
2352
		 * @param array $return Array of default modules.
2353
		 * @param string $min_version Minimum version number required to use modules.
2354
		 * @param string $max_version Maximum version number required to use modules.
2355
		 */
2356
		return apply_filters( 'jetpack_get_default_modules', $return, $min_version, $max_version );
2357
	}
2358
2359
	/**
2360
	 * Checks activated modules during auto-activation to determine
2361
	 * if any of those modules are being deprecated.  If so, close
2362
	 * them out, and add any replacement modules.
2363
	 *
2364
	 * Runs at priority 99 by default.
2365
	 *
2366
	 * This is run late, so that it can still activate a module if
2367
	 * the new module is a replacement for another that the user
2368
	 * currently has active, even if something at the normal priority
2369
	 * would kibosh everything.
2370
	 *
2371
	 * @since 2.6
2372
	 * @uses jetpack_get_default_modules filter
2373
	 * @param array $modules
2374
	 * @return array
2375
	 */
2376
	function handle_deprecated_modules( $modules ) {
2377
		$deprecated_modules = array(
2378
			'debug'            => null,  // Closed out and moved to ./class.jetpack-debugger.php
2379
			'wpcc'             => 'sso', // Closed out in 2.6 -- SSO provides the same functionality.
2380
			'gplus-authorship' => null,  // Closed out in 3.2 -- Google dropped support.
2381
		);
2382
2383
		// Don't activate SSO if they never completed activating WPCC.
2384
		if ( Jetpack::is_module_active( 'wpcc' ) ) {
2385
			$wpcc_options = Jetpack_Options::get_option( 'wpcc_options' );
2386
			if ( empty( $wpcc_options ) || empty( $wpcc_options['client_id'] ) || empty( $wpcc_options['client_id'] ) ) {
2387
				$deprecated_modules['wpcc'] = null;
2388
			}
2389
		}
2390
2391
		foreach ( $deprecated_modules as $module => $replacement ) {
2392
			if ( Jetpack::is_module_active( $module ) ) {
2393
				self::deactivate_module( $module );
2394
				if ( $replacement ) {
2395
					$modules[] = $replacement;
2396
				}
2397
			}
2398
		}
2399
2400
		return array_unique( $modules );
2401
	}
2402
2403
	/**
2404
	 * Checks activated plugins during auto-activation to determine
2405
	 * if any of those plugins are in the list with a corresponding module
2406
	 * that is not compatible with the plugin. The module will not be allowed
2407
	 * to auto-activate.
2408
	 *
2409
	 * @since 2.6
2410
	 * @uses jetpack_get_default_modules filter
2411
	 * @param array $modules
2412
	 * @return array
2413
	 */
2414
	function filter_default_modules( $modules ) {
2415
2416
		$active_plugins = self::get_active_plugins();
2417
2418
		if ( ! empty( $active_plugins ) ) {
2419
2420
			// For each module we'd like to auto-activate...
2421
			foreach ( $modules as $key => $module ) {
2422
				// If there are potential conflicts for it...
2423
				if ( ! empty( $this->conflicting_plugins[ $module ] ) ) {
2424
					// For each potential conflict...
2425
					foreach ( $this->conflicting_plugins[ $module ] as $title => $plugin ) {
2426
						// If that conflicting plugin is active...
2427
						if ( in_array( $plugin, $active_plugins ) ) {
2428
							// Remove that item from being auto-activated.
2429
							unset( $modules[ $key ] );
2430
						}
2431
					}
2432
				}
2433
			}
2434
		}
2435
2436
		return $modules;
2437
	}
2438
2439
	/**
2440
	 * Extract a module's slug from its full path.
2441
	 */
2442
	public static function get_module_slug( $file ) {
2443
		return str_replace( '.php', '', basename( $file ) );
2444
	}
2445
2446
	/**
2447
	 * Generate a module's path from its slug.
2448
	 */
2449
	public static function get_module_path( $slug ) {
2450
		return JETPACK__PLUGIN_DIR . "modules/$slug.php";
2451
	}
2452
2453
	/**
2454
	 * Load module data from module file. Headers differ from WordPress
2455
	 * plugin headers to avoid them being identified as standalone
2456
	 * plugins on the WordPress plugins page.
2457
	 */
2458
	public static function get_module( $module ) {
2459
		$headers = array(
2460
			'name'                      => 'Module Name',
2461
			'description'               => 'Module Description',
2462
			'jumpstart_desc'            => 'Jumpstart Description',
2463
			'sort'                      => 'Sort Order',
2464
			'recommendation_order'      => 'Recommendation Order',
2465
			'introduced'                => 'First Introduced',
2466
			'changed'                   => 'Major Changes In',
2467
			'deactivate'                => 'Deactivate',
2468
			'free'                      => 'Free',
2469
			'requires_connection'       => 'Requires Connection',
2470
			'auto_activate'             => 'Auto Activate',
2471
			'module_tags'               => 'Module Tags',
2472
			'feature'                   => 'Feature',
2473
			'additional_search_queries' => 'Additional Search Queries',
2474
			'plan_classes'              => 'Plans',
2475
		);
2476
2477
		$file = Jetpack::get_module_path( Jetpack::get_module_slug( $module ) );
2478
2479
		$mod = Jetpack::get_file_data( $file, $headers );
2480
		if ( empty( $mod['name'] ) ) {
2481
			return false;
2482
		}
2483
2484
		$mod['sort']                    = empty( $mod['sort'] ) ? 10 : (int) $mod['sort'];
2485
		$mod['recommendation_order']    = empty( $mod['recommendation_order'] ) ? 20 : (int) $mod['recommendation_order'];
2486
		$mod['deactivate']              = empty( $mod['deactivate'] );
2487
		$mod['free']                    = empty( $mod['free'] );
2488
		$mod['requires_connection']     = ( ! empty( $mod['requires_connection'] ) && 'No' == $mod['requires_connection'] ) ? false : true;
2489
2490
		if ( empty( $mod['auto_activate'] ) || ! in_array( strtolower( $mod['auto_activate'] ), array( 'yes', 'no', 'public' ) ) ) {
2491
			$mod['auto_activate'] = 'No';
2492
		} else {
2493
			$mod['auto_activate'] = (string) $mod['auto_activate'];
2494
		}
2495
2496
		if ( $mod['module_tags'] ) {
2497
			$mod['module_tags'] = explode( ',', $mod['module_tags'] );
2498
			$mod['module_tags'] = array_map( 'trim', $mod['module_tags'] );
2499
			$mod['module_tags'] = array_map( array( __CLASS__, 'translate_module_tag' ), $mod['module_tags'] );
2500
		} else {
2501
			$mod['module_tags'] = array( self::translate_module_tag( 'Other' ) );
2502
		}
2503
2504 View Code Duplication
		if ( $mod['plan_classes'] ) {
2505
			$mod['plan_classes'] = explode( ',', $mod['plan_classes'] );
2506
			$mod['plan_classes'] = array_map( 'strtolower', array_map( 'trim', $mod['plan_classes'] ) );
2507
		} else {
2508
			$mod['plan_classes'] = array( 'free' );
2509
		}
2510
2511 View Code Duplication
		if ( $mod['feature'] ) {
2512
			$mod['feature'] = explode( ',', $mod['feature'] );
2513
			$mod['feature'] = array_map( 'trim', $mod['feature'] );
2514
		} else {
2515
			$mod['feature'] = array( self::translate_module_tag( 'Other' ) );
2516
		}
2517
2518
		/**
2519
		 * Filters the feature array on a module.
2520
		 *
2521
		 * This filter allows you to control where each module is filtered: Recommended,
2522
		 * Jumpstart, and the default "Other" listing.
2523
		 *
2524
		 * @since 3.5.0
2525
		 *
2526
		 * @param array   $mod['feature'] The areas to feature this module:
2527
		 *     'Jumpstart' adds to the "Jumpstart" option to activate many modules at once.
2528
		 *     'Recommended' shows on the main Jetpack admin screen.
2529
		 *     'Other' should be the default if no other value is in the array.
2530
		 * @param string  $module The slug of the module, e.g. sharedaddy.
2531
		 * @param array   $mod All the currently assembled module data.
2532
		 */
2533
		$mod['feature'] = apply_filters( 'jetpack_module_feature', $mod['feature'], $module, $mod );
2534
2535
		/**
2536
		 * Filter the returned data about a module.
2537
		 *
2538
		 * This filter allows overriding any info about Jetpack modules. It is dangerous,
2539
		 * so please be careful.
2540
		 *
2541
		 * @since 3.6.0
2542
		 *
2543
		 * @param array   $mod    The details of the requested module.
2544
		 * @param string  $module The slug of the module, e.g. sharedaddy
2545
		 * @param string  $file   The path to the module source file.
2546
		 */
2547
		return apply_filters( 'jetpack_get_module', $mod, $module, $file );
2548
	}
2549
2550
	/**
2551
	 * Like core's get_file_data implementation, but caches the result.
2552
	 */
2553
	public static function get_file_data( $file, $headers ) {
2554
		//Get just the filename from $file (i.e. exclude full path) so that a consistent hash is generated
2555
		$file_name = basename( $file );
2556
2557
		$cache_key = 'jetpack_file_data_' . JETPACK__VERSION;
2558
2559
		$file_data_option = get_transient( $cache_key );
2560
2561
		if ( false === $file_data_option ) {
2562
			$file_data_option = array();
2563
		}
2564
2565
		$key           = md5( $file_name . serialize( $headers ) );
2566
		$refresh_cache = is_admin() && isset( $_GET['page'] ) && 'jetpack' === substr( $_GET['page'], 0, 7 );
2567
2568
		// If we don't need to refresh the cache, and already have the value, short-circuit!
2569
		if ( ! $refresh_cache && isset( $file_data_option[ $key ] ) ) {
2570
			return $file_data_option[ $key ];
2571
		}
2572
2573
		$data = get_file_data( $file, $headers );
2574
2575
		$file_data_option[ $key ] = $data;
2576
2577
		set_transient( $cache_key, $file_data_option, 29 * DAY_IN_SECONDS );
2578
2579
		return $data;
2580
	}
2581
2582
2583
	/**
2584
	 * Return translated module tag.
2585
	 *
2586
	 * @param string $tag Tag as it appears in each module heading.
2587
	 *
2588
	 * @return mixed
2589
	 */
2590
	public static function translate_module_tag( $tag ) {
2591
		return jetpack_get_module_i18n_tag( $tag );
2592
	}
2593
2594
	/**
2595
	 * Get i18n strings as a JSON-encoded string
2596
	 *
2597
	 * @return string The locale as JSON
2598
	 */
2599
	public static function get_i18n_data_json() {
2600
		$i18n_json = JETPACK__PLUGIN_DIR . 'languages/json/jetpack-' . jetpack_get_user_locale() . '.json';
2601
2602
		if ( is_file( $i18n_json ) && is_readable( $i18n_json ) ) {
2603
			$locale_data = @file_get_contents( $i18n_json );
2604
			if ( $locale_data ) {
2605
				return $locale_data;
2606
			}
2607
		}
2608
2609
		// Return valid empty Jed locale
2610
		return json_encode( array(
2611
			'' => array(
2612
				'domain' => 'jetpack',
2613
				'lang'   => is_admin() ? get_user_locale() : get_locale(),
2614
			),
2615
		) );
2616
	}
2617
2618
	/**
2619
	 * Return module name translation. Uses matching string created in modules/module-headings.php.
2620
	 *
2621
	 * @since 3.9.2
2622
	 *
2623
	 * @param array $modules
2624
	 *
2625
	 * @return string|void
2626
	 */
2627
	public static function get_translated_modules( $modules ) {
2628
		foreach ( $modules as $index => $module ) {
2629
			$i18n_module = jetpack_get_module_i18n( $module['module'] );
2630
			if ( isset( $module['name'] ) ) {
2631
				$modules[ $index ]['name'] = $i18n_module['name'];
2632
			}
2633
			if ( isset( $module['description'] ) ) {
2634
				$modules[ $index ]['description'] = $i18n_module['description'];
2635
				$modules[ $index ]['short_description'] = $i18n_module['description'];
2636
			}
2637
		}
2638
		return $modules;
2639
	}
2640
2641
	/**
2642
	 * Get a list of activated modules as an array of module slugs.
2643
	 */
2644
	public static function get_active_modules() {
2645
		$active = Jetpack_Options::get_option( 'active_modules' );
2646
2647
		if ( ! is_array( $active ) ) {
2648
			$active = array();
2649
		}
2650
2651
		if ( class_exists( 'VaultPress' ) || function_exists( 'vaultpress_contact_service' ) ) {
2652
			$active[] = 'vaultpress';
2653
		} else {
2654
			$active = array_diff( $active, array( 'vaultpress' ) );
2655
		}
2656
2657
		//If protect is active on the main site of a multisite, it should be active on all sites.
2658
		if ( ! in_array( 'protect', $active ) && is_multisite() && get_site_option( 'jetpack_protect_active' ) ) {
2659
			$active[] = 'protect';
2660
		}
2661
2662
		/**
2663
		 * Allow filtering of the active modules.
2664
		 *
2665
		 * Gives theme and plugin developers the power to alter the modules that
2666
		 * are activated on the fly.
2667
		 *
2668
		 * @since 5.8.0
2669
		 *
2670
		 * @param array $active Array of active module slugs.
2671
		 */
2672
		$active = apply_filters( 'jetpack_active_modules', $active );
2673
2674
		return array_unique( $active );
2675
	}
2676
2677
	/**
2678
	 * Check whether or not a Jetpack module is active.
2679
	 *
2680
	 * @param string $module The slug of a Jetpack module.
2681
	 * @return bool
2682
	 *
2683
	 * @static
2684
	 */
2685
	public static function is_module_active( $module ) {
2686
		return in_array( $module, self::get_active_modules() );
2687
	}
2688
2689
	public static function is_module( $module ) {
2690
		return ! empty( $module ) && ! validate_file( $module, Jetpack::get_available_modules() );
2691
	}
2692
2693
	/**
2694
	 * Catches PHP errors.  Must be used in conjunction with output buffering.
2695
	 *
2696
	 * @param bool $catch True to start catching, False to stop.
2697
	 *
2698
	 * @static
2699
	 */
2700
	public static function catch_errors( $catch ) {
2701
		static $display_errors, $error_reporting;
2702
2703
		if ( $catch ) {
2704
			$display_errors  = @ini_set( 'display_errors', 1 );
2705
			$error_reporting = @error_reporting( E_ALL );
2706
			add_action( 'shutdown', array( 'Jetpack', 'catch_errors_on_shutdown' ), 0 );
2707
		} else {
2708
			@ini_set( 'display_errors', $display_errors );
2709
			@error_reporting( $error_reporting );
2710
			remove_action( 'shutdown', array( 'Jetpack', 'catch_errors_on_shutdown' ), 0 );
2711
		}
2712
	}
2713
2714
	/**
2715
	 * Saves any generated PHP errors in ::state( 'php_errors', {errors} )
2716
	 */
2717
	public static function catch_errors_on_shutdown() {
2718
		Jetpack::state( 'php_errors', self::alias_directories( ob_get_clean() ) );
2719
	}
2720
2721
	/**
2722
	 * Rewrite any string to make paths easier to read.
2723
	 *
2724
	 * Rewrites ABSPATH (eg `/home/jetpack/wordpress/`) to ABSPATH, and if WP_CONTENT_DIR
2725
	 * is located outside of ABSPATH, rewrites that to WP_CONTENT_DIR.
2726
	 *
2727
	 * @param $string
2728
	 * @return mixed
2729
	 */
2730
	public static function alias_directories( $string ) {
2731
		// ABSPATH has a trailing slash.
2732
		$string = str_replace( ABSPATH, 'ABSPATH/', $string );
2733
		// WP_CONTENT_DIR does not have a trailing slash.
2734
		$string = str_replace( WP_CONTENT_DIR, 'WP_CONTENT_DIR', $string );
2735
2736
		return $string;
2737
	}
2738
2739
	public static function activate_default_modules(
2740
		$min_version = false,
2741
		$max_version = false,
2742
		$other_modules = array(),
2743
		$redirect = true,
2744
		$send_state_messages = true
2745
	) {
2746
		$jetpack = Jetpack::init();
2747
2748
		$modules = Jetpack::get_default_modules( $min_version, $max_version );
2749
		$modules = array_merge( $other_modules, $modules );
2750
2751
		// Look for standalone plugins and disable if active.
2752
2753
		$to_deactivate = array();
2754
		foreach ( $modules as $module ) {
2755
			if ( isset( $jetpack->plugins_to_deactivate[$module] ) ) {
2756
				$to_deactivate[$module] = $jetpack->plugins_to_deactivate[$module];
2757
			}
2758
		}
2759
2760
		$deactivated = array();
2761
		foreach ( $to_deactivate as $module => $deactivate_me ) {
2762
			list( $probable_file, $probable_title ) = $deactivate_me;
2763
			if ( Jetpack_Client_Server::deactivate_plugin( $probable_file, $probable_title ) ) {
2764
				$deactivated[] = $module;
2765
			}
2766
		}
2767
2768
		if ( $deactivated && $redirect ) {
2769
			Jetpack::state( 'deactivated_plugins', join( ',', $deactivated ) );
2770
2771
			$url = add_query_arg(
2772
				array(
2773
					'action'   => 'activate_default_modules',
2774
					'_wpnonce' => wp_create_nonce( 'activate_default_modules' ),
2775
				),
2776
				add_query_arg( compact( 'min_version', 'max_version', 'other_modules' ), Jetpack::admin_url( 'page=jetpack' ) )
2777
			);
2778
			wp_safe_redirect( $url );
2779
			exit;
2780
		}
2781
2782
		/**
2783
		 * Fires before default modules are activated.
2784
		 *
2785
		 * @since 1.9.0
2786
		 *
2787
		 * @param string $min_version Minimum version number required to use modules.
2788
		 * @param string $max_version Maximum version number required to use modules.
2789
		 * @param array $other_modules Array of other modules to activate alongside the default modules.
2790
		 */
2791
		do_action( 'jetpack_before_activate_default_modules', $min_version, $max_version, $other_modules );
2792
2793
		// Check each module for fatal errors, a la wp-admin/plugins.php::activate before activating
2794
		Jetpack::restate();
2795
		Jetpack::catch_errors( true );
2796
2797
		$active = Jetpack::get_active_modules();
2798
2799
		foreach ( $modules as $module ) {
2800
			if ( did_action( "jetpack_module_loaded_$module" ) ) {
2801
				$active[] = $module;
2802
				self::update_active_modules( $active );
2803
				continue;
2804
			}
2805
2806
			if ( $send_state_messages && in_array( $module, $active ) ) {
2807
				$module_info = Jetpack::get_module( $module );
2808 View Code Duplication
				if ( ! $module_info['deactivate'] ) {
2809
					$state = in_array( $module, $other_modules ) ? 'reactivated_modules' : 'activated_modules';
2810
					if ( $active_state = Jetpack::state( $state ) ) {
2811
						$active_state = explode( ',', $active_state );
2812
					} else {
2813
						$active_state = array();
2814
					}
2815
					$active_state[] = $module;
2816
					Jetpack::state( $state, implode( ',', $active_state ) );
2817
				}
2818
				continue;
2819
			}
2820
2821
			$file = Jetpack::get_module_path( $module );
2822
			if ( ! file_exists( $file ) ) {
2823
				continue;
2824
			}
2825
2826
			// we'll override this later if the plugin can be included without fatal error
2827
			if ( $redirect ) {
2828
				wp_safe_redirect( Jetpack::admin_url( 'page=jetpack' ) );
2829
			}
2830
2831
			if ( $send_state_messages ) {
2832
				Jetpack::state( 'error', 'module_activation_failed' );
2833
				Jetpack::state( 'module', $module );
2834
			}
2835
2836
			ob_start();
2837
			require_once $file;
2838
2839
			$active[] = $module;
2840
2841 View Code Duplication
			if ( $send_state_messages ) {
2842
2843
				$state    = in_array( $module, $other_modules ) ? 'reactivated_modules' : 'activated_modules';
2844
				if ( $active_state = Jetpack::state( $state ) ) {
2845
					$active_state = explode( ',', $active_state );
2846
				} else {
2847
					$active_state = array();
2848
				}
2849
				$active_state[] = $module;
2850
				Jetpack::state( $state, implode( ',', $active_state ) );
2851
			}
2852
2853
			Jetpack::update_active_modules( $active );
2854
2855
			ob_end_clean();
2856
		}
2857
2858
		if ( $send_state_messages ) {
2859
			Jetpack::state( 'error', false );
2860
			Jetpack::state( 'module', false );
2861
		}
2862
2863
		Jetpack::catch_errors( false );
2864
		/**
2865
		 * Fires when default modules are activated.
2866
		 *
2867
		 * @since 1.9.0
2868
		 *
2869
		 * @param string $min_version Minimum version number required to use modules.
2870
		 * @param string $max_version Maximum version number required to use modules.
2871
		 * @param array $other_modules Array of other modules to activate alongside the default modules.
2872
		 */
2873
		do_action( 'jetpack_activate_default_modules', $min_version, $max_version, $other_modules );
2874
	}
2875
2876
	public static function activate_module( $module, $exit = true, $redirect = true ) {
2877
		/**
2878
		 * Fires before a module is activated.
2879
		 *
2880
		 * @since 2.6.0
2881
		 *
2882
		 * @param string $module Module slug.
2883
		 * @param bool $exit Should we exit after the module has been activated. Default to true.
2884
		 * @param bool $redirect Should the user be redirected after module activation? Default to true.
2885
		 */
2886
		do_action( 'jetpack_pre_activate_module', $module, $exit, $redirect );
2887
2888
		$jetpack = Jetpack::init();
2889
2890
		if ( ! strlen( $module ) )
2891
			return false;
2892
2893
		if ( ! Jetpack::is_module( $module ) )
2894
			return false;
2895
2896
		// If it's already active, then don't do it again
2897
		$active = Jetpack::get_active_modules();
2898
		foreach ( $active as $act ) {
2899
			if ( $act == $module )
2900
				return true;
2901
		}
2902
2903
		$module_data = Jetpack::get_module( $module );
2904
2905
		if ( ! Jetpack::is_active() ) {
2906
			if ( ! Jetpack::is_development_mode() && ! Jetpack::is_onboarding() )
2907
				return false;
2908
2909
			// If we're not connected but in development mode, make sure the module doesn't require a connection
2910
			if ( Jetpack::is_development_mode() && $module_data['requires_connection'] )
2911
				return false;
2912
		}
2913
2914
		// Check and see if the old plugin is active
2915
		if ( isset( $jetpack->plugins_to_deactivate[ $module ] ) ) {
2916
			// Deactivate the old plugin
2917
			if ( Jetpack_Client_Server::deactivate_plugin( $jetpack->plugins_to_deactivate[ $module ][0], $jetpack->plugins_to_deactivate[ $module ][1] ) ) {
2918
				// If we deactivated the old plugin, remembere that with ::state() and redirect back to this page to activate the module
2919
				// We can't activate the module on this page load since the newly deactivated old plugin is still loaded on this page load.
2920
				Jetpack::state( 'deactivated_plugins', $module );
2921
				wp_safe_redirect( add_query_arg( 'jetpack_restate', 1 ) );
2922
				exit;
2923
			}
2924
		}
2925
2926
		// Protect won't work with mis-configured IPs
2927
		if ( 'protect' === $module ) {
2928
			include_once JETPACK__PLUGIN_DIR . 'modules/protect/shared-functions.php';
2929
			if ( ! jetpack_protect_get_ip() ) {
2930
				Jetpack::state( 'message', 'protect_misconfigured_ip' );
2931
				return false;
2932
			}
2933
		}
2934
2935
		if ( ! Jetpack::active_plan_supports( $module ) ) {
2936
			return false;
2937
		}
2938
2939
		// Check the file for fatal errors, a la wp-admin/plugins.php::activate
2940
		Jetpack::state( 'module', $module );
2941
		Jetpack::state( 'error', 'module_activation_failed' ); // we'll override this later if the plugin can be included without fatal error
2942
2943
		Jetpack::catch_errors( true );
2944
		ob_start();
2945
		require Jetpack::get_module_path( $module );
2946
		/** This action is documented in class.jetpack.php */
2947
		do_action( 'jetpack_activate_module', $module );
2948
		$active[] = $module;
2949
		Jetpack::update_active_modules( $active );
2950
2951
		Jetpack::state( 'error', false ); // the override
2952
		ob_end_clean();
2953
		Jetpack::catch_errors( false );
2954
2955
		// A flag for Jump Start so it's not shown again. Only set if it hasn't been yet.
2956 View Code Duplication
		if ( 'new_connection' === Jetpack_Options::get_option( 'jumpstart' ) ) {
2957
			Jetpack_Options::update_option( 'jumpstart', 'jetpack_action_taken' );
2958
2959
			//Jump start is being dismissed send data to MC Stats
2960
			$jetpack->stat( 'jumpstart', 'manual,'.$module );
2961
2962
			$jetpack->do_stats( 'server_side' );
2963
		}
2964
2965
		if ( $redirect ) {
2966
			wp_safe_redirect( Jetpack::admin_url( 'page=jetpack' ) );
2967
		}
2968
		if ( $exit ) {
2969
			exit;
2970
		}
2971
		return true;
2972
	}
2973
2974
	function activate_module_actions( $module ) {
2975
		_deprecated_function( __METHOD__, 'jetpack-4.2' );
2976
	}
2977
2978
	public static function deactivate_module( $module ) {
2979
		/**
2980
		 * Fires when a module is deactivated.
2981
		 *
2982
		 * @since 1.9.0
2983
		 *
2984
		 * @param string $module Module slug.
2985
		 */
2986
		do_action( 'jetpack_pre_deactivate_module', $module );
2987
2988
		$jetpack = Jetpack::init();
2989
2990
		$active = Jetpack::get_active_modules();
2991
		$new    = array_filter( array_diff( $active, (array) $module ) );
2992
2993
		// A flag for Jump Start so it's not shown again.
2994 View Code Duplication
		if ( 'new_connection' === Jetpack_Options::get_option( 'jumpstart' ) ) {
2995
			Jetpack_Options::update_option( 'jumpstart', 'jetpack_action_taken' );
2996
2997
			//Jump start is being dismissed send data to MC Stats
2998
			$jetpack->stat( 'jumpstart', 'manual,deactivated-'.$module );
2999
3000
			$jetpack->do_stats( 'server_side' );
3001
		}
3002
3003
		return self::update_active_modules( $new );
3004
	}
3005
3006
	public static function enable_module_configurable( $module ) {
3007
		$module = Jetpack::get_module_slug( $module );
3008
		add_filter( 'jetpack_module_configurable_' . $module, '__return_true' );
3009
	}
3010
3011
	public static function module_configuration_url( $module ) {
3012
		$module = Jetpack::get_module_slug( $module );
3013
		return Jetpack::admin_url( array( 'page' => 'jetpack', 'configure' => $module ) );
3014
	}
3015
3016
	public static function module_configuration_load( $module, $method ) {
3017
		$module = Jetpack::get_module_slug( $module );
3018
		add_action( 'jetpack_module_configuration_load_' . $module, $method );
3019
	}
3020
3021
	public static function module_configuration_head( $module, $method ) {
3022
		$module = Jetpack::get_module_slug( $module );
3023
		add_action( 'jetpack_module_configuration_head_' . $module, $method );
3024
	}
3025
3026
	public static function module_configuration_screen( $module, $method ) {
3027
		$module = Jetpack::get_module_slug( $module );
3028
		add_action( 'jetpack_module_configuration_screen_' . $module, $method );
3029
	}
3030
3031
	public static function module_configuration_activation_screen( $module, $method ) {
3032
		$module = Jetpack::get_module_slug( $module );
3033
		add_action( 'display_activate_module_setting_' . $module, $method );
3034
	}
3035
3036
/* Installation */
3037
3038
	public static function bail_on_activation( $message, $deactivate = true ) {
3039
?>
3040
<!doctype html>
3041
<html>
3042
<head>
3043
<meta charset="<?php bloginfo( 'charset' ); ?>">
3044
<style>
3045
* {
3046
	text-align: center;
3047
	margin: 0;
3048
	padding: 0;
3049
	font-family: "Lucida Grande",Verdana,Arial,"Bitstream Vera Sans",sans-serif;
3050
}
3051
p {
3052
	margin-top: 1em;
3053
	font-size: 18px;
3054
}
3055
</style>
3056
<body>
3057
<p><?php echo esc_html( $message ); ?></p>
3058
</body>
3059
</html>
3060
<?php
3061
		if ( $deactivate ) {
3062
			$plugins = get_option( 'active_plugins' );
3063
			$jetpack = plugin_basename( JETPACK__PLUGIN_DIR . 'jetpack.php' );
3064
			$update  = false;
3065
			foreach ( $plugins as $i => $plugin ) {
3066
				if ( $plugin === $jetpack ) {
3067
					$plugins[$i] = false;
3068
					$update = true;
3069
				}
3070
			}
3071
3072
			if ( $update ) {
3073
				update_option( 'active_plugins', array_filter( $plugins ) );
3074
			}
3075
		}
3076
		exit;
3077
	}
3078
3079
	/**
3080
	 * Attached to activate_{ plugin_basename( __FILES__ ) } by register_activation_hook()
3081
	 * @static
3082
	 */
3083
	public static function plugin_activation( $network_wide ) {
3084
		Jetpack_Options::update_option( 'activated', 1 );
3085
3086
		if ( version_compare( $GLOBALS['wp_version'], JETPACK__MINIMUM_WP_VERSION, '<' ) ) {
3087
			Jetpack::bail_on_activation( sprintf( __( 'Jetpack requires WordPress version %s or later.', 'jetpack' ), JETPACK__MINIMUM_WP_VERSION ) );
3088
		}
3089
3090
		if ( $network_wide )
3091
			Jetpack::state( 'network_nag', true );
3092
3093
		// For firing one-off events (notices) immediately after activation
3094
		set_transient( 'activated_jetpack', true, .1 * MINUTE_IN_SECONDS );
3095
3096
		update_option( 'jetpack_activation_source', self::get_activation_source( wp_get_referer() ) );
3097
3098
		Jetpack::plugin_initialize();
3099
	}
3100
3101
	public static function get_activation_source( $referer_url ) {
3102
3103
		if ( defined( 'WP_CLI' ) && WP_CLI ) {
3104
			return array( 'wp-cli', null );
3105
		}
3106
3107
		$referer = parse_url( $referer_url );
3108
3109
		$source_type = 'unknown';
3110
		$source_query = null;
3111
3112
		if ( ! is_array( $referer ) ) {
3113
			return array( $source_type, $source_query );
3114
		}
3115
3116
		$plugins_path = parse_url( admin_url( 'plugins.php' ), PHP_URL_PATH );
3117
		$plugins_install_path = parse_url( admin_url( 'plugin-install.php' ), PHP_URL_PATH );// /wp-admin/plugin-install.php
3118
3119
		if ( isset( $referer['query'] ) ) {
3120
			parse_str( $referer['query'], $query_parts );
3121
		} else {
3122
			$query_parts = array();
3123
		}
3124
3125
		if ( $plugins_path === $referer['path'] ) {
3126
			$source_type = 'list';
3127
		} elseif ( $plugins_install_path === $referer['path'] ) {
3128
			$tab = isset( $query_parts['tab'] ) ? $query_parts['tab'] : 'featured';
3129
			switch( $tab ) {
3130
				case 'popular':
3131
					$source_type = 'popular';
3132
					break;
3133
				case 'recommended':
3134
					$source_type = 'recommended';
3135
					break;
3136
				case 'favorites':
3137
					$source_type = 'favorites';
3138
					break;
3139
				case 'search':
3140
					$source_type = 'search-' . ( isset( $query_parts['type'] ) ? $query_parts['type'] : 'term' );
3141
					$source_query = isset( $query_parts['s'] ) ? $query_parts['s'] : null;
3142
					break;
3143
				default:
3144
					$source_type = 'featured';
3145
			}
3146
		}
3147
3148
		return array( $source_type, $source_query );
3149
	}
3150
3151
	/**
3152
	 * Runs before bumping version numbers up to a new version
3153
	 * @param  string $version    Version:timestamp
3154
	 * @param  string $old_version Old Version:timestamp or false if not set yet.
3155
	 * @return null              [description]
3156
	 */
3157
	public static function do_version_bump( $version, $old_version ) {
3158
3159
		if ( ! $old_version ) { // For new sites
3160
			// Setting up jetpack manage
3161
			Jetpack::activate_manage();
3162
		}
3163
	}
3164
3165
	/**
3166
	 * Sets the internal version number and activation state.
3167
	 * @static
3168
	 */
3169
	public static function plugin_initialize() {
3170
		if ( ! Jetpack_Options::get_option( 'activated' ) ) {
3171
			Jetpack_Options::update_option( 'activated', 2 );
3172
		}
3173
3174 View Code Duplication
		if ( ! Jetpack_Options::get_option( 'version' ) ) {
3175
			$version = $old_version = JETPACK__VERSION . ':' . time();
3176
			/** This action is documented in class.jetpack.php */
3177
			do_action( 'updating_jetpack_version', $version, false );
3178
			Jetpack_Options::update_options( compact( 'version', 'old_version' ) );
3179
		}
3180
3181
		Jetpack::load_modules();
3182
3183
		Jetpack_Options::delete_option( 'do_activate' );
3184
		Jetpack_Options::delete_option( 'dismissed_connection_banner' );
3185
	}
3186
3187
	/**
3188
	 * Removes all connection options
3189
	 * @static
3190
	 */
3191
	public static function plugin_deactivation( ) {
3192
		require_once( ABSPATH . '/wp-admin/includes/plugin.php' );
3193
		if( is_plugin_active_for_network( 'jetpack/jetpack.php' ) ) {
3194
			Jetpack_Network::init()->deactivate();
3195
		} else {
3196
			Jetpack::disconnect( false );
3197
			//Jetpack_Heartbeat::init()->deactivate();
3198
		}
3199
	}
3200
3201
	/**
3202
	 * Disconnects from the Jetpack servers.
3203
	 * Forgets all connection details and tells the Jetpack servers to do the same.
3204
	 * @static
3205
	 */
3206
	public static function disconnect( $update_activated_state = true ) {
3207
		wp_clear_scheduled_hook( 'jetpack_clean_nonces' );
3208
		Jetpack::clean_nonces( true );
3209
3210
		// If the site is in an IDC because sync is not allowed,
3211
		// let's make sure to not disconnect the production site.
3212
		if ( ! self::validate_sync_error_idc_option() ) {
3213
			JetpackTracking::record_user_event( 'disconnect_site', array() );
3214
			Jetpack::load_xml_rpc_client();
3215
			$xml = new Jetpack_IXR_Client();
3216
			$xml->query( 'jetpack.deregister' );
3217
		}
3218
3219
		Jetpack_Options::delete_option(
3220
			array(
3221
				'blog_token',
3222
				'user_token',
3223
				'user_tokens',
3224
				'master_user',
3225
				'time_diff',
3226
				'fallback_no_verify_ssl_certs',
3227
			)
3228
		);
3229
3230
		Jetpack_IDC::clear_all_idc_options();
3231
		Jetpack_Options::delete_raw_option( 'jetpack_secrets' );
3232
3233
		if ( $update_activated_state ) {
3234
			Jetpack_Options::update_option( 'activated', 4 );
3235
		}
3236
3237
		if ( $jetpack_unique_connection = Jetpack_Options::get_option( 'unique_connection' ) ) {
3238
			// Check then record unique disconnection if site has never been disconnected previously
3239
			if ( - 1 == $jetpack_unique_connection['disconnected'] ) {
3240
				$jetpack_unique_connection['disconnected'] = 1;
3241
			} else {
3242
				if ( 0 == $jetpack_unique_connection['disconnected'] ) {
3243
					//track unique disconnect
3244
					$jetpack = Jetpack::init();
3245
3246
					$jetpack->stat( 'connections', 'unique-disconnect' );
3247
					$jetpack->do_stats( 'server_side' );
3248
				}
3249
				// increment number of times disconnected
3250
				$jetpack_unique_connection['disconnected'] += 1;
3251
			}
3252
3253
			Jetpack_Options::update_option( 'unique_connection', $jetpack_unique_connection );
3254
		}
3255
3256
		// Delete cached connected user data
3257
		$transient_key = "jetpack_connected_user_data_" . get_current_user_id();
3258
		delete_transient( $transient_key );
3259
3260
		// Delete all the sync related data. Since it could be taking up space.
3261
		require_once JETPACK__PLUGIN_DIR . 'sync/class.jetpack-sync-sender.php';
3262
		Jetpack_Sync_Sender::get_instance()->uninstall();
3263
3264
		// Disable the Heartbeat cron
3265
		Jetpack_Heartbeat::init()->deactivate();
3266
	}
3267
3268
	/**
3269
	 * Unlinks the current user from the linked WordPress.com user
3270
	 */
3271
	public static function unlink_user( $user_id = null ) {
3272
		if ( ! $tokens = Jetpack_Options::get_option( 'user_tokens' ) )
3273
			return false;
3274
3275
		$user_id = empty( $user_id ) ? get_current_user_id() : intval( $user_id );
3276
3277
		if ( Jetpack_Options::get_option( 'master_user' ) == $user_id )
3278
			return false;
3279
3280
		if ( ! isset( $tokens[ $user_id ] ) )
3281
			return false;
3282
3283
		Jetpack::load_xml_rpc_client();
3284
		$xml = new Jetpack_IXR_Client( compact( 'user_id' ) );
3285
		$xml->query( 'jetpack.unlink_user', $user_id );
3286
3287
		unset( $tokens[ $user_id ] );
3288
3289
		Jetpack_Options::update_option( 'user_tokens', $tokens );
3290
3291
		/**
3292
		 * Fires after the current user has been unlinked from WordPress.com.
3293
		 *
3294
		 * @since 4.1.0
3295
		 *
3296
		 * @param int $user_id The current user's ID.
3297
		 */
3298
		do_action( 'jetpack_unlinked_user', $user_id );
3299
3300
		return true;
3301
	}
3302
3303
	/**
3304
	 * Attempts Jetpack registration.  If it fail, a state flag is set: @see ::admin_page_load()
3305
	 */
3306
	public static function try_registration() {
3307
		// The user has agreed to the TOS at some point by now.
3308
		Jetpack_Options::update_option( 'tos_agreed', true );
3309
3310
		// Let's get some testing in beta versions and such.
3311
		if ( self::is_development_version() && defined( 'PHP_URL_HOST' ) ) {
3312
			// Before attempting to connect, let's make sure that the domains are viable.
3313
			$domains_to_check = array_unique( array(
3314
				'siteurl' => parse_url( get_site_url(), PHP_URL_HOST ),
3315
				'homeurl' => parse_url( get_home_url(), PHP_URL_HOST ),
3316
			) );
3317
			foreach ( $domains_to_check as $domain ) {
3318
				$result = Jetpack_Data::is_usable_domain( $domain );
3319
				if ( is_wp_error( $result ) ) {
3320
					return $result;
3321
				}
3322
			}
3323
		}
3324
3325
		$result = Jetpack::register();
3326
3327
		// If there was an error with registration and the site was not registered, record this so we can show a message.
3328
		if ( ! $result || is_wp_error( $result ) ) {
3329
			return $result;
3330
		} else {
3331
			return true;
3332
		}
3333
	}
3334
3335
	/**
3336
	 * Tracking an internal event log. Try not to put too much chaff in here.
3337
	 *
3338
	 * [Everyone Loves a Log!](https://www.youtube.com/watch?v=2C7mNr5WMjA)
3339
	 */
3340
	public static function log( $code, $data = null ) {
3341
		// only grab the latest 200 entries
3342
		$log = array_slice( Jetpack_Options::get_option( 'log', array() ), -199, 199 );
3343
3344
		// Append our event to the log
3345
		$log_entry = array(
3346
			'time'    => time(),
3347
			'user_id' => get_current_user_id(),
3348
			'blog_id' => Jetpack_Options::get_option( 'id' ),
3349
			'code'    => $code,
3350
		);
3351
		// Don't bother storing it unless we've got some.
3352
		if ( ! is_null( $data ) ) {
3353
			$log_entry['data'] = $data;
3354
		}
3355
		$log[] = $log_entry;
3356
3357
		// Try add_option first, to make sure it's not autoloaded.
3358
		// @todo: Add an add_option method to Jetpack_Options
3359
		if ( ! add_option( 'jetpack_log', $log, null, 'no' ) ) {
3360
			Jetpack_Options::update_option( 'log', $log );
3361
		}
3362
3363
		/**
3364
		 * Fires when Jetpack logs an internal event.
3365
		 *
3366
		 * @since 3.0.0
3367
		 *
3368
		 * @param array $log_entry {
3369
		 *	Array of details about the log entry.
3370
		 *
3371
		 *	@param string time Time of the event.
3372
		 *	@param int user_id ID of the user who trigerred the event.
3373
		 *	@param int blog_id Jetpack Blog ID.
3374
		 *	@param string code Unique name for the event.
3375
		 *	@param string data Data about the event.
3376
		 * }
3377
		 */
3378
		do_action( 'jetpack_log_entry', $log_entry );
3379
	}
3380
3381
	/**
3382
	 * Get the internal event log.
3383
	 *
3384
	 * @param $event (string) - only return the specific log events
3385
	 * @param $num   (int)    - get specific number of latest results, limited to 200
3386
	 *
3387
	 * @return array of log events || WP_Error for invalid params
3388
	 */
3389
	public static function get_log( $event = false, $num = false ) {
3390
		if ( $event && ! is_string( $event ) ) {
3391
			return new WP_Error( __( 'First param must be string or empty', 'jetpack' ) );
3392
		}
3393
3394
		if ( $num && ! is_numeric( $num ) ) {
3395
			return new WP_Error( __( 'Second param must be numeric or empty', 'jetpack' ) );
3396
		}
3397
3398
		$entire_log = Jetpack_Options::get_option( 'log', array() );
3399
3400
		// If nothing set - act as it did before, otherwise let's start customizing the output
3401
		if ( ! $num && ! $event ) {
3402
			return $entire_log;
3403
		} else {
3404
			$entire_log = array_reverse( $entire_log );
3405
		}
3406
3407
		$custom_log_output = array();
3408
3409
		if ( $event ) {
3410
			foreach ( $entire_log as $log_event ) {
3411
				if ( $event == $log_event[ 'code' ] ) {
3412
					$custom_log_output[] = $log_event;
3413
				}
3414
			}
3415
		} else {
3416
			$custom_log_output = $entire_log;
3417
		}
3418
3419
		if ( $num ) {
3420
			$custom_log_output = array_slice( $custom_log_output, 0, $num );
3421
		}
3422
3423
		return $custom_log_output;
3424
	}
3425
3426
	/**
3427
	 * Log modification of important settings.
3428
	 */
3429
	public static function log_settings_change( $option, $old_value, $value ) {
3430
		switch( $option ) {
3431
			case 'jetpack_sync_non_public_post_stati':
3432
				self::log( $option, $value );
3433
				break;
3434
		}
3435
	}
3436
3437
	/**
3438
	 * Return stat data for WPCOM sync
3439
	 */
3440
	public static function get_stat_data( $encode = true, $extended = true ) {
3441
		$data = Jetpack_Heartbeat::generate_stats_array();
3442
3443
		if ( $extended ) {
3444
			$additional_data = self::get_additional_stat_data();
3445
			$data = array_merge( $data, $additional_data );
3446
		}
3447
3448
		if ( $encode ) {
3449
			return json_encode( $data );
3450
		}
3451
3452
		return $data;
3453
	}
3454
3455
	/**
3456
	 * Get additional stat data to sync to WPCOM
3457
	 */
3458
	public static function get_additional_stat_data( $prefix = '' ) {
3459
		$return["{$prefix}themes"]         = Jetpack::get_parsed_theme_data();
0 ignored issues
show
Coding Style Comprehensibility introduced by
$return was never initialized. Although not strictly required by PHP, it is generally a good practice to add $return = array(); before regardless.

Adding an explicit array definition is generally preferable to implicit array definition as it guarantees a stable state of the code.

Let’s take a look at an example:

foreach ($collection as $item) {
    $myArray['foo'] = $item->getFoo();

    if ($item->hasBar()) {
        $myArray['bar'] = $item->getBar();
    }

    // do something with $myArray
}

As you can see in this example, the array $myArray is initialized the first time when the foreach loop is entered. You can also see that the value of the bar key is only written conditionally; thus, its value might result from a previous iteration.

This might or might not be intended. To make your intention clear, your code more readible and to avoid accidental bugs, we recommend to add an explicit initialization $myArray = array() either outside or inside the foreach loop.

Loading history...
3460
		$return["{$prefix}plugins-extra"]  = Jetpack::get_parsed_plugin_data();
3461
		$return["{$prefix}users"]          = (int) Jetpack::get_site_user_count();
3462
		$return["{$prefix}site-count"]     = 0;
3463
3464
		if ( function_exists( 'get_blog_count' ) ) {
3465
			$return["{$prefix}site-count"] = get_blog_count();
3466
		}
3467
		return $return;
3468
	}
3469
3470
	private static function get_site_user_count() {
3471
		global $wpdb;
3472
3473
		if ( function_exists( 'wp_is_large_network' ) ) {
3474
			if ( wp_is_large_network( 'users' ) ) {
3475
				return -1; // Not a real value but should tell us that we are dealing with a large network.
3476
			}
3477
		}
3478 View Code Duplication
		if ( false === ( $user_count = get_transient( 'jetpack_site_user_count' ) ) ) {
3479
			// It wasn't there, so regenerate the data and save the transient
3480
			$user_count = $wpdb->get_var( "SELECT COUNT(*) FROM $wpdb->usermeta WHERE meta_key = '{$wpdb->prefix}capabilities'" );
3481
			set_transient( 'jetpack_site_user_count', $user_count, DAY_IN_SECONDS );
3482
		}
3483
		return $user_count;
3484
	}
3485
3486
	/* Admin Pages */
3487
3488
	function admin_init() {
3489
		// If the plugin is not connected, display a connect message.
3490
		if (
3491
			// the plugin was auto-activated and needs its candy
3492
			Jetpack_Options::get_option_and_ensure_autoload( 'do_activate', '0' )
3493
		||
3494
			// the plugin is active, but was never activated.  Probably came from a site-wide network activation
3495
			! Jetpack_Options::get_option( 'activated' )
3496
		) {
3497
			Jetpack::plugin_initialize();
3498
		}
3499
3500
		if ( ! Jetpack::is_active() && ! Jetpack::is_development_mode() ) {
3501
			Jetpack_Connection_Banner::init();
3502
		} elseif ( false === Jetpack_Options::get_option( 'fallback_no_verify_ssl_certs' ) ) {
3503
			// Upgrade: 1.1 -> 1.1.1
3504
			// Check and see if host can verify the Jetpack servers' SSL certificate
3505
			$args = array();
3506
			Jetpack_Client::_wp_remote_request(
3507
				Jetpack::fix_url_for_bad_hosts( Jetpack::api_url( 'test' ) ),
3508
				$args,
3509
				true
3510
			);
3511
		} else if ( $this->can_display_jetpack_manage_notice() && ! Jetpack_Options::get_option( 'dismissed_manage_banner' ) ) {
3512
			// Show the notice on the Dashboard only for now
3513
			add_action( 'load-index.php', array( $this, 'prepare_manage_jetpack_notice' ) );
3514
		}
3515
3516
		if ( current_user_can( 'manage_options' ) && 'AUTO' == JETPACK_CLIENT__HTTPS && ! self::permit_ssl() ) {
3517
			add_action( 'jetpack_notices', array( $this, 'alert_auto_ssl_fail' ) );
3518
		}
3519
3520
		add_action( 'load-plugins.php', array( $this, 'intercept_plugin_error_scrape_init' ) );
3521
		add_action( 'admin_enqueue_scripts', array( $this, 'admin_menu_css' ) );
3522
		add_filter( 'plugin_action_links_' . plugin_basename( JETPACK__PLUGIN_DIR . 'jetpack.php' ), array( $this, 'plugin_action_links' ) );
3523
3524
		if ( Jetpack::is_active() || Jetpack::is_development_mode() ) {
3525
			// Artificially throw errors in certain whitelisted cases during plugin activation
3526
			add_action( 'activate_plugin', array( $this, 'throw_error_on_activate_plugin' ) );
3527
		}
3528
3529
		// Jetpack Manage Activation Screen from .com
3530
		Jetpack::module_configuration_activation_screen( 'manage', array( $this, 'manage_activate_screen' ) );
3531
3532
		// Add custom column in wp-admin/users.php to show whether user is linked.
3533
		add_filter( 'manage_users_columns',       array( $this, 'jetpack_icon_user_connected' ) );
3534
		add_action( 'manage_users_custom_column', array( $this, 'jetpack_show_user_connected_icon' ), 10, 3 );
3535
		add_action( 'admin_print_styles',         array( $this, 'jetpack_user_col_style' ) );
3536
	}
3537
3538
	function admin_body_class( $admin_body_class = '' ) {
3539
		$classes = explode( ' ', trim( $admin_body_class ) );
3540
3541
		$classes[] = self::is_active() ? 'jetpack-connected' : 'jetpack-disconnected';
3542
3543
		$admin_body_class = implode( ' ', array_unique( $classes ) );
3544
		return " $admin_body_class ";
3545
	}
3546
3547
	static function add_jetpack_pagestyles( $admin_body_class = '' ) {
3548
		return $admin_body_class . ' jetpack-pagestyles ';
3549
	}
3550
3551
	/**
3552
	 * Call this function if you want the Big Jetpack Manage Notice to show up.
3553
	 *
3554
	 * @return null
3555
	 */
3556
	function prepare_manage_jetpack_notice() {
3557
3558
		add_action( 'admin_print_styles', array( $this, 'admin_banner_styles' ) );
3559
		add_action( 'admin_notices', array( $this, 'admin_jetpack_manage_notice' ) );
3560
	}
3561
3562
	function manage_activate_screen() {
3563
		include ( JETPACK__PLUGIN_DIR . 'modules/manage/activate-admin.php' );
3564
	}
3565
	/**
3566
	 * Sometimes a plugin can activate without causing errors, but it will cause errors on the next page load.
3567
	 * This function artificially throws errors for such cases (whitelisted).
3568
	 *
3569
	 * @param string $plugin The activated plugin.
3570
	 */
3571
	function throw_error_on_activate_plugin( $plugin ) {
3572
		$active_modules = Jetpack::get_active_modules();
3573
3574
		// The Shortlinks module and the Stats plugin conflict, but won't cause errors on activation because of some function_exists() checks.
3575
		if ( function_exists( 'stats_get_api_key' ) && in_array( 'shortlinks', $active_modules ) ) {
3576
			$throw = false;
3577
3578
			// Try and make sure it really was the stats plugin
3579
			if ( ! class_exists( 'ReflectionFunction' ) ) {
3580
				if ( 'stats.php' == basename( $plugin ) ) {
3581
					$throw = true;
3582
				}
3583
			} else {
3584
				$reflection = new ReflectionFunction( 'stats_get_api_key' );
3585
				if ( basename( $plugin ) == basename( $reflection->getFileName() ) ) {
3586
					$throw = true;
3587
				}
3588
			}
3589
3590
			if ( $throw ) {
3591
				trigger_error( sprintf( __( 'Jetpack contains the most recent version of the old &#8220;%1$s&#8221; plugin.', 'jetpack' ), 'WordPress.com Stats' ), E_USER_ERROR );
3592
			}
3593
		}
3594
	}
3595
3596
	function intercept_plugin_error_scrape_init() {
3597
		add_action( 'check_admin_referer', array( $this, 'intercept_plugin_error_scrape' ), 10, 2 );
3598
	}
3599
3600
	function intercept_plugin_error_scrape( $action, $result ) {
3601
		if ( ! $result ) {
3602
			return;
3603
		}
3604
3605
		foreach ( $this->plugins_to_deactivate as $deactivate_me ) {
3606
			if ( "plugin-activation-error_{$deactivate_me[0]}" == $action ) {
3607
				Jetpack::bail_on_activation( sprintf( __( 'Jetpack contains the most recent version of the old &#8220;%1$s&#8221; plugin.', 'jetpack' ), $deactivate_me[1] ), false );
3608
			}
3609
		}
3610
	}
3611
3612
	function add_remote_request_handlers() {
3613
		add_action( 'wp_ajax_nopriv_jetpack_upload_file', array( $this, 'remote_request_handlers' ) );
3614
		add_action( 'wp_ajax_nopriv_jetpack_update_file', array( $this, 'remote_request_handlers' ) );
3615
	}
3616
3617
	function remote_request_handlers() {
3618
		$action = current_filter();
3619
3620
		switch ( current_filter() ) {
3621
		case 'wp_ajax_nopriv_jetpack_upload_file' :
3622
			$response = $this->upload_handler();
3623
			break;
3624
3625
		case 'wp_ajax_nopriv_jetpack_update_file' :
3626
			$response = $this->upload_handler( true );
3627
			break;
3628
		default :
3629
			$response = new Jetpack_Error( 'unknown_handler', 'Unknown Handler', 400 );
3630
			break;
3631
		}
3632
3633
		if ( ! $response ) {
3634
			$response = new Jetpack_Error( 'unknown_error', 'Unknown Error', 400 );
3635
		}
3636
3637
		if ( is_wp_error( $response ) ) {
3638
			$status_code       = $response->get_error_data();
3639
			$error             = $response->get_error_code();
3640
			$error_description = $response->get_error_message();
3641
3642
			if ( ! is_int( $status_code ) ) {
3643
				$status_code = 400;
3644
			}
3645
3646
			status_header( $status_code );
3647
			die( json_encode( (object) compact( 'error', 'error_description' ) ) );
3648
		}
3649
3650
		status_header( 200 );
3651
		if ( true === $response ) {
3652
			exit;
3653
		}
3654
3655
		die( json_encode( (object) $response ) );
3656
	}
3657
3658
	/**
3659
	 * Uploads a file gotten from the global $_FILES.
3660
	 * If `$update_media_item` is true and `post_id` is defined
3661
	 * the attachment file of the media item (gotten through of the post_id)
3662
	 * will be updated instead of add a new one.
3663
	 *
3664
	 * @param  boolean $update_media_item - update media attachment
3665
	 * @return array - An array describing the uploadind files process
3666
	 */
3667
	function upload_handler( $update_media_item = false ) {
3668
		if ( 'POST' !== strtoupper( $_SERVER['REQUEST_METHOD'] ) ) {
3669
			return new Jetpack_Error( 405, get_status_header_desc( 405 ), 405 );
3670
		}
3671
3672
		$user = wp_authenticate( '', '' );
3673
		if ( ! $user || is_wp_error( $user ) ) {
3674
			return new Jetpack_Error( 403, get_status_header_desc( 403 ), 403 );
3675
		}
3676
3677
		wp_set_current_user( $user->ID );
3678
3679
		if ( ! current_user_can( 'upload_files' ) ) {
3680
			return new Jetpack_Error( 'cannot_upload_files', 'User does not have permission to upload files', 403 );
3681
		}
3682
3683
		if ( empty( $_FILES ) ) {
3684
			return new Jetpack_Error( 'no_files_uploaded', 'No files were uploaded: nothing to process', 400 );
3685
		}
3686
3687
		foreach ( array_keys( $_FILES ) as $files_key ) {
3688
			if ( ! isset( $_POST["_jetpack_file_hmac_{$files_key}"] ) ) {
3689
				return new Jetpack_Error( 'missing_hmac', 'An HMAC for one or more files is missing', 400 );
3690
			}
3691
		}
3692
3693
		$media_keys = array_keys( $_FILES['media'] );
3694
3695
		$token = Jetpack_Data::get_access_token( get_current_user_id() );
3696
		if ( ! $token || is_wp_error( $token ) ) {
3697
			return new Jetpack_Error( 'unknown_token', 'Unknown Jetpack token', 403 );
3698
		}
3699
3700
		$uploaded_files = array();
3701
		$global_post    = isset( $GLOBALS['post'] ) ? $GLOBALS['post'] : null;
3702
		unset( $GLOBALS['post'] );
3703
		foreach ( $_FILES['media']['name'] as $index => $name ) {
3704
			$file = array();
3705
			foreach ( $media_keys as $media_key ) {
3706
				$file[$media_key] = $_FILES['media'][$media_key][$index];
3707
			}
3708
3709
			list( $hmac_provided, $salt ) = explode( ':', $_POST['_jetpack_file_hmac_media'][$index] );
3710
3711
			$hmac_file = hash_hmac_file( 'sha1', $file['tmp_name'], $salt . $token->secret );
3712
			if ( $hmac_provided !== $hmac_file ) {
3713
				$uploaded_files[$index] = (object) array( 'error' => 'invalid_hmac', 'error_description' => 'The corresponding HMAC for this file does not match' );
3714
				continue;
3715
			}
3716
3717
			$_FILES['.jetpack.upload.'] = $file;
3718
			$post_id = isset( $_POST['post_id'][$index] ) ? absint( $_POST['post_id'][$index] ) : 0;
3719
			if ( ! current_user_can( 'edit_post', $post_id ) ) {
3720
				$post_id = 0;
3721
			}
3722
3723
			if ( $update_media_item ) {
3724
				if ( ! isset( $post_id ) || $post_id === 0 ) {
3725
					return new Jetpack_Error( 'invalid_input', 'Media ID must be defined.', 400 );
3726
				}
3727
3728
				$media_array = $_FILES['media'];
3729
3730
				$file_array['name'] = $media_array['name'][0];
3731
				$file_array['type'] = $media_array['type'][0];
3732
				$file_array['tmp_name'] = $media_array['tmp_name'][0];
3733
				$file_array['error'] = $media_array['error'][0];
3734
				$file_array['size'] = $media_array['size'][0];
3735
3736
				$edited_media_item = Jetpack_Media::edit_media_file( $post_id, $file_array );
3737
3738
				if ( is_wp_error( $edited_media_item ) ) {
3739
					return $edited_media_item;
3740
				}
3741
3742
				$response = (object) array(
3743
					'id'   => (string) $post_id,
3744
					'file' => (string) $edited_media_item->post_title,
3745
					'url'  => (string) wp_get_attachment_url( $post_id ),
3746
					'type' => (string) $edited_media_item->post_mime_type,
3747
					'meta' => (array) wp_get_attachment_metadata( $post_id ),
3748
				);
3749
3750
				return (array) array( $response );
3751
			}
3752
3753
			$attachment_id = media_handle_upload(
3754
				'.jetpack.upload.',
3755
				$post_id,
3756
				array(),
3757
				array(
3758
					'action' => 'jetpack_upload_file',
3759
				)
3760
			);
3761
3762
			if ( ! $attachment_id ) {
3763
				$uploaded_files[$index] = (object) array( 'error' => 'unknown', 'error_description' => 'An unknown problem occurred processing the upload on the Jetpack site' );
3764
			} elseif ( is_wp_error( $attachment_id ) ) {
3765
				$uploaded_files[$index] = (object) array( 'error' => 'attachment_' . $attachment_id->get_error_code(), 'error_description' => $attachment_id->get_error_message() );
3766
			} else {
3767
				$attachment = get_post( $attachment_id );
3768
				$uploaded_files[$index] = (object) array(
3769
					'id'   => (string) $attachment_id,
3770
					'file' => $attachment->post_title,
3771
					'url'  => wp_get_attachment_url( $attachment_id ),
3772
					'type' => $attachment->post_mime_type,
3773
					'meta' => wp_get_attachment_metadata( $attachment_id ),
3774
				);
3775
				// Zip files uploads are not supported unless they are done for installation purposed
3776
				// lets delete them in case something goes wrong in this whole process
3777
				if ( 'application/zip' === $attachment->post_mime_type ) {
3778
					// Schedule a cleanup for 2 hours from now in case of failed install.
3779
					wp_schedule_single_event( time() + 2 * HOUR_IN_SECONDS, 'upgrader_scheduled_cleanup', array( $attachment_id ) );
3780
				}
3781
			}
3782
		}
3783
		if ( ! is_null( $global_post ) ) {
3784
			$GLOBALS['post'] = $global_post;
3785
		}
3786
3787
		return $uploaded_files;
3788
	}
3789
3790
	/**
3791
	 * Add help to the Jetpack page
3792
	 *
3793
	 * @since Jetpack (1.2.3)
3794
	 * @return false if not the Jetpack page
3795
	 */
3796
	function admin_help() {
3797
		$current_screen = get_current_screen();
3798
3799
		// Overview
3800
		$current_screen->add_help_tab(
3801
			array(
3802
				'id'		=> 'home',
3803
				'title'		=> __( 'Home', 'jetpack' ),
3804
				'content'	=>
3805
					'<p><strong>' . __( 'Jetpack by WordPress.com', 'jetpack' ) . '</strong></p>' .
3806
					'<p>' . __( 'Jetpack supercharges your self-hosted WordPress site with the awesome cloud power of WordPress.com.', 'jetpack' ) . '</p>' .
3807
					'<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>',
3808
			)
3809
		);
3810
3811
		// Screen Content
3812
		if ( current_user_can( 'manage_options' ) ) {
3813
			$current_screen->add_help_tab(
3814
				array(
3815
					'id'		=> 'settings',
3816
					'title'		=> __( 'Settings', 'jetpack' ),
3817
					'content'	=>
3818
						'<p><strong>' . __( 'Jetpack by WordPress.com',                                              'jetpack' ) . '</strong></p>' .
3819
						'<p>' . __( 'You can activate or deactivate individual Jetpack modules to suit your needs.', 'jetpack' ) . '</p>' .
3820
						'<ol>' .
3821
							'<li>' . __( 'Each module has an Activate or Deactivate link so you can toggle one individually.',														'jetpack' ) . '</li>' .
3822
							'<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>' .
3823
						'</ol>' .
3824
						'<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>'
3825
				)
3826
			);
3827
		}
3828
3829
		// Help Sidebar
3830
		$current_screen->set_help_sidebar(
3831
			'<p><strong>' . __( 'For more information:', 'jetpack' ) . '</strong></p>' .
3832
			'<p><a href="https://jetpack.com/faq/" target="_blank">'     . __( 'Jetpack FAQ',     'jetpack' ) . '</a></p>' .
3833
			'<p><a href="https://jetpack.com/support/" target="_blank">' . __( 'Jetpack Support', 'jetpack' ) . '</a></p>' .
3834
			'<p><a href="' . Jetpack::admin_url( array( 'page' => 'jetpack-debugger' )  ) .'">' . __( 'Jetpack Debugging Center', 'jetpack' ) . '</a></p>'
3835
		);
3836
	}
3837
3838
	function admin_menu_css() {
3839
		wp_enqueue_style( 'jetpack-icons' );
3840
	}
3841
3842
	function admin_menu_order() {
3843
		return true;
3844
	}
3845
3846
	function enqueue_gutenberg_assets() {
3847
		wp_add_inline_script(
3848
			'wp-i18n',
3849
			'wp.i18n.setLocaleData( ' . self::get_i18n_data_json() . ', \'jetpack\' );'
3850
		);
3851
		wp_enqueue_script(
3852
			'jetpack-gutenberg',
3853
			Jetpack::get_file_url_for_environment(
3854
				'_inc/build/gutenberg.min.js',
3855
				'_inc/build/gutenberg.js'
3856
			),
3857
			array( 'wp-blocks', 'wp-element', 'wp-i18n' ),
3858
			JETPACK__VERSION,
3859
			true
3860
		);
3861
		wp_enqueue_style( 'jetpack-icons' );
3862
	}
3863
3864 View Code Duplication
	function jetpack_menu_order( $menu_order ) {
3865
		$jp_menu_order = array();
3866
3867
		foreach ( $menu_order as $index => $item ) {
3868
			if ( $item != 'jetpack' ) {
3869
				$jp_menu_order[] = $item;
3870
			}
3871
3872
			if ( $index == 0 ) {
3873
				$jp_menu_order[] = 'jetpack';
3874
			}
3875
		}
3876
3877
		return $jp_menu_order;
3878
	}
3879
3880
	function admin_head() {
3881 View Code Duplication
		if ( isset( $_GET['configure'] ) && Jetpack::is_module( $_GET['configure'] ) && current_user_can( 'manage_options' ) )
3882
			/** This action is documented in class.jetpack-admin-page.php */
3883
			do_action( 'jetpack_module_configuration_head_' . $_GET['configure'] );
3884
	}
3885
3886
	function admin_banner_styles() {
3887
		$min = ( defined( 'SCRIPT_DEBUG' ) && SCRIPT_DEBUG ) ? '' : '.min';
3888
3889
		if ( ! wp_style_is( 'jetpack-dops-style' ) ) {
3890
			wp_register_style(
3891
				'jetpack-dops-style',
3892
				plugins_url( '_inc/build/admin.dops-style.css', JETPACK__PLUGIN_FILE ),
3893
				array(),
3894
				JETPACK__VERSION
3895
			);
3896
		}
3897
3898
		wp_enqueue_style(
3899
			'jetpack',
3900
			plugins_url( "css/jetpack-banners{$min}.css", JETPACK__PLUGIN_FILE ),
3901
			array( 'jetpack-dops-style' ),
3902
			 JETPACK__VERSION . '-20121016'
3903
		);
3904
		wp_style_add_data( 'jetpack', 'rtl', 'replace' );
3905
		wp_style_add_data( 'jetpack', 'suffix', $min );
3906
	}
3907
3908
	function plugin_action_links( $actions ) {
3909
3910
		$jetpack_home = array( 'jetpack-home' => sprintf( '<a href="%s">%s</a>', Jetpack::admin_url( 'page=jetpack' ), __( 'Jetpack', 'jetpack' ) ) );
3911
3912
		if( current_user_can( 'jetpack_manage_modules' ) && ( Jetpack::is_active() || Jetpack::is_development_mode() ) ) {
3913
			return array_merge(
3914
				$jetpack_home,
3915
				array( 'settings' => sprintf( '<a href="%s">%s</a>', Jetpack::admin_url( 'page=jetpack#/settings' ), __( 'Settings', 'jetpack' ) ) ),
3916
				array( 'support' => sprintf( '<a href="%s">%s</a>', Jetpack::admin_url( 'page=jetpack-debugger '), __( 'Support', 'jetpack' ) ) ),
3917
				$actions
3918
				);
3919
			}
3920
3921
		return array_merge( $jetpack_home, $actions );
3922
	}
3923
3924
	/**
3925
	 * This is the first banner
3926
	 * It should be visible only to user that can update the option
3927
	 * Are not connected
3928
	 *
3929
	 * @return null
3930
	 */
3931
	function admin_jetpack_manage_notice() {
3932
		$screen = get_current_screen();
3933
3934
		// Don't show the connect notice on the jetpack settings page.
3935
		if ( ! in_array( $screen->base, array( 'dashboard' ) ) || $screen->is_network || $screen->action ) {
3936
			return;
3937
		}
3938
3939
		$opt_out_url = $this->opt_out_jetpack_manage_url();
3940
		$opt_in_url  = $this->opt_in_jetpack_manage_url();
3941
		/**
3942
		 * I think it would be great to have different wordsing depending on where you are
3943
		 * for example if we show the notice on dashboard and a different one if we show it on Plugins screen
3944
		 * etc..
3945
		 */
3946
3947
		?>
3948
		<div id="message" class="updated jp-banner">
3949
				<a href="<?php echo esc_url( $opt_out_url ); ?>" class="notice-dismiss" title="<?php esc_attr_e( 'Dismiss this notice', 'jetpack' ); ?>"></a>
3950
				<div class="jp-banner__description-container">
3951
					<h2 class="jp-banner__header"><?php esc_html_e( 'Jetpack Centralized Site Management', 'jetpack' ); ?></h2>
3952
					<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>
3953
					<p class="jp-banner__button-container">
3954
						<a href="<?php echo esc_url( $opt_in_url ); ?>" class="button button-primary" id="wpcom-connect"><?php _e( 'Activate Jetpack Manage', 'jetpack' ); ?></a>
3955
						<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>
3956
					</p>
3957
				</div>
3958
		</div>
3959
		<?php
3960
	}
3961
3962
	/**
3963
	 * Returns the url that the user clicks to remove the notice for the big banner
3964
	 * @return string
3965
	 */
3966
	function opt_out_jetpack_manage_url() {
3967
		$referer = '&_wp_http_referer=' . add_query_arg( '_wp_http_referer', null );
3968
		return wp_nonce_url( Jetpack::admin_url( 'jetpack-notice=jetpack-manage-opt-out' . $referer ), 'jetpack_manage_banner_opt_out' );
3969
	}
3970
	/**
3971
	 * Returns the url that the user clicks to opt in to Jetpack Manage
3972
	 * @return string
3973
	 */
3974
	function opt_in_jetpack_manage_url() {
3975
		return wp_nonce_url( Jetpack::admin_url( 'jetpack-notice=jetpack-manage-opt-in' ), 'jetpack_manage_banner_opt_in' );
3976
	}
3977
3978
	function opt_in_jetpack_manage_notice() {
3979
		?>
3980
		<div class="wrap">
3981
			<div id="message" class="jetpack-message is-opt-in">
3982
				<?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' ); ?>
3983
			</div>
3984
		</div>
3985
		<?php
3986
3987
	}
3988
	/**
3989
	 * Determines whether to show the notice of not true = display notice
3990
	 * @return bool
3991
	 */
3992
	function can_display_jetpack_manage_notice() {
3993
		// never display the notice to users that can't do anything about it anyways
3994
		if( ! current_user_can( 'jetpack_manage_modules' ) )
3995
			return false;
3996
3997
		// don't display if we are in development more
3998
		if( Jetpack::is_development_mode() ) {
3999
			return false;
4000
		}
4001
		// don't display if the site is private
4002
		if(  ! Jetpack_Options::get_option( 'public' ) )
4003
			return false;
4004
4005
		/**
4006
		 * Should the Jetpack Remote Site Management notice be displayed.
4007
		 *
4008
		 * @since 3.3.0
4009
		 *
4010
		 * @param bool ! self::is_module_active( 'manage' ) Is the Manage module inactive.
4011
		 */
4012
		return apply_filters( 'can_display_jetpack_manage_notice', ! self::is_module_active( 'manage' ) );
4013
	}
4014
4015
	/*
4016
	 * Registration flow:
4017
	 * 1 - ::admin_page_load() action=register
4018
	 * 2 - ::try_registration()
4019
	 * 3 - ::register()
4020
	 *     - Creates jetpack_register option containing two secrets and a timestamp
4021
	 *     - Calls https://jetpack.wordpress.com/jetpack.register/1/ with
4022
	 *       siteurl, home, gmt_offset, timezone_string, site_name, secret_1, secret_2, site_lang, timeout, stats_id
4023
	 *     - That request to jetpack.wordpress.com does not immediately respond.  It first makes a request BACK to this site's
4024
	 *       xmlrpc.php?for=jetpack: RPC method: jetpack.verifyRegistration, Parameters: secret_1
4025
	 *     - The XML-RPC request verifies secret_1, deletes both secrets and responds with: secret_2
4026
	 *     - https://jetpack.wordpress.com/jetpack.register/1/ verifies that XML-RPC response (secret_2) then finally responds itself with
4027
	 *       jetpack_id, jetpack_secret, jetpack_public
4028
	 *     - ::register() then stores jetpack_options: id => jetpack_id, blog_token => jetpack_secret
4029
	 * 4 - redirect to https://wordpress.com/start/jetpack-connect
4030
	 * 5 - user logs in with WP.com account
4031
	 * 6 - remote request to this site's xmlrpc.php with action remoteAuthorize, Jetpack_XMLRPC_Server->remote_authorize
4032
	 *		- Jetpack_Client_Server::authorize()
4033
	 *		- Jetpack_Client_Server::get_token()
4034
	 *		- GET https://jetpack.wordpress.com/jetpack.token/1/ with
4035
	 *        client_id, client_secret, grant_type, code, redirect_uri:action=authorize, state, scope, user_email, user_login
4036
	 *			- which responds with access_token, token_type, scope
4037
	 *		- Jetpack_Client_Server::authorize() stores jetpack_options: user_token => access_token.$user_id
4038
	 *		- Jetpack::activate_default_modules()
4039
	 *     		- Deactivates deprecated plugins
4040
	 *     		- Activates all default modules
4041
	 *		- Responds with either error, or 'connected' for new connection, or 'linked' for additional linked users
4042
	 * 7 - For a new connection, user selects a Jetpack plan on wordpress.com
4043
	 * 8 - User is redirected back to wp-admin/index.php?page=jetpack with state:message=authorized
4044
	 *     Done!
4045
	 */
4046
4047
	/**
4048
	 * Handles the page load events for the Jetpack admin page
4049
	 */
4050
	function admin_page_load() {
4051
		$error = false;
4052
4053
		// Make sure we have the right body class to hook stylings for subpages off of.
4054
		add_filter( 'admin_body_class', array( __CLASS__, 'add_jetpack_pagestyles' ) );
4055
4056
		if ( ! empty( $_GET['jetpack_restate'] ) ) {
4057
			// Should only be used in intermediate redirects to preserve state across redirects
4058
			Jetpack::restate();
4059
		}
4060
4061
		if ( isset( $_GET['connect_url_redirect'] ) ) {
4062
			// User clicked in the iframe to link their accounts
4063
			if ( ! Jetpack::is_user_connected() ) {
4064
				$from = ! empty( $_GET['from'] ) ? $_GET['from'] : 'iframe';
4065
				$redirect = ! empty( $_GET['redirect_after_auth'] ) ? $_GET['redirect_after_auth'] : false;
4066
4067
				add_filter( 'allowed_redirect_hosts', array( &$this, 'allow_wpcom_environments' ) );
4068
				$connect_url = $this->build_connect_url( true, $redirect, $from );
4069
				remove_filter( 'allowed_redirect_hosts', array( &$this, 'allow_wpcom_environments' ) );
4070
4071
				if ( isset( $_GET['notes_iframe'] ) )
4072
					$connect_url .= '&notes_iframe';
4073
				wp_redirect( $connect_url );
4074
				exit;
4075
			} else {
4076
				if ( ! isset( $_GET['calypso_env'] ) ) {
4077
					Jetpack::state( 'message', 'already_authorized' );
4078
					wp_safe_redirect( Jetpack::admin_url() );
4079
					exit;
4080
				} else {
4081
					$connect_url = $this->build_connect_url( true, false, 'iframe' );
4082
					$connect_url .= '&already_authorized=true';
4083
					wp_redirect( $connect_url );
4084
					exit;
4085
				}
4086
			}
4087
		}
4088
4089
4090
		if ( isset( $_GET['action'] ) ) {
4091
			switch ( $_GET['action'] ) {
4092
			case 'authorize':
4093
				if ( Jetpack::is_active() && Jetpack::is_user_connected() ) {
4094
					Jetpack::state( 'message', 'already_authorized' );
4095
					wp_safe_redirect( Jetpack::admin_url() );
4096
					exit;
4097
				}
4098
				Jetpack::log( 'authorize' );
4099
				$client_server = new Jetpack_Client_Server;
4100
				$client_server->client_authorize();
4101
				exit;
4102
			case 'register' :
4103
				if ( ! current_user_can( 'jetpack_connect' ) ) {
4104
					$error = 'cheatin';
4105
					break;
4106
				}
4107
				check_admin_referer( 'jetpack-register' );
4108
				Jetpack::log( 'register' );
4109
				Jetpack::maybe_set_version_option();
4110
				$registered = Jetpack::try_registration();
4111
				if ( is_wp_error( $registered ) ) {
4112
					$error = $registered->get_error_code();
4113
					Jetpack::state( 'error', $error );
4114
					Jetpack::state( 'error', $registered->get_error_message() );
4115
					JetpackTracking::record_user_event( 'jpc_register_fail', array(
4116
						'error_code' => $error,
4117
						'error_message' => $registered->get_error_message()
4118
					) );
4119
					break;
4120
				}
4121
4122
				$from = isset( $_GET['from'] ) ? $_GET['from'] : false;
4123
				$redirect = isset( $_GET['redirect'] ) ? $_GET['redirect'] : false;
4124
4125
				JetpackTracking::record_user_event( 'jpc_register_success', array(
4126
					'from' => $from
4127
				) );
4128
4129
				$url = $this->build_connect_url( true, $redirect, $from );
4130
4131
				if ( ! empty( $_GET['onboarding'] ) ) {
4132
					$url = add_query_arg( 'onboarding', $_GET['onboarding'], $url );
4133
				}
4134
4135
				if ( ! empty( $_GET['auth_approved'] ) && 'true' === $_GET['auth_approved'] ) {
4136
					$url = add_query_arg( 'auth_approved', 'true', $url );
4137
				}
4138
4139
				wp_redirect( $url );
4140
				exit;
4141
			case 'activate' :
4142
				if ( ! current_user_can( 'jetpack_activate_modules' ) ) {
4143
					$error = 'cheatin';
4144
					break;
4145
				}
4146
4147
				$module = stripslashes( $_GET['module'] );
4148
				check_admin_referer( "jetpack_activate-$module" );
4149
				Jetpack::log( 'activate', $module );
4150
				if ( ! Jetpack::activate_module( $module ) ) {
4151
					Jetpack::state( 'error', sprintf( __( 'Could not activate %s', 'jetpack' ), $module ) );
4152
				}
4153
				// The following two lines will rarely happen, as Jetpack::activate_module normally exits at the end.
4154
				wp_safe_redirect( Jetpack::admin_url( 'page=jetpack' ) );
4155
				exit;
4156
			case 'activate_default_modules' :
4157
				check_admin_referer( 'activate_default_modules' );
4158
				Jetpack::log( 'activate_default_modules' );
4159
				Jetpack::restate();
4160
				$min_version   = isset( $_GET['min_version'] ) ? $_GET['min_version'] : false;
4161
				$max_version   = isset( $_GET['max_version'] ) ? $_GET['max_version'] : false;
4162
				$other_modules = isset( $_GET['other_modules'] ) && is_array( $_GET['other_modules'] ) ? $_GET['other_modules'] : array();
4163
				Jetpack::activate_default_modules( $min_version, $max_version, $other_modules );
4164
				wp_safe_redirect( Jetpack::admin_url( 'page=jetpack' ) );
4165
				exit;
4166
			case 'disconnect' :
4167
				if ( ! current_user_can( 'jetpack_disconnect' ) ) {
4168
					$error = 'cheatin';
4169
					break;
4170
				}
4171
4172
				check_admin_referer( 'jetpack-disconnect' );
4173
				Jetpack::log( 'disconnect' );
4174
				Jetpack::disconnect();
4175
				wp_safe_redirect( Jetpack::admin_url( 'disconnected=true' ) );
4176
				exit;
0 ignored issues
show
Coding Style Compatibility introduced by
The method admin_page_load() contains an exit expression.

An exit expression should only be used in rare cases. For example, if you write a short command line script.

In most cases however, using an exit expression makes the code untestable and often causes incompatibilities with other libraries. Thus, unless you are absolutely sure it is required here, we recommend to refactor your code to avoid its usage.

Loading history...
4177
			case 'reconnect' :
4178
				if ( ! current_user_can( 'jetpack_reconnect' ) ) {
4179
					$error = 'cheatin';
4180
					break;
4181
				}
4182
4183
				check_admin_referer( 'jetpack-reconnect' );
4184
				Jetpack::log( 'reconnect' );
4185
				$this->disconnect();
4186
				wp_redirect( $this->build_connect_url( true, false, 'reconnect' ) );
4187
				exit;
4188 View Code Duplication
			case 'deactivate' :
4189
				if ( ! current_user_can( 'jetpack_deactivate_modules' ) ) {
4190
					$error = 'cheatin';
4191
					break;
4192
				}
4193
4194
				$modules = stripslashes( $_GET['module'] );
4195
				check_admin_referer( "jetpack_deactivate-$modules" );
4196
				foreach ( explode( ',', $modules ) as $module ) {
4197
					Jetpack::log( 'deactivate', $module );
4198
					Jetpack::deactivate_module( $module );
4199
					Jetpack::state( 'message', 'module_deactivated' );
4200
				}
4201
				Jetpack::state( 'module', $modules );
4202
				wp_safe_redirect( Jetpack::admin_url( 'page=jetpack' ) );
4203
				exit;
4204
			case 'unlink' :
4205
				$redirect = isset( $_GET['redirect'] ) ? $_GET['redirect'] : '';
4206
				check_admin_referer( 'jetpack-unlink' );
4207
				Jetpack::log( 'unlink' );
4208
				$this->unlink_user();
4209
				Jetpack::state( 'message', 'unlinked' );
4210
				if ( 'sub-unlink' == $redirect ) {
4211
					wp_safe_redirect( admin_url() );
4212
				} else {
4213
					wp_safe_redirect( Jetpack::admin_url( array( 'page' => $redirect ) ) );
4214
				}
4215
				exit;
4216
			case 'onboard' :
4217
				if ( ! current_user_can( 'manage_options' ) ) {
4218
					wp_safe_redirect( Jetpack::admin_url( 'page=jetpack' ) );
4219
				} else {
4220
					Jetpack::create_onboarding_token();
4221
					$url = $this->build_connect_url( true );
4222
4223
					if ( false !== ( $token = Jetpack_Options::get_option( 'onboarding' ) ) ) {
4224
						$url = add_query_arg( 'onboarding', $token, $url );
4225
					}
4226
4227
					$calypso_env = ! empty( $_GET[ 'calypso_env' ] ) ? $_GET[ 'calypso_env' ] : false;
4228
					if ( $calypso_env ) {
4229
						$url = add_query_arg( 'calypso_env', $calypso_env, $url );
4230
					}
4231
4232
					wp_redirect( $url );
4233
					exit;
4234
				}
4235
				exit;
4236
			default:
4237
				/**
4238
				 * Fires when a Jetpack admin page is loaded with an unrecognized parameter.
4239
				 *
4240
				 * @since 2.6.0
4241
				 *
4242
				 * @param string sanitize_key( $_GET['action'] ) Unrecognized URL parameter.
4243
				 */
4244
				do_action( 'jetpack_unrecognized_action', sanitize_key( $_GET['action'] ) );
4245
			}
4246
		}
4247
4248
		if ( ! $error = $error ? $error : Jetpack::state( 'error' ) ) {
4249
			self::activate_new_modules( true );
4250
		}
4251
4252
		$message_code = Jetpack::state( 'message' );
4253
		if ( Jetpack::state( 'optin-manage' ) ) {
4254
			$activated_manage = $message_code;
4255
			$message_code = 'jetpack-manage';
4256
		}
4257
4258
		switch ( $message_code ) {
4259
		case 'jetpack-manage':
4260
			$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>';
4261
			if ( $activated_manage ) {
4262
				$this->message .= '<br /><strong>' . __( 'Manage has been activated for you!', 'jetpack'  ) . '</strong>';
4263
			}
4264
			break;
4265
4266
		}
4267
4268
		$deactivated_plugins = Jetpack::state( 'deactivated_plugins' );
4269
4270
		if ( ! empty( $deactivated_plugins ) ) {
4271
			$deactivated_plugins = explode( ',', $deactivated_plugins );
4272
			$deactivated_titles  = array();
4273
			foreach ( $deactivated_plugins as $deactivated_plugin ) {
4274
				if ( ! isset( $this->plugins_to_deactivate[$deactivated_plugin] ) ) {
4275
					continue;
4276
				}
4277
4278
				$deactivated_titles[] = '<strong>' . str_replace( ' ', '&nbsp;', $this->plugins_to_deactivate[$deactivated_plugin][1] ) . '</strong>';
4279
			}
4280
4281
			if ( $deactivated_titles ) {
4282
				if ( $this->message ) {
4283
					$this->message .= "<br /><br />\n";
4284
				}
4285
4286
				$this->message .= wp_sprintf(
4287
					_n(
4288
						'Jetpack contains the most recent version of the old %l plugin.',
4289
						'Jetpack contains the most recent versions of the old %l plugins.',
4290
						count( $deactivated_titles ),
4291
						'jetpack'
4292
					),
4293
					$deactivated_titles
4294
				);
4295
4296
				$this->message .= "<br />\n";
4297
4298
				$this->message .= _n(
4299
					'The old version has been deactivated and can be removed from your site.',
4300
					'The old versions have been deactivated and can be removed from your site.',
4301
					count( $deactivated_titles ),
4302
					'jetpack'
4303
				);
4304
			}
4305
		}
4306
4307
		$this->privacy_checks = Jetpack::state( 'privacy_checks' );
4308
4309
		if ( $this->message || $this->error || $this->privacy_checks || $this->can_display_jetpack_manage_notice() ) {
4310
			add_action( 'jetpack_notices', array( $this, 'admin_notices' ) );
4311
		}
4312
4313 View Code Duplication
		if ( isset( $_GET['configure'] ) && Jetpack::is_module( $_GET['configure'] ) && current_user_can( 'manage_options' ) ) {
4314
			/**
4315
			 * Fires when a module configuration page is loaded.
4316
			 * The dynamic part of the hook is the configure parameter from the URL.
4317
			 *
4318
			 * @since 1.1.0
4319
			 */
4320
			do_action( 'jetpack_module_configuration_load_' . $_GET['configure'] );
4321
		}
4322
4323
		add_filter( 'jetpack_short_module_description', 'wptexturize' );
4324
	}
4325
4326
	function admin_notices() {
4327
4328
		if ( $this->error ) {
4329
?>
4330
<div id="message" class="jetpack-message jetpack-err">
4331
	<div class="squeezer">
4332
		<h2><?php echo wp_kses( $this->error, array( 'a' => array( 'href' => array() ), 'small' => true, 'code' => true, 'strong' => true, 'br' => true, 'b' => true ) ); ?></h2>
4333
<?php	if ( $desc = Jetpack::state( 'error_description' ) ) : ?>
4334
		<p><?php echo esc_html( stripslashes( $desc ) ); ?></p>
4335
<?php	endif; ?>
4336
	</div>
4337
</div>
4338
<?php
4339
		}
4340
4341
		if ( $this->message ) {
4342
?>
4343
<div id="message" class="jetpack-message">
4344
	<div class="squeezer">
4345
		<h2><?php echo wp_kses( $this->message, array( 'strong' => array(), 'a' => array( 'href' => true ), 'br' => true ) ); ?></h2>
4346
	</div>
4347
</div>
4348
<?php
4349
		}
4350
4351
		if ( $this->privacy_checks ) :
4352
			$module_names = $module_slugs = array();
4353
4354
			$privacy_checks = explode( ',', $this->privacy_checks );
4355
			$privacy_checks = array_filter( $privacy_checks, array( 'Jetpack', 'is_module' ) );
4356
			foreach ( $privacy_checks as $module_slug ) {
4357
				$module = Jetpack::get_module( $module_slug );
4358
				if ( ! $module ) {
4359
					continue;
4360
				}
4361
4362
				$module_slugs[] = $module_slug;
4363
				$module_names[] = "<strong>{$module['name']}</strong>";
4364
			}
4365
4366
			$module_slugs = join( ',', $module_slugs );
4367
?>
4368
<div id="message" class="jetpack-message jetpack-err">
4369
	<div class="squeezer">
4370
		<h2><strong><?php esc_html_e( 'Is this site private?', 'jetpack' ); ?></strong></h2><br />
4371
		<p><?php
4372
			echo wp_kses(
4373
				wptexturize(
4374
					wp_sprintf(
4375
						_nx(
4376
							"Like your site's RSS feeds, %l allows access to your posts and other content to third parties.",
4377
							"Like your site's RSS feeds, %l allow access to your posts and other content to third parties.",
4378
							count( $privacy_checks ),
4379
							'%l = list of Jetpack module/feature names',
4380
							'jetpack'
4381
						),
4382
						$module_names
4383
					)
4384
				),
4385
				array( 'strong' => true )
4386
			);
4387
4388
			echo "\n<br />\n";
4389
4390
			echo wp_kses(
4391
				sprintf(
4392
					_nx(
4393
						'If your site is not publicly accessible, consider <a href="%1$s" title="%2$s">deactivating this feature</a>.',
4394
						'If your site is not publicly accessible, consider <a href="%1$s" title="%2$s">deactivating these features</a>.',
4395
						count( $privacy_checks ),
4396
						'%1$s = deactivation URL, %2$s = "Deactivate {list of Jetpack module/feature names}',
4397
						'jetpack'
4398
					),
4399
					wp_nonce_url(
4400
						Jetpack::admin_url(
4401
							array(
4402
								'page'   => 'jetpack',
4403
								'action' => 'deactivate',
4404
								'module' => urlencode( $module_slugs ),
4405
							)
4406
						),
4407
						"jetpack_deactivate-$module_slugs"
4408
					),
4409
					esc_attr( wp_kses( wp_sprintf( _x( 'Deactivate %l', '%l = list of Jetpack module/feature names', 'jetpack' ), $module_names ), array() ) )
4410
				),
4411
				array( 'a' => array( 'href' => true, 'title' => true ) )
4412
			);
4413
		?></p>
4414
	</div>
4415
</div>
4416
<?php endif;
4417
	// only display the notice if the other stuff is not there
4418
	if( $this->can_display_jetpack_manage_notice() && !  $this->error && ! $this->message && ! $this->privacy_checks ) {
4419
		if( isset( $_GET['page'] ) && 'jetpack' != $_GET['page'] )
4420
			$this->opt_in_jetpack_manage_notice();
4421
		}
4422
	}
4423
4424
	/**
4425
	 * Record a stat for later output.  This will only currently output in the admin_footer.
4426
	 */
4427
	function stat( $group, $detail ) {
4428
		if ( ! isset( $this->stats[ $group ] ) )
4429
			$this->stats[ $group ] = array();
4430
		$this->stats[ $group ][] = $detail;
4431
	}
4432
4433
	/**
4434
	 * Load stats pixels. $group is auto-prefixed with "x_jetpack-"
4435
	 */
4436
	function do_stats( $method = '' ) {
4437
		if ( is_array( $this->stats ) && count( $this->stats ) ) {
4438
			foreach ( $this->stats as $group => $stats ) {
4439
				if ( is_array( $stats ) && count( $stats ) ) {
4440
					$args = array( "x_jetpack-{$group}" => implode( ',', $stats ) );
4441
					if ( 'server_side' === $method ) {
4442
						self::do_server_side_stat( $args );
4443
					} else {
4444
						echo '<img src="' . esc_url( self::build_stats_url( $args ) ) . '" width="1" height="1" style="display:none;" />';
4445
					}
4446
				}
4447
				unset( $this->stats[ $group ] );
4448
			}
4449
		}
4450
	}
4451
4452
	/**
4453
	 * Runs stats code for a one-off, server-side.
4454
	 *
4455
	 * @param $args array|string The arguments to append to the URL. Should include `x_jetpack-{$group}={$stats}` or whatever we want to store.
4456
	 *
4457
	 * @return bool If it worked.
4458
	 */
4459
	static function do_server_side_stat( $args ) {
4460
		$response = wp_remote_get( esc_url_raw( self::build_stats_url( $args ) ) );
4461
		if ( is_wp_error( $response ) )
4462
			return false;
4463
4464
		if ( 200 !== wp_remote_retrieve_response_code( $response ) )
4465
			return false;
4466
4467
		return true;
4468
	}
4469
4470
	/**
4471
	 * Builds the stats url.
4472
	 *
4473
	 * @param $args array|string The arguments to append to the URL.
4474
	 *
4475
	 * @return string The URL to be pinged.
4476
	 */
4477
	static function build_stats_url( $args ) {
4478
		$defaults = array(
4479
			'v'    => 'wpcom2',
4480
			'rand' => md5( mt_rand( 0, 999 ) . time() ),
4481
		);
4482
		$args     = wp_parse_args( $args, $defaults );
4483
		/**
4484
		 * Filter the URL used as the Stats tracking pixel.
4485
		 *
4486
		 * @since 2.3.2
4487
		 *
4488
		 * @param string $url Base URL used as the Stats tracking pixel.
4489
		 */
4490
		$base_url = apply_filters(
4491
			'jetpack_stats_base_url',
4492
			'https://pixel.wp.com/g.gif'
4493
		);
4494
		$url      = add_query_arg( $args, $base_url );
4495
		return $url;
4496
	}
4497
4498
	static function translate_current_user_to_role() {
4499
		foreach ( self::$capability_translations as $role => $cap ) {
4500
			if ( current_user_can( $role ) || current_user_can( $cap ) ) {
4501
				return $role;
4502
			}
4503
		}
4504
4505
		return false;
4506
	}
4507
4508
	static function translate_user_to_role( $user ) {
4509
		foreach ( self::$capability_translations as $role => $cap ) {
4510
			if ( user_can( $user, $role ) || user_can( $user, $cap ) ) {
4511
				return $role;
4512
			}
4513
		}
4514
4515
		return false;
4516
    }
4517
4518
	static function translate_role_to_cap( $role ) {
4519
		if ( ! isset( self::$capability_translations[$role] ) ) {
4520
			return false;
4521
		}
4522
4523
		return self::$capability_translations[$role];
4524
	}
4525
4526
	static function sign_role( $role, $user_id = null ) {
4527
		if ( empty( $user_id ) ) {
4528
			$user_id = (int) get_current_user_id();
4529
		}
4530
4531
		if ( ! $user_id  ) {
4532
			return false;
4533
		}
4534
4535
		$token = Jetpack_Data::get_access_token();
4536
		if ( ! $token || is_wp_error( $token ) ) {
4537
			return false;
4538
		}
4539
4540
		return $role . ':' . hash_hmac( 'md5', "{$role}|{$user_id}", $token->secret );
4541
	}
4542
4543
4544
	/**
4545
	 * Builds a URL to the Jetpack connection auth page
4546
	 *
4547
	 * @since 3.9.5
4548
	 *
4549
	 * @param bool $raw If true, URL will not be escaped.
4550
	 * @param bool|string $redirect If true, will redirect back to Jetpack wp-admin landing page after connection.
4551
	 *                              If string, will be a custom redirect.
4552
	 * @param bool|string $from If not false, adds 'from=$from' param to the connect URL.
4553
	 * @param bool $register If true, will generate a register URL regardless of the existing token, since 4.9.0
4554
	 *
4555
	 * @return string Connect URL
4556
	 */
4557
	function build_connect_url( $raw = false, $redirect = false, $from = false, $register = false ) {
4558
		$site_id = Jetpack_Options::get_option( 'id' );
4559
		$token = Jetpack_Options::get_option( 'blog_token' );
4560
4561
		if ( $register || ! $token || ! $site_id ) {
4562
			$url = Jetpack::nonce_url_no_esc( Jetpack::admin_url( 'action=register' ), 'jetpack-register' );
4563
4564
			if ( ! empty( $redirect ) ) {
4565
				$url = add_query_arg(
4566
					'redirect',
4567
					urlencode( wp_validate_redirect( esc_url_raw( $redirect ) ) ),
4568
					$url
4569
				);
4570
			}
4571
4572
			if( is_network_admin() ) {
4573
				$url = add_query_arg( 'is_multisite', network_admin_url( 'admin.php?page=jetpack-settings' ), $url );
4574
			}
4575
		} else {
4576
4577
			// Let's check the existing blog token to see if we need to re-register. We only check once per minute
4578
			// because otherwise this logic can get us in to a loop.
4579
			$last_connect_url_check = intval( Jetpack_Options::get_raw_option( 'jetpack_last_connect_url_check' ) );
4580
			if ( ! $last_connect_url_check || ( time() - $last_connect_url_check ) > MINUTE_IN_SECONDS ) {
4581
				Jetpack_Options::update_raw_option( 'jetpack_last_connect_url_check', time() );
4582
4583
				$response = Jetpack_Client::wpcom_json_api_request_as_blog(
4584
					sprintf( '/sites/%d', $site_id ) .'?force=wpcom',
4585
					'1.1'
4586
				);
4587
4588
				if ( 200 !== wp_remote_retrieve_response_code( $response ) ) {
4589
					// Generating a register URL instead to refresh the existing token
4590
					return $this->build_connect_url( $raw, $redirect, $from, true );
4591
				}
4592
			}
4593
4594
			if ( defined( 'JETPACK__GLOTPRESS_LOCALES_PATH' ) && include_once JETPACK__GLOTPRESS_LOCALES_PATH ) {
4595
				$gp_locale = GP_Locales::by_field( 'wp_locale', get_locale() );
4596
			}
4597
4598
			$role = self::translate_current_user_to_role();
4599
			$signed_role = self::sign_role( $role );
4600
4601
			$user = wp_get_current_user();
4602
4603
			$jetpack_admin_page = esc_url_raw( admin_url( 'admin.php?page=jetpack' ) );
4604
			$redirect = $redirect
4605
				? wp_validate_redirect( esc_url_raw( $redirect ), $jetpack_admin_page )
4606
				: $jetpack_admin_page;
4607
4608
			if( isset( $_REQUEST['is_multisite'] ) ) {
4609
				$redirect = Jetpack_Network::init()->get_url( 'network_admin_page' );
4610
			}
4611
4612
			$secrets = Jetpack::generate_secrets( 'authorize', false, 2 * HOUR_IN_SECONDS );
4613
4614
			$site_icon = ( function_exists( 'has_site_icon') && has_site_icon() )
4615
				? get_site_icon_url()
4616
				: false;
4617
4618
			/**
4619
			 * Filter the type of authorization.
4620
			 * 'calypso' completes authorization on wordpress.com/jetpack/connect
4621
			 * while 'jetpack' ( or any other value ) completes the authorization at jetpack.wordpress.com.
4622
			 *
4623
			 * @since 4.3.3
4624
			 *
4625
			 * @param string $auth_type Defaults to 'calypso', can also be 'jetpack'.
4626
			 */
4627
			$auth_type = apply_filters( 'jetpack_auth_type', 'calypso' );
4628
4629
			$tracks_identity = jetpack_tracks_get_identity( get_current_user_id() );
4630
4631
			$args = urlencode_deep(
4632
				array(
4633
					'response_type' => 'code',
4634
					'client_id'     => Jetpack_Options::get_option( 'id' ),
4635
					'redirect_uri'  => add_query_arg(
4636
						array(
4637
							'action'   => 'authorize',
4638
							'_wpnonce' => wp_create_nonce( "jetpack-authorize_{$role}_{$redirect}" ),
4639
							'redirect' => urlencode( $redirect ),
4640
						),
4641
						esc_url( admin_url( 'admin.php?page=jetpack' ) )
4642
					),
4643
					'state'         => $user->ID,
4644
					'scope'         => $signed_role,
4645
					'user_email'    => $user->user_email,
4646
					'user_login'    => $user->user_login,
4647
					'is_active'     => Jetpack::is_active(),
4648
					'jp_version'    => JETPACK__VERSION,
4649
					'auth_type'     => $auth_type,
4650
					'secret'        => $secrets['secret_1'],
4651
					'locale'        => ( isset( $gp_locale ) && isset( $gp_locale->slug ) ) ? $gp_locale->slug : '',
4652
					'blogname'      => get_option( 'blogname' ),
4653
					'site_url'      => site_url(),
4654
					'home_url'      => home_url(),
4655
					'site_icon'     => $site_icon,
4656
					'site_lang'     => get_locale(),
4657
					'_ui'           => $tracks_identity['_ui'],
4658
					'_ut'           => $tracks_identity['_ut']
4659
				)
4660
			);
4661
4662
			self::apply_activation_source_to_args( $args );
4663
4664
			$url = add_query_arg( $args, Jetpack::api_url( 'authorize' ) );
4665
		}
4666
4667
		if ( $from ) {
4668
			$url = add_query_arg( 'from', $from, $url );
4669
		}
4670
4671
4672
		if ( isset( $_GET['calypso_env'] ) ) {
4673
			$url = add_query_arg( 'calypso_env', sanitize_key( $_GET['calypso_env'] ), $url );
4674
		}
4675
4676
		return $raw ? $url : esc_url( $url );
4677
	}
4678
4679
	public static function apply_activation_source_to_args( &$args ) {
4680
		list( $activation_source_name, $activation_source_keyword ) = get_option( 'jetpack_activation_source' );
4681
4682
		if ( $activation_source_name ) {
4683
			$args['_as'] = urlencode( $activation_source_name );
4684
		}
4685
4686
		if ( $activation_source_keyword ) {
4687
			$args['_ak'] = urlencode( $activation_source_keyword );
4688
		}
4689
	}
4690
4691
	function build_reconnect_url( $raw = false ) {
4692
		$url = wp_nonce_url( Jetpack::admin_url( 'action=reconnect' ), 'jetpack-reconnect' );
4693
		return $raw ? $url : esc_url( $url );
4694
	}
4695
4696
	public static function admin_url( $args = null ) {
4697
		$args = wp_parse_args( $args, array( 'page' => 'jetpack' ) );
4698
		$url = add_query_arg( $args, admin_url( 'admin.php' ) );
4699
		return $url;
4700
	}
4701
4702
	public static function nonce_url_no_esc( $actionurl, $action = -1, $name = '_wpnonce' ) {
4703
		$actionurl = str_replace( '&amp;', '&', $actionurl );
4704
		return add_query_arg( $name, wp_create_nonce( $action ), $actionurl );
4705
	}
4706
4707
	function dismiss_jetpack_notice() {
4708
4709
		if ( ! isset( $_GET['jetpack-notice'] ) ) {
4710
			return;
4711
		}
4712
4713
		switch( $_GET['jetpack-notice'] ) {
4714
			case 'dismiss':
4715
				if ( check_admin_referer( 'jetpack-deactivate' ) && ! is_plugin_active_for_network( plugin_basename( JETPACK__PLUGIN_DIR . 'jetpack.php' ) ) ) {
4716
4717
					require_once ABSPATH . 'wp-admin/includes/plugin.php';
4718
					deactivate_plugins( JETPACK__PLUGIN_DIR . 'jetpack.php', false, false );
4719
					wp_safe_redirect( admin_url() . 'plugins.php?deactivate=true&plugin_status=all&paged=1&s=' );
4720
				}
4721
				break;
4722 View Code Duplication
			case 'jetpack-manage-opt-out':
4723
4724
				if ( check_admin_referer( 'jetpack_manage_banner_opt_out' ) ) {
4725
					// Don't show the banner again
4726
4727
					Jetpack_Options::update_option( 'dismissed_manage_banner', true );
4728
					// redirect back to the page that had the notice
4729
					if ( wp_get_referer() ) {
4730
						wp_safe_redirect( wp_get_referer() );
4731
					} else {
4732
						// Take me to Jetpack
4733
						wp_safe_redirect( admin_url( 'admin.php?page=jetpack' ) );
4734
					}
4735
				}
4736
				break;
4737 View Code Duplication
			case 'jetpack-protect-multisite-opt-out':
4738
4739
				if ( check_admin_referer( 'jetpack_protect_multisite_banner_opt_out' ) ) {
4740
					// Don't show the banner again
4741
4742
					update_site_option( 'jetpack_dismissed_protect_multisite_banner', true );
4743
					// redirect back to the page that had the notice
4744
					if ( wp_get_referer() ) {
4745
						wp_safe_redirect( wp_get_referer() );
4746
					} else {
4747
						// Take me to Jetpack
4748
						wp_safe_redirect( admin_url( 'admin.php?page=jetpack' ) );
4749
					}
4750
				}
4751
				break;
4752
			case 'jetpack-manage-opt-in':
4753
				if ( check_admin_referer( 'jetpack_manage_banner_opt_in' ) ) {
4754
					// This makes sure that we are redirect to jetpack home so that we can see the Success Message.
4755
4756
					$redirection_url = Jetpack::admin_url();
4757
					remove_action( 'jetpack_pre_activate_module',   array( Jetpack_Admin::init(), 'fix_redirect' ) );
4758
4759
					// Don't redirect form the Jetpack Setting Page
4760
					$referer_parsed = parse_url ( wp_get_referer() );
4761
					// check that we do have a wp_get_referer and the query paramater is set orderwise go to the Jetpack Home
4762
					if ( isset( $referer_parsed['query'] ) && false !== strpos( $referer_parsed['query'], 'page=jetpack_modules' ) ) {
4763
						// Take the user to Jetpack home except when on the setting page
4764
						$redirection_url = wp_get_referer();
4765
						add_action( 'jetpack_pre_activate_module',   array( Jetpack_Admin::init(), 'fix_redirect' ) );
4766
					}
4767
					// Also update the JSON API FULL MANAGEMENT Option
4768
					Jetpack::activate_module( 'manage', false, false );
4769
4770
					// Special Message when option in.
4771
					Jetpack::state( 'optin-manage', 'true' );
4772
					// Activate the Module if not activated already
4773
4774
					// Redirect properly
4775
					wp_safe_redirect( $redirection_url );
4776
4777
				}
4778
				break;
4779
		}
4780
	}
4781
4782
	public static function admin_screen_configure_module( $module_id ) {
4783
4784
		// User that doesn't have 'jetpack_configure_modules' will never end up here since Jetpack Landing Page woun't let them.
4785
		if ( ! in_array( $module_id, Jetpack::get_active_modules() ) && current_user_can( 'manage_options' ) ) {
4786
			if ( has_action( 'display_activate_module_setting_' . $module_id ) ) {
4787
				/**
4788
				 * Fires to diplay a custom module activation screen.
4789
				 *
4790
				 * To add a module actionation screen use Jetpack::module_configuration_activation_screen method.
4791
				 * Example: Jetpack::module_configuration_activation_screen( 'manage', array( $this, 'manage_activate_screen' ) );
4792
				 *
4793
				 * @module manage
4794
				 *
4795
				 * @since 3.8.0
4796
				 *
4797
				 * @param int $module_id Module ID.
4798
				 */
4799
				do_action( 'display_activate_module_setting_' . $module_id );
4800
			} else {
4801
				self::display_activate_module_link( $module_id );
4802
			}
4803
4804
			return false;
4805
		} ?>
4806
4807
		<div id="jp-settings-screen" style="position: relative">
4808
			<h3>
4809
			<?php
4810
				$module = Jetpack::get_module( $module_id );
4811
				echo '<a href="' . Jetpack::admin_url( 'page=jetpack_modules' ) . '">' . __( 'Jetpack by WordPress.com', 'jetpack' ) . '</a> &rarr; ';
4812
				printf( __( 'Configure %s', 'jetpack' ), $module['name'] );
4813
			?>
4814
			</h3>
4815
			<?php
4816
				/**
4817
				 * Fires within the displayed message when a feature configuation is updated.
4818
				 *
4819
				 * @since 3.4.0
4820
				 *
4821
				 * @param int $module_id Module ID.
4822
				 */
4823
				do_action( 'jetpack_notices_update_settings', $module_id );
4824
				/**
4825
				 * Fires when a feature configuation screen is loaded.
4826
				 * The dynamic part of the hook, $module_id, is the module ID.
4827
				 *
4828
				 * @since 1.1.0
4829
				 */
4830
				do_action( 'jetpack_module_configuration_screen_' . $module_id );
4831
			?>
4832
		</div><?php
4833
	}
4834
4835
	/**
4836
	 * Display link to activate the module to see the settings screen.
4837
	 * @param  string $module_id
4838
	 * @return null
4839
	 */
4840
	public static function display_activate_module_link( $module_id ) {
4841
4842
		$info =  Jetpack::get_module( $module_id );
4843
		$extra = '';
4844
		$activate_url = wp_nonce_url(
4845
				Jetpack::admin_url(
4846
					array(
4847
						'page'   => 'jetpack',
4848
						'action' => 'activate',
4849
						'module' => $module_id,
4850
					)
4851
				),
4852
				"jetpack_activate-$module_id"
4853
			);
4854
4855
		?>
4856
4857
		<div class="wrap configure-module">
4858
			<div id="jp-settings-screen">
4859
				<?php
4860
				if ( $module_id == 'json-api' ) {
4861
4862
					$info['name'] = esc_html__( 'Activate Site Management and JSON API', 'jetpack' );
4863
4864
					$activate_url = Jetpack::init()->opt_in_jetpack_manage_url();
4865
4866
					$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' );
4867
4868
					// $extra = __( 'To use Site Management, you need to first activate JSON API to allow remote management of your site. ', 'jetpack' );
4869
				} ?>
4870
4871
				<h3><?php echo esc_html( $info['name'] ); ?></h3>
4872
				<div class="narrow">
4873
					<p><?php echo  $info['description']; ?></p>
4874
					<?php if( $extra ) { ?>
4875
					<p><?php echo esc_html( $extra ); ?></p>
4876
					<?php } ?>
4877
					<p>
4878
						<?php
4879
						if( wp_get_referer() ) {
4880
							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() );
4881
						} else {
4882
							printf( __( '<a class="button-primary" href="%s">Activate Now</a>', 'jetpack' ) , $activate_url  );
4883
						} ?>
4884
					</p>
4885
				</div>
4886
4887
			</div>
4888
		</div>
4889
4890
		<?php
4891
	}
4892
4893
	public static function sort_modules( $a, $b ) {
4894
		if ( $a['sort'] == $b['sort'] )
4895
			return 0;
4896
4897
		return ( $a['sort'] < $b['sort'] ) ? -1 : 1;
4898
	}
4899
4900
	function ajax_recheck_ssl() {
4901
		check_ajax_referer( 'recheck-ssl', 'ajax-nonce' );
4902
		$result = Jetpack::permit_ssl( true );
4903
		wp_send_json( array(
4904
			'enabled' => $result,
4905
			'message' => get_transient( 'jetpack_https_test_message' )
4906
		) );
4907
	}
4908
4909
/* Client API */
4910
4911
	/**
4912
	 * Returns the requested Jetpack API URL
4913
	 *
4914
	 * @return string
4915
	 */
4916
	public static function api_url( $relative_url ) {
4917
		return trailingslashit( JETPACK__API_BASE . $relative_url  ) . JETPACK__API_VERSION . '/';
4918
	}
4919
4920
	/**
4921
	 * Some hosts disable the OpenSSL extension and so cannot make outgoing HTTPS requsets
4922
	 */
4923
	public static function fix_url_for_bad_hosts( $url ) {
4924
		if ( 0 !== strpos( $url, 'https://' ) ) {
4925
			return $url;
4926
		}
4927
4928
		switch ( JETPACK_CLIENT__HTTPS ) {
4929
			case 'ALWAYS' :
4930
				return $url;
4931
			case 'NEVER' :
4932
				return set_url_scheme( $url, 'http' );
4933
			// default : case 'AUTO' :
4934
		}
4935
4936
		// we now return the unmodified SSL URL by default, as a security precaution
4937
		return $url;
4938
	}
4939
4940
	/**
4941
	 * Create a random secret for validating onboarding payload
4942
	 *
4943
	 * @return string Secret token
4944
	 */
4945
	public static function create_onboarding_token() {
4946
		if ( false === ( $token = Jetpack_Options::get_option( 'onboarding' ) ) ) {
4947
			$token = wp_generate_password( 32, false );
4948
			Jetpack_Options::update_option( 'onboarding', $token );
4949
		}
4950
4951
		return $token;
4952
	}
4953
4954
	/**
4955
	 * Remove the onboarding token
4956
	 *
4957
	 * @return bool True on success, false on failure
4958
	 */
4959
	public static function invalidate_onboarding_token() {
4960
		return Jetpack_Options::delete_option( 'onboarding' );
4961
	}
4962
4963
	/**
4964
	 * Validate an onboarding token for a specific action
4965
	 *
4966
	 * @return boolean True if token/action pair is accepted, false if not
4967
	 */
4968
	public static function validate_onboarding_token_action( $token, $action ) {
4969
		// Compare tokens, bail if tokens do not match
4970
		if ( ! hash_equals( $token, Jetpack_Options::get_option( 'onboarding' ) ) ) {
4971
			return false;
4972
		}
4973
4974
		// List of valid actions we can take
4975
		$valid_actions = array(
4976
			'/jetpack/v4/settings',
4977
		);
4978
4979
		// Whitelist the action
4980
		if ( ! in_array( $action, $valid_actions ) ) {
4981
			return false;
4982
		}
4983
4984
		return true;
4985
	}
4986
4987
	/**
4988
	 * Checks to see if the URL is using SSL to connect with Jetpack
4989
	 *
4990
	 * @since 2.3.3
4991
	 * @return boolean
4992
	 */
4993
	public static function permit_ssl( $force_recheck = false ) {
4994
		// Do some fancy tests to see if ssl is being supported
4995
		if ( $force_recheck || false === ( $ssl = get_transient( 'jetpack_https_test' ) ) ) {
4996
			$message = '';
4997
			if ( 'https' !== substr( JETPACK__API_BASE, 0, 5 ) ) {
4998
				$ssl = 0;
4999
			} else {
5000
				switch ( JETPACK_CLIENT__HTTPS ) {
5001
					case 'NEVER':
5002
						$ssl = 0;
5003
						$message = __( 'JETPACK_CLIENT__HTTPS is set to NEVER', 'jetpack' );
5004
						break;
5005
					case 'ALWAYS':
5006
					case 'AUTO':
5007
					default:
5008
						$ssl = 1;
5009
						break;
5010
				}
5011
5012
				// If it's not 'NEVER', test to see
5013
				if ( $ssl ) {
5014
					if ( ! wp_http_supports( array( 'ssl' => true ) ) ) {
5015
						$ssl = 0;
5016
						$message = __( 'WordPress reports no SSL support', 'jetpack' );
5017
					} else {
5018
						$response = wp_remote_get( JETPACK__API_BASE . 'test/1/' );
5019
						if ( is_wp_error( $response ) ) {
5020
							$ssl = 0;
5021
							$message = __( 'WordPress reports no SSL support', 'jetpack' );
5022
						} elseif ( 'OK' !== wp_remote_retrieve_body( $response ) ) {
5023
							$ssl = 0;
5024
							$message = __( 'Response was not OK: ', 'jetpack' ) . wp_remote_retrieve_body( $response );
5025
						}
5026
					}
5027
				}
5028
			}
5029
			set_transient( 'jetpack_https_test', $ssl, DAY_IN_SECONDS );
5030
			set_transient( 'jetpack_https_test_message', $message, DAY_IN_SECONDS );
5031
		}
5032
5033
		return (bool) $ssl;
5034
	}
5035
5036
	/*
5037
	 * Displays an admin_notice, alerting the user to their JETPACK_CLIENT__HTTPS constant being 'AUTO' but SSL isn't working.
5038
	 */
5039
	public function alert_auto_ssl_fail() {
5040
		if ( ! current_user_can( 'manage_options' ) )
5041
			return;
5042
5043
		$ajax_nonce = wp_create_nonce( 'recheck-ssl' );
5044
		?>
5045
5046
		<div id="jetpack-ssl-warning" class="error jp-identity-crisis">
5047
			<div class="jp-banner__content">
5048
				<h2><?php _e( 'Outbound HTTPS not working', 'jetpack' ); ?></h2>
5049
				<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>
5050
				<p>
5051
					<?php _e( 'Jetpack will re-test for HTTPS support once a day, but you can click here to try again immediately: ', 'jetpack' ); ?>
5052
					<a href="#" id="jetpack-recheck-ssl-button"><?php _e( 'Try again', 'jetpack' ); ?></a>
5053
					<span id="jetpack-recheck-ssl-output"><?php echo get_transient( 'jetpack_https_test_message' ); ?></span>
5054
				</p>
5055
				<p>
5056
					<?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' ),
5057
							esc_url( Jetpack::admin_url( array( 'page' => 'jetpack-debugger' )  ) ),
5058
							esc_url( 'https://jetpack.com/support/getting-started-with-jetpack/troubleshooting-tips/' ) ); ?>
5059
				</p>
5060
			</div>
5061
		</div>
5062
		<style>
5063
			#jetpack-recheck-ssl-output { margin-left: 5px; color: red; }
5064
		</style>
5065
		<script type="text/javascript">
5066
			jQuery( document ).ready( function( $ ) {
5067
				$( '#jetpack-recheck-ssl-button' ).click( function( e ) {
5068
					var $this = $( this );
5069
					$this.html( <?php echo json_encode( __( 'Checking', 'jetpack' ) ); ?> );
5070
					$( '#jetpack-recheck-ssl-output' ).html( '' );
5071
					e.preventDefault();
5072
					var data = { action: 'jetpack-recheck-ssl', 'ajax-nonce': '<?php echo $ajax_nonce; ?>' };
5073
					$.post( ajaxurl, data )
5074
					  .done( function( response ) {
5075
					  	if ( response.enabled ) {
5076
					  		$( '#jetpack-ssl-warning' ).hide();
5077
					  	} else {
5078
					  		this.html( <?php echo json_encode( __( 'Try again', 'jetpack' ) ); ?> );
5079
					  		$( '#jetpack-recheck-ssl-output' ).html( 'SSL Failed: ' + response.message );
5080
					  	}
5081
					  }.bind( $this ) );
5082
				} );
5083
			} );
5084
		</script>
5085
5086
		<?php
5087
	}
5088
5089
	/**
5090
	 * Returns the Jetpack XML-RPC API
5091
	 *
5092
	 * @return string
5093
	 */
5094
	public static function xmlrpc_api_url() {
5095
		$base = preg_replace( '#(https?://[^?/]+)(/?.*)?$#', '\\1', JETPACK__API_BASE );
5096
		return untrailingslashit( $base ) . '/xmlrpc.php';
5097
	}
5098
5099
	/**
5100
	 * Creates two secret tokens and the end of life timestamp for them.
5101
	 *
5102
	 * Note these tokens are unique per call, NOT static per site for connecting.
5103
	 *
5104
	 * @since 2.6
5105
	 * @return array
5106
	 */
5107
	public static function generate_secrets( $action, $user_id = false, $exp = 600 ) {
5108
		if ( ! $user_id ) {
5109
			$user_id = get_current_user_id();
5110
		}
5111
5112
		$secret_name  = 'jetpack_' . $action . '_' . $user_id;
5113
		$secrets      = Jetpack_Options::get_raw_option( 'jetpack_secrets', array() );
5114
5115
		if (
5116
			isset( $secrets[ $secret_name ] ) &&
5117
			$secrets[ $secret_name ]['exp'] > time()
5118
		) {
5119
			return $secrets[ $secret_name ];
5120
		}
5121
5122
		$secret_value = array(
5123
			'secret_1'  => wp_generate_password( 32, false ),
5124
			'secret_2'  => wp_generate_password( 32, false ),
5125
			'exp'       => time() + $exp,
5126
		);
5127
5128
		$secrets[ $secret_name ] = $secret_value;
5129
5130
		Jetpack_Options::update_raw_option( 'jetpack_secrets', $secrets );
5131
		return $secrets[ $secret_name ];
5132
	}
5133
5134
	public static function get_secrets( $action, $user_id ) {
5135
		$secret_name = 'jetpack_' . $action . '_' . $user_id;
5136
		$secrets = Jetpack_Options::get_raw_option( 'jetpack_secrets', array() );
5137
5138
		if ( ! isset( $secrets[ $secret_name ] ) ) {
5139
			return new WP_Error( 'verify_secrets_missing', 'Verification secrets not found' );
5140
		}
5141
5142
		if ( $secrets[ $secret_name ]['exp'] < time() ) {
5143
			self::delete_secrets( $action, $user_id );
5144
			return new WP_Error( 'verify_secrets_expired', 'Verification took too long' );
5145
		}
5146
5147
		return $secrets[ $secret_name ];
5148
	}
5149
5150
	public static function delete_secrets( $action, $user_id ) {
5151
		$secret_name = 'jetpack_' . $action . '_' . $user_id;
5152
		$secrets = Jetpack_Options::get_raw_option( 'jetpack_secrets', array() );
5153
		if ( isset( $secrets[ $secret_name ] ) ) {
5154
			unset( $secrets[ $secret_name ] );
5155
			Jetpack_Options::update_raw_option( 'jetpack_secrets', $secrets );
5156
		}
5157
	}
5158
5159
	/**
5160
	 * Builds the timeout limit for queries talking with the wpcom servers.
5161
	 *
5162
	 * Based on local php max_execution_time in php.ini
5163
	 *
5164
	 * @since 2.6
5165
	 * @return int
5166
	 * @deprecated
5167
	 **/
5168
	public function get_remote_query_timeout_limit() {
5169
		_deprecated_function( __METHOD__, 'jetpack-5.4' );
5170
		return Jetpack::get_max_execution_time();
5171
	}
5172
5173
	/**
5174
	 * Builds the timeout limit for queries talking with the wpcom servers.
5175
	 *
5176
	 * Based on local php max_execution_time in php.ini
5177
	 *
5178
	 * @since 5.4
5179
	 * @return int
5180
	 **/
5181
	public static function get_max_execution_time() {
5182
		$timeout = (int) ini_get( 'max_execution_time' );
5183
5184
		// Ensure exec time set in php.ini
5185
		if ( ! $timeout ) {
5186
			$timeout = 30;
5187
		}
5188
		return $timeout;
5189
	}
5190
5191
	/**
5192
	 * Sets a minimum request timeout, and returns the current timeout
5193
	 *
5194
	 * @since 5.4
5195
	 **/
5196
	public static function set_min_time_limit( $min_timeout ) {
5197
		$timeout = self::get_max_execution_time();
5198
		if ( $timeout < $min_timeout ) {
5199
			$timeout = $min_timeout;
5200
			set_time_limit( $timeout );
5201
		}
5202
		return $timeout;
5203
	}
5204
5205
5206
	/**
5207
	 * Takes the response from the Jetpack register new site endpoint and
5208
	 * verifies it worked properly.
5209
	 *
5210
	 * @since 2.6
5211
	 * @return string|Jetpack_Error A JSON object on success or Jetpack_Error on failures
5212
	 **/
5213
	public function validate_remote_register_response( $response ) {
5214
	  if ( is_wp_error( $response ) ) {
5215
			return new Jetpack_Error( 'register_http_request_failed', $response->get_error_message() );
5216
		}
5217
5218
		$code   = wp_remote_retrieve_response_code( $response );
5219
		$entity = wp_remote_retrieve_body( $response );
5220
		if ( $entity )
5221
			$registration_response = json_decode( $entity );
5222
		else
5223
			$registration_response = false;
5224
5225
		$code_type = intval( $code / 100 );
5226
		if ( 5 == $code_type ) {
5227
			return new Jetpack_Error( 'wpcom_5??', sprintf( __( 'Error Details: %s', 'jetpack' ), $code ), $code );
5228
		} elseif ( 408 == $code ) {
5229
			return new Jetpack_Error( 'wpcom_408', sprintf( __( 'Error Details: %s', 'jetpack' ), $code ), $code );
5230
		} elseif ( ! empty( $registration_response->error ) ) {
5231
			if ( 'xml_rpc-32700' == $registration_response->error && ! function_exists( 'xml_parser_create' ) ) {
5232
				$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' );
5233
			} else {
5234
				$error_description = isset( $registration_response->error_description ) ? sprintf( __( 'Error Details: %s', 'jetpack' ), (string) $registration_response->error_description ) : '';
5235
			}
5236
5237
			return new Jetpack_Error( (string) $registration_response->error, $error_description, $code );
5238
		} elseif ( 200 != $code ) {
5239
			return new Jetpack_Error( 'wpcom_bad_response', sprintf( __( 'Error Details: %s', 'jetpack' ), $code ), $code );
5240
		}
5241
5242
		// Jetpack ID error block
5243
		if ( empty( $registration_response->jetpack_id ) ) {
5244
			return new Jetpack_Error( 'jetpack_id', sprintf( __( 'Error Details: Jetpack ID is empty. Do not publicly post this error message! %s', 'jetpack' ), $entity ), $entity );
5245
		} elseif ( ! is_scalar( $registration_response->jetpack_id ) ) {
5246
			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 );
5247
		} elseif ( preg_match( '/[^0-9]/', $registration_response->jetpack_id ) ) {
5248
			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 );
5249
		}
5250
5251
	    return $registration_response;
5252
	}
5253
	/**
5254
	 * @return bool|WP_Error
5255
	 */
5256
	public static function register() {
5257
		JetpackTracking::record_user_event( 'jpc_register_begin' );
5258
		add_action( 'pre_update_jetpack_option_register', array( 'Jetpack_Options', 'delete_option' ) );
5259
		$secrets = Jetpack::generate_secrets( 'register' );
5260
5261 View Code Duplication
		if (
5262
			empty( $secrets['secret_1'] ) ||
5263
			empty( $secrets['secret_2'] ) ||
5264
			empty( $secrets['exp'] )
5265
		) {
5266
			return new Jetpack_Error( 'missing_secrets' );
5267
		}
5268
5269
		// better to try (and fail) to set a higher timeout than this system
5270
		// supports than to have register fail for more users than it should
5271
		$timeout = Jetpack::set_min_time_limit( 60 ) / 2;
5272
5273
		$gmt_offset = get_option( 'gmt_offset' );
5274
		if ( ! $gmt_offset ) {
5275
			$gmt_offset = 0;
5276
		}
5277
5278
		$stats_options = get_option( 'stats_options' );
5279
		$stats_id = isset($stats_options['blog_id']) ? $stats_options['blog_id'] : null;
5280
5281
		$tracks_identity = jetpack_tracks_get_identity( get_current_user_id() );
5282
5283
		$args = array(
5284
			'method'  => 'POST',
5285
			'body'    => array(
5286
				'siteurl'         => site_url(),
5287
				'home'            => home_url(),
5288
				'gmt_offset'      => $gmt_offset,
5289
				'timezone_string' => (string) get_option( 'timezone_string' ),
5290
				'site_name'       => (string) get_option( 'blogname' ),
5291
				'secret_1'        => $secrets['secret_1'],
5292
				'secret_2'        => $secrets['secret_2'],
5293
				'site_lang'       => get_locale(),
5294
				'timeout'         => $timeout,
5295
				'stats_id'        => $stats_id,
5296
				'state'           => get_current_user_id(),
5297
				'_ui'             => $tracks_identity['_ui'],
5298
				'_ut'             => $tracks_identity['_ut'],
5299
				'jetpack_version' => JETPACK__VERSION
5300
			),
5301
			'headers' => array(
5302
				'Accept' => 'application/json',
5303
			),
5304
			'timeout' => $timeout,
5305
		);
5306
5307
		self::apply_activation_source_to_args( $args['body'] );
5308
5309
		$response = Jetpack_Client::_wp_remote_request( Jetpack::fix_url_for_bad_hosts( Jetpack::api_url( 'register' ) ), $args, true );
5310
5311
		// Make sure the response is valid and does not contain any Jetpack errors
5312
		$registration_details = Jetpack::init()->validate_remote_register_response( $response );
5313
		if ( is_wp_error( $registration_details ) ) {
5314
			return $registration_details;
5315
		} elseif ( ! $registration_details ) {
5316
			return new Jetpack_Error( 'unknown_error', __( 'Unknown error registering your Jetpack site', 'jetpack' ), wp_remote_retrieve_response_code( $response ) );
5317
		}
5318
5319 View Code Duplication
		if ( empty( $registration_details->jetpack_secret ) || ! is_string( $registration_details->jetpack_secret ) ) {
5320
			return new Jetpack_Error( 'jetpack_secret', '', wp_remote_retrieve_response_code( $response ) );
5321
		}
5322
5323
		if ( isset( $registration_details->jetpack_public ) ) {
5324
			$jetpack_public = (int) $registration_details->jetpack_public;
5325
		} else {
5326
			$jetpack_public = false;
5327
		}
5328
5329
		Jetpack_Options::update_options(
5330
			array(
5331
				'id'         => (int)    $registration_details->jetpack_id,
5332
				'blog_token' => (string) $registration_details->jetpack_secret,
5333
				'public'     => $jetpack_public,
5334
			)
5335
		);
5336
5337
		/**
5338
		 * Fires when a site is registered on WordPress.com.
5339
		 *
5340
		 * @since 3.7.0
5341
		 *
5342
		 * @param int $json->jetpack_id Jetpack Blog ID.
5343
		 * @param string $json->jetpack_secret Jetpack Blog Token.
5344
		 * @param int|bool $jetpack_public Is the site public.
5345
		 */
5346
		do_action( 'jetpack_site_registered', $registration_details->jetpack_id, $registration_details->jetpack_secret, $jetpack_public );
5347
5348
		// Initialize Jump Start for the first and only time.
5349
		if ( ! Jetpack_Options::get_option( 'jumpstart' ) ) {
5350
			Jetpack_Options::update_option( 'jumpstart', 'new_connection' );
5351
5352
			$jetpack = Jetpack::init();
5353
5354
			$jetpack->stat( 'jumpstart', 'unique-views' );
5355
			$jetpack->do_stats( 'server_side' );
5356
		};
5357
5358
		return true;
5359
	}
5360
5361
	/**
5362
	 * If the db version is showing something other that what we've got now, bump it to current.
5363
	 *
5364
	 * @return bool: True if the option was incorrect and updated, false if nothing happened.
5365
	 */
5366
	public static function maybe_set_version_option() {
5367
		list( $version ) = explode( ':', Jetpack_Options::get_option( 'version' ) );
5368
		if ( JETPACK__VERSION != $version ) {
5369
			Jetpack_Options::update_option( 'version', JETPACK__VERSION . ':' . time() );
5370
5371
			if ( version_compare( JETPACK__VERSION, $version, '>' ) ) {
5372
				/** This action is documented in class.jetpack.php */
5373
				do_action( 'updating_jetpack_version', JETPACK__VERSION, $version );
5374
			}
5375
5376
			return true;
5377
		}
5378
		return false;
5379
	}
5380
5381
/* Client Server API */
5382
5383
	/**
5384
	 * Loads the Jetpack XML-RPC client
5385
	 */
5386
	public static function load_xml_rpc_client() {
5387
		require_once ABSPATH . WPINC . '/class-IXR.php';
5388
		require_once JETPACK__PLUGIN_DIR . 'class.jetpack-ixr-client.php';
5389
	}
5390
5391
	/**
5392
	 * Resets the saved authentication state in between testing requests.
5393
	 */
5394
	public function reset_saved_auth_state() {
5395
		$this->xmlrpc_verification = null;
5396
		$this->rest_authentication_status = null;
5397
	}
5398
5399
	function verify_xml_rpc_signature() {
5400
		if ( $this->xmlrpc_verification ) {
5401
			return $this->xmlrpc_verification;
5402
		}
5403
5404
		// It's not for us
5405
		if ( ! isset( $_GET['token'] ) || empty( $_GET['signature'] ) ) {
5406
			return false;
5407
		}
5408
5409
		@list( $token_key, $version, $user_id ) = explode( ':', $_GET['token'] );
5410
		if (
5411
			empty( $token_key )
5412
		||
5413
			empty( $version ) || strval( JETPACK__API_VERSION ) !== $version
5414
		) {
5415
			return false;
5416
		}
5417
5418
		if ( '0' === $user_id ) {
5419
			$token_type = 'blog';
5420
			$user_id = 0;
5421
		} else {
5422
			$token_type = 'user';
5423
			if ( empty( $user_id ) || ! ctype_digit( $user_id ) ) {
5424
				return false;
5425
			}
5426
			$user_id = (int) $user_id;
5427
5428
			$user = new WP_User( $user_id );
5429
			if ( ! $user || ! $user->exists() ) {
5430
				return false;
5431
			}
5432
		}
5433
5434
		$token = Jetpack_Data::get_access_token( $user_id );
5435
		if ( ! $token ) {
5436
			return false;
5437
		}
5438
5439
		$token_check = "$token_key.";
5440
		if ( ! hash_equals( substr( $token->secret, 0, strlen( $token_check ) ), $token_check ) ) {
5441
			return false;
5442
		}
5443
5444
		require_once JETPACK__PLUGIN_DIR . 'class.jetpack-signature.php';
5445
5446
		$jetpack_signature = new Jetpack_Signature( $token->secret, (int) Jetpack_Options::get_option( 'time_diff' ) );
5447
		if ( isset( $_POST['_jetpack_is_multipart'] ) ) {
5448
			$post_data   = $_POST;
5449
			$file_hashes = array();
5450
			foreach ( $post_data as $post_data_key => $post_data_value ) {
5451
				if ( 0 !== strpos( $post_data_key, '_jetpack_file_hmac_' ) ) {
5452
					continue;
5453
				}
5454
				$post_data_key = substr( $post_data_key, strlen( '_jetpack_file_hmac_' ) );
5455
				$file_hashes[$post_data_key] = $post_data_value;
5456
			}
5457
5458
			foreach ( $file_hashes as $post_data_key => $post_data_value ) {
5459
				unset( $post_data["_jetpack_file_hmac_{$post_data_key}"] );
5460
				$post_data[$post_data_key] = $post_data_value;
5461
			}
5462
5463
			ksort( $post_data );
5464
5465
			$body = http_build_query( stripslashes_deep( $post_data ) );
5466
		} elseif ( is_null( $this->HTTP_RAW_POST_DATA ) ) {
5467
			$body = file_get_contents( 'php://input' );
5468
		} else {
5469
			$body = null;
5470
		}
5471
5472
		$signature = $jetpack_signature->sign_current_request(
5473
			array( 'body' => is_null( $body ) ? $this->HTTP_RAW_POST_DATA : $body, )
5474
		);
5475
5476
		if ( ! $signature ) {
5477
			return false;
5478
		} else if ( is_wp_error( $signature ) ) {
5479
			return $signature;
5480
		} else if ( ! hash_equals( $signature, $_GET['signature'] ) ) {
5481
			return false;
5482
		}
5483
5484
		$timestamp = (int) $_GET['timestamp'];
5485
		$nonce     = stripslashes( (string) $_GET['nonce'] );
5486
5487
		if ( ! $this->add_nonce( $timestamp, $nonce ) ) {
5488
			return false;
5489
		}
5490
5491
		// Let's see if this is onboarding. In such case, use user token type and the provided user id.
5492
		if ( isset( $this->HTTP_RAW_POST_DATA ) || ! empty( $_GET['onboarding'] ) ) {
5493
			if ( ! empty( $_GET['onboarding'] ) ) {
5494
				$jpo = $_GET;
5495
			} else {
5496
				$jpo = json_decode( $this->HTTP_RAW_POST_DATA, true );
5497
			}
5498
5499
			$jpo_token = ! empty( $jpo['onboarding']['token'] ) ? $jpo['onboarding']['token'] : null;
5500
			$jpo_user = ! empty( $jpo['onboarding']['jpUser'] ) ? $jpo['onboarding']['jpUser'] : null;
5501
5502
			if (
5503
				isset( $jpo_user ) && isset( $jpo_token ) &&
5504
				is_email( $jpo_user ) && ctype_alnum( $jpo_token ) &&
5505
				isset( $_GET['rest_route'] ) &&
5506
				self::validate_onboarding_token_action( $jpo_token, $_GET['rest_route'] )
5507
			) {
5508
				$jpUser = get_user_by( 'email', $jpo_user );
5509
				if ( is_a( $jpUser, 'WP_User' ) ) {
5510
					wp_set_current_user( $jpUser->ID );
5511
					$user_can = is_multisite()
5512
						? current_user_can_for_blog( get_current_blog_id(), 'manage_options' )
5513
						: current_user_can( 'manage_options' );
5514
					if ( $user_can ) {
5515
						$token_type = 'user';
5516
						$token->external_user_id = $jpUser->ID;
5517
					}
5518
				}
5519
			}
5520
		}
5521
5522
		$this->xmlrpc_verification = array(
5523
			'type'    => $token_type,
5524
			'user_id' => $token->external_user_id,
5525
		);
5526
5527
		return $this->xmlrpc_verification;
5528
	}
5529
5530
	/**
5531
	 * Authenticates XML-RPC and other requests from the Jetpack Server
5532
	 */
5533
	function authenticate_jetpack( $user, $username, $password ) {
5534
		if ( is_a( $user, 'WP_User' ) ) {
5535
			return $user;
5536
		}
5537
5538
		$token_details = $this->verify_xml_rpc_signature();
5539
5540
		if ( ! $token_details || is_wp_error( $token_details ) ) {
5541
			return $user;
5542
		}
5543
5544
		if ( 'user' !== $token_details['type'] ) {
5545
			return $user;
5546
		}
5547
5548
		if ( ! $token_details['user_id'] ) {
5549
			return $user;
5550
		}
5551
5552
		nocache_headers();
5553
5554
		return new WP_User( $token_details['user_id'] );
5555
	}
5556
5557
	// Authenticates requests from Jetpack server to WP REST API endpoints.
5558
	// Uses the existing XMLRPC request signing implementation.
5559
	function wp_rest_authenticate( $user ) {
5560
		if ( ! empty( $user ) ) {
5561
			// Another authentication method is in effect.
5562
			return $user;
5563
		}
5564
5565
		if ( ! isset( $_GET['_for'] ) || $_GET['_for'] !== 'jetpack' ) {
5566
			// Nothing to do for this authentication method.
5567
			return null;
5568
		}
5569
5570
		if ( ! isset( $_GET['token'] ) && ! isset( $_GET['signature'] ) ) {
5571
			// Nothing to do for this authentication method.
5572
			return null;
5573
		}
5574
5575
		// Ensure that we always have the request body available.  At this
5576
		// point, the WP REST API code to determine the request body has not
5577
		// run yet.  That code may try to read from 'php://input' later, but
5578
		// this can only be done once per request in PHP versions prior to 5.6.
5579
		// So we will go ahead and perform this read now if needed, and save
5580
		// the request body where both the Jetpack signature verification code
5581
		// and the WP REST API code can see it.
5582
		if ( ! isset( $GLOBALS['HTTP_RAW_POST_DATA'] ) ) {
5583
			$GLOBALS['HTTP_RAW_POST_DATA'] = file_get_contents( 'php://input' );
5584
		}
5585
		$this->HTTP_RAW_POST_DATA = $GLOBALS['HTTP_RAW_POST_DATA'];
5586
5587
		// Only support specific request parameters that have been tested and
5588
		// are known to work with signature verification.  A different method
5589
		// can be passed to the WP REST API via the '?_method=' parameter if
5590
		// needed.
5591
		if ( $_SERVER['REQUEST_METHOD'] !== 'GET' && $_SERVER['REQUEST_METHOD'] !== 'POST' ) {
5592
			$this->rest_authentication_status = new WP_Error(
5593
				'rest_invalid_request',
5594
				__( 'This request method is not supported.', 'jetpack' ),
5595
				array( 'status' => 400 )
5596
			);
5597
			return null;
5598
		}
5599
		if ( $_SERVER['REQUEST_METHOD'] !== 'POST' && ! empty( $this->HTTP_RAW_POST_DATA ) ) {
5600
			$this->rest_authentication_status = new WP_Error(
5601
				'rest_invalid_request',
5602
				__( 'This request method does not support body parameters.', 'jetpack' ),
5603
				array( 'status' => 400 )
5604
			);
5605
			return null;
5606
		}
5607
5608
		if ( ! empty( $_SERVER['CONTENT_TYPE'] ) ) {
5609
			$content_type = $_SERVER['CONTENT_TYPE'];
5610
		} elseif ( ! empty( $_SERVER['HTTP_CONTENT_TYPE'] ) ) {
5611
			$content_type = $_SERVER['HTTP_CONTENT_TYPE'];
5612
		}
5613
5614
		if (
5615
			isset( $content_type ) &&
5616
			$content_type !== 'application/x-www-form-urlencoded' &&
5617
			$content_type !== 'application/json'
5618
		) {
5619
			$this->rest_authentication_status = new WP_Error(
5620
				'rest_invalid_request',
5621
				__( 'This Content-Type is not supported.', 'jetpack' ),
5622
				array( 'status' => 400 )
5623
			);
5624
			return null;
5625
		}
5626
5627
		$verified = $this->verify_xml_rpc_signature();
5628
5629
		if ( is_wp_error( $verified ) ) {
5630
			$this->rest_authentication_status = $verified;
5631
			return null;
5632
		}
5633
5634
		if (
5635
			$verified &&
5636
			isset( $verified['type'] ) &&
5637
			'user' === $verified['type'] &&
5638
			! empty( $verified['user_id'] )
5639
		) {
5640
			// Authentication successful.
5641
			$this->rest_authentication_status = true;
5642
			return $verified['user_id'];
5643
		}
5644
5645
		// Something else went wrong.  Probably a signature error.
5646
		$this->rest_authentication_status = new WP_Error(
5647
			'rest_invalid_signature',
5648
			__( 'The request is not signed correctly.', 'jetpack' ),
5649
			array( 'status' => 400 )
5650
		);
5651
		return null;
5652
	}
5653
5654
	/**
5655
	 * Report authentication status to the WP REST API.
5656
	 *
5657
	 * @param  WP_Error|mixed $result Error from another authentication handler, null if we should handle it, or another value if not
5658
	 * @return WP_Error|boolean|null {@see WP_JSON_Server::check_authentication}
5659
	 */
5660
	public function wp_rest_authentication_errors( $value ) {
5661
		if ( $value !== null ) {
5662
			return $value;
5663
		}
5664
		return $this->rest_authentication_status;
5665
	}
5666
5667
	function add_nonce( $timestamp, $nonce ) {
5668
		global $wpdb;
5669
		static $nonces_used_this_request = array();
5670
5671
		if ( isset( $nonces_used_this_request["$timestamp:$nonce"] ) ) {
5672
			return $nonces_used_this_request["$timestamp:$nonce"];
5673
		}
5674
5675
		// This should always have gone through Jetpack_Signature::sign_request() first to check $timestamp an $nonce
5676
		$timestamp = (int) $timestamp;
5677
		$nonce     = esc_sql( $nonce );
5678
5679
		// Raw query so we can avoid races: add_option will also update
5680
		$show_errors = $wpdb->show_errors( false );
5681
5682
		$old_nonce = $wpdb->get_row(
5683
			$wpdb->prepare( "SELECT * FROM `$wpdb->options` WHERE option_name = %s", "jetpack_nonce_{$timestamp}_{$nonce}" )
5684
		);
5685
5686
		if ( is_null( $old_nonce ) ) {
5687
			$return = $wpdb->query(
5688
				$wpdb->prepare(
5689
					"INSERT INTO `$wpdb->options` (`option_name`, `option_value`, `autoload`) VALUES (%s, %s, %s)",
5690
					"jetpack_nonce_{$timestamp}_{$nonce}",
5691
					time(),
5692
					'no'
5693
				)
5694
			);
5695
		} else {
5696
			$return = false;
5697
		}
5698
5699
		$wpdb->show_errors( $show_errors );
5700
5701
		$nonces_used_this_request["$timestamp:$nonce"] = $return;
5702
5703
		return $return;
5704
	}
5705
5706
	/**
5707
	 * In some setups, $HTTP_RAW_POST_DATA can be emptied during some IXR_Server paths since it is passed by reference to various methods.
5708
	 * Capture it here so we can verify the signature later.
5709
	 */
5710
	function xmlrpc_methods( $methods ) {
5711
		$this->HTTP_RAW_POST_DATA = $GLOBALS['HTTP_RAW_POST_DATA'];
5712
		return $methods;
5713
	}
5714
5715
	function public_xmlrpc_methods( $methods ) {
5716
		if ( array_key_exists( 'wp.getOptions', $methods ) ) {
5717
			$methods['wp.getOptions'] = array( $this, 'jetpack_getOptions' );
5718
		}
5719
		return $methods;
5720
	}
5721
5722
	function jetpack_getOptions( $args ) {
5723
		global $wp_xmlrpc_server;
5724
5725
		$wp_xmlrpc_server->escape( $args );
5726
5727
		$username	= $args[1];
5728
		$password	= $args[2];
5729
5730
		if ( !$user = $wp_xmlrpc_server->login($username, $password) ) {
5731
			return $wp_xmlrpc_server->error;
5732
		}
5733
5734
		$options = array();
5735
		$user_data = $this->get_connected_user_data();
5736
		if ( is_array( $user_data ) ) {
5737
			$options['jetpack_user_id'] = array(
5738
				'desc'          => __( 'The WP.com user ID of the connected user', 'jetpack' ),
5739
				'readonly'      => true,
5740
				'value'         => $user_data['ID'],
5741
			);
5742
			$options['jetpack_user_login'] = array(
5743
				'desc'          => __( 'The WP.com username of the connected user', 'jetpack' ),
5744
				'readonly'      => true,
5745
				'value'         => $user_data['login'],
5746
			);
5747
			$options['jetpack_user_email'] = array(
5748
				'desc'          => __( 'The WP.com user email of the connected user', 'jetpack' ),
5749
				'readonly'      => true,
5750
				'value'         => $user_data['email'],
5751
			);
5752
			$options['jetpack_user_site_count'] = array(
5753
				'desc'          => __( 'The number of sites of the connected WP.com user', 'jetpack' ),
5754
				'readonly'      => true,
5755
				'value'         => $user_data['site_count'],
5756
			);
5757
		}
5758
		$wp_xmlrpc_server->blog_options = array_merge( $wp_xmlrpc_server->blog_options, $options );
5759
		$args = stripslashes_deep( $args );
5760
		return $wp_xmlrpc_server->wp_getOptions( $args );
5761
	}
5762
5763
	function xmlrpc_options( $options ) {
5764
		$jetpack_client_id = false;
5765
		if ( self::is_active() ) {
5766
			$jetpack_client_id = Jetpack_Options::get_option( 'id' );
5767
		}
5768
		$options['jetpack_version'] = array(
5769
				'desc'          => __( 'Jetpack Plugin Version', 'jetpack' ),
5770
				'readonly'      => true,
5771
				'value'         => JETPACK__VERSION,
5772
		);
5773
5774
		$options['jetpack_client_id'] = array(
5775
				'desc'          => __( 'The Client ID/WP.com Blog ID of this site', 'jetpack' ),
5776
				'readonly'      => true,
5777
				'value'         => $jetpack_client_id,
5778
		);
5779
		return $options;
5780
	}
5781
5782
	public static function clean_nonces( $all = false ) {
5783
		global $wpdb;
5784
5785
		$sql = "DELETE FROM `$wpdb->options` WHERE `option_name` LIKE %s";
5786
		$sql_args = array( $wpdb->esc_like( 'jetpack_nonce_' ) . '%' );
5787
5788
		if ( true !== $all ) {
5789
			$sql .= ' AND CAST( `option_value` AS UNSIGNED ) < %d';
5790
			$sql_args[] = time() - 3600;
5791
		}
5792
5793
		$sql .= ' ORDER BY `option_id` LIMIT 100';
5794
5795
		$sql = $wpdb->prepare( $sql, $sql_args );
5796
5797
		for ( $i = 0; $i < 1000; $i++ ) {
5798
			if ( ! $wpdb->query( $sql ) ) {
5799
				break;
5800
			}
5801
		}
5802
	}
5803
5804
	/**
5805
	 * State is passed via cookies from one request to the next, but never to subsequent requests.
5806
	 * SET: state( $key, $value );
5807
	 * GET: $value = state( $key );
5808
	 *
5809
	 * @param string $key
5810
	 * @param string $value
5811
	 * @param bool $restate private
5812
	 */
5813
	public static function state( $key = null, $value = null, $restate = false ) {
5814
		static $state = array();
5815
		static $path, $domain;
5816
		if ( ! isset( $path ) ) {
5817
			require_once( ABSPATH . 'wp-admin/includes/plugin.php' );
5818
			$admin_url = Jetpack::admin_url();
5819
			$bits      = parse_url( $admin_url );
5820
5821
			if ( is_array( $bits ) ) {
5822
				$path   = ( isset( $bits['path'] ) ) ? dirname( $bits['path'] ) : null;
5823
				$domain = ( isset( $bits['host'] ) ) ? $bits['host'] : null;
5824
			} else {
5825
				$path = $domain = null;
5826
			}
5827
		}
5828
5829
		// Extract state from cookies and delete cookies
5830
		if ( isset( $_COOKIE[ 'jetpackState' ] ) && is_array( $_COOKIE[ 'jetpackState' ] ) ) {
5831
			$yum = $_COOKIE[ 'jetpackState' ];
5832
			unset( $_COOKIE[ 'jetpackState' ] );
5833
			foreach ( $yum as $k => $v ) {
5834
				if ( strlen( $v ) )
5835
					$state[ $k ] = $v;
5836
				setcookie( "jetpackState[$k]", false, 0, $path, $domain );
5837
			}
5838
		}
5839
5840
		if ( $restate ) {
5841
			foreach ( $state as $k => $v ) {
5842
				setcookie( "jetpackState[$k]", $v, 0, $path, $domain );
5843
			}
5844
			return;
5845
		}
5846
5847
		// Get a state variable
5848
		if ( isset( $key ) && ! isset( $value ) ) {
5849
			if ( array_key_exists( $key, $state ) )
5850
				return $state[ $key ];
5851
			return null;
5852
		}
5853
5854
		// Set a state variable
5855
		if ( isset ( $key ) && isset( $value ) ) {
5856
			if( is_array( $value ) && isset( $value[0] ) ) {
5857
				$value = $value[0];
5858
			}
5859
			$state[ $key ] = $value;
5860
			setcookie( "jetpackState[$key]", $value, 0, $path, $domain );
5861
		}
5862
	}
5863
5864
	public static function restate() {
5865
		Jetpack::state( null, null, true );
5866
	}
5867
5868
	public static function check_privacy( $file ) {
5869
		static $is_site_publicly_accessible = null;
5870
5871
		if ( is_null( $is_site_publicly_accessible ) ) {
5872
			$is_site_publicly_accessible = false;
5873
5874
			Jetpack::load_xml_rpc_client();
5875
			$rpc = new Jetpack_IXR_Client();
5876
5877
			$success = $rpc->query( 'jetpack.isSitePubliclyAccessible', home_url() );
5878
			if ( $success ) {
5879
				$response = $rpc->getResponse();
5880
				if ( $response ) {
5881
					$is_site_publicly_accessible = true;
5882
				}
5883
			}
5884
5885
			Jetpack_Options::update_option( 'public', (int) $is_site_publicly_accessible );
5886
		}
5887
5888
		if ( $is_site_publicly_accessible ) {
5889
			return;
5890
		}
5891
5892
		$module_slug = self::get_module_slug( $file );
5893
5894
		$privacy_checks = Jetpack::state( 'privacy_checks' );
5895
		if ( ! $privacy_checks ) {
5896
			$privacy_checks = $module_slug;
5897
		} else {
5898
			$privacy_checks .= ",$module_slug";
5899
		}
5900
5901
		Jetpack::state( 'privacy_checks', $privacy_checks );
5902
	}
5903
5904
	/**
5905
	 * Helper method for multicall XMLRPC.
5906
	 */
5907
	public static function xmlrpc_async_call() {
5908
		global $blog_id;
5909
		static $clients = array();
5910
5911
		$client_blog_id = is_multisite() ? $blog_id : 0;
5912
5913
		if ( ! isset( $clients[$client_blog_id] ) ) {
5914
			Jetpack::load_xml_rpc_client();
5915
			$clients[$client_blog_id] = new Jetpack_IXR_ClientMulticall( array( 'user_id' => JETPACK_MASTER_USER, ) );
5916
			if ( function_exists( 'ignore_user_abort' ) ) {
5917
				ignore_user_abort( true );
5918
			}
5919
			add_action( 'shutdown', array( 'Jetpack', 'xmlrpc_async_call' ) );
5920
		}
5921
5922
		$args = func_get_args();
5923
5924
		if ( ! empty( $args[0] ) ) {
5925
			call_user_func_array( array( $clients[$client_blog_id], 'addCall' ), $args );
5926
		} elseif ( is_multisite() ) {
5927
			foreach ( $clients as $client_blog_id => $client ) {
5928
				if ( ! $client_blog_id || empty( $client->calls ) ) {
5929
					continue;
5930
				}
5931
5932
				$switch_success = switch_to_blog( $client_blog_id, true );
5933
				if ( ! $switch_success ) {
5934
					continue;
5935
				}
5936
5937
				flush();
5938
				$client->query();
5939
5940
				restore_current_blog();
5941
			}
5942
		} else {
5943
			if ( isset( $clients[0] ) && ! empty( $clients[0]->calls ) ) {
5944
				flush();
5945
				$clients[0]->query();
5946
			}
5947
		}
5948
	}
5949
5950
	public static function staticize_subdomain( $url ) {
5951
5952
		// Extract hostname from URL
5953
		$host = parse_url( $url, PHP_URL_HOST );
5954
5955
		// Explode hostname on '.'
5956
		$exploded_host = explode( '.', $host );
5957
5958
		// Retrieve the name and TLD
5959
		if ( count( $exploded_host ) > 1 ) {
5960
			$name = $exploded_host[ count( $exploded_host ) - 2 ];
5961
			$tld = $exploded_host[ count( $exploded_host ) - 1 ];
5962
			// Rebuild domain excluding subdomains
5963
			$domain = $name . '.' . $tld;
5964
		} else {
5965
			$domain = $host;
5966
		}
5967
		// Array of Automattic domains
5968
		$domain_whitelist = array( 'wordpress.com', 'wp.com' );
5969
5970
		// Return $url if not an Automattic domain
5971
		if ( ! in_array( $domain, $domain_whitelist ) ) {
5972
			return $url;
5973
		}
5974
5975
		if ( is_ssl() ) {
5976
			return preg_replace( '|https?://[^/]++/|', 'https://s-ssl.wordpress.com/', $url );
5977
		}
5978
5979
		srand( crc32( basename( $url ) ) );
5980
		$static_counter = rand( 0, 2 );
5981
		srand(); // this resets everything that relies on this, like array_rand() and shuffle()
5982
5983
		return preg_replace( '|://[^/]+?/|', "://s$static_counter.wp.com/", $url );
5984
	}
5985
5986
/* JSON API Authorization */
5987
5988
	/**
5989
	 * Handles the login action for Authorizing the JSON API
5990
	 */
5991
	function login_form_json_api_authorization() {
5992
		$this->verify_json_api_authorization_request();
5993
5994
		add_action( 'wp_login', array( &$this, 'store_json_api_authorization_token' ), 10, 2 );
5995
5996
		add_action( 'login_message', array( &$this, 'login_message_json_api_authorization' ) );
5997
		add_action( 'login_form', array( &$this, 'preserve_action_in_login_form_for_json_api_authorization' ) );
5998
		add_filter( 'site_url', array( &$this, 'post_login_form_to_signed_url' ), 10, 3 );
5999
	}
6000
6001
	// Make sure the login form is POSTed to the signed URL so we can reverify the request
6002
	function post_login_form_to_signed_url( $url, $path, $scheme ) {
6003
		if ( 'wp-login.php' !== $path || ( 'login_post' !== $scheme && 'login' !== $scheme ) ) {
6004
			return $url;
6005
		}
6006
6007
		$parsed_url = parse_url( $url );
6008
		$url = strtok( $url, '?' );
6009
		$url = "$url?{$_SERVER['QUERY_STRING']}";
6010
		if ( ! empty( $parsed_url['query'] ) )
6011
			$url .= "&{$parsed_url['query']}";
6012
6013
		return $url;
6014
	}
6015
6016
	// Make sure the POSTed request is handled by the same action
6017
	function preserve_action_in_login_form_for_json_api_authorization() {
6018
		echo "<input type='hidden' name='action' value='jetpack_json_api_authorization' />\n";
6019
		echo "<input type='hidden' name='jetpack_json_api_original_query' value='" . esc_url( set_url_scheme( $_SERVER['HTTP_HOST'] . $_SERVER['REQUEST_URI'] ) ) . "' />\n";
6020
	}
6021
6022
	// If someone logs in to approve API access, store the Access Code in usermeta
6023
	function store_json_api_authorization_token( $user_login, $user ) {
6024
		add_filter( 'login_redirect', array( &$this, 'add_token_to_login_redirect_json_api_authorization' ), 10, 3 );
6025
		add_filter( 'allowed_redirect_hosts', array( &$this, 'allow_wpcom_public_api_domain' ) );
6026
		$token = wp_generate_password( 32, false );
6027
		update_user_meta( $user->ID, 'jetpack_json_api_' . $this->json_api_authorization_request['client_id'], $token );
6028
	}
6029
6030
	// Add public-api.wordpress.com to the safe redirect whitelist - only added when someone allows API access
6031
	function allow_wpcom_public_api_domain( $domains ) {
6032
		$domains[] = 'public-api.wordpress.com';
6033
		return $domains;
6034
	}
6035
6036
	// Add all wordpress.com environments to the safe redirect whitelist
6037
	function allow_wpcom_environments( $domains ) {
6038
		$domains[] = 'wordpress.com';
6039
		$domains[] = 'wpcalypso.wordpress.com';
6040
		$domains[] = 'horizon.wordpress.com';
6041
		$domains[] = 'calypso.localhost';
6042
		return $domains;
6043
	}
6044
6045
	// Add the Access Code details to the public-api.wordpress.com redirect
6046
	function add_token_to_login_redirect_json_api_authorization( $redirect_to, $original_redirect_to, $user ) {
6047
		return add_query_arg(
6048
			urlencode_deep(
6049
				array(
6050
					'jetpack-code'    => get_user_meta( $user->ID, 'jetpack_json_api_' . $this->json_api_authorization_request['client_id'], true ),
6051
					'jetpack-user-id' => (int) $user->ID,
6052
					'jetpack-state'   => $this->json_api_authorization_request['state'],
6053
				)
6054
			),
6055
			$redirect_to
6056
		);
6057
	}
6058
6059
6060
	/**
6061
	 * Verifies the request by checking the signature
6062
	 *
6063
	 * @since 4.6.0 Method was updated to use `$_REQUEST` instead of `$_GET` and `$_POST`. Method also updated to allow
6064
	 * passing in an `$environment` argument that overrides `$_REQUEST`. This was useful for integrating with SSO.
6065
	 *
6066
	 * @param null|array $environment
6067
	 */
6068
	function verify_json_api_authorization_request( $environment = null ) {
6069
		require_once JETPACK__PLUGIN_DIR . 'class.jetpack-signature.php';
6070
6071
		$environment = is_null( $environment )
6072
			? $_REQUEST
6073
			: $environment;
6074
6075
		list( $envToken, $envVersion, $envUserId ) = explode( ':', $environment['token'] );
6076
		$token = Jetpack_Data::get_access_token( $envUserId );
6077
		if ( ! $token || empty( $token->secret ) ) {
6078
			wp_die( __( 'You must connect your Jetpack plugin to WordPress.com to use this feature.' , 'jetpack' ) );
6079
		}
6080
6081
		$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' );
6082
6083
		$jetpack_signature = new Jetpack_Signature( $token->secret, (int) Jetpack_Options::get_option( 'time_diff' ) );
6084
6085
		if ( isset( $environment['jetpack_json_api_original_query'] ) ) {
6086
			$signature = $jetpack_signature->sign_request(
6087
				$environment['token'],
6088
				$environment['timestamp'],
6089
				$environment['nonce'],
6090
				'',
6091
				'GET',
6092
				$environment['jetpack_json_api_original_query'],
6093
				null,
6094
				true
6095
			);
6096
		} else {
6097
			$signature = $jetpack_signature->sign_current_request( array( 'body' => null, 'method' => 'GET' ) );
6098
		}
6099
6100
		if ( ! $signature ) {
6101
			wp_die( $die_error );
6102
		} else if ( is_wp_error( $signature ) ) {
6103
			wp_die( $die_error );
6104
		} else if ( ! hash_equals( $signature, $environment['signature'] ) ) {
6105
			if ( is_ssl() ) {
6106
				// 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
6107
				$signature = $jetpack_signature->sign_current_request( array( 'scheme' => 'http', 'body' => null, 'method' => 'GET' ) );
6108
				if ( ! $signature || is_wp_error( $signature ) || ! hash_equals( $signature, $environment['signature'] ) ) {
6109
					wp_die( $die_error );
6110
				}
6111
			} else {
6112
				wp_die( $die_error );
6113
			}
6114
		}
6115
6116
		$timestamp = (int) $environment['timestamp'];
6117
		$nonce     = stripslashes( (string) $environment['nonce'] );
6118
6119
		if ( ! $this->add_nonce( $timestamp, $nonce ) ) {
6120
			// De-nonce the nonce, at least for 5 minutes.
6121
			// 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)
6122
			$old_nonce_time = get_option( "jetpack_nonce_{$timestamp}_{$nonce}" );
6123
			if ( $old_nonce_time < time() - 300 ) {
6124
				wp_die( __( 'The authorization process expired.  Please go back and try again.' , 'jetpack' ) );
6125
			}
6126
		}
6127
6128
		$data = json_decode( base64_decode( stripslashes( $environment['data'] ) ) );
6129
		$data_filters = array(
6130
			'state'        => 'opaque',
6131
			'client_id'    => 'int',
6132
			'client_title' => 'string',
6133
			'client_image' => 'url',
6134
		);
6135
6136
		foreach ( $data_filters as $key => $sanitation ) {
6137
			if ( ! isset( $data->$key ) ) {
6138
				wp_die( $die_error );
6139
			}
6140
6141
			switch ( $sanitation ) {
6142
			case 'int' :
6143
				$this->json_api_authorization_request[$key] = (int) $data->$key;
6144
				break;
6145
			case 'opaque' :
6146
				$this->json_api_authorization_request[$key] = (string) $data->$key;
6147
				break;
6148
			case 'string' :
6149
				$this->json_api_authorization_request[$key] = wp_kses( (string) $data->$key, array() );
6150
				break;
6151
			case 'url' :
6152
				$this->json_api_authorization_request[$key] = esc_url_raw( (string) $data->$key );
6153
				break;
6154
			}
6155
		}
6156
6157
		if ( empty( $this->json_api_authorization_request['client_id'] ) ) {
6158
			wp_die( $die_error );
6159
		}
6160
	}
6161
6162
	function login_message_json_api_authorization( $message ) {
6163
		return '<p class="message">' . sprintf(
6164
			esc_html__( '%s wants to access your site&#8217;s data.  Log in to authorize that access.' , 'jetpack' ),
6165
			'<strong>' . esc_html( $this->json_api_authorization_request['client_title'] ) . '</strong>'
6166
		) . '<img src="' . esc_url( $this->json_api_authorization_request['client_image'] ) . '" /></p>';
6167
	}
6168
6169
	/**
6170
	 * Get $content_width, but with a <s>twist</s> filter.
6171
	 */
6172
	public static function get_content_width() {
6173
		$content_width = isset( $GLOBALS['content_width'] ) ? $GLOBALS['content_width'] : false;
6174
		/**
6175
		 * Filter the Content Width value.
6176
		 *
6177
		 * @since 2.2.3
6178
		 *
6179
		 * @param string $content_width Content Width value.
6180
		 */
6181
		return apply_filters( 'jetpack_content_width', $content_width );
6182
	}
6183
6184
	/**
6185
	 * Pings the WordPress.com Mirror Site for the specified options.
6186
	 *
6187
	 * @param string|array $option_names The option names to request from the WordPress.com Mirror Site
6188
	 *
6189
	 * @return array An associative array of the option values as stored in the WordPress.com Mirror Site
6190
	 */
6191
	public function get_cloud_site_options( $option_names ) {
6192
		$option_names = array_filter( (array) $option_names, 'is_string' );
6193
6194
		Jetpack::load_xml_rpc_client();
6195
		$xml = new Jetpack_IXR_Client( array( 'user_id' => JETPACK_MASTER_USER, ) );
6196
		$xml->query( 'jetpack.fetchSiteOptions', $option_names );
6197
		if ( $xml->isError() ) {
6198
			return array(
6199
				'error_code' => $xml->getErrorCode(),
6200
				'error_msg'  => $xml->getErrorMessage(),
6201
			);
6202
		}
6203
		$cloud_site_options = $xml->getResponse();
6204
6205
		return $cloud_site_options;
6206
	}
6207
6208
	/**
6209
	 * Checks if the site is currently in an identity crisis.
6210
	 *
6211
	 * @return array|bool Array of options that are in a crisis, or false if everything is OK.
6212
	 */
6213
	public static function check_identity_crisis() {
6214
		if ( ! Jetpack::is_active() || Jetpack::is_development_mode() || ! self::validate_sync_error_idc_option() ) {
6215
			return false;
6216
		}
6217
6218
		return Jetpack_Options::get_option( 'sync_error_idc' );
6219
	}
6220
6221
	/**
6222
	 * Checks whether the home and siteurl specifically are whitelisted
6223
	 * Written so that we don't have re-check $key and $value params every time
6224
	 * we want to check if this site is whitelisted, for example in footer.php
6225
	 *
6226
	 * @since  3.8.0
6227
	 * @return bool True = already whitelisted False = not whitelisted
6228
	 */
6229
	public static function is_staging_site() {
6230
		$is_staging = false;
6231
6232
		$known_staging = array(
6233
			'urls' => array(
6234
				'#\.staging\.wpengine\.com$#i', // WP Engine
6235
				'#\.staging\.kinsta\.com$#i',   // Kinsta.com
6236
				),
6237
			'constants' => array(
6238
				'IS_WPE_SNAPSHOT',      // WP Engine
6239
				'KINSTA_DEV_ENV',       // Kinsta.com
6240
				'WPSTAGECOACH_STAGING', // WP Stagecoach
6241
				'JETPACK_STAGING_MODE', // Generic
6242
				)
6243
			);
6244
		/**
6245
		 * Filters the flags of known staging sites.
6246
		 *
6247
		 * @since 3.9.0
6248
		 *
6249
		 * @param array $known_staging {
6250
		 *     An array of arrays that each are used to check if the current site is staging.
6251
		 *     @type array $urls      URLs of staging sites in regex to check against site_url.
6252
		 *     @type array $constants PHP constants of known staging/developement environments.
6253
		 *  }
6254
		 */
6255
		$known_staging = apply_filters( 'jetpack_known_staging', $known_staging );
6256
6257
		if ( isset( $known_staging['urls'] ) ) {
6258
			foreach ( $known_staging['urls'] as $url ){
6259
				if ( preg_match( $url, site_url() ) ) {
6260
					$is_staging = true;
6261
					break;
6262
				}
6263
			}
6264
		}
6265
6266
		if ( isset( $known_staging['constants'] ) ) {
6267
			foreach ( $known_staging['constants'] as $constant ) {
6268
				if ( defined( $constant ) && constant( $constant ) ) {
6269
					$is_staging = true;
6270
				}
6271
			}
6272
		}
6273
6274
		// Last, let's check if sync is erroring due to an IDC. If so, set the site to staging mode.
6275
		if ( ! $is_staging && self::validate_sync_error_idc_option() ) {
6276
			$is_staging = true;
6277
		}
6278
6279
		/**
6280
		 * Filters is_staging_site check.
6281
		 *
6282
		 * @since 3.9.0
6283
		 *
6284
		 * @param bool $is_staging If the current site is a staging site.
6285
		 */
6286
		return apply_filters( 'jetpack_is_staging_site', $is_staging );
6287
	}
6288
6289
	/**
6290
	 * Checks whether the sync_error_idc option is valid or not, and if not, will do cleanup.
6291
	 *
6292
	 * @since 4.4.0
6293
	 * @since 5.4.0 Do not call get_sync_error_idc_option() unless site is in IDC
6294
	 *
6295
	 * @return bool
6296
	 */
6297
	public static function validate_sync_error_idc_option() {
6298
		$is_valid = false;
6299
6300
		$idc_allowed = get_transient( 'jetpack_idc_allowed' );
6301
		if ( false === $idc_allowed ) {
6302
			$response = wp_remote_get( 'https://jetpack.com/is-idc-allowed/' );
6303
			if ( 200 === (int) wp_remote_retrieve_response_code( $response ) ) {
6304
				$json = json_decode( wp_remote_retrieve_body( $response ) );
6305
				$idc_allowed = isset( $json, $json->result ) && $json->result ? '1' : '0';
6306
				$transient_duration = HOUR_IN_SECONDS;
6307
			} else {
6308
				// If the request failed for some reason, then assume IDC is allowed and set shorter transient.
6309
				$idc_allowed = '1';
6310
				$transient_duration = 5 * MINUTE_IN_SECONDS;
6311
			}
6312
6313
			set_transient( 'jetpack_idc_allowed', $idc_allowed, $transient_duration );
6314
		}
6315
6316
		// Is the site opted in and does the stored sync_error_idc option match what we now generate?
6317
		$sync_error = Jetpack_Options::get_option( 'sync_error_idc' );
6318
		if ( $idc_allowed && $sync_error && self::sync_idc_optin() ) {
6319
			$local_options = self::get_sync_error_idc_option();
6320
			if ( $sync_error['home'] === $local_options['home'] && $sync_error['siteurl'] === $local_options['siteurl'] ) {
6321
				$is_valid = true;
6322
			}
6323
		}
6324
6325
		/**
6326
		 * Filters whether the sync_error_idc option is valid.
6327
		 *
6328
		 * @since 4.4.0
6329
		 *
6330
		 * @param bool $is_valid If the sync_error_idc is valid or not.
6331
		 */
6332
		$is_valid = (bool) apply_filters( 'jetpack_sync_error_idc_validation', $is_valid );
6333
6334
		if ( ! $idc_allowed || ( ! $is_valid && $sync_error ) ) {
6335
			// Since the option exists, and did not validate, delete it
6336
			Jetpack_Options::delete_option( 'sync_error_idc' );
6337
		}
6338
6339
		return $is_valid;
6340
	}
6341
6342
	/**
6343
	 * Normalizes a url by doing three things:
6344
	 *  - Strips protocol
6345
	 *  - Strips www
6346
	 *  - Adds a trailing slash
6347
	 *
6348
	 * @since 4.4.0
6349
	 * @param string $url
6350
	 * @return WP_Error|string
6351
	 */
6352
	public static function normalize_url_protocol_agnostic( $url ) {
6353
		$parsed_url = wp_parse_url( trailingslashit( esc_url_raw( $url ) ) );
6354
		if ( ! $parsed_url || empty( $parsed_url['host'] ) || empty( $parsed_url['path'] ) ) {
6355
			return new WP_Error( 'cannot_parse_url', sprintf( esc_html__( 'Cannot parse URL %s', 'jetpack' ), $url ) );
6356
		}
6357
6358
		// Strip www and protocols
6359
		$url = preg_replace( '/^www\./i', '', $parsed_url['host'] . $parsed_url['path'] );
6360
		return $url;
6361
	}
6362
6363
	/**
6364
	 * Gets the value that is to be saved in the jetpack_sync_error_idc option.
6365
	 *
6366
	 * @since 4.4.0
6367
	 * @since 5.4.0 Add transient since home/siteurl retrieved directly from DB
6368
	 *
6369
	 * @param array $response
6370
	 * @return array Array of the local urls, wpcom urls, and error code
6371
	 */
6372
	public static function get_sync_error_idc_option( $response = array() ) {
6373
		// Since the local options will hit the database directly, store the values
6374
		// in a transient to allow for autoloading and caching on subsequent views.
6375
		$local_options = get_transient( 'jetpack_idc_local' );
6376
		if ( false === $local_options ) {
6377
			require_once JETPACK__PLUGIN_DIR . 'sync/class.jetpack-sync-functions.php';
6378
			$local_options = array(
6379
				'home'    => Jetpack_Sync_Functions::home_url(),
6380
				'siteurl' => Jetpack_Sync_Functions::site_url(),
6381
			);
6382
			set_transient( 'jetpack_idc_local', $local_options, MINUTE_IN_SECONDS );
6383
		}
6384
6385
		$options = array_merge( $local_options, $response );
6386
6387
		$returned_values = array();
6388
		foreach( $options as $key => $option ) {
6389
			if ( 'error_code' === $key ) {
6390
				$returned_values[ $key ] = $option;
6391
				continue;
6392
			}
6393
6394
			if ( is_wp_error( $normalized_url = self::normalize_url_protocol_agnostic( $option ) ) ) {
6395
				continue;
6396
			}
6397
6398
			$returned_values[ $key ] = $normalized_url;
6399
		}
6400
6401
		set_transient( 'jetpack_idc_option', $returned_values, MINUTE_IN_SECONDS );
6402
6403
		return $returned_values;
6404
	}
6405
6406
	/**
6407
	 * Returns the value of the jetpack_sync_idc_optin filter, or constant.
6408
	 * If set to true, the site will be put into staging mode.
6409
	 *
6410
	 * @since 4.3.2
6411
	 * @return bool
6412
	 */
6413
	public static function sync_idc_optin() {
6414
		if ( Jetpack_Constants::is_defined( 'JETPACK_SYNC_IDC_OPTIN' ) ) {
6415
			$default = Jetpack_Constants::get_constant( 'JETPACK_SYNC_IDC_OPTIN' );
6416
		} else {
6417
			$default = ! Jetpack_Constants::is_defined( 'SUNRISE' ) && ! is_multisite();
6418
		}
6419
6420
		/**
6421
		 * Allows sites to optin to IDC mitigation which blocks the site from syncing to WordPress.com when the home
6422
		 * URL or site URL do not match what WordPress.com expects. The default value is either false, or the value of
6423
		 * JETPACK_SYNC_IDC_OPTIN constant if set.
6424
		 *
6425
		 * @since 4.3.2
6426
		 *
6427
		 * @param bool $default Whether the site is opted in to IDC mitigation.
6428
		 */
6429
		return (bool) apply_filters( 'jetpack_sync_idc_optin', $default );
6430
	}
6431
6432
	/**
6433
	 * Maybe Use a .min.css stylesheet, maybe not.
6434
	 *
6435
	 * Hooks onto `plugins_url` filter at priority 1, and accepts all 3 args.
6436
	 */
6437
	public static function maybe_min_asset( $url, $path, $plugin ) {
6438
		// Short out on things trying to find actual paths.
6439
		if ( ! $path || empty( $plugin ) ) {
6440
			return $url;
6441
		}
6442
6443
		$path = ltrim( $path, '/' );
6444
6445
		// Strip out the abspath.
6446
		$base = dirname( plugin_basename( $plugin ) );
6447
6448
		// Short out on non-Jetpack assets.
6449
		if ( 'jetpack/' !== substr( $base, 0, 8 ) ) {
6450
			return $url;
6451
		}
6452
6453
		// File name parsing.
6454
		$file              = "{$base}/{$path}";
6455
		$full_path         = JETPACK__PLUGIN_DIR . substr( $file, 8 );
6456
		$file_name         = substr( $full_path, strrpos( $full_path, '/' ) + 1 );
6457
		$file_name_parts_r = array_reverse( explode( '.', $file_name ) );
6458
		$extension         = array_shift( $file_name_parts_r );
6459
6460
		if ( in_array( strtolower( $extension ), array( 'css', 'js' ) ) ) {
6461
			// Already pointing at the minified version.
6462
			if ( 'min' === $file_name_parts_r[0] ) {
6463
				return $url;
6464
			}
6465
6466
			$min_full_path = preg_replace( "#\.{$extension}$#", ".min.{$extension}", $full_path );
6467
			if ( file_exists( $min_full_path ) ) {
6468
				$url = preg_replace( "#\.{$extension}$#", ".min.{$extension}", $url );
6469
				// If it's a CSS file, stash it so we can set the .min suffix for rtl-ing.
6470
				if ( 'css' === $extension ) {
6471
					$key = str_replace( JETPACK__PLUGIN_DIR, 'jetpack/', $min_full_path );
6472
					self::$min_assets[ $key ] = $path;
6473
				}
6474
			}
6475
		}
6476
6477
		return $url;
6478
	}
6479
6480
	/**
6481
	 * If the asset is minified, let's flag .min as the suffix.
6482
	 *
6483
	 * Attached to `style_loader_src` filter.
6484
	 *
6485
	 * @param string $tag The tag that would link to the external asset.
6486
	 * @param string $handle The registered handle of the script in question.
6487
	 * @param string $href The url of the asset in question.
6488
	 */
6489
	public static function set_suffix_on_min( $src, $handle ) {
6490
		if ( false === strpos( $src, '.min.css' ) ) {
6491
			return $src;
6492
		}
6493
6494
		if ( ! empty( self::$min_assets ) ) {
6495
			foreach ( self::$min_assets as $file => $path ) {
6496
				if ( false !== strpos( $src, $file ) ) {
6497
					wp_style_add_data( $handle, 'suffix', '.min' );
6498
					return $src;
6499
				}
6500
			}
6501
		}
6502
6503
		return $src;
6504
	}
6505
6506
	/**
6507
	 * Maybe inlines a stylesheet.
6508
	 *
6509
	 * If you'd like to inline a stylesheet instead of printing a link to it,
6510
	 * wp_style_add_data( 'handle', 'jetpack-inline', true );
6511
	 *
6512
	 * Attached to `style_loader_tag` filter.
6513
	 *
6514
	 * @param string $tag The tag that would link to the external asset.
6515
	 * @param string $handle The registered handle of the script in question.
6516
	 *
6517
	 * @return string
6518
	 */
6519
	public static function maybe_inline_style( $tag, $handle ) {
6520
		global $wp_styles;
6521
		$item = $wp_styles->registered[ $handle ];
6522
6523
		if ( ! isset( $item->extra['jetpack-inline'] ) || ! $item->extra['jetpack-inline'] ) {
6524
			return $tag;
6525
		}
6526
6527
		if ( preg_match( '# href=\'([^\']+)\' #i', $tag, $matches ) ) {
6528
			$href = $matches[1];
6529
			// Strip off query string
6530
			if ( $pos = strpos( $href, '?' ) ) {
6531
				$href = substr( $href, 0, $pos );
6532
			}
6533
			// Strip off fragment
6534
			if ( $pos = strpos( $href, '#' ) ) {
6535
				$href = substr( $href, 0, $pos );
6536
			}
6537
		} else {
6538
			return $tag;
6539
		}
6540
6541
		$plugins_dir = plugin_dir_url( JETPACK__PLUGIN_FILE );
6542
		if ( $plugins_dir !== substr( $href, 0, strlen( $plugins_dir ) ) ) {
6543
			return $tag;
6544
		}
6545
6546
		// If this stylesheet has a RTL version, and the RTL version replaces normal...
6547
		if ( isset( $item->extra['rtl'] ) && 'replace' === $item->extra['rtl'] && is_rtl() ) {
6548
			// And this isn't the pass that actually deals with the RTL version...
6549
			if ( false === strpos( $tag, " id='$handle-rtl-css' " ) ) {
6550
				// Short out, as the RTL version will deal with it in a moment.
6551
				return $tag;
6552
			}
6553
		}
6554
6555
		$file = JETPACK__PLUGIN_DIR . substr( $href, strlen( $plugins_dir ) );
6556
		$css  = Jetpack::absolutize_css_urls( file_get_contents( $file ), $href );
6557
		if ( $css ) {
6558
			$tag = "<!-- Inline {$item->handle} -->\r\n";
6559
			if ( empty( $item->extra['after'] ) ) {
6560
				wp_add_inline_style( $handle, $css );
6561
			} else {
6562
				array_unshift( $item->extra['after'], $css );
6563
				wp_style_add_data( $handle, 'after', $item->extra['after'] );
6564
			}
6565
		}
6566
6567
		return $tag;
6568
	}
6569
6570
	/**
6571
	 * Loads a view file from the views
6572
	 *
6573
	 * Data passed in with the $data parameter will be available in the
6574
	 * template file as $data['value']
6575
	 *
6576
	 * @param string $template - Template file to load
6577
	 * @param array $data - Any data to pass along to the template
6578
	 * @return boolean - If template file was found
6579
	 **/
6580
	public function load_view( $template, $data = array() ) {
6581
		$views_dir = JETPACK__PLUGIN_DIR . 'views/';
6582
6583
		if( file_exists( $views_dir . $template ) ) {
6584
			require_once( $views_dir . $template );
6585
			return true;
6586
		}
6587
6588
		error_log( "Jetpack: Unable to find view file $views_dir$template" );
6589
		return false;
6590
	}
6591
6592
	/**
6593
	 * Throws warnings for deprecated hooks to be removed from Jetpack
6594
	 */
6595
	public function deprecated_hooks() {
6596
		global $wp_filter;
6597
6598
		/*
6599
		 * Format:
6600
		 * deprecated_filter_name => replacement_name
6601
		 *
6602
		 * If there is no replacement, use null for replacement_name
6603
		 */
6604
		$deprecated_list = array(
6605
			'jetpack_bail_on_shortcode'                              => 'jetpack_shortcodes_to_include',
6606
			'wpl_sharing_2014_1'                                     => null,
6607
			'jetpack-tools-to-include'                               => 'jetpack_tools_to_include',
6608
			'jetpack_identity_crisis_options_to_check'               => null,
6609
			'update_option_jetpack_single_user_site'                 => null,
6610
			'audio_player_default_colors'                            => null,
6611
			'add_option_jetpack_featured_images_enabled'             => null,
6612
			'add_option_jetpack_update_details'                      => null,
6613
			'add_option_jetpack_updates'                             => null,
6614
			'add_option_jetpack_network_name'                        => null,
6615
			'add_option_jetpack_network_allow_new_registrations'     => null,
6616
			'add_option_jetpack_network_add_new_users'               => null,
6617
			'add_option_jetpack_network_site_upload_space'           => null,
6618
			'add_option_jetpack_network_upload_file_types'           => null,
6619
			'add_option_jetpack_network_enable_administration_menus' => null,
6620
			'add_option_jetpack_is_multi_site'                       => null,
6621
			'add_option_jetpack_is_main_network'                     => null,
6622
			'add_option_jetpack_main_network_site'                   => null,
6623
			'jetpack_sync_all_registered_options'                    => null,
6624
			'jetpack_has_identity_crisis'                            => 'jetpack_sync_error_idc_validation',
6625
			'jetpack_is_post_mailable'                               => null,
6626
			'jetpack_seo_site_host'                                  => null,
6627
			'jetpack_installed_plugin'                               => 'jetpack_plugin_installed',
6628
			'jetpack_holiday_snow_option_name'                       => null,
6629
			'jetpack_holiday_chance_of_snow'                         => null,
6630
			'jetpack_holiday_snow_js_url'                            => null,
6631
			'jetpack_is_holiday_snow_season'                         => null,
6632
			'jetpack_holiday_snow_option_updated'                    => null,
6633
			'jetpack_holiday_snowing'                                => null,
6634
			'jetpack_sso_auth_cookie_expirtation'                    => 'jetpack_sso_auth_cookie_expiration',
6635
			'jetpack_cache_plans'                                    => null,
6636
			'jetpack_updated_theme'                                  => 'jetpack_updated_themes',
6637
		);
6638
6639
		// This is a silly loop depth. Better way?
6640
		foreach( $deprecated_list AS $hook => $hook_alt ) {
6641
			if ( has_action( $hook ) ) {
6642
				foreach( $wp_filter[ $hook ] AS $func => $values ) {
6643
					foreach( $values AS $hooked ) {
6644
						if ( is_callable( $hooked['function'] ) ) {
6645
							$function_name = 'an anonymous function';
6646
						} else {
6647
							$function_name = $hooked['function'];
6648
						}
6649
						_deprecated_function( $hook . ' used for ' . $function_name, null, $hook_alt );
6650
					}
6651
				}
6652
			}
6653
		}
6654
	}
6655
6656
	/**
6657
	 * Converts any url in a stylesheet, to the correct absolute url.
6658
	 *
6659
	 * Considerations:
6660
	 *  - Normal, relative URLs     `feh.png`
6661
	 *  - Data URLs                 `data:image/gif;base64,eh129ehiuehjdhsa==`
6662
	 *  - Schema-agnostic URLs      `//domain.com/feh.png`
6663
	 *  - Absolute URLs             `http://domain.com/feh.png`
6664
	 *  - Domain root relative URLs `/feh.png`
6665
	 *
6666
	 * @param $css string: The raw CSS -- should be read in directly from the file.
6667
	 * @param $css_file_url : The URL that the file can be accessed at, for calculating paths from.
6668
	 *
6669
	 * @return mixed|string
6670
	 */
6671
	public static function absolutize_css_urls( $css, $css_file_url ) {
6672
		$pattern = '#url\((?P<path>[^)]*)\)#i';
6673
		$css_dir = dirname( $css_file_url );
6674
		$p       = parse_url( $css_dir );
6675
		$domain  = sprintf(
6676
					'%1$s//%2$s%3$s%4$s',
6677
					isset( $p['scheme'] )           ? "{$p['scheme']}:" : '',
6678
					isset( $p['user'], $p['pass'] ) ? "{$p['user']}:{$p['pass']}@" : '',
6679
					$p['host'],
6680
					isset( $p['port'] )             ? ":{$p['port']}" : ''
6681
				);
6682
6683
		if ( preg_match_all( $pattern, $css, $matches, PREG_SET_ORDER ) ) {
6684
			$find = $replace = array();
6685
			foreach ( $matches as $match ) {
6686
				$url = trim( $match['path'], "'\" \t" );
6687
6688
				// If this is a data url, we don't want to mess with it.
6689
				if ( 'data:' === substr( $url, 0, 5 ) ) {
6690
					continue;
6691
				}
6692
6693
				// If this is an absolute or protocol-agnostic url,
6694
				// we don't want to mess with it.
6695
				if ( preg_match( '#^(https?:)?//#i', $url ) ) {
6696
					continue;
6697
				}
6698
6699
				switch ( substr( $url, 0, 1 ) ) {
6700
					case '/':
6701
						$absolute = $domain . $url;
6702
						break;
6703
					default:
6704
						$absolute = $css_dir . '/' . $url;
6705
				}
6706
6707
				$find[]    = $match[0];
6708
				$replace[] = sprintf( 'url("%s")', $absolute );
6709
			}
6710
			$css = str_replace( $find, $replace, $css );
6711
		}
6712
6713
		return $css;
6714
	}
6715
6716
	/**
6717
	 * This methods removes all of the registered css files on the front end
6718
	 * from Jetpack in favor of using a single file. In effect "imploding"
6719
	 * all the files into one file.
6720
	 *
6721
	 * Pros:
6722
	 * - Uses only ONE css asset connection instead of 15
6723
	 * - Saves a minimum of 56k
6724
	 * - Reduces server load
6725
	 * - Reduces time to first painted byte
6726
	 *
6727
	 * Cons:
6728
	 * - Loads css for ALL modules. However all selectors are prefixed so it
6729
	 *		should not cause any issues with themes.
6730
	 * - Plugins/themes dequeuing styles no longer do anything. See
6731
	 *		jetpack_implode_frontend_css filter for a workaround
6732
	 *
6733
	 * For some situations developers may wish to disable css imploding and
6734
	 * instead operate in legacy mode where each file loads seperately and
6735
	 * can be edited individually or dequeued. This can be accomplished with
6736
	 * the following line:
6737
	 *
6738
	 * add_filter( 'jetpack_implode_frontend_css', '__return_false' );
6739
	 *
6740
	 * @since 3.2
6741
	 **/
6742
	public function implode_frontend_css( $travis_test = false ) {
6743
		$do_implode = true;
6744
		if ( defined( 'SCRIPT_DEBUG' ) && SCRIPT_DEBUG ) {
6745
			$do_implode = false;
6746
		}
6747
6748
		/**
6749
		 * Allow CSS to be concatenated into a single jetpack.css file.
6750
		 *
6751
		 * @since 3.2.0
6752
		 *
6753
		 * @param bool $do_implode Should CSS be concatenated? Default to true.
6754
		 */
6755
		$do_implode = apply_filters( 'jetpack_implode_frontend_css', $do_implode );
6756
6757
		// Do not use the imploded file when default behaviour was altered through the filter
6758
		if ( ! $do_implode ) {
6759
			return;
6760
		}
6761
6762
		// We do not want to use the imploded file in dev mode, or if not connected
6763
		if ( Jetpack::is_development_mode() || ! self::is_active() ) {
6764
			if ( ! $travis_test ) {
6765
				return;
6766
			}
6767
		}
6768
6769
		// Do not use the imploded file if sharing css was dequeued via the sharing settings screen
6770
		if ( get_option( 'sharedaddy_disable_resources' ) ) {
6771
			return;
6772
		}
6773
6774
		/*
6775
		 * Now we assume Jetpack is connected and able to serve the single
6776
		 * file.
6777
		 *
6778
		 * In the future there will be a check here to serve the file locally
6779
		 * or potentially from the Jetpack CDN
6780
		 *
6781
		 * For now:
6782
		 * - Enqueue a single imploded css file
6783
		 * - Zero out the style_loader_tag for the bundled ones
6784
		 * - Be happy, drink scotch
6785
		 */
6786
6787
		add_filter( 'style_loader_tag', array( $this, 'concat_remove_style_loader_tag' ), 10, 2 );
6788
6789
		$version = Jetpack::is_development_version() ? filemtime( JETPACK__PLUGIN_DIR . 'css/jetpack.css' ) : JETPACK__VERSION;
6790
6791
		wp_enqueue_style( 'jetpack_css', plugins_url( 'css/jetpack.css', __FILE__ ), array(), $version );
6792
		wp_style_add_data( 'jetpack_css', 'rtl', 'replace' );
6793
	}
6794
6795
	function concat_remove_style_loader_tag( $tag, $handle ) {
6796
		if ( in_array( $handle, $this->concatenated_style_handles ) ) {
6797
			$tag = '';
6798
			if ( defined( 'WP_DEBUG' ) && WP_DEBUG ) {
6799
				$tag = "<!-- `" . esc_html( $handle ) . "` is included in the concatenated jetpack.css -->\r\n";
6800
			}
6801
		}
6802
6803
		return $tag;
6804
	}
6805
6806
	/*
6807
	 * Check the heartbeat data
6808
	 *
6809
	 * Organizes the heartbeat data by severity.  For example, if the site
6810
	 * is in an ID crisis, it will be in the $filtered_data['bad'] array.
6811
	 *
6812
	 * Data will be added to "caution" array, if it either:
6813
	 *  - Out of date Jetpack version
6814
	 *  - Out of date WP version
6815
	 *  - Out of date PHP version
6816
	 *
6817
	 * $return array $filtered_data
6818
	 */
6819
	public static function jetpack_check_heartbeat_data() {
6820
		$raw_data = Jetpack_Heartbeat::generate_stats_array();
6821
6822
		$good    = array();
6823
		$caution = array();
6824
		$bad     = array();
6825
6826
		foreach ( $raw_data as $stat => $value ) {
6827
6828
			// Check jetpack version
6829
			if ( 'version' == $stat ) {
6830
				if ( version_compare( $value, JETPACK__VERSION, '<' ) ) {
6831
					$caution[ $stat ] = $value . " - min supported is " . JETPACK__VERSION;
6832
					continue;
6833
				}
6834
			}
6835
6836
			// Check WP version
6837
			if ( 'wp-version' == $stat ) {
6838
				if ( version_compare( $value, JETPACK__MINIMUM_WP_VERSION, '<' ) ) {
6839
					$caution[ $stat ] = $value . " - min supported is " . JETPACK__MINIMUM_WP_VERSION;
6840
					continue;
6841
				}
6842
			}
6843
6844
			// Check PHP version
6845
			if ( 'php-version' == $stat ) {
6846
				if ( version_compare( PHP_VERSION, '5.2.4', '<' ) ) {
6847
					$caution[ $stat ] = $value . " - min supported is 5.2.4";
6848
					continue;
6849
				}
6850
			}
6851
6852
			// Check ID crisis
6853
			if ( 'identitycrisis' == $stat ) {
6854
				if ( 'yes' == $value ) {
6855
					$bad[ $stat ] = $value;
6856
					continue;
6857
				}
6858
			}
6859
6860
			// The rest are good :)
6861
			$good[ $stat ] = $value;
6862
		}
6863
6864
		$filtered_data = array(
6865
			'good'    => $good,
6866
			'caution' => $caution,
6867
			'bad'     => $bad
6868
		);
6869
6870
		return $filtered_data;
6871
	}
6872
6873
6874
	/*
6875
	 * This method is used to organize all options that can be reset
6876
	 * without disconnecting Jetpack.
6877
	 *
6878
	 * It is used in class.jetpack-cli.php to reset options
6879
	 *
6880
	 * @since 5.4.0 Logic moved to Jetpack_Options class. Method left in Jetpack class for backwards compat.
6881
	 *
6882
	 * @return array of options to delete.
6883
	 */
6884
	public static function get_jetpack_options_for_reset() {
6885
		return Jetpack_Options::get_options_for_reset();
6886
	}
6887
6888
	/**
6889
	 * Check if an option of a Jetpack module has been updated.
6890
	 *
6891
	 * If any module option has been updated before Jump Start has been dismissed,
6892
	 * update the 'jumpstart' option so we can hide Jump Start.
6893
	 *
6894
	 * @param string $option_name
6895
	 *
6896
	 * @return bool
6897
	 */
6898
	public static function jumpstart_has_updated_module_option( $option_name = '' ) {
6899
		// Bail if Jump Start has already been dismissed
6900
		if ( 'new_connection' !== Jetpack_Options::get_option( 'jumpstart' ) ) {
6901
			return false;
6902
		}
6903
6904
		$jetpack = Jetpack::init();
6905
6906
		// Manual build of module options
6907
		$option_names = self::get_jetpack_options_for_reset();
6908
6909
		if ( in_array( $option_name, $option_names['wp_options'] ) ) {
6910
			Jetpack_Options::update_option( 'jumpstart', 'jetpack_action_taken' );
6911
6912
			//Jump start is being dismissed send data to MC Stats
6913
			$jetpack->stat( 'jumpstart', 'manual,'.$option_name );
6914
6915
			$jetpack->do_stats( 'server_side' );
6916
		}
6917
6918
	}
6919
6920
	/*
6921
	 * Strip http:// or https:// from a url, replaces forward slash with ::,
6922
	 * so we can bring them directly to their site in calypso.
6923
	 *
6924
	 * @param string | url
6925
	 * @return string | url without the guff
6926
	 */
6927
	public static function build_raw_urls( $url ) {
6928
		$strip_http = '/.*?:\/\//i';
6929
		$url = preg_replace( $strip_http, '', $url  );
6930
		$url = str_replace( '/', '::', $url );
6931
		return $url;
6932
	}
6933
6934
	/**
6935
	 * Stores and prints out domains to prefetch for page speed optimization.
6936
	 *
6937
	 * @param mixed $new_urls
6938
	 */
6939
	public static function dns_prefetch( $new_urls = null ) {
6940
		static $prefetch_urls = array();
6941
		if ( empty( $new_urls ) && ! empty( $prefetch_urls ) ) {
6942
			echo "\r\n";
6943
			foreach ( $prefetch_urls as $this_prefetch_url ) {
6944
				printf( "<link rel='dns-prefetch' href='%s'/>\r\n", esc_attr( $this_prefetch_url ) );
6945
			}
6946
		} elseif ( ! empty( $new_urls ) ) {
6947
			if ( ! has_action( 'wp_head', array( __CLASS__, __FUNCTION__ ) ) ) {
6948
				add_action( 'wp_head', array( __CLASS__, __FUNCTION__ ) );
6949
			}
6950
			foreach ( (array) $new_urls as $this_new_url ) {
6951
				$prefetch_urls[] = strtolower( untrailingslashit( preg_replace( '#^https?://#i', '//', $this_new_url ) ) );
6952
			}
6953
			$prefetch_urls = array_unique( $prefetch_urls );
6954
		}
6955
	}
6956
6957
	public function wp_dashboard_setup() {
6958
		if ( self::is_active() ) {
6959
			add_action( 'jetpack_dashboard_widget', array( __CLASS__, 'dashboard_widget_footer' ), 999 );
6960
		}
6961
6962
		if ( has_action( 'jetpack_dashboard_widget' ) ) {
6963
			wp_add_dashboard_widget(
6964
				'jetpack_summary_widget',
6965
				esc_html__( 'Site Stats', 'jetpack' ),
6966
				array( __CLASS__, 'dashboard_widget' )
6967
			);
6968
			wp_enqueue_style( 'jetpack-dashboard-widget', plugins_url( 'css/dashboard-widget.css', JETPACK__PLUGIN_FILE ), array(), JETPACK__VERSION );
6969
6970
			// If we're inactive and not in development mode, sort our box to the top.
6971
			if ( ! self::is_active() && ! self::is_development_mode() ) {
6972
				global $wp_meta_boxes;
6973
6974
				$dashboard = $wp_meta_boxes['dashboard']['normal']['core'];
6975
				$ours      = array( 'jetpack_summary_widget' => $dashboard['jetpack_summary_widget'] );
6976
6977
				$wp_meta_boxes['dashboard']['normal']['core'] = array_merge( $ours, $dashboard );
6978
			}
6979
		}
6980
	}
6981
6982
	/**
6983
	 * @param mixed $result Value for the user's option
6984
	 * @return mixed
6985
	 */
6986
	function get_user_option_meta_box_order_dashboard( $sorted ) {
6987
		if ( ! is_array( $sorted ) ) {
6988
			return $sorted;
6989
		}
6990
6991
		foreach ( $sorted as $box_context => $ids ) {
6992
			if ( false === strpos( $ids, 'dashboard_stats' ) ) {
6993
				// If the old id isn't anywhere in the ids, don't bother exploding and fail out.
6994
				continue;
6995
			}
6996
6997
			$ids_array = explode( ',', $ids );
6998
			$key = array_search( 'dashboard_stats', $ids_array );
6999
7000
			if ( false !== $key ) {
7001
				// If we've found that exact value in the option (and not `google_dashboard_stats` for example)
7002
				$ids_array[ $key ] = 'jetpack_summary_widget';
7003
				$sorted[ $box_context ] = implode( ',', $ids_array );
7004
				// We've found it, stop searching, and just return.
7005
				break;
7006
			}
7007
		}
7008
7009
		return $sorted;
7010
	}
7011
7012
	public static function dashboard_widget() {
7013
		/**
7014
		 * Fires when the dashboard is loaded.
7015
		 *
7016
		 * @since 3.4.0
7017
		 */
7018
		do_action( 'jetpack_dashboard_widget' );
7019
	}
7020
7021
	public static function dashboard_widget_footer() {
7022
		?>
7023
		<footer>
7024
7025
		<div class="protect">
7026
			<?php if ( Jetpack::is_module_active( 'protect' ) ) : ?>
7027
				<h3><?php echo number_format_i18n( get_site_option( 'jetpack_protect_blocked_attempts', 0 ) ); ?></h3>
7028
				<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>
7029
			<?php elseif ( current_user_can( 'jetpack_activate_modules' ) && ! self::is_development_mode() ) : ?>
7030
				<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' ); ?>">
7031
					<?php esc_html_e( 'Activate Protect', 'jetpack' ); ?>
7032
				</a>
7033
			<?php else : ?>
7034
				<?php esc_html_e( 'Protect is inactive.', 'jetpack' ); ?>
7035
			<?php endif; ?>
7036
		</div>
7037
7038
		<div class="akismet">
7039
			<?php if ( is_plugin_active( 'akismet/akismet.php' ) ) : ?>
7040
				<h3><?php echo number_format_i18n( get_option( 'akismet_spam_count', 0 ) ); ?></h3>
7041
				<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>
7042
			<?php elseif ( current_user_can( 'activate_plugins' ) && ! is_wp_error( validate_plugin( 'akismet/akismet.php' ) ) ) : ?>
7043
				<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">
7044
					<?php esc_html_e( 'Activate Akismet', 'jetpack' ); ?>
7045
				</a>
7046
			<?php else : ?>
7047
				<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>
7048
			<?php endif; ?>
7049
		</div>
7050
7051
		</footer>
7052
		<?php
7053
	}
7054
7055
	/**
7056
	 * Return string containing the Jetpack logo.
7057
	 *
7058
	 * @since 3.9.0
7059
	 *
7060
	 * @return string
7061
	 */
7062
	public static function get_jp_emblem() {
7063
		return '<svg id="jetpack-logo__icon" xmlns="http://www.w3.org/2000/svg" x="0px" y="0px" viewBox="0 0 32 32"><path fill="#00BE28" d="M16,0C7.2,0,0,7.2,0,16s7.2,16,16,16c8.8,0,16-7.2,16-16S24.8,0,16,0z M15.2,18.7h-8l8-15.5V18.7z M16.8,28.8 V13.3h8L16.8,28.8z"/></svg>';
7064
	}
7065
7066
	/*
7067
	 * Adds a "blank" column in the user admin table to display indication of user connection.
7068
	 */
7069
	function jetpack_icon_user_connected( $columns ) {
7070
		$columns['user_jetpack'] = '';
7071
		return $columns;
7072
	}
7073
7074
	/*
7075
	 * Show Jetpack icon if the user is linked.
7076
	 */
7077
	function jetpack_show_user_connected_icon( $val, $col, $user_id ) {
7078
		if ( 'user_jetpack' == $col && Jetpack::is_user_connected( $user_id ) ) {
7079
			$emblem_html = sprintf(
7080
				'<a title="%1$s" class="jp-emblem-user-admin">%2$s</a>',
7081
				esc_attr__( 'This user is linked and ready to fly with Jetpack.', 'jetpack' ),
7082
				Jetpack::get_jp_emblem()
7083
			);
7084
			return $emblem_html;
7085
		}
7086
7087
		return $val;
7088
	}
7089
7090
	/*
7091
	 * Style the Jetpack user column
7092
	 */
7093
	function jetpack_user_col_style() {
7094
		global $current_screen;
7095
		if ( ! empty( $current_screen->base ) && 'users' == $current_screen->base ) { ?>
7096
			<style>
7097
				.fixed .column-user_jetpack {
7098
					width: 21px;
7099
				}
7100
				.jp-emblem-user-admin svg {
7101
					width: 20px;
7102
					height: 20px;
7103
				}
7104
				.jp-emblem-user-admin path {
7105
					fill: #00BE28;
7106
				}
7107
			</style>
7108
		<?php }
7109
	}
7110
7111
	/**
7112
	 * Checks if Akismet is active and working.
7113
	 *
7114
	 * @since  5.1.0
7115
	 * @return bool True = Akismet available. False = Aksimet not available.
7116
	 */
7117
	public static function is_akismet_active() {
7118
		if ( method_exists( 'Akismet' , 'http_post' ) || function_exists( 'akismet_http_post' ) ) {
7119
			return true;
7120
		}
7121
		return false;
7122
	}
7123
7124
	/**
7125
	 * Checks if one or more function names is in debug_backtrace
7126
	 *
7127
	 * @param $names Mixed string name of function or array of string names of functions
7128
	 *
7129
	 * @return bool
7130
	 */
7131
	public static function is_function_in_backtrace( $names ) {
7132
		$backtrace = debug_backtrace( false );
7133
		if ( ! is_array( $names ) ) {
7134
			$names = array( $names );
7135
		}
7136
		$names_as_keys = array_flip( $names );
7137
7138
		//Do check in constant O(1) time for PHP5.5+
7139
		if ( function_exists( 'array_column' ) ) {
7140
			$backtrace_functions = array_column( $backtrace, 'function' );
7141
			$backtrace_functions_as_keys = array_flip( $backtrace_functions );
7142
			$intersection = array_intersect_key( $backtrace_functions_as_keys, $names_as_keys );
7143
			return ! empty ( $intersection );
7144
		}
7145
7146
		//Do check in linear O(n) time for < PHP5.5 ( using isset at least prevents O(n^2) )
7147
		foreach ( $backtrace as $call ) {
7148
			if ( isset( $names_as_keys[ $call['function'] ] ) ) {
7149
				return true;
7150
			}
7151
		}
7152
		return false;
7153
	}
7154
7155
	/**
7156
	 * Given a minified path, and a non-minified path, will return
7157
	 * a minified or non-minified file URL based on whether SCRIPT_DEBUG is set and truthy.
7158
	 *
7159
	 * Both `$min_base` and `$non_min_base` are expected to be relative to the
7160
	 * root Jetpack directory.
7161
	 *
7162
	 * @since 5.6.0
7163
	 *
7164
	 * @param string $min_path
7165
	 * @param string $non_min_path
7166
	 * @return string The URL to the file
7167
	 */
7168
	public static function get_file_url_for_environment( $min_path, $non_min_path ) {
7169
		$path = ( Jetpack_Constants::is_defined( 'SCRIPT_DEBUG' ) && Jetpack_Constants::get_constant( 'SCRIPT_DEBUG' ) )
7170
			? $non_min_path
7171
			: $min_path;
7172
7173
		return plugins_url( $path, JETPACK__PLUGIN_FILE );
7174
	}
7175
7176
	/**
7177
	 * Checks for whether Jetpack Rewind is enabled.
7178
	 * Will return true if the state of Rewind is anything except "unavailable".
7179
	 * @return bool|int|mixed
7180
	 */
7181
	public static function is_rewind_enabled() {
7182
		if ( ! Jetpack::is_active() ) {
7183
			return false;
7184
		}
7185
7186
		$rewind_enabled = get_transient( 'jetpack_rewind_enabled' );
7187
		if ( false === $rewind_enabled ) {
7188
			jetpack_require_lib( 'class.core-rest-api-endpoints' );
7189
			$rewind_data = (array) Jetpack_Core_Json_Api_Endpoints::rewind_data();
7190
			$rewind_enabled = ( ! is_wp_error( $rewind_data )
7191
				&& ! empty( $rewind_data['state'] )
7192
				&& 'active' === $rewind_data['state'] )
7193
				? 1
7194
				: 0;
7195
7196
			set_transient( 'jetpack_rewind_enabled', $rewind_enabled, 10 * MINUTE_IN_SECONDS );
7197
		}
7198
		return $rewind_enabled;
7199
	}
7200
7201
	/**
7202
	 * Checks whether or not TOS has been agreed upon.
7203
	 * Will return true if a user has clicked to register, or is already connected.
7204
	 */
7205
	public static function jetpack_tos_agreed() {
7206
		return Jetpack_Options::get_option( 'tos_agreed' ) || Jetpack::is_active();
7207
	}
7208
7209
	/**
7210
	 * Handles activating default modules as well general cleanup for the new connection.
7211
	 *
7212
	 * @param boolean $activate_sso                 Whether to activate the SSO module when activating default modules.
7213
	 * @param boolean $redirect_on_activation_error Whether to redirect on activation error.
7214
	 * @return void
7215
	 */
7216
	public static function handle_post_authorization_actions( $activate_sso = false, $redirect_on_activation_error = false ) {
7217
		$other_modules = $activate_sso
7218
			? array( 'sso' )
7219
			: array();
7220
7221 View Code Duplication
		if ( $active_modules = Jetpack_Options::get_option( 'active_modules' ) ) {
7222
			Jetpack::delete_active_modules();
7223
7224
			Jetpack::activate_default_modules( 999, 1, array_merge( $active_modules, $other_modules ), $redirect_on_activation_error, false );
7225
		} else {
7226
			Jetpack::activate_default_modules( false, false, $other_modules, $redirect_on_activation_error, false );
7227
		}
7228
7229
		// Since this is a fresh connection, be sure to clear out IDC options
7230
		Jetpack_IDC::clear_all_idc_options();
7231
		Jetpack_Options::delete_raw_option( 'jetpack_last_connect_url_check' );
7232
7233
		// Start nonce cleaner
7234
		wp_clear_scheduled_hook( 'jetpack_clean_nonces' );
7235
		wp_schedule_event( time(), 'hourly', 'jetpack_clean_nonces' );
7236
7237
		Jetpack::state( 'message', 'authorized' );
7238
	}
7239
}
7240