Completed
Push — fix/wpme-always-https ( 068c3b )
by
unknown
27:47 queued 20:13
created

class.jetpack.php (1 issue)

Upgrade to new PHP Analysis Engine

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

1
<?php
2
3
/*
4
Options:
5
jetpack_options (array)
6
	An array of options.
7
	@see Jetpack_Options::get_option_names()
8
9
jetpack_register (string)
10
	Temporary verification secrets.
11
12
jetpack_activated (int)
13
	1: the plugin was activated normally
14
	2: the plugin was activated on this site because of a network-wide activation
15
	3: the plugin was auto-installed
16
	4: the plugin was manually disconnected (but is still installed)
17
18
jetpack_active_modules (array)
19
	Array of active module slugs.
20
21
jetpack_do_activate (bool)
22
	Flag for "activating" the plugin on sites where the activation hook never fired (auto-installs)
23
*/
24
25
require_once( JETPACK__PLUGIN_DIR . '_inc/lib/class.media.php' );
26
27
class Jetpack {
28
	public $xmlrpc_server = null;
29
30
	private $xmlrpc_verification = null;
31
	private $rest_authentication_status = null;
32
33
	public $HTTP_RAW_POST_DATA = null; // copy of $GLOBALS['HTTP_RAW_POST_DATA']
34
35
	/**
36
	 * @var array The handles of styles that are concatenated into jetpack.css
37
	 */
38
	public $concatenated_style_handles = array(
39
		'jetpack-carousel',
40
		'grunion.css',
41
		'the-neverending-homepage',
42
		'jetpack_likes',
43
		'jetpack_related-posts',
44
		'sharedaddy',
45
		'jetpack-slideshow',
46
		'presentations',
47
		'jetpack-subscriptions',
48
		'jetpack-responsive-videos-style',
49
		'jetpack-social-menu',
50
		'tiled-gallery',
51
		'jetpack_display_posts_widget',
52
		'gravatar-profile-widget',
53
		'goodreads-widget',
54
		'jetpack_social_media_icons_widget',
55
		'jetpack-top-posts-widget',
56
		'jetpack_image_widget',
57
		'jetpack-my-community-widget',
58
		'wordads',
59
		'eu-cookie-law-style',
60
		'flickr-widget-style',
61
	);
62
63
	/**
64
	 * Contains all assets that have had their URL rewritten to minified versions.
65
	 *
66
	 * @var array
67
	 */
68
	static $min_assets = array();
69
70
	public $plugins_to_deactivate = array(
71
		'stats'               => array( 'stats/stats.php', 'WordPress.com Stats' ),
72
		'shortlinks'          => array( 'stats/stats.php', 'WordPress.com Stats' ),
73
		'sharedaddy'          => array( 'sharedaddy/sharedaddy.php', 'Sharedaddy' ),
74
		'twitter-widget'      => array( 'wickett-twitter-widget/wickett-twitter-widget.php', 'Wickett Twitter Widget' ),
75
		'after-the-deadline'  => array( 'after-the-deadline/after-the-deadline.php', 'After The Deadline' ),
76
		'contact-form'        => array( 'grunion-contact-form/grunion-contact-form.php', 'Grunion Contact Form' ),
77
		'contact-form'        => array( 'mullet/mullet-contact-form.php', 'Mullet Contact Form' ),
78
		'custom-css'          => array( 'safecss/safecss.php', 'WordPress.com Custom CSS' ),
79
		'random-redirect'     => array( 'random-redirect/random-redirect.php', 'Random Redirect' ),
80
		'videopress'          => array( 'video/video.php', 'VideoPress' ),
81
		'widget-visibility'   => array( 'jetpack-widget-visibility/widget-visibility.php', 'Jetpack Widget Visibility' ),
82
		'widget-visibility'   => array( 'widget-visibility-without-jetpack/widget-visibility-without-jetpack.php', 'Widget Visibility Without Jetpack' ),
83
		'sharedaddy'          => array( 'jetpack-sharing/sharedaddy.php', 'Jetpack Sharing' ),
84
		'gravatar-hovercards' => array( 'jetpack-gravatar-hovercards/gravatar-hovercards.php', 'Jetpack Gravatar Hovercards' ),
85
		'latex'               => array( 'wp-latex/wp-latex.php', 'WP LaTeX' )
86
	);
87
88
	static $capability_translations = array(
89
		'administrator' => 'manage_options',
90
		'editor'        => 'edit_others_posts',
91
		'author'        => 'publish_posts',
92
		'contributor'   => 'edit_posts',
93
		'subscriber'    => 'read',
94
	);
95
96
	/**
97
	 * Map of modules that have conflicts with plugins and should not be auto-activated
98
	 * if the plugins are active.  Used by filter_default_modules
99
	 *
100
	 * Plugin Authors: If you'd like to prevent a single module from auto-activating,
101
	 * change `module-slug` and add this to your plugin:
102
	 *
103
	 * add_filter( 'jetpack_get_default_modules', 'my_jetpack_get_default_modules' );
104
	 * function my_jetpack_get_default_modules( $modules ) {
105
	 *     return array_diff( $modules, array( 'module-slug' ) );
106
	 * }
107
	 *
108
	 * @var array
109
	 */
110
	private $conflicting_plugins = array(
111
		'comments'          => array(
112
			'Intense Debate'                       => 'intensedebate/intensedebate.php',
113
			'Disqus'                               => 'disqus-comment-system/disqus.php',
114
			'Livefyre'                             => 'livefyre-comments/livefyre.php',
115
			'Comments Evolved for WordPress'       => 'gplus-comments/comments-evolved.php',
116
			'Google+ Comments'                     => 'google-plus-comments/google-plus-comments.php',
117
			'WP-SpamShield Anti-Spam'              => 'wp-spamshield/wp-spamshield.php',
118
		),
119
		'comment-likes' => array(
120
			'Epoch'                                => 'epoch/plugincore.php',
121
		),
122
		'contact-form'      => array(
123
			'Contact Form 7'                       => 'contact-form-7/wp-contact-form-7.php',
124
			'Gravity Forms'                        => 'gravityforms/gravityforms.php',
125
			'Contact Form Plugin'                  => 'contact-form-plugin/contact_form.php',
126
			'Easy Contact Forms'                   => 'easy-contact-forms/easy-contact-forms.php',
127
			'Fast Secure Contact Form'             => 'si-contact-form/si-contact-form.php',
128
			'Ninja Forms'                          => 'ninja-forms/ninja-forms.php',
129
		),
130
		'minileven'         => array(
131
			'WPtouch'                              => 'wptouch/wptouch.php',
132
		),
133
		'latex'             => array(
134
			'LaTeX for WordPress'                  => 'latex/latex.php',
135
			'Youngwhans Simple Latex'              => 'youngwhans-simple-latex/yw-latex.php',
136
			'Easy WP LaTeX'                        => 'easy-wp-latex-lite/easy-wp-latex-lite.php',
137
			'MathJax-LaTeX'                        => 'mathjax-latex/mathjax-latex.php',
138
			'Enable Latex'                         => 'enable-latex/enable-latex.php',
139
			'WP QuickLaTeX'                        => 'wp-quicklatex/wp-quicklatex.php',
140
		),
141
		'protect'           => array(
142
			'Limit Login Attempts'                 => 'limit-login-attempts/limit-login-attempts.php',
143
			'Captcha'                              => 'captcha/captcha.php',
144
			'Brute Force Login Protection'         => 'brute-force-login-protection/brute-force-login-protection.php',
145
			'Login Security Solution'              => 'login-security-solution/login-security-solution.php',
146
			'WPSecureOps Brute Force Protect'      => 'wpsecureops-bruteforce-protect/wpsecureops-bruteforce-protect.php',
147
			'BulletProof Security'                 => 'bulletproof-security/bulletproof-security.php',
148
			'SiteGuard WP Plugin'                  => 'siteguard/siteguard.php',
149
			'Security-protection'                  => 'security-protection/security-protection.php',
150
			'Login Security'                       => 'login-security/login-security.php',
151
			'Botnet Attack Blocker'                => 'botnet-attack-blocker/botnet-attack-blocker.php',
152
			'Wordfence Security'                   => 'wordfence/wordfence.php',
153
			'All In One WP Security & Firewall'    => 'all-in-one-wp-security-and-firewall/wp-security.php',
154
			'iThemes Security'                     => 'better-wp-security/better-wp-security.php',
155
		),
156
		'random-redirect'   => array(
157
			'Random Redirect 2'                    => 'random-redirect-2/random-redirect.php',
158
		),
159
		'related-posts'     => array(
160
			'YARPP'                                => 'yet-another-related-posts-plugin/yarpp.php',
161
			'WordPress Related Posts'              => 'wordpress-23-related-posts-plugin/wp_related_posts.php',
162
			'nrelate Related Content'              => 'nrelate-related-content/nrelate-related.php',
163
			'Contextual Related Posts'             => 'contextual-related-posts/contextual-related-posts.php',
164
			'Related Posts for WordPress'          => 'microkids-related-posts/microkids-related-posts.php',
165
			'outbrain'                             => 'outbrain/outbrain.php',
166
			'Shareaholic'                          => 'shareaholic/shareaholic.php',
167
			'Sexybookmarks'                        => 'sexybookmarks/shareaholic.php',
168
		),
169
		'sharedaddy'        => array(
170
			'AddThis'                              => 'addthis/addthis_social_widget.php',
171
			'Add To Any'                           => 'add-to-any/add-to-any.php',
172
			'ShareThis'                            => 'share-this/sharethis.php',
173
			'Shareaholic'                          => 'shareaholic/shareaholic.php',
174
		),
175
		'seo-tools' => array(
176
			'WordPress SEO by Yoast'               => 'wordpress-seo/wp-seo.php',
177
			'WordPress SEO Premium by Yoast'       => 'wordpress-seo-premium/wp-seo-premium.php',
178
			'All in One SEO Pack'                  => 'all-in-one-seo-pack/all_in_one_seo_pack.php',
179
			'All in One SEO Pack Pro'              => 'all-in-one-seo-pack-pro/all_in_one_seo_pack.php',
180
		),
181
		'verification-tools' => array(
182
			'WordPress SEO by Yoast'               => 'wordpress-seo/wp-seo.php',
183
			'WordPress SEO Premium by Yoast'       => 'wordpress-seo-premium/wp-seo-premium.php',
184
			'All in One SEO Pack'                  => 'all-in-one-seo-pack/all_in_one_seo_pack.php',
185
			'All in One SEO Pack Pro'              => 'all-in-one-seo-pack-pro/all_in_one_seo_pack.php',
186
		),
187
		'widget-visibility' => array(
188
			'Widget Logic'                         => 'widget-logic/widget_logic.php',
189
			'Dynamic Widgets'                      => 'dynamic-widgets/dynamic-widgets.php',
190
		),
191
		'sitemaps' => array(
192
			'Google XML Sitemaps'                  => 'google-sitemap-generator/sitemap.php',
193
			'Better WordPress Google XML Sitemaps' => 'bwp-google-xml-sitemaps/bwp-simple-gxs.php',
194
			'Google XML Sitemaps for qTranslate'   => 'google-xml-sitemaps-v3-for-qtranslate/sitemap.php',
195
			'XML Sitemap & Google News feeds'      => 'xml-sitemap-feed/xml-sitemap.php',
196
			'Google Sitemap by BestWebSoft'        => 'google-sitemap-plugin/google-sitemap-plugin.php',
197
			'WordPress SEO by Yoast'               => 'wordpress-seo/wp-seo.php',
198
			'WordPress SEO Premium by Yoast'       => 'wordpress-seo-premium/wp-seo-premium.php',
199
			'All in One SEO Pack'                  => 'all-in-one-seo-pack/all_in_one_seo_pack.php',
200
			'All in One SEO Pack Pro'              => 'all-in-one-seo-pack-pro/all_in_one_seo_pack.php',
201
			'Sitemap'                              => 'sitemap/sitemap.php',
202
			'Simple Wp Sitemap'                    => 'simple-wp-sitemap/simple-wp-sitemap.php',
203
			'Simple Sitemap'                       => 'simple-sitemap/simple-sitemap.php',
204
			'XML Sitemaps'                         => 'xml-sitemaps/xml-sitemaps.php',
205
			'MSM Sitemaps'                         => 'msm-sitemap/msm-sitemap.php',
206
		),
207
	);
208
209
	/**
210
	 * Plugins for which we turn off our Facebook OG Tags implementation.
211
	 *
212
	 * Note: All in One SEO Pack, All in one SEO Pack Pro, WordPress SEO by Yoast, and WordPress SEO Premium by Yoast automatically deactivate
213
	 * Jetpack's Open Graph tags via filter when their Social Meta modules are active.
214
	 *
215
	 * Plugin authors: If you'd like to prevent Jetpack's Open Graph tag generation in your plugin, you can do so via this filter:
216
	 * add_filter( 'jetpack_enable_open_graph', '__return_false' );
217
	 */
218
	private $open_graph_conflicting_plugins = array(
219
		'2-click-socialmedia-buttons/2-click-socialmedia-buttons.php',
220
		                                                         // 2 Click Social Media Buttons
221
		'add-link-to-facebook/add-link-to-facebook.php',         // Add Link to Facebook
222
		'add-meta-tags/add-meta-tags.php',                       // Add Meta Tags
223
		'autodescription/autodescription.php',                   // The SEO Framework
224
		'easy-facebook-share-thumbnails/esft.php',               // Easy Facebook Share Thumbnail
225
		'heateor-open-graph-meta-tags/heateor-open-graph-meta-tags.php',
226
		                                                         // Open Graph Meta Tags by Heateor
227
		'facebook/facebook.php',                                 // Facebook (official plugin)
228
		'facebook-awd/AWD_facebook.php',                         // Facebook AWD All in one
229
		'facebook-featured-image-and-open-graph-meta-tags/fb-featured-image.php',
230
		                                                         // Facebook Featured Image & OG Meta Tags
231
		'facebook-meta-tags/facebook-metatags.php',              // Facebook Meta Tags
232
		'wonderm00ns-simple-facebook-open-graph-tags/wonderm00n-open-graph.php',
233
		                                                         // Facebook Open Graph Meta Tags for WordPress
234
		'facebook-revised-open-graph-meta-tag/index.php',        // Facebook Revised Open Graph Meta Tag
235
		'facebook-thumb-fixer/_facebook-thumb-fixer.php',        // Facebook Thumb Fixer
236
		'facebook-and-digg-thumbnail-generator/facebook-and-digg-thumbnail-generator.php',
237
		                                                         // Fedmich's Facebook Open Graph Meta
238
		'network-publisher/networkpub.php',                      // Network Publisher
239
		'nextgen-facebook/nextgen-facebook.php',                 // NextGEN Facebook OG
240
		'social-networks-auto-poster-facebook-twitter-g/NextScripts_SNAP.php',
241
		                                                         // NextScripts SNAP
242
		'og-tags/og-tags.php',                                   // OG Tags
243
		'opengraph/opengraph.php',                               // Open Graph
244
		'open-graph-protocol-framework/open-graph-protocol-framework.php',
245
		                                                         // Open Graph Protocol Framework
246
		'seo-facebook-comments/seofacebook.php',                 // SEO Facebook Comments
247
		'seo-ultimate/seo-ultimate.php',                         // SEO Ultimate
248
		'sexybookmarks/sexy-bookmarks.php',                      // Shareaholic
249
		'shareaholic/sexy-bookmarks.php',                        // Shareaholic
250
		'sharepress/sharepress.php',                             // SharePress
251
		'simple-facebook-connect/sfc.php',                       // Simple Facebook Connect
252
		'social-discussions/social-discussions.php',             // Social Discussions
253
		'social-sharing-toolkit/social_sharing_toolkit.php',     // Social Sharing Toolkit
254
		'socialize/socialize.php',                               // Socialize
255
		'squirrly-seo/squirrly.php',                             // SEO by SQUIRRLY™
256
		'only-tweet-like-share-and-google-1/tweet-like-plusone.php',
257
		                                                         // Tweet, Like, Google +1 and Share
258
		'wordbooker/wordbooker.php',                             // Wordbooker
259
		'wpsso/wpsso.php',                                       // WordPress Social Sharing Optimization
260
		'wp-caregiver/wp-caregiver.php',                         // WP Caregiver
261
		'wp-facebook-like-send-open-graph-meta/wp-facebook-like-send-open-graph-meta.php',
262
		                                                         // WP Facebook Like Send & Open Graph Meta
263
		'wp-facebook-open-graph-protocol/wp-facebook-ogp.php',   // WP Facebook Open Graph protocol
264
		'wp-ogp/wp-ogp.php',                                     // WP-OGP
265
		'zoltonorg-social-plugin/zosp.php',                      // Zolton.org Social Plugin
266
		'wp-fb-share-like-button/wp_fb_share-like_widget.php'    // WP Facebook Like Button
267
	);
268
269
	/**
270
	 * Plugins for which we turn off our Twitter Cards Tags implementation.
271
	 */
272
	private $twitter_cards_conflicting_plugins = array(
273
	//	'twitter/twitter.php',                       // The official one handles this on its own.
274
	//	                                             // https://github.com/twitter/wordpress/blob/master/src/Twitter/WordPress/Cards/Compatibility.php
275
		'eewee-twitter-card/index.php',              // Eewee Twitter Card
276
		'ig-twitter-cards/ig-twitter-cards.php',     // IG:Twitter Cards
277
		'jm-twitter-cards/jm-twitter-cards.php',     // JM Twitter Cards
278
		'kevinjohn-gallagher-pure-web-brilliants-social-graph-twitter-cards-extention/kevinjohn_gallagher___social_graph_twitter_output.php',
279
		                                             // Pure Web Brilliant's Social Graph Twitter Cards Extension
280
		'twitter-cards/twitter-cards.php',           // Twitter Cards
281
		'twitter-cards-meta/twitter-cards-meta.php', // Twitter Cards Meta
282
		'wp-twitter-cards/twitter_cards.php',        // WP Twitter Cards
283
	);
284
285
	/**
286
	 * Message to display in admin_notice
287
	 * @var string
288
	 */
289
	public $message = '';
290
291
	/**
292
	 * Error to display in admin_notice
293
	 * @var string
294
	 */
295
	public $error = '';
296
297
	/**
298
	 * Modules that need more privacy description.
299
	 * @var string
300
	 */
301
	public $privacy_checks = '';
302
303
	/**
304
	 * Stats to record once the page loads
305
	 *
306
	 * @var array
307
	 */
308
	public $stats = array();
309
310
	/**
311
	 * Jetpack_Sync object
312
	 */
313
	public $sync;
314
315
	/**
316
	 * Verified data for JSON authorization request
317
	 */
318
	public $json_api_authorization_request = array();
319
320
	/**
321
	 * Holds the singleton instance of this class
322
	 * @since 2.3.3
323
	 * @var Jetpack
324
	 */
325
	static $instance = false;
326
327
	/**
328
	 * Singleton
329
	 * @static
330
	 */
331
	public static function init() {
332
		if ( ! self::$instance ) {
333
			self::$instance = new Jetpack;
334
335
			self::$instance->plugin_upgrade();
336
		}
337
338
		return self::$instance;
339
	}
340
341
	/**
342
	 * Must never be called statically
343
	 */
344
	function plugin_upgrade() {
345
		if ( Jetpack::is_active() ) {
346
			list( $version ) = explode( ':', Jetpack_Options::get_option( 'version' ) );
347
			if ( JETPACK__VERSION != $version ) {
348
349
				// check which active modules actually exist and remove others from active_modules list
350
				$unfiltered_modules = Jetpack::get_active_modules();
351
				$modules = array_filter( $unfiltered_modules, array( 'Jetpack', 'is_module' ) );
352
				if ( array_diff( $unfiltered_modules, $modules ) ) {
353
					Jetpack::update_active_modules( $modules );
354
				}
355
356
				add_action( 'init', array( __CLASS__, 'activate_new_modules' ) );
357
358
				// Upgrade to 4.3.0
359
				if ( Jetpack_Options::get_option( 'identity_crisis_whitelist' ) ) {
360
					Jetpack_Options::delete_option( 'identity_crisis_whitelist' );
361
				}
362
363
				// Make sure Markdown for posts gets turned back on
364
				if ( ! get_option( 'wpcom_publish_posts_with_markdown' ) ) {
365
					update_option( 'wpcom_publish_posts_with_markdown', true );
366
				}
367
368
				if ( did_action( 'wp_loaded' ) ) {
369
					self::upgrade_on_load();
370
				} else {
371
					add_action(
372
						'wp_loaded',
373
						array( __CLASS__, 'upgrade_on_load' )
374
					);
375
				}
376
			}
377
		}
378
	}
379
380
	/**
381
	 * Runs upgrade routines that need to have modules loaded.
382
	 */
383
	static function upgrade_on_load() {
384
385
		// Not attempting any upgrades if jetpack_modules_loaded did not fire.
386
		// This can happen in case Jetpack has been just upgraded and is
387
		// being initialized late during the page load. In this case we wait
388
		// until the next proper admin page load with Jetpack active.
389
		if ( ! did_action( 'jetpack_modules_loaded' ) ) {
390
			return;
391
		}
392
393
		Jetpack::maybe_set_version_option();
394
395
		if ( class_exists( 'Jetpack_Widget_Conditions' ) ) {
396
			Jetpack_Widget_Conditions::migrate_post_type_rules();
397
		}
398
399
		if (
400
			class_exists( 'Jetpack_Sitemap_Manager' )
401
			&& version_compare( JETPACK__VERSION, '5.3', '>=' )
402
		) {
403
			do_action( 'jetpack_sitemaps_purge_data' );
404
		}
405
	}
406
407
	static function activate_manage( ) {
408
		if ( did_action( 'init' ) || current_filter() == 'init' ) {
409
			self::activate_module( 'manage', false, false );
410
		} else if ( !  has_action( 'init' , array( __CLASS__, 'activate_manage' ) ) ) {
411
			add_action( 'init', array( __CLASS__, 'activate_manage' ) );
412
		}
413
	}
414
415
	static function update_active_modules( $modules ) {
416
		$current_modules = Jetpack_Options::get_option( 'active_modules', array() );
417
418
		$success = Jetpack_Options::update_option( 'active_modules', array_unique( $modules ) );
419
420
		if ( is_array( $modules ) && is_array( $current_modules ) ) {
421
			$new_active_modules = array_diff( $modules, $current_modules );
422
			foreach( $new_active_modules as $module ) {
423
				/**
424
				 * Fires when a specific module is activated.
425
				 *
426
				 * @since 1.9.0
427
				 *
428
				 * @param string $module Module slug.
429
				 * @param boolean $success whether the module was activated. @since 4.2
430
				 */
431
				do_action( 'jetpack_activate_module', $module, $success );
432
433
				/**
434
				 * Fires when a module is activated.
435
				 * The dynamic part of the filter, $module, is the module slug.
436
				 *
437
				 * @since 1.9.0
438
				 *
439
				 * @param string $module Module slug.
440
				 */
441
				do_action( "jetpack_activate_module_$module", $module );
442
			}
443
444
			$new_deactive_modules = array_diff( $current_modules, $modules );
445
			foreach( $new_deactive_modules as $module ) {
446
				/**
447
				 * Fired after a module has been deactivated.
448
				 *
449
				 * @since 4.2.0
450
				 *
451
				 * @param string $module Module slug.
452
				 * @param boolean $success whether the module was deactivated.
453
				 */
454
				do_action( 'jetpack_deactivate_module', $module, $success );
455
				/**
456
				 * Fires when a module is deactivated.
457
				 * The dynamic part of the filter, $module, is the module slug.
458
				 *
459
				 * @since 1.9.0
460
				 *
461
				 * @param string $module Module slug.
462
				 */
463
				do_action( "jetpack_deactivate_module_$module", $module );
464
			}
465
		}
466
467
		return $success;
468
	}
469
470
	static function delete_active_modules() {
471
		self::update_active_modules( array() );
472
	}
473
474
	/**
475
	 * Constructor.  Initializes WordPress hooks
476
	 */
477
	private function __construct() {
478
		/*
479
		 * Check for and alert any deprecated hooks
480
		 */
481
		add_action( 'init', array( $this, 'deprecated_hooks' ) );
482
483
		/*
484
		 * Enable enhanced handling of previewing sites in Calypso
485
		 */
486
		if ( Jetpack::is_active() ) {
487
			require_once JETPACK__PLUGIN_DIR . '_inc/lib/class.jetpack-iframe-embed.php';
488
			add_action( 'init', array( 'Jetpack_Iframe_Embed', 'init' ), 9, 0 );
489
		}
490
491
		/*
492
		 * Load things that should only be in Network Admin.
493
		 *
494
		 * For now blow away everything else until a more full
495
		 * understanding of what is needed at the network level is
496
		 * available
497
		 */
498
		if( is_multisite() ) {
499
			Jetpack_Network::init();
500
		}
501
502
		add_action( 'set_user_role', array( $this, 'maybe_clear_other_linked_admins_transient' ), 10, 3 );
503
504
		// Unlink user before deleting the user from .com
505
		add_action( 'deleted_user', array( $this, 'unlink_user' ), 10, 1 );
506
		add_action( 'remove_user_from_blog', array( $this, 'unlink_user' ), 10, 1 );
507
508
		if ( defined( 'XMLRPC_REQUEST' ) && XMLRPC_REQUEST && isset( $_GET['for'] ) && 'jetpack' == $_GET['for'] ) {
509
			@ini_set( 'display_errors', false ); // Display errors can cause the XML to be not well formed.
510
511
			require_once JETPACK__PLUGIN_DIR . 'class.jetpack-xmlrpc-server.php';
512
			$this->xmlrpc_server = new Jetpack_XMLRPC_Server();
513
514
			$this->require_jetpack_authentication();
515
516
			if ( Jetpack::is_active() ) {
517
				// Hack to preserve $HTTP_RAW_POST_DATA
518
				add_filter( 'xmlrpc_methods', array( $this, 'xmlrpc_methods' ) );
519
520
				$signed = $this->verify_xml_rpc_signature();
521
				if ( $signed && ! is_wp_error( $signed ) ) {
522
					// The actual API methods.
523
					add_filter( 'xmlrpc_methods', array( $this->xmlrpc_server, 'xmlrpc_methods' ) );
524
				} else {
525
					// The jetpack.authorize method should be available for unauthenticated users on a site with an
526
					// active Jetpack connection, so that additional users can link their account.
527
					add_filter( 'xmlrpc_methods', array( $this->xmlrpc_server, 'authorize_xmlrpc_methods' ) );
528
				}
529
			} else {
530
				// The bootstrap API methods.
531
				add_filter( 'xmlrpc_methods', array( $this->xmlrpc_server, 'bootstrap_xmlrpc_methods' ) );
532
			}
533
534
			// Now that no one can authenticate, and we're whitelisting all XML-RPC methods, force enable_xmlrpc on.
535
			add_filter( 'pre_option_enable_xmlrpc', '__return_true' );
536
		} elseif (
537
			is_admin() &&
538
			isset( $_POST['action'] ) && (
539
				'jetpack_upload_file' == $_POST['action'] ||
540
				'jetpack_update_file' == $_POST['action']
541
			)
542
		) {
543
			$this->require_jetpack_authentication();
544
			$this->add_remote_request_handlers();
545
		} else {
546
			if ( Jetpack::is_active() ) {
547
				add_action( 'login_form_jetpack_json_api_authorization', array( &$this, 'login_form_json_api_authorization' ) );
548
				add_filter( 'xmlrpc_methods', array( $this, 'public_xmlrpc_methods' ) );
549
			}
550
		}
551
552
		if ( Jetpack::is_active() ) {
553
			Jetpack_Heartbeat::init();
554
		}
555
556
		add_filter( 'determine_current_user', array( $this, 'wp_rest_authenticate' ) );
557
		add_filter( 'rest_authentication_errors', array( $this, 'wp_rest_authentication_errors' ) );
558
559
		add_action( 'jetpack_clean_nonces', array( 'Jetpack', 'clean_nonces' ) );
560
		if ( ! wp_next_scheduled( 'jetpack_clean_nonces' ) ) {
561
			wp_schedule_event( time(), 'hourly', 'jetpack_clean_nonces' );
562
		}
563
564
		add_filter( 'xmlrpc_blog_options', array( $this, 'xmlrpc_options' ) );
565
566
		add_action( 'admin_init', array( $this, 'admin_init' ) );
567
		add_action( 'admin_init', array( $this, 'dismiss_jetpack_notice' ) );
568
569
		add_filter( 'admin_body_class', array( $this, 'admin_body_class' ) );
570
571
		add_action( 'wp_dashboard_setup', array( $this, 'wp_dashboard_setup' ) );
572
		// Filter the dashboard meta box order to swap the new one in in place of the old one.
573
		add_filter( 'get_user_option_meta-box-order_dashboard', array( $this, 'get_user_option_meta_box_order_dashboard' ) );
574
575
		// returns HTTPS support status
576
		add_action( 'wp_ajax_jetpack-recheck-ssl', array( $this, 'ajax_recheck_ssl' ) );
577
578
		// If any module option is updated before Jump Start is dismissed, hide Jump Start.
579
		add_action( 'update_option', array( $this, 'jumpstart_has_updated_module_option' ) );
580
581
		// JITM AJAX callback function
582
		add_action( 'wp_ajax_jitm_ajax',  array( $this, 'jetpack_jitm_ajax_callback' ) );
583
584
		// Universal ajax callback for all tracking events triggered via js
585
		add_action( 'wp_ajax_jetpack_tracks', array( $this, 'jetpack_admin_ajax_tracks_callback' ) );
586
587
		add_action( 'wp_ajax_jetpack_connection_banner', array( $this, 'jetpack_connection_banner_callback' ) );
588
589
		add_action( 'wp_loaded', array( $this, 'register_assets' ) );
590
		add_action( 'wp_enqueue_scripts', array( $this, 'devicepx' ) );
591
		add_action( 'customize_controls_enqueue_scripts', array( $this, 'devicepx' ) );
592
		add_action( 'admin_enqueue_scripts', array( $this, 'devicepx' ) );
593
594
		add_action( 'plugins_loaded', array( $this, 'extra_oembed_providers' ), 100 );
595
596
		/**
597
		 * These actions run checks to load additional files.
598
		 * They check for external files or plugins, so they need to run as late as possible.
599
		 */
600
		add_action( 'wp_head', array( $this, 'check_open_graph' ),       1 );
601
		add_action( 'plugins_loaded', array( $this, 'check_twitter_tags' ),     999 );
602
		add_action( 'plugins_loaded', array( $this, 'check_rest_api_compat' ), 1000 );
603
604
		add_filter( 'plugins_url',      array( 'Jetpack', 'maybe_min_asset' ),     1, 3 );
605
		add_action( 'style_loader_src', array( 'Jetpack', 'set_suffix_on_min' ), 10, 2  );
606
		add_filter( 'style_loader_tag', array( 'Jetpack', 'maybe_inline_style' ), 10, 2 );
607
608
		add_filter( 'map_meta_cap', array( $this, 'jetpack_custom_caps' ), 1, 4 );
609
610
		add_filter( 'jetpack_get_default_modules', array( $this, 'filter_default_modules' ) );
611
		add_filter( 'jetpack_get_default_modules', array( $this, 'handle_deprecated_modules' ), 99 );
612
613
		// A filter to control all just in time messages
614
		add_filter( 'jetpack_just_in_time_msgs', '__return_true', 9 );
615
		add_filter( 'jetpack_just_in_time_msg_cache', '__return_true', 9);
616
617
		// If enabled, point edit post and page links to Calypso instead of WP-Admin.
618
		// We should make sure to only do this for front end links.
619
		if ( Jetpack_Options::get_option( 'edit_links_calypso_redirect' ) && ! is_admin() ) {
620
			add_filter( 'get_edit_post_link', array( $this, 'point_edit_links_to_calypso' ), 1, 2 );
621
		}
622
623
		// Update the Jetpack plan from API on heartbeats
624
		add_action( 'jetpack_heartbeat', array( $this, 'refresh_active_plan_from_wpcom' ) );
625
626
		/**
627
		 * This is the hack to concatinate all css files into one.
628
		 * For description and reasoning see the implode_frontend_css method
629
		 *
630
		 * Super late priority so we catch all the registered styles
631
		 */
632
		if( !is_admin() ) {
633
			add_action( 'wp_print_styles', array( $this, 'implode_frontend_css' ), -1 ); // Run first
634
			add_action( 'wp_print_footer_scripts', array( $this, 'implode_frontend_css' ), -1 ); // Run first to trigger before `print_late_styles`
635
		}
636
637
		/**
638
		 * These are sync actions that we need to keep track of for jitms
639
		 */
640
		add_filter( 'jetpack_sync_before_send_updated_option', array( $this, 'jetpack_track_last_sync_callback' ), 99 );
641
	}
642
643
	function point_edit_links_to_calypso( $default_url, $post_id ) {
644
		$post = get_post( $post_id );
645
646
		if ( empty( $post ) ) {
647
			return $default_url;
648
		}
649
650
		$post_type = $post->post_type;
651
652
		// Mapping the allowed CPTs on WordPress.com to corresponding paths in Calypso.
653
		// https://en.support.wordpress.com/custom-post-types/
654
		$allowed_post_types = array(
655
			'post' => 'post',
656
			'page' => 'page',
657
			'jetpack-portfolio' => 'edit/jetpack-portfolio',
658
			'jetpack-testimonial' => 'edit/jetpack-testimonial',
659
		);
660
661
		if ( ! in_array( $post_type, array_keys( $allowed_post_types ) ) ) {
662
			return $default_url;
663
		}
664
665
		$path_prefix = $allowed_post_types[ $post_type ];
666
667
		$site_slug  = Jetpack::build_raw_urls( get_home_url() );
668
669
		return esc_url( sprintf( 'https://wordpress.com/%s/%s/%d', $path_prefix, $site_slug, $post_id ) );
670
	}
671
672
	function jetpack_track_last_sync_callback( $params ) {
673
		/**
674
		 * Filter to turn off jitm caching
675
		 *
676
		 * @since 5.4.0
677
		 *
678
		 * @param bool false Whether to cache just in time messages
679
		 */
680
		if ( ! apply_filters( 'jetpack_just_in_time_msg_cache', false ) ) {
681
			return $params;
682
		}
683
684
		if ( is_array( $params ) && isset( $params[0] ) ) {
685
			$option = $params[0];
686
			if ( 'active_plugins' === $option ) {
687
				// use the cache if we can, but not terribly important if it gets evicted
688
				set_transient( 'jetpack_last_plugin_sync', time(), HOUR_IN_SECONDS );
689
			}
690
		}
691
692
		return $params;
693
	}
694
695
	function jetpack_connection_banner_callback() {
696
		check_ajax_referer( 'jp-connection-banner-nonce', 'nonce' );
697
698
		if ( isset( $_REQUEST['dismissBanner'] ) ) {
699
			Jetpack_Options::update_option( 'dismissed_connection_banner', 1 );
700
			wp_send_json_success();
701
		}
702
703
		wp_die();
704
	}
705
706
	function jetpack_admin_ajax_tracks_callback() {
707
		// Check for nonce
708
		if ( ! isset( $_REQUEST['tracksNonce'] ) || ! wp_verify_nonce( $_REQUEST['tracksNonce'], 'jp-tracks-ajax-nonce' ) ) {
709
			wp_die( 'Permissions check failed.' );
710
		}
711
712
		if ( ! isset( $_REQUEST['tracksEventName'] ) || ! isset( $_REQUEST['tracksEventType'] )  ) {
713
			wp_die( 'No valid event name or type.' );
714
		}
715
716
		$tracks_data = array();
717
		if ( 'click' === $_REQUEST['tracksEventType'] && isset( $_REQUEST['tracksEventProp'] ) ) {
718
			if ( is_array( $_REQUEST['tracksEventProp'] ) ) {
719
				$tracks_data = $_REQUEST['tracksEventProp'];
720
			} else {
721
				$tracks_data = array( 'clicked' => $_REQUEST['tracksEventProp'] );
722
			}
723
		}
724
725
		JetpackTracking::record_user_event( $_REQUEST['tracksEventName'], $tracks_data );
726
		wp_send_json_success();
727
		wp_die();
728
	}
729
730
	/**
731
	 * The callback for the JITM ajax requests.
732
	 */
733
	function jetpack_jitm_ajax_callback() {
734
		// Check for nonce
735
		if ( ! isset( $_REQUEST['jitmNonce'] ) || ! wp_verify_nonce( $_REQUEST['jitmNonce'], 'jetpack-jitm-nonce' ) ) {
736
			wp_die( 'Module activation failed due to lack of appropriate permissions' );
737
		}
738
		if ( isset( $_REQUEST['jitmActionToTake'] ) && 'activate' == $_REQUEST['jitmActionToTake'] ) {
739
			$module_slug = $_REQUEST['jitmModule'];
740
			Jetpack::log( 'activate', $module_slug );
741
			Jetpack::activate_module( $module_slug, false, false );
742
			Jetpack::state( 'message', 'no_message' );
743
744
			//A Jetpack module is being activated through a JITM, track it
745
			$this->stat( 'jitm', $module_slug.'-activated-' . JETPACK__VERSION );
746
			$this->do_stats( 'server_side' );
747
748
			wp_send_json_success();
749
		}
750
		if ( isset( $_REQUEST['jitmActionToTake'] ) && 'dismiss' == $_REQUEST['jitmActionToTake'] ) {
751
			// get the hide_jitm options array
752
			$jetpack_hide_jitm = Jetpack_Options::get_option( 'hide_jitm' );
753
			$module_slug = $_REQUEST['jitmModule'];
754
755
			if( ! $jetpack_hide_jitm ) {
756
				$jetpack_hide_jitm = array(
757
					$module_slug => 'hide'
758
				);
759
			} else {
760
				$jetpack_hide_jitm[$module_slug] = 'hide';
761
			}
762
763
			Jetpack_Options::update_option( 'hide_jitm', $jetpack_hide_jitm );
764
765
			//jitm is being dismissed forever, track it
766
			$this->stat( 'jitm', $module_slug.'-dismissed-' . JETPACK__VERSION );
767
			$this->do_stats( 'server_side' );
768
769
			wp_send_json_success();
770
		}
771 View Code Duplication
		if ( isset( $_REQUEST['jitmActionToTake'] ) && 'launch' == $_REQUEST['jitmActionToTake'] ) {
772
			$module_slug = $_REQUEST['jitmModule'];
773
774
			// User went to WordPress.com, track this
775
			$this->stat( 'jitm', $module_slug.'-wordpress-tools-' . JETPACK__VERSION );
776
			$this->do_stats( 'server_side' );
777
778
			wp_send_json_success();
779
		}
780 View Code Duplication
		if ( isset( $_REQUEST['jitmActionToTake'] ) && 'viewed' == $_REQUEST['jitmActionToTake'] ) {
781
			$track = $_REQUEST['jitmModule'];
782
783
			// User is viewing JITM, track it.
784
			$this->stat( 'jitm', $track . '-viewed-' . JETPACK__VERSION );
785
			$this->do_stats( 'server_side' );
786
787
			wp_send_json_success();
788
		}
789
	}
790
791
	/**
792
	 * If there are any stats that need to be pushed, but haven't been, push them now.
793
	 */
794
	function __destruct() {
795
		if ( ! empty( $this->stats ) ) {
796
			$this->do_stats( 'server_side' );
797
		}
798
	}
799
800
	function jetpack_custom_caps( $caps, $cap, $user_id, $args ) {
801
		switch( $cap ) {
802
			case 'jetpack_connect' :
803
			case 'jetpack_reconnect' :
804
				if ( Jetpack::is_development_mode() ) {
805
					$caps = array( 'do_not_allow' );
806
					break;
807
				}
808
				/**
809
				 * Pass through. If it's not development mode, these should match disconnect.
810
				 * Let users disconnect if it's development mode, just in case things glitch.
811
				 */
812
			case 'jetpack_disconnect' :
813
				/**
814
				 * In multisite, can individual site admins manage their own connection?
815
				 *
816
				 * Ideally, this should be extracted out to a separate filter in the Jetpack_Network class.
817
				 */
818
				if ( is_multisite() && ! is_super_admin() && is_plugin_active_for_network( 'jetpack/jetpack.php' ) ) {
819
					if ( ! Jetpack_Network::init()->get_option( 'sub-site-connection-override' ) ) {
820
						/**
821
						 * We need to update the option name -- it's terribly unclear which
822
						 * direction the override goes.
823
						 *
824
						 * @todo: Update the option name to `sub-sites-can-manage-own-connections`
825
						 */
826
						$caps = array( 'do_not_allow' );
827
						break;
828
					}
829
				}
830
831
				$caps = array( 'manage_options' );
832
				break;
833
			case 'jetpack_manage_modules' :
834
			case 'jetpack_activate_modules' :
835
			case 'jetpack_deactivate_modules' :
836
				$caps = array( 'manage_options' );
837
				break;
838
			case 'jetpack_configure_modules' :
839
				$caps = array( 'manage_options' );
840
				break;
841
			case 'jetpack_network_admin_page':
842
			case 'jetpack_network_settings_page':
843
				$caps = array( 'manage_network_plugins' );
844
				break;
845
			case 'jetpack_network_sites_page':
846
				$caps = array( 'manage_sites' );
847
				break;
848
			case 'jetpack_admin_page' :
849
				if ( Jetpack::is_development_mode() ) {
850
					$caps = array( 'manage_options' );
851
					break;
852
				} else {
853
					$caps = array( 'read' );
854
				}
855
				break;
856
			case 'jetpack_connect_user' :
857
				if ( Jetpack::is_development_mode() ) {
858
					$caps = array( 'do_not_allow' );
859
					break;
860
				}
861
				$caps = array( 'read' );
862
				break;
863
		}
864
		return $caps;
865
	}
866
867
	function require_jetpack_authentication() {
868
		// Don't let anyone authenticate
869
		$_COOKIE = array();
870
		remove_all_filters( 'authenticate' );
871
		remove_all_actions( 'wp_login_failed' );
872
873
		if ( Jetpack::is_active() ) {
874
			// Allow Jetpack authentication
875
			add_filter( 'authenticate', array( $this, 'authenticate_jetpack' ), 10, 3 );
876
		}
877
	}
878
879
	/**
880
	 * Load language files
881
	 * @action plugins_loaded
882
	 */
883
	public static function plugin_textdomain() {
884
		// Note to self, the third argument must not be hardcoded, to account for relocated folders.
885
		load_plugin_textdomain( 'jetpack', false, dirname( plugin_basename( JETPACK__PLUGIN_FILE ) ) . '/languages/' );
886
	}
887
888
	/**
889
	 * Register assets for use in various modules and the Jetpack admin page.
890
	 *
891
	 * @uses wp_script_is, wp_register_script, plugins_url
892
	 * @action wp_loaded
893
	 * @return null
894
	 */
895
	public function register_assets() {
896 View Code Duplication
		if ( ! wp_script_is( 'spin', 'registered' ) ) {
897
			wp_register_script( 'spin', plugins_url( '_inc/spin.js', JETPACK__PLUGIN_FILE ), false, '1.3' );
898
		}
899
900 View Code Duplication
		if ( ! wp_script_is( 'jquery.spin', 'registered' ) ) {
901
			wp_register_script( 'jquery.spin', plugins_url( '_inc/jquery.spin.js', JETPACK__PLUGIN_FILE ) , array( 'jquery', 'spin' ), '1.3' );
902
		}
903
904 View Code Duplication
		if ( ! wp_script_is( 'jetpack-gallery-settings', 'registered' ) ) {
905
			wp_register_script( 'jetpack-gallery-settings', plugins_url( '_inc/gallery-settings.js', JETPACK__PLUGIN_FILE ), array( 'media-views' ), '20121225' );
906
		}
907
908 View Code Duplication
		if ( ! wp_script_is( 'jetpack-twitter-timeline', 'registered' ) ) {
909
			wp_register_script( 'jetpack-twitter-timeline', plugins_url( '_inc/twitter-timeline.js', JETPACK__PLUGIN_FILE ) , array( 'jquery' ), '4.0.0', true );
910
		}
911
912
		if ( ! wp_script_is( 'jetpack-facebook-embed', 'registered' ) ) {
913
			wp_register_script( 'jetpack-facebook-embed', plugins_url( '_inc/facebook-embed.js', __FILE__ ), array( 'jquery' ), null, true );
914
915
			/** This filter is documented in modules/sharedaddy/sharing-sources.php */
916
			$fb_app_id = apply_filters( 'jetpack_sharing_facebook_app_id', '249643311490' );
917
			if ( ! is_numeric( $fb_app_id ) ) {
918
				$fb_app_id = '';
919
			}
920
			wp_localize_script(
921
				'jetpack-facebook-embed',
922
				'jpfbembed',
923
				array(
924
					'appid' => $fb_app_id,
925
					'locale' => $this->get_locale(),
926
				)
927
			);
928
		}
929
930
		/**
931
		 * As jetpack_register_genericons is by default fired off a hook,
932
		 * the hook may have already fired by this point.
933
		 * So, let's just trigger it manually.
934
		 */
935
		require_once( JETPACK__PLUGIN_DIR . '_inc/genericons.php' );
936
		jetpack_register_genericons();
937
938
		/**
939
		 * Register the social logos
940
		 */
941
		require_once( JETPACK__PLUGIN_DIR . '_inc/social-logos.php' );
942
		jetpack_register_social_logos();
943
944 View Code Duplication
		if ( ! wp_style_is( 'jetpack-icons', 'registered' ) )
945
			wp_register_style( 'jetpack-icons', plugins_url( 'css/jetpack-icons.min.css', JETPACK__PLUGIN_FILE ), false, JETPACK__VERSION );
946
	}
947
948
	/**
949
	 * Guess locale from language code.
950
	 *
951
	 * @param string $lang Language code.
952
	 * @return string|bool
953
	 */
954
	function guess_locale_from_lang( $lang ) {
955
		if ( 'en' === $lang || 'en_US' === $lang || ! $lang ) {
956
			return 'en_US';
957
		}
958
959 View Code Duplication
		if ( ! class_exists( 'GP_Locales' ) ) {
960
			if ( ! defined( 'JETPACK__GLOTPRESS_LOCALES_PATH' ) || ! file_exists( JETPACK__GLOTPRESS_LOCALES_PATH ) ) {
961
				return false;
962
			}
963
964
			require JETPACK__GLOTPRESS_LOCALES_PATH;
965
		}
966
967
		if ( defined( 'IS_WPCOM' ) && IS_WPCOM ) {
968
			// WP.com: get_locale() returns 'it'
969
			$locale = GP_Locales::by_slug( $lang );
970
		} else {
971
			// Jetpack: get_locale() returns 'it_IT';
972
			$locale = GP_Locales::by_field( 'facebook_locale', $lang );
973
		}
974
975
		if ( ! $locale ) {
976
			return false;
977
		}
978
979
		if ( empty( $locale->facebook_locale ) ) {
980
			if ( empty( $locale->wp_locale ) ) {
981
				return false;
982
			} else {
983
				// Facebook SDK is smart enough to fall back to en_US if a
984
				// locale isn't supported. Since supported Facebook locales
985
				// can fall out of sync, we'll attempt to use the known
986
				// wp_locale value and rely on said fallback.
987
				return $locale->wp_locale;
988
			}
989
		}
990
991
		return $locale->facebook_locale;
992
	}
993
994
	/**
995
	 * Get the locale.
996
	 *
997
	 * @return string|bool
998
	 */
999
	function get_locale() {
1000
		$locale = $this->guess_locale_from_lang( get_locale() );
1001
1002
		if ( ! $locale ) {
1003
			$locale = 'en_US';
1004
		}
1005
1006
		return $locale;
1007
	}
1008
1009
	/**
1010
	 * Device Pixels support
1011
	 * This improves the resolution of gravatars and wordpress.com uploads on hi-res and zoomed browsers.
1012
	 */
1013
	function devicepx() {
1014
		if ( Jetpack::is_active() ) {
1015
			wp_enqueue_script( 'devicepx', 'https://s0.wp.com/wp-content/js/devicepx-jetpack.js', array(), gmdate( 'oW' ), true );
1016
		}
1017
	}
1018
1019
	/**
1020
	 * Return the network_site_url so that .com knows what network this site is a part of.
1021
	 * @param  bool $option
1022
	 * @return string
1023
	 */
1024
	public function jetpack_main_network_site_option( $option ) {
1025
		return network_site_url();
1026
	}
1027
	/**
1028
	 * Network Name.
1029
	 */
1030
	static function network_name( $option = null ) {
1031
		global $current_site;
1032
		return $current_site->site_name;
1033
	}
1034
	/**
1035
	 * Does the network allow new user and site registrations.
1036
	 * @return string
1037
	 */
1038
	static function network_allow_new_registrations( $option = null ) {
1039
		return ( in_array( get_site_option( 'registration' ), array('none', 'user', 'blog', 'all' ) ) ? get_site_option( 'registration') : 'none' );
1040
	}
1041
	/**
1042
	 * Does the network allow admins to add new users.
1043
	 * @return boolian
1044
	 */
1045
	static function network_add_new_users( $option = null ) {
1046
		return (bool) get_site_option( 'add_new_users' );
1047
	}
1048
	/**
1049
	 * File upload psace left per site in MB.
1050
	 *  -1 means NO LIMIT.
1051
	 * @return number
1052
	 */
1053
	static function network_site_upload_space( $option = null ) {
1054
		// value in MB
1055
		return ( get_site_option( 'upload_space_check_disabled' ) ? -1 : get_space_allowed() );
1056
	}
1057
1058
	/**
1059
	 * Network allowed file types.
1060
	 * @return string
1061
	 */
1062
	static function network_upload_file_types( $option = null ) {
1063
		return get_site_option( 'upload_filetypes', 'jpg jpeg png gif' );
1064
	}
1065
1066
	/**
1067
	 * Maximum file upload size set by the network.
1068
	 * @return number
1069
	 */
1070
	static function network_max_upload_file_size( $option = null ) {
1071
		// value in KB
1072
		return get_site_option( 'fileupload_maxk', 300 );
1073
	}
1074
1075
	/**
1076
	 * Lets us know if a site allows admins to manage the network.
1077
	 * @return array
1078
	 */
1079
	static function network_enable_administration_menus( $option = null ) {
1080
		return get_site_option( 'menu_items' );
1081
	}
1082
1083
	/**
1084
	 * If a user has been promoted to or demoted from admin, we need to clear the
1085
	 * jetpack_other_linked_admins transient.
1086
	 *
1087
	 * @since 4.3.2
1088
	 * @since 4.4.0  $old_roles is null by default and if it's not passed, the transient is cleared.
1089
	 *
1090
	 * @param int    $user_id   The user ID whose role changed.
1091
	 * @param string $role      The new role.
1092
	 * @param array  $old_roles An array of the user's previous roles.
1093
	 */
1094
	function maybe_clear_other_linked_admins_transient( $user_id, $role, $old_roles = null ) {
1095
		if ( 'administrator' == $role
1096
			|| ( is_array( $old_roles ) && in_array( 'administrator', $old_roles ) )
1097
			|| is_null( $old_roles )
1098
		) {
1099
			delete_transient( 'jetpack_other_linked_admins' );
1100
		}
1101
	}
1102
1103
	/**
1104
	 * Checks to see if there are any other users available to become primary
1105
	 * Users must both:
1106
	 * - Be linked to wpcom
1107
	 * - Be an admin
1108
	 *
1109
	 * @return mixed False if no other users are linked, Int if there are.
1110
	 */
1111
	static function get_other_linked_admins() {
1112
		$other_linked_users = get_transient( 'jetpack_other_linked_admins' );
1113
1114
		if ( false === $other_linked_users ) {
1115
			$admins = get_users( array( 'role' => 'administrator' ) );
1116
			if ( count( $admins ) > 1 ) {
1117
				$available = array();
1118
				foreach ( $admins as $admin ) {
1119
					if ( Jetpack::is_user_connected( $admin->ID ) ) {
1120
						$available[] = $admin->ID;
1121
					}
1122
				}
1123
1124
				$count_connected_admins = count( $available );
1125
				if ( count( $available ) > 1 ) {
1126
					$other_linked_users = $count_connected_admins;
1127
				} else {
1128
					$other_linked_users = 0;
1129
				}
1130
			} else {
1131
				$other_linked_users = 0;
1132
			}
1133
1134
			set_transient( 'jetpack_other_linked_admins', $other_linked_users, HOUR_IN_SECONDS );
1135
		}
1136
1137
		return ( 0 === $other_linked_users ) ? false : $other_linked_users;
1138
	}
1139
1140
	/**
1141
	 * Return whether we are dealing with a multi network setup or not.
1142
	 * The reason we are type casting this is because we want to avoid the situation where
1143
	 * the result is false since when is_main_network_option return false it cases
1144
	 * the rest the get_option( 'jetpack_is_multi_network' ); to return the value that is set in the
1145
	 * database which could be set to anything as opposed to what this function returns.
1146
	 * @param  bool  $option
1147
	 *
1148
	 * @return boolean
1149
	 */
1150
	public function is_main_network_option( $option ) {
1151
		// return '1' or ''
1152
		return (string) (bool) Jetpack::is_multi_network();
1153
	}
1154
1155
	/**
1156
	 * Return true if we are with multi-site or multi-network false if we are dealing with single site.
1157
	 *
1158
	 * @param  string  $option
1159
	 * @return boolean
1160
	 */
1161
	public function is_multisite( $option ) {
1162
		return (string) (bool) is_multisite();
1163
	}
1164
1165
	/**
1166
	 * Implemented since there is no core is multi network function
1167
	 * Right now there is no way to tell if we which network is the dominant network on the system
1168
	 *
1169
	 * @since  3.3
1170
	 * @return boolean
1171
	 */
1172
	public static function is_multi_network() {
1173
		global  $wpdb;
1174
1175
		// if we don't have a multi site setup no need to do any more
1176
		if ( ! is_multisite() ) {
1177
			return false;
1178
		}
1179
1180
		$num_sites = $wpdb->get_var( "SELECT COUNT(*) FROM {$wpdb->site}" );
1181
		if ( $num_sites > 1 ) {
1182
			return true;
1183
		} else {
1184
			return false;
1185
		}
1186
	}
1187
1188
	/**
1189
	 * Trigger an update to the main_network_site when we update the siteurl of a site.
1190
	 * @return null
1191
	 */
1192
	function update_jetpack_main_network_site_option() {
1193
		_deprecated_function( __METHOD__, 'jetpack-4.2' );
1194
	}
1195
	/**
1196
	 * Triggered after a user updates the network settings via Network Settings Admin Page
1197
	 *
1198
	 */
1199
	function update_jetpack_network_settings() {
1200
		_deprecated_function( __METHOD__, 'jetpack-4.2' );
1201
		// Only sync this info for the main network site.
1202
	}
1203
1204
	/**
1205
	 * Get back if the current site is single user site.
1206
	 *
1207
	 * @return bool
1208
	 */
1209
	public static function is_single_user_site() {
1210
		global $wpdb;
1211
1212 View Code Duplication
		if ( false === ( $some_users = get_transient( 'jetpack_is_single_user' ) ) ) {
1213
			$some_users = $wpdb->get_var( "SELECT COUNT(*) FROM (SELECT user_id FROM $wpdb->usermeta WHERE meta_key = '{$wpdb->prefix}capabilities' LIMIT 2) AS someusers" );
1214
			set_transient( 'jetpack_is_single_user', (int) $some_users, 12 * HOUR_IN_SECONDS );
1215
		}
1216
		return 1 === (int) $some_users;
1217
	}
1218
1219
	/**
1220
	 * Returns true if the site has file write access false otherwise.
1221
	 * @return string ( '1' | '0' )
1222
	 **/
1223
	public static function file_system_write_access() {
1224
		if ( ! function_exists( 'get_filesystem_method' ) ) {
1225
			require_once( ABSPATH . 'wp-admin/includes/file.php' );
1226
		}
1227
1228
		require_once( ABSPATH . 'wp-admin/includes/template.php' );
1229
1230
		$filesystem_method = get_filesystem_method();
1231
		if ( $filesystem_method === 'direct' ) {
1232
			return 1;
1233
		}
1234
1235
		ob_start();
1236
		$filesystem_credentials_are_stored = request_filesystem_credentials( self_admin_url() );
1237
		ob_end_clean();
1238
		if ( $filesystem_credentials_are_stored ) {
1239
			return 1;
1240
		}
1241
		return 0;
1242
	}
1243
1244
	/**
1245
	 * Finds out if a site is using a version control system.
1246
	 * @return string ( '1' | '0' )
1247
	 **/
1248
	public static function is_version_controlled() {
1249
		_deprecated_function( __METHOD__, 'jetpack-4.2', 'Jetpack_Sync_Functions::is_version_controlled' );
1250
		return (string) (int) Jetpack_Sync_Functions::is_version_controlled();
1251
	}
1252
1253
	/**
1254
	 * Determines whether the current theme supports featured images or not.
1255
	 * @return string ( '1' | '0' )
1256
	 */
1257
	public static function featured_images_enabled() {
1258
		_deprecated_function( __METHOD__, 'jetpack-4.2' );
1259
		return current_theme_supports( 'post-thumbnails' ) ? '1' : '0';
1260
	}
1261
1262
	/**
1263
	 * Wrapper for core's get_avatar_url().  This one is deprecated.
1264
	 *
1265
	 * @deprecated 4.7 use get_avatar_url instead.
1266
	 * @param int|string|object $id_or_email A user ID,  email address, or comment object
1267
	 * @param int $size Size of the avatar image
1268
	 * @param string $default URL to a default image to use if no avatar is available
1269
	 * @param bool $force_display Whether to force it to return an avatar even if show_avatars is disabled
1270
	 *
1271
	 * @return array
1272
	 */
1273
	public static function get_avatar_url( $id_or_email, $size = 96, $default = '', $force_display = false ) {
1274
		_deprecated_function( __METHOD__, 'jetpack-4.7', 'get_avatar_url' );
1275
		return get_avatar_url( $id_or_email, array(
1276
			'size' => $size,
1277
			'default' => $default,
1278
			'force_default' => $force_display,
1279
		) );
1280
	}
1281
1282
	/**
1283
	 * jetpack_updates is saved in the following schema:
1284
	 *
1285
	 * array (
1286
	 *      'plugins'                       => (int) Number of plugin updates available.
1287
	 *      'themes'                        => (int) Number of theme updates available.
1288
	 *      'wordpress'                     => (int) Number of WordPress core updates available.
1289
	 *      'translations'                  => (int) Number of translation updates available.
1290
	 *      'total'                         => (int) Total of all available updates.
1291
	 *      'wp_update_version'             => (string) The latest available version of WordPress, only present if a WordPress update is needed.
1292
	 * )
1293
	 * @return array
1294
	 */
1295
	public static function get_updates() {
1296
		$update_data = wp_get_update_data();
1297
1298
		// Stores the individual update counts as well as the total count.
1299
		if ( isset( $update_data['counts'] ) ) {
1300
			$updates = $update_data['counts'];
1301
		}
1302
1303
		// If we need to update WordPress core, let's find the latest version number.
1304 View Code Duplication
		if ( ! empty( $updates['wordpress'] ) ) {
1305
			$cur = get_preferred_from_update_core();
1306
			if ( isset( $cur->response ) && 'upgrade' === $cur->response ) {
1307
				$updates['wp_update_version'] = $cur->current;
1308
			}
1309
		}
1310
		return isset( $updates ) ? $updates : array();
1311
	}
1312
1313
	public static function get_update_details() {
1314
		$update_details = array(
1315
			'update_core' => get_site_transient( 'update_core' ),
1316
			'update_plugins' => get_site_transient( 'update_plugins' ),
1317
			'update_themes' => get_site_transient( 'update_themes' ),
1318
		);
1319
		return $update_details;
1320
	}
1321
1322
	public static function refresh_update_data() {
1323
		_deprecated_function( __METHOD__, 'jetpack-4.2' );
1324
1325
	}
1326
1327
	public static function refresh_theme_data() {
1328
		_deprecated_function( __METHOD__, 'jetpack-4.2' );
1329
	}
1330
1331
	/**
1332
	 * Is Jetpack active?
1333
	 */
1334
	public static function is_active() {
1335
		return (bool) Jetpack_Data::get_access_token( JETPACK_MASTER_USER );
1336
	}
1337
1338
	/**
1339
	 * Make an API call to WordPress.com for plan status
1340
	 *
1341
	 * @uses Jetpack_Options::get_option()
1342
	 * @uses Jetpack_Client::wpcom_json_api_request_as_blog()
1343
	 * @uses update_option()
1344
	 *
1345
	 * @access public
1346
	 * @static
1347
	 *
1348
	 * @return bool True if plan is updated, false if no update
1349
	 */
1350
	public static function refresh_active_plan_from_wpcom() {
1351
		// Make the API request
1352
		$request = sprintf( '/sites/%d', Jetpack_Options::get_option( 'id' ) );
1353
		$response = Jetpack_Client::wpcom_json_api_request_as_blog( $request, '1.1' );
1354
1355
		// Bail if there was an error or malformed response
1356
		if ( is_wp_error( $response ) || ! is_array( $response ) || ! isset( $response['body'] ) ) {
1357
			return false;
1358
		}
1359
1360
		// Decode the results
1361
		$results = json_decode( $response['body'], true );
1362
1363
		// Bail if there were no results or plan details returned
1364
		if ( ! is_array( $results ) || ! isset( $results['plan'] ) ) {
1365
			return false;
1366
		}
1367
1368
		// Store the option and return true if updated
1369
		return update_option( 'jetpack_active_plan', $results['plan'] );
1370
	}
1371
1372
	/**
1373
	 * Get the plan that this Jetpack site is currently using
1374
	 *
1375
	 * @uses get_option()
1376
	 *
1377
	 * @access public
1378
	 * @static
1379
	 *
1380
	 * @return array Active Jetpack plan details
1381
	 */
1382
	public static function get_active_plan() {
1383
		$plan = get_option( 'jetpack_active_plan', array() );
1384
1385
		// Set the default options
1386
		if ( empty( $plan ) || ( isset( $plan['product_slug'] ) && 'jetpack_free' === $plan['product_slug'] ) ) {
1387
			$plan = wp_parse_args( $plan, array(
1388
				'product_slug' => 'jetpack_free',
1389
				'supports'     => array(),
1390
				'class'        => 'free',
1391
			) );
1392
		}
1393
1394
		// Define what paid modules are supported by personal plans
1395
		$personal_plans = array(
1396
			'jetpack_personal',
1397
			'jetpack_personal_monthly',
1398
			'personal-bundle',
1399
		);
1400
1401
		if ( in_array( $plan['product_slug'], $personal_plans ) ) {
1402
			$plan['supports'] = array(
1403
				'akismet',
1404
			);
1405
			$plan['class'] = 'personal';
1406
		}
1407
1408
		// Define what paid modules are supported by premium plans
1409
		$premium_plans = array(
1410
			'jetpack_premium',
1411
			'jetpack_premium_monthly',
1412
			'value_bundle',
1413
		);
1414
1415
		if ( in_array( $plan['product_slug'], $premium_plans ) ) {
1416
			$plan['supports'] = array(
1417
				'videopress',
1418
				'akismet',
1419
				'vaultpress',
1420
				'wordads',
1421
			);
1422
			$plan['class'] = 'premium';
1423
		}
1424
1425
		// Define what paid modules are supported by professional plans
1426
		$business_plans = array(
1427
			'jetpack_business',
1428
			'jetpack_business_monthly',
1429
			'business-bundle',
1430
		);
1431
1432
		if ( in_array( $plan['product_slug'], $business_plans ) ) {
1433
			$plan['supports'] = array(
1434
				'videopress',
1435
				'akismet',
1436
				'vaultpress',
1437
				'seo-tools',
1438
				'google-analytics',
1439
				'wordads',
1440
				'search',
1441
			);
1442
			$plan['class'] = 'business';
1443
		}
1444
1445
		// Make sure we have an array here in the event database data is stale
1446
		if ( ! isset( $plan['supports'] ) ) {
1447
			$plan['supports'] = array();
1448
		}
1449
1450
		return $plan;
1451
	}
1452
1453
	/**
1454
	 * Determine whether the active plan supports a particular feature
1455
	 *
1456
	 * @uses Jetpack::get_active_plan()
1457
	 *
1458
	 * @access public
1459
	 * @static
1460
	 *
1461
	 * @return bool True if plan supports feature, false if not
1462
	 */
1463
	public static function active_plan_supports( $feature ) {
1464
		$plan = Jetpack::get_active_plan();
1465
1466
		if ( in_array( $feature, $plan['supports'] ) ) {
1467
			return true;
1468
		}
1469
1470
		return false;
1471
	}
1472
1473
	/**
1474
	 * Is Jetpack in development (offline) mode?
1475
	 */
1476
	public static function is_development_mode() {
1477
		$development_mode = false;
1478
1479
		if ( defined( 'JETPACK_DEV_DEBUG' ) ) {
1480
			$development_mode = JETPACK_DEV_DEBUG;
1481
		} elseif ( $site_url = site_url() ) {
1482
			$development_mode = false === strpos( $site_url, '.' );
1483
		}
1484
1485
		/**
1486
		 * Filters Jetpack's development mode.
1487
		 *
1488
		 * @see https://jetpack.com/support/development-mode/
1489
		 *
1490
		 * @since 2.2.1
1491
		 *
1492
		 * @param bool $development_mode Is Jetpack's development mode active.
1493
		 */
1494
		return apply_filters( 'jetpack_development_mode', $development_mode );
1495
	}
1496
1497
	/**
1498
	* Get Jetpack development mode notice text and notice class.
1499
	*
1500
	* Mirrors the checks made in Jetpack::is_development_mode
1501
	*
1502
	*/
1503
	public static function show_development_mode_notice() {
1504
		if ( Jetpack::is_development_mode() ) {
1505
			if ( defined( 'JETPACK_DEV_DEBUG' ) && JETPACK_DEV_DEBUG ) {
1506
				$notice = sprintf(
1507
					/* translators: %s is a URL */
1508
					__( 'In <a href="%s" target="_blank">Development Mode</a>, via the JETPACK_DEV_DEBUG constant being defined in wp-config.php or elsewhere.', 'jetpack' ),
1509
					'https://jetpack.com/support/development-mode/'
1510
				);
1511
			} elseif ( site_url() && false === strpos( site_url(), '.' ) ) {
1512
				$notice = sprintf(
1513
					/* translators: %s is a URL */
1514
					__( 'In <a href="%s" target="_blank">Development Mode</a>, via site URL lacking a dot (e.g. http://localhost).', 'jetpack' ),
1515
					'https://jetpack.com/support/development-mode/'
1516
				);
1517
			} else {
1518
				$notice = sprintf(
1519
					/* translators: %s is a URL */
1520
					__( 'In <a href="%s" target="_blank">Development Mode</a>, via the jetpack_development_mode filter.', 'jetpack' ),
1521
					'https://jetpack.com/support/development-mode/'
1522
				);
1523
			}
1524
1525
			echo '<div class="updated" style="border-color: #f0821e;"><p>' . $notice . '</p></div>';
1526
		}
1527
1528
		// Throw up a notice if using a development version and as for feedback.
1529
		if ( Jetpack::is_development_version() ) {
1530
			/* translators: %s is a URL */
1531
			$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/' );
1532
1533
			echo '<div class="updated" style="border-color: #f0821e;"><p>' . $notice . '</p></div>';
1534
		}
1535
		// Throw up a notice if using staging mode
1536
		if ( Jetpack::is_staging_site() ) {
1537
			/* translators: %s is a URL */
1538
			$notice = sprintf( __( 'You are running Jetpack on a <a href="%s" target="_blank">staging server</a>.', 'jetpack' ), 'https://jetpack.com/support/staging-sites/' );
1539
1540
			echo '<div class="updated" style="border-color: #f0821e;"><p>' . $notice . '</p></div>';
1541
		}
1542
	}
1543
1544
	/**
1545
	 * Whether Jetpack's version maps to a public release, or a development version.
1546
	 */
1547
	public static function is_development_version() {
1548
		/**
1549
		 * Allows filtering whether this is a development version of Jetpack.
1550
		 *
1551
		 * This filter is especially useful for tests.
1552
		 *
1553
		 * @since 4.3.0
1554
		 *
1555
		 * @param bool $development_version Is this a develoment version of Jetpack?
1556
		 */
1557
		return (bool) apply_filters(
1558
			'jetpack_development_version',
1559
			! preg_match( '/^\d+(\.\d+)+$/', Jetpack_Constants::get_constant( 'JETPACK__VERSION' ) )
1560
		);
1561
	}
1562
1563
	/**
1564
	 * Is a given user (or the current user if none is specified) linked to a WordPress.com user?
1565
	 */
1566
	public static function is_user_connected( $user_id = false ) {
1567
		$user_id = false === $user_id ? get_current_user_id() : absint( $user_id );
1568
		if ( ! $user_id ) {
1569
			return false;
1570
		}
1571
1572
		return (bool) Jetpack_Data::get_access_token( $user_id );
1573
	}
1574
1575
	/**
1576
	 * Get the wpcom user data of the current|specified connected user.
1577
	 */
1578
	public static function get_connected_user_data( $user_id = null ) {
1579
		if ( ! $user_id ) {
1580
			$user_id = get_current_user_id();
1581
		}
1582
1583
		$transient_key = "jetpack_connected_user_data_$user_id";
1584
1585
		if ( $cached_user_data = get_transient( $transient_key ) ) {
1586
			return $cached_user_data;
1587
		}
1588
1589
		Jetpack::load_xml_rpc_client();
1590
		$xml = new Jetpack_IXR_Client( array(
1591
			'user_id' => $user_id,
1592
		) );
1593
		$xml->query( 'wpcom.getUser' );
1594
		if ( ! $xml->isError() ) {
1595
			$user_data = $xml->getResponse();
1596
			set_transient( $transient_key, $xml->getResponse(), DAY_IN_SECONDS );
1597
			return $user_data;
1598
		}
1599
1600
		return false;
1601
	}
1602
1603
	/**
1604
	 * Get the wpcom email of the current|specified connected user.
1605
	 */
1606 View Code Duplication
	public static function get_connected_user_email( $user_id = null ) {
1607
		if ( ! $user_id ) {
1608
			$user_id = get_current_user_id();
1609
		}
1610
		Jetpack::load_xml_rpc_client();
1611
		$xml = new Jetpack_IXR_Client( array(
1612
			'user_id' => $user_id,
1613
		) );
1614
		$xml->query( 'wpcom.getUserEmail' );
1615
		if ( ! $xml->isError() ) {
1616
			return $xml->getResponse();
1617
		}
1618
		return false;
1619
	}
1620
1621
	/**
1622
	 * Get the wpcom email of the master user.
1623
	 */
1624
	public static function get_master_user_email() {
1625
		$master_user_id = Jetpack_Options::get_option( 'master_user' );
1626
		if ( $master_user_id ) {
1627
			return self::get_connected_user_email( $master_user_id );
1628
		}
1629
		return '';
1630
	}
1631
1632
	function current_user_is_connection_owner() {
1633
		$user_token = Jetpack_Data::get_access_token( JETPACK_MASTER_USER );
1634
		return $user_token && is_object( $user_token ) && isset( $user_token->external_user_id ) && get_current_user_id() === $user_token->external_user_id;
1635
	}
1636
1637
	/**
1638
	 * Add any extra oEmbed providers that we know about and use on wpcom for feature parity.
1639
	 */
1640
	function extra_oembed_providers() {
1641
		// Cloudup: https://dev.cloudup.com/#oembed
1642
		wp_oembed_add_provider( 'https://cloudup.com/*' , 'https://cloudup.com/oembed' );
1643
		wp_oembed_add_provider( 'https://me.sh/*', 'https://me.sh/oembed?format=json' );
1644
		wp_oembed_add_provider( '#https?://(www\.)?gfycat\.com/.*#i', 'https://api.gfycat.com/v1/oembed', true );
1645
		wp_oembed_add_provider( '#https?://[^.]+\.(wistia\.com|wi\.st)/(medias|embed)/.*#', 'https://fast.wistia.com/oembed', true );
1646
		wp_oembed_add_provider( '#https?://sketchfab\.com/.*#i', 'https://sketchfab.com/oembed', true );
1647
		wp_oembed_add_provider( '#https?://(www\.)?icloud\.com/keynote/.*#i', 'https://iwmb.icloud.com/iwmb/oembed', true );
1648
	}
1649
1650
	/**
1651
	 * Synchronize connected user role changes
1652
	 */
1653
	function user_role_change( $user_id ) {
1654
		_deprecated_function( __METHOD__, 'jetpack-4.2', 'Jetpack_Sync_Users::user_role_change()' );
1655
		Jetpack_Sync_Users::user_role_change( $user_id );
1656
	}
1657
1658
	/**
1659
	 * Loads the currently active modules.
1660
	 */
1661
	public static function load_modules() {
1662
		if (
1663
			! self::is_active()
1664
			&& ! self::is_development_mode()
1665
			&& (
1666
				! is_multisite()
1667
				|| ! get_site_option( 'jetpack_protect_active' )
1668
			)
1669
		) {
1670
			return;
1671
		}
1672
1673
		$version = Jetpack_Options::get_option( 'version' );
1674 View Code Duplication
		if ( ! $version ) {
1675
			$version = $old_version = JETPACK__VERSION . ':' . time();
1676
			/** This action is documented in class.jetpack.php */
1677
			do_action( 'updating_jetpack_version', $version, false );
1678
			Jetpack_Options::update_options( compact( 'version', 'old_version' ) );
1679
		}
1680
		list( $version ) = explode( ':', $version );
1681
1682
		$modules = array_filter( Jetpack::get_active_modules(), array( 'Jetpack', 'is_module' ) );
1683
1684
		$modules_data = array();
1685
1686
		// Don't load modules that have had "Major" changes since the stored version until they have been deactivated/reactivated through the lint check.
1687
		if ( version_compare( $version, JETPACK__VERSION, '<' ) ) {
1688
			$updated_modules = array();
1689
			foreach ( $modules as $module ) {
1690
				$modules_data[ $module ] = Jetpack::get_module( $module );
1691
				if ( ! isset( $modules_data[ $module ]['changed'] ) ) {
1692
					continue;
1693
				}
1694
1695
				if ( version_compare( $modules_data[ $module ]['changed'], $version, '<=' ) ) {
1696
					continue;
1697
				}
1698
1699
				$updated_modules[] = $module;
1700
			}
1701
1702
			$modules = array_diff( $modules, $updated_modules );
1703
		}
1704
1705
		$is_development_mode = Jetpack::is_development_mode();
1706
1707
		foreach ( $modules as $index => $module ) {
1708
			// If we're in dev mode, disable modules requiring a connection
1709
			if ( $is_development_mode ) {
1710
				// Prime the pump if we need to
1711
				if ( empty( $modules_data[ $module ] ) ) {
1712
					$modules_data[ $module ] = Jetpack::get_module( $module );
1713
				}
1714
				// If the module requires a connection, but we're in local mode, don't include it.
1715
				if ( $modules_data[ $module ]['requires_connection'] ) {
1716
					continue;
1717
				}
1718
			}
1719
1720
			if ( did_action( 'jetpack_module_loaded_' . $module ) ) {
1721
				continue;
1722
			}
1723
1724
			if ( ! include_once( Jetpack::get_module_path( $module ) ) ) {
1725
				unset( $modules[ $index ] );
1726
				self::update_active_modules( array_values( $modules ) );
1727
				continue;
1728
			}
1729
1730
			/**
1731
			 * Fires when a specific module is loaded.
1732
			 * The dynamic part of the hook, $module, is the module slug.
1733
			 *
1734
			 * @since 1.1.0
1735
			 */
1736
			do_action( 'jetpack_module_loaded_' . $module );
1737
		}
1738
1739
		/**
1740
		 * Fires when all the modules are loaded.
1741
		 *
1742
		 * @since 1.1.0
1743
		 */
1744
		do_action( 'jetpack_modules_loaded' );
1745
1746
		// 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.
1747
		require_once( JETPACK__PLUGIN_DIR . 'modules/module-extras.php' );
1748
	}
1749
1750
	/**
1751
	 * Check if Jetpack's REST API compat file should be included
1752
	 * @action plugins_loaded
1753
	 * @return null
1754
	 */
1755
	public function check_rest_api_compat() {
1756
		/**
1757
		 * Filters the list of REST API compat files to be included.
1758
		 *
1759
		 * @since 2.2.5
1760
		 *
1761
		 * @param array $args Array of REST API compat files to include.
1762
		 */
1763
		$_jetpack_rest_api_compat_includes = apply_filters( 'jetpack_rest_api_compat', array() );
1764
1765
		if ( function_exists( 'bbpress' ) )
1766
			$_jetpack_rest_api_compat_includes[] = JETPACK__PLUGIN_DIR . 'class.jetpack-bbpress-json-api-compat.php';
1767
1768
		foreach ( $_jetpack_rest_api_compat_includes as $_jetpack_rest_api_compat_include )
1769
			require_once $_jetpack_rest_api_compat_include;
1770
	}
1771
1772
	/**
1773
	 * Gets all plugins currently active in values, regardless of whether they're
1774
	 * traditionally activated or network activated.
1775
	 *
1776
	 * @todo Store the result in core's object cache maybe?
1777
	 */
1778
	public static function get_active_plugins() {
1779
		$active_plugins = (array) get_option( 'active_plugins', array() );
1780
1781
		if ( is_multisite() ) {
1782
			// Due to legacy code, active_sitewide_plugins stores them in the keys,
1783
			// whereas active_plugins stores them in the values.
1784
			$network_plugins = array_keys( get_site_option( 'active_sitewide_plugins', array() ) );
1785
			if ( $network_plugins ) {
1786
				$active_plugins = array_merge( $active_plugins, $network_plugins );
1787
			}
1788
		}
1789
1790
		sort( $active_plugins );
1791
1792
		return array_unique( $active_plugins );
1793
	}
1794
1795
	/**
1796
	 * Gets and parses additional plugin data to send with the heartbeat data
1797
	 *
1798
	 * @since 3.8.1
1799
	 *
1800
	 * @return array Array of plugin data
1801
	 */
1802
	public static function get_parsed_plugin_data() {
1803
		if ( ! function_exists( 'get_plugins' ) ) {
1804
			require_once( ABSPATH . 'wp-admin/includes/plugin.php' );
1805
		}
1806
		/** This filter is documented in wp-admin/includes/class-wp-plugins-list-table.php */
1807
		$all_plugins    = apply_filters( 'all_plugins', get_plugins() );
1808
		$active_plugins = Jetpack::get_active_plugins();
1809
1810
		$plugins = array();
1811
		foreach ( $all_plugins as $path => $plugin_data ) {
1812
			$plugins[ $path ] = array(
1813
					'is_active' => in_array( $path, $active_plugins ),
1814
					'file'      => $path,
1815
					'name'      => $plugin_data['Name'],
1816
					'version'   => $plugin_data['Version'],
1817
					'author'    => $plugin_data['Author'],
1818
			);
1819
		}
1820
1821
		return $plugins;
1822
	}
1823
1824
	/**
1825
	 * Gets and parses theme data to send with the heartbeat data
1826
	 *
1827
	 * @since 3.8.1
1828
	 *
1829
	 * @return array Array of theme data
1830
	 */
1831
	public static function get_parsed_theme_data() {
1832
		$all_themes = wp_get_themes( array( 'allowed' => true ) );
1833
		$header_keys = array( 'Name', 'Author', 'Version', 'ThemeURI', 'AuthorURI', 'Status', 'Tags' );
1834
1835
		$themes = array();
1836
		foreach ( $all_themes as $slug => $theme_data ) {
1837
			$theme_headers = array();
1838
			foreach ( $header_keys as $header_key ) {
1839
				$theme_headers[ $header_key ] = $theme_data->get( $header_key );
1840
			}
1841
1842
			$themes[ $slug ] = array(
1843
					'is_active_theme' => $slug == wp_get_theme()->get_template(),
1844
					'slug' => $slug,
1845
					'theme_root' => $theme_data->get_theme_root_uri(),
1846
					'parent' => $theme_data->parent(),
1847
					'headers' => $theme_headers
1848
			);
1849
		}
1850
1851
		return $themes;
1852
	}
1853
1854
	/**
1855
	 * Checks whether a specific plugin is active.
1856
	 *
1857
	 * We don't want to store these in a static variable, in case
1858
	 * there are switch_to_blog() calls involved.
1859
	 */
1860
	public static function is_plugin_active( $plugin = 'jetpack/jetpack.php' ) {
1861
		return in_array( $plugin, self::get_active_plugins() );
1862
	}
1863
1864
	/**
1865
	 * Check if Jetpack's Open Graph tags should be used.
1866
	 * If certain plugins are active, Jetpack's og tags are suppressed.
1867
	 *
1868
	 * @uses Jetpack::get_active_modules, add_filter, get_option, apply_filters
1869
	 * @action plugins_loaded
1870
	 * @return null
1871
	 */
1872
	public function check_open_graph() {
1873
		if ( in_array( 'publicize', Jetpack::get_active_modules() ) || in_array( 'sharedaddy', Jetpack::get_active_modules() ) ) {
1874
			add_filter( 'jetpack_enable_open_graph', '__return_true', 0 );
1875
		}
1876
1877
		$active_plugins = self::get_active_plugins();
1878
1879
		if ( ! empty( $active_plugins ) ) {
1880
			foreach ( $this->open_graph_conflicting_plugins as $plugin ) {
1881
				if ( in_array( $plugin, $active_plugins ) ) {
1882
					add_filter( 'jetpack_enable_open_graph', '__return_false', 99 );
1883
					break;
1884
				}
1885
			}
1886
		}
1887
1888
		/**
1889
		 * Allow the addition of Open Graph Meta Tags to all pages.
1890
		 *
1891
		 * @since 2.0.3
1892
		 *
1893
		 * @param bool false Should Open Graph Meta tags be added. Default to false.
1894
		 */
1895
		if ( apply_filters( 'jetpack_enable_open_graph', false ) ) {
1896
			require_once JETPACK__PLUGIN_DIR . 'functions.opengraph.php';
1897
		}
1898
	}
1899
1900
	/**
1901
	 * Check if Jetpack's Twitter tags should be used.
1902
	 * If certain plugins are active, Jetpack's twitter tags are suppressed.
1903
	 *
1904
	 * @uses Jetpack::get_active_modules, add_filter, get_option, apply_filters
1905
	 * @action plugins_loaded
1906
	 * @return null
1907
	 */
1908
	public function check_twitter_tags() {
1909
1910
		$active_plugins = self::get_active_plugins();
1911
1912
		if ( ! empty( $active_plugins ) ) {
1913
			foreach ( $this->twitter_cards_conflicting_plugins as $plugin ) {
1914
				if ( in_array( $plugin, $active_plugins ) ) {
1915
					add_filter( 'jetpack_disable_twitter_cards', '__return_true', 99 );
1916
					break;
1917
				}
1918
			}
1919
		}
1920
1921
		/**
1922
		 * Allow Twitter Card Meta tags to be disabled.
1923
		 *
1924
		 * @since 2.6.0
1925
		 *
1926
		 * @param bool true Should Twitter Card Meta tags be disabled. Default to true.
1927
		 */
1928
		if ( ! apply_filters( 'jetpack_disable_twitter_cards', false ) ) {
1929
			require_once JETPACK__PLUGIN_DIR . 'class.jetpack-twitter-cards.php';
1930
		}
1931
	}
1932
1933
	/**
1934
	 * Allows plugins to submit security reports.
1935
 	 *
1936
	 * @param string  $type         Report type (login_form, backup, file_scanning, spam)
1937
	 * @param string  $plugin_file  Plugin __FILE__, so that we can pull plugin data
1938
	 * @param array   $args         See definitions above
1939
	 */
1940
	public static function submit_security_report( $type = '', $plugin_file = '', $args = array() ) {
1941
		_deprecated_function( __FUNCTION__, 'jetpack-4.2', null );
1942
	}
1943
1944
/* Jetpack Options API */
1945
1946
	public static function get_option_names( $type = 'compact' ) {
1947
		return Jetpack_Options::get_option_names( $type );
1948
	}
1949
1950
	/**
1951
	 * Returns the requested option.  Looks in jetpack_options or jetpack_$name as appropriate.
1952
 	 *
1953
	 * @param string $name    Option name
1954
	 * @param mixed  $default (optional)
1955
	 */
1956
	public static function get_option( $name, $default = false ) {
1957
		return Jetpack_Options::get_option( $name, $default );
1958
	}
1959
1960
	/**
1961
	 * Updates the single given option.  Updates jetpack_options or jetpack_$name as appropriate.
1962
 	 *
1963
	 * @deprecated 3.4 use Jetpack_Options::update_option() instead.
1964
	 * @param string $name  Option name
1965
	 * @param mixed  $value Option value
1966
	 */
1967
	public static function update_option( $name, $value ) {
1968
		_deprecated_function( __METHOD__, 'jetpack-3.4', 'Jetpack_Options::update_option()' );
1969
		return Jetpack_Options::update_option( $name, $value );
1970
	}
1971
1972
	/**
1973
	 * Updates the multiple given options.  Updates jetpack_options and/or jetpack_$name as appropriate.
1974
 	 *
1975
	 * @deprecated 3.4 use Jetpack_Options::update_options() instead.
1976
	 * @param array $array array( option name => option value, ... )
1977
	 */
1978
	public static function update_options( $array ) {
1979
		_deprecated_function( __METHOD__, 'jetpack-3.4', 'Jetpack_Options::update_options()' );
1980
		return Jetpack_Options::update_options( $array );
1981
	}
1982
1983
	/**
1984
	 * Deletes the given option.  May be passed multiple option names as an array.
1985
	 * Updates jetpack_options and/or deletes jetpack_$name as appropriate.
1986
	 *
1987
	 * @deprecated 3.4 use Jetpack_Options::delete_option() instead.
1988
	 * @param string|array $names
1989
	 */
1990
	public static function delete_option( $names ) {
1991
		_deprecated_function( __METHOD__, 'jetpack-3.4', 'Jetpack_Options::delete_option()' );
1992
		return Jetpack_Options::delete_option( $names );
1993
	}
1994
1995
	/**
1996
	 * Enters a user token into the user_tokens option
1997
	 *
1998
	 * @param int $user_id
1999
	 * @param string $token
2000
	 * return bool
2001
	 */
2002
	public static function update_user_token( $user_id, $token, $is_master_user ) {
2003
		// not designed for concurrent updates
2004
		$user_tokens = Jetpack_Options::get_option( 'user_tokens' );
2005
		if ( ! is_array( $user_tokens ) )
2006
			$user_tokens = array();
2007
		$user_tokens[$user_id] = $token;
2008
		if ( $is_master_user ) {
2009
			$master_user = $user_id;
2010
			$options     = compact( 'user_tokens', 'master_user' );
2011
		} else {
2012
			$options = compact( 'user_tokens' );
2013
		}
2014
		return Jetpack_Options::update_options( $options );
2015
	}
2016
2017
	/**
2018
	 * Returns an array of all PHP files in the specified absolute path.
2019
	 * Equivalent to glob( "$absolute_path/*.php" ).
2020
	 *
2021
	 * @param string $absolute_path The absolute path of the directory to search.
2022
	 * @return array Array of absolute paths to the PHP files.
2023
	 */
2024
	public static function glob_php( $absolute_path ) {
2025
		if ( function_exists( 'glob' ) ) {
2026
			return glob( "$absolute_path/*.php" );
2027
		}
2028
2029
		$absolute_path = untrailingslashit( $absolute_path );
2030
		$files = array();
2031
		if ( ! $dir = @opendir( $absolute_path ) ) {
2032
			return $files;
2033
		}
2034
2035
		while ( false !== $file = readdir( $dir ) ) {
2036
			if ( '.' == substr( $file, 0, 1 ) || '.php' != substr( $file, -4 ) ) {
2037
				continue;
2038
			}
2039
2040
			$file = "$absolute_path/$file";
2041
2042
			if ( ! is_file( $file ) ) {
2043
				continue;
2044
			}
2045
2046
			$files[] = $file;
2047
		}
2048
2049
		closedir( $dir );
2050
2051
		return $files;
2052
	}
2053
2054
	public static function activate_new_modules( $redirect = false ) {
2055
		if ( ! Jetpack::is_active() && ! Jetpack::is_development_mode() ) {
2056
			return;
2057
		}
2058
2059
		$jetpack_old_version = Jetpack_Options::get_option( 'version' ); // [sic]
2060 View Code Duplication
		if ( ! $jetpack_old_version ) {
2061
			$jetpack_old_version = $version = $old_version = '1.1:' . time();
2062
			/** This action is documented in class.jetpack.php */
2063
			do_action( 'updating_jetpack_version', $version, false );
2064
			Jetpack_Options::update_options( compact( 'version', 'old_version' ) );
2065
		}
2066
2067
		list( $jetpack_version ) = explode( ':', $jetpack_old_version ); // [sic]
2068
2069
		if ( version_compare( JETPACK__VERSION, $jetpack_version, '<=' ) ) {
2070
			return;
2071
		}
2072
2073
		$active_modules     = Jetpack::get_active_modules();
2074
		$reactivate_modules = array();
2075
		foreach ( $active_modules as $active_module ) {
2076
			$module = Jetpack::get_module( $active_module );
2077
			if ( ! isset( $module['changed'] ) ) {
2078
				continue;
2079
			}
2080
2081
			if ( version_compare( $module['changed'], $jetpack_version, '<=' ) ) {
2082
				continue;
2083
			}
2084
2085
			$reactivate_modules[] = $active_module;
2086
			Jetpack::deactivate_module( $active_module );
2087
		}
2088
2089
		$new_version = JETPACK__VERSION . ':' . time();
2090
		/** This action is documented in class.jetpack.php */
2091
		do_action( 'updating_jetpack_version', $new_version, $jetpack_old_version );
2092
		Jetpack_Options::update_options(
2093
			array(
2094
				'version'     => $new_version,
2095
				'old_version' => $jetpack_old_version,
2096
			)
2097
		);
2098
2099
		Jetpack::state( 'message', 'modules_activated' );
2100
		Jetpack::activate_default_modules( $jetpack_version, JETPACK__VERSION, $reactivate_modules );
2101
2102
		if ( $redirect ) {
2103
			$page = 'jetpack'; // make sure we redirect to either settings or the jetpack page
2104
			if ( isset( $_GET['page'] ) && in_array( $_GET['page'], array( 'jetpack', 'jetpack_modules' ) ) ) {
2105
				$page = $_GET['page'];
2106
			}
2107
2108
			wp_safe_redirect( Jetpack::admin_url( 'page=' . $page ) );
2109
			exit;
2110
		}
2111
	}
2112
2113
	/**
2114
	 * List available Jetpack modules. Simply lists .php files in /modules/.
2115
	 * Make sure to tuck away module "library" files in a sub-directory.
2116
	 */
2117
	public static function get_available_modules( $min_version = false, $max_version = false ) {
2118
		static $modules = null;
2119
2120
		if ( ! isset( $modules ) ) {
2121
			$available_modules_option = Jetpack_Options::get_option( 'available_modules', array() );
2122
			// Use the cache if we're on the front-end and it's available...
2123
			if ( ! is_admin() && ! empty( $available_modules_option[ JETPACK__VERSION ] ) ) {
2124
				$modules = $available_modules_option[ JETPACK__VERSION ];
2125
			} else {
2126
				$files = Jetpack::glob_php( JETPACK__PLUGIN_DIR . 'modules' );
2127
2128
				$modules = array();
2129
2130
				foreach ( $files as $file ) {
2131
					if ( ! $headers = Jetpack::get_module( $file ) ) {
2132
						continue;
2133
					}
2134
2135
					$modules[ Jetpack::get_module_slug( $file ) ] = $headers['introduced'];
2136
				}
2137
2138
				Jetpack_Options::update_option( 'available_modules', array(
2139
					JETPACK__VERSION => $modules,
2140
				) );
2141
			}
2142
		}
2143
2144
		/**
2145
		 * Filters the array of modules available to be activated.
2146
		 *
2147
		 * @since 2.4.0
2148
		 *
2149
		 * @param array $modules Array of available modules.
2150
		 * @param string $min_version Minimum version number required to use modules.
2151
		 * @param string $max_version Maximum version number required to use modules.
2152
		 */
2153
		$mods = apply_filters( 'jetpack_get_available_modules', $modules, $min_version, $max_version );
2154
2155
		if ( ! $min_version && ! $max_version ) {
2156
			return array_keys( $mods );
2157
		}
2158
2159
		$r = array();
2160
		foreach ( $mods as $slug => $introduced ) {
2161
			if ( $min_version && version_compare( $min_version, $introduced, '>=' ) ) {
2162
				continue;
2163
			}
2164
2165
			if ( $max_version && version_compare( $max_version, $introduced, '<' ) ) {
2166
				continue;
2167
			}
2168
2169
			$r[] = $slug;
2170
		}
2171
2172
		return $r;
2173
	}
2174
2175
	/**
2176
	 * Default modules loaded on activation.
2177
	 */
2178
	public static function get_default_modules( $min_version = false, $max_version = false ) {
2179
		$return = array();
2180
2181
		foreach ( Jetpack::get_available_modules( $min_version, $max_version ) as $module ) {
2182
			$module_data = Jetpack::get_module( $module );
2183
2184
			switch ( strtolower( $module_data['auto_activate'] ) ) {
2185
				case 'yes' :
2186
					$return[] = $module;
2187
					break;
2188
				case 'public' :
2189
					if ( Jetpack_Options::get_option( 'public' ) ) {
2190
						$return[] = $module;
2191
					}
2192
					break;
2193
				case 'no' :
2194
				default :
2195
					break;
2196
			}
2197
		}
2198
		/**
2199
		 * Filters the array of default modules.
2200
		 *
2201
		 * @since 2.5.0
2202
		 *
2203
		 * @param array $return Array of default modules.
2204
		 * @param string $min_version Minimum version number required to use modules.
2205
		 * @param string $max_version Maximum version number required to use modules.
2206
		 */
2207
		return apply_filters( 'jetpack_get_default_modules', $return, $min_version, $max_version );
2208
	}
2209
2210
	/**
2211
	 * Checks activated modules during auto-activation to determine
2212
	 * if any of those modules are being deprecated.  If so, close
2213
	 * them out, and add any replacement modules.
2214
	 *
2215
	 * Runs at priority 99 by default.
2216
	 *
2217
	 * This is run late, so that it can still activate a module if
2218
	 * the new module is a replacement for another that the user
2219
	 * currently has active, even if something at the normal priority
2220
	 * would kibosh everything.
2221
	 *
2222
	 * @since 2.6
2223
	 * @uses jetpack_get_default_modules filter
2224
	 * @param array $modules
2225
	 * @return array
2226
	 */
2227
	function handle_deprecated_modules( $modules ) {
2228
		$deprecated_modules = array(
2229
			'debug'            => null,  // Closed out and moved to ./class.jetpack-debugger.php
2230
			'wpcc'             => 'sso', // Closed out in 2.6 -- SSO provides the same functionality.
2231
			'gplus-authorship' => null,  // Closed out in 3.2 -- Google dropped support.
2232
		);
2233
2234
		// Don't activate SSO if they never completed activating WPCC.
2235
		if ( Jetpack::is_module_active( 'wpcc' ) ) {
2236
			$wpcc_options = Jetpack_Options::get_option( 'wpcc_options' );
2237
			if ( empty( $wpcc_options ) || empty( $wpcc_options['client_id'] ) || empty( $wpcc_options['client_id'] ) ) {
2238
				$deprecated_modules['wpcc'] = null;
2239
			}
2240
		}
2241
2242
		foreach ( $deprecated_modules as $module => $replacement ) {
2243
			if ( Jetpack::is_module_active( $module ) ) {
2244
				self::deactivate_module( $module );
2245
				if ( $replacement ) {
2246
					$modules[] = $replacement;
2247
				}
2248
			}
2249
		}
2250
2251
		return array_unique( $modules );
2252
	}
2253
2254
	/**
2255
	 * Checks activated plugins during auto-activation to determine
2256
	 * if any of those plugins are in the list with a corresponding module
2257
	 * that is not compatible with the plugin. The module will not be allowed
2258
	 * to auto-activate.
2259
	 *
2260
	 * @since 2.6
2261
	 * @uses jetpack_get_default_modules filter
2262
	 * @param array $modules
2263
	 * @return array
2264
	 */
2265
	function filter_default_modules( $modules ) {
2266
2267
		$active_plugins = self::get_active_plugins();
2268
2269
		if ( ! empty( $active_plugins ) ) {
2270
2271
			// For each module we'd like to auto-activate...
2272
			foreach ( $modules as $key => $module ) {
2273
				// If there are potential conflicts for it...
2274
				if ( ! empty( $this->conflicting_plugins[ $module ] ) ) {
2275
					// For each potential conflict...
2276
					foreach ( $this->conflicting_plugins[ $module ] as $title => $plugin ) {
2277
						// If that conflicting plugin is active...
2278
						if ( in_array( $plugin, $active_plugins ) ) {
2279
							// Remove that item from being auto-activated.
2280
							unset( $modules[ $key ] );
2281
						}
2282
					}
2283
				}
2284
			}
2285
		}
2286
2287
		return $modules;
2288
	}
2289
2290
	/**
2291
	 * Extract a module's slug from its full path.
2292
	 */
2293
	public static function get_module_slug( $file ) {
2294
		return str_replace( '.php', '', basename( $file ) );
2295
	}
2296
2297
	/**
2298
	 * Generate a module's path from its slug.
2299
	 */
2300
	public static function get_module_path( $slug ) {
2301
		return JETPACK__PLUGIN_DIR . "modules/$slug.php";
2302
	}
2303
2304
	/**
2305
	 * Load module data from module file. Headers differ from WordPress
2306
	 * plugin headers to avoid them being identified as standalone
2307
	 * plugins on the WordPress plugins page.
2308
	 */
2309
	public static function get_module( $module ) {
2310
		$headers = array(
2311
			'name'                      => 'Module Name',
2312
			'description'               => 'Module Description',
2313
			'jumpstart_desc'            => 'Jumpstart Description',
2314
			'sort'                      => 'Sort Order',
2315
			'recommendation_order'      => 'Recommendation Order',
2316
			'introduced'                => 'First Introduced',
2317
			'changed'                   => 'Major Changes In',
2318
			'deactivate'                => 'Deactivate',
2319
			'free'                      => 'Free',
2320
			'requires_connection'       => 'Requires Connection',
2321
			'auto_activate'             => 'Auto Activate',
2322
			'module_tags'               => 'Module Tags',
2323
			'feature'                   => 'Feature',
2324
			'additional_search_queries' => 'Additional Search Queries',
2325
		);
2326
2327
		$file = Jetpack::get_module_path( Jetpack::get_module_slug( $module ) );
2328
2329
		$mod = Jetpack::get_file_data( $file, $headers );
2330
		if ( empty( $mod['name'] ) ) {
2331
			return false;
2332
		}
2333
2334
		$mod['sort']                    = empty( $mod['sort'] ) ? 10 : (int) $mod['sort'];
2335
		$mod['recommendation_order']    = empty( $mod['recommendation_order'] ) ? 20 : (int) $mod['recommendation_order'];
2336
		$mod['deactivate']              = empty( $mod['deactivate'] );
2337
		$mod['free']                    = empty( $mod['free'] );
2338
		$mod['requires_connection']     = ( ! empty( $mod['requires_connection'] ) && 'No' == $mod['requires_connection'] ) ? false : true;
2339
2340
		if ( empty( $mod['auto_activate'] ) || ! in_array( strtolower( $mod['auto_activate'] ), array( 'yes', 'no', 'public' ) ) ) {
2341
			$mod['auto_activate'] = 'No';
2342
		} else {
2343
			$mod['auto_activate'] = (string) $mod['auto_activate'];
2344
		}
2345
2346
		if ( $mod['module_tags'] ) {
2347
			$mod['module_tags'] = explode( ',', $mod['module_tags'] );
2348
			$mod['module_tags'] = array_map( 'trim', $mod['module_tags'] );
2349
			$mod['module_tags'] = array_map( array( __CLASS__, 'translate_module_tag' ), $mod['module_tags'] );
2350
		} else {
2351
			$mod['module_tags'] = array( self::translate_module_tag( 'Other' ) );
2352
		}
2353
2354
		if ( $mod['feature'] ) {
2355
			$mod['feature'] = explode( ',', $mod['feature'] );
2356
			$mod['feature'] = array_map( 'trim', $mod['feature'] );
2357
		} else {
2358
			$mod['feature'] = array( self::translate_module_tag( 'Other' ) );
2359
		}
2360
2361
		/**
2362
		 * Filters the feature array on a module.
2363
		 *
2364
		 * This filter allows you to control where each module is filtered: Recommended,
2365
		 * Jumpstart, and the default "Other" listing.
2366
		 *
2367
		 * @since 3.5.0
2368
		 *
2369
		 * @param array   $mod['feature'] The areas to feature this module:
2370
		 *     'Jumpstart' adds to the "Jumpstart" option to activate many modules at once.
2371
		 *     'Recommended' shows on the main Jetpack admin screen.
2372
		 *     'Other' should be the default if no other value is in the array.
2373
		 * @param string  $module The slug of the module, e.g. sharedaddy.
2374
		 * @param array   $mod All the currently assembled module data.
2375
		 */
2376
		$mod['feature'] = apply_filters( 'jetpack_module_feature', $mod['feature'], $module, $mod );
2377
2378
		/**
2379
		 * Filter the returned data about a module.
2380
		 *
2381
		 * This filter allows overriding any info about Jetpack modules. It is dangerous,
2382
		 * so please be careful.
2383
		 *
2384
		 * @since 3.6.0
2385
		 *
2386
		 * @param array   $mod    The details of the requested module.
2387
		 * @param string  $module The slug of the module, e.g. sharedaddy
2388
		 * @param string  $file   The path to the module source file.
2389
		 */
2390
		return apply_filters( 'jetpack_get_module', $mod, $module, $file );
2391
	}
2392
2393
	/**
2394
	 * Like core's get_file_data implementation, but caches the result.
2395
	 */
2396
	public static function get_file_data( $file, $headers ) {
2397
		//Get just the filename from $file (i.e. exclude full path) so that a consistent hash is generated
2398
		$file_name = basename( $file );
2399
2400
		$cache_key = 'jetpack_file_data_' . JETPACK__VERSION;
2401
2402
		$file_data_option = get_transient( $cache_key );
2403
2404
		if ( false === $file_data_option ) {
2405
			$file_data_option = array();
2406
		}
2407
2408
		$key           = md5( $file_name . serialize( $headers ) );
2409
		$refresh_cache = is_admin() && isset( $_GET['page'] ) && 'jetpack' === substr( $_GET['page'], 0, 7 );
2410
2411
		// If we don't need to refresh the cache, and already have the value, short-circuit!
2412
		if ( ! $refresh_cache && isset( $file_data_option[ $key ] ) ) {
2413
			return $file_data_option[ $key ];
2414
		}
2415
2416
		$data = get_file_data( $file, $headers );
2417
2418
		$file_data_option[ $key ] = $data;
2419
2420
		set_transient( $cache_key, $file_data_option, 29 * DAY_IN_SECONDS );
2421
2422
		return $data;
2423
	}
2424
2425
2426
	/**
2427
	 * Return translated module tag.
2428
	 *
2429
	 * @param string $tag Tag as it appears in each module heading.
2430
	 *
2431
	 * @return mixed
2432
	 */
2433
	public static function translate_module_tag( $tag ) {
2434
		return jetpack_get_module_i18n_tag( $tag );
2435
	}
2436
2437
	/**
2438
	 * Return module name translation. Uses matching string created in modules/module-headings.php.
2439
	 *
2440
	 * @since 3.9.2
2441
	 *
2442
	 * @param array $modules
2443
	 *
2444
	 * @return string|void
2445
	 */
2446
	public static function get_translated_modules( $modules ) {
2447
		foreach ( $modules as $index => $module ) {
2448
			$i18n_module = jetpack_get_module_i18n( $module['module'] );
2449
			if ( isset( $module['name'] ) ) {
2450
				$modules[ $index ]['name'] = $i18n_module['name'];
2451
			}
2452
			if ( isset( $module['description'] ) ) {
2453
				$modules[ $index ]['description'] = $i18n_module['description'];
2454
				$modules[ $index ]['short_description'] = $i18n_module['description'];
2455
			}
2456
		}
2457
		return $modules;
2458
	}
2459
2460
	/**
2461
	 * Get a list of activated modules as an array of module slugs.
2462
	 */
2463
	public static function get_active_modules() {
2464
		$active = Jetpack_Options::get_option( 'active_modules' );
2465
2466
		if ( ! is_array( $active ) ) {
2467
			$active = array();
2468
		}
2469
2470
		if ( class_exists( 'VaultPress' ) || function_exists( 'vaultpress_contact_service' ) ) {
2471
			$active[] = 'vaultpress';
2472
		} else {
2473
			$active = array_diff( $active, array( 'vaultpress' ) );
2474
		}
2475
2476
		//If protect is active on the main site of a multisite, it should be active on all sites.
2477
		if ( ! in_array( 'protect', $active ) && is_multisite() && get_site_option( 'jetpack_protect_active' ) ) {
2478
			$active[] = 'protect';
2479
		}
2480
2481
		return array_unique( $active );
2482
	}
2483
2484
	/**
2485
	 * Check whether or not a Jetpack module is active.
2486
	 *
2487
	 * @param string $module The slug of a Jetpack module.
2488
	 * @return bool
2489
	 *
2490
	 * @static
2491
	 */
2492
	public static function is_module_active( $module ) {
2493
		return in_array( $module, self::get_active_modules() );
2494
	}
2495
2496
	public static function is_module( $module ) {
2497
		return ! empty( $module ) && ! validate_file( $module, Jetpack::get_available_modules() );
2498
	}
2499
2500
	/**
2501
	 * Catches PHP errors.  Must be used in conjunction with output buffering.
2502
	 *
2503
	 * @param bool $catch True to start catching, False to stop.
2504
	 *
2505
	 * @static
2506
	 */
2507
	public static function catch_errors( $catch ) {
2508
		static $display_errors, $error_reporting;
2509
2510
		if ( $catch ) {
2511
			$display_errors  = @ini_set( 'display_errors', 1 );
2512
			$error_reporting = @error_reporting( E_ALL );
2513
			add_action( 'shutdown', array( 'Jetpack', 'catch_errors_on_shutdown' ), 0 );
2514
		} else {
2515
			@ini_set( 'display_errors', $display_errors );
2516
			@error_reporting( $error_reporting );
2517
			remove_action( 'shutdown', array( 'Jetpack', 'catch_errors_on_shutdown' ), 0 );
2518
		}
2519
	}
2520
2521
	/**
2522
	 * Saves any generated PHP errors in ::state( 'php_errors', {errors} )
2523
	 */
2524
	public static function catch_errors_on_shutdown() {
2525
		Jetpack::state( 'php_errors', self::alias_directories( ob_get_clean() ) );
2526
	}
2527
2528
	/**
2529
	 * Rewrite any string to make paths easier to read.
2530
	 *
2531
	 * Rewrites ABSPATH (eg `/home/jetpack/wordpress/`) to ABSPATH, and if WP_CONTENT_DIR
2532
	 * is located outside of ABSPATH, rewrites that to WP_CONTENT_DIR.
2533
	 *
2534
	 * @param $string
2535
	 * @return mixed
2536
	 */
2537
	public static function alias_directories( $string ) {
2538
		// ABSPATH has a trailing slash.
2539
		$string = str_replace( ABSPATH, 'ABSPATH/', $string );
2540
		// WP_CONTENT_DIR does not have a trailing slash.
2541
		$string = str_replace( WP_CONTENT_DIR, 'WP_CONTENT_DIR', $string );
2542
2543
		return $string;
2544
	}
2545
2546
	public static function activate_default_modules(
2547
		$min_version = false,
2548
		$max_version = false,
2549
		$other_modules = array(),
2550
		$redirect = true,
2551
		$send_state_messages = true
2552
	) {
2553
		$jetpack = Jetpack::init();
2554
2555
		$modules = Jetpack::get_default_modules( $min_version, $max_version );
2556
		$modules = array_merge( $other_modules, $modules );
2557
2558
		// Look for standalone plugins and disable if active.
2559
2560
		$to_deactivate = array();
2561
		foreach ( $modules as $module ) {
2562
			if ( isset( $jetpack->plugins_to_deactivate[$module] ) ) {
2563
				$to_deactivate[$module] = $jetpack->plugins_to_deactivate[$module];
2564
			}
2565
		}
2566
2567
		$deactivated = array();
2568
		foreach ( $to_deactivate as $module => $deactivate_me ) {
2569
			list( $probable_file, $probable_title ) = $deactivate_me;
2570
			if ( Jetpack_Client_Server::deactivate_plugin( $probable_file, $probable_title ) ) {
2571
				$deactivated[] = $module;
2572
			}
2573
		}
2574
2575
		if ( $deactivated && $redirect ) {
2576
			Jetpack::state( 'deactivated_plugins', join( ',', $deactivated ) );
2577
2578
			$url = add_query_arg(
2579
				array(
2580
					'action'   => 'activate_default_modules',
2581
					'_wpnonce' => wp_create_nonce( 'activate_default_modules' ),
2582
				),
2583
				add_query_arg( compact( 'min_version', 'max_version', 'other_modules' ), Jetpack::admin_url( 'page=jetpack' ) )
2584
			);
2585
			wp_safe_redirect( $url );
2586
			exit;
2587
		}
2588
2589
		/**
2590
		 * Fires before default modules are activated.
2591
		 *
2592
		 * @since 1.9.0
2593
		 *
2594
		 * @param string $min_version Minimum version number required to use modules.
2595
		 * @param string $max_version Maximum version number required to use modules.
2596
		 * @param array $other_modules Array of other modules to activate alongside the default modules.
2597
		 */
2598
		do_action( 'jetpack_before_activate_default_modules', $min_version, $max_version, $other_modules );
2599
2600
		// Check each module for fatal errors, a la wp-admin/plugins.php::activate before activating
2601
		Jetpack::restate();
2602
		Jetpack::catch_errors( true );
2603
2604
		$active = Jetpack::get_active_modules();
2605
2606
		foreach ( $modules as $module ) {
2607
			if ( did_action( "jetpack_module_loaded_$module" ) ) {
2608
				$active[] = $module;
2609
				self::update_active_modules( $active );
2610
				continue;
2611
			}
2612
2613
			if ( $send_state_messages && in_array( $module, $active ) ) {
2614
				$module_info = Jetpack::get_module( $module );
2615 View Code Duplication
				if ( ! $module_info['deactivate'] ) {
2616
					$state = in_array( $module, $other_modules ) ? 'reactivated_modules' : 'activated_modules';
2617
					if ( $active_state = Jetpack::state( $state ) ) {
2618
						$active_state = explode( ',', $active_state );
2619
					} else {
2620
						$active_state = array();
2621
					}
2622
					$active_state[] = $module;
2623
					Jetpack::state( $state, implode( ',', $active_state ) );
2624
				}
2625
				continue;
2626
			}
2627
2628
			$file = Jetpack::get_module_path( $module );
2629
			if ( ! file_exists( $file ) ) {
2630
				continue;
2631
			}
2632
2633
			// we'll override this later if the plugin can be included without fatal error
2634
			if ( $redirect ) {
2635
				wp_safe_redirect( Jetpack::admin_url( 'page=jetpack' ) );
2636
			}
2637
2638
			if ( $send_state_messages ) {
2639
				Jetpack::state( 'error', 'module_activation_failed' );
2640
				Jetpack::state( 'module', $module );
2641
			}
2642
2643
			ob_start();
2644
			require $file;
2645
2646
			$active[] = $module;
2647
2648 View Code Duplication
			if ( $send_state_messages ) {
2649
2650
				$state    = in_array( $module, $other_modules ) ? 'reactivated_modules' : 'activated_modules';
2651
				if ( $active_state = Jetpack::state( $state ) ) {
2652
					$active_state = explode( ',', $active_state );
2653
				} else {
2654
					$active_state = array();
2655
				}
2656
				$active_state[] = $module;
2657
				Jetpack::state( $state, implode( ',', $active_state ) );
2658
			}
2659
2660
			Jetpack::update_active_modules( $active );
2661
2662
			ob_end_clean();
2663
		}
2664
2665
		if ( $send_state_messages ) {
2666
			Jetpack::state( 'error', false );
2667
			Jetpack::state( 'module', false );
2668
		}
2669
2670
		Jetpack::catch_errors( false );
2671
		/**
2672
		 * Fires when default modules are activated.
2673
		 *
2674
		 * @since 1.9.0
2675
		 *
2676
		 * @param string $min_version Minimum version number required to use modules.
2677
		 * @param string $max_version Maximum version number required to use modules.
2678
		 * @param array $other_modules Array of other modules to activate alongside the default modules.
2679
		 */
2680
		do_action( 'jetpack_activate_default_modules', $min_version, $max_version, $other_modules );
2681
	}
2682
2683
	public static function activate_module( $module, $exit = true, $redirect = true ) {
2684
		/**
2685
		 * Fires before a module is activated.
2686
		 *
2687
		 * @since 2.6.0
2688
		 *
2689
		 * @param string $module Module slug.
2690
		 * @param bool $exit Should we exit after the module has been activated. Default to true.
2691
		 * @param bool $redirect Should the user be redirected after module activation? Default to true.
2692
		 */
2693
		do_action( 'jetpack_pre_activate_module', $module, $exit, $redirect );
2694
2695
		$jetpack = Jetpack::init();
2696
2697
		if ( ! strlen( $module ) )
2698
			return false;
2699
2700
		if ( ! Jetpack::is_module( $module ) )
2701
			return false;
2702
2703
		// If it's already active, then don't do it again
2704
		$active = Jetpack::get_active_modules();
2705
		foreach ( $active as $act ) {
2706
			if ( $act == $module )
2707
				return true;
2708
		}
2709
2710
		$module_data = Jetpack::get_module( $module );
2711
2712
		if ( ! Jetpack::is_active() ) {
2713
			if ( !Jetpack::is_development_mode() )
2714
				return false;
2715
2716
			// If we're not connected but in development mode, make sure the module doesn't require a connection
2717
			if ( Jetpack::is_development_mode() && $module_data['requires_connection'] )
2718
				return false;
2719
		}
2720
2721
		// Check and see if the old plugin is active
2722
		if ( isset( $jetpack->plugins_to_deactivate[ $module ] ) ) {
2723
			// Deactivate the old plugin
2724
			if ( Jetpack_Client_Server::deactivate_plugin( $jetpack->plugins_to_deactivate[ $module ][0], $jetpack->plugins_to_deactivate[ $module ][1] ) ) {
2725
				// If we deactivated the old plugin, remembere that with ::state() and redirect back to this page to activate the module
2726
				// We can't activate the module on this page load since the newly deactivated old plugin is still loaded on this page load.
2727
				Jetpack::state( 'deactivated_plugins', $module );
2728
				wp_safe_redirect( add_query_arg( 'jetpack_restate', 1 ) );
2729
				exit;
2730
			}
2731
		}
2732
2733
		// Protect won't work with mis-configured IPs
2734
		if ( 'protect' === $module ) {
2735
			include_once JETPACK__PLUGIN_DIR . 'modules/protect/shared-functions.php';
2736
			if ( ! jetpack_protect_get_ip() ) {
2737
				Jetpack::state( 'message', 'protect_misconfigured_ip' );
2738
				return false;
2739
			}
2740
		}
2741
2742
		// Check the file for fatal errors, a la wp-admin/plugins.php::activate
2743
		Jetpack::state( 'module', $module );
2744
		Jetpack::state( 'error', 'module_activation_failed' ); // we'll override this later if the plugin can be included without fatal error
2745
2746
		Jetpack::catch_errors( true );
2747
		ob_start();
2748
		require Jetpack::get_module_path( $module );
2749
		/** This action is documented in class.jetpack.php */
2750
		do_action( 'jetpack_activate_module', $module );
2751
		$active[] = $module;
2752
		Jetpack::update_active_modules( $active );
2753
2754
		Jetpack::state( 'error', false ); // the override
2755
		ob_end_clean();
2756
		Jetpack::catch_errors( false );
2757
2758
		// A flag for Jump Start so it's not shown again. Only set if it hasn't been yet.
2759 View Code Duplication
		if ( 'new_connection' === Jetpack_Options::get_option( 'jumpstart' ) ) {
2760
			Jetpack_Options::update_option( 'jumpstart', 'jetpack_action_taken' );
2761
2762
			//Jump start is being dismissed send data to MC Stats
2763
			$jetpack->stat( 'jumpstart', 'manual,'.$module );
2764
2765
			$jetpack->do_stats( 'server_side' );
2766
		}
2767
2768
		if ( $redirect ) {
2769
			wp_safe_redirect( Jetpack::admin_url( 'page=jetpack' ) );
2770
		}
2771
		if ( $exit ) {
2772
			exit;
2773
		}
2774
		return true;
2775
	}
2776
2777
	function activate_module_actions( $module ) {
2778
		_deprecated_function( __METHOD__, 'jeptack-4.2' );
2779
	}
2780
2781
	public static function deactivate_module( $module ) {
2782
		/**
2783
		 * Fires when a module is deactivated.
2784
		 *
2785
		 * @since 1.9.0
2786
		 *
2787
		 * @param string $module Module slug.
2788
		 */
2789
		do_action( 'jetpack_pre_deactivate_module', $module );
2790
2791
		$jetpack = Jetpack::init();
2792
2793
		$active = Jetpack::get_active_modules();
2794
		$new    = array_filter( array_diff( $active, (array) $module ) );
2795
2796
		// A flag for Jump Start so it's not shown again.
2797 View Code Duplication
		if ( 'new_connection' === Jetpack_Options::get_option( 'jumpstart' ) ) {
2798
			Jetpack_Options::update_option( 'jumpstart', 'jetpack_action_taken' );
2799
2800
			//Jump start is being dismissed send data to MC Stats
2801
			$jetpack->stat( 'jumpstart', 'manual,deactivated-'.$module );
2802
2803
			$jetpack->do_stats( 'server_side' );
2804
		}
2805
2806
		return self::update_active_modules( $new );
2807
	}
2808
2809
	public static function enable_module_configurable( $module ) {
2810
		$module = Jetpack::get_module_slug( $module );
2811
		add_filter( 'jetpack_module_configurable_' . $module, '__return_true' );
2812
	}
2813
2814
	public static function module_configuration_url( $module ) {
2815
		$module = Jetpack::get_module_slug( $module );
2816
		return Jetpack::admin_url( array( 'page' => 'jetpack', 'configure' => $module ) );
2817
	}
2818
2819
	public static function module_configuration_load( $module, $method ) {
2820
		$module = Jetpack::get_module_slug( $module );
2821
		add_action( 'jetpack_module_configuration_load_' . $module, $method );
2822
	}
2823
2824
	public static function module_configuration_head( $module, $method ) {
2825
		$module = Jetpack::get_module_slug( $module );
2826
		add_action( 'jetpack_module_configuration_head_' . $module, $method );
2827
	}
2828
2829
	public static function module_configuration_screen( $module, $method ) {
2830
		$module = Jetpack::get_module_slug( $module );
2831
		add_action( 'jetpack_module_configuration_screen_' . $module, $method );
2832
	}
2833
2834
	public static function module_configuration_activation_screen( $module, $method ) {
2835
		$module = Jetpack::get_module_slug( $module );
2836
		add_action( 'display_activate_module_setting_' . $module, $method );
2837
	}
2838
2839
/* Installation */
2840
2841
	public static function bail_on_activation( $message, $deactivate = true ) {
2842
?>
2843
<!doctype html>
2844
<html>
2845
<head>
2846
<meta charset="<?php bloginfo( 'charset' ); ?>">
2847
<style>
2848
* {
2849
	text-align: center;
2850
	margin: 0;
2851
	padding: 0;
2852
	font-family: "Lucida Grande",Verdana,Arial,"Bitstream Vera Sans",sans-serif;
2853
}
2854
p {
2855
	margin-top: 1em;
2856
	font-size: 18px;
2857
}
2858
</style>
2859
<body>
2860
<p><?php echo esc_html( $message ); ?></p>
2861
</body>
2862
</html>
2863
<?php
2864
		if ( $deactivate ) {
2865
			$plugins = get_option( 'active_plugins' );
2866
			$jetpack = plugin_basename( JETPACK__PLUGIN_DIR . 'jetpack.php' );
2867
			$update  = false;
2868
			foreach ( $plugins as $i => $plugin ) {
2869
				if ( $plugin === $jetpack ) {
2870
					$plugins[$i] = false;
2871
					$update = true;
2872
				}
2873
			}
2874
2875
			if ( $update ) {
2876
				update_option( 'active_plugins', array_filter( $plugins ) );
2877
			}
2878
		}
2879
		exit;
2880
	}
2881
2882
	/**
2883
	 * Attached to activate_{ plugin_basename( __FILES__ ) } by register_activation_hook()
2884
	 * @static
2885
	 */
2886
	public static function plugin_activation( $network_wide ) {
2887
		Jetpack_Options::update_option( 'activated', 1 );
2888
2889
		if ( version_compare( $GLOBALS['wp_version'], JETPACK__MINIMUM_WP_VERSION, '<' ) ) {
2890
			Jetpack::bail_on_activation( sprintf( __( 'Jetpack requires WordPress version %s or later.', 'jetpack' ), JETPACK__MINIMUM_WP_VERSION ) );
2891
		}
2892
2893
		if ( $network_wide )
2894
			Jetpack::state( 'network_nag', true );
2895
2896
		// For firing one-off events (notices) immediately after activation
2897
		set_transient( 'activated_jetpack', true, .1 * MINUTE_IN_SECONDS );
2898
2899
		update_option( 'jetpack_activation_source', self::get_activation_source( wp_get_referer() ) );
2900
2901
		Jetpack::plugin_initialize();
2902
	}
2903
2904
	public static function get_activation_source( $referer_url ) {
2905
2906
		if ( defined( 'WP_CLI' ) && WP_CLI ) {
2907
			return array( 'wp-cli', null );
2908
		}
2909
2910
		$referer = parse_url( $referer_url );
2911
2912
		$source_type = 'unknown';
2913
		$source_query = null;
2914
2915
		if ( ! is_array( $referer ) ) {
2916
			return array( $source_type, $source_query );
2917
		}
2918
2919
		$plugins_path = parse_url( admin_url( 'plugins.php' ), PHP_URL_PATH );
2920
		$plugins_install_path = parse_url( admin_url( 'plugin-install.php' ), PHP_URL_PATH );// /wp-admin/plugin-install.php
2921
2922
		if ( isset( $referer['query'] ) ) {
2923
			parse_str( $referer['query'], $query_parts );
2924
		} else {
2925
			$query_parts = array();
2926
		}
2927
2928
		if ( $plugins_path === $referer['path'] ) {
2929
			$source_type = 'list';
2930
		} elseif ( $plugins_install_path === $referer['path'] ) {
2931
			$tab = isset( $query_parts['tab'] ) ? $query_parts['tab'] : 'featured';
2932
			switch( $tab ) {
2933
				case 'popular':
2934
					$source_type = 'popular';
2935
					break;
2936
				case 'recommended':
2937
					$source_type = 'recommended';
2938
					break;
2939
				case 'favorites':
2940
					$source_type = 'favorites';
2941
					break;
2942
				case 'search':
2943
					$source_type = 'search-' . ( isset( $query_parts['type'] ) ? $query_parts['type'] : 'term' );
2944
					$source_query = isset( $query_parts['s'] ) ? $query_parts['s'] : null;
2945
					break;
2946
				default:
2947
					$source_type = 'featured';
2948
			}
2949
		}
2950
2951
		return array( $source_type, $source_query );
2952
	}
2953
2954
	/**
2955
	 * Runs before bumping version numbers up to a new version
2956
	 * @param  string $version    Version:timestamp
2957
	 * @param  string $old_version Old Version:timestamp or false if not set yet.
2958
	 * @return null              [description]
2959
	 */
2960
	public static function do_version_bump( $version, $old_version ) {
2961
2962
		if ( ! $old_version ) { // For new sites
2963
			// Setting up jetpack manage
2964
			Jetpack::activate_manage();
2965
		}
2966
	}
2967
2968
	/**
2969
	 * Sets the internal version number and activation state.
2970
	 * @static
2971
	 */
2972
	public static function plugin_initialize() {
2973
		if ( ! Jetpack_Options::get_option( 'activated' ) ) {
2974
			Jetpack_Options::update_option( 'activated', 2 );
2975
		}
2976
2977 View Code Duplication
		if ( ! Jetpack_Options::get_option( 'version' ) ) {
2978
			$version = $old_version = JETPACK__VERSION . ':' . time();
2979
			/** This action is documented in class.jetpack.php */
2980
			do_action( 'updating_jetpack_version', $version, false );
2981
			Jetpack_Options::update_options( compact( 'version', 'old_version' ) );
2982
		}
2983
2984
		Jetpack::load_modules();
2985
2986
		Jetpack_Options::delete_option( 'do_activate' );
2987
		Jetpack_Options::delete_option( 'dismissed_connection_banner' );
2988
	}
2989
2990
	/**
2991
	 * Removes all connection options
2992
	 * @static
2993
	 */
2994
	public static function plugin_deactivation( ) {
2995
		require_once( ABSPATH . '/wp-admin/includes/plugin.php' );
2996
		if( is_plugin_active_for_network( 'jetpack/jetpack.php' ) ) {
2997
			Jetpack_Network::init()->deactivate();
2998
		} else {
2999
			Jetpack::disconnect( false );
3000
			//Jetpack_Heartbeat::init()->deactivate();
3001
		}
3002
	}
3003
3004
	/**
3005
	 * Disconnects from the Jetpack servers.
3006
	 * Forgets all connection details and tells the Jetpack servers to do the same.
3007
	 * @static
3008
	 */
3009
	public static function disconnect( $update_activated_state = true ) {
3010
		wp_clear_scheduled_hook( 'jetpack_clean_nonces' );
3011
		Jetpack::clean_nonces( true );
3012
3013
		// If the site is in an IDC because sync is not allowed,
3014
		// let's make sure to not disconnect the production site.
3015
		if ( ! self::validate_sync_error_idc_option() ) {
3016
			JetpackTracking::record_user_event( 'disconnect_site', array() );
3017
			Jetpack::load_xml_rpc_client();
3018
			$xml = new Jetpack_IXR_Client();
3019
			$xml->query( 'jetpack.deregister' );
3020
		}
3021
3022
		Jetpack_Options::delete_option(
3023
			array(
3024
				'blog_token',
3025
				'user_token',
3026
				'user_tokens',
3027
				'master_user',
3028
				'time_diff',
3029
				'fallback_no_verify_ssl_certs',
3030
			)
3031
		);
3032
3033
		Jetpack_IDC::clear_all_idc_options();
3034
		Jetpack_Options::delete_raw_option( 'jetpack_secrets' );
3035
3036
		if ( $update_activated_state ) {
3037
			Jetpack_Options::update_option( 'activated', 4 );
3038
		}
3039
3040
		if ( $jetpack_unique_connection = Jetpack_Options::get_option( 'unique_connection' ) ) {
3041
			// Check then record unique disconnection if site has never been disconnected previously
3042
			if ( - 1 == $jetpack_unique_connection['disconnected'] ) {
3043
				$jetpack_unique_connection['disconnected'] = 1;
3044
			} else {
3045
				if ( 0 == $jetpack_unique_connection['disconnected'] ) {
3046
					//track unique disconnect
3047
					$jetpack = Jetpack::init();
3048
3049
					$jetpack->stat( 'connections', 'unique-disconnect' );
3050
					$jetpack->do_stats( 'server_side' );
3051
				}
3052
				// increment number of times disconnected
3053
				$jetpack_unique_connection['disconnected'] += 1;
3054
			}
3055
3056
			Jetpack_Options::update_option( 'unique_connection', $jetpack_unique_connection );
3057
		}
3058
3059
		// Delete cached connected user data
3060
		$transient_key = "jetpack_connected_user_data_" . get_current_user_id();
3061
		delete_transient( $transient_key );
3062
3063
		// Delete all the sync related data. Since it could be taking up space.
3064
		require_once JETPACK__PLUGIN_DIR . 'sync/class.jetpack-sync-sender.php';
3065
		Jetpack_Sync_Sender::get_instance()->uninstall();
3066
3067
		// Disable the Heartbeat cron
3068
		Jetpack_Heartbeat::init()->deactivate();
3069
	}
3070
3071
	/**
3072
	 * Unlinks the current user from the linked WordPress.com user
3073
	 */
3074
	public static function unlink_user( $user_id = null ) {
3075
		if ( ! $tokens = Jetpack_Options::get_option( 'user_tokens' ) )
3076
			return false;
3077
3078
		$user_id = empty( $user_id ) ? get_current_user_id() : intval( $user_id );
3079
3080
		if ( Jetpack_Options::get_option( 'master_user' ) == $user_id )
3081
			return false;
3082
3083
		if ( ! isset( $tokens[ $user_id ] ) )
3084
			return false;
3085
3086
		Jetpack::load_xml_rpc_client();
3087
		$xml = new Jetpack_IXR_Client( compact( 'user_id' ) );
3088
		$xml->query( 'jetpack.unlink_user', $user_id );
3089
3090
		unset( $tokens[ $user_id ] );
3091
3092
		Jetpack_Options::update_option( 'user_tokens', $tokens );
3093
3094
		/**
3095
		 * Fires after the current user has been unlinked from WordPress.com.
3096
		 *
3097
		 * @since 4.1.0
3098
		 *
3099
		 * @param int $user_id The current user's ID.
3100
		 */
3101
		do_action( 'jetpack_unlinked_user', $user_id );
3102
3103
		return true;
3104
	}
3105
3106
	/**
3107
	 * Attempts Jetpack registration.  If it fail, a state flag is set: @see ::admin_page_load()
3108
	 */
3109
	public static function try_registration() {
3110
		// Let's get some testing in beta versions and such.
3111
		if ( self::is_development_version() && defined( 'PHP_URL_HOST' ) ) {
3112
			// Before attempting to connect, let's make sure that the domains are viable.
3113
			$domains_to_check = array_unique( array(
3114
				'siteurl' => parse_url( get_site_url(), PHP_URL_HOST ),
3115
				'homeurl' => parse_url( get_home_url(), PHP_URL_HOST ),
3116
			) );
3117
			foreach ( $domains_to_check as $domain ) {
3118
				$result = Jetpack_Data::is_usable_domain( $domain );
3119
				if ( is_wp_error( $result ) ) {
3120
					return $result;
3121
				}
3122
			}
3123
		}
3124
3125
		$result = Jetpack::register();
3126
3127
		// If there was an error with registration and the site was not registered, record this so we can show a message.
3128
		if ( ! $result || is_wp_error( $result ) ) {
3129
			return $result;
3130
		} else {
3131
			return true;
3132
		}
3133
	}
3134
3135
	/**
3136
	 * Tracking an internal event log. Try not to put too much chaff in here.
3137
	 *
3138
	 * [Everyone Loves a Log!](https://www.youtube.com/watch?v=2C7mNr5WMjA)
3139
	 */
3140
	public static function log( $code, $data = null ) {
3141
		// only grab the latest 200 entries
3142
		$log = array_slice( Jetpack_Options::get_option( 'log', array() ), -199, 199 );
3143
3144
		// Append our event to the log
3145
		$log_entry = array(
3146
			'time'    => time(),
3147
			'user_id' => get_current_user_id(),
3148
			'blog_id' => Jetpack_Options::get_option( 'id' ),
3149
			'code'    => $code,
3150
		);
3151
		// Don't bother storing it unless we've got some.
3152
		if ( ! is_null( $data ) ) {
3153
			$log_entry['data'] = $data;
3154
		}
3155
		$log[] = $log_entry;
3156
3157
		// Try add_option first, to make sure it's not autoloaded.
3158
		// @todo: Add an add_option method to Jetpack_Options
3159
		if ( ! add_option( 'jetpack_log', $log, null, 'no' ) ) {
3160
			Jetpack_Options::update_option( 'log', $log );
3161
		}
3162
3163
		/**
3164
		 * Fires when Jetpack logs an internal event.
3165
		 *
3166
		 * @since 3.0.0
3167
		 *
3168
		 * @param array $log_entry {
3169
		 *	Array of details about the log entry.
3170
		 *
3171
		 *	@param string time Time of the event.
3172
		 *	@param int user_id ID of the user who trigerred the event.
3173
		 *	@param int blog_id Jetpack Blog ID.
3174
		 *	@param string code Unique name for the event.
3175
		 *	@param string data Data about the event.
3176
		 * }
3177
		 */
3178
		do_action( 'jetpack_log_entry', $log_entry );
3179
	}
3180
3181
	/**
3182
	 * Get the internal event log.
3183
	 *
3184
	 * @param $event (string) - only return the specific log events
3185
	 * @param $num   (int)    - get specific number of latest results, limited to 200
3186
	 *
3187
	 * @return array of log events || WP_Error for invalid params
3188
	 */
3189
	public static function get_log( $event = false, $num = false ) {
3190
		if ( $event && ! is_string( $event ) ) {
3191
			return new WP_Error( __( 'First param must be string or empty', 'jetpack' ) );
3192
		}
3193
3194
		if ( $num && ! is_numeric( $num ) ) {
3195
			return new WP_Error( __( 'Second param must be numeric or empty', 'jetpack' ) );
3196
		}
3197
3198
		$entire_log = Jetpack_Options::get_option( 'log', array() );
3199
3200
		// If nothing set - act as it did before, otherwise let's start customizing the output
3201
		if ( ! $num && ! $event ) {
3202
			return $entire_log;
3203
		} else {
3204
			$entire_log = array_reverse( $entire_log );
3205
		}
3206
3207
		$custom_log_output = array();
3208
3209
		if ( $event ) {
3210
			foreach ( $entire_log as $log_event ) {
3211
				if ( $event == $log_event[ 'code' ] ) {
3212
					$custom_log_output[] = $log_event;
3213
				}
3214
			}
3215
		} else {
3216
			$custom_log_output = $entire_log;
3217
		}
3218
3219
		if ( $num ) {
3220
			$custom_log_output = array_slice( $custom_log_output, 0, $num );
3221
		}
3222
3223
		return $custom_log_output;
3224
	}
3225
3226
	/**
3227
	 * Log modification of important settings.
3228
	 */
3229
	public static function log_settings_change( $option, $old_value, $value ) {
3230
		switch( $option ) {
3231
			case 'jetpack_sync_non_public_post_stati':
3232
				self::log( $option, $value );
3233
				break;
3234
		}
3235
	}
3236
3237
	/**
3238
	 * Return stat data for WPCOM sync
3239
	 */
3240
	public static function get_stat_data( $encode = true, $extended = true ) {
3241
		$data = Jetpack_Heartbeat::generate_stats_array();
3242
3243
		if ( $extended ) {
3244
			$additional_data = self::get_additional_stat_data();
3245
			$data = array_merge( $data, $additional_data );
3246
		}
3247
3248
		if ( $encode ) {
3249
			return json_encode( $data );
3250
		}
3251
3252
		return $data;
3253
	}
3254
3255
	/**
3256
	 * Get additional stat data to sync to WPCOM
3257
	 */
3258
	public static function get_additional_stat_data( $prefix = '' ) {
3259
		$return["{$prefix}themes"]         = Jetpack::get_parsed_theme_data();
3260
		$return["{$prefix}plugins-extra"]  = Jetpack::get_parsed_plugin_data();
3261
		$return["{$prefix}users"]          = (int) Jetpack::get_site_user_count();
3262
		$return["{$prefix}site-count"]     = 0;
3263
3264
		if ( function_exists( 'get_blog_count' ) ) {
3265
			$return["{$prefix}site-count"] = get_blog_count();
3266
		}
3267
		return $return;
3268
	}
3269
3270
	private static function get_site_user_count() {
3271
		global $wpdb;
3272
3273
		if ( function_exists( 'wp_is_large_network' ) ) {
3274
			if ( wp_is_large_network( 'users' ) ) {
3275
				return -1; // Not a real value but should tell us that we are dealing with a large network.
3276
			}
3277
		}
3278 View Code Duplication
		if ( false === ( $user_count = get_transient( 'jetpack_site_user_count' ) ) ) {
3279
			// It wasn't there, so regenerate the data and save the transient
3280
			$user_count = $wpdb->get_var( "SELECT COUNT(*) FROM $wpdb->usermeta WHERE meta_key = '{$wpdb->prefix}capabilities'" );
3281
			set_transient( 'jetpack_site_user_count', $user_count, DAY_IN_SECONDS );
3282
		}
3283
		return $user_count;
3284
	}
3285
3286
	/* Admin Pages */
3287
3288
	function admin_init() {
3289
		// If the plugin is not connected, display a connect message.
3290
		if (
3291
			// the plugin was auto-activated and needs its candy
3292
			Jetpack_Options::get_option_and_ensure_autoload( 'do_activate', '0' )
3293
		||
3294
			// the plugin is active, but was never activated.  Probably came from a site-wide network activation
3295
			! Jetpack_Options::get_option( 'activated' )
3296
		) {
3297
			Jetpack::plugin_initialize();
3298
		}
3299
3300
		if ( ! Jetpack::is_active() && ! Jetpack::is_development_mode() ) {
3301
			Jetpack_Connection_Banner::init();
3302
		} elseif ( false === Jetpack_Options::get_option( 'fallback_no_verify_ssl_certs' ) ) {
3303
			// Upgrade: 1.1 -> 1.1.1
3304
			// Check and see if host can verify the Jetpack servers' SSL certificate
3305
			$args = array();
3306
			Jetpack_Client::_wp_remote_request(
3307
				Jetpack::fix_url_for_bad_hosts( Jetpack::api_url( 'test' ) ),
3308
				$args,
3309
				true
3310
			);
3311
		} else if ( $this->can_display_jetpack_manage_notice() && ! Jetpack_Options::get_option( 'dismissed_manage_banner' ) ) {
3312
			// Show the notice on the Dashboard only for now
3313
			add_action( 'load-index.php', array( $this, 'prepare_manage_jetpack_notice' ) );
3314
		}
3315
3316
		if ( current_user_can( 'manage_options' ) && 'AUTO' == JETPACK_CLIENT__HTTPS && ! self::permit_ssl() ) {
3317
			add_action( 'jetpack_notices', array( $this, 'alert_auto_ssl_fail' ) );
3318
		}
3319
3320
		add_action( 'load-plugins.php', array( $this, 'intercept_plugin_error_scrape_init' ) );
3321
		add_action( 'admin_enqueue_scripts', array( $this, 'admin_menu_css' ) );
3322
		add_filter( 'plugin_action_links_' . plugin_basename( JETPACK__PLUGIN_DIR . 'jetpack.php' ), array( $this, 'plugin_action_links' ) );
3323
3324
		if ( Jetpack::is_active() || Jetpack::is_development_mode() ) {
3325
			// Artificially throw errors in certain whitelisted cases during plugin activation
3326
			add_action( 'activate_plugin', array( $this, 'throw_error_on_activate_plugin' ) );
3327
		}
3328
3329
		// Jetpack Manage Activation Screen from .com
3330
		Jetpack::module_configuration_activation_screen( 'manage', array( $this, 'manage_activate_screen' ) );
3331
3332
		// Add custom column in wp-admin/users.php to show whether user is linked.
3333
		add_filter( 'manage_users_columns',       array( $this, 'jetpack_icon_user_connected' ) );
3334
		add_action( 'manage_users_custom_column', array( $this, 'jetpack_show_user_connected_icon' ), 10, 3 );
3335
		add_action( 'admin_print_styles',         array( $this, 'jetpack_user_col_style' ) );
3336
	}
3337
3338
	function admin_body_class( $admin_body_class = '' ) {
3339
		$classes = explode( ' ', trim( $admin_body_class ) );
3340
3341
		$classes[] = self::is_active() ? 'jetpack-connected' : 'jetpack-disconnected';
3342
3343
		$admin_body_class = implode( ' ', array_unique( $classes ) );
3344
		return " $admin_body_class ";
3345
	}
3346
3347
	static function add_jetpack_pagestyles( $admin_body_class = '' ) {
3348
		return $admin_body_class . ' jetpack-pagestyles ';
3349
	}
3350
3351
	/**
3352
	 * Call this function if you want the Big Jetpack Manage Notice to show up.
3353
	 *
3354
	 * @return null
3355
	 */
3356
	function prepare_manage_jetpack_notice() {
3357
3358
		add_action( 'admin_print_styles', array( $this, 'admin_banner_styles' ) );
3359
		add_action( 'admin_notices', array( $this, 'admin_jetpack_manage_notice' ) );
3360
	}
3361
3362
	function manage_activate_screen() {
3363
		include ( JETPACK__PLUGIN_DIR . 'modules/manage/activate-admin.php' );
3364
	}
3365
	/**
3366
	 * Sometimes a plugin can activate without causing errors, but it will cause errors on the next page load.
3367
	 * This function artificially throws errors for such cases (whitelisted).
3368
	 *
3369
	 * @param string $plugin The activated plugin.
3370
	 */
3371
	function throw_error_on_activate_plugin( $plugin ) {
3372
		$active_modules = Jetpack::get_active_modules();
3373
3374
		// The Shortlinks module and the Stats plugin conflict, but won't cause errors on activation because of some function_exists() checks.
3375
		if ( function_exists( 'stats_get_api_key' ) && in_array( 'shortlinks', $active_modules ) ) {
3376
			$throw = false;
3377
3378
			// Try and make sure it really was the stats plugin
3379
			if ( ! class_exists( 'ReflectionFunction' ) ) {
3380
				if ( 'stats.php' == basename( $plugin ) ) {
3381
					$throw = true;
3382
				}
3383
			} else {
3384
				$reflection = new ReflectionFunction( 'stats_get_api_key' );
3385
				if ( basename( $plugin ) == basename( $reflection->getFileName() ) ) {
3386
					$throw = true;
3387
				}
3388
			}
3389
3390
			if ( $throw ) {
3391
				trigger_error( sprintf( __( 'Jetpack contains the most recent version of the old &#8220;%1$s&#8221; plugin.', 'jetpack' ), 'WordPress.com Stats' ), E_USER_ERROR );
3392
			}
3393
		}
3394
	}
3395
3396
	function intercept_plugin_error_scrape_init() {
3397
		add_action( 'check_admin_referer', array( $this, 'intercept_plugin_error_scrape' ), 10, 2 );
3398
	}
3399
3400
	function intercept_plugin_error_scrape( $action, $result ) {
3401
		if ( ! $result ) {
3402
			return;
3403
		}
3404
3405
		foreach ( $this->plugins_to_deactivate as $deactivate_me ) {
3406
			if ( "plugin-activation-error_{$deactivate_me[0]}" == $action ) {
3407
				Jetpack::bail_on_activation( sprintf( __( 'Jetpack contains the most recent version of the old &#8220;%1$s&#8221; plugin.', 'jetpack' ), $deactivate_me[1] ), false );
3408
			}
3409
		}
3410
	}
3411
3412
	function add_remote_request_handlers() {
3413
		add_action( 'wp_ajax_nopriv_jetpack_upload_file', array( $this, 'remote_request_handlers' ) );
3414
		add_action( 'wp_ajax_nopriv_jetpack_update_file', array( $this, 'remote_request_handlers' ) );
3415
	}
3416
3417
	function remote_request_handlers() {
3418
		$action = current_filter();
3419
3420
		switch ( current_filter() ) {
3421
		case 'wp_ajax_nopriv_jetpack_upload_file' :
3422
			$response = $this->upload_handler();
3423
			break;
3424
3425
		case 'wp_ajax_nopriv_jetpack_update_file' :
3426
			$response = $this->upload_handler( true );
3427
			break;
3428
		default :
3429
			$response = new Jetpack_Error( 'unknown_handler', 'Unknown Handler', 400 );
3430
			break;
3431
		}
3432
3433
		if ( ! $response ) {
3434
			$response = new Jetpack_Error( 'unknown_error', 'Unknown Error', 400 );
3435
		}
3436
3437
		if ( is_wp_error( $response ) ) {
3438
			$status_code       = $response->get_error_data();
3439
			$error             = $response->get_error_code();
3440
			$error_description = $response->get_error_message();
3441
3442
			if ( ! is_int( $status_code ) ) {
3443
				$status_code = 400;
3444
			}
3445
3446
			status_header( $status_code );
3447
			die( json_encode( (object) compact( 'error', 'error_description' ) ) );
3448
		}
3449
3450
		status_header( 200 );
3451
		if ( true === $response ) {
3452
			exit;
3453
		}
3454
3455
		die( json_encode( (object) $response ) );
3456
	}
3457
3458
	/**
3459
	 * Uploads a file gotten from the global $_FILES.
3460
	 * If `$update_media_item` is true and `post_id` is defined
3461
	 * the attachment file of the media item (gotten through of the post_id)
3462
	 * will be updated instead of add a new one.
3463
	 *
3464
	 * @param  boolean $update_media_item - update media attachment
3465
	 * @return array - An array describing the uploadind files process
3466
	 */
3467
	function upload_handler( $update_media_item = false ) {
3468
		if ( 'POST' !== strtoupper( $_SERVER['REQUEST_METHOD'] ) ) {
3469
			return new Jetpack_Error( 405, get_status_header_desc( 405 ), 405 );
3470
		}
3471
3472
		$user = wp_authenticate( '', '' );
3473
		if ( ! $user || is_wp_error( $user ) ) {
3474
			return new Jetpack_Error( 403, get_status_header_desc( 403 ), 403 );
3475
		}
3476
3477
		wp_set_current_user( $user->ID );
3478
3479
		if ( ! current_user_can( 'upload_files' ) ) {
3480
			return new Jetpack_Error( 'cannot_upload_files', 'User does not have permission to upload files', 403 );
3481
		}
3482
3483
		if ( empty( $_FILES ) ) {
3484
			return new Jetpack_Error( 'no_files_uploaded', 'No files were uploaded: nothing to process', 400 );
3485
		}
3486
3487
		foreach ( array_keys( $_FILES ) as $files_key ) {
3488
			if ( ! isset( $_POST["_jetpack_file_hmac_{$files_key}"] ) ) {
3489
				return new Jetpack_Error( 'missing_hmac', 'An HMAC for one or more files is missing', 400 );
3490
			}
3491
		}
3492
3493
		$media_keys = array_keys( $_FILES['media'] );
3494
3495
		$token = Jetpack_Data::get_access_token( get_current_user_id() );
3496
		if ( ! $token || is_wp_error( $token ) ) {
3497
			return new Jetpack_Error( 'unknown_token', 'Unknown Jetpack token', 403 );
3498
		}
3499
3500
		$uploaded_files = array();
3501
		$global_post    = isset( $GLOBALS['post'] ) ? $GLOBALS['post'] : null;
3502
		unset( $GLOBALS['post'] );
3503
		foreach ( $_FILES['media']['name'] as $index => $name ) {
3504
			$file = array();
3505
			foreach ( $media_keys as $media_key ) {
3506
				$file[$media_key] = $_FILES['media'][$media_key][$index];
3507
			}
3508
3509
			list( $hmac_provided, $salt ) = explode( ':', $_POST['_jetpack_file_hmac_media'][$index] );
3510
3511
			$hmac_file = hash_hmac_file( 'sha1', $file['tmp_name'], $salt . $token->secret );
3512
			if ( $hmac_provided !== $hmac_file ) {
3513
				$uploaded_files[$index] = (object) array( 'error' => 'invalid_hmac', 'error_description' => 'The corresponding HMAC for this file does not match' );
3514
				continue;
3515
			}
3516
3517
			$_FILES['.jetpack.upload.'] = $file;
3518
			$post_id = isset( $_POST['post_id'][$index] ) ? absint( $_POST['post_id'][$index] ) : 0;
3519
			if ( ! current_user_can( 'edit_post', $post_id ) ) {
3520
				$post_id = 0;
3521
			}
3522
3523
			if ( $update_media_item ) {
3524
				if ( ! isset( $post_id ) || $post_id === 0 ) {
3525
					return new Jetpack_Error( 'invalid_input', 'Media ID must be defined.', 400 );
3526
				}
3527
3528
				$media_array = $_FILES['media'];
3529
3530
				$file_array['name'] = $media_array['name'][0];
3531
				$file_array['type'] = $media_array['type'][0];
3532
				$file_array['tmp_name'] = $media_array['tmp_name'][0];
3533
				$file_array['error'] = $media_array['error'][0];
3534
				$file_array['size'] = $media_array['size'][0];
3535
3536
				$edited_media_item = Jetpack_Media::edit_media_file( $post_id, $file_array );
3537
3538
				if ( is_wp_error( $edited_media_item ) ) {
3539
					return $edited_media_item;
3540
				}
3541
3542
				$response = (object) array(
3543
					'id'   => (string) $post_id,
3544
					'file' => (string) $edited_media_item->post_title,
3545
					'url'  => (string) wp_get_attachment_url( $post_id ),
3546
					'type' => (string) $edited_media_item->post_mime_type,
3547
					'meta' => (array) wp_get_attachment_metadata( $post_id ),
3548
				);
3549
3550
				return (array) array( $response );
3551
			}
3552
3553
			$attachment_id = media_handle_upload(
3554
				'.jetpack.upload.',
3555
				$post_id,
3556
				array(),
3557
				array(
3558
					'action' => 'jetpack_upload_file',
3559
				)
3560
			);
3561
3562
			if ( ! $attachment_id ) {
3563
				$uploaded_files[$index] = (object) array( 'error' => 'unknown', 'error_description' => 'An unknown problem occurred processing the upload on the Jetpack site' );
3564
			} elseif ( is_wp_error( $attachment_id ) ) {
3565
				$uploaded_files[$index] = (object) array( 'error' => 'attachment_' . $attachment_id->get_error_code(), 'error_description' => $attachment_id->get_error_message() );
3566
			} else {
3567
				$attachment = get_post( $attachment_id );
3568
				$uploaded_files[$index] = (object) array(
3569
					'id'   => (string) $attachment_id,
3570
					'file' => $attachment->post_title,
3571
					'url'  => wp_get_attachment_url( $attachment_id ),
3572
					'type' => $attachment->post_mime_type,
3573
					'meta' => wp_get_attachment_metadata( $attachment_id ),
3574
				);
3575
				// Zip files uploads are not supported unless they are done for installation purposed
3576
				// lets delete them in case something goes wrong in this whole process
3577
				if ( 'application/zip' === $attachment->post_mime_type ) {
3578
					// Schedule a cleanup for 2 hours from now in case of failed install.
3579
					wp_schedule_single_event( time() + 2 * HOUR_IN_SECONDS, 'upgrader_scheduled_cleanup', array( $attachment_id ) );
3580
				}
3581
			}
3582
		}
3583
		if ( ! is_null( $global_post ) ) {
3584
			$GLOBALS['post'] = $global_post;
3585
		}
3586
3587
		return $uploaded_files;
3588
	}
3589
3590
	/**
3591
	 * Add help to the Jetpack page
3592
	 *
3593
	 * @since Jetpack (1.2.3)
3594
	 * @return false if not the Jetpack page
3595
	 */
3596
	function admin_help() {
3597
		$current_screen = get_current_screen();
3598
3599
		// Overview
3600
		$current_screen->add_help_tab(
3601
			array(
3602
				'id'		=> 'home',
3603
				'title'		=> __( 'Home', 'jetpack' ),
3604
				'content'	=>
3605
					'<p><strong>' . __( 'Jetpack by WordPress.com', 'jetpack' ) . '</strong></p>' .
3606
					'<p>' . __( 'Jetpack supercharges your self-hosted WordPress site with the awesome cloud power of WordPress.com.', 'jetpack' ) . '</p>' .
3607
					'<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>',
3608
			)
3609
		);
3610
3611
		// Screen Content
3612
		if ( current_user_can( 'manage_options' ) ) {
3613
			$current_screen->add_help_tab(
3614
				array(
3615
					'id'		=> 'settings',
3616
					'title'		=> __( 'Settings', 'jetpack' ),
3617
					'content'	=>
3618
						'<p><strong>' . __( 'Jetpack by WordPress.com',                                              'jetpack' ) . '</strong></p>' .
3619
						'<p>' . __( 'You can activate or deactivate individual Jetpack modules to suit your needs.', 'jetpack' ) . '</p>' .
3620
						'<ol>' .
3621
							'<li>' . __( 'Each module has an Activate or Deactivate link so you can toggle one individually.',														'jetpack' ) . '</li>' .
3622
							'<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>' .
3623
						'</ol>' .
3624
						'<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>'
3625
				)
3626
			);
3627
		}
3628
3629
		// Help Sidebar
3630
		$current_screen->set_help_sidebar(
3631
			'<p><strong>' . __( 'For more information:', 'jetpack' ) . '</strong></p>' .
3632
			'<p><a href="https://jetpack.com/faq/" target="_blank">'     . __( 'Jetpack FAQ',     'jetpack' ) . '</a></p>' .
3633
			'<p><a href="https://jetpack.com/support/" target="_blank">' . __( 'Jetpack Support', 'jetpack' ) . '</a></p>' .
3634
			'<p><a href="' . Jetpack::admin_url( array( 'page' => 'jetpack-debugger' )  ) .'">' . __( 'Jetpack Debugging Center', 'jetpack' ) . '</a></p>'
3635
		);
3636
	}
3637
3638
	function admin_menu_css() {
3639
		wp_enqueue_style( 'jetpack-icons' );
3640
	}
3641
3642
	function admin_menu_order() {
3643
		return true;
3644
	}
3645
3646 View Code Duplication
	function jetpack_menu_order( $menu_order ) {
3647
		$jp_menu_order = array();
3648
3649
		foreach ( $menu_order as $index => $item ) {
3650
			if ( $item != 'jetpack' ) {
3651
				$jp_menu_order[] = $item;
3652
			}
3653
3654
			if ( $index == 0 ) {
3655
				$jp_menu_order[] = 'jetpack';
3656
			}
3657
		}
3658
3659
		return $jp_menu_order;
3660
	}
3661
3662
	function admin_head() {
3663 View Code Duplication
		if ( isset( $_GET['configure'] ) && Jetpack::is_module( $_GET['configure'] ) && current_user_can( 'manage_options' ) )
3664
			/** This action is documented in class.jetpack-admin-page.php */
3665
			do_action( 'jetpack_module_configuration_head_' . $_GET['configure'] );
3666
	}
3667
3668
	function admin_banner_styles() {
3669
		$min = ( defined( 'SCRIPT_DEBUG' ) && SCRIPT_DEBUG ) ? '' : '.min';
3670
3671 View Code Duplication
		if ( ! wp_style_is( 'jetpack-dops-style' ) ) {
3672
			wp_register_style(
3673
				'jetpack-dops-style',
3674
				plugins_url( '_inc/build/admin.dops-style.css', JETPACK__PLUGIN_FILE ),
3675
				array(),
3676
				JETPACK__VERSION
3677
			);
3678
		}
3679
3680
		wp_enqueue_style(
3681
			'jetpack',
3682
			plugins_url( "css/jetpack-banners{$min}.css", JETPACK__PLUGIN_FILE ),
3683
			array( 'jetpack-dops-style' ),
3684
			 JETPACK__VERSION . '-20121016'
3685
		);
3686
		wp_style_add_data( 'jetpack', 'rtl', 'replace' );
3687
		wp_style_add_data( 'jetpack', 'suffix', $min );
3688
	}
3689
3690
	function plugin_action_links( $actions ) {
3691
3692
		$jetpack_home = array( 'jetpack-home' => sprintf( '<a href="%s">%s</a>', Jetpack::admin_url( 'page=jetpack' ), __( 'Jetpack', 'jetpack' ) ) );
3693
3694
		if( current_user_can( 'jetpack_manage_modules' ) && ( Jetpack::is_active() || Jetpack::is_development_mode() ) ) {
3695
			return array_merge(
3696
				$jetpack_home,
3697
				array( 'settings' => sprintf( '<a href="%s">%s</a>', Jetpack::admin_url( 'page=jetpack#/settings' ), __( 'Settings', 'jetpack' ) ) ),
3698
				array( 'support' => sprintf( '<a href="%s">%s</a>', Jetpack::admin_url( 'page=jetpack-debugger '), __( 'Support', 'jetpack' ) ) ),
3699
				$actions
3700
				);
3701
			}
3702
3703
		return array_merge( $jetpack_home, $actions );
3704
	}
3705
3706
	/**
3707
	 * This is the first banner
3708
	 * It should be visible only to user that can update the option
3709
	 * Are not connected
3710
	 *
3711
	 * @return null
3712
	 */
3713
	function admin_jetpack_manage_notice() {
3714
		$screen = get_current_screen();
3715
3716
		// Don't show the connect notice on the jetpack settings page.
3717
		if ( ! in_array( $screen->base, array( 'dashboard' ) ) || $screen->is_network || $screen->action ) {
3718
			return;
3719
		}
3720
3721
		$opt_out_url = $this->opt_out_jetpack_manage_url();
3722
		$opt_in_url  = $this->opt_in_jetpack_manage_url();
3723
		/**
3724
		 * I think it would be great to have different wordsing depending on where you are
3725
		 * for example if we show the notice on dashboard and a different one if we show it on Plugins screen
3726
		 * etc..
3727
		 */
3728
3729
		?>
3730
		<div id="message" class="updated jp-banner">
3731
				<a href="<?php echo esc_url( $opt_out_url ); ?>" class="notice-dismiss" title="<?php esc_attr_e( 'Dismiss this notice', 'jetpack' ); ?>"></a>
3732
				<div class="jp-banner__description-container">
3733
					<h2 class="jp-banner__header"><?php esc_html_e( 'Jetpack Centralized Site Management', 'jetpack' ); ?></h2>
3734
					<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>
3735
					<p class="jp-banner__button-container">
3736
						<a href="<?php echo esc_url( $opt_in_url ); ?>" class="button button-primary" id="wpcom-connect"><?php _e( 'Activate Jetpack Manage', 'jetpack' ); ?></a>
3737
						<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>
3738
					</p>
3739
				</div>
3740
		</div>
3741
		<?php
3742
	}
3743
3744
	/**
3745
	 * Returns the url that the user clicks to remove the notice for the big banner
3746
	 * @return string
3747
	 */
3748
	function opt_out_jetpack_manage_url() {
3749
		$referer = '&_wp_http_referer=' . add_query_arg( '_wp_http_referer', null );
3750
		return wp_nonce_url( Jetpack::admin_url( 'jetpack-notice=jetpack-manage-opt-out' . $referer ), 'jetpack_manage_banner_opt_out' );
3751
	}
3752
	/**
3753
	 * Returns the url that the user clicks to opt in to Jetpack Manage
3754
	 * @return string
3755
	 */
3756
	function opt_in_jetpack_manage_url() {
3757
		return wp_nonce_url( Jetpack::admin_url( 'jetpack-notice=jetpack-manage-opt-in' ), 'jetpack_manage_banner_opt_in' );
3758
	}
3759
3760
	function opt_in_jetpack_manage_notice() {
3761
		?>
3762
		<div class="wrap">
3763
			<div id="message" class="jetpack-message is-opt-in">
3764
				<?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' ); ?>
3765
			</div>
3766
		</div>
3767
		<?php
3768
3769
	}
3770
	/**
3771
	 * Determines whether to show the notice of not true = display notice
3772
	 * @return bool
3773
	 */
3774
	function can_display_jetpack_manage_notice() {
3775
		// never display the notice to users that can't do anything about it anyways
3776
		if( ! current_user_can( 'jetpack_manage_modules' ) )
3777
			return false;
3778
3779
		// don't display if we are in development more
3780
		if( Jetpack::is_development_mode() ) {
3781
			return false;
3782
		}
3783
		// don't display if the site is private
3784
		if(  ! Jetpack_Options::get_option( 'public' ) )
3785
			return false;
3786
3787
		/**
3788
		 * Should the Jetpack Remote Site Management notice be displayed.
3789
		 *
3790
		 * @since 3.3.0
3791
		 *
3792
		 * @param bool ! self::is_module_active( 'manage' ) Is the Manage module inactive.
3793
		 */
3794
		return apply_filters( 'can_display_jetpack_manage_notice', ! self::is_module_active( 'manage' ) );
3795
	}
3796
3797
	/*
3798
	 * Registration flow:
3799
	 * 1 - ::admin_page_load() action=register
3800
	 * 2 - ::try_registration()
3801
	 * 3 - ::register()
3802
	 *     - Creates jetpack_register option containing two secrets and a timestamp
3803
	 *     - Calls https://jetpack.wordpress.com/jetpack.register/1/ with
3804
	 *       siteurl, home, gmt_offset, timezone_string, site_name, secret_1, secret_2, site_lang, timeout, stats_id
3805
	 *     - That request to jetpack.wordpress.com does not immediately respond.  It first makes a request BACK to this site's
3806
	 *       xmlrpc.php?for=jetpack: RPC method: jetpack.verifyRegistration, Parameters: secret_1
3807
	 *     - The XML-RPC request verifies secret_1, deletes both secrets and responds with: secret_2
3808
	 *     - https://jetpack.wordpress.com/jetpack.register/1/ verifies that XML-RPC response (secret_2) then finally responds itself with
3809
	 *       jetpack_id, jetpack_secret, jetpack_public
3810
	 *     - ::register() then stores jetpack_options: id => jetpack_id, blog_token => jetpack_secret
3811
	 * 4 - redirect to https://wordpress.com/start/jetpack-connect
3812
	 * 5 - user logs in with WP.com account
3813
	 * 6 - remote request to this site's xmlrpc.php with action remoteAuthorize, Jetpack_XMLRPC_Server->remote_authorize
3814
	 *		- Jetpack_Client_Server::authorize()
3815
	 *		- Jetpack_Client_Server::get_token()
3816
	 *		- GET https://jetpack.wordpress.com/jetpack.token/1/ with
3817
	 *        client_id, client_secret, grant_type, code, redirect_uri:action=authorize, state, scope, user_email, user_login
3818
	 *			- which responds with access_token, token_type, scope
3819
	 *		- Jetpack_Client_Server::authorize() stores jetpack_options: user_token => access_token.$user_id
3820
	 *		- Jetpack::activate_default_modules()
3821
	 *     		- Deactivates deprecated plugins
3822
	 *     		- Activates all default modules
3823
	 *		- Responds with either error, or 'connected' for new connection, or 'linked' for additional linked users
3824
	 * 7 - For a new connection, user selects a Jetpack plan on wordpress.com
3825
	 * 8 - User is redirected back to wp-admin/index.php?page=jetpack with state:message=authorized
3826
	 *     Done!
3827
	 */
3828
3829
	/**
3830
	 * Handles the page load events for the Jetpack admin page
3831
	 */
3832
	function admin_page_load() {
3833
		$error = false;
3834
3835
		// Make sure we have the right body class to hook stylings for subpages off of.
3836
		add_filter( 'admin_body_class', array( __CLASS__, 'add_jetpack_pagestyles' ) );
3837
3838
		if ( ! empty( $_GET['jetpack_restate'] ) ) {
3839
			// Should only be used in intermediate redirects to preserve state across redirects
3840
			Jetpack::restate();
3841
		}
3842
3843
		if ( isset( $_GET['connect_url_redirect'] ) ) {
3844
			// User clicked in the iframe to link their accounts
3845
			if ( ! Jetpack::is_user_connected() ) {
3846
				$connect_url = $this->build_connect_url( true, false, 'iframe' );
3847
				if ( isset( $_GET['notes_iframe'] ) )
3848
					$connect_url .= '&notes_iframe';
3849
				wp_redirect( $connect_url );
3850
				exit;
3851
			} else {
3852
				if ( ! isset( $_GET['calypso_env'] ) ) {
3853
					Jetpack::state( 'message', 'already_authorized' );
3854
					wp_safe_redirect( Jetpack::admin_url() );
3855
					exit;
3856
				} else {
3857
					$connect_url = $this->build_connect_url( true, false, 'iframe' );
3858
					$connect_url .= '&already_authorized=true';
3859
					wp_redirect( $connect_url );
3860
					exit;
3861
				}
3862
			}
3863
		}
3864
3865
3866
		if ( isset( $_GET['action'] ) ) {
3867
			switch ( $_GET['action'] ) {
3868
			case 'authorize':
3869
				if ( Jetpack::is_active() && Jetpack::is_user_connected() ) {
3870
					Jetpack::state( 'message', 'already_authorized' );
3871
					wp_safe_redirect( Jetpack::admin_url() );
3872
					exit;
3873
				}
3874
				Jetpack::log( 'authorize' );
3875
				$client_server = new Jetpack_Client_Server;
3876
				$client_server->client_authorize();
3877
				exit;
3878
			case 'register' :
3879
				if ( ! current_user_can( 'jetpack_connect' ) ) {
3880
					$error = 'cheatin';
3881
					break;
3882
				}
3883
				check_admin_referer( 'jetpack-register' );
3884
				Jetpack::log( 'register' );
3885
				Jetpack::maybe_set_version_option();
3886
				$registered = Jetpack::try_registration();
3887
				if ( is_wp_error( $registered ) ) {
3888
					$error = $registered->get_error_code();
3889
					Jetpack::state( 'error', $error );
3890
					Jetpack::state( 'error', $registered->get_error_message() );
3891
					JetpackTracking::record_user_event( 'jpc_register_fail', array(
3892
						'error_code' => $error,
3893
						'error_message' => $registered->get_error_message()
3894
					) );
3895
					break;
3896
				}
3897
3898
				$from = isset( $_GET['from'] ) ? $_GET['from'] : false;
3899
				$redirect = isset( $_GET['redirect'] ) ? $_GET['redirect'] : false;
3900
3901
				JetpackTracking::record_user_event( 'jpc_register_success', array(
3902
					'from' => $from
3903
				) );
3904
3905
				wp_redirect( $this->build_connect_url( true, $redirect, $from ) );
3906
				exit;
3907
			case 'activate' :
3908
				if ( ! current_user_can( 'jetpack_activate_modules' ) ) {
3909
					$error = 'cheatin';
3910
					break;
3911
				}
3912
3913
				$module = stripslashes( $_GET['module'] );
3914
				check_admin_referer( "jetpack_activate-$module" );
3915
				Jetpack::log( 'activate', $module );
3916
				Jetpack::activate_module( $module );
3917
				// The following two lines will rarely happen, as Jetpack::activate_module normally exits at the end.
3918
				wp_safe_redirect( Jetpack::admin_url( 'page=jetpack' ) );
3919
				exit;
3920
			case 'activate_default_modules' :
3921
				check_admin_referer( 'activate_default_modules' );
3922
				Jetpack::log( 'activate_default_modules' );
3923
				Jetpack::restate();
3924
				$min_version   = isset( $_GET['min_version'] ) ? $_GET['min_version'] : false;
3925
				$max_version   = isset( $_GET['max_version'] ) ? $_GET['max_version'] : false;
3926
				$other_modules = isset( $_GET['other_modules'] ) && is_array( $_GET['other_modules'] ) ? $_GET['other_modules'] : array();
3927
				Jetpack::activate_default_modules( $min_version, $max_version, $other_modules );
3928
				wp_safe_redirect( Jetpack::admin_url( 'page=jetpack' ) );
3929
				exit;
3930
			case 'disconnect' :
3931
				if ( ! current_user_can( 'jetpack_disconnect' ) ) {
3932
					$error = 'cheatin';
3933
					break;
3934
				}
3935
3936
				check_admin_referer( 'jetpack-disconnect' );
3937
				Jetpack::log( 'disconnect' );
3938
				Jetpack::disconnect();
3939
				wp_safe_redirect( Jetpack::admin_url( 'disconnected=true' ) );
3940
				exit;
3941
			case 'reconnect' :
3942
				if ( ! current_user_can( 'jetpack_reconnect' ) ) {
3943
					$error = 'cheatin';
3944
					break;
3945
				}
3946
3947
				check_admin_referer( 'jetpack-reconnect' );
3948
				Jetpack::log( 'reconnect' );
3949
				$this->disconnect();
3950
				wp_redirect( $this->build_connect_url( true, false, 'reconnect' ) );
3951
				exit;
3952 View Code Duplication
			case 'deactivate' :
3953
				if ( ! current_user_can( 'jetpack_deactivate_modules' ) ) {
3954
					$error = 'cheatin';
3955
					break;
3956
				}
3957
3958
				$modules = stripslashes( $_GET['module'] );
3959
				check_admin_referer( "jetpack_deactivate-$modules" );
3960
				foreach ( explode( ',', $modules ) as $module ) {
3961
					Jetpack::log( 'deactivate', $module );
3962
					Jetpack::deactivate_module( $module );
3963
					Jetpack::state( 'message', 'module_deactivated' );
3964
				}
3965
				Jetpack::state( 'module', $modules );
3966
				wp_safe_redirect( Jetpack::admin_url( 'page=jetpack' ) );
3967
				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...
3968
			case 'unlink' :
3969
				$redirect = isset( $_GET['redirect'] ) ? $_GET['redirect'] : '';
3970
				check_admin_referer( 'jetpack-unlink' );
3971
				Jetpack::log( 'unlink' );
3972
				$this->unlink_user();
3973
				Jetpack::state( 'message', 'unlinked' );
3974
				if ( 'sub-unlink' == $redirect ) {
3975
					wp_safe_redirect( admin_url() );
3976
				} else {
3977
					wp_safe_redirect( Jetpack::admin_url( array( 'page' => $redirect ) ) );
3978
				}
3979
				exit;
3980
			default:
3981
				/**
3982
				 * Fires when a Jetpack admin page is loaded with an unrecognized parameter.
3983
				 *
3984
				 * @since 2.6.0
3985
				 *
3986
				 * @param string sanitize_key( $_GET['action'] ) Unrecognized URL parameter.
3987
				 */
3988
				do_action( 'jetpack_unrecognized_action', sanitize_key( $_GET['action'] ) );
3989
			}
3990
		}
3991
3992
		if ( ! $error = $error ? $error : Jetpack::state( 'error' ) ) {
3993
			self::activate_new_modules( true );
3994
		}
3995
3996
		$message_code = Jetpack::state( 'message' );
3997
		if ( Jetpack::state( 'optin-manage' ) ) {
3998
			$activated_manage = $message_code;
3999
			$message_code = 'jetpack-manage';
4000
		}
4001
4002
		switch ( $message_code ) {
4003
		case 'jetpack-manage':
4004
			$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>';
4005
			if ( $activated_manage ) {
4006
				$this->message .= '<br /><strong>' . __( 'Manage has been activated for you!', 'jetpack'  ) . '</strong>';
4007
			}
4008
			break;
4009
4010
		}
4011
4012
		$deactivated_plugins = Jetpack::state( 'deactivated_plugins' );
4013
4014
		if ( ! empty( $deactivated_plugins ) ) {
4015
			$deactivated_plugins = explode( ',', $deactivated_plugins );
4016
			$deactivated_titles  = array();
4017
			foreach ( $deactivated_plugins as $deactivated_plugin ) {
4018
				if ( ! isset( $this->plugins_to_deactivate[$deactivated_plugin] ) ) {
4019
					continue;
4020
				}
4021
4022
				$deactivated_titles[] = '<strong>' . str_replace( ' ', '&nbsp;', $this->plugins_to_deactivate[$deactivated_plugin][1] ) . '</strong>';
4023
			}
4024
4025
			if ( $deactivated_titles ) {
4026
				if ( $this->message ) {
4027
					$this->message .= "<br /><br />\n";
4028
				}
4029
4030
				$this->message .= wp_sprintf(
4031
					_n(
4032
						'Jetpack contains the most recent version of the old %l plugin.',
4033
						'Jetpack contains the most recent versions of the old %l plugins.',
4034
						count( $deactivated_titles ),
4035
						'jetpack'
4036
					),
4037
					$deactivated_titles
4038
				);
4039
4040
				$this->message .= "<br />\n";
4041
4042
				$this->message .= _n(
4043
					'The old version has been deactivated and can be removed from your site.',
4044
					'The old versions have been deactivated and can be removed from your site.',
4045
					count( $deactivated_titles ),
4046
					'jetpack'
4047
				);
4048
			}
4049
		}
4050
4051
		$this->privacy_checks = Jetpack::state( 'privacy_checks' );
4052
4053
		if ( $this->message || $this->error || $this->privacy_checks || $this->can_display_jetpack_manage_notice() ) {
4054
			add_action( 'jetpack_notices', array( $this, 'admin_notices' ) );
4055
		}
4056
4057 View Code Duplication
		if ( isset( $_GET['configure'] ) && Jetpack::is_module( $_GET['configure'] ) && current_user_can( 'manage_options' ) ) {
4058
			/**
4059
			 * Fires when a module configuration page is loaded.
4060
			 * The dynamic part of the hook is the configure parameter from the URL.
4061
			 *
4062
			 * @since 1.1.0
4063
			 */
4064
			do_action( 'jetpack_module_configuration_load_' . $_GET['configure'] );
4065
		}
4066
4067
		add_filter( 'jetpack_short_module_description', 'wptexturize' );
4068
	}
4069
4070
	function admin_notices() {
4071
4072
		if ( $this->error ) {
4073
?>
4074
<div id="message" class="jetpack-message jetpack-err">
4075
	<div class="squeezer">
4076
		<h2><?php echo wp_kses( $this->error, array( 'a' => array( 'href' => array() ), 'small' => true, 'code' => true, 'strong' => true, 'br' => true, 'b' => true ) ); ?></h2>
4077
<?php	if ( $desc = Jetpack::state( 'error_description' ) ) : ?>
4078
		<p><?php echo esc_html( stripslashes( $desc ) ); ?></p>
4079
<?php	endif; ?>
4080
	</div>
4081
</div>
4082
<?php
4083
		}
4084
4085
		if ( $this->message ) {
4086
?>
4087
<div id="message" class="jetpack-message">
4088
	<div class="squeezer">
4089
		<h2><?php echo wp_kses( $this->message, array( 'strong' => array(), 'a' => array( 'href' => true ), 'br' => true ) ); ?></h2>
4090
	</div>
4091
</div>
4092
<?php
4093
		}
4094
4095
		if ( $this->privacy_checks ) :
4096
			$module_names = $module_slugs = array();
4097
4098
			$privacy_checks = explode( ',', $this->privacy_checks );
4099
			$privacy_checks = array_filter( $privacy_checks, array( 'Jetpack', 'is_module' ) );
4100
			foreach ( $privacy_checks as $module_slug ) {
4101
				$module = Jetpack::get_module( $module_slug );
4102
				if ( ! $module ) {
4103
					continue;
4104
				}
4105
4106
				$module_slugs[] = $module_slug;
4107
				$module_names[] = "<strong>{$module['name']}</strong>";
4108
			}
4109
4110
			$module_slugs = join( ',', $module_slugs );
4111
?>
4112
<div id="message" class="jetpack-message jetpack-err">
4113
	<div class="squeezer">
4114
		<h2><strong><?php esc_html_e( 'Is this site private?', 'jetpack' ); ?></strong></h2><br />
4115
		<p><?php
4116
			echo wp_kses(
4117
				wptexturize(
4118
					wp_sprintf(
4119
						_nx(
4120
							"Like your site's RSS feeds, %l allows access to your posts and other content to third parties.",
4121
							"Like your site's RSS feeds, %l allow access to your posts and other content to third parties.",
4122
							count( $privacy_checks ),
4123
							'%l = list of Jetpack module/feature names',
4124
							'jetpack'
4125
						),
4126
						$module_names
4127
					)
4128
				),
4129
				array( 'strong' => true )
4130
			);
4131
4132
			echo "\n<br />\n";
4133
4134
			echo wp_kses(
4135
				sprintf(
4136
					_nx(
4137
						'If your site is not publicly accessible, consider <a href="%1$s" title="%2$s">deactivating this feature</a>.',
4138
						'If your site is not publicly accessible, consider <a href="%1$s" title="%2$s">deactivating these features</a>.',
4139
						count( $privacy_checks ),
4140
						'%1$s = deactivation URL, %2$s = "Deactivate {list of Jetpack module/feature names}',
4141
						'jetpack'
4142
					),
4143
					wp_nonce_url(
4144
						Jetpack::admin_url(
4145
							array(
4146
								'page'   => 'jetpack',
4147
								'action' => 'deactivate',
4148
								'module' => urlencode( $module_slugs ),
4149
							)
4150
						),
4151
						"jetpack_deactivate-$module_slugs"
4152
					),
4153
					esc_attr( wp_kses( wp_sprintf( _x( 'Deactivate %l', '%l = list of Jetpack module/feature names', 'jetpack' ), $module_names ), array() ) )
4154
				),
4155
				array( 'a' => array( 'href' => true, 'title' => true ) )
4156
			);
4157
		?></p>
4158
	</div>
4159
</div>
4160
<?php endif;
4161
	// only display the notice if the other stuff is not there
4162
	if( $this->can_display_jetpack_manage_notice() && !  $this->error && ! $this->message && ! $this->privacy_checks ) {
4163
		if( isset( $_GET['page'] ) && 'jetpack' != $_GET['page'] )
4164
			$this->opt_in_jetpack_manage_notice();
4165
		}
4166
	}
4167
4168
	/**
4169
	 * Record a stat for later output.  This will only currently output in the admin_footer.
4170
	 */
4171
	function stat( $group, $detail ) {
4172
		if ( ! isset( $this->stats[ $group ] ) )
4173
			$this->stats[ $group ] = array();
4174
		$this->stats[ $group ][] = $detail;
4175
	}
4176
4177
	/**
4178
	 * Load stats pixels. $group is auto-prefixed with "x_jetpack-"
4179
	 */
4180
	function do_stats( $method = '' ) {
4181
		if ( is_array( $this->stats ) && count( $this->stats ) ) {
4182
			foreach ( $this->stats as $group => $stats ) {
4183
				if ( is_array( $stats ) && count( $stats ) ) {
4184
					$args = array( "x_jetpack-{$group}" => implode( ',', $stats ) );
4185
					if ( 'server_side' === $method ) {
4186
						self::do_server_side_stat( $args );
4187
					} else {
4188
						echo '<img src="' . esc_url( self::build_stats_url( $args ) ) . '" width="1" height="1" style="display:none;" />';
4189
					}
4190
				}
4191
				unset( $this->stats[ $group ] );
4192
			}
4193
		}
4194
	}
4195
4196
	/**
4197
	 * Runs stats code for a one-off, server-side.
4198
	 *
4199
	 * @param $args array|string The arguments to append to the URL. Should include `x_jetpack-{$group}={$stats}` or whatever we want to store.
4200
	 *
4201
	 * @return bool If it worked.
4202
	 */
4203
	static function do_server_side_stat( $args ) {
4204
		$response = wp_remote_get( esc_url_raw( self::build_stats_url( $args ) ) );
4205
		if ( is_wp_error( $response ) )
4206
			return false;
4207
4208
		if ( 200 !== wp_remote_retrieve_response_code( $response ) )
4209
			return false;
4210
4211
		return true;
4212
	}
4213
4214
	/**
4215
	 * Builds the stats url.
4216
	 *
4217
	 * @param $args array|string The arguments to append to the URL.
4218
	 *
4219
	 * @return string The URL to be pinged.
4220
	 */
4221
	static function build_stats_url( $args ) {
4222
		$defaults = array(
4223
			'v'    => 'wpcom2',
4224
			'rand' => md5( mt_rand( 0, 999 ) . time() ),
4225
		);
4226
		$args     = wp_parse_args( $args, $defaults );
4227
		/**
4228
		 * Filter the URL used as the Stats tracking pixel.
4229
		 *
4230
		 * @since 2.3.2
4231
		 *
4232
		 * @param string $url Base URL used as the Stats tracking pixel.
4233
		 */
4234
		$base_url = apply_filters(
4235
			'jetpack_stats_base_url',
4236
			'https://pixel.wp.com/g.gif'
4237
		);
4238
		$url      = add_query_arg( $args, $base_url );
4239
		return $url;
4240
	}
4241
4242
	static function translate_current_user_to_role() {
4243
		foreach ( self::$capability_translations as $role => $cap ) {
4244
			if ( current_user_can( $role ) || current_user_can( $cap ) ) {
4245
				return $role;
4246
			}
4247
		}
4248
4249
		return false;
4250
	}
4251
4252
	static function translate_user_to_role( $user ) {
4253
		foreach ( self::$capability_translations as $role => $cap ) {
4254
			if ( user_can( $user, $role ) || user_can( $user, $cap ) ) {
4255
				return $role;
4256
			}
4257
		}
4258
4259
		return false;
4260
    }
4261
4262
	static function translate_role_to_cap( $role ) {
4263
		if ( ! isset( self::$capability_translations[$role] ) ) {
4264
			return false;
4265
		}
4266
4267
		return self::$capability_translations[$role];
4268
	}
4269
4270
	static function sign_role( $role, $user_id = null ) {
4271
		if ( empty( $user_id ) ) {
4272
			$user_id = (int) get_current_user_id();
4273
		}
4274
4275
		if ( ! $user_id  ) {
4276
			return false;
4277
		}
4278
4279
		$token = Jetpack_Data::get_access_token();
4280
		if ( ! $token || is_wp_error( $token ) ) {
4281
			return false;
4282
		}
4283
4284
		return $role . ':' . hash_hmac( 'md5', "{$role}|{$user_id}", $token->secret );
4285
	}
4286
4287
4288
	/**
4289
	 * Builds a URL to the Jetpack connection auth page
4290
	 *
4291
	 * @since 3.9.5
4292
	 *
4293
	 * @param bool $raw If true, URL will not be escaped.
4294
	 * @param bool|string $redirect If true, will redirect back to Jetpack wp-admin landing page after connection.
4295
	 *                              If string, will be a custom redirect.
4296
	 * @param bool|string $from If not false, adds 'from=$from' param to the connect URL.
4297
	 * @param bool $register If true, will generate a register URL regardless of the existing token, since 4.9.0
4298
	 *
4299
	 * @return string Connect URL
4300
	 */
4301
	function build_connect_url( $raw = false, $redirect = false, $from = false, $register = false ) {
4302
		$site_id = Jetpack_Options::get_option( 'id' );
4303
		$token = Jetpack_Options::get_option( 'blog_token' );
4304
4305
		if ( $register || ! $token || ! $site_id ) {
4306
			$url = Jetpack::nonce_url_no_esc( Jetpack::admin_url( 'action=register' ), 'jetpack-register' );
4307
4308
			if ( ! empty( $redirect ) ) {
4309
				$url = add_query_arg(
4310
					'redirect',
4311
					urlencode( wp_validate_redirect( esc_url_raw( $redirect ) ) ),
4312
					$url
4313
				);
4314
			}
4315
4316
			if( is_network_admin() ) {
4317
				$url = add_query_arg( 'is_multisite', network_admin_url( 'admin.php?page=jetpack-settings' ), $url );
4318
			}
4319
		} else {
4320
4321
			// Let's check the existing blog token to see if we need to re-register. We only check once per minute
4322
			// because otherwise this logic can get us in to a loop.
4323
			$last_connect_url_check = intval( Jetpack_Options::get_raw_option( 'jetpack_last_connect_url_check' ) );
4324
			if ( ! $last_connect_url_check || ( time() - $last_connect_url_check ) > MINUTE_IN_SECONDS ) {
4325
				Jetpack_Options::update_raw_option( 'jetpack_last_connect_url_check', time() );
4326
4327
				$response = Jetpack_Client::wpcom_json_api_request_as_blog(
4328
					sprintf( '/sites/%d', $site_id ) .'?force=wpcom',
4329
					'1.1'
4330
				);
4331
4332
				if ( 200 !== wp_remote_retrieve_response_code( $response ) ) {
4333
					// Generating a register URL instead to refresh the existing token
4334
					return $this->build_connect_url( $raw, $redirect, $from, true );
4335
				}
4336
			}
4337
4338
			if ( defined( 'JETPACK__GLOTPRESS_LOCALES_PATH' ) && include_once JETPACK__GLOTPRESS_LOCALES_PATH ) {
4339
				$gp_locale = GP_Locales::by_field( 'wp_locale', get_locale() );
4340
			}
4341
4342
			$role = self::translate_current_user_to_role();
4343
			$signed_role = self::sign_role( $role );
4344
4345
			$user = wp_get_current_user();
4346
4347
			$jetpack_admin_page = esc_url_raw( admin_url( 'admin.php?page=jetpack' ) );
4348
			$redirect = $redirect
4349
				? wp_validate_redirect( esc_url_raw( $redirect ), $jetpack_admin_page )
4350
				: $jetpack_admin_page;
4351
4352
			if( isset( $_REQUEST['is_multisite'] ) ) {
4353
				$redirect = Jetpack_Network::init()->get_url( 'network_admin_page' );
4354
			}
4355
4356
			$secrets = Jetpack::generate_secrets( 'authorize', false, 2 * HOUR_IN_SECONDS );
4357
4358
			$site_icon = ( function_exists( 'has_site_icon') && has_site_icon() )
4359
				? get_site_icon_url()
4360
				: false;
4361
4362
			/**
4363
			 * Filter the type of authorization.
4364
			 * 'calypso' completes authorization on wordpress.com/jetpack/connect
4365
			 * while 'jetpack' ( or any other value ) completes the authorization at jetpack.wordpress.com.
4366
			 *
4367
			 * @since 4.3.3
4368
			 *
4369
			 * @param string $auth_type Defaults to 'calypso', can also be 'jetpack'.
4370
			 */
4371
			$auth_type = apply_filters( 'jetpack_auth_type', 'calypso' );
4372
4373
			$tracks_identity = jetpack_tracks_get_identity( get_current_user_id() );
4374
4375
			$args = urlencode_deep(
4376
				array(
4377
					'response_type' => 'code',
4378
					'client_id'     => Jetpack_Options::get_option( 'id' ),
4379
					'redirect_uri'  => add_query_arg(
4380
						array(
4381
							'action'   => 'authorize',
4382
							'_wpnonce' => wp_create_nonce( "jetpack-authorize_{$role}_{$redirect}" ),
4383
							'redirect' => urlencode( $redirect ),
4384
						),
4385
						esc_url( admin_url( 'admin.php?page=jetpack' ) )
4386
					),
4387
					'state'         => $user->ID,
4388
					'scope'         => $signed_role,
4389
					'user_email'    => $user->user_email,
4390
					'user_login'    => $user->user_login,
4391
					'is_active'     => Jetpack::is_active(),
4392
					'jp_version'    => JETPACK__VERSION,
4393
					'auth_type'     => $auth_type,
4394
					'secret'        => $secrets['secret_1'],
4395
					'locale'        => ( isset( $gp_locale ) && isset( $gp_locale->slug ) ) ? $gp_locale->slug : '',
4396
					'blogname'      => get_option( 'blogname' ),
4397
					'site_url'      => site_url(),
4398
					'home_url'      => home_url(),
4399
					'site_icon'     => $site_icon,
4400
					'site_lang'     => get_locale(),
4401
					'_ui'           => $tracks_identity['_ui'],
4402
					'_ut'           => $tracks_identity['_ut']
4403
				)
4404
			);
4405
4406
			self::apply_activation_source_to_args( $args );
4407
4408
			$url = add_query_arg( $args, Jetpack::api_url( 'authorize' ) );
4409
		}
4410
4411
		if ( $from ) {
4412
			$url = add_query_arg( 'from', $from, $url );
4413
		}
4414
4415
4416
		if ( isset( $_GET['calypso_env'] ) ) {
4417
			$url = add_query_arg( 'calypso_env', sanitize_key( $_GET['calypso_env'] ), $url );
4418
		}
4419
4420
		if ( false !== ( $token = Jetpack_Options::get_option( 'onboarding' ) ) ) {
4421
			$url = add_query_arg( 'onboarding', $token, $url );
4422
4423
			// Remove this once https://github.com/Automattic/wp-calypso/pull/17094 is merged.
4424
			// Uncomment for development until it's merged.
4425
			//$url = add_query_arg( 'calypso_env', 'development', $url );
4426
		}
4427
4428
		return $raw ? $url : esc_url( $url );
4429
	}
4430
4431
	public static function apply_activation_source_to_args( &$args ) {
4432
		list( $activation_source_name, $activation_source_keyword ) = get_option( 'jetpack_activation_source' );
4433
4434
		if ( $activation_source_name ) {
4435
			$args['_as'] = urlencode( $activation_source_name );
4436
		}
4437
4438
		if ( $activation_source_keyword ) {
4439
			$args['_ak'] = urlencode( $activation_source_keyword );
4440
		}
4441
	}
4442
4443
	function build_reconnect_url( $raw = false ) {
4444
		$url = wp_nonce_url( Jetpack::admin_url( 'action=reconnect' ), 'jetpack-reconnect' );
4445
		return $raw ? $url : esc_url( $url );
4446
	}
4447
4448
	public static function admin_url( $args = null ) {
4449
		$args = wp_parse_args( $args, array( 'page' => 'jetpack' ) );
4450
		$url = add_query_arg( $args, admin_url( 'admin.php' ) );
4451
		return $url;
4452
	}
4453
4454
	public static function nonce_url_no_esc( $actionurl, $action = -1, $name = '_wpnonce' ) {
4455
		$actionurl = str_replace( '&amp;', '&', $actionurl );
4456
		return add_query_arg( $name, wp_create_nonce( $action ), $actionurl );
4457
	}
4458
4459
	function dismiss_jetpack_notice() {
4460
4461
		if ( ! isset( $_GET['jetpack-notice'] ) ) {
4462
			return;
4463
		}
4464
4465
		switch( $_GET['jetpack-notice'] ) {
4466
			case 'dismiss':
4467
				if ( check_admin_referer( 'jetpack-deactivate' ) && ! is_plugin_active_for_network( plugin_basename( JETPACK__PLUGIN_DIR . 'jetpack.php' ) ) ) {
4468
4469
					require_once ABSPATH . 'wp-admin/includes/plugin.php';
4470
					deactivate_plugins( JETPACK__PLUGIN_DIR . 'jetpack.php', false, false );
4471
					wp_safe_redirect( admin_url() . 'plugins.php?deactivate=true&plugin_status=all&paged=1&s=' );
4472
				}
4473
				break;
4474 View Code Duplication
			case 'jetpack-manage-opt-out':
4475
4476
				if ( check_admin_referer( 'jetpack_manage_banner_opt_out' ) ) {
4477
					// Don't show the banner again
4478
4479
					Jetpack_Options::update_option( 'dismissed_manage_banner', true );
4480
					// redirect back to the page that had the notice
4481
					if ( wp_get_referer() ) {
4482
						wp_safe_redirect( wp_get_referer() );
4483
					} else {
4484
						// Take me to Jetpack
4485
						wp_safe_redirect( admin_url( 'admin.php?page=jetpack' ) );
4486
					}
4487
				}
4488
				break;
4489 View Code Duplication
			case 'jetpack-protect-multisite-opt-out':
4490
4491
				if ( check_admin_referer( 'jetpack_protect_multisite_banner_opt_out' ) ) {
4492
					// Don't show the banner again
4493
4494
					update_site_option( 'jetpack_dismissed_protect_multisite_banner', true );
4495
					// redirect back to the page that had the notice
4496
					if ( wp_get_referer() ) {
4497
						wp_safe_redirect( wp_get_referer() );
4498
					} else {
4499
						// Take me to Jetpack
4500
						wp_safe_redirect( admin_url( 'admin.php?page=jetpack' ) );
4501
					}
4502
				}
4503
				break;
4504
			case 'jetpack-manage-opt-in':
4505
				if ( check_admin_referer( 'jetpack_manage_banner_opt_in' ) ) {
4506
					// This makes sure that we are redirect to jetpack home so that we can see the Success Message.
4507
4508
					$redirection_url = Jetpack::admin_url();
4509
					remove_action( 'jetpack_pre_activate_module',   array( Jetpack_Admin::init(), 'fix_redirect' ) );
4510
4511
					// Don't redirect form the Jetpack Setting Page
4512
					$referer_parsed = parse_url ( wp_get_referer() );
4513
					// check that we do have a wp_get_referer and the query paramater is set orderwise go to the Jetpack Home
4514
					if ( isset( $referer_parsed['query'] ) && false !== strpos( $referer_parsed['query'], 'page=jetpack_modules' ) ) {
4515
						// Take the user to Jetpack home except when on the setting page
4516
						$redirection_url = wp_get_referer();
4517
						add_action( 'jetpack_pre_activate_module',   array( Jetpack_Admin::init(), 'fix_redirect' ) );
4518
					}
4519
					// Also update the JSON API FULL MANAGEMENT Option
4520
					Jetpack::activate_module( 'manage', false, false );
4521
4522
					// Special Message when option in.
4523
					Jetpack::state( 'optin-manage', 'true' );
4524
					// Activate the Module if not activated already
4525
4526
					// Redirect properly
4527
					wp_safe_redirect( $redirection_url );
4528
4529
				}
4530
				break;
4531
		}
4532
	}
4533
4534
	public static function admin_screen_configure_module( $module_id ) {
4535
4536
		// User that doesn't have 'jetpack_configure_modules' will never end up here since Jetpack Landing Page woun't let them.
4537
		if ( ! in_array( $module_id, Jetpack::get_active_modules() ) && current_user_can( 'manage_options' ) ) {
4538
			if ( has_action( 'display_activate_module_setting_' . $module_id ) ) {
4539
				/**
4540
				 * Fires to diplay a custom module activation screen.
4541
				 *
4542
				 * To add a module actionation screen use Jetpack::module_configuration_activation_screen method.
4543
				 * Example: Jetpack::module_configuration_activation_screen( 'manage', array( $this, 'manage_activate_screen' ) );
4544
				 *
4545
				 * @module manage
4546
				 *
4547
				 * @since 3.8.0
4548
				 *
4549
				 * @param int $module_id Module ID.
4550
				 */
4551
				do_action( 'display_activate_module_setting_' . $module_id );
4552
			} else {
4553
				self::display_activate_module_link( $module_id );
4554
			}
4555
4556
			return false;
4557
		} ?>
4558
4559
		<div id="jp-settings-screen" style="position: relative">
4560
			<h3>
4561
			<?php
4562
				$module = Jetpack::get_module( $module_id );
4563
				echo '<a href="' . Jetpack::admin_url( 'page=jetpack_modules' ) . '">' . __( 'Jetpack by WordPress.com', 'jetpack' ) . '</a> &rarr; ';
4564
				printf( __( 'Configure %s', 'jetpack' ), $module['name'] );
4565
			?>
4566
			</h3>
4567
			<?php
4568
				/**
4569
				 * Fires within the displayed message when a feature configuation is updated.
4570
				 *
4571
				 * @since 3.4.0
4572
				 *
4573
				 * @param int $module_id Module ID.
4574
				 */
4575
				do_action( 'jetpack_notices_update_settings', $module_id );
4576
				/**
4577
				 * Fires when a feature configuation screen is loaded.
4578
				 * The dynamic part of the hook, $module_id, is the module ID.
4579
				 *
4580
				 * @since 1.1.0
4581
				 */
4582
				do_action( 'jetpack_module_configuration_screen_' . $module_id );
4583
			?>
4584
		</div><?php
4585
	}
4586
4587
	/**
4588
	 * Display link to activate the module to see the settings screen.
4589
	 * @param  string $module_id
4590
	 * @return null
4591
	 */
4592
	public static function display_activate_module_link( $module_id ) {
4593
4594
		$info =  Jetpack::get_module( $module_id );
4595
		$extra = '';
4596
		$activate_url = wp_nonce_url(
4597
				Jetpack::admin_url(
4598
					array(
4599
						'page'   => 'jetpack',
4600
						'action' => 'activate',
4601
						'module' => $module_id,
4602
					)
4603
				),
4604
				"jetpack_activate-$module_id"
4605
			);
4606
4607
		?>
4608
4609
		<div class="wrap configure-module">
4610
			<div id="jp-settings-screen">
4611
				<?php
4612
				if ( $module_id == 'json-api' ) {
4613
4614
					$info['name'] = esc_html__( 'Activate Site Management and JSON API', 'jetpack' );
4615
4616
					$activate_url = Jetpack::init()->opt_in_jetpack_manage_url();
4617
4618
					$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' );
4619
4620
					// $extra = __( 'To use Site Management, you need to first activate JSON API to allow remote management of your site. ', 'jetpack' );
4621
				} ?>
4622
4623
				<h3><?php echo esc_html( $info['name'] ); ?></h3>
4624
				<div class="narrow">
4625
					<p><?php echo  $info['description']; ?></p>
4626
					<?php if( $extra ) { ?>
4627
					<p><?php echo esc_html( $extra ); ?></p>
4628
					<?php } ?>
4629
					<p>
4630
						<?php
4631
						if( wp_get_referer() ) {
4632
							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() );
4633
						} else {
4634
							printf( __( '<a class="button-primary" href="%s">Activate Now</a>', 'jetpack' ) , $activate_url  );
4635
						} ?>
4636
					</p>
4637
				</div>
4638
4639
			</div>
4640
		</div>
4641
4642
		<?php
4643
	}
