wp-admin/includes/class-core-upgrader.php

   1 <?php
   2 /**
   3  * Upgrade API: Core_Upgrader class
   4  *
   5  * @package WordPress
   6  * @subpackage Upgrader
   7  * @since 4.6.0
   8  */
   9
  10 /**
  11  * Core class used for updating core.
  12  *
  13  * It allows for WordPress to upgrade itself in combination with
  14  * the wp-admin/includes/update-core.php file.
  15  *
  16  * @since 2.8.0
  17  * @since 4.6.0 Moved to its own file from wp-admin/includes/class-wp-upgrader.php.
  18  *
  19  * @see WP_Upgrader
  20  */
  21 class Core_Upgrader extends WP_Upgrader {
  22
  23         /**
  24          * Initialize the upgrade strings.
  25          *
  26          * @since 2.8.0
  27          * @access public
  28          */
  29         public function upgrade_strings() {
  30                 $this->strings['up_to_date'] = __('WordPress is at the latest version.');
  31                 $this->strings['locked'] = __('Another update is currently in progress.');
  32                 $this->strings['no_package'] = __('Update package not available.');
  33                 $this->strings['downloading_package'] = __('Downloading update from <span class="code">%s</span>&#8230;');
  34                 $this->strings['unpack_package'] = __('Unpacking the update&#8230;');
  35                 $this->strings['copy_failed'] = __('Could not copy files.');
  36                 $this->strings['copy_failed_space'] = __('Could not copy files. You may have run out of disk space.' );
  37                 $this->strings['start_rollback'] = __( 'Attempting to roll back to previous version.' );
  38                 $this->strings['rollback_was_required'] = __( 'Due to an error during updating, WordPress has rolled back to your previous version.' );
  39         }
  40
  41         /**
  42          * Upgrade WordPress core.
  43          *
  44          * @since 2.8.0
  45          * @access public
  46          *
  47          * @global WP_Filesystem_Base $wp_filesystem Subclass
  48          * @global callable           $_wp_filesystem_direct_method
  49          *
  50          * @param object $current Response object for whether WordPress is current.
  51          * @param array  $args {
  52          *        Optional. Arguments for upgrading WordPress core. Default empty array.
  53          *
  54          *        @type bool $pre_check_md5    Whether to check the file checksums before
  55          *                                     attempting the upgrade. Default true.
  56          *        @type bool $attempt_rollback Whether to attempt to rollback the chances if
  57          *                                     there is a problem. Default false.
  58          *        @type bool $do_rollback      Whether to perform this "upgrade" as a rollback.
  59          *                                     Default false.
  60          * }
  61          * @return null|false|WP_Error False or WP_Error on failure, null on success.
  62          */
  63         public function upgrade( $current, $args = array() ) {
  64                 global $wp_filesystem;
  65
  66                 include( ABSPATH . WPINC . '/version.php' ); // $wp_version;
  67
  68                 $start_time = time();
  69
  70                 $defaults = array(
  71                         'pre_check_md5'    => true,
  72                         'attempt_rollback' => false,
  73                         'do_rollback'      => false,
  74                         'allow_relaxed_file_ownership' => false,
  75                 );
  76                 $parsed_args = wp_parse_args( $args, $defaults );
  77
  78                 $this->init();
  79                 $this->upgrade_strings();
  80
  81                 // Is an update available?
  82                 if ( !isset( $current->response ) || $current->response == 'latest' )
  83                         return new WP_Error('up_to_date', $this->strings['up_to_date']);
  84
  85                 $res = $this->fs_connect( array( ABSPATH, WP_CONTENT_DIR ), $parsed_args['allow_relaxed_file_ownership'] );
  86                 if ( ! $res || is_wp_error( $res ) ) {
  87                         return $res;
  88                 }
  89
  90                 $wp_dir = trailingslashit($wp_filesystem->abspath());
  91
  92                 $partial = true;
  93                 if ( $parsed_args['do_rollback'] )
  94                         $partial = false;
  95                 elseif ( $parsed_args['pre_check_md5'] && ! $this->check_files() )
  96                         $partial = false;
  97
  98                 /*
  99                  * If partial update is returned from the API, use that, unless we're doing
 100                  * a reinstall. If we cross the new_bundled version number, then use
 101                  * the new_bundled zip. Don't though if the constant is set to skip bundled items.
 102                  * If the API returns a no_content zip, go with it. Finally, default to the full zip.
 103                  */
 104                 if ( $parsed_args['do_rollback'] && $current->packages->rollback )
 105                         $to_download = 'rollback';
 106                 elseif ( $current->packages->partial && 'reinstall' != $current->response && $wp_version == $current->partial_version && $partial )
 107                         $to_download = 'partial';
 108                 elseif ( $current->packages->new_bundled && version_compare( $wp_version, $current->new_bundled, '<' )
 109                         && ( ! defined( 'CORE_UPGRADE_SKIP_NEW_BUNDLED' ) || ! CORE_UPGRADE_SKIP_NEW_BUNDLED ) )
 110                         $to_download = 'new_bundled';
 111                 elseif ( $current->packages->no_content )
 112                         $to_download = 'no_content';
 113                 else
 114                         $to_download = 'full';
 115
 116                 // Lock to prevent multiple Core Updates occurring
 117                 $lock = WP_Upgrader::create_lock( 'core_updater', 15 * MINUTE_IN_SECONDS );
 118                 if ( ! $lock ) {
 119                         return new WP_Error( 'locked', $this->strings['locked'] );
 120                 }
 121
 122                 $download = $this->download_package( $current->packages->$to_download );
 123                 if ( is_wp_error( $download ) ) {
 124                         WP_Upgrader::release_lock( 'core_updater' );
 125                         return $download;
 126                 }
 127
 128                 $working_dir = $this->unpack_package( $download );
 129                 if ( is_wp_error( $working_dir ) ) {
 130                         WP_Upgrader::release_lock( 'core_updater' );
 131                         return $working_dir;
 132                 }
 133
 134                 // Copy update-core.php from the new version into place.
 135                 if ( !$wp_filesystem->copy($working_dir . '/wordpress/wp-admin/includes/update-core.php', $wp_dir . 'wp-admin/includes/update-core.php', true) ) {
 136                         $wp_filesystem->delete($working_dir, true);
 137                         WP_Upgrader::release_lock( 'core_updater' );
 138                         return new WP_Error( 'copy_failed_for_update_core_file', __( 'The update cannot be installed because we will be unable to copy some files. This is usually due to inconsistent file permissions.' ), 'wp-admin/includes/update-core.php' );
 139                 }
 140                 $wp_filesystem->chmod($wp_dir . 'wp-admin/includes/update-core.php', FS_CHMOD_FILE);
 141
 142                 require_once( ABSPATH . 'wp-admin/includes/update-core.php' );
 143
 144                 if ( ! function_exists( 'update_core' ) ) {
 145                         WP_Upgrader::release_lock( 'core_updater' );
 146                         return new WP_Error( 'copy_failed_space', $this->strings['copy_failed_space'] );
 147                 }
 148
 149                 $result = update_core( $working_dir, $wp_dir );
 150
 151                 // In the event of an issue, we may be able to roll back.
 152                 if ( $parsed_args['attempt_rollback'] && $current->packages->rollback && ! $parsed_args['do_rollback'] ) {
 153                         $try_rollback = false;
 154                         if ( is_wp_error( $result ) ) {
 155                                 $error_code = $result->get_error_code();
 156                                 /*
 157                                  * Not all errors are equal. These codes are critical: copy_failed__copy_dir,
 158                                  * mkdir_failed__copy_dir, copy_failed__copy_dir_retry, and disk_full.
 159                                  * do_rollback allows for update_core() to trigger a rollback if needed.
 160                                  */
 161                                 if ( false !== strpos( $error_code, 'do_rollback' ) )
 162                                         $try_rollback = true;
 163                                 elseif ( false !== strpos( $error_code, '__copy_dir' ) )
 164                                         $try_rollback = true;
 165                                 elseif ( 'disk_full' === $error_code )
 166                                         $try_rollback = true;
 167                         }
 168
 169                         if ( $try_rollback ) {
 170                                 /** This filter is documented in wp-admin/includes/update-core.php */
 171                                 apply_filters( 'update_feedback', $result );
 172
 173                                 /** This filter is documented in wp-admin/includes/update-core.php */
 174                                 apply_filters( 'update_feedback', $this->strings['start_rollback'] );
 175
 176                                 $rollback_result = $this->upgrade( $current, array_merge( $parsed_args, array( 'do_rollback' => true ) ) );
 177
 178                                 $original_result = $result;
 179                                 $result = new WP_Error( 'rollback_was_required', $this->strings['rollback_was_required'], (object) array( 'update' => $original_result, 'rollback' => $rollback_result ) );
 180                         }
 181                 }
 182
 183                 /** This action is documented in wp-admin/includes/class-wp-upgrader.php */
 184                 do_action( 'upgrader_process_complete', $this, array( 'action' => 'update', 'type' => 'core' ) );
 185
 186                 // Clear the current updates
 187                 delete_site_transient( 'update_core' );
 188
 189                 if ( ! $parsed_args['do_rollback'] ) {
 190                         $stats = array(
 191                                 'update_type'      => $current->response,
 192                                 'success'          => true,
 193                                 'fs_method'        => $wp_filesystem->method,
 194                                 'fs_method_forced' => defined( 'FS_METHOD' ) || has_filter( 'filesystem_method' ),
 195                                 'fs_method_direct' => !empty( $GLOBALS['_wp_filesystem_direct_method'] ) ? $GLOBALS['_wp_filesystem_direct_method'] : '',
 196                                 'time_taken'       => time() - $start_time,
 197                                 'reported'         => $wp_version,
 198                                 'attempted'        => $current->version,
 199                         );
 200
 201                         if ( is_wp_error( $result ) ) {
 202                                 $stats['success'] = false;
 203                                 // Did a rollback occur?
 204                                 if ( ! empty( $try_rollback ) ) {
 205                                         $stats['error_code'] = $original_result->get_error_code();
 206                                         $stats['error_data'] = $original_result->get_error_data();
 207                                         // Was the rollback successful? If not, collect its error too.
 208                                         $stats['rollback'] = ! is_wp_error( $rollback_result );
 209                                         if ( is_wp_error( $rollback_result ) ) {
 210                                                 $stats['rollback_code'] = $rollback_result->get_error_code();
 211                                                 $stats['rollback_data'] = $rollback_result->get_error_data();
 212                                         }
 213                                 } else {
 214                                         $stats['error_code'] = $result->get_error_code();
 215                                         $stats['error_data'] = $result->get_error_data();
 216                                 }
 217                         }
 218
 219                         wp_version_check( $stats );
 220                 }
 221
 222                 WP_Upgrader::release_lock( 'core_updater' );
 223
 224                 return $result;
 225         }
 226
 227         /**
 228          * Determines if this WordPress Core version should update to an offered version or not.
 229          *
 230          * @since 3.7.0
 231          * @access public
 232          *
 233          * @static
 234          *
 235          * @param string $offered_ver The offered version, of the format x.y.z.
 236          * @return bool True if we should update to the offered version, otherwise false.
 237          */
 238         public static function should_update_to_version( $offered_ver ) {
 239                 include( ABSPATH . WPINC . '/version.php' ); // $wp_version; // x.y.z
 240
 241                 $current_branch = implode( '.', array_slice( preg_split( '/[.-]/', $wp_version  ), 0, 2 ) ); // x.y
 242                 $new_branch     = implode( '.', array_slice( preg_split( '/[.-]/', $offered_ver ), 0, 2 ) ); // x.y
 243                 $current_is_development_version = (bool) strpos( $wp_version, '-' );
 244
 245                 // Defaults:
 246                 $upgrade_dev   = true;
 247                 $upgrade_minor = true;
 248                 $upgrade_major = false;
 249
 250                 // WP_AUTO_UPDATE_CORE = true (all), 'minor', false.
 251                 if ( defined( 'WP_AUTO_UPDATE_CORE' ) ) {
 252                         if ( false === WP_AUTO_UPDATE_CORE ) {
 253                                 // Defaults to turned off, unless a filter allows it
 254                                 $upgrade_dev = $upgrade_minor = $upgrade_major = false;
 255                         } elseif ( true === WP_AUTO_UPDATE_CORE ) {
 256                                 // ALL updates for core
 257                                 $upgrade_dev = $upgrade_minor = $upgrade_major = true;
 258                         } elseif ( 'minor' === WP_AUTO_UPDATE_CORE ) {
 259                                 // Only minor updates for core
 260                                 $upgrade_dev = $upgrade_major = false;
 261                                 $upgrade_minor = true;
 262                         }
 263                 }
 264
 265                 // 1: If we're already on that version, not much point in updating?
 266                 if ( $offered_ver == $wp_version )
 267                         return false;
 268
 269                 // 2: If we're running a newer version, that's a nope
 270                 if ( version_compare( $wp_version, $offered_ver, '>' ) )
 271                         return false;
 272
 273                 $failure_data = get_site_option( 'auto_core_update_failed' );
 274                 if ( $failure_data ) {
 275                         // If this was a critical update failure, cannot update.
 276                         if ( ! empty( $failure_data['critical'] ) )
 277                                 return false;
 278
 279                         // Don't claim we can update on update-core.php if we have a non-critical failure logged.
 280                         if ( $wp_version == $failure_data['current'] && false !== strpos( $offered_ver, '.1.next.minor' ) )
 281                                 return false;
 282
 283                         // Cannot update if we're retrying the same A to B update that caused a non-critical failure.
 284                         // Some non-critical failures do allow retries, like download_failed.
 285                         // 3.7.1 => 3.7.2 resulted in files_not_writable, if we are still on 3.7.1 and still trying to update to 3.7.2.
 286                         if ( empty( $failure_data['retry'] ) && $wp_version == $failure_data['current'] && $offered_ver == $failure_data['attempted'] )
 287                                 return false;
 288                 }
 289
 290                 // 3: 3.7-alpha-25000 -> 3.7-alpha-25678 -> 3.7-beta1 -> 3.7-beta2
 291                 if ( $current_is_development_version ) {
 292
 293                         /**
 294                          * Filters whether to enable automatic core updates for development versions.
 295                          *
 296                          * @since 3.7.0
 297                          *
 298                          * @param bool $upgrade_dev Whether to enable automatic updates for
 299                          *                          development versions.
 300                          */
 301                         if ( ! apply_filters( 'allow_dev_auto_core_updates', $upgrade_dev ) )
 302                                 return false;
 303                         // Else fall through to minor + major branches below.
 304                 }
 305
 306                 // 4: Minor In-branch updates (3.7.0 -> 3.7.1 -> 3.7.2 -> 3.7.4)
 307                 if ( $current_branch == $new_branch ) {
 308
 309                         /**
 310                          * Filters whether to enable minor automatic core updates.
 311                          *
 312                          * @since 3.7.0
 313                          *
 314                          * @param bool $upgrade_minor Whether to enable minor automatic core updates.
 315                          */
 316                         return apply_filters( 'allow_minor_auto_core_updates', $upgrade_minor );
 317                 }
 318
 319                 // 5: Major version updates (3.7.0 -> 3.8.0 -> 3.9.1)
 320                 if ( version_compare( $new_branch, $current_branch, '>' ) ) {
 321
 322                         /**
 323                          * Filters whether to enable major automatic core updates.
 324                          *
 325                          * @since 3.7.0
 326                          *
 327                          * @param bool $upgrade_major Whether to enable major automatic core updates.
 328                          */
 329                         return apply_filters( 'allow_major_auto_core_updates', $upgrade_major );
 330                 }
 331
 332                 // If we're not sure, we don't want it
 333                 return false;
 334         }
 335
 336         /**
 337          * Compare the disk file checksums against the expected checksums.
 338          *
 339          * @since 3.7.0
 340          * @access public
 341          *
 342          * @global string $wp_version
 343          * @global string $wp_local_package
 344          *
 345          * @return bool True if the checksums match, otherwise false.
 346          */
 347         public function check_files() {
 348                 global $wp_version, $wp_local_package;
 349
 350                 $checksums = get_core_checksums( $wp_version, isset( $wp_local_package ) ? $wp_local_package : 'en_US' );
 351
 352                 if ( ! is_array( $checksums ) )
 353                         return false;
 354
 355                 foreach ( $checksums as $file => $checksum ) {
 356                         // Skip files which get updated
 357                         if ( 'wp-content' == substr( $file, 0, 10 ) )
 358                                 continue;
 359                         if ( ! file_exists( ABSPATH . $file ) || md5_file( ABSPATH . $file ) !== $checksum )
 360                                 return false;
 361                 }
 362
 363                 return true;
 364         }
 365 }