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

This method has been deprecated. The supplier of the class has supplied an explanatory message.

The explanatory message should give you some clue as to whether and when the method will be removed from the class and what other method or class to use instead.

Loading history...
3826
		if ( ! $token || is_wp_error( $token ) ) {
3827
			return new Jetpack_Error( 'unknown_token', 'Unknown Jetpack token', 403 );
3828
		}
3829
3830
		$uploaded_files = array();
3831
		$global_post    = isset( $GLOBALS['post'] ) ? $GLOBALS['post'] : null;
3832
		unset( $GLOBALS['post'] );
3833
		foreach ( $_FILES['media']['name'] as $index => $name ) {
3834
			$file = array();
3835
			foreach ( $media_keys as $media_key ) {
3836
				$file[ $media_key ] = $_FILES['media'][ $media_key ][ $index ];
3837
			}
3838
3839
			list( $hmac_provided, $salt ) = explode( ':', $_POST['_jetpack_file_hmac_media'][ $index ] );
3840
3841
			$hmac_file = hash_hmac_file( 'sha1', $file['tmp_name'], $salt . $token->secret );
3842
			if ( $hmac_provided !== $hmac_file ) {
3843
				$uploaded_files[ $index ] = (object) array(
3844
					'error'             => 'invalid_hmac',
3845
					'error_description' => 'The corresponding HMAC for this file does not match',
3846
				);
3847
				continue;
3848
			}
3849
3850
			$_FILES['.jetpack.upload.'] = $file;
3851
			$post_id                    = isset( $_POST['post_id'][ $index ] ) ? absint( $_POST['post_id'][ $index ] ) : 0;
3852
			if ( ! current_user_can( 'edit_post', $post_id ) ) {
3853
				$post_id = 0;
3854
			}
3855
3856
			if ( $update_media_item ) {
3857
				if ( ! isset( $post_id ) || $post_id === 0 ) {
3858
					return new Jetpack_Error( 'invalid_input', 'Media ID must be defined.', 400 );
3859
				}
3860
3861
				$media_array = $_FILES['media'];
3862
3863
				$file_array['name']     = $media_array['name'][0];
3864
				$file_array['type']     = $media_array['type'][0];
3865
				$file_array['tmp_name'] = $media_array['tmp_name'][0];
3866
				$file_array['error']    = $media_array['error'][0];
3867
				$file_array['size']     = $media_array['size'][0];
3868
3869
				$edited_media_item = Jetpack_Media::edit_media_file( $post_id, $file_array );
3870
3871
				if ( is_wp_error( $edited_media_item ) ) {
3872
					return $edited_media_item;
3873
				}
3874
3875
				$response = (object) array(
3876
					'id'   => (string) $post_id,
3877
					'file' => (string) $edited_media_item->post_title,
3878
					'url'  => (string) wp_get_attachment_url( $post_id ),
3879
					'type' => (string) $edited_media_item->post_mime_type,
3880
					'meta' => (array) wp_get_attachment_metadata( $post_id ),
3881
				);
3882
3883
				return (array) array( $response );
3884
			}
3885
3886
			$attachment_id = media_handle_upload(
3887
				'.jetpack.upload.',
3888
				$post_id,
3889
				array(),
3890
				array(
3891
					'action' => 'jetpack_upload_file',
3892
				)
3893
			);
3894
3895
			if ( ! $attachment_id ) {
3896
				$uploaded_files[ $index ] = (object) array(
3897
					'error'             => 'unknown',
3898
					'error_description' => 'An unknown problem occurred processing the upload on the Jetpack site',
3899
				);
3900
			} elseif ( is_wp_error( $attachment_id ) ) {
3901
				$uploaded_files[ $index ] = (object) array(
3902
					'error'             => 'attachment_' . $attachment_id->get_error_code(),
3903
					'error_description' => $attachment_id->get_error_message(),
3904
				);
3905
			} else {
3906
				$attachment               = get_post( $attachment_id );
3907
				$uploaded_files[ $index ] = (object) array(
3908
					'id'   => (string) $attachment_id,
3909
					'file' => $attachment->post_title,
3910
					'url'  => wp_get_attachment_url( $attachment_id ),
3911
					'type' => $attachment->post_mime_type,
3912
					'meta' => wp_get_attachment_metadata( $attachment_id ),
3913
				);
3914
				// Zip files uploads are not supported unless they are done for installation purposed
3915
				// lets delete them in case something goes wrong in this whole process
3916
				if ( 'application/zip' === $attachment->post_mime_type ) {
3917
					// Schedule a cleanup for 2 hours from now in case of failed install.
3918
					wp_schedule_single_event( time() + 2 * HOUR_IN_SECONDS, 'upgrader_scheduled_cleanup', array( $attachment_id ) );
3919
				}
3920
			}
3921
		}
3922
		if ( ! is_null( $global_post ) ) {
3923
			$GLOBALS['post'] = $global_post;
3924
		}
3925
3926
		return $uploaded_files;
3927
	}
3928
3929
	/**
3930
	 * Add help to the Jetpack page
3931
	 *
3932
	 * @since Jetpack (1.2.3)
3933
	 * @return false if not the Jetpack page
3934
	 */
3935
	function admin_help() {
3936
		$current_screen = get_current_screen();
3937
3938
		// Overview
3939
		$current_screen->add_help_tab(
3940
			array(
3941
				'id'      => 'home',
3942
				'title'   => __( 'Home', 'jetpack' ),
3943
				'content' =>
3944
					'<p><strong>' . __( 'Jetpack by WordPress.com', 'jetpack' ) . '</strong></p>' .
3945
					'<p>' . __( 'Jetpack supercharges your self-hosted WordPress site with the awesome cloud power of WordPress.com.', 'jetpack' ) . '</p>' .
3946
					'<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>',
3947
			)
3948
		);
3949
3950
		// Screen Content
3951
		if ( current_user_can( 'manage_options' ) ) {
3952
			$current_screen->add_help_tab(
3953
				array(
3954
					'id'      => 'settings',
3955
					'title'   => __( 'Settings', 'jetpack' ),
3956
					'content' =>
3957
						'<p><strong>' . __( 'Jetpack by WordPress.com', 'jetpack' ) . '</strong></p>' .
3958
						'<p>' . __( 'You can activate or deactivate individual Jetpack modules to suit your needs.', 'jetpack' ) . '</p>' .
3959
						'<ol>' .
3960
							'<li>' . __( 'Each module has an Activate or Deactivate link so you can toggle one individually.', 'jetpack' ) . '</li>' .
3961
							'<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>' .
3962
						'</ol>' .
3963
						'<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>',
3964
				)
3965
			);
3966
		}
3967
3968
		// Help Sidebar
3969
		$support_url = self::build_redirect_url( 'jetpack-support' );
3970
		$faq_url     = self::build_redirect_url( 'jetpack-faq' );
3971
		$current_screen->set_help_sidebar(
3972
			'<p><strong>' . __( 'For more information:', 'jetpack' ) . '</strong></p>' .
3973
			'<p><a href="' . $faq_url . '" target="_blank">' . __( 'Jetpack FAQ', 'jetpack' ) . '</a></p>' .
3974
			'<p><a href="' . $support_url . '" target="_blank">' . __( 'Jetpack Support', 'jetpack' ) . '</a></p>' .
3975
			'<p><a href="' . self::admin_url( array( 'page' => 'jetpack-debugger' ) ) . '">' . __( 'Jetpack Debugging Center', 'jetpack' ) . '</a></p>'
3976
		);
3977
	}
3978
3979
	function admin_menu_css() {
3980
		wp_enqueue_style( 'jetpack-icons' );
3981
	}
3982
3983
	function admin_menu_order() {
3984
		return true;
3985
	}
3986
3987 View Code Duplication
	function jetpack_menu_order( $menu_order ) {
3988
		$jp_menu_order = array();
3989
3990
		foreach ( $menu_order as $index => $item ) {
3991
			if ( $item != 'jetpack' ) {
3992
				$jp_menu_order[] = $item;
3993
			}
3994
3995
			if ( $index == 0 ) {
3996
				$jp_menu_order[] = 'jetpack';
3997
			}
3998
		}
3999
4000
		return $jp_menu_order;
4001
	}
4002
4003
	function admin_banner_styles() {
4004
		$min = ( defined( 'SCRIPT_DEBUG' ) && SCRIPT_DEBUG ) ? '' : '.min';
4005
4006 View Code Duplication
		if ( ! wp_style_is( 'jetpack-dops-style' ) ) {
4007
			wp_register_style(
4008
				'jetpack-dops-style',
4009
				plugins_url( '_inc/build/admin.css', JETPACK__PLUGIN_FILE ),
4010
				array(),
4011
				JETPACK__VERSION
4012
			);
4013
		}
4014
4015
		wp_enqueue_style(
4016
			'jetpack',
4017
			plugins_url( "css/jetpack-banners{$min}.css", JETPACK__PLUGIN_FILE ),
4018
			array( 'jetpack-dops-style' ),
4019
			JETPACK__VERSION . '-20121016'
4020
		);
4021
		wp_style_add_data( 'jetpack', 'rtl', 'replace' );
4022
		wp_style_add_data( 'jetpack', 'suffix', $min );
4023
	}
4024
4025
	function plugin_action_links( $actions ) {
4026
4027
		$jetpack_home = array( 'jetpack-home' => sprintf( '<a href="%s">%s</a>', self::admin_url( 'page=jetpack' ), 'Jetpack' ) );
4028
4029
		if ( current_user_can( 'jetpack_manage_modules' ) && ( self::is_active() || ( new Status() )->is_development_mode() ) ) {
4030
			return array_merge(
4031
				$jetpack_home,
4032
				array( 'settings' => sprintf( '<a href="%s">%s</a>', self::admin_url( 'page=jetpack#/settings' ), __( 'Settings', 'jetpack' ) ) ),
4033
				array( 'support' => sprintf( '<a href="%s">%s</a>', self::admin_url( 'page=jetpack-debugger ' ), __( 'Support', 'jetpack' ) ) ),
4034
				$actions
4035
			);
4036
		}
4037
4038
		return array_merge( $jetpack_home, $actions );
4039
	}
4040
4041
	/**
4042
	 * Filters the login URL to include the registration flow in case the user isn't logged in.
4043
	 *
4044
	 * @param string $login_url The wp-login URL.
4045
	 * @param string $redirect  URL to redirect users after logging in.
4046
	 * @since Jetpack 8.4
4047
	 * @return string
4048
	 */
4049
	public function login_url( $login_url, $redirect ) {
4050
		parse_str( wp_parse_url( $redirect, PHP_URL_QUERY ), $redirect_parts );
4051
		if ( ! empty( $redirect_parts[ self::$jetpack_redirect_login ] ) ) {
4052
			$login_url = add_query_arg( self::$jetpack_redirect_login, 'true', $login_url );
4053
		}
4054
		return $login_url;
4055
	}
4056
4057
	/**
4058
	 * Redirects non-authenticated users to authenticate with Calypso if redirect flag is set.
4059
	 *
4060
	 * @since Jetpack 8.4
4061
	 */
4062
	public function login_init() {
4063
		// phpcs:ignore WordPress.Security.NonceVerification
4064
		if ( ! empty( $_GET[ self::$jetpack_redirect_login ] ) ) {
4065
			add_filter( 'allowed_redirect_hosts', array( &$this, 'allow_wpcom_environments' ) );
4066
			wp_safe_redirect(
4067
				add_query_arg(
4068
					array(
4069
						'forceInstall' => 1,
4070
						'url'          => rawurlencode( get_site_url() ),
4071
					),
4072
					// @todo provide way to go to specific calypso env.
4073
					self::get_calypso_host() . 'jetpack/connect'
4074
				)
4075
			);
4076
			exit;
4077
		}
4078
	}
4079
4080
	/*
4081
	 * Registration flow:
4082
	 * 1 - ::admin_page_load() action=register
4083
	 * 2 - ::try_registration()
4084
	 * 3 - ::register()
4085
	 *     - Creates jetpack_register option containing two secrets and a timestamp
4086
	 *     - Calls https://jetpack.wordpress.com/jetpack.register/1/ with
4087
	 *       siteurl, home, gmt_offset, timezone_string, site_name, secret_1, secret_2, site_lang, timeout, stats_id
4088
	 *     - That request to jetpack.wordpress.com does not immediately respond.  It first makes a request BACK to this site's
4089
	 *       xmlrpc.php?for=jetpack: RPC method: jetpack.verifyRegistration, Parameters: secret_1
4090
	 *     - The XML-RPC request verifies secret_1, deletes both secrets and responds with: secret_2
4091
	 *     - https://jetpack.wordpress.com/jetpack.register/1/ verifies that XML-RPC response (secret_2) then finally responds itself with
4092
	 *       jetpack_id, jetpack_secret, jetpack_public
4093
	 *     - ::register() then stores jetpack_options: id => jetpack_id, blog_token => jetpack_secret
4094
	 * 4 - redirect to https://wordpress.com/start/jetpack-connect
4095
	 * 5 - user logs in with WP.com account
4096
	 * 6 - remote request to this site's xmlrpc.php with action remoteAuthorize, Jetpack_XMLRPC_Server->remote_authorize
4097
	 *		- Manager::authorize()
4098
	 *		- Manager::get_token()
4099
	 *		- GET https://jetpack.wordpress.com/jetpack.token/1/ with
4100
	 *        client_id, client_secret, grant_type, code, redirect_uri:action=authorize, state, scope, user_email, user_login
4101
	 *			- which responds with access_token, token_type, scope
4102
	 *		- Manager::authorize() stores jetpack_options: user_token => access_token.$user_id
4103
	 *		- Jetpack::activate_default_modules()
4104
	 *     		- Deactivates deprecated plugins
4105
	 *     		- Activates all default modules
4106
	 *		- Responds with either error, or 'connected' for new connection, or 'linked' for additional linked users
4107
	 * 7 - For a new connection, user selects a Jetpack plan on wordpress.com
4108
	 * 8 - User is redirected back to wp-admin/index.php?page=jetpack with state:message=authorized
4109
	 *     Done!
4110
	 */
4111
4112
	/**
4113
	 * Handles the page load events for the Jetpack admin page
4114
	 */