4644
4645
	public static function sort_modules( $a, $b ) {
4646
		if ( $a['sort'] == $b['sort'] )
4647
			return 0;
4648
4649
		return ( $a['sort'] < $b['sort'] ) ? -1 : 1;
4650
	}
4651
4652
	function ajax_recheck_ssl() {
4653
		check_ajax_referer( 'recheck-ssl', 'ajax-nonce' );
4654
		$result = Jetpack::permit_ssl( true );
4655
		wp_send_json( array(
4656
			'enabled' => $result,
4657
			'message' => get_transient( 'jetpack_https_test_message' )
4658
		) );
4659
	}
4660
4661
/* Client API */
4662
4663
	/**
4664
	 * Returns the requested Jetpack API URL
4665
	 *
4666
	 * @return string
4667
	 */
4668
	public static function api_url( $relative_url ) {
4669
		return trailingslashit( JETPACK__API_BASE . $relative_url  ) . JETPACK__API_VERSION . '/';
4670
	}
4671
4672
	/**
4673
	 * Some hosts disable the OpenSSL extension and so cannot make outgoing HTTPS requsets
4674
	 */
4675
	public static function fix_url_for_bad_hosts( $url ) {
4676
		if ( 0 !== strpos( $url, 'https://' ) ) {
4677
			return $url;
4678
		}
4679
4680
		switch ( JETPACK_CLIENT__HTTPS ) {
4681
			case 'ALWAYS' :
4682
				return $url;
4683
			case 'NEVER' :
4684
				return set_url_scheme( $url, 'http' );
4685
			// default : case 'AUTO' :
4686
		}
4687
4688
		// we now return the unmodified SSL URL by default, as a security precaution
4689
		return $url;
4690
	}
