1 <?php

     2 /**

     3  * A File upgrader class for WordPress.

     4  *

     5  * This set of classes are designed to be used to upgrade/install a local set of files on the filesystem via the Filesystem Abstraction classes.

     6  *

     7  * @link http://trac.wordpress.org/ticket/7875 consolidate plugin/theme/core upgrade/install functions

     8  *

     9  * @package WordPress

    10  * @subpackage Upgrader

    11  * @since 2.8.0

    12  */

    13 

    14 require ABSPATH . 'wp-admin/includes/class-wp-upgrader-skins.php';

    15 

    16 /**

    17  * WordPress Upgrader class for Upgrading/Installing a local set of files via the Filesystem Abstraction classes from a Zip file.

    18  *

    19  * @package WordPress

    20  * @subpackage Upgrader

    21  * @since 2.8.0

    22  */

    23 class WP_Upgrader {

    24 	var $strings = array();

    25 	var $skin = null;

    26 	var $result = array();

    27 

    28 	function __construct($skin = null) {

    29 		if ( null == $skin )

    30 			$this->skin = new WP_Upgrader_Skin();

    31 		else

    32 			$this->skin = $skin;

    33 	}

    34 

    35 	function init() {

    36 		$this->skin->set_upgrader($this);

    37 		$this->generic_strings();

    38 	}

    39 

    40 	function generic_strings() {

    41 		$this->strings['bad_request'] = __('Invalid Data provided.');

    42 		$this->strings['fs_unavailable'] = __('Could not access filesystem.');

    43 		$this->strings['fs_error'] = __('Filesystem error.');

    44 		$this->strings['fs_no_root_dir'] = __('Unable to locate WordPress Root directory.');

    45 		$this->strings['fs_no_content_dir'] = __('Unable to locate WordPress Content directory (wp-content).');

    46 		$this->strings['fs_no_plugins_dir'] = __('Unable to locate WordPress Plugin directory.');

    47 		$this->strings['fs_no_themes_dir'] = __('Unable to locate WordPress Theme directory.');

    48 		/* translators: %s: directory name */

    49 		$this->strings['fs_no_folder'] = __('Unable to locate needed folder (%s).');

    50 

    51 		$this->strings['download_failed'] = __('Download failed.');

    52 		$this->strings['installing_package'] = __('Installing the latest version…');

    53 		$this->strings['no_files'] = __('The package contains no files.');

    54 		$this->strings['folder_exists'] = __('Destination folder already exists.');

    55 		$this->strings['mkdir_failed'] = __('Could not create directory.');

    56 		$this->strings['incompatible_archive'] = __('The package could not be installed.');

    57 

    58 		$this->strings['maintenance_start'] = __('Enabling Maintenance mode…');

    59 		$this->strings['maintenance_end'] = __('Disabling Maintenance mode…');

    60 	}

    61 

    62 	function fs_connect( $directories = array() ) {

    63 		global $wp_filesystem;

    64 

    65 		if ( false === ($credentials = $this->skin->request_filesystem_credentials()) )

    66 			return false;

    67 

    68 		if ( ! WP_Filesystem($credentials) ) {

    69 			$error = true;

    70 			if ( is_object($wp_filesystem) && $wp_filesystem->errors->get_error_code() )

    71 				$error = $wp_filesystem->errors;

    72 			$this->skin->request_filesystem_credentials($error); //Failed to connect, Error and request again

    73 			return false;

    74 		}

    75 

    76 		if ( ! is_object($wp_filesystem) )

    77 			return new WP_Error('fs_unavailable', $this->strings['fs_unavailable'] );

    78 

    79 		if ( is_wp_error($wp_filesystem->errors) && $wp_filesystem->errors->get_error_code() )

    80 			return new WP_Error('fs_error', $this->strings['fs_error'], $wp_filesystem->errors);

    81 

    82 		foreach ( (array)$directories as $dir ) {

    83 			switch ( $dir ) {

    84 				case ABSPATH:

    85 					if ( ! $wp_filesystem->abspath() )

    86 						return new WP_Error('fs_no_root_dir', $this->strings['fs_no_root_dir']);

    87 					break;

    88 				case WP_CONTENT_DIR:

    89 					if ( ! $wp_filesystem->wp_content_dir() )

    90 						return new WP_Error('fs_no_content_dir', $this->strings['fs_no_content_dir']);

    91 					break;

    92 				case WP_PLUGIN_DIR:

    93 					if ( ! $wp_filesystem->wp_plugins_dir() )

    94 						return new WP_Error('fs_no_plugins_dir', $this->strings['fs_no_plugins_dir']);

    95 					break;

    96 				case get_theme_root():

    97 					if ( ! $wp_filesystem->wp_themes_dir() )

    98 						return new WP_Error('fs_no_themes_dir', $this->strings['fs_no_themes_dir']);

    99 					break;

   100 				default:

   101 					if ( ! $wp_filesystem->find_folder($dir) )

   102 						return new WP_Error( 'fs_no_folder', sprintf( $this->strings['fs_no_folder'], esc_html( basename( $dir ) ) ) );

   103 					break;

   104 			}

   105 		}

   106 		return true;

   107 	} //end fs_connect();

   108 

   109 	function download_package($package) {

   110 

   111 		/**

   112 		 * Filter whether to return the package.

   113 		 *

   114 		 * @since 3.7.0

   115 		 *

   116 		 * @param bool    $reply   Whether to bail without returning the package. Default is false.

   117 		 * @param string  $package The package file name.

   118 		 * @param object  $this    The WP_Upgrader instance.

   119 		 */

   120 		$reply = apply_filters( 'upgrader_pre_download', false, $package, $this );

   121 		if ( false !== $reply )

   122 			return $reply;

   123 

   124 		if ( ! preg_match('!^(http|https|ftp)://!i', $package) && file_exists($package) ) //Local file or remote?

   125 			return $package; //must be a local file..

   126 

   127 		if ( empty($package) )

   128 			return new WP_Error('no_package', $this->strings['no_package']);

   129 

   130 		$this->skin->feedback('downloading_package', $package);

   131 

   132 		$download_file = download_url($package);

   133 

   134 		if ( is_wp_error($download_file) )

   135 			return new WP_Error('download_failed', $this->strings['download_failed'], $download_file->get_error_message());

   136 

   137 		return $download_file;

   138 	}

   139 

   140 	function unpack_package($package, $delete_package = true) {

   141 		global $wp_filesystem;

   142 

   143 		$this->skin->feedback('unpack_package');

   144 

   145 		$upgrade_folder = $wp_filesystem->wp_content_dir() . 'upgrade/';

   146 

   147 		//Clean up contents of upgrade directory beforehand.

   148 		$upgrade_files = $wp_filesystem->dirlist($upgrade_folder);

   149 		if ( !empty($upgrade_files) ) {

   150 			foreach ( $upgrade_files as $file )

   151 				$wp_filesystem->delete($upgrade_folder . $file['name'], true);

   152 		}

   153 

   154 		//We need a working directory

   155 		$working_dir = $upgrade_folder . basename($package, '.zip');

   156 

   157 		// Clean up working directory

   158 		if ( $wp_filesystem->is_dir($working_dir) )

   159 			$wp_filesystem->delete($working_dir, true);

   160 

   161 		// Unzip package to working directory

   162 		$result = unzip_file( $package, $working_dir );

   163 

   164 		// Once extracted, delete the package if required.

   165 		if ( $delete_package )

   166 			unlink($package);

   167 

   168 		if ( is_wp_error($result) ) {

   169 			$wp_filesystem->delete($working_dir, true);

   170 			if ( 'incompatible_archive' == $result->get_error_code() ) {

   171 				return new WP_Error( 'incompatible_archive', $this->strings['incompatible_archive'], $result->get_error_data() );

   172 			}

   173 			return $result;

   174 		}

   175 

   176 		return $working_dir;

   177 	}

   178 

   179 	function install_package( $args = array() ) {

   180 		global $wp_filesystem, $wp_theme_directories;

   181 

   182 		$defaults = array(

   183 			'source' => '', // Please always pass this

   184 			'destination' => '', // and this

   185 			'clear_destination' => false,

   186 			'clear_working' => false,

   187 			'abort_if_destination_exists' => true,

   188 			'hook_extra' => array()

   189 		);

   190 

   191 		$args = wp_parse_args($args, $defaults);

   192 		extract($args);

   193 

   194 		@set_time_limit( 300 );

   195 

   196 		if ( empty($source) || empty($destination) )

   197 			return new WP_Error('bad_request', $this->strings['bad_request']);

   198 

   199 		$this->skin->feedback('installing_package');

   200 

   201 		$res = apply_filters('upgrader_pre_install', true, $hook_extra);

   202 		if ( is_wp_error($res) )

   203 			return $res;

   204 

   205 		//Retain the Original source and destinations

   206 		$remote_source = $source;

   207 		$local_destination = $destination;

   208 

   209 		$source_files = array_keys( $wp_filesystem->dirlist($remote_source) );

   210 		$remote_destination = $wp_filesystem->find_folder($local_destination);

   211 

   212 		//Locate which directory to copy to the new folder, This is based on the actual folder holding the files.

   213 		if ( 1 == count($source_files) && $wp_filesystem->is_dir( trailingslashit($source) . $source_files[0] . '/') ) //Only one folder? Then we want its contents.

   214 			$source = trailingslashit($source) . trailingslashit($source_files[0]);

   215 		elseif ( count($source_files) == 0 )

   216 			return new WP_Error( 'incompatible_archive_empty', $this->strings['incompatible_archive'], $this->strings['no_files'] ); // There are no files?

   217 		else //It's only a single file, the upgrader will use the foldername of this file as the destination folder. foldername is based on zip filename.

   218 			$source = trailingslashit($source);

   219 

   220 		//Hook ability to change the source file location..

   221 		$source = apply_filters('upgrader_source_selection', $source, $remote_source, $this);

   222 		if ( is_wp_error($source) )

   223 			return $source;

   224 

   225 		//Has the source location changed? If so, we need a new source_files list.

   226 		if ( $source !== $remote_source )

   227 			$source_files = array_keys( $wp_filesystem->dirlist($source) );

   228 

   229 		// Protection against deleting files in any important base directories.

   230 		// Theme_Upgrader & Plugin_Upgrader also trigger this, as they pass the destination directory (WP_PLUGIN_DIR / wp-content/themes)

   231 		// intending to copy the directory into the directory, whilst they pass the source as the actual files to copy.

   232 		$protected_directories = array( ABSPATH, WP_CONTENT_DIR, WP_PLUGIN_DIR, WP_CONTENT_DIR . '/themes' );

   233 		if ( is_array( $wp_theme_directories ) )

   234 			$protected_directories = array_merge( $protected_directories, $wp_theme_directories );

   235 		if ( in_array( $destination, $protected_directories ) ) {

   236 			$remote_destination = trailingslashit($remote_destination) . trailingslashit(basename($source));

   237 			$destination = trailingslashit($destination) . trailingslashit(basename($source));

   238 		}

   239 

   240 		if ( $clear_destination ) {

   241 			//We're going to clear the destination if there's something there

   242 			$this->skin->feedback('remove_old');

   243 			$removed = true;

   244 			if ( $wp_filesystem->exists($remote_destination) )

   245 				$removed = $wp_filesystem->delete($remote_destination, true);

   246 			$removed = apply_filters('upgrader_clear_destination', $removed, $local_destination, $remote_destination, $hook_extra);

   247 

   248 			if ( is_wp_error($removed) )

   249 				return $removed;

   250 			else if ( ! $removed )

   251 				return new WP_Error('remove_old_failed', $this->strings['remove_old_failed']);

   252 		} elseif ( $abort_if_destination_exists && $wp_filesystem->exists($remote_destination) ) {

   253 			//If we're not clearing the destination folder and something exists there already, Bail.

   254 			//But first check to see if there are actually any files in the folder.

   255 			$_files = $wp_filesystem->dirlist($remote_destination);

   256 			if ( ! empty($_files) ) {

   257 				$wp_filesystem->delete($remote_source, true); //Clear out the source files.

   258 				return new WP_Error('folder_exists', $this->strings['folder_exists'], $remote_destination );

   259 			}

   260 		}

   261 

   262 		//Create destination if needed

   263 		if ( !$wp_filesystem->exists($remote_destination) )

   264 			if ( !$wp_filesystem->mkdir($remote_destination, FS_CHMOD_DIR) )

   265 				return new WP_Error( 'mkdir_failed_destination', $this->strings['mkdir_failed'], $remote_destination );

   266 

   267 		// Copy new version of item into place.

   268 		$result = copy_dir($source, $remote_destination);

   269 		if ( is_wp_error($result) ) {

   270 			if ( $clear_working )

   271 				$wp_filesystem->delete($remote_source, true);

   272 			return $result;

   273 		}

   274 

   275 		//Clear the Working folder?

   276 		if ( $clear_working )

   277 			$wp_filesystem->delete($remote_source, true);

   278 

   279 		$destination_name = basename( str_replace($local_destination, '', $destination) );

   280 		if ( '.' == $destination_name )

   281 			$destination_name = '';

   282 

   283 		$this->result = compact('local_source', 'source', 'source_name', 'source_files', 'destination', 'destination_name', 'local_destination', 'remote_destination', 'clear_destination', 'delete_source_dir');

   284 

   285 		$res = apply_filters('upgrader_post_install', true, $hook_extra, $this->result);

   286 		if ( is_wp_error($res) ) {

   287 			$this->result = $res;

   288 			return $res;

   289 		}

   290 

   291 		//Bombard the calling function will all the info which we've just used.

   292 		return $this->result;

   293 	}

   294 

   295 	function run($options) {

   296 

   297 		$defaults = array(

   298 			'package' => '', // Please always pass this.

   299 			'destination' => '', // And this

   300 			'clear_destination' => false,

   301 			'abort_if_destination_exists' => true, // Abort if the Destination directory exists, Pass clear_destination as false please

   302 			'clear_working' => true,

   303 			'is_multi' => false,

   304 			'hook_extra' => array() // Pass any extra $hook_extra args here, this will be passed to any hooked filters.

   305 		);

   306 

   307 		$options = wp_parse_args($options, $defaults);

   308 		extract($options);

   309 

   310 		if ( ! $is_multi ) // call $this->header separately if running multiple times

   311 			$this->skin->header();

   312 

   313 		// Connect to the Filesystem first.

   314 		$res = $this->fs_connect( array(WP_CONTENT_DIR, $destination) );

   315 		// Mainly for non-connected filesystem.

   316 		if ( ! $res ) {

   317 			if ( ! $is_multi )

   318 				$this->skin->footer();

   319 			return false;

   320 		}

   321 

   322 		$this->skin->before();

   323 

   324 		if ( is_wp_error($res) ) {

   325 			$this->skin->error($res);

   326 			$this->skin->after();

   327 			if ( ! $is_multi )

   328 				$this->skin->footer();

   329 			return $res;

   330 		}

   331 

   332 		//Download the package (Note, This just returns the filename of the file if the package is a local file)

   333 		$download = $this->download_package( $package );

   334 		if ( is_wp_error($download) ) {

   335 			$this->skin->error($download);

   336 			$this->skin->after();

   337 			if ( ! $is_multi )

   338 				$this->skin->footer();

   339 			return $download;

   340 		}

   341 

   342 		$delete_package = ($download != $package); // Do not delete a "local" file

   343 

   344 		//Unzips the file into a temporary directory

   345 		$working_dir = $this->unpack_package( $download, $delete_package );

   346 		if ( is_wp_error($working_dir) ) {

   347 			$this->skin->error($working_dir);

   348 			$this->skin->after();

   349 			if ( ! $is_multi )

   350 				$this->skin->footer();

   351 			return $working_dir;

   352 		}

   353 

   354 		//With the given options, this installs it to the destination directory.

   355 		$result = $this->install_package( array(

   356 			'source' => $working_dir,

   357 			'destination' => $destination,

   358 			'clear_destination' => $clear_destination,

   359 			'abort_if_destination_exists' => $abort_if_destination_exists,

   360 			'clear_working' => $clear_working,

   361 			'hook_extra' => $hook_extra

   362 		) );

   363 

   364 		$this->skin->set_result($result);

   365 		if ( is_wp_error($result) ) {

   366 			$this->skin->error($result);

   367 			$this->skin->feedback('process_failed');

   368 		} else {

   369 			//Install Succeeded

   370 			$this->skin->feedback('process_success');

   371 		}

   372 

   373 		$this->skin->after();

   374 

   375 		if ( ! $is_multi ) {

   376 			do_action( 'upgrader_process_complete', $this, $hook_extra );

   377 			$this->skin->footer();

   378 		}

   379 

   380 		return $result;

   381 	}

   382 

   383 	function maintenance_mode($enable = false) {

   384 		global $wp_filesystem;

   385 		$file = $wp_filesystem->abspath() . '.maintenance';

   386 		if ( $enable ) {

   387 			$this->skin->feedback('maintenance_start');

   388 			// Create maintenance file to signal that we are upgrading

   389 			$maintenance_string = '<?php $upgrading = ' . time() . '; ?>';

   390 			$wp_filesystem->delete($file);

   391 			$wp_filesystem->put_contents($file, $maintenance_string, FS_CHMOD_FILE);

   392 		} else if ( !$enable && $wp_filesystem->exists($file) ) {

   393 			$this->skin->feedback('maintenance_end');

   394 			$wp_filesystem->delete($file);

   395 		}

   396 	}

   397 

   398 }

   399 

   400 /**

   401  * Plugin Upgrader class for WordPress Plugins, It is designed to upgrade/install plugins from a local zip, remote zip URL, or uploaded zip file.

   402  *

   403  * @package WordPress

   404  * @subpackage Upgrader

   405  * @since 2.8.0

   406  */

   407 class Plugin_Upgrader extends WP_Upgrader {

   408 

   409 	var $result;

   410 	var $bulk = false;

   411 	var $show_before = '';

   412 

   413 	function upgrade_strings() {

   414 		$this->strings['up_to_date'] = __('The plugin is at the latest version.');

   415 		$this->strings['no_package'] = __('Update package not available.');

   416 		$this->strings['downloading_package'] = __('Downloading update from <span class="code">%s</span>&#8230;');

   417 		$this->strings['unpack_package'] = __('Unpacking the update…');

   418 		$this->strings['remove_old'] = __('Removing the old version of the plugin…');

   419 		$this->strings['remove_old_failed'] = __('Could not remove the old plugin.');

   420 		$this->strings['process_failed'] = __('Plugin update failed.');

   421 		$this->strings['process_success'] = __('Plugin updated successfully.');

   422 	}

   423 

   424 	function install_strings() {

   425 		$this->strings['no_package'] = __('Install package not available.');

   426 		$this->strings['downloading_package'] = __('Downloading install package from <span class="code">%s</span>&#8230;');

   427 		$this->strings['unpack_package'] = __('Unpacking the package…');

   428 		$this->strings['installing_package'] = __('Installing the plugin…');

   429 		$this->strings['no_files'] = __('The plugin contains no files.');

   430 		$this->strings['process_failed'] = __('Plugin install failed.');

   431 		$this->strings['process_success'] = __('Plugin installed successfully.');

   432 	}

   433 

   434 	function install( $package, $args = array() ) {

   435 

   436 		$defaults = array(

   437 			'clear_update_cache' => true,

   438 		);

   439 		$parsed_args = wp_parse_args( $args, $defaults );

   440 

   441 		$this->init();

   442 		$this->install_strings();

   443 

   444 		add_filter('upgrader_source_selection', array($this, 'check_package') );

   445 

   446 		$this->run( array(

   447 			'package' => $package,

   448 			'destination' => WP_PLUGIN_DIR,

   449 			'clear_destination' => false, // Do not overwrite files.

   450 			'clear_working' => true,

   451 			'hook_extra' => array(

   452 				'type' => 'plugin',

   453 				'action' => 'install',

   454 			)

   455 		) );

   456 

   457 		remove_filter('upgrader_source_selection', array($this, 'check_package') );

   458 

   459 		if ( ! $this->result || is_wp_error($this->result) )

   460 			return $this->result;

   461 

   462 		// Force refresh of plugin update information

   463 		wp_clean_plugins_cache( $parsed_args['clear_update_cache'] );

   464 

   465 		return true;

   466 	}

   467 

   468 	function upgrade( $plugin, $args = array() ) {

   469 

   470 		$defaults = array(

   471 			'clear_update_cache' => true,

   472 		);

   473 		$parsed_args = wp_parse_args( $args, $defaults );

   474 

   475 		$this->init();

   476 		$this->upgrade_strings();

   477 

   478 		$current = get_site_transient( 'update_plugins' );

   479 		if ( !isset( $current->response[ $plugin ] ) ) {

   480 			$this->skin->before();

   481 			$this->skin->set_result(false);

   482 			$this->skin->error('up_to_date');

   483 			$this->skin->after();

   484 			return false;

   485 		}

   486 

   487 		// Get the URL to the zip file

   488 		$r = $current->response[ $plugin ];

   489 

   490 		add_filter('upgrader_pre_install', array($this, 'deactivate_plugin_before_upgrade'), 10, 2);

   491 		add_filter('upgrader_clear_destination', array($this, 'delete_old_plugin'), 10, 4);

   492 		//'source_selection' => array($this, 'source_selection'), //there's a trac ticket to move up the directory for zip's which are made a bit differently, useful for non-.org plugins.

   493 

   494 		$this->run( array(

   495 			'package' => $r->package,

   496 			'destination' => WP_PLUGIN_DIR,

   497 			'clear_destination' => true,

   498 			'clear_working' => true,

   499 			'hook_extra' => array(

   500 				'plugin' => $plugin,

   501 				'type' => 'plugin',

   502 				'action' => 'update',

   503 			),

   504 		) );

   505 

   506 		// Cleanup our hooks, in case something else does a upgrade on this connection.

   507 		remove_filter('upgrader_pre_install', array($this, 'deactivate_plugin_before_upgrade'));

   508 		remove_filter('upgrader_clear_destination', array($this, 'delete_old_plugin'));

   509 

   510 		if ( ! $this->result || is_wp_error($this->result) )

   511 			return $this->result;

   512 

   513 		// Force refresh of plugin update information

   514 		wp_clean_plugins_cache( $parsed_args['clear_update_cache'] );

   515 

   516 		return true;

   517 	}

   518 

   519 	function bulk_upgrade( $plugins, $args = array() ) {

   520 

   521 		$defaults = array(

   522 			'clear_update_cache' => true,

   523 		);

   524 		$parsed_args = wp_parse_args( $args, $defaults );

   525 

   526 		$this->init();

   527 		$this->bulk = true;

   528 		$this->upgrade_strings();

   529 

   530 		$current = get_site_transient( 'update_plugins' );

   531 

   532 		add_filter('upgrader_clear_destination', array($this, 'delete_old_plugin'), 10, 4);

   533 

   534 		$this->skin->header();

   535 

   536 		// Connect to the Filesystem first.

   537 		$res = $this->fs_connect( array(WP_CONTENT_DIR, WP_PLUGIN_DIR) );

   538 		if ( ! $res ) {

   539 			$this->skin->footer();

   540 			return false;

   541 		}

   542 

   543 		$this->skin->bulk_header();

   544 

   545 		// Only start maintenance mode if:

   546 		// - running Multisite and there are one or more plugins specified, OR

   547 		// - a plugin with an update available is currently active.

   548 		// @TODO: For multisite, maintenance mode should only kick in for individual sites if at all possible.

   549 		$maintenance = ( is_multisite() && ! empty( $plugins ) );

   550 		foreach ( $plugins as $plugin )

   551 			$maintenance = $maintenance || ( is_plugin_active( $plugin ) && isset( $current->response[ $plugin] ) );

   552 		if ( $maintenance )

   553 			$this->maintenance_mode(true);

   554 

   555 		$results = array();

   556 

   557 		$this->update_count = count($plugins);

   558 		$this->update_current = 0;

   559 		foreach ( $plugins as $plugin ) {

   560 			$this->update_current++;

   561 			$this->skin->plugin_info = get_plugin_data( WP_PLUGIN_DIR . '/' . $plugin, false, true);

   562 

   563 			if ( !isset( $current->response[ $plugin ] ) ) {

   564 				$this->skin->set_result(true);

   565 				$this->skin->before();

   566 				$this->skin->feedback('up_to_date');

   567 				$this->skin->after();

   568 				$results[$plugin] = true;

   569 				continue;

   570 			}

   571 

   572 			// Get the URL to the zip file

   573 			$r = $current->response[ $plugin ];

   574 

   575 			$this->skin->plugin_active = is_plugin_active($plugin);

   576 

   577 			$result = $this->run( array(

   578 				'package' => $r->package,

   579 				'destination' => WP_PLUGIN_DIR,

   580 				'clear_destination' => true,

   581 				'clear_working' => true,

   582 				'is_multi' => true,

   583 				'hook_extra' => array(

   584 					'plugin' => $plugin

   585 				)

   586 			) );

   587 

   588 			$results[$plugin] = $this->result;

   589 

   590 			// Prevent credentials auth screen from displaying multiple times

   591 			if ( false === $result )

   592 				break;

   593 		} //end foreach $plugins

   594 

   595 		$this->maintenance_mode(false);

   596 

   597 		do_action( 'upgrader_process_complete', $this, array(

   598 			'action' => 'update',

   599 			'type' => 'plugin',

   600 			'bulk' => true,

   601 			'plugins' => $plugins,

   602 		) );

   603 

   604 		$this->skin->bulk_footer();

   605 

   606 		$this->skin->footer();

   607 

   608 		// Cleanup our hooks, in case something else does a upgrade on this connection.

   609 		remove_filter('upgrader_clear_destination', array($this, 'delete_old_plugin'));

   610 

   611 		// Force refresh of plugin update information

   612 		wp_clean_plugins_cache( $parsed_args['clear_update_cache'] );

   613 

   614 		return $results;

   615 	}

   616 

   617 	function check_package($source) {

   618 		global $wp_filesystem;

   619 

   620 		if ( is_wp_error($source) )

   621 			return $source;

   622 

   623 		$working_directory = str_replace( $wp_filesystem->wp_content_dir(), trailingslashit(WP_CONTENT_DIR), $source);

   624 		if ( ! is_dir($working_directory) ) // Sanity check, if the above fails, lets not prevent installation.

   625 			return $source;

   626 

   627 		// Check the folder contains at least 1 valid plugin.

   628 		$plugins_found = false;

   629 		foreach ( glob( $working_directory . '*.php' ) as $file ) {

   630 			$info = get_plugin_data($file, false, false);

   631 			if ( !empty( $info['Name'] ) ) {

   632 				$plugins_found = true;

   633 				break;

   634 			}

   635 		}

   636 

   637 		if ( ! $plugins_found )

   638 			return new WP_Error( 'incompatible_archive_no_plugins', $this->strings['incompatible_archive'], __( 'No valid plugins were found.' ) );

   639 

   640 		return $source;

   641 	}

   642 

   643 	//return plugin info.

   644 	function plugin_info() {

   645 		if ( ! is_array($this->result) )

   646 			return false;

   647 		if ( empty($this->result['destination_name']) )

   648 			return false;

   649 

   650 		$plugin = get_plugins('/' . $this->result['destination_name']); //Ensure to pass with leading slash

   651 		if ( empty($plugin) )

   652 			return false;

   653 

   654 		$pluginfiles = array_keys($plugin); //Assume the requested plugin is the first in the list

   655 

   656 		return $this->result['destination_name'] . '/' . $pluginfiles[0];

   657 	}

   658 

   659 	//Hooked to pre_install

   660 	function deactivate_plugin_before_upgrade($return, $plugin) {

   661 

   662 		if ( is_wp_error($return) ) //Bypass.

   663 			return $return;

   664 

   665 		// When in cron (background updates) don't deactivate the plugin, as we require a browser to reactivate it

   666 		if ( defined( 'DOING_CRON' ) && DOING_CRON )

   667 			return $return;

   668 

   669 		$plugin = isset($plugin['plugin']) ? $plugin['plugin'] : '';

   670 		if ( empty($plugin) )

   671 			return new WP_Error('bad_request', $this->strings['bad_request']);

   672 

   673 		if ( is_plugin_active($plugin) ) {

   674 			//Deactivate the plugin silently, Prevent deactivation hooks from running.

   675 			deactivate_plugins($plugin, true);

   676 		}

   677 	}

   678 

   679 	//Hooked to upgrade_clear_destination

   680 	function delete_old_plugin($removed, $local_destination, $remote_destination, $plugin) {

   681 		global $wp_filesystem;

   682 

   683 		if ( is_wp_error($removed) )

   684 			return $removed; //Pass errors through.

   685 

   686 		$plugin = isset($plugin['plugin']) ? $plugin['plugin'] : '';

   687 		if ( empty($plugin) )

   688 			return new WP_Error('bad_request', $this->strings['bad_request']);

   689 

   690 		$plugins_dir = $wp_filesystem->wp_plugins_dir();

   691 		$this_plugin_dir = trailingslashit( dirname($plugins_dir . $plugin) );

   692 

   693 		if ( ! $wp_filesystem->exists($this_plugin_dir) ) //If it's already vanished.

   694 			return $removed;

   695 

   696 		// If plugin is in its own directory, recursively delete the directory.

   697 		if ( strpos($plugin, '/') && $this_plugin_dir != $plugins_dir ) //base check on if plugin includes directory separator AND that it's not the root plugin folder

   698 			$deleted = $wp_filesystem->delete($this_plugin_dir, true);

   699 		else

   700 			$deleted = $wp_filesystem->delete($plugins_dir . $plugin);

   701 

   702 		if ( ! $deleted )

   703 			return new WP_Error('remove_old_failed', $this->strings['remove_old_failed']);

   704 

   705 		return true;

   706 	}

   707 }

   708 

   709 /**

   710  * Theme Upgrader class for WordPress Themes, It is designed to upgrade/install themes from a local zip, remote zip URL, or uploaded zip file.

   711  *

   712  * @package WordPress

   713  * @subpackage Upgrader

   714  * @since 2.8.0

   715  */

   716 class Theme_Upgrader extends WP_Upgrader {

   717 

   718 	var $result;

   719 	var $bulk = false;

   720 

   721 	function upgrade_strings() {

   722 		$this->strings['up_to_date'] = __('The theme is at the latest version.');

   723 		$this->strings['no_package'] = __('Update package not available.');

   724 		$this->strings['downloading_package'] = __('Downloading update from <span class="code">%s</span>&#8230;');

   725 		$this->strings['unpack_package'] = __('Unpacking the update…');

   726 		$this->strings['remove_old'] = __('Removing the old version of the theme…');

   727 		$this->strings['remove_old_failed'] = __('Could not remove the old theme.');

   728 		$this->strings['process_failed'] = __('Theme update failed.');

   729 		$this->strings['process_success'] = __('Theme updated successfully.');

   730 	}

   731 

   732 	function install_strings() {

   733 		$this->strings['no_package'] = __('Install package not available.');

   734 		$this->strings['downloading_package'] = __('Downloading install package from <span class="code">%s</span>&#8230;');

   735 		$this->strings['unpack_package'] = __('Unpacking the package…');

   736 		$this->strings['installing_package'] = __('Installing the theme…');

   737 		$this->strings['no_files'] = __('The theme contains no files.');

   738 		$this->strings['process_failed'] = __('Theme install failed.');

   739 		$this->strings['process_success'] = __('Theme installed successfully.');

   740 		/* translators: 1: theme name, 2: version */

   741 		$this->strings['process_success_specific'] = __('Successfully installed the theme <strong>%1$s %2$s</strong>.');

   742 		$this->strings['parent_theme_search'] = __('This theme requires a parent theme. Checking if it is installed…');

   743 		/* translators: 1: theme name, 2: version */

   744 		$this->strings['parent_theme_prepare_install'] = __('Preparing to install <strong>%1$s %2$s</strong>&#8230;');

   745 		/* translators: 1: theme name, 2: version */

   746 		$this->strings['parent_theme_currently_installed'] = __('The parent theme, <strong>%1$s %2$s</strong>, is currently installed.');

   747 		/* translators: 1: theme name, 2: version */

   748 		$this->strings['parent_theme_install_success'] = __('Successfully installed the parent theme, <strong>%1$s %2$s</strong>.');

   749 		$this->strings['parent_theme_not_found'] = __('<strong>The parent theme could not be found.</strong> You will need to install the parent theme, <strong>%s</strong>, before you can use this child theme.');

   750 	}

   751 

   752 	function check_parent_theme_filter($install_result, $hook_extra, $child_result) {

   753 		// Check to see if we need to install a parent theme

   754 		$theme_info = $this->theme_info();

   755 

   756 		if ( ! $theme_info->parent() )

   757 			return $install_result;

   758 

   759 		$this->skin->feedback( 'parent_theme_search' );

   760 

   761 		if ( ! $theme_info->parent()->errors() ) {

   762 			$this->skin->feedback( 'parent_theme_currently_installed', $theme_info->parent()->display('Name'), $theme_info->parent()->display('Version') );

   763 			// We already have the theme, fall through.

   764 			return $install_result;

   765 		}

   766 

   767 		// We don't have the parent theme, lets install it

   768 		$api = themes_api('theme_information', array('slug' => $theme_info->get('Template'), 'fields' => array('sections' => false, 'tags' => false) ) ); //Save on a bit of bandwidth.

   769 

   770 		if ( ! $api || is_wp_error($api) ) {

   771 			$this->skin->feedback( 'parent_theme_not_found', $theme_info->get('Template') );

   772 			// Don't show activate or preview actions after install

   773 			add_filter('install_theme_complete_actions', array($this, 'hide_activate_preview_actions') );

   774 			return $install_result;

   775 		}

   776 

   777 		// Backup required data we're going to override:

   778 		$child_api = $this->skin->api;

   779 		$child_success_message = $this->strings['process_success'];

   780 

   781 		// Override them

   782 		$this->skin->api = $api;

   783 		$this->strings['process_success_specific'] = $this->strings['parent_theme_install_success'];//, $api->name, $api->version);

   784 

   785 		$this->skin->feedback('parent_theme_prepare_install', $api->name, $api->version);

   786 

   787 		add_filter('install_theme_complete_actions', '__return_false', 999); // Don't show any actions after installing the theme.

   788 

   789 		// Install the parent theme

   790 		$parent_result = $this->run( array(

   791 			'package' => $api->download_link,

   792 			'destination' => get_theme_root(),

   793 			'clear_destination' => false, //Do not overwrite files.

   794 			'clear_working' => true

   795 		) );

   796 

   797 		if ( is_wp_error($parent_result) )

   798 			add_filter('install_theme_complete_actions', array($this, 'hide_activate_preview_actions') );

   799 

   800 		// Start cleaning up after the parents installation

   801 		remove_filter('install_theme_complete_actions', '__return_false', 999);

   802 

   803 		// Reset child's result and data

   804 		$this->result = $child_result;

   805 		$this->skin->api = $child_api;

   806 		$this->strings['process_success'] = $child_success_message;

   807 

   808 		return $install_result;

   809 	}

   810 

   811 	function hide_activate_preview_actions($actions) {

   812 		unset($actions['activate'], $actions['preview']);

   813 		return $actions;

   814 	}

   815 

   816 	function install( $package, $args = array() ) {

   817 

   818 		$defaults = array(

   819 			'clear_update_cache' => true,

   820 		);

   821 		$parsed_args = wp_parse_args( $args, $defaults );

   822 

   823 		$this->init();

   824 		$this->install_strings();

   825 

   826 		add_filter('upgrader_source_selection', array($this, 'check_package') );

   827 		add_filter('upgrader_post_install', array($this, 'check_parent_theme_filter'), 10, 3);

   828 

   829 		$this->run( array(

   830 			'package' => $package,

   831 			'destination' => get_theme_root(),

   832 			'clear_destination' => false, //Do not overwrite files.

   833 			'clear_working' => true,

   834 			'hook_extra' => array(

   835 				'type' => 'theme',

   836 				'action' => 'install',

   837 			),

   838 		) );

   839 

   840 		remove_filter('upgrader_source_selection', array($this, 'check_package') );

   841 		remove_filter('upgrader_post_install', array($this, 'check_parent_theme_filter'));

   842 

   843 		if ( ! $this->result || is_wp_error($this->result) )

   844 			return $this->result;

   845 

   846 		// Refresh the Theme Update information

   847 		wp_clean_themes_cache( $parsed_args['clear_update_cache'] );

   848 

   849 		return true;

   850 	}

   851 

   852 	function upgrade( $theme, $args = array() ) {

   853 

   854 		$defaults = array(

   855 			'clear_update_cache' => true,

   856 		);

   857 		$parsed_args = wp_parse_args( $args, $defaults );

   858 

   859 		$this->init();

   860 		$this->upgrade_strings();

   861 

   862 		// Is an update available?

   863 		$current = get_site_transient( 'update_themes' );

   864 		if ( !isset( $current->response[ $theme ] ) ) {

   865 			$this->skin->before();

   866 			$this->skin->set_result(false);

   867 			$this->skin->error('up_to_date');

   868 			$this->skin->after();

   869 			return false;

   870 		}

   871 

   872 		$r = $current->response[ $theme ];

   873 

   874 		add_filter('upgrader_pre_install', array($this, 'current_before'), 10, 2);

   875 		add_filter('upgrader_post_install', array($this, 'current_after'), 10, 2);

   876 		add_filter('upgrader_clear_destination', array($this, 'delete_old_theme'), 10, 4);

   877 

   878 		$this->run( array(

   879 			'package' => $r['package'],

   880 			'destination' => get_theme_root( $theme ),

   881 			'clear_destination' => true,

   882 			'clear_working' => true,

   883 			'hook_extra' => array(

   884 				'theme' => $theme,

   885 				'type' => 'theme',

   886 				'action' => 'update',

   887 			),

   888 		) );

   889 

   890 		remove_filter('upgrader_pre_install', array($this, 'current_before'));

   891 		remove_filter('upgrader_post_install', array($this, 'current_after'));

   892 		remove_filter('upgrader_clear_destination', array($this, 'delete_old_theme'));

   893 

   894 		if ( ! $this->result || is_wp_error($this->result) )

   895 			return $this->result;

   896 

   897 		wp_clean_themes_cache( $parsed_args['clear_update_cache'] );

   898 

   899 		return true;

   900 	}

   901 

   902 	function bulk_upgrade( $themes, $args = array() ) {

   903 

   904 		$defaults = array(

   905 			'clear_update_cache' => true,

   906 		);

   907 		$parsed_args = wp_parse_args( $args, $defaults );

   908 

   909 		$this->init();

   910 		$this->bulk = true;

   911 		$this->upgrade_strings();

   912 

   913 		$current = get_site_transient( 'update_themes' );

   914 

   915 		add_filter('upgrader_pre_install', array($this, 'current_before'), 10, 2);

   916 		add_filter('upgrader_post_install', array($this, 'current_after'), 10, 2);

   917 		add_filter('upgrader_clear_destination', array($this, 'delete_old_theme'), 10, 4);

   918 

   919 		$this->skin->header();

   920 

   921 		// Connect to the Filesystem first.

   922 		$res = $this->fs_connect( array(WP_CONTENT_DIR) );

   923 		if ( ! $res ) {

   924 			$this->skin->footer();

   925 			return false;

   926 		}

   927 

   928 		$this->skin->bulk_header();

   929 

   930 		// Only start maintenance mode if:

   931 		// - running Multisite and there are one or more themes specified, OR

   932 		// - a theme with an update available is currently in use.

   933 		// @TODO: For multisite, maintenance mode should only kick in for individual sites if at all possible.

   934 		$maintenance = ( is_multisite() && ! empty( $themes ) );

   935 		foreach ( $themes as $theme )

   936 			$maintenance = $maintenance || $theme == get_stylesheet() || $theme == get_template();

   937 		if ( $maintenance )

   938 			$this->maintenance_mode(true);

   939 

   940 		$results = array();

   941 

   942 		$this->update_count = count($themes);

   943 		$this->update_current = 0;

   944 		foreach ( $themes as $theme ) {

   945 			$this->update_current++;

   946 

   947 			$this->skin->theme_info = $this->theme_info($theme);

   948 

   949 			if ( !isset( $current->response[ $theme ] ) ) {

   950 				$this->skin->set_result(true);

   951 				$this->skin->before();

   952 				$this->skin->feedback('up_to_date');

   953 				$this->skin->after();

   954 				$results[$theme] = true;

   955 				continue;

   956 			}

   957 

   958 			// Get the URL to the zip file

   959 			$r = $current->response[ $theme ];

   960 

   961 			$result = $this->run( array(

   962 				'package' => $r['package'],

   963 				'destination' => get_theme_root( $theme ),

   964 				'clear_destination' => true,

   965 				'clear_working' => true,

   966 				'hook_extra' => array(

   967 					'theme' => $theme

   968 				),

   969 			) );

   970 

   971 			$results[$theme] = $this->result;

   972 

   973 			// Prevent credentials auth screen from displaying multiple times

   974 			if ( false === $result )

   975 				break;

   976 		} //end foreach $plugins

   977 

   978 		$this->maintenance_mode(false);

   979 

   980 		do_action( 'upgrader_process_complete', $this, array(

   981 			'action' => 'update',

   982 			'type' => 'plugin',

   983 			'bulk' => true,

   984 			'themes' => $themes,

   985 		) );

   986 

   987 		$this->skin->bulk_footer();

   988 

   989 		$this->skin->footer();

   990 

   991 		// Cleanup our hooks, in case something else does a upgrade on this connection.

   992 		remove_filter('upgrader_pre_install', array($this, 'current_before'));

   993 		remove_filter('upgrader_post_install', array($this, 'current_after'));

   994 		remove_filter('upgrader_clear_destination', array($this, 'delete_old_theme'));

   995 

   996 		// Refresh the Theme Update information

   997 		wp_clean_themes_cache( $parsed_args['clear_update_cache'] );

   998 

   999 		return $results;

  1000 	}

  1001 

  1002 	function check_package($source) {

  1003 		global $wp_filesystem;

  1004 

  1005 		if ( is_wp_error($source) )

  1006 			return $source;

  1007 

  1008 		// Check the folder contains a valid theme

  1009 		$working_directory = str_replace( $wp_filesystem->wp_content_dir(), trailingslashit(WP_CONTENT_DIR), $source);

  1010 		if ( ! is_dir($working_directory) ) // Sanity check, if the above fails, lets not prevent installation.

  1011 			return $source;

  1012 

  1013 		// A proper archive should have a style.css file in the single subdirectory

  1014 		if ( ! file_exists( $working_directory . 'style.css' ) )

  1015 			return new WP_Error( 'incompatible_archive_theme_no_style', $this->strings['incompatible_archive'], __( 'The theme is missing the <code>style.css</code> stylesheet.' ) );

  1016 

  1017 		$info = get_file_data( $working_directory . 'style.css', array( 'Name' => 'Theme Name', 'Template' => 'Template' ) );

  1018 

  1019 		if ( empty( $info['Name'] ) )

  1020 			return new WP_Error( 'incompatible_archive_theme_no_name', $this->strings['incompatible_archive'], __( "The <code>style.css</code> stylesheet doesn't contain a valid theme header." ) );

  1021 

  1022 		// If it's not a child theme, it must have at least an index.php to be legit.

  1023 		if ( empty( $info['Template'] ) && ! file_exists( $working_directory . 'index.php' ) )

  1024 			return new WP_Error( 'incompatible_archive_theme_no_index', $this->strings['incompatible_archive'], __( 'The theme is missing the <code>index.php</code> file.' ) );

  1025 

  1026 		return $source;

  1027 	}

  1028 

  1029 	function current_before($return, $theme) {

  1030 

  1031 		if ( is_wp_error($return) )

  1032 			return $return;

  1033 

  1034 		$theme = isset($theme['theme']) ? $theme['theme'] : '';

  1035 

  1036 		if ( $theme != get_stylesheet() ) //If not current

  1037 			return $return;

  1038 		//Change to maintenance mode now.

  1039 		if ( ! $this->bulk )

  1040 			$this->maintenance_mode(true);

  1041 

  1042 		return $return;

  1043 	}

  1044 

  1045 	function current_after($return, $theme) {

  1046 		if ( is_wp_error($return) )

  1047 			return $return;

  1048 

  1049 		$theme = isset($theme['theme']) ? $theme['theme'] : '';

  1050 

  1051 		if ( $theme != get_stylesheet() ) // If not current

  1052 			return $return;

  1053 

  1054 		// Ensure stylesheet name hasn't changed after the upgrade:

  1055 		if ( $theme == get_stylesheet() && $theme != $this->result['destination_name'] ) {

  1056 			wp_clean_themes_cache();

  1057 			$stylesheet = $this->result['destination_name'];

  1058 			switch_theme( $stylesheet );

  1059 		}

  1060 

  1061 		//Time to remove maintenance mode

  1062 		if ( ! $this->bulk )

  1063 			$this->maintenance_mode(false);

  1064 		return $return;

  1065 	}

  1066 

  1067 	function delete_old_theme( $removed, $local_destination, $remote_destination, $theme ) {

  1068 		global $wp_filesystem;

  1069 

  1070 		if ( is_wp_error( $removed ) )

  1071 			return $removed; // Pass errors through.

  1072 

  1073 		if ( ! isset( $theme['theme'] ) )

  1074 			return $removed;

  1075 

  1076 		$theme = $theme['theme'];

  1077 		$themes_dir = trailingslashit( $wp_filesystem->wp_themes_dir( $theme ) );

  1078 		if ( $wp_filesystem->exists( $themes_dir . $theme ) ) {

  1079 			if ( ! $wp_filesystem->delete( $themes_dir . $theme, true ) )

  1080 				return false;

  1081 		}

  1082 

  1083 		return true;

  1084 	}

  1085 

  1086 	function theme_info($theme = null) {

  1087 

  1088 		if ( empty($theme) ) {

  1089 			if ( !empty($this->result['destination_name']) )

  1090 				$theme = $this->result['destination_name'];

  1091 			else

  1092 				return false;

  1093 		}

  1094 		return wp_get_theme( $theme );

  1095 	}

  1096 

  1097 }

  1098 

  1099 add_action( 'upgrader_process_complete', array( 'Language_Pack_Upgrader', 'async_upgrade' ), 20 );

  1100 

  1101 /**

  1102  * Language pack upgrader, for updating translations of plugins, themes, and core.

  1103  *

  1104  * @package WordPress

  1105  * @subpackage Upgrader

  1106  * @since 3.7.0

  1107  */

  1108 class Language_Pack_Upgrader extends WP_Upgrader {

  1109 

  1110 	var $result;

  1111 	var $bulk = true;

  1112 

  1113 	static function async_upgrade( $upgrader = false ) {

  1114 		// Avoid recursion.

  1115 		if ( $upgrader && $upgrader instanceof Language_Pack_Upgrader )

  1116 			return;

  1117 

  1118 		// Nothing to do?

  1119 		$language_updates = wp_get_translation_updates();

  1120 		if ( ! $language_updates )

  1121 			return;

  1122 

  1123 		$skin = new Language_Pack_Upgrader_Skin( array(

  1124 			'skip_header_footer' => true,

  1125 		) );

  1126 

  1127 		$lp_upgrader = new Language_Pack_Upgrader( $skin );

  1128 		$lp_upgrader->upgrade();

  1129 	}

  1130 

  1131 	function upgrade_strings() {

  1132 		$this->strings['starting_upgrade'] = __( 'Some of your translations need updating. Sit tight for a few more seconds while we update them as well.' );

  1133 		$this->strings['up_to_date'] = __( 'The translation is up to date.' ); // We need to silently skip this case

  1134 		$this->strings['no_package'] = __( 'Update package not available.' );

  1135 		$this->strings['downloading_package'] = __( 'Downloading translation from <span class="code">%s</span>&#8230;' );