installed plugin Jetpack Protect version 1.0.2
This commit is contained in:
Gitium
@ -0,0 +1,55 @@
|
||||
<?php
|
||||
/**
|
||||
* A static in-process cache for blog data.
|
||||
*
|
||||
* @package automattic/jetpack-status
|
||||
*/
|
||||
|
||||
namespace Automattic\Jetpack\Status;
|
||||
|
||||
/**
|
||||
* A static in-process cache for blog data.
|
||||
*
|
||||
* For internal use only. Do not use this externally.
|
||||
*/
|
||||
class Cache {
|
||||
/**
|
||||
* Cached data;
|
||||
*
|
||||
* @var array[]
|
||||
*/
|
||||
private static $cache = array();
|
||||
|
||||
/**
|
||||
* Get a value from the cache.
|
||||
*
|
||||
* @param string $key Key to fetch.
|
||||
* @param mixed $default Default value to return if the key is not set.
|
||||
* @returns mixed Data.
|
||||
*/
|
||||
public static function get( $key, $default = null ) {
|
||||
$blog_id = get_current_blog_id();
|
||||
return isset( self::$cache[ $blog_id ] ) && array_key_exists( $key, self::$cache[ $blog_id ] ) ? self::$cache[ $blog_id ][ $key ] : $default;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set a value in the cache.
|
||||
*
|
||||
* @param string $key Key to set.
|
||||
* @param mixed $value Value to store.
|
||||
*/
|
||||
public static function set( $key, $value ) {
|
||||
$blog_id = get_current_blog_id();
|
||||
self::$cache[ $blog_id ][ $key ] = $value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Clear the cache.
|
||||
*
|
||||
* This is intended for use in unit tests.
|
||||
*/
|
||||
public static function clear() {
|
||||
self::$cache = array();
|
||||
}
|
||||
|
||||
}
|
||||
@ -0,0 +1,103 @@
|
||||
<?php
|
||||
/**
|
||||
* Pass state to subsequent requests via cookies.
|
||||
*
|
||||
* @package automattic/jetpack-status
|
||||
*/
|
||||
|
||||
namespace Automattic\Jetpack;
|
||||
|
||||
/**
|
||||
* Class Automattic\Jetpack\Status
|
||||
*
|
||||
* Used to retrieve information about the current status of Jetpack and the site overall.
|
||||
*/
|
||||
class CookieState {
|
||||
|
||||
/**
|
||||
* State is passed via cookies from one request to the next, but never to subsequent requests.
|
||||
* SET: state( $key, $value );
|
||||
* GET: $value = state( $key );
|
||||
*
|
||||
* @param string $key State key.
|
||||
* @param string $value Value.
|
||||
* @param bool $restate Reset the cookie (private).
|
||||
*/
|
||||
public function state( $key = null, $value = null, $restate = false ) {
|
||||
static $state = array();
|
||||
static $path, $domain;
|
||||
if ( ! isset( $path ) ) {
|
||||
require_once ABSPATH . 'wp-admin/includes/plugin.php';
|
||||
$admin_url = ( new Paths() )->admin_url();
|
||||
$bits = wp_parse_url( $admin_url );
|
||||
|
||||
if ( is_array( $bits ) ) {
|
||||
$path = ( isset( $bits['path'] ) ) ? dirname( $bits['path'] ) : null;
|
||||
$domain = ( isset( $bits['host'] ) ) ? $bits['host'] : null;
|
||||
} else {
|
||||
$path = null;
|
||||
$domain = null;
|
||||
}
|
||||
}
|
||||
|
||||
// Extract state from cookies and delete cookies.
|
||||
if ( isset( $_COOKIE['jetpackState'] ) && is_array( $_COOKIE['jetpackState'] ) ) {
|
||||
// phpcs:ignore WordPress.Security.ValidatedSanitizedInput.InputNotSanitized -- User should sanitize if necessary.
|
||||
$yum = wp_unslash( $_COOKIE['jetpackState'] );
|
||||
unset( $_COOKIE['jetpackState'] );
|
||||
foreach ( $yum as $k => $v ) {
|
||||
if ( strlen( $v ) ) {
|
||||
$state[ $k ] = $v;
|
||||
}
|
||||
setcookie( "jetpackState[$k]", false, 0, $path, $domain, is_ssl(), true );
|
||||
}
|
||||
}
|
||||
|
||||
if ( $restate ) {
|
||||
foreach ( $state as $k => $v ) {
|
||||
setcookie( "jetpackState[$k]", $v, 0, $path, $domain, is_ssl(), true );
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
// Get a state variable.
|
||||
if ( isset( $key ) && ! isset( $value ) ) {
|
||||
if ( array_key_exists( $key, $state ) ) {
|
||||
return $state[ $key ];
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
// Set a state variable.
|
||||
if ( isset( $key ) && isset( $value ) ) {
|
||||
if ( is_array( $value ) && isset( $value[0] ) ) {
|
||||
$value = $value[0];
|
||||
}
|
||||
$state[ $key ] = $value;
|
||||
if ( ! headers_sent() ) {
|
||||
if ( $this->should_set_cookie( $key ) ) {
|
||||
setcookie( "jetpackState[$key]", $value, 0, $path, $domain, is_ssl(), true );
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Determines whether the jetpackState[$key] value should be added to the
|
||||
* cookie.
|
||||
*
|
||||
* @param string $key The state key.
|
||||
*
|
||||
* @return boolean Whether the value should be added to the cookie.
|
||||
*/
|
||||
public function should_set_cookie( $key ) {
|
||||
global $current_screen;
|
||||
$page = isset( $current_screen->base ) ? $current_screen->base : null;
|
||||
|
||||
if ( 'toplevel_page_jetpack' === $page && 'display_update_modal' === $key ) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,43 @@
|
||||
<?php
|
||||
/**
|
||||
* An errors utility class for Jetpack.
|
||||
*
|
||||
* @package automattic/jetpack-status
|
||||
*/
|
||||
|
||||
// phpcs:disable WordPress.PHP.IniSet.display_errors_Blacklisted
|
||||
// phpcs:disable WordPress.PHP.NoSilencedErrors.Discouraged
|
||||
// phpcs:disable WordPress.PHP.DevelopmentFunctions.prevent_path_disclosure_error_reporting
|
||||
// phpcs:disable WordPress.PHP.DiscouragedPHPFunctions.runtime_configuration_error_reporting
|
||||
|
||||
namespace Automattic\Jetpack;
|
||||
|
||||
/**
|
||||
* Erros class.
|
||||
*/
|
||||
class Errors {
|
||||
/**
|
||||
* Catches PHP errors. Must be used in conjunction with output buffering.
|
||||
*
|
||||
* @param bool $catch True to start catching, False to stop.
|
||||
*
|
||||
* @static
|
||||
*/
|
||||
public function catch_errors( $catch ) {
|
||||
static $display_errors, $error_reporting;
|
||||
|
||||
if ( $catch ) {
|
||||
$display_errors = @ini_set( 'display_errors', 1 );
|
||||
$error_reporting = @error_reporting( E_ALL );
|
||||
if ( class_exists( 'Jetpack' ) ) {
|
||||
add_action( 'shutdown', array( 'Jetpack', 'catch_errors_on_shutdown' ), 0 );
|
||||
}
|
||||
} else {
|
||||
@ini_set( 'display_errors', $display_errors );
|
||||
@error_reporting( $error_reporting );
|
||||
if ( class_exists( 'Jetpack' ) ) {
|
||||
remove_action( 'shutdown', array( 'Jetpack', 'catch_errors_on_shutdown' ), 0 );
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,54 @@
|
||||
<?php
|
||||
/**
|
||||
* A modules class for Jetpack.
|
||||
*
|
||||
* @package automattic/jetpack-status
|
||||
*/
|
||||
|
||||
namespace Automattic\Jetpack;
|
||||
|
||||
/**
|
||||
* Class Automattic\Jetpack\Files
|
||||
*
|
||||
* Used to retrieve information about files.
|
||||
*/
|
||||
class Files {
|
||||
/**
|
||||
* Returns an array of all PHP files in the specified absolute path.
|
||||
* Equivalent to glob( "$absolute_path/*.php" ).
|
||||
*
|
||||
* @param string $absolute_path The absolute path of the directory to search.
|
||||
* @return array Array of absolute paths to the PHP files.
|
||||
*/
|
||||
public function glob_php( $absolute_path ) {
|
||||
if ( function_exists( 'glob' ) ) {
|
||||
return glob( "$absolute_path/*.php" );
|
||||
}
|
||||
|
||||
$absolute_path = untrailingslashit( $absolute_path );
|
||||
$files = array();
|
||||
$dir = @opendir( $absolute_path ); // phpcs:ignore WordPress.PHP.NoSilencedErrors.Discouraged
|
||||
if ( ! $dir ) {
|
||||
return $files;
|
||||
}
|
||||
|
||||
// phpcs:ignore WordPress.CodeAnalysis.AssignmentInCondition.FoundInWhileCondition
|
||||
while ( false !== $file = readdir( $dir ) ) {
|
||||
if ( '.' === substr( $file, 0, 1 ) || '.php' !== substr( $file, -4 ) ) {
|
||||
continue;
|
||||
}
|
||||
|
||||
$file = "$absolute_path/$file";
|
||||
|
||||
if ( ! is_file( $file ) ) {
|
||||
continue;
|
||||
}
|
||||
|
||||
$files[] = $file;
|
||||
}
|
||||
|
||||
closedir( $dir );
|
||||
|
||||
return $files;
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,76 @@
|
||||
<?php
|
||||
/**
|
||||
* A hosting provide class for Jetpack.
|
||||
*
|
||||
* @package automattic/jetpack-status
|
||||
*/
|
||||
|
||||
namespace Automattic\Jetpack\Status;
|
||||
|
||||
use Automattic\Jetpack\Constants;
|
||||
|
||||
/**
|
||||
* Hosting provider class.
|
||||
*/
|
||||
class Host {
|
||||
/**
|
||||
* Determine if this site is an WordPress.com on Atomic site or not by looking for presence of the wpcomsh plugin.
|
||||
*
|
||||
* @since 1.9.0
|
||||
*
|
||||
* @return bool
|
||||
*/
|
||||
public function is_woa_site() {
|
||||
$ret = Cache::get( 'is_woa_site' );
|
||||
if ( null === $ret ) {
|
||||
$ret = $this->is_atomic_platform() && Constants::is_true( 'WPCOMSH__PLUGIN_FILE' );
|
||||
Cache::set( 'is_woa_site', $ret );
|
||||
}
|
||||
return $ret;
|
||||
}
|
||||
|
||||
/**
|
||||
* Determine if the site is hosted on the Atomic hosting platform.
|
||||
*
|
||||
* @since 1.9.0
|
||||
*
|
||||
* @return bool;
|
||||
*/
|
||||
public function is_atomic_platform() {
|
||||
return Constants::is_true( 'ATOMIC_SITE_ID' ) && Constants::is_true( 'ATOMIC_CLIENT_ID' );
|
||||
}
|
||||
|
||||
/**
|
||||
* Determine if this is a Newspack site.
|
||||
*
|
||||
* @return bool
|
||||
*/
|
||||
public function is_newspack_site() {
|
||||
return Constants::is_defined( 'NEWSPACK_PLUGIN_FILE' );
|
||||
}
|
||||
|
||||
/**
|
||||
* Determine if this is a VIP-hosted site.
|
||||
*
|
||||
* @return bool
|
||||
*/
|
||||
public function is_vip_site() {
|
||||
return Constants::is_defined( 'WPCOM_IS_VIP_ENV' ) && true === Constants::get_constant( 'WPCOM_IS_VIP_ENV' );
|
||||
}
|
||||
|
||||
/**
|
||||
* Add all wordpress.com environments to the safe redirect allowed list.
|
||||
*
|
||||
* To be used with a filter of allowed domains for a redirect.
|
||||
*
|
||||
* @param array $domains Allowed WP.com Environments.
|
||||
*/
|
||||
public static function allow_wpcom_environments( $domains ) {
|
||||
$domains[] = 'wordpress.com';
|
||||
$domains[] = 'jetpack.wordpress.com';
|
||||
$domains[] = 'wpcalypso.wordpress.com';
|
||||
$domains[] = 'horizon.wordpress.com';
|
||||
$domains[] = 'calypso.localhost';
|
||||
return $domains;
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,591 @@
|
||||
<?php
|
||||
/**
|
||||
* A modules class for Jetpack.
|
||||
*
|
||||
* @package automattic/jetpack-status
|
||||
*/
|
||||
|
||||
namespace Automattic\Jetpack;
|
||||
|
||||
use Automattic\Jetpack\Constants as Constants;
|
||||
|
||||
/**
|
||||
* Class Automattic\Jetpack\Modules
|
||||
*
|
||||
* Used to retrieve information about the current status of Jetpack modules.
|
||||
*/
|
||||
class Modules {
|
||||
|
||||
/**
|
||||
* Check whether or not a Jetpack module is active.
|
||||
*
|
||||
* @param string $module The slug of a Jetpack module.
|
||||
* @return bool
|
||||
*/
|
||||
public function is_active( $module ) {
|
||||
return in_array( $module, self::get_active(), true );
|
||||
}
|
||||
|
||||
/**
|
||||
* Load module data from module file. Headers differ from WordPress
|
||||
* plugin headers to avoid them being identified as standalone
|
||||
* plugins on the WordPress plugins page.
|
||||
*
|
||||
* @param string $module The module slug.
|
||||
*/
|
||||
public function get( $module ) {
|
||||
static $modules_details;
|
||||
|
||||
// This method relies heavy on auto-generated file found in Jetpack only: module-headings.php
|
||||
// If it doesn't exist, it's safe to assume none of this will be helpful.
|
||||
if ( ! function_exists( 'jetpack_has_no_module_info' ) ) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if ( jetpack_has_no_module_info( $module ) ) {
|
||||
return false;
|
||||
}
|
||||
|
||||
$file = $this->get_path( $this->get_slug( $module ) );
|
||||
|
||||
if ( isset( $modules_details[ $module ] ) ) {
|
||||
$mod = $modules_details[ $module ];
|
||||
} else {
|
||||
$mod = jetpack_get_module_info( $module );
|
||||
|
||||
if ( null === $mod ) {
|
||||
// Try to get the module info from the file as a fallback.
|
||||
$mod = $this->get_file_data( $file, jetpack_get_all_module_header_names() );
|
||||
|
||||
if ( empty( $mod['name'] ) ) {
|
||||
// No info for this module.
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
$mod['sort'] = empty( $mod['sort'] ) ? 10 : (int) $mod['sort'];
|
||||
$mod['recommendation_order'] = empty( $mod['recommendation_order'] ) ? 20 : (int) $mod['recommendation_order'];
|
||||
$mod['deactivate'] = empty( $mod['deactivate'] );
|
||||
$mod['free'] = empty( $mod['free'] );
|
||||
$mod['requires_connection'] = ( ! empty( $mod['requires_connection'] ) && 'No' === $mod['requires_connection'] ) ? false : true;
|
||||
$mod['requires_user_connection'] = ( empty( $mod['requires_user_connection'] ) || 'No' === $mod['requires_user_connection'] ) ? false : true;
|
||||
|
||||
if ( empty( $mod['auto_activate'] ) || ! in_array( strtolower( $mod['auto_activate'] ), array( 'yes', 'no', 'public' ), true ) ) {
|
||||
$mod['auto_activate'] = 'No';
|
||||
} else {
|
||||
$mod['auto_activate'] = (string) $mod['auto_activate'];
|
||||
}
|
||||
|
||||
if ( $mod['module_tags'] ) {
|
||||
$mod['module_tags'] = explode( ',', $mod['module_tags'] );
|
||||
$mod['module_tags'] = array_map( 'trim', $mod['module_tags'] );
|
||||
$mod['module_tags'] = array_map( 'jetpack_get_module_i18n_tag', $mod['module_tags'] );
|
||||
} else {
|
||||
$mod['module_tags'] = array( jetpack_get_module_i18n_tag( 'Other' ) );
|
||||
}
|
||||
|
||||
if ( $mod['plan_classes'] ) {
|
||||
$mod['plan_classes'] = explode( ',', $mod['plan_classes'] );
|
||||
$mod['plan_classes'] = array_map( 'strtolower', array_map( 'trim', $mod['plan_classes'] ) );
|
||||
} else {
|
||||
$mod['plan_classes'] = array( 'free' );
|
||||
}
|
||||
|
||||
if ( $mod['feature'] ) {
|
||||
$mod['feature'] = explode( ',', $mod['feature'] );
|
||||
$mod['feature'] = array_map( 'trim', $mod['feature'] );
|
||||
} else {
|
||||
$mod['feature'] = array( jetpack_get_module_i18n_tag( 'Other' ) );
|
||||
}
|
||||
|
||||
$modules_details[ $module ] = $mod;
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* Filters the feature array on a module.
|
||||
*
|
||||
* This filter allows you to control where each module is filtered: Recommended,
|
||||
* and the default "Other" listing.
|
||||
*
|
||||
* @since-jetpack 3.5.0
|
||||
*
|
||||
* @param array $mod['feature'] The areas to feature this module:
|
||||
* 'Recommended' shows on the main Jetpack admin screen.
|
||||
* 'Other' should be the default if no other value is in the array.
|
||||
* @param string $module The slug of the module, e.g. sharedaddy.
|
||||
* @param array $mod All the currently assembled module data.
|
||||
*/
|
||||
$mod['feature'] = apply_filters( 'jetpack_module_feature', $mod['feature'], $module, $mod );
|
||||
|
||||
/**
|
||||
* Filter the returned data about a module.
|
||||
*
|
||||
* This filter allows overriding any info about Jetpack modules. It is dangerous,
|
||||
* so please be careful.
|
||||
*
|
||||
* @since-jetpack 3.6.0
|
||||
*
|
||||
* @param array $mod The details of the requested module.
|
||||
* @param string $module The slug of the module, e.g. sharedaddy
|
||||
* @param string $file The path to the module source file.
|
||||
*/
|
||||
return apply_filters( 'jetpack_get_module', $mod, $module, $file );
|
||||
}
|
||||
|
||||
/**
|
||||
* Like core's get_file_data implementation, but caches the result.
|
||||
*
|
||||
* @param string $file Absolute path to the file.
|
||||
* @param array $headers List of headers, in the format array( 'HeaderKey' => 'Header Name' ).
|
||||
*/
|
||||
public function get_file_data( $file, $headers ) {
|
||||
// Get just the filename from $file (i.e. exclude full path) so that a consistent hash is generated.
|
||||
$file_name = basename( $file );
|
||||
|
||||
if ( ! Constants::is_defined( 'JETPACK__VERSION' ) ) {
|
||||
return get_file_data( $file, $headers );
|
||||
}
|
||||
|
||||
$cache_key = 'jetpack_file_data_' . JETPACK__VERSION;
|
||||
|
||||
$file_data_option = get_transient( $cache_key );
|
||||
|
||||
if ( ! is_array( $file_data_option ) ) {
|
||||
delete_transient( $cache_key );
|
||||
$file_data_option = false;
|
||||
}
|
||||
|
||||
if ( false === $file_data_option ) {
|
||||
$file_data_option = array();
|
||||
}
|
||||
|
||||
$key = md5( $file_name . maybe_serialize( $headers ) );
|
||||
$refresh_cache = is_admin() && isset( $_GET['page'] ) && 'jetpack' === substr( $_GET['page'], 0, 7 ); // phpcs:ignore WordPress.Security.NonceVerification.Recommended, WordPress.Security.ValidatedSanitizedInput
|
||||
|
||||
// If we don't need to refresh the cache, and already have the value, short-circuit!
|
||||
if ( ! $refresh_cache && isset( $file_data_option[ $key ] ) ) {
|
||||
return $file_data_option[ $key ];
|
||||
}
|
||||
|
||||
$data = get_file_data( $file, $headers );
|
||||
|
||||
$file_data_option[ $key ] = $data;
|
||||
|
||||
set_transient( $cache_key, $file_data_option, 29 * DAY_IN_SECONDS );
|
||||
|
||||
return $data;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get a list of activated modules as an array of module slugs.
|
||||
*/
|
||||
public function get_active() {
|
||||
$active = \Jetpack_Options::get_option( 'active_modules' );
|
||||
|
||||
if ( ! is_array( $active ) ) {
|
||||
$active = array();
|
||||
}
|
||||
|
||||
if ( class_exists( 'VaultPress' ) || function_exists( 'vaultpress_contact_service' ) ) {
|
||||
$active[] = 'vaultpress';
|
||||
} else {
|
||||
$active = array_diff( $active, array( 'vaultpress' ) );
|
||||
}
|
||||
|
||||
// If protect is active on the main site of a multisite, it should be active on all sites.
|
||||
if ( ! in_array( 'protect', $active, true ) && is_multisite() && get_site_option( 'jetpack_protect_active' ) ) {
|
||||
$active[] = 'protect';
|
||||
}
|
||||
|
||||
// If it's not available, it shouldn't be active.
|
||||
// We don't delete it from the options though, as it will be active again when a plugin gets reactivated.
|
||||
$active = array_intersect( $active, $this->get_available() );
|
||||
|
||||
/**
|
||||
* Allow filtering of the active modules.
|
||||
*
|
||||
* Gives theme and plugin developers the power to alter the modules that
|
||||
* are activated on the fly.
|
||||
*
|
||||
* @since-jetpack 5.8.0
|
||||
*
|
||||
* @param array $active Array of active module slugs.
|
||||
*/
|
||||
$active = apply_filters( 'jetpack_active_modules', $active );
|
||||
|
||||
return array_unique( $active );
|
||||
}
|
||||
|
||||
/**
|
||||
* Extract a module's slug from its full path.
|
||||
*
|
||||
* @param string $file Full path to a file.
|
||||
*
|
||||
* @return string Module slug.
|
||||
*/
|
||||
public function get_slug( $file ) {
|
||||
return str_replace( '.php', '', basename( $file ) );
|
||||
}
|
||||
|
||||
/**
|
||||
* List available Jetpack modules. Simply lists .php files in /modules/.
|
||||
* Make sure to tuck away module "library" files in a sub-directory.
|
||||
*
|
||||
* @param bool|string $min_version Only return modules introduced in this version or later. Default is false, do not filter.
|
||||
* @param bool|string $max_version Only return modules introduced before this version. Default is false, do not filter.
|
||||
* @param bool|null $requires_connection Pass a boolean value to only return modules that require (or do not require) a connection.
|
||||
* @param bool|null $requires_user_connection Pass a boolean value to only return modules that require (or do not require) a user connection.
|
||||
*
|
||||
* @return array $modules Array of module slugs
|
||||
*/
|
||||
public function get_available( $min_version = false, $max_version = false, $requires_connection = null, $requires_user_connection = null ) {
|
||||
static $modules = null;
|
||||
|
||||
if ( ! class_exists( 'Jetpack' ) || ! Constants::is_defined( 'JETPACK__VERSION' ) || ! Constants::is_defined( 'JETPACK__PLUGIN_DIR' ) ) {
|
||||
return array_unique(
|
||||
/**
|
||||
* Stand alone plugins need to use this filter to register the modules they interact with.
|
||||
* This will allow them to activate and deactivate these modules even when Jetpack is not present.
|
||||
* Note: Standalone plugins can only interact with modules that also exist in the Jetpack plugin, otherwise they'll lose the ability to control it if Jetpack is activated.
|
||||
*
|
||||
* @since 1.13.6
|
||||
*
|
||||
* @param array $modules The list of available modules as an array of slugs.
|
||||
* @param bool $requires_connection Whether to list only modules that require a connection to work.
|
||||
* @param bool $requires_user_connection Whether to list only modules that require a user connection to work.
|
||||
*/
|
||||
apply_filters( 'jetpack_get_available_standalone_modules', array(), $requires_connection, $requires_user_connection )
|
||||
);
|
||||
}
|
||||
|
||||
if ( ! isset( $modules ) ) {
|
||||
$available_modules_option = \Jetpack_Options::get_option( 'available_modules', array() );
|
||||
// Use the cache if we're on the front-end and it's available...
|
||||
if ( ! is_admin() && ! empty( $available_modules_option[ JETPACK__VERSION ] ) ) {
|
||||
$modules = $available_modules_option[ JETPACK__VERSION ];
|
||||
} else {
|
||||
$files = ( new Files() )->glob_php( JETPACK__PLUGIN_DIR . 'modules' );
|
||||
|
||||
$modules = array();
|
||||
|
||||
foreach ( $files as $file ) {
|
||||
$slug = $this->get_slug( $file );
|
||||
$headers = $this->get( $slug );
|
||||
|
||||
if ( ! $headers ) {
|
||||
continue;
|
||||
}
|
||||
|
||||
$modules[ $slug ] = $headers['introduced'];
|
||||
}
|
||||
|
||||
\Jetpack_Options::update_option(
|
||||
'available_modules',
|
||||
array(
|
||||
JETPACK__VERSION => $modules,
|
||||
)
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Filters the array of modules available to be activated.
|
||||
*
|
||||
* @since 2.4.0
|
||||
*
|
||||
* @param array $modules Array of available modules.
|
||||
* @param string $min_version Minimum version number required to use modules.
|
||||
* @param string $max_version Maximum version number required to use modules.
|
||||
* @param bool|null $requires_connection Value of the Requires Connection filter.
|
||||
* @param bool|null $requires_user_connection Value of the Requires User Connection filter.
|
||||
*/
|
||||
$mods = apply_filters( 'jetpack_get_available_modules', $modules, $min_version, $max_version, $requires_connection, $requires_user_connection );
|
||||
|
||||
if ( ! $min_version && ! $max_version && $requires_connection === null && $requires_user_connection === null ) {
|
||||
return array_keys( $mods );
|
||||
}
|
||||
|
||||
$r = array();
|
||||
foreach ( $mods as $slug => $introduced ) {
|
||||
if ( $min_version && version_compare( $min_version, $introduced, '>=' ) ) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if ( $max_version && version_compare( $max_version, $introduced, '<' ) ) {
|
||||
continue;
|
||||
}
|
||||
|
||||
$mod_details = $this->get( $slug );
|
||||
|
||||
if ( null !== $requires_connection && (bool) $requires_connection !== $mod_details['requires_connection'] ) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if ( null !== $requires_user_connection && (bool) $requires_user_connection !== $mod_details['requires_user_connection'] ) {
|
||||
continue;
|
||||
}
|
||||
|
||||
$r[] = $slug;
|
||||
}
|
||||
|
||||
return $r;
|
||||
}
|
||||
|
||||
/**
|
||||
* Is slug a valid module.
|
||||
*
|
||||
* @param string $module Module slug.
|
||||
*
|
||||
* @return bool
|
||||
*/
|
||||
public function is_module( $module ) {
|
||||
return ! empty( $module ) && ! validate_file( $module, $this->get_available() );
|
||||
}
|
||||
|
||||
/**
|
||||
* Update module status.
|
||||
*
|
||||
* @param string $module - module slug.
|
||||
* @param boolean $active - true to activate, false to deactivate.
|
||||
* @param bool $exit Should exit be called after deactivation.
|
||||
* @param bool $redirect Should there be a redirection after activation.
|
||||
*/
|
||||
public function update_status( $module, $active, $exit = true, $redirect = true ) {
|
||||
return $active ? $this->activate( $module, $exit, $redirect ) : $this->deactivate( $module );
|
||||
}
|
||||
|
||||
/**
|
||||
* Activate a module.
|
||||
*
|
||||
* @param string $module Module slug.
|
||||
* @param bool $exit Should exit be called after deactivation.
|
||||
* @param bool $redirect Should there be a redirection after activation.
|
||||
*
|
||||
* @return bool|void
|
||||
*/
|
||||
public function activate( $module, $exit = true, $redirect = true ) {
|
||||
/**
|
||||
* Fires before a module is activated.
|
||||
*
|
||||
* @since 2.6.0
|
||||
*
|
||||
* @param string $module Module slug.
|
||||
* @param bool $exit Should we exit after the module has been activated. Default to true.
|
||||
* @param bool $redirect Should the user be redirected after module activation? Default to true.
|
||||
*/
|
||||
do_action( 'jetpack_pre_activate_module', $module, $exit, $redirect );
|
||||
|
||||
if ( ! strlen( $module ) ) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// If it's already active, then don't do it again.
|
||||
$active = $this->get_active();
|
||||
foreach ( $active as $act ) {
|
||||
if ( $act === $module ) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
if ( ! $this->is_module( $module ) ) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Jetpack plugin only
|
||||
if ( class_exists( 'Jetpack' ) ) {
|
||||
|
||||
$module_data = $this->get( $module );
|
||||
|
||||
$status = new Status();
|
||||
$state = new CookieState();
|
||||
|
||||
if ( ! \Jetpack::is_connection_ready() ) {
|
||||
if ( ! $status->is_offline_mode() && ! $status->is_onboarding() ) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// If we're not connected but in offline mode, make sure the module doesn't require a connection.
|
||||
if ( $status->is_offline_mode() && $module_data['requires_connection'] ) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
if ( class_exists( 'Jetpack_Client_Server' ) ) {
|
||||
$jetpack = \Jetpack::init();
|
||||
|
||||
// Check and see if the old plugin is active.
|
||||
if ( isset( $jetpack->plugins_to_deactivate[ $module ] ) ) {
|
||||
// Deactivate the old plugin.
|
||||
if ( \Jetpack_Client_Server::deactivate_plugin( $jetpack->plugins_to_deactivate[ $module ][0], $jetpack->plugins_to_deactivate[ $module ][1] ) ) {
|
||||
// If we deactivated the old plugin, remembere that with ::state() and redirect back to this page to activate the module
|
||||
// We can't activate the module on this page load since the newly deactivated old plugin is still loaded on this page load.
|
||||
$state->state( 'deactivated_plugins', $module );
|
||||
wp_safe_redirect( add_query_arg( 'jetpack_restate', 1 ) );
|
||||
exit;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Protect won't work with mis-configured IPs.
|
||||
if ( 'protect' === $module && Constants::is_defined( 'JETPACK__PLUGIN_DIR' ) ) {
|
||||
include_once JETPACK__PLUGIN_DIR . 'modules/protect/shared-functions.php';
|
||||
if ( ! jetpack_protect_get_ip() ) {
|
||||
$state->state( 'message', 'protect_misconfigured_ip' );
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
if ( class_exists( 'Jetpack_Plan' ) && ! \Jetpack_Plan::supports( $module ) ) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Check the file for fatal errors, a la wp-admin/plugins.php::activate.
|
||||
$errors = new Errors();
|
||||
$state->state( 'module', $module );
|
||||
$state->state( 'error', 'module_activation_failed' ); // we'll override this later if the plugin can be included without fatal error.
|
||||
$errors->catch_errors( true );
|
||||
|
||||
ob_start();
|
||||
$module_path = $this->get_path( $module );
|
||||
if ( file_exists( $module_path ) ) {
|
||||
require $this->get_path( $module ); // phpcs:ignore WordPressVIPMinimum.Files.IncludingFile.NotAbsolutePath
|
||||
}
|
||||
|
||||
$active[] = $module;
|
||||
$this->update_active( $active );
|
||||
|
||||
$state->state( 'error', false ); // the override.
|
||||
ob_end_clean();
|
||||
$errors->catch_errors( false );
|
||||
} else { // Not a Jetpack plugin.
|
||||
$active[] = $module;
|
||||
$this->update_active( $active );
|
||||
}
|
||||
|
||||
if ( $redirect ) {
|
||||
wp_safe_redirect( ( new Paths() )->admin_url( 'page=jetpack' ) );
|
||||
}
|
||||
if ( $exit ) {
|
||||
exit;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Deactivate module.
|
||||
*
|
||||
* @param string $module Module slug.
|
||||
*
|
||||
* @return bool
|
||||
*/
|
||||
public function deactivate( $module ) {
|
||||
/**
|
||||
* Fires when a module is deactivated.
|
||||
*
|
||||
* @since 1.9.0
|
||||
*
|
||||
* @param string $module Module slug.
|
||||
*/
|
||||
do_action( 'jetpack_pre_deactivate_module', $module );
|
||||
|
||||
$active = $this->get_active();
|
||||
$new = array_filter( array_diff( $active, (array) $module ) );
|
||||
|
||||
return $this->update_active( $new );
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate a module's path from its slug.
|
||||
*
|
||||
* @param string $slug Module slug.
|
||||
*/
|
||||
public function get_path( $slug ) {
|
||||
if ( ! Constants::is_defined( 'JETPACK__PLUGIN_DIR' ) ) {
|
||||
return '';
|
||||
}
|
||||
/**
|
||||
* Filters the path of a modules.
|
||||
*
|
||||
* @since 7.4.0
|
||||
*
|
||||
* @param array $return The absolute path to a module's root php file
|
||||
* @param string $slug The module slug
|
||||
*/
|
||||
return apply_filters( 'jetpack_get_module_path', JETPACK__PLUGIN_DIR . "modules/$slug.php", $slug );
|
||||
}
|
||||
|
||||
/**
|
||||
* Saves all the currently active modules to options.
|
||||
* Also fires Action hooks for each newly activated and deactivated module.
|
||||
*
|
||||
* @param array $modules Array of active modules to be saved in options.
|
||||
*
|
||||
* @return $success bool true for success, false for failure.
|
||||
*/
|
||||
public function update_active( $modules ) {
|
||||
$current_modules = \Jetpack_Options::get_option( 'active_modules', array() );
|
||||
$active_modules = $this->get_active();
|
||||
$new_active_modules = array_diff( $modules, $current_modules );
|
||||
$new_inactive_modules = array_diff( $active_modules, $modules );
|
||||
$new_current_modules = array_diff( array_merge( $current_modules, $new_active_modules ), $new_inactive_modules );
|
||||
$reindexed_modules = array_values( $new_current_modules );
|
||||
$success = \Jetpack_Options::update_option( 'active_modules', array_unique( $reindexed_modules ) );
|
||||
// Let's take `pre_update_option_jetpack_active_modules` filter into account
|
||||
// and actually decide for which modules we need to fire hooks by comparing
|
||||
// the 'active_modules' option before and after the update.
|
||||
$current_modules_post_update = \Jetpack_Options::get_option( 'active_modules', array() );
|
||||
|
||||
$new_inactive_modules = array_diff( $current_modules, $current_modules_post_update );
|
||||
$new_inactive_modules = array_unique( $new_inactive_modules );
|
||||
$new_inactive_modules = array_values( $new_inactive_modules );
|
||||
|
||||
$new_active_modules = array_diff( $current_modules_post_update, $current_modules );
|
||||
$new_active_modules = array_unique( $new_active_modules );
|
||||
$new_active_modules = array_values( $new_active_modules );
|
||||
|
||||
foreach ( $new_active_modules as $module ) {
|
||||
/**
|
||||
* Fires when a specific module is activated.
|
||||
*
|
||||
* @since 1.9.0
|
||||
*
|
||||
* @param string $module Module slug.
|
||||
* @param boolean $success whether the module was activated. @since 4.2
|
||||
*/
|
||||
do_action( 'jetpack_activate_module', $module, $success );
|
||||
/**
|
||||
* Fires when a module is activated.
|
||||
* The dynamic part of the filter, $module, is the module slug.
|
||||
*
|
||||
* @since 1.9.0
|
||||
*
|
||||
* @param string $module Module slug.
|
||||
*/
|
||||
do_action( "jetpack_activate_module_$module", $module );
|
||||
}
|
||||
|
||||
foreach ( $new_inactive_modules as $module ) {
|
||||
/**
|
||||
* Fired after a module has been deactivated.
|
||||
*
|
||||
* @since 4.2.0
|
||||
*
|
||||
* @param string $module Module slug.
|
||||
* @param boolean $success whether the module was deactivated.
|
||||
*/
|
||||
do_action( 'jetpack_deactivate_module', $module, $success );
|
||||
/**
|
||||
* Fires when a module is deactivated.
|
||||
* The dynamic part of the filter, $module, is the module slug.
|
||||
*
|
||||
* @since 1.9.0
|
||||
*
|
||||
* @param string $module Module slug.
|
||||
*/
|
||||
do_action( "jetpack_deactivate_module_$module", $module );
|
||||
}
|
||||
|
||||
return $success;
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,28 @@
|
||||
<?php
|
||||
/**
|
||||
* A Path & URL utility class for Jetpack.
|
||||
*
|
||||
* @package automattic/jetpack-status
|
||||
*/
|
||||
|
||||
namespace Automattic\Jetpack;
|
||||
|
||||
/**
|
||||
* Class Automattic\Jetpack\Paths
|
||||
*
|
||||
* Used to retrieve information about files.
|
||||
*/
|
||||
class Paths {
|
||||
/**
|
||||
* Jetpack Admin URL.
|
||||
*
|
||||
* @param array $args Query string args.
|
||||
*
|
||||
* @return string Jetpack admin URL.
|
||||
*/
|
||||
public function admin_url( $args = null ) {
|
||||
$args = wp_parse_args( $args, array( 'page' => 'jetpack' ) );
|
||||
$url = add_query_arg( $args, admin_url( 'admin.php' ) );
|
||||
return $url;
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,355 @@
|
||||
<?php
|
||||
/**
|
||||
* A status class for Jetpack.
|
||||
*
|
||||
* @package automattic/jetpack-status
|
||||
*/
|
||||
|
||||
namespace Automattic\Jetpack;
|
||||
|
||||
use Automattic\Jetpack\Status\Cache;
|
||||
use Automattic\Jetpack\Status\Host;
|
||||
use WPCOM_Masterbar;
|
||||
|
||||
/**
|
||||
* Class Automattic\Jetpack\Status
|
||||
*
|
||||
* Used to retrieve information about the current status of Jetpack and the site overall.
|
||||
*/
|
||||
class Status {
|
||||
/**
|
||||
* Is Jetpack in development (offline) mode?
|
||||
*
|
||||
* @deprecated 1.3.0 Use Status->is_offline_mode().
|
||||
*
|
||||
* @return bool Whether Jetpack's offline mode is active.
|
||||
*/
|
||||
public function is_development_mode() {
|
||||
_deprecated_function( __FUNCTION__, '1.3.0', 'Automattic\Jetpack\Status->is_offline_mode' );
|
||||
return $this->is_offline_mode();
|
||||
}
|
||||
|
||||
/**
|
||||
* Is Jetpack in offline mode?
|
||||
*
|
||||
* This was formerly called "Development Mode", but sites "in development" aren't always offline/localhost.
|
||||
*
|
||||
* @since 1.3.0
|
||||
*
|
||||
* @return bool Whether Jetpack's offline mode is active.
|
||||
*/
|
||||
public function is_offline_mode() {
|
||||
$cached = Cache::get( 'is_offline_mode' );
|
||||
if ( null !== $cached ) {
|
||||
return $cached;
|
||||
}
|
||||
|
||||
$offline_mode = false;
|
||||
|
||||
if ( defined( '\\JETPACK_DEV_DEBUG' ) ) {
|
||||
$offline_mode = constant( '\\JETPACK_DEV_DEBUG' );
|
||||
} elseif ( defined( '\\WP_LOCAL_DEV' ) ) {
|
||||
$offline_mode = constant( '\\WP_LOCAL_DEV' );
|
||||
} elseif ( $this->is_local_site() ) {
|
||||
$offline_mode = true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Filters Jetpack's offline mode.
|
||||
*
|
||||
* @see https://jetpack.com/support/development-mode/
|
||||
* @todo Update documentation ^^.
|
||||
*
|
||||
* @since 1.1.1
|
||||
* @since-jetpack 2.2.1
|
||||
* @deprecated 1.3.0
|
||||
*
|
||||
* @param bool $offline_mode Is Jetpack's offline mode active.
|
||||
*/
|
||||
$offline_mode = (bool) apply_filters_deprecated( 'jetpack_development_mode', array( $offline_mode ), '1.3.0', 'jetpack_offline_mode' );
|
||||
|
||||
/**
|
||||
* Filters Jetpack's offline mode.
|
||||
*
|
||||
* @see https://jetpack.com/support/development-mode/
|
||||
* @todo Update documentation ^^.
|
||||
*
|
||||
* @since 1.3.0
|
||||
*
|
||||
* @param bool $offline_mode Is Jetpack's offline mode active.
|
||||
*/
|
||||
$offline_mode = (bool) apply_filters( 'jetpack_offline_mode', $offline_mode );
|
||||
|
||||
Cache::set( 'is_offline_mode', $offline_mode );
|
||||
return $offline_mode;
|
||||
}
|
||||
|
||||
/**
|
||||
* Is Jetpack in "No User test mode"?
|
||||
*
|
||||
* This will make Jetpack act as if there were no connected users, but only a site connection (aka blog token)
|
||||
*
|
||||
* @since 1.6.0
|
||||
* @deprecated 1.7.5 Since this version, Jetpack connection is considered active after registration, making no_user_testing_mode obsolete.
|
||||
*
|
||||
* @return bool Whether Jetpack's No User Testing Mode is active.
|
||||
*/
|
||||
public function is_no_user_testing_mode() {
|
||||
_deprecated_function( __METHOD__, '1.7.5' );
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Whether this is a system with a multiple networks.
|
||||
* Implemented since there is no core is_multi_network function.
|
||||
* Right now there is no way to tell which network is the dominant network on the system.
|
||||
*
|
||||
* @return boolean
|
||||
*/
|
||||
public function is_multi_network() {
|
||||
global $wpdb;
|
||||
|
||||
$cached = Cache::get( 'is_multi_network' );
|
||||
if ( null !== $cached ) {
|
||||
return $cached;
|
||||
}
|
||||
|
||||
// If we don't have a multi site setup no need to do any more.
|
||||
if ( ! is_multisite() ) {
|
||||
Cache::set( 'is_multi_network', false );
|
||||
return false;
|
||||
}
|
||||
|
||||
$num_sites = $wpdb->get_var( "SELECT COUNT(*) FROM {$wpdb->site}" );
|
||||
if ( $num_sites > 1 ) {
|
||||
Cache::set( 'is_multi_network', true );
|
||||
return true;
|
||||
}
|
||||
|
||||
Cache::set( 'is_multi_network', false );
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Whether the current site is single user site.
|
||||
*
|
||||
* @return bool
|
||||
*/
|
||||
public function is_single_user_site() {
|
||||
global $wpdb;
|
||||
|
||||
$ret = Cache::get( 'is_single_user_site' );
|
||||
if ( null === $ret ) {
|
||||
$some_users = get_transient( 'jetpack_is_single_user' );
|
||||
if ( false === $some_users ) {
|
||||
$some_users = $wpdb->get_var( "SELECT COUNT(*) FROM (SELECT user_id FROM $wpdb->usermeta WHERE meta_key = '{$wpdb->prefix}capabilities' LIMIT 2) AS someusers" );
|
||||
set_transient( 'jetpack_is_single_user', (int) $some_users, 12 * HOUR_IN_SECONDS );
|
||||
}
|
||||
$ret = 1 === (int) $some_users;
|
||||
Cache::set( 'is_single_user_site', $ret );
|
||||
}
|
||||
return $ret;
|
||||
}
|
||||
|
||||
/**
|
||||
* If the site is a local site.
|
||||
*
|
||||
* @since 1.3.0
|
||||
*
|
||||
* @return bool
|
||||
*/
|
||||
public function is_local_site() {
|
||||
$cached = Cache::get( 'is_local_site' );
|
||||
if ( null !== $cached ) {
|
||||
return $cached;
|
||||
}
|
||||
|
||||
$site_url = site_url();
|
||||
|
||||
// Check for localhost and sites using an IP only first.
|
||||
$is_local = $site_url && false === strpos( $site_url, '.' );
|
||||
|
||||
// @todo Remove function_exists when the package has a documented minimum WP version.
|
||||
// Use Core's environment check, if available. Added in 5.5.0 / 5.5.1 (for `local` return value).
|
||||
if ( function_exists( 'wp_get_environment_type' ) && 'local' === wp_get_environment_type() ) {
|
||||
$is_local = true;
|
||||
}
|
||||
|
||||
// Then check for usual usual domains used by local dev tools.
|
||||
$known_local = array(
|
||||
'#\.local$#i',
|
||||
'#\.localhost$#i',
|
||||
'#\.test$#i',
|
||||
'#\.docksal$#i', // Docksal.
|
||||
'#\.docksal\.site$#i', // Docksal.
|
||||
'#\.dev\.cc$#i', // ServerPress.
|
||||
'#\.lndo\.site$#i', // Lando.
|
||||
);
|
||||
|
||||
if ( ! $is_local ) {
|
||||
foreach ( $known_local as $url ) {
|
||||
if ( preg_match( $url, $site_url ) ) {
|
||||
$is_local = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Filters is_local_site check.
|
||||
*
|
||||
* @since 1.3.0
|
||||
*
|
||||
* @param bool $is_local If the current site is a local site.
|
||||
*/
|
||||
$is_local = apply_filters( 'jetpack_is_local_site', $is_local );
|
||||
|
||||
Cache::set( 'is_local_site', $is_local );
|
||||
return $is_local;
|
||||
}
|
||||
|
||||
/**
|
||||
* If is a staging site.
|
||||
*
|
||||
* @todo Add IDC detection to a package.
|
||||
*
|
||||
* @return bool
|
||||
*/
|
||||
public function is_staging_site() {
|
||||
$cached = Cache::get( 'is_staging_site' );
|
||||
if ( null !== $cached ) {
|
||||
return $cached;
|
||||
}
|
||||
|
||||
// @todo Remove function_exists when the package has a documented minimum WP version.
|
||||
// Core's wp_get_environment_type allows for a few specific options. We should default to bowing out gracefully for anything other than production or local.
|
||||
$is_staging = function_exists( 'wp_get_environment_type' ) && ! in_array( wp_get_environment_type(), array( 'production', 'local' ), true );
|
||||
|
||||
$known_staging = array(
|
||||
'urls' => array(
|
||||
'#\.staging\.wpengine\.com$#i', // WP Engine. This is their legacy staging URL structure. Their new platform does not have a common URL. https://github.com/Automattic/jetpack/issues/21504
|
||||
'#\.staging\.kinsta\.com$#i', // Kinsta.com.
|
||||
'#\.kinsta\.cloud$#i', // Kinsta.com.
|
||||
'#\.stage\.site$#i', // DreamPress.
|
||||
'#\.newspackstaging\.com$#i', // Newspack.
|
||||
'#\.pantheonsite\.io$#i', // Pantheon.
|
||||
'#\.flywheelsites\.com$#i', // Flywheel.
|
||||
'#\.flywheelstaging\.com$#i', // Flywheel.
|
||||
'#\.cloudwaysapps\.com$#i', // Cloudways.
|
||||
'#\.azurewebsites\.net$#i', // Azure.
|
||||
'#\.wpserveur\.net$#i', // WPServeur.
|
||||
'#\-liquidwebsites\.com$#i', // Liquidweb.
|
||||
),
|
||||
'constants' => array(
|
||||
'IS_WPE_SNAPSHOT', // WP Engine. This is used on their legacy staging environment. Their new platform does not have a constant. https://github.com/Automattic/jetpack/issues/21504
|
||||
'KINSTA_DEV_ENV', // Kinsta.com.
|
||||
'WPSTAGECOACH_STAGING', // WP Stagecoach.
|
||||
'JETPACK_STAGING_MODE', // Generic.
|
||||
'WP_LOCAL_DEV', // Generic.
|
||||
),
|
||||
);
|
||||
/**
|
||||
* Filters the flags of known staging sites.
|
||||
*
|
||||
* @since 1.1.1
|
||||
* @since-jetpack 3.9.0
|
||||
*
|
||||
* @param array $known_staging {
|
||||
* An array of arrays that each are used to check if the current site is staging.
|
||||
* @type array $urls URLs of staging sites in regex to check against site_url.
|
||||
* @type array $constants PHP constants of known staging/developement environments.
|
||||
* }
|
||||
*/
|
||||
$known_staging = apply_filters( 'jetpack_known_staging', $known_staging );
|
||||
|
||||
if ( isset( $known_staging['urls'] ) ) {
|
||||
$site_url = site_url();
|
||||
foreach ( $known_staging['urls'] as $url ) {
|
||||
if ( preg_match( $url, wp_parse_url( $site_url, PHP_URL_HOST ) ) ) {
|
||||
$is_staging = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if ( isset( $known_staging['constants'] ) ) {
|
||||
foreach ( $known_staging['constants'] as $constant ) {
|
||||
if ( defined( $constant ) && constant( $constant ) ) {
|
||||
$is_staging = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Last, let's check if sync is erroring due to an IDC. If so, set the site to staging mode.
|
||||
if ( ! $is_staging && method_exists( 'Automattic\\Jetpack\\Identity_Crisis', 'validate_sync_error_idc_option' ) && \Automattic\Jetpack\Identity_Crisis::validate_sync_error_idc_option() ) {
|
||||
$is_staging = true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Filters is_staging_site check.
|
||||
*
|
||||
* @since 1.1.1
|
||||
* @since-jetpack 3.9.0
|
||||
*
|
||||
* @param bool $is_staging If the current site is a staging site.
|
||||
*/
|
||||
$is_staging = apply_filters( 'jetpack_is_staging_site', $is_staging );
|
||||
|
||||
Cache::set( 'is_staging_site', $is_staging );
|
||||
return $is_staging;
|
||||
}
|
||||
|
||||
/**
|
||||
* Whether the site is currently onboarding or not.
|
||||
* A site is considered as being onboarded if it currently has an onboarding token.
|
||||
*
|
||||
* @since-jetpack 5.8
|
||||
*
|
||||
* @access public
|
||||
* @static
|
||||
*
|
||||
* @return bool True if the site is currently onboarding, false otherwise
|
||||
*/
|
||||
public function is_onboarding() {
|
||||
return \Jetpack_Options::get_option( 'onboarding' ) !== false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the site slug suffix to be used as part of Calypso URLs.
|
||||
*
|
||||
* Strips http:// or https:// from a url, replaces forward slash with ::.
|
||||
*
|
||||
* @since 1.6.0
|
||||
*
|
||||
* @param string $url Optional. URL to build the site suffix from. Default: Home URL.
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function get_site_suffix( $url = '' ) {
|
||||
// On WordPress.com, site suffixes are a bit different.
|
||||
if ( method_exists( 'WPCOM_Masterbar', 'get_calypso_site_slug' ) ) {
|
||||
return WPCOM_Masterbar::get_calypso_site_slug( get_current_blog_id() );
|
||||
}
|
||||
|
||||
// Grab the 'site_url' option for WoA sites to avoid plugins to interfere with the site
|
||||
// identifier (e.g. i18n plugins may change the main url to '<DOMAIN>/<LOCALE>', but we
|
||||
// want to exclude the locale since it's not part of the site suffix).
|
||||
if ( ( new Host() )->is_woa_site() ) {
|
||||
$url = \site_url();
|
||||
}
|
||||
|
||||
if ( empty( $url ) ) {
|
||||
// WordPress can be installed in subdirectories (e.g. make.wordpress.org/plugins)
|
||||
// where the 'site_url' option points to the root domain (e.g. make.wordpress.org)
|
||||
// which could collide with another site in the same domain but with WordPress
|
||||
// installed in a different subdirectory (e.g. make.wordpress.org/core). To avoid
|
||||
// such collision, we identify the site with the 'home_url' option.
|
||||
$url = \home_url();
|
||||
}
|
||||
|
||||
$url = preg_replace( '#^.*?://#', '', $url );
|
||||
$url = str_replace( '/', '::', $url );
|
||||
|
||||
return rtrim( $url, ':' );
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,44 @@
|
||||
<?php
|
||||
/**
|
||||
* Status and information regarding the site visitor.
|
||||
*
|
||||
* @package automattic/jetpack-status
|
||||
*/
|
||||
|
||||
namespace Automattic\Jetpack\Status;
|
||||
|
||||
/**
|
||||
* Visitor class.
|
||||
*/
|
||||
class Visitor {
|
||||
|
||||
/**
|
||||
* Gets current user IP address.
|
||||
*
|
||||
* @param bool $check_all_headers Check all headers? Default is `false`.
|
||||
*
|
||||
* @return string Current user IP address.
|
||||
*/
|
||||
public function get_ip( $check_all_headers = false ) {
|
||||
if ( $check_all_headers ) {
|
||||
foreach ( array(
|
||||
'HTTP_CF_CONNECTING_IP',
|
||||
'HTTP_CLIENT_IP',
|
||||
'HTTP_X_FORWARDED_FOR',
|
||||
'HTTP_X_FORWARDED',
|
||||
'HTTP_X_CLUSTER_CLIENT_IP',
|
||||
'HTTP_FORWARDED_FOR',
|
||||
'HTTP_FORWARDED',
|
||||
'HTTP_VIA',
|
||||
) as $key ) {
|
||||
if ( ! empty( $_SERVER[ $key ] ) ) {
|
||||
// @todo Some of these might actually be lists of IPs (e.g. HTTP_X_FORWARDED_FOR) or something else entirely (HTTP_VIA).
|
||||
return filter_var( wp_unslash( $_SERVER[ $key ] ) );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return ! empty( $_SERVER['REMOTE_ADDR'] ) ? filter_var( wp_unslash( $_SERVER['REMOTE_ADDR'] ) ) : '';
|
||||
}
|
||||
|
||||
}
|
||||
Reference in New Issue
Block a user