4691
4692
	/**
4693
	 * Create a random secret for validating onboarding payload
4694
	 *
4695
	 * @return string Secret token
4696
	 */
4697
	public static function create_onboarding_token() {
4698
		if ( false === ( $token = Jetpack_Options::get_option( 'onboarding' ) ) ) {
4699
			$token = wp_generate_password( 32, false );
4700
			Jetpack_Options::update_option( 'onboarding', $token );
4701
		}
4702
4703
		return $token;
4704
	}
4705
4706
	/**
4707
	 * Remove the onboarding token
4708
	 *
4709
	 * @return bool True on success, false on failure
4710
	 */
4711
	public static function invalidate_onboarding_token() {
4712
		return Jetpack_Options::delete_option( 'onboarding' );
4713
	}
4714
4715
	/**
4716
	 * Validate an onboarding token for a specific action
4717
	 *
4718
	 * @return boolean True if token/action pair is accepted, false if not
4719
	 */
4720
	public static function validate_onboarding_token_action( $token, $action ) {
4721
		// Compare tokens, bail if tokens do not match
4722
		if ( ! hash_equals( $token, Jetpack_Options::get_option( 'onboarding' ) ) ) {
4723
			return false;
4724
		}
4725
4726
		// List of valid actions we can take
4727
		$valid_actions = array(
4728
			'/jetpack/v4/settings',
4729
		);
4730
4731
		// Whitelist the action
4732
		if ( ! in_array( $action, $valid_actions ) ) {
4733
			return false;
4734
		}
4735
4736
		return true;
4737
	}