4115
	function admin_page_load() {
4116
		$error = false;
4117
4118
		// Make sure we have the right body class to hook stylings for subpages off of.
4119
		add_filter( 'admin_body_class', array( __CLASS__, 'add_jetpack_pagestyles' ), 20 );
4120
4121
		if ( ! empty( $_GET['jetpack_restate'] ) ) {
4122
			// Should only be used in intermediate redirects to preserve state across redirects
4123
			self::restate();
4124
		}
4125
4126
		if ( isset( $_GET['connect_url_redirect'] ) ) {
4127
			// @todo: Add validation against a known whitelist
4128
			$from = ! empty( $_GET['from'] ) ? $_GET['from'] : 'iframe';
4129
			// User clicked in the iframe to link their accounts
4130
			if ( ! self::is_user_connected() ) {
4131
				$redirect = ! empty( $_GET['redirect_after_auth'] ) ? $_GET['redirect_after_auth'] : false;
4132
4133
				add_filter( 'allowed_redirect_hosts', array( &$this, 'allow_wpcom_environments' ) );
4134
				$connect_url = $this->build_connect_url( true, $redirect, $from );
4135
				remove_filter( 'allowed_redirect_hosts', array( &$this, 'allow_wpcom_environments' ) );
4136
4137
				if ( isset( $_GET['notes_iframe'] ) ) {
4138
					$connect_url .= '&notes_iframe';
4139
				}
4140
				wp_redirect( $connect_url );
4141
				exit;
4142
			} else {
4143
				if ( ! isset( $_GET['calypso_env'] ) ) {
4144
					self::state( 'message', 'already_authorized' );
4145
					wp_safe_redirect( self::admin_url() );
4146
					exit;
4147
				} else {
4148
					$connect_url  = $this->build_connect_url( true, false, $from );
4149
					$connect_url .= '&already_authorized=true';
4150
					wp_redirect( $connect_url );
4151
					exit;
4152
				}
4153
			}
4154
		}
4155
4156
		if ( isset( $_GET['action'] ) ) {
4157
			switch ( $_GET['action'] ) {
4158
				case 'authorize':
4159
					if ( self::is_active() && self::is_user_connected() ) {
4160
						self::state( 'message', 'already_authorized' );
4161
						wp_safe_redirect( self::admin_url() );
4162
						exit;
4163
					}
4164
					self::log( 'authorize' );
4165
					$client_server = new Jetpack_Client_Server();
4166
					$client_server->client_authorize();
4167
					exit;
4168
				case 'register':
4169
					if ( ! current_user_can( 'jetpack_connect' ) ) {
4170
						$error = 'cheatin';
4171
						break;
4172
					}
4173
					check_admin_referer( 'jetpack-register' );
4174
					self::log( 'register' );
4175
					self::maybe_set_version_option();
4176
					$registered = self::try_registration();
4177 View Code Duplication
					if ( is_wp_error( $registered ) ) {
4178
						$error = $registered->get_error_code();
4179
						self::state( 'error', $error );
4180
						self::state( 'error', $registered->get_error_message() );
4181
4182
						/**
4183
						 * Jetpack registration Error.
4184
						 *
4185
						 * @since 7.5.0
4186
						 *
4187
						 * @param string|int $error The error code.
4188
						 * @param \WP_Error $registered The error object.
4189
						 */
4190
						do_action( 'jetpack_connection_register_fail', $error, $registered );
4191
						break;
4192
					}
4193
4194
					$from     = isset( $_GET['from'] ) ? $_GET['from'] : false;
4195
					$redirect = isset( $_GET['redirect'] ) ? $_GET['redirect'] : false;
4196
4197
					/**
4198
					 * Jetpack registration Success.
4199
					 *
4200
					 * @since 7.5.0
4201
					 *
4202
					 * @param string $from 'from' GET parameter;
4203
					 */
4204
					do_action( 'jetpack_connection_register_success', $from );
4205
4206
					$url = $this->build_connect_url( true, $redirect, $from );
4207
4208
					if ( ! empty( $_GET['onboarding'] ) ) {
4209
						$url = add_query_arg( 'onboarding', $_GET['onboarding'], $url );
4210
					}
4211
4212
					if ( ! empty( $_GET['auth_approved'] ) && 'true' === $_GET['auth_approved'] ) {
4213
						$url = add_query_arg( 'auth_approved', 'true', $url );
4214
					}
4215
4216
					wp_redirect( $url );
4217
					exit;
4218
				case 'activate':
4219
					if ( ! current_user_can( 'jetpack_activate_modules' ) ) {
4220
						$error = 'cheatin';
4221
						break;
4222
					}
4223
4224
					$module = stripslashes( $_GET['module'] );
4225
					check_admin_referer( "jetpack_activate-$module" );
4226
					self::log( 'activate', $module );
4227
					if ( ! self::activate_module( $module ) ) {
4228
						self::state( 'error', sprintf( __( 'Could not activate %s', 'jetpack' ), $module ) );
4229
					}
4230
					// The following two lines will rarely happen, as Jetpack::activate_module normally exits at the end.
4231
					wp_safe_redirect( self::admin_url( 'page=jetpack' ) );
4232
					exit;
4233
				case 'activate_default_modules':
4234
					check_admin_referer( 'activate_default_modules' );
4235
					self::log( 'activate_default_modules' );
4236
					self::restate();
4237
					$min_version   = isset( $_GET['min_version'] ) ? $_GET['min_version'] : false;
4238
					$max_version   = isset( $_GET['max_version'] ) ? $_GET['max_version'] : false;
4239
					$other_modules = isset( $_GET['other_modules'] ) && is_array( $_GET['other_modules'] ) ? $_GET['other_modules'] : array();
4240
					self::activate_default_modules( $min_version, $max_version, $other_modules );
4241
					wp_safe_redirect( self::admin_url( 'page=jetpack' ) );
4242
					exit;
4243
				case 'disconnect':
4244
					if ( ! current_user_can( 'jetpack_disconnect' ) ) {
4245
						$error = 'cheatin';
4246
						break;
4247
					}
4248
4249
					check_admin_referer( 'jetpack-disconnect' );
4250
					self::log( 'disconnect' );
4251
					self::disconnect();
4252
					wp_safe_redirect( self::admin_url( 'disconnected=true' ) );
4253
					exit;
4254
				case 'reconnect':
4255
					if ( ! current_user_can( 'jetpack_reconnect' ) ) {
4256
						$error = 'cheatin';
4257
						break;
4258
					}
4259
4260
					check_admin_referer( 'jetpack-reconnect' );
4261
					self::log( 'reconnect' );
4262
					$this->disconnect();
4263
					wp_redirect( $this->build_connect_url( true, false, 'reconnect' ) );
4264
					exit;
4265 View Code Duplication
				case 'deactivate':
4266
					if ( ! current_user_can( 'jetpack_deactivate_modules' ) ) {
4267
						$error = 'cheatin';
4268
						break;
4269
					}
4270
4271
					$modules = stripslashes( $_GET['module'] );
4272
					check_admin_referer( "jetpack_deactivate-$modules" );
4273
					foreach ( explode( ',', $modules ) as $module ) {
4274
						self::log( 'deactivate', $module );
4275
						self::deactivate_module( $module );
4276
						self::state( 'message', 'module_deactivated' );
4277
					}
4278
					self::state( 'module', $modules );
4279
					wp_safe_redirect( self::admin_url( 'page=jetpack' ) );
4280
					exit;
4281
				case 'unlink':
4282
					$redirect = isset( $_GET['redirect'] ) ? $_GET['redirect'] : '';
4283
					check_admin_referer( 'jetpack-unlink' );
4284
					self::log( 'unlink' );
4285
					Connection_Manager::disconnect_user();
4286
					self::state( 'message', 'unlinked' );
4287
					if ( 'sub-unlink' == $redirect ) {
4288
						wp_safe_redirect( admin_url() );
4289
					} else {
4290
						wp_safe_redirect( self::admin_url( array( 'page' => $redirect ) ) );
4291
					}
4292
					exit;
4293
				case 'onboard':
4294
					if ( ! current_user_can( 'manage_options' ) ) {
4295
						wp_safe_redirect( self::admin_url( 'page=jetpack' ) );
4296
					} else {
4297
						self::create_onboarding_token();
4298
						$url = $this->build_connect_url( true );
4299
4300
						if ( false !== ( $token = Jetpack_Options::get_option( 'onboarding' ) ) ) {
4301
							$url = add_query_arg( 'onboarding', $token, $url );
4302
						}
4303
4304
						$calypso_env = $this->get_calypso_env();
4305
						if ( ! empty( $calypso_env ) ) {
4306
							$url = add_query_arg( 'calypso_env', $calypso_env, $url );
4307
						}
4308
4309
						wp_redirect( $url );
4310
						exit;
4311
					}
4312
					exit;
4313
				default:
4314
					/**
4315
					 * Fires when a Jetpack admin page is loaded with an unrecognized parameter.
4316
					 *
4317
					 * @since 2.6.0
4318
					 *
4319
					 * @param string sanitize_key( $_GET['action'] ) Unrecognized URL parameter.
4320
					 */
4321
					do_action( 'jetpack_unrecognized_action', sanitize_key( $_GET['action'] ) );
4322
			}
4323
		}
4324
4325
		if ( ! $error = $error ? $error : self::state( 'error' ) ) {
4326
			self::activate_new_modules( true );
4327
		}
4328
4329
		$message_code = self::state( 'message' );
4330
		if ( self::state( 'optin-manage' ) ) {
4331
			$activated_manage = $message_code;
4332
			$message_code     = 'jetpack-manage';
4333
		}
4334
4335
		switch ( $message_code ) {
4336
			case 'jetpack-manage':
4337
				$sites_url = esc_url( self::build_redirect_url( 'calypso-sites' ) );
4338
				// translators: %s is the URL to the "Sites" panel on wordpress.com.
4339
				$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' ), $sites_url ) . '</strong>';
4340
				if ( $activated_manage ) {
4341
					$this->message .= '<br /><strong>' . __( 'Manage has been activated for you!', 'jetpack' ) . '</strong>';
4342
				}
4343
				break;
4344
4345
		}
4346
4347
		$deactivated_plugins = self::state( 'deactivated_plugins' );
4348
4349
		if ( ! empty( $deactivated_plugins ) ) {
4350
			$deactivated_plugins = explode( ',', $deactivated_plugins );
4351
			$deactivated_titles  = array();
4352
			foreach ( $deactivated_plugins as $deactivated_plugin ) {
4353
				if ( ! isset( $this->plugins_to_deactivate[ $deactivated_plugin ] ) ) {
4354
					continue;
4355
				}
4356
4357
				$deactivated_titles[] = '<strong>' . str_replace( ' ', '&nbsp;', $this->plugins_to_deactivate[ $deactivated_plugin ][1] ) . '</strong>';
4358
			}
4359
4360
			if ( $deactivated_titles ) {
4361
				if ( $this->message ) {
4362
					$this->message .= "<br /><br />\n";
4363
				}
4364
4365
				$this->message .= wp_sprintf(
4366
					_n(
4367
						'Jetpack contains the most recent version of the old %l plugin.',
4368
						'Jetpack contains the most recent versions of the old %l plugins.',
4369
						count( $deactivated_titles ),
4370
						'jetpack'
4371
					),
4372
					$deactivated_titles
4373
				);
4374
4375
				$this->message .= "<br />\n";
4376
4377
				$this->message .= _n(
4378
					'The old version has been deactivated and can be removed from your site.',
4379
					'The old versions have been deactivated and can be removed from your site.',
4380
					count( $deactivated_titles ),
4381
					'jetpack'
4382
				);
4383
			}
4384
		}
4385
4386
		$this->privacy_checks = self::state( 'privacy_checks' );
4387
4388
		if ( $this->message || $this->error || $this->privacy_checks ) {
4389
			add_action( 'jetpack_notices', array( $this, 'admin_notices' ) );
4390
		}
4391
4392
		add_filter( 'jetpack_short_module_description', 'wptexturize' );
4393
	}
4394
4395
	function admin_notices() {
4396
4397
		if ( $this->error ) {
4398
			?>
4399
<div id="message" class="jetpack-message jetpack-err">
4400
	<div class="squeezer">
4401
		<h2>
4402
			<?php
4403
			echo wp_kses(
4404
				$this->error,
4405
				array(
4406
					'a'      => array( 'href' => array() ),
4407
					'small'  => true,
4408
					'code'   => true,
4409
					'strong' => true,
4410
					'br'     => true,
4411
					'b'      => true,
4412
				)
4413
			);
4414
			?>
4415
			</h2>
4416
			<?php	if ( $desc = self::state( 'error_description' ) ) : ?>
4417
		<p><?php echo esc_html( stripslashes( $desc ) ); ?></p>
4418
<?php	endif; ?>
4419
	</div>
4420
</div>
4421
			<?php
4422
		}
4423
4424
		if ( $this->message ) {
4425
			?>
4426
<div id="message" class="jetpack-message">
4427
	<div class="squeezer">
4428
		<h2>
4429
			<?php
4430
			echo wp_kses(
4431
				$this->message,
4432
				array(
4433
					'strong' => array(),
4434
					'a'      => array( 'href' => true ),
4435
					'br'     => true,
4436
				)
4437
			);
4438
			?>
4439
			</h2>
4440
	</div>
4441
</div>
4442
			<?php
4443
		}
4444
4445
		if ( $this->privacy_checks ) :
4446
			$module_names = $module_slugs = array();
4447
4448
			$privacy_checks = explode( ',', $this->privacy_checks );
4449
			$privacy_checks = array_filter( $privacy_checks, array( 'Jetpack', 'is_module' ) );
4450
			foreach ( $privacy_checks as $module_slug ) {
4451
				$module = self::get_module( $module_slug );
4452
				if ( ! $module ) {
4453
					continue;
4454
				}
4455
4456
				$module_slugs[] = $module_slug;
4457
				$module_names[] = "<strong>{$module['name']}</strong>";
4458
			}
4459
4460
			$module_slugs = join( ',', $module_slugs );
4461
			?>
4462
<div id="message" class="jetpack-message jetpack-err">
4463
	<div class="squeezer">
4464
		<h2><strong><?php esc_html_e( 'Is this site private?', 'jetpack' ); ?></strong></h2><br />
4465
		<p>
4466
			<?php
4467
			echo wp_kses(
4468
				wptexturize(
4469
					wp_sprintf(
4470
						_nx(
4471
							"Like your site's RSS feeds, %l allows access to your posts and other content to third parties.",
4472
							"Like your site's RSS feeds, %l allow access to your posts and other content to third parties.",
4473
							count( $privacy_checks ),
4474
							'%l = list of Jetpack module/feature names',
4475
							'jetpack'
4476
						),
4477
						$module_names
4478
					)
4479
				),
4480
				array( 'strong' => true )
4481
			);
4482
4483
			echo "\n<br />\n";
4484
4485
			echo wp_kses(
4486
				sprintf(
4487
					_nx(
4488
						'If your site is not publicly accessible, consider <a href="%1$s" title="%2$s">deactivating this feature</a>.',
4489
						'If your site is not publicly accessible, consider <a href="%1$s" title="%2$s">deactivating these features</a>.',
4490
						count( $privacy_checks ),
4491
						'%1$s = deactivation URL, %2$s = "Deactivate {list of Jetpack module/feature names}',
4492
						'jetpack'
4493
					),
4494
					wp_nonce_url(
4495
						self::admin_url(
4496
							array(
4497
								'page'   => 'jetpack',
4498
								'action' => 'deactivate',
4499
								'module' => urlencode( $module_slugs ),
4500
							)
4501
						),
4502
						"jetpack_deactivate-$module_slugs"
4503
					),
4504
					esc_attr( wp_kses( wp_sprintf( _x( 'Deactivate %l', '%l = list of Jetpack module/feature names', 'jetpack' ), $module_names ), array() ) )
4505
				),
4506
				array(
4507
					'a' => array(
4508
						'href'  => true,
4509
						'title' => true,
4510
					),
4511
				)
4512
			);
4513
			?>
4514
		</p>
4515
	</div>
4516
</div>
4517
			<?php
4518
endif;
4519
	}
4520
4521
	/**
4522
	 * We can't always respond to a signed XML-RPC request with a
4523
	 * helpful error message. In some circumstances, doing so could
4524
	 * leak information.
4525
	 *
4526
	 * Instead, track that the error occurred via a Jetpack_Option,
4527
	 * and send that data back in the heartbeat.
4528
	 * All this does is increment a number, but it's enough to find
4529
	 * trends.
4530
	 *
4531
	 * @param WP_Error $xmlrpc_error The error produced during
4532
	 *                               signature validation.
4533
	 */
4534
	function track_xmlrpc_error( $xmlrpc_error ) {
4535
		$code = is_wp_error( $xmlrpc_error )
4536
			? $xmlrpc_error->get_error_code()
4537
			: 'should-not-happen';
4538
4539
		$xmlrpc_errors = Jetpack_Options::get_option( 'xmlrpc_errors', array() );
4540
		if ( isset( $xmlrpc_errors[ $code ] ) && $xmlrpc_errors[ $code ] ) {
4541
			// No need to update the option if we already have
4542
			// this code stored.
4543
			return;
4544
		}
4545
		$xmlrpc_errors[ $code ] = true;
4546
4547
		Jetpack_Options::update_option( 'xmlrpc_errors', $xmlrpc_errors, false );
4548
	}
4549
4550
	/**
4551
	 * Record a stat for later output.  This will only currently output in the admin_footer.
4552
	 */
4553
	function stat( $group, $detail ) {
4554
		if ( ! isset( $this->stats[ $group ] ) ) {
4555
			$this->stats[ $group ] = array();
4556
		}
4557
		$this->stats[ $group ][] = $detail;
4558
	}
4559
4560
	/**
4561
	 * Load stats pixels. $group is auto-prefixed with "x_jetpack-"
4562
	 */
4563
	function do_stats( $method = '' ) {
4564
		if ( is_array( $this->stats ) && count( $this->stats ) ) {
4565
			foreach ( $this->stats as $group => $stats ) {
4566
				if ( is_array( $stats ) && count( $stats ) ) {
4567
					$args = array( "x_jetpack-{$group}" => implode( ',', $stats ) );
4568
					if ( 'server_side' === $method ) {
4569
						self::do_server_side_stat( $args );
4570
					} else {
4571
						echo '<img src="' . esc_url( self::build_stats_url( $args ) ) . '" width="1" height="1" style="display:none;" />';
4572
					}
4573
				}
4574
				unset( $this->stats[ $group ] );
4575
			}
4576
		}
4577
	}
4578
4579
	/**
4580
	 * Runs stats code for a one-off, server-side.
4581
	 *
4582
	 * @param $args array|string The arguments to append to the URL. Should include `x_jetpack-{$group}={$stats}` or whatever we want to store.
4583
	 *
4584
	 * @return bool If it worked.
4585
	 */
4586
	static function do_server_side_stat( $args ) {
4587
		$response = wp_remote_get( esc_url_raw( self::build_stats_url( $args ) ) );
4588
		if ( is_wp_error( $response ) ) {
4589
			return false;
4590
		}
4591
4592
		if ( 200 !== wp_remote_retrieve_response_code( $response ) ) {
4593
			return false;
4594
		}
4595
4596
		return true;
4597
	}
4598
4599
	/**
4600
	 * Builds the stats url.
4601
	 *
4602
	 * @param $args array|string The arguments to append to the URL.
4603
	 *
4604
	 * @return string The URL to be pinged.
4605
	 */
4606
	static function build_stats_url( $args ) {
4607
		$defaults = array(
4608
			'v'    => 'wpcom2',
4609
			'rand' => md5( mt_rand( 0, 999 ) . time() ),
4610
		);
4611
		$args     = wp_parse_args( $args, $defaults );
4612
		/**
4613
		 * Filter the URL used as the Stats tracking pixel.
4614
		 *
4615
		 * @since 2.3.2
4616
		 *
4617
		 * @param string $url Base URL used as the Stats tracking pixel.
4618
		 */
4619
		$base_url = apply_filters(
4620
			'jetpack_stats_base_url',
4621
			'https://pixel.wp.com/g.gif'
4622
		);
4623
		$url      = add_query_arg( $args, $base_url );
4624
		return $url;
4625
	}
4626
4627
	/**
4628
	 * Get the role of the current user.
4629
	 *
4630
	 * @deprecated 7.6 Use Automattic\Jetpack\Roles::translate_current_user_to_role() instead.
4631
	 *
4632
	 * @access public
4633
	 * @static
4634
	 *
4635
	 * @return string|boolean Current user's role, false if not enough capabilities for any of the roles.
4636
	 */
4637
	public static function translate_current_user_to_role() {
4638
		_deprecated_function( __METHOD__, 'jetpack-7.6.0' );
4639
4640
		$roles = new Roles();
4641
		return $roles->translate_current_user_to_role();
4642
	}
4643
4644
	/**
4645
	 * Get the role of a particular user.
4646
	 *
4647
	 * @deprecated 7.6 Use Automattic\Jetpack\Roles::translate_user_to_role() instead.
4648
	 *
4649
	 * @access public
4650
	 * @static
4651
	 *
4652
	 * @param \WP_User $user User object.
4653
	 * @return string|boolean User's role, false if not enough capabilities for any of the roles.
4654
	 */
4655
	public static function translate_user_to_role( $user ) {
4656
		_deprecated_function( __METHOD__, 'jetpack-7.6.0' );
4657
4658
		$roles = new Roles();
4659
		return $roles->translate_user_to_role( $user );
4660
	}
4661
4662
	/**
4663
	 * Get the minimum capability for a role.
4664
	 *
4665
	 * @deprecated 7.6 Use Automattic\Jetpack\Roles::translate_role_to_cap() instead.
4666
	 *
4667
	 * @access public
4668
	 * @static
4669
	 *
4670
	 * @param string $role Role name.
4671
	 * @return string|boolean Capability, false if role isn't mapped to any capabilities.
4672
	 */
4673
	public static function translate_role_to_cap( $role ) {
4674
		_deprecated_function( __METHOD__, 'jetpack-7.6.0' );
4675
4676
		$roles = new Roles();
4677
		return $roles->translate_role_to_cap( $role );
4678
	}
4679
4680
	/**
4681
	 * Sign a user role with the master access token.
4682
	 * If not specified, will default to the current user.
4683
	 *
4684
	 * @deprecated since 7.7
4685
	 * @see Automattic\Jetpack\Connection\Manager::sign_role()
4686
	 *
4687
	 * @access public
4688
	 * @static
4689
	 *
4690
	 * @param string $role    User role.
4691
	 * @param int    $user_id ID of the user.
4692
	 * @return string Signed user role.
4693
	 */
4694
	public static function sign_role( $role, $user_id = null ) {
4695
		_deprecated_function( __METHOD__, 'jetpack-7.7', 'Automattic\\Jetpack\\Connection\\Manager::sign_role' );
4696
		return self::connection()->sign_role( $role, $user_id );
4697
	}
4698
4699
	/**
4700
	 * Builds a URL to the Jetpack connection auth page
4701
	 *
4702
	 * @since 3.9.5
4703
	 *
4704
	 * @param bool        $raw If true, URL will not be escaped.
4705
	 * @param bool|string $redirect If true, will redirect back to Jetpack wp-admin landing page after connection.
4706
	 *                              If string, will be a custom redirect.
4707
	 * @param bool|string $from If not false, adds 'from=$from' param to the connect URL.
4708
	 * @param bool        $register If true, will generate a register URL regardless of the existing token, since 4.9.0
4709
	 *
4710
	 * @return string Connect URL
4711
	 */
4712
	function build_connect_url( $raw = false, $redirect = false, $from = false, $register = false ) {
4713
		$site_id    = Jetpack_Options::get_option( 'id' );
4714
		$blog_token = Jetpack_Data::get_access_token();
4715
4716
		if ( $register || ! $blog_token || ! $site_id ) {
4717
			$url = self::nonce_url_no_esc( self::admin_url( 'action=register' ), 'jetpack-register' );
4718
4719
			if ( ! empty( $redirect ) ) {
4720
				$url = add_query_arg(
4721
					'redirect',
4722
					urlencode( wp_validate_redirect( esc_url_raw( $redirect ) ) ),
4723
					$url
4724
				);
4725
			}
4726
4727
			if ( is_network_admin() ) {
4728
				$url = add_query_arg( 'is_multisite', network_admin_url( 'admin.php?page=jetpack-settings' ), $url );
4729
			}
4730
4731
			$calypso_env = self::get_calypso_env();
4732
4733
			if ( ! empty( $calypso_env ) ) {
4734
				$url = add_query_arg( 'calypso_env', $calypso_env, $url );
4735
			}
4736
		} else {
4737
4738
			// Let's check the existing blog token to see if we need to re-register. We only check once per minute
4739
			// because otherwise this logic can get us in to a loop.
4740
			$last_connect_url_check = intval( Jetpack_Options::get_raw_option( 'jetpack_last_connect_url_check' ) );
4741
			if ( ! $last_connect_url_check || ( time() - $last_connect_url_check ) > MINUTE_IN_SECONDS ) {
4742
				Jetpack_Options::update_raw_option( 'jetpack_last_connect_url_check', time() );
4743
4744
				$response = Client::wpcom_json_api_request_as_blog(
4745
					sprintf( '/sites/%d', $site_id ) . '?force=wpcom',
4746
					'1.1'
4747
				);
4748
4749
				if ( 200 !== wp_remote_retrieve_response_code( $response ) ) {
4750
4751
					// Generating a register URL instead to refresh the existing token
4752
					return $this->build_connect_url( $raw, $redirect, $from, true );
4753
				}
4754
			}
4755
4756
			$url = $this->build_authorize_url( $redirect );
4757
		}
4758
4759
		if ( $from ) {
4760
			$url = add_query_arg( 'from', $from, $url );
4761
		}
4762
4763
		$url = $raw ? esc_url_raw( $url ) : esc_url( $url );
4764
		/**
4765
		 * Filter the URL used when connecting a user to a WordPress.com account.
4766
		 *
4767
		 * @since 8.1.0
4768
		 *
4769
		 * @param string $url Connection URL.
4770
		 * @param bool   $raw If true, URL will not be escaped.
4771
		 */
4772
		return apply_filters( 'jetpack_build_connection_url', $url, $raw );
4773
	}
4774
4775
	public static function build_authorize_url( $redirect = false, $iframe = false ) {
4776
4777
		add_filter( 'jetpack_connect_request_body', array( __CLASS__, 'filter_connect_request_body' ) );
4778
		add_filter( 'jetpack_connect_redirect_url', array( __CLASS__, 'filter_connect_redirect_url' ) );
4779
		add_filter( 'jetpack_connect_processing_url', array( __CLASS__, 'filter_connect_processing_url' ) );
4780
4781
		if ( $iframe ) {
4782
			add_filter( 'jetpack_use_iframe_authorization_flow', '__return_true' );
4783
		}
4784
4785
		$c8n = self::connection();
4786
		$url = $c8n->get_authorization_url( wp_get_current_user(), $redirect );
4787
4788
		remove_filter( 'jetpack_connect_request_body', array( __CLASS__, 'filter_connect_request_body' ) );
4789
		remove_filter( 'jetpack_connect_redirect_url', array( __CLASS__, 'filter_connect_redirect_url' ) );
4790
		remove_filter( 'jetpack_connect_processing_url', array( __CLASS__, 'filter_connect_processing_url' ) );
4791
4792
		if ( $iframe ) {
4793
			remove_filter( 'jetpack_use_iframe_authorization_flow', '__return_true' );
4794
		}
4795
4796
		return $url;
4797
	}
4798
4799
	/**
4800
	 * Filters the connection URL parameter array.
4801
	 *
4802
	 * @param Array $args default URL parameters used by the package.
4803
	 * @return Array the modified URL arguments array.
4804
	 */
4805
	public static function filter_connect_request_body( $args ) {
4806
		if (
4807
			Constants::is_defined( 'JETPACK__GLOTPRESS_LOCALES_PATH' )
4808
			&& include_once Constants::get_constant( 'JETPACK__GLOTPRESS_LOCALES_PATH' )
4809
		) {
4810
			$gp_locale = GP_Locales::by_field( 'wp_locale', get_locale() );
4811
			$args['locale'] = isset( $gp_locale ) && isset( $gp_locale->slug )
4812
				? $gp_locale->slug
4813
				: '';
4814
		}
4815
4816
		$tracking        = new Tracking();
4817
		$tracks_identity = $tracking->tracks_get_identity( $args['state'] );
4818
4819
		$args = array_merge(
4820
			$args,
4821
			array(
4822
				'_ui' => $tracks_identity['_ui'],
4823
				'_ut' => $tracks_identity['_ut'],
4824
			)
4825
		);
4826
4827
		$calypso_env = self::get_calypso_env();
4828
4829
		if ( ! empty( $calypso_env ) ) {
4830
			$args['calypso_env'] = $calypso_env;
4831
		}
4832
4833
		return $args;
4834
	}
4835
4836
	/**
4837
	 * Filters the URL that will process the connection data. It can be different from the URL
4838
	 * that we send the user to after everything is done.
4839
	 *
4840
	 * @param String $processing_url the default redirect URL used by the package.
4841
	 * @return String the modified URL.
4842
	 */
4843
	public static function filter_connect_processing_url( $processing_url ) {
4844
		$processing_url = admin_url( 'admin.php?page=jetpack' ); // Making PHPCS happy.
4845
		return $processing_url;
4846
	}
4847
4848
	/**
4849
	 * Filters the redirection URL that is used for connect requests. The redirect
4850
	 * URL should return the user back to the Jetpack console.
4851
	 *
4852
	 * @param String $redirect the default redirect URL used by the package.
4853
	 * @return String the modified URL.
4854
	 */
4855
	public static function filter_connect_redirect_url( $redirect ) {
4856
		$jetpack_admin_page = esc_url_raw( admin_url( 'admin.php?page=jetpack' ) );
4857
		$redirect           = $redirect
4858
			? wp_validate_redirect( esc_url_raw( $redirect ), $jetpack_admin_page )
4859
			: $jetpack_admin_page;
4860
4861
		if ( isset( $_REQUEST['is_multisite'] ) ) {
4862
			$redirect = Jetpack_Network::init()->get_url( 'network_admin_page' );
4863
		}
4864
4865
		return $redirect;
4866
	}
4867
4868
	/**
4869
	 * This action fires at the beginning of the Manager::authorize method.
4870
	 */
4871
	public static function authorize_starting() {
4872
		$jetpack_unique_connection = Jetpack_Options::get_option( 'unique_connection' );
4873
		// Checking if site has been active/connected previously before recording unique connection.
4874
		if ( ! $jetpack_unique_connection ) {
4875
			// jetpack_unique_connection option has never been set.
4876
			$jetpack_unique_connection = array(
4877
				'connected'    => 0,
4878
				'disconnected' => 0,
4879
				'version'      => '3.6.1',
4880
			);
4881
4882
			update_option( 'jetpack_unique_connection', $jetpack_unique_connection );
4883
4884
			// Track unique connection.
4885
			$jetpack = self::init();
4886
4887
			$jetpack->stat( 'connections', 'unique-connection' );
4888
			$jetpack->do_stats( 'server_side' );
4889
		}
4890
4891
		// Increment number of times connected.
4892
		$jetpack_unique_connection['connected'] += 1;
4893
		Jetpack_Options::update_option( 'unique_connection', $jetpack_unique_connection );
4894
	}
4895
4896
	/**
4897
	 * This action fires at the end of the Manager::authorize method when a secondary user is
4898
	 * linked.
4899
	 */
4900
	public static function authorize_ending_linked() {
4901
		// Don't activate anything since we are just connecting a user.
4902
		self::state( 'message', 'linked' );
4903
	}
4904
4905
	/**
4906
	 * This action fires at the end of the Manager::authorize method when the master user is
4907
	 * authorized.
4908
	 *
4909
	 * @param array $data The request data.
4910
	 */
4911
	public static function authorize_ending_authorized( $data ) {
4912
		// If this site has been through the Jetpack Onboarding flow, delete the onboarding token.
4913
		self::invalidate_onboarding_token();
4914
4915
		// If redirect_uri is SSO, ensure SSO module is enabled.
4916
		parse_str( wp_parse_url( $data['redirect_uri'], PHP_URL_QUERY ), $redirect_options );
4917
4918
		/** This filter is documented in class.jetpack-cli.php */
4919
		$jetpack_start_enable_sso = apply_filters( 'jetpack_start_enable_sso', true );
4920
4921
		$activate_sso = (
4922
			isset( $redirect_options['action'] ) &&
4923
			'jetpack-sso' === $redirect_options['action'] &&
4924
			$jetpack_start_enable_sso
4925
		);
4926
4927
		$do_redirect_on_error = ( 'client' === $data['auth_type'] );
4928
4929
		self::handle_post_authorization_actions( $activate_sso, $do_redirect_on_error );
4930
	}
4931
4932
	/**
4933
	 * Get our assumed site creation date.
4934
	 * Calculated based on the earlier date of either:
4935
	 * - Earliest admin user registration date.
4936
	 * - Earliest date of post of any post type.
4937
	 *
4938
	 * @since 7.2.0
4939
	 * @deprecated since 7.8.0
4940
	 *
4941
	 * @return string Assumed site creation date and time.
4942
	 */
4943
	public static function get_assumed_site_creation_date() {
4944
		_deprecated_function( __METHOD__, 'jetpack-7.8', 'Automattic\\Jetpack\\Connection\\Manager' );
4945
		return self::connection()->get_assumed_site_creation_date();
4946
	}
4947
4948 View Code Duplication
	public static function apply_activation_source_to_args( &$args ) {
4949
		list( $activation_source_name, $activation_source_keyword ) = get_option( 'jetpack_activation_source' );
4950
4951
		if ( $activation_source_name ) {
4952
			$args['_as'] = urlencode( $activation_source_name );
4953
		}
4954
4955
		if ( $activation_source_keyword ) {
4956
			$args['_ak'] = urlencode( $activation_source_keyword );
4957
		}
4958
	}
4959
4960
	function build_reconnect_url( $raw = false ) {
4961
		$url = wp_nonce_url( self::admin_url( 'action=reconnect' ), 'jetpack-reconnect' );
4962
		return $raw ? $url : esc_url( $url );
4963
	}
4964
4965
	public static function admin_url( $args = null ) {
4966
		$args = wp_parse_args( $args, array( 'page' => 'jetpack' ) );
4967
		$url  = add_query_arg( $args, admin_url( 'admin.php' ) );
4968
		return $url;
4969
	}
4970
4971
	public static function nonce_url_no_esc( $actionurl, $action = -1, $name = '_wpnonce' ) {
4972
		$actionurl = str_replace( '&amp;', '&', $actionurl );
4973
		return add_query_arg( $name, wp_create_nonce( $action ), $actionurl );
4974
	}
4975
4976
	function dismiss_jetpack_notice() {
4977
4978
		if ( ! isset( $_GET['jetpack-notice'] ) ) {
4979
			return;
4980
		}
4981
4982
		switch ( $_GET['jetpack-notice'] ) {
4983
			case 'dismiss':
4984
				if ( check_admin_referer( 'jetpack-deactivate' ) && ! is_plugin_active_for_network( plugin_basename( JETPACK__PLUGIN_DIR . 'jetpack.php' ) ) ) {
4985
4986
					require_once ABSPATH . 'wp-admin/includes/plugin.php';
4987
					deactivate_plugins( JETPACK__PLUGIN_DIR . 'jetpack.php', false, false );
4988
					wp_safe_redirect( admin_url() . 'plugins.php?deactivate=true&plugin_status=all&paged=1&s=' );
4989
				}
4990
				break;
4991
		}
4992
	}
4993
4994
	public static function sort_modules( $a, $b ) {
4995
		if ( $a['sort'] == $b['sort'] ) {
4996
			return 0;
4997
		}
4998
4999
		return ( $a['sort'] < $b['sort'] ) ? -1 : 1;
5000
	}
5001
5002
	function ajax_recheck_ssl() {
5003
		check_ajax_referer( 'recheck-ssl', 'ajax-nonce' );
5004
		$result = self::permit_ssl( true );
5005
		wp_send_json(
5006
			array(
5007
				'enabled' => $result,
5008
				'message' => get_transient( 'jetpack_https_test_message' ),
5009
			)
5010
		);
5011
	}
5012
5013
	/* Client API */
5014
5015
	/**
5016
	 * Returns the requested Jetpack API URL
5017
	 *
5018
	 * @deprecated since 7.7
5019
	 * @return string
5020
	 */
5021
	public static function api_url( $relative_url ) {
5022
		_deprecated_function( __METHOD__, 'jetpack-7.7', 'Automattic\\Jetpack\\Connection\\Manager::api_url' );
5023
		$connection = self::connection();
5024
		return $connection->api_url( $relative_url );
5025
	}
5026
5027
	/**
5028
	 * @deprecated 8.0 Use Automattic\Jetpack\Connection\Utils::fix_url_for_bad_hosts() instead.
5029
	 *
5030
	 * Some hosts disable the OpenSSL extension and so cannot make outgoing HTTPS requsets
5031
	 */
5032
	public static function fix_url_for_bad_hosts( $url ) {
5033
		_deprecated_function( __METHOD__, 'jetpack-8.0', 'Automattic\\Jetpack\\Connection\\Utils::fix_url_for_bad_hosts' );
5034
		return Connection_Utils::fix_url_for_bad_hosts( $url );
5035
	}
5036
5037
	public static function verify_onboarding_token( $token_data, $token, $request_data ) {
5038
		// Default to a blog token.
5039
		$token_type = 'blog';
5040
5041
		// Let's see if this is onboarding. In such case, use user token type and the provided user id.
5042
		if ( isset( $request_data ) || ! empty( $_GET['onboarding'] ) ) {
5043
			if ( ! empty( $_GET['onboarding'] ) ) {
5044
				$jpo = $_GET;
5045
			} else {
5046
				$jpo = json_decode( $request_data, true );
5047
			}
5048
5049
			$jpo_token = ! empty( $jpo['onboarding']['token'] ) ? $jpo['onboarding']['token'] : null;
5050
			$jpo_user  = ! empty( $jpo['onboarding']['jpUser'] ) ? $jpo['onboarding']['jpUser'] : null;
5051
5052
			if (
5053
				isset( $jpo_user )
5054
				&& isset( $jpo_token )
5055
				&& is_email( $jpo_user )
5056
				&& ctype_alnum( $jpo_token )
5057
				&& isset( $_GET['rest_route'] )
5058
				&& self::validate_onboarding_token_action(
5059
					$jpo_token,
5060
					$_GET['rest_route']
5061
				)
5062
			) {
5063
				$jp_user = get_user_by( 'email', $jpo_user );
5064
				if ( is_a( $jp_user, 'WP_User' ) ) {
5065
					wp_set_current_user( $jp_user->ID );
5066
					$user_can = is_multisite()
5067
						? current_user_can_for_blog( get_current_blog_id(), 'manage_options' )
5068
						: current_user_can( 'manage_options' );
5069
					if ( $user_can ) {
5070
						$token_type              = 'user';
5071
						$token->external_user_id = $jp_user->ID;
5072
					}
5073
				}
5074
			}
5075
5076
			$token_data['type']    = $token_type;
5077
			$token_data['user_id'] = $token->external_user_id;
5078
		}
5079
5080
		return $token_data;
5081
	}
5082
5083
	/**
5084
	 * Create a random secret for validating onboarding payload
5085
	 *
5086
	 * @return string Secret token
5087
	 */
5088
	public static function create_onboarding_token() {
5089
		if ( false === ( $token = Jetpack_Options::get_option( 'onboarding' ) ) ) {
5090
			$token = wp_generate_password( 32, false );
5091
			Jetpack_Options::update_option( 'onboarding', $token );
5092
		}
5093
5094
		return $token;
5095
	}
5096
5097
	/**
5098
	 * Remove the onboarding token
5099
	 *
5100
	 * @return bool True on success, false on failure
5101
	 */
5102
	public static function invalidate_onboarding_token() {
5103
		return Jetpack_Options::delete_option( 'onboarding' );
5104
	}
5105
5106
	/**
5107
	 * Validate an onboarding token for a specific action
5108
	 *
5109
	 * @return boolean True if token/action pair is accepted, false if not
5110
	 */
5111
	public static function validate_onboarding_token_action( $token, $action ) {
5112
		// Compare tokens, bail if tokens do not match
5113
		if ( ! hash_equals( $token, Jetpack_Options::get_option( 'onboarding' ) ) ) {
5114
			return false;
5115
		}
5116
5117
		// List of valid actions we can take
5118
		$valid_actions = array(
5119
			'/jetpack/v4/settings',
5120
		);
5121
5122
		// Whitelist the action
5123
		if ( ! in_array( $action, $valid_actions ) ) {
5124
			return false;
5125
		}
5126
5127
		return true;
5128
	}
5129
5130
	/**
5131
	 * Checks to see if the URL is using SSL to connect with Jetpack
5132
	 *
5133
	 * @since 2.3.3
5134
	 * @return boolean
5135
	 */
5136
	public static function permit_ssl( $force_recheck = false ) {
5137
		// Do some fancy tests to see if ssl is being supported
5138
		if ( $force_recheck || false === ( $ssl = get_transient( 'jetpack_https_test' ) ) ) {
5139
			$message = '';
5140
			if ( 'https' !== substr( JETPACK__API_BASE, 0, 5 ) ) {
5141
				$ssl = 0;
5142
			} else {
5143
				switch ( JETPACK_CLIENT__HTTPS ) {
5144
					case 'NEVER':
5145
						$ssl     = 0;
5146
						$message = __( 'JETPACK_CLIENT__HTTPS is set to NEVER', 'jetpack' );
5147
						break;
5148
					case 'ALWAYS':
5149
					case 'AUTO':
5150
					default:
5151
						$ssl = 1;
5152
						break;
5153
				}
5154
5155
				// If it's not 'NEVER', test to see
5156
				if ( $ssl ) {
5157
					if ( ! wp_http_supports( array( 'ssl' => true ) ) ) {
5158
						$ssl     = 0;
5159
						$message = __( 'WordPress reports no SSL support', 'jetpack' );
5160
					} else {
5161
						$response = wp_remote_get( JETPACK__API_BASE . 'test/1/' );
5162
						if ( is_wp_error( $response ) ) {
5163
							$ssl     = 0;
5164
							$message = __( 'WordPress reports no SSL support', 'jetpack' );
5165
						} elseif ( 'OK' !== wp_remote_retrieve_body( $response ) ) {
5166
							$ssl     = 0;
5167
							$message = __( 'Response was not OK: ', 'jetpack' ) . wp_remote_retrieve_body( $response );
5168
						}
5169
					}
5170
				}
5171
			}
5172
			set_transient( 'jetpack_https_test', $ssl, DAY_IN_SECONDS );
5173
			set_transient( 'jetpack_https_test_message', $message, DAY_IN_SECONDS );
5174
		}
5175
5176
		return (bool) $ssl;
5177
	}
5178
5179
	/*
5180
	 * Displays an admin_notice, alerting the user to their JETPACK_CLIENT__HTTPS constant being 'AUTO' but SSL isn't working.
5181
	 */
5182
	public function alert_auto_ssl_fail() {
5183
		if ( ! current_user_can( 'manage_options' ) ) {
5184
			return;
5185
		}
5186
5187
		$ajax_nonce = wp_create_nonce( 'recheck-ssl' );
5188
		?>
5189
5190
		<div id="jetpack-ssl-warning" class="error jp-identity-crisis">
5191
			<div class="jp-banner__content">
5192
				<h2><?php _e( 'Outbound HTTPS not working', 'jetpack' ); ?></h2>
5193
				<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>
5194
				<p>
5195
					<?php _e( 'Jetpack will re-test for HTTPS support once a day, but you can click here to try again immediately: ', 'jetpack' ); ?>
5196
					<a href="#" id="jetpack-recheck-ssl-button"><?php _e( 'Try again', 'jetpack' ); ?></a>
5197
					<span id="jetpack-recheck-ssl-output"><?php echo get_transient( 'jetpack_https_test_message' ); ?></span>
5198
				</p>
5199
				<p>
5200
					<?php
5201
					printf(
5202
						__( 'For more help, try our <a href="%1$s">connection debugger</a> or <a href="%2$s" target="_blank">troubleshooting tips</a>.', 'jetpack' ),
5203
						esc_url( self::admin_url( array( 'page' => 'jetpack-debugger' ) ) ),
5204
						esc_url( self::build_redirect_url( 'jetpack-support-getting-started-troubleshooting-tips' ) )
5205
					);
5206
					?>
5207
				</p>
5208
			</div>
5209
		</div>
5210
		<style>
5211
			#jetpack-recheck-ssl-output { margin-left: 5px; color: red; }
5212
		</style>
5213
		<script type="text/javascript">
5214
			jQuery( document ).ready( function( $ ) {
5215
				$( '#jetpack-recheck-ssl-button' ).click( function( e ) {
5216
					var $this = $( this );
5217
					$this.html( <?php echo json_encode( __( 'Checking', 'jetpack' ) ); ?> );
5218
					$( '#jetpack-recheck-ssl-output' ).html( '' );
5219
					e.preventDefault();
5220
					var data = { action: 'jetpack-recheck-ssl', 'ajax-nonce': '<?php echo $ajax_nonce; ?>' };
5221
					$.post( ajaxurl, data )
5222
					  .done( function( response ) {
5223
						  if ( response.enabled ) {
5224
							  $( '#jetpack-ssl-warning' ).hide();
5225
						  } else {
5226
							  this.html( <?php echo json_encode( __( 'Try again', 'jetpack' ) ); ?> );
5227
							  $( '#jetpack-recheck-ssl-output' ).html( 'SSL Failed: ' + response.message );
5228
						  }
5229
					  }.bind( $this ) );
5230
				} );
5231
			} );
5232
		</script>
5233
5234
		<?php
5235
	}
5236
5237
	/**
5238
	 * Returns the Jetpack XML-RPC API
5239
	 *
5240
	 * @deprecated 8.0 Use Connection_Manager instead.
5241
	 * @return string
5242
	 */
5243
	public static function xmlrpc_api_url() {
5244
		_deprecated_function( __METHOD__, 'jetpack-8.0', 'Automattic\\Jetpack\\Connection\\Manager::xmlrpc_api_url()' );
5245
		return self::connection()->xmlrpc_api_url();
5246
	}
5247
5248
	/**
5249
	 * Returns the connection manager object.
5250
	 *
5251
	 * @return Automattic\Jetpack\Connection\Manager
5252
	 */
5253
	public static function connection() {
5254
		$jetpack = static::init();
5255
5256
		// If the connection manager hasn't been instantiated, do that now.
5257
		if ( ! $jetpack->connection_manager ) {
5258
			$jetpack->connection_manager = new Connection_Manager();
5259
		}
5260
5261
		return $jetpack->connection_manager;
5262
	}
5263
5264
	/**
5265
	 * Creates two secret tokens and the end of life timestamp for them.
5266
	 *
5267
	 * Note these tokens are unique per call, NOT static per site for connecting.
5268
	 *
5269
	 * @since 2.6
5270
	 * @param String  $action  The action name.
5271
	 * @param Integer $user_id The user identifier.
5272
	 * @param Integer $exp     Expiration time in seconds.
5273
	 * @return array
5274
	 */
5275
	public static function generate_secrets( $action, $user_id = false, $exp = 600 ) {
5276
		return self::connection()->generate_secrets( $action, $user_id, $exp );
5277
	}
5278
5279
	public static function get_secrets( $action, $user_id ) {
5280
		$secrets = self::connection()->get_secrets( $action, $user_id );
5281
5282
		if ( Connection_Manager::SECRETS_MISSING === $secrets ) {
5283
			return new WP_Error( 'verify_secrets_missing', 'Verification secrets not found' );
5284
		}
5285
5286
		if ( Connection_Manager::SECRETS_EXPIRED === $secrets ) {
5287
			return new WP_Error( 'verify_secrets_expired', 'Verification took too long' );
5288
		}
5289
5290
		return $secrets;
5291
	}
5292
5293
	/**
5294
	 * @deprecated 7.5 Use Connection_Manager instead.
5295
	 *
5296
	 * @param $action
5297
	 * @param $user_id
5298
	 */
5299
	public static function delete_secrets( $action, $user_id ) {
5300
		return self::connection()->delete_secrets( $action, $user_id );
5301
	}
5302
5303
	/**
5304
	 * Builds the timeout limit for queries talking with the wpcom servers.
5305
	 *
5306
	 * Based on local php max_execution_time in php.ini
5307
	 *
5308
	 * @since 2.6
5309
	 * @return int
5310
	 * @deprecated
5311
	 **/
5312
	public function get_remote_query_timeout_limit() {
5313
		_deprecated_function( __METHOD__, 'jetpack-5.4' );
5314
		return self::get_max_execution_time();
5315
	}
5316
5317
	/**
5318
	 * Builds the timeout limit for queries talking with the wpcom servers.
5319
	 *
5320
	 * Based on local php max_execution_time in php.ini
5321
	 *
5322
	 * @since 5.4
5323
	 * @return int
5324
	 **/
5325
	public static function get_max_execution_time() {
5326
		$timeout = (int) ini_get( 'max_execution_time' );
5327
5328
		// Ensure exec time set in php.ini
5329
		if ( ! $timeout ) {
5330
			$timeout = 30;
5331
		}
5332
		return $timeout;
5333
	}
5334
5335
	/**
5336
	 * Sets a minimum request timeout, and returns the current timeout
5337
	 *
5338
	 * @since 5.4
5339
	 **/
5340 View Code Duplication
	public static function set_min_time_limit( $min_timeout ) {
5341
		$timeout = self::get_max_execution_time();
5342
		if ( $timeout < $min_timeout ) {
5343
			$timeout = $min_timeout;
5344
			set_time_limit( $timeout );
5345
		}
5346
		return $timeout;
5347
	}
5348
5349
	/**
5350
	 * Takes the response from the Jetpack register new site endpoint and
5351
	 * verifies it worked properly.
5352
	 *
5353
	 * @since 2.6
5354
	 * @deprecated since 7.7.0
5355
	 * @see Automattic\Jetpack\Connection\Manager::validate_remote_register_response()
5356
	 **/
5357
	public function validate_remote_register_response() {
5358
		_deprecated_function( __METHOD__, 'jetpack-7.7', 'Automattic\\Jetpack\\Connection\\Manager::validate_remote_register_response' );
5359
	}
5360
5361
	/**
5362
	 * @return bool|WP_Error
5363
	 */
5364
	public static function register() {
5365
		$tracking = new Tracking();
5366
		$tracking->record_user_event( 'jpc_register_begin' );
5367
5368
		add_filter( 'jetpack_register_request_body', array( __CLASS__, 'filter_register_request_body' ) );
5369
5370
		$connection   = self::connection();
5371
		$registration = $connection->register();
5372
5373
		remove_filter( 'jetpack_register_request_body', array( __CLASS__, 'filter_register_request_body' ) );
5374
5375
		if ( ! $registration || is_wp_error( $registration ) ) {
5376
			return $registration;
5377
		}
5378
5379
		return true;
5380
	}
5381
5382
	/**
5383
	 * Filters the registration request body to include tracking properties.
5384
	 *
5385
	 * @param Array $properties
5386
	 * @return Array amended properties.
5387
	 */
5388 View Code Duplication
	public static function filter_register_request_body( $properties ) {
5389
		$tracking        = new Tracking();
5390
		$tracks_identity = $tracking->tracks_get_identity( get_current_user_id() );
5391
5392
		return array_merge(
5393
			$properties,
5394
			array(
5395
				'_ui' => $tracks_identity['_ui'],
5396
				'_ut' => $tracks_identity['_ut'],
5397
			)
5398
		);
5399
	}
5400
5401
	/**
5402
	 * Filters the token request body to include tracking properties.
5403
	 *
5404
	 * @param Array $properties
5405
	 * @return Array amended properties.
5406
	 */
5407 View Code Duplication
	public static function filter_token_request_body( $properties ) {
5408
		$tracking        = new Tracking();
5409
		$tracks_identity = $tracking->tracks_get_identity( get_current_user_id() );
5410
5411
		return array_merge(
5412
			$properties,
5413
			array(
5414
				'_ui' => $tracks_identity['_ui'],
5415
				'_ut' => $tracks_identity['_ut'],
5416
			)
5417
		);
5418
	}
5419
5420
	/**
5421
	 * If the db version is showing something other that what we've got now, bump it to current.
5422
	 *
5423
	 * @return bool: True if the option was incorrect and updated, false if nothing happened.
5424
	 */
5425
	public static function maybe_set_version_option() {
5426
		list( $version ) = explode( ':', Jetpack_Options::get_option( 'version' ) );
5427
		if ( JETPACK__VERSION != $version ) {
5428
			Jetpack_Options::update_option( 'version', JETPACK__VERSION . ':' . time() );
5429
5430
			if ( version_compare( JETPACK__VERSION, $version, '>' ) ) {
5431
				/** This action is documented in class.jetpack.php */
5432
				do_action( 'updating_jetpack_version', JETPACK__VERSION, $version );
5433
			}
5434
5435
			return true;
5436
		}
5437
		return false;
5438
	}
5439
5440
	/* Client Server API */
5441
5442
	/**
5443
	 * Loads the Jetpack XML-RPC client.
5444
	 * No longer necessary, as the XML-RPC client will be automagically loaded.
5445
	 *
5446
	 * @deprecated since 7.7.0
5447
	 */
5448
	public static function load_xml_rpc_client() {
5449
		_deprecated_function( __METHOD__, 'jetpack-7.7' );
5450
	}
5451
5452
	/**
5453
	 * Resets the saved authentication state in between testing requests.
5454
	 */
5455
	public function reset_saved_auth_state() {
5456
		$this->rest_authentication_status = null;
5457
5458
		if ( ! $this->connection_manager ) {
5459
			$this->connection_manager = new Connection_Manager();
5460
		}
5461
5462
		$this->connection_manager->reset_saved_auth_state();
5463
	}
5464
5465
	/**
5466
	 * Verifies the signature of the current request.
5467
	 *
5468
	 * @deprecated since 7.7.0
5469
	 * @see Automattic\Jetpack\Connection\Manager::verify_xml_rpc_signature()
5470
	 *
5471
	 * @return false|array
5472
	 */
5473
	public function verify_xml_rpc_signature() {
5474
		_deprecated_function( __METHOD__, 'jetpack-7.7', 'Automattic\\Jetpack\\Connection\\Manager::verify_xml_rpc_signature' );
5475
		return self::connection()->verify_xml_rpc_signature();
5476
	}
5477
5478
	/**
5479
	 * Verifies the signature of the current request.
5480
	 *
5481
	 * This function has side effects and should not be used. Instead,
5482
	 * use the memoized version `->verify_xml_rpc_signature()`.
5483
	 *
5484
	 * @deprecated since 7.7.0
5485
	 * @see Automattic\Jetpack\Connection\Manager::internal_verify_xml_rpc_signature()
5486
	 * @internal
5487
	 */
5488
	private function internal_verify_xml_rpc_signature() {
5489
		_deprecated_function( __METHOD__, 'jetpack-7.7', 'Automattic\\Jetpack\\Connection\\Manager::internal_verify_xml_rpc_signature' );
5490
	}
5491
5492
	/**
5493
	 * Authenticates XML-RPC and other requests from the Jetpack Server.
5494
	 *
5495
	 * @deprecated since 7.7.0
5496
	 * @see Automattic\Jetpack\Connection\Manager::authenticate_jetpack()
5497
	 *
5498
	 * @param \WP_User|mixed $user     User object if authenticated.
5499
	 * @param string         $username Username.
5500
	 * @param string         $password Password string.
5501
	 * @return \WP_User|mixed Authenticated user or error.
5502
	 */
5503 View Code Duplication
	public function authenticate_jetpack( $user, $username, $password ) {
5504
		_deprecated_function( __METHOD__, 'jetpack-7.7', 'Automattic\\Jetpack\\Connection\\Manager::authenticate_jetpack' );
5505
5506
		if ( ! $this->connection_manager ) {
5507
			$this->connection_manager = new Connection_Manager();
5508
		}
5509
5510
		return $this->connection_manager->authenticate_jetpack( $user, $username, $password );
5511
	}
5512
5513
	// Authenticates requests from Jetpack server to WP REST API endpoints.
5514
	// Uses the existing XMLRPC request signing implementation.
5515
	function wp_rest_authenticate( $user ) {
5516
		if ( ! empty( $user ) ) {
5517
			// Another authentication method is in effect.
5518
			return $user;
5519
		}
5520
5521
		if ( ! isset( $_GET['_for'] ) || $_GET['_for'] !== 'jetpack' ) {
5522
			// Nothing to do for this authentication method.
5523
			return null;
5524
		}
5525
5526
		if ( ! isset( $_GET['token'] ) && ! isset( $_GET['signature'] ) ) {
5527
			// Nothing to do for this authentication method.
5528
			return null;
5529
		}
5530
5531
		// Ensure that we always have the request body available.  At this
5532
		// point, the WP REST API code to determine the request body has not
5533
		// run yet.  That code may try to read from 'php://input' later, but
5534
		// this can only be done once per request in PHP versions prior to 5.6.
5535
		// So we will go ahead and perform this read now if needed, and save
5536
		// the request body where both the Jetpack signature verification code
5537
		// and the WP REST API code can see it.
5538
		if ( ! isset( $GLOBALS['HTTP_RAW_POST_DATA'] ) ) {
5539
			$GLOBALS['HTTP_RAW_POST_DATA'] = file_get_contents( 'php://input' );
5540
		}
5541
		$this->HTTP_RAW_POST_DATA = $GLOBALS['HTTP_RAW_POST_DATA'];
5542
5543
		// Only support specific request parameters that have been tested and
5544
		// are known to work with signature verification.  A different method
5545
		// can be passed to the WP REST API via the '?_method=' parameter if
5546
		// needed.
5547
		if ( $_SERVER['REQUEST_METHOD'] !== 'GET' && $_SERVER['REQUEST_METHOD'] !== 'POST' ) {
5548
			$this->rest_authentication_status = new WP_Error(
5549
				'rest_invalid_request',
5550
				__( 'This request method is not supported.', 'jetpack' ),
5551
				array( 'status' => 400 )
5552
			);
5553
			return null;
5554
		}
5555
		if ( $_SERVER['REQUEST_METHOD'] !== 'POST' && ! empty( $this->HTTP_RAW_POST_DATA ) ) {
5556
			$this->rest_authentication_status = new WP_Error(
5557
				'rest_invalid_request',
5558
				__( 'This request method does not support body parameters.', 'jetpack' ),
5559
				array( 'status' => 400 )
5560
			);
5561
			return null;
5562
		}
5563
5564
		if ( ! $this->connection_manager ) {
5565
			$this->connection_manager = new Connection_Manager();
5566
		}
5567
5568
		$verified = $this->connection_manager->verify_xml_rpc_signature();
5569
5570
		if (
5571
			$verified &&
5572
			isset( $verified['type'] ) &&
5573
			'user' === $verified['type'] &&
5574
			! empty( $verified['user_id'] )
5575
		) {
5576
			// Authentication successful.
5577
			$this->rest_authentication_status = true;
5578
			return $verified['user_id'];
5579
		}
5580
5581
		// Something else went wrong.  Probably a signature error.
5582
		$this->rest_authentication_status = new WP_Error(
5583
			'rest_invalid_signature',
5584
			__( 'The request is not signed correctly.', 'jetpack' ),
5585
			array( 'status' => 400 )
5586
		);
5587
		return null;
5588
	}
5589
5590
	/**
5591
	 * Report authentication status to the WP REST API.
5592
	 *
5593
	 * @param  WP_Error|mixed $result Error from another authentication handler, null if we should handle it, or another value if not
5594
	 * @return WP_Error|boolean|null {@see WP_JSON_Server::check_authentication}
5595
	 */
5596
	public function wp_rest_authentication_errors( $value ) {
5597
		if ( $value !== null ) {
5598
			return $value;
5599
		}
5600
		return $this->rest_authentication_status;
5601
	}
5602
5603
	/**
5604
	 * Add our nonce to this request.
5605
	 *
5606
	 * @deprecated since 7.7.0
5607
	 * @see Automattic\Jetpack\Connection\Manager::add_nonce()
5608
	 *
5609
	 * @param int    $timestamp Timestamp of the request.
5610
	 * @param string $nonce     Nonce string.
5611
	 */
5612 View Code Duplication
	public function add_nonce( $timestamp, $nonce ) {
5613
		_deprecated_function( __METHOD__, 'jetpack-7.7', 'Automattic\\Jetpack\\Connection\\Manager::add_nonce' );
5614
5615
		if ( ! $this->connection_manager ) {
5616
			$this->connection_manager = new Connection_Manager();
5617
		}
5618
5619
		return $this->connection_manager->add_nonce( $timestamp, $nonce );
5620
	}
5621
5622
	/**
5623
	 * In some setups, $HTTP_RAW_POST_DATA can be emptied during some IXR_Server paths since it is passed by reference to various methods.
5624
	 * Capture it here so we can verify the signature later.
5625
	 *
5626
	 * @deprecated since 7.7.0
5627
	 * @see Automattic\Jetpack\Connection\Manager::xmlrpc_methods()
5628
	 *
5629
	 * @param array $methods XMLRPC methods.
5630
	 * @return array XMLRPC methods, with the $HTTP_RAW_POST_DATA one.
5631
	 */
5632 View Code Duplication
	public function xmlrpc_methods( $methods ) {
5633
		_deprecated_function( __METHOD__, 'jetpack-7.7', 'Automattic\\Jetpack\\Connection\\Manager::xmlrpc_methods' );
5634
5635
		if ( ! $this->connection_manager ) {
5636
			$this->connection_manager = new Connection_Manager();
5637
		}
5638
5639
		return $this->connection_manager->xmlrpc_methods( $methods );
5640
	}
5641
5642
	/**
5643
	 * Register additional public XMLRPC methods.
5644
	 *
5645
	 * @deprecated since 7.7.0
5646
	 * @see Automattic\Jetpack\Connection\Manager::public_xmlrpc_methods()
5647
	 *
5648
	 * @param array $methods Public XMLRPC methods.
5649
	 * @return array Public XMLRPC methods, with the getOptions one.
5650
	 */
5651 View Code Duplication
	public function public_xmlrpc_methods( $methods ) {
5652
		_deprecated_function( __METHOD__, 'jetpack-7.7', 'Automattic\\Jetpack\\Connection\\Manager::public_xmlrpc_methods' );
5653
5654
		if ( ! $this->connection_manager ) {
5655
			$this->connection_manager = new Connection_Manager();
5656
		}
5657
5658
		return $this->connection_manager->public_xmlrpc_methods( $methods );
5659
	}
5660
5661
	/**
5662
	 * Handles a getOptions XMLRPC method call.
5663
	 *
5664
	 * @deprecated since 7.7.0
5665
	 * @see Automattic\Jetpack\Connection\Manager::jetpack_getOptions()
5666
	 *
5667
	 * @param array $args method call arguments.
5668
	 * @return array an amended XMLRPC server options array.
5669
	 */
5670 View Code Duplication
	public function jetpack_getOptions( $args ) { // phpcs:ignore WordPress.NamingConventions.ValidFunctionName.MethodNameInvalid
5671
		_deprecated_function( __METHOD__, 'jetpack-7.7', 'Automattic\\Jetpack\\Connection\\Manager::jetpack_getOptions' );
5672
5673
		if ( ! $this->connection_manager ) {
5674
			$this->connection_manager = new Connection_Manager();
5675
		}
5676
5677
		return $this->connection_manager->jetpack_getOptions( $args );
5678
	}
5679
5680
	/**
5681
	 * Adds Jetpack-specific options to the output of the XMLRPC options method.
5682
	 *
5683
	 * @deprecated since 7.7.0
5684
	 * @see Automattic\Jetpack\Connection\Manager::xmlrpc_options()
5685
	 *
5686
	 * @param array $options Standard Core options.
5687
	 * @return array Amended options.
5688
	 */
5689 View Code Duplication
	public function xmlrpc_options( $options ) {
5690
		_deprecated_function( __METHOD__, 'jetpack-7.7', 'Automattic\\Jetpack\\Connection\\Manager::xmlrpc_options' );
5691
5692
		if ( ! $this->connection_manager ) {
5693
			$this->connection_manager = new Connection_Manager();
5694
		}
5695
5696
		return $this->connection_manager->xmlrpc_options( $options );
5697
	}
5698
5699
	/**
5700
	 * Cleans nonces that were saved when calling ::add_nonce.
5701
	 *
5702
	 * @deprecated since 7.7.0
5703
	 * @see Automattic\Jetpack\Connection\Manager::clean_nonces()
5704
	 *
5705
	 * @param bool $all whether to clean even non-expired nonces.
5706
	 */
5707
	public static function clean_nonces( $all = false ) {
5708
		_deprecated_function( __METHOD__, 'jetpack-7.7', 'Automattic\\Jetpack\\Connection\\Manager::clean_nonces' );
5709
		return self::connection()->clean_nonces( $all );
5710
	}
5711
5712
	/**
5713
	 * State is passed via cookies from one request to the next, but never to subsequent requests.
5714
	 * SET: state( $key, $value );
5715
	 * GET: $value = state( $key );
5716
	 *
5717
	 * @param string $key
5718
	 * @param string $value
5719
	 * @param bool   $restate private
5720
	 */
5721
	public static function state( $key = null, $value = null, $restate = false ) {
5722
		static $state = array();
5723
		static $path, $domain;
5724
		if ( ! isset( $path ) ) {
5725
			require_once ABSPATH . 'wp-admin/includes/plugin.php';
5726
			$admin_url = self::admin_url();
5727
			$bits      = wp_parse_url( $admin_url );
5728
5729
			if ( is_array( $bits ) ) {
5730
				$path   = ( isset( $bits['path'] ) ) ? dirname( $bits['path'] ) : null;
5731
				$domain = ( isset( $bits['host'] ) ) ? $bits['host'] : null;
5732
			} else {
5733
				$path = $domain = null;
5734
			}
5735
		}
5736
5737
		// Extract state from cookies and delete cookies
5738
		if ( isset( $_COOKIE['jetpackState'] ) && is_array( $_COOKIE['jetpackState'] ) ) {
5739
			$yum = $_COOKIE['jetpackState'];
5740
			unset( $_COOKIE['jetpackState'] );
5741
			foreach ( $yum as $k => $v ) {
5742
				if ( strlen( $v ) ) {
5743
					$state[ $k ] = $v;
5744
				}
5745
				setcookie( "jetpackState[$k]", false, 0, $path, $domain );
5746
			}
5747
		}
5748
5749
		if ( $restate ) {
5750
			foreach ( $state as $k => $v ) {
5751
				setcookie( "jetpackState[$k]", $v, 0, $path, $domain );
5752
			}
5753
			return;
5754
		}
5755
5756
		// Get a state variable
5757
		if ( isset( $key ) && ! isset( $value ) ) {
5758
			if ( array_key_exists( $key, $state ) ) {
5759
				return $state[ $key ];
5760
			}
5761
			return null;
5762
		}
5763
5764
		// Set a state variable
5765
		if ( isset( $key ) && isset( $value ) ) {
5766
			if ( is_array( $value ) && isset( $value[0] ) ) {
5767
				$value = $value[0];
5768
			}
5769
			$state[ $key ] = $value;
5770
			if ( ! headers_sent() ) {
5771
				setcookie( "jetpackState[$key]", $value, 0, $path, $domain );
5772
			}
5773
		}
5774
	}
5775
5776
	public static function restate() {
5777
		self::state( null, null, true );
5778
	}
5779
5780
	public static function check_privacy( $file ) {
5781
		static $is_site_publicly_accessible = null;
5782
5783
		if ( is_null( $is_site_publicly_accessible ) ) {
5784
			$is_site_publicly_accessible = false;
5785
5786
			$rpc = new Jetpack_IXR_Client();
5787
5788
			$success = $rpc->query( 'jetpack.isSitePubliclyAccessible', home_url() );
5789
			if ( $success ) {
5790
				$response = $rpc->getResponse();
5791
				if ( $response ) {
5792
					$is_site_publicly_accessible = true;
5793
				}
5794
			}
5795
5796
			Jetpack_Options::update_option( 'public', (int) $is_site_publicly_accessible );
5797
		}
5798
5799
		if ( $is_site_publicly_accessible ) {
5800
			return;
5801
		}
5802
5803
		$module_slug = self::get_module_slug( $file );
5804
5805
		$privacy_checks = self::state( 'privacy_checks' );
5806
		if ( ! $privacy_checks ) {
5807
			$privacy_checks = $module_slug;
5808
		} else {
5809
			$privacy_checks .= ",$module_slug";
5810
		}
5811
5812
		self::state( 'privacy_checks', $privacy_checks );
5813
	}
5814
5815
	/**
5816
	 * Helper method for multicall XMLRPC.
5817
	 *
5818
	 * @param ...$args Args for the async_call.
5819
	 */
5820
	public static function xmlrpc_async_call( ...$args ) {
5821
		global $blog_id;
5822
		static $clients = array();
5823
5824
		$client_blog_id = is_multisite() ? $blog_id : 0;
5825
5826
		if ( ! isset( $clients[ $client_blog_id ] ) ) {
5827
			$clients[ $client_blog_id ] = new Jetpack_IXR_ClientMulticall( array( 'user_id' => JETPACK_MASTER_USER ) );
5828
			if ( function_exists( 'ignore_user_abort' ) ) {
5829
				ignore_user_abort( true );
5830
			}
5831
			add_action( 'shutdown', array( 'Jetpack', 'xmlrpc_async_call' ) );
5832
		}
5833
5834
		if ( ! empty( $args[0] ) ) {
5835
			call_user_func_array( array( $clients[ $client_blog_id ], 'addCall' ), $args );
5836
		} elseif ( is_multisite() ) {
5837
			foreach ( $clients as $client_blog_id => $client ) {
5838
				if ( ! $client_blog_id || empty( $client->calls ) ) {
5839
					continue;
5840
				}
5841
5842
				$switch_success = switch_to_blog( $client_blog_id, true );
5843
				if ( ! $switch_success ) {
5844
					continue;
5845
				}
5846
5847
				flush();
5848
				$client->query();
5849
5850
				restore_current_blog();
5851
			}
5852
		} else {
5853
			if ( isset( $clients[0] ) && ! empty( $clients[0]->calls ) ) {
5854
				flush();
5855
				$clients[0]->query();
5856
			}
5857
		}
5858
	}
5859
5860
	public static function staticize_subdomain( $url ) {
5861
5862
		// Extract hostname from URL
5863
		$host = wp_parse_url( $url, PHP_URL_HOST );
5864
5865
		// Explode hostname on '.'
5866
		$exploded_host = explode( '.', $host );
5867
5868
		// Retrieve the name and TLD
5869
		if ( count( $exploded_host ) > 1 ) {
5870
			$name = $exploded_host[ count( $exploded_host ) - 2 ];
5871
			$tld  = $exploded_host[ count( $exploded_host ) - 1 ];
5872
			// Rebuild domain excluding subdomains
5873
			$domain = $name . '.' . $tld;
5874
		} else {
5875
			$domain = $host;
5876
		}
5877
		// Array of Automattic domains
5878
		$domain_whitelist = array( 'wordpress.com', 'wp.com' );
5879
5880
		// Return $url if not an Automattic domain
5881
		if ( ! in_array( $domain, $domain_whitelist ) ) {
5882
			return $url;
5883
		}
5884
5885
		if ( is_ssl() ) {
5886
			return preg_replace( '|https?://[^/]++/|', 'https://s-ssl.wordpress.com/', $url );
5887
		}
5888
5889
		srand( crc32( basename( $url ) ) );
5890
		$static_counter = rand( 0, 2 );
5891
		srand(); // this resets everything that relies on this, like array_rand() and shuffle()
5892
5893
		return preg_replace( '|://[^/]+?/|', "://s$static_counter.wp.com/", $url );
5894
	}
5895
5896
	/* JSON API Authorization */
5897
5898
	/**
5899
	 * Handles the login action for Authorizing the JSON API
5900
	 */
5901
	function login_form_json_api_authorization() {
5902
		$this->verify_json_api_authorization_request();
5903
5904
		add_action( 'wp_login', array( &$this, 'store_json_api_authorization_token' ), 10, 2 );
5905
5906
		add_action( 'login_message', array( &$this, 'login_message_json_api_authorization' ) );
5907
		add_action( 'login_form', array( &$this, 'preserve_action_in_login_form_for_json_api_authorization' ) );
5908
		add_filter( 'site_url', array( &$this, 'post_login_form_to_signed_url' ), 10, 3 );
5909
	}
5910
5911
	// Make sure the login form is POSTed to the signed URL so we can reverify the request
5912
	function post_login_form_to_signed_url( $url, $path, $scheme ) {
5913
		if ( 'wp-login.php' !== $path || ( 'login_post' !== $scheme && 'login' !== $scheme ) ) {
5914
			return $url;
5915
		}
5916
5917
		$parsed_url = wp_parse_url( $url );
5918
		$url        = strtok( $url, '?' );
5919
		$url        = "$url?{$_SERVER['QUERY_STRING']}";
5920
		if ( ! empty( $parsed_url['query'] ) ) {
5921
			$url .= "&{$parsed_url['query']}";
5922
		}
5923
5924
		return $url;
5925
	}
5926
5927
	// Make sure the POSTed request is handled by the same action
5928
	function preserve_action_in_login_form_for_json_api_authorization() {
5929
		echo "<input type='hidden' name='action' value='jetpack_json_api_authorization' />\n";
5930
		echo "<input type='hidden' name='jetpack_json_api_original_query' value='" . esc_url( set_url_scheme( $_SERVER['HTTP_HOST'] . $_SERVER['REQUEST_URI'] ) ) . "' />\n";
5931
	}
5932
5933
	// If someone logs in to approve API access, store the Access Code in usermeta
5934
	function store_json_api_authorization_token( $user_login, $user ) {
5935
		add_filter( 'login_redirect', array( &$this, 'add_token_to_login_redirect_json_api_authorization' ), 10, 3 );
5936
		add_filter( 'allowed_redirect_hosts', array( &$this, 'allow_wpcom_public_api_domain' ) );
5937
		$token = wp_generate_password( 32, false );
5938
		update_user_meta( $user->ID, 'jetpack_json_api_' . $this->json_api_authorization_request['client_id'], $token );
5939
	}
5940
5941
	// Add public-api.wordpress.com to the safe redirect whitelist - only added when someone allows API access
5942
	function allow_wpcom_public_api_domain( $domains ) {
5943
		$domains[] = 'public-api.wordpress.com';
5944
		return $domains;
5945
	}
5946
5947
	static function is_redirect_encoded( $redirect_url ) {
5948
		return preg_match( '/https?%3A%2F%2F/i', $redirect_url ) > 0;
5949
	}
5950
5951
	// Add all wordpress.com environments to the safe redirect whitelist
5952
	function allow_wpcom_environments( $domains ) {
5953
		$domains[] = 'wordpress.com';
5954
		$domains[] = 'wpcalypso.wordpress.com';
5955
		$domains[] = 'horizon.wordpress.com';
5956
		$domains[] = 'calypso.localhost';
5957
		return $domains;
5958
	}
5959
5960
	// Add the Access Code details to the public-api.wordpress.com redirect
5961
	function add_token_to_login_redirect_json_api_authorization( $redirect_to, $original_redirect_to, $user ) {
5962
		return add_query_arg(
5963
			urlencode_deep(
5964
				array(
5965
					'jetpack-code'    => get_user_meta( $user->ID, 'jetpack_json_api_' . $this->json_api_authorization_request['client_id'], true ),
5966
					'jetpack-user-id' => (int) $user->ID,
5967
					'jetpack-state'   => $this->json_api_authorization_request['state'],
5968
				)
5969
			),
5970
			$redirect_to
5971
		);
5972
	}
5973
5974
5975
	/**
5976
	 * Verifies the request by checking the signature
5977
	 *
5978
	 * @since 4.6.0 Method was updated to use `$_REQUEST` instead of `$_GET` and `$_POST`. Method also updated to allow
5979
	 * passing in an `$environment` argument that overrides `$_REQUEST`. This was useful for integrating with SSO.
5980
	 *
5981
	 * @param null|array $environment
5982
	 */
5983
	function verify_json_api_authorization_request( $environment = null ) {
5984
		$environment = is_null( $environment )
5985
			? $_REQUEST
5986
			: $environment;
5987
5988
		list( $envToken, $envVersion, $envUserId ) = explode( ':', $environment['token'] );
5989
		$token                                     = Jetpack_Data::get_access_token( $envUserId, $envToken );
5990
		if ( ! $token || empty( $token->secret ) ) {
5991
			wp_die( __( 'You must connect your Jetpack plugin to WordPress.com to use this feature.', 'jetpack' ) );
5992
		}
5993
5994
		$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' );
5995
5996
		// Host has encoded the request URL, probably as a result of a bad http => https redirect
5997
		if ( self::is_redirect_encoded( $_GET['redirect_to'] ) ) {
5998
			/**
5999
			 * Jetpack authorisation request Error.
6000
			 *
6001
			 * @since 7.5.0
6002
			 */
6003
			do_action( 'jetpack_verify_api_authorization_request_error_double_encode' );
6004
			$die_error = sprintf(
6005
				/* translators: %s is a URL */
6006
				__( 'Your site is incorrectly double-encoding redirects from http to https. This is preventing Jetpack from authenticating your connection. Please visit our <a href="%s">support page</a> for details about how to resolve this.', 'jetpack' ),
6007
				self::build_redirect_url( 'jetpack-support-double-encoding' )
6008
			);
6009
		}
6010
6011
		$jetpack_signature = new Jetpack_Signature( $token->secret, (int) Jetpack_Options::get_option( 'time_diff' ) );
6012
6013
		if ( isset( $environment['jetpack_json_api_original_query'] ) ) {
6014
			$signature = $jetpack_signature->sign_request(
6015
				$environment['token'],
6016
				$environment['timestamp'],
6017
				$environment['nonce'],
6018
				'',
6019
				'GET',
6020
				$environment['jetpack_json_api_original_query'],
6021
				null,
6022
				true
6023
			);
6024
		} else {
6025
			$signature = $jetpack_signature->sign_current_request(
6026
				array(
6027
					'body'   => null,
6028
					'method' => 'GET',
6029
				)
6030
			);
6031
		}
6032
6033
		if ( ! $signature ) {
6034
			wp_die( $die_error );
6035
		} elseif ( is_wp_error( $signature ) ) {
6036
			wp_die( $die_error );
6037
		} elseif ( ! hash_equals( $signature, $environment['signature'] ) ) {
6038
			if ( is_ssl() ) {
6039
				// 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
6040
				$signature = $jetpack_signature->sign_current_request(
6041
					array(
6042
						'scheme' => 'http',
6043
						'body'   => null,
6044
						'method' => 'GET',
6045
					)
6046
				);
6047
				if ( ! $signature || is_wp_error( $signature ) || ! hash_equals( $signature, $environment['signature'] ) ) {
6048
					wp_die( $die_error );
6049
				}
6050
			} else {
6051
				wp_die( $die_error );
6052
			}
6053
		}
6054
6055
		$timestamp = (int) $environment['timestamp'];
6056
		$nonce     = stripslashes( (string) $environment['nonce'] );
6057
6058
		if ( ! $this->connection_manager ) {
6059
			$this->connection_manager = new Connection_Manager();
6060
		}
6061
6062
		if ( ! $this->connection_manager->add_nonce( $timestamp, $nonce ) ) {
6063
			// De-nonce the nonce, at least for 5 minutes.
6064
			// 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)
6065
			$old_nonce_time = get_option( "jetpack_nonce_{$timestamp}_{$nonce}" );
6066
			if ( $old_nonce_time < time() - 300 ) {
6067
				wp_die( __( 'The authorization process expired.  Please go back and try again.', 'jetpack' ) );
6068
			}
6069
		}
6070
6071
		$data         = json_decode( base64_decode( stripslashes( $environment['data'] ) ) );
6072
		$data_filters = array(
6073
			'state'        => 'opaque',
6074
			'client_id'    => 'int',
6075
			'client_title' => 'string',
6076
			'client_image' => 'url',
6077
		);
6078
6079
		foreach ( $data_filters as $key => $sanitation ) {
6080
			if ( ! isset( $data->$key ) ) {
6081
				wp_die( $die_error );
6082
			}
6083
6084
			switch ( $sanitation ) {
6085
				case 'int':
6086
					$this->json_api_authorization_request[ $key ] = (int) $data->$key;
6087
					break;
6088
				case 'opaque':
6089
					$this->json_api_authorization_request[ $key ] = (string) $data->$key;
6090
					break;
6091
				case 'string':
6092
					$this->json_api_authorization_request[ $key ] = wp_kses( (string) $data->$key, array() );
6093
					break;
6094
				case 'url':
6095
					$this->json_api_authorization_request[ $key ] = esc_url_raw( (string) $data->$key );
6096
					break;
6097
			}
6098
		}
6099
6100
		if ( empty( $this->json_api_authorization_request['client_id'] ) ) {
6101
			wp_die( $die_error );
6102
		}
6103
	}
6104
6105
	function login_message_json_api_authorization( $message ) {
6106
		return '<p class="message">' . sprintf(
6107
			esc_html__( '%s wants to access your site&#8217;s data.  Log in to authorize that access.', 'jetpack' ),
6108
			'<strong>' . esc_html( $this->json_api_authorization_request['client_title'] ) . '</strong>'
6109
		) . '<img src="' . esc_url( $this->json_api_authorization_request['client_image'] ) . '" /></p>';
6110
	}
6111
6112
	/**
6113
	 * Get $content_width, but with a <s>twist</s> filter.
6114
	 */
6115
	public static function get_content_width() {
6116
		$content_width = ( isset( $GLOBALS['content_width'] ) && is_numeric( $GLOBALS['content_width'] ) )
6117
			? $GLOBALS['content_width']
6118
			: false;
6119
		/**
6120
		 * Filter the Content Width value.
6121
		 *
6122
		 * @since 2.2.3
6123
		 *
6124
		 * @param string $content_width Content Width value.
6125
		 */
6126
		return apply_filters( 'jetpack_content_width', $content_width );
6127
	}
6128
6129
	/**
6130
	 * Pings the WordPress.com Mirror Site for the specified options.
6131
	 *
6132
	 * @param string|array $option_names The option names to request from the WordPress.com Mirror Site
6133
	 *
6134
	 * @return array An associative array of the option values as stored in the WordPress.com Mirror Site
6135
	 */
6136
	public function get_cloud_site_options( $option_names ) {
6137
		$option_names = array_filter( (array) $option_names, 'is_string' );
6138
6139
		$xml = new Jetpack_IXR_Client( array( 'user_id' => JETPACK_MASTER_USER ) );
6140
		$xml->query( 'jetpack.fetchSiteOptions', $option_names );
6141
		if ( $xml->isError() ) {
6142
			return array(
6143
				'error_code' => $xml->getErrorCode(),
6144
				'error_msg'  => $xml->getErrorMessage(),
6145
			);
6146
		}
6147
		$cloud_site_options = $xml->getResponse();
6148
6149
		return $cloud_site_options;
6150
	}
6151
6152
	/**
6153
	 * Checks if the site is currently in an identity crisis.
6154
	 *
6155
	 * @return array|bool Array of options that are in a crisis, or false if everything is OK.
6156
	 */
6157
	public static function check_identity_crisis() {
6158
		if ( ! self::is_active() || ( new Status() )->is_development_mode() || ! self::validate_sync_error_idc_option() ) {
6159
			return false;
6160
		}
6161
6162
		return Jetpack_Options::get_option( 'sync_error_idc' );
6163
	}
6164
6165
	/**
6166
	 * Checks whether the home and siteurl specifically are whitelisted
6167
	 * Written so that we don't have re-check $key and $value params every time
6168
	 * we want to check if this site is whitelisted, for example in footer.php
6169
	 *
6170
	 * @since  3.8.0
6171
	 * @return bool True = already whitelisted False = not whitelisted
6172
	 */
6173
	public static function is_staging_site() {
6174
		_deprecated_function( 'Jetpack::is_staging_site', 'jetpack-8.1', '/Automattic/Jetpack/Status->is_staging_site' );
6175
		return ( new Status() )->is_staging_site();
6176
	}
6177
6178
	/**
6179
	 * Checks whether the sync_error_idc option is valid or not, and if not, will do cleanup.
6180
	 *
6181
	 * @since 4.4.0
6182
	 * @since 5.4.0 Do not call get_sync_error_idc_option() unless site is in IDC
6183
	 *
6184
	 * @return bool
6185
	 */
6186
	public static function validate_sync_error_idc_option() {
6187
		$is_valid = false;
6188
6189
		$idc_allowed = get_transient( 'jetpack_idc_allowed' );
6190
		if ( false === $idc_allowed ) {
6191
			$response = wp_remote_get( 'https://jetpack.com/is-idc-allowed/' );
6192
			if ( 200 === (int) wp_remote_retrieve_response_code( $response ) ) {
6193
				$json               = json_decode( wp_remote_retrieve_body( $response ) );
6194
				$idc_allowed        = isset( $json, $json->result ) && $json->result ? '1' : '0';
6195
				$transient_duration = HOUR_IN_SECONDS;
6196
			} else {
6197
				// If the request failed for some reason, then assume IDC is allowed and set shorter transient.
6198
				$idc_allowed        = '1';
6199
				$transient_duration = 5 * MINUTE_IN_SECONDS;
6200
			}
6201
6202
			set_transient( 'jetpack_idc_allowed', $idc_allowed, $transient_duration );
6203
		}
6204
6205
		// Is the site opted in and does the stored sync_error_idc option match what we now generate?
6206
		$sync_error = Jetpack_Options::get_option( 'sync_error_idc' );
6207
		if ( $idc_allowed && $sync_error && self::sync_idc_optin() ) {
6208
			$local_options = self::get_sync_error_idc_option();
6209
			// Ensure all values are set.
6210
			if ( isset( $sync_error['home'] ) && isset ( $local_options['home'] ) && isset( $sync_error['siteurl'] ) && isset( $local_options['siteurl'] ) ) {
6211
				if ( $sync_error['home'] === $local_options['home'] && $sync_error['siteurl'] === $local_options['siteurl'] ) {
6212
					$is_valid = true;
6213
				}
6214
			}
6215
6216
		}
6217
6218
		/**
6219
		 * Filters whether the sync_error_idc option is valid.
6220
		 *
6221
		 * @since 4.4.0
6222
		 *
6223
		 * @param bool $is_valid If the sync_error_idc is valid or not.
6224
		 */
6225
		$is_valid = (bool) apply_filters( 'jetpack_sync_error_idc_validation', $is_valid );
6226
6227
		if ( ! $idc_allowed || ( ! $is_valid && $sync_error ) ) {
6228
			// Since the option exists, and did not validate, delete it
6229
			Jetpack_Options::delete_option( 'sync_error_idc' );
6230
		}
6231
6232
		return $is_valid;
6233
	}
6234
6235
	/**
6236
	 * Normalizes a url by doing three things:
6237
	 *  - Strips protocol
6238
	 *  - Strips www
6239
	 *  - Adds a trailing slash
6240
	 *
6241
	 * @since 4.4.0
6242
	 * @param string $url
6243
	 * @return WP_Error|string
6244
	 */
6245
	public static function normalize_url_protocol_agnostic( $url ) {
6246
		$parsed_url = wp_parse_url( trailingslashit( esc_url_raw( $url ) ) );
6247
		if ( ! $parsed_url || empty( $parsed_url['host'] ) || empty( $parsed_url['path'] ) ) {
6248
			return new WP_Error( 'cannot_parse_url', sprintf( esc_html__( 'Cannot parse URL %s', 'jetpack' ), $url ) );
6249
		}
6250
6251
		// Strip www and protocols
6252
		$url = preg_replace( '/^www\./i', '', $parsed_url['host'] . $parsed_url['path'] );
6253
		return $url;
6254
	}
6255
6256
	/**
6257
	 * Gets the value that is to be saved in the jetpack_sync_error_idc option.
6258
	 *
6259
	 * @since 4.4.0
6260
	 * @since 5.4.0 Add transient since home/siteurl retrieved directly from DB
6261
	 *
6262
	 * @param array $response
6263
	 * @return array Array of the local urls, wpcom urls, and error code
6264
	 */
6265
	public static function get_sync_error_idc_option( $response = array() ) {
6266
		// Since the local options will hit the database directly, store the values
6267
		// in a transient to allow for autoloading and caching on subsequent views.
6268
		$local_options = get_transient( 'jetpack_idc_local' );
6269
		if ( false === $local_options ) {
6270
			$local_options = array(
6271
				'home'    => Functions::home_url(),
6272
				'siteurl' => Functions::site_url(),
6273
			);
6274
			set_transient( 'jetpack_idc_local', $local_options, MINUTE_IN_SECONDS );
6275
		}
6276
6277
		$options = array_merge( $local_options, $response );
6278
6279
		$returned_values = array();
6280
		foreach ( $options as $key => $option ) {
6281
			if ( 'error_code' === $key ) {
6282
				$returned_values[ $key ] = $option;
6283
				continue;
6284
			}
6285
6286
			if ( is_wp_error( $normalized_url = self::normalize_url_protocol_agnostic( $option ) ) ) {
6287
				continue;
6288
			}
6289
6290
			$returned_values[ $key ] = $normalized_url;
6291
		}
6292
6293
		set_transient( 'jetpack_idc_option', $returned_values, MINUTE_IN_SECONDS );
6294
6295
		return $returned_values;
6296
	}
6297
6298
	/**
6299
	 * Returns the value of the jetpack_sync_idc_optin filter, or constant.
6300
	 * If set to true, the site will be put into staging mode.
6301
	 *
6302
	 * @since 4.3.2
6303
	 * @return bool
6304
	 */
6305
	public static function sync_idc_optin() {
6306
		if ( Constants::is_defined( 'JETPACK_SYNC_IDC_OPTIN' ) ) {
6307
			$default = Constants::get_constant( 'JETPACK_SYNC_IDC_OPTIN' );
6308
		} else {
6309
			$default = ! Constants::is_defined( 'SUNRISE' ) && ! is_multisite();
6310
		}
6311
6312
		/**
6313
		 * Allows sites to opt in to IDC mitigation which blocks the site from syncing to WordPress.com when the home
6314
		 * URL or site URL do not match what WordPress.com expects. The default value is either false, or the value of
6315
		 * JETPACK_SYNC_IDC_OPTIN constant if set.
6316
		 *
6317
		 * @since 4.3.2
6318
		 *
6319
		 * @param bool $default Whether the site is opted in to IDC mitigation.
6320
		 */
6321
		return (bool) apply_filters( 'jetpack_sync_idc_optin', $default );
6322
	}
6323
6324
	/**
6325
	 * Maybe Use a .min.css stylesheet, maybe not.
6326
	 *
6327
	 * Hooks onto `plugins_url` filter at priority 1, and accepts all 3 args.
6328
	 */
6329
	public static function maybe_min_asset( $url, $path, $plugin ) {
6330
		// Short out on things trying to find actual paths.
6331
		if ( ! $path || empty( $plugin ) ) {
6332
			return $url;
6333
		}
6334
6335
		$path = ltrim( $path, '/' );
6336
6337
		// Strip out the abspath.
6338
		$base = dirname( plugin_basename( $plugin ) );
6339
6340
		// Short out on non-Jetpack assets.
6341
		if ( 'jetpack/' !== substr( $base, 0, 8 ) ) {
6342
			return $url;
6343
		}
6344
6345
		// File name parsing.
6346
		$file              = "{$base}/{$path}";
6347
		$full_path         = JETPACK__PLUGIN_DIR . substr( $file, 8 );
6348
		$file_name         = substr( $full_path, strrpos( $full_path, '/' ) + 1 );
6349
		$file_name_parts_r = array_reverse( explode( '.', $file_name ) );
6350
		$extension         = array_shift( $file_name_parts_r );
6351
6352
		if ( in_array( strtolower( $extension ), array( 'css', 'js' ) ) ) {
6353
			// Already pointing at the minified version.
6354
			if ( 'min' === $file_name_parts_r[0] ) {
6355
				return $url;
6356
			}
6357
6358
			$min_full_path = preg_replace( "#\.{$extension}$#", ".min.{$extension}", $full_path );
6359
			if ( file_exists( $min_full_path ) ) {
6360
				$url = preg_replace( "#\.{$extension}$#", ".min.{$extension}", $url );
6361
				// If it's a CSS file, stash it so we can set the .min suffix for rtl-ing.
6362
				if ( 'css' === $extension ) {
6363
					$key                      = str_replace( JETPACK__PLUGIN_DIR, 'jetpack/', $min_full_path );
6364
					self::$min_assets[ $key ] = $path;
6365
				}
6366
			}
6367
		}
6368
6369
		return $url;
6370
	}
6371
6372
	/**
6373
	 * If the asset is minified, let's flag .min as the suffix.
6374
	 *
6375
	 * Attached to `style_loader_src` filter.
6376
	 *
6377
	 * @param string $tag The tag that would link to the external asset.
6378
	 * @param string $handle The registered handle of the script in question.
6379
	 * @param string $href The url of the asset in question.
6380
	 */
6381
	public static function set_suffix_on_min( $src, $handle ) {
6382
		if ( false === strpos( $src, '.min.css' ) ) {
6383
			return $src;
6384
		}
6385
6386
		if ( ! empty( self::$min_assets ) ) {
6387
			foreach ( self::$min_assets as $file => $path ) {
6388
				if ( false !== strpos( $src, $file ) ) {
6389
					wp_style_add_data( $handle, 'suffix', '.min' );
6390
					return $src;
6391
				}
6392
			}
6393
		}
6394
6395
		return $src;
6396
	}
6397
6398
	/**
6399
	 * Maybe inlines a stylesheet.
6400
	 *
6401
	 * If you'd like to inline a stylesheet instead of printing a link to it,
6402
	 * wp_style_add_data( 'handle', 'jetpack-inline', true );
6403
	 *
6404
	 * Attached to `style_loader_tag` filter.
6405
	 *
6406
	 * @param string $tag The tag that would link to the external asset.
6407
	 * @param string $handle The registered handle of the script in question.
6408
	 *
6409
	 * @return string
6410
	 */
6411
	public static function maybe_inline_style( $tag, $handle ) {
6412
		global $wp_styles;
6413
		$item = $wp_styles->registered[ $handle ];
6414
6415
		if ( ! isset( $item->extra['jetpack-inline'] ) || ! $item->extra['jetpack-inline'] ) {
6416
			return $tag;
6417
		}
6418
6419
		if ( preg_match( '# href=\'([^\']+)\' #i', $tag, $matches ) ) {
6420
			$href = $matches[1];
6421
			// Strip off query string
6422
			if ( $pos = strpos( $href, '?' ) ) {
6423
				$href = substr( $href, 0, $pos );
6424
			}
6425
			// Strip off fragment
6426
			if ( $pos = strpos( $href, '#' ) ) {
6427
				$href = substr( $href, 0, $pos );
6428
			}
6429
		} else {
6430
			return $tag;
6431
		}
6432
6433
		$plugins_dir = plugin_dir_url( JETPACK__PLUGIN_FILE );
6434
		if ( $plugins_dir !== substr( $href, 0, strlen( $plugins_dir ) ) ) {
6435
			return $tag;
6436
		}
6437
6438
		// If this stylesheet has a RTL version, and the RTL version replaces normal...
6439
		if ( isset( $item->extra['rtl'] ) && 'replace' === $item->extra['rtl'] && is_rtl() ) {
6440
			// And this isn't the pass that actually deals with the RTL version...
6441
			if ( false === strpos( $tag, " id='$handle-rtl-css' " ) ) {
6442
				// Short out, as the RTL version will deal with it in a moment.
6443
				return $tag;
6444
			}
6445
		}
6446
6447
		$file = JETPACK__PLUGIN_DIR . substr( $href, strlen( $plugins_dir ) );
6448
		$css  = self::absolutize_css_urls( file_get_contents( $file ), $href );
6449
		if ( $css ) {
6450
			$tag = "<!-- Inline {$item->handle} -->\r\n";
6451
			if ( empty( $item->extra['after'] ) ) {
6452
				wp_add_inline_style( $handle, $css );
6453
			} else {
6454
				array_unshift( $item->extra['after'], $css );
6455
				wp_style_add_data( $handle, 'after', $item->extra['after'] );
6456
			}
6457
		}
6458
6459
		return $tag;
6460
	}
6461
6462
	/**
6463
	 * Loads a view file from the views
6464
	 *
6465
	 * Data passed in with the $data parameter will be available in the
6466
	 * template file as $data['value']
6467
	 *
6468
	 * @param string $template - Template file to load
6469
	 * @param array  $data - Any data to pass along to the template
6470
	 * @return boolean - If template file was found
6471
	 **/
6472
	public function load_view( $template, $data = array() ) {
6473
		$views_dir = JETPACK__PLUGIN_DIR . 'views/';
6474
6475
		if ( file_exists( $views_dir . $template ) ) {
6476
			require_once $views_dir . $template;
6477
			return true;
6478
		}
6479
6480
		error_log( "Jetpack: Unable to find view file $views_dir$template" );
6481
		return false;
6482
	}
6483
6484
	/**
6485
	 * Throws warnings for deprecated hooks to be removed from Jetpack
6486
	 */
6487
	public function deprecated_hooks() {
6488
		global $wp_filter;
6489
6490
		/*
6491
		 * Format:
6492
		 * deprecated_filter_name => replacement_name
6493
		 *
6494
		 * If there is no replacement, use null for replacement_name
6495
		 */
6496
		$deprecated_list = array(
6497
			'jetpack_bail_on_shortcode'                    => 'jetpack_shortcodes_to_include',
6498
			'wpl_sharing_2014_1'                           => null,
6499
			'jetpack-tools-to-include'                     => 'jetpack_tools_to_include',
6500
			'jetpack_identity_crisis_options_to_check'     => null,
6501
			'update_option_jetpack_single_user_site'       => null,
6502
			'audio_player_default_colors'                  => null,
6503
			'add_option_jetpack_featured_images_enabled'   => null,
6504
			'add_option_jetpack_update_details'            => null,
6505
			'add_option_jetpack_updates'                   => null,
6506
			'add_option_jetpack_network_name'              => null,
6507
			'add_option_jetpack_network_allow_new_registrations' => null,
6508
			'add_option_jetpack_network_add_new_users'     => null,
6509
			'add_option_jetpack_network_site_upload_space' => null,
6510
			'add_option_jetpack_network_upload_file_types' => null,
6511
			'add_option_jetpack_network_enable_administration_menus' => null,
6512
			'add_option_jetpack_is_multi_site'             => null,
6513
			'add_option_jetpack_is_main_network'           => null,
6514
			'add_option_jetpack_main_network_site'         => null,
6515
			'jetpack_sync_all_registered_options'          => null,
6516
			'jetpack_has_identity_crisis'                  => 'jetpack_sync_error_idc_validation',
6517
			'jetpack_is_post_mailable'                     => null,
6518
			'jetpack_seo_site_host'                        => null,
6519
			'jetpack_installed_plugin'                     => 'jetpack_plugin_installed',
6520
			'jetpack_holiday_snow_option_name'             => null,
6521
			'jetpack_holiday_chance_of_snow'               => null,
6522
			'jetpack_holiday_snow_js_url'                  => null,
6523
			'jetpack_is_holiday_snow_season'               => null,
6524
			'jetpack_holiday_snow_option_updated'          => null,
6525
			'jetpack_holiday_snowing'                      => null,
6526
			'jetpack_sso_auth_cookie_expirtation'          => 'jetpack_sso_auth_cookie_expiration',
6527
			'jetpack_cache_plans'                          => null,
6528
			'jetpack_updated_theme'                        => 'jetpack_updated_themes',
6529
			'jetpack_lazy_images_skip_image_with_atttributes' => 'jetpack_lazy_images_skip_image_with_attributes',
6530
			'jetpack_enable_site_verification'             => null,
6531
			'can_display_jetpack_manage_notice'            => null,
6532
			// Removed in Jetpack 7.3.0
6533
			'atd_load_scripts'                             => null,
6534
			'atd_http_post_timeout'                        => null,
6535
			'atd_http_post_error'                          => null,
6536
			'atd_service_domain'                           => null,
6537
			'jetpack_widget_authors_exclude'               => 'jetpack_widget_authors_params',
6538
			// Removed in Jetpack 7.9.0
6539
			'jetpack_pwa_manifest'                         => null,
6540
			'jetpack_pwa_background_color'                 => null,
6541
			// Removed in Jetpack 8.3.0.
6542
			'jetpack_check_mobile'                         => null,
6543
			'jetpack_mobile_stylesheet'                    => null,
6544
			'jetpack_mobile_template'                      => null,
6545
			'mobile_reject_mobile'                         => null,
6546
			'mobile_force_mobile'                          => null,
6547
			'mobile_app_promo_download'                    => null,
6548
			'mobile_setup'                                 => null,
6549
			'jetpack_mobile_footer_before'                 => null,
6550
			'wp_mobile_theme_footer'                       => null,
6551
			'minileven_credits'                            => null,
6552
			'jetpack_mobile_header_before'                 => null,
6553
			'jetpack_mobile_header_after'                  => null,
6554
			'jetpack_mobile_theme_menu'                    => null,
6555
			'minileven_show_featured_images'               => null,
6556
			'minileven_attachment_size'                    => null,
6557
		);
6558
6559
		// This is a silly loop depth. Better way?
6560
		foreach ( $deprecated_list as $hook => $hook_alt ) {
6561
			if ( has_action( $hook ) ) {
6562
				foreach ( $wp_filter[ $hook ] as $func => $values ) {
6563
					foreach ( $values as $hooked ) {
6564
						if ( is_callable( $hooked['function'] ) ) {
6565
							$function_name = 'an anonymous function';
6566
						} else {
6567
							$function_name = $hooked['function'];
6568
						}
6569
						_deprecated_function( $hook . ' used for ' . $function_name, null, $hook_alt );
6570
					}
6571
				}
6572
			}
6573
		}
6574
	}
6575
6576
	/**
6577
	 * Converts any url in a stylesheet, to the correct absolute url.
6578
	 *
6579
	 * Considerations:
6580
	 *  - Normal, relative URLs     `feh.png`
6581
	 *  - Data URLs                 `data:image/gif;base64,eh129ehiuehjdhsa==`
6582
	 *  - Schema-agnostic URLs      `//domain.com/feh.png`
6583
	 *  - Absolute URLs             `http://domain.com/feh.png`
6584
	 *  - Domain root relative URLs `/feh.png`
6585
	 *
6586
	 * @param $css string: The raw CSS -- should be read in directly from the file.
6587
	 * @param $css_file_url : The URL that the file can be accessed at, for calculating paths from.
6588
	 *
6589
	 * @return mixed|string
6590
	 */
6591
	public static function absolutize_css_urls( $css, $css_file_url ) {
6592
		$pattern = '#url\((?P<path>[^)]*)\)#i';
6593
		$css_dir = dirname( $css_file_url );
6594
		$p       = wp_parse_url( $css_dir );
6595
		$domain  = sprintf(
6596
			'%1$s//%2$s%3$s%4$s',
6597
			isset( $p['scheme'] ) ? "{$p['scheme']}:" : '',
6598
			isset( $p['user'], $p['pass'] ) ? "{$p['user']}:{$p['pass']}@" : '',
6599
			$p['host'],
6600
			isset( $p['port'] ) ? ":{$p['port']}" : ''
6601
		);
6602
6603
		if ( preg_match_all( $pattern, $css, $matches, PREG_SET_ORDER ) ) {
6604
			$find = $replace = array();
6605
			foreach ( $matches as $match ) {
6606
				$url = trim( $match['path'], "'\" \t" );
6607
6608
				// If this is a data url, we don't want to mess with it.
6609
				if ( 'data:' === substr( $url, 0, 5 ) ) {
6610
					continue;
6611
				}
6612
6613
				// If this is an absolute or protocol-agnostic url,
6614
				// we don't want to mess with it.
6615
				if ( preg_match( '#^(https?:)?//#i', $url ) ) {
6616
					continue;
6617
				}
6618
6619
				switch ( substr( $url, 0, 1 ) ) {
6620
					case '/':
6621
						$absolute = $domain . $url;
6622
						break;
6623
					default:
6624
						$absolute = $css_dir . '/' . $url;
6625
				}
6626
6627
				$find[]    = $match[0];
6628
				$replace[] = sprintf( 'url("%s")', $absolute );
6629
			}
6630
			$css = str_replace( $find, $replace, $css );
6631
		}
6632
6633
		return $css;
6634
	}
6635
6636
	/**
6637
	 * This methods removes all of the registered css files on the front end
6638
	 * from Jetpack in favor of using a single file. In effect "imploding"
6639
	 * all the files into one file.
6640
	 *
6641
	 * Pros:
6642
	 * - Uses only ONE css asset connection instead of 15
6643
	 * - Saves a minimum of 56k
6644
	 * - Reduces server load
6645
	 * - Reduces time to first painted byte
6646
	 *
6647
	 * Cons:
6648
	 * - Loads css for ALL modules. However all selectors are prefixed so it
6649
	 *      should not cause any issues with themes.
6650
	 * - Plugins/themes dequeuing styles no longer do anything. See
6651
	 *      jetpack_implode_frontend_css filter for a workaround
6652
	 *
6653
	 * For some situations developers may wish to disable css imploding and
6654
	 * instead operate in legacy mode where each file loads seperately and
6655
	 * can be edited individually or dequeued. This can be accomplished with
6656
	 * the following line:
6657
	 *
6658
	 * add_filter( 'jetpack_implode_frontend_css', '__return_false' );
6659
	 *
6660
	 * @since 3.2
6661
	 **/
6662
	public function implode_frontend_css( $travis_test = false ) {
6663
		$do_implode = true;
6664
		if ( defined( 'SCRIPT_DEBUG' ) && SCRIPT_DEBUG ) {
6665
			$do_implode = false;
6666
		}
6667
6668
		// Do not implode CSS when the page loads via the AMP plugin.
6669
		if ( Jetpack_AMP_Support::is_amp_request() ) {
6670
			$do_implode = false;
6671
		}
6672
6673
		/**
6674
		 * Allow CSS to be concatenated into a single jetpack.css file.
6675
		 *
6676
		 * @since 3.2.0
6677
		 *
6678
		 * @param bool $do_implode Should CSS be concatenated? Default to true.
6679
		 */
6680
		$do_implode = apply_filters( 'jetpack_implode_frontend_css', $do_implode );
6681
6682
		// Do not use the imploded file when default behavior was altered through the filter
6683
		if ( ! $do_implode ) {
6684
			return;
6685
		}
6686
6687
		// We do not want to use the imploded file in dev mode, or if not connected
6688
		if ( ( new Status() )->is_development_mode() || ! self::is_active() ) {
6689
			if ( ! $travis_test ) {
6690
				return;
6691
			}
6692
		}
6693
6694
		// Do not use the imploded file if sharing css was dequeued via the sharing settings screen
6695
		if ( get_option( 'sharedaddy_disable_resources' ) ) {
6696
			return;
6697
		}
6698
6699
		/*
6700
		 * Now we assume Jetpack is connected and able to serve the single
6701
		 * file.
6702
		 *
6703
		 * In the future there will be a check here to serve the file locally
6704
		 * or potentially from the Jetpack CDN
6705
		 *
6706
		 * For now:
6707
		 * - Enqueue a single imploded css file
6708
		 * - Zero out the style_loader_tag for the bundled ones
6709
		 * - Be happy, drink scotch
6710
		 */
6711
6712
		add_filter( 'style_loader_tag', array( $this, 'concat_remove_style_loader_tag' ), 10, 2 );
6713
6714
		$version = self::is_development_version() ? filemtime( JETPACK__PLUGIN_DIR . 'css/jetpack.css' ) : JETPACK__VERSION;
6715
6716
		wp_enqueue_style( 'jetpack_css', plugins_url( 'css/jetpack.css', __FILE__ ), array(), $version );
6717
		wp_style_add_data( 'jetpack_css', 'rtl', 'replace' );
6718
	}
6719
6720
	function concat_remove_style_loader_tag( $tag, $handle ) {
6721
		if ( in_array( $handle, $this->concatenated_style_handles ) ) {
6722
			$tag = '';
6723
			if ( defined( 'WP_DEBUG' ) && WP_DEBUG ) {
6724
				$tag = '<!-- `' . esc_html( $handle ) . "` is included in the concatenated jetpack.css -->\r\n";
6725
			}
6726
		}
6727
6728
		return $tag;
6729
	}
6730
6731
	/**
6732
	 * Add an async attribute to scripts that can be loaded asynchronously.
6733
	 * https://www.w3schools.com/tags/att_script_async.asp
6734
	 *
6735
	 * @since 7.7.0
6736
	 *
6737
	 * @param string $tag    The <script> tag for the enqueued script.
6738
	 * @param string $handle The script's registered handle.
6739
	 * @param string $src    The script's source URL.
6740
	 */
6741
	public function script_add_async( $tag, $handle, $src ) {
6742
		if ( in_array( $handle, $this->async_script_handles, true ) ) {
6743
			return preg_replace( '/^<script /i', '<script async ', $tag );
6744
		}
6745
6746
		return $tag;
6747
	}
6748
6749
	/*
6750
	 * Check the heartbeat data
6751
	 *
6752
	 * Organizes the heartbeat data by severity.  For example, if the site
6753
	 * is in an ID crisis, it will be in the $filtered_data['bad'] array.
6754
	 *
6755
	 * Data will be added to "caution" array, if it either:
6756
	 *  - Out of date Jetpack version
6757
	 *  - Out of date WP version
6758
	 *  - Out of date PHP version
6759
	 *
6760
	 * $return array $filtered_data
6761
	 */
6762
	public static function jetpack_check_heartbeat_data() {
6763
		$raw_data = Jetpack_Heartbeat::generate_stats_array();
6764
6765
		$good    = array();
6766
		$caution = array();
6767
		$bad     = array();
6768
6769
		foreach ( $raw_data as $stat => $value ) {
6770
6771
			// Check jetpack version
6772
			if ( 'version' == $stat ) {
6773
				if ( version_compare( $value, JETPACK__VERSION, '<' ) ) {
6774
					$caution[ $stat ] = $value . ' - min supported is ' . JETPACK__VERSION;
6775
					continue;
6776
				}
6777
			}
6778
6779
			// Check WP version
6780
			if ( 'wp-version' == $stat ) {
6781
				if ( version_compare( $value, JETPACK__MINIMUM_WP_VERSION, '<' ) ) {
6782
					$caution[ $stat ] = $value . ' - min supported is ' . JETPACK__MINIMUM_WP_VERSION;
6783
					continue;
6784
				}
6785
			}
6786
6787
			// Check PHP version
6788
			if ( 'php-version' == $stat ) {
6789
				if ( version_compare( PHP_VERSION, JETPACK__MINIMUM_PHP_VERSION, '<' ) ) {
6790
					$caution[ $stat ] = $value . " - min supported is " . JETPACK__MINIMUM_PHP_VERSION;
6791
					continue;
6792
				}
6793
			}
6794
6795
			// Check ID crisis
6796
			if ( 'identitycrisis' == $stat ) {
6797
				if ( 'yes' == $value ) {
6798
					$bad[ $stat ] = $value;
6799
					continue;
6800
				}
6801
			}
6802
6803
			// The rest are good :)
6804
			$good[ $stat ] = $value;
6805
		}
6806
6807
		$filtered_data = array(
6808
			'good'    => $good,
6809
			'caution' => $caution,
6810
			'bad'     => $bad,
6811
		);
6812
6813
		return $filtered_data;
6814
	}
6815
6816
6817
	/*
6818
	 * This method is used to organize all options that can be reset
6819
	 * without disconnecting Jetpack.
6820
	 *
6821
	 * It is used in class.jetpack-cli.php to reset options
6822
	 *
6823
	 * @since 5.4.0 Logic moved to Jetpack_Options class. Method left in Jetpack class for backwards compat.
6824
	 *
6825
	 * @return array of options to delete.
6826
	 */
6827
	public static function get_jetpack_options_for_reset() {
6828
		return Jetpack_Options::get_options_for_reset();
6829
	}
6830
6831
	/*
6832
	 * Strip http:// or https:// from a url, replaces forward slash with ::,
6833
	 * so we can bring them directly to their site in calypso.
6834
	 *
6835
	 * @param string | url
6836
	 * @return string | url without the guff
6837
	 */
6838
	public static function build_raw_urls( $url ) {
6839
		$strip_http = '/.*?:\/\//i';
6840
		$url        = preg_replace( $strip_http, '', $url );
6841
		$url        = str_replace( '/', '::', $url );
6842
		return $url;
6843
	}
6844
6845
	/**
6846
	 * Builds an URL using the jetpack.com/redirect service
6847
	 *
6848
	 * Note to WP.com: Changes to this method must be synced to wpcom
6849
	 *
6850
	 * @since 8.5.0
6851
	 *
6852
	 * @param string        $source The URL handler registered in the server
6853
	 * @param array|string  $args {
6854
	 *    Optional. Additional arguments to build the url
6855
	 *
6856
	 *    @type string $site URL of the site; Default is current site.
6857
	 *    @type string $path Additional path to be appended to the URL.
6858
	 *    @type string $query Query parameters to be added to the URL.
6859
	 *    @type string $anchor Anchor to be added to the URL.
6860
	 * }
6861
	 *
6862
	 * @return string The built URL
6863
	 */
6864
	public static function build_redirect_url( $source, $args = array() ) {
6865
6866
		$url           = 'https://jetpack.com/redirect';
6867
		$args          = wp_parse_args( $args, array( 'site' => self::build_raw_urls( get_home_url() ) ) );
6868
		$accepted_args = array( 'site', 'path', 'query', 'anchor' );
6869
6870
		$to_be_added = array(
6871
			'source' => rawurlencode( $source ),
6872
		);
6873
6874
		foreach ( $args as $arg_name => $arg_value ) {
6875
6876
			if ( ! in_array( $arg_name, $accepted_args, true ) || empty( $arg_value ) ) {
6877
				continue;
6878
			}
6879
6880
			$to_be_added[ $arg_name ] = rawurlencode( $arg_value );
6881
6882
		}
6883
6884
		if ( ! empty( $to_be_added ) ) {
6885
			$url = add_query_arg( $to_be_added, $url );
6886
		}
6887
6888
		return $url;
6889
	}
6890
6891
	/**
6892
	 * Stores and prints out domains to prefetch for page speed optimization.
6893
	 *
6894
	 * @param mixed $new_urls
6895
	 */
6896
	public static function dns_prefetch( $new_urls = null ) {
6897
		static $prefetch_urls = array();
6898
		if ( empty( $new_urls ) && ! empty( $prefetch_urls ) ) {
6899
			echo "\r\n";
6900
			foreach ( $prefetch_urls as $this_prefetch_url ) {
6901
				printf( "<link rel='dns-prefetch' href='%s'/>\r\n", esc_attr( $this_prefetch_url ) );
6902
			}
6903
		} elseif ( ! empty( $new_urls ) ) {
6904
			if ( ! has_action( 'wp_head', array( __CLASS__, __FUNCTION__ ) ) ) {
6905
				add_action( 'wp_head', array( __CLASS__, __FUNCTION__ ) );
6906
			}
6907
			foreach ( (array) $new_urls as $this_new_url ) {
6908
				$prefetch_urls[] = strtolower( untrailingslashit( preg_replace( '#^https?://#i', '//', $this_new_url ) ) );
6909
			}
6910
			$prefetch_urls = array_unique( $prefetch_urls );
6911
		}
6912
	}
6913
6914
	public function wp_dashboard_setup() {
6915
		if ( self::is_active() ) {
6916
			add_action( 'jetpack_dashboard_widget', array( __CLASS__, 'dashboard_widget_footer' ), 999 );
6917
		}
6918
6919
		if ( has_action( 'jetpack_dashboard_widget' ) ) {
6920
			$jetpack_logo = new Jetpack_Logo();
6921
			$widget_title = sprintf(
6922
				wp_kses(
6923
					/* translators: Placeholder is a Jetpack logo. */
6924
					__( 'Stats <span>by %s</span>', 'jetpack' ),
6925
					array( 'span' => array() )
6926
				),
6927
				$jetpack_logo->get_jp_emblem( true )
6928
			);
6929
6930
			wp_add_dashboard_widget(
6931
				'jetpack_summary_widget',
6932
				$widget_title,
6933
				array( __CLASS__, 'dashboard_widget' )
6934
			);
6935
			wp_enqueue_style( 'jetpack-dashboard-widget', plugins_url( 'css/dashboard-widget.css', JETPACK__PLUGIN_FILE ), array(), JETPACK__VERSION );
6936
			wp_style_add_data( 'jetpack-dashboard-widget', 'rtl', 'replace' );
6937
6938
			// If we're inactive and not in development mode, sort our box to the top.
6939
			if ( ! self::is_active() && ! ( new Status() )->is_development_mode() ) {
6940
				global $wp_meta_boxes;
6941
6942
				$dashboard = $wp_meta_boxes['dashboard']['normal']['core'];
6943
				$ours      = array( 'jetpack_summary_widget' => $dashboard['jetpack_summary_widget'] );
6944
6945
				$wp_meta_boxes['dashboard']['normal']['core'] = array_merge( $ours, $dashboard );
6946
			}
6947
		}
6948
	}
6949
6950
	/**
6951
	 * @param mixed $result Value for the user's option
6952
	 * @return mixed
6953
	 */
6954
	function get_user_option_meta_box_order_dashboard( $sorted ) {
6955
		if ( ! is_array( $sorted ) ) {
6956
			return $sorted;
6957
		}
6958
6959
		foreach ( $sorted as $box_context => $ids ) {
6960
			if ( false === strpos( $ids, 'dashboard_stats' ) ) {
6961
				// If the old id isn't anywhere in the ids, don't bother exploding and fail out.
6962
				continue;
6963
			}
6964
6965
			$ids_array = explode( ',', $ids );
6966
			$key       = array_search( 'dashboard_stats', $ids_array );
6967
6968
			if ( false !== $key ) {
6969
				// If we've found that exact value in the option (and not `google_dashboard_stats` for example)
6970
				$ids_array[ $key ]      = 'jetpack_summary_widget';
6971
				$sorted[ $box_context ] = implode( ',', $ids_array );
6972
				// We've found it, stop searching, and just return.
6973
				break;
6974
			}
6975
		}
6976
6977
		return $sorted;
6978
	}
6979
6980
	public static function dashboard_widget() {
6981
		/**
6982
		 * Fires when the dashboard is loaded.
6983
		 *
6984
		 * @since 3.4.0
6985
		 */
6986
		do_action( 'jetpack_dashboard_widget' );
6987
	}
6988
6989
	public static function dashboard_widget_footer() {
6990
		?>
6991
		<footer>
6992
6993
		<div class="protect">
6994
			<h3><?php esc_html_e( 'Brute force attack protection', 'jetpack' ); ?></h3>
6995
			<?php if ( self::is_module_active( 'protect' ) ) : ?>
6996
				<p class="blocked-count">
6997
					<?php echo number_format_i18n( get_site_option( 'jetpack_protect_blocked_attempts', 0 ) ); ?>
6998
				</p>
6999
				<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>
7000
			<?php elseif ( current_user_can( 'jetpack_activate_modules' ) && ! ( new Status() )->is_development_mode() ) : ?>
7001
				<a href="
7002
				<?php
7003
				echo esc_url(
7004
					wp_nonce_url(
7005
						self::admin_url(
7006
							array(
7007
								'action' => 'activate',
7008
								'module' => 'protect',
7009
							)
7010
						),
7011
						'jetpack_activate-protect'
7012
					)
7013
				);
7014
				?>
7015
							" class="button button-jetpack" title="<?php esc_attr_e( 'Protect helps to keep you secure from brute-force login attacks.', 'jetpack' ); ?>">
7016
					<?php esc_html_e( 'Activate brute force attack protection', 'jetpack' ); ?>
7017
				</a>
7018
			<?php else : ?>
7019
				<?php esc_html_e( 'Brute force attack protection is inactive.', 'jetpack' ); ?>
7020
			<?php endif; ?>
7021
		</div>
7022
7023
		<div class="akismet">
7024
			<h3><?php esc_html_e( 'Anti-spam', 'jetpack' ); ?></h3>
7025
			<?php if ( is_plugin_active( 'akismet/akismet.php' ) ) : ?>
7026
				<p class="blocked-count">
7027
					<?php echo number_format_i18n( get_option( 'akismet_spam_count', 0 ) ); ?>
7028
				</p>
7029
				<p><?php echo esc_html_x( 'Blocked spam comments.', '{#} Spam comments blocked by Akismet -- number is on a prior line, text is a caption.', 'jetpack' ); ?></p>
7030
			<?php elseif ( current_user_can( 'activate_plugins' ) && ! is_wp_error( validate_plugin( 'akismet/akismet.php' ) ) ) : ?>
7031
				<a href="
7032
				<?php
7033
				echo esc_url(
7034
					wp_nonce_url(
7035
						add_query_arg(
7036
							array(
7037
								'action' => 'activate',
7038
								'plugin' => 'akismet/akismet.php',
7039
							),
7040
							admin_url( 'plugins.php' )
7041
						),
7042
						'activate-plugin_akismet/akismet.php'
7043
					)
7044
				);
7045
				?>
7046
							" class="button button-jetpack">
7047
					<?php esc_html_e( 'Activate Anti-spam', 'jetpack' ); ?>
7048
				</a>
7049
			<?php else : ?>
7050
				<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( 'Anti-spam can help to keep your blog safe from spam!', 'jetpack' ); ?></a></p>
7051
			<?php endif; ?>
7052
		</div>
7053
7054
		</footer>
7055
		<?php
7056
	}
7057
7058
	/*
7059
	 * Adds a "blank" column in the user admin table to display indication of user connection.
7060
	 */
7061
	function jetpack_icon_user_connected( $columns ) {
7062
		$columns['user_jetpack'] = '';
7063
		return $columns;
7064
	}
7065
7066
	/*
7067
	 * Show Jetpack icon if the user is linked.
7068
	 */
7069
	function jetpack_show_user_connected_icon( $val, $col, $user_id ) {
7070
		if ( 'user_jetpack' == $col && self::is_user_connected( $user_id ) ) {
7071
			$jetpack_logo = new Jetpack_Logo();
7072
			$emblem_html  = sprintf(
7073
				'<a title="%1$s" class="jp-emblem-user-admin">%2$s</a>',
7074
				esc_attr__( 'This user is linked and ready to fly with Jetpack.', 'jetpack' ),
7075
				$jetpack_logo->get_jp_emblem()
7076
			);
7077
			return $emblem_html;
7078
		}
7079
7080
		return $val;
7081
	}
7082
7083
	/*
7084
	 * Style the Jetpack user column
7085
	 */
7086
	function jetpack_user_col_style() {
7087
		global $current_screen;
7088
		if ( ! empty( $current_screen->base ) && 'users' == $current_screen->base ) {
7089
			?>
7090
			<style>
7091
				.fixed .column-user_jetpack {
7092
					width: 21px;
7093
				}
7094
				.jp-emblem-user-admin svg {
7095
					width: 20px;
7096
					height: 20px;
7097
				}
7098
				.jp-emblem-user-admin path {
7099
					fill: #00BE28;
7100
				}
7101
			</style>
7102
			<?php
7103
		}
7104
	}
7105
7106
	/**
7107
	 * Checks if Akismet is active and working.
7108
	 *
7109
	 * We dropped support for Akismet 3.0 with Jetpack 6.1.1 while introducing a check for an Akismet valid key
7110
	 * that implied usage of methods present since more recent version.
7111
	 * See https://github.com/Automattic/jetpack/pull/9585
7112
	 *
7113
	 * @since  5.1.0
7114
	 *
7115
	 * @return bool True = Akismet available. False = Aksimet not available.
7116
	 */
7117
	public static function is_akismet_active() {
7118
		static $status = null;
7119
7120
		if ( ! is_null( $status ) ) {
7121
			return $status;
7122
		}
7123
7124
		// Check if a modern version of Akismet is active.
7125
		if ( ! method_exists( 'Akismet', 'http_post' ) ) {
7126
			$status = false;
7127
			return $status;
7128
		}
7129
7130
		// Make sure there is a key known to Akismet at all before verifying key.
7131
		$akismet_key = Akismet::get_api_key();
7132
		if ( ! $akismet_key ) {
7133
			$status = false;
7134
			return $status;
7135
		}
7136
7137
		// Possible values: valid, invalid, failure via Akismet. false if no status is cached.
7138
		$akismet_key_state = get_transient( 'jetpack_akismet_key_is_valid' );
7139
7140
		// Do not used the cache result in wp-admin or REST API requests if the key isn't valid, in case someone is actively renewing, etc.
7141
		$recheck = ( is_admin() || ( defined( 'REST_REQUEST' ) && REST_REQUEST ) ) && 'valid' !== $akismet_key_state;
7142
		// We cache the result of the Akismet key verification for ten minutes.
7143
		if ( ! $akismet_key_state || $recheck ) {
7144
			$akismet_key_state = Akismet::verify_key( $akismet_key );
7145
			set_transient( 'jetpack_akismet_key_is_valid', $akismet_key_state, 10 * MINUTE_IN_SECONDS );
7146
		}
7147
7148
		$status = 'valid' === $akismet_key_state;
7149
7150
		return $status;
7151
	}
7152
7153
	/**
7154
	 * @deprecated
7155
	 *
7156
	 * @see Automattic\Jetpack\Sync\Modules\Users::is_function_in_backtrace
7157
	 */
7158
	public static function is_function_in_backtrace() {
7159
		_deprecated_function( __METHOD__, 'jetpack-7.6.0' );
7160
	}
7161
7162
	/**
7163
	 * Given a minified path, and a non-minified path, will return
7164
	 * a minified or non-minified file URL based on whether SCRIPT_DEBUG is set and truthy.
7165
	 *
7166
	 * Both `$min_base` and `$non_min_base` are expected to be relative to the
7167
	 * root Jetpack directory.
7168
	 *
7169
	 * @since 5.6.0
7170
	 *
7171
	 * @param string $min_path
7172
	 * @param string $non_min_path
7173
	 * @return string The URL to the file
7174
	 */
7175
	public static function get_file_url_for_environment( $min_path, $non_min_path ) {
7176
		return Assets::get_file_url_for_environment( $min_path, $non_min_path );
7177
	}
7178
7179
	/**
7180
	 * Checks for whether Jetpack Backup & Scan is enabled.
7181
	 * Will return true if the state of Backup & Scan is anything except "unavailable".
7182
	 *
7183
	 * @return bool|int|mixed
7184
	 */
7185
	public static function is_rewind_enabled() {
7186
		if ( ! self::is_active() ) {
7187
			return false;
7188
		}
7189
7190
		$rewind_enabled = get_transient( 'jetpack_rewind_enabled' );
7191
		if ( false === $rewind_enabled ) {
7192
			jetpack_require_lib( 'class.core-rest-api-endpoints' );
7193
			$rewind_data    = (array) Jetpack_Core_Json_Api_Endpoints::rewind_data();
7194
			$rewind_enabled = ( ! is_wp_error( $rewind_data )
7195
				&& ! empty( $rewind_data['state'] )
7196
				&& 'active' === $rewind_data['state'] )
7197
				? 1
7198
				: 0;
7199
7200
			set_transient( 'jetpack_rewind_enabled', $rewind_enabled, 10 * MINUTE_IN_SECONDS );
7201
		}
7202
		return $rewind_enabled;
7203
	}
7204
7205
	/**
7206
	 * Return Calypso environment value; used for developing Jetpack and pairing
7207
	 * it with different Calypso enrionments, such as localhost.
7208
	 *
7209
	 * @since 7.4.0
7210
	 *
7211
	 * @return string Calypso environment
7212
	 */
7213
	public static function get_calypso_env() {
7214
		if ( isset( $_GET['calypso_env'] ) ) {
7215
			return sanitize_key( $_GET['calypso_env'] );
7216
		}
7217
7218
		if ( getenv( 'CALYPSO_ENV' ) ) {
7219
			return sanitize_key( getenv( 'CALYPSO_ENV' ) );
7220
		}
7221
7222
		if ( defined( 'CALYPSO_ENV' ) && CALYPSO_ENV ) {
7223
			return sanitize_key( CALYPSO_ENV );
7224
		}
7225
7226
		return '';
7227
	}
7228
7229
	/**
7230
	 * Returns the hostname with protocol for Calypso.
7231
	 * Used for developing Jetpack with Calypso.
7232
	 *
7233
	 * @since 8.4.0
7234
	 *
7235
	 * @return string Calypso host.
7236
	 */
7237
	public static function get_calypso_host() {
7238
		$calypso_env = self::get_calypso_env();
7239
		switch ( $calypso_env ) {
7240
			case 'development':
7241
				return 'http://calypso.localhost:3000/';
7242
			case 'wpcalypso':
7243
				return 'https://wpcalypso.wordpress.com/';
7244
			case 'horizon':
7245
				return 'https://horizon.wordpress.com/';
7246
			default:
7247
				return 'https://wordpress.com/';
7248
		}
7249
	}
7250
7251
	/**
7252
	 * Checks whether or not TOS has been agreed upon.
7253
	 * Will return true if a user has clicked to register, or is already connected.
7254
	 */
7255
	public static function jetpack_tos_agreed() {
7256
		_deprecated_function( 'Jetpack::jetpack_tos_agreed', 'Jetpack 7.9.0', '\Automattic\Jetpack\Terms_Of_Service->has_agreed' );
7257
7258
		$terms_of_service = new Terms_Of_Service();
7259
		return $terms_of_service->has_agreed();
7260
7261
	}
7262
7263
	/**
7264
	 * Handles activating default modules as well general cleanup for the new connection.
7265
	 *
7266
	 * @param boolean $activate_sso                 Whether to activate the SSO module when activating default modules.
7267
	 * @param boolean $redirect_on_activation_error Whether to redirect on activation error.
7268
	 * @param boolean $send_state_messages          Whether to send state messages.
7269
	 * @return void
7270
	 */
7271
	public static function handle_post_authorization_actions(
7272
		$activate_sso = false,
7273
		$redirect_on_activation_error = false,
7274
		$send_state_messages = true
7275
	) {
7276
		$other_modules = $activate_sso
7277
			? array( 'sso' )
7278
			: array();
7279
7280
		if ( $active_modules = Jetpack_Options::get_option( 'active_modules' ) ) {
7281
			self::delete_active_modules();
7282
7283
			self::activate_default_modules( 999, 1, array_merge( $active_modules, $other_modules ), $redirect_on_activation_error, $send_state_messages );
7284
		} else {
7285
			self::activate_default_modules( false, false, $other_modules, $redirect_on_activation_error, $send_state_messages );
7286
		}
7287
7288
		// Since this is a fresh connection, be sure to clear out IDC options
7289
		Jetpack_IDC::clear_all_idc_options();
7290
7291
		if ( $send_state_messages ) {
7292
			self::state( 'message', 'authorized' );
7293
		}
7294
	}
7295
7296
	/**
7297
	 * Returns a boolean for whether backups UI should be displayed or not.
7298
	 *
7299
	 * @return bool Should backups UI be displayed?
7300
	 */
7301
	public static function show_backups_ui() {
7302
		/**
7303
		 * Whether UI for backups should be displayed.
7304
		 *
7305
		 * @since 6.5.0
7306
		 *
7307
		 * @param bool $show_backups Should UI for backups be displayed? True by default.
7308
		 */
7309
		return self::is_plugin_active( 'vaultpress/vaultpress.php' ) || apply_filters( 'jetpack_show_backups', true );
7310
	}
7311
7312
	/*
7313
	 * Deprecated manage functions
7314
	 */
7315
	function prepare_manage_jetpack_notice() {
7316
		_deprecated_function( __METHOD__, 'jetpack-7.3' );
7317
	}
7318
	function manage_activate_screen() {
7319
		_deprecated_function( __METHOD__, 'jetpack-7.3' );
7320
	}
7321
	function admin_jetpack_manage_notice() {
7322
		_deprecated_function( __METHOD__, 'jetpack-7.3' );
7323
	}
7324
	function opt_out_jetpack_manage_url() {
7325
		_deprecated_function( __METHOD__, 'jetpack-7.3' );
7326
	}
7327
	function opt_in_jetpack_manage_url() {
7328
		_deprecated_function( __METHOD__, 'jetpack-7.3' );
7329
	}
7330
	function opt_in_jetpack_manage_notice() {
7331
		_deprecated_function( __METHOD__, 'jetpack-7.3' );
7332
	}
7333
	function can_display_jetpack_manage_notice() {
7334
		_deprecated_function( __METHOD__, 'jetpack-7.3' );
7335
	}
7336
7337
	/**
7338
	 * Clean leftoveruser meta.
7339
	 *
7340
	 * Delete Jetpack-related user meta when it is no longer needed.
7341
	 *
7342
	 * @since 7.3.0
7343
	 *
7344
	 * @param int $user_id User ID being updated.
7345
	 */
7346
	public static function user_meta_cleanup( $user_id ) {
7347
		$meta_keys = array(
7348
			// AtD removed from Jetpack 7.3
7349
			'AtD_options',
7350
			'AtD_check_when',
7351
			'AtD_guess_lang',
7352
			'AtD_ignored_phrases',
7353
		);
7354
7355
		foreach ( $meta_keys as $meta_key ) {
7356
			if ( get_user_meta( $user_id, $meta_key ) ) {
7357
				delete_user_meta( $user_id, $meta_key );
7358
			}
7359
		}
7360
	}
7361
7362
	/**
7363
	 * Checks if a Jetpack site is both active and not in development.
7364
	 *
7365
	 * This is a DRY function to avoid repeating `Jetpack::is_active && ! Automattic\Jetpack\Status->is_development_mode`.
7366
	 *
7367
	 * @return bool True if Jetpack is active and not in development.
7368
	 */
7369
	public static function is_active_and_not_development_mode() {
7370
		if ( ! self::is_active() || ( new Status() )->is_development_mode() ) {
7371
			return false;
7372
		}
7373
		return true;
7374
	}
7375
}
7376