<?php

/**

 * Upgrade API: WP_Automatic_Updater class

 *

 * @package WordPress

 * @subpackage Upgrader

 * @since 4.6.0

 */

/**

 * Core class used for handling automatic background updates.

 *

 * @since 3.7.0

 * @since 4.6.0 Moved to its own file from wp-admin/includes/class-wp-upgrader.php.

 */

#[AllowDynamicProperties]

class WP_Automatic_Updater {

	/**

	 * Tracks update results during processing.

	 *

	 * @var array

	 */

	protected $update_results = array();

	/**

	 * Determines whether the entire automatic updater is disabled.

	 *

	 * @since 3.7.0

	 *

	 * @return bool True if the automatic updater is disabled, false otherwise.

	 */

	public function is_disabled() {

		// Background updates are disabled if you don't want file changes.

		if ( ! wp_is_file_mod_allowed( 'automatic_updater' ) ) {

			return true;

		}

		if ( wp_installing() ) {

			return true;

		}

		// More fine grained control can be done through the WP_AUTO_UPDATE_CORE constant and filters.

		$disabled = defined( 'AUTOMATIC_UPDATER_DISABLED' ) && AUTOMATIC_UPDATER_DISABLED;

		/**

		 * Filters whether to entirely disable background updates.

		 *

		 * There are more fine-grained filters and controls for selective disabling.

		 * This filter parallels the AUTOMATIC_UPDATER_DISABLED constant in name.

		 *

		 * This also disables update notification emails. That may change in the future.

		 *

		 * @since 3.7.0

		 *

		 * @param bool $disabled Whether the updater should be disabled.

		 */

		return apply_filters( 'automatic_updater_disabled', $disabled );

	}

	/**

	 * Checks whether access to a given directory is allowed.

	 *

	 * This is used when detecting version control checkouts. Takes into account

	 * the PHP `open_basedir` restrictions, so that WordPress does not try to access

	 * directories it is not allowed to.

	 *

	 * @since 6.2.0

	 *

	 * @param string $dir The directory to check.

	 * @return bool True if access to the directory is allowed, false otherwise.

	 */

	public function is_allowed_dir( $dir ) {

		if ( is_string( $dir ) ) {

			$dir = trim( $dir );

		}

		if ( ! is_string( $dir ) || '' === $dir ) {

			_doing_it_wrong(

				__METHOD__,

				sprintf(

					/* translators: %s: The "$dir" argument. */

					__( 'The "%s" argument must be a non-empty string.' ),

					'$dir'

				),

				'6.2.0'

			);

			return false;

		}

		$open_basedir = ini_get( 'open_basedir' );

		if ( empty( $open_basedir ) ) {

			return true;

		}

		$open_basedir_list = explode( PATH_SEPARATOR, $open_basedir );

		foreach ( $open_basedir_list as $basedir ) {

			if ( '' !== trim( $basedir ) && str_starts_with( $dir, $basedir ) ) {

				return true;

			}

		}

		return false;

	}

	/**

	 * Checks for version control checkouts.

	 *

	 * Checks for Subversion, Git, Mercurial, and Bazaar. It recursively looks up the

	 * filesystem to the top of the drive, erring on the side of detecting a VCS

	 * checkout somewhere.

	 *

	 * ABSPATH is always checked in addition to whatever `$context` is (which may be the

	 * wp-content directory, for example). The underlying assumption is that if you are

	 * using version control *anywhere*, then you should be making decisions for

	 * how things get updated.

	 *

	 * @since 3.7.0

	 *

	 * @param string $context The filesystem path to check, in addition to ABSPATH.

	 * @return bool True if a VCS checkout was discovered at `$context` or ABSPATH,

	 *              or anywhere higher. False otherwise.

	 */

	public function is_vcs_checkout( $context ) {

		$context_dirs = array( untrailingslashit( $context ) );

		if ( ABSPATH !== $context ) {

			$context_dirs[] = untrailingslashit( ABSPATH );

		}

		$vcs_dirs   = array( '.svn', '.git', '.hg', '.bzr' );

		$check_dirs = array();

		foreach ( $context_dirs as $context_dir ) {

			// Walk up from $context_dir to the root.

			do {

				$check_dirs[] = $context_dir;

				// Once we've hit '/' or 'C:\', we need to stop. dirname will keep returning the input here.

				if ( dirname( $context_dir ) === $context_dir ) {

					break;

				}

				// Continue one level at a time.

			} while ( $context_dir = dirname( $context_dir ) );

		}

		$check_dirs = array_unique( $check_dirs );

		$checkout   = false;

		// Search all directories we've found for evidence of version control.

		foreach ( $vcs_dirs as $vcs_dir ) {

			foreach ( $check_dirs as $check_dir ) {

				if ( ! $this->is_allowed_dir( $check_dir ) ) {

					continue;

				}

				$checkout = is_dir( rtrim( $check_dir, '\\/' ) . "/$vcs_dir" );

				if ( $checkout ) {

					break 2;

				}

			}

		}

		/**

		 * Filters whether the automatic updater should consider a filesystem

		 * location to be potentially managed by a version control system.

		 *

		 * @since 3.7.0

		 *

		 * @param bool $checkout  Whether a VCS checkout was discovered at `$context`

		 *                        or ABSPATH, or anywhere higher.

		 * @param string $context The filesystem context (a path) against which

		 *                        filesystem status should be checked.

		 */

		return apply_filters( 'automatic_updates_is_vcs_checkout', $checkout, $context );

	}

	/**

	 * Tests to see if we can and should update a specific item.

	 *

	 * @since 3.7.0

	 *

	 * @global wpdb $wpdb WordPress database abstraction object.

	 *

	 * @param string $type    The type of update being checked: 'core', 'theme',

	 *                        'plugin', 'translation'.

	 * @param object $item    The update offer.

	 * @param string $context The filesystem context (a path) against which filesystem

	 *                        access and status should be checked.

	 * @return bool True if the item should be updated, false otherwise.

	 */

	public function should_update( $type, $item, $context ) {

		// Used to see if WP_Filesystem is set up to allow unattended updates.

		$skin = new Automatic_Upgrader_Skin();

		if ( $this->is_disabled() ) {

			return false;

		}

		// Only relax the filesystem checks when the update doesn't include new files.

		$allow_relaxed_file_ownership = false;

		if ( 'core' === $type && isset( $item->new_files ) && ! $item->new_files ) {

			$allow_relaxed_file_ownership = true;

		}

		// If we can't do an auto core update, we may still be able to email the user.

		if ( ! $skin->request_filesystem_credentials( false, $context, $allow_relaxed_file_ownership )

			|| $this->is_vcs_checkout( $context )

		) {

			if ( 'core' === $type ) {

				$this->send_core_update_notification_email( $item );

			}

			return false;

		}

		// Next up, is this an item we can update?

		if ( 'core' === $type ) {

			$update = Core_Upgrader::should_update_to_version( $item->current );

		} elseif ( 'plugin' === $type || 'theme' === $type ) {

			$update = ! empty( $item->autoupdate );

			if ( ! $update && wp_is_auto_update_enabled_for_type( $type ) ) {

				// Check if the site admin has enabled auto-updates by default for the specific item.

				$auto_updates = (array) get_site_option( "auto_update_{$type}s", array() );

				$update       = in_array( $item->{$type}, $auto_updates, true );

			}

		} else {

			$update = ! empty( $item->autoupdate );

		}

		// If the `disable_autoupdate` flag is set, override any user-choice, but allow filters.

		if ( ! empty( $item->disable_autoupdate ) ) {

			$update = false;

		}

		/**

		 * Filters whether to automatically update core, a plugin, a theme, or a language.

		 *

		 * The dynamic portion of the hook name, `$type`, refers to the type of update

		 * being checked.

		 *

		 * Possible hook names include:

		 *

		 *  - `auto_update_core`

		 *  - `auto_update_plugin`

		 *  - `auto_update_theme`

		 *  - `auto_update_translation`

		 *

		 * Since WordPress 3.7, minor and development versions of core, and translations have

		 * been auto-updated by default. New installs on WordPress 5.6 or higher will also

		 * auto-update major versions by default. Starting in 5.6, older sites can opt-in to

		 * major version auto-updates, and auto-updates for plugins and themes.

		 *

		 * See the {@see 'allow_dev_auto_core_updates'}, {@see 'allow_minor_auto_core_updates'},

		 * and {@see 'allow_major_auto_core_updates'} filters for a more straightforward way to

		 * adjust core updates.

		 *

		 * @since 3.7.0

		 * @since 5.5.0 The `$update` parameter accepts the value of null.

		 *

		 * @param bool|null $update Whether to update. The value of null is internally used

		 *                          to detect whether nothing has hooked into this filter.

		 * @param object    $item   The update offer.

		 */

		$update = apply_filters( "auto_update_{$type}", $update, $item );

		if ( ! $update ) {

			if ( 'core' === $type ) {

				$this->send_core_update_notification_email( $item );

			}

			return false;

		}

		// If it's a core update, are we actually compatible with its requirements?

		if ( 'core' === $type ) {

			global $wpdb;

			$php_compat = version_compare( PHP_VERSION, $item->php_version, '>=' );

			if ( file_exists( WP_CONTENT_DIR . '/db.php' ) && empty( $wpdb->is_mysql ) ) {

				$mysql_compat = true;

			} else {

				$mysql_compat = version_compare( $wpdb->db_version(), $item->mysql_version, '>=' );

			}

			if ( ! $php_compat || ! $mysql_compat ) {

				return false;

			}

		}

		// If updating a plugin or theme, ensure the minimum PHP version requirements are satisfied.

		if ( in_array( $type, array( 'plugin', 'theme' ), true ) ) {

			if ( ! empty( $item->requires_php ) && version_compare( PHP_VERSION, $item->requires_php, '<' ) ) {

				return false;

			}

		}

		return true;

	}

	/**

	 * Notifies an administrator of a core update.

	 *

	 * @since 3.7.0

	 *

	 * @param object $item The update offer.

	 * @return bool True if the site administrator is notified of a core update,

	 *              false otherwise.

	 */

	protected function send_core_update_notification_email( $item ) {

		$notified = get_site_option( 'auto_core_update_notified' );

		// Don't notify if we've already notified the same email address of the same version.

		if ( $notified

			&& get_site_option( 'admin_email' ) === $notified['email']

			&& $notified['version'] === $item->current

		) {

			return false;

		}

		// See if we need to notify users of a core update.

		$notify = ! empty( $item->notify_email );

		/**

		 * Filters whether to notify the site administrator of a new core update.

		 *

		 * By default, administrators are notified when the update offer received

		 * from WordPress.org sets a particular flag. This allows some discretion

		 * in if and when to notify.

		 *

		 * This filter is only evaluated once per release. If the same email address

		 * was already notified of the same new version, WordPress won't repeatedly

		 * email the administrator.

		 *

		 * This filter is also used on about.php to check if a plugin has disabled

		 * these notifications.

		 *

		 * @since 3.7.0

		 *

		 * @param bool   $notify Whether the site administrator is notified.

		 * @param object $item   The update offer.

		 */

		if ( ! apply_filters( 'send_core_update_notification_email', $notify, $item ) ) {

			return false;

		}

		$this->send_email( 'manual', $item );

		return true;

	}

	/**

	 * Updates an item, if appropriate.

	 *

	 * @since 3.7.0

	 *

	 * @param string $type The type of update being checked: 'core', 'theme', 'plugin', 'translation'.

	 * @param object $item The update offer.

	 * @return null|WP_Error

	 */

	public function update( $type, $item ) {

		$skin = new Automatic_Upgrader_Skin();

		switch ( $type ) {

			case 'core':

				// The Core upgrader doesn't use the Upgrader's skin during the actual main part of the upgrade, instead, firing a filter.

				add_filter( 'update_feedback', array( $skin, 'feedback' ) );

				$upgrader = new Core_Upgrader( $skin );

				$context  = ABSPATH;

				break;

			case 'plugin':

				$upgrader = new Plugin_Upgrader( $skin );

				$context  = WP_PLUGIN_DIR; // We don't support custom Plugin directories, or updates for WPMU_PLUGIN_DIR.

				break;

			case 'theme':

				$upgrader = new Theme_Upgrader( $skin );

				$context  = get_theme_root( $item->theme );

				break;

			case 'translation':

				$upgrader = new Language_Pack_Upgrader( $skin );

				$context  = WP_CONTENT_DIR; // WP_LANG_DIR;

				break;

		}

		// Determine whether we can and should perform this update.

		if ( ! $this->should_update( $type, $item, $context ) ) {

			return false;

		}

		/**

		 * Fires immediately prior to an auto-update.

		 *

		 * @since 4.4.0

		 *

		 * @param string $type    The type of update being checked: 'core', 'theme', 'plugin', or 'translation'.

		 * @param object $item    The update offer.

		 * @param string $context The filesystem context (a path) against which filesystem access and status

		 *                        should be checked.

		 */

		do_action( 'pre_auto_update', $type, $item, $context );

		$upgrader_item = $item;

		switch ( $type ) {

			case 'core':

				/* translators: %s: WordPress version. */

				$skin->feedback( __( 'Updating to WordPress %s' ), $item->version );

				/* translators: %s: WordPress version. */

				$item_name = sprintf( __( 'WordPress %s' ), $item->version );

				break;

			case 'theme':

				$upgrader_item = $item->theme;

				$theme         = wp_get_theme( $upgrader_item );

				$item_name     = $theme->Get( 'Name' );

				// Add the current version so that it can be reported in the notification email.

				$item->current_version = $theme->get( 'Version' );

				if ( empty( $item->current_version ) ) {

					$item->current_version = false;

				}

				/* translators: %s: Theme name. */

				$skin->feedback( __( 'Updating theme: %s' ), $item_name );

				break;

			case 'plugin':

				$upgrader_item = $item->plugin;

				$plugin_data   = get_plugin_data( $context . '/' . $upgrader_item );

				$item_name     = $plugin_data['Name'];

				// Add the current version so that it can be reported in the notification email.

				$item->current_version = $plugin_data['Version'];