4738
4739
	/**
4740
	 * Checks to see if the URL is using SSL to connect with Jetpack
4741
	 *
4742
	 * @since 2.3.3
4743
	 * @return boolean
4744
	 */
4745
	public static function permit_ssl( $force_recheck = false ) {
4746
		// Do some fancy tests to see if ssl is being supported
4747
		if ( $force_recheck || false === ( $ssl = get_transient( 'jetpack_https_test' ) ) ) {
4748
			$message = '';
4749
			if ( 'https' !== substr( JETPACK__API_BASE, 0, 5 ) ) {
4750
				$ssl = 0;
4751
			} else {
4752
				switch ( JETPACK_CLIENT__HTTPS ) {
4753
					case 'NEVER':
4754
						$ssl = 0;
4755
						$message = __( 'JETPACK_CLIENT__HTTPS is set to NEVER', 'jetpack' );
4756
						break;
4757
					case 'ALWAYS':
4758
					case 'AUTO':
4759
					default:
4760
						$ssl = 1;
4761
						break;
4762
				}
4763
4764
				// If it's not 'NEVER', test to see
4765
				if ( $ssl ) {
4766
					if ( ! wp_http_supports( array( 'ssl' => true ) ) ) {
4767
						$ssl = 0;
4768
						$message = __( 'WordPress reports no SSL support', 'jetpack' );
4769
					} else {
4770
						$response = wp_remote_get( JETPACK__API_BASE . 'test/1/' );
4771
						if ( is_wp_error( $response ) ) {
4772
							$ssl = 0;
4773
							$message = __( 'WordPress reports no SSL support', 'jetpack' );
4774
						} elseif ( 'OK' !== wp_remote_retrieve_body( $response ) ) {
4775
							$ssl = 0;
4776
							$message = __( 'Response was not OK: ', 'jetpack' ) . wp_remote_retrieve_body( $response );
4777
						}
4778
					}
4779
				}
4780
			}
4781
			set_transient( 'jetpack_https_test', $ssl, DAY_IN_SECONDS );
4782
			set_transient( 'jetpack_https_test_message', $message, DAY_IN_SECONDS );
4783
		}
4784
4785
		return (bool) $ssl;
4786
	}
4787
4788
	/*
4789
	 * Displays an admin_notice, alerting the user to their JETPACK_CLIENT__HTTPS constant being 'AUTO' but SSL isn't working.
4790
	 */
4791
	public function alert_auto_ssl_fail() {
4792
		if ( ! current_user_can( 'manage_options' ) )
4793
			return;
4794
4795
		$ajax_nonce = wp_create_nonce( 'recheck-ssl' );
4796
		?>
4797
4798
		<div id="jetpack-ssl-warning" class="error jp-identity-crisis">
4799
			<div class="jp-banner__content">
4800
				<h2><?php _e( 'Outbound HTTPS not working', 'jetpack' ); ?></h2>
4801
				<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>
4802
				<p>
4803
					<?php _e( 'Jetpack will re-test for HTTPS support once a day, but you can click here to try again immediately: ', 'jetpack' ); ?>
4804
					<a href="#" id="jetpack-recheck-ssl-button"><?php _e( 'Try again', 'jetpack' ); ?></a>
4805
					<span id="jetpack-recheck-ssl-output"><?php echo get_transient( 'jetpack_https_test_message' ); ?></span>
4806
				</p>
4807
				<p>
4808
					<?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' ),
4809
							esc_url( Jetpack::admin_url( array( 'page' => 'jetpack-debugger' )  ) ),
4810
							esc_url( 'https://jetpack.com/support/getting-started-with-jetpack/troubleshooting-tips/' ) ); ?>
4811
				</p>
4812
			</div>
4813
		</div>
4814
		<style>
4815
			#jetpack-recheck-ssl-output { margin-left: 5px; color: red; }
4816
		</style>
4817
		<script type="text/javascript">
4818
			jQuery( document ).ready( function( $ ) {
4819
				$( '#jetpack-recheck-ssl-button' ).click( function( e ) {
4820
					var $this = $( this );
4821
					$this.html( <?php echo json_encode( __( 'Checking', 'jetpack' ) ); ?> );
4822
					$( '#jetpack-recheck-ssl-output' ).html( '' );
4823
					e.preventDefault();
4824
					var data = { action: 'jetpack-recheck-ssl', 'ajax-nonce': '<?php echo $ajax_nonce; ?>' };
4825
					$.post( ajaxurl, data )
4826
					  .done( function( response ) {
4827
					  	if ( response.enabled ) {
4828
					  		$( '#jetpack-ssl-warning' ).hide();
4829
					  	} else {
4830
					  		this.html( <?php echo json_encode( __( 'Try again', 'jetpack' ) ); ?> );
4831
					  		$( '#jetpack-recheck-ssl-output' ).html( 'SSL Failed: ' + response.message );
4832
					  	}
4833
					  }.bind( $this ) );
4834
				} );
4835
			} );
4836
		</script>
4837
4838
		<?php
4839
	}
4840
4841
	/**
4842
	 * Returns the Jetpack XML-RPC API
4843
	 *
4844
	 * @return string
4845
	 */
4846
	public static function xmlrpc_api_url() {
4847
		$base = preg_replace( '#(https?://[^?/]+)(/?.*)?$#', '\\1', JETPACK__API_BASE );
4848
		return untrailingslashit( $base ) . '/xmlrpc.php';
4849
	}
4850
4851
	/**
4852
	 * Creates two secret tokens and the end of life timestamp for them.
4853
	 *
4854
	 * Note these tokens are unique per call, NOT static per site for connecting.
4855
	 *
4856
	 * @since 2.6
4857
	 * @return array
4858
	 */
4859
	public static function generate_secrets( $action, $user_id = false, $exp = 600 ) {
4860
		if ( ! $user_id ) {
4861
			$user_id = get_current_user_id();
4862
		}
4863
4864
		$secret_name  = 'jetpack_' . $action . '_' . $user_id;
4865
		$secrets      = Jetpack_Options::get_raw_option( 'jetpack_secrets', array() );
4866
4867
		if (
4868
			isset( $secrets[ $secret_name ] ) &&
4869
			$secrets[ $secret_name ]['exp'] > time()
4870
		) {
4871
			return $secrets[ $secret_name ];
4872
		}
4873
4874
		$secret_value = array(
4875
			'secret_1'  => wp_generate_password( 32, false ),
4876
			'secret_2'  => wp_generate_password( 32, false ),
4877
			'exp'       => time() + $exp,
4878
		);
4879
4880
		$secrets[ $secret_name ] = $secret_value;
4881
4882
		Jetpack_Options::update_raw_option( 'jetpack_secrets', $secrets );
4883
		return $secrets[ $secret_name ];
4884
	}
4885
4886
	public static function get_secrets( $action, $user_id ) {
4887
		$secret_name = 'jetpack_' . $action . '_' . $user_id;
4888
		$secrets = Jetpack_Options::get_raw_option( 'jetpack_secrets', array() );
4889
4890
		if ( ! isset( $secrets[ $secret_name ] ) ) {
4891
			return new WP_Error( 'verify_secrets_missing', 'Verification secrets not found' );
4892
		}
4893
4894
		if ( $secrets[ $secret_name ]['exp'] < time() ) {
4895
			self::delete_secrets( $action, $user_id );
4896
			return new WP_Error( 'verify_secrets_expired', 'Verification took too long' );
4897
		}
4898
4899
		return $secrets[ $secret_name ];
4900
	}
4901
4902
	public static function delete_secrets( $action, $user_id ) {
4903
		$secret_name = 'jetpack_' . $action . '_' . $user_id;
4904
		$secrets = Jetpack_Options::get_raw_option( 'jetpack_secrets', array() );
4905
		if ( isset( $secrets[ $secret_name ] ) ) {
4906
			unset( $secrets[ $secret_name ] );
4907
			Jetpack_Options::update_raw_option( 'jetpack_secrets', $secrets );
4908
		}
4909
	}
4910
4911
	/**
4912
	 * Builds the timeout limit for queries talking with the wpcom servers.
4913
	 *
4914
	 * Based on local php max_execution_time in php.ini
4915
	 *
4916
	 * @since 2.6
4917
	 * @return int
4918
	 * @deprecated
4919
	 **/
4920
	public function get_remote_query_timeout_limit() {
4921
		_deprecated_function( __METHOD__, 'jetpack-5.4' );
4922
		return Jetpack::get_max_execution_time();
4923
	}
4924
4925
	/**
4926
	 * Builds the timeout limit for queries talking with the wpcom servers.
4927
	 *
4928
	 * Based on local php max_execution_time in php.ini
4929
	 *
4930
	 * @since 5.4
4931
	 * @return int
4932
	 **/
4933
	public static function get_max_execution_time() {
4934
		$timeout = (int) ini_get( 'max_execution_time' );
4935
4936
		// Ensure exec time set in php.ini
4937
		if ( ! $timeout ) {
4938
			$timeout = 30;
4939
		}
4940
		return $timeout;
4941
	}
4942
4943
	/**
4944
	 * Sets a minimum request timeout, and returns the current timeout
4945
	 *
4946
	 * @since 5.4
4947
	 **/
4948
	public static function set_min_time_limit( $min_timeout ) {
4949
		$timeout = self::get_max_execution_time();
4950
		if ( $timeout < $min_timeout ) {
4951
			$timeout = $min_timeout;
4952
			set_time_limit( $timeout );
4953
		}
4954
		return $timeout;
4955
	}
4956
4957
4958
	/**
4959
	 * Takes the response from the Jetpack register new site endpoint and
4960
	 * verifies it worked properly.
4961
	 *
4962
	 * @since 2.6
4963
	 * @return string|Jetpack_Error A JSON object on success or Jetpack_Error on failures
4964
	 **/
4965
	public function validate_remote_register_response( $response ) {
4966
	  if ( is_wp_error( $response ) ) {
4967
			return new Jetpack_Error( 'register_http_request_failed', $response->get_error_message() );
4968
		}
4969
4970
		$code   = wp_remote_retrieve_response_code( $response );
4971
		$entity = wp_remote_retrieve_body( $response );
4972
		if ( $entity )
4973
			$registration_response = json_decode( $entity );
4974
		else
4975
			$registration_response = false;
4976
4977
		$code_type = intval( $code / 100 );
4978
		if ( 5 == $code_type ) {
4979
			return new Jetpack_Error( 'wpcom_5??', sprintf( __( 'Error Details: %s', 'jetpack' ), $code ), $code );
4980
		} elseif ( 408 == $code ) {
4981
			return new Jetpack_Error( 'wpcom_408', sprintf( __( 'Error Details: %s', 'jetpack' ), $code ), $code );
4982
		} elseif ( ! empty( $registration_response->error ) ) {
4983
			if ( 'xml_rpc-32700' == $registration_response->error && ! function_exists( 'xml_parser_create' ) ) {
4984
				$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' );
4985
			} else {
4986
				$error_description = isset( $registration_response->error_description ) ? sprintf( __( 'Error Details: %s', 'jetpack' ), (string) $registration_response->error_description ) : '';
4987
			}
4988
4989
			return new Jetpack_Error( (string) $registration_response->error, $error_description, $code );
4990
		} elseif ( 200 != $code ) {
4991
			return new Jetpack_Error( 'wpcom_bad_response', sprintf( __( 'Error Details: %s', 'jetpack' ), $code ), $code );
4992
		}
4993
4994
		// Jetpack ID error block
4995
		if ( empty( $registration_response->jetpack_id ) ) {
4996
			return new Jetpack_Error( 'jetpack_id', sprintf( __( 'Error Details: Jetpack ID is empty. Do not publicly post this error message! %s', 'jetpack' ), $entity ), $entity );
4997
		} elseif ( ! is_scalar( $registration_response->jetpack_id ) ) {
4998
			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 );
4999
		} elseif ( preg_match( '/[^0-9]/', $registration_response->jetpack_id ) ) {
5000
			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 );
5001
		}
5002
5003
	    return $registration_response;
5004
	}
5005
	/**
5006
	 * @return bool|WP_Error
5007
	 */
5008
	public static function register() {
5009
		JetpackTracking::record_user_event( 'jpc_register_begin' );
5010
		add_action( 'pre_update_jetpack_option_register', array( 'Jetpack_Options', 'delete_option' ) );
5011
		$secrets = Jetpack::generate_secrets( 'register' );
5012
5013 View Code Duplication
		if (
5014
			empty( $secrets['secret_1'] ) ||
5015
			empty( $secrets['secret_2'] ) ||
5016
			empty( $secrets['exp'] )
5017
		) {
5018
			return new Jetpack_Error( 'missing_secrets' );
5019
		}
5020
5021
		// better to try (and fail) to set a higher timeout than this system
5022
		// supports than to have register fail for more users than it should
5023
		$timeout = Jetpack::set_min_time_limit( 60 ) / 2;
5024
5025
		$gmt_offset = get_option( 'gmt_offset' );
5026
		if ( ! $gmt_offset ) {
5027
			$gmt_offset = 0;
5028
		}
5029
5030
		$stats_options = get_option( 'stats_options' );
5031
		$stats_id = isset($stats_options['blog_id']) ? $stats_options['blog_id'] : null;
5032
5033
		$tracks_identity = jetpack_tracks_get_identity( get_current_user_id() );
5034
5035
		$args = array(
5036
			'method'  => 'POST',
5037
			'body'    => array(
5038
				'siteurl'         => site_url(),
5039
				'home'            => home_url(),
5040
				'gmt_offset'      => $gmt_offset,
5041
				'timezone_string' => (string) get_option( 'timezone_string' ),
5042
				'site_name'       => (string) get_option( 'blogname' ),
5043
				'secret_1'        => $secrets['secret_1'],
5044
				'secret_2'        => $secrets['secret_2'],
5045
				'site_lang'       => get_locale(),
5046
				'timeout'         => $timeout,
5047
				'stats_id'        => $stats_id,
5048
				'state'           => get_current_user_id(),
5049
				'_ui'             => $tracks_identity['_ui'],
5050
				'_ut'             => $tracks_identity['_ut'],
5051
				'jetpack_version' => JETPACK__VERSION
5052
			),
5053
			'headers' => array(
5054
				'Accept' => 'application/json',
5055
			),
5056
			'timeout' => $timeout,
5057
		);
5058
5059
		self::apply_activation_source_to_args( $args['body'] );
5060
5061
		$response = Jetpack_Client::_wp_remote_request( Jetpack::fix_url_for_bad_hosts( Jetpack::api_url( 'register' ) ), $args, true );
5062
5063
		// Make sure the response is valid and does not contain any Jetpack errors
5064
		$registration_details = Jetpack::init()->validate_remote_register_response( $response );
5065
		if ( is_wp_error( $registration_details ) ) {
5066
			return $registration_details;
5067
		} elseif ( ! $registration_details ) {
5068
			return new Jetpack_Error( 'unknown_error', __( 'Unknown error registering your Jetpack site', 'jetpack' ), wp_remote_retrieve_response_code( $response ) );
5069
		}
5070
5071 View Code Duplication
		if ( empty( $registration_details->jetpack_secret ) || ! is_string( $registration_details->jetpack_secret ) ) {
5072
			return new Jetpack_Error( 'jetpack_secret', '', wp_remote_retrieve_response_code( $response ) );
5073
		}
5074
5075
		if ( isset( $registration_details->jetpack_public ) ) {
5076
			$jetpack_public = (int) $registration_details->jetpack_public;
5077
		} else {
5078
			$jetpack_public = false;
5079
		}
5080
5081
		Jetpack_Options::update_options(
5082
			array(
5083
				'id'         => (int)    $registration_details->jetpack_id,
5084
				'blog_token' => (string) $registration_details->jetpack_secret,
5085
				'public'     => $jetpack_public,
5086
			)
5087
		);
5088
5089
		/**
5090
		 * Fires when a site is registered on WordPress.com.
5091
		 *
5092
		 * @since 3.7.0
5093
		 *
5094
		 * @param int $json->jetpack_id Jetpack Blog ID.
5095
		 * @param string $json->jetpack_secret Jetpack Blog Token.
5096
		 * @param int|bool $jetpack_public Is the site public.
5097
		 */
5098
		do_action( 'jetpack_site_registered', $registration_details->jetpack_id, $registration_details->jetpack_secret, $jetpack_public );
5099
5100
		// Initialize Jump Start for the first and only time.
5101
		if ( ! Jetpack_Options::get_option( 'jumpstart' ) ) {
5102
			Jetpack_Options::update_option( 'jumpstart', 'new_connection' );
5103
5104
			$jetpack = Jetpack::init();
5105
5106
			$jetpack->stat( 'jumpstart', 'unique-views' );
5107
			$jetpack->do_stats( 'server_side' );
5108
		};
5109
5110
		return true;
5111
	}
5112
5113
	/**
5114
	 * If the db version is showing something other that what we've got now, bump it to current.
5115
	 *
5116
	 * @return bool: True if the option was incorrect and updated, false if nothing happened.
5117
	 */
5118
	public static function maybe_set_version_option() {
5119
		list( $version ) = explode( ':', Jetpack_Options::get_option( 'version' ) );
5120
		if ( JETPACK__VERSION != $version ) {
5121
			Jetpack_Options::update_option( 'version', JETPACK__VERSION . ':' . time() );
5122
5123
			if ( version_compare( JETPACK__VERSION, $version, '>' ) ) {
5124
				/** This action is documented in class.jetpack.php */
5125
				do_action( 'updating_jetpack_version', JETPACK__VERSION, $version );
5126
			}
5127
5128
			return true;
5129
		}
5130
		return false;
5131
	}
5132
5133
/* Client Server API */
5134
5135
	/**
5136
	 * Loads the Jetpack XML-RPC client
5137
	 */
5138
	public static function load_xml_rpc_client() {
5139
		require_once ABSPATH . WPINC . '/class-IXR.php';
5140
		require_once JETPACK__PLUGIN_DIR . 'class.jetpack-ixr-client.php';
5141
	}
5142
5143
	/**
5144
	 * Resets the saved authentication state in between testing requests.
5145
	 */
5146
	public function reset_saved_auth_state() {
5147
		$this->xmlrpc_verification = null;
5148
		$this->rest_authentication_status = null;
5149
	}
5150
5151
	function verify_xml_rpc_signature() {
5152
		if ( $this->xmlrpc_verification ) {
5153
			return $this->xmlrpc_verification;
5154
		}
5155
5156
		// It's not for us
5157
		if ( ! isset( $_GET['token'] ) || empty( $_GET['signature'] ) ) {
5158
			return false;
5159
		}
5160
5161
		@list( $token_key, $version, $user_id ) = explode( ':', $_GET['token'] );
5162
		if (
5163
			empty( $token_key )
5164
		||
5165
			empty( $version ) || strval( JETPACK__API_VERSION ) !== $version
5166
		) {
5167
			return false;
5168
		}
5169
5170
		if ( '0' === $user_id ) {
5171
			$token_type = 'blog';
5172
			$user_id = 0;
5173
		} else {
5174
			$token_type = 'user';
5175
			if ( empty( $user_id ) || ! ctype_digit( $user_id ) ) {
5176
				return false;
5177
			}
5178
			$user_id = (int) $user_id;
5179
5180
			$user = new WP_User( $user_id );
5181
			if ( ! $user || ! $user->exists() ) {
5182
				return false;
5183
			}
5184
		}
5185
5186
		$token = Jetpack_Data::get_access_token( $user_id );
5187
		if ( ! $token ) {
5188
			return false;
5189
		}
5190
5191
		$token_check = "$token_key.";
5192
		if ( ! hash_equals( substr( $token->secret, 0, strlen( $token_check ) ), $token_check ) ) {
5193
			return false;
5194
		}
5195
5196
		require_once JETPACK__PLUGIN_DIR . 'class.jetpack-signature.php';
5197
5198
		$jetpack_signature = new Jetpack_Signature( $token->secret, (int) Jetpack_Options::get_option( 'time_diff' ) );
5199
		if ( isset( $_POST['_jetpack_is_multipart'] ) ) {
5200
			$post_data   = $_POST;
5201
			$file_hashes = array();
5202
			foreach ( $post_data as $post_data_key => $post_data_value ) {
5203
				if ( 0 !== strpos( $post_data_key, '_jetpack_file_hmac_' ) ) {
5204
					continue;
5205
				}
5206
				$post_data_key = substr( $post_data_key, strlen( '_jetpack_file_hmac_' ) );
5207
				$file_hashes[$post_data_key] = $post_data_value;
5208
			}
5209
5210
			foreach ( $file_hashes as $post_data_key => $post_data_value ) {
5211
				unset( $post_data["_jetpack_file_hmac_{$post_data_key}"] );
5212
				$post_data[$post_data_key] = $post_data_value;
5213
			}
5214
5215
			ksort( $post_data );
5216
5217
			$body = http_build_query( stripslashes_deep( $post_data ) );
5218
		} elseif ( is_null( $this->HTTP_RAW_POST_DATA ) ) {
5219
			$body = file_get_contents( 'php://input' );
5220
		} else {
5221
			$body = null;
5222
		}
5223
5224
		$signature = $jetpack_signature->sign_current_request(
5225
			array( 'body' => is_null( $body ) ? $this->HTTP_RAW_POST_DATA : $body, )
5226
		);
5227
5228
		if ( ! $signature ) {
5229
			return false;
5230
		} else if ( is_wp_error( $signature ) ) {
5231
			return $signature;
5232
		} else if ( ! hash_equals( $signature, $_GET['signature'] ) ) {
5233
			return false;
5234
		}
5235
5236
		$timestamp = (int) $_GET['timestamp'];
5237
		$nonce     = stripslashes( (string) $_GET['nonce'] );
5238
5239
		if ( ! $this->add_nonce( $timestamp, $nonce ) ) {
5240
			return false;
5241
		}
5242
5243
		// Let's see if this is onboarding. In such case, use user token type and the provided user id.
5244
		if ( isset( $this->HTTP_RAW_POST_DATA ) ) {
5245
			$jpo = json_decode( $this->HTTP_RAW_POST_DATA );
5246
			if (
5247
				isset( $jpo->onboarding ) &&
5248
				isset( $jpo->onboarding->jpUser ) && isset( $jpo->onboarding->token ) &&
5249
				is_email( $jpo->onboarding->jpUser ) && ctype_alnum( $jpo->onboarding->token ) &&
5250
				isset( $_GET['rest_route'] ) &&
5251
				self::validate_onboarding_token_action( $jpo->onboarding->token, $_GET['rest_route'] )
5252
			) {
5253
				$jpUser = get_user_by( 'email', $jpo->onboarding->jpUser );
5254
				if ( is_a( $jpUser, 'WP_User' ) ) {
5255
					wp_set_current_user( $jpUser->ID );
5256
					$user_can = is_multisite()
5257
						? current_user_can_for_blog( get_current_blog_id(), 'manage_options' )
5258
						: current_user_can( 'manage_options' );
5259
					if ( $user_can ) {
5260
						$token_type = 'user';
5261
						$token->external_user_id = $jpUser->ID;
5262
					}
5263
				}
5264
			}
5265
		}
5266
5267
		$this->xmlrpc_verification = array(
5268
			'type'    => $token_type,
5269
			'user_id' => $token->external_user_id,
5270
		);
5271
5272
		return $this->xmlrpc_verification;
5273
	}
5274
5275
	/**
5276
	 * Authenticates XML-RPC and other requests from the Jetpack Server
5277
	 */
5278
	function authenticate_jetpack( $user, $username, $password ) {
5279
		if ( is_a( $user, 'WP_User' ) ) {
5280
			return $user;
5281
		}
5282
5283
		$token_details = $this->verify_xml_rpc_signature();
5284
5285
		if ( ! $token_details || is_wp_error( $token_details ) ) {
5286
			return $user;
5287
		}
5288
5289
		if ( 'user' !== $token_details['type'] ) {
5290
			return $user;
5291
		}
5292
5293
		if ( ! $token_details['user_id'] ) {
5294
			return $user;
5295
		}
5296
5297
		nocache_headers();
5298
5299
		return new WP_User( $token_details['user_id'] );
5300
	}
5301
5302
	// Authenticates requests from Jetpack server to WP REST API endpoints.
5303
	// Uses the existing XMLRPC request signing implementation.
5304
	function wp_rest_authenticate( $user ) {
5305
		if ( ! empty( $user ) ) {
5306
			// Another authentication method is in effect.
5307
			return $user;
5308
		}
5309
5310
		if ( ! isset( $_GET['_for'] ) || $_GET['_for'] !== 'jetpack' ) {
5311
			// Nothing to do for this authentication method.
5312
			return null;
5313
		}
5314
5315
		if ( ! isset( $_GET['token'] ) && ! isset( $_GET['signature'] ) ) {
5316
			// Nothing to do for this authentication method.
5317
			return null;
5318
		}
5319
5320
		// Ensure that we always have the request body available.  At this
5321
		// point, the WP REST API code to determine the request body has not
5322
		// run yet.  That code may try to read from 'php://input' later, but
5323
		// this can only be done once per request in PHP versions prior to 5.6.
5324
		// So we will go ahead and perform this read now if needed, and save
5325
		// the request body where both the Jetpack signature verification code
5326
		// and the WP REST API code can see it.
5327
		if ( ! isset( $GLOBALS['HTTP_RAW_POST_DATA'] ) ) {
5328
			$GLOBALS['HTTP_RAW_POST_DATA'] = file_get_contents( 'php://input' );
5329
		}
5330
		$this->HTTP_RAW_POST_DATA = $GLOBALS['HTTP_RAW_POST_DATA'];
5331
5332
		// Only support specific request parameters that have been tested and
5333
		// are known to work with signature verification.  A different method
5334
		// can be passed to the WP REST API via the '?_method=' parameter if
5335
		// needed.
5336
		if ( $_SERVER['REQUEST_METHOD'] !== 'GET' && $_SERVER['REQUEST_METHOD'] !== 'POST' ) {
5337
			$this->rest_authentication_status = new WP_Error(
5338
				'rest_invalid_request',
5339
				__( 'This request method is not supported.', 'jetpack' ),
5340
				array( 'status' => 400 )
5341
			);
5342
			return null;
5343
		}
5344
		if ( $_SERVER['REQUEST_METHOD'] !== 'POST' && ! empty( $this->HTTP_RAW_POST_DATA ) ) {
5345
			$this->rest_authentication_status = new WP_Error(
5346
				'rest_invalid_request',
5347
				__( 'This request method does not support body parameters.', 'jetpack' ),
5348
				array( 'status' => 400 )
5349
			);
5350
			return null;
5351
		}
5352
5353
		if ( ! empty( $_SERVER['CONTENT_TYPE'] ) ) {
5354
			$content_type = $_SERVER['CONTENT_TYPE'];
5355
		} elseif ( ! empty( $_SERVER['HTTP_CONTENT_TYPE'] ) ) {
5356
			$content_type = $_SERVER['HTTP_CONTENT_TYPE'];
5357
		}
5358
5359
		if (
5360
			isset( $content_type ) &&
5361
			$content_type !== 'application/x-www-form-urlencoded' &&
5362
			$content_type !== 'application/json'
5363
		) {
5364
			$this->rest_authentication_status = new WP_Error(
5365
				'rest_invalid_request',
5366
				__( 'This Content-Type is not supported.', 'jetpack' ),
5367
				array( 'status' => 400 )
5368
			);
5369
			return null;
5370
		}
5371
5372
		$verified = $this->verify_xml_rpc_signature();
5373
5374
		if ( is_wp_error( $verified ) ) {
5375
			$this->rest_authentication_status = $verified;
5376
			return null;
5377
		}
5378
5379
		if (
5380
			$verified &&
5381
			isset( $verified['type'] ) &&
5382
			'user' === $verified['type'] &&
5383
			! empty( $verified['user_id'] )
5384
		) {
5385
			// Authentication successful.
5386
			$this->rest_authentication_status = true;
5387
			return $verified['user_id'];
5388
		}
5389
5390
		// Something else went wrong.  Probably a signature error.
5391
		$this->rest_authentication_status = new WP_Error(
5392
			'rest_invalid_signature',
5393
			__( 'The request is not signed correctly.', 'jetpack' ),
5394
			array( 'status' => 400 )
5395
		);
5396
		return null;
5397
	}
5398
5399
	/**
5400
	 * Report authentication status to the WP REST API.
5401
	 *
5402
	 * @param  WP_Error|mixed $result Error from another authentication handler, null if we should handle it, or another value if not
5403
	 * @return WP_Error|boolean|null {@see WP_JSON_Server::check_authentication}
5404
	 */
5405
	public function wp_rest_authentication_errors( $value ) {
5406
		if ( $value !== null ) {
5407
			return $value;
5408
		}
5409
		return $this->rest_authentication_status;
5410
	}
5411
5412
	function add_nonce( $timestamp, $nonce ) {
5413
		global $wpdb;
5414
		static $nonces_used_this_request = array();
5415
5416
		if ( isset( $nonces_used_this_request["$timestamp:$nonce"] ) ) {
5417
			return $nonces_used_this_request["$timestamp:$nonce"];
5418
		}
5419
5420
		// This should always have gone through Jetpack_Signature::sign_request() first to check $timestamp an $nonce
5421
		$timestamp = (int) $timestamp;
5422
		$nonce     = esc_sql( $nonce );
5423
5424
		// Raw query so we can avoid races: add_option will also update
5425
		$show_errors = $wpdb->show_errors( false );
5426
5427
		$old_nonce = $wpdb->get_row(
5428
			$wpdb->prepare( "SELECT * FROM `$wpdb->options` WHERE option_name = %s", "jetpack_nonce_{$timestamp}_{$nonce}" )
5429
		);
5430
5431
		if ( is_null( $old_nonce ) ) {
5432
			$return = $wpdb->query(
5433
				$wpdb->prepare(
5434
					"INSERT INTO `$wpdb->options` (`option_name`, `option_value`, `autoload`) VALUES (%s, %s, %s)",
5435
					"jetpack_nonce_{$timestamp}_{$nonce}",
5436
					time(),
5437
					'no'
5438
				)
5439
			);
5440
		} else {
5441
			$return = false;
5442
		}
5443
5444
		$wpdb->show_errors( $show_errors );
5445
5446
		$nonces_used_this_request["$timestamp:$nonce"] = $return;
5447
5448
		return $return;
5449
	}
5450
5451
	/**
5452
	 * In some setups, $HTTP_RAW_POST_DATA can be emptied during some IXR_Server paths since it is passed by reference to various methods.
5453
	 * Capture it here so we can verify the signature later.
5454
	 */
5455
	function xmlrpc_methods( $methods ) {
5456
		$this->HTTP_RAW_POST_DATA = $GLOBALS['HTTP_RAW_POST_DATA'];
5457
		return $methods;
5458
	}
5459
5460
	function public_xmlrpc_methods( $methods ) {
5461
		if ( array_key_exists( 'wp.getOptions', $methods ) ) {
5462
			$methods['wp.getOptions'] = array( $this, 'jetpack_getOptions' );
5463
		}
5464
		return $methods;
5465
	}
5466
5467
	function jetpack_getOptions( $args ) {
5468
		global $wp_xmlrpc_server;
5469
5470
		$wp_xmlrpc_server->escape( $args );
5471
5472
		$username	= $args[1];
5473
		$password	= $args[2];
5474
5475
		if ( !$user = $wp_xmlrpc_server->login($username, $password) ) {
5476
			return $wp_xmlrpc_server->error;
5477
		}
5478
5479
		$options = array();
5480
		$user_data = $this->get_connected_user_data();
5481
		if ( is_array( $user_data ) ) {
5482
			$options['jetpack_user_id'] = array(
5483
				'desc'          => __( 'The WP.com user ID of the connected user', 'jetpack' ),
5484
				'readonly'      => true,
5485
				'value'         => $user_data['ID'],
5486
			);
5487
			$options['jetpack_user_login'] = array(
5488
				'desc'          => __( 'The WP.com username of the connected user', 'jetpack' ),
5489
				'readonly'      => true,
5490
				'value'         => $user_data['login'],
5491
			);
5492
			$options['jetpack_user_email'] = array(
5493
				'desc'          => __( 'The WP.com user email of the connected user', 'jetpack' ),
5494
				'readonly'      => true,
5495
				'value'         => $user_data['email'],
5496
			);
5497
			$options['jetpack_user_site_count'] = array(
5498
				'desc'          => __( 'The number of sites of the connected WP.com user', 'jetpack' ),
5499
				'readonly'      => true,
5500
				'value'         => $user_data['site_count'],
5501
			);
5502
		}
5503
		$wp_xmlrpc_server->blog_options = array_merge( $wp_xmlrpc_server->blog_options, $options );
5504
		$args = stripslashes_deep( $args );
5505
		return $wp_xmlrpc_server->wp_getOptions( $args );
5506
	}
5507
5508
	function xmlrpc_options( $options ) {
5509
		$jetpack_client_id = false;
5510
		if ( self::is_active() ) {
5511
			$jetpack_client_id = Jetpack_Options::get_option( 'id' );
5512
		}
5513
		$options['jetpack_version'] = array(
5514
				'desc'          => __( 'Jetpack Plugin Version', 'jetpack' ),
5515
				'readonly'      => true,
5516
				'value'         => JETPACK__VERSION,
5517
		);
5518
5519
		$options['jetpack_client_id'] = array(
5520
				'desc'          => __( 'The Client ID/WP.com Blog ID of this site', 'jetpack' ),
5521
				'readonly'      => true,
5522
				'value'         => $jetpack_client_id,
5523
		);
5524
		return $options;
5525
	}
5526
5527
	public static function clean_nonces( $all = false ) {
5528
		global $wpdb;
5529
5530
		$sql = "DELETE FROM `$wpdb->options` WHERE `option_name` LIKE %s";
5531
		$sql_args = array( $wpdb->esc_like( 'jetpack_nonce_' ) . '%' );
5532
5533
		if ( true !== $all ) {
5534
			$sql .= ' AND CAST( `option_value` AS UNSIGNED ) < %d';
5535
			$sql_args[] = time() - 3600;
5536
		}
5537
5538
		$sql .= ' ORDER BY `option_id` LIMIT 100';
5539
5540
		$sql = $wpdb->prepare( $sql, $sql_args );
5541
5542
		for ( $i = 0; $i < 1000; $i++ ) {
5543
			if ( ! $wpdb->query( $sql ) ) {
5544
				break;
5545
			}
5546
		}
5547
	}
5548
5549
	/**
5550
	 * State is passed via cookies from one request to the next, but never to subsequent requests.
5551
	 * SET: state( $key, $value );
5552
	 * GET: $value = state( $key );
5553
	 *
5554
	 * @param string $key
5555
	 * @param string $value
5556
	 * @param bool $restate private
5557
	 */
5558
	public static function state( $key = null, $value = null, $restate = false ) {
5559
		static $state = array();
5560
		static $path, $domain;
5561
		if ( ! isset( $path ) ) {
5562
			require_once( ABSPATH . 'wp-admin/includes/plugin.php' );
5563
			$admin_url = Jetpack::admin_url();
5564
			$bits      = parse_url( $admin_url );
5565
5566
			if ( is_array( $bits ) ) {
5567
				$path   = ( isset( $bits['path'] ) ) ? dirname( $bits['path'] ) : null;
5568
				$domain = ( isset( $bits['host'] ) ) ? $bits['host'] : null;
5569
			} else {
5570
				$path = $domain = null;
5571
			}
5572
		}
5573
5574
		// Extract state from cookies and delete cookies
5575
		if ( isset( $_COOKIE[ 'jetpackState' ] ) && is_array( $_COOKIE[ 'jetpackState' ] ) ) {
5576
			$yum = $_COOKIE[ 'jetpackState' ];
5577
			unset( $_COOKIE[ 'jetpackState' ] );
5578
			foreach ( $yum as $k => $v ) {
5579
				if ( strlen( $v ) )
5580
					$state[ $k ] = $v;
5581
				setcookie( "jetpackState[$k]", false, 0, $path, $domain );
5582
			}
5583
		}
5584
5585
		if ( $restate ) {
5586
			foreach ( $state as $k => $v ) {
5587
				setcookie( "jetpackState[$k]", $v, 0, $path, $domain );
5588
			}
5589
			return;
5590
		}
5591
5592
		// Get a state variable
5593
		if ( isset( $key ) && ! isset( $value ) ) {
5594
			if ( array_key_exists( $key, $state ) )
5595
				return $state[ $key ];
5596
			return null;
5597
		}
5598
5599
		// Set a state variable
5600
		if ( isset ( $key ) && isset( $value ) ) {
5601
			if( is_array( $value ) && isset( $value[0] ) ) {
5602
				$value = $value[0];
5603
			}
5604
			$state[ $key ] = $value;
5605
			setcookie( "jetpackState[$key]", $value, 0, $path, $domain );
5606
		}
5607
	}
5608
5609
	public static function restate() {
5610
		Jetpack::state( null, null, true );
5611
	}
5612
5613
	public static function check_privacy( $file ) {
5614
		static $is_site_publicly_accessible = null;
5615
5616
		if ( is_null( $is_site_publicly_accessible ) ) {
5617
			$is_site_publicly_accessible = false;
5618
5619
			Jetpack::load_xml_rpc_client();
5620
			$rpc = new Jetpack_IXR_Client();
5621
5622
			$success = $rpc->query( 'jetpack.isSitePubliclyAccessible', home_url() );
5623
			if ( $success ) {
5624
				$response = $rpc->getResponse();
5625
				if ( $response ) {
5626
					$is_site_publicly_accessible = true;
5627
				}
5628
			}
5629
5630
			Jetpack_Options::update_option( 'public', (int) $is_site_publicly_accessible );
5631
		}
5632
5633
		if ( $is_site_publicly_accessible ) {
5634
			return;
5635
		}
5636
5637
		$module_slug = self::get_module_slug( $file );
5638
5639
		$privacy_checks = Jetpack::state( 'privacy_checks' );
5640
		if ( ! $privacy_checks ) {
5641
			$privacy_checks = $module_slug;
5642
		} else {
5643
			$privacy_checks .= ",$module_slug";
5644
		}
5645
5646
		Jetpack::state( 'privacy_checks', $privacy_checks );
5647
	}
5648
5649
	/**
5650
	 * Helper method for multicall XMLRPC.
5651
	 */
5652
	public static function xmlrpc_async_call() {
5653
		global $blog_id;
5654
		static $clients = array();
5655
5656
		$client_blog_id = is_multisite() ? $blog_id : 0;
5657
5658
		if ( ! isset( $clients[$client_blog_id] ) ) {
5659
			Jetpack::load_xml_rpc_client();
5660
			$clients[$client_blog_id] = new Jetpack_IXR_ClientMulticall( array( 'user_id' => JETPACK_MASTER_USER, ) );
5661
			if ( function_exists( 'ignore_user_abort' ) ) {
5662
				ignore_user_abort( true );
5663
			}
5664
			add_action( 'shutdown', array( 'Jetpack', 'xmlrpc_async_call' ) );
5665
		}
5666
5667
		$args = func_get_args();
5668
5669
		if ( ! empty( $args[0] ) ) {
5670
			call_user_func_array( array( $clients[$client_blog_id], 'addCall' ), $args );
5671
		} elseif ( is_multisite() ) {
5672
			foreach ( $clients as $client_blog_id => $client ) {
5673
				if ( ! $client_blog_id || empty( $client->calls ) ) {
5674
					continue;
5675
				}
5676
5677
				$switch_success = switch_to_blog( $client_blog_id, true );
5678
				if ( ! $switch_success ) {
5679
					continue;
5680
				}
5681
5682
				flush();
5683
				$client->query();
5684
5685
				restore_current_blog();
5686
			}
5687
		} else {
5688
			if ( isset( $clients[0] ) && ! empty( $clients[0]->calls ) ) {
5689
				flush();
5690
				$clients[0]->query();
5691
			}
5692
		}
5693
	}
5694
5695
	public static function staticize_subdomain( $url ) {
5696
5697
		// Extract hostname from URL
5698
		$host = parse_url( $url, PHP_URL_HOST );
5699
5700
		// Explode hostname on '.'
5701
		$exploded_host = explode( '.', $host );
5702
5703
		// Retrieve the name and TLD
5704
		if ( count( $exploded_host ) > 1 ) {
5705
			$name = $exploded_host[ count( $exploded_host ) - 2 ];
5706
			$tld = $exploded_host[ count( $exploded_host ) - 1 ];
5707
			// Rebuild domain excluding subdomains
5708
			$domain = $name . '.' . $tld;
5709
		} else {
5710
			$domain = $host;
5711
		}
5712
		// Array of Automattic domains
5713
		$domain_whitelist = array( 'wordpress.com', 'wp.com' );
5714
5715
		// Return $url if not an Automattic domain
5716
		if ( ! in_array( $domain, $domain_whitelist ) ) {
5717
			return $url;
5718
		}
5719
5720
		if ( is_ssl() ) {
5721
			return preg_replace( '|https?://[^/]++/|', 'https://s-ssl.wordpress.com/', $url );
5722
		}
5723
5724
		srand( crc32( basename( $url ) ) );
5725
		$static_counter = rand( 0, 2 );
5726
		srand(); // this resets everything that relies on this, like array_rand() and shuffle()
5727
5728
		return preg_replace( '|://[^/]+?/|', "://s$static_counter.wp.com/", $url );
5729
	}
5730
5731
/* JSON API Authorization */
5732
5733
	/**
5734
	 * Handles the login action for Authorizing the JSON API
5735
	 */
5736
	function login_form_json_api_authorization() {
5737
		$this->verify_json_api_authorization_request();
5738
5739
		add_action( 'wp_login', array( &$this, 'store_json_api_authorization_token' ), 10, 2 );
5740
5741
		add_action( 'login_message', array( &$this, 'login_message_json_api_authorization' ) );
5742
		add_action( 'login_form', array( &$this, 'preserve_action_in_login_form_for_json_api_authorization' ) );
5743
		add_filter( 'site_url', array( &$this, 'post_login_form_to_signed_url' ), 10, 3 );
5744
	}
5745
5746
	// Make sure the login form is POSTed to the signed URL so we can reverify the request
5747
	function post_login_form_to_signed_url( $url, $path, $scheme ) {
5748
		if ( 'wp-login.php' !== $path || ( 'login_post' !== $scheme && 'login' !== $scheme ) ) {
5749
			return $url;
5750
		}
5751
5752
		$parsed_url = parse_url( $url );
5753
		$url = strtok( $url, '?' );
5754
		$url = "$url?{$_SERVER['QUERY_STRING']}";
5755
		if ( ! empty( $parsed_url['query'] ) )
5756
			$url .= "&{$parsed_url['query']}";
5757
5758
		return $url;
5759
	}
5760
5761
	// Make sure the POSTed request is handled by the same action
5762
	function preserve_action_in_login_form_for_json_api_authorization() {
5763
		echo "<input type='hidden' name='action' value='jetpack_json_api_authorization' />\n";
5764
		echo "<input type='hidden' name='jetpack_json_api_original_query' value='" . esc_url( set_url_scheme( $_SERVER['HTTP_HOST'] . $_SERVER['REQUEST_URI'] ) ) . "' />\n";
5765
	}
5766
5767
	// If someone logs in to approve API access, store the Access Code in usermeta
5768
	function store_json_api_authorization_token( $user_login, $user ) {
5769
		add_filter( 'login_redirect', array( &$this, 'add_token_to_login_redirect_json_api_authorization' ), 10, 3 );
5770
		add_filter( 'allowed_redirect_hosts', array( &$this, 'allow_wpcom_public_api_domain' ) );
5771
		$token = wp_generate_password( 32, false );
5772
		update_user_meta( $user->ID, 'jetpack_json_api_' . $this->json_api_authorization_request['client_id'], $token );
5773
	}
5774
5775
	// Add public-api.wordpress.com to the safe redirect whitelist - only added when someone allows API access
5776
	function allow_wpcom_public_api_domain( $domains ) {
5777
		$domains[] = 'public-api.wordpress.com';
5778
		return $domains;
5779
	}
5780
5781
	// Add the Access Code details to the public-api.wordpress.com redirect
5782
	function add_token_to_login_redirect_json_api_authorization( $redirect_to, $original_redirect_to, $user ) {
5783
		return add_query_arg(
5784
			urlencode_deep(
5785
				array(
5786
					'jetpack-code'    => get_user_meta( $user->ID, 'jetpack_json_api_' . $this->json_api_authorization_request['client_id'], true ),
5787
					'jetpack-user-id' => (int) $user->ID,
5788
					'jetpack-state'   => $this->json_api_authorization_request['state'],
5789
				)
5790
			),
5791
			$redirect_to
5792
		);
5793
	}
5794
5795
5796
	/**
5797
	 * Verifies the request by checking the signature
5798
	 *
5799
	 * @since 4.6.0 Method was updated to use `$_REQUEST` instead of `$_GET` and `$_POST`. Method also updated to allow
5800
	 * passing in an `$environment` argument that overrides `$_REQUEST`. This was useful for integrating with SSO.
5801
	 *
5802
	 * @param null|array $environment
5803
	 */
5804
	function verify_json_api_authorization_request( $environment = null ) {
5805
		require_once JETPACK__PLUGIN_DIR . 'class.jetpack-signature.php';
5806
5807
		$environment = is_null( $environment )
5808
			? $_REQUEST
5809
			: $environment;
5810
5811
		list( $envToken, $envVersion, $envUserId ) = explode( ':', $environment['token'] );
5812
		$token = Jetpack_Data::get_access_token( $envUserId );
5813
		if ( ! $token || empty( $token->secret ) ) {
5814
			wp_die( __( 'You must connect your Jetpack plugin to WordPress.com to use this feature.' , 'jetpack' ) );
5815
		}
5816
5817
		$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' );
5818
5819
		$jetpack_signature = new Jetpack_Signature( $token->secret, (int) Jetpack_Options::get_option( 'time_diff' ) );
5820
5821
		if ( isset( $environment['jetpack_json_api_original_query'] ) ) {
5822
			$signature = $jetpack_signature->sign_request(
5823
				$environment['token'],
5824
				$environment['timestamp'],
5825
				$environment['nonce'],
5826
				'',
5827
				'GET',
5828
				$environment['jetpack_json_api_original_query'],
5829
				null,
5830
				true
5831
			);
5832
		} else {
5833
			$signature = $jetpack_signature->sign_current_request( array( 'body' => null, 'method' => 'GET' ) );
5834
		}
5835
5836
		if ( ! $signature ) {
5837
			wp_die( $die_error );
5838
		} else if ( is_wp_error( $signature ) ) {
5839
			wp_die( $die_error );
5840
		} else if ( ! hash_equals( $signature, $environment['signature'] ) ) {
5841
			if ( is_ssl() ) {
5842
				// 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
5843
				$signature = $jetpack_signature->sign_current_request( array( 'scheme' => 'http', 'body' => null, 'method' => 'GET' ) );
5844
				if ( ! $signature || is_wp_error( $signature ) || ! hash_equals( $signature, $environment['signature'] ) ) {
5845
					wp_die( $die_error );
5846
				}
5847
			} else {
5848
				wp_die( $die_error );
5849
			}
5850
		}
5851
5852
		$timestamp = (int) $environment['timestamp'];
5853
		$nonce     = stripslashes( (string) $environment['nonce'] );
5854
5855
		if ( ! $this->add_nonce( $timestamp, $nonce ) ) {
5856
			// De-nonce the nonce, at least for 5 minutes.
5857
			// 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)
5858
			$old_nonce_time = get_option( "jetpack_nonce_{$timestamp}_{$nonce}" );
5859
			if ( $old_nonce_time < time() - 300 ) {
5860
				wp_die( __( 'The authorization process expired.  Please go back and try again.' , 'jetpack' ) );
5861
			}
5862
		}
5863
5864
		$data = json_decode( base64_decode( stripslashes( $environment['data'] ) ) );
5865
		$data_filters = array(
5866
			'state'        => 'opaque',
5867
			'client_id'    => 'int',
5868
			'client_title' => 'string',
5869
			'client_image' => 'url',
5870
		);
5871
5872
		foreach ( $data_filters as $key => $sanitation ) {
5873
			if ( ! isset( $data->$key ) ) {
5874
				wp_die( $die_error );
5875
			}
5876
5877
			switch ( $sanitation ) {
5878
			case 'int' :
5879
				$this->json_api_authorization_request[$key] = (int) $data->$key;
5880
				break;
5881
			case 'opaque' :
5882
				$this->json_api_authorization_request[$key] = (string) $data->$key;
5883
				break;
5884
			case 'string' :
5885
				$this->json_api_authorization_request[$key] = wp_kses( (string) $data->$key, array() );
5886
				break;
5887
			case 'url' :
5888
				$this->json_api_authorization_request[$key] = esc_url_raw( (string) $data->$key );
5889
				break;
5890
			}
5891
		}
5892
5893
		if ( empty( $this->json_api_authorization_request['client_id'] ) ) {
5894
			wp_die( $die_error );
5895
		}
5896
	}
5897
5898
	function login_message_json_api_authorization( $message ) {
5899
		return '<p class="message">' . sprintf(
5900
			esc_html__( '%s wants to access your site&#8217;s data.  Log in to authorize that access.' , 'jetpack' ),
5901
			'<strong>' . esc_html( $this->json_api_authorization_request['client_title'] ) . '</strong>'
5902
		) . '<img src="' . esc_url( $this->json_api_authorization_request['client_image'] ) . '" /></p>';
5903
	}
5904
5905
	/**
5906
	 * Get $content_width, but with a <s>twist</s> filter.
5907
	 */
5908
	public static function get_content_width() {
5909
		$content_width = isset( $GLOBALS['content_width'] ) ? $GLOBALS['content_width'] : false;
5910
		/**
5911
		 * Filter the Content Width value.
5912
		 *
5913
		 * @since 2.2.3
5914
		 *
5915
		 * @param string $content_width Content Width value.
5916
		 */
5917
		return apply_filters( 'jetpack_content_width', $content_width );
5918
	}
5919
5920
	/**
5921
	 * Pings the WordPress.com Mirror Site for the specified options.
5922
	 *
5923
	 * @param string|array $option_names The option names to request from the WordPress.com Mirror Site
5924
	 *
5925
	 * @return array An associative array of the option values as stored in the WordPress.com Mirror Site
5926
	 */
5927
	public function get_cloud_site_options( $option_names ) {
5928
		$option_names = array_filter( (array) $option_names, 'is_string' );
5929
5930
		Jetpack::load_xml_rpc_client();
5931
		$xml = new Jetpack_IXR_Client( array( 'user_id' => JETPACK_MASTER_USER, ) );
5932
		$xml->query( 'jetpack.fetchSiteOptions', $option_names );
5933
		if ( $xml->isError() ) {
5934
			return array(
5935
				'error_code' => $xml->getErrorCode(),
5936
				'error_msg'  => $xml->getErrorMessage(),
5937
			);
5938
		}
5939
		$cloud_site_options = $xml->getResponse();
5940
5941
		return $cloud_site_options;
5942
	}
5943
5944
	/**
5945
	 * Checks if the site is currently in an identity crisis.
5946
	 *
5947
	 * @return array|bool Array of options that are in a crisis, or false if everything is OK.
5948
	 */
5949
	public static function check_identity_crisis() {
5950
		if ( ! Jetpack::is_active() || Jetpack::is_development_mode() || ! self::validate_sync_error_idc_option() ) {
5951
			return false;
5952
		}
5953
5954
		return Jetpack_Options::get_option( 'sync_error_idc' );
5955
	}
5956
5957
	/**
5958
	 * Checks whether the home and siteurl specifically are whitelisted
5959
	 * Written so that we don't have re-check $key and $value params every time
5960
	 * we want to check if this site is whitelisted, for example in footer.php
5961
	 *
5962
	 * @since  3.8.0
5963
	 * @return bool True = already whitelisted False = not whitelisted
5964
	 */
5965
	public static function is_staging_site() {
5966
		$is_staging = false;
5967
5968
		$known_staging = array(
5969
			'urls' => array(
5970
				'#\.staging\.wpengine\.com$#i', // WP Engine
5971
				'#\.staging\.kinsta\.com$#i',   // Kinsta.com
5972
				),
5973
			'constants' => array(
5974
				'IS_WPE_SNAPSHOT',      // WP Engine
5975
				'KINSTA_DEV_ENV',       // Kinsta.com
5976
				'WPSTAGECOACH_STAGING', // WP Stagecoach
5977
				'JETPACK_STAGING_MODE', // Generic
5978
				)
5979
			);
5980
		/**
5981
		 * Filters the flags of known staging sites.
5982
		 *
5983
		 * @since 3.9.0
5984
		 *
5985
		 * @param array $known_staging {
5986
		 *     An array of arrays that each are used to check if the current site is staging.
5987
		 *     @type array $urls      URLs of staging sites in regex to check against site_url.
5988
		 *     @type array $constants PHP constants of known staging/developement environments.
5989
		 *  }
5990
		 */
5991
		$known_staging = apply_filters( 'jetpack_known_staging', $known_staging );
5992
5993
		if ( isset( $known_staging['urls'] ) ) {
5994
			foreach ( $known_staging['urls'] as $url ){
5995
				if ( preg_match( $url, site_url() ) ) {
5996
					$is_staging = true;
5997
					break;
5998
				}
5999
			}
6000
		}
6001
6002
		if ( isset( $known_staging['constants'] ) ) {
6003
			foreach ( $known_staging['constants'] as $constant ) {
6004
				if ( defined( $constant ) && constant( $constant ) ) {
6005
					$is_staging = true;
6006
				}
6007
			}
6008
		}
6009
6010
		// Last, let's check if sync is erroring due to an IDC. If so, set the site to staging mode.
6011
		if ( ! $is_staging && self::validate_sync_error_idc_option() ) {
6012
			$is_staging = true;
6013
		}
6014
6015
		/**
6016
		 * Filters is_staging_site check.
6017
		 *
6018
		 * @since 3.9.0
6019
		 *
6020
		 * @param bool $is_staging If the current site is a staging site.
6021
		 */
6022
		return apply_filters( 'jetpack_is_staging_site', $is_staging );
6023
	}
6024
6025
	/**
6026
	 * Checks whether the sync_error_idc option is valid or not, and if not, will do cleanup.
6027
	 *
6028
	 * @since 4.4.0
6029
	 * @since 5.4.0 Do not call get_sync_error_idc_option() unless site is in IDC
6030
	 *
6031
	 * @return bool
6032
	 */
6033
	public static function validate_sync_error_idc_option() {
6034
		$is_valid = false;
6035
6036
		$idc_allowed = get_transient( 'jetpack_idc_allowed' );
6037
		if ( false === $idc_allowed ) {
6038
			$response = wp_remote_get( 'https://jetpack.com/is-idc-allowed/' );
6039
			if ( 200 === (int) wp_remote_retrieve_response_code( $response ) ) {
6040
				$json = json_decode( wp_remote_retrieve_body( $response ) );
6041
				$idc_allowed = isset( $json, $json->result ) && $json->result ? '1' : '0';
6042
				$transient_duration = HOUR_IN_SECONDS;
6043
			} else {
6044
				// If the request failed for some reason, then assume IDC is allowed and set shorter transient.
6045
				$idc_allowed = '1';
6046
				$transient_duration = 5 * MINUTE_IN_SECONDS;
6047
			}
6048
6049
			set_transient( 'jetpack_idc_allowed', $idc_allowed, $transient_duration );
6050
		}
6051
6052
		// Is the site opted in and does the stored sync_error_idc option match what we now generate?
6053
		$sync_error = Jetpack_Options::get_option( 'sync_error_idc' );
6054
		if ( $idc_allowed && $sync_error && self::sync_idc_optin() ) {
6055
			$local_options = self::get_sync_error_idc_option();
6056
			if ( $sync_error['home'] === $local_options['home'] && $sync_error['siteurl'] === $local_options['siteurl'] ) {
6057
				$is_valid = true;
6058
			}
6059
		}
6060
6061
		/**
6062
		 * Filters whether the sync_error_idc option is valid.
6063
		 *
6064
		 * @since 4.4.0
6065
		 *
6066
		 * @param bool $is_valid If the sync_error_idc is valid or not.
6067
		 */
6068
		$is_valid = (bool) apply_filters( 'jetpack_sync_error_idc_validation', $is_valid );
6069
6070
		if ( ! $idc_allowed || ( ! $is_valid && $sync_error ) ) {
6071
			// Since the option exists, and did not validate, delete it
6072
			Jetpack_Options::delete_option( 'sync_error_idc' );
6073
		}
6074
6075
		return $is_valid;
6076
	}
6077
6078
	/**
6079
	 * Normalizes a url by doing three things:
6080
	 *  - Strips protocol
6081
	 *  - Strips www
6082
	 *  - Adds a trailing slash
6083
	 *
6084
	 * @since 4.4.0
6085
	 * @param string $url
6086
	 * @return WP_Error|string
6087
	 */
6088
	public static function normalize_url_protocol_agnostic( $url ) {
6089
		$parsed_url = wp_parse_url( trailingslashit( esc_url_raw( $url ) ) );
6090
		if ( ! $parsed_url || empty( $parsed_url['host'] ) || empty( $parsed_url['path'] ) ) {
6091
			return new WP_Error( 'cannot_parse_url', sprintf( esc_html__( 'Cannot parse URL %s', 'jetpack' ), $url ) );
6092
		}
6093
6094
		// Strip www and protocols
6095
		$url = preg_replace( '/^www\./i', '', $parsed_url['host'] . $parsed_url['path'] );
6096
		return $url;
6097
	}
6098
6099
	/**
6100
	 * Gets the value that is to be saved in the jetpack_sync_error_idc option.
6101
	 *
6102
	 * @since 4.4.0
6103
	 * @since 5.4.0 Add transient since home/siteurl retrieved directly from DB
6104
	 *
6105
	 * @param array $response
6106
	 * @return array Array of the local urls, wpcom urls, and error code
6107
	 */
6108
	public static function get_sync_error_idc_option( $response = array() ) {
6109
		$returned_values = get_transient( 'jetpack_idc_option' );
6110
		if ( false === $returned_values ) {
6111
			require_once JETPACK__PLUGIN_DIR . 'sync/class.jetpack-sync-functions.php';
6112
			$local_options = array(
6113
				'home'    => Jetpack_Sync_Functions::home_url(),
6114
				'siteurl' => Jetpack_Sync_Functions::site_url(),
6115
			);
6116
6117
			$options = array_merge( $local_options, $response );
6118
6119
			$returned_values = array();
6120
			foreach( $options as $key => $option ) {
6121
				if ( 'error_code' === $key ) {
6122
					$returned_values[ $key ] = $option;
6123
					continue;
6124
				}
6125
6126
				if ( is_wp_error( $normalized_url = self::normalize_url_protocol_agnostic( $option ) ) ) {
6127
					continue;
6128
				}
6129
6130
				$returned_values[ $key ] = $normalized_url;
6131
			}
6132
6133
			set_transient( 'jetpack_idc_option', $returned_values, MINUTE_IN_SECONDS );
6134
		}
6135
6136
		return $returned_values;
6137
	}
6138
6139
	/**
6140
	 * Returns the value of the jetpack_sync_idc_optin filter, or constant.
6141
	 * If set to true, the site will be put into staging mode.
6142
	 *
6143
	 * @since 4.3.2
6144
	 * @return bool
6145
	 */
6146
	public static function sync_idc_optin() {
6147
		if ( Jetpack_Constants::is_defined( 'JETPACK_SYNC_IDC_OPTIN' ) ) {
6148
			$default = Jetpack_Constants::get_constant( 'JETPACK_SYNC_IDC_OPTIN' );
6149
		} else {
6150
			$default = ! Jetpack_Constants::is_defined( 'SUNRISE' ) && ! is_multisite();
6151
		}
6152
6153
		/**
6154
		 * Allows sites to optin to IDC mitigation which blocks the site from syncing to WordPress.com when the home
6155
		 * URL or site URL do not match what WordPress.com expects. The default value is either false, or the value of
6156
		 * JETPACK_SYNC_IDC_OPTIN constant if set.
6157
		 *
6158
		 * @since 4.3.2
6159
		 *
6160
		 * @param bool $default Whether the site is opted in to IDC mitigation.
6161
		 */
6162
		return (bool) apply_filters( 'jetpack_sync_idc_optin', $default );
6163
	}
6164
6165
	/**
6166
	 * Maybe Use a .min.css stylesheet, maybe not.
6167
	 *
6168
	 * Hooks onto `plugins_url` filter at priority 1, and accepts all 3 args.
6169
	 */
6170
	public static function maybe_min_asset( $url, $path, $plugin ) {
6171
		// Short out on things trying to find actual paths.
6172
		if ( ! $path || empty( $plugin ) ) {
6173
			return $url;
6174
		}
6175
6176
		$path = ltrim( $path, '/' );
6177
6178
		// Strip out the abspath.
6179
		$base = dirname( plugin_basename( $plugin ) );
6180
6181
		// Short out on non-Jetpack assets.
6182
		if ( 'jetpack/' !== substr( $base, 0, 8 ) ) {
6183
			return $url;
6184
		}
6185
6186
		// File name parsing.
6187
		$file              = "{$base}/{$path}";
6188
		$full_path         = JETPACK__PLUGIN_DIR . substr( $file, 8 );
6189
		$file_name         = substr( $full_path, strrpos( $full_path, '/' ) + 1 );
6190
		$file_name_parts_r = array_reverse( explode( '.', $file_name ) );
6191
		$extension         = array_shift( $file_name_parts_r );
6192
6193
		if ( in_array( strtolower( $extension ), array( 'css', 'js' ) ) ) {
6194
			// Already pointing at the minified version.
6195
			if ( 'min' === $file_name_parts_r[0] ) {
6196
				return $url;
6197
			}
6198
6199
			$min_full_path = preg_replace( "#\.{$extension}$#", ".min.{$extension}", $full_path );
6200
			if ( file_exists( $min_full_path ) ) {
6201
				$url = preg_replace( "#\.{$extension}$#", ".min.{$extension}", $url );
6202
				// If it's a CSS file, stash it so we can set the .min suffix for rtl-ing.
6203
				if ( 'css' === $extension ) {
6204
					$key = str_replace( JETPACK__PLUGIN_DIR, 'jetpack/', $min_full_path );
6205
					self::$min_assets[ $key ] = $path;
6206
				}
6207
			}
6208
		}
6209
6210
		return $url;
6211
	}
6212
6213
	/**
6214
	 * If the asset is minified, let's flag .min as the suffix.
6215
	 *
6216
	 * Attached to `style_loader_src` filter.
6217
	 *
6218
	 * @param string $tag The tag that would link to the external asset.
6219
	 * @param string $handle The registered handle of the script in question.
6220
	 * @param string $href The url of the asset in question.
6221
	 */
6222
	public static function set_suffix_on_min( $src, $handle ) {
6223
		if ( false === strpos( $src, '.min.css' ) ) {
6224
			return $src;
6225
		}
6226
6227
		if ( ! empty( self::$min_assets ) ) {
6228
			foreach ( self::$min_assets as $file => $path ) {
6229
				if ( false !== strpos( $src, $file ) ) {
6230
					wp_style_add_data( $handle, 'suffix', '.min' );
6231
					return $src;
6232
				}
6233
			}
6234
		}
6235
6236
		return $src;
6237
	}
6238
6239
	/**
6240
	 * Maybe inlines a stylesheet.
6241
	 *
6242
	 * If you'd like to inline a stylesheet instead of printing a link to it,
6243
	 * wp_style_add_data( 'handle', 'jetpack-inline', true );
6244
	 *
6245
	 * Attached to `style_loader_tag` filter.
6246
	 *
6247
	 * @param string $tag The tag that would link to the external asset.
6248
	 * @param string $handle The registered handle of the script in question.
6249
	 *
6250
	 * @return string
6251
	 */
6252
	public static function maybe_inline_style( $tag, $handle ) {
6253
		global $wp_styles;
6254
		$item = $wp_styles->registered[ $handle ];
6255
6256
		if ( ! isset( $item->extra['jetpack-inline'] ) || ! $item->extra['jetpack-inline'] ) {
6257
			return $tag;
6258
		}
6259
6260
		if ( preg_match( '# href=\'([^\']+)\' #i', $tag, $matches ) ) {
6261
			$href = $matches[1];
6262
			// Strip off query string
6263
			if ( $pos = strpos( $href, '?' ) ) {
6264
				$href = substr( $href, 0, $pos );
6265
			}
6266
			// Strip off fragment
6267
			if ( $pos = strpos( $href, '#' ) ) {
6268
				$href = substr( $href, 0, $pos );
6269
			}
6270
		} else {
6271
			return $tag;
6272
		}
6273
6274
		$plugins_dir = plugin_dir_url( JETPACK__PLUGIN_FILE );
6275
		if ( $plugins_dir !== substr( $href, 0, strlen( $plugins_dir ) ) ) {
6276
			return $tag;
6277
		}
6278
6279
		// If this stylesheet has a RTL version, and the RTL version replaces normal...
6280
		if ( isset( $item->extra['rtl'] ) && 'replace' === $item->extra['rtl'] && is_rtl() ) {
6281
			// And this isn't the pass that actually deals with the RTL version...
6282
			if ( false === strpos( $tag, " id='$handle-rtl-css' " ) ) {
6283
				// Short out, as the RTL version will deal with it in a moment.
6284
				return $tag;
6285
			}
6286
		}
6287
6288
		$file = JETPACK__PLUGIN_DIR . substr( $href, strlen( $plugins_dir ) );
6289
		$css  = Jetpack::absolutize_css_urls( file_get_contents( $file ), $href );
6290
		if ( $css ) {
6291
			$tag = "<!-- Inline {$item->handle} -->\r\n";
6292
			if ( empty( $item->extra['after'] ) ) {
6293
				wp_add_inline_style( $handle, $css );
6294
			} else {
6295
				array_unshift( $item->extra['after'], $css );
6296
				wp_style_add_data( $handle, 'after', $item->extra['after'] );
6297
			}
6298
		}
6299
6300
		return $tag;
6301
	}
6302
6303
	/**
6304
	 * Loads a view file from the views
6305
	 *
6306
	 * Data passed in with the $data parameter will be available in the
6307
	 * template file as $data['value']
6308
	 *
6309
	 * @param string $template - Template file to load
6310
	 * @param array $data - Any data to pass along to the template
6311
	 * @return boolean - If template file was found
6312
	 **/
6313
	public function load_view( $template, $data = array() ) {
6314
		$views_dir = JETPACK__PLUGIN_DIR . 'views/';
6315
6316
		if( file_exists( $views_dir . $template ) ) {
6317
			require_once( $views_dir . $template );
6318
			return true;
6319
		}
6320
6321
		error_log( "Jetpack: Unable to find view file $views_dir$template" );
6322
		return false;
6323
	}
6324
6325
	/**
6326
	 * Throws warnings for deprecated hooks to be removed from Jetpack
6327
	 */
6328
	public function deprecated_hooks() {
6329
		global $wp_filter;
6330
6331
		/*
6332
		 * Format:
6333
		 * deprecated_filter_name => replacement_name
6334
		 *
6335
		 * If there is no replacement, use null for replacement_name
6336
		 */
6337
		$deprecated_list = array(
6338
			'jetpack_bail_on_shortcode'                              => 'jetpack_shortcodes_to_include',
6339
			'wpl_sharing_2014_1'                                     => null,
6340
			'jetpack-tools-to-include'                               => 'jetpack_tools_to_include',
6341
			'jetpack_identity_crisis_options_to_check'               => null,
6342
			'update_option_jetpack_single_user_site'                 => null,
6343
			'audio_player_default_colors'                            => null,
6344
			'add_option_jetpack_featured_images_enabled'             => null,
6345
			'add_option_jetpack_update_details'                      => null,
6346
			'add_option_jetpack_updates'                             => null,
6347
			'add_option_jetpack_network_name'                        => null,
6348
			'add_option_jetpack_network_allow_new_registrations'     => null,
6349
			'add_option_jetpack_network_add_new_users'               => null,
6350
			'add_option_jetpack_network_site_upload_space'           => null,
6351
			'add_option_jetpack_network_upload_file_types'           => null,
6352
			'add_option_jetpack_network_enable_administration_menus' => null,
6353
			'add_option_jetpack_is_multi_site'                       => null,
6354
			'add_option_jetpack_is_main_network'                     => null,
6355
			'add_option_jetpack_main_network_site'                   => null,
6356
			'jetpack_sync_all_registered_options'                    => null,
6357
			'jetpack_has_identity_crisis'                            => 'jetpack_sync_error_idc_validation',
6358
			'jetpack_is_post_mailable'                               => null,
6359
			'jetpack_seo_site_host'                                  => null,
6360
		);
6361
6362
		// This is a silly loop depth. Better way?
6363
		foreach( $deprecated_list AS $hook => $hook_alt ) {
6364
			if ( has_action( $hook ) ) {
6365
				foreach( $wp_filter[ $hook ] AS $func => $values ) {
6366
					foreach( $values AS $hooked ) {
6367
						if ( is_callable( $hooked['function'] ) ) {
6368
							$function_name = 'an anonymous function';
6369
						} else {
6370
							$function_name = $hooked['function'];
6371
						}
6372
						_deprecated_function( $hook . ' used for ' . $function_name, null, $hook_alt );
6373
					}
6374
				}
6375
			}
6376
		}
6377
	}
6378
6379
	/**
6380
	 * Converts any url in a stylesheet, to the correct absolute url.
6381
	 *
6382
	 * Considerations:
6383
	 *  - Normal, relative URLs     `feh.png`
6384
	 *  - Data URLs                 `data:image/gif;base64,eh129ehiuehjdhsa==`
6385
	 *  - Schema-agnostic URLs      `//domain.com/feh.png`
6386
	 *  - Absolute URLs             `http://domain.com/feh.png`
6387
	 *  - Domain root relative URLs `/feh.png`
6388
	 *
6389
	 * @param $css string: The raw CSS -- should be read in directly from the file.
6390
	 * @param $css_file_url : The URL that the file can be accessed at, for calculating paths from.
6391
	 *
6392
	 * @return mixed|string
6393
	 */
6394
	public static function absolutize_css_urls( $css, $css_file_url ) {
6395
		$pattern = '#url\((?P<path>[^)]*)\)#i';
6396
		$css_dir = dirname( $css_file_url );
6397
		$p       = parse_url( $css_dir );
6398
		$domain  = sprintf(
6399
					'%1$s//%2$s%3$s%4$s',
6400
					isset( $p['scheme'] )           ? "{$p['scheme']}:" : '',
6401
					isset( $p['user'], $p['pass'] ) ? "{$p['user']}:{$p['pass']}@" : '',
6402
					$p['host'],
6403
					isset( $p['port'] )             ? ":{$p['port']}" : ''
6404
				);
6405
6406
		if ( preg_match_all( $pattern, $css, $matches, PREG_SET_ORDER ) ) {
6407
			$find = $replace = array();
6408
			foreach ( $matches as $match ) {
6409
				$url = trim( $match['path'], "'\" \t" );
6410
6411
				// If this is a data url, we don't want to mess with it.
6412
				if ( 'data:' === substr( $url, 0, 5 ) ) {
6413
					continue;
6414
				}
6415
6416
				// If this is an absolute or protocol-agnostic url,
6417
				// we don't want to mess with it.
6418
				if ( preg_match( '#^(https?:)?//#i', $url ) ) {
6419
					continue;
6420
				}
6421
6422
				switch ( substr( $url, 0, 1 ) ) {
6423
					case '/':
6424
						$absolute = $domain . $url;
6425
						break;
6426
					default:
6427
						$absolute = $css_dir . '/' . $url;
6428
				}
6429
6430
				$find[]    = $match[0];
6431
				$replace[] = sprintf( 'url("%s")', $absolute );
6432
			}
6433
			$css = str_replace( $find, $replace, $css );
6434
		}
6435
6436
		return $css;
6437
	}
6438
6439
	/**
6440
	 * This methods removes all of the registered css files on the front end
6441
	 * from Jetpack in favor of using a single file. In effect "imploding"
6442
	 * all the files into one file.
6443
	 *
6444
	 * Pros:
6445
	 * - Uses only ONE css asset connection instead of 15
6446
	 * - Saves a minimum of 56k
6447
	 * - Reduces server load
6448
	 * - Reduces time to first painted byte
6449
	 *
6450
	 * Cons:
6451
	 * - Loads css for ALL modules. However all selectors are prefixed so it
6452
	 *		should not cause any issues with themes.
6453
	 * - Plugins/themes dequeuing styles no longer do anything. See
6454
	 *		jetpack_implode_frontend_css filter for a workaround
6455
	 *
6456
	 * For some situations developers may wish to disable css imploding and
6457
	 * instead operate in legacy mode where each file loads seperately and
6458
	 * can be edited individually or dequeued. This can be accomplished with
6459
	 * the following line:
6460
	 *
6461
	 * add_filter( 'jetpack_implode_frontend_css', '__return_false' );
6462
	 *
6463
	 * @since 3.2
6464
	 **/
6465
	public function implode_frontend_css( $travis_test = false ) {
6466
		$do_implode = true;
6467
		if ( defined( 'SCRIPT_DEBUG' ) && SCRIPT_DEBUG ) {
6468
			$do_implode = false;
6469
		}
6470
6471
		/**
6472
		 * Allow CSS to be concatenated into a single jetpack.css file.
6473
		 *
6474
		 * @since 3.2.0
6475
		 *
6476
		 * @param bool $do_implode Should CSS be concatenated? Default to true.
6477
		 */
6478
		$do_implode = apply_filters( 'jetpack_implode_frontend_css', $do_implode );
6479
6480
		// Do not use the imploded file when default behaviour was altered through the filter
6481
		if ( ! $do_implode ) {
6482
			return;
6483
		}
6484
6485
		// We do not want to use the imploded file in dev mode, or if not connected
6486
		if ( Jetpack::is_development_mode() || ! self::is_active() ) {
6487
			if ( ! $travis_test ) {
6488
				return;
6489
			}
6490
		}
6491
6492
		// Do not use the imploded file if sharing css was dequeued via the sharing settings screen
6493
		if ( get_option( 'sharedaddy_disable_resources' ) ) {
6494
			return;
6495
		}
6496
6497
		/*
6498
		 * Now we assume Jetpack is connected and able to serve the single
6499
		 * file.
6500
		 *
6501
		 * In the future there will be a check here to serve the file locally
6502
		 * or potentially from the Jetpack CDN
6503
		 *
6504
		 * For now:
6505
		 * - Enqueue a single imploded css file
6506
		 * - Zero out the style_loader_tag for the bundled ones
6507
		 * - Be happy, drink scotch
6508
		 */
6509
6510
		add_filter( 'style_loader_tag', array( $this, 'concat_remove_style_loader_tag' ), 10, 2 );
6511
6512
		$version = Jetpack::is_development_version() ? filemtime( JETPACK__PLUGIN_DIR . 'css/jetpack.css' ) : JETPACK__VERSION;
6513
6514
		wp_enqueue_style( 'jetpack_css', plugins_url( 'css/jetpack.css', __FILE__ ), array(), $version );
6515
		wp_style_add_data( 'jetpack_css', 'rtl', 'replace' );
6516
	}
6517
6518
	function concat_remove_style_loader_tag( $tag, $handle ) {
6519
		if ( in_array( $handle, $this->concatenated_style_handles ) ) {
6520
			$tag = '';
6521
			if ( defined( 'WP_DEBUG' ) && WP_DEBUG ) {
6522
				$tag = "<!-- `" . esc_html( $handle ) . "` is included in the concatenated jetpack.css -->\r\n";
6523
			}
6524
		}
6525
6526
		return $tag;
6527
	}
6528
6529
	/*
6530
	 * Check the heartbeat data
6531
	 *
6532
	 * Organizes the heartbeat data by severity.  For example, if the site
6533
	 * is in an ID crisis, it will be in the $filtered_data['bad'] array.
6534
	 *
6535
	 * Data will be added to "caution" array, if it either:
6536
	 *  - Out of date Jetpack version
6537
	 *  - Out of date WP version
6538
	 *  - Out of date PHP version
6539
	 *
6540
	 * $return array $filtered_data
6541
	 */
6542
	public static function jetpack_check_heartbeat_data() {
6543
		$raw_data = Jetpack_Heartbeat::generate_stats_array();
6544
6545
		$good    = array();
6546
		$caution = array();
6547
		$bad     = array();
6548
6549
		foreach ( $raw_data as $stat => $value ) {
6550
6551
			// Check jetpack version
6552
			if ( 'version' == $stat ) {
6553
				if ( version_compare( $value, JETPACK__VERSION, '<' ) ) {
6554
					$caution[ $stat ] = $value . " - min supported is " . JETPACK__VERSION;
6555
					continue;
6556
				}
6557
			}
6558
6559
			// Check WP version
6560
			if ( 'wp-version' == $stat ) {
6561
				if ( version_compare( $value, JETPACK__MINIMUM_WP_VERSION, '<' ) ) {
6562
					$caution[ $stat ] = $value . " - min supported is " . JETPACK__MINIMUM_WP_VERSION;
6563
					continue;
6564
				}
6565
			}
6566
6567
			// Check PHP version
6568
			if ( 'php-version' == $stat ) {
6569
				if ( version_compare( PHP_VERSION, '5.2.4', '<' ) ) {
6570
					$caution[ $stat ] = $value . " - min supported is 5.2.4";
6571
					continue;
6572
				}
6573
			}
6574
6575
			// Check ID crisis
6576
			if ( 'identitycrisis' == $stat ) {
6577
				if ( 'yes' == $value ) {
6578
					$bad[ $stat ] = $value;
6579
					continue;
6580
				}
6581
			}
6582
6583
			// The rest are good :)
6584
			$good[ $stat ] = $value;
6585
		}
6586
6587
		$filtered_data = array(
6588
			'good'    => $good,
6589
			'caution' => $caution,
6590
			'bad'     => $bad
6591
		);
6592
6593
		return $filtered_data;
6594
	}
6595
6596
6597
	/*
6598
	 * This method is used to organize all options that can be reset
6599
	 * without disconnecting Jetpack.
6600
	 *
6601
	 * It is used in class.jetpack-cli.php to reset options
6602
	 *
6603
	 * @since 5.4.0 Logic moved to Jetpack_Options class. Method left in Jetpack class for backwards compat.
6604
	 *
6605
	 * @return array of options to delete.
6606
	 */
6607
	public static function get_jetpack_options_for_reset() {
6608
		return Jetpack_Options::get_options_for_reset();
6609
	}
6610
6611
	/**
6612
	 * Check if an option of a Jetpack module has been updated.
6613
	 *
6614
	 * If any module option has been updated before Jump Start has been dismissed,
6615
	 * update the 'jumpstart' option so we can hide Jump Start.
6616
	 *
6617
	 * @param string $option_name
6618
	 *
6619
	 * @return bool
6620
	 */
6621
	public static function jumpstart_has_updated_module_option( $option_name = '' ) {
6622
		// Bail if Jump Start has already been dismissed
6623
		if ( 'new_connection' !== Jetpack_Options::get_option( 'jumpstart' ) ) {
6624
			return false;
6625
		}
6626
6627
		$jetpack = Jetpack::init();
6628
6629
		// Manual build of module options
6630
		$option_names = self::get_jetpack_options_for_reset();
6631
6632
		if ( in_array( $option_name, $option_names['wp_options'] ) ) {
6633
			Jetpack_Options::update_option( 'jumpstart', 'jetpack_action_taken' );
6634
6635
			//Jump start is being dismissed send data to MC Stats
6636
			$jetpack->stat( 'jumpstart', 'manual,'.$option_name );
6637
6638
			$jetpack->do_stats( 'server_side' );
6639
		}
6640
6641
	}
6642
6643
	/*
6644
	 * Strip http:// or https:// from a url, replaces forward slash with ::,
6645
	 * so we can bring them directly to their site in calypso.
6646
	 *
6647
	 * @param string | url
6648
	 * @return string | url without the guff
6649
	 */
6650
	public static function build_raw_urls( $url ) {
6651
		$strip_http = '/.*?:\/\//i';
6652
		$url = preg_replace( $strip_http, '', $url  );
6653
		$url = str_replace( '/', '::', $url );
6654
		return $url;
6655
	}
6656
6657
	/**
6658
	 * Stores and prints out domains to prefetch for page speed optimization.
6659
	 *
6660
	 * @param mixed $new_urls
6661
	 */
6662
	public static function dns_prefetch( $new_urls = null ) {
6663
		static $prefetch_urls = array();
6664
		if ( empty( $new_urls ) && ! empty( $prefetch_urls ) ) {
6665
			echo "\r\n";
6666
			foreach ( $prefetch_urls as $this_prefetch_url ) {
6667
				printf( "<link rel='dns-prefetch' href='%s'/>\r\n", esc_attr( $this_prefetch_url ) );
6668
			}
6669
		} elseif ( ! empty( $new_urls ) ) {
6670
			if ( ! has_action( 'wp_head', array( __CLASS__, __FUNCTION__ ) ) ) {
6671
				add_action( 'wp_head', array( __CLASS__, __FUNCTION__ ) );
6672
			}
6673
			foreach ( (array) $new_urls as $this_new_url ) {
6674
				$prefetch_urls[] = strtolower( untrailingslashit( preg_replace( '#^https?://#i', '//', $this_new_url ) ) );
6675
			}
6676
			$prefetch_urls = array_unique( $prefetch_urls );
6677
		}
6678
	}
6679
6680
	public function wp_dashboard_setup() {
6681
		if ( self::is_active() ) {
6682
			add_action( 'jetpack_dashboard_widget', array( __CLASS__, 'dashboard_widget_footer' ), 999 );
6683
		}
6684
6685
		if ( has_action( 'jetpack_dashboard_widget' ) ) {
6686
			wp_add_dashboard_widget(
6687
				'jetpack_summary_widget',
6688
				esc_html__( 'Site Stats', 'jetpack' ),
6689
				array( __CLASS__, 'dashboard_widget' )
6690
			);
6691
			wp_enqueue_style( 'jetpack-dashboard-widget', plugins_url( 'css/dashboard-widget.css', JETPACK__PLUGIN_FILE ), array(), JETPACK__VERSION );
6692
6693
			// If we're inactive and not in development mode, sort our box to the top.
6694
			if ( ! self::is_active() && ! self::is_development_mode() ) {
6695
				global $wp_meta_boxes;
6696
6697
				$dashboard = $wp_meta_boxes['dashboard']['normal']['core'];
6698
				$ours      = array( 'jetpack_summary_widget' => $dashboard['jetpack_summary_widget'] );
6699
6700
				$wp_meta_boxes['dashboard']['normal']['core'] = array_merge( $ours, $dashboard );
6701
			}
6702
		}
6703
	}
6704
6705
	/**
6706
	 * @param mixed $result Value for the user's option
6707
	 * @return mixed
6708
	 */
6709
	function get_user_option_meta_box_order_dashboard( $sorted ) {
6710
		if ( ! is_array( $sorted ) ) {
6711
			return $sorted;
6712
		}
6713
6714
		foreach ( $sorted as $box_context => $ids ) {
6715
			if ( false === strpos( $ids, 'dashboard_stats' ) ) {
6716
				// If the old id isn't anywhere in the ids, don't bother exploding and fail out.
6717
				continue;
6718
			}
6719
6720
			$ids_array = explode( ',', $ids );
6721
			$key = array_search( 'dashboard_stats', $ids_array );
6722
6723
			if ( false !== $key ) {
6724
				// If we've found that exact value in the option (and not `google_dashboard_stats` for example)
6725
				$ids_array[ $key ] = 'jetpack_summary_widget';
6726
				$sorted[ $box_context ] = implode( ',', $ids_array );
6727
				// We've found it, stop searching, and just return.
6728
				break;
6729
			}
6730
		}
6731
6732
		return $sorted;
6733
	}
6734
6735
	public static function dashboard_widget() {
6736
		/**
6737
		 * Fires when the dashboard is loaded.
6738
		 *
6739
		 * @since 3.4.0
6740
		 */
6741
		do_action( 'jetpack_dashboard_widget' );
6742
	}
6743
6744
	public static function dashboard_widget_footer() {
6745
		?>
6746
		<footer>
6747
6748
		<div class="protect">
6749
			<?php if ( Jetpack::is_module_active( 'protect' ) ) : ?>
6750
				<h3><?php echo number_format_i18n( get_site_option( 'jetpack_protect_blocked_attempts', 0 ) ); ?></h3>
6751
				<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>
6752
			<?php elseif ( current_user_can( 'jetpack_activate_modules' ) && ! self::is_development_mode() ) : ?>
6753
				<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' ); ?>">
6754
					<?php esc_html_e( 'Activate Protect', 'jetpack' ); ?>
6755
				</a>
6756
			<?php else : ?>
6757
				<?php esc_html_e( 'Protect is inactive.', 'jetpack' ); ?>
6758
			<?php endif; ?>
6759
		</div>
6760
6761
		<div class="akismet">
6762
			<?php if ( is_plugin_active( 'akismet/akismet.php' ) ) : ?>
6763
				<h3><?php echo number_format_i18n( get_option( 'akismet_spam_count', 0 ) ); ?></h3>
6764
				<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>
6765
			<?php elseif ( current_user_can( 'activate_plugins' ) && ! is_wp_error( validate_plugin( 'akismet/akismet.php' ) ) ) : ?>
6766
				<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">
6767
					<?php esc_html_e( 'Activate Akismet', 'jetpack' ); ?>
6768
				</a>
6769
			<?php else : ?>
6770
				<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>
6771
			<?php endif; ?>
6772
		</div>
6773
6774
		</footer>
6775
		<?php
6776
	}
6777
6778
	/**
6779
	 * Return string containing the Jetpack logo.
6780
	 *
6781
	 * @since 3.9.0
6782
	 *
6783
	 * @return string
6784
	 */
6785
	public static function get_jp_emblem() {
6786
		return '<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" version="1.1" id="Layer_1" x="0" y="0" width="20" height="20" viewBox="0 0 172.9 172.9" enable-background="new 0 0 172.9 172.9" xml:space="preserve"><path d="M86.4 0C38.7 0 0 38.7 0 86.4c0 47.7 38.7 86.4 86.4 86.4s86.4-38.7 86.4-86.4C172.9 38.7 134.2 0 86.4 0zM83.1 106.6l-27.1-6.9C49 98 45.7 90.1 49.3 84l33.8-58.5V106.6zM124.9 88.9l-33.8 58.5V66.3l27.1 6.9C125.1 74.9 128.4 82.8 124.9 88.9z" /></svg>';
6787
	}
6788
6789
	/*
6790
	 * Adds a "blank" column in the user admin table to display indication of user connection.
6791
	 */
6792
	function jetpack_icon_user_connected( $columns ) {
6793
		$columns['user_jetpack'] = '';
6794
		return $columns;
6795
	}
6796
6797
	/*
6798
	 * Show Jetpack icon if the user is linked.
6799
	 */
6800
	function jetpack_show_user_connected_icon( $val, $col, $user_id ) {
6801
		if ( 'user_jetpack' == $col && Jetpack::is_user_connected( $user_id ) ) {
6802
			$emblem_html = sprintf(
6803
				'<a title="%1$s" class="jp-emblem-user-admin">%2$s</a>',
6804
				esc_attr__( 'This user is linked and ready to fly with Jetpack.', 'jetpack' ),
6805
				Jetpack::get_jp_emblem()
6806
			);
6807
			return $emblem_html;
6808
		}
6809
6810
		return $val;
6811
	}
6812
6813
	/*
6814
	 * Style the Jetpack user column
6815
	 */
6816
	function jetpack_user_col_style() {
6817
		global $current_screen;
6818
		if ( ! empty( $current_screen->base ) && 'users' == $current_screen->base ) { ?>
6819
			<style>
6820
				.fixed .column-user_jetpack {
6821
					width: 21px;
6822
				}
6823
				.jp-emblem-user-admin svg {
6824
					width: 20px;
6825
					height: 20px;
6826
				}
6827
				.jp-emblem-user-admin path {
6828
					fill: #8cc258;
6829
				}
6830
			</style>
6831
		<?php }
6832
	}
6833
6834
	/**
6835
	 * Checks if Akismet is active and working.
6836
	 *
6837
	 * @since  5.1.0
6838
	 * @return bool True = Akismet available. False = Aksimet not available.
6839
	 */
6840
	public static function is_akismet_active() {
6841
		if ( method_exists( 'Akismet' , 'http_post' ) || function_exists( 'akismet_http_post' ) ) {
6842
			return true;
6843
		}
6844
		return false;
6845
	}
6846
6847
	/**
6848
	 * Checks if one or more function names is in debug_backtrace
6849
	 *
6850
	 * @param $names Mixed string name of function or array of string names of functions
6851
	 *
6852
	 * @return bool
6853
	 */
6854
	public static function is_function_in_backtrace( $names ) {
6855
		$backtrace = debug_backtrace( false );
6856
		if ( ! is_array( $names ) ) {
6857
			$names = array( $names );
6858
		}
6859
		$names_as_keys = array_flip( $names );
6860
6861
		//Do check in constant O(1) time for PHP5.5+
6862
		if ( function_exists( 'array_column' ) ) {
6863
			$backtrace_functions = array_column( $backtrace, 'function' );
6864
			$backtrace_functions_as_keys = array_flip( $backtrace_functions );
6865
			$intersection = array_intersect_key( $backtrace_functions_as_keys, $names_as_keys );
6866
			return ! empty ( $intersection );
6867
		}
6868
6869
		//Do check in linear O(n) time for < PHP5.5 ( using isset at least prevents O(n^2) )
6870
		foreach ( $backtrace as $call ) {
6871
			if ( isset( $names_as_keys[ $call['function'] ] ) ) {
6872
				return true;
6873
			}
6874
		}
6875
		return false;
6876
	}
6877
}
6878