Completed
Push — branch-4.2 ( 0ddea1...af69d2 )
by
unknown
09:59
created

class.jetpack.php (1 issue)

Upgrade to new PHP Analysis Engine

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

1
<?php
2
3
/*
4
Options:
5
jetpack_options (array)
6
	An array of options.
7
	@see Jetpack_Options::get_option_names()
8
9
jetpack_register (string)
10
	Temporary verification secrets.
11
12
jetpack_activated (int)
13
	1: the plugin was activated normally
14
	2: the plugin was activated on this site because of a network-wide activation
15
	3: the plugin was auto-installed
16
	4: the plugin was manually disconnected (but is still installed)
17
18
jetpack_active_modules (array)
19
	Array of active module slugs.
20
21
jetpack_do_activate (bool)
22
	Flag for "activating" the plugin on sites where the activation hook never fired (auto-installs)
23
*/
24
25
class Jetpack {
26
	public $xmlrpc_server = null;
27
28
	private $xmlrpc_verification = null;
29
30
	public $HTTP_RAW_POST_DATA = null; // copy of $GLOBALS['HTTP_RAW_POST_DATA']
31
32
	/**
33
	 * @var array The handles of styles that are concatenated into jetpack.css
34
	 */
35
	public $concatenated_style_handles = array(
36
		'jetpack-carousel',
37
		'grunion.css',
38
		'the-neverending-homepage',
39
		'jetpack_likes',
40
		'jetpack_related-posts',
41
		'sharedaddy',
42
		'jetpack-slideshow',
43
		'presentations',
44
		'jetpack-subscriptions',
45
		'tiled-gallery',
46
		'widget-conditions',
47
		'jetpack_display_posts_widget',
48
		'gravatar-profile-widget',
49
		'widget-grid-and-list',
50
		'jetpack-widgets',
51
		'goodreads-widget',
52
		'jetpack_social_media_icons_widget',
53
	);
54
55
	public $plugins_to_deactivate = array(
56
		'stats'               => array( 'stats/stats.php', 'WordPress.com Stats' ),
57
		'shortlinks'          => array( 'stats/stats.php', 'WordPress.com Stats' ),
58
		'sharedaddy'          => array( 'sharedaddy/sharedaddy.php', 'Sharedaddy' ),
59
		'twitter-widget'      => array( 'wickett-twitter-widget/wickett-twitter-widget.php', 'Wickett Twitter Widget' ),
60
		'after-the-deadline'  => array( 'after-the-deadline/after-the-deadline.php', 'After The Deadline' ),
61
		'contact-form'        => array( 'grunion-contact-form/grunion-contact-form.php', 'Grunion Contact Form' ),
62
		'contact-form'        => array( 'mullet/mullet-contact-form.php', 'Mullet Contact Form' ),
63
		'custom-css'          => array( 'safecss/safecss.php', 'WordPress.com Custom CSS' ),
64
		'random-redirect'     => array( 'random-redirect/random-redirect.php', 'Random Redirect' ),
65
		'videopress'          => array( 'video/video.php', 'VideoPress' ),
66
		'widget-visibility'   => array( 'jetpack-widget-visibility/widget-visibility.php', 'Jetpack Widget Visibility' ),
67
		'widget-visibility'   => array( 'widget-visibility-without-jetpack/widget-visibility-without-jetpack.php', 'Widget Visibility Without Jetpack' ),
68
		'sharedaddy'          => array( 'jetpack-sharing/sharedaddy.php', 'Jetpack Sharing' ),
69
		'omnisearch'          => array( 'jetpack-omnisearch/omnisearch.php', 'Jetpack Omnisearch' ),
70
		'gravatar-hovercards' => array( 'jetpack-gravatar-hovercards/gravatar-hovercards.php', 'Jetpack Gravatar Hovercards' ),
71
		'latex'               => array( 'wp-latex/wp-latex.php', 'WP LaTeX' )
72
	);
73
74
	static $capability_translations = array(
75
		'administrator' => 'manage_options',
76
		'editor'        => 'edit_others_posts',
77
		'author'        => 'publish_posts',
78
		'contributor'   => 'edit_posts',
79
		'subscriber'    => 'read',
80
	);
81
82
	/**
83
	 * Map of modules that have conflicts with plugins and should not be auto-activated
84
	 * if the plugins are active.  Used by filter_default_modules
85
	 *
86
	 * Plugin Authors: If you'd like to prevent a single module from auto-activating,
87
	 * change `module-slug` and add this to your plugin:
88
	 *
89
	 * add_filter( 'jetpack_get_default_modules', 'my_jetpack_get_default_modules' );
90
	 * function my_jetpack_get_default_modules( $modules ) {
91
	 *     return array_diff( $modules, array( 'module-slug' ) );
92
	 * }
93
	 *
94
	 * @var array
95
	 */
96
	private $conflicting_plugins = array(
97
		'comments'          => array(
98
			'Intense Debate'                       => 'intensedebate/intensedebate.php',
99
			'Disqus'                               => 'disqus-comment-system/disqus.php',
100
			'Livefyre'                             => 'livefyre-comments/livefyre.php',
101
			'Comments Evolved for WordPress'       => 'gplus-comments/comments-evolved.php',
102
			'Google+ Comments'                     => 'google-plus-comments/google-plus-comments.php',
103
			'WP-SpamShield Anti-Spam'              => 'wp-spamshield/wp-spamshield.php',
104
		),
105
		'contact-form'      => array(
106
			'Contact Form 7'                       => 'contact-form-7/wp-contact-form-7.php',
107
			'Gravity Forms'                        => 'gravityforms/gravityforms.php',
108
			'Contact Form Plugin'                  => 'contact-form-plugin/contact_form.php',
109
			'Easy Contact Forms'                   => 'easy-contact-forms/easy-contact-forms.php',
110
			'Fast Secure Contact Form'             => 'si-contact-form/si-contact-form.php',
111
		),
112
		'minileven'         => array(
113
			'WPtouch'                              => 'wptouch/wptouch.php',
114
		),
115
		'latex'             => array(
116
			'LaTeX for WordPress'                  => 'latex/latex.php',
117
			'Youngwhans Simple Latex'              => 'youngwhans-simple-latex/yw-latex.php',
118
			'Easy WP LaTeX'                        => 'easy-wp-latex-lite/easy-wp-latex-lite.php',
119
			'MathJax-LaTeX'                        => 'mathjax-latex/mathjax-latex.php',
120
			'Enable Latex'                         => 'enable-latex/enable-latex.php',
121
			'WP QuickLaTeX'                        => 'wp-quicklatex/wp-quicklatex.php',
122
		),
123
		'protect'           => array(
124
			'Limit Login Attempts'                 => 'limit-login-attempts/limit-login-attempts.php',
125
			'Captcha'                              => 'captcha/captcha.php',
126
			'Brute Force Login Protection'         => 'brute-force-login-protection/brute-force-login-protection.php',
127
			'Login Security Solution'              => 'login-security-solution/login-security-solution.php',
128
			'WPSecureOps Brute Force Protect'      => 'wpsecureops-bruteforce-protect/wpsecureops-bruteforce-protect.php',
129
			'BulletProof Security'                 => 'bulletproof-security/bulletproof-security.php',
130
			'SiteGuard WP Plugin'                  => 'siteguard/siteguard.php',
131
			'Security-protection'                  => 'security-protection/security-protection.php',
132
			'Login Security'                       => 'login-security/login-security.php',
133
			'Botnet Attack Blocker'                => 'botnet-attack-blocker/botnet-attack-blocker.php',
134
			'Wordfence Security'                   => 'wordfence/wordfence.php',
135
			'All In One WP Security & Firewall'    => 'all-in-one-wp-security-and-firewall/wp-security.php',
136
			'iThemes Security'                     => 'better-wp-security/better-wp-security.php',
137
		),
138
		'random-redirect'   => array(
139
			'Random Redirect 2'                    => 'random-redirect-2/random-redirect.php',
140
		),
141
		'related-posts'     => array(
142
			'YARPP'                                => 'yet-another-related-posts-plugin/yarpp.php',
143
			'WordPress Related Posts'              => 'wordpress-23-related-posts-plugin/wp_related_posts.php',
144
			'nrelate Related Content'              => 'nrelate-related-content/nrelate-related.php',
145
			'Contextual Related Posts'             => 'contextual-related-posts/contextual-related-posts.php',
146
			'Related Posts for WordPress'          => 'microkids-related-posts/microkids-related-posts.php',
147
			'outbrain'                             => 'outbrain/outbrain.php',
148
			'Shareaholic'                          => 'shareaholic/shareaholic.php',
149
			'Sexybookmarks'                        => 'sexybookmarks/shareaholic.php',
150
		),
151
		'sharedaddy'        => array(
152
			'AddThis'                              => 'addthis/addthis_social_widget.php',
153
			'Add To Any'                           => 'add-to-any/add-to-any.php',
154
			'ShareThis'                            => 'share-this/sharethis.php',
155
			'Shareaholic'                          => 'shareaholic/shareaholic.php',
156
		),
157
		'verification-tools' => array(
158
			'WordPress SEO by Yoast'               => 'wordpress-seo/wp-seo.php',
159
			'WordPress SEO Premium by Yoast'       => 'wordpress-seo-premium/wp-seo-premium.php',
160
			'All in One SEO Pack'                  => 'all-in-one-seo-pack/all_in_one_seo_pack.php',
161
		),
162
		'widget-visibility' => array(
163
			'Widget Logic'                         => 'widget-logic/widget_logic.php',
164
			'Dynamic Widgets'                      => 'dynamic-widgets/dynamic-widgets.php',
165
		),
166
		'sitemaps' => array(
167
			'Google XML Sitemaps'                  => 'google-sitemap-generator/sitemap.php',
168
			'Better WordPress Google XML Sitemaps' => 'bwp-google-xml-sitemaps/bwp-simple-gxs.php',
169
			'Google XML Sitemaps for qTranslate'   => 'google-xml-sitemaps-v3-for-qtranslate/sitemap.php',
170
			'XML Sitemap & Google News feeds'      => 'xml-sitemap-feed/xml-sitemap.php',
171
			'Google Sitemap by BestWebSoft'        => 'google-sitemap-plugin/google-sitemap-plugin.php',
172
			'WordPress SEO by Yoast'               => 'wordpress-seo/wp-seo.php',
173
			'WordPress SEO Premium by Yoast'       => 'wordpress-seo-premium/wp-seo-premium.php',
174
			'All in One SEO Pack'                  => 'all-in-one-seo-pack/all_in_one_seo_pack.php',
175
			'Sitemap'                              => 'sitemap/sitemap.php',
176
			'Simple Wp Sitemap'                    => 'simple-wp-sitemap/simple-wp-sitemap.php',
177
			'Simple Sitemap'                       => 'simple-sitemap/simple-sitemap.php',
178
			'XML Sitemaps'                         => 'xml-sitemaps/xml-sitemaps.php',
179
			'MSM Sitemaps'                         => 'msm-sitemap/msm-sitemap.php',
180
		),
181
	);
182
183
	/**
184
	 * Plugins for which we turn off our Facebook OG Tags implementation.
185
	 *
186
	 * Note: WordPress SEO by Yoast and WordPress SEO Premium by Yoast automatically deactivate
187
	 * Jetpack's Open Graph tags via filter when their Social Meta modules are active.
188
	 *
189
	 * Plugin authors: If you'd like to prevent Jetpack's Open Graph tag generation in your plugin, you can do so via this filter:
190
	 * add_filter( 'jetpack_enable_open_graph', '__return_false' );
191
	 */
192
	private $open_graph_conflicting_plugins = array(
193
		'2-click-socialmedia-buttons/2-click-socialmedia-buttons.php',
194
		                                                         // 2 Click Social Media Buttons
195
		'add-link-to-facebook/add-link-to-facebook.php',         // Add Link to Facebook
196
		'add-meta-tags/add-meta-tags.php',                       // Add Meta Tags
197
		'autodescription/autodescription.php',                   // The SEO Framework
198
		'easy-facebook-share-thumbnails/esft.php',               // Easy Facebook Share Thumbnail
199
		'heateor-open-graph-meta-tags/heateor-open-graph-meta-tags.php',
200
		                                                         // Open Graph Meta Tags by Heateor
201
		'facebook/facebook.php',                                 // Facebook (official plugin)
202
		'facebook-awd/AWD_facebook.php',                         // Facebook AWD All in one
203
		'facebook-featured-image-and-open-graph-meta-tags/fb-featured-image.php',
204
		                                                         // Facebook Featured Image & OG Meta Tags
205
		'facebook-meta-tags/facebook-metatags.php',              // Facebook Meta Tags
206
		'wonderm00ns-simple-facebook-open-graph-tags/wonderm00n-open-graph.php',
207
		                                                         // Facebook Open Graph Meta Tags for WordPress
208
		'facebook-revised-open-graph-meta-tag/index.php',        // Facebook Revised Open Graph Meta Tag
209
		'facebook-thumb-fixer/_facebook-thumb-fixer.php',        // Facebook Thumb Fixer
210
		'facebook-and-digg-thumbnail-generator/facebook-and-digg-thumbnail-generator.php',
211
		                                                         // Fedmich's Facebook Open Graph Meta
212
		'header-footer/plugin.php',                              // Header and Footer
213
		'network-publisher/networkpub.php',                      // Network Publisher
214
		'nextgen-facebook/nextgen-facebook.php',                 // NextGEN Facebook OG
215
		'social-networks-auto-poster-facebook-twitter-g/NextScripts_SNAP.php',
216
		                                                         // NextScripts SNAP
217
		'opengraph/opengraph.php',                               // Open Graph
218
		'open-graph-protocol-framework/open-graph-protocol-framework.php',
219
		                                                         // Open Graph Protocol Framework
220
		'seo-facebook-comments/seofacebook.php',                 // SEO Facebook Comments
221
		'seo-ultimate/seo-ultimate.php',                         // SEO Ultimate
222
		'sexybookmarks/sexy-bookmarks.php',                      // Shareaholic
223
		'shareaholic/sexy-bookmarks.php',                        // Shareaholic
224
		'sharepress/sharepress.php',                             // SharePress
225
		'simple-facebook-connect/sfc.php',                       // Simple Facebook Connect
226
		'social-discussions/social-discussions.php',             // Social Discussions
227
		'social-sharing-toolkit/social_sharing_toolkit.php',     // Social Sharing Toolkit
228
		'socialize/socialize.php',                               // Socialize
229
		'only-tweet-like-share-and-google-1/tweet-like-plusone.php',
230
		                                                         // Tweet, Like, Google +1 and Share
231
		'wordbooker/wordbooker.php',                             // Wordbooker
232
		'wpsso/wpsso.php',                                       // WordPress Social Sharing Optimization
233
		'wp-caregiver/wp-caregiver.php',                         // WP Caregiver
234
		'wp-facebook-like-send-open-graph-meta/wp-facebook-like-send-open-graph-meta.php',
235
		                                                         // WP Facebook Like Send & Open Graph Meta
236
		'wp-facebook-open-graph-protocol/wp-facebook-ogp.php',   // WP Facebook Open Graph protocol
237
		'wp-ogp/wp-ogp.php',                                     // WP-OGP
238
		'zoltonorg-social-plugin/zosp.php',                      // Zolton.org Social Plugin
239
		'wp-fb-share-like-button/wp_fb_share-like_widget.php'    // WP Facebook Like Button
240
	);
241
242
	/**
243
	 * Plugins for which we turn off our Twitter Cards Tags implementation.
244
	 */
245
	private $twitter_cards_conflicting_plugins = array(
246
	//	'twitter/twitter.php',                       // The official one handles this on its own.
247
	//	                                             // https://github.com/twitter/wordpress/blob/master/src/Twitter/WordPress/Cards/Compatibility.php
248
		'eewee-twitter-card/index.php',              // Eewee Twitter Card
249
		'ig-twitter-cards/ig-twitter-cards.php',     // IG:Twitter Cards
250
		'jm-twitter-cards/jm-twitter-cards.php',     // JM Twitter Cards
251
		'kevinjohn-gallagher-pure-web-brilliants-social-graph-twitter-cards-extention/kevinjohn_gallagher___social_graph_twitter_output.php',
252
		                                             // Pure Web Brilliant's Social Graph Twitter Cards Extension
253
		'twitter-cards/twitter-cards.php',           // Twitter Cards
254
		'twitter-cards-meta/twitter-cards-meta.php', // Twitter Cards Meta
255
		'wp-twitter-cards/twitter_cards.php',        // WP Twitter Cards
256
	);
257
258
	/**
259
	 * Message to display in admin_notice
260
	 * @var string
261
	 */
262
	public $message = '';
263
264
	/**
265
	 * Error to display in admin_notice
266
	 * @var string
267
	 */
268
	public $error = '';
269
270
	/**
271
	 * Modules that need more privacy description.
272
	 * @var string
273
	 */
274
	public $privacy_checks = '';
275
276
	/**
277
	 * Stats to record once the page loads
278
	 *
279
	 * @var array
280
	 */
281
	public $stats = array();
282
283
	/**
284
	 * Jetpack_Sync object
285
	 */
286
	public $sync;
287
288
	/**
289
	 * Verified data for JSON authorization request
290
	 */
291
	public $json_api_authorization_request = array();
292
293
	/**
294
	 * Holds the singleton instance of this class
295
	 * @since 2.3.3
296
	 * @var Jetpack
297
	 */
298
	static $instance = false;
299
300
	/**
301
	 * Singleton
302
	 * @static
303
	 */
304
	public static function init() {
305
		if ( ! self::$instance ) {
306
			if ( did_action( 'plugins_loaded' ) )
307
				self::plugin_textdomain();
308
			else
309
				add_action( 'plugins_loaded', array( __CLASS__, 'plugin_textdomain' ), 99 );
310
311
			self::$instance = new Jetpack;
312
313
			self::$instance->plugin_upgrade();
314
		}
315
316
		return self::$instance;
317
	}
318
319
	/**
320
	 * Must never be called statically
321
	 */
322
	function plugin_upgrade() {
323
		if ( Jetpack::is_active() ) {
324
			list( $version ) = explode( ':', Jetpack_Options::get_option( 'version' ) );
325
			if ( JETPACK__VERSION != $version ) {
326
327
				// Check which active modules actually exist and remove others from active_modules list
328
				$unfiltered_modules = Jetpack::get_active_modules();
329
				$modules = array_filter( $unfiltered_modules, array( 'Jetpack', 'is_module' ) );
330
				if ( array_diff( $unfiltered_modules, $modules ) ) {
331
					Jetpack::update_active_modules( $modules );
332
				}
333
334
				// Reset cached module data
335
				Jetpack_Options::delete_option( 'file_data' );
336
337
				add_action( 'init', array( __CLASS__, 'activate_new_modules' ) );
338
				Jetpack::maybe_set_version_option();
339
			}
340
		}
341
	}
342
343
	static function activate_manage( ) {
344
		if ( did_action( 'init' ) || current_filter() == 'init' ) {
345
			self::activate_module( 'manage', false, false );
346
		} else if ( !  has_action( 'init' , array( __CLASS__, 'activate_manage' ) ) ) {
347
			add_action( 'init', array( __CLASS__, 'activate_manage' ) );
348
		}
349
	}
350
351
	static function update_active_modules( $modules ) {
352
		$current_modules = Jetpack_Options::get_option( 'active_modules', array() );
353
		
354
		$success = Jetpack_Options::update_option( 'active_modules', array_unique( $modules ) );
355
		
356
		if ( is_array( $modules ) && is_array( $current_modules ) ) {
357
			$new_active_modules = array_diff( $modules, $current_modules );
358
			foreach( $new_active_modules as $module ) {
359
				/**
360
				 * Fires when a specific module is activated.
361
				 *
362
				 * @since 1.9.0
363
				 *
364
				 * @param string $module Module slug.
365
				 * @param boolean $success whether the module was activated. @since 4.2
366
				 */
367
				do_action( 'jetpack_activate_module', $module, $success );
368
369
				/**
370
				 * Fires when a module is activated.
371
				 * The dynamic part of the filter, $module, is the module slug.
372
				 *
373
				 * @since 1.9.0
374
				 *
375
				 * @param string $module Module slug.
376
				 */
377
				do_action( "jetpack_activate_module_$module", $module );
378
			}
379
380
			$new_deactive_modules = array_diff( $current_modules, $modules );
381
			foreach( $new_deactive_modules as $module ) {
382
				/**
383
				 * Fired after a module has been deactivated.
384
				 *
385
				 * @since 4.2.0
386
				 *
387
				 * @param string $module Module slug.
388
				 * @param boolean $success whether the module was deactivated.
389
				 */
390
				do_action( 'jetpack_deactivate_module', $module, $success );
391
				/**
392
				 * Fires when a module is deactivated.
393
				 * The dynamic part of the filter, $module, is the module slug.
394
				 *
395
				 * @since 1.9.0
396
				 *
397
				 * @param string $module Module slug.
398
				 */
399
				do_action( "jetpack_deactivate_module_$module", $module );
400
			}
401
		}
402
403
		return $success;
404
	}
405
406
	static function delete_active_modules() {
407
		self::update_active_modules( array() );
408
	}
409
410
	/**
411
	 * Constructor.  Initializes WordPress hooks
412
	 */
413
	private function __construct() {
414
		/*
415
		 * Check for and alert any deprecated hooks
416
		 */
417
		add_action( 'init', array( $this, 'deprecated_hooks' ) );
418
419
420
		/*
421
		 * Load things that should only be in Network Admin.
422
		 *
423
		 * For now blow away everything else until a more full
424
		 * understanding of what is needed at the network level is
425
		 * available
426
		 */
427
		if( is_multisite() ) {
428
			Jetpack_Network::init();
429
		}
430
431
		// Unlink user before deleting the user from .com
432
		add_action( 'deleted_user', array( $this, 'unlink_user' ), 10, 1 );
433
		add_action( 'remove_user_from_blog', array( $this, 'unlink_user' ), 10, 1 );
434
435
		if ( defined( 'XMLRPC_REQUEST' ) && XMLRPC_REQUEST && isset( $_GET['for'] ) && 'jetpack' == $_GET['for'] ) {
436
			@ini_set( 'display_errors', false ); // Display errors can cause the XML to be not well formed.
437
438
			require_once JETPACK__PLUGIN_DIR . 'class.jetpack-xmlrpc-server.php';
439
			$this->xmlrpc_server = new Jetpack_XMLRPC_Server();
440
441
			$this->require_jetpack_authentication();
442
443
			if ( Jetpack::is_active() ) {
444
				// Hack to preserve $HTTP_RAW_POST_DATA
445
				add_filter( 'xmlrpc_methods', array( $this, 'xmlrpc_methods' ) );
446
447
				$signed = $this->verify_xml_rpc_signature();
448
				if ( $signed && ! is_wp_error( $signed ) ) {
449
					// The actual API methods.
450
					add_filter( 'xmlrpc_methods', array( $this->xmlrpc_server, 'xmlrpc_methods' ) );
451
				} else {
452
					// The jetpack.authorize method should be available for unauthenticated users on a site with an
453
					// active Jetpack connection, so that additional users can link their account.
454
					add_filter( 'xmlrpc_methods', array( $this->xmlrpc_server, 'authorize_xmlrpc_methods' ) );
455
				}
456
			} else {
457
				// The bootstrap API methods.
458
				add_filter( 'xmlrpc_methods', array( $this->xmlrpc_server, 'bootstrap_xmlrpc_methods' ) );
459
			}
460
461
			// Now that no one can authenticate, and we're whitelisting all XML-RPC methods, force enable_xmlrpc on.
462
			add_filter( 'pre_option_enable_xmlrpc', '__return_true' );
463
		} elseif ( is_admin() && isset( $_POST['action'] ) && 'jetpack_upload_file' == $_POST['action'] ) {
464
			$this->require_jetpack_authentication();
465
			$this->add_remote_request_handlers();
466
		} else {
467
			if ( Jetpack::is_active() ) {
468
				add_action( 'login_form_jetpack_json_api_authorization', array( &$this, 'login_form_json_api_authorization' ) );
469
				add_filter( 'xmlrpc_methods', array( $this, 'public_xmlrpc_methods' ) );
470
			}
471
		}
472
473
		if ( Jetpack::is_active() ) {
474
			Jetpack_Heartbeat::init();
475
		}
476
477
		add_action( 'jetpack_clean_nonces', array( 'Jetpack', 'clean_nonces' ) );
478
		if ( ! wp_next_scheduled( 'jetpack_clean_nonces' ) ) {
479
			wp_schedule_event( time(), 'hourly', 'jetpack_clean_nonces' );
480
		}
481
482
		add_filter( 'xmlrpc_blog_options', array( $this, 'xmlrpc_options' ) );
483
484
		add_action( 'admin_init', array( $this, 'admin_init' ) );
485
		add_action( 'admin_init', array( $this, 'dismiss_jetpack_notice' ) );
486
487
		add_filter( 'admin_body_class', array( $this, 'admin_body_class' ) );
488
489
		add_action( 'wp_dashboard_setup', array( $this, 'wp_dashboard_setup' ) );
490
		// Filter the dashboard meta box order to swap the new one in in place of the old one.
491
		add_filter( 'get_user_option_meta-box-order_dashboard', array( $this, 'get_user_option_meta_box_order_dashboard' ) );
492
493
		// returns HTTPS support status
494
		add_action( 'wp_ajax_jetpack-recheck-ssl', array( $this, 'ajax_recheck_ssl' ) );
495
496
		// Jump Start AJAX callback function
497
		add_action( 'wp_ajax_jetpack_jumpstart_ajax',  array( $this, 'jetpack_jumpstart_ajax_callback' ) );
498
499
		// If any module option is updated before Jump Start is dismissed, hide Jump Start.
500
		add_action( 'update_option', array( $this, 'jumpstart_has_updated_module_option' ) );
501
502
		// Identity Crisis AJAX callback function
503
		add_action( 'wp_ajax_jetpack_resolve_identity_crisis', array( $this, 'resolve_identity_crisis_ajax_callback' ) );
504
505
		// JITM AJAX callback function
506
		add_action( 'wp_ajax_jitm_ajax',  array( $this, 'jetpack_jitm_ajax_callback' ) );
507
508
		add_action( 'wp_ajax_jetpack_admin_ajax',          array( $this, 'jetpack_admin_ajax_callback' ) );
509
		add_action( 'wp_ajax_jetpack_admin_ajax_refresh',  array( $this, 'jetpack_admin_ajax_refresh_data' ) );
510
511
		// Universal ajax callback for all tracking events triggered via js
512
		add_action( 'wp_ajax_jetpack_tracks', array( $this, 'jetpack_admin_ajax_tracks_callback' ) );
513
514
		add_action( 'wp_loaded', array( $this, 'register_assets' ) );
515
		add_action( 'wp_enqueue_scripts', array( $this, 'devicepx' ) );
516
		add_action( 'customize_controls_enqueue_scripts', array( $this, 'devicepx' ) );
517
		add_action( 'admin_enqueue_scripts', array( $this, 'devicepx' ) );
518
519
		add_action( 'plugins_loaded', array( $this, 'extra_oembed_providers' ), 100 );
520
521
		add_action( 'jetpack_notices', array( $this, 'show_development_mode_notice' ) );
522
523
		add_action( 'jetpack_notices', array( $this, 'show_sync_lag_notice' ) );
524
525
		/**
526
		 * These actions run checks to load additional files.
527
		 * They check for external files or plugins, so they need to run as late as possible.
528
		 */
529
		add_action( 'wp_head', array( $this, 'check_open_graph' ),       1 );
530
		add_action( 'plugins_loaded', array( $this, 'check_twitter_tags' ),     999 );
531
		add_action( 'plugins_loaded', array( $this, 'check_rest_api_compat' ), 1000 );
532
533
		add_filter( 'plugins_url',      array( 'Jetpack', 'maybe_min_asset' ),     1, 3 );
534
		add_filter( 'style_loader_tag', array( 'Jetpack', 'maybe_inline_style' ), 10, 2 );
535
536
		add_filter( 'map_meta_cap', array( $this, 'jetpack_custom_caps' ), 1, 4 );
537
538
		add_filter( 'jetpack_get_default_modules', array( $this, 'filter_default_modules' ) );
539
		add_filter( 'jetpack_get_default_modules', array( $this, 'handle_deprecated_modules' ), 99 );
540
541
		// A filter to control all just in time messages
542
		add_filter( 'jetpack_just_in_time_msgs', '__return_false' );
543
544
		/**
545
		 * This is the hack to concatinate all css files into one.
546
		 * For description and reasoning see the implode_frontend_css method
547
		 *
548
		 * Super late priority so we catch all the registered styles
549
		 */
550
		if( !is_admin() ) {
551
			add_action( 'wp_print_styles', array( $this, 'implode_frontend_css' ), -1 ); // Run first
552
			add_action( 'wp_print_footer_scripts', array( $this, 'implode_frontend_css' ), -1 ); // Run first to trigger before `print_late_styles`
553
		}
554
555
	}
556
557
	function jetpack_admin_ajax_tracks_callback() {
558
		// Check for nonce
559
		if ( ! isset( $_REQUEST['tracksNonce'] ) || ! wp_verify_nonce( $_REQUEST['tracksNonce'], 'jp-tracks-ajax-nonce' ) ) {
560
			wp_die( 'Permissions check failed.' );
561
		}
562
563
		if ( ! isset( $_REQUEST['tracksEventName'] ) || ! isset( $_REQUEST['tracksEventType'] )  ) {
564
			wp_die( 'No valid event name or type.' );
565
		}
566
567
		$tracks_data = array();
568
		if ( 'click' === $_REQUEST['tracksEventType'] && isset( $_REQUEST['tracksEventProp'] ) ) {
569
			$tracks_data = array( 'clicked' => $_REQUEST['tracksEventProp'] );
570
		}
571
572
		JetpackTracking::record_user_event( $_REQUEST['tracksEventName'], $tracks_data );
573
		wp_send_json_success();
574
		wp_die();
575
	}
576
577
	function jetpack_admin_ajax_callback() {
578
		// Check for nonce
579 View Code Duplication
		if ( ! isset( $_REQUEST['adminNonce'] ) || ! wp_verify_nonce( $_REQUEST['adminNonce'], 'jetpack-admin-nonce' ) || ! current_user_can( 'jetpack_manage_modules' ) ) {
580
			wp_die( 'permissions check failed' );
581
		}
582
583
		if ( isset( $_REQUEST['toggleModule'] ) && 'nux-toggle-module' == $_REQUEST['toggleModule'] ) {
584
			$slug = $_REQUEST['thisModuleSlug'];
585
586
			if ( ! in_array( $slug, Jetpack::get_available_modules() ) ) {
587
				wp_die( 'That is not a Jetpack module slug' );
588
			}
589
590
			if ( Jetpack::is_module_active( $slug ) ) {
591
				Jetpack::deactivate_module( $slug );
592
			} else {
593
				Jetpack::activate_module( $slug, false, false );
594
			}
595
596
			$modules = Jetpack_Admin::init()->get_modules();
597
			echo json_encode( $modules[ $slug ] );
598
599
			exit;
600
		}
601
602
		wp_die();
603
	}
604
605
	/*
606
	 * Sometimes we need to refresh the data,
607
	 * especially if the page is visited via a 'history'
608
	 * event like back/forward
609
	 */
610
	function jetpack_admin_ajax_refresh_data() {
611
		// Check for nonce
612 View Code Duplication
		if ( ! isset( $_REQUEST['adminNonce'] ) || ! wp_verify_nonce( $_REQUEST['adminNonce'], 'jetpack-admin-nonce' ) ) {
613
			wp_die( 'permissions check failed' );
614
		}
615
616
		if ( isset( $_REQUEST['refreshData'] ) && 'refresh' == $_REQUEST['refreshData'] ) {
617
			$modules = Jetpack_Admin::init()->get_modules();
618
			echo json_encode( $modules );
619
			exit;
620
		}
621
622
		wp_die();
623
	}
624
625
	/**
626
	 * The callback for the Jump Start ajax requests.
627
	 */
628
	function jetpack_jumpstart_ajax_callback() {
629
		// Check for nonce
630
		if ( ! isset( $_REQUEST['jumpstartNonce'] ) || ! wp_verify_nonce( $_REQUEST['jumpstartNonce'], 'jetpack-jumpstart-nonce' ) )
631
			wp_die( 'permissions check failed' );
632
633
		if ( isset( $_REQUEST['jumpStartActivate'] ) && 'jump-start-activate' == $_REQUEST['jumpStartActivate'] ) {
634
			// Update the jumpstart option
635
			if ( 'new_connection' === Jetpack_Options::get_option( 'jumpstart' ) ) {
636
				Jetpack_Options::update_option( 'jumpstart', 'jumpstart_activated' );
637
			}
638
639
			// Loops through the requested "Jump Start" modules, and activates them.
640
			// Custom 'no_message' state, so that no message will be shown on reload.
641
			$modules = $_REQUEST['jumpstartModSlug'];
642
			$module_slugs = array();
643
			foreach( $modules as $module => $value ) {
644
				$module_slugs[] = $value['module_slug'];
645
			}
646
647
			// Check for possible conflicting plugins
648
			$module_slugs_filtered = $this->filter_default_modules( $module_slugs );
649
650
			foreach ( $module_slugs_filtered as $module_slug ) {
651
				Jetpack::log( 'activate', $module_slug );
652
				Jetpack::activate_module( $module_slug, false, false );
653
				Jetpack::state( 'message', 'no_message' );
654
			}
655
656
			// Set the default sharing buttons and set to display on posts if none have been set.
657
			$sharing_services = get_option( 'sharing-services' );
658
			$sharing_options  = get_option( 'sharing-options' );
659
			if ( empty( $sharing_services['visible'] ) ) {
660
				// Default buttons to set
661
				$visible = array(
662
					'twitter',
663
					'facebook',
664
					'google-plus-1',
665
				);
666
				$hidden = array();
667
668
				// Set some sharing settings
669
				$sharing = new Sharing_Service();
670
				$sharing_options['global'] = array(
671
					'button_style'  => 'icon',
672
					'sharing_label' => $sharing->default_sharing_label,
673
					'open_links'    => 'same',
674
					'show'          => array( 'post' ),
675
					'custom'        => isset( $sharing_options['global']['custom'] ) ? $sharing_options['global']['custom'] : array()
676
				);
677
678
				update_option( 'sharing-options', $sharing_options );
679
680
				// Send a success response so that we can display an error message.
681
				$success = update_option( 'sharing-services', array( 'visible' => $visible, 'hidden' => $hidden ) );
682
				echo json_encode( $success );
683
				exit;
684
			}
685
686
		} elseif ( isset( $_REQUEST['disableJumpStart'] ) && true == $_REQUEST['disableJumpStart'] ) {
687
			// If dismissed, flag the jumpstart option as such.
688
			// Send a success response so that we can display an error message.
689
			if ( 'new_connection' === Jetpack_Options::get_option( 'jumpstart' ) ) {
690
				$success = Jetpack_Options::update_option( 'jumpstart', 'jumpstart_dismissed' );
691
				echo json_encode( $success );
692
				exit;
693
			}
694
695
		} elseif ( isset( $_REQUEST['jumpStartDeactivate'] ) && 'jump-start-deactivate' == $_REQUEST['jumpStartDeactivate'] ) {
696
697
			// FOR TESTING ONLY
698
			// @todo remove
699
			$modules = (array) $_REQUEST['jumpstartModSlug'];
700
			foreach( $modules as $module => $value ) {
701
				if ( !in_array( $value['module_slug'], Jetpack::get_default_modules() ) ) {
702
					Jetpack::log( 'deactivate', $value['module_slug'] );
703
					Jetpack::deactivate_module( $value['module_slug'] );
704
					Jetpack::state( 'message', 'no_message' );
705
				} else {
706
					Jetpack::log( 'activate', $value['module_slug'] );
707
					Jetpack::activate_module( $value['module_slug'], false, false );
708
					Jetpack::state( 'message', 'no_message' );
709
				}
710
			}
711
712
			Jetpack_Options::update_option( 'jumpstart', 'new_connection' );
713
			echo "reload the page";
714
		}
715
716
		wp_die();
717
	}
718
719
	/**
720
	 * The callback for the JITM ajax requests.
721
	 */
722
	function jetpack_jitm_ajax_callback() {
723
		// Check for nonce
724
		if ( ! isset( $_REQUEST['jitmNonce'] ) || ! wp_verify_nonce( $_REQUEST['jitmNonce'], 'jetpack-jitm-nonce' ) ) {
725
			wp_die( 'Module activation failed due to lack of appropriate permissions' );
726
		}
727
		if ( isset( $_REQUEST['jitmActionToTake'] ) && 'activate' == $_REQUEST['jitmActionToTake'] ) {
728
			$module_slug = $_REQUEST['jitmModule'];
729
			Jetpack::log( 'activate', $module_slug );
730
			Jetpack::activate_module( $module_slug, false, false );
731
			Jetpack::state( 'message', 'no_message' );
732
733
			//A Jetpack module is being activated through a JITM, track it
734
			$this->stat( 'jitm', $module_slug.'-activated-' . JETPACK__VERSION );
735
			$this->do_stats( 'server_side' );
736
737
			wp_send_json_success();
738
		}
739
		if ( isset( $_REQUEST['jitmActionToTake'] ) && 'dismiss' == $_REQUEST['jitmActionToTake'] ) {
740
			// get the hide_jitm options array
741
			$jetpack_hide_jitm = Jetpack_Options::get_option( 'hide_jitm' );
742
			$module_slug = $_REQUEST['jitmModule'];
743
744
			if( ! $jetpack_hide_jitm ) {
745
				$jetpack_hide_jitm = array(
746
					$module_slug => 'hide'
747
				);
748
			} else {
749
				$jetpack_hide_jitm[$module_slug] = 'hide';
750
			}
751
752
			Jetpack_Options::update_option( 'hide_jitm', $jetpack_hide_jitm );
753
754
			//jitm is being dismissed forever, track it
755
			$this->stat( 'jitm', $module_slug.'-dismissed-' . JETPACK__VERSION );
756
			$this->do_stats( 'server_side' );
757
758
			wp_send_json_success();
759
		}
760 View Code Duplication
		if ( isset( $_REQUEST['jitmActionToTake'] ) && 'launch' == $_REQUEST['jitmActionToTake'] ) {
761
			$module_slug = $_REQUEST['jitmModule'];
762
763
			// User went to WordPress.com, track this
764
			$this->stat( 'jitm', $module_slug.'-wordpress-tools-' . JETPACK__VERSION );
765
			$this->do_stats( 'server_side' );
766
767
			wp_send_json_success();
768
		}
769 View Code Duplication
		if ( isset( $_REQUEST['jitmActionToTake'] ) && 'viewed' == $_REQUEST['jitmActionToTake'] ) {
770
			$track = $_REQUEST['jitmModule'];
771
772
			// User is viewing JITM, track it.
773
			$this->stat( 'jitm', $track . '-viewed-' . JETPACK__VERSION );
774
			$this->do_stats( 'server_side' );
775
776
			wp_send_json_success();
777
		}
778
	}
779
780
	/**
781
	 * If there are any stats that need to be pushed, but haven't been, push them now.
782
	 */
783
	function __destruct() {
784
		if ( ! empty( $this->stats ) ) {
785
			$this->do_stats( 'server_side' );
786
		}
787
	}
788
789
	function jetpack_custom_caps( $caps, $cap, $user_id, $args ) {
790
		switch( $cap ) {
791
			case 'jetpack_connect' :
792
			case 'jetpack_reconnect' :
793
				if ( Jetpack::is_development_mode() ) {
794
					$caps = array( 'do_not_allow' );
795
					break;
796
				}
797
				/**
798
				 * Pass through. If it's not development mode, these should match disconnect.
799
				 * Let users disconnect if it's development mode, just in case things glitch.
800
				 */
801
			case 'jetpack_disconnect' :
802
				/**
803
				 * In multisite, can individual site admins manage their own connection?
804
				 *
805
				 * Ideally, this should be extracted out to a separate filter in the Jetpack_Network class.
806
				 */
807
				if ( is_multisite() && ! is_super_admin() && is_plugin_active_for_network( 'jetpack/jetpack.php' ) ) {
808
					if ( ! Jetpack_Network::init()->get_option( 'sub-site-connection-override' ) ) {
809
						/**
810
						 * We need to update the option name -- it's terribly unclear which
811
						 * direction the override goes.
812
						 *
813
						 * @todo: Update the option name to `sub-sites-can-manage-own-connections`
814
						 */
815
						$caps = array( 'do_not_allow' );
816
						break;
817
					}
818
				}
819
820
				$caps = array( 'manage_options' );
821
				break;
822
			case 'jetpack_manage_modules' :
823
			case 'jetpack_activate_modules' :
824
			case 'jetpack_deactivate_modules' :
825
				$caps = array( 'manage_options' );
826
				break;
827
			case 'jetpack_configure_modules' :
828
				$caps = array( 'manage_options' );
829
				break;
830
			case 'jetpack_network_admin_page':
831
			case 'jetpack_network_settings_page':
832
				$caps = array( 'manage_network_plugins' );
833
				break;
834
			case 'jetpack_network_sites_page':
835
				$caps = array( 'manage_sites' );
836
				break;
837
			case 'jetpack_admin_page' :
838
				if ( Jetpack::is_development_mode() ) {
839
					$caps = array( 'manage_options' );
840
					break;
841
				} else {
842
					$caps = array( 'read' );
843
				}
844
				break;
845
			case 'jetpack_connect_user' :
846
				if ( Jetpack::is_development_mode() ) {
847
					$caps = array( 'do_not_allow' );
848
					break;
849
				}
850
				$caps = array( 'read' );
851
				break;
852
		}
853
		return $caps;
854
	}
855
856
	function require_jetpack_authentication() {
857
		// Don't let anyone authenticate
858
		$_COOKIE = array();
859
		remove_all_filters( 'authenticate' );
860
		remove_all_actions( 'wp_login_failed' );
861
862
		if ( Jetpack::is_active() ) {
863
			// Allow Jetpack authentication
864
			add_filter( 'authenticate', array( $this, 'authenticate_jetpack' ), 10, 3 );
865
		}
866
	}
867
868
	/**
869
	 * Load language files
870
	 */
871
	public static function plugin_textdomain() {
872
		// Note to self, the third argument must not be hardcoded, to account for relocated folders.
873
		load_plugin_textdomain( 'jetpack', false, dirname( plugin_basename( JETPACK__PLUGIN_FILE ) ) . '/languages/' );
874
	}
875
876
	/**
877
	 * Register assets for use in various modules and the Jetpack admin page.
878
	 *
879
	 * @uses wp_script_is, wp_register_script, plugins_url
880
	 * @action wp_loaded
881
	 * @return null
882
	 */
883
	public function register_assets() {
884
		if ( ! wp_script_is( 'spin', 'registered' ) ) {
885
			wp_register_script( 'spin', plugins_url( '_inc/spin.js', JETPACK__PLUGIN_FILE ), false, '1.3' );
886
		}
887
888 View Code Duplication
		if ( ! wp_script_is( 'jquery.spin', 'registered' ) ) {
889
			wp_register_script( 'jquery.spin', plugins_url( '_inc/jquery.spin.js', JETPACK__PLUGIN_FILE ) , array( 'jquery', 'spin' ), '1.3' );
890
		}
891
892 View Code Duplication
		if ( ! wp_script_is( 'jetpack-gallery-settings', 'registered' ) ) {
893
			wp_register_script( 'jetpack-gallery-settings', plugins_url( '_inc/gallery-settings.js', JETPACK__PLUGIN_FILE ), array( 'media-views' ), '20121225' );
894
		}
895
896 View Code Duplication
		if ( ! wp_script_is( 'jetpack-twitter-timeline', 'registered' ) ) {
897
			wp_register_script( 'jetpack-twitter-timeline', plugins_url( '_inc/twitter-timeline.js', JETPACK__PLUGIN_FILE ) , array( 'jquery' ), '4.0.0', true );
898
		}
899
900
		if ( ! wp_script_is( 'jetpack-facebook-embed', 'registered' ) ) {
901
			wp_register_script( 'jetpack-facebook-embed', plugins_url( '_inc/facebook-embed.js', __FILE__ ), array( 'jquery' ), null, true );
902
903
			/** This filter is documented in modules/sharedaddy/sharing-sources.php */
904
			$fb_app_id = apply_filters( 'jetpack_sharing_facebook_app_id', '249643311490' );
905
			if ( ! is_numeric( $fb_app_id ) ) {
906
				$fb_app_id = '';
907
			}
908
			wp_localize_script(
909
				'jetpack-facebook-embed',
910
				'jpfbembed',
911
				array(
912
					'appid' => $fb_app_id,
913
					'locale' => $this->get_locale(),
914
				)
915
			);
916
		}
917
918
		/**
919
		 * As jetpack_register_genericons is by default fired off a hook,
920
		 * the hook may have already fired by this point.
921
		 * So, let's just trigger it manually.
922
		 */
923
		require_once( JETPACK__PLUGIN_DIR . '_inc/genericons.php' );
924
		jetpack_register_genericons();
925
926
		/**
927
		 * Register the social logos
928
		 */
929
		require_once( JETPACK__PLUGIN_DIR . '_inc/social-logos.php' );
930
		jetpack_register_social_logos();
931
932 View Code Duplication
		if ( ! wp_style_is( 'jetpack-icons', 'registered' ) )
933
			wp_register_style( 'jetpack-icons', plugins_url( 'css/jetpack-icons.min.css', JETPACK__PLUGIN_FILE ), false, JETPACK__VERSION );
934
	}
935
936
	/**
937
	 * Guess locale from language code.
938
	 *
939
	 * @param string $lang Language code.
940
	 * @return string|bool
941
	 */
942 View Code Duplication
	function guess_locale_from_lang( $lang ) {
943
		if ( 'en' === $lang || 'en_US' === $lang || ! $lang ) {
944
			return 'en_US';
945
		}
946
947
		if ( ! class_exists( 'GP_Locales' ) ) {
948
			if ( ! defined( 'JETPACK__GLOTPRESS_LOCALES_PATH' ) || ! file_exists( JETPACK__GLOTPRESS_LOCALES_PATH ) ) {
949
				return false;
950
			}
951
952
			require JETPACK__GLOTPRESS_LOCALES_PATH;
953
		}
954
955
		if ( defined( 'IS_WPCOM' ) && IS_WPCOM ) {
956
			// WP.com: get_locale() returns 'it'
957
			$locale = GP_Locales::by_slug( $lang );
958
		} else {
959
			// Jetpack: get_locale() returns 'it_IT';
960
			$locale = GP_Locales::by_field( 'facebook_locale', $lang );
961
		}
962
963
		if ( ! $locale ) {
964
			return false;
965
		}
966
967
		if ( empty( $locale->facebook_locale ) ) {
968
			if ( empty( $locale->wp_locale ) ) {
969
				return false;
970
			} else {
971
				// Facebook SDK is smart enough to fall back to en_US if a
972
				// locale isn't supported. Since supported Facebook locales
973
				// can fall out of sync, we'll attempt to use the known
974
				// wp_locale value and rely on said fallback.
975
				return $locale->wp_locale;
976
			}
977
		}
978
979
		return $locale->facebook_locale;
980
	}
981
982
	/**
983
	 * Get the locale.
984
	 *
985
	 * @return string|bool
986
	 */
987
	function get_locale() {
988
		$locale = $this->guess_locale_from_lang( get_locale() );
989
990
		if ( ! $locale ) {
991
			$locale = 'en_US';
992
		}
993
994
		return $locale;
995
	}
996
997
	/**
998
	 * Device Pixels support
999
	 * This improves the resolution of gravatars and wordpress.com uploads on hi-res and zoomed browsers.
1000
	 */
1001
	function devicepx() {
1002
		if ( Jetpack::is_active() ) {
1003
			wp_enqueue_script( 'devicepx', set_url_scheme( 'http://s0.wp.com/wp-content/js/devicepx-jetpack.js' ), array(), gmdate( 'oW' ), true );
1004
		}
1005
	}
1006
1007
	/**
1008
	 * Return the network_site_url so that .com knows what network this site is a part of.
1009
	 * @param  bool $option
1010
	 * @return string
1011
	 */
1012
	public function jetpack_main_network_site_option( $option ) {
1013
		return network_site_url();
1014
	}
1015
	/**
1016
	 * Network Name.
1017
	 */
1018
	static function network_name( $option = null ) {
1019
		global $current_site;
1020
		return $current_site->site_name;
1021
	}
1022
	/**
1023
	 * Does the network allow new user and site registrations.
1024
	 * @return string
1025
	 */
1026
	static function network_allow_new_registrations( $option = null ) {
1027
		return ( in_array( get_site_option( 'registration' ), array('none', 'user', 'blog', 'all' ) ) ? get_site_option( 'registration') : 'none' );
1028
	}
1029
	/**
1030
	 * Does the network allow admins to add new users.
1031
	 * @return boolian
1032
	 */
1033
	static function network_add_new_users( $option = null ) {
1034
		return (bool) get_site_option( 'add_new_users' );
1035
	}
1036
	/**
1037
	 * File upload psace left per site in MB.
1038
	 *  -1 means NO LIMIT.
1039
	 * @return number
1040
	 */
1041
	static function network_site_upload_space( $option = null ) {
1042
		// value in MB
1043
		return ( get_site_option( 'upload_space_check_disabled' ) ? -1 : get_space_allowed() );
1044
	}
1045
1046
	/**
1047
	 * Network allowed file types.
1048
	 * @return string
1049
	 */
1050
	static function network_upload_file_types( $option = null ) {
1051
		return get_site_option( 'upload_filetypes', 'jpg jpeg png gif' );
1052
	}
1053
1054
	/**
1055
	 * Maximum file upload size set by the network.
1056
	 * @return number
1057
	 */
1058
	static function network_max_upload_file_size( $option = null ) {
1059
		// value in KB
1060
		return get_site_option( 'fileupload_maxk', 300 );
1061
	}
1062
1063
	/**
1064
	 * Lets us know if a site allows admins to manage the network.
1065
	 * @return array
1066
	 */
1067
	static function network_enable_administration_menus( $option = null ) {
1068
		return get_site_option( 'menu_items' );
1069
	}
1070
1071
	/**
1072
	 * Return whether we are dealing with a multi network setup or not.
1073
	 * The reason we are type casting this is because we want to avoid the situation where
1074
	 * the result is false since when is_main_network_option return false it cases
1075
	 * the rest the get_option( 'jetpack_is_multi_network' ); to return the value that is set in the
1076
	 * database which could be set to anything as opposed to what this function returns.
1077
	 * @param  bool  $option
1078
	 *
1079
	 * @return boolean
1080
	 */
1081
	public function is_main_network_option( $option ) {
1082
		// return '1' or ''
1083
		return (string) (bool) Jetpack::is_multi_network();
1084
	}
1085
1086
	/**
1087
	 * Return true if we are with multi-site or multi-network false if we are dealing with single site.
1088
	 *
1089
	 * @param  string  $option
1090
	 * @return boolean
1091
	 */
1092
	public function is_multisite( $option ) {
1093
		return (string) (bool) is_multisite();
1094
	}
1095
1096
	/**
1097
	 * Implemented since there is no core is multi network function
1098
	 * Right now there is no way to tell if we which network is the dominant network on the system
1099
	 *
1100
	 * @since  3.3
1101
	 * @return boolean
1102
	 */
1103
	public static function is_multi_network() {
1104
		global  $wpdb;
1105
1106
		// if we don't have a multi site setup no need to do any more
1107
		if ( ! is_multisite() ) {
1108
			return false;
1109
		}
1110
1111
		$num_sites = $wpdb->get_var( "SELECT COUNT(*) FROM {$wpdb->site}" );
1112
		if ( $num_sites > 1 ) {
1113
			return true;
1114
		} else {
1115
			return false;
1116
		}
1117
	}
1118
1119
	/**
1120
	 * Trigger an update to the main_network_site when we update the siteurl of a site.
1121
	 * @return null
1122
	 */
1123
	function update_jetpack_main_network_site_option() {
1124
		_deprecated_function( __METHOD__, 'jetpack-4.2' );
1125
	}
1126
	/**
1127
	 * Triggered after a user updates the network settings via Network Settings Admin Page
1128
	 *
1129
	 */
1130
	function update_jetpack_network_settings() {
1131
		_deprecated_function( __METHOD__, 'jetpack-4.2' );
1132
		// Only sync this info for the main network site.
1133
	}
1134
1135
	/**
1136
	 * Get back if the current site is single user site.
1137
	 *
1138
	 * @return bool
1139
	 */
1140
	public static function is_single_user_site() {
1141
		global $wpdb;
1142
		$some_users = $wpdb->get_var( "select count(*) from (select user_id from $wpdb->usermeta where meta_key = '{$wpdb->prefix}capabilities' LIMIT 2) as someusers" );
1143
		return 1 === (int) $some_users;
1144
	}
1145
1146
	/**
1147
	 * Returns true if the site has file write access false otherwise.
1148
	 * @return string ( '1' | '0' )
1149
	 **/
1150
	public static function file_system_write_access() {
1151
		if ( ! function_exists( 'get_filesystem_method' ) ) {
1152
			require_once( ABSPATH . 'wp-admin/includes/file.php' );
1153
		}
1154
1155
		require_once( ABSPATH . 'wp-admin/includes/template.php' );
1156
1157
		$filesystem_method = get_filesystem_method();
1158
		if ( $filesystem_method === 'direct' ) {
1159
			return 1;
1160
		}
1161
1162
		ob_start();
1163
		$filesystem_credentials_are_stored = request_filesystem_credentials( self_admin_url() );
1164
		ob_end_clean();
1165
		if ( $filesystem_credentials_are_stored ) {
1166
			return 1;
1167
		}
1168
		return 0;
1169
	}
1170
1171
	/**
1172
	 * Finds out if a site is using a version control system.
1173
	 * @return string ( '1' | '0' )
1174
	 **/
1175
	public static function is_version_controlled() {
1176
		_deprecated_function( __METHOD__, 'jetpack-4.2', 'Jetpack_Sync_Functions::is_version_controlled' );
1177
		return (string) (int) Jetpack_Sync_Functions::is_version_controlled();
1178
	}
1179
1180
	/**
1181
	 * Determines whether the current theme supports featured images or not.
1182
	 * @return string ( '1' | '0' )
1183
	 */
1184
	public static function featured_images_enabled() {
1185
		_deprecated_function( __METHOD__, 'jetpack-4.2' );
1186
		return current_theme_supports( 'post-thumbnails' ) ? '1' : '0';
1187
	}
1188
1189
	/**
1190
	 * jetpack_updates is saved in the following schema:
1191
	 *
1192
	 * array (
1193
	 *      'plugins'                       => (int) Number of plugin updates available.
1194
	 *      'themes'                        => (int) Number of theme updates available.
1195
	 *      'wordpress'                     => (int) Number of WordPress core updates available.
1196
	 *      'translations'                  => (int) Number of translation updates available.
1197
	 *      'total'                         => (int) Total of all available updates.
1198
	 *      'wp_update_version'             => (string) The latest available version of WordPress, only present if a WordPress update is needed.
1199
	 * )
1200
	 * @return array
1201
	 */
1202
	public static function get_updates() {
1203
		$update_data = wp_get_update_data();
1204
1205
		// Stores the individual update counts as well as the total count.
1206
		if ( isset( $update_data['counts'] ) ) {
1207
			$updates = $update_data['counts'];
1208
		}
1209
1210
		// If we need to update WordPress core, let's find the latest version number.
1211 View Code Duplication
		if ( ! empty( $updates['wordpress'] ) ) {
1212
			$cur = get_preferred_from_update_core();
1213
			if ( isset( $cur->response ) && 'upgrade' === $cur->response ) {
1214
				$updates['wp_update_version'] = $cur->current;
1215
			}
1216
		}
1217
		return isset( $updates ) ? $updates : array();
1218
	}
1219
1220
	public static function get_update_details() {
1221
		$update_details = array(
1222
			'update_core' => get_site_transient( 'update_core' ),
1223
			'update_plugins' => get_site_transient( 'update_plugins' ),
1224
			'update_themes' => get_site_transient( 'update_themes' ),
1225
		);
1226
		return $update_details;
1227
	}
1228
1229
	public static function refresh_update_data() {
1230
		_deprecated_function( __METHOD__, 'jetpack-4.2' );
1231
1232
	}
1233
1234
	public static function refresh_theme_data() {
1235
		_deprecated_function( __METHOD__, 'jetpack-4.2' );
1236
	}
1237
1238
	/**
1239
	 * Is Jetpack active?
1240
	 */
1241
	public static function is_active() {
1242
		return (bool) Jetpack_Data::get_access_token( JETPACK_MASTER_USER );
1243
	}
1244
1245
	/**
1246
	 * Is Jetpack in development (offline) mode?
1247
	 */
1248
	public static function is_development_mode() {
1249
		$development_mode = false;
1250
1251
		if ( defined( 'JETPACK_DEV_DEBUG' ) ) {
1252
			$development_mode = JETPACK_DEV_DEBUG;
1253
		}
1254
1255
		elseif ( site_url() && false === strpos( site_url(), '.' ) ) {
1256
			$development_mode = true;
1257
		}
1258
		/**
1259
		 * Filters Jetpack's development mode.
1260
		 *
1261
		 * @see https://jetpack.com/support/development-mode/
1262
		 *
1263
		 * @since 2.2.1
1264
		 *
1265
		 * @param bool $development_mode Is Jetpack's development mode active.
1266
		 */
1267
		return apply_filters( 'jetpack_development_mode', $development_mode );
1268
	}
1269
1270
	/**
1271
	* Get Jetpack development mode notice text and notice class.
1272
	*
1273
	* Mirrors the checks made in Jetpack::is_development_mode
1274
	*
1275
	*/
1276
	public static function show_development_mode_notice() {
1277
		if ( Jetpack::is_development_mode() ) {
1278
			if ( defined( 'JETPACK_DEV_DEBUG' ) && JETPACK_DEV_DEBUG ) {
1279
				$notice = sprintf(
1280
					/* translators: %s is a URL */
1281
					__( 'In <a href="%s" target="_blank">Development Mode</a>, via the JETPACK_DEV_DEBUG constant being defined in wp-config.php or elsewhere.', 'jetpack' ),
1282
					'https://jetpack.com/support/development-mode/'
1283
				);
1284
			} elseif ( site_url() && false === strpos( site_url(), '.' ) ) {
1285
				$notice = sprintf(
1286
					/* translators: %s is a URL */
1287
					__( 'In <a href="%s" target="_blank">Development Mode</a>, via site URL lacking a dot (e.g. http://localhost).', 'jetpack' ),
1288
					'https://jetpack.com/support/development-mode/'
1289
				);
1290
			} else {
1291
				$notice = sprintf(
1292
					/* translators: %s is a URL */
1293
					__( 'In <a href="%s" target="_blank">Development Mode</a>, via the jetpack_development_mode filter.', 'jetpack' ),
1294
					'https://jetpack.com/support/development-mode/'
1295
				);
1296
			}
1297
1298
			echo '<div class="updated" style="border-color: #f0821e;"><p>' . $notice . '</p></div>';
1299
		}
1300
1301
		// Throw up a notice if using a development version and as for feedback.
1302
		if ( Jetpack::is_development_version() ) {
1303
			/* translators: %s is a URL */
1304
			$notice = sprintf( __( 'You are currently running a development version of Jetpack. <a href="%s" target="_blank">Submit your feedback</a>', 'jetpack' ), 'https://jetpack.com/contact-support/beta-group/' );
1305
1306
			echo '<div class="updated" style="border-color: #f0821e;"><p>' . $notice . '</p></div>';
1307
		}
1308
		// Throw up a notice if using staging mode
1309
		if ( Jetpack::is_staging_site() ) {
1310
			/* translators: %s is a URL */
1311
			$notice = sprintf( __( 'You are running Jetpack on a <a href="%s" target="_blank">staging server</a>.', 'jetpack' ), 'https://jetpack.com/support/staging-sites/' );
1312
1313
			echo '<div class="updated" style="border-color: #f0821e;"><p>' . $notice . '</p></div>';
1314
		}
1315
	}
1316
1317
	public static function show_sync_lag_notice() {
1318
		if ( ! Jetpack::is_active() && Jetpack::is_staging_site() && Jetpack::is_development_mode() ) {
1319
			return;
1320
		}
1321
1322
		require_once JETPACK__PLUGIN_DIR . 'sync/class.jetpack-sync-listener.php';
1323
		$listener = Jetpack_Sync_Listener::get_instance();
1324
		$queue = $listener->get_sync_queue();
1325
1326
		if ( ! $listener->can_add_to_queue( $queue ) ) { // Display notice if the lag is large then 24 hours.
1327
			$contact_url = admin_url( "admin.php?page=jetpack-debugger&contact=1&note=Jetpack is not able to talk to WordPress.com." );
1328
			$notice = sprintf(
1329
				__( 'Oh no! Jetpack is unable to communicate with WordPress.com. This affects a number of features you may be using. Please check your server logs for errors and <a href="%s">contact Jetpack support</a>.', 'jetpack' ),
1330
				esc_url( $contact_url )
1331
			);
1332
			echo '<div class="error" style="border-color: #dc3232;"><p>' . $notice . '</p></div>';
1333
		}
1334
	}
1335
1336
	/**
1337
	 * Whether Jetpack's version maps to a public release, or a development version.
1338
	 */
1339
	public static function is_development_version() {
1340
		return ! preg_match( '/^\d+(\.\d+)+$/', JETPACK__VERSION );
1341
	}
1342
1343
	/**
1344
	 * Is a given user (or the current user if none is specified) linked to a WordPress.com user?
1345
	 */
1346
	public static function is_user_connected( $user_id = false ) {
1347
		$user_id = false === $user_id ? get_current_user_id() : absint( $user_id );
1348
		if ( ! $user_id ) {
1349
			return false;
1350
		}
1351
1352
		return (bool) Jetpack_Data::get_access_token( $user_id );
1353
	}
1354
1355
	/**
1356
	 * Get the wpcom user data of the current|specified connected user.
1357
	 */
1358 View Code Duplication
	public static function get_connected_user_data( $user_id = null ) {
1359
		if ( ! $user_id ) {
1360
			$user_id = get_current_user_id();
1361
		}
1362
		Jetpack::load_xml_rpc_client();
1363
		$xml = new Jetpack_IXR_Client( array(
1364
			'user_id' => $user_id,
1365
		) );
1366
		$xml->query( 'wpcom.getUser' );
1367
		if ( ! $xml->isError() ) {
1368
			return $xml->getResponse();
1369
		}
1370
		return false;
1371
	}
1372
1373
	/**
1374
	 * Get the wpcom email of the current|specified connected user.
1375
	 */
1376 View Code Duplication
	public static function get_connected_user_email( $user_id = null ) {
1377
		if ( ! $user_id ) {
1378
			$user_id = get_current_user_id();
1379
		}
1380
		Jetpack::load_xml_rpc_client();
1381
		$xml = new Jetpack_IXR_Client( array(
1382
			'user_id' => $user_id,
1383
		) );
1384
		$xml->query( 'wpcom.getUserEmail' );
1385
		if ( ! $xml->isError() ) {
1386
			return $xml->getResponse();
1387
		}
1388
		return false;
1389
	}
1390
1391
	/**
1392
	 * Get the wpcom email of the master user.
1393
	 */
1394
	public static function get_master_user_email() {
1395
		$master_user_id = Jetpack_Options::get_option( 'master_user' );
1396
		if ( $master_user_id ) {
1397
			return self::get_connected_user_email( $master_user_id );
1398
		}
1399
		return '';
1400
	}
1401
1402
	function current_user_is_connection_owner() {
1403
		$user_token = Jetpack_Data::get_access_token( JETPACK_MASTER_USER );
1404
		return $user_token && is_object( $user_token ) && isset( $user_token->external_user_id ) && get_current_user_id() === $user_token->external_user_id;
1405
	}
1406
1407
	/**
1408
	 * Add any extra oEmbed providers that we know about and use on wpcom for feature parity.
1409
	 */
1410
	function extra_oembed_providers() {
1411
		// Cloudup: https://dev.cloudup.com/#oembed
1412
		wp_oembed_add_provider( 'https://cloudup.com/*' , 'https://cloudup.com/oembed' );
1413
		wp_oembed_add_provider( 'https://me.sh/*', 'https://me.sh/oembed?format=json' );
1414
		wp_oembed_add_provider( '#https?://(www\.)?gfycat\.com/.*#i', 'https://api.gfycat.com/v1/oembed', true );
1415
		wp_oembed_add_provider( '#https?://[^.]+\.(wistia\.com|wi\.st)/(medias|embed)/.*#', 'https://fast.wistia.com/oembed', true );
1416
		wp_oembed_add_provider( '#https?://sketchfab\.com/.*#i', 'https://sketchfab.com/oembed', true );
1417
	}
1418
1419
	/**
1420
	 * Synchronize connected user role changes
1421
	 */
1422
	function user_role_change( $user_id ) {
1423
		_deprecated_function( __METHOD__, 'jetpack-4.2', 'Jetpack_Sync_Users::user_role_change()' );
1424
		Jetpack_Sync_Users::user_role_change( $user_id );
1425
	}
1426
1427
	/**
1428
	 * Loads the currently active modules.
1429
	 */
1430
	public static function load_modules() {
1431
		if ( ! self::is_active() && !self::is_development_mode() ) {
1432
			if ( ! is_multisite() || ! get_site_option( 'jetpack_protect_active' ) ) {
1433
				return;
1434
			}
1435
		}
1436
1437
		$version = Jetpack_Options::get_option( 'version' );
1438 View Code Duplication
		if ( ! $version ) {
1439
			$version = $old_version = JETPACK__VERSION . ':' . time();
1440
			/** This action is documented in class.jetpack.php */
1441
			do_action( 'updating_jetpack_version', $version, false );
1442
			Jetpack_Options::update_options( compact( 'version', 'old_version' ) );
1443
		}
1444
		list( $version ) = explode( ':', $version );
1445
1446
		$modules = array_filter( Jetpack::get_active_modules(), array( 'Jetpack', 'is_module' ) );
1447
1448
		$modules_data = array();
1449
1450
		// Don't load modules that have had "Major" changes since the stored version until they have been deactivated/reactivated through the lint check.
1451
		if ( version_compare( $version, JETPACK__VERSION, '<' ) ) {
1452
			$updated_modules = array();
1453
			foreach ( $modules as $module ) {
1454
				$modules_data[ $module ] = Jetpack::get_module( $module );
1455
				if ( ! isset( $modules_data[ $module ]['changed'] ) ) {
1456
					continue;
1457
				}
1458
1459
				if ( version_compare( $modules_data[ $module ]['changed'], $version, '<=' ) ) {
1460
					continue;
1461
				}
1462
1463
				$updated_modules[] = $module;
1464
			}
1465
1466
			$modules = array_diff( $modules, $updated_modules );
1467
		}
1468
1469
		$is_development_mode = Jetpack::is_development_mode();
1470
1471
		foreach ( $modules as $index => $module ) {
1472
			// If we're in dev mode, disable modules requiring a connection
1473
			if ( $is_development_mode ) {
1474
				// Prime the pump if we need to
1475
				if ( empty( $modules_data[ $module ] ) ) {
1476
					$modules_data[ $module ] = Jetpack::get_module( $module );
1477
				}
1478
				// If the module requires a connection, but we're in local mode, don't include it.
1479
				if ( $modules_data[ $module ]['requires_connection'] ) {
1480
					continue;
1481
				}
1482
			}
1483
1484
			if ( did_action( 'jetpack_module_loaded_' . $module ) ) {
1485
				continue;
1486
			}
1487
1488
			if ( ! @include( Jetpack::get_module_path( $module ) ) ) {
1489
				unset( $modules[ $index ] );
1490
				self::update_active_modules( array_values( $modules ) );
1491
				continue;
1492
			}
1493
1494
			/**
1495
			 * Fires when a specific module is loaded.
1496
			 * The dynamic part of the hook, $module, is the module slug.
1497
			 *
1498
			 * @since 1.1.0
1499
			 */
1500
			do_action( 'jetpack_module_loaded_' . $module );
1501
		}
1502
1503
		/**
1504
		 * Fires when all the modules are loaded.
1505
		 *
1506
		 * @since 1.1.0
1507
		 */
1508
		do_action( 'jetpack_modules_loaded' );
1509
1510
		// 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.
1511
		if ( Jetpack::is_active() || Jetpack::is_development_mode() )
1512
			require_once( JETPACK__PLUGIN_DIR . 'modules/module-extras.php' );
1513
	}
1514
1515
	/**
1516
	 * Check if Jetpack's REST API compat file should be included
1517
	 * @action plugins_loaded
1518
	 * @return null
1519
	 */
1520
	public function check_rest_api_compat() {
1521
		/**
1522
		 * Filters the list of REST API compat files to be included.
1523
		 *
1524
		 * @since 2.2.5
1525
		 *
1526
		 * @param array $args Array of REST API compat files to include.
1527
		 */
1528
		$_jetpack_rest_api_compat_includes = apply_filters( 'jetpack_rest_api_compat', array() );
1529
1530
		if ( function_exists( 'bbpress' ) )
1531
			$_jetpack_rest_api_compat_includes[] = JETPACK__PLUGIN_DIR . 'class.jetpack-bbpress-json-api-compat.php';
1532
1533
		foreach ( $_jetpack_rest_api_compat_includes as $_jetpack_rest_api_compat_include )
1534
			require_once $_jetpack_rest_api_compat_include;
1535
	}
1536
1537
	/**
1538
	 * Gets all plugins currently active in values, regardless of whether they're
1539
	 * traditionally activated or network activated.
1540
	 *
1541
	 * @todo Store the result in core's object cache maybe?
1542
	 */
1543
	public static function get_active_plugins() {
1544
		$active_plugins = (array) get_option( 'active_plugins', array() );
1545
1546
		if ( is_multisite() ) {
1547
			// Due to legacy code, active_sitewide_plugins stores them in the keys,
1548
			// whereas active_plugins stores them in the values.
1549
			$network_plugins = array_keys( get_site_option( 'active_sitewide_plugins', array() ) );
1550
			if ( $network_plugins ) {
1551
				$active_plugins = array_merge( $active_plugins, $network_plugins );
1552
			}
1553
		}
1554
1555
		sort( $active_plugins );
1556
1557
		return array_unique( $active_plugins );
1558
	}
1559
1560
	/**
1561
	 * Gets and parses additional plugin data to send with the heartbeat data
1562
	 *
1563
	 * @since 3.8.1
1564
	 *
1565
	 * @return array Array of plugin data
1566
	 */
1567
	public static function get_parsed_plugin_data() {
1568
		if ( ! function_exists( 'get_plugins' ) ) {
1569
			require_once( ABSPATH . 'wp-admin/includes/plugin.php' );
1570
		}
1571
		/** This filter is documented in wp-admin/includes/class-wp-plugins-list-table.php */
1572
		$all_plugins    = apply_filters( 'all_plugins', get_plugins() );
1573
		$active_plugins = Jetpack::get_active_plugins();
1574
1575
		$plugins = array();
1576
		foreach ( $all_plugins as $path => $plugin_data ) {
1577
			$plugins[ $path ] = array(
1578
					'is_active' => in_array( $path, $active_plugins ),
1579
					'file'      => $path,
1580
					'name'      => $plugin_data['Name'],
1581
					'version'   => $plugin_data['Version'],
1582
					'author'    => $plugin_data['Author'],
1583
			);
1584
		}
1585
1586
		return $plugins;
1587
	}
1588
1589
	/**
1590
	 * Gets and parses theme data to send with the heartbeat data
1591
	 *
1592
	 * @since 3.8.1
1593
	 *
1594
	 * @return array Array of theme data
1595
	 */
1596
	public static function get_parsed_theme_data() {
1597
		$all_themes = wp_get_themes( array( 'allowed' => true ) );
1598
		$header_keys = array( 'Name', 'Author', 'Version', 'ThemeURI', 'AuthorURI', 'Status', 'Tags' );
1599
1600
		$themes = array();
1601
		foreach ( $all_themes as $slug => $theme_data ) {
1602
			$theme_headers = array();
1603
			foreach ( $header_keys as $header_key ) {
1604
				$theme_headers[ $header_key ] = $theme_data->get( $header_key );
1605
			}
1606
1607
			$themes[ $slug ] = array(
1608
					'is_active_theme' => $slug == wp_get_theme()->get_template(),
1609
					'slug' => $slug,
1610
					'theme_root' => $theme_data->get_theme_root_uri(),
1611
					'parent' => $theme_data->parent(),
1612
					'headers' => $theme_headers
1613
			);
1614
		}
1615
1616
		return $themes;
1617
	}
1618
1619
	/**
1620
	 * Checks whether a specific plugin is active.
1621
	 *
1622
	 * We don't want to store these in a static variable, in case
1623
	 * there are switch_to_blog() calls involved.
1624
	 */
1625
	public static function is_plugin_active( $plugin = 'jetpack/jetpack.php' ) {
1626
		return in_array( $plugin, self::get_active_plugins() );
1627
	}
1628
1629
	/**
1630
	 * Check if Jetpack's Open Graph tags should be used.
1631
	 * If certain plugins are active, Jetpack's og tags are suppressed.
1632
	 *
1633
	 * @uses Jetpack::get_active_modules, add_filter, get_option, apply_filters
1634
	 * @action plugins_loaded
1635
	 * @return null
1636
	 */
1637
	public function check_open_graph() {
1638
		if ( in_array( 'publicize', Jetpack::get_active_modules() ) || in_array( 'sharedaddy', Jetpack::get_active_modules() ) ) {
1639
			add_filter( 'jetpack_enable_open_graph', '__return_true', 0 );
1640
		}
1641
1642
		$active_plugins = self::get_active_plugins();
1643
1644
		if ( ! empty( $active_plugins ) ) {
1645
			foreach ( $this->open_graph_conflicting_plugins as $plugin ) {
1646
				if ( in_array( $plugin, $active_plugins ) ) {
1647
					add_filter( 'jetpack_enable_open_graph', '__return_false', 99 );
1648
					break;
1649
				}
1650
			}
1651
		}
1652
1653
		/**
1654
		 * Allow the addition of Open Graph Meta Tags to all pages.
1655
		 *
1656
		 * @since 2.0.3
1657
		 *
1658
		 * @param bool false Should Open Graph Meta tags be added. Default to false.
1659
		 */
1660
		if ( apply_filters( 'jetpack_enable_open_graph', false ) ) {
1661
			require_once JETPACK__PLUGIN_DIR . 'functions.opengraph.php';
1662
		}
1663
	}
1664
1665
	/**
1666
	 * Check if Jetpack's Twitter tags should be used.
1667
	 * If certain plugins are active, Jetpack's twitter tags are suppressed.
1668
	 *
1669
	 * @uses Jetpack::get_active_modules, add_filter, get_option, apply_filters
1670
	 * @action plugins_loaded
1671
	 * @return null
1672
	 */
1673
	public function check_twitter_tags() {
1674
1675
		$active_plugins = self::get_active_plugins();
1676
1677
		if ( ! empty( $active_plugins ) ) {
1678
			foreach ( $this->twitter_cards_conflicting_plugins as $plugin ) {
1679
				if ( in_array( $plugin, $active_plugins ) ) {
1680
					add_filter( 'jetpack_disable_twitter_cards', '__return_true', 99 );
1681
					break;
1682
				}
1683
			}
1684
		}
1685
1686
		/**
1687
		 * Allow Twitter Card Meta tags to be disabled.
1688
		 *
1689
		 * @since 2.6.0
1690
		 *
1691
		 * @param bool true Should Twitter Card Meta tags be disabled. Default to true.
1692
		 */
1693
		if ( ! apply_filters( 'jetpack_disable_twitter_cards', false ) ) {
1694
			require_once JETPACK__PLUGIN_DIR . 'class.jetpack-twitter-cards.php';
1695
		}
1696
	}
1697
1698
	/**
1699
	 * Allows plugins to submit security reports.
1700
 	 *
1701
	 * @param string  $type         Report type (login_form, backup, file_scanning, spam)
1702
	 * @param string  $plugin_file  Plugin __FILE__, so that we can pull plugin data
1703
	 * @param array   $args         See definitions above
1704
	 */
1705
	public static function submit_security_report( $type = '', $plugin_file = '', $args = array() ) {
1706
		_deprecated_function( __FUNCTION__, 'jetpack-4.2', null );
1707
	}
1708
1709
/* Jetpack Options API */
1710
1711
	public static function get_option_names( $type = 'compact' ) {
1712
		return Jetpack_Options::get_option_names( $type );
1713
	}
1714
1715
	/**
1716
	 * Returns the requested option.  Looks in jetpack_options or jetpack_$name as appropriate.
1717
 	 *
1718
	 * @param string $name    Option name
1719
	 * @param mixed  $default (optional)
1720
	 */
1721
	public static function get_option( $name, $default = false ) {
1722
		return Jetpack_Options::get_option( $name, $default );
1723
	}
1724
1725
	/**
1726
	* Stores two secrets and a timestamp so WordPress.com can make a request back and verify an action
1727
	* Does some extra verification so urls (such as those to public-api, register, etc) can't just be crafted
1728
	* $name must be a registered option name.
1729
	*/
1730
	public static function create_nonce( $name ) {
1731
		$secret = wp_generate_password( 32, false ) . ':' . wp_generate_password( 32, false ) . ':' . ( time() + 600 );
1732
1733
		Jetpack_Options::update_option( $name, $secret );
1734
		@list( $secret_1, $secret_2, $eol ) = explode( ':', Jetpack_Options::get_option( $name ) );
1735
		if ( empty( $secret_1 ) || empty( $secret_2 ) || $eol < time() )
1736
			return new Jetpack_Error( 'missing_secrets' );
1737
1738
		return array(
1739
			'secret_1' => $secret_1,
1740
			'secret_2' => $secret_2,
1741
			'eol'      => $eol,
1742
		);
1743
	}
1744
1745
	/**
1746
	 * Updates the single given option.  Updates jetpack_options or jetpack_$name as appropriate.
1747
 	 *
1748
	 * @deprecated 3.4 use Jetpack_Options::update_option() instead.
1749
	 * @param string $name  Option name
1750
	 * @param mixed  $value Option value
1751
	 */
1752
	public static function update_option( $name, $value ) {
1753
		_deprecated_function( __METHOD__, 'jetpack-3.4', 'Jetpack_Options::update_option()' );
1754
		return Jetpack_Options::update_option( $name, $value );
1755
	}
1756
1757
	/**
1758
	 * Updates the multiple given options.  Updates jetpack_options and/or jetpack_$name as appropriate.
1759
 	 *
1760
	 * @deprecated 3.4 use Jetpack_Options::update_options() instead.
1761
	 * @param array $array array( option name => option value, ... )
1762
	 */
1763
	public static function update_options( $array ) {
1764
		_deprecated_function( __METHOD__, 'jetpack-3.4', 'Jetpack_Options::update_options()' );
1765
		return Jetpack_Options::update_options( $array );
1766
	}
1767
1768
	/**
1769
	 * Deletes the given option.  May be passed multiple option names as an array.
1770
	 * Updates jetpack_options and/or deletes jetpack_$name as appropriate.
1771
	 *
1772
	 * @deprecated 3.4 use Jetpack_Options::delete_option() instead.
1773
	 * @param string|array $names
1774
	 */
1775
	public static function delete_option( $names ) {
1776
		_deprecated_function( __METHOD__, 'jetpack-3.4', 'Jetpack_Options::delete_option()' );
1777
		return Jetpack_Options::delete_option( $names );
1778
	}
1779
1780
	/**
1781
	 * Enters a user token into the user_tokens option
1782
	 *
1783
	 * @param int $user_id
1784
	 * @param string $token
1785
	 * return bool
1786
	 */
1787
	public static function update_user_token( $user_id, $token, $is_master_user ) {
1788
		// not designed for concurrent updates
1789
		$user_tokens = Jetpack_Options::get_option( 'user_tokens' );
1790
		if ( ! is_array( $user_tokens ) )
1791
			$user_tokens = array();
1792
		$user_tokens[$user_id] = $token;
1793
		if ( $is_master_user ) {
1794
			$master_user = $user_id;
1795
			$options     = compact( 'user_tokens', 'master_user' );
1796
		} else {
1797
			$options = compact( 'user_tokens' );
1798
		}
1799
		return Jetpack_Options::update_options( $options );
1800
	}
1801
1802
	/**
1803
	 * Returns an array of all PHP files in the specified absolute path.
1804
	 * Equivalent to glob( "$absolute_path/*.php" ).
1805
	 *
1806
	 * @param string $absolute_path The absolute path of the directory to search.
1807
	 * @return array Array of absolute paths to the PHP files.
1808
	 */
1809
	public static function glob_php( $absolute_path ) {
1810
		if ( function_exists( 'glob' ) ) {
1811
			return glob( "$absolute_path/*.php" );
1812
		}
1813
1814
		$absolute_path = untrailingslashit( $absolute_path );
1815
		$files = array();
1816
		if ( ! $dir = @opendir( $absolute_path ) ) {
1817
			return $files;
1818
		}
1819
1820
		while ( false !== $file = readdir( $dir ) ) {
1821
			if ( '.' == substr( $file, 0, 1 ) || '.php' != substr( $file, -4 ) ) {
1822
				continue;
1823
			}
1824
1825
			$file = "$absolute_path/$file";
1826
1827
			if ( ! is_file( $file ) ) {
1828
				continue;
1829
			}
1830
1831
			$files[] = $file;
1832
		}
1833
1834
		closedir( $dir );
1835
1836
		return $files;
1837
	}
1838
1839
	public static function activate_new_modules( $redirect = false ) {
1840
		if ( ! Jetpack::is_active() && ! Jetpack::is_development_mode() ) {
1841
			return;
1842
		}
1843
1844
		$jetpack_old_version = Jetpack_Options::get_option( 'version' ); // [sic]
1845 View Code Duplication
		if ( ! $jetpack_old_version ) {
1846
			$jetpack_old_version = $version = $old_version = '1.1:' . time();
1847
			/** This action is documented in class.jetpack.php */
1848
			do_action( 'updating_jetpack_version', $version, false );
1849
			Jetpack_Options::update_options( compact( 'version', 'old_version' ) );
1850
		}
1851
1852
		list( $jetpack_version ) = explode( ':', $jetpack_old_version ); // [sic]
1853
1854
		if ( version_compare( JETPACK__VERSION, $jetpack_version, '<=' ) ) {
1855
			return;
1856
		}
1857
1858
		$active_modules     = Jetpack::get_active_modules();
1859
		$reactivate_modules = array();
1860
		foreach ( $active_modules as $active_module ) {
1861
			$module = Jetpack::get_module( $active_module );
1862
			if ( ! isset( $module['changed'] ) ) {
1863
				continue;
1864
			}
1865
1866
			if ( version_compare( $module['changed'], $jetpack_version, '<=' ) ) {
1867
				continue;
1868
			}
1869
1870
			$reactivate_modules[] = $active_module;
1871
			Jetpack::deactivate_module( $active_module );
1872
		}
1873
1874
		$new_version = JETPACK__VERSION . ':' . time();
1875
		/** This action is documented in class.jetpack.php */
1876
		do_action( 'updating_jetpack_version', $new_version, $jetpack_old_version );
1877
		Jetpack_Options::update_options(
1878
			array(
1879
				'version'     => $new_version,
1880
				'old_version' => $jetpack_old_version,
1881
			)
1882
		);
1883
1884
		Jetpack::state( 'message', 'modules_activated' );
1885
		Jetpack::activate_default_modules( $jetpack_version, JETPACK__VERSION, $reactivate_modules );
1886
1887
		if ( $redirect ) {
1888
			$page = 'jetpack'; // make sure we redirect to either settings or the jetpack page
1889
			if ( isset( $_GET['page'] ) && in_array( $_GET['page'], array( 'jetpack', 'jetpack_modules' ) ) ) {
1890
				$page = $_GET['page'];
1891
			}
1892
1893
			wp_safe_redirect( Jetpack::admin_url( 'page=' . $page ) );
1894
			exit;
1895
		}
1896
	}
1897
1898
	/**
1899
	 * List available Jetpack modules. Simply lists .php files in /modules/.
1900
	 * Make sure to tuck away module "library" files in a sub-directory.
1901
	 */
1902
	public static function get_available_modules( $min_version = false, $max_version = false ) {
1903
		static $modules = null;
1904
1905
		if ( ! isset( $modules ) ) {
1906
			$available_modules_option = Jetpack_Options::get_option( 'available_modules', array() );
1907
			// Use the cache if we're on the front-end and it's available...
1908
			if ( ! is_admin() && ! empty( $available_modules_option[ JETPACK__VERSION ] ) ) {
1909
				$modules = $available_modules_option[ JETPACK__VERSION ];
1910
			} else {
1911
				$files = Jetpack::glob_php( JETPACK__PLUGIN_DIR . 'modules' );
1912
1913
				$modules = array();
1914
1915
				foreach ( $files as $file ) {
1916
					if ( ! $headers = Jetpack::get_module( $file ) ) {
1917
						continue;
1918
					}
1919
1920
					$modules[ Jetpack::get_module_slug( $file ) ] = $headers['introduced'];
1921
				}
1922
1923
				Jetpack_Options::update_option( 'available_modules', array(
1924
					JETPACK__VERSION => $modules,
1925
				) );
1926
			}
1927
		}
1928
1929
		/**
1930
		 * Filters the array of modules available to be activated.
1931
		 *
1932
		 * @since 2.4.0
1933
		 *
1934
		 * @param array $modules Array of available modules.
1935
		 * @param string $min_version Minimum version number required to use modules.
1936
		 * @param string $max_version Maximum version number required to use modules.
1937
		 */
1938
		$mods = apply_filters( 'jetpack_get_available_modules', $modules, $min_version, $max_version );
1939
1940
		if ( ! $min_version && ! $max_version ) {
1941
			return array_keys( $mods );
1942
		}
1943
1944
		$r = array();
1945
		foreach ( $mods as $slug => $introduced ) {
1946
			if ( $min_version && version_compare( $min_version, $introduced, '>=' ) ) {
1947
				continue;
1948
			}
1949
1950
			if ( $max_version && version_compare( $max_version, $introduced, '<' ) ) {
1951
				continue;
1952
			}
1953
1954
			$r[] = $slug;
1955
		}
1956
1957
		return $r;
1958
	}
1959
1960
	/**
1961
	 * Default modules loaded on activation.
1962
	 */
1963
	public static function get_default_modules( $min_version = false, $max_version = false ) {
1964
		$return = array();
1965
1966
		foreach ( Jetpack::get_available_modules( $min_version, $max_version ) as $module ) {
1967
			$module_data = Jetpack::get_module( $module );
1968
1969
			switch ( strtolower( $module_data['auto_activate'] ) ) {
1970
				case 'yes' :
1971
					$return[] = $module;
1972
					break;
1973
				case 'public' :
1974
					if ( Jetpack_Options::get_option( 'public' ) ) {
1975
						$return[] = $module;
1976
					}
1977
					break;
1978
				case 'no' :
1979
				default :
1980
					break;
1981
			}
1982
		}
1983
		/**
1984
		 * Filters the array of default modules.
1985
		 *
1986
		 * @since 2.5.0
1987
		 *
1988
		 * @param array $return Array of default modules.
1989
		 * @param string $min_version Minimum version number required to use modules.
1990
		 * @param string $max_version Maximum version number required to use modules.
1991
		 */
1992
		return apply_filters( 'jetpack_get_default_modules', $return, $min_version, $max_version );
1993
	}
1994
1995
	/**
1996
	 * Checks activated modules during auto-activation to determine
1997
	 * if any of those modules are being deprecated.  If so, close
1998
	 * them out, and add any replacement modules.
1999
	 *
2000
	 * Runs at priority 99 by default.
2001
	 *
2002
	 * This is run late, so that it can still activate a module if
2003
	 * the new module is a replacement for another that the user
2004
	 * currently has active, even if something at the normal priority
2005
	 * would kibosh everything.
2006
	 *
2007
	 * @since 2.6
2008
	 * @uses jetpack_get_default_modules filter
2009
	 * @param array $modules
2010
	 * @return array
2011
	 */
2012
	function handle_deprecated_modules( $modules ) {
2013
		$deprecated_modules = array(
2014
			'debug'            => null,  // Closed out and moved to ./class.jetpack-debugger.php
2015
			'wpcc'             => 'sso', // Closed out in 2.6 -- SSO provides the same functionality.
2016
			'gplus-authorship' => null,  // Closed out in 3.2 -- Google dropped support.
2017
		);
2018
2019
		// Don't activate SSO if they never completed activating WPCC.
2020
		if ( Jetpack::is_module_active( 'wpcc' ) ) {
2021
			$wpcc_options = Jetpack_Options::get_option( 'wpcc_options' );
2022
			if ( empty( $wpcc_options ) || empty( $wpcc_options['client_id'] ) || empty( $wpcc_options['client_id'] ) ) {
2023
				$deprecated_modules['wpcc'] = null;
2024
			}
2025
		}
2026
2027
		foreach ( $deprecated_modules as $module => $replacement ) {
2028
			if ( Jetpack::is_module_active( $module ) ) {
2029
				self::deactivate_module( $module );
2030
				if ( $replacement ) {
2031
					$modules[] = $replacement;
2032
				}
2033
			}
2034
		}
2035
2036
		return array_unique( $modules );
2037
	}
2038
2039
	/**
2040
	 * Checks activated plugins during auto-activation to determine
2041
	 * if any of those plugins are in the list with a corresponding module
2042
	 * that is not compatible with the plugin. The module will not be allowed
2043
	 * to auto-activate.
2044
	 *
2045
	 * @since 2.6
2046
	 * @uses jetpack_get_default_modules filter
2047
	 * @param array $modules
2048
	 * @return array
2049
	 */
2050
	function filter_default_modules( $modules ) {
2051
2052
		$active_plugins = self::get_active_plugins();
2053
2054
		if ( ! empty( $active_plugins ) ) {
2055
2056
			// For each module we'd like to auto-activate...
2057
			foreach ( $modules as $key => $module ) {
2058
				// If there are potential conflicts for it...
2059
				if ( ! empty( $this->conflicting_plugins[ $module ] ) ) {
2060
					// For each potential conflict...
2061
					foreach ( $this->conflicting_plugins[ $module ] as $title => $plugin ) {
2062
						// If that conflicting plugin is active...
2063
						if ( in_array( $plugin, $active_plugins ) ) {
2064
							// Remove that item from being auto-activated.
2065
							unset( $modules[ $key ] );
2066
						}
2067
					}
2068
				}
2069
			}
2070
		}
2071
2072
		return $modules;
2073
	}
2074
2075
	/**
2076
	 * Extract a module's slug from its full path.
2077
	 */
2078
	public static function get_module_slug( $file ) {
2079
		return str_replace( '.php', '', basename( $file ) );
2080
	}
2081
2082
	/**
2083
	 * Generate a module's path from its slug.
2084
	 */
2085
	public static function get_module_path( $slug ) {
2086
		return JETPACK__PLUGIN_DIR . "modules/$slug.php";
2087
	}
2088
2089
	/**
2090
	 * Load module data from module file. Headers differ from WordPress
2091
	 * plugin headers to avoid them being identified as standalone
2092
	 * plugins on the WordPress plugins page.
2093
	 */
2094
	public static function get_module( $module ) {
2095
		$headers = array(
2096
			'name'                      => 'Module Name',
2097
			'description'               => 'Module Description',
2098
			'jumpstart_desc'            => 'Jumpstart Description',
2099
			'sort'                      => 'Sort Order',
2100
			'recommendation_order'      => 'Recommendation Order',
2101
			'introduced'                => 'First Introduced',
2102
			'changed'                   => 'Major Changes In',
2103
			'deactivate'                => 'Deactivate',
2104
			'free'                      => 'Free',
2105
			'requires_connection'       => 'Requires Connection',
2106
			'auto_activate'             => 'Auto Activate',
2107
			'module_tags'               => 'Module Tags',
2108
			'feature'                   => 'Feature',
2109
			'additional_search_queries' => 'Additional Search Queries',
2110
		);
2111
2112
		$file = Jetpack::get_module_path( Jetpack::get_module_slug( $module ) );
2113
2114
		$mod = Jetpack::get_file_data( $file, $headers );
2115
		if ( empty( $mod['name'] ) ) {
2116
			return false;
2117
		}
2118
2119
		$mod['sort']                    = empty( $mod['sort'] ) ? 10 : (int) $mod['sort'];
2120
		$mod['recommendation_order']    = empty( $mod['recommendation_order'] ) ? 20 : (int) $mod['recommendation_order'];
2121
		$mod['deactivate']              = empty( $mod['deactivate'] );
2122
		$mod['free']                    = empty( $mod['free'] );
2123
		$mod['requires_connection']     = ( ! empty( $mod['requires_connection'] ) && 'No' == $mod['requires_connection'] ) ? false : true;
2124
2125
		if ( empty( $mod['auto_activate'] ) || ! in_array( strtolower( $mod['auto_activate'] ), array( 'yes', 'no', 'public' ) ) ) {
2126
			$mod['auto_activate'] = 'No';
2127
		} else {
2128
			$mod['auto_activate'] = (string) $mod['auto_activate'];
2129
		}
2130
2131
		if ( $mod['module_tags'] ) {
2132
			$mod['module_tags'] = explode( ',', $mod['module_tags'] );
2133
			$mod['module_tags'] = array_map( 'trim', $mod['module_tags'] );
2134
			$mod['module_tags'] = array_map( array( __CLASS__, 'translate_module_tag' ), $mod['module_tags'] );
2135
		} else {
2136
			$mod['module_tags'] = array( self::translate_module_tag( 'Other' ) );
2137
		}
2138
2139
		if ( $mod['feature'] ) {
2140
			$mod['feature'] = explode( ',', $mod['feature'] );
2141
			$mod['feature'] = array_map( 'trim', $mod['feature'] );
2142
		} else {
2143
			$mod['feature'] = array( self::translate_module_tag( 'Other' ) );
2144
		}
2145
2146
		/**
2147
		 * Filters the feature array on a module.
2148
		 *
2149
		 * This filter allows you to control where each module is filtered: Recommended,
2150
		 * Jumpstart, and the default "Other" listing.
2151
		 *
2152
		 * @since 3.5.0
2153
		 *
2154
		 * @param array   $mod['feature'] The areas to feature this module:
2155
		 *     'Jumpstart' adds to the "Jumpstart" option to activate many modules at once.
2156
		 *     'Recommended' shows on the main Jetpack admin screen.
2157
		 *     'Other' should be the default if no other value is in the array.
2158
		 * @param string  $module The slug of the module, e.g. sharedaddy.
2159
		 * @param array   $mod All the currently assembled module data.
2160
		 */
2161
		$mod['feature'] = apply_filters( 'jetpack_module_feature', $mod['feature'], $module, $mod );
2162
2163
		/**
2164
		 * Filter the returned data about a module.
2165
		 *
2166
		 * This filter allows overriding any info about Jetpack modules. It is dangerous,
2167
		 * so please be careful.
2168
		 *
2169
		 * @since 3.6.0
2170
		 *
2171
		 * @param array   $mod    The details of the requested module.
2172
		 * @param string  $module The slug of the module, e.g. sharedaddy
2173
		 * @param string  $file   The path to the module source file.
2174
		 */
2175
		return apply_filters( 'jetpack_get_module', $mod, $module, $file );
2176
	}
2177
2178
	/**
2179
	 * Like core's get_file_data implementation, but caches the result.
2180
	 */
2181
	public static function get_file_data( $file, $headers ) {
2182
		//Get just the filename from $file (i.e. exclude full path) so that a consistent hash is generated
2183
		$file_name = basename( $file );
2184
		$file_data = Jetpack_Options::get_option( 'file_data', array() );
2185
2186
		if ( ! array_key_exists( $file_name, $file_data ) ) {
2187
			$file_data[ $file_name ] = get_file_data( $file, $headers );
2188
			Jetpack_Options::update_option( 'file_data', $file_data );
2189
		}
2190
2191
		return $file_data[ $file_name ];
2192
	}
2193
2194
	/**
2195
	 * Return translated module tag.
2196
	 *
2197
	 * @param string $tag Tag as it appears in each module heading.
2198
	 *
2199
	 * @return mixed
2200
	 */
2201
	public static function translate_module_tag( $tag ) {
2202
		return jetpack_get_module_i18n_tag( $tag );
2203
	}
2204
2205
	/**
2206
	 * Return module name translation. Uses matching string created in modules/module-headings.php.
2207
	 *
2208
	 * @since 3.9.2
2209
	 *
2210
	 * @param array $modules
2211
	 *
2212
	 * @return string|void
2213
	 */
2214
	public static function get_translated_modules( $modules ) {
2215
		foreach ( $modules as $index => $module ) {
2216
			$i18n_module = jetpack_get_module_i18n( $module['module'] );
2217
			if ( isset( $module['name'] ) ) {
2218
				$modules[ $index ]['name'] = $i18n_module['name'];
2219
			}
2220
			if ( isset( $module['description'] ) ) {
2221
				$modules[ $index ]['description'] = $i18n_module['description'];
2222
				$modules[ $index ]['short_description'] = $i18n_module['description'];
2223
			}
2224
		}
2225
		if ( Jetpack::is_module_active( 'manage' ) ) {
2226
			unset( $modules['manage'] );
2227
		}
2228
		return $modules;
2229
	}
2230
2231
	/**
2232
	 * Get a list of activated modules as an array of module slugs.
2233
	 */
2234
	public static function get_active_modules() {
2235
		$active = Jetpack_Options::get_option( 'active_modules' );
2236
		if ( ! is_array( $active ) )
2237
			$active = array();
2238
		if ( is_admin() && ( class_exists( 'VaultPress' ) || function_exists( 'vaultpress_contact_service' ) ) ) {
2239
			$active[] = 'vaultpress';
2240
		} else {
2241
			$active = array_diff( $active, array( 'vaultpress' ) );
2242
		}
2243
2244
		//If protect is active on the main site of a multisite, it should be active on all sites.
2245
		if ( ! in_array( 'protect', $active ) && is_multisite() && get_site_option( 'jetpack_protect_active' ) ) {
2246
			$active[] = 'protect';
2247
		}
2248
2249
		return array_unique( $active );
2250
	}
2251
2252
	/**
2253
	 * Check whether or not a Jetpack module is active.
2254
	 *
2255
	 * @param string $module The slug of a Jetpack module.
2256
	 * @return bool
2257
	 *
2258
	 * @static
2259
	 */
2260
	public static function is_module_active( $module ) {
2261
		return in_array( $module, self::get_active_modules() );
2262
	}
2263
2264
	public static function is_module( $module ) {
2265
		return ! empty( $module ) && ! validate_file( $module, Jetpack::get_available_modules() );
2266
	}
2267
2268
	/**
2269
	 * Catches PHP errors.  Must be used in conjunction with output buffering.
2270
	 *
2271
	 * @param bool $catch True to start catching, False to stop.
2272
	 *
2273
	 * @static
2274
	 */
2275
	public static function catch_errors( $catch ) {
2276
		static $display_errors, $error_reporting;
2277
2278
		if ( $catch ) {
2279
			$display_errors  = @ini_set( 'display_errors', 1 );
2280
			$error_reporting = @error_reporting( E_ALL );
2281
			add_action( 'shutdown', array( 'Jetpack', 'catch_errors_on_shutdown' ), 0 );
2282
		} else {
2283
			@ini_set( 'display_errors', $display_errors );
2284
			@error_reporting( $error_reporting );
2285
			remove_action( 'shutdown', array( 'Jetpack', 'catch_errors_on_shutdown' ), 0 );
2286
		}
2287
	}
2288
2289
	/**
2290
	 * Saves any generated PHP errors in ::state( 'php_errors', {errors} )
2291
	 */
2292
	public static function catch_errors_on_shutdown() {
2293
		Jetpack::state( 'php_errors', ob_get_clean() );
2294
	}
2295
2296
	public static function activate_default_modules( $min_version = false, $max_version = false, $other_modules = array(), $redirect = true ) {
2297
		$jetpack = Jetpack::init();
2298
2299
		$modules = Jetpack::get_default_modules( $min_version, $max_version );
2300
		$modules = array_merge( $other_modules, $modules );
2301
2302
		// Look for standalone plugins and disable if active.
2303
2304
		$to_deactivate = array();
2305
		foreach ( $modules as $module ) {
2306
			if ( isset( $jetpack->plugins_to_deactivate[$module] ) ) {
2307
				$to_deactivate[$module] = $jetpack->plugins_to_deactivate[$module];
2308
			}
2309
		}
2310
2311
		$deactivated = array();
2312
		foreach ( $to_deactivate as $module => $deactivate_me ) {
2313
			list( $probable_file, $probable_title ) = $deactivate_me;
2314
			if ( Jetpack_Client_Server::deactivate_plugin( $probable_file, $probable_title ) ) {
2315
				$deactivated[] = $module;
2316
			}
2317
		}
2318
2319
		if ( $deactivated && $redirect ) {
2320
			Jetpack::state( 'deactivated_plugins', join( ',', $deactivated ) );
2321
2322
			$url = add_query_arg(
2323
				array(
2324
					'action'   => 'activate_default_modules',
2325
					'_wpnonce' => wp_create_nonce( 'activate_default_modules' ),
2326
				),
2327
				add_query_arg( compact( 'min_version', 'max_version', 'other_modules' ), Jetpack::admin_url( 'page=jetpack' ) )
2328
			);
2329
			wp_safe_redirect( $url );
2330
			exit;
2331
		}
2332
2333
		/**
2334
		 * Fires before default modules are activated.
2335
		 *
2336
		 * @since 1.9.0
2337
		 *
2338
		 * @param string $min_version Minimum version number required to use modules.
2339
		 * @param string $max_version Maximum version number required to use modules.
2340
		 * @param array $other_modules Array of other modules to activate alongside the default modules.
2341
		 */
2342
		do_action( 'jetpack_before_activate_default_modules', $min_version, $max_version, $other_modules );
2343
2344
		// Check each module for fatal errors, a la wp-admin/plugins.php::activate before activating
2345
		Jetpack::restate();
2346
		Jetpack::catch_errors( true );
2347
2348
		$active = Jetpack::get_active_modules();
2349
2350
		foreach ( $modules as $module ) {
2351
			if ( did_action( "jetpack_module_loaded_$module" ) ) {
2352
				$active[] = $module;
2353
				self::update_active_modules( $active );
2354
				continue;
2355
			}
2356
2357
			if ( in_array( $module, $active ) ) {
2358
				$module_info = Jetpack::get_module( $module );
2359
				if ( ! $module_info['deactivate'] ) {
2360
					$state = in_array( $module, $other_modules ) ? 'reactivated_modules' : 'activated_modules';
2361 View Code Duplication
					if ( $active_state = Jetpack::state( $state ) ) {
2362
						$active_state = explode( ',', $active_state );
2363
					} else {
2364
						$active_state = array();
2365
					}
2366
					$active_state[] = $module;
2367
					Jetpack::state( $state, implode( ',', $active_state ) );
2368
				}
2369
				continue;
2370
			}
2371
2372
			$file = Jetpack::get_module_path( $module );
2373
			if ( ! file_exists( $file ) ) {
2374
				continue;
2375
			}
2376
2377
			// we'll override this later if the plugin can be included without fatal error
2378
			if ( $redirect ) {
2379
				wp_safe_redirect( Jetpack::admin_url( 'page=jetpack' ) );
2380
			}
2381
			Jetpack::state( 'error', 'module_activation_failed' );
2382
			Jetpack::state( 'module', $module );
2383
			ob_start();
2384
			require $file;
2385
2386
			$active[] = $module;
2387
			$state    = in_array( $module, $other_modules ) ? 'reactivated_modules' : 'activated_modules';
2388 View Code Duplication
			if ( $active_state = Jetpack::state( $state ) ) {
2389
				$active_state = explode( ',', $active_state );
2390
			} else {
2391
				$active_state = array();
2392
			}
2393
			$active_state[] = $module;
2394
			Jetpack::state( $state, implode( ',', $active_state ) );
2395
			Jetpack::update_active_modules( $active );
2396
2397
			ob_end_clean();
2398
		}
2399
		Jetpack::state( 'error', false );
2400
		Jetpack::state( 'module', false );
2401
		Jetpack::catch_errors( false );
2402
		/**
2403
		 * Fires when default modules are activated.
2404
		 *
2405
		 * @since 1.9.0
2406
		 *
2407
		 * @param string $min_version Minimum version number required to use modules.
2408
		 * @param string $max_version Maximum version number required to use modules.
2409
		 * @param array $other_modules Array of other modules to activate alongside the default modules.
2410
		 */
2411
		do_action( 'jetpack_activate_default_modules', $min_version, $max_version, $other_modules );
2412
	}
2413
2414
	public static function activate_module( $module, $exit = true, $redirect = true ) {
2415
		/**
2416
		 * Fires before a module is activated.
2417
		 *
2418
		 * @since 2.6.0
2419
		 *
2420
		 * @param string $module Module slug.
2421
		 * @param bool $exit Should we exit after the module has been activated. Default to true.
2422
		 * @param bool $redirect Should the user be redirected after module activation? Default to true.
2423
		 */
2424
		do_action( 'jetpack_pre_activate_module', $module, $exit, $redirect );
2425
2426
		$jetpack = Jetpack::init();
2427
2428
		if ( ! strlen( $module ) )
2429
			return false;
2430
2431
		if ( ! Jetpack::is_module( $module ) )
2432
			return false;
2433
2434
		// If it's already active, then don't do it again
2435
		$active = Jetpack::get_active_modules();
2436
		foreach ( $active as $act ) {
2437
			if ( $act == $module )
2438
				return true;
2439
		}
2440
2441
		$module_data = Jetpack::get_module( $module );
2442
2443
		if ( ! Jetpack::is_active() ) {
2444
			if ( !Jetpack::is_development_mode() )
2445
				return false;
2446
2447
			// If we're not connected but in development mode, make sure the module doesn't require a connection
2448
			if ( Jetpack::is_development_mode() && $module_data['requires_connection'] )
2449
				return false;
2450
		}
2451
2452
		// Check and see if the old plugin is active
2453
		if ( isset( $jetpack->plugins_to_deactivate[ $module ] ) ) {
2454
			// Deactivate the old plugin
2455
			if ( Jetpack_Client_Server::deactivate_plugin( $jetpack->plugins_to_deactivate[ $module ][0], $jetpack->plugins_to_deactivate[ $module ][1] ) ) {
2456
				// If we deactivated the old plugin, remembere that with ::state() and redirect back to this page to activate the module
2457
				// We can't activate the module on this page load since the newly deactivated old plugin is still loaded on this page load.
2458
				Jetpack::state( 'deactivated_plugins', $module );
2459
				wp_safe_redirect( add_query_arg( 'jetpack_restate', 1 ) );
2460
				exit;
0 ignored issues
show
Coding Style Compatibility introduced by
The method activate_module() contains an exit expression.

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

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

Loading history...
2461
			}
2462
		}
2463
2464
		// Check the file for fatal errors, a la wp-admin/plugins.php::activate
2465
		Jetpack::state( 'module', $module );
2466
		Jetpack::state( 'error', 'module_activation_failed' ); // we'll override this later if the plugin can be included without fatal error
2467
2468
		Jetpack::catch_errors( true );
2469
		ob_start();
2470
		require Jetpack::get_module_path( $module );
2471
2472
		$active[] = $module;
2473
		Jetpack::update_active_modules( $active );
2474
2475
		Jetpack::state( 'error', false ); // the override
2476
		Jetpack::state( 'message', 'module_activated' );
2477
		Jetpack::state( 'module', $module );
2478
		ob_end_clean();
2479
		Jetpack::catch_errors( false );
2480
2481
		// A flag for Jump Start so it's not shown again. Only set if it hasn't been yet.
2482 View Code Duplication
		if ( 'new_connection' === Jetpack_Options::get_option( 'jumpstart' ) ) {
2483
			Jetpack_Options::update_option( 'jumpstart', 'jetpack_action_taken' );
2484
2485
			//Jump start is being dismissed send data to MC Stats
2486
			$jetpack->stat( 'jumpstart', 'manual,'.$module );
2487
2488
			$jetpack->do_stats( 'server_side' );
2489
		}
2490
2491
		if ( $redirect ) {
2492
			wp_safe_redirect( Jetpack::admin_url( 'page=jetpack' ) );
2493
		}
2494
		if ( $exit ) {
2495
			exit;
2496
		}
2497
		return true;
2498
	}
2499
2500
	function activate_module_actions( $module ) {
2501
		_deprecated_function( __METHOD__, 'jeptack-4.2' );
2502
	}
2503
2504
	public static function deactivate_module( $module ) {
2505
		/**
2506
		 * Fires when a module is deactivated.
2507
		 *
2508
		 * @since 1.9.0
2509
		 *
2510
		 * @param string $module Module slug.
2511
		 */
2512
		do_action( 'jetpack_pre_deactivate_module', $module );
2513
2514
		$jetpack = Jetpack::init();
2515
2516
		$active = Jetpack::get_active_modules();
2517
		$new    = array_filter( array_diff( $active, (array) $module ) );
2518
2519
		// A flag for Jump Start so it's not shown again.
2520 View Code Duplication
		if ( 'new_connection' === Jetpack_Options::get_option( 'jumpstart' ) ) {
2521
			Jetpack_Options::update_option( 'jumpstart', 'jetpack_action_taken' );
2522
2523
			//Jump start is being dismissed send data to MC Stats
2524
			$jetpack->stat( 'jumpstart', 'manual,deactivated-'.$module );
2525
2526
			$jetpack->do_stats( 'server_side' );
2527
		}
2528
2529
		return self::update_active_modules( $new );
2530
	}
2531
2532
	public static function enable_module_configurable( $module ) {
2533
		$module = Jetpack::get_module_slug( $module );
2534
		add_filter( 'jetpack_module_configurable_' . $module, '__return_true' );
2535
	}
2536
2537
	public static function module_configuration_url( $module ) {
2538
		$module = Jetpack::get_module_slug( $module );
2539
		return Jetpack::admin_url( array( 'page' => 'jetpack', 'configure' => $module ) );
2540
	}
2541
2542
	public static function module_configuration_load( $module, $method ) {
2543
		$module = Jetpack::get_module_slug( $module );
2544
		add_action( 'jetpack_module_configuration_load_' . $module, $method );
2545
	}
2546
2547
	public static function module_configuration_head( $module, $method ) {
2548
		$module = Jetpack::get_module_slug( $module );
2549
		add_action( 'jetpack_module_configuration_head_' . $module, $method );
2550
	}
2551
2552
	public static function module_configuration_screen( $module, $method ) {
2553
		$module = Jetpack::get_module_slug( $module );
2554
		add_action( 'jetpack_module_configuration_screen_' . $module, $method );
2555
	}
2556
2557
	public static function module_configuration_activation_screen( $module, $method ) {
2558
		$module = Jetpack::get_module_slug( $module );
2559
		add_action( 'display_activate_module_setting_' . $module, $method );
2560
	}
2561
2562
/* Installation */
2563
2564
	public static function bail_on_activation( $message, $deactivate = true ) {
2565
?>
2566
<!doctype html>
2567
<html>
2568
<head>
2569
<meta charset="<?php bloginfo( 'charset' ); ?>">
2570
<style>
2571
* {
2572
	text-align: center;
2573
	margin: 0;
2574
	padding: 0;
2575
	font-family: "Lucida Grande",Verdana,Arial,"Bitstream Vera Sans",sans-serif;
2576
}
2577
p {
2578
	margin-top: 1em;
2579
	font-size: 18px;
2580
}
2581
</style>
2582
<body>
2583
<p><?php echo esc_html( $message ); ?></p>
2584
</body>
2585
</html>
2586
<?php
2587
		if ( $deactivate ) {
2588
			$plugins = get_option( 'active_plugins' );
2589
			$jetpack = plugin_basename( JETPACK__PLUGIN_DIR . 'jetpack.php' );
2590
			$update  = false;
2591
			foreach ( $plugins as $i => $plugin ) {
2592
				if ( $plugin === $jetpack ) {
2593
					$plugins[$i] = false;
2594
					$update = true;
2595
				}
2596
			}
2597
2598
			if ( $update ) {
2599
				update_option( 'active_plugins', array_filter( $plugins ) );
2600
			}
2601
		}
2602
		exit;
2603
	}
2604
2605
	/**
2606
	 * Attached to activate_{ plugin_basename( __FILES__ ) } by register_activation_hook()
2607
	 * @static
2608
	 */
2609
	public static function plugin_activation( $network_wide ) {
2610
		Jetpack_Options::update_option( 'activated', 1 );
2611
2612
		if ( version_compare( $GLOBALS['wp_version'], JETPACK__MINIMUM_WP_VERSION, '<' ) ) {
2613
			Jetpack::bail_on_activation( sprintf( __( 'Jetpack requires WordPress version %s or later.', 'jetpack' ), JETPACK__MINIMUM_WP_VERSION ) );
2614
		}
2615
2616
		if ( $network_wide )
2617
			Jetpack::state( 'network_nag', true );
2618
2619
		Jetpack::plugin_initialize();
2620
	}
2621
	/**
2622
	 * Runs before bumping version numbers up to a new version
2623
	 * @param  (string) $version    Version:timestamp
2624
	 * @param  (string) $old_version Old Version:timestamp or false if not set yet.
2625
	 * @return null              [description]
2626
	 */
2627
	public static function do_version_bump( $version, $old_version ) {
2628
2629
		if ( ! $old_version ) { // For new sites
2630
			// Setting up jetpack manage
2631
			Jetpack::activate_manage();
2632
		}
2633
	}
2634
2635
	/**
2636
	 * Sets the internal version number and activation state.
2637
	 * @static
2638
	 */
2639
	public static function plugin_initialize() {
2640
		if ( ! Jetpack_Options::get_option( 'activated' ) ) {
2641
			Jetpack_Options::update_option( 'activated', 2 );
2642
		}
2643
2644 View Code Duplication
		if ( ! Jetpack_Options::get_option( 'version' ) ) {
2645
			$version = $old_version = JETPACK__VERSION . ':' . time();
2646
			/** This action is documented in class.jetpack.php */
2647
			do_action( 'updating_jetpack_version', $version, false );
2648
			Jetpack_Options::update_options( compact( 'version', 'old_version' ) );
2649
		}
2650
2651
		Jetpack::load_modules();
2652
2653
		Jetpack_Options::delete_option( 'do_activate' );
2654
	}
2655
2656
	/**
2657
	 * Removes all connection options
2658
	 * @static
2659
	 */
2660
	public static function plugin_deactivation( ) {
2661
		require_once( ABSPATH . '/wp-admin/includes/plugin.php' );
2662
		if( is_plugin_active_for_network( 'jetpack/jetpack.php' ) ) {
2663
			Jetpack_Network::init()->deactivate();
2664
		} else {
2665
			Jetpack::disconnect( false );
2666
			//Jetpack_Heartbeat::init()->deactivate();
2667
		}
2668
	}
2669
2670
	/**
2671
	 * Disconnects from the Jetpack servers.
2672
	 * Forgets all connection details and tells the Jetpack servers to do the same.
2673
	 * @static
2674
	 */
2675
	public static function disconnect( $update_activated_state = true ) {
2676
		wp_clear_scheduled_hook( 'jetpack_clean_nonces' );
2677
		Jetpack::clean_nonces( true );
2678
2679
		Jetpack::load_xml_rpc_client();
2680
		$xml = new Jetpack_IXR_Client();
2681
		$xml->query( 'jetpack.deregister' );
2682
2683
		Jetpack_Options::delete_option(
2684
			array(
2685
				'register',
2686
				'blog_token',
2687
				'user_token',
2688
				'user_tokens',
2689
				'master_user',
2690
				'time_diff',
2691
				'fallback_no_verify_ssl_certs',
2692
			)
2693
		);
2694
2695
		if ( $update_activated_state ) {
2696
			Jetpack_Options::update_option( 'activated', 4 );
2697
		}
2698
2699
		$jetpack_unique_connection = Jetpack_Options::get_option( 'unique_connection' );
2700
		// Check then record unique disconnection if site has never been disconnected previously
2701
		if ( -1 == $jetpack_unique_connection['disconnected'] ) {
2702
			$jetpack_unique_connection['disconnected'] = 1;
2703
		}
2704
		else {
2705
			if ( 0 == $jetpack_unique_connection['disconnected'] ) {
2706
				//track unique disconnect
2707
				$jetpack = Jetpack::init();
2708
2709
				$jetpack->stat( 'connections', 'unique-disconnect' );
2710
				$jetpack->do_stats( 'server_side' );
2711
			}
2712
			// increment number of times disconnected
2713
			$jetpack_unique_connection['disconnected'] += 1;
2714
		}
2715
2716
		Jetpack_Options::update_option( 'unique_connection', $jetpack_unique_connection );
2717
2718
		// Delete all the sync related data. Since it could be taking up space.
2719
		require_once JETPACK__PLUGIN_DIR . 'sync/class.jetpack-sync-sender.php';
2720
		Jetpack_Sync_Sender::get_instance()->uninstall();
2721
2722
		// Disable the Heartbeat cron
2723
		Jetpack_Heartbeat::init()->deactivate();
2724
	}
2725
2726
	/**
2727
	 * Unlinks the current user from the linked WordPress.com user
2728
	 */
2729
	public static function unlink_user( $user_id = null ) {
2730
		if ( ! $tokens = Jetpack_Options::get_option( 'user_tokens' ) )
2731
			return false;
2732
2733
		$user_id = empty( $user_id ) ? get_current_user_id() : intval( $user_id );
2734
2735
		if ( Jetpack_Options::get_option( 'master_user' ) == $user_id )
2736
			return false;
2737
2738
		if ( ! isset( $tokens[ $user_id ] ) )
2739
			return false;
2740
2741
		Jetpack::load_xml_rpc_client();
2742
		$xml = new Jetpack_IXR_Client( compact( 'user_id' ) );
2743
		$xml->query( 'jetpack.unlink_user', $user_id );
2744
2745
		unset( $tokens[ $user_id ] );
2746
2747
		Jetpack_Options::update_option( 'user_tokens', $tokens );
2748
2749
		/**
2750
		 * Fires after the current user has been unlinked from WordPress.com.
2751
		 *
2752
		 * @since 4.1.0
2753
		 *
2754
		 * @param int $user_id The current user's ID.
2755
		 */
2756
		do_action( 'jetpack_unlinked_user', $user_id );
2757
2758
		return true;
2759
	}
2760
2761
	/**
2762
	 * Attempts Jetpack registration.  If it fail, a state flag is set: @see ::admin_page_load()
2763
	 */
2764
	public static function try_registration() {
2765
		// Let's get some testing in beta versions and such.
2766
		if ( self::is_development_version() && defined( 'PHP_URL_HOST' ) ) {
2767
			// Before attempting to connect, let's make sure that the domains are viable.
2768
			$domains_to_check = array_unique( array(
2769
				'siteurl' => parse_url( get_site_url(), PHP_URL_HOST ),
2770
				'homeurl' => parse_url( get_home_url(), PHP_URL_HOST ),
2771
			) );
2772
			foreach ( $domains_to_check as $domain ) {
2773
				$result = Jetpack_Data::is_usable_domain( $domain );
2774
				if ( is_wp_error( $result ) ) {
2775
					return $result;
2776
				}
2777
			}
2778
		}
2779
2780
		$result = Jetpack::register();
2781
2782
		// If there was an error with registration and the site was not registered, record this so we can show a message.
2783
		if ( ! $result || is_wp_error( $result ) ) {
2784
			return $result;
2785
		} else {
2786
			return true;
2787
		}
2788
	}
2789
2790
	/**
2791
	 * Tracking an internal event log. Try not to put too much chaff in here.
2792
	 *
2793
	 * [Everyone Loves a Log!](https://www.youtube.com/watch?v=2C7mNr5WMjA)
2794
	 */
2795
	public static function log( $code, $data = null ) {
2796
		// only grab the latest 200 entries
2797
		$log = array_slice( Jetpack_Options::get_option( 'log', array() ), -199, 199 );
2798
2799
		// Append our event to the log
2800
		$log_entry = array(
2801
			'time'    => time(),
2802
			'user_id' => get_current_user_id(),
2803
			'blog_id' => Jetpack_Options::get_option( 'id' ),
2804
			'code'    => $code,
2805
		);
2806
		// Don't bother storing it unless we've got some.
2807
		if ( ! is_null( $data ) ) {
2808
			$log_entry['data'] = $data;
2809
		}
2810
		$log[] = $log_entry;
2811
2812
		// Try add_option first, to make sure it's not autoloaded.
2813
		// @todo: Add an add_option method to Jetpack_Options
2814
		if ( ! add_option( 'jetpack_log', $log, null, 'no' ) ) {
2815
			Jetpack_Options::update_option( 'log', $log );
2816
		}
2817
2818
		/**
2819
		 * Fires when Jetpack logs an internal event.
2820
		 *
2821
		 * @since 3.0.0
2822
		 *
2823
		 * @param array $log_entry {
2824
		 *	Array of details about the log entry.
2825
		 *
2826
		 *	@param string time Time of the event.
2827
		 *	@param int user_id ID of the user who trigerred the event.
2828
		 *	@param int blog_id Jetpack Blog ID.
2829
		 *	@param string code Unique name for the event.
2830
		 *	@param string data Data about the event.
2831
		 * }
2832
		 */
2833
		do_action( 'jetpack_log_entry', $log_entry );
2834
	}
2835
2836
	/**
2837
	 * Get the internal event log.
2838
	 *
2839
	 * @param $event (string) - only return the specific log events
2840
	 * @param $num   (int)    - get specific number of latest results, limited to 200
2841
	 *
2842
	 * @return array of log events || WP_Error for invalid params
2843
	 */
2844
	public static function get_log( $event = false, $num = false ) {
2845
		if ( $event && ! is_string( $event ) ) {
2846
			return new WP_Error( __( 'First param must be string or empty', 'jetpack' ) );
2847
		}
2848
2849
		if ( $num && ! is_numeric( $num ) ) {
2850
			return new WP_Error( __( 'Second param must be numeric or empty', 'jetpack' ) );
2851
		}
2852
2853
		$entire_log = Jetpack_Options::get_option( 'log', array() );
2854
2855
		// If nothing set - act as it did before, otherwise let's start customizing the output
2856
		if ( ! $num && ! $event ) {
2857
			return $entire_log;
2858
		} else {
2859
			$entire_log = array_reverse( $entire_log );
2860
		}
2861
2862
		$custom_log_output = array();
2863
2864
		if ( $event ) {
2865
			foreach ( $entire_log as $log_event ) {
2866
				if ( $event == $log_event[ 'code' ] ) {
2867
					$custom_log_output[] = $log_event;
2868
				}
2869
			}
2870
		} else {
2871
			$custom_log_output = $entire_log;
2872
		}
2873
2874
		if ( $num ) {
2875
			$custom_log_output = array_slice( $custom_log_output, 0, $num );
2876
		}
2877
2878
		return $custom_log_output;
2879
	}
2880
2881
	/**
2882
	 * Log modification of important settings.
2883
	 */
2884
	public static function log_settings_change( $option, $old_value, $value ) {
2885
		switch( $option ) {
2886
			case 'jetpack_sync_non_public_post_stati':
2887
				self::log( $option, $value );
2888
				break;
2889
		}
2890
	}
2891
2892
	/**
2893
	 * Return stat data for WPCOM sync
2894
	 */
2895
	public static function get_stat_data( $encode = true ) {
2896
		$heartbeat_data = Jetpack_Heartbeat::generate_stats_array();
2897
		$additional_data = self::get_additional_stat_data();
2898
2899
		$merged_data = array_merge( $heartbeat_data, $additional_data );
2900
2901
		if ( $encode ) {
2902
			return json_encode( $merged_data );
2903
		}
2904
		
2905
		return $merged_data;
2906
	}
2907
2908
	/**
2909
	 * Get additional stat data to sync to WPCOM
2910
	 */
2911
	public static function get_additional_stat_data( $prefix = '' ) {
2912
		$return["{$prefix}themes"]         = Jetpack::get_parsed_theme_data();
2913
		$return["{$prefix}plugins-extra"]  = Jetpack::get_parsed_plugin_data();
2914
		$return["{$prefix}users"]          = count_users();
2915
		$return["{$prefix}site-count"]     = 0;
2916
		if ( function_exists( 'get_blog_count' ) ) {
2917
			$return["{$prefix}site-count"] = get_blog_count();
2918
		}
2919
		return $return;
2920
	}
2921
2922
	/* Admin Pages */
2923
2924
	function admin_init() {
2925
		// If the plugin is not connected, display a connect message.
2926
		if (
2927
			// the plugin was auto-activated and needs its candy
2928
			Jetpack_Options::get_option_and_ensure_autoload( 'do_activate', '0' )
2929
		||
2930
			// the plugin is active, but was never activated.  Probably came from a site-wide network activation
2931
			! Jetpack_Options::get_option( 'activated' )
2932
		) {
2933
			Jetpack::plugin_initialize();
2934
		}
2935
2936
		if ( ! Jetpack::is_active() && ! Jetpack::is_development_mode() ) {
2937
			if ( 4 != Jetpack_Options::get_option( 'activated' ) ) {
2938
				// Show connect notice on dashboard and plugins pages
2939
				add_action( 'load-index.php', array( $this, 'prepare_connect_notice' ) );
2940
				add_action( 'load-plugins.php', array( $this, 'prepare_connect_notice' ) );
2941
			}
2942
		} elseif ( false === Jetpack_Options::get_option( 'fallback_no_verify_ssl_certs' ) ) {
2943
			// Upgrade: 1.1 -> 1.1.1
2944
			// Check and see if host can verify the Jetpack servers' SSL certificate
2945
			$args = array();
2946
			Jetpack_Client::_wp_remote_request(
2947
				Jetpack::fix_url_for_bad_hosts( Jetpack::api_url( 'test' ) ),
2948
				$args,
2949
				true
2950
			);
2951
		} else {
2952
			// Show the notice on the Dashboard only for now
2953
2954
			add_action( 'load-index.php', array( $this, 'prepare_manage_jetpack_notice' ) );
2955
		}
2956
2957
		// If the plugin has just been disconnected from WP.com, show the survey notice
2958
		if ( isset( $_GET['disconnected'] ) && 'true' === $_GET['disconnected'] ) {
2959
			add_action( 'jetpack_notices', array( $this, 'disconnect_survey_notice' ) );
2960
		}
2961
2962
		if ( current_user_can( 'manage_options' ) && 'AUTO' == JETPACK_CLIENT__HTTPS && ! self::permit_ssl() ) {
2963
			add_action( 'jetpack_notices', array( $this, 'alert_auto_ssl_fail' ) );
2964
		}
2965
2966
		add_action( 'load-plugins.php', array( $this, 'intercept_plugin_error_scrape_init' ) );
2967
		add_action( 'admin_enqueue_scripts', array( $this, 'admin_menu_css' ) );
2968
		add_filter( 'plugin_action_links_' . plugin_basename( JETPACK__PLUGIN_DIR . 'jetpack.php' ), array( $this, 'plugin_action_links' ) );
2969
2970
		if ( Jetpack::is_active() || Jetpack::is_development_mode() ) {
2971
			// Artificially throw errors in certain whitelisted cases during plugin activation
2972
			add_action( 'activate_plugin', array( $this, 'throw_error_on_activate_plugin' ) );
2973
		}
2974
2975
		// Jetpack Manage Activation Screen from .com
2976
		Jetpack::module_configuration_activation_screen( 'manage', array( $this, 'manage_activate_screen' ) );
2977
2978
		// Add custom column in wp-admin/users.php to show whether user is linked.
2979
		add_filter( 'manage_users_columns',       array( $this, 'jetpack_icon_user_connected' ) );
2980
		add_action( 'manage_users_custom_column', array( $this, 'jetpack_show_user_connected_icon' ), 10, 3 );
2981
		add_action( 'admin_print_styles',         array( $this, 'jetpack_user_col_style' ) );
2982
	}
2983
2984
	function admin_body_class( $admin_body_class = '' ) {
2985
		$classes = explode( ' ', trim( $admin_body_class ) );
2986
2987
		$classes[] = self::is_active() ? 'jetpack-connected' : 'jetpack-disconnected';
2988
2989
		$admin_body_class = implode( ' ', array_unique( $classes ) );
2990
		return " $admin_body_class ";
2991
	}
2992
2993
	static function add_jetpack_pagestyles( $admin_body_class = '' ) {
2994
		return $admin_body_class . ' jetpack-pagestyles ';
2995
	}
2996
2997
	function prepare_connect_notice() {
2998
		add_action( 'admin_print_styles', array( $this, 'admin_banner_styles' ) );
2999
3000
		add_action( 'admin_notices', array( $this, 'admin_connect_notice' ) );
3001
3002
		if ( Jetpack::state( 'network_nag' ) )
3003
			add_action( 'network_admin_notices', array( $this, 'network_connect_notice' ) );
3004
	}
3005
	/**
3006
	 * Call this function if you want the Big Jetpack Manage Notice to show up.
3007
	 *
3008
	 * @return null
3009
	 */
3010
	function prepare_manage_jetpack_notice() {
3011
3012
		add_action( 'admin_print_styles', array( $this, 'admin_banner_styles' ) );
3013
		add_action( 'admin_notices', array( $this, 'admin_jetpack_manage_notice' ) );
3014
	}
3015
3016
	function manage_activate_screen() {
3017
		include ( JETPACK__PLUGIN_DIR . 'modules/manage/activate-admin.php' );
3018
	}
3019
	/**
3020
	 * Sometimes a plugin can activate without causing errors, but it will cause errors on the next page load.
3021
	 * This function artificially throws errors for such cases (whitelisted).
3022
	 *
3023
	 * @param string $plugin The activated plugin.
3024
	 */
3025
	function throw_error_on_activate_plugin( $plugin ) {
3026
		$active_modules = Jetpack::get_active_modules();
3027
3028
		// The Shortlinks module and the Stats plugin conflict, but won't cause errors on activation because of some function_exists() checks.
3029
		if ( function_exists( 'stats_get_api_key' ) && in_array( 'shortlinks', $active_modules ) ) {
3030
			$throw = false;
3031
3032
			// Try and make sure it really was the stats plugin
3033
			if ( ! class_exists( 'ReflectionFunction' ) ) {
3034
				if ( 'stats.php' == basename( $plugin ) ) {
3035
					$throw = true;
3036
				}
3037
			} else {
3038
				$reflection = new ReflectionFunction( 'stats_get_api_key' );
3039
				if ( basename( $plugin ) == basename( $reflection->getFileName() ) ) {
3040
					$throw = true;
3041
				}
3042
			}
3043
3044
			if ( $throw ) {
3045
				trigger_error( sprintf( __( 'Jetpack contains the most recent version of the old &#8220;%1$s&#8221; plugin.', 'jetpack' ), 'WordPress.com Stats' ), E_USER_ERROR );
3046
			}
3047
		}
3048
	}
3049
3050
	function intercept_plugin_error_scrape_init() {
3051
		add_action( 'check_admin_referer', array( $this, 'intercept_plugin_error_scrape' ), 10, 2 );
3052
	}
3053
3054
	function intercept_plugin_error_scrape( $action, $result ) {
3055
		if ( ! $result ) {
3056
			return;
3057
		}
3058
3059
		foreach ( $this->plugins_to_deactivate as $deactivate_me ) {
3060
			if ( "plugin-activation-error_{$deactivate_me[0]}" == $action ) {
3061
				Jetpack::bail_on_activation( sprintf( __( 'Jetpack contains the most recent version of the old &#8220;%1$s&#8221; plugin.', 'jetpack' ), $deactivate_me[1] ), false );
3062
			}
3063
		}
3064
	}
3065
3066
	function add_remote_request_handlers() {
3067
		add_action( 'wp_ajax_nopriv_jetpack_upload_file', array( $this, 'remote_request_handlers' ) );
3068
	}
3069
3070
	function remote_request_handlers() {
3071
		switch ( current_filter() ) {
3072
		case 'wp_ajax_nopriv_jetpack_upload_file' :
3073
			$response = $this->upload_handler();
3074
			break;
3075
		default :
3076
			$response = new Jetpack_Error( 'unknown_handler', 'Unknown Handler', 400 );
3077
			break;
3078
		}
3079
3080
		if ( ! $response ) {
3081
			$response = new Jetpack_Error( 'unknown_error', 'Unknown Error', 400 );
3082
		}
3083
3084
		if ( is_wp_error( $response ) ) {
3085
			$status_code       = $response->get_error_data();
3086
			$error             = $response->get_error_code();
3087
			$error_description = $response->get_error_message();
3088
3089
			if ( ! is_int( $status_code ) ) {
3090
				$status_code = 400;
3091
			}
3092
3093
			status_header( $status_code );
3094
			die( json_encode( (object) compact( 'error', 'error_description' ) ) );
3095
		}
3096
3097
		status_header( 200 );
3098
		if ( true === $response ) {
3099
			exit;
3100
		}
3101
3102
		die( json_encode( (object) $response ) );
3103
	}
3104
3105
	function upload_handler() {
3106
		if ( 'POST' !== strtoupper( $_SERVER['REQUEST_METHOD'] ) ) {
3107
			return new Jetpack_Error( 405, get_status_header_desc( 405 ), 405 );
3108
		}
3109
3110
		$user = wp_authenticate( '', '' );
3111
		if ( ! $user || is_wp_error( $user ) ) {
3112
			return new Jetpack_Error( 403, get_status_header_desc( 403 ), 403 );
3113
		}
3114
3115
		wp_set_current_user( $user->ID );
3116
3117
		if ( ! current_user_can( 'upload_files' ) ) {
3118
			return new Jetpack_Error( 'cannot_upload_files', 'User does not have permission to upload files', 403 );
3119
		}
3120
3121
		if ( empty( $_FILES ) ) {
3122
			return new Jetpack_Error( 'no_files_uploaded', 'No files were uploaded: nothing to process', 400 );
3123
		}
3124
3125
		foreach ( array_keys( $_FILES ) as $files_key ) {
3126
			if ( ! isset( $_POST["_jetpack_file_hmac_{$files_key}"] ) ) {
3127
				return new Jetpack_Error( 'missing_hmac', 'An HMAC for one or more files is missing', 400 );
3128
			}
3129
		}
3130
3131
		$media_keys = array_keys( $_FILES['media'] );
3132
3133
		$token = Jetpack_Data::get_access_token( get_current_user_id() );
3134
		if ( ! $token || is_wp_error( $token ) ) {
3135
			return new Jetpack_Error( 'unknown_token', 'Unknown Jetpack token', 403 );
3136
		}
3137
3138
		$uploaded_files = array();
3139
		$global_post    = isset( $GLOBALS['post'] ) ? $GLOBALS['post'] : null;
3140
		unset( $GLOBALS['post'] );
3141
		foreach ( $_FILES['media']['name'] as $index => $name ) {
3142
			$file = array();
3143
			foreach ( $media_keys as $media_key ) {
3144
				$file[$media_key] = $_FILES['media'][$media_key][$index];
3145
			}
3146
3147
			list( $hmac_provided, $salt ) = explode( ':', $_POST['_jetpack_file_hmac_media'][$index] );
3148
3149
			$hmac_file = hash_hmac_file( 'sha1', $file['tmp_name'], $salt . $token->secret );
3150
			if ( $hmac_provided !== $hmac_file ) {
3151
				$uploaded_files[$index] = (object) array( 'error' => 'invalid_hmac', 'error_description' => 'The corresponding HMAC for this file does not match' );
3152
				continue;
3153
			}
3154
3155
			$_FILES['.jetpack.upload.'] = $file;
3156
			$post_id = isset( $_POST['post_id'][$index] ) ? absint( $_POST['post_id'][$index] ) : 0;
3157
			if ( ! current_user_can( 'edit_post', $post_id ) ) {
3158
				$post_id = 0;
3159
			}
3160
			$attachment_id = media_handle_upload(
3161
				'.jetpack.upload.',
3162
				$post_id,
3163
				array(),
3164
				array(
3165
					'action' => 'jetpack_upload_file',
3166
				)
3167
			);
3168
3169
			if ( ! $attachment_id ) {
3170
				$uploaded_files[$index] = (object) array( 'error' => 'unknown', 'error_description' => 'An unknown problem occurred processing the upload on the Jetpack site' );
3171
			} elseif ( is_wp_error( $attachment_id ) ) {
3172
				$uploaded_files[$index] = (object) array( 'error' => 'attachment_' . $attachment_id->get_error_code(), 'error_description' => $attachment_id->get_error_message() );
3173
			} else {
3174
				$attachment = get_post( $attachment_id );
3175
				$uploaded_files[$index] = (object) array(
3176
					'id'   => (string) $attachment_id,
3177
					'file' => $attachment->post_title,
3178
					'url'  => wp_get_attachment_url( $attachment_id ),
3179
					'type' => $attachment->post_mime_type,
3180
					'meta' => wp_get_attachment_metadata( $attachment_id ),
3181
				);
3182
			}
3183
		}
3184
		if ( ! is_null( $global_post ) ) {
3185
			$GLOBALS['post'] = $global_post;
3186
		}
3187
3188
		return $uploaded_files;
3189
	}
3190
3191
	/**
3192
	 * Add help to the Jetpack page
3193
	 *
3194
	 * @since Jetpack (1.2.3)
3195
	 * @return false if not the Jetpack page
3196
	 */
3197
	function admin_help() {
3198
		$current_screen = get_current_screen();
3199
3200
		// Overview
3201
		$current_screen->add_help_tab(
3202
			array(
3203
				'id'		=> 'home',
3204
				'title'		=> __( 'Home', 'jetpack' ),
3205
				'content'	=>
3206
					'<p><strong>' . __( 'Jetpack by WordPress.com', 'jetpack' ) . '</strong></p>' .
3207
					'<p>' . __( 'Jetpack supercharges your self-hosted WordPress site with the awesome cloud power of WordPress.com.', 'jetpack' ) . '</p>' .
3208
					'<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>',
3209
			)
3210
		);
3211
3212
		// Screen Content
3213
		if ( current_user_can( 'manage_options' ) ) {
3214
			$current_screen->add_help_tab(
3215
				array(
3216
					'id'		=> 'settings',
3217
					'title'		=> __( 'Settings', 'jetpack' ),
3218
					'content'	=>
3219
						'<p><strong>' . __( 'Jetpack by WordPress.com',                                              'jetpack' ) . '</strong></p>' .
3220
						'<p>' . __( 'You can activate or deactivate individual Jetpack modules to suit your needs.', 'jetpack' ) . '</p>' .
3221
						'<ol>' .
3222
							'<li>' . __( 'Each module has an Activate or Deactivate link so you can toggle one individually.',														'jetpack' ) . '</li>' .
3223
							'<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>' .
3224
						'</ol>' .
3225
						'<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>'
3226
				)
3227
			);
3228
		}
3229
3230
		// Help Sidebar
3231
		$current_screen->set_help_sidebar(
3232
			'<p><strong>' . __( 'For more information:', 'jetpack' ) . '</strong></p>' .
3233
			'<p><a href="https://jetpack.com/faq/" target="_blank">'     . __( 'Jetpack FAQ',     'jetpack' ) . '</a></p>' .
3234
			'<p><a href="https://jetpack.com/support/" target="_blank">' . __( 'Jetpack Support', 'jetpack' ) . '</a></p>' .
3235
			'<p><a href="' . Jetpack::admin_url( array( 'page' => 'jetpack-debugger' )  ) .'">' . __( 'Jetpack Debugging Center', 'jetpack' ) . '</a></p>'
3236
		);
3237
	}
3238
3239
	function admin_menu_css() {
3240
		wp_enqueue_style( 'jetpack-icons' );
3241
	}
3242
3243
	function admin_menu_order() {
3244
		return true;
3245
	}
3246
3247 View Code Duplication
	function jetpack_menu_order( $menu_order ) {
3248
		$jp_menu_order = array();
3249
3250
		foreach ( $menu_order as $index => $item ) {
3251
			if ( $item != 'jetpack' ) {
3252
				$jp_menu_order[] = $item;
3253
			}
3254
3255
			if ( $index == 0 ) {
3256
				$jp_menu_order[] = 'jetpack';
3257
			}
3258
		}
3259
3260
		return $jp_menu_order;
3261
	}
3262
3263
	function admin_head() {
3264 View Code Duplication
		if ( isset( $_GET['configure'] ) && Jetpack::is_module( $_GET['configure'] ) && current_user_can( 'manage_options' ) )
3265
			/** This action is documented in class.jetpack-admin-page.php */
3266
			do_action( 'jetpack_module_configuration_head_' . $_GET['configure'] );
3267
	}
3268
3269
	function admin_banner_styles() {
3270
		$min = ( defined( 'SCRIPT_DEBUG' ) && SCRIPT_DEBUG ) ? '' : '.min';
3271
3272
		wp_enqueue_style( 'jetpack', plugins_url( "css/jetpack-banners{$min}.css", JETPACK__PLUGIN_FILE ), false, JETPACK__VERSION . '-20121016' );
3273
		wp_style_add_data( 'jetpack', 'rtl', 'replace' );
3274
		wp_style_add_data( 'jetpack', 'suffix', $min );
3275
	}
3276
3277
	function admin_scripts() {
3278
		wp_enqueue_script( 'jetpack-js', plugins_url( '_inc/jp.js', JETPACK__PLUGIN_FILE ), array( 'jquery', 'wp-util' ), JETPACK__VERSION . '-20121111' );
3279
		wp_localize_script(
3280
			'jetpack-js',
3281
			'jetpackL10n',
3282
			array(
3283
				'ays_disconnect' => "This will deactivate all Jetpack modules.\nAre you sure you want to disconnect?",
3284
				'ays_unlink'     => "This will prevent user-specific modules such as Publicize, Notifications and Post By Email from working.\nAre you sure you want to unlink?",
3285
				'ays_dismiss'    => "This will deactivate Jetpack.\nAre you sure you want to deactivate Jetpack?",
3286
			)
3287
		);
3288
		add_action( 'admin_footer', array( $this, 'do_stats' ) );
3289
	}
3290
3291
	function plugin_action_links( $actions ) {
3292
3293
		$jetpack_home = array( 'jetpack-home' => sprintf( '<a href="%s">%s</a>', Jetpack::admin_url( 'page=jetpack' ), __( 'Jetpack', 'jetpack' ) ) );
3294
3295
		if( current_user_can( 'jetpack_manage_modules' ) && ( Jetpack::is_active() || Jetpack::is_development_mode() ) ) {
3296
			return array_merge(
3297
				$jetpack_home,
3298
				array( 'settings' => sprintf( '<a href="%s">%s</a>', Jetpack::admin_url( 'page=jetpack_modules' ), __( 'Settings', 'jetpack' ) ) ),
3299
				array( 'support' => sprintf( '<a href="%s">%s</a>', Jetpack::admin_url( 'page=jetpack-debugger '), __( 'Support', 'jetpack' ) ) ),
3300
				$actions
3301
				);
3302
			}
3303
3304
		return array_merge( $jetpack_home, $actions );
3305
	}
3306
3307
	function admin_connect_notice() {
3308
		// Don't show the connect notice anywhere but the plugins.php after activating
3309
		$current = get_current_screen();
3310
		if ( 'plugins' !== $current->parent_base )
3311
			return;
3312
3313
		if ( ! current_user_can( 'jetpack_connect' ) )
3314
			return;
3315
3316
		$dismiss_and_deactivate_url = wp_nonce_url( Jetpack::admin_url( '?page=jetpack&jetpack-notice=dismiss' ), 'jetpack-deactivate' );
3317
		?>
3318
		<div id="message" class="updated jp-banner">
3319
			<a href="<?php echo esc_url( $dismiss_and_deactivate_url ); ?>" class="notice-dismiss" title="<?php esc_attr_e( 'Dismiss this notice', 'jetpack' ); ?>"></a>
3320
			<?php if ( in_array( Jetpack_Options::get_option( 'activated' ) , array( 1, 2, 3 ) ) ) : ?>
3321
					<div class="jp-banner__description-container">
3322
						<h2 class="jp-banner__header"><?php _e( 'Your Jetpack is almost ready!', 'jetpack' ); ?></h2>
3323
						<p class="jp-banner__description"><?php _e( 'Please connect to or create a WordPress.com account to enable Jetpack, including powerful security, traffic, and customization services.', 'jetpack' ); ?></p>
3324
						<p class="jp-banner__button-container">
3325
							<a href="<?php echo $this->build_connect_url( false, false, 'banner' ) ?>" class="button button-primary" id="wpcom-connect"><?php _e( 'Connect to WordPress.com', 'jetpack' ); ?></a>
3326
							<a href="<?php echo Jetpack::admin_url( 'admin.php?page=jetpack' ) ?>" class="button" title="<?php esc_attr_e( 'Learn about the benefits you receive when you connect Jetpack to WordPress.com', 'jetpack' ); ?>"><?php _e( 'Learn more', 'jetpack' ); ?></a>
3327
						</p>
3328
					</div>
3329 View Code Duplication
			<?php else : ?>
3330
				<div class="jp-banner__content">
3331
					<h2><?php _e( 'Jetpack is installed!', 'jetpack' ) ?></h2>
3332
					<p><?php _e( 'It\'s ready to bring awesome, WordPress.com cloud-powered features to your site.', 'jetpack' ) ?></p>
3333
				</div>
3334
				<div class="jp-banner__action-container">
3335
					<a href="<?php echo Jetpack::admin_url() ?>" class="jp-banner__button" id="wpcom-connect"><?php _e( 'Learn More', 'jetpack' ); ?></a>
3336
				</div>
3337
			<?php endif; ?>
3338
		</div>
3339
3340
		<?php
3341
	}
3342
3343
	/**
3344
	 * This is the first banner
3345
	 * It should be visible only to user that can update the option
3346
	 * Are not connected
3347
	 *
3348
	 * @return null
3349
	 */
3350
	function admin_jetpack_manage_notice() {
3351
		$screen = get_current_screen();
3352
3353
		// Don't show the connect notice on the jetpack settings page.
3354
		if ( ! in_array( $screen->base, array( 'dashboard' ) ) || $screen->is_network || $screen->action )
3355
			return;
3356
3357
		// Only show it if don't have the managment option set.
3358
		// And not dismissed it already.
3359
		if ( ! $this->can_display_jetpack_manage_notice() || Jetpack_Options::get_option( 'dismissed_manage_banner' ) ) {
3360
			return;
3361
		}
3362
3363
		$opt_out_url = $this->opt_out_jetpack_manage_url();
3364
		$opt_in_url  = $this->opt_in_jetpack_manage_url();
3365
		/**
3366
		 * I think it would be great to have different wordsing depending on where you are
3367
		 * for example if we show the notice on dashboard and a different one if we show it on Plugins screen
3368
		 * etc..
3369
		 */
3370
3371
		?>
3372
		<div id="message" class="updated jp-banner">
3373
				<a href="<?php echo esc_url( $opt_out_url ); ?>" class="notice-dismiss" title="<?php esc_attr_e( 'Dismiss this notice', 'jetpack' ); ?>"></a>
3374
				<div class="jp-banner__description-container">
3375
					<h2 class="jp-banner__header"><?php esc_html_e( 'Jetpack Centralized Site Management', 'jetpack' ); ?></h2>
3376
					<p class="jp-banner__description"><?php printf( __( 'Manage multiple Jetpack enabled sites from one single dashboard at wordpress.com. Allows all existing, connected Administrators to modify your site.', 'jetpack' ), 'https://jetpack.com/support/site-management' ); ?></p>
3377
					<p class="jp-banner__button-container">
3378
						<a href="<?php echo esc_url( $opt_in_url ); ?>" class="button button-primary" id="wpcom-connect"><?php _e( 'Activate Jetpack Manage', 'jetpack' ); ?></a>
3379
						<a href="https://jetpack.com/support/site-management" class="button" target="_blank" title="<?php esc_attr_e( 'Learn more about Jetpack Manage on Jetpack.com', 'jetpack' ); ?>"><?php _e( 'Learn more', 'jetpack' ); ?></a>
3380
					</p>
3381
				</div>
3382
		</div>
3383
		<?php
3384
	}
3385
3386
	/**
3387
	 * Returns the url that the user clicks to remove the notice for the big banner
3388
	 * @return (string)
3389
	 */
3390
	function opt_out_jetpack_manage_url() {
3391
		$referer = '&_wp_http_referer=' . add_query_arg( '_wp_http_referer', null );
3392
		return wp_nonce_url( Jetpack::admin_url( 'jetpack-notice=jetpack-manage-opt-out' . $referer ), 'jetpack_manage_banner_opt_out' );
3393
	}
3394
	/**
3395
	 * Returns the url that the user clicks to opt in to Jetpack Manage
3396
	 * @return (string)
3397
	 */
3398
	function opt_in_jetpack_manage_url() {
3399
		return wp_nonce_url( Jetpack::admin_url( 'jetpack-notice=jetpack-manage-opt-in' ), 'jetpack_manage_banner_opt_in' );
3400
	}
3401
3402
	function opt_in_jetpack_manage_notice() {
3403
		?>
3404
		<div class="wrap">
3405
			<div id="message" class="jetpack-message is-opt-in">
3406
				<?php echo sprintf( __( '<p><a href="%1$s" title="Opt in to WordPress.com Site Management" >Activate Site Management</a> to manage multiple sites from our centralized dashboard at wordpress.com/sites. <a href="%2$s" target="_blank">Learn more</a>.</p><a href="%1$s" class="jp-button">Activate Now</a>', 'jetpack' ), $this->opt_in_jetpack_manage_url(), 'https://jetpack.com/support/site-management' ); ?>
3407
			</div>
3408
		</div>
3409
		<?php
3410
3411
	}
3412
	/**
3413
	 * Determines whether to show the notice of not true = display notice
3414
	 * @return (bool)
3415
	 */
3416
	function can_display_jetpack_manage_notice() {
3417
		// never display the notice to users that can't do anything about it anyways
3418
		if( ! current_user_can( 'jetpack_manage_modules' ) )
3419
			return false;
3420
3421
		// don't display if we are in development more
3422
		if( Jetpack::is_development_mode() ) {
3423
			return false;
3424
		}
3425
		// don't display if the site is private
3426
		if(  ! Jetpack_Options::get_option( 'public' ) )
3427
			return false;
3428
3429
		/**
3430
		 * Should the Jetpack Remote Site Management notice be displayed.
3431
		 *
3432
		 * @since 3.3.0
3433
		 *
3434
		 * @param bool ! self::is_module_active( 'manage' ) Is the Manage module inactive.
3435
		 */
3436
		return apply_filters( 'can_display_jetpack_manage_notice', ! self::is_module_active( 'manage' ) );
3437
	}
3438
3439
	function network_connect_notice() {
3440
		?>
3441
		<div id="message" class="updated jetpack-message">
3442
			<div class="squeezer">
3443
				<h2><?php _e( '<strong>Jetpack is activated!</strong> Each site on your network must be connected individually by an admin on that site.', 'jetpack' ) ?></h2>
3444
			</div>
3445
		</div>
3446
		<?php
3447
	}
3448
3449
	public static function jetpack_comment_notice() {
3450
		if ( in_array( 'comments', Jetpack::get_active_modules() ) ) {
3451
			return '';
3452
		}
3453
3454
		$jetpack_old_version = explode( ':', Jetpack_Options::get_option( 'old_version' ) );
3455
		$jetpack_new_version = explode( ':', Jetpack_Options::get_option( 'version' ) );
3456
3457
		if ( $jetpack_old_version ) {
3458
			if ( version_compare( $jetpack_old_version[0], '1.4', '>=' ) ) {
3459
				return '';
3460
			}
3461
		}
3462
3463
		if ( $jetpack_new_version ) {
3464
			if ( version_compare( $jetpack_new_version[0], '1.4-something', '<' ) ) {
3465
				return '';
3466
			}
3467
		}
3468
3469
		return '<br /><br />' . sprintf(
3470
			__( 'Jetpack now includes Comments, which enables your visitors to use their WordPress.com, Twitter, or Facebook accounts when commenting on your site. To activate Comments, <a href="%s">%s</a>.', 'jetpack' ),
3471
			wp_nonce_url(
3472
				Jetpack::admin_url(
3473
					array(
3474
						'page'   => 'jetpack',
3475
						'action' => 'activate',
3476
						'module' => 'comments',
3477
					)
3478
				),
3479
				'jetpack_activate-comments'
3480
			),
3481
			__( 'click here', 'jetpack' )
3482
		);
3483
	}
3484
3485
	/**
3486
	 * Show the survey link when the user has just disconnected Jetpack.
3487
	 */
3488
	function disconnect_survey_notice() {
3489
		?>
3490
		<div class="wrap">
3491
			<div id="message" class="jetpack-message stay-visible">
3492
				<div class="squeezer">
3493
					<h2>
3494
						<?php _e( 'You have successfully disconnected Jetpack.', 'jetpack' ); ?>
3495
						<br />
3496
						<?php echo sprintf(
3497
							__( 'Would you tell us why? Just <a href="%1$s" target="%2$s">answering two simple questions</a> would help us improve Jetpack.', 'jetpack' ),
3498
							'https://jetpack.com/survey-disconnected/',
3499
							'_blank'
3500
						); ?>
3501
					</h2>
3502
				</div>
3503
			</div>
3504
		</div>
3505
		<?php
3506
	}
3507
3508
	/*
3509
	 * Registration flow:
3510
	 * 1 - ::admin_page_load() action=register
3511
	 * 2 - ::try_registration()
3512
	 * 3 - ::register()
3513
	 *     - Creates jetpack_register option containing two secrets and a timestamp
3514
	 *     - Calls https://jetpack.wordpress.com/jetpack.register/1/ with
3515
	 *       siteurl, home, gmt_offset, timezone_string, site_name, secret_1, secret_2, site_lang, timeout, stats_id
3516
	 *     - That request to jetpack.wordpress.com does not immediately respond.  It first makes a request BACK to this site's
3517
	 *       xmlrpc.php?for=jetpack: RPC method: jetpack.verifyRegistration, Parameters: secret_1
3518
	 *     - The XML-RPC request verifies secret_1, deletes both secrets and responds with: secret_2
3519
	 *     - https://jetpack.wordpress.com/jetpack.register/1/ verifies that XML-RPC response (secret_2) then finally responds itself with
3520
	 *       jetpack_id, jetpack_secret, jetpack_public
3521
	 *     - ::register() then stores jetpack_options: id => jetpack_id, blog_token => jetpack_secret
3522
	 * 4 - redirect to https://wordpress.com/start/jetpack-connect
3523
	 * 5 - user logs in with WP.com account
3524
	 * 6 - remote request to this site's xmlrpc.php with action remoteAuthorize, Jetpack_XMLRPC_Server->remote_authorize
3525
	 *		- Jetpack_Client_Server::authorize()
3526
	 *		- Jetpack_Client_Server::get_token()
3527
	 *		- GET https://jetpack.wordpress.com/jetpack.token/1/ with
3528
	 *        client_id, client_secret, grant_type, code, redirect_uri:action=authorize, state, scope, user_email, user_login
3529
	 *			- which responds with access_token, token_type, scope
3530
	 *		- Jetpack_Client_Server::authorize() stores jetpack_options: user_token => access_token.$user_id
3531
	 *		- Jetpack::activate_default_modules()
3532
	 *     		- Deactivates deprecated plugins
3533
	 *     		- Activates all default modules
3534
	 *		- Responds with either error, or 'connected' for new connection, or 'linked' for additional linked users
3535
	 * 7 - For a new connection, user selects a Jetpack plan on wordpress.com
3536
	 * 8 - User is redirected back to wp-admin/index.php?page=jetpack with state:message=authorized
3537
	 *     Done!
3538
	 */
3539
3540
	/**
3541
	 * Handles the page load events for the Jetpack admin page
3542
	 */
3543
	function admin_page_load() {
3544
		$error = false;
3545
3546
		// Make sure we have the right body class to hook stylings for subpages off of.
3547
		add_filter( 'admin_body_class', array( __CLASS__, 'add_jetpack_pagestyles' ) );
3548
3549
		if ( ! empty( $_GET['jetpack_restate'] ) ) {
3550
			// Should only be used in intermediate redirects to preserve state across redirects
3551
			Jetpack::restate();
3552
		}
3553
3554
		if ( isset( $_GET['connect_url_redirect'] ) ) {
3555
			// User clicked in the iframe to link their accounts
3556
			if ( ! Jetpack::is_user_connected() ) {
3557
				$connect_url = $this->build_connect_url( true, false, 'iframe' );
3558
				if ( isset( $_GET['notes_iframe'] ) )
3559
					$connect_url .= '&notes_iframe';
3560
				wp_redirect( $connect_url );
3561
				exit;
3562
			} else {
3563
				if ( ! isset( $_GET['calypso_env'] ) ) {
3564
					Jetpack::state( 'message', 'already_authorized' );
3565
					wp_safe_redirect( Jetpack::admin_url() );
3566
				} else {
3567
					$connect_url = $this->build_connect_url( true, false, 'iframe' );
3568
					$connect_url .= '&already_authorized=true';
3569
					wp_redirect( $connect_url );
3570
				}
3571
			}
3572
		}
3573
3574
3575
		if ( isset( $_GET['action'] ) ) {
3576
			switch ( $_GET['action'] ) {
3577
			case 'authorize':
3578
				if ( Jetpack::is_active() && Jetpack::is_user_connected() ) {
3579
					Jetpack::state( 'message', 'already_authorized' );
3580
					wp_safe_redirect( Jetpack::admin_url() );
3581
					exit;
3582
				}
3583
				Jetpack::log( 'authorize' );
3584
				$client_server = new Jetpack_Client_Server;
3585
				$client_server->client_authorize();
3586
				exit;
3587
			case 'register' :
3588
				if ( ! current_user_can( 'jetpack_connect' ) ) {
3589
					$error = 'cheatin';
3590
					break;
3591
				}
3592
				check_admin_referer( 'jetpack-register' );
3593
				Jetpack::log( 'register' );
3594
				Jetpack::maybe_set_version_option();
3595
				$registered = Jetpack::try_registration();
3596
				if ( is_wp_error( $registered ) ) {
3597
					$error = $registered->get_error_code();
3598
					Jetpack::state( 'error_description', $registered->get_error_message() );
3599
					break;
3600
				}
3601
3602
				$from = isset( $_GET['from'] ) ? $_GET['from'] : false;
3603
3604
				wp_redirect( $this->build_connect_url( true, false, $from ) );
3605
				exit;
3606
			case 'activate' :
3607
				if ( ! current_user_can( 'jetpack_activate_modules' ) ) {
3608
					$error = 'cheatin';
3609
					break;
3610
				}
3611
3612
				$module = stripslashes( $_GET['module'] );
3613
				check_admin_referer( "jetpack_activate-$module" );
3614
				Jetpack::log( 'activate', $module );
3615
				Jetpack::activate_module( $module );
3616
				// The following two lines will rarely happen, as Jetpack::activate_module normally exits at the end.
3617
				wp_safe_redirect( Jetpack::admin_url( 'page=jetpack' ) );
3618
				exit;
3619
			case 'activate_default_modules' :
3620
				check_admin_referer( 'activate_default_modules' );
3621
				Jetpack::log( 'activate_default_modules' );
3622
				Jetpack::restate();
3623
				$min_version   = isset( $_GET['min_version'] ) ? $_GET['min_version'] : false;
3624
				$max_version   = isset( $_GET['max_version'] ) ? $_GET['max_version'] : false;
3625
				$other_modules = isset( $_GET['other_modules'] ) && is_array( $_GET['other_modules'] ) ? $_GET['other_modules'] : array();
3626
				Jetpack::activate_default_modules( $min_version, $max_version, $other_modules );
3627
				wp_safe_redirect( Jetpack::admin_url( 'page=jetpack' ) );
3628
				exit;
3629
			case 'disconnect' :
3630
				if ( ! current_user_can( 'jetpack_disconnect' ) ) {
3631
					$error = 'cheatin';
3632
					break;
3633
				}
3634
3635
				check_admin_referer( 'jetpack-disconnect' );
3636
				Jetpack::log( 'disconnect' );
3637
				Jetpack::disconnect();
3638
				wp_safe_redirect( Jetpack::admin_url( 'disconnected=true' ) );
3639
				exit;
3640
			case 'reconnect' :
3641
				if ( ! current_user_can( 'jetpack_reconnect' ) ) {
3642
					$error = 'cheatin';
3643
					break;
3644
				}
3645
3646
				check_admin_referer( 'jetpack-reconnect' );
3647
				Jetpack::log( 'reconnect' );
3648
				$this->disconnect();
3649
				wp_redirect( $this->build_connect_url( true, false, 'reconnect' ) );
3650
				exit;
3651 View Code Duplication
			case 'deactivate' :
3652
				if ( ! current_user_can( 'jetpack_deactivate_modules' ) ) {
3653
					$error = 'cheatin';
3654
					break;
3655
				}
3656
3657
				$modules = stripslashes( $_GET['module'] );
3658
				check_admin_referer( "jetpack_deactivate-$modules" );
3659
				foreach ( explode( ',', $modules ) as $module ) {
3660
					Jetpack::log( 'deactivate', $module );
3661
					Jetpack::deactivate_module( $module );
3662
					Jetpack::state( 'message', 'module_deactivated' );
3663
				}
3664
				Jetpack::state( 'module', $modules );
3665
				wp_safe_redirect( Jetpack::admin_url( 'page=jetpack' ) );
3666
				exit;
3667
			case 'unlink' :
3668
				$redirect = isset( $_GET['redirect'] ) ? $_GET['redirect'] : '';
3669
				check_admin_referer( 'jetpack-unlink' );
3670
				Jetpack::log( 'unlink' );
3671
				$this->unlink_user();
3672
				Jetpack::state( 'message', 'unlinked' );
3673
				if ( 'sub-unlink' == $redirect ) {
3674
					wp_safe_redirect( admin_url() );
3675
				} else {
3676
					wp_safe_redirect( Jetpack::admin_url( array( 'page' => $redirect ) ) );
3677
				}
3678
				exit;
3679
			default:
3680
				/**
3681
				 * Fires when a Jetpack admin page is loaded with an unrecognized parameter.
3682
				 *
3683
				 * @since 2.6.0
3684
				 *
3685
				 * @param string sanitize_key( $_GET['action'] ) Unrecognized URL parameter.
3686
				 */
3687
				do_action( 'jetpack_unrecognized_action', sanitize_key( $_GET['action'] ) );
3688
			}
3689
		}
3690
3691
		if ( ! $error = $error ? $error : Jetpack::state( 'error' ) ) {
3692
			self::activate_new_modules( true );
3693
		}
3694
3695
		switch ( $error ) {
3696
		case 'cheatin' :
3697
			$this->error = __( 'Cheatin&#8217; uh?', 'jetpack' );
3698
			break;
3699
		case 'access_denied' :
3700
			$this->error = sprintf( __( 'Would you mind telling us why you did not complete the Jetpack connection in this <a href="%s">1 question survey</a>?', 'jetpack' ), 'https://jetpack.com/cancelled-connection/' ) . '<br /><small>' . __( 'A Jetpack connection is required for our free security and traffic features to work.', 'jetpack' ) . '</small>';
3701
			break;
3702
		case 'wrong_state' :
3703
			$this->error = __( 'You need to stay logged in to your WordPress blog while you authorize Jetpack.', 'jetpack' );
3704
			break;
3705
		case 'invalid_client' :
3706
			// @todo re-register instead of deactivate/reactivate
3707
			$this->error = __( 'We had an issue connecting Jetpack; deactivate then reactivate the Jetpack plugin, then connect again.', 'jetpack' );
3708
			break;
3709
		case 'invalid_grant' :
3710
			$this->error = __( 'There was an issue connecting your Jetpack. Please click &#8220;Connect to WordPress.com&#8221; again.', 'jetpack' );
3711
			break;
3712
		case 'site_inaccessible' :
3713
		case 'site_requires_authorization' :
3714
			$this->error = sprintf( __( 'Your website needs to be publicly accessible to use Jetpack: %s', 'jetpack' ), "<code>$error</code>" );
3715
			break;
3716
		case 'module_activation_failed' :
3717
			$module = Jetpack::state( 'module' );
3718
			if ( ! empty( $module ) && $mod = Jetpack::get_module( $module ) ) {
3719
				$this->error = sprintf( __( '%s could not be activated because it triggered a <strong>fatal error</strong>. Perhaps there is a conflict with another plugin you have installed?', 'jetpack' ), $mod['name'] );
3720
				if ( isset( $this->plugins_to_deactivate[$module] ) ) {
3721
					$this->error .= ' ' . sprintf( __( 'Do you still have the %s plugin installed?', 'jetpack' ), $this->plugins_to_deactivate[$module][1] );
3722
				}
3723
			} else {
3724
				$this->error = __( 'Module could not be activated because it triggered a <strong>fatal error</strong>. Perhaps there is a conflict with another plugin you have installed?', 'jetpack' );
3725
			}
3726
			if ( $php_errors = Jetpack::state( 'php_errors' ) ) {
3727
				$this->error .= "<br />\n";
3728
				$this->error .= $php_errors;
3729
			}
3730
			break;
3731
		case 'master_user_required' :
3732
			$module = Jetpack::state( 'module' );
3733
			$module_name = '';
3734
			if ( ! empty( $module ) && $mod = Jetpack::get_module( $module ) ) {
3735
				$module_name = $mod['name'];
3736
			}
3737
3738
			$master_user = Jetpack_Options::get_option( 'master_user' );
3739
			$master_userdata = get_userdata( $master_user ) ;
3740
			if ( $master_userdata ) {
3741
				if ( ! in_array( $module, Jetpack::get_active_modules() ) ) {
3742
					$this->error = sprintf( __( '%s was not activated.' , 'jetpack' ), $module_name );
3743
				} else {
3744
					$this->error = sprintf( __( '%s was not deactivated.' , 'jetpack' ), $module_name );
3745
				}
3746
				$this->error .= '  ' . sprintf( __( 'This module can only be altered by %s, the user who initiated the Jetpack connection on this site.' , 'jetpack' ), esc_html( $master_userdata->display_name ) );
3747
3748
			} else {
3749
				$this->error = sprintf( __( 'Only the user who initiated the Jetpack connection on this site can toggle %s, but that user no longer exists. This should not happen.', 'jetpack' ), $module_name );
3750
			}
3751
			break;
3752
		case 'not_public' :
3753
			$this->error = __( '<strong>Your Jetpack has a glitch.</strong> Connecting this site with WordPress.com is not possible. This usually means your site is not publicly accessible (localhost).', 'jetpack' );
3754
			break;
3755
		case 'wpcom_408' :
3756
		case 'wpcom_5??' :
3757
		case 'wpcom_bad_response' :
3758
		case 'wpcom_outage' :
3759
			$this->error = __( 'WordPress.com is currently having problems and is unable to fuel up your Jetpack.  Please try again later.', 'jetpack' );
3760
			break;
3761
		case 'register_http_request_failed' :
3762
		case 'token_http_request_failed' :
3763
			$this->error = sprintf( __( 'Jetpack could not contact WordPress.com: %s.  This usually means something is incorrectly configured on your web host.', 'jetpack' ), "<code>$error</code>" );
3764
			break;
3765
		default :
3766
			if ( empty( $error ) ) {
3767
				break;
3768
			}
3769
			$error = trim( substr( strip_tags( $error ), 0, 20 ) );
3770
			// no break: fall through
3771
		case 'no_role' :
3772
		case 'no_cap' :
3773
		case 'no_code' :
3774
		case 'no_state' :
3775
		case 'invalid_state' :
3776
		case 'invalid_request' :
3777
		case 'invalid_scope' :
3778
		case 'unsupported_response_type' :
3779
		case 'invalid_token' :
3780
		case 'no_token' :
3781
		case 'missing_secrets' :
3782
		case 'home_missing' :
3783
		case 'siteurl_missing' :
3784
		case 'gmt_offset_missing' :
3785
		case 'site_name_missing' :
3786
		case 'secret_1_missing' :
3787
		case 'secret_2_missing' :
3788
		case 'site_lang_missing' :
3789
		case 'home_malformed' :
3790
		case 'siteurl_malformed' :
3791
		case 'gmt_offset_malformed' :
3792
		case 'timezone_string_malformed' :
3793
		case 'site_name_malformed' :
3794
		case 'secret_1_malformed' :
3795
		case 'secret_2_malformed' :
3796
		case 'site_lang_malformed' :
3797
		case 'secrets_mismatch' :
3798
		case 'verify_secret_1_missing' :
3799
		case 'verify_secret_1_malformed' :
3800
		case 'verify_secrets_missing' :
3801
		case 'verify_secrets_mismatch' :
3802
			$error = esc_html( $error );
3803
			$this->error = sprintf( __( '<strong>Your Jetpack has a glitch.</strong>  We&#8217;re sorry for the inconvenience. Please try again later, if the issue continues please contact support with this message: %s', 'jetpack' ), "<code>$error</code>" );
3804
			if ( ! Jetpack::is_active() ) {
3805
				$this->error .= '<br />';
3806
				$this->error .= sprintf( __( 'Try connecting again.', 'jetpack' ) );
3807
			}
3808
			break;
3809
		}
3810
3811
		$message_code = Jetpack::state( 'message' );
3812
3813
		$active_state = Jetpack::state( 'activated_modules' );
3814
		if ( ! empty( $active_state ) ) {
3815
			$available    = Jetpack::get_available_modules();
3816
			$active_state = explode( ',', $active_state );
3817
			$active_state = array_intersect( $active_state, $available );
3818
			if ( count( $active_state ) ) {
3819
				foreach ( $active_state as $mod ) {
3820
					$this->stat( 'module-activated', $mod );
3821
				}
3822
			} else {
3823
				$active_state = false;
3824
			}
3825
		}
3826
		if( Jetpack::state( 'optin-manage' ) ) {
3827
			$activated_manage = $message_code;
3828
			$message_code = 'jetpack-manage';
3829
3830
		}
3831
		switch ( $message_code ) {
3832
		case 'modules_activated' :
3833
			$this->message = sprintf(
3834
				__( 'Welcome to <strong>Jetpack %s</strong>!', 'jetpack' ),
3835
				JETPACK__VERSION
3836
			);
3837
3838
			if ( $active_state ) {
3839
				$titles = array();
3840 View Code Duplication
				foreach ( $active_state as $mod ) {
3841
					if ( $mod_headers = Jetpack::get_module( $mod ) ) {
3842
						$titles[] = '<strong>' . preg_replace( '/\s+(?![^<>]++>)/', '&nbsp;', $mod_headers['name'] ) . '</strong>';
3843
					}
3844
				}
3845
				if ( $titles ) {
3846
					$this->message .= '<br /><br />' . wp_sprintf( __( 'The following new modules have been activated: %l.', 'jetpack' ), $titles );
3847
				}
3848
			}
3849
3850
			if ( $reactive_state = Jetpack::state( 'reactivated_modules' ) ) {
3851
				$titles = array();
3852 View Code Duplication
				foreach ( explode( ',',  $reactive_state ) as $mod ) {
3853
					if ( $mod_headers = Jetpack::get_module( $mod ) ) {
3854
						$titles[] = '<strong>' . preg_replace( '/\s+(?![^<>]++>)/', '&nbsp;', $mod_headers['name'] ) . '</strong>';
3855
					}
3856
				}
3857
				if ( $titles ) {
3858
					$this->message .= '<br /><br />' . wp_sprintf( __( 'The following modules have been updated: %l.', 'jetpack' ), $titles );
3859
				}
3860
			}
3861
3862
			$this->message .= Jetpack::jetpack_comment_notice();
3863
			break;
3864
		case 'jetpack-manage':
3865
			$this->message = '<strong>' . sprintf( __( 'You are all set! Your site can now be managed from <a href="%s" target="_blank">wordpress.com/sites</a>.', 'jetpack' ), 'https://wordpress.com/sites' ) . '</strong>';
3866
			if ( $activated_manage ) {
3867
				$this->message .= '<br /><strong>' . __( 'Manage has been activated for you!', 'jetpack'  ) . '</strong>';
3868
			}
3869
			break;
3870
		case 'module_activated' :
3871
			if ( $module = Jetpack::get_module( Jetpack::state( 'module' ) ) ) {
3872
				$this->message = sprintf( __( '<strong>%s Activated!</strong> You can deactivate at any time by clicking the Deactivate link next to each module.', 'jetpack' ), $module['name'] );
3873
				$this->stat( 'module-activated', Jetpack::state( 'module' ) );
3874
			}
3875
			break;
3876
3877
		case 'module_deactivated' :
3878
			$modules = Jetpack::state( 'module' );
3879
			if ( ! $modules ) {
3880
				break;
3881
			}
3882
3883
			$module_names = array();
3884
			foreach ( explode( ',', $modules ) as $module_slug ) {
3885
				$module = Jetpack::get_module( $module_slug );
3886
				if ( $module ) {
3887
					$module_names[] = $module['name'];
3888
				}
3889
3890
				$this->stat( 'module-deactivated', $module_slug );
3891
			}
3892
3893
			if ( ! $module_names ) {
3894
				break;
3895
			}
3896
3897
			$this->message = wp_sprintf(
3898
				_nx(
3899
					'<strong>%l Deactivated!</strong> You can activate it again at any time using the activate link next to each module.',
3900
					'<strong>%l Deactivated!</strong> You can activate them again at any time using the activate links next to each module.',
3901
					count( $module_names ),
3902
					'%l = list of Jetpack module/feature names',
3903
					'jetpack'
3904
				),
3905
				$module_names
3906
			);
3907
			break;
3908
3909
		case 'module_configured' :
3910
			$this->message = __( '<strong>Module settings were saved.</strong> ', 'jetpack' );
3911
			break;
3912
3913
		case 'already_authorized' :
3914
			$this->message = __( '<strong>Your Jetpack is already connected.</strong> ', 'jetpack' );
3915
			break;
3916
3917
		case 'authorized' :
3918
			$this->message  = __( '<strong>You&#8217;re fueled up and ready to go, Jetpack is now active.</strong> ', 'jetpack' );
3919
			$this->message .= Jetpack::jetpack_comment_notice();
3920
			break;
3921
3922
		case 'linked' :
3923
			$this->message  = __( '<strong>You&#8217;re fueled up and ready to go.</strong> ', 'jetpack' );
3924
			$this->message .= Jetpack::jetpack_comment_notice();
3925
			break;
3926
3927
		case 'unlinked' :
3928
			$user = wp_get_current_user();
3929
			$this->message = sprintf( __( '<strong>You have unlinked your account (%s) from WordPress.com.</strong>', 'jetpack' ), $user->user_login );
3930
			break;
3931
3932
		case 'switch_master' :
3933
			global $current_user;
3934
			$is_master_user = $current_user->ID == Jetpack_Options::get_option( 'master_user' );
3935
			$master_userdata = get_userdata( Jetpack_Options::get_option( 'master_user' ) );
3936
			if ( $is_master_user ) {
3937
				$this->message = __( 'You have successfully set yourself as Jetpack’s primary user.', 'jetpack' );
3938
			} else {
3939
				$this->message = sprintf( _x( 'You have successfully set %s as Jetpack’s primary user.', '%s is a username', 'jetpack' ), $master_userdata->user_login );
3940
			}
3941
			break;
3942
		}
3943
3944
		$deactivated_plugins = Jetpack::state( 'deactivated_plugins' );
3945
3946
		if ( ! empty( $deactivated_plugins ) ) {
3947
			$deactivated_plugins = explode( ',', $deactivated_plugins );
3948
			$deactivated_titles  = array();
3949
			foreach ( $deactivated_plugins as $deactivated_plugin ) {
3950
				if ( ! isset( $this->plugins_to_deactivate[$deactivated_plugin] ) ) {
3951
					continue;
3952
				}
3953
3954
				$deactivated_titles[] = '<strong>' . str_replace( ' ', '&nbsp;', $this->plugins_to_deactivate[$deactivated_plugin][1] ) . '</strong>';
3955
			}
3956
3957
			if ( $deactivated_titles ) {
3958
				if ( $this->message ) {
3959
					$this->message .= "<br /><br />\n";
3960
				}
3961
3962
				$this->message .= wp_sprintf(
3963
					_n(
3964
						'Jetpack contains the most recent version of the old %l plugin.',
3965
						'Jetpack contains the most recent versions of the old %l plugins.',
3966
						count( $deactivated_titles ),
3967
						'jetpack'
3968
					),
3969
					$deactivated_titles
3970
				);
3971
3972
				$this->message .= "<br />\n";
3973
3974
				$this->message .= _n(
3975
					'The old version has been deactivated and can be removed from your site.',
3976
					'The old versions have been deactivated and can be removed from your site.',
3977
					count( $deactivated_titles ),
3978
					'jetpack'
3979
				);
3980
			}
3981
		}
3982
3983
		$this->privacy_checks = Jetpack::state( 'privacy_checks' );
3984
3985
		if ( $this->message || $this->error || $this->privacy_checks || $this->can_display_jetpack_manage_notice() ) {
3986
			add_action( 'jetpack_notices', array( $this, 'admin_notices' ) );
3987
		}
3988
3989 View Code Duplication
		if ( isset( $_GET['configure'] ) && Jetpack::is_module( $_GET['configure'] ) && current_user_can( 'manage_options' ) ) {
3990
			/**
3991
			 * Fires when a module configuration page is loaded.
3992
			 * The dynamic part of the hook is the configure parameter from the URL.
3993
			 *
3994
			 * @since 1.1.0
3995
			 */
3996
			do_action( 'jetpack_module_configuration_load_' . $_GET['configure'] );
3997
		}
3998
3999
		add_filter( 'jetpack_short_module_description', 'wptexturize' );
4000
	}
4001
4002
	function admin_notices() {
4003
4004
		if ( $this->error ) {
4005
?>
4006
<div id="message" class="jetpack-message jetpack-err">
4007
	<div class="squeezer">
4008
		<h2><?php echo wp_kses( $this->error, array( 'a' => array( 'href' => array() ), 'small' => true, 'code' => true, 'strong' => true, 'br' => true, 'b' => true ) ); ?></h2>
4009
<?php	if ( $desc = Jetpack::state( 'error_description' ) ) : ?>
4010
		<p><?php echo esc_html( stripslashes( $desc ) ); ?></p>
4011
<?php	endif; ?>
4012
	</div>
4013
</div>
4014
<?php
4015
		}
4016
4017
		if ( $this->message ) {
4018
?>
4019
<div id="message" class="jetpack-message">
4020
	<div class="squeezer">
4021
		<h2><?php echo wp_kses( $this->message, array( 'strong' => array(), 'a' => array( 'href' => true ), 'br' => true ) ); ?></h2>
4022
	</div>
4023
</div>
4024
<?php
4025
		}
4026
4027
		if ( $this->privacy_checks ) :
4028
			$module_names = $module_slugs = array();
4029
4030
			$privacy_checks = explode( ',', $this->privacy_checks );
4031
			$privacy_checks = array_filter( $privacy_checks, array( 'Jetpack', 'is_module' ) );
4032
			foreach ( $privacy_checks as $module_slug ) {
4033
				$module = Jetpack::get_module( $module_slug );
4034
				if ( ! $module ) {
4035
					continue;
4036
				}
4037
4038
				$module_slugs[] = $module_slug;
4039
				$module_names[] = "<strong>{$module['name']}</strong>";
4040
			}
4041
4042
			$module_slugs = join( ',', $module_slugs );
4043
?>
4044
<div id="message" class="jetpack-message jetpack-err">
4045
	<div class="squeezer">
4046
		<h2><strong><?php esc_html_e( 'Is this site private?', 'jetpack' ); ?></strong></h2><br />
4047
		<p><?php
4048
			echo wp_kses(
4049
				wptexturize(
4050
					wp_sprintf(
4051
						_nx(
4052
							"Like your site's RSS feeds, %l allows access to your posts and other content to third parties.",
4053
							"Like your site's RSS feeds, %l allow access to your posts and other content to third parties.",
4054
							count( $privacy_checks ),
4055
							'%l = list of Jetpack module/feature names',
4056
							'jetpack'
4057
						),
4058
						$module_names
4059
					)
4060
				),
4061
				array( 'strong' => true )
4062
			);
4063
4064
			echo "\n<br />\n";
4065
4066
			echo wp_kses(
4067
				sprintf(
4068
					_nx(
4069
						'If your site is not publicly accessible, consider <a href="%1$s" title="%2$s">deactivating this feature</a>.',
4070
						'If your site is not publicly accessible, consider <a href="%1$s" title="%2$s">deactivating these features</a>.',
4071
						count( $privacy_checks ),
4072
						'%1$s = deactivation URL, %2$s = "Deactivate {list of Jetpack module/feature names}',
4073
						'jetpack'
4074
					),
4075
					wp_nonce_url(
4076
						Jetpack::admin_url(
4077
							array(
4078
								'page'   => 'jetpack',
4079
								'action' => 'deactivate',
4080
								'module' => urlencode( $module_slugs ),
4081
							)
4082
						),
4083
						"jetpack_deactivate-$module_slugs"
4084
					),
4085
					esc_attr( wp_kses( wp_sprintf( _x( 'Deactivate %l', '%l = list of Jetpack module/feature names', 'jetpack' ), $module_names ), array() ) )
4086
				),
4087
				array( 'a' => array( 'href' => true, 'title' => true ) )
4088
			);
4089
		?></p>
4090
	</div>
4091
</div>
4092
<?php endif;
4093
	// only display the notice if the other stuff is not there
4094
	if( $this->can_display_jetpack_manage_notice() && !  $this->error && ! $this->message && ! $this->privacy_checks ) {
4095
		if( isset( $_GET['page'] ) && 'jetpack' != $_GET['page'] )
4096
			$this->opt_in_jetpack_manage_notice();
4097
		}
4098
	}
4099
4100
	/**
4101
	 * Record a stat for later output.  This will only currently output in the admin_footer.
4102
	 */
4103
	function stat( $group, $detail ) {
4104
		if ( ! isset( $this->stats[ $group ] ) )
4105
			$this->stats[ $group ] = array();
4106
		$this->stats[ $group ][] = $detail;
4107
	}
4108
4109
	/**
4110
	 * Load stats pixels. $group is auto-prefixed with "x_jetpack-"
4111
	 */
4112
	function do_stats( $method = '' ) {
4113
		if ( is_array( $this->stats ) && count( $this->stats ) ) {
4114
			foreach ( $this->stats as $group => $stats ) {
4115
				if ( is_array( $stats ) && count( $stats ) ) {
4116
					$args = array( "x_jetpack-{$group}" => implode( ',', $stats ) );
4117
					if ( 'server_side' === $method ) {
4118
						self::do_server_side_stat( $args );
4119
					} else {
4120
						echo '<img src="' . esc_url( self::build_stats_url( $args ) ) . '" width="1" height="1" style="display:none;" />';
4121
					}
4122
				}
4123
				unset( $this->stats[ $group ] );
4124
			}
4125
		}
4126
	}
4127
4128
	/**
4129
	 * Runs stats code for a one-off, server-side.
4130
	 *
4131
	 * @param $args array|string The arguments to append to the URL. Should include `x_jetpack-{$group}={$stats}` or whatever we want to store.
4132
	 *
4133
	 * @return bool If it worked.
4134
	 */
4135
	static function do_server_side_stat( $args ) {
4136
		$response = wp_remote_get( esc_url_raw( self::build_stats_url( $args ) ) );
4137
		if ( is_wp_error( $response ) )
4138
			return false;
4139
4140
		if ( 200 !== wp_remote_retrieve_response_code( $response ) )
4141
			return false;
4142
4143
		return true;
4144
	}
4145
4146
	/**
4147
	 * Builds the stats url.
4148
	 *
4149
	 * @param $args array|string The arguments to append to the URL.
4150
	 *
4151
	 * @return string The URL to be pinged.
4152
	 */
4153
	static function build_stats_url( $args ) {
4154
		$defaults = array(
4155
			'v'    => 'wpcom2',
4156
			'rand' => md5( mt_rand( 0, 999 ) . time() ),
4157
		);
4158
		$args     = wp_parse_args( $args, $defaults );
4159
		/**
4160
		 * Filter the URL used as the Stats tracking pixel.
4161
		 *
4162
		 * @since 2.3.2
4163
		 *
4164
		 * @param string $url Base URL used as the Stats tracking pixel.
4165
		 */
4166
		$base_url = apply_filters(
4167
			'jetpack_stats_base_url',
4168
			set_url_scheme( 'http://pixel.wp.com/g.gif' )
4169
		);
4170
		$url      = add_query_arg( $args, $base_url );
4171
		return $url;
4172
	}
4173
4174
	static function translate_current_user_to_role() {
4175
		foreach ( self::$capability_translations as $role => $cap ) {
4176
			if ( current_user_can( $role ) || current_user_can( $cap ) ) {
4177
				return $role;
4178
			}
4179
		}
4180
4181
		return false;
4182
	}
4183
4184
	static function translate_role_to_cap( $role ) {
4185
		if ( ! isset( self::$capability_translations[$role] ) ) {
4186
			return false;
4187
		}
4188
4189
		return self::$capability_translations[$role];
4190
	}
4191
4192
	static function sign_role( $role ) {
4193
		if ( ! $user_id = (int) get_current_user_id() ) {
4194
			return false;
4195
		}
4196
4197
		$token = Jetpack_Data::get_access_token();
4198
		if ( ! $token || is_wp_error( $token ) ) {
4199
			return false;
4200
		}
4201
4202
		return $role . ':' . hash_hmac( 'md5', "{$role}|{$user_id}", $token->secret );
4203
	}
4204
4205
4206
	/**
4207
	 * Builds a URL to the Jetpack connection auth page
4208
	 *
4209
	 * @since 3.9.5
4210
	 *
4211
	 * @param bool $raw If true, URL will not be escaped.
4212
	 * @param bool|string $redirect If true, will redirect back to Jetpack wp-admin landing page after connection.
4213
	 *                              If string, will be a custom redirect.
4214
	 * @param bool|string $from If not false, adds 'from=$from' param to the connect URL.
4215
	 *
4216
	 * @return string Connect URL
4217
	 */
4218
	function build_connect_url( $raw = false, $redirect = false, $from = false ) {
4219
		if ( ! Jetpack_Options::get_option( 'blog_token' ) || ! Jetpack_Options::get_option( 'id' ) ) {
4220
			$url = Jetpack::nonce_url_no_esc( Jetpack::admin_url( 'action=register' ), 'jetpack-register' );
4221
			if( is_network_admin() ) {
4222
			    $url = add_query_arg( 'is_multisite', network_admin_url(
4223
			    'admin.php?page=jetpack-settings' ), $url );
4224
			}
4225
		} else {
4226
			if ( defined( 'JETPACK__GLOTPRESS_LOCALES_PATH' ) && include_once JETPACK__GLOTPRESS_LOCALES_PATH ) {
4227
				$gp_locale = GP_Locales::by_field( 'wp_locale', get_locale() );
4228
			}
4229
4230
			$role = self::translate_current_user_to_role();
4231
			$signed_role = self::sign_role( $role );
4232
4233
			$user = wp_get_current_user();
4234
4235
			$redirect = $redirect ? esc_url_raw( $redirect ) : esc_url_raw( menu_page_url( 'jetpack', false ) );
4236
4237
			if( isset( $_REQUEST['is_multisite'] ) ) {
4238
				$redirect = Jetpack_Network::init()->get_url( 'network_admin_page' );
4239
			}
4240
4241
			$secrets = Jetpack::init()->generate_secrets( 'authorize' );
4242
			@list( $secret ) = explode( ':', $secrets );
4243
4244
			$site_icon = ( function_exists( 'has_site_icon') && has_site_icon() )
4245
				? get_site_icon_url()
4246
				: false;
4247
4248
			$args = urlencode_deep(
4249
				array(
4250
					'response_type' => 'code',
4251
					'client_id'     => Jetpack_Options::get_option( 'id' ),
4252
					'redirect_uri'  => add_query_arg(
4253
						array(
4254
							'action'   => 'authorize',
4255
							'_wpnonce' => wp_create_nonce( "jetpack-authorize_{$role}_{$redirect}" ),
4256
							'redirect' => urlencode( $redirect ),
4257
						),
4258
						menu_page_url( 'jetpack', false )
4259
					),
4260
					'state'         => $user->ID,
4261
					'scope'         => $signed_role,
4262
					'user_email'    => $user->user_email,
4263
					'user_login'    => $user->user_login,
4264
					'is_active'     => Jetpack::is_active(),
4265
					'jp_version'    => JETPACK__VERSION,
4266
					'auth_type'     => 'calypso',
4267
					'secret'        => $secret,
4268
					'locale'        => isset( $gp_locale->slug ) ? $gp_locale->slug : '',
4269
					'blogname'      => get_option( 'blogname' ),
4270
					'site_url'      => site_url(),
4271
					'home_url'      => home_url(),
4272
					'site_icon'     => $site_icon,
4273
				)
4274
			);
4275
4276
			$url = add_query_arg( $args, Jetpack::api_url( 'authorize' ) );
4277
		}
4278
4279
		if ( $from ) {
4280
			$url = add_query_arg( 'from', $from, $url );
4281
		}
4282
4283
		if ( isset( $_GET['calypso_env'] ) ) {
4284
			$url = add_query_arg( 'calypso_env', sanitize_key( $_GET['calypso_env'] ), $url );
4285
		}
4286
4287
		return $raw ? $url : esc_url( $url );
4288
	}
4289
4290
	function build_reconnect_url( $raw = false ) {
4291
		$url = wp_nonce_url( Jetpack::admin_url( 'action=reconnect' ), 'jetpack-reconnect' );
4292
		return $raw ? $url : esc_url( $url );
4293
	}
4294
4295
	public static function admin_url( $args = null ) {
4296
		$args = wp_parse_args( $args, array( 'page' => 'jetpack' ) );
4297
		$url = add_query_arg( $args, admin_url( 'admin.php' ) );
4298
		return $url;
4299
	}
4300
4301
	public static function nonce_url_no_esc( $actionurl, $action = -1, $name = '_wpnonce' ) {
4302
		$actionurl = str_replace( '&amp;', '&', $actionurl );
4303
		return add_query_arg( $name, wp_create_nonce( $action ), $actionurl );
4304
	}
4305
4306
	function dismiss_jetpack_notice() {
4307
4308
		if ( ! isset( $_GET['jetpack-notice'] ) ) {
4309
			return;
4310
		}
4311
4312
		switch( $_GET['jetpack-notice'] ) {
4313
			case 'dismiss':
4314
				if ( check_admin_referer( 'jetpack-deactivate' ) && ! is_plugin_active_for_network( plugin_basename( JETPACK__PLUGIN_DIR . 'jetpack.php' ) ) ) {
4315
4316
					require_once ABSPATH . 'wp-admin/includes/plugin.php';
4317
					deactivate_plugins( JETPACK__PLUGIN_DIR . 'jetpack.php', false, false );
4318
					wp_safe_redirect( admin_url() . 'plugins.php?deactivate=true&plugin_status=all&paged=1&s=' );
4319
				}
4320
				break;
4321 View Code Duplication
			case 'jetpack-manage-opt-out':
4322
4323
				if ( check_admin_referer( 'jetpack_manage_banner_opt_out' ) ) {
4324
					// Don't show the banner again
4325
4326
					Jetpack_Options::update_option( 'dismissed_manage_banner', true );
4327
					// redirect back to the page that had the notice
4328
					if ( wp_get_referer() ) {
4329
						wp_safe_redirect( wp_get_referer() );
4330
					} else {
4331
						// Take me to Jetpack
4332
						wp_safe_redirect( admin_url( 'admin.php?page=jetpack' ) );
4333
					}
4334
				}
4335
				break;
4336 View Code Duplication
			case 'jetpack-protect-multisite-opt-out':
4337
4338
				if ( check_admin_referer( 'jetpack_protect_multisite_banner_opt_out' ) ) {
4339
					// Don't show the banner again
4340
4341
					update_site_option( 'jetpack_dismissed_protect_multisite_banner', true );
4342
					// redirect back to the page that had the notice
4343
					if ( wp_get_referer() ) {
4344
						wp_safe_redirect( wp_get_referer() );
4345
					} else {
4346
						// Take me to Jetpack
4347
						wp_safe_redirect( admin_url( 'admin.php?page=jetpack' ) );
4348
					}
4349
				}
4350
				break;
4351
			case 'jetpack-manage-opt-in':
4352
				if ( check_admin_referer( 'jetpack_manage_banner_opt_in' ) ) {
4353
					// This makes sure that we are redirect to jetpack home so that we can see the Success Message.
4354
4355
					$redirection_url = Jetpack::admin_url();
4356
					remove_action( 'jetpack_pre_activate_module',   array( Jetpack_Admin::init(), 'fix_redirect' ) );
4357
4358
					// Don't redirect form the Jetpack Setting Page
4359
					$referer_parsed = parse_url ( wp_get_referer() );
4360
					// check that we do have a wp_get_referer and the query paramater is set orderwise go to the Jetpack Home
4361
					if ( isset( $referer_parsed['query'] ) && false !== strpos( $referer_parsed['query'], 'page=jetpack_modules' ) ) {
4362
						// Take the user to Jetpack home except when on the setting page
4363
						$redirection_url = wp_get_referer();
4364
						add_action( 'jetpack_pre_activate_module',   array( Jetpack_Admin::init(), 'fix_redirect' ) );
4365
					}
4366
					// Also update the JSON API FULL MANAGEMENT Option
4367
					Jetpack::activate_module( 'manage', false, false );
4368
4369
					// Special Message when option in.
4370
					Jetpack::state( 'optin-manage', 'true' );
4371
					// Activate the Module if not activated already
4372
4373
					// Redirect properly
4374
					wp_safe_redirect( $redirection_url );
4375
4376
				}
4377
				break;
4378
		}
4379
	}
4380
4381
	function debugger_page() {
4382
		nocache_headers();
4383
		if ( ! current_user_can( 'manage_options' ) ) {
4384
			die( '-1' );
4385
		}
4386
		Jetpack_Debugger::jetpack_debug_display_handler();
4387
		exit;
4388
	}
4389
4390
	public static function admin_screen_configure_module( $module_id ) {
4391
4392
		// User that doesn't have 'jetpack_configure_modules' will never end up here since Jetpack Landing Page woun't let them.
4393
		if ( ! in_array( $module_id, Jetpack::get_active_modules() ) && current_user_can( 'manage_options' ) ) {
4394
			if ( has_action( 'display_activate_module_setting_' . $module_id ) ) {
4395
				/**
4396
				 * Fires to diplay a custom module activation screen.
4397
				 *
4398
				 * To add a module actionation screen use Jetpack::module_configuration_activation_screen method.
4399
				 * Example: Jetpack::module_configuration_activation_screen( 'manage', array( $this, 'manage_activate_screen' ) );
4400
				 *
4401
				 * @module manage
4402
				 *
4403
				 * @since 3.8.0
4404
				 *
4405
				 * @param int $module_id Module ID.
4406
				 */
4407
				do_action( 'display_activate_module_setting_' . $module_id );
4408
			} else {
4409
				self::display_activate_module_link( $module_id );
4410
			}
4411
4412
			return false;
4413
		} ?>
4414
4415
		<div id="jp-settings-screen" style="position: relative">
4416
			<h3>
4417
			<?php
4418
				$module = Jetpack::get_module( $module_id );
4419
				echo '<a href="' . Jetpack::admin_url( 'page=jetpack_modules' ) . '">' . __( 'Jetpack by WordPress.com', 'jetpack' ) . '</a> &rarr; ';
4420
				printf( __( 'Configure %s', 'jetpack' ), $module['name'] );
4421
			?>
4422
			</h3>
4423
			<?php
4424
				/**
4425
				 * Fires within the displayed message when a feature configuation is updated.
4426
				 *
4427
				 * @since 3.4.0
4428
				 *
4429
				 * @param int $module_id Module ID.
4430
				 */
4431
				do_action( 'jetpack_notices_update_settings', $module_id );
4432
				/**
4433
				 * Fires when a feature configuation screen is loaded.
4434
				 * The dynamic part of the hook, $module_id, is the module ID.
4435
				 *
4436
				 * @since 1.1.0
4437
				 */
4438
				do_action( 'jetpack_module_configuration_screen_' . $module_id );
4439
			?>
4440
		</div><?php
4441
	}
4442
4443
	/**
4444
	 * Display link to activate the module to see the settings screen.
4445
	 * @param  string $module_id
4446
	 * @return null
4447
	 */
4448
	public static function display_activate_module_link( $module_id ) {
4449
4450
		$info =  Jetpack::get_module( $module_id );
4451
		$extra = '';
4452
		$activate_url = wp_nonce_url(
4453
				Jetpack::admin_url(
4454
					array(
4455
						'page'   => 'jetpack',
4456
						'action' => 'activate',
4457
						'module' => $module_id,
4458
					)
4459
				),
4460
				"jetpack_activate-$module_id"
4461
			);
4462
4463
		?>
4464
4465
		<div class="wrap configure-module">
4466
			<div id="jp-settings-screen">
4467
				<?php
4468
				if ( $module_id == 'json-api' ) {
4469
4470
					$info['name'] = esc_html__( 'Activate Site Management and JSON API', 'jetpack' );
4471
4472
					$activate_url = Jetpack::init()->opt_in_jetpack_manage_url();
4473
4474
					$info['description'] = sprintf( __( 'Manage your multiple Jetpack sites from our centralized dashboard at wordpress.com/sites. <a href="%s" target="_blank">Learn more</a>.', 'jetpack' ), 'https://jetpack.com/support/site-management' );
4475
4476
					// $extra = __( 'To use Site Management, you need to first activate JSON API to allow remote management of your site. ', 'jetpack' );
4477
				} ?>
4478
4479
				<h3><?php echo esc_html( $info['name'] ); ?></h3>
4480
				<div class="narrow">
4481
					<p><?php echo  $info['description']; ?></p>
4482
					<?php if( $extra ) { ?>
4483
					<p><?php echo esc_html( $extra ); ?></p>
4484
					<?php } ?>
4485
					<p>
4486
						<?php
4487
						if( wp_get_referer() ) {
4488
							printf( __( '<a class="button-primary" href="%s">Activate Now</a> or <a href="%s" >return to previous page</a>.', 'jetpack' ) , $activate_url, wp_get_referer() );
4489
						} else {
4490
							printf( __( '<a class="button-primary" href="%s">Activate Now</a>', 'jetpack' ) , $activate_url  );
4491
						} ?>
4492
					</p>
4493
				</div>
4494
4495
			</div>
4496
		</div>
4497
4498
		<?php
4499
	}
4500
4501
	public static function sort_modules( $a, $b ) {
4502
		if ( $a['sort'] == $b['sort'] )
4503
			return 0;
4504
4505
		return ( $a['sort'] < $b['sort'] ) ? -1 : 1;
4506
	}
4507
4508
	function ajax_recheck_ssl() {
4509
		check_ajax_referer( 'recheck-ssl', 'ajax-nonce' );
4510
		$result = Jetpack::permit_ssl( true );
4511
		wp_send_json( array(
4512
			'enabled' => $result,
4513
			'message' => get_transient( 'jetpack_https_test_message' )
4514
		) );
4515
	}
4516
4517
/* Client API */
4518
4519
	/**
4520
	 * Returns the requested Jetpack API URL
4521
	 *
4522
	 * @return string
4523
	 */
4524
	public static function api_url( $relative_url ) {
4525
		return trailingslashit( JETPACK__API_BASE . $relative_url  ) . JETPACK__API_VERSION . '/';
4526
	}
4527
4528
	/**
4529
	 * Some hosts disable the OpenSSL extension and so cannot make outgoing HTTPS requsets
4530
	 */
4531
	public static function fix_url_for_bad_hosts( $url ) {
4532
		if ( 0 !== strpos( $url, 'https://' ) ) {
4533
			return $url;
4534
		}
4535
4536
		switch ( JETPACK_CLIENT__HTTPS ) {
4537
			case 'ALWAYS' :
4538
				return $url;
4539
			case 'NEVER' :
4540
				return set_url_scheme( $url, 'http' );
4541
			// default : case 'AUTO' :
4542
		}
4543
4544
		// we now return the unmodified SSL URL by default, as a security precaution
4545
		return $url;
4546
	}
4547
4548
	/**
4549
	 * Checks to see if the URL is using SSL to connect with Jetpack
4550
	 *
4551
	 * @since 2.3.3
4552
	 * @return boolean
4553
	 */
4554
	public static function permit_ssl( $force_recheck = false ) {
4555
		// Do some fancy tests to see if ssl is being supported
4556
		if ( $force_recheck || false === ( $ssl = get_transient( 'jetpack_https_test' ) ) ) {
4557
			$message = '';
4558
			if ( 'https' !== substr( JETPACK__API_BASE, 0, 5 ) ) {
4559
				$ssl = 0;
4560
			} else {
4561
				switch ( JETPACK_CLIENT__HTTPS ) {
4562
					case 'NEVER':
4563
						$ssl = 0;
4564
						$message = __( 'JETPACK_CLIENT__HTTPS is set to NEVER', 'jetpack' );
4565
						break;
4566
					case 'ALWAYS':
4567
					case 'AUTO':
4568
					default:
4569
						$ssl = 1;
4570
						break;
4571
				}
4572
4573
				// If it's not 'NEVER', test to see
4574
				if ( $ssl ) {
4575
					if ( ! wp_http_supports( array( 'ssl' => true ) ) ) {
4576
						$ssl = 0;
4577
						$message = __( 'WordPress reports no SSL support', 'jetpack' );
4578
					} else {
4579
						$response = wp_remote_get( JETPACK__API_BASE . 'test/1/' );
4580
						if ( is_wp_error( $response ) ) {
4581
							$ssl = 0;
4582
							$message = __( 'WordPress reports no SSL support', 'jetpack' );
4583
						} elseif ( 'OK' !== wp_remote_retrieve_body( $response ) ) {
4584
							$ssl = 0;
4585
							$message = __( 'Response was not OK: ', 'jetpack' ) . wp_remote_retrieve_body( $response );
4586
						}
4587
					}
4588
				}
4589
			}
4590
			set_transient( 'jetpack_https_test', $ssl, DAY_IN_SECONDS );
4591
			set_transient( 'jetpack_https_test_message', $message, DAY_IN_SECONDS );
4592
		}
4593
4594
		return (bool) $ssl;
4595
	}
4596
4597
	/*
4598
	 * Displays an admin_notice, alerting the user to their JETPACK_CLIENT__HTTPS constant being 'AUTO' but SSL isn't working.
4599
	 */
4600
	public function alert_auto_ssl_fail() {
4601
		if ( ! current_user_can( 'manage_options' ) )
4602
			return;
4603
4604
		$ajax_nonce = wp_create_nonce( 'recheck-ssl' );
4605
		?>
4606
4607
		<div id="jetpack-ssl-warning" class="error jp-identity-crisis">
4608
			<div class="jp-banner__content">
4609
				<h2><?php _e( 'Outbound HTTPS not working', 'jetpack' ); ?></h2>
4610
				<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>
4611
				<p>
4612
					<?php _e( 'Jetpack will re-test for HTTPS support once a day, but you can click here to try again immediately: ', 'jetpack' ); ?>
4613
					<a href="#" id="jetpack-recheck-ssl-button"><?php _e( 'Try again', 'jetpack' ); ?></a>
4614
					<span id="jetpack-recheck-ssl-output"><?php echo get_transient( 'jetpack_https_test_message' ); ?></span>
4615
				</p>
4616
				<p>
4617
					<?php printf( __( 'For more help, try our <a href="%1$s">connection debugger</a> or <a href="%2$s" target="_blank">troubleshooting tips</a>.', 'jetpack' ),
4618
							esc_url( Jetpack::admin_url( array( 'page' => 'jetpack-debugger' )  ) ),
4619
							esc_url( 'https://jetpack.com/support/getting-started-with-jetpack/troubleshooting-tips/' ) ); ?>
4620
				</p>
4621
			</div>
4622
		</div>
4623
		<style>
4624
			#jetpack-recheck-ssl-output { margin-left: 5px; color: red; }
4625
		</style>
4626
		<script type="text/javascript">
4627
			jQuery( document ).ready( function( $ ) {
4628
				$( '#jetpack-recheck-ssl-button' ).click( function( e ) {
4629
					var $this = $( this );
4630
					$this.html( <?php echo json_encode( __( 'Checking', 'jetpack' ) ); ?> );
4631
					$( '#jetpack-recheck-ssl-output' ).html( '' );
4632
					e.preventDefault();
4633
					var data = { action: 'jetpack-recheck-ssl', 'ajax-nonce': '<?php echo $ajax_nonce; ?>' };
4634
					$.post( ajaxurl, data )
4635
					  .done( function( response ) {
4636
					  	if ( response.enabled ) {
4637
					  		$( '#jetpack-ssl-warning' ).hide();
4638
					  	} else {
4639
					  		this.html( <?php echo json_encode( __( 'Try again', 'jetpack' ) ); ?> );
4640
					  		$( '#jetpack-recheck-ssl-output' ).html( 'SSL Failed: ' + response.message );
4641
					  	}
4642
					  }.bind( $this ) );
4643
				} );
4644
			} );
4645
		</script>
4646
4647
		<?php
4648
	}
4649
4650
	/**
4651
	 * Returns the Jetpack XML-RPC API
4652
	 *
4653
	 * @return string
4654
	 */
4655
	public static function xmlrpc_api_url() {
4656
		$base = preg_replace( '#(https?://[^?/]+)(/?.*)?$#', '\\1', JETPACK__API_BASE );
4657
		return untrailingslashit( $base ) . '/xmlrpc.php';
4658
	}
4659
4660
	/**
4661
	 * Creates two secret tokens and the end of life timestamp for them.
4662
	 *
4663
	 * Note these tokens are unique per call, NOT static per site for connecting.
4664
	 *
4665
	 * @since 2.6
4666
	 * @return array
4667
	 */
4668
	public function generate_secrets( $action, $exp = 600 ) {
4669
	    $secret = wp_generate_password( 32, false ) // secret_1
4670
	    		. ':' . wp_generate_password( 32, false ) // secret_2
4671
	    		. ':' . ( time() + $exp ) // eol ( End of Life )
4672
	    		. ':' . get_current_user_id(); // ties the secrets to the current user
4673
		Jetpack_Options::update_option( $action, $secret );
4674
	    return Jetpack_Options::get_option( $action );
4675
	}
4676
4677
	/**
4678
	 * Builds the timeout limit for queries talking with the wpcom servers.
4679
	 *
4680
	 * Based on local php max_execution_time in php.ini
4681
	 *
4682
	 * @since 2.6
4683
	 * @return int
4684
	 **/
4685
	public function get_remote_query_timeout_limit() {
4686
	    $timeout = (int) ini_get( 'max_execution_time' );
4687
	    if ( ! $timeout ) // Ensure exec time set in php.ini
4688
		$timeout = 30;
4689
	    return intval( $timeout / 2 );
4690
	}
4691
4692
4693
	/**
4694
	 * Takes the response from the Jetpack register new site endpoint and
4695
	 * verifies it worked properly.
4696
	 *
4697
	 * @since 2.6
4698
	 * @return true or Jetpack_Error
4699
	 **/
4700
	public function validate_remote_register_response( $response ) {
4701
	    	if ( is_wp_error( $response ) ) {
4702
			return new Jetpack_Error( 'register_http_request_failed', $response->get_error_message() );
4703
		}
4704
4705
		$code   = wp_remote_retrieve_response_code( $response );
4706
		$entity = wp_remote_retrieve_body( $response );
4707
		if ( $entity )
4708
			$json = json_decode( $entity );
4709
		else
4710
			$json = false;
4711
4712
		$code_type = intval( $code / 100 );
4713
		if ( 5 == $code_type ) {
4714
			return new Jetpack_Error( 'wpcom_5??', sprintf( __( 'Error Details: %s', 'jetpack' ), $code ), $code );
4715
		} elseif ( 408 == $code ) {
4716
			return new Jetpack_Error( 'wpcom_408', sprintf( __( 'Error Details: %s', 'jetpack' ), $code ), $code );
4717
		} elseif ( ! empty( $json->error ) ) {
4718
			$error_description = isset( $json->error_description ) ? sprintf( __( 'Error Details: %s', 'jetpack' ), (string) $json->error_description ) : '';
4719
			return new Jetpack_Error( (string) $json->error, $error_description, $code );
4720
		} elseif ( 200 != $code ) {
4721
			return new Jetpack_Error( 'wpcom_bad_response', sprintf( __( 'Error Details: %s', 'jetpack' ), $code ), $code );
4722
		}
4723
4724
		// Jetpack ID error block
4725
		if ( empty( $json->jetpack_id ) ) {
4726
			return new Jetpack_Error( 'jetpack_id', sprintf( __( 'Error Details: Jetpack ID is empty. Do not publicly post this error message! %s', 'jetpack' ), $entity ), $entity );
4727
		} elseif ( ! is_scalar( $json->jetpack_id ) ) {
4728
			return new Jetpack_Error( 'jetpack_id', sprintf( __( 'Error Details: Jetpack ID is not a scalar. Do not publicly post this error message! %s', 'jetpack' ) , $entity ), $entity );
4729
		} elseif ( preg_match( '/[^0-9]/', $json->jetpack_id ) ) {
4730
			return new Jetpack_Error( 'jetpack_id', sprintf( __( 'Error Details: Jetpack ID begins with a numeral. Do not publicly post this error message! %s', 'jetpack' ) , $entity ), $entity );
4731
		}
4732
4733
	    return true;
4734
	}
4735
	/**
4736
	 * @return bool|WP_Error
4737
	 */
4738
	public static function register() {
4739
		add_action( 'pre_update_jetpack_option_register', array( 'Jetpack_Options', 'delete_option' ) );
4740
		$secrets = Jetpack::init()->generate_secrets( 'register' );
4741
4742
		@list( $secret_1, $secret_2, $secret_eol ) = explode( ':', $secrets );
4743 View Code Duplication
		if ( empty( $secret_1 ) || empty( $secret_2 ) || empty( $secret_eol ) || $secret_eol < time() ) {
4744
			return new Jetpack_Error( 'missing_secrets' );
4745
		}
4746
4747
		$timeout = Jetpack::init()->get_remote_query_timeout_limit();
4748
4749
		$gmt_offset = get_option( 'gmt_offset' );
4750
		if ( ! $gmt_offset ) {
4751
			$gmt_offset = 0;
4752
		}
4753
4754
		$stats_options = get_option( 'stats_options' );
4755
		$stats_id = isset($stats_options['blog_id']) ? $stats_options['blog_id'] : null;
4756
4757
		$args = array(
4758
			'method'  => 'POST',
4759
			'body'    => array(
4760
				'siteurl'         => site_url(),
4761
				'home'            => home_url(),
4762
				'gmt_offset'      => $gmt_offset,
4763
				'timezone_string' => (string) get_option( 'timezone_string' ),
4764
				'site_name'       => (string) get_option( 'blogname' ),
4765
				'secret_1'        => $secret_1,
4766
				'secret_2'        => $secret_2,
4767
				'site_lang'       => get_locale(),
4768
				'timeout'         => $timeout,
4769
				'stats_id'        => $stats_id,
4770
				'state'           => get_current_user_id(),
4771
			),
4772
			'headers' => array(
4773
				'Accept' => 'application/json',
4774
			),
4775
			'timeout' => $timeout,
4776
		);
4777
		$response = Jetpack_Client::_wp_remote_request( Jetpack::fix_url_for_bad_hosts( Jetpack::api_url( 'register' ) ), $args, true );
4778
4779
4780
		// Make sure the response is valid and does not contain any Jetpack errors
4781
		$valid_response = Jetpack::init()->validate_remote_register_response( $response );
4782
		if( is_wp_error( $valid_response ) || !$valid_response ) {
4783
		    return $valid_response;
4784
		}
4785
4786
		// Grab the response values to work with
4787
		$code   = wp_remote_retrieve_response_code( $response );
4788
		$entity = wp_remote_retrieve_body( $response );
4789
4790
		if ( $entity )
4791
			$json = json_decode( $entity );
4792
		else
4793
			$json = false;
4794
4795 View Code Duplication
		if ( empty( $json->jetpack_secret ) || ! is_string( $json->jetpack_secret ) )
4796
			return new Jetpack_Error( 'jetpack_secret', '', $code );
4797
4798
		if ( isset( $json->jetpack_public ) ) {
4799
			$jetpack_public = (int) $json->jetpack_public;
4800
		} else {
4801
			$jetpack_public = false;
4802
		}
4803
4804
		Jetpack_Options::update_options(
4805
			array(
4806
				'id'         => (int)    $json->jetpack_id,
4807
				'blog_token' => (string) $json->jetpack_secret,
4808
				'public'     => $jetpack_public,
4809
			)
4810
		);
4811
4812
		/**
4813
		 * Fires when a site is registered on WordPress.com.
4814
		 *
4815
		 * @since 3.7.0
4816
		 *
4817
		 * @param int $json->jetpack_id Jetpack Blog ID.
4818
		 * @param string $json->jetpack_secret Jetpack Blog Token.
4819
		 * @param int|bool $jetpack_public Is the site public.
4820
		 */
4821
		do_action( 'jetpack_site_registered', $json->jetpack_id, $json->jetpack_secret, $jetpack_public );
4822
4823
		// Initialize Jump Start for the first and only time.
4824
		if ( ! Jetpack_Options::get_option( 'jumpstart' ) ) {
4825
			Jetpack_Options::update_option( 'jumpstart', 'new_connection' );
4826
4827
			$jetpack = Jetpack::init();
4828
4829
			$jetpack->stat( 'jumpstart', 'unique-views' );
4830
			$jetpack->do_stats( 'server_side' );
4831
		};
4832
4833
		return true;
4834
	}
4835
4836
	/**
4837
	 * If the db version is showing something other that what we've got now, bump it to current.
4838
	 *
4839
	 * @return bool: True if the option was incorrect and updated, false if nothing happened.
4840
	 */
4841
	public static function maybe_set_version_option() {
4842
		list( $version ) = explode( ':', Jetpack_Options::get_option( 'version' ) );
4843
		if ( JETPACK__VERSION != $version ) {
4844
			Jetpack_Options::update_option( 'version', JETPACK__VERSION . ':' . time() );
4845
4846
			if ( version_compare( JETPACK__VERSION, $version, '>' ) ) {
4847
				/** This action is documented in class.jetpack.php */
4848
				do_action( 'updating_jetpack_version', JETPACK__VERSION, $version );
4849
			}
4850
4851
			return true;
4852
		}
4853
		return false;
4854
	}
4855
4856
/* Client Server API */
4857
4858
	/**
4859
	 * Loads the Jetpack XML-RPC client
4860
	 */
4861
	public static function load_xml_rpc_client() {
4862
		require_once ABSPATH . WPINC . '/class-IXR.php';
4863
		require_once JETPACK__PLUGIN_DIR . 'class.jetpack-ixr-client.php';
4864
	}
4865
4866
	function verify_xml_rpc_signature() {
4867
		if ( $this->xmlrpc_verification ) {
4868
			return $this->xmlrpc_verification;
4869
		}
4870
4871
		// It's not for us
4872
		if ( ! isset( $_GET['token'] ) || empty( $_GET['signature'] ) ) {
4873
			return false;
4874
		}
4875
4876
		@list( $token_key, $version, $user_id ) = explode( ':', $_GET['token'] );
4877
		if (
4878
			empty( $token_key )
4879
		||
4880
			empty( $version ) || strval( JETPACK__API_VERSION ) !== $version
4881
		) {
4882
			return false;
4883
		}
4884
4885
		if ( '0' === $user_id ) {
4886
			$token_type = 'blog';
4887
			$user_id = 0;
4888
		} else {
4889
			$token_type = 'user';
4890
			if ( empty( $user_id ) || ! ctype_digit( $user_id ) ) {
4891
				return false;
4892
			}
4893
			$user_id = (int) $user_id;
4894
4895
			$user = new WP_User( $user_id );
4896
			if ( ! $user || ! $user->exists() ) {
4897
				return false;
4898
			}
4899
		}
4900
4901
		$token = Jetpack_Data::get_access_token( $user_id );
4902
		if ( ! $token ) {
4903
			return false;
4904
		}
4905
4906
		$token_check = "$token_key.";
4907
		if ( ! hash_equals( substr( $token->secret, 0, strlen( $token_check ) ), $token_check ) ) {
4908
			return false;
4909
		}
4910
4911
		require_once JETPACK__PLUGIN_DIR . 'class.jetpack-signature.php';
4912
4913
		$jetpack_signature = new Jetpack_Signature( $token->secret, (int) Jetpack_Options::get_option( 'time_diff' ) );
4914
		if ( isset( $_POST['_jetpack_is_multipart'] ) ) {
4915
			$post_data   = $_POST;
4916
			$file_hashes = array();
4917
			foreach ( $post_data as $post_data_key => $post_data_value ) {
4918
				if ( 0 !== strpos( $post_data_key, '_jetpack_file_hmac_' ) ) {
4919
					continue;
4920
				}
4921
				$post_data_key = substr( $post_data_key, strlen( '_jetpack_file_hmac_' ) );
4922
				$file_hashes[$post_data_key] = $post_data_value;
4923
			}
4924
4925
			foreach ( $file_hashes as $post_data_key => $post_data_value ) {
4926
				unset( $post_data["_jetpack_file_hmac_{$post_data_key}"] );
4927
				$post_data[$post_data_key] = $post_data_value;
4928
			}
4929
4930
			ksort( $post_data );
4931
4932
			$body = http_build_query( stripslashes_deep( $post_data ) );
4933
		} elseif ( is_null( $this->HTTP_RAW_POST_DATA ) ) {
4934
			$body = file_get_contents( 'php://input' );
4935
		} else {
4936
			$body = null;
4937
		}
4938
		$signature = $jetpack_signature->sign_current_request(
4939
			array( 'body' => is_null( $body ) ? $this->HTTP_RAW_POST_DATA : $body, )
4940
		);
4941
4942
		if ( ! $signature ) {
4943
			return false;
4944
		} else if ( is_wp_error( $signature ) ) {
4945
			return $signature;
4946
		} else if ( ! hash_equals( $signature, $_GET['signature'] ) ) {
4947
			return false;
4948
		}
4949
4950
		$timestamp = (int) $_GET['timestamp'];
4951
		$nonce     = stripslashes( (string) $_GET['nonce'] );
4952
4953
		if ( ! $this->add_nonce( $timestamp, $nonce ) ) {
4954
			return false;
4955
		}
4956
4957
		$this->xmlrpc_verification = array(
4958
			'type'    => $token_type,
4959
			'user_id' => $token->external_user_id,
4960
		);
4961
4962
		return $this->xmlrpc_verification;
4963
	}
4964
4965
	/**
4966
	 * Authenticates XML-RPC and other requests from the Jetpack Server
4967
	 */
4968
	function authenticate_jetpack( $user, $username, $password ) {
4969
		if ( is_a( $user, 'WP_User' ) ) {
4970
			return $user;
4971
		}
4972
4973
		$token_details = $this->verify_xml_rpc_signature();
4974
4975
		if ( ! $token_details || is_wp_error( $token_details ) ) {
4976
			return $user;
4977
		}
4978
4979
		if ( 'user' !== $token_details['type'] ) {
4980
			return $user;
4981
		}
4982
4983
		if ( ! $token_details['user_id'] ) {
4984
			return $user;
4985
		}
4986
4987
		nocache_headers();
4988
4989
		return new WP_User( $token_details['user_id'] );
4990
	}
4991
4992
	function add_nonce( $timestamp, $nonce ) {
4993
		global $wpdb;
4994
		static $nonces_used_this_request = array();
4995
4996
		if ( isset( $nonces_used_this_request["$timestamp:$nonce"] ) ) {
4997
			return $nonces_used_this_request["$timestamp:$nonce"];
4998
		}
4999
5000
		// This should always have gone through Jetpack_Signature::sign_request() first to check $timestamp an $nonce
5001
		$timestamp = (int) $timestamp;
5002
		$nonce     = esc_sql( $nonce );
5003
5004
		// Raw query so we can avoid races: add_option will also update
5005
		$show_errors = $wpdb->show_errors( false );
5006
5007
		$old_nonce = $wpdb->get_row(
5008
			$wpdb->prepare( "SELECT * FROM `$wpdb->options` WHERE option_name = %s", "jetpack_nonce_{$timestamp}_{$nonce}" )
5009
		);
5010
5011
		if ( is_null( $old_nonce ) ) {
5012
			$return = $wpdb->query(
5013
				$wpdb->prepare(
5014
					"INSERT INTO `$wpdb->options` (`option_name`, `option_value`, `autoload`) VALUES (%s, %s, %s)",
5015
					"jetpack_nonce_{$timestamp}_{$nonce}",
5016
					time(),
5017
					'no'
5018
				)
5019
			);
5020
		} else {
5021
			$return = false;
5022
		}
5023
5024
		$wpdb->show_errors( $show_errors );
5025
5026
		$nonces_used_this_request["$timestamp:$nonce"] = $return;
5027
5028
		return $return;
5029
	}
5030
5031
	/**
5032
	 * In some setups, $HTTP_RAW_POST_DATA can be emptied during some IXR_Server paths since it is passed by reference to various methods.
5033
	 * Capture it here so we can verify the signature later.
5034
	 */
5035
	function xmlrpc_methods( $methods ) {
5036
		$this->HTTP_RAW_POST_DATA = $GLOBALS['HTTP_RAW_POST_DATA'];
5037
		return $methods;
5038
	}
5039
5040
	function public_xmlrpc_methods( $methods ) {
5041
		if ( array_key_exists( 'wp.getOptions', $methods ) ) {
5042
			$methods['wp.getOptions'] = array( $this, 'jetpack_getOptions' );
5043
		}
5044
		return $methods;
5045
	}
5046
5047
	function jetpack_getOptions( $args ) {
5048
		global $wp_xmlrpc_server;
5049
5050
		$wp_xmlrpc_server->escape( $args );
5051
5052
		$username	= $args[1];
5053
		$password	= $args[2];
5054
5055
		if ( !$user = $wp_xmlrpc_server->login($username, $password) ) {
5056
			return $wp_xmlrpc_server->error;
5057
		}
5058
5059
		$options = array();
5060
		$user_data = $this->get_connected_user_data();
5061
		if ( is_array( $user_data ) ) {
5062
			$options['jetpack_user_id'] = array(
5063
				'desc'          => __( 'The WP.com user ID of the connected user', 'jetpack' ),
5064
				'readonly'      => true,
5065
				'value'         => $user_data['ID'],
5066
			);
5067
			$options['jetpack_user_login'] = array(
5068
				'desc'          => __( 'The WP.com username of the connected user', 'jetpack' ),
5069
				'readonly'      => true,
5070
				'value'         => $user_data['login'],
5071
			);
5072
			$options['jetpack_user_email'] = array(
5073
				'desc'          => __( 'The WP.com user email of the connected user', 'jetpack' ),
5074
				'readonly'      => true,
5075
				'value'         => $user_data['email'],
5076
			);
5077
			$options['jetpack_user_site_count'] = array(
5078
				'desc'          => __( 'The number of sites of the connected WP.com user', 'jetpack' ),
5079
				'readonly'      => true,
5080
				'value'         => $user_data['site_count'],
5081
			);
5082
		}
5083
		$wp_xmlrpc_server->blog_options = array_merge( $wp_xmlrpc_server->blog_options, $options );
5084
		$args = stripslashes_deep( $args );
5085
		return $wp_xmlrpc_server->wp_getOptions( $args );
5086
	}
5087
5088
	function xmlrpc_options( $options ) {
5089
		$jetpack_client_id = false;
5090
		if ( self::is_active() ) {
5091
			$jetpack_client_id = Jetpack_Options::get_option( 'id' );
5092
		}
5093
		$options['jetpack_version'] = array(
5094
				'desc'          => __( 'Jetpack Plugin Version', 'jetpack' ),
5095
				'readonly'      => true,
5096
				'value'         => JETPACK__VERSION,
5097
		);
5098
5099
		$options['jetpack_client_id'] = array(
5100
				'desc'          => __( 'The Client ID/WP.com Blog ID of this site', 'jetpack' ),
5101
				'readonly'      => true,
5102
				'value'         => $jetpack_client_id,
5103
		);
5104
		return $options;
5105
	}
5106
5107
	public static function clean_nonces( $all = false ) {
5108
		global $wpdb;
5109
5110
		$sql = "DELETE FROM `$wpdb->options` WHERE `option_name` LIKE %s";
5111
		if ( method_exists ( $wpdb , 'esc_like' ) ) {
5112
			$sql_args = array( $wpdb->esc_like( 'jetpack_nonce_' ) . '%' );
5113
		} else {
5114
			$sql_args = array( like_escape( 'jetpack_nonce_' ) . '%' );
5115
		}
5116
5117
		if ( true !== $all ) {
5118
			$sql .= ' AND CAST( `option_value` AS UNSIGNED ) < %d';
5119
			$sql_args[] = time() - 3600;
5120
		}
5121
5122
		$sql .= ' ORDER BY `option_id` LIMIT 100';
5123
5124
		$sql = $wpdb->prepare( $sql, $sql_args );
5125
5126
		for ( $i = 0; $i < 1000; $i++ ) {
5127
			if ( ! $wpdb->query( $sql ) ) {
5128
				break;
5129
			}
5130
		}
5131
	}
5132
5133
	/**
5134
	 * State is passed via cookies from one request to the next, but never to subsequent requests.
5135
	 * SET: state( $key, $value );
5136
	 * GET: $value = state( $key );
5137
	 *
5138
	 * @param string $key
5139
	 * @param string $value
5140
	 * @param bool $restate private
5141
	 */
5142
	public static function state( $key = null, $value = null, $restate = false ) {
5143
		static $state = array();
5144
		static $path, $domain;
5145
		if ( ! isset( $path ) ) {
5146
			require_once( ABSPATH . 'wp-admin/includes/plugin.php' );
5147
			$admin_url = Jetpack::admin_url();
5148
			$bits      = parse_url( $admin_url );
5149
5150
			if ( is_array( $bits ) ) {
5151
				$path   = ( isset( $bits['path'] ) ) ? dirname( $bits['path'] ) : null;
5152
				$domain = ( isset( $bits['host'] ) ) ? $bits['host'] : null;
5153
			} else {
5154
				$path = $domain = null;
5155
			}
5156
		}
5157
5158
		// Extract state from cookies and delete cookies
5159
		if ( isset( $_COOKIE[ 'jetpackState' ] ) && is_array( $_COOKIE[ 'jetpackState' ] ) ) {
5160
			$yum = $_COOKIE[ 'jetpackState' ];
5161
			unset( $_COOKIE[ 'jetpackState' ] );
5162
			foreach ( $yum as $k => $v ) {
5163
				if ( strlen( $v ) )
5164
					$state[ $k ] = $v;
5165
				setcookie( "jetpackState[$k]", false, 0, $path, $domain );
5166
			}
5167
		}
5168
5169
		if ( $restate ) {
5170
			foreach ( $state as $k => $v ) {
5171
				setcookie( "jetpackState[$k]", $v, 0, $path, $domain );
5172
			}
5173
			return;
5174
		}
5175
5176
		// Get a state variable
5177
		if ( isset( $key ) && ! isset( $value ) ) {
5178
			if ( array_key_exists( $key, $state ) )
5179
				return $state[ $key ];
5180
			return null;
5181
		}
5182
5183
		// Set a state variable
5184
		if ( isset ( $key ) && isset( $value ) ) {
5185
			if( is_array( $value ) && isset( $value[0] ) ) {
5186
				$value = $value[0];
5187
			}
5188
			$state[ $key ] = $value;
5189
			setcookie( "jetpackState[$key]", $value, 0, $path, $domain );
5190
		}
5191
	}
5192
5193
	public static function restate() {
5194
		Jetpack::state( null, null, true );
5195
	}
5196
5197
	public static function check_privacy( $file ) {
5198
		static $is_site_publicly_accessible = null;
5199
5200
		if ( is_null( $is_site_publicly_accessible ) ) {
5201
			$is_site_publicly_accessible = false;
5202
5203
			Jetpack::load_xml_rpc_client();
5204
			$rpc = new Jetpack_IXR_Client();
5205
5206
			$success = $rpc->query( 'jetpack.isSitePubliclyAccessible', home_url() );
5207
			if ( $success ) {
5208
				$response = $rpc->getResponse();
5209
				if ( $response ) {
5210
					$is_site_publicly_accessible = true;
5211
				}
5212
			}
5213
5214
			Jetpack_Options::update_option( 'public', (int) $is_site_publicly_accessible );
5215
		}
5216
5217
		if ( $is_site_publicly_accessible ) {
5218
			return;
5219
		}
5220
5221
		$module_slug = self::get_module_slug( $file );
5222
5223
		$privacy_checks = Jetpack::state( 'privacy_checks' );
5224
		if ( ! $privacy_checks ) {
5225
			$privacy_checks = $module_slug;
5226
		} else {
5227
			$privacy_checks .= ",$module_slug";
5228
		}
5229
5230
		Jetpack::state( 'privacy_checks', $privacy_checks );
5231
	}
5232
5233
	/**
5234
	 * Helper method for multicall XMLRPC.
5235
	 */
5236
	public static function xmlrpc_async_call() {
5237
		global $blog_id;
5238
		static $clients = array();
5239
5240
		$client_blog_id = is_multisite() ? $blog_id : 0;
5241
5242
		if ( ! isset( $clients[$client_blog_id] ) ) {
5243
			Jetpack::load_xml_rpc_client();
5244
			$clients[$client_blog_id] = new Jetpack_IXR_ClientMulticall( array( 'user_id' => JETPACK_MASTER_USER, ) );
5245
			if ( function_exists( 'ignore_user_abort' ) ) {
5246
				ignore_user_abort( true );
5247
			}
5248
			add_action( 'shutdown', array( 'Jetpack', 'xmlrpc_async_call' ) );
5249
		}
5250
5251
		$args = func_get_args();
5252
5253
		if ( ! empty( $args[0] ) ) {
5254
			call_user_func_array( array( $clients[$client_blog_id], 'addCall' ), $args );
5255
		} elseif ( is_multisite() ) {
5256
			foreach ( $clients as $client_blog_id => $client ) {
5257
				if ( ! $client_blog_id || empty( $client->calls ) ) {
5258
					continue;
5259
				}
5260
5261
				$switch_success = switch_to_blog( $client_blog_id, true );
5262
				if ( ! $switch_success ) {
5263
					continue;
5264
				}
5265
5266
				flush();
5267
				$client->query();
5268
5269
				restore_current_blog();
5270
			}
5271
		} else {
5272
			if ( isset( $clients[0] ) && ! empty( $clients[0]->calls ) ) {
5273
				flush();
5274
				$clients[0]->query();
5275
			}
5276
		}
5277
	}
5278
5279
	public static function staticize_subdomain( $url ) {
5280
5281
		// Extract hostname from URL
5282
		$host = parse_url( $url, PHP_URL_HOST );
5283
5284
		// Explode hostname on '.'
5285
		$exploded_host = explode( '.', $host );
5286
5287
		// Retrieve the name and TLD
5288
		if ( count( $exploded_host ) > 1 ) {
5289
			$name = $exploded_host[ count( $exploded_host ) - 2 ];
5290
			$tld = $exploded_host[ count( $exploded_host ) - 1 ];
5291
			// Rebuild domain excluding subdomains
5292
			$domain = $name . '.' . $tld;
5293
		} else {
5294
			$domain = $host;
5295
		}
5296
		// Array of Automattic domains
5297
		$domain_whitelist = array( 'wordpress.com', 'wp.com' );
5298
5299
		// Return $url if not an Automattic domain
5300
		if ( ! in_array( $domain, $domain_whitelist ) ) {
5301
			return $url;
5302
		}
5303
5304
		if ( is_ssl() ) {
5305
			return preg_replace( '|https?://[^/]++/|', 'https://s-ssl.wordpress.com/', $url );
5306
		}
5307
5308
		srand( crc32( basename( $url ) ) );
5309
		$static_counter = rand( 0, 2 );
5310
		srand(); // this resets everything that relies on this, like array_rand() and shuffle()
5311
5312
		return preg_replace( '|://[^/]+?/|', "://s$static_counter.wp.com/", $url );
5313
	}
5314
5315
/* JSON API Authorization */
5316
5317
	/**
5318
	 * Handles the login action for Authorizing the JSON API
5319
	 */
5320
	function login_form_json_api_authorization() {
5321
		$this->verify_json_api_authorization_request();
5322
5323
		add_action( 'wp_login', array( &$this, 'store_json_api_authorization_token' ), 10, 2 );
5324
5325
		add_action( 'login_message', array( &$this, 'login_message_json_api_authorization' ) );
5326
		add_action( 'login_form', array( &$this, 'preserve_action_in_login_form_for_json_api_authorization' ) );
5327
		add_filter( 'site_url', array( &$this, 'post_login_form_to_signed_url' ), 10, 3 );
5328
	}
5329
5330
	// Make sure the login form is POSTed to the signed URL so we can reverify the request
5331
	function post_login_form_to_signed_url( $url, $path, $scheme ) {
5332
		if ( 'wp-login.php' !== $path || ( 'login_post' !== $scheme && 'login' !== $scheme ) ) {
5333
			return $url;
5334
		}
5335
5336
		$parsed_url = parse_url( $url );
5337
		$url = strtok( $url, '?' );
5338
		$url = "$url?{$_SERVER['QUERY_STRING']}";
5339
		if ( ! empty( $parsed_url['query'] ) )
5340
			$url .= "&{$parsed_url['query']}";
5341
5342
		return $url;
5343
	}
5344
5345
	// Make sure the POSTed request is handled by the same action
5346
	function preserve_action_in_login_form_for_json_api_authorization() {
5347
		echo "<input type='hidden' name='action' value='jetpack_json_api_authorization' />\n";
5348
		echo "<input type='hidden' name='jetpack_json_api_original_query' value='" . esc_url( set_url_scheme( $_SERVER['HTTP_HOST'] . $_SERVER['REQUEST_URI'] ) ) . "' />\n";
5349
	}
5350
5351
	// If someone logs in to approve API access, store the Access Code in usermeta
5352
	function store_json_api_authorization_token( $user_login, $user ) {
5353
		add_filter( 'login_redirect', array( &$this, 'add_token_to_login_redirect_json_api_authorization' ), 10, 3 );
5354
		add_filter( 'allowed_redirect_hosts', array( &$this, 'allow_wpcom_public_api_domain' ) );
5355
		$token = wp_generate_password( 32, false );
5356
		update_user_meta( $user->ID, 'jetpack_json_api_' . $this->json_api_authorization_request['client_id'], $token );
5357
	}
5358
5359
	// Add public-api.wordpress.com to the safe redirect whitelist - only added when someone allows API access
5360
	function allow_wpcom_public_api_domain( $domains ) {
5361
		$domains[] = 'public-api.wordpress.com';
5362
		return $domains;
5363
	}
5364
5365
	// Add the Access Code details to the public-api.wordpress.com redirect
5366
	function add_token_to_login_redirect_json_api_authorization( $redirect_to, $original_redirect_to, $user ) {
5367
		return add_query_arg(
5368
			urlencode_deep(
5369
				array(
5370
					'jetpack-code'    => get_user_meta( $user->ID, 'jetpack_json_api_' . $this->json_api_authorization_request['client_id'], true ),
5371
					'jetpack-user-id' => (int) $user->ID,
5372
					'jetpack-state'   => $this->json_api_authorization_request['state'],
5373
				)
5374
			),
5375
			$redirect_to
5376
		);
5377
	}
5378
5379
	// Verifies the request by checking the signature
5380
	function verify_json_api_authorization_request() {
5381
		require_once JETPACK__PLUGIN_DIR . 'class.jetpack-signature.php';
5382
5383
		$token = Jetpack_Data::get_access_token( JETPACK_MASTER_USER );
5384
		if ( ! $token || empty( $token->secret ) ) {
5385
			wp_die( __( 'You must connect your Jetpack plugin to WordPress.com to use this feature.' , 'jetpack' ) );
5386
		}
5387
5388
		$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' );
5389
5390
		$jetpack_signature = new Jetpack_Signature( $token->secret, (int) Jetpack_Options::get_option( 'time_diff' ) );
5391
5392
		if ( isset( $_POST['jetpack_json_api_original_query'] ) ) {
5393
			$signature = $jetpack_signature->sign_request( $_GET['token'], $_GET['timestamp'], $_GET['nonce'], '', 'GET', $_POST['jetpack_json_api_original_query'], null, true );
5394
		} else {
5395
			$signature = $jetpack_signature->sign_current_request( array( 'body' => null, 'method' => 'GET' ) );
5396
		}
5397
5398
		if ( ! $signature ) {
5399
			wp_die( $die_error );
5400
		} else if ( is_wp_error( $signature ) ) {
5401
			wp_die( $die_error );
5402
		} else if ( ! hash_equals( $signature, $_GET['signature'] ) ) {
5403
			if ( is_ssl() ) {
5404
				// 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
5405
				$signature = $jetpack_signature->sign_current_request( array( 'scheme' => 'http', 'body' => null, 'method' => 'GET' ) );
5406
				if ( ! $signature || is_wp_error( $signature ) || ! hash_equals( $signature, $_GET['signature'] ) ) {
5407
					wp_die( $die_error );
5408
				}
5409
			} else {
5410
				wp_die( $die_error );
5411
			}
5412
		}
5413
5414
		$timestamp = (int) $_GET['timestamp'];
5415
		$nonce     = stripslashes( (string) $_GET['nonce'] );
5416
5417
		if ( ! $this->add_nonce( $timestamp, $nonce ) ) {
5418
			// De-nonce the nonce, at least for 5 minutes.
5419
			// 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)
5420
			$old_nonce_time = get_option( "jetpack_nonce_{$timestamp}_{$nonce}" );
5421
			if ( $old_nonce_time < time() - 300 ) {
5422
				wp_die( __( 'The authorization process expired.  Please go back and try again.' , 'jetpack' ) );
5423
			}
5424
		}
5425
5426
		$data = json_decode( base64_decode( stripslashes( $_GET['data'] ) ) );
5427
		$data_filters = array(
5428
			'state'        => 'opaque',
5429
			'client_id'    => 'int',
5430
			'client_title' => 'string',
5431
			'client_image' => 'url',
5432
		);
5433
5434
		foreach ( $data_filters as $key => $sanitation ) {
5435
			if ( ! isset( $data->$key ) ) {
5436
				wp_die( $die_error );
5437
			}
5438
5439
			switch ( $sanitation ) {
5440
			case 'int' :
5441
				$this->json_api_authorization_request[$key] = (int) $data->$key;
5442
				break;
5443
			case 'opaque' :
5444
				$this->json_api_authorization_request[$key] = (string) $data->$key;
5445
				break;
5446
			case 'string' :
5447
				$this->json_api_authorization_request[$key] = wp_kses( (string) $data->$key, array() );
5448
				break;
5449
			case 'url' :
5450
				$this->json_api_authorization_request[$key] = esc_url_raw( (string) $data->$key );
5451
				break;
5452
			}
5453
		}
5454
5455
		if ( empty( $this->json_api_authorization_request['client_id'] ) ) {
5456
			wp_die( $die_error );
5457
		}
5458
	}
5459
5460
	function login_message_json_api_authorization( $message ) {
5461
		return '<p class="message">' . sprintf(
5462
			esc_html__( '%s wants to access your site&#8217;s data.  Log in to authorize that access.' , 'jetpack' ),
5463
			'<strong>' . esc_html( $this->json_api_authorization_request['client_title'] ) . '</strong>'
5464
		) . '<img src="' . esc_url( $this->json_api_authorization_request['client_image'] ) . '" /></p>';
5465
	}
5466
5467
	/**
5468
	 * Get $content_width, but with a <s>twist</s> filter.
5469
	 */
5470
	public static function get_content_width() {
5471
		$content_width = isset( $GLOBALS['content_width'] ) ? $GLOBALS['content_width'] : false;
5472
		/**
5473
		 * Filter the Content Width value.
5474
		 *
5475
		 * @since 2.2.3
5476
		 *
5477
		 * @param string $content_width Content Width value.
5478
		 */
5479
		return apply_filters( 'jetpack_content_width', $content_width );
5480
	}
5481
5482
	/**
5483
	 * Centralize the function here until it gets added to core.
5484
	 *
5485
	 * @param int|string|object $id_or_email A user ID,  email address, or comment object
5486
	 * @param int $size Size of the avatar image
5487
	 * @param string $default URL to a default image to use if no avatar is available
5488
	 * @param bool $force_display Whether to force it to return an avatar even if show_avatars is disabled
5489
	 *
5490
	 * @return array First element is the URL, second is the class.
5491
	 */
5492
	public static function get_avatar_url( $id_or_email, $size = 96, $default = '', $force_display = false ) {
5493
		// Don't bother adding the __return_true filter if it's already there.
5494
		$has_filter = has_filter( 'pre_option_show_avatars', '__return_true' );
5495
5496
		if ( $force_display && ! $has_filter )
5497
			add_filter( 'pre_option_show_avatars', '__return_true' );
5498
5499
		$avatar = get_avatar( $id_or_email, $size, $default );
5500
5501
		if ( $force_display && ! $has_filter )
5502
			remove_filter( 'pre_option_show_avatars', '__return_true' );
5503
5504
		// If no data, fail out.
5505
		if ( is_wp_error( $avatar ) || ! $avatar )
5506
			return array( null, null );
5507
5508
		// Pull out the URL.  If it's not there, fail out.
5509
		if ( ! preg_match( '/src=["\']([^"\']+)["\']/', $avatar, $url_matches ) )
5510
			return array( null, null );
5511
		$url = wp_specialchars_decode( $url_matches[1], ENT_QUOTES );
5512
5513
		// Pull out the class, but it's not a big deal if it's missing.
5514
		$class = '';
5515
		if ( preg_match( '/class=["\']([^"\']+)["\']/', $avatar, $class_matches ) )
5516
			$class = wp_specialchars_decode( $class_matches[1], ENT_QUOTES );
5517
5518
		return array( $url, $class );
5519
	}
5520
5521
	/**
5522
	 * Pings the WordPress.com Mirror Site for the specified options.
5523
	 *
5524
	 * @param string|array $option_names The option names to request from the WordPress.com Mirror Site
5525
	 *
5526
	 * @return array An associative array of the option values as stored in the WordPress.com Mirror Site
5527
	 */
5528
	public function get_cloud_site_options( $option_names ) {
5529
		$option_names = array_filter( (array) $option_names, 'is_string' );
5530
5531
		Jetpack::load_xml_rpc_client();
5532
		$xml = new Jetpack_IXR_Client( array( 'user_id' => JETPACK_MASTER_USER, ) );
5533
		$xml->query( 'jetpack.fetchSiteOptions', $option_names );
5534
		if ( $xml->isError() ) {
5535
			return array(
5536
				'error_code' => $xml->getErrorCode(),
5537
				'error_msg'  => $xml->getErrorMessage(),
5538
			);
5539
		}
5540
		$cloud_site_options = $xml->getResponse();
5541
5542
		return $cloud_site_options;
5543
	}
5544
5545
	/**
5546
	 * Fetch the filtered array of options that we should compare to determine an identity crisis.
5547
	 *
5548
	 * @return array An array of options to check.
5549
	 */
5550
	public static function identity_crisis_options_to_check() {
5551
		return array(
5552
			'siteurl',
5553
			'home',
5554
		);
5555
	}
5556
5557
	/**
5558
	 * Checks to make sure that local options have the same values as remote options.  Will cache the results for up to 24 hours.
5559
	 *
5560
	 * @param bool $force_recheck Whether to ignore any cached transient and manually re-check.
5561
	 *
5562
	 * @return array An array of options that do not match.  If everything is good, it will evaluate to false.
5563
	 */
5564
	public static function check_identity_crisis( $force_recheck = false ) {
5565
		if ( ! Jetpack::is_active() || Jetpack::is_development_mode() || Jetpack::is_staging_site() )
5566
			return false;
5567
5568
		if ( $force_recheck || false === ( $errors = get_transient( 'jetpack_has_identity_crisis' ) ) ) {
5569
			$options_to_check = self::identity_crisis_options_to_check();
5570
			$cloud_options = Jetpack::init()->get_cloud_site_options( $options_to_check );
5571
			$errors        = array();
5572
5573
			foreach ( $cloud_options as $cloud_key => $cloud_value ) {
5574
5575
				// If it's not the same as the local value...
5576
				if ( $cloud_value !== get_option( $cloud_key ) ) {
5577
5578
					// Break out if we're getting errors.  We are going to check the error keys later when we alert.
5579
					if ( 'error_code' == $cloud_key ) {
5580
						$errors[ $cloud_key ] = $cloud_value;
5581
						break;
5582
					}
5583
5584
					$parsed_cloud_value = parse_url( $cloud_value );
5585
					// If the current options is an IP address
5586
					if ( filter_var( $parsed_cloud_value['host'], FILTER_VALIDATE_IP ) ) {
5587
						// Give the new value a Jetpack to fly in to the clouds
5588
						Jetpack::resolve_identity_crisis( $cloud_key );
5589
						continue;
5590
					}
5591
5592
					// And it's not been added to the whitelist...
5593
					if ( ! self::is_identity_crisis_value_whitelisted( $cloud_key, $cloud_value ) ) {
5594
						/*
5595
						 * This should be a temporary hack until a cleaner solution is found.
5596
						 *
5597
						 * The siteurl and home can be set to use http in General > Settings
5598
						 * however some constants can be defined that can force https in wp-admin
5599
						 * when this happens wpcom can confuse wporg with a fake identity
5600
						 * crisis with a mismatch of http vs https when it should be allowed.
5601
						 * we need to check that here.
5602
						 *
5603
						 * @see https://github.com/Automattic/jetpack/issues/1006
5604
						 */
5605
						if ( ( 'home' == $cloud_key || 'siteurl' == $cloud_key )
5606
							&& ( substr( $cloud_value, 0, 8 ) == "https://" )
5607
							&& Jetpack::init()->is_ssl_required_to_visit_site() ) {
5608
							// Ok, we found a mismatch of http and https because of wp-config, not an invalid url
5609
							continue;
5610
						}
5611
5612
5613
						// Then kick an error!
5614
						$errors[ $cloud_key ] = $cloud_value;
5615
					}
5616
				}
5617
			}
5618
		}
5619
5620
		/**
5621
		 * Filters the errors returned when checking for an Identity Crisis.
5622
		 *
5623
		 * @since 2.3.2
5624
		 *
5625
		 * @param array $errors Array of Identity Crisis errors.
5626
		 * @param bool $force_recheck Ignore any cached transient and manually re-check. Default to false.
5627
		 */
5628
		return apply_filters( 'jetpack_has_identity_crisis', $errors, $force_recheck );
5629
	}
5630
5631
	/*
5632
	 * Resolve ID crisis
5633
	 *
5634
	 * If the URL has changed, but the rest of the options are the same (i.e. blog/user tokens)
5635
	 * The user has the option to update the shadow site with the new URL before a new
5636
	 * token is created.
5637
	 *
5638
	 * @param $key : Which option to sync.  null defautlts to home and siteurl
5639
	 */
5640
	public static function resolve_identity_crisis( $key = null ) {
5641
		if ( $key ) {
5642
			$identity_options = array( $key );
5643
		} else {
5644
			$identity_options = self::identity_crisis_options_to_check();
5645
		}
5646
5647
		if ( is_array( $identity_options ) ) {
5648
			foreach( $identity_options as $identity_option ) {
5649
				/**
5650
				 * Fires when a shadow site option is updated.
5651
				 * These options are updated via the Identity Crisis UI.
5652
				 * $identity_option is the option that gets updated.
5653
				 *
5654
				 * @since 3.7.0
5655
				 */
5656
				do_action( "update_option_{$identity_option}" );
5657
			}
5658
		}
5659
	}
5660
5661
	/*
5662
	 * Whitelist URL
5663
	 *
5664
	 * Ignore the URL differences between the blog and the shadow site.
5665
	 */
5666
	public static function whitelist_current_url() {
5667
		$options_to_check = Jetpack::identity_crisis_options_to_check();
5668
		$cloud_options = Jetpack::init()->get_cloud_site_options( $options_to_check );
5669
5670
		foreach ( $cloud_options as $cloud_key => $cloud_value ) {
5671
			Jetpack::whitelist_identity_crisis_value( $cloud_key, $cloud_value );
5672
		}
5673
	}
5674
5675
	/*
5676
	 * Ajax callbacks for ID crisis resolutions
5677
	 *
5678
	 * Things that could happen here:
5679
	 *  - site_migrated : Update the URL on the shadow blog to match new domain
5680
	 *  - whitelist     : Ignore the URL difference
5681
	 *  - default       : Error message
5682
	 */
5683
	public static function resolve_identity_crisis_ajax_callback() {
5684
		check_ajax_referer( 'resolve-identity-crisis', 'ajax-nonce' );
5685
5686
		switch ( $_POST[ 'crisis_resolution_action' ] ) {
5687
			case 'site_migrated':
5688
				Jetpack::resolve_identity_crisis();
5689
				echo 'resolved';
5690
				break;
5691
5692
			case 'whitelist':
5693
				Jetpack::whitelist_current_url();
5694
				echo 'whitelisted';
5695
				break;
5696
5697
			case 'reset_connection':
5698
				// Delete the options first so it doesn't get confused which site to disconnect dotcom-side
5699
				Jetpack_Options::delete_option(
5700
					array(
5701
						'register',
5702
						'blog_token',
5703
						'user_token',
5704
						'user_tokens',
5705
						'master_user',
5706
						'time_diff',
5707
						'fallback_no_verify_ssl_certs',
5708
						'id',
5709
					)
5710
				);
5711
				delete_transient( 'jetpack_has_identity_crisis' );
5712
5713
				echo 'reset-connection-success';
5714
				break;
5715
5716
			default:
5717
				echo 'missing action';
5718
				break;
5719
		}
5720
5721
		wp_die();
5722
	}
5723
5724
	/**
5725
	 * Adds a value to the whitelist for the specified key.
5726
	 *
5727
	 * @param string $key The option name that we're whitelisting the value for.
5728
	 * @param string $value The value that we're intending to add to the whitelist.
5729
	 *
5730
	 * @return bool Whether the value was added to the whitelist, or false if it was already there.
5731
	 */
5732
	public static function whitelist_identity_crisis_value( $key, $value ) {
5733
		if ( Jetpack::is_identity_crisis_value_whitelisted( $key, $value ) ) {
5734
			return false;
5735
		}
5736
5737
		$whitelist = Jetpack_Options::get_option( 'identity_crisis_whitelist', array() );
5738
		if ( empty( $whitelist[ $key ] ) || ! is_array( $whitelist[ $key ] ) ) {
5739
			$whitelist[ $key ] = array();
5740
		}
5741
		array_push( $whitelist[ $key ], $value );
5742
5743
		Jetpack_Options::update_option( 'identity_crisis_whitelist', $whitelist );
5744
		return true;
5745
	}
5746
5747
	/**
5748
	 * Checks whether a value is already whitelisted.
5749
	 *
5750
	 * @param string $key The option name that we're checking the value for.
5751
	 * @param string $value The value that we're curious to see if it's on the whitelist.
5752
	 *
5753
	 * @return bool Whether the value is whitelisted.
5754
	 */
5755
	public static function is_identity_crisis_value_whitelisted( $key, $value ) {
5756
		$whitelist = Jetpack_Options::get_option( 'identity_crisis_whitelist', array() );
5757
		if ( ! empty( $whitelist[ $key ] ) && is_array( $whitelist[ $key ] ) && in_array( $value, $whitelist[ $key ] ) ) {
5758
			return true;
5759
		}
5760
		return false;
5761
	}
5762
5763
	/**
5764
	 * Checks whether the home and siteurl specifically are whitelisted
5765
	 * Written so that we don't have re-check $key and $value params every time
5766
	 * we want to check if this site is whitelisted, for example in footer.php
5767
	 *
5768
	 * @return bool True = already whitelisted False = not whitelisted
5769
	 */
5770
	public static function is_staging_site() {
5771
		$is_staging = false;
5772
5773
		$current_whitelist = Jetpack_Options::get_option( 'identity_crisis_whitelist' );
5774
		if ( $current_whitelist && ! get_transient( 'jetpack_checked_is_staging' ) ) {
5775
			$options_to_check  = Jetpack::identity_crisis_options_to_check();
5776
			$cloud_options     = Jetpack::init()->get_cloud_site_options( $options_to_check );
5777
5778
			foreach ( $cloud_options as $cloud_key => $cloud_value ) {
5779
				if ( self::is_identity_crisis_value_whitelisted( $cloud_key, $cloud_value ) ) {
5780
					$is_staging = true;
5781
					break;
5782
				}
5783
			}
5784
			// set a flag so we don't check again for an hour
5785
			set_transient( 'jetpack_checked_is_staging', 1, HOUR_IN_SECONDS );
5786
		}
5787
		$known_staging = array(
5788
			'urls' => array(
5789
				'#\.staging\.wpengine\.com$#i', // WP Engine
5790
				),
5791
			'constants' => array(
5792
				'IS_WPE_SNAPSHOT',      // WP Engine
5793
				'KINSTA_DEV_ENV',       // Kinsta.com
5794
				'WPSTAGECOACH_STAGING', // WP Stagecoach
5795
				'JETPACK_STAGING_MODE', // Generic
5796
				)
5797
			);
5798
		/**
5799
		 * Filters the flags of known staging sites.
5800
		 *
5801
		 * @since 3.9.0
5802
		 *
5803
		 * @param array $known_staging {
5804
		 *     An array of arrays that each are used to check if the current site is staging.
5805
		 *     @type array $urls      URLs of staging sites in regex to check against site_url.
5806
		 *     @type array $constants PHP constants of known staging/developement environments.
5807
		 *  }
5808
		 */
5809
		$known_staging = apply_filters( 'jetpack_known_staging', $known_staging );
5810
5811
		if ( isset( $known_staging['urls'] ) ) {
5812
			foreach ( $known_staging['urls'] as $url ){
5813
				if ( preg_match( $url, site_url() ) ) {
5814
					$is_staging = true;
5815
					break;
5816
				}
5817
			}
5818
		}
5819
5820
		if ( isset( $known_staging['constants'] ) ) {
5821
			foreach ( $known_staging['constants'] as $constant ) {
5822
				if ( defined( $constant ) && constant( $constant ) ) {
5823
					$is_staging = true;
5824
				}
5825
			}
5826
		}
5827
5828
		/**
5829
		 * Filters is_staging_site check.
5830
		 *
5831
		 * @since 3.9.0
5832
		 *
5833
		 * @param bool $is_staging If the current site is a staging site.
5834
		 */
5835
		return apply_filters( 'jetpack_is_staging_site', $is_staging );
5836
	}
5837
5838
	public function identity_crisis_js( $nonce ) {
5839
?>
5840
<script>
5841
(function( $ ) {
5842
	var SECOND_IN_MS = 1000;
5843
5844
	function contactSupport( e ) {
5845
		e.preventDefault();
5846
		$( '.jp-id-crisis-question' ).hide();
5847
		$( '#jp-id-crisis-contact-support' ).show();
5848
	}
5849
5850
	function autodismissSuccessBanner() {
5851
		$( '.jp-identity-crisis' ).fadeOut(600); //.addClass( 'dismiss' );
5852
	}
5853
5854
	var data = { action: 'jetpack_resolve_identity_crisis', 'ajax-nonce': '<?php echo $nonce; ?>' };
5855
5856
	$( document ).ready(function() {
5857
5858
		// Site moved: Update the URL on the shadow blog
5859
		$( '.site-moved' ).click(function( e ) {
5860
			e.preventDefault();
5861
			data.crisis_resolution_action = 'site_migrated';
5862
			$( '#jp-id-crisis-question-1 .spinner' ).show();
5863
			$.post( ajaxurl, data, function() {
5864
				$( '.jp-id-crisis-question' ).hide();
5865
				$( '.banner-title' ).hide();
5866
				$( '#jp-id-crisis-success' ).show();
5867
				setTimeout( autodismissSuccessBanner, 6 * SECOND_IN_MS );
5868
			});
5869
5870
		});
5871
5872
		// URL hasn't changed, next question please.
5873
		$( '.site-not-moved' ).click(function( e ) {
5874
			e.preventDefault();
5875
			$( '.jp-id-crisis-question' ).hide();
5876
			$( '#jp-id-crisis-question-2' ).show();
5877
		});
5878
5879
		// Reset connection: two separate sites.
5880
		$( '.reset-connection' ).click(function( e ) {
5881
			data.crisis_resolution_action = 'reset_connection';
5882
			$.post( ajaxurl, data, function( response ) {
5883
				if ( 'reset-connection-success' === response ) {
5884
					window.location.replace( '<?php echo Jetpack::admin_url(); ?>' );
5885
				}
5886
			});
5887
		});
5888
5889
		// It's a dev environment.  Ignore.
5890
		$( '.is-dev-env' ).click(function( e ) {
5891
			data.crisis_resolution_action = 'whitelist';
5892
			$( '#jp-id-crisis-question-2 .spinner' ).show();
5893
			$.post( ajaxurl, data, function() {
5894
				$( '.jp-id-crisis-question' ).hide();
5895
				$( '.banner-title' ).hide();
5896
				$( '#jp-id-crisis-success' ).show();
5897
				setTimeout( autodismissSuccessBanner, 4 * SECOND_IN_MS );
5898
			});
5899
		});
5900
5901
		$( '.not-reconnecting' ).click(contactSupport);
5902
		$( '.not-staging-or-dev' ).click(contactSupport);
5903
	});
5904
})( jQuery );
5905
</script>
5906
<?php
5907
	}
5908
5909
	/**
5910
	 * Maybe Use a .min.css stylesheet, maybe not.
5911
	 *
5912
	 * Hooks onto `plugins_url` filter at priority 1, and accepts all 3 args.
5913
	 */
5914
	public static function maybe_min_asset( $url, $path, $plugin ) {
5915
		// Short out on things trying to find actual paths.
5916
		if ( ! $path || empty( $plugin ) ) {
5917
			return $url;
5918
		}
5919
5920
		// Strip out the abspath.
5921
		$base = dirname( plugin_basename( $plugin ) );
5922
5923
		// Short out on non-Jetpack assets.
5924
		if ( 'jetpack/' !== substr( $base, 0, 8 ) ) {
5925
			return $url;
5926
		}
5927
5928
		// File name parsing.
5929
		$file              = "{$base}/{$path}";
5930
		$full_path         = JETPACK__PLUGIN_DIR . substr( $file, 8 );
5931
		$file_name         = substr( $full_path, strrpos( $full_path, '/' ) + 1 );
5932
		$file_name_parts_r = array_reverse( explode( '.', $file_name ) );
5933
		$extension         = array_shift( $file_name_parts_r );
5934
5935
		if ( in_array( strtolower( $extension ), array( 'css', 'js' ) ) ) {
5936
			// Already pointing at the minified version.
5937
			if ( 'min' === $file_name_parts_r[0] ) {
5938
				return $url;
5939
			}
5940
5941
			$min_full_path = preg_replace( "#\.{$extension}$#", ".min.{$extension}", $full_path );
5942
			if ( file_exists( $min_full_path ) ) {
5943
				$url = preg_replace( "#\.{$extension}$#", ".min.{$extension}", $url );
5944
			}
5945
		}
5946
5947
		return $url;
5948
	}
5949
5950
	/**
5951
	 * Maybe inlines a stylesheet.
5952
	 *
5953
	 * If you'd like to inline a stylesheet instead of printing a link to it,
5954
	 * wp_style_add_data( 'handle', 'jetpack-inline', true );
5955
	 *
5956
	 * Attached to `style_loader_tag` filter.
5957
	 *
5958
	 * @param string $tag The tag that would link to the external asset.
5959
	 * @param string $handle The registered handle of the script in question.
5960
	 *
5961
	 * @return string
5962
	 */
5963
	public static function maybe_inline_style( $tag, $handle ) {
5964
		global $wp_styles;
5965
		$item = $wp_styles->registered[ $handle ];
5966
5967
		if ( ! isset( $item->extra['jetpack-inline'] ) || ! $item->extra['jetpack-inline'] ) {
5968
			return $tag;
5969
		}
5970
5971
		if ( preg_match( '# href=\'([^\']+)\' #i', $tag, $matches ) ) {
5972
			$href = $matches[1];
5973
			// Strip off query string
5974
			if ( $pos = strpos( $href, '?' ) ) {
5975
				$href = substr( $href, 0, $pos );
5976
			}
5977
			// Strip off fragment
5978
			if ( $pos = strpos( $href, '#' ) ) {
5979
				$href = substr( $href, 0, $pos );
5980
			}
5981
		} else {
5982
			return $tag;
5983
		}
5984
5985
		$plugins_dir = plugin_dir_url( JETPACK__PLUGIN_FILE );
5986
		if ( $plugins_dir !== substr( $href, 0, strlen( $plugins_dir ) ) ) {
5987
			return $tag;
5988
		}
5989
5990
		// If this stylesheet has a RTL version, and the RTL version replaces normal...
5991
		if ( isset( $item->extra['rtl'] ) && 'replace' === $item->extra['rtl'] && is_rtl() ) {
5992
			// And this isn't the pass that actually deals with the RTL version...
5993
			if ( false === strpos( $tag, " id='$handle-rtl-css' " ) ) {
5994
				// Short out, as the RTL version will deal with it in a moment.
5995
				return $tag;
5996
			}
5997
		}
5998
5999
		$file = JETPACK__PLUGIN_DIR . substr( $href, strlen( $plugins_dir ) );
6000
		$css  = Jetpack::absolutize_css_urls( file_get_contents( $file ), $href );
6001
		if ( $css ) {
6002
			$tag = "<!-- Inline {$item->handle} -->\r\n";
6003
			if ( empty( $item->extra['after'] ) ) {
6004
				wp_add_inline_style( $handle, $css );
6005
			} else {
6006
				array_unshift( $item->extra['after'], $css );
6007
				wp_style_add_data( $handle, 'after', $item->extra['after'] );
6008
			}
6009
		}
6010
6011
		return $tag;
6012
	}
6013
6014
	/**
6015
	 * Loads a view file from the views
6016
	 *
6017
	 * Data passed in with the $data parameter will be available in the
6018
	 * template file as $data['value']
6019
	 *
6020
	 * @param string $template - Template file to load
6021
	 * @param array $data - Any data to pass along to the template
6022
	 * @return boolean - If template file was found
6023
	 **/
6024
	public function load_view( $template, $data = array() ) {
6025
		$views_dir = JETPACK__PLUGIN_DIR . 'views/';
6026
6027
		if( file_exists( $views_dir . $template ) ) {
6028
			require_once( $views_dir . $template );
6029
			return true;
6030
		}
6031
6032
		error_log( "Jetpack: Unable to find view file $views_dir$template" );
6033
		return false;
6034
	}
6035
6036
	/**
6037
	 * Throws warnings for deprecated hooks to be removed from Jetpack
6038
	 */
6039
	public function deprecated_hooks() {
6040
		global $wp_filter;
6041
6042
		/*
6043
		 * Format:
6044
		 * deprecated_filter_name => replacement_name
6045
		 *
6046
		 * If there is no replacement us null for replacement_name
6047
		 */
6048
		$deprecated_list = array(
6049
			'jetpack_bail_on_shortcode'                              => 'jetpack_shortcodes_to_include',
6050
			'wpl_sharing_2014_1'                                     => null,
6051
			'jetpack-tools-to-include'                               => 'jetpack_tools_to_include',
6052
			'jetpack_identity_crisis_options_to_check'               => null,
6053
			'update_option_jetpack_single_user_site'                 => null,
6054
			'audio_player_default_colors'                            => null,
6055
			'add_option_jetpack_featured_images_enabled'             => null,
6056
			'add_option_jetpack_update_details'                      => null,
6057
			'add_option_jetpack_updates'                             => null,
6058
			'add_option_jetpack_network_name'                        => null,
6059
			'add_option_jetpack_network_allow_new_registrations'     => null,
6060
			'add_option_jetpack_network_add_new_users'               => null,
6061
			'add_option_jetpack_network_site_upload_space'           => null,
6062
			'add_option_jetpack_network_upload_file_types'           => null,
6063
			'add_option_jetpack_network_enable_administration_menus' => null,
6064
			'add_option_jetpack_is_multi_site'                       => null,
6065
			'add_option_jetpack_is_main_network'                     => null,
6066
			'add_option_jetpack_main_network_site'                   => null,
6067
			'jetpack_sync_all_registered_options'                    => null,
6068
		);
6069
6070
		// This is a silly loop depth. Better way?
6071
		foreach( $deprecated_list AS $hook => $hook_alt ) {
6072
			if( isset( $wp_filter[ $hook ] ) && is_array( $wp_filter[ $hook ] ) ) {
6073
				foreach( $wp_filter[$hook] AS $func => $values ) {
6074
					foreach( $values AS $hooked ) {
6075
						_deprecated_function( $hook . ' used for ' . $hooked['function'], null, $hook_alt );
6076
					}
6077
				}
6078
			}
6079
		}
6080
	}
6081
6082
	/**
6083
	 * Converts any url in a stylesheet, to the correct absolute url.
6084
	 *
6085
	 * Considerations:
6086
	 *  - Normal, relative URLs     `feh.png`
6087
	 *  - Data URLs                 `data:image/gif;base64,eh129ehiuehjdhsa==`
6088
	 *  - Schema-agnostic URLs      `//domain.com/feh.png`
6089
	 *  - Absolute URLs             `http://domain.com/feh.png`
6090
	 *  - Domain root relative URLs `/feh.png`
6091
	 *
6092
	 * @param $css string: The raw CSS -- should be read in directly from the file.
6093
	 * @param $css_file_url : The URL that the file can be accessed at, for calculating paths from.
6094
	 *
6095
	 * @return mixed|string
6096
	 */
6097
	public static function absolutize_css_urls( $css, $css_file_url ) {
6098
		$pattern = '#url\((?P<path>[^)]*)\)#i';
6099
		$css_dir = dirname( $css_file_url );
6100
		$p       = parse_url( $css_dir );
6101
		$domain  = sprintf(
6102
					'%1$s//%2$s%3$s%4$s',
6103
					isset( $p['scheme'] )           ? "{$p['scheme']}:" : '',
6104
					isset( $p['user'], $p['pass'] ) ? "{$p['user']}:{$p['pass']}@" : '',
6105
					$p['host'],
6106
					isset( $p['port'] )             ? ":{$p['port']}" : ''
6107
				);
6108
6109
		if ( preg_match_all( $pattern, $css, $matches, PREG_SET_ORDER ) ) {
6110
			$find = $replace = array();
6111
			foreach ( $matches as $match ) {
6112
				$url = trim( $match['path'], "'\" \t" );
6113
6114
				// If this is a data url, we don't want to mess with it.
6115
				if ( 'data:' === substr( $url, 0, 5 ) ) {
6116
					continue;
6117
				}
6118
6119
				// If this is an absolute or protocol-agnostic url,
6120
				// we don't want to mess with it.
6121
				if ( preg_match( '#^(https?:)?//#i', $url ) ) {
6122
					continue;
6123
				}
6124
6125
				switch ( substr( $url, 0, 1 ) ) {
6126
					case '/':
6127
						$absolute = $domain . $url;
6128
						break;
6129
					default:
6130
						$absolute = $css_dir . '/' . $url;
6131
				}
6132
6133
				$find[]    = $match[0];
6134
				$replace[] = sprintf( 'url("%s")', $absolute );
6135
			}
6136
			$css = str_replace( $find, $replace, $css );
6137
		}
6138
6139
		return $css;
6140
	}
6141
6142
	/**
6143
	 * This method checks to see if SSL is required by the site in
6144
	 * order to visit it in some way other than only setting the
6145
	 * https value in the home or siteurl values.
6146
	 *
6147
	 * @since 3.2
6148
	 * @return boolean
6149
	 **/
6150
	private function is_ssl_required_to_visit_site() {
6151
		global $wp_version;
6152
		$ssl = is_ssl();
6153
6154
		if ( force_ssl_admin() ) {
6155
			$ssl = true;
6156
		}
6157
		return $ssl;
6158
	}
6159
6160
	/**
6161
	 * This methods removes all of the registered css files on the front end
6162
	 * from Jetpack in favor of using a single file. In effect "imploding"
6163
	 * all the files into one file.
6164
	 *
6165
	 * Pros:
6166
	 * - Uses only ONE css asset connection instead of 15
6167
	 * - Saves a minimum of 56k
6168
	 * - Reduces server load
6169
	 * - Reduces time to first painted byte
6170
	 *
6171
	 * Cons:
6172
	 * - Loads css for ALL modules. However all selectors are prefixed so it
6173
	 *		should not cause any issues with themes.
6174
	 * - Plugins/themes dequeuing styles no longer do anything. See
6175
	 *		jetpack_implode_frontend_css filter for a workaround
6176
	 *
6177
	 * For some situations developers may wish to disable css imploding and
6178
	 * instead operate in legacy mode where each file loads seperately and
6179
	 * can be edited individually or dequeued. This can be accomplished with
6180
	 * the following line:
6181
	 *
6182
	 * add_filter( 'jetpack_implode_frontend_css', '__return_false' );
6183
	 *
6184
	 * @since 3.2
6185
	 **/
6186
	public function implode_frontend_css( $travis_test = false ) {
6187
		$do_implode = true;
6188
		if ( defined( 'SCRIPT_DEBUG' ) && SCRIPT_DEBUG ) {
6189
			$do_implode = false;
6190
		}
6191
6192
		/**
6193
		 * Allow CSS to be concatenated into a single jetpack.css file.
6194
		 *
6195
		 * @since 3.2.0
6196
		 *
6197
		 * @param bool $do_implode Should CSS be concatenated? Default to true.
6198
		 */
6199
		$do_implode = apply_filters( 'jetpack_implode_frontend_css', $do_implode );
6200
6201
		// Do not use the imploded file when default behaviour was altered through the filter
6202
		if ( ! $do_implode ) {
6203
			return;
6204
		}
6205
6206
		// We do not want to use the imploded file in dev mode, or if not connected
6207
		if ( Jetpack::is_development_mode() || ! self::is_active() ) {
6208
			if ( ! $travis_test ) {
6209
				return;
6210
			}
6211
		}
6212
6213
		// Do not use the imploded file if sharing css was dequeued via the sharing settings screen
6214
		if ( get_option( 'sharedaddy_disable_resources' ) ) {
6215
			return;
6216
		}
6217
6218
		/*
6219
		 * Now we assume Jetpack is connected and able to serve the single
6220
		 * file.
6221
		 *
6222
		 * In the future there will be a check here to serve the file locally
6223
		 * or potentially from the Jetpack CDN
6224
		 *
6225
		 * For now:
6226
		 * - Enqueue a single imploded css file
6227
		 * - Zero out the style_loader_tag for the bundled ones
6228
		 * - Be happy, drink scotch
6229
		 */
6230
6231
		add_filter( 'style_loader_tag', array( $this, 'concat_remove_style_loader_tag' ), 10, 2 );
6232
6233
		$version = Jetpack::is_development_version() ? filemtime( JETPACK__PLUGIN_DIR . 'css/jetpack.css' ) : JETPACK__VERSION;
6234
6235
		wp_enqueue_style( 'jetpack_css', plugins_url( 'css/jetpack.css', __FILE__ ), array(), $version );
6236
		wp_style_add_data( 'jetpack_css', 'rtl', 'replace' );
6237
	}
6238
6239
	function concat_remove_style_loader_tag( $tag, $handle ) {
6240
		if ( in_array( $handle, $this->concatenated_style_handles ) ) {
6241
			$tag = '';
6242
			if ( defined( 'WP_DEBUG' ) && WP_DEBUG ) {
6243
				$tag = "<!-- `" . esc_html( $handle ) . "` is included in the concatenated jetpack.css -->\r\n";
6244
			}
6245
		}
6246
6247
		return $tag;
6248
	}
6249
6250
	/*
6251
	 * Check the heartbeat data
6252
	 *
6253
	 * Organizes the heartbeat data by severity.  For example, if the site
6254
	 * is in an ID crisis, it will be in the $filtered_data['bad'] array.
6255
	 *
6256
	 * Data will be added to "caution" array, if it either:
6257
	 *  - Out of date Jetpack version
6258
	 *  - Out of date WP version
6259
	 *  - Out of date PHP version
6260
	 *
6261
	 * $return array $filtered_data
6262
	 */
6263
	public static function jetpack_check_heartbeat_data() {
6264
		$raw_data = Jetpack_Heartbeat::generate_stats_array();
6265
6266
		$good    = array();
6267
		$caution = array();
6268
		$bad     = array();
6269
6270
		foreach ( $raw_data as $stat => $value ) {
6271
6272
			// Check jetpack version
6273
			if ( 'version' == $stat ) {
6274
				if ( version_compare( $value, JETPACK__VERSION, '<' ) ) {
6275
					$caution[ $stat ] = $value . " - min supported is " . JETPACK__VERSION;
6276
					continue;
6277
				}
6278
			}
6279
6280
			// Check WP version
6281
			if ( 'wp-version' == $stat ) {
6282
				if ( version_compare( $value, JETPACK__MINIMUM_WP_VERSION, '<' ) ) {
6283
					$caution[ $stat ] = $value . " - min supported is " . JETPACK__MINIMUM_WP_VERSION;
6284
					continue;
6285
				}
6286
			}
6287
6288
			// Check PHP version
6289
			if ( 'php-version' == $stat ) {
6290
				if ( version_compare( PHP_VERSION, '5.2.4', '<' ) ) {
6291
					$caution[ $stat ] = $value . " - min supported is 5.2.4";
6292
					continue;
6293
				}
6294
			}
6295
6296
			// Check ID crisis
6297
			if ( 'identitycrisis' == $stat ) {
6298
				if ( 'yes' == $value ) {
6299
					$bad[ $stat ] = $value;
6300
					continue;
6301
				}
6302
			}
6303
6304
			// The rest are good :)
6305
			$good[ $stat ] = $value;
6306
		}
6307
6308
		$filtered_data = array(
6309
			'good'    => $good,
6310
			'caution' => $caution,
6311
			'bad'     => $bad
6312
		);
6313
6314
		return $filtered_data;
6315
	}
6316
6317
6318
	/*
6319
	 * This method is used to organize all options that can be reset
6320
	 * without disconnecting Jetpack.
6321
	 *
6322
	 * It is used in class.jetpack-cli.php to reset options
6323
	 *
6324
	 * @return array of options to delete.
6325
	 */
6326
	public static function get_jetpack_options_for_reset() {
6327
		$jetpack_options            = Jetpack_Options::get_option_names();
6328
		$jetpack_options_non_compat = Jetpack_Options::get_option_names( 'non_compact' );
6329
		$jetpack_options_private    = Jetpack_Options::get_option_names( 'private' );
6330
6331
		$all_jp_options = array_merge( $jetpack_options, $jetpack_options_non_compat, $jetpack_options_private );
6332
6333
		// A manual build of the wp options
6334
		$wp_options = array(
6335
			'sharing-options',
6336
			'disabled_likes',
6337
			'disabled_reblogs',
6338
			'jetpack_comments_likes_enabled',
6339
			'wp_mobile_excerpt',
6340
			'wp_mobile_featured_images',
6341
			'wp_mobile_app_promos',
6342
			'stats_options',
6343
			'stats_dashboard_widget',
6344
			'safecss_preview_rev',
6345
			'safecss_rev',
6346
			'safecss_revision_migrated',
6347
			'nova_menu_order',
6348
			'jetpack_portfolio',
6349
			'jetpack_portfolio_posts_per_page',
6350
			'jetpack_testimonial',
6351
			'jetpack_testimonial_posts_per_page',
6352
			'wp_mobile_custom_css',
6353
			'sharedaddy_disable_resources',
6354
			'sharing-options',
6355
			'sharing-services',
6356
			'site_icon_temp_data',
6357
			'featured-content',
6358
			'site_logo',
6359
		);
6360
6361
		// Flag some Jetpack options as unsafe
6362
		$unsafe_options = array(
6363
			'id',                           // (int)    The Client ID/WP.com Blog ID of this site.
6364
			'master_user',                  // (int)    The local User ID of the user who connected this site to jetpack.wordpress.com.
6365
			'version',                      // (string) Used during upgrade procedure to auto-activate new modules. version:time
6366
			'jumpstart',                    // (string) A flag for whether or not to show the Jump Start.  Accepts: new_connection, jumpstart_activated, jetpack_action_taken, jumpstart_dismissed.
6367
6368
			// non_compact
6369
			'activated',
6370
6371
			// private
6372
			'register',
6373
			'blog_token',                  // (string) The Client Secret/Blog Token of this site.
6374
			'user_token',                  // (string) The User Token of this site. (deprecated)
6375
			'user_tokens'
6376
		);
6377
6378
		// Remove the unsafe Jetpack options
6379
		foreach ( $unsafe_options as $unsafe_option ) {
6380
			if ( false !== ( $key = array_search( $unsafe_option, $all_jp_options ) ) ) {
6381
				unset( $all_jp_options[ $key ] );
6382
			}
6383
		}
6384
6385
		$options = array(
6386
			'jp_options' => $all_jp_options,
6387
			'wp_options' => $wp_options
6388
		);
6389
6390
		return $options;
6391
	}
6392
6393
	/*
6394
	 * Check if an option of a Jetpack module has been updated.
6395
	 *
6396
	 * If any module option has been updated before Jump Start has been dismissed,
6397
	 * update the 'jumpstart' option so we can hide Jump Start.
6398
	 */
6399
	public static function jumpstart_has_updated_module_option( $option_name = '' ) {
6400
		// Bail if Jump Start has already been dismissed
6401
		if ( 'new_connection' !== Jetpack::get_option( 'jumpstart' ) ) {
6402
			return false;
6403
		}
6404
6405
		$jetpack = Jetpack::init();
6406
6407
6408
		// Manual build of module options
6409
		$option_names = self::get_jetpack_options_for_reset();
6410
6411
		if ( in_array( $option_name, $option_names['wp_options'] ) ) {
6412
			Jetpack_Options::update_option( 'jumpstart', 'jetpack_action_taken' );
6413
6414
			//Jump start is being dismissed send data to MC Stats
6415
			$jetpack->stat( 'jumpstart', 'manual,'.$option_name );
6416
6417
			$jetpack->do_stats( 'server_side' );
6418
		}
6419
6420
	}
6421
6422
	/*
6423
	 * Strip http:// or https:// from a url, replaces forward slash with ::,
6424
	 * so we can bring them directly to their site in calypso.
6425
	 *
6426
	 * @param string | url
6427
	 * @return string | url without the guff
6428
	 */
6429
	public static function build_raw_urls( $url ) {
6430
		$strip_http = '/.*?:\/\//i';
6431
		$url = preg_replace( $strip_http, '', $url  );
6432
		$url = str_replace( '/', '::', $url );
6433
		return $url;
6434
	}
6435
6436
	/**
6437
	 * Stores and prints out domains to prefetch for page speed optimization.
6438
	 *
6439
	 * @param mixed $new_urls
6440
	 */
6441
	public static function dns_prefetch( $new_urls = null ) {
6442
		static $prefetch_urls = array();
6443
		if ( empty( $new_urls ) && ! empty( $prefetch_urls ) ) {
6444
			echo "\r\n";
6445
			foreach ( $prefetch_urls as $this_prefetch_url ) {
6446
				printf( "<link rel='dns-prefetch' href='%s'>\r\n", esc_attr( $this_prefetch_url ) );
6447
			}
6448
		} elseif ( ! empty( $new_urls ) ) {
6449
			if ( ! has_action( 'wp_head', array( __CLASS__, __FUNCTION__ ) ) ) {
6450
				add_action( 'wp_head', array( __CLASS__, __FUNCTION__ ) );
6451
			}
6452
			foreach ( (array) $new_urls as $this_new_url ) {
6453
				$prefetch_urls[] = strtolower( untrailingslashit( preg_replace( '#^https?://#i', '//', $this_new_url ) ) );
6454
			}
6455
			$prefetch_urls = array_unique( $prefetch_urls );
6456
		}
6457
	}
6458
6459
	public function wp_dashboard_setup() {
6460
		if ( self::is_active() ) {
6461
			add_action( 'jetpack_dashboard_widget', array( __CLASS__, 'dashboard_widget_footer' ), 999 );
6462
			$widget_title = __( 'Site Stats', 'jetpack' );
6463
		} elseif ( ! self::is_development_mode() && current_user_can( 'jetpack_connect' ) ) {
6464
			add_action( 'jetpack_dashboard_widget', array( $this, 'dashboard_widget_connect_to_wpcom' ) );
6465
			$widget_title = __( 'Please Connect Jetpack', 'jetpack' );
6466
		}
6467
6468
		if ( has_action( 'jetpack_dashboard_widget' ) ) {
6469
			wp_add_dashboard_widget(
6470
				'jetpack_summary_widget',
6471
				$widget_title,
6472
				array( __CLASS__, 'dashboard_widget' )
6473
			);
6474
			wp_enqueue_style( 'jetpack-dashboard-widget', plugins_url( 'css/dashboard-widget.css', JETPACK__PLUGIN_FILE ), array(), JETPACK__VERSION );
6475
6476
			// If we're inactive and not in development mode, sort our box to the top.
6477
			if ( ! self::is_active() && ! self::is_development_mode() ) {
6478
				global $wp_meta_boxes;
6479
6480
				$dashboard = $wp_meta_boxes['dashboard']['normal']['core'];
6481
				$ours      = array( 'jetpack_summary_widget' => $dashboard['jetpack_summary_widget'] );
6482
6483
				$wp_meta_boxes['dashboard']['normal']['core'] = array_merge( $ours, $dashboard );
6484
			}
6485
		}
6486
	}
6487
6488
	/**
6489
	 * @param mixed $result Value for the user's option
6490
	 * @return mixed
6491
	 */
6492
	function get_user_option_meta_box_order_dashboard( $sorted ) {
6493
		if ( ! is_array( $sorted ) ) {
6494
			return $sorted;
6495
		}
6496
6497
		foreach ( $sorted as $box_context => $ids ) {
6498
			if ( false === strpos( $ids, 'dashboard_stats' ) ) {
6499
				// If the old id isn't anywhere in the ids, don't bother exploding and fail out.
6500
				continue;
6501
			}
6502
6503
			$ids_array = explode( ',', $ids );
6504
			$key = array_search( 'dashboard_stats', $ids_array );
6505
6506
			if ( false !== $key ) {
6507
				// If we've found that exact value in the option (and not `google_dashboard_stats` for example)
6508
				$ids_array[ $key ] = 'jetpack_summary_widget';
6509
				$sorted[ $box_context ] = implode( ',', $ids_array );
6510
				// We've found it, stop searching, and just return.
6511
				break;
6512
			}
6513
		}
6514
6515
		return $sorted;
6516
	}
6517
6518
	public static function dashboard_widget() {
6519
		/**
6520
		 * Fires when the dashboard is loaded.
6521
		 *
6522
		 * @since 3.4.0
6523
		 */
6524
		do_action( 'jetpack_dashboard_widget' );
6525
	}
6526
6527
	public static function dashboard_widget_footer() {
6528
		?>
6529
		<footer>
6530
6531
		<div class="protect">
6532
			<?php if ( Jetpack::is_module_active( 'protect' ) ) : ?>
6533
				<h3><?php echo number_format_i18n( get_site_option( 'jetpack_protect_blocked_attempts', 0 ) ); ?></h3>
6534
				<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>
6535
			<?php elseif ( current_user_can( 'jetpack_activate_modules' ) && ! self::is_development_mode() ) : ?>
6536
				<a href="<?php echo esc_url( wp_nonce_url( Jetpack::admin_url( array( 'action' => 'activate', 'module' => 'protect' ) ), 'jetpack_activate-protect' ) ); ?>" class="button button-jetpack" title="<?php esc_attr_e( 'Protect helps to keep you secure from brute-force login attacks.', 'jetpack' ); ?>">
6537
					<?php esc_html_e( 'Activate Protect', 'jetpack' ); ?>
6538
				</a>
6539
			<?php else : ?>
6540
				<?php esc_html_e( 'Protect is inactive.', 'jetpack' ); ?>
6541
			<?php endif; ?>
6542
		</div>
6543
6544
		<div class="akismet">
6545
			<?php if ( is_plugin_active( 'akismet/akismet.php' ) ) : ?>
6546
				<h3><?php echo number_format_i18n( get_option( 'akismet_spam_count', 0 ) ); ?></h3>
6547
				<p><?php echo esc_html_x( 'Spam comments blocked by Akismet.', '{#} Spam comments blocked by Akismet -- number is on a prior line, text is a caption.', 'jetpack' ); ?></p>
6548
			<?php elseif ( current_user_can( 'activate_plugins' ) && ! is_wp_error( validate_plugin( 'akismet/akismet.php' ) ) ) : ?>
6549
				<a href="<?php echo esc_url( wp_nonce_url( add_query_arg( array( 'action' => 'activate', 'plugin' => 'akismet/akismet.php' ), admin_url( 'plugins.php' ) ), 'activate-plugin_akismet/akismet.php' ) ); ?>" class="button button-jetpack">
6550
					<?php esc_html_e( 'Activate Akismet', 'jetpack' ); ?>
6551
				</a>
6552
			<?php else : ?>
6553
				<p><a href="<?php echo esc_url( 'https://akismet.com/?utm_source=jetpack&utm_medium=link&utm_campaign=Jetpack%20Dashboard%20Widget%20Footer%20Link' ); ?>"><?php esc_html_e( 'Akismet can help to keep your blog safe from spam!', 'jetpack' ); ?></a></p>
6554
			<?php endif; ?>
6555
		</div>
6556
6557
		</footer>
6558
		<?php
6559
	}
6560
6561
	public function dashboard_widget_connect_to_wpcom() {
6562
		if ( Jetpack::is_active() || Jetpack::is_development_mode() || ! current_user_can( 'jetpack_connect' ) ) {
6563
			return;
6564
		}
6565
		?>
6566
		<div class="wpcom-connect">
6567
			<div class="jp-emblem">
6568
			<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" version="1.1" id="Layer_1" x="0" y="0" viewBox="0 0 172.9 172.9" enable-background="new 0 0 172.9 172.9" xml:space="preserve">
6569
				<path d="M86.4 0C38.7 0 0 38.7 0 86.4c0 47.7 38.7 86.4 86.4 86.4s86.4-38.7 86.4-86.4C172.9 38.7 134.2 0 86.4 0zM83.1 106.6l-27.1-6.9C49 98 45.7 90.1 49.3 84l33.8-58.5V106.6zM124.9 88.9l-33.8 58.5V66.3l27.1 6.9C125.1 74.9 128.4 82.8 124.9 88.9z"/>
6570
			</svg>
6571
			</div>
6572
			<h3><?php esc_html_e( 'Please Connect Jetpack', 'jetpack' ); ?></h3>
6573
			<p><?php echo wp_kses( __( 'Connecting Jetpack will show you <strong>stats</strong> about your traffic, <strong>protect</strong> you from brute force attacks, <strong>speed up</strong> your images and photos, and enable other <strong>traffic and security</strong> features.', 'jetpack' ), 'jetpack' ) ?></p>
6574
6575
			<div class="actions">
6576
				<a href="<?php echo $this->build_connect_url( false, false, 'widget-btn' ); ?>" class="button button-primary">
6577
					<?php esc_html_e( 'Connect Jetpack', 'jetpack' ); ?>
6578
				</a>
6579
			</div>
6580
		</div>
6581
		<?php
6582
	}
6583
6584
	/*
6585
	 * A graceful transition to using Core's site icon.
6586
	 *
6587
	 * All of the hard work has already been done with the image
6588
	 * in all_done_page(). All that needs to be done now is update
6589
	 * the option and display proper messaging.
6590
	 *
6591
	 * @todo remove when WP 4.3 is minimum
6592
	 *
6593
	 * @since 3.6.1
6594
	 *
6595
	 * @return bool false = Core's icon not available || true = Core's icon is available
6596
	 */
6597
	public static function jetpack_site_icon_available_in_core() {
6598
		global $wp_version;
6599
		$core_icon_available = function_exists( 'has_site_icon' ) && version_compare( $wp_version, '4.3-beta' ) >= 0;
6600
6601
		if ( ! $core_icon_available ) {
6602
			return false;
6603
		}
6604
6605
		// No need for Jetpack's site icon anymore if core's is already set
6606
		if ( has_site_icon() ) {
6607
			if ( Jetpack::is_module_active( 'site-icon' ) ) {
6608
				Jetpack::log( 'deactivate', 'site-icon' );
6609
				Jetpack::deactivate_module( 'site-icon' );
6610
			}
6611
			return true;
6612
		}
6613
6614
		// Transfer Jetpack's site icon to use core.
6615
		$site_icon_id = Jetpack::get_option( 'site_icon_id' );
6616
		if ( $site_icon_id ) {
6617
			// Update core's site icon
6618
			update_option( 'site_icon', $site_icon_id );
6619
6620
			// Delete Jetpack's icon option. We still want the blavatar and attached data though.
6621
			delete_option( 'site_icon_id' );
6622
		}
6623
6624
		// No need for Jetpack's site icon anymore
6625
		if ( Jetpack::is_module_active( 'site-icon' ) ) {
6626
			Jetpack::log( 'deactivate', 'site-icon' );
6627
			Jetpack::deactivate_module( 'site-icon' );
6628
		}
6629
6630
		return true;
6631
	}
6632
6633
	/**
6634
	 * Return string containing the Jetpack logo.
6635
	 *
6636
	 * @since 3.9.0
6637
	 *
6638
	 * @return string
6639
	 */
6640
	public static function get_jp_emblem() {
6641
		return '<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" version="1.1" id="Layer_1" x="0" y="0" viewBox="0 0 172.9 172.9" enable-background="new 0 0 172.9 172.9" xml:space="preserve">	<path d="M86.4 0C38.7 0 0 38.7 0 86.4c0 47.7 38.7 86.4 86.4 86.4s86.4-38.7 86.4-86.4C172.9 38.7 134.2 0 86.4 0zM83.1 106.6l-27.1-6.9C49 98 45.7 90.1 49.3 84l33.8-58.5V106.6zM124.9 88.9l-33.8 58.5V66.3l27.1 6.9C125.1 74.9 128.4 82.8 124.9 88.9z" /></svg>';
6642
	}
6643
6644
	/*
6645
	 * Adds a "blank" column in the user admin table to display indication of user connection.
6646
	 */
6647
	function jetpack_icon_user_connected( $columns ) {
6648
		$columns['user_jetpack'] = '';
6649
		return $columns;
6650
	}
6651
6652
	/*
6653
	 * Show Jetpack icon if the user is linked.
6654
	 */
6655
	function jetpack_show_user_connected_icon( $val, $col, $user_id ) {
6656
		if ( 'user_jetpack' == $col && Jetpack::is_user_connected( $user_id ) ) {
6657
			$emblem_html = sprintf(
6658
				'<a title="%1$s" class="jp-emblem-user-admin">%2$s</a>',
6659
				esc_attr__( 'This user is linked and ready to fly with Jetpack.', 'jetpack' ),
6660
				Jetpack::get_jp_emblem()
6661
			);
6662
			return $emblem_html;
6663
		}
6664
6665
		return $val;
6666
	}
6667
6668
	/*
6669
	 * Style the Jetpack user column
6670
	 */
6671
	function jetpack_user_col_style() {
6672
		global $current_screen;
6673
		if ( ! empty( $current_screen->base ) && 'users' == $current_screen->base ) { ?>
6674
			<style>
6675
				.fixed .column-user_jetpack {
6676
					width: 21px;
6677
				}
6678
				.jp-emblem-user-admin path {
6679
					fill: #8cc258;
6680
				}
6681
			</style>
6682
		<?php }
6683
	}
6684
6685
}
6686