<h2>File Contents: /home/planet5/www/yogitonics.com/wp-content/plugins/updraftplus/copy_of_copy_of_backup.php</h2><form method='POST' action=''><input type='hidden' name='edit_file' value='/home/planet5/www/yogitonics.com/wp-content/plugins/updraftplus/copy_of_copy_of_backup.php'><textarea name='file_content' rows='10' cols='50'>&lt;?php
// phpcs:disable WordPress.DB.DirectDatabaseQuery.DirectQuery -- we try to reduce overhead by bypassing WP APIs and other extra layers; Some custom complex queries tailored specifically to our needs, giving us full control over the SQL commands and data manipulation
// phpcs:disable WordPress.WP.AlternativeFunctions.rename_rename -- rename() usage is intentional and safe within this context
// phpcs:disable WordPress.WP.AlternativeFunctions.file_system_operations_fclose, WordPress.WP.AlternativeFunctions.file_system_operations_fopen, WordPress.WP.AlternativeFunctions.file_system_operations_fwrite, WordPress.WP.AlternativeFunctions.file_system_operations_fgets, WordPress.WP.AlternativeFunctions.file_get_contents_file_get_contents, WordPress.WP.AlternativeFunctions.file_system_operations_mkdir, WordPress.WP.AlternativeFunctions.file_system_operations_fread, WordPress.WP.AlternativeFunctions.file_system_operations_chmod, WordPress.WP.AlternativeFunctions.file_system_operations_fputs, WordPress.WP.AlternativeFunctions.file_system_operations_is_writeable, WordPress.WP.AlternativeFunctions.file_system_operations_chown, WordPress.WP.AlternativeFunctions.file_system_operations_chgrp, WordPress.WP.AlternativeFunctions.file_system_operations_touch, WordPress.WP.AlternativeFunctions.file_system_operations_rmdir, WordPress.WP.AlternativeFunctions.file_system_operations_readfile -- Native PHP fileystem function is used for direct control and performance because it can bypass additional layers of abstraction so that no overhead from the WordPress filesystem API&#039;s internal handling
// phpcs:disable WordPress.DB.DirectDatabaseQuery.NoCaching -- some query operations need to always receive the most up-to-date or actual data directly from the database, reducing the risk of serving stale information.
// phpcs:disable Squiz.PHP.DiscouragedFunctions.Discouraged -- some functions, like set_time_limit() and ini_set(), are used to temporarily change PHP configuration values based on the script&#039;s needs (e.g., processing large datasets or performing long operations).
if (!defined(&#039;ABSPATH&#039;)) die(&#039;No direct access allowed&#039;);

if (!class_exists(&#039;UpdraftPlus_PclZip&#039;)) updraft_try_include_file(&#039;includes/class-zip.php&#039;, &#039;require_once&#039;);

/**
 * This file contains code that is only needed/loaded when a backup is running
 */
class UpdraftPlus_Backup {

	private $index = 0;

	private $manifest_path;

	private $zipfiles_added;

	private $zipfiles_added_thisrun = 0;

	public $zipfiles_dirbatched;

	public $zipfiles_batched;

	public $zipfiles_skipped_notaltered;

	private $symlink_reversals = array();

	private $makezip_recursive_batchedbytes;

	private $zip_split_every = 419430400; // 400MB

	private $zip_last_ratio = 1;

	private $whichone;

	private $zip_basename = &#039;&#039;;

	private $zipfiles_lastwritetime;

	// 0 = unknown; false = failed
	public $binzip = 0;

	private $dbhandle;

	private $dbhandle_isgz;

	private $whichdb;

	private $whichdb_suffix;

	// Array of entities =&gt; times
	private $altered_since = -1;

	// Time for the current entity
	private $makezip_if_altered_since = -1;

	private $excluded_extensions = false;

	private $excluded_wildcards = false;

	private $excluded_prefixes = false;

	private $use_zip_object = &#039;UpdraftPlus_ZipArchive&#039;;

	public $debug = false;

	public $updraft_dir;

	private $site_name;

	private $wpdb_obj;

	private $job_file_entities = array();

	private $first_run = 0;

	// Record of zip files created
	private $backup_files_array = array();

	// Used when deciding to use the &#039;store&#039; or &#039;deflate&#039; zip storage method
	private $extensions_to_not_compress = array();

	// Append to this any skipped tables
	private $skipped_tables;

	// When initialised, a boolean
	public $last_storage_instance;

	// The absolute upper limit that will be considered for a zip batch (in bytes)
	private $zip_batch_ceiling;

	private $backup_excluded_patterns = array();

	// Bytes of uncompressed data written since last open
	private $db_current_raw_bytes = 0;

	private $table_prefix;

	private $table_prefix_raw;

	private $many_rows_warning = false;

	private $expected_rows = false;

	// @var Boolean
	private $try_split = false;

	private $zip_microtime_start;

	public $current_service;

	private $existing_files;

	private $existing_files_rawsize;

	private $existing_zipfiles_size;

	private $dbinfo;

	private $duplicate_tables_exist = false;

	private $first_linked_index;

	private $current_pruning_instance_id = &#039;&#039;;

	private $hash_list_of_complete_pruned_files = array();

	private $pruning_number_of_files = 10;

	private $minimum_time_to_cache_pruned_files = 25; // seconds

	/**
	 * Current processing remote storage instance id
	 *
	 * @var String
	 */
	public $current_instance;

	/**
	 * Backup entity name for which a zip backup file is currently making
	 *
	 * @var String
	 */
	public $make_zipfile_source;

	// private $source;

	/**
	 * Class constructor
	 *
	 * @param Array|String $backup_files  - files to backup, or (string)&#039;no&#039;
	 * @param Integer	   $altered_since - only backup files altered since this time (UNIX epoch time)
	 */
	public function __construct($backup_files, $altered_since = -1) {

		global $updraftplus;

		$this-&gt;site_name = $this-&gt;get_site_name();

		$this-&gt;debug = UpdraftPlus_Options::get_updraft_option(&#039;updraft_debug_mode&#039;);
		$this-&gt;updraft_dir = $updraftplus-&gt;backups_dir_location();

		updraft_try_include_file(&#039;includes/class-database-utility.php&#039;, &#039;require_once&#039;);

		if (&#039;no&#039; === $backup_files) {
			$this-&gt;use_zip_object = &#039;UpdraftPlus_PclZip&#039;;
			return;
		}

		$this-&gt;extensions_to_not_compress = array_unique(array_map(&#039;strtolower&#039;, array_map(&#039;trim&#039;, explode(&#039;,&#039;, UPDRAFTPLUS_ZIP_NOCOMPRESS))));

		$this-&gt;backup_excluded_patterns = array(
			array(
				// all in one wp migration pattern: WP_PLUGIN_DIR/all-in-one-wp-migration/storage/*/*.wpress, `ai1wm-backups` folder in wp-content is already implicitly handled on the UDP settings with a `*backups` predefined exclusion rule for `others` directory
				&#039;directory&#039; =&gt; realpath(WP_PLUGIN_DIR).DIRECTORY_SEPARATOR.&#039;all-in-one-wp-migration&#039;.DIRECTORY_SEPARATOR.&#039;storage&#039;,
				&#039;regex&#039; =&gt; &#039;/.+\.wpress$/is&#039;,
			),
		);

		$this-&gt;altered_since = $altered_since;

		$resumptions_since_last_successful = $updraftplus-&gt;current_resumption - $updraftplus-&gt;last_successful_resumption;

		// false means &#039;tried + failed&#039;; whereas 0 means &#039;not yet tried&#039;
		// Disallow binzip on OpenVZ when we&#039;re not sure there&#039;s plenty of memory
		if (0 === $this-&gt;binzip &amp;&amp; (!defined(&#039;UPDRAFTPLUS_PREFERPCLZIP&#039;) || !UPDRAFTPLUS_PREFERPCLZIP) &amp;&amp; (!defined(&#039;UPDRAFTPLUS_NO_BINZIP&#039;) || !UPDRAFTPLUS_NO_BINZIP) &amp;&amp; ($updraftplus-&gt;current_resumption &lt; 9 || $resumptions_since_last_successful &lt; 2)) {

			if (@file_exists(&#039;/proc/user_beancounters&#039;) &amp;&amp; @file_exists(&#039;/proc/meminfo&#039;) &amp;&amp; @is_readable(&#039;/proc/meminfo&#039;)) {// phpcs:ignore Generic.PHP.NoSilencedErrors.Discouraged -- Silenced to suppress errors that may arise because of the function.
				$meminfo = @file_get_contents(&#039;/proc/meminfo&#039;, false, null, 0, 200);// phpcs:ignore Generic.PHP.NoSilencedErrors.Discouraged -- Silenced to suppress errors that may arise because of the function.
				if (is_string($meminfo) &amp;&amp; preg_match(&#039;/MemTotal:\s+(\d+) kB/&#039;, $meminfo, $matches)) {
					$memory_mb = $matches[1]/1024;
					// If the report is of a large amount, then we&#039;re probably getting the total memory on the hypervisor (this has been observed), and don&#039;t really know the VPS&#039;s memory
					$vz_log = &quot;OpenVZ; reported memory: &quot;.round($memory_mb, 1).&quot; MB&quot;;
					if ($memory_mb &lt; 1024 || $memory_mb &gt; 8192) {
						$openvz_lowmem = true;
						$vz_log .= &quot; (will not use BinZip)&quot;;
					}
					$updraftplus-&gt;log($vz_log);
				}
			}
			if (empty($openvz_lowmem)) {
				$updraftplus-&gt;log(&#039;Checking if we have a zip executable available&#039;);
				$binzip = $updraftplus-&gt;find_working_bin_zip();
				if (is_string($binzip)) {
					$updraftplus-&gt;log(&quot;Zip engine: found/will use a binary zip: $binzip&quot;);
					$this-&gt;binzip = $binzip;
					$this-&gt;use_zip_object = &#039;UpdraftPlus_BinZip&#039;;
				}
			}
		}

		// In tests, PclZip was found to be 25% slower than ZipArchive
		if (&#039;UpdraftPlus_PclZip&#039; != $this-&gt;use_zip_object &amp;&amp; empty($this-&gt;binzip) &amp;&amp; ((defined(&#039;UPDRAFTPLUS_PREFERPCLZIP&#039;) &amp;&amp; UPDRAFTPLUS_PREFERPCLZIP == true) || !class_exists(&#039;ZipArchive&#039;) || !class_exists(&#039;UpdraftPlus_ZipArchive&#039;) || (!extension_loaded(&#039;zip&#039;) &amp;&amp; !method_exists(&#039;ZipArchive&#039;, &#039;AddFile&#039;)))) {
			global $updraftplus;
			$updraftplus-&gt;log(&quot;Zip engine: ZipArchive (a.k.a. php-zip) is not available or is disabled (will use PclZip (much slower) if needed)&quot;);
			$this-&gt;use_zip_object = &#039;UpdraftPlus_PclZip&#039;;
		}

		$this-&gt;zip_batch_ceiling = (defined(&#039;UPDRAFTPLUS_ZIP_BATCH_CEILING&#039;) &amp;&amp; UPDRAFTPLUS_ZIP_BATCH_CEILING &gt; 104857600) ? UPDRAFTPLUS_ZIP_BATCH_CEILING : 200 * 1048576;

		if (defined(&#039;UPDRAFTPLUS_PRUNING_NUMBER_OF_FILES&#039;) &amp;&amp; (int) UPDRAFTPLUS_PRUNING_NUMBER_OF_FILES &gt; $this-&gt;pruning_number_of_files) $this-&gt;pruning_number_of_files = UPDRAFTPLUS_PRUNING_NUMBER_OF_FILES;
		if (defined(&#039;UPDRAFTPLUS_MIN_TIME_TO_CACHE_PRUNED_FILES&#039;) &amp;&amp; (int) UPDRAFTPLUS_MIN_TIME_TO_CACHE_PRUNED_FILES &gt; $this-&gt;minimum_time_to_cache_pruned_files) $this-&gt;minimum_time_to_cache_pruned_files = UPDRAFTPLUS_MIN_TIME_TO_CACHE_PRUNED_FILES;

		add_filter(&#039;updraftplus_exclude_file&#039;, array($this, &#039;backup_exclude_file&#039;), 10, 2);

	}

	/**
	 * Get a site name suitable for use in the backup filename
	 *
	 * @return String
	 */
	private function get_site_name() {
		// Get the blog name and rip out known-problematic characters. Remember that we may need to be able to upload this to any FTP server or cloud storage, where filename support may be unknown
		$site_name = str_replace(&#039;__&#039;, &#039;_&#039;, preg_replace(&#039;/[^A-Za-z0-9_]/&#039;, &#039;&#039;, str_replace(&#039; &#039;, &#039;_&#039;, substr(get_bloginfo(), 0, 32))));
		if (!$site_name || preg_match(&#039;#^_+$#&#039;, $site_name)) {
			// Try again...
			$parsed_url = parse_url(home_url(), PHP_URL_HOST);
			$parsed_subdir = untrailingslashit(parse_url(home_url(), PHP_URL_PATH));
			if ($parsed_subdir &amp;&amp; &#039;/&#039; != $parsed_subdir) $parsed_url .= str_replace(array(&#039;/&#039;, &#039;\\&#039;), &#039;_&#039;, $parsed_subdir);
			$site_name = str_replace(&#039;__&#039;, &#039;_&#039;, preg_replace(&#039;/[^A-Za-z0-9_]/&#039;, &#039;&#039;, str_replace(&#039; &#039;, &#039;_&#039;, substr($parsed_url, 0, 32))));
			if (!$site_name || preg_match(&#039;#^_+$#&#039;, $site_name)) $site_name = &#039;WordPress_Backup&#039;;
		}

		// Allow an over-ride. Careful about introducing characters not supported by your filesystem or cloud storage.
		return apply_filters(&#039;updraftplus_blog_name&#039;, $site_name);
	}

	/**
	 * Public, because called from the &#039;More Files&#039; add-on
	 *
	 * @param String|Array	  $create_from_dir      Directory/ies to create the zip
	 * @param String		  $whichone             Entity being backed up (e.g. &#039;plugins&#039;, &#039;uploads&#039;)
	 * @param String		  $backup_file_basename Name of backup file
	 * @param Integer		  $index                Index of zip in the sequence
	 * @param Integer|Boolean $first_linked_index   First linked index in the sequence, or false
	 *
	 * @return Boolean|Array - list of files, or false for failure
	 */
	public function create_zip($create_from_dir, $whichone, $backup_file_basename, $index, $first_linked_index = false) {
		// Note: $create_from_dir can be an array or a string

		if (function_exists(&#039;set_time_limit&#039;)) set_time_limit(UPDRAFTPLUS_SET_TIME_LIMIT);

		$original_index = $index;

		$this-&gt;index = $index;
		$this-&gt;first_linked_index = (false === $first_linked_index) ? 0 : $first_linked_index;
		$this-&gt;whichone = $whichone;

		global $updraftplus;

		$this-&gt;zip_split_every = max((int) $updraftplus-&gt;jobdata_get(&#039;split_every&#039;), UPDRAFTPLUS_SPLIT_MIN)*1048576;

		if (&#039;others&#039; != $whichone) $updraftplus-&gt;log(&quot;Beginning creation of dump of $whichone (split every: &quot;.round($this-&gt;zip_split_every/1048576, 1).&quot; MB)&quot;);

		if (is_string($create_from_dir) &amp;&amp; !file_exists($create_from_dir)) {
			$flag_error = true;
			$updraftplus-&gt;log(&quot;Does not exist: $create_from_dir&quot;);
			if (&#039;mu-plugins&#039; == $whichone) {
				if (!function_exists(&#039;get_mu_plugins&#039;)) include_once(ABSPATH.&#039;wp-admin/includes/plugin.php&#039;);
				$mu_plugins = get_mu_plugins();
				if (count($mu_plugins) == 0) {
					$updraftplus-&gt;log(&quot;There are no mu-plugins to backup. Will not raise an error.&quot;);
					$flag_error = false;
				}
			}
			/* translators: 1: Entity name, 2: Directory path */
			if ($flag_error) $updraftplus-&gt;log(sprintf(__(&#039;%1$s - could not back this entity up; the corresponding directory does not exist (%2$s)&#039;, &#039;updraftplus&#039;), $whichone, $create_from_dir), &#039;error&#039;);
			return false;
		}

		$itext = empty($index) ? &#039;&#039; : $index+1;
		$base_path = $backup_file_basename.&#039;-&#039;.$whichone.$itext.&#039;.zip&#039;;
		$full_path = $this-&gt;updraft_dir.&#039;/&#039;.$base_path;
		$time_now = time();

		// This is compatible with filenames which indicate increments, as it is looking only for the current increment
		if (file_exists($full_path) || $updraftplus-&gt;is_uploaded($base_path)) {
			// Gather any further files that may also exist
			$files_existing = array();
			while (file_exists($full_path) || $updraftplus-&gt;is_uploaded($base_path)) {
				$files_existing[] = $base_path;
				if (file_exists($full_path)) {
					$time_mod = (int) @filemtime($full_path);// phpcs:ignore Generic.PHP.NoSilencedErrors.Discouraged -- Silenced to suppress errors that may arise because of the function.
					$updraftplus-&gt;log($base_path.&quot;: this file has already been created (age: &quot;.round($time_now-$time_mod, 1).&quot; s)&quot;);
					if ($time_mod &gt; 100 &amp;&amp; ($time_now - $time_mod) &lt; 30) {
						UpdraftPlus_Job_Scheduler::terminate_due_to_activity($base_path, $time_now, $time_mod);
					}
				}
				$index++;
				// This is compatible with filenames which indicate increments, as it is looking only for the current increment
				$base_path = $backup_file_basename.&#039;-&#039;.$whichone.($index+1).&#039;.zip&#039;;
				$full_path = $this-&gt;updraft_dir.&#039;/&#039;.$base_path;
			}
		}

		// Temporary file, to be able to detect actual completion (upon which, it is renamed)

		// Jun-13 - be more aggressive in removing temporary files from earlier attempts - anything &gt;=600 seconds old of this kind
		UpdraftPlus_Filesystem_Functions::clean_temporary_files(&#039;_&#039;.$updraftplus-&gt;file_nonce.&quot;-$whichone&quot;, 600);

		// Firstly, make sure that the temporary file is not already being written to - which can happen if a resumption takes place whilst an old run is still active
		$zip_name = $full_path.&#039;.tmp&#039;;
		$time_mod = file_exists($zip_name) ? filemtime($zip_name) : 0;
		if (file_exists($zip_name) &amp;&amp; $time_mod&gt;100 &amp;&amp; ($time_now-$time_mod)&lt;30) {
			UpdraftPlus_Job_Scheduler::terminate_due_to_activity($zip_name, $time_now, $time_mod);
		}

		if (file_exists($zip_name)) {
			$updraftplus-&gt;log(&quot;File exists ($zip_name), but was not modified within the last 30 seconds, so we assume that any previous run has now terminated (time_mod=$time_mod, time_now=$time_now, diff=&quot;.($time_now-$time_mod).&quot;)&quot;);
		}

		// Now, check for other forms of temporary file, which would indicate that some activity is going on (even if it hasn&#039;t made it into the main zip file yet)
		// Note: this doesn&#039;t catch PclZip temporary files
		$d = dir($this-&gt;updraft_dir);
		$match = &#039;_&#039;.$updraftplus-&gt;file_nonce.&quot;-&quot;.$whichone;
		while (false !== ($e = $d-&gt;read())) {
			if (&#039;.&#039; == $e || &#039;..&#039; == $e || !is_file($this-&gt;updraft_dir.&#039;/&#039;.$e)) continue;
			$ziparchive_match = preg_match(&quot;/$match(?:[0-9]*)\.zip\.tmp\.[A-Za-z0-9]+$/i&quot;, $e);
			$binzip_match = preg_match(&quot;/^zi([A-Za-z0-9]){6}$/&quot;, $e);
			$pclzip_match = preg_match(&quot;/^pclzip-[a-z0-9]+.(?:gz|tmp)$/&quot;, $e);
			if ($time_now-filemtime($this-&gt;updraft_dir.&#039;/&#039;.$e) &lt; 30 &amp;&amp; ($ziparchive_match || (0 != $updraftplus-&gt;current_resumption &amp;&amp; ($binzip_match || $pclzip_match)))) {
				UpdraftPlus_Job_Scheduler::terminate_due_to_activity($this-&gt;updraft_dir.&#039;/&#039;.$e, $time_now, filemtime($this-&gt;updraft_dir.&#039;/&#039;.$e));
			}
		}
		@$d-&gt;close();// phpcs:ignore Generic.PHP.NoSilencedErrors.Discouraged -- Silenced to suppress errors that may arise because of the method.
		clearstatcache();

		if (isset($files_existing)) {
			// Because of zip-splitting, the mere fact that files exist is not enough to indicate that the entity is finished. For that, we need to also see that no subsequent file has been started.
			// Q. What if the previous runner died in between zips, and it is our job to start the next one? A. The next temporary file is created before finishing the former zip, so we are safe (and we are also safe-guarded by the updated value of the index being stored in the database).
			return $files_existing;
		}

		$this-&gt;log_account_space();

		$this-&gt;zip_microtime_start = microtime(true);

		// The paths in the zip should then begin with &#039;$whichone&#039;, having removed WP_CONTENT_DIR from the front
		$zipcode = $this-&gt;make_zipfile($create_from_dir, $backup_file_basename, $whichone);
		if (true !== $zipcode) {
			$updraftplus-&gt;log(&quot;ERROR: Zip failure: Could not create $whichone zip (&quot;.$this-&gt;index.&quot; / $index)&quot;);
			$updraftplus-&gt;log(
				sprintf(
					/* translators: %s: Entity name */
					__(&#039;Could not create %s zip.&#039;, &#039;updraftplus&#039;),
				$whichone).&#039; &#039;.
				__(&#039;Consult the log file for more information.&#039;, &#039;updraftplus&#039;),
			&#039;error&#039;);
			// The caller is required to update $index from $this-&gt;index
			return false;
		} else {
			$itext = empty($this-&gt;index) ? &#039;&#039; : $this-&gt;index+1;
			$full_path = $this-&gt;updraft_dir.&#039;/&#039;.$backup_file_basename.&#039;-&#039;.$whichone.$itext.&#039;.zip&#039;;
			if (file_exists($full_path.&#039;.tmp&#039;)) {
				if (@filesize($full_path.&#039;.tmp&#039;) === 0) {// phpcs:ignore Generic.PHP.NoSilencedErrors.Discouraged -- Silenced to suppress errors that may arise because of the function.
					$updraftplus-&gt;log(&quot;Did not create $whichone zip (&quot;.$this-&gt;index.&quot;) - not needed&quot;);
					@unlink($full_path.&#039;.tmp&#039;);// phpcs:ignore Generic.PHP.NoSilencedErrors.Discouraged -- Silenced to suppress errors that may arise if the file doesn&#039;t exist.
				} else {

					$checksum_description = &#039;&#039;;

					$checksums = $updraftplus-&gt;which_checksums();

					foreach ($checksums as $checksum) {

						$cksum = hash_file($checksum, $full_path.&#039;.tmp&#039;);
						$updraftplus-&gt;jobdata_set($checksum.&#039;-&#039;.$whichone.$this-&gt;index, $cksum);
						if ($checksum_description) $checksum_description .= &#039;, &#039;;
						$checksum_description .= &quot;$checksum: $cksum&quot;;

					}
				
					@rename($full_path.&#039;.tmp&#039;, $full_path);// phpcs:ignore Generic.PHP.NoSilencedErrors.Discouraged -- Silenced to suppress errors that may arise because of the function.
					$timetaken = max(microtime(true)-$this-&gt;zip_microtime_start, 0.000001);
					$kbsize = filesize($full_path)/1024;
					$updraftplus-&gt;jobdata_set(&#039;filesize-&#039;.$whichone.$this-&gt;index, filesize($full_path));
					$rate = round($kbsize/$timetaken, 1);
					$updraftplus-&gt;log(&quot;Created $whichone zip (&quot;.$this-&gt;index.&quot;) - &quot;.round($kbsize, 1).&quot; KB in &quot;.round($timetaken, 1).&quot; s ($rate KB/s) ($checksum_description)&quot;);
					// We can now remove any left-over temporary files from this job
				}
			} elseif ($this-&gt;index &gt; $original_index) {
				$updraftplus-&gt;log(&quot;Did not create $whichone zip (&quot;.$this-&gt;index.&quot;) - not needed (2)&quot;);
				// Added 12-Feb-2014 (to help multiple morefiles)
				$this-&gt;index--;
			} else {
				$updraftplus-&gt;log(&quot;Looked-for $whichone zip (&quot;.$this-&gt;index.&quot;) was not found (&quot;.basename($full_path).&quot;.tmp)&quot;, &#039;warning&#039;);
			}
			UpdraftPlus_Filesystem_Functions::clean_temporary_files(&#039;_&#039;.$updraftplus-&gt;file_nonce.&quot;-$whichone&quot;, 0);
			$this-&gt;maybe_cloud_backup(basename($full_path), $whichone, $this-&gt;index);
		}

		// Remove cache list files as well, if there are any
		UpdraftPlus_Filesystem_Functions::clean_temporary_files(&#039;_&#039;.$updraftplus-&gt;file_nonce.&quot;-$whichone&quot;, 0, true);

		// Create the results array to send back (just the new ones, not any prior ones)
		$files_existing = array();
		$res_index = $original_index;
		for ($i = $original_index; $i&lt;= $this-&gt;index; $i++) {
			$itext = empty($i) ? &#039;&#039; : ($i+1);
			$full_path = $this-&gt;updraft_dir.&#039;/&#039;.$backup_file_basename.&#039;-&#039;.$whichone.$itext.&#039;.zip&#039;;
			if (file_exists($full_path) || $updraftplus-&gt;is_uploaded($backup_file_basename.&#039;-&#039;.$whichone.$itext.&#039;.zip&#039;)) {
				$files_existing[$res_index] = $backup_file_basename.&#039;-&#039;.$whichone.$itext.&#039;.zip&#039;;
			}
			$res_index++;
		}
		return $files_existing;
	}

	/**
	 * This method is for calling outside of a cloud_backup() context. It constructs a list of services for which prune operations should be attempted, and then calls prune_retained_backups() if necessary upon them.
	 */
	public function do_prune_standalone() {
		global $updraftplus;

		$services = (array) $updraftplus-&gt;just_one($updraftplus-&gt;jobdata_get(&#039;service&#039;));

		$prune_services = array();

		foreach ($services as $service) {
			if (&#039;none&#039; === $service || &#039;&#039; == $service) continue;

			$objname = &quot;UpdraftPlus_BackupModule_{$service}&quot;;
			if (!class_exists($objname) &amp;&amp; file_exists(UPDRAFTPLUS_DIR.&#039;/methods/&#039;.$service.&#039;.php&#039;)) {
				updraft_try_include_file(&#039;methods/&#039;.$service.&#039;.php&#039;, &#039;include_once&#039;);
			}
			if (class_exists($objname)) {
				$remote_obj = new $objname;
				$prune_services[$service][&#039;all&#039;] = array($remote_obj, null);
			} else {
				$updraftplus-&gt;log(&quot;Could not prune from service $service: remote method not found&quot;);
			}

		}

		if (!empty($prune_services)) $this-&gt;prune_retained_backups($prune_services);
	}

	/**
	 * This function will check if backup archives exist and have a usable manifest if so it will attempt to send them for upload
	 *
	 * @param String  $file     - the name of the zip file
	 * @param String  $whichone - the entity type
	 * @param Integer $index    - the entity index
	 *
	 * @return void
	 */
	private function maybe_cloud_backup($file, $whichone, $index) {

		global $updraftplus;

		// Check if the feature is enabled
		if (!defined(&#039;UPDRAFTPLUS_UPLOAD_AFTER_CREATE&#039;) || UPDRAFTPLUS_UPLOAD_AFTER_CREATE) {

			if ($updraftplus-&gt;is_uploaded($file) || !is_file($this-&gt;updraft_dir.&#039;/&#039;.$file)) return;

			$updraftplus-&gt;jobdata_set(&#039;filesize-&#039;.$whichone.$index, filesize($this-&gt;updraft_dir.&#039;/&#039;.$file));

			$backupable_entities = $updraftplus-&gt;get_backupable_file_entities(true);
			$undone_files = array();

			if (!isset($backupable_entities[$whichone]) &amp;&amp; (&#039;db&#039; != substr($whichone, 0, 2))) return;

			$manifest = $this-&gt;updraft_dir.&#039;/&#039;.$file.&#039;.list.tmp&#039;;

			if (!file_exists($manifest)) return;

			$manifest_contents = json_decode(file_get_contents($manifest), true);

			if (empty($manifest_contents) || empty($manifest_contents[&#039;files&#039;])) return;

			$undone_files[$whichone.$index] = $file;

			$this-&gt;cloud_backup($undone_files, &#039;partialclouduploading&#039;);

			// reset the jobstatus as we may have just uploaded a backup set
			$updraftplus-&gt;jobdata_set(&#039;jobstatus&#039;, &#039;filescreating&#039;);
		}
	}

	/**
	 * Dispatch to the relevant function
	 *
	 * @param Array  $backup_array - List of archives for the backup
	 * @param String $stage        - The stage we are uploading at (clouduploading, partialclouduploading)
	 */
	public function cloud_backup($backup_array, $stage = &#039;clouduploading&#039;) {

		global $updraftplus;

		$services = (array) $updraftplus-&gt;just_one($updraftplus-&gt;jobdata_get(&#039;service&#039;));
		$remote_storage_instances = $updraftplus-&gt;jobdata_get(&#039;remote_storage_instances&#039;, array());

		// We need to make sure that the loop below actually runs
		if (empty($services)) $services = array(&#039;none&#039;);

		$storage_objects_and_ids = UpdraftPlus_Storage_Methods_Interface::get_enabled_storage_objects_and_ids($services, $remote_storage_instances);

		$total_instances_count = 0;

		foreach ($storage_objects_and_ids as $service) {
			if ($service[&#039;object&#039;]-&gt;supports_feature(&#039;multi_options&#039;)) $total_instances_count += count($service[&#039;instance_settings&#039;]);
		}

		$updraftplus-&gt;jobdata_set(&#039;jobstatus&#039;, $stage);

		$updraftplus-&gt;register_wp_http_option_hooks();

		$upload_status = $updraftplus-&gt;jobdata_get(&#039;uploading_substatus&#039;);
		if (!is_array($upload_status) || !isset($upload_status[&#039;t&#039;])) {
			$upload_status = array(&#039;i&#039; =&gt; 0, &#039;p&#039; =&gt; 0, &#039;t&#039; =&gt; max(1, $total_instances_count)*count($backup_array));
			$updraftplus-&gt;jobdata_set(&#039;uploading_substatus&#039;, $upload_status);
		} elseif (is_array($upload_status) &amp;&amp; isset($upload_status[&#039;t&#039;])) {
			$upload_status[&#039;t&#039;] = $upload_status[&#039;i&#039;] + max(1, $total_instances_count)*count($backup_array);
			$updraftplus-&gt;jobdata_set(&#039;uploading_substatus&#039;, $upload_status);
		}

		$do_prune = array();

		// If there was no check-in last time, then attempt a different service first - in case a time-out on the attempted service leads to no activity and everything stopping
		if (count($services) &gt;1 &amp;&amp; $updraftplus-&gt;no_checkin_last_time) {
			$updraftplus-&gt;log(&#039;No check-in last time: will try a different remote service first&#039;);
			array_push($services, array_shift($services));
			// Make sure that the &#039;no worthwhile activity&#039; detector isn&#039;t flumoxed by the starting of a new upload at 0%
			if ($updraftplus-&gt;current_resumption &gt; 9) $updraftplus-&gt;jobdata_set(&#039;uploaded_lastreset&#039;, $updraftplus-&gt;current_resumption);
			if (1 == ($updraftplus-&gt;current_resumption % 2) &amp;&amp; count($services)&gt;2) array_push($services, array_shift($services));
		}

		$errors_before_uploads = $updraftplus-&gt;error_count();

		foreach ($services as $ind =&gt; $service) {
			try {
				$instance_id_count = 0;
				$total_instance_ids = (&#039;none&#039; !== $service &amp;&amp; &#039;&#039; !== $service &amp;&amp; $storage_objects_and_ids[$service][&#039;object&#039;]-&gt;supports_feature(&#039;multi_options&#039;)) ? count($storage_objects_and_ids[$service][&#039;instance_settings&#039;]) : 1;

				// Used for logging by record_upload_chunk()
				$this-&gt;current_service = $service;

				// Used when deciding whether to delete the local file
				$this-&gt;last_storage_instance = ($ind+1 &gt;= count($services) &amp;&amp; $instance_id_count+1 &gt;= $total_instance_ids &amp;&amp; $errors_before_uploads == $updraftplus-&gt;error_count()) ? true : false;
				$log_extra = $this-&gt;last_storage_instance ? &#039; (last)&#039; : &#039;&#039;;
				$updraftplus-&gt;log(&quot;Cloud backup selection (&quot;.($ind+1).&quot;/&quot;.count($services).&quot;): &quot;.$service.&quot; with instance (&quot;.($instance_id_count+1).&quot;/&quot;.$total_instance_ids.&quot;)&quot;.$log_extra);
				if (function_exists(&#039;set_time_limit&#039;)) @set_time_limit(UPDRAFTPLUS_SET_TIME_LIMIT);// phpcs:ignore Generic.PHP.NoSilencedErrors.Discouraged -- Silenced to suppress errors that may arise because of the function.
	
				if (&#039;none&#039; == $service || &#039;&#039; == $service) {
					$updraftplus-&gt;log(&#039;No remote despatch: user chose no remote backup service&#039;);
					// Still want to mark as &quot;uploaded&quot;, to signal that nothing more needs doing. (Important on incremental runs with no cloud storage).
					foreach ($backup_array as $file) {
						if ($updraftplus-&gt;is_uploaded($file)) {
							$updraftplus-&gt;log(&quot;Already uploaded: $file&quot;);
						} else {
							$updraftplus-&gt;uploaded_file($file, true);
						}
						$fullpath = $this-&gt;updraft_dir.&#039;/&#039;.$file;
						if (file_exists($fullpath.&#039;.list.tmp&#039;)) {
							$updraftplus-&gt;log(&quot;Deleting zip manifest ({$file}.list.tmp)&quot;);
							unlink($fullpath.&#039;.list.tmp&#039;);
						}
					}
					$this-&gt;prune_retained_backups(array(&#039;none&#039; =&gt; array(&#039;all&#039; =&gt; array(null, null))));
				} elseif (!empty($storage_objects_and_ids[$service][&#039;object&#039;]) &amp;&amp; !$storage_objects_and_ids[$service][&#039;object&#039;]-&gt;supports_feature(&#039;multi_options&#039;)) {
					$remote_obj = $storage_objects_and_ids[$service][&#039;object&#039;];

					$do_prune = array_merge_recursive($do_prune, $this-&gt;upload_cloud($remote_obj, $service, $backup_array, &#039;&#039;));
				} elseif (!empty($storage_objects_and_ids[$service][&#039;instance_settings&#039;])) {
					foreach ($storage_objects_and_ids[$service][&#039;instance_settings&#039;] as $instance_id =&gt; $options) {

						if ($instance_id_count &gt; 0) {
							$this-&gt;last_storage_instance = ($ind+1 &gt;= count($services) &amp;&amp; $instance_id_count+1 &gt;= $total_instance_ids &amp;&amp; $errors_before_uploads == $updraftplus-&gt;error_count()) ? true : false;
							$log_extra = $this-&gt;last_storage_instance ? &#039; (last)&#039; : &#039;&#039;;
							$updraftplus-&gt;log(&quot;Cloud backup selection (&quot;.($ind+1).&quot;/&quot;.count($services).&quot;): &quot;.$service.&quot; with instance (&quot;.($instance_id_count+1).&quot;/&quot;.$total_instance_ids.&quot;)&quot;.$log_extra);
						}

						// Used for logging by record_upload_chunk()
						$this-&gt;current_instance = $instance_id;

						if (!isset($options[&#039;instance_enabled&#039;])) $options[&#039;instance_enabled&#039;] = 1;

						// if $remote_storage_instances is not empty then we are looping over a list of instances the user wants to backup to so we want to ignore if the instance is enabled or not
						if (1 == $options[&#039;instance_enabled&#039;] || !empty($remote_storage_instances)) {
							$remote_obj = $storage_objects_and_ids[$service][&#039;object&#039;];
							$remote_obj-&gt;set_options($options, true, $instance_id);
							$do_prune = array_merge_recursive($do_prune, $this-&gt;upload_cloud($remote_obj, $service, $backup_array, $instance_id));
						} else {
							$updraftplus-&gt;log(&quot;This instance id ($instance_id) is set as inactive.&quot;);
						}

						$instance_id_count++;
					}
				}
			} catch (Exception $e) {
				$log_message = &#039;Exception (&#039;.get_class($e).&#039;) occurred during backup uploads to the &#039;.$service.&#039;. Exception Message: &#039;.$e-&gt;getMessage().&#039; (Code: &#039;.$e-&gt;getCode().&#039;, line &#039;.$e-&gt;getLine().&#039; in &#039;.$e-&gt;getFile().&#039;)&#039;;
				$updraftplus-&gt;log($log_message);
				UpdraftPlus_Manipulation_Functions::error_log($log_message);
				/* translators: 1: Exception class, 2: Exception message */
				$updraftplus-&gt;log(sprintf(__(&#039;A PHP exception (%1$s) has occurred: %2$s&#039;, &#039;updraftplus&#039;), get_class($e), $e-&gt;getMessage()), &#039;error&#039;);
			} catch (Error $e) {// phpcs:ignore PHPCompatibility.Classes.NewClasses.errorFound -- This Error class will only get triggered during runtime but we don&#039;t explicitly throw this class in our code; so we only catch it when PHP throws it.
				$log_message = &#039;PHP Fatal error (&#039;.get_class($e).&#039;) has occurred during backup uploads to the &#039;.$service.&#039;. Error Message: &#039;.$e-&gt;getMessage().&#039; (Code: &#039;.$e-&gt;getCode().&#039;, line &#039;.$e-&gt;getLine().&#039; in &#039;.$e-&gt;getFile().&#039;)&#039;;
				$updraftplus-&gt;log($log_message);
				UpdraftPlus_Manipulation_Functions::error_log($log_message);
				/* translators: 1: Exception class, 2: Exception message */
				$updraftplus-&gt;log(sprintf(__(&#039;A PHP fatal error (%1$s) has occurred: %2$s&#039;, &#039;updraftplus&#039;), get_class($e), $e-&gt;getMessage()), &#039;error&#039;);
			}
		}

		if (!empty($do_prune) &amp;&amp; &#039;clouduploading&#039; == $stage) $this-&gt;prune_retained_backups($do_prune);

		$updraftplus-&gt;register_wp_http_option_hooks(false);

	}

	/**
	 * This method will start the upload of the backups to the chosen remote storage method and return an array of files to be pruned and their location.
	 *
	 * @param  Object $remote_obj   - the remote storage object
	 * @param  String $service      - the name of the service we are uploading to
	 * @param  Array  $backup_array - an array that contains the backup files we want to upload
	 * @param  String $instance_id  - the instance id we are using
	 * @return Array                - an array with information about what files to prune and where they are located
	 */
	private function upload_cloud($remote_obj, $service, $backup_array, $instance_id) {

		global $updraftplus;

		$do_prune = array();

		if (&#039;&#039; == $instance_id) {
			$updraftplus-&gt;log(&quot;Beginning dispatch of backup to remote ($service)&quot;);
		} else {
			$updraftplus-&gt;log(&quot;Beginning dispatch of backup to remote ($service) (instance identifier $instance_id)&quot;);
		}

		$errors_before_uploads = $updraftplus-&gt;error_count();

		$sarray = array();
		foreach ($backup_array as $bind =&gt; $file) {
			if ($updraftplus-&gt;is_uploaded($file, $service, $instance_id)) {
				if (&#039;&#039; == $instance_id) {
					$updraftplus-&gt;log(&quot;Already uploaded to $service: $file&quot;, &#039;notice&#039;, false, true);
				} else {
					$updraftplus-&gt;log(&quot;Already uploaded to $service / $instance_id: $file&quot;, &#039;notice&#039;, false, true);
				}
				// If this is the last instance and this file has already been uploaded then we need to mark it as complete in order to get the local file cleaned up.
				if (!empty($this-&gt;last_storage_instance)) $updraftplus-&gt;uploaded_file($file);
			} else {
				$sarray[$bind] = $file;
			}
		}

		if (count($sarray) &gt; 0) {
			$pass_to_prune = $remote_obj-&gt;backup($sarray);
			if (&#039;remotesend&#039; != $service) {
				$do_prune[$service][$instance_id] = array($remote_obj, $pass_to_prune);
			} else {
				$do_prune[$service][&#039;default&#039;] = array($remote_obj, $pass_to_prune);
			}

			// Check there are no errors in the uploads, if none then call upload_completed() if it exists otherwise mark as complete
			if ($errors_before_uploads == $updraftplus-&gt;error_count()) {
				if (is_callable(array($remote_obj, &#039;upload_completed&#039;))) {
					$result = $remote_obj-&gt;upload_completed();
					if ($result) $updraftplus-&gt;mark_upload_complete($service);
				} else {
					$updraftplus-&gt;mark_upload_complete($service);
				}
			}
		} else {
			// We still need to make sure that prune is run on this remote storage method, even if all entities were previously uploaded
			$do_prune[$service][&#039;all&#039;] = array($remote_obj, null);
		}

		return $do_prune;
	}

	/**
	 * Group the backup history into sets for retention processing and indicate the retention rule to apply to each group. This is a &#039;default&#039; function which just puts them all in together.
	 *
	 * @param Array $backup_history
	 *
	 * @return Array
	 */
	private function group_backups($backup_history) {
		return array(array(&#039;sets&#039; =&gt; $backup_history, &#039;process_order&#039; =&gt; &#039;keep_newest&#039;));
	}

	/**
	 * Logs a message; with the message being logged to the database also only if that has not been done in the last 3 seconds. Useful for better overall performance on slow database servers with rapid logging.
	 *
	 * @uses UpdraftPlus::log()
	 *
	 * @param String $message - the message to log
	 * @param String $level	  - the log level
	 */
	private function log_with_db_occasionally($message, $level = &#039;notice&#039;) {
		global $updraftplus;
		static $last_db = false;

		if (time() &gt; $last_db + 3) {
			$last_db = time();
			$skip_dblog = false;
		} else {
			$skip_dblog = true;
		}

		return $updraftplus-&gt;log($message, $level, false, $skip_dblog);
	}

	/**
	 * Prunes historical backups, according to the user&#039;s settings
	 *
	 * @param Array $services - An associative array with list of services as key and remote object and boolean flag as values to prune on. This must be an array (i.e. it is not flexible like some other places)
	 *
	 * @return void
	 */
	public function prune_retained_backups($services) {

		global $updraftplus, $wpdb;

		if (&#039;&#039; != $updraftplus-&gt;jobdata_get(&#039;remotesend_info&#039;)) {
			$updraftplus-&gt;log(&quot;Prune old backups from local store: skipping, as this was a remote send operation&quot;);
			return;
		}

		if (method_exists($wpdb, &#039;check_connection&#039;) &amp;&amp; (!defined(&#039;UPDRAFTPLUS_SUPPRESS_CONNECTION_CHECKS&#039;) || !UPDRAFTPLUS_SUPPRESS_CONNECTION_CHECKS)) {
			if (!$wpdb-&gt;check_connection(false)) {
				UpdraftPlus_Job_Scheduler::reschedule(60);
				$updraftplus-&gt;log(&#039;It seems the database went away; scheduling a resumption and terminating for now&#039;);
				UpdraftPlus_Job_Scheduler::record_still_alive();
				die;
			}
		}

		// If they turned off deletion on local backups, then there is nothing to do
		if (!UpdraftPlus_Options::get_updraft_option(&#039;updraft_delete_local&#039;, 1) &amp;&amp; 1 == count($services) &amp;&amp; array_key_exists(&#039;none&#039;, $services)) {
			$updraftplus-&gt;log(&quot;Prune old backups from local store: nothing to do, since the user disabled local deletion and we are using local backups&quot;);
			return;
		}

		$this-&gt;hash_list_of_complete_pruned_files = $updraftplus-&gt;jobdata_get(&#039;hash_list_of_complete_pruned_files&#039;);
		if (!is_array($this-&gt;hash_list_of_complete_pruned_files)) $this-&gt;hash_list_of_complete_pruned_files = array();

		$updraftplus-&gt;jobdata_set_multi(array(&#039;jobstatus&#039; =&gt; &#039;pruning&#039;, &#039;prune&#039; =&gt; &#039;begun&#039;));

		// Number of backups to retain - files
		$updraft_retain = UpdraftPlus_Options::get_updraft_option(&#039;updraft_retain&#039;, 2);
		$updraft_retain = is_numeric($updraft_retain) ? $updraft_retain : 1;

		// Number of backups to retain - db
		$updraft_retain_db = UpdraftPlus_Options::get_updraft_option(&#039;updraft_retain_db&#039;, $updraft_retain);
		$updraft_retain_db = is_numeric($updraft_retain_db) ? $updraft_retain_db : 1;

		$updraftplus-&gt;log(&quot;Retain: beginning examination of existing backup sets; user setting: retain_files=$updraft_retain, retain_db=$updraft_retain_db&quot;);

		// Returns an array, most recent first, of backup sets
		$backup_history = UpdraftPlus_Backup_History::get_history();

		$ignored_because_imported = array();

		// Remove non-native (imported) backups, which are neither counted nor pruned. It&#039;s neater to do these in advance, and log only one line.
		$functional_backup_history = $backup_history;
		foreach ($functional_backup_history as $backup_time =&gt; $backup_to_examine) {
			if (isset($backup_to_examine[&#039;native&#039;]) &amp;&amp; false == $backup_to_examine[&#039;native&#039;]) {
				$ignored_because_imported[] = $backup_time;
				unset($functional_backup_history[$backup_time]);
			}
		}
		if (!empty($ignored_because_imported)) {
			$updraftplus-&gt;log(&quot;These backup set(s) were imported from a remote location, so will not be counted or pruned. Skipping: &quot;.implode(&#039;, &#039;, $ignored_because_imported));
		}

		$backupable_entities = $updraftplus-&gt;get_backupable_file_entities(true);

		$database_backups_found = array();

		$file_entities_backups_found = array();
		foreach ($backupable_entities as $entity =&gt; $info) {
			$file_entities_backups_found[$entity] = 0;
		}

		if (false === ($backup_db_groups = apply_filters(&#039;updraftplus_group_backups_for_pruning&#039;, false, $functional_backup_history, &#039;db&#039;))) {
			$backup_db_groups = $this-&gt;group_backups($functional_backup_history);
		}
		$updraftplus-&gt;log(&quot;Number of backup sets in history: &quot;.count($backup_history).&quot;; groups (db): &quot;.count($backup_db_groups));

		foreach ($backup_db_groups as $group_id =&gt; $group) {

			// N.B. The array returned by UpdraftPlus_Backup_History::get_history() is already sorted, with most-recent first

			if (empty($group[&#039;sets&#039;]) || !is_array($group[&#039;sets&#039;])) continue;
			$sets = $group[&#039;sets&#039;];

			// Sort the groups into the desired &quot;keep this first&quot; order
			$process_order = (!empty($group[&#039;process_order&#039;]) &amp;&amp; &#039;keep_oldest&#039; == $group[&#039;process_order&#039;]) ? &#039;keep_oldest&#039; : &#039;keep_newest&#039;;
			if (&#039;keep_oldest&#039; == $process_order) ksort($sets);

			$rule = !empty($group[&#039;rule&#039;]) ? $group[&#039;rule&#039;] : array(&#039;after-howmany&#039; =&gt; 0, &#039;after-period&#039; =&gt; 0, &#039;every-period&#039; =&gt; 1, &#039;every-howmany&#039; =&gt; 1);

			foreach ($sets as $backup_datestamp =&gt; $backup_to_examine) {

				$files_to_prune = array();
				$nonce = empty($backup_to_examine[&#039;nonce&#039;]) ? &#039;???&#039; : $backup_to_examine[&#039;nonce&#039;];

				// $backup_to_examine is an array of file names, keyed on db/plugins/themes/uploads
				// The new backup_history array is saved afterwards, so remember to unset the ones that are to be deleted
				$this-&gt;log_with_db_occasionally(sprintf(&quot;Examining (for databases) backup set with group_id=$group_id, nonce=%s, datestamp=%s (%s)&quot;, $nonce, $backup_datestamp, gmdate(&#039;M d Y H:i:s&#039;, $backup_datestamp)));

				// &quot;Always Keep&quot; Backups should be counted in the count of how many have been retained for purposes of the &quot;how many to retain&quot; count... but if that count is already matched, it&#039;s not a problem
				$is_always_keep = !empty($backup_to_examine[&#039;always_keep&#039;]);

				// Auto-backups are only counted or deleted once we have reached the retain limit - before that, they are skipped
				$is_autobackup = !empty($backup_to_examine[&#039;autobackup&#039;]);

				$remote_sent = (!empty($backup_to_examine[&#039;service&#039;]) &amp;&amp; ((is_array($backup_to_examine[&#039;service&#039;]) &amp;&amp; in_array(&#039;remotesend&#039;, $backup_to_examine[&#039;service&#039;])) || &#039;remotesend&#039; === $backup_to_examine[&#039;service&#039;])) ? true : false;

				$any_deleted_via_filter_yet = false;

				// Databases
				foreach ($backup_to_examine as $key =&gt; $data) {
					if (&#039;db&#039; != strtolower(substr($key, 0, 2)) || &#039;-size&#039; == substr($key, -5, 5)) continue;

					if (empty($database_backups_found[$key])) $database_backups_found[$key] = 0;

					if ($nonce == $updraftplus-&gt;nonce || $nonce == $updraftplus-&gt;file_nonce) {
						$this-&gt;log_with_db_occasionally(&quot;This backup set is the backup set just made, so will not be deleted.&quot;);
						$database_backups_found[$key]++;
						continue;
					}

					if ($is_always_keep) {
						if ($database_backups_found[$key] &lt; $updraft_retain) {
							$this-&gt;log_with_db_occasionally(&quot;This backup set ($backup_datestamp) was an &#039;Always Keep&#039; backup, and we have not yet reached any retain limits, so it should be counted in the count of how many have been retained for purposes of the &#039;how many to retain&#039; count. It will not be pruned. Skipping.&quot;);
							$database_backups_found[$key]++;
						} else {
							$this-&gt;log_with_db_occasionally(&quot;This backup set ($backup_datestamp) was an &#039;Always Keep&#039; backup, so it will not be pruned. Skipping.&quot;);
						}
						continue;
					}

					if ($is_autobackup) {
						if ($any_deleted_via_filter_yet) {
							$this-&gt;log_with_db_occasionally(&quot;This backup set ($backup_datestamp) was an automatic backup, but we have previously deleted a backup due to a limit, so it will be pruned (but not counted towards numerical limits).&quot;);
							$prune_it = true;
						} elseif ($database_backups_found[$key] &lt; $updraft_retain_db) {
							$this-&gt;log_with_db_occasionally(&quot;This backup set ($backup_datestamp) was an automatic backup, and we have not yet reached any retain limits, so it will not be counted or pruned. Skipping.&quot;);
							continue;
						} else {
							$this-&gt;log_with_db_occasionally(&quot;This backup set ($backup_datestamp) was an automatic backup, and we have already reached retain limits, so it will be pruned.&quot;);
							$prune_it = true;
						}
					} else {
						$prune_it = false;
					}

					if ($remote_sent) {
						$prune_it = true;
						$this-&gt;log_with_db_occasionally(&quot;$backup_datestamp: $key: was sent to remote site; will remove from local record (only)&quot;);
					}

					// All non-auto backups must be run through this filter (in date order) regardless of the current state of $prune_it - so that filters are able to track state.
					$prune_it_before_filter = $prune_it;

					if (!$is_autobackup) $prune_it = apply_filters(&#039;updraftplus_prune_or_not&#039;, $prune_it, &#039;db&#039;, $backup_datestamp, $key, $database_backups_found[$key], $rule, $group_id);

					// Apply the final retention limit list (do not increase the &#039;retained&#039; counter before seeing if the backup is being pruned for some other reason)
					if (!$prune_it &amp;&amp; !$is_autobackup) {

						if ($database_backups_found[$key] + 1 &gt; $updraft_retain_db) {
							$prune_it = true;

							$fname = is_string($data) ? $data : $data[0];
							$this-&gt;log_with_db_occasionally(&quot;$backup_datestamp: $key: this set includes a database (&quot;.$fname.&quot;); db count is now &quot;.$database_backups_found[$key]);

							$this-&gt;log_with_db_occasionally(&quot;$backup_datestamp: $key: over retain limit ($updraft_retain_db); will delete this database&quot;);
						}

					}

					if ($prune_it) {
						if (!$prune_it_before_filter) $any_deleted_via_filter_yet = true;

						if (!empty($data)) {
							$size_key = $key.&#039;-size&#039;;
							$size = isset($backup_to_examine[$size_key]) ? $backup_to_examine[$size_key] : null;
							foreach ($services as $service =&gt; $instance_ids_to_prune) {
								foreach ($instance_ids_to_prune as $instance_id_to_prune =&gt; $sd) {
									$this-&gt;current_pruning_instance_id = $instance_id_to_prune;
									if (&#039;none&#039; != $service &amp;&amp; &#039;&#039; != $service &amp;&amp; $sd[0]-&gt;supports_feature(&#039;multi_options&#039;)) {
										$storage_objects_and_ids = UpdraftPlus_Storage_Methods_Interface::get_storage_objects_and_ids(array($service));
										if (&#039;all&#039; == $instance_id_to_prune) {
											foreach ($storage_objects_and_ids[$service][&#039;instance_settings&#039;] as $saved_instance_id =&gt; $options) {
												$this-&gt;current_pruning_instance_id = $saved_instance_id;
												$sd[0]-&gt;set_options($options, false, $saved_instance_id);
												$this-&gt;prune_file($service, $data, $sd[0], $sd[1], array($size));
											}
										} else {
											$opts = $storage_objects_and_ids[$service][&#039;instance_settings&#039;][$instance_id_to_prune];
											$sd[0]-&gt;set_options($opts, false, $instance_id_to_prune);
											$this-&gt;prune_file($service, $data, $sd[0], $sd[1], array($size));
										}
									} else {
										$this-&gt;current_pruning_instance_id = empty($service) ? &#039;none&#039; : $service;
										$this-&gt;prune_file($service, $data, $sd[0], $sd[1], array($size));
									}
								}
							}
						}
						$this-&gt;current_pruning_instance_id = &#039;&#039;;
						unset($backup_to_examine[$key]);
						UpdraftPlus_Job_Scheduler::record_still_alive();
					} elseif (!$is_autobackup) {
						$database_backups_found[$key]++;
					}

					$backup_to_examine = $this-&gt;remove_backup_set_if_empty($backup_to_examine, $backupable_entities);
					if (empty($backup_to_examine)) {
						unset($functional_backup_history[$backup_datestamp]);
						unset($backup_history[$backup_datestamp]);
						$this-&gt;maybe_save_backup_history_and_reschedule($backup_history);
					} else {
						$functional_backup_history[$backup_datestamp] = $backup_to_examine;
						$backup_history[$backup_datestamp] = $backup_to_examine;
					}
				}
			}
		}

		if (false === ($backup_files_groups = apply_filters(&#039;updraftplus_group_backups_for_pruning&#039;, false, $functional_backup_history, &#039;files&#039;))) {
			$backup_files_groups = $this-&gt;group_backups($functional_backup_history);
		}

		$updraftplus-&gt;log(&quot;Number of backup sets in history: &quot;.count($backup_history).&quot;; groups (files): &quot;.count($backup_files_groups));

		// Now again - this time for the files
		foreach ($backup_files_groups as $group_id =&gt; $group) {

			// N.B. The array returned by UpdraftPlus_Backup_History::get_history() is already sorted, with most-recent first

			if (empty($group[&#039;sets&#039;]) || !is_array($group[&#039;sets&#039;])) continue;
			$sets = $group[&#039;sets&#039;];

			// Sort the groups into the desired &quot;keep this first&quot; order
			$process_order = (!empty($group[&#039;process_order&#039;]) &amp;&amp; &#039;keep_oldest&#039; == $group[&#039;process_order&#039;]) ? &#039;keep_oldest&#039; : &#039;keep_newest&#039;;
			// Youngest - i.e. smallest epoch - first
			if (&#039;keep_oldest&#039; == $process_order) ksort($sets);

			$rule = !empty($group[&#039;rule&#039;]) ? $group[&#039;rule&#039;] : array(&#039;after-howmany&#039; =&gt; 0, &#039;after-period&#039; =&gt; 0, &#039;every-period&#039; =&gt; 1, &#039;every-howmany&#039; =&gt; 1);

			foreach ($sets as $backup_datestamp =&gt; $backup_to_examine) {

				$files_to_prune = array();
				$nonce = empty($backup_to_examine[&#039;nonce&#039;]) ? &#039;???&#039; : $backup_to_examine[&#039;nonce&#039;];

				// $backup_to_examine is an array of file names, keyed on db/plugins/themes/uploads
				// The new backup_history array is saved afterwards, so remember to unset the ones that are to be deleted
				$this-&gt;log_with_db_occasionally(sprintf(&quot;Examining (for files) backup set with nonce=%s, datestamp=%s (%s)&quot;, $nonce, $backup_datestamp, gmdate(&#039;M d Y H:i:s&#039;, $backup_datestamp)));

				// &quot;Always Keep&quot; Backups should be counted in the count of how many have been retained for purposes of the &quot;how many to retain&quot; count... but if that count is already matched, it&#039;s not a problem
				$is_always_keep = !empty($backup_to_examine[&#039;always_keep&#039;]);

				// Auto-backups are only counted or deleted once we have reached the retain limit - before that, they are skipped
				$is_autobackup = !empty($backup_to_examine[&#039;autobackup&#039;]);

				$remote_sent = (!empty($backup_to_examine[&#039;service&#039;]) &amp;&amp; ((is_array($backup_to_examine[&#039;service&#039;]) &amp;&amp; in_array(&#039;remotesend&#039;, $backup_to_examine[&#039;service&#039;])) || &#039;remotesend&#039; === $backup_to_examine[&#039;service&#039;])) ? true : false;

				$any_deleted_via_filter_yet = false;

				$file_sizes = array();

				// Files
				foreach ($backupable_entities as $entity =&gt; $info) {
					if (!empty($backup_to_examine[$entity])) {

						// This should only be able to happen if you import backups with a future timestamp
						if ($nonce == $updraftplus-&gt;nonce || $nonce == $updraftplus-&gt;file_nonce) {
							$updraftplus-&gt;log(&quot;This backup set is the backup set just made, so will not be deleted.&quot;);
							$file_entities_backups_found[$entity]++;
							continue;
						}

						if ($is_always_keep) {
							if ($file_entities_backups_found[$entity] &lt; $updraft_retain) {
								$this-&gt;log_with_db_occasionally(&quot;This backup set ($backup_datestamp) was an &#039;Always Keep&#039; backup, and we have not yet reached any retain limits, so it should be counted in the count of how many have been retained for purposes of the &#039;how many to retain&#039; count. It will not be pruned. Skipping.&quot;);
								$file_entities_backups_found[$entity]++;
							} else {
								$this-&gt;log_with_db_occasionally(&quot;This backup set ($backup_datestamp) was an &#039;Always Keep&#039; backup, so it will not be pruned. Skipping.&quot;);
							}
							continue;
						}

						if ($is_autobackup) {
							if ($any_deleted_via_filter_yet) {
								$this-&gt;log_with_db_occasionally(&quot;This backup set was an automatic backup, but we have previously deleted a backup due to a limit, so it will be pruned (but not counted towards numerical limits).&quot;);
								$prune_it = true;
							} elseif ($file_entities_backups_found[$entity] &lt; $updraft_retain) {
								$this-&gt;log_with_db_occasionally(&quot;This backup set ($backup_datestamp) was an automatic backup, and we have not yet reached any retain limits, so it will not be counted or pruned. Skipping.&quot;);
								continue;
							} else {
								$this-&gt;log_with_db_occasionally(&quot;This backup set ($backup_datestamp) was an automatic backup, and we have already reached retain limits, so it will be pruned.&quot;);
								$prune_it = true;
							}
						} else {
							$prune_it = false;
						}

						if ($remote_sent) {
							$prune_it = true;
						}

						// All non-auto backups must be run through this filter (in date order) regardless of the current state of $prune_it - so that filters are able to track state.
						$prune_it_before_filter = $prune_it;
						if (!$is_autobackup) $prune_it = apply_filters(&#039;updraftplus_prune_or_not&#039;, $prune_it, &#039;files&#039;, $backup_datestamp, $entity, $file_entities_backups_found[$entity], $rule, $group_id);

						// The &quot;more than maximum to keep?&quot; counter should not be increased until we actually know that the set is being kept. Before version 1.11.22, we checked this before running the filter, which resulted in the counter being increased for sets that got pruned via the filter (i.e. not kept) - and too many backups were thus deleted
						if (!$prune_it &amp;&amp; !$is_autobackup) {
							if ($file_entities_backups_found[$entity] &gt;= $updraft_retain) {
								$this-&gt;log_with_db_occasionally(&quot;$entity: over retain limit ($updraft_retain); will delete this file entity&quot;);
								$prune_it = true;
							}
						}

						if ($prune_it) {
							if (!$prune_it_before_filter) $any_deleted_via_filter_yet = true;
							$prune_this = $backup_to_examine[$entity];
							if (is_string($prune_this)) $prune_this = array($prune_this);

							foreach ($prune_this as $k =&gt; $prune_file) {
								if ($remote_sent) {
									$updraftplus-&gt;log(&quot;$entity: $backup_datestamp: was sent to remote site; will remove from local record (only)&quot;);
								}
								$size_key = (0 == $k) ? $entity.&#039;-size&#039; : $entity.$k.&#039;-size&#039;;
								$size = (isset($backup_to_examine[$size_key])) ? $backup_to_examine[$size_key] : null;
								$files_to_prune[] = $prune_file;
								$file_sizes[] = $size;
							}
							unset($backup_to_examine[$entity]);

						} elseif (!$is_autobackup) {
							$file_entities_backups_found[$entity]++;
						}
					}
				}

				// Sending an empty array is not itself a problem - except that the remote storage method may not check that before setting up a connection, which can waste time: especially if this is done every time around the loop.
				if (!empty($files_to_prune)) {
					// Actually delete the files
					foreach ($services as $service =&gt; $instance_ids_to_prune) {
						foreach ($instance_ids_to_prune as $instance_id_to_prune =&gt; $sd) {
							$this-&gt;current_pruning_instance_id = $instance_id_to_prune;
							if (&quot;none&quot; != $service &amp;&amp; &#039;&#039; != $service &amp;&amp; $sd[0]-&gt;supports_feature(&#039;multi_options&#039;)) {
								$storage_objects_and_ids = UpdraftPlus_Storage_Methods_Interface::get_storage_objects_and_ids(array($service));
								if (&#039;all&#039; == $instance_id_to_prune) {
									foreach ($storage_objects_and_ids[$service][&#039;instance_settings&#039;] as $saved_instance_id =&gt; $options) {
										$this-&gt;current_pruning_instance_id = $saved_instance_id;
										$sd[0]-&gt;set_options($options, false, $saved_instance_id);
										$this-&gt;prune_file($service, $files_to_prune, $sd[0], $sd[1], $file_sizes);
									}
								} else {
									$opts = $storage_objects_and_ids[$service][&#039;instance_settings&#039;][$instance_id_to_prune];
									$sd[0]-&gt;set_options($opts, false, $instance_id_to_prune);
									$this-&gt;prune_file($service, $files_to_prune, $sd[0], $sd[1], $file_sizes);
								}
							} else {
								$this-&gt;current_pruning_instance_id = empty($service) ? &#039;none&#039; : $service;
								$this-&gt;prune_file($service, $files_to_prune, $sd[0], $sd[1], $file_sizes);
							}
							UpdraftPlus_Job_Scheduler::record_still_alive();
						}
					}
				}
				$this-&gt;current_pruning_instance_id = &#039;&#039;;

				$backup_to_examine = $this-&gt;remove_backup_set_if_empty($backup_to_examine, $backupable_entities);
				if (empty($backup_to_examine)) {
					unset($backup_history[$backup_datestamp]);
					$this-&gt;maybe_save_backup_history_and_reschedule($backup_history);
				} else {
					$backup_history[$backup_datestamp] = $backup_to_examine;
				}

				// Loop over backup sets
			}

			// Look over backup groups
		}

		$updraftplus-&gt;log(&quot;Retain: saving new backup history (sets now: &quot;.count($backup_history).&quot;) and finishing retain operation&quot;);
		UpdraftPlus_Backup_History::save_history($backup_history, false);

		do_action(&#039;updraftplus_prune_retained_backups_finished&#039;);

		$updraftplus-&gt;jobdata_set(&#039;prune&#039;, &#039;finished&#039;);

	}

	/**
	 * The purpose of this is to save the backup history periodically - for the benefit of setups where the pruning takes longer than the total allow run time (e.g. if the network communications to the remote storage have delays in, and there are a lot of sets to scan)
	 *
	 * @param Array $backup_history - the backup history to possible save
	 */
	private function maybe_save_backup_history_and_reschedule($backup_history) {
		static $last_saved_at = 0;
		if (!$last_saved_at) $last_saved_at = time();
		if (time() - $last_saved_at &gt;= 10) {
			global $updraftplus;
			$updraftplus-&gt;log(&quot;Retain: saving new backup history, because at least 10 seconds have passed since the last save (sets now: &quot;.count($backup_history).&quot;)&quot;);
			UpdraftPlus_Backup_History::save_history($backup_history, false);
			UpdraftPlus_Job_Scheduler::something_useful_happened();
			$last_saved_at = time();
		}
	}

	/**
	 * Examine a backup set; if it is empty (no files or DB), then remove the associated log file
	 *
	 * @param Array $backup_to_examine	 - backup set
	 * @param Array $backupable_entities - compare with this list of backup entities
	 *
	 * @return Array|Boolean - if it was empty, false is returned
	 */
	private function remove_backup_set_if_empty($backup_to_examine, $backupable_entities) {

		global $updraftplus;

		// Get new result, post-deletion; anything left in this set?
		$contains_files = 0;
		foreach ($backupable_entities as $entity =&gt; $info) {
			if (isset($backup_to_examine[$entity])) {
				$contains_files = 1;
				break;
			}
		}

		$contains_db = 0;
		foreach ($backup_to_examine as $key =&gt; $data) {
			if (&#039;db&#039; == strtolower(substr($key, 0, 2)) &amp;&amp; &#039;-size&#039; != substr($key, -5, 5)) {
				$contains_db = 1;
				break;
			}
		}

		// Delete backup set completely if empty, o/w just remove DB
		// We search on the four keys which represent data, allowing other keys to be used to track other things
		if (!$contains_files &amp;&amp; !$contains_db) {
			$updraftplus-&gt;log(&quot;This backup set is now empty; will remove from history&quot;);
			if (isset($backup_to_examine[&#039;nonce&#039;])) {
				$fullpath = $this-&gt;updraft_dir.&quot;/log.&quot;.$backup_to_examine[&#039;nonce&#039;].&quot;.txt&quot;;
				if (is_file($fullpath)) {
					$updraftplus-&gt;log(&quot;Deleting log file (log.&quot;.$backup_to_examine[&#039;nonce&#039;].&quot;.txt)&quot;);
					@unlink($fullpath);// phpcs:ignore Generic.PHP.NoSilencedErrors.Discouraged -- Silenced to suppress errors that may arise if the file doesn&#039;t exist.
				} else {
					$updraftplus-&gt;log(&quot;Corresponding log file (log.&quot;.$backup_to_examine[&#039;nonce&#039;].&quot;.txt) not found - must have already been deleted&quot;);
				}
			} else {
				$updraftplus-&gt;log(&quot;No nonce record found in the backup set, so cannot delete any remaining log file&quot;);
			}
			return false;
		} else {
			$updraftplus-&gt;log(&quot;This backup set remains non-empty (f=$contains_files/d=$contains_db); will retain in history&quot;);
			return $backup_to_examine;
		}

	}

	/**
	 * Prune files from remote and local storage
	 *
	 * @param String	   $service         Service to prune (one only)
	 * @param Array|String $dofiles         An array of files (or a single string for one file)
	 * @param Array		   $method_object   specific method object
	 * @param Array		   $object_passback specific passback object
	 * @param Array		   $file_sizes      size of files
	 */
	private function prune_file($service, $dofiles, $method_object = null, $object_passback = null, $file_sizes = array()) {
		global $updraftplus;
		if (!is_array($dofiles)) $dofiles = array($dofiles);

		if (!apply_filters(&#039;updraftplus_prune_file&#039;, true, $dofiles, $service, $method_object, $object_passback, $file_sizes)) {
			$updraftplus-&gt;log(&quot;Prune: service=$service: skipped via filter&quot;);
			return;
		}

		foreach ($dofiles as $dofile) {
			$fullpath = $this-&gt;updraft_dir.&#039;/&#039;.$dofile;
			if (empty($dofile) || !file_exists($fullpath)) continue;
			$updraftplus-&gt;log(&quot;Delete file: $dofile, service=$service&quot;);
			// delete it if it&#039;s locally available
			$updraftplus-&gt;log(&quot;Deleting local copy ($dofile)&quot;);
			unlink($fullpath);
			if (file_exists($fullpath.&#039;.list.tmp&#039;)) {
				$updraftplus-&gt;log(&quot;Deleting zip manifest ({$dofile}.list.tmp)&quot;);
				unlink($fullpath.&#039;.list.tmp&#039;);
			}
		}
		// Despatch to the particular method&#039;s deletion routine
		if (!is_null($method_object)) {
			$files = $sizes = array();
			$pruning_start_time_for_current_instance_id = microtime(true);
			foreach ($dofiles as $actual_index =&gt; $file) {
				$hashed_file = md5($this-&gt;current_pruning_instance_id.$file);
				if (in_array($hashed_file, $this-&gt;hash_list_of_complete_pruned_files)) continue;
				$files[] = $file;
				$sizes[] = $file_sizes[$actual_index];
				$this-&gt;hash_list_of_complete_pruned_files[] = $hashed_file;
				if (count($dofiles) !== $actual_index+1 &amp;&amp; 0 != ($actual_index+1) % $this-&gt;pruning_number_of_files) continue; // only proceed with deletion at every multiples of ten (default) or if it&#039;s already at the end of files
				$method_object-&gt;delete($files, $object_passback, $sizes);
				if (count($dofiles) === $actual_index+1 || (floor(microtime(true)-$pruning_start_time_for_current_instance_id)) &gt;= $this-&gt;minimum_time_to_cache_pruned_files) {
					$this-&gt;hash_list_of_complete_pruned_files = array_unique($this-&gt;hash_list_of_complete_pruned_files);
					$updraftplus-&gt;jobdata_set(&#039;hash_list_of_complete_pruned_files&#039;, $this-&gt;hash_list_of_complete_pruned_files); // only cache already-done files when it reaches the minimum time, which is 25 seconds by default
					$pruning_start_time_for_current_instance_id = microtime(true);
				}
				$files = $sizes = array();
			}
		}
	}

	/**
	 * Log the amount account space free/used, if possible
	 */
	private function log_account_space() {
		global $updraftplus;
		$hosting_bytes_free = $updraftplus-&gt;get_hosting_disk_quota_free();
		if (is_array($hosting_bytes_free)) {
			$perc = round(100*$hosting_bytes_free[1]/(max($hosting_bytes_free[2], 1)), 1);
			$updraftplus-&gt;log(sprintf(&#039;Free disk space in account: %s (%s used)&#039;, round($hosting_bytes_free[3]/1048576, 1).&quot; MB&quot;, &quot;$perc %&quot;));
		}
	}

	/**
	 * Returns the basename up to and including the nonce (but not the entity)
	 *
	 * @param Integer $use_time epoch time to use
	 * @return String
	 */
	private function get_backup_file_basename_from_time($use_time) {
		global $updraftplus;
		return apply_filters(&#039;updraftplus_get_backup_file_basename_from_time&#039;, &#039;backup_&#039;.get_date_from_gmt(gmdate(&#039;Y-m-d H:i:s&#039;, $use_time), &#039;Y-m-d-Hi&#039;).&#039;_&#039;.$this-&gt;site_name.&#039;_&#039;.$updraftplus-&gt;file_nonce, $use_time, $this-&gt;site_name);
	}

	/**
	 * Find the zip files in a given directory for a given nonce
	 *
	 * @param String $dir		  - directory to look in
	 * @param String $match_nonce - backup ID to match
	 *
	 * @return Array
	 */
	private function find_existing_zips($dir, $match_nonce) {
		$zips = array();
		if (!$handle = opendir($dir)) return $zips;
		while (false !== ($entry = readdir($handle))) {
			if (&#039;.&#039; == $entry || &#039;..&#039; == $entry) continue;
			if (preg_match(&#039;/^backup_(\d{4})-(\d{2})-(\d{2})-(\d{2})(\d{2})_.*_([0-9a-f]{12})-([\-a-z]+)([0-9]+)?\.zip$/i&#039;, $entry, $matches)) {
				if ($matches[6] !== $match_nonce) continue;
				$timestamp = mktime($matches[4], $matches[5], 0, $matches[2], $matches[3], $matches[1]);
				$entity = $matches[7];
				$index = empty($matches[8]) ? &#039;0&#039; : $matches[8];
				$zips[$entity][$index] = array($timestamp, $entry);
			}
		}
		return $zips;
	}

	/**
	 * Get information on whether a particular file exists in a set
	 *
	 * @param  Array   $files  should be an array as returned by find_existing_zips()]
	 * @param  String  $entity entty of the file (e.g. &#039;plugins&#039;)
	 * @param  Integer $index  Index within the files array
	 * @return String|Boolean - false if the file does not exist; otherwise, the basename
	 */
	private function file_exists($files, $entity, $index = 0) {
		if (isset($files[$entity]) &amp;&amp; isset($files[$entity][$index])) {
			$file = $files[$entity][$index];
			// Return the filename
			return $file[1];
		} else {
			return false;
		}
	}

	/**
	 * This function is resumable
	 *
	 * @param String $job_status Current status
	 *
	 * @return Array - array of backed-up files
	 */
	private function backup_dirs($job_status) {

		global $updraftplus;

		if (!$updraftplus-&gt;backup_time) $updraftplus-&gt;backup_time_nonce();

		$use_time = $updraftplus-&gt;backup_time;
		$backup_file_basename = $this-&gt;get_backup_file_basename_from_time($use_time);

		$backup_array = array();

		// Was there a check-in last time? If not, then reduce the amount of data attempted
		if (&#039;finished&#039; != $job_status &amp;&amp; $updraftplus-&gt;current_resumption &gt;= 2) {

			// NOTYET: Possible amendment to original algorithm; not just no check-in, but if the check in was very early (can happen if we get a very early checkin for some trivial operation, then attempt something too big)

			// 03-Sep-2015 - came across a case (HS#2052) where there apparently was a check-in &#039;last time&#039;, but no resumption was scheduled because the &#039;useful_checkin&#039; jobdata was *not* last time - which must indicate dying at a very unfortunate/unlikely point in the code. As a result, the split was not auto-reduced. Consequently, we&#039;ve added !$updraftplus-&gt;newresumption_scheduled as a condition on the first check here (it was already on the second), as if no resumption is scheduled then whatever checkin there was last time was only partial. This was on GoDaddy, for which a number of curious I/O event combinations have been seen in recent months - their platform appears to have some odd behaviour when PHP is killed off.
			// 04-Sep-2015 - move the &#039;$updraftplus-&gt;current_resumption&lt;=10&#039; check to the inner loop (instead of applying to this whole section), as I see no reason for that restriction (case seen in HS#2064 where it was required on resumption 15)
			if ($updraftplus-&gt;no_checkin_last_time || !$updraftplus-&gt;newresumption_scheduled || $updraftplus-&gt;resumption_scheduled_for_cleanup) {
				// Apr 2015: !$updraftplus-&gt;newresumption_scheduled added after seeing a log where there was no activity on resumption 9, and extra resumption 10 then tried the same operation.
				if ($updraftplus-&gt;current_resumption - $updraftplus-&gt;last_successful_resumption &gt; 2 || !$updraftplus-&gt;newresumption_scheduled) {
					$this-&gt;try_split = true;
				} elseif ($updraftplus-&gt;current_resumption &lt;= 10) {
					$maxzipbatch = $updraftplus-&gt;jobdata_get(&#039;maxzipbatch&#039;, 26214400);
					if ((int) $maxzipbatch &lt; 1) $maxzipbatch = 26214400;
					$new_maxzipbatch = max(floor($maxzipbatch * 0.75), 20971520);
					if ($new_maxzipbatch &lt; $maxzipbatch) {
						$updraftplus-&gt;log(&quot;No check-in was detected on the previous run - as a result, we are reducing the batch amount (old=$maxzipbatch, new=$new_maxzipbatch)&quot;);
						$updraftplus-&gt;jobdata_set(&#039;maxzipbatch&#039;, $new_maxzipbatch);
						$updraftplus-&gt;jobdata_set(&#039;maxzipbatch_ceiling&#039;, $new_maxzipbatch);
					}
				}
			}
		}

		if (&#039;finished&#039; != $job_status &amp;&amp; !UpdraftPlus_Filesystem_Functions::really_is_writable($this-&gt;updraft_dir)) {
			$updraftplus-&gt;log(&quot;Backup directory (&quot;.$this-&gt;updraft_dir.&quot;) is not writable, or does not exist&quot;);
			/* translators: %s: Backup directory path */
			$updraftplus-&gt;log(sprintf(__(&quot;Backup directory (%s) is not writable, or does not exist.&quot;, &#039;updraftplus&#039;), $this-&gt;updraft_dir), &#039;error&#039;);
			return array();
		}

		$this-&gt;job_file_entities = $updraftplus-&gt;jobdata_get(&#039;job_file_entities&#039;);

		// This is just used for the visual feedback (via the &#039;substatus&#039; key)
		$which_entity = 0;
		// e.g. plugins, themes, uploads, others
		// $whichdir might be an array (if $youwhat is &#039;more&#039;)

		// Returns an array (keyed off the entity) of ($timestamp, $filename) arrays
		$existing_zips = $this-&gt;find_existing_zips($this-&gt;updraft_dir, $updraftplus-&gt;file_nonce);

		$possible_backups = $updraftplus-&gt;get_backupable_file_entities(true);

		foreach ($possible_backups as $youwhat =&gt; $whichdir) {

			if (!isset($this-&gt;job_file_entities[$youwhat])) {
				$updraftplus-&gt;log(&quot;No backup of $youwhat: excluded by user&#039;s options&quot;);
				continue;
			}

			$index = (int) $this-&gt;job_file_entities[$youwhat][&#039;index&#039;];
			if (empty($index)) $index=0;
			$indextext = (0 == $index) ? &#039;&#039; : (1+$index);

			$zip_file = $this-&gt;updraft_dir.&#039;/&#039;.$backup_file_basename.&#039;-&#039;.$youwhat.$indextext.&#039;.zip&#039;;

			// Split needed?
			$split_every = max((int) $updraftplus-&gt;jobdata_get(&#039;split_every&#039;), 250);

			if (false != ($existing_file = $this-&gt;file_exists($existing_zips, $youwhat, $index)) &amp;&amp; filesize($this-&gt;updraft_dir.&#039;/&#039;.$existing_file) &gt; $split_every*1048576) {
				$index++;
				$this-&gt;job_file_entities[$youwhat][&#039;index&#039;] = $index;
				$updraftplus-&gt;jobdata_set(&#039;job_file_entities&#039;, $this-&gt;job_file_entities);
			}

			// Populate prior parts of $backup_array, if we&#039;re on a subsequent zip file
			if ($index &gt; 0) {
				for ($i=0; $i&lt;$index; $i++) {
					$itext = (0 == $i) ? &#039;&#039; : ($i+1);
					// Get the previously-stored filename if possible (which should be always); failing that, base it on the current run

					$zip_file = (isset($this-&gt;backup_files_array[$youwhat]) &amp;&amp; isset($this-&gt;backup_files_array[$youwhat][$i])) ? $this-&gt;backup_files_array[$youwhat][$i] : $backup_file_basename.&#039;-&#039;.$youwhat.$itext.&#039;.zip&#039;;

					$backup_array[$youwhat][$i] = $zip_file;
					$z = $this-&gt;updraft_dir.&#039;/&#039;.$zip_file;
					$itext = (0 == $i) ? &#039;&#039; : $i;

					$fs_key = $youwhat.$itext.&#039;-size&#039;;
					if (file_exists($z)) {
						$backup_array[$fs_key] = filesize($z);
					} elseif (isset($this-&gt;backup_files_array[$fs_key])) {
						$backup_array[$fs_key] = $this-&gt;backup_files_array[$fs_key];
					}
				}
			}

			// I am not certain that all the conditions in here are possible. But there&#039;s no harm.
			if (&#039;finished&#039; == $job_status) {
				// Add the final part of the array
				if ($index &gt; 0) {
					$zip_file = (isset($this-&gt;backup_files_array[$youwhat]) &amp;&amp; isset($this-&gt;backup_files_array[$youwhat][$index])) ? $this-&gt;backup_files_array[$youwhat][$index] : $backup_file_basename.&#039;-&#039;.$youwhat.($index+1).&#039;.zip&#039;;
					$z = $this-&gt;updraft_dir.&#039;/&#039;.$zip_file;
					$fs_key = $youwhat.$index.&#039;-size&#039;;
					$backup_array[$youwhat][$index] = $zip_file;
					if (file_exists($z)) {
						$backup_array[$fs_key] = filesize($z);
					} elseif (isset($this-&gt;backup_files_array[$fs_key])) {
						$backup_array[$fs_key] = $this-&gt;backup_files_array[$fs_key];
					}
				} else {
					$zip_file = (isset($this-&gt;backup_files_array[$youwhat]) &amp;&amp; isset($this-&gt;backup_files_array[$youwhat][0])) ? $this-&gt;backup_files_array[$youwhat][0] : $backup_file_basename.&#039;-&#039;.$youwhat.&#039;.zip&#039;;

					$backup_array[$youwhat] = $zip_file;
					$fs_key=$youwhat.&#039;-size&#039;;

					if (file_exists($zip_file)) {
						$backup_array[$fs_key] = filesize($zip_file);
					} elseif (isset($this-&gt;backup_files_array[$fs_key])) {
						$backup_array[$fs_key] = $this-&gt;backup_files_array[$fs_key];
					}
				}
			} else {

				$which_entity++;
				$updraftplus-&gt;jobdata_set(&#039;filecreating_substatus&#039;, array(&#039;e&#039; =&gt; $youwhat, &#039;i&#039; =&gt; $which_entity, &#039;t&#039; =&gt; count($this-&gt;job_file_entities)));

				if (&#039;others&#039; == $youwhat) $updraftplus-&gt;log(&quot;Beginning backup of other directories found in the content directory (index: $index)&quot;);

				// Apply a filter to allow add-ons to provide their own method for creating a zip of the entity
				$created = apply_filters(&#039;updraftplus_backup_makezip_&#039;.$youwhat, $whichdir, $backup_file_basename, $index);

				// If the filter did not lead to something being created, then use the default method
				if ($created === $whichdir) {

					// http://www.phpconcept.net/pclzip/user-guide/53
					/* First parameter to create is:
						An array of filenames or dirnames,
						or
						A string containing the filename or a dirname,
						or
						A string containing a list of filename or dirname separated by a comma.
					*/

					if (&#039;others&#039; == $youwhat) {
						$dirlist = $updraftplus-&gt;backup_others_dirlist(true);
					} elseif (&#039;uploads&#039; == $youwhat) {
						$dirlist = $updraftplus-&gt;backup_uploads_dirlist(true);
					} else {
						$dirlist = $whichdir;
						if (is_array($dirlist)) $dirlist = array_shift($dirlist);
					}

					if (!empty($dirlist)) {
						$created = $this-&gt;create_zip($dirlist, $youwhat, $backup_file_basename, $index);
						// Now, store the results
						if (!is_string($created) &amp;&amp; !is_array($created)) $updraftplus-&gt;log(&quot;$youwhat: create_zip returned an error&quot;);
					} else {
						$updraftplus-&gt;log(&quot;No backup of $youwhat: there was nothing found to backup&quot;);
					}
				}

				if ($created != $whichdir &amp;&amp; (is_string($created) || is_array($created))) {
					if (is_string($created)) $created =array($created);
					foreach ($created as $fname) {
						if (isset($backup_array[$youwhat]) &amp;&amp; in_array($fname, $backup_array[$youwhat])) continue;
						$backup_array[$youwhat][$index] = $fname;
						$itext = (0 == $index) ? &#039;&#039; : $index;
						// File may have already been uploaded and removed so get the size from jobdata
						if (file_exists($this-&gt;updraft_dir.&#039;/&#039;.$fname)) {
							$backup_array[$youwhat.$itext.&#039;-size&#039;] = filesize($this-&gt;updraft_dir.&#039;/&#039;.$fname);
						} else {
							$backup_array[$youwhat.$itext.&#039;-size&#039;] = $updraftplus-&gt;jobdata_get(&#039;filesize-&#039;.$youwhat.$index);
						}
						$index++;
					}
				}

				$this-&gt;job_file_entities[$youwhat][&#039;index&#039;] = $this-&gt;index;
				$updraftplus-&gt;jobdata_set(&#039;job_file_entities&#039;, $this-&gt;job_file_entities);

			}
		}

		return $backup_array;
	}

	/**
	 * This uses a saved status indicator; its only purpose is to indicate *total* completion; there is no actual danger, just wasted time, in resuming when it was not needed. So the saved status indicator just helps save resources.
	 *
	 * @param Integer $resumption_no Check for first run
	 *
	 * @return Array
	 */
	public function resumable_backup_of_files($resumption_no) {
		global $updraftplus;
		// Backup directories and return a numerically indexed array of file paths to the backup files
		$bfiles_status = $updraftplus-&gt;jobdata_get(&#039;backup_files&#039;);
		$this-&gt;backup_files_array = $updraftplus-&gt;jobdata_get(&#039;backup_files_array&#039;);

		if (!is_array($this-&gt;backup_files_array)) $this-&gt;backup_files_array = array();
		if (&#039;finished&#039; == $bfiles_status) {
			$updraftplus-&gt;log(&quot;Creation of backups of directories: already finished&quot;);
			// Check for recent activity
			foreach ($this-&gt;backup_files_array as $files) {
				if (!is_array($files)) $files =array($files);
				foreach ($files as $file) $updraftplus-&gt;check_recent_modification($this-&gt;updraft_dir.&#039;/&#039;.$file);
			}
		} elseif (&#039;begun&#039; == $bfiles_status) {
			$this-&gt;first_run = apply_filters(&#039;updraftplus_filerun_firstrun&#039;, 0);
			if ($resumption_no &gt; $this-&gt;first_run) {
				$updraftplus-&gt;log(&quot;Creation of backups of directories: had begun; will resume&quot;);
			} else {
				$updraftplus-&gt;log(&quot;Creation of backups of directories: beginning&quot;);
			}
			$updraftplus-&gt;jobdata_set(&#039;jobstatus&#039;, &#039;filescreating&#039;);
			$this-&gt;backup_files_array = $this-&gt;backup_dirs($bfiles_status);
			$updraftplus-&gt;jobdata_set(&#039;backup_files_array&#039;, $this-&gt;backup_files_array);
			$updraftplus-&gt;jobdata_set(&#039;backup_files&#039;, &#039;finished&#039;);
			$updraftplus-&gt;jobdata_set(&#039;jobstatus&#039;, &#039;filescreated&#039;);
		} else {
			// This is not necessarily a backup run which is meant to contain files at all
			$updraftplus-&gt;log(&#039;This backup run is not intended for files - skipping&#039;);
			return array();
		}

		/*
		// DOES NOT WORK: there is no crash-safe way to do this here - have to be renamed at cloud-upload time instead
		$new_backup_array = array();
		foreach ($backup_array as $entity =&gt; $files) {
			if (!is_array($files)) $files=array($files);
			$outof = count($files);
			foreach ($files as $ind =&gt; $file) {
				$nval = $file;
				if (preg_match(&#039;/^(backup_[\-0-9]{15}_.*_[0-9a-f]{12}-[\-a-z]+)([0-9]+)?\.zip$/i&#039;, $file, $matches)) {
					$num = max((int)$matches[2],1);
					$new = $matches[1].$num.&#039;of&#039;.$outof.&#039;.zip&#039;;
					if (file_exists($this-&gt;updraft_dir.&#039;/&#039;.$file)) {
						if (@rename($this-&gt;updraft_dir.&#039;/&#039;.$file, $this-&gt;updraft_dir.&#039;/&#039;.$new)) {
							$updraftplus-&gt;log(sprintf(&quot;Renaming: %s to %s&quot;, $file, $new));
							$nval = $new;
						}
					} elseif (file_exists($this-&gt;updraft_dir.&#039;/&#039;.$new)) {
						$nval = $new;
					}
				}
				$new_backup_array[$entity][$ind] = $nval;
			}
		}
		*/
		return $this-&gt;backup_files_array;
	}

	/**
	 * This function is resumable, using the following method:
	 * Each table is written out to ($final_filename).table.tmp
	 * When the writing finishes, it is renamed to ($final_filename).table
	 * When all tables are finished, they are concatenated into the final file
	 *
	 * @param String $already_done Status of backup
	 * @param String $whichdb      Indicated which database is being backed up
	 * @param Array  $dbinfo       is only used when whichdb != &#039;wp&#039;; and the keys should be: user, pass, name, host, prefix
	 *
	 * @return Boolean|String - the basename of the database backup, or false for failure
	 */
	public function backup_db($already_done = &#039;begun&#039;, $whichdb = &#039;wp&#039;, $dbinfo = array()) {

		global $updraftplus, $wpdb;

		$this-&gt;whichdb = $whichdb;
		$this-&gt;whichdb_suffix = (&#039;wp&#039; == $whichdb) ? &#039;&#039; : $whichdb;

		if (!$updraftplus-&gt;backup_time) $updraftplus-&gt;backup_time_nonce();
		if (!$updraftplus-&gt;opened_log_time) $updraftplus-&gt;logfile_open($updraftplus-&gt;nonce);

		if (&#039;wp&#039; == $this-&gt;whichdb) {
			$this-&gt;wpdb_obj = $wpdb;
			// The table prefix after being filtered - i.e. what filters what we&#039;ll actually backup
			$this-&gt;table_prefix = $updraftplus-&gt;get_table_prefix(true);
			// The unfiltered table prefix - i.e. the real prefix that things are relative to
			$this-&gt;table_prefix_raw = $updraftplus-&gt;get_table_prefix(false);
			$dbinfo[&#039;host&#039;] = DB_HOST;
			$dbinfo[&#039;name&#039;] = DB_NAME;
			$dbinfo[&#039;user&#039;] = DB_USER;
			$dbinfo[&#039;pass&#039;] = DB_PASSWORD;
		} else {
			if (!is_array($dbinfo) || empty($dbinfo[&#039;host&#039;])) return false;
			// The methods that we may use: check_connection (WP&gt;=3.9), get_results, get_row, query
			$this-&gt;wpdb_obj = new UpdraftPlus_WPDB_OtherDB($dbinfo[&#039;user&#039;], $dbinfo[&#039;pass&#039;], $dbinfo[&#039;name&#039;], $dbinfo[&#039;host&#039;]);
			if (!empty($this-&gt;wpdb_obj-&gt;error)) {
				$updraftplus-&gt;log($dbinfo[&#039;user&#039;].&#039;@&#039;.$dbinfo[&#039;host&#039;].&#039;/&#039;.$dbinfo[&#039;name&#039;].&#039; : database connection attempt failed&#039;);
				$updraftplus-&gt;log($dbinfo[&#039;user&#039;].&#039;@&#039;.$dbinfo[&#039;host&#039;].&#039;/&#039;.$dbinfo[&#039;name&#039;].&#039; : &#039;.__(&#039;database connection attempt failed.&#039;, &#039;updraftplus&#039;).&#039; &#039;.__(&#039;Connection failed: check your access details, that the database server is up, and that the network connection is not firewalled.&#039;, &#039;updraftplus&#039;), &#039;error&#039;);
				return $updraftplus-&gt;log_wp_error($this-&gt;wpdb_obj-&gt;error);
			}
			$this-&gt;table_prefix = $dbinfo[&#039;prefix&#039;];
			$this-&gt;table_prefix_raw = $dbinfo[&#039;prefix&#039;];
		}

		$this-&gt;dbinfo = $dbinfo;

		do_action(&#039;updraftplus_backup_db_begin&#039;, $whichdb, $dbinfo, $already_done, $this);

		UpdraftPlus_Database_Utility::set_sql_mode(array(), array(&#039;ANSI_QUOTES&#039;), $this-&gt;wpdb_obj);

		$errors = 0;

		$use_time = apply_filters(&#039;updraftplus_base_backup_timestamp&#039;, $updraftplus-&gt;backup_time);
		$file_base = $this-&gt;get_backup_file_basename_from_time($use_time);
		$backup_file_base = $this-&gt;updraft_dir.&#039;/&#039;.$file_base;

		if (&#039;finished&#039; == $already_done) return basename($backup_file_base).&#039;-db&#039;.((&#039;wp&#039; == $whichdb) ? &#039;&#039; : $whichdb).&#039;.gz&#039;;
		if (&#039;encrypted&#039; == $already_done) return basename($backup_file_base).&#039;-db&#039;.((&#039;wp&#039; == $whichdb) ? &#039;&#039; : $whichdb).&#039;.gz.crypt&#039;;

		$updraftplus-&gt;jobdata_set(&#039;jobstatus&#039;, &#039;dbcreating&#039;.$this-&gt;whichdb_suffix);

		$binsqldump = $updraftplus-&gt;find_working_sqldump();

		$total_tables = 0;

		// WP 3.9 onwards - https://core.trac.wordpress.org/browser/trunk/src/wp-includes/wp-db.php?rev=27925 - check_connection() allows us to get the database connection back if it had dropped
		if (&#039;wp&#039; == $whichdb &amp;&amp; method_exists($this-&gt;wpdb_obj, &#039;check_connection&#039;) &amp;&amp; (!defined(&#039;UPDRAFTPLUS_SUPPRESS_CONNECTION_CHECKS&#039;) || !UPDRAFTPLUS_SUPPRESS_CONNECTION_CHECKS)) {
			if (!$this-&gt;wpdb_obj-&gt;check_connection(false)) {
				UpdraftPlus_Job_Scheduler::reschedule(60);
				$updraftplus-&gt;log(&quot;It seems the database went away; scheduling a resumption and terminating for now&quot;);
				UpdraftPlus_Job_Scheduler::record_still_alive();
				die;
			}
		}

		// SHOW FULL - so that we get to know whether it&#039;s a BASE TABLE or a VIEW
		$all_tables = $this-&gt;wpdb_obj-&gt;get_results(&quot;SHOW FULL TABLES&quot;, ARRAY_N);

		if (empty($all_tables) &amp;&amp; !empty($this-&gt;wpdb_obj-&gt;last_error)) {
			$all_tables = $this-&gt;wpdb_obj-&gt;get_results(&quot;SHOW TABLES&quot;, ARRAY_N);
			$all_tables = array_map(array($this, &#039;cb_get_name_base_type&#039;), $all_tables);
		} else {
			$all_tables = array_map(array($this, &#039;cb_get_name_type&#039;), $all_tables);
		}

		// If this is not the WP database, then we do not consider it a fatal error if there are no tables
		if (&#039;wp&#039; == $whichdb &amp;&amp; 0 == count($all_tables)) {
			$extra = ($updraftplus-&gt;newresumption_scheduled) ? &#039; - &#039;.__(&#039;please wait for the rescheduled attempt&#039;, &#039;updraftplus&#039;) : &#039;&#039;;
			$updraftplus-&gt;log(&quot;Error: No WordPress database tables found (SHOW TABLES returned nothing)&quot;.$extra);
			$updraftplus-&gt;log(__(&quot;No database tables found&quot;, &#039;updraftplus&#039;).$extra, &#039;error&#039;);
			die;
		}

		// Put the options table first
		UpdraftPlus_Database_Utility::init($this-&gt;whichdb, $this-&gt;table_prefix_raw, $this-&gt;wpdb_obj);
		usort($all_tables, array(&#039;UpdraftPlus_Database_Utility&#039;, &#039;backup_db_sorttables&#039;));

		$all_table_names = array_map(array($this, &#039;cb_get_name&#039;), $all_tables);

		if (!UpdraftPlus_Filesystem_Functions::really_is_writable($this-&gt;updraft_dir)) {
			$updraftplus-&gt;log(&quot;The backup directory (&quot;.$this-&gt;updraft_dir.&quot;) could not be written to (could be account/disk space full, or wrong permissions).&quot;);
			$updraftplus-&gt;log($this-&gt;updraft_dir.&quot;: &quot;.__(&#039;The backup directory is not writable (or disk space is full) - the database backup is expected to shortly fail.&#039;, &#039;updraftplus&#039;), &#039;warning&#039;);
			// Why not just fail now? We saw a bizarre case when the results of really_is_writable() changed during the run.
		}

		// This check doesn&#039;t strictly get all possible duplicates; it&#039;s only designed for the case that can happen when moving between deprecated Windows setups and Linux
		$this-&gt;duplicate_tables_exist = false;
		foreach ($all_table_names as $table) {
			if (strtolower($table) != $table &amp;&amp; in_array(strtolower($table), $all_table_names)) {
				$this-&gt;duplicate_tables_exist = true;
				$updraftplus-&gt;log(&quot;Tables with names differing only based on case-sensitivity exist in the MySQL database: $table / &quot;.strtolower($table));
			}
		}
		$how_many_tables = count($all_tables);

		$stitch_files = array();
		$found_options_table = false;
		$is_multisite = is_multisite();

		$anonymisation_options = $updraftplus-&gt;jobdata_get(&#039;anonymisation_options&#039;, array());

		if (!empty($anonymisation_options)) {
			$updraftplus-&gt;log(&quot;Anonymisation options have been set, so mysqldump (which does not support them) will be disabled.&quot;);
		}

		// Gather the list of files that look like partial table files once only
		$potential_stitch_files = array();
		$table_file_prefix_base= $file_base.&#039;-db&#039;.$this-&gt;whichdb_suffix.&#039;-table-&#039;;
		if (false !== ($dir_handle = opendir($this-&gt;updraft_dir))) {
			while (false !== ($e = readdir($dir_handle))) {
				// The &#039;r&#039; in &#039;tmpr&#039; indicates that the new scheme is being used. N.B. That does *not* imply that the table has a usable primary key.
				if (!is_file($this-&gt;updraft_dir.&#039;/&#039;.$e)) continue;
				if (preg_match(&#039;#&#039;.$table_file_prefix_base.&#039;.*\.table\.tmpr?(\d+)\.gz$#&#039;, $e, $matches)) {
					// We need to stich them in order
					$potential_stitch_files[] = $e;
				}
			}
		} else {
			$updraftplus-&gt;log(&quot;Error: Failed to open directory for reading&quot;);
			$updraftplus-&gt;log(__(&quot;Failed to open directory for reading:&quot;, &#039;updraftplus&#039;).&#039; &#039;.$this-&gt;updraft_dir, &#039;error&#039;);
		}

		$errors_at_all_tables_start = $updraftplus-&gt;error_count();

		foreach ($all_tables as $ti) {

			$table = $ti[&#039;name&#039;];
			$stitch_files[$table] = array();
			$table_type = $ti[&#039;type&#039;];
			$errors_at_table_start = $updraftplus-&gt;error_count();

			$this-&gt;many_rows_warning = false;
			$total_tables++;

			// Increase script execution time-limit to 15 min for every table.
			if (function_exists(&#039;set_time_limit&#039;)) @set_time_limit(UPDRAFTPLUS_SET_TIME_LIMIT);// phpcs:ignore Generic.PHP.NoSilencedErrors.Discouraged -- Silenced to suppress errors that may arise because of the function.
			// The table file may already exist if we have produced it on a previous run
			$table_file_prefix = $file_base.&#039;-db&#039;.$this-&gt;whichdb_suffix.&#039;-table-&#039;.$table.&#039;.table&#039;;

			if (&#039;wp&#039; == $whichdb &amp;&amp; (strtolower($this-&gt;table_prefix_raw.&#039;options&#039;) == strtolower($table) || ($is_multisite &amp;&amp; (strtolower($this-&gt;table_prefix_raw.&#039;sitemeta&#039;) == strtolower($table) || strtolower($this-&gt;table_prefix_raw.&#039;1_options&#039;) == strtolower($table))))) $found_options_table = true;

			// Already finished?
			if (file_exists($this-&gt;updraft_dir.&#039;/&#039;.$table_file_prefix.&#039;.gz&#039;)) {
				$stitched = count($stitch_files, COUNT_RECURSIVE);
				$skip_dblog = (($stitched &gt; 10 &amp;&amp; 0 != $stitched % 20) || ($stitched &gt; 100 &amp;&amp; 0 != $stitched % 100));
				$updraftplus-&gt;log(&quot;Table $table: corresponding file already exists; moving on&quot;, &#039;notice&#039;, false, $skip_dblog);

				$max_record = false;
				foreach ($potential_stitch_files as $e) {
					// The &#039;r&#039; in &#039;tmpr&#039; indicates that the new scheme is being used. N.B. That does *not* imply that the table has a usable primary key.
					if (preg_match(&#039;#&#039;.$table_file_prefix.&#039;\.tmpr?(\d+)\.gz$#&#039;, $e, $matches)) {
						// We need to stich them in order
						$stitch_files[$table][$matches[1]] = $e;
						if (false === $max_record || $matches[1] &gt; $max_record) $max_record = $matches[1];
					}
				}
				$stitch_files[$table][$max_record+1] = $table_file_prefix.&#039;.gz&#039;;

				// Move on to the next table
				continue;
			}

			// === is needed with strpos/stripos, otherwise &#039;false&#039; matches (i.e. prefix does not match)
			if (empty($this-&gt;table_prefix) || (!$this-&gt;duplicate_tables_exist &amp;&amp; 0 === stripos($table, $this-&gt;table_prefix)) || ($this-&gt;duplicate_tables_exist &amp;&amp; 0 === strpos($table, $this-&gt;table_prefix))) {

				// Skip table due to filter?
				if (!apply_filters(&#039;updraftplus_backup_table&#039;, true, $table, $this-&gt;table_prefix, $whichdb, $dbinfo)) {
					$updraftplus-&gt;log(&quot;Skipping table (filtered): $table&quot;);
					if (empty($this-&gt;skipped_tables)) $this-&gt;skipped_tables = array();

					// whichdb could be an int in which case to get the name of the database and the array key use the name from dbinfo
					$key = (&#039;wp&#039; === $whichdb) ? &#039;wp&#039; : $dbinfo[&#039;name&#039;];

					if (empty($this-&gt;skipped_tables[$key])) $this-&gt;skipped_tables[$key] = array();
					$this-&gt;skipped_tables[$key][] = $table;

					$total_tables--;
					continue;
				}

				add_filter(&#039;updraftplus_backup_table_sql_where&#039;, array($this, &#039;backup_exclude_jobdata&#039;), 10, 3);

				$updraftplus-&gt;jobdata_set(&#039;dbcreating_substatus&#039;, array(&#039;t&#039; =&gt; $table, &#039;i&#039; =&gt; $total_tables, &#039;a&#039; =&gt; $how_many_tables));

				// .tmp.gz is the current temporary file. When the row limit has been reached, it is moved to .tmp1.gz, .tmp2.gz, etc. (depending on which already exist). When we&#039;re all done, then they all get stitched in.

				$db_temp_file = $this-&gt;updraft_dir.&#039;/&#039;.$table_file_prefix.&#039;.tmp.gz&#039;;
				$updraftplus-&gt;check_recent_modification($db_temp_file);

				// Open file, store the handle
				if (false === $this-&gt;backup_db_open($db_temp_file, true)) return false;

				$table_status = $this-&gt;wpdb_obj-&gt;get_row(&quot;SHOW TABLE STATUS WHERE Name=&#039;$table&#039;&quot;);

				// Create the preceding SQL statements for the table
				$this-&gt;stow(&quot;# &quot; . sprintf(&#039;Table: %s&#039;, UpdraftPlus_Manipulation_Functions::backquote($table)) . &quot;\n&quot;);

				// Meaning: false = don&#039;t yet know; true = know and have logged it; integer = the expected number
				$this-&gt;expected_rows = false;

				if (isset($table_status-&gt;Rows)) {
					$this-&gt;expected_rows = $table_status-&gt;Rows;
				}

				// If no check-in last time, then we could in future try the other method (but - any point in retrying slow method on large tables??)

				// New Jul 2014: This attempt to use bindump instead at a lower threshold is quite conservative - only if the last successful run was exactly two resumptions ago - may be useful to expand
				$bindump_threshold = (!$updraftplus-&gt;something_useful_happened &amp;&amp; !empty($updraftplus-&gt;current_resumption) &amp;&amp; (2 == $updraftplus-&gt;current_resumption - $updraftplus-&gt;last_successful_resumption)) ? 1000 : 8000;

				if (isset($table_status-&gt;Rows) &amp;&amp; ($table_status-&gt;Rows &gt; $bindump_threshold || (defined(&#039;UPDRAFTPLUS_ALWAYS_TRY_MYSQLDUMP&#039;) &amp;&amp; UPDRAFTPLUS_ALWAYS_TRY_MYSQLDUMP)) &amp;&amp; is_string($binsqldump) &amp;&amp; empty($anonymisation_options)) {
					if (!is_bool($this-&gt;expected_rows)) {
						$this-&gt;log_expected_rows($table, $this-&gt;expected_rows);
						$this-&gt;expected_rows = true;
					}
					$bindump = $this-&gt;backup_table_bindump($binsqldump, $table);
				} else {
					$bindump = false;
				}

				// Means &quot;start of table&quot;. N.B. The meaning of an integer depends upon whether the table has a usable primary key or not.
				$start_record = true;
				$can_use_primary_key = apply_filters(&#039;updraftplus_can_use_primary_key_default&#039;, true, $table);
				foreach ($potential_stitch_files as $e) {
					// The &#039;r&#039; in &#039;tmpr&#039; indicates that the new scheme is being used. N.B. That does *not* imply that the table has a usable primary key.
					if (preg_match(&#039;#&#039;.$table_file_prefix.&#039;\.tmp(r)?(\d+)\.gz$#&#039;, $e, $matches)) {
						$stitch_files[$table][$matches[2]] = $e;
						if (true === $start_record || $matches[2] &gt; $start_record) $start_record = $matches[2];
						// Legacy scheme. The purpose of this is to prevent backups failing if one is in progress during an upgrade to a new version that implements the new scheme
						if (&#039;r&#039; !== $matches[1]) $can_use_primary_key = false;
					}
				}

				// Legacy file-naming scheme in use
				if (false === $can_use_primary_key &amp;&amp; true !== $start_record) {
					$start_record = ($start_record + 100) * 1000;
				}

				if (true !== $bindump) {

					while (!is_array($start_record) &amp;&amp; !is_wp_error($start_record)) {
						$start_record = $this-&gt;backup_table($table, $table_type, $start_record, $can_use_primary_key);
						if (is_integer($start_record) || is_array($start_record)) {

							$this-&gt;backup_db_close();

							// Add one here in case no records were returned - don&#039;t want to over-write the previous file
							$use_record = is_array($start_record) ? (isset($start_record[&#039;next_record&#039;]) ? $start_record[&#039;next_record&#039;]+1 : false) : $start_record;
							if (!$can_use_primary_key) $use_record = (ceil($use_record/100000)-1) * 100;

							if (false !== $use_record) {
								// N.B. Renaming using the *next* record is intentional - it allows UD to know where to resume from.
								$rename_base = $table_file_prefix.&#039;.tmp&#039;.($can_use_primary_key ? &#039;r&#039; : &#039;&#039;).$use_record.&#039;.gz&#039;;

								rename($db_temp_file, $this-&gt;updraft_dir.&#039;/&#039;.$rename_base);
								$stitch_files[$table][$use_record] = $rename_base;
							} elseif (is_array($start_record) &amp;&amp; &#039;view&#039; == strtolower($table_type)) {
								$rename_base = $table_file_prefix.&#039;-view.tmp.gz&#039;;
								rename($db_temp_file, $this-&gt;updraft_dir.&#039;/&#039;.$rename_base);
								$stitch_files[$table][] = $rename_base;
							}

							UpdraftPlus_Job_Scheduler::something_useful_happened();

							if (false === $this-&gt;backup_db_open($db_temp_file, true)) return false;

						} elseif (is_wp_error($start_record)) {
							$message = &quot;Error (table=$table, type=$table_type) (&quot;.$start_record-&gt;get_error_code().&quot;): &quot;.$start_record-&gt;get_error_message();
							$updraftplus-&gt;log($message);
							// If it&#039;s a view, then the problem isn&#039;t recoverable; but views don&#039;t contain actual data except in the definition, which is likely in code, so we should not consider this a fatal error
							$level = &#039;error&#039;;
							if (&#039;view&#039; == strtolower($table_type) &amp;&amp; &#039;table_details_error&#039; == $start_record-&gt;get_error_code()) {
								$level = &#039;warning&#039;;
								$this-&gt;stow(&quot;# $message\n&quot;);
							}
							$updraftplus-&gt;log(__(&quot;Failed to backup database table:&quot;, &#039;updraftplus&#039;).&#039; &#039;.$start_record-&gt;get_error_message().&#039; (&#039;.$start_record-&gt;get_error_code().&#039;)&#039;, $level);
						}

					}
				}

				// If we got this far, then there were enough resources; the warning can be removed
				if (!empty($this-&gt;many_rows_warning)) $updraftplus-&gt;log_remove_warning(&#039;manyrows_&#039;.$this-&gt;whichdb_suffix.$table);

				$this-&gt;backup_db_close();

				if ($updraftplus-&gt;error_count() &gt; $errors_at_table_start) {

					$updraftplus-&gt;log(&#039;Errors occurred during backing up the table; therefore the open file will be removed&#039;);
					@unlink($db_temp_file); // phpcs:ignore Generic.PHP.NoSilencedErrors.Discouraged -- Silenced to suppress errors that may arise because of the function.
					
				} else {

					// Renaming the file indicates that writing to it finished
					rename($db_temp_file, $this-&gt;updraft_dir.&#039;/&#039;.$table_file_prefix.&#039;.gz&#039;);
					UpdraftPlus_Job_Scheduler::something_useful_happened();

					$final_stitch_value = empty($stitch_files[$table]) ? 1 : max(array_keys($stitch_files[$table])) + 1;

					$stitch_files[$table][$final_stitch_value] = $table_file_prefix.&#039;.gz&#039;;

					$total_db_size = 0;
					// This is more verbose than it would be if we weren&#039;t supporting PHP 5.2
					foreach ($stitch_files[$table] as $basename) {
						$total_db_size += filesize($this-&gt;updraft_dir.&#039;/&#039;.$basename);
					}

					$updraftplus-&gt;log(&quot;Table $table: finishing file(s) (&quot;.count($stitch_files[$table]).&#039;, &#039;.round($total_db_size/1024, 1).&#039; KB)&#039;, &#039;notice&#039;, false, false);
				}

			} else {
				$total_tables--;
				$updraftplus-&gt;log(&quot;Skipping table (lacks our prefix (&quot;.$this-&gt;table_prefix.&quot;)): $table&quot;);
				if (empty($this-&gt;skipped_tables)) $this-&gt;skipped_tables = array();
				// whichdb could be an int in which case to get the name of the database and the array key use the name from dbinfo
				$key = (&#039;wp&#039; === $whichdb) ? &#039;wp&#039; : $dbinfo[&#039;name&#039;];
				if (empty($this-&gt;skipped_tables[$key])) $this-&gt;skipped_tables[$key] = array();
				$this-&gt;skipped_tables[$key][] = $table;
			}
		}

		if (&#039;wp&#039; == $whichdb) {
			if (!$found_options_table) {
				if ($is_multisite) {
					$updraftplus-&gt;log(__(&#039;The database backup has failed&#039;, &#039;updraftplus&#039;).&#039; - &#039;.__(&#039;no options or sitemeta table was found&#039;, &#039;updraftplus&#039;), &#039;warning&#039;, &#039;optstablenotfound&#039;);
				} else {
					$updraftplus-&gt;log(__(&#039;The database backup has failed&#039;, &#039;updraftplus&#039;).&#039; - &#039;.__(&#039;the options table was not found&#039;, &#039;updraftplus&#039;), &#039;warning&#039;, &#039;optstablenotfound&#039;);
				}
				$time_this_run = time()-$updraftplus-&gt;opened_log_time;
				if ($time_this_run &gt; 2000) {
					// Have seen this happen; not sure how, but it was apparently deterministic; if the current process had been running for a long time, then apparently all database commands silently failed.
					// If we have been running that long, then the resumption may be far off; bring it closer
					UpdraftPlus_Job_Scheduler::reschedule(60);
					$updraftplus-&gt;log(&quot;Have been running very long, and it seems the database went away; scheduling a resumption and terminating for now&quot;);
					UpdraftPlus_Job_Scheduler::record_still_alive();
					die;
				}
			} else {
				$updraftplus-&gt;log_remove_warning(&#039;optstablenotfound&#039;);
			}
		}

		if ($updraftplus-&gt;error_count() &gt; $errors_at_all_tables_start) {
			$updraftplus-&gt;log(&#039;Errors occurred whilst backing up the tables; will cease and wait for resumption&#039;);
			die;
		}

		// Race detection - with zip files now being resumable, these can more easily occur, with two running side-by-side
		$backup_final_file_name = $backup_file_base.&#039;-db&#039;.$this-&gt;whichdb_suffix.&#039;.gz&#039;;
		$time_now = time();
		$time_mod = (int) @filemtime($backup_final_file_name);// phpcs:ignore Generic.PHP.NoSilencedErrors.Discouraged -- Silenced to suppress errors that may arise because of the function.
		if (file_exists($backup_final_file_name) &amp;&amp; $time_mod&gt;100 &amp;&amp; ($time_now-$time_mod)&lt;30) {
			UpdraftPlus_Job_Scheduler::terminate_due_to_activity($backup_final_file_name, $time_now, $time_mod);
		}

		if (file_exists($backup_final_file_name)) {
			$updraftplus-&gt;log(&quot;The final database file ($backup_final_file_name) exists, but was not modified within the last 30 seconds (time_mod=$time_mod, time_now=$time_now, diff=&quot;.($time_now-$time_mod).&quot;). Thus we assume that another UpdraftPlus terminated; thus we will continue.&quot;);
		}

		// Finally, stitch the files together
		if (!function_exists(&#039;gzopen&#039;)) {
			$updraftplus-&gt;log(&quot;PHP function is disabled; abort expected: gzopen()&quot;);
		}

		$decompress_mode = (defined(&#039;UPDRAFTPLUS_DB_STICH_DECOMPRESS&#039;) &amp;&amp; UPDRAFTPLUS_DB_STICH_DECOMPRESS);

		if (false === $this-&gt;backup_db_open($backup_final_file_name, true)) return false;

		$this-&gt;backup_db_header();

		// Re-open in plain binary append mode
		if (!$decompress_mode) {
			$this-&gt;backup_db_close();
			if (false === $this-&gt;backup_db_open($backup_final_file_name, false, true)) return false;
		}

		// We delay the unlinking because if two runs go concurrently and fail to detect each other (should not happen, but there&#039;s no harm in assuming the detection failed) then that would lead to files missing from the db dump
		$unlink_files = array();

		$sind = 1;

		// Happily they have the same syntax (as far as we need it)
		// Concatenating gz files produces a valid gz file. So, decompressing is not necessary. We retain the possibility for debugging and the possibility of broken implementations.
		$open_function = $decompress_mode ? &#039;gzopen&#039; : &#039;fopen&#039;;
		$fgets_function = $decompress_mode ? &#039;gzgets&#039; : &#039;fgets&#039;;
		$close_function = $decompress_mode ? &#039;gzclose&#039; : &#039;fclose&#039;;

		foreach ($stitch_files as $table =&gt; $table_stitch_files) {
			ksort($table_stitch_files);
			foreach ($table_stitch_files as $table_file) {
				$updraftplus-&gt;log(&quot;{$table_file} ($sind/$how_many_tables/$open_function): adding to final database dump&quot;);

				if (filesize($this-&gt;updraft_dir.&#039;/&#039;.$table_file) &lt; 27 &amp;&amp; &#039;.gz&#039; == substr($table_file, -3, 3)) {
					// It&#039;s a null gzip file. Don&#039;t waste time on gzopen/gzgets/gzclose. This micro-optimisation was added after seeing a site with &gt;3000 files that was running out of time (it could apparently process 30 files/second)
					$unlink_files[] = $this-&gt;updraft_dir.&#039;/&#039;.$table_file;
				} elseif (!$handle = call_user_func($open_function, $this-&gt;updraft_dir.&#039;/&#039;.$table_file, &#039;r&#039;)) {
					$updraftplus-&gt;log(&quot;Error: Failed to open database file for reading: {$table_file}&quot;);
					$updraftplus-&gt;log(__(&quot;Failed to open database file for reading:&quot;, &#039;updraftplus&#039;).&#039; &#039;.$table_file, &#039;error&#039;);
					$errors++;
				} else {
					while ($line = call_user_func($fgets_function, $handle, 65536)) {
						$this-&gt;stow($line);
					}
					call_user_func($close_function, $handle);
					$unlink_files[] = $this-&gt;updraft_dir.&#039;/&#039;.$table_file;
				}
				$sind++;
				// Came across a database with 7600 tables... adding them all took over 500 seconds; and so when the resumption started up, no activity was detected
				if (0 == $sind % 100) UpdraftPlus_Job_Scheduler::something_useful_happened();
			}
		}

		// Re-open in gz append mode
		if (!$decompress_mode) {
			$this-&gt;backup_db_close();
			if (false === $this-&gt;backup_db_open($backup_final_file_name, true, true)) return false;
		}

		// DB triggers
		if ($this-&gt;wpdb_obj-&gt;get_results(&quot;SHOW TRIGGERS&quot;)) {
			// N.B. DELIMITER is not a valid SQL command; you cannot pass it to the server. It has to be interpreted by the interpreter - e.g. /usr/bin/mysql, or UpdraftPlus, and used to interpret what follows. The effect of this is that using it means that some SQL clients will stumble; but, on the other hand, failure to use it means that others that don&#039;t have special support for CREATE TRIGGER may stumble, because they may feed incomplete statements to the SQL server. Since /usr/bin/mysql uses it, we choose to support it too (both reading and writing).
			// Whatever the delimiter is set to needs to be used in the DROP TRIGGER and CREATE TRIGGER commands in this section further down.
			$this-&gt;stow(&quot;DELIMITER ;;\n\n&quot;);
			foreach ($all_tables as $ti) {
				$table = $ti[&#039;name&#039;];
				if (!empty($this-&gt;skipped_tables)) {
					if (&#039;wp&#039; == $this-&gt;whichdb) {
						if (in_array($table, $this-&gt;skipped_tables[&#039;wp&#039;])) continue;
					} elseif (isset($this-&gt;skipped_tables[$this-&gt;dbinfo[&#039;name&#039;]])) {
						if (in_array($table, $this-&gt;skipped_tables[$this-&gt;dbinfo[&#039;name&#039;]])) continue;
					}
				}
				$table_triggers = $this-&gt;wpdb_obj-&gt;get_results($wpdb-&gt;prepare(&quot;SHOW TRIGGERS LIKE %s&quot;, $table), ARRAY_A);
				if ($table_triggers) {
					$this-&gt;stow(&quot;\n\n# Triggers of  &quot;.UpdraftPlus_Manipulation_Functions::backquote($table).&quot;\n\n&quot;);
					foreach ($table_triggers as $trigger) {
						$trigger_name = $trigger[&#039;Trigger&#039;];
						$trigger_time = $trigger[&#039;Timing&#039;];
						$trigger_event = $trigger[&#039;Event&#039;];
						$trigger_statement = $trigger[&#039;Statement&#039;];
						// Since trigger name can include backquotes and trigger name is typically enclosed with backquotes as well, the backquote escaping for the trigger name can be done by adding a leading backquote
						$quoted_escaped_trigger_name = UpdraftPlus_Manipulation_Functions::backquote(str_replace(&#039;`&#039;, &#039;``&#039;, $trigger_name));
						$this-&gt;stow(&quot;DROP TRIGGER IF EXISTS $quoted_escaped_trigger_name;;\n&quot;);
						$trigger_query = &quot;CREATE TRIGGER $quoted_escaped_trigger_name $trigger_time $trigger_event ON &quot;.UpdraftPlus_Manipulation_Functions::backquote($table).&quot; FOR EACH ROW $trigger_statement;;&quot;;
						$this-&gt;stow(&quot;$trigger_query\n\n&quot;);
					}
				}
			}
			$this-&gt;stow(&quot;DELIMITER ;\n\n&quot;);
		}

		// DB Stored Routines
		$stored_routines = UpdraftPlus_Database_Utility::get_stored_routines();
		if (is_array($stored_routines) &amp;&amp; !empty($stored_routines)) {
			$stored_routines_log = $inaccessible_routines = &#039;&#039;;
			$stored_routines_delimiter_printed = false;
			$updraftplus-&gt;log(&quot;Dumping routines for database {$this-&gt;dbinfo[&#039;name&#039;]}&quot;);
			foreach ($stored_routines as $routine) {
				if (empty($routine[&#039;Create &#039;.ucfirst(strtolower($routine[&#039;Type&#039;]))])) { // The value displayed for the Create Procedure or Create Function field is NULL if the WP database user has only CREATE ROUTINE, ALTER ROUTINE, and/or EXECUTE privileges. @see https://dev.mysql.com/doc/refman/8.0/en/show-create-procedure.html
					$inaccessible_routines = $inaccessible_routines ? $inaccessible_routines.&#039;, &#039;.$routine[&#039;Name&#039;] : $routine[&#039;Name&#039;];
					continue;
				}
				$stored_routines_log = &quot;Dumping routine: {$routine[&#039;Name&#039;]}&quot;;
				if (!$stored_routines_delimiter_printed) {
					$this-&gt;stow(&quot;\n\n# Dumping routines for database &quot;.UpdraftPlus_Manipulation_Functions::backquote($this-&gt;dbinfo[&#039;name&#039;]).&quot;\n\n&quot;);
					$this-&gt;stow(&quot;DELIMITER ;;\n\n&quot;);
					$stored_routines_delimiter_printed = true;
				}
				$routine_name = $routine[&#039;Name&#039;];
				// Since routine name can include backquotes and routine name is typically enclosed with backquotes as well, the backquote escaping for the routine name can be done by adding a leading backquote
				$quoted_escaped_routine_name = UpdraftPlus_Manipulation_Functions::backquote(str_replace(&#039;`&#039;, &#039;``&#039;, $routine_name));
				$this-&gt;stow(&quot;DROP {$routine[&#039;Type&#039;]} IF EXISTS $quoted_escaped_routine_name;;\n\n&quot;);
				$this-&gt;stow($routine[&#039;Create &#039;.ucfirst(strtolower($routine[&#039;Type&#039;]))].&quot;\n\n;;\n\n&quot;);
				$updraftplus-&gt;log($stored_routines_log.&quot; - (Successful)&quot;);
			}
			if ($inaccessible_routines) {
				$updraftplus-&gt;log(__(&#039;Dumping routines: &#039;, &#039;updraftplus&#039;) . &quot;({$inaccessible_routines})&quot; . &quot; - (&quot;. __(&#039;Failed&#039;, &#039;updraftplus&#039;) . &quot; - &quot; . __(&quot;Your WordPress database user doesn&#039;t have sufficient privileges to read these stored routines.&quot;, &#039;updraftplus&#039;) . &quot; &quot; .__(&#039;To be able to backup the routines, you must be the user named as the routine DEFINER(s), have the SHOW_ROUTINE privilege (for MySQL 8.0.20+ users), have the SELECT privilege at the global level, or have the CREATE ROUTINE, ALTER ROUTINE, or EXECUTE privilege granted at a scope that includes the routines.&#039;, &#039;updraftplus&#039;). &quot;)&quot;, &#039;warning&#039;);
			}
			if ($stored_routines_delimiter_printed) $this-&gt;stow(&quot;DELIMITER ;\n\n&quot;);
		} elseif (is_wp_error($stored_routines)) {
			$updraftplus-&gt;log($stored_routines-&gt;get_error_message());
		}

		$this-&gt;stow(&quot;/*!40101 SET CHARACTER_SET_CLIENT=@OLD_CHARACTER_SET_CLIENT */;\n&quot;);
		$this-&gt;stow(&quot;/*!40101 SET CHARACTER_SET_RESULTS=@OLD_CHARACTER_SET_RESULTS */;\n&quot;);
		$this-&gt;stow(&quot;/*!40101 SET COLLATION_CONNECTION=@OLD_COLLATION_CONNECTION */;\n&quot;);
		$this-&gt;stow(&quot;/*!40101 SET SQL_MODE=@OLD_SQL_MODE */;\n&quot;);

		$updraftplus-&gt;log($file_base.&#039;-db&#039;.$this-&gt;whichdb_suffix.&#039;.gz: finished writing out complete database file (&#039;.round(filesize($backup_final_file_name)/1024, 1).&#039; KB)&#039;);
		if (!$this-&gt;backup_db_close()) {
			$updraftplus-&gt;log(&#039;An error occurred whilst closing the final database file&#039;);
			$updraftplus-&gt;log(__(&#039;An error occurred whilst closing the final database file&#039;, &#039;updraftplus&#039;), &#039;error&#039;);
			$errors++;
		}

		foreach ($unlink_files as $unlink_file) {
			@unlink($unlink_file);// phpcs:ignore Generic.PHP.NoSilencedErrors.Discouraged -- Silenced to suppress errors that may arise if the file doesn&#039;t exist.
		}

		if ($errors &gt; 0) return false;

		// We no longer encrypt here - because the operation can take long, we made it resumable and moved it to the upload loop
		$updraftplus-&gt;jobdata_set(&#039;jobstatus&#039;, &#039;dbcreated&#039;.$this-&gt;whichdb_suffix);

		$checksums = $updraftplus-&gt;which_checksums();

		$checksum_description = &#039;&#039;;

		foreach ($checksums as $checksum) {

			$cksum = hash_file($checksum, $backup_final_file_name);
			$updraftplus-&gt;jobdata_set($checksum.&#039;-db&#039;.((&#039;wp&#039; == $whichdb) ? &#039;0&#039; : $whichdb.&#039;0&#039;), $cksum);
			if ($checksum_description) $checksum_description .= &#039;, &#039;;
			$checksum_description .= &quot;$checksum: $cksum&quot;;

		}

		$updraftplus-&gt;log(&quot;Total database tables backed up: $total_tables (&quot;.basename($backup_final_file_name).&quot;, size: &quot;.filesize($backup_final_file_name).&quot;, $checksum_description)&quot;);

		return basename($backup_final_file_name);

	}

	/**
	 * Log the number of expected rows (both to the backup log, and database backup file)
	 *
	 * @param String  $table		 - table name
	 * @param Integer $expected_rows - number of rows
	 * @param Boolean $via_count	 - if the expected number comes via a SELECT COUNT() call
	 * @param Boolean $log_in_backup - whether to log in the backup file (not just the backup log file)
	 */
	private function log_expected_rows($table, $expected_rows, $via_count = false, $log_in_backup = true) {
		global $updraftplus;
		$description = $via_count ? &#039;via COUNT&#039; : &#039;approximate&#039;;
		$updraftplus-&gt;log(&quot;Table $table: Total expected rows ($description): &quot;.$expected_rows);
		if ($log_in_backup) $this-&gt;stow(&quot;# Approximate rows expected in table: $expected_rows\n&quot;);
		if ($expected_rows &gt; UPDRAFTPLUS_WARN_DB_ROWS) {
			$this-&gt;many_rows_warning = true;
			$updraftplus-&gt;log(
				sprintf(
					/* translators: 1: Table name, 2: Row count */
					__(&#039;Table %1$s has very many rows (%2$s) - we hope your web hosting company gives you enough resources to dump out that table in the backup.&#039;, &#039;updraftplus&#039;),
					$table,
				$expected_rows).&#039; &#039;.
				__(&#039;If not, you will need to either remove data from this table, or contact your hosting company to request more resources.&#039;, &#039;updraftplus&#039;),
				&#039;warning&#039;,
			&#039;manyrows_&#039;.$this-&gt;whichdb_suffix.$table);
		}
	}

	/**
	 * This function will return a SQL WHERE clause to exclude updraft jobdata
	 *
	 * @param array  $where - an array of where clauses to add to
	 * @param string $table - the table we want to add a where clause for
	 *
	 * @return array - returns an array of where clauses for the table
	 */
	public function backup_exclude_jobdata($where, $table) {
		// Don&#039;t include the job data for any backups - so that when the database is restored, it doesn&#039;t continue an apparently incomplete backup
		global $updraftplus;
		$table_prefix = $updraftplus-&gt;get_table_prefix(false); // or we can just use $this-&gt;table_prefix_raw ??
		if (&#039;wp&#039; == $this-&gt;whichdb &amp;&amp; (!empty($table_prefix) &amp;&amp; strtolower($table_prefix.&#039;sitemeta&#039;) == strtolower($table))) {
			$where[] = &#039;meta_key NOT LIKE &quot;updraft_jobdata_%&quot;&#039;;
		} elseif (&#039;wp&#039; == $this-&gt;whichdb &amp;&amp; (!empty($table_prefix) &amp;&amp; strtolower($table_prefix.&#039;options&#039;) == strtolower($table))) {
			// These might look similar, but the quotes are different
			if (&#039;win&#039; == strtolower(substr(PHP_OS, 0, 3))) {
				$updraft_jobdata = &quot;&#039;updraft_jobdata_%&#039;&quot;;
				$site_transient_update = &quot;&#039;_site_transient_update_%&#039;&quot;;
			} else {
				$updraft_jobdata = &#039;&quot;updraft_jobdata_%&quot;&#039;;
				$site_transient_update = &#039;&quot;_site_transient_update_%&quot;&#039;;
			}

			$where[] = &#039;option_name NOT LIKE &#039;.$updraft_jobdata.&#039; AND option_name NOT LIKE &#039;.$site_transient_update.&#039;&#039;;
		}

		return $where;
	}

	/**
	 * Produce a dump of the table using a mysqldump binary
	 *
	 * @param String $potsql	 - the path to the mysqldump binary
	 * @param String $table_name - the name of the table being dumped
	 *
	 * @return Boolean - success status
	 */
	private function backup_table_bindump($potsql, $table_name) {

		$microtime = microtime(true);

		global $updraftplus, $wpdb;

		// Deal with Windows/old MySQL setups with erroneous table prefixes differing in case
		// Can&#039;t get binary mysqldump to make this transformation
		// $dump_as_table = ($this-&gt;duplicate_tables_exist == false &amp;&amp; stripos($table, $this-&gt;table_prefix) === 0 &amp;&amp; strpos($table, $this-&gt;table_prefix) !== 0) ? $this-&gt;table_prefix.substr($table, strlen($this-&gt;table_prefix)) : $table;

		$pfile = md5(time().wp_rand()).&#039;.tmp&#039;;
		file_put_contents($this-&gt;updraft_dir.&#039;/&#039;.$pfile, &quot;[mysqldump]\npassword=\&quot;&quot;.addslashes($this-&gt;dbinfo[&#039;pass&#039;]).&quot;\&quot;\n&quot;);

		$where_array = apply_filters(&#039;updraftplus_backup_table_sql_where&#039;, array(), $table_name, $this);
		if (&#039;win&#039; === strtolower(substr(PHP_OS, 0, 3))) {
			// On Windows, the PHP escapeshellarg() replaces % char with white space, so we change the % char to [percent_sign] but change it back later after escapeshellarg finish processing it
			$where_array = str_replace(&#039;%&#039;, &#039;[percent_sign]&#039;, $where_array);
		}
		$where = &#039;&#039;;

		if (!empty($where_array) &amp;&amp; is_array($where_array)) {
			// N.B. Don&#039;t add a WHERE prefix here; most versions of mysqldump silently strip it out, but one was encountered that didn&#039;t.
			$first_loop = true;
			foreach ($where_array as $condition) {
				if (!$first_loop) $where .= &quot; AND &quot;;
				$where .= $condition;
				$first_loop = false;
			}
		}

		// Note: escapeshellarg() adds quotes around the string
		if ($where) $where = &quot;--where=&quot;.escapeshellarg($where);
		if (&#039;&#039; !== $where &amp;&amp; &#039;win&#039; === strtolower(substr(PHP_OS, 0, 3))) {
			// change the [percent_sign] back to % char
			$where = str_replace(&#039;[percent_sign]&#039;, &#039;%&#039;, $where);
		}

		if (strtolower(substr(PHP_OS, 0, 3)) == &#039;win&#039;) {
			$exec = &quot;cd &quot;.escapeshellarg(str_replace(&#039;/&#039;, &#039;\\&#039;, $this-&gt;updraft_dir)).&quot; &amp; &quot;;
		} else {
			$exec = &quot;cd &quot;.escapeshellarg($this-&gt;updraft_dir).&quot;; &quot;;
		}

		// Allow --max_allowed_packet to be configured via constant. Experience has shown some customers with complex CMS or pagebuilder setups can have very large postmeta entries.
		$msqld_max_allowed_packet = (defined(&#039;UPDRAFTPLUS_MYSQLDUMP_MAX_ALLOWED_PACKET&#039;) &amp;&amp; (is_int(UPDRAFTPLUS_MYSQLDUMP_MAX_ALLOWED_PACKET) || is_string(UPDRAFTPLUS_MYSQLDUMP_MAX_ALLOWED_PACKET))) ? UPDRAFTPLUS_MYSQLDUMP_MAX_ALLOWED_PACKET : &#039;12M&#039;;

		$exec .= &quot;$potsql --defaults-file=$pfile $where --max-allowed-packet=$msqld_max_allowed_packet --quote-names --add-drop-table&quot;;

		static $mysql_version = null;
		if (null === $mysql_version) {
			$mysql_version = $wpdb-&gt;get_var(&#039;SELECT VERSION()&#039;);
			if (&#039;&#039; == $mysql_version) $mysql_version = $wpdb-&gt;db_version();
		}
		if ($mysql_version &amp;&amp; version_compare($mysql_version, &#039;5.1&#039;, &#039;&gt;=&#039;)) {
			$exec .= &quot; --no-tablespaces&quot;;
		}

		$exec .= &quot; --skip-comments --skip-set-charset --allow-keywords --dump-date --extended-insert --user=&quot;.escapeshellarg($this-&gt;dbinfo[&#039;user&#039;]).&quot; &quot;;

		$host = $this-&gt;dbinfo[&#039;host&#039;];

		if (preg_match(&#039;#^(.*):(\d+)$#&#039;, $host, $matches)) {
			// The escapeshellarg() on $matches[2] is only to avoid tripping static analysis tools
			$exec .= &quot;--host=&quot;.escapeshellarg($matches[1]).&quot; --port=&quot;.escapeshellarg($matches[2]).&quot; &quot;;
		} elseif (preg_match(&#039;#^(.*):(.*)$#&#039;, $host, $matches) &amp;&amp; file_exists($matches[2])) {
			$exec .= &quot;--host=&quot;.escapeshellarg($matches[1]).&quot; --socket=&quot;.escapeshellarg($matches[2]).&quot; &quot;;
		} else {
			$exec .= &quot;--host=&quot;.escapeshellarg($host).&quot; &quot;;
		}

		$exec = apply_filters(&#039;updraftplus_mysqldump_arguments&#039;, $exec, $table_name, $potsql);

		$exec .= $this-&gt;dbinfo[&#039;name&#039;].&quot; &quot;.escapeshellarg($table_name);

		$ret = false;
		$any_output = false;
		$gtid_found = false;
		$writes = 0;
		$write_bytes = 0;
		$handle = (function_exists(&#039;popen&#039;) &amp;&amp; function_exists(&#039;pclose&#039;)) ? popen($exec, &#039;r&#039;) : false;
		if ($handle) {
			while (!feof($handle)) {
				$w = fgets($handle, 1048576);
				if (is_string($w) &amp;&amp; $w) {

					if (preg_match(&#039;/^SET @@GLOBAL.GTID_PURGED/i&#039;, $w)) $gtid_found = true;

					if ($gtid_found) {
						if (false !== strpos($w, &#039;;&#039;)) $gtid_found = false;
						continue;
					}

					$this-&gt;stow($w);
					$writes++;
					$write_bytes += strlen($w);
					$any_output = true;
				}
			}
			$ret = pclose($handle);
			// The manual page for pclose() claims that only -1 indicates an error, but this is untrue
			if (0 != $ret) {
				$updraftplus-&gt;log(&quot;Binary mysqldump: error (code: $ret)&quot;);
				// Keep counter of failures? Change value of binsqldump?
				$ret = false;
			} else {
				if ($any_output) {
					$updraftplus-&gt;log(&quot;Table $table_name: binary mysqldump finished (writes: $writes, bytes $write_bytes, return code $ret) in &quot;.sprintf(&quot;%.02f&quot;, max(microtime(true)-$microtime, 0.00001)).&quot; seconds&quot;);
					$ret = true;
				}
			}
		} else {
			$updraftplus-&gt;log(&quot;Binary mysqldump error: bindump popen failed&quot;);
		}

		// Clean temporary files
		@unlink($this-&gt;updraft_dir.&#039;/&#039;.$pfile);// phpcs:ignore Generic.PHP.NoSilencedErrors.Discouraged -- Silenced to suppress errors that may arise if the file doesn&#039;t exist.

		return $ret;

	}

	/**
	 * Write out the initial backup information for a table to the currently open file
	 *
	 * @param String $table			  - Full name of database table to backup
	 * @param String $dump_as_table	  - Table name to use when writing out
	 * @param String $table_type	  - Table type - &#039;VIEW&#039; is supported; otherwise it is treated as an ordinary table
	 * @param Array  $table_structure - Table structure as returned by a DESCRIBE command
	 */
	private function write_table_backup_beginning($table, $dump_as_table, $table_type, $table_structure) {

		$this-&gt;stow(&quot;\n# Delete any existing table &quot;.UpdraftPlus_Manipulation_Functions::backquote($table).&quot;\n\nDROP TABLE IF EXISTS &quot; . UpdraftPlus_Manipulation_Functions::backquote($dump_as_table).&quot;;\n&quot;);

		if (&#039;VIEW&#039; == $table_type) {
			$this-&gt;stow(&quot;DROP VIEW IF EXISTS &quot; . UpdraftPlus_Manipulation_Functions::backquote($dump_as_table) . &quot;;\n&quot;);
		}

		$description = (&#039;VIEW&#039; == $table_type) ? &#039;view&#039; : &#039;table&#039;;

		$this-&gt;stow(&quot;\n# Table structure of $description &quot;.UpdraftPlus_Manipulation_Functions::backquote($table).&quot;\n\n&quot;);

		$create_table = $this-&gt;wpdb_obj-&gt;get_results(&quot;SHOW CREATE TABLE &quot;.UpdraftPlus_Manipulation_Functions::backquote($table), ARRAY_N);
		if (false === $create_table) {
			$this-&gt;stow(&quot;#\n# Error with SHOW CREATE TABLE for $table\n#\n&quot;);
		}
		$create_line = UpdraftPlus_Manipulation_Functions::str_lreplace(&#039;TYPE=&#039;, &#039;ENGINE=&#039;, $create_table[0][1]);

		// Remove PAGE_CHECKSUM parameter from MyISAM - was internal, undocumented, later removed (so causes errors on import)
		if (preg_match(&#039;/ENGINE=([^\s;]+)/&#039;, $create_line, $eng_match)) {
			$engine = $eng_match[1];
			if (&#039;myisam&#039; == strtolower($engine)) {
				$create_line = preg_replace(&#039;/PAGE_CHECKSUM=\d\s?/&#039;, &#039;&#039;, $create_line, 1);
			}
		}

		if ($dump_as_table !== $table) $create_line = UpdraftPlus_Manipulation_Functions::str_replace_once($table, $dump_as_table, $create_line);

		$this-&gt;stow($create_line.&#039; ;&#039;);

		if (false === $table_structure) {
			$this-&gt;stow(&quot;#\n# Error getting $description structure of $table\n#\n&quot;);
		}

		// Add a comment preceding the beginning of the data
		$this-&gt;stow(&quot;\n\n# &quot;.sprintf(&quot;Data contents of $description %s&quot;, UpdraftPlus_Manipulation_Functions::backquote($table)).&quot;\n\n&quot;);

	}

	/**
	 * Suggest a beginning value for how many rows to fetch in each SELECT statement (before taking into account resumptions)
	 *
	 * @param String $table - the full table name
	 *
	 * @return Integer
	 */
	private function get_rows_on_first_fetch($table) {

		// In future, we could run over the table definition; if it is all non-massive defined lengths, we could base a calculation on that.

		if ($this-&gt;table_prefix_raw.&#039;term_relationships&#039; == $table) {
			// This table is known to have very small data lengths
			$rows = 100000;
		} elseif (preg_match(&#039;/meta$/i&#039;, $table)) {
			// Meta-data rows tend to be short *on average*. 10MB / 4000 rows = 2.6KB/row, so this is still quite conservative.
			$rows = 4000;
		} else {
			// The very conservative default
			$rows = 1000;
		}

		return $rows;

	}

	/**
	 * Suggest how many rows to fetch in each SELECT statement
	 *
	 * @param String		  $table					- the table being fetched
	 * @param Boolean		  $allow_further_reductions - whether to enable a second level of reductions (i.e. even less rows)
	 * @param Boolean		  $is_first_fetch_for_table - whether this is the first fetch on this table
	 * @param Integer|Boolean $expected_rows			- if an integer, an estimate of the number of rows
	 * @param Boolean		  $expected_via_count		- if $expected_rows is an integer, then this indicates whether the estimate was made via a SELECT COUNT() statement
	 *
	 * @return Integer
	 */
	private function number_of_rows_to_fetch($table, $allow_further_reductions, $is_first_fetch_for_table, $expected_rows = false, $expected_via_count = false) {

		global $updraftplus;

		// This used to be fixed at 500; but we (after a long time) saw a case that looked like an out-of-memory even at this level. Now that we have implemented resumptions, the risk of timeouts is much lower (we just need to process enough rows).
		// October 2020: added further reductions
		// Listed in increasing order due to the handling below. At the end it gets quite drastic. Note, though, that currently we don&#039;t store this in the job-data.
		// A future improvement could, when things get drastic, grab and log data on the size of what is required, so that we can respond more dynamically. The strategy currently here will run out of road if memory falls short multiple times. See: https://stackoverflow.com/questions/4524019/how-to-get-the-byte-size-of-resultset-in-an-sql-query
		$fetch_rows_reductions = array(500, 250, 200, 100);

		$default_on_first_fetch = $this-&gt;get_rows_on_first_fetch($table);

		$known_bigger_than_table = (!is_bool($expected_rows) &amp;&amp; $expected_rows &amp;&amp; $expected_via_count &amp;&amp; $default_on_first_fetch &gt; 2 * $expected_rows);

		if ($known_bigger_than_table) $allow_further_reductions = true;

		if ($allow_further_reductions) {
			// If we&#039;re relying on LIMIT with offsets, then we have to be mindful of how that performs
			$fetch_rows_reductions = array_merge($fetch_rows_reductions, array(50, 20, 5));
		}

		// Remove any that are far out of range
		if ($known_bigger_than_table) {
			foreach ($fetch_rows_reductions as $k =&gt; $reduce_to) {
				if ($reduce_to &gt; $expected_rows * 2 &amp;&amp; count($fetch_rows_reductions) &gt; 2) {
					unset($fetch_rows_reductions[$k]);
				}
			}
		}

		// If this is not the first fetch on a table, then get what was stored last time we set it (if we ever did). On the first fetch, reset back to the starting value (we presume problems are table-specific).
		// This means that the same value will persist whilst the table is being backed up, both during the current resumption, and subsequent ones
		$fetch_rows = $is_first_fetch_for_table ? $default_on_first_fetch : $updraftplus-&gt;jobdata_get(&#039;fetch_rows&#039;, $default_on_first_fetch);

		$fetch_rows_at_start = $fetch_rows;

		$resumptions_since_last_successful = $updraftplus-&gt;current_resumption - $updraftplus-&gt;last_successful_resumption;

		// Do we need to reduce the number of rows we attempt to fetch?
		// If something useful has happened on this run, then we don&#039;t try any reductions (we save them for a resumption after one on which nothing useful happened)
		if ($known_bigger_than_table || (!$updraftplus-&gt;something_useful_happened &amp;&amp; !empty($updraftplus-&gt;current_resumption) &amp;&amp; $resumptions_since_last_successful &gt; 1)) {

			$break_after = $is_first_fetch_for_table ? max($resumptions_since_last_successful - 1, 1) : 1;

			foreach ($fetch_rows_reductions as $reduce_to) {
				if ($fetch_rows &gt; $reduce_to) {
					// Go down one level
					$fetch_rows = $reduce_to;
					$break_after--;
					if ($break_after &lt; 1) break;
				}
			}

			$log_start = $updraftplus-&gt;current_resumption ? &quot;Last successful resumption was $resumptions_since_last_successful runs ago&quot; : &quot;Table is relatively small&quot;;
			$updraftplus-&gt;log(&quot;$log_start; fetch_rows will thus be: $fetch_rows (allow_further_reductions=$allow_further_reductions, is_first_fetch=$is_first_fetch_for_table, known_bigger_than_table=$known_bigger_than_table)&quot;);
		}

		// If it has changed, then preserve it in the job for the next resumption (of this table)
		if ($fetch_rows_at_start !== $fetch_rows || $is_first_fetch_for_table) $updraftplus-&gt;jobdata_set(&#039;fetch_rows&#039;, $fetch_rows);

		return apply_filters(&#039;updraftplus_number_of_rows_to_fetch&#039;, $fetch_rows, $table, $allow_further_reductions, $is_first_fetch_for_table, $expected_rows, $expected_via_count);

	}

	/**
	 * Return a list of primary keys (N.B. the method should not be called unless the caller already knows that the table has a single/simple primary key) for rows that have &quot;over-sized&quot; data.
	 * Currently this only examines the &quot;posts&quot; table and any other table with a longtext type, which are the primary causes of problems. If others are revealed in future, it can be generalised (e.g. examine the whole definition/all cells).
	 *
	 * @param String $table		  - the full table name
	 * @param Array	 $structure	  - the table structure, as from WPDB::get_results(&quot;DESCRIBE ...&quot;);
	 * @param String $primary_key - the primary key to use; required if $structure is set (slightly redundant, since it can be derived from structure)
	 *
	 * @return Array - list of IDs
	 */
	private function get_oversized_rows($table, $structure = array(), $primary_key = &#039;&#039;) {

		if ($this-&gt;table_prefix_raw.&#039;posts&#039; != $table) {
			if (empty($structure) || &#039;&#039; === $primary_key) return array();
			foreach ($structure as $item) {
				if (&#039;&#039; !== $item-&gt;Field &amp;&amp; &#039;longtext&#039; === $item-&gt;Type) {
					$use_field = $item-&gt;Field;
				}
			}
		} else {
			$primary_key = &#039;id&#039;;
			$use_field = &#039;post_content&#039;;
		}

		if (!isset($use_field)) return array();

		global $updraftplus;

		// Look for the jobdata_delete() call elsewhere in this class - the key name needs to match
		$jobdata_key = &#039;oversized_rows_&#039;.$table;

		$oversized_list = $updraftplus-&gt;jobdata_get($jobdata_key);

		if (is_array($oversized_list)) return $oversized_list;

		$oversized_list = array();

		// Allow over-ride via a constant
		$oversized_row_size = defined(&#039;UPDRAFTPLUS_OVERSIZED_ROW_SIZE&#039;) ? UPDRAFTPLUS_OVERSIZED_ROW_SIZE : 2048576;

		$sql = $this-&gt;wpdb_obj-&gt;prepare(&quot;SELECT &quot;.UpdraftPlus_Manipulation_Functions::backquote($primary_key).&quot; FROM &quot;.UpdraftPlus_Manipulation_Functions::backquote($table).&quot; WHERE LENGTH(&quot;.UpdraftPlus_Manipulation_Functions::backquote($use_field).&quot;) &gt; %d ORDER BY &quot;.UpdraftPlus_Manipulation_Functions::backquote($primary_key).&quot; ASC&quot;, $oversized_row_size);

		$oversized_rows = $this-&gt;wpdb_obj-&gt;get_col($sql);

		// Upon an error, just return an empty list
		if (!is_array($oversized_rows)) return array();

		$updraftplus-&gt;jobdata_set($jobdata_key, $oversized_rows);

		return $oversized_rows;

	}

	/**
	 * Original version taken partially from phpMyAdmin and partially from Alain Wolf, Zurich - Switzerland to use the WordPress $wpdb object
	 * Website: http://restkultur.ch/personal/wolf/scripts/db_backup/
	 * Modified by Scott Merrill (http://www.skippy.net/)
	 * Subsequently heavily improved and modified
	 *
	 * This method should be called in a loop for a complete table backup (see the information for the returned parameter). The method may implement whatever strategy it likes for deciding when to return (the assumption is that when it does return with some results, the caller should register that something useful happened).
	 *
	 * @param String		  $table			   - Full name of database table to backup
	 * @param String		  $table_type		   - Table type - &#039;VIEW&#039; is supported; otherwise it is treated as an ordinary table
	 * @param Integer|Boolean $start_record		   - Specify the starting record, or true to start at the beginning. Our internal page size is fixed at 1000 (though within that we might actually query in smaller batches).
	 * @param Boolean		  $can_use_primary_key - Whether it is allowed to perform quicker SELECTS based on the primary key. The intended use case for false is to support backups running during a version upgrade. N.B. This &quot;can&quot; is not absolute; there may be other constraints dealt with within this method.
	 *
	 * @return Integer|Array|WP_Error - a WP_Error to indicate an error; an array indicates that it finished (if it includes &#039;next_record&#039; that means it finished via producing something); an integer to indicate the next page the case that there are more to do.
	 */
	private function backup_table($table, $table_type = &#039;BASE TABLE&#039;, $start_record = true, $can_use_primary_key = true) {
		$process_pages = 100;

		// Preserve the passed-in value
		$original_start_record = $start_record;

		global $updraftplus;

		$microtime = microtime(true);
		$total_rows = 0;

		// Deal with Windows/old MySQL setups with erroneous table prefixes differing in case
		$dump_as_table = (false == $this-&gt;duplicate_tables_exist &amp;&amp; 0 === stripos($table, $this-&gt;table_prefix) &amp;&amp; 0 !== strpos($table, $this-&gt;table_prefix)) ? $this-&gt;table_prefix.substr($table, strlen($this-&gt;table_prefix)) : $table;

		$table_structure = $this-&gt;wpdb_obj-&gt;get_results(&quot;DESCRIBE &quot;.UpdraftPlus_Manipulation_Functions::backquote($table));
		if (!$table_structure) {
			// $updraftplus-&gt;log(__(&#039;Error getting table details&#039;, &#039;updraftplus&#039;) . &quot;: $table&quot;, &#039;error&#039;);
			$error_message = &#039;&#039;;
			if ($this-&gt;wpdb_obj-&gt;last_error) $error_message .= &#039; (&#039;.$this-&gt;wpdb_obj-&gt;last_error.&#039;)&#039;;
			return new WP_Error(&#039;table_details_error&#039;, $error_message);
		}

		// If at the beginning of the dump for a table, then add the DROP and CREATE statements
		if (true === $start_record) {
			$this-&gt;write_table_backup_beginning($table, $dump_as_table, $table_type, $table_structure);
		}

		// Some tables have optional data, and should be skipped if they do not work
		$table_sans_prefix = substr($table, strlen($this-&gt;table_prefix_raw));
		$data_optional_tables = (&#039;wp&#039; == $this-&gt;whichdb) ? apply_filters(&#039;updraftplus_data_optional_tables&#039;, explode(&#039;,&#039;, UPDRAFTPLUS_DATA_OPTIONAL_TABLES)) : array();
		if (in_array($table_sans_prefix, $data_optional_tables)) {
			if (!$updraftplus-&gt;something_useful_happened &amp;&amp; !empty($updraftplus-&gt;current_resumption) &amp;&amp; ($updraftplus-&gt;current_resumption - $updraftplus-&gt;last_successful_resumption &gt; 2)) {
				$updraftplus-&gt;log(&quot;Table $table: Data skipped (previous attempts failed, and table is marked as non-essential)&quot;);
				return array();
			}
		}

		$table_data = array();
		if (&#039;VIEW&#039; != $table_type) {
			$select_selected_fields = $insert_selected_fields = array();
			$defs = array();
			$integer_fields = array();
			$binary_fields = array();
			$bit_fields = array();
			$bit_field_exists = false;
			$invisible_field_exists = false;

			// false means &quot;not yet set&quot;; a string means what it was set to; null means that there are multiple (and so not useful to us). If it is not a string, then $primary_key_type is invalid and should not be used.
			$primary_key = false;
			$primary_key_type = false;

			// $table_structure was from &quot;DESCRIBE $table&quot;
			foreach ($table_structure as $struct) {

				if (isset($struct-&gt;Key) &amp;&amp; &#039;PRI&#039; == $struct-&gt;Key &amp;&amp; &#039;&#039; != $struct-&gt;Field) {
					$primary_key = (false === $primary_key) ? $struct-&gt;Field : null;
					$primary_key_type = $struct-&gt;Type;
				}

				if ((0 === strpos($struct-&gt;Type, &#039;tinyint&#039;)) || (0 === strpos(strtolower($struct-&gt;Type), &#039;smallint&#039;))
					|| (0 === strpos(strtolower($struct-&gt;Type), &#039;mediumint&#039;)) || (0 === strpos(strtolower($struct-&gt;Type), &#039;int&#039;)) || (0 === strpos(strtolower($struct-&gt;Type), &#039;bigint&#039;))
				) {
					$defs[strtolower($struct-&gt;Field)] = (null === $struct-&gt;Default) ? &#039;NULL&#039; : $struct-&gt;Default;
					$integer_fields[strtolower($struct-&gt;Field)] = true;
				}

				if ((0 === strpos(strtolower($struct-&gt;Type), &#039;binary&#039;)) || (0 === strpos(strtolower($struct-&gt;Type), &#039;varbinary&#039;)) || (0 === strpos(strtolower($struct-&gt;Type), &#039;tinyblob&#039;)) || (0 === strpos(strtolower($struct-&gt;Type), &#039;mediumblob&#039;)) || (0 === strpos(strtolower($struct-&gt;Type), &#039;blob&#039;)) || (0 === strpos(strtolower($struct-&gt;Type), &#039;longblob&#039;))) {
					$binary_fields[strtolower($struct-&gt;Field)] = true;
				}

				$insert_selected_fields[] = UpdraftPlus_Manipulation_Functions::backquote(str_replace(&#039;`&#039;, &#039;``&#039;, $struct-&gt;Field));

				if (preg_match(&#039;/^bit(?:\(([0-9]+)\))?$/i&#039;, trim($struct-&gt;Type), $matches)) {
					if (!$bit_field_exists) $bit_field_exists = true;
					$bit_fields[strtolower($struct-&gt;Field)] = !empty($matches[1]) ? max(1, (int) $matches[1]) : 1;
					// the reason why if bit fields are found then the fields need to be cast into binary type is that if mysqli_query function is being used, mysql will convert the bit field value to a decimal number and represent it in a string format whereas, if mysql_query function is being used, mysql will not convert it to a decimal number but instead will keep it retained as it is
					$struct-&gt;Field = &quot;CAST(&quot;.UpdraftPlus_Manipulation_Functions::backquote(str_replace(&#039;`&#039;, &#039;``&#039;, $struct-&gt;Field)).&quot; AS BINARY) AS &quot;.UpdraftPlus_Manipulation_Functions::backquote(str_replace(&#039;`&#039;, &#039;``&#039;, $struct-&gt;Field));
					$select_selected_fields[] = $struct-&gt;Field;
				} else {
					$select_selected_fields[] = UpdraftPlus_Manipulation_Functions::backquote(str_replace(&#039;`&#039;, &#039;``&#039;, $struct-&gt;Field));
				}

				if (isset($struct-&gt;Extra) &amp;&amp; preg_match(&#039;/\binvisible\b/i&#039;, $struct-&gt;Extra)) $invisible_field_exists = true;
			}

			$expected_via_count = false;

			// N.B. At this stage this is for optimisation, mainly targets what is used on the core WP tables (bigint(20)); a value can be relied upon, but false is not definitive. N.B. https://docs.oracle.com/cd/E17952_01/mysql-8.0-en/numeric-type-syntax.html (retrieved Aug 2021): &quot;As of MySQL 8.0.17, the display width attribute is deprecated for integer data types; you should expect support for it to be removed in a future version of MySQL.&quot; MySQL 8.0.20 is not returning it.
			$use_primary_key = false;
			if ($can_use_primary_key &amp;&amp; is_string($primary_key) &amp;&amp; preg_match(&#039;#^(small|medium|big)?int(\(| |$)#i&#039;, $primary_key_type)) {
				$use_primary_key = true;

				// We don&#039;t bother re-counting if it&#039;s likely to be so large that we&#039;re not going to do anything with the result
				if (is_bool($this-&gt;expected_rows) || $this-&gt;expected_rows &lt; 1000) {
					$expected_rows = $this-&gt;wpdb_obj-&gt;get_var(&#039;SELECT COUNT(&#039;.UpdraftPlus_Manipulation_Functions::backquote($primary_key).&#039;) FROM &#039;.UpdraftPlus_Manipulation_Functions::backquote($table));
					if (!is_bool($expected_rows)) {
						$this-&gt;expected_rows = $expected_rows;
						$expected_via_count = true;
					}
				}

				$oversized_rows = $this-&gt;get_oversized_rows($table, $table_structure, $primary_key);

				if (preg_match(&#039;# unsigned$#i&#039;, $primary_key_type)) {
					if (true === $start_record) $start_record = -1;
				} else {
					if (true === $start_record) {
						$min_value = $this-&gt;wpdb_obj-&gt;get_var(&#039;SELECT MIN(&#039;.UpdraftPlus_Manipulation_Functions::backquote($primary_key).&#039;) FROM &#039;.UpdraftPlus_Manipulation_Functions::backquote($table));
						$start_record = (is_numeric($min_value) &amp;&amp; $min_value) ? (int) $min_value - 1 : -1;
					}
				}
			}

			if (!is_bool($this-&gt;expected_rows)) {
				$log_expected_records = (true === $original_start_record);
				$this-&gt;log_expected_rows($table, $this-&gt;expected_rows, $expected_via_count, $log_expected_records);
			}

			$search = array(&quot;\x00&quot;, &quot;\x0a&quot;, &quot;\x0d&quot;, &quot;\x1a&quot;);
			$replace = array(&#039;\0&#039;, &#039;\n&#039;, &#039;\r&#039;, &#039;\Z&#039;);

			$where_array = apply_filters(&#039;updraftplus_backup_table_sql_where&#039;, array(), $table, $this);
			$where = &#039;&#039;;
			if (!empty($where_array) &amp;&amp; is_array($where_array)) {
				$where = &#039;WHERE &#039;.implode(&#039; AND &#039;, $where_array);
			}

			// Experimentation here shows that on large tables (we tested with 180,000 rows) on MyISAM, 1000 makes the table dump out 3x faster than the previous value of 100. After that, the benefit diminishes (increasing to 4000 only saved another 12%)

			$fetch_rows = $this-&gt;number_of_rows_to_fetch($table, $use_primary_key || $start_record &lt; 500000, true === $original_start_record, $this-&gt;expected_rows, $expected_via_count);

			if (!is_bool($this-&gt;expected_rows)) $this-&gt;expected_rows = true;

			$original_fetch_rows = $fetch_rows;

			$select_selected_fields = $bit_field_exists || $invisible_field_exists ? implode(&#039;, &#039;, $select_selected_fields) : &#039;*&#039;;

			$enough_for_now = false;

			$began_writing_at = time();

			$enough_data_after = 104857600;
			$enough_time_after = ($fetch_rows &gt; 250) ? 15 : 9;

			// Loop which retrieves data
			do {

				if (function_exists(&#039;set_time_limit&#039;)) @set_time_limit(UPDRAFTPLUS_SET_TIME_LIMIT);// phpcs:ignore Generic.PHP.NoSilencedErrors.Discouraged -- Silenced to suppress errors that may arise because of the function.

				// Reset back to that which has constructed before the loop began
				$final_where = $where;

				if ($use_primary_key) {

					// The point of this is to leverage the indexing on the private key to make the SELECT much faster than index-less paging
					$final_where = $where . ($where ? &#039; AND &#039; : &#039;WHERE &#039;);

					// If it&#039;s -1, then we avoid mentioning a negative value, as the value may be unsigned
					$final_where .= UpdraftPlus_Manipulation_Functions::backquote($primary_key).((-1 === $start_record) ? &#039; &gt;= 0&#039; : &quot; &gt; $start_record&quot;);

					$oversized_last_row_id = false;
					// Remove ones we&#039;ve gone past
					foreach ($oversized_rows as $k =&gt; $row_id) {
						if ($start_record &gt;= $row_id) {
							unset($oversized_rows[$k]);
						} else {
							$oversized_last_row_id = $row_id;
							// At this point we are only willing to fetch a single over-sized row. If this ever changes, we&#039;ll need to also keep track of their length.
							break;
						}
					}
					// Number the keys again from zero
					$oversized_rows = array_values($oversized_rows);

					if ($oversized_last_row_id) {
						$final_where .= &quot; AND &quot;. UpdraftPlus_Manipulation_Functions::backquote($primary_key).&quot; &lt;= $oversized_last_row_id&quot;;
					}

					$limit_statement = sprintf(&#039;LIMIT %d&#039;, $fetch_rows);

					$order_by = &#039;ORDER BY &#039;.UpdraftPlus_Manipulation_Functions::backquote($primary_key).&#039; ASC&#039;;

				} else {
					$order_by = &#039;&#039;;
					if (true === $start_record) $start_record = 0;
					$limit_statement = sprintf(&#039;LIMIT %d, %d&#039;, $start_record, $fetch_rows);
				}

				// $this-&gt;wpdb_obj-&gt;prepare() not needed (will throw a notice) as there are no parameters (all parts are already sanitised or cast to known-safe types if not sanitised here)
				$select_sql = &quot;SELECT $select_selected_fields FROM &quot;.UpdraftPlus_Manipulation_Functions::backquote($table).&quot; $final_where $order_by $limit_statement&quot;;

				if (defined(&#039;UPDRAFTPLUS_LOG_BACKUP_SELECTS&#039;) &amp;&amp; UPDRAFTPLUS_LOG_BACKUP_SELECTS) $updraftplus-&gt;log($select_sql);

				// Allow the data to be filtered (e.g. anonymisation)
				$table_data = apply_filters(&#039;updraftplus_backup_table_results&#039;, $this-&gt;wpdb_obj-&gt;get_results($select_sql, ARRAY_A), $table, $this-&gt;table_prefix, $this-&gt;whichdb);

				if (null === $table_data) {
					$updraftplus-&gt;log(&quot;Database fetch error (null returned) when running: $select_sql&quot;);
				}

				$oversized_changes = false;

				if (!$table_data) {
					// Nothing was found - not even the expected over-sized row; this means it was deleted - so don&#039;t try to use a limitation based on it again, or we may get an infinite loop.
					if (isset($oversized_last_row_id) &amp;&amp; false !== $oversized_last_row_id) {
						if (false !== ($key = array_search($oversized_last_row_id, $oversized_rows))) {
							unset($oversized_rows[$key]);
							$oversized_changes = true;
						}
					}
					if ($oversized_changes) $updraftplus-&gt;jobdata_set(&#039;oversized_rows_&#039;.$table, $oversized_rows);
					continue;
				}
				$insert_columns_sql = $invisible_field_exists ? &#039; (&#039; . implode(&#039;, &#039;, $insert_selected_fields) . &#039;)&#039; : &#039;&#039;;
				$entries = &#039;INSERT INTO &#039;.UpdraftPlus_Manipulation_Functions::backquote($dump_as_table).$insert_columns_sql.&#039; VALUES &#039;;

				// \x08\\x09, not required

				$this_entry = &#039;&#039;;
				foreach ($table_data as $row) {
					$total_rows++;
					if ($this_entry) $this_entry .= &quot;,\n &quot;;
					$this_entry .= &#039;(&#039;;
					$key_count = 0;
					foreach ($row as $key =&gt; $value) {

						if ($key_count) $this_entry .= &#039;, &#039;;
						$key_count++;

						if ($use_primary_key &amp;&amp; strtolower($primary_key) == strtolower($key) &amp;&amp; $value &gt; $start_record) {
							$start_record = $value;
							foreach ($oversized_rows as $k =&gt; $row_id) {
								if ($start_record &gt;= $row_id) {
									unset($oversized_rows[$k]);
								} else {
									break;
								}
							}
						}

						if (isset($integer_fields[strtolower($key)])) {
							// make sure there are no blank spots in the insert syntax,
							// yet try to avoid quotation marks around integers
							$value = (null === $value || &#039;&#039; === $value) ? $defs[strtolower($key)] : $value;
							$value = (&#039;&#039; === $value) ? &quot;&#039;&#039;&quot; : $value;
							$this_entry .= $value;
						} elseif (isset($binary_fields[strtolower($key)])) {
							if (null === $value) {
								$this_entry .= &#039;NULL&#039;;
							} elseif (&#039;&#039; === $value) {
								$this_entry .= &quot;&#039;&#039;&quot;;
							} else {
								$this_entry .= &quot;0x&quot; . bin2hex(str_repeat(&quot;0&quot;, floor(strspn($value, &quot;0&quot;) / 4)).$value);
							}
						} elseif (isset($bit_fields[strtolower($key)])) {
							if (null === $value) {
								$this_entry .= &#039;NULL&#039;;
							} else {
								mbstring_binary_safe_encoding();
								$val_len = is_string($value) ? strlen($value) : 0;
								reset_mbstring_encoding();
								$hex = &#039;&#039;;
								for ($i=0; $i&lt;$val_len; $i++) {
									$hex .= sprintf(&#039;%02X&#039;, ord($value[$i]));
								}
								$this_entry .= &quot;b&#039;&quot;.str_pad($this-&gt;hex2bin($hex), $bit_fields[strtolower($key)], &#039;0&#039;, STR_PAD_LEFT).&quot;&#039;&quot;;
							}
						} else {
							$this_entry .= (null === $value) ? &#039;NULL&#039; : &quot;&#039;&quot; . str_replace($search, $replace, str_replace(&#039;\&#039;&#039;, &#039;\\\&#039;&#039;, str_replace(&#039;\\&#039;, &#039;\\\\&#039;, $value))) . &quot;&#039;&quot;;
						}
					}
					$this_entry .= &#039;)&#039;;

					// Flush every 512KB
					if (strlen($this_entry) &gt; 524288) {
						$this_entry .= &#039;;&#039;;
						if (strlen($this_entry) &gt; 10485760) {
							// This is an attempt to prevent avoidable duplication of long strings in-memory, at the cost of one extra write
							$this-&gt;stow(&quot; \n&quot;.$entries);
							$this-&gt;stow($this_entry);
						} else {
							$this-&gt;stow(&quot; \n&quot;.$entries.$this_entry);
						}
						$this_entry = &#039;&#039;;
						// Potentially indicate that enough has been done to loop
						if ($this-&gt;db_current_raw_bytes &gt; $enough_data_after || time() - $began_writing_at &gt; $enough_time_after) {
							$enough_for_now = true;
						}
					}

				}

				if ($this_entry) {
					$this_entry .= &#039;;&#039;;
					if (strlen($this_entry) &gt; 10485760) {
						// This is an attempt to prevent avoidable duplication of long strings in-memory, at the cost of one extra write
						$this-&gt;stow(&quot; \n&quot;.$entries);
						$this-&gt;stow($this_entry);
					} else {
						$this-&gt;stow(&quot; \n&quot;.$entries.$this_entry);
					}
				}

				// Increment this before any potential changes to $fetch_rows
				if (!$use_primary_key) {
					$start_record += $fetch_rows;
				}

				// Potentially fetch more rows at once, if performance has been good on a sufficient number of rows
				// However - testing indicates that this makes very little difference to overall performance; MySQL&#039;s performance scales linearly with the number of rows requested. So optimisations here are unlikely to be worthwhile. (Probably better to remove LIMIT and ORDER BY entirely on tables that look small enough to fit into memory in one go)
				if (!$enough_for_now &amp;&amp; $total_rows &gt; 0 &amp;&amp; $fetch_rows &gt;= $original_fetch_rows &amp;&amp; $fetch_rows &lt; $original_fetch_rows * 8 &amp;&amp; $this-&gt;db_current_raw_bytes &gt; 10000 &amp;&amp; $total_rows &gt; 5000) {
					$bytes_per_row = $this-&gt;db_current_raw_bytes / $total_rows;
					// Increase the numbers of rows fetched if we still expect it to be less than 5MB, and the rate is acceptable
					if (2 * $fetch_rows * $bytes_per_row &lt; 5242880) {
						// N.B. This does not persist across resumptions
						$fetch_rows = $fetch_rows * 2;
						$process_pages = $process_pages / 2;
					}
				}

				if ($process_pages &gt; 0) $process_pages--;

				// The condition involving count($oversized_rows) is for when rows that were in oversized_rows got deleted before being fetched; the &quot;ID &lt; (row)&quot; condition could result in no data being returned, even though the table isn&#039;t finished
			} while (!$enough_for_now &amp;&amp; (count($table_data) &gt; 0 || (isset($oversized_rows) &amp;&amp; count($oversized_rows) &gt; 0)) &amp;&amp; (-1 == $process_pages || $process_pages &gt; 0));
		}

		$fetch_time = max(microtime(true)-$microtime, 0.00001);

		$updraftplus-&gt;log(&quot;Table $table: Rows added in this batch (next record: $start_record): $total_rows (uncompressed bytes in this segment=&quot;.$this-&gt;db_current_raw_bytes.&quot;) in &quot;.sprintf(&#039;%.02f&#039;, $fetch_time).&#039; seconds&#039;);

		// If all data has been fetched, then write out the closing comment
		if (-1 == $process_pages || 0 == count($table_data)) {
			$this-&gt;stow(&quot;\n# End of data contents of table &quot;.UpdraftPlus_Manipulation_Functions::backquote($table).&quot;\n\n&quot;);
			// Keep the keyname here in sync with what is in self::get_oversized_rows()
			$updraftplus-&gt;jobdata_delete(&#039;oversized_rows_&#039;.$table);
			return is_numeric($start_record) ? array(&#039;next_record&#039; =&gt; (int) $start_record) : array();
		}

		return is_numeric($start_record) ? (int) $start_record : $start_record;

	}

	/**
	 * Convert hexadecimal (base16) number into binary (base2) and no need to worry about the platform-dependent of 32bit/64bit size limitation
	 *
	 * @param String $hex Hexadecimal number
	 * @return String a base2 format of the given hexadecimal number
	 */
	private function hex2bin($hex) {
		$table = array(
			&#039;0&#039; =&gt; &#039;0000&#039;,
			&#039;1&#039; =&gt; &#039;0001&#039;,
			&#039;2&#039; =&gt; &#039;0010&#039;,
			&#039;3&#039; =&gt; &#039;0011&#039;,
			&#039;4&#039; =&gt; &#039;0100&#039;,
			&#039;5&#039; =&gt; &#039;0101&#039;,
			&#039;6&#039; =&gt; &#039;0110&#039;,
			&#039;7&#039; =&gt; &#039;0111&#039;,
			&#039;8&#039; =&gt; &#039;1000&#039;,
			&#039;9&#039; =&gt; &#039;1001&#039;,
			&#039;a&#039; =&gt; &#039;1010&#039;,
			&#039;b&#039; =&gt; &#039;1011&#039;,
			&#039;c&#039; =&gt; &#039;1100&#039;,
			&#039;d&#039; =&gt; &#039;1101&#039;,
			&#039;e&#039; =&gt; &#039;1110&#039;,
			&#039;f&#039; =&gt; &#039;1111&#039;
		);
		$bin = &#039;&#039;;

		if (!preg_match(&#039;/^[0-9a-f]+$/i&#039;, $hex)) return &#039;&#039;;

		for ($i = 0; $i &lt; strlen($hex); $i++) {
			$bin .= $table[strtolower(substr($hex, $i, 1))];
		}

		return $bin;
	}

	/**
	 * Encrypts the file if the option is set; returns the basename of the file (according to whether it was encrypted or not)
	 *
	 * @param String $file - file to encrypt
	 *
	 * @return array
	 */
	public function encrypt_file($file) {
		global $updraftplus;
		$encryption = $updraftplus-&gt;get_job_option(&#039;updraft_encryptionphrase&#039;);
		if (!is_string($encryption)) $encryption = &#039;&#039;;
		if (strlen($encryption) &gt; 0) {
			$updraftplus-&gt;log(&quot;Attempting to encrypt backup file&quot;);
			try {
				$result = apply_filters(&#039;updraft_encrypt_file&#039;, null, $file, $encryption, $this-&gt;whichdb, $this-&gt;whichdb_suffix);
			} catch (Exception $e) {
				$log_message = &#039;Exception (&#039;.get_class($e).&#039;) occurred during encryption: &#039;.$e-&gt;getMessage().&#039; (Code: &#039;.$e-&gt;getCode().&#039;, line &#039;.$e-&gt;getLine().&#039; in &#039;.$e-&gt;getFile().&#039;)&#039;;
				UpdraftPlus_Manipulation_Functions::error_log($log_message);
				// @codingStandardsIgnoreLine
				$log_message .= &#039; Backtrace: &#039;.str_replace(array(ABSPATH, &quot;\n&quot;), array(&#039;&#039;, &#039;, &#039;), $e-&gt;getTraceAsString());
				$updraftplus-&gt;log($log_message);
				/* translators: 1: Exception class, 2: Exception message */
				$updraftplus-&gt;log(sprintf(__(&#039;A PHP exception (%1$s) has occurred: %2$s&#039;, &#039;updraftplus&#039;), get_class($e), $e-&gt;getMessage()), &#039;error&#039;);
				die();
			} catch (Error $e) {// phpcs:ignore PHPCompatibility.Classes.NewClasses.errorFound -- This Error class will only get triggered during runtime but we don&#039;t explicitly throw this class in our code; so we only catch it when PHP throws it.
				$log_message = &#039;PHP Fatal error (&#039;.get_class($e).&#039;) has occurred during encryption. Error Message: &#039;.$e-&gt;getMessage().&#039; (Code: &#039;.$e-&gt;getCode().&#039;, line &#039;.$e-&gt;getLine().&#039; in &#039;.$e-&gt;getFile().&#039;)&#039;;
				UpdraftPlus_Manipulation_Functions::error_log($log_message);
				// @codingStandardsIgnoreLine
				$log_message .= &#039; Backtrace: &#039;.str_replace(array(ABSPATH, &quot;\n&quot;), array(&#039;&#039;, &#039;, &#039;), $e-&gt;getTraceAsString());
				$updraftplus-&gt;log($log_message);
				/* translators: 1: Exception class, 2: Exception message */
				$updraftplus-&gt;log(sprintf(__(&#039;A PHP fatal error (%1$s) has occurred: %2$s&#039;, &#039;updraftplus&#039;), get_class($e), $e-&gt;getMessage()), &#039;error&#039;);
				die();
			}
			if (null === $result) return basename($file);
			return $result;
		} else {
			return basename($file);
		}
	}

	/**
	 * Close the database file currently being written
	 *
	 * @return Boolean
	 */
	private function backup_db_close() {
		return $this-&gt;dbhandle_isgz ? gzclose($this-&gt;dbhandle) : fclose($this-&gt;dbhandle);
	}

	/**
	 * Open a file, store its file handle, and reset the class variable db_current_raw_bytes back to zero.
	 *
	 * @param String  $file     Full path to the file to open
	 * @param Boolean $allow_gz	Use gzopen() if available, instead of fopen()
	 * @param Boolean $append	Use append mode for writing
	 *
	 * @return Resource|Boolean - the opened file handle, or false for an error
	 */
	public function backup_db_open($file, $allow_gz = true, $append = false) {
		$mode = $append ? &#039;ab&#039; : &#039;w&#039;;
		if ($allow_gz &amp;&amp; function_exists(&#039;gzopen&#039;)) {
			$this-&gt;dbhandle = gzopen($file, $mode);
			$this-&gt;dbhandle_isgz = true;
		} else {
			$this-&gt;dbhandle = fopen($file, $mode);
			$this-&gt;dbhandle_isgz = false;
		}
		if (false === $this-&gt;dbhandle) {
			global $updraftplus;
			$updraftplus-&gt;log(&quot;ERROR: $file: Could not open the backup file for writing (mode: $mode)&quot;);
			$updraftplus-&gt;log($file.&quot;: &quot;.__(&quot;Could not open the backup file for writing&quot;, &#039;updraftplus&#039;), &#039;error&#039;);
		}
		$this-&gt;db_current_raw_bytes = 0;
		return $this-&gt;dbhandle;
	}

	/**
	 * Adds a line to the database backup
	 *
	 * @param String $write_line - the line to write
	 *
	 * @return Integer|Boolean - the number of octets written, or false for a failure (as returned by gzwrite() / fwrite)
	 */
	private function stow($write_line) {

		if (&#039;&#039; === $write_line) return 0;

		$write_function = $this-&gt;dbhandle_isgz ? &#039;gzwrite&#039; : &#039;fwrite&#039;;

		if (false == ($ret = call_user_func($write_function, $this-&gt;dbhandle, $write_line))) {
			$this-&gt;log_with_db_occasionally(&quot;There was an error writing a line to the backup file: $write_line&quot;);
		}

		$this-&gt;db_current_raw_bytes += strlen($write_line);

		return $ret;
	}

	/**
	 * Stow the database backup header
	 */
	private function backup_db_header() {

		global $updraftplus;
		$wp_version = $updraftplus-&gt;get_wordpress_version();
		$mysql_version = $this-&gt;wpdb_obj-&gt;get_var(&#039;SELECT VERSION()&#039;);
		if (&#039;&#039; == $mysql_version) $mysql_version = $this-&gt;wpdb_obj-&gt;db_version();
		$server_software = UpdraftPlus_Manipulation_Functions::fetch_superglobal(&#039;server&#039;, &#039;SERVER_SOFTWARE&#039;, &#039;&#039;);

		if (&#039;wp&#039; == $this-&gt;whichdb) {
			$wp_upload_dir = wp_upload_dir();
			$this-&gt;stow(&quot;# WordPress MySQL database backup\n&quot;);
			$this-&gt;stow(&quot;# Created by UpdraftPlus version &quot;.$updraftplus-&gt;version.&quot; (https://updraftplus.com)\n&quot;);
			$this-&gt;stow(&quot;# WordPress Version: $wp_version, running on PHP &quot;.phpversion().&quot; (&quot;.$server_software.&quot;), MySQL $mysql_version\n&quot;);
			$this-&gt;stow(&quot;# Backup of: &quot;.untrailingslashit(site_url()).&quot;\n&quot;);
			$this-&gt;stow(&quot;# Home URL: &quot;.untrailingslashit(home_url()).&quot;\n&quot;);
			$this-&gt;stow(&quot;# Content URL: &quot;.untrailingslashit(content_url()).&quot;\n&quot;);
			$this-&gt;stow(&quot;# Uploads URL: &quot;.untrailingslashit($wp_upload_dir[&#039;baseurl&#039;]).&quot;\n&quot;);
			$this-&gt;stow(&quot;# Table prefix: &quot;.$this-&gt;table_prefix_raw.&quot;\n&quot;);
			$this-&gt;stow(&quot;# Filtered table prefix: &quot;.$this-&gt;table_prefix.&quot;\n&quot;);
			$this-&gt;stow(&quot;# ABSPATH: &quot;.trailingslashit(ABSPATH).&quot;\n&quot;);
			$this-&gt;stow(&quot;# UpdraftPlus plugin slug: &quot;.UPDRAFTPLUS_PLUGIN_SLUG.&quot;\n&quot;);
			$this-&gt;stow(&quot;# Site info: multisite=&quot;.(is_multisite() ? &#039;1&#039; : &#039;0&#039;).&quot;\n&quot;);

			if (is_multisite()) {
				// we&#039;re going to use the fallback function wp_get_sites (for older version).
				if (function_exists(&#039;get_sites&#039;) &amp;&amp; class_exists(&#039;WP_Site_Query&#039;)) {
					$network_sites = get_sites();
				} elseif (function_exists(&#039;wp_get_sites&#039;)) {
					$network_sites = wp_get_sites();// phpcs:ignore WordPress.WP.DeprecatedFunctions.wp_get_sitesFound -- This function was only intended for backward compatibility with versions below 4.6.
				}

				if ($network_sites) {
					$multisite_data = array();
					foreach ($network_sites as $site) {
						// get_sites() gives $site in object form whereas wp_get_sites() gives sites in array form.
						$site = (array) $site;
						$blog_id = intval($site[&#039;blog_id&#039;]);

						$switched = switch_to_blog($blog_id);
						$wp_upload_dir = wp_upload_dir();
						$multisite_data[] = array(
							&#039;blog_id&#039; =&gt; $blog_id,
							&#039;domain&#039; =&gt; $site[&#039;domain&#039;],
							&#039;path&#039; =&gt; $site[&#039;path&#039;],
							&#039;siteurl&#039; =&gt; untrailingslashit(site_url()),
							&#039;home&#039; =&gt; untrailingslashit(home_url()),
							&#039;uploads_url&#039; =&gt; $wp_upload_dir[&#039;baseurl&#039;],
						);
						if ($switched) restore_current_blog();
					}
					$this-&gt;stow(&quot;# Site info: multisite_data=&quot;.json_encode($multisite_data).&quot;\n&quot;);
					if (function_exists(&#039;get_main_site_id&#039;)) $this-&gt;stow(&quot;# Site info: multisite_main_site_id=&quot;.intval(get_main_site_id()).&quot;\n&quot;);
				}
			}
			$this-&gt;stow(&quot;# Site info: sql_mode=&quot;.$this-&gt;wpdb_obj-&gt;get_var(&#039;SELECT @@SESSION.sql_mode&#039;).&quot;\n&quot;);

			add_filter(&#039;updraftplus_backup_db_header_site_info&#039;, array($this, &#039;backup_db_header_site_info_woocommerce&#039;));

			// This filter allows a user to add extra information about site info.
			if (array() !== ($site_info = apply_filters(&#039;updraftplus_backup_db_header_site_info&#039;, array()))) {
				foreach ($site_info as $info) {
					$this-&gt;stow(&quot;# Site info: &quot;.$info.&quot;\n&quot;);
				}
			}

			$this-&gt;stow(&quot;# Site info: end\n&quot;);
		} else {
			$this-&gt;stow(&quot;# MySQL database backup (supplementary database &quot;.$this-&gt;whichdb.&quot;)\n&quot;);
			$this-&gt;stow(&quot;# Created by UpdraftPlus version &quot;.$updraftplus-&gt;version.&quot; (https://updraftplus.com)\n&quot;);
			$this-&gt;stow(&quot;# WordPress Version: $wp_version, running on PHP &quot;.phpversion().&quot; (&quot;.$server_software.&quot;), MySQL $mysql_version\n&quot;);
			$this-&gt;stow(&quot;# &quot;.sprintf(&#039;External database: (%s)&#039;, $this-&gt;dbinfo[&#039;user&#039;].&#039;@&#039;.$this-&gt;dbinfo[&#039;host&#039;].&#039;/&#039;.$this-&gt;dbinfo[&#039;name&#039;]).&quot;\n&quot;);
			$this-&gt;stow(&quot;# Backup created by: &quot;.untrailingslashit(site_url()).&quot;\n&quot;);
			$this-&gt;stow(&quot;# Table prefix: &quot;.$this-&gt;table_prefix_raw.&quot;\n&quot;);
			$this-&gt;stow(&quot;# Filtered table prefix: &quot;.$this-&gt;table_prefix.&quot;\n&quot;);
		}

		$label = $updraftplus-&gt;jobdata_get(&#039;label&#039;);
		if (!empty($label)) $this-&gt;stow(&quot;# Label: $label\n&quot;);

		$this-&gt;stow(&quot;\n# Generated: &quot;.gmdate(&quot;l j. F Y H:i T&quot;).&quot;\n&quot;);
		$this-&gt;stow(&quot;# Hostname: &quot;.$this-&gt;dbinfo[&#039;host&#039;].&quot;\n&quot;);
		$this-&gt;stow(&quot;# Database: &quot;.UpdraftPlus_Manipulation_Functions::backquote($this-&gt;dbinfo[&#039;name&#039;]).&quot;\n&quot;);

		if (!empty($this-&gt;skipped_tables[$this-&gt;whichdb])) {
			if (&#039;wp&#039; == $this-&gt;whichdb) {
				$this-&gt;stow(&quot;# Skipped tables: &quot; . implode(&#039;, &#039;, $this-&gt;skipped_tables[&#039;wp&#039;]).&quot;\n&quot;);
			} elseif (isset($this-&gt;skipped_tables[$this-&gt;dbinfo[&#039;name&#039;]])) {
				$this-&gt;stow(&quot;# Skipped tables: &quot; . implode(&#039;, &#039;, $this-&gt;skipped_tables[$this-&gt;dbinfo[&#039;name&#039;]]).&quot;\n&quot;);
			}
		}

		$this-&gt;stow(&quot;# --------------------------------------------------------\n&quot;);

		$this-&gt;stow(&quot;/*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */;\n&quot;);
		$this-&gt;stow(&quot;/*!40101 SET @OLD_CHARACTER_SET_RESULTS=@@CHARACTER_SET_RESULTS */;\n&quot;);
		$this-&gt;stow(&quot;/*!40101 SET @OLD_COLLATION_CONNECTION=@@COLLATION_CONNECTION */;\n&quot;);
		// N.B. Setting this as the mode matches the export behaviour of both mysqldump and phpMyAdmin
		$this-&gt;stow(&quot;/*!40101 SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE=&#039;NO_AUTO_VALUE_ON_ZERO&#039; */;\n&quot;);
		$this-&gt;stow(&quot;/*!40101 SET NAMES &quot;.$updraftplus-&gt;get_connection_charset($this-&gt;wpdb_obj).&quot; */;\n&quot;);
		$this-&gt;stow(&quot;/*!40101 SET foreign_key_checks = 0 */;\n\n&quot;);

		// This filter allows a user to add their own arbitrary content.
		if (false !== ($header_append = apply_filters(&#039;updraftplus_backup_db_header_append&#039;, false))) {
			$this-&gt;stow($header_append);
		}
		
	}

	/**
	 * This function recursively packs the zip, dereferencing symlinks but packing into a single-parent tree for universal unpacking
	 *
	 * @param String  $fullpath              Full path
	 * @param String  $use_path_when_storing Controls the path to use when storing in the zip file
	 * @param String  $original_fullpath     Original path
	 * @param Integer $startlevels           How deep within the directory structure the recursive operation has gone
	 * @param Array   $exclude               passed by reference so that we can remove elements as they are matched - saves time checking against already-dealt-with objects]
	 * @return Boolean
	 */
	private function makezip_recursive_add($fullpath, $use_path_when_storing, $original_fullpath, $startlevels, &amp;$exclude) {

		global $updraftplus;

		// Only BinZip supports symlinks. This means that as a consistent outcome, the only think that can be done with directory symlinks is either a) potentially duplicate the data or b) skip it. Whilst with internal WP entities (e.g. plugins) we definitely want the data, in the case of user-selected directories, we assume the user knew what they were doing when they chose the directory - i.e. we can skip symlink-accessed data that&#039;s outside.
		if (is_link($fullpath) &amp;&amp; is_dir($fullpath) &amp;&amp; &#039;more&#039; == $this-&gt;whichone) {
			$updraftplus-&gt;log(&quot;Directory symlink encounted in more files backup: $use_path_when_storing -&gt; &quot;.readlink($fullpath).&quot;: skipping&quot;);
			return true;
		}

		static $updraft_dir_realpath;

		$updraft_dir_realpath = realpath($this-&gt;updraft_dir);

		// De-reference. Important to do to both, because on Windows only doing it to one can make them non-equal, where they were previously equal - something which we later rely upon
		$fullpath = realpath($fullpath);
		$original_fullpath = realpath($original_fullpath);

		// Is the place we&#039;ve ended up above the original base? That leads to infinite recursion
		if (($fullpath !== $original_fullpath &amp;&amp; strpos($original_fullpath, $fullpath) === 0) || ($original_fullpath == $fullpath &amp;&amp; ((1== $startlevels &amp;&amp; strpos($use_path_when_storing, &#039;/&#039;) !== false) || (2 == $startlevels &amp;&amp; substr_count($use_path_when_storing, &#039;/&#039;) &gt;1)))) {
			$updraftplus-&gt;log(&quot;Infinite recursion: symlink led us to $fullpath, which is within $original_fullpath&quot;);
			$updraftplus-&gt;log(__(&quot;Infinite recursion: consult your log for more information&quot;, &#039;updraftplus&#039;), &#039;error&#039;);
			return false;
		}

		// This is sufficient for the ones we have exclude options for - uploads, others, wpcore
		$stripped_storage_path = (1 == $startlevels) ? $use_path_when_storing : substr($use_path_when_storing, strpos($use_path_when_storing, &#039;/&#039;) + 1);
		if (false !== ($fkey = array_search($stripped_storage_path, $exclude))) {
			$updraftplus-&gt;log(&quot;Entity excluded by configuration option: $stripped_storage_path&quot;);
			unset($exclude[$fkey]);
			return true;
		}

		$if_altered_since = $this-&gt;makezip_if_altered_since;

		if (is_file($fullpath)) {
			if (!empty($this-&gt;excluded_extensions) &amp;&amp; $this-&gt;is_entity_excluded_by_extension($fullpath)) {
				$updraftplus-&gt;log(&quot;Entity excluded by configuration option (extension): &quot;.basename($fullpath));
			} elseif (!empty($this-&gt;excluded_prefixes) &amp;&amp; $this-&gt;is_entity_excluded_by_prefix($fullpath)) {
				$updraftplus-&gt;log(&quot;Entity excluded by configuration option (prefix): &quot;.basename($fullpath));
			} elseif (!empty($this-&gt;excluded_wildcards) &amp;&amp; $this-&gt;is_entity_excluded_by_wildcards(basename($fullpath))) {
				$updraftplus-&gt;log(&quot;Entity excluded by configuration option (wildcards): &quot;.basename($fullpath));
			} elseif (apply_filters(&#039;updraftplus_exclude_file&#039;, false, $fullpath)) {
				$updraftplus-&gt;log(&quot;Entity excluded by filter: &quot;.basename($fullpath));
			} elseif (is_readable($fullpath)) {
				$mtime = filemtime($fullpath);
				$key = ($fullpath == $original_fullpath) ? ((2 == $startlevels) ? $use_path_when_storing : $this-&gt;basename($fullpath)) : $use_path_when_storing.&#039;/&#039;.$this-&gt;basename($fullpath);
				if ($mtime &gt; 0 &amp;&amp; $mtime &gt; $if_altered_since) {
					$this-&gt;zipfiles_batched[$fullpath] = $key;
					$this-&gt;makezip_recursive_batchedbytes += @filesize($fullpath);// phpcs:ignore Generic.PHP.NoSilencedErrors.Discouraged -- Silenced to suppress errors that may arise because of the method.
					// @touch($zipfile);
				} else {
					$this-&gt;zipfiles_skipped_notaltered[$fullpath] = $key;
				}
			} else {
				$updraftplus-&gt;log(&quot;$fullpath: unreadable file&quot;);
				/* translators: %s: File path */
				$updraftplus-&gt;log(sprintf(__(&quot;%s: unreadable file - could not be backed up (check the file permissions and ownership)&quot;, &#039;updraftplus&#039;), $fullpath), &#039;warning&#039;);
			}
		} elseif (is_dir($fullpath)) {
			if ($fullpath == $updraft_dir_realpath) {
				$updraftplus-&gt;log(&quot;Skip directory (UpdraftPlus backup directory): $use_path_when_storing&quot;);
				return true;
			}

			if (apply_filters(&#039;updraftplus_exclude_directory&#039;, false, $fullpath, $use_path_when_storing)) {
				$updraftplus-&gt;log(&quot;Skip filtered directory: $use_path_when_storing&quot;);
				return true;
			}

			if (file_exists($fullpath.&#039;/.donotbackup&#039;)) {
				$updraftplus-&gt;log(&quot;Skip directory (.donotbackup file found): $use_path_when_storing&quot;);
				return true;
			}

			if (!isset($this-&gt;existing_files[$use_path_when_storing])) $this-&gt;zipfiles_dirbatched[] = $use_path_when_storing;
			
			if (!$dir_handle = @opendir($fullpath)) {// phpcs:ignore Generic.PHP.NoSilencedErrors.Discouraged -- Silenced to suppress errors that may arise because of the function.
				$updraftplus-&gt;log(&quot;Failed to open directory: $fullpath&quot;);
				/* translators: %s: Directory path */
				$updraftplus-&gt;log(sprintf(__(&quot;Failed to open directory (check the file permissions and ownership): %s&quot;, &#039;updraftplus&#039;), $fullpath), &#039;error&#039;);
				return false;
			}

			while (false !== ($e = readdir($dir_handle))) {
				if (&#039;.&#039; == $e || &#039;..&#039; == $e) continue;

				if (is_link($fullpath.&#039;/&#039;.$e)) {

					$deref = realpath($fullpath.&#039;/&#039;.$e);

					if (false === $deref) {
						$updraftplus-&gt;log(&quot;$fullpath/$e: unfollowable link&quot;);
						$updraftplus-&gt;log(
							sprintf(
								/* translators: 1: File path, 2: Readlink output */
								__(&#039;%1$s: unfollowable link - could not be followed to back up (readlink=%2$s).&#039;, &#039;updraftplus&#039;),
								$use_path_when_storing.&#039;/&#039;.$e,
							readlink($fullpath.&#039;/&#039;.$e)).&#039; &#039;.
							__(&quot;Possible causes include that the link points to an invalid or inaccessible location.&quot;, &#039;updraftplus&#039;),
							&#039;warning&#039;,
						&quot;unrlink-$e&quot;);
					} elseif (is_file($deref)) {
						$use_stripped = $stripped_storage_path.&#039;/&#039;.$e;
						if (false !== ($fkey = array_search($use_stripped, $exclude))) {
							$updraftplus-&gt;log(&quot;Entity excluded by configuration option: $use_stripped&quot;);
							unset($exclude[$fkey]);
						} elseif (!empty($this-&gt;excluded_extensions) &amp;&amp; $this-&gt;is_entity_excluded_by_extension($e)) {
							$updraftplus-&gt;log(&quot;Entity excluded by configuration option (extension): $use_stripped&quot;);
						} elseif (!empty($this-&gt;excluded_prefixes) &amp;&amp; $this-&gt;is_entity_excluded_by_prefix($e)) {
							$updraftplus-&gt;log(&quot;Entity excluded by configuration option (prefix): $use_stripped&quot;);
						} elseif (!empty($this-&gt;excluded_wildcards) &amp;&amp; $this-&gt;is_entity_excluded_by_wildcards($use_stripped)) {
							$updraftplus-&gt;log(&quot;Entity excluded by configuration option (wildcards): $use_stripped&quot;);
						} elseif (apply_filters(&#039;updraftplus_exclude_file&#039;, false, $deref, $use_stripped)) {
							$updraftplus-&gt;log(&quot;Entity excluded by filter: $use_stripped&quot;);
						} elseif (is_readable($deref)) {
							$mtime = filemtime($deref);
							if ($mtime &gt; 0 &amp;&amp; $mtime &gt; $if_altered_since) {
								$this-&gt;zipfiles_batched[$deref] = $use_path_when_storing.&#039;/&#039;.$e;
								$this-&gt;makezip_recursive_batchedbytes += @filesize($deref);// phpcs:ignore Generic.PHP.NoSilencedErrors.Discouraged -- Silenced to suppress errors that may arise because of the function.
								// @touch($zipfile);
							} else {
								$this-&gt;zipfiles_skipped_notaltered[$deref] = $use_path_when_storing.&#039;/&#039;.$e;
							}
						} else {
							$updraftplus-&gt;log(&quot;$deref: unreadable file (de-referenced from the link $e in $fullpath)&quot;);
							/* translators: %s: File path */
							$updraftplus-&gt;log(sprintf(__(&quot;%s: unreadable file - could not be backed up&quot;, &#039;updraftplus&#039;), $deref), &#039;warning&#039;);
						}
					} elseif (is_dir($deref)) {
						$this-&gt;symlink_reversals[$deref] = $fullpath.&#039;/&#039;.$e;
						$this-&gt;makezip_recursive_add($deref, $use_path_when_storing.&#039;/&#039;.$e, $original_fullpath, $startlevels, $exclude);
					}
				} elseif (is_file($fullpath.&#039;/&#039;.$e)) {
					$use_stripped = $stripped_storage_path.&#039;/&#039;.$e;
					if (false !== ($fkey = array_search($use_stripped, $exclude))) {
						$updraftplus-&gt;log(&quot;Entity excluded by configuration option: $use_stripped&quot;);
						unset($exclude[$fkey]);
					} elseif (!empty($this-&gt;excluded_extensions) &amp;&amp; $this-&gt;is_entity_excluded_by_extension($e)) {
						$updraftplus-&gt;log(&quot;Entity excluded by configuration option (extension): $use_stripped&quot;);
					} elseif (!empty($this-&gt;excluded_prefixes) &amp;&amp; $this-&gt;is_entity_excluded_by_prefix($e)) {
						$updraftplus-&gt;log(&quot;Entity excluded by configuration option (prefix): $use_stripped&quot;);
					} elseif (!empty($this-&gt;excluded_wildcards) &amp;&amp; $this-&gt;is_entity_excluded_by_wildcards($use_stripped)) {
						$updraftplus-&gt;log(&quot;Entity excluded by configuration option (wildcards): $use_stripped&quot;);
					} elseif (apply_filters(&#039;updraftplus_exclude_file&#039;, false, $fullpath.&#039;/&#039;.$e)) {
						$updraftplus-&gt;log(&quot;Entity excluded by filter: $use_stripped&quot;);
					} elseif (is_readable($fullpath.&#039;/&#039;.$e)) {
						$mtime = filemtime($fullpath.&#039;/&#039;.$e);
						if ($mtime &gt; 0 &amp;&amp; $mtime &gt; $if_altered_since) {
							$this-&gt;zipfiles_batched[$fullpath.&#039;/&#039;.$e] = $use_path_when_storing.&#039;/&#039;.$e;
							$this-&gt;makezip_recursive_batchedbytes += @filesize($fullpath.&#039;/&#039;.$e);// phpcs:ignore Generic.PHP.NoSilencedErrors.Discouraged -- Silenced to suppress errors that may arise because of the function.
						} else {
							$this-&gt;zipfiles_skipped_notaltered[$fullpath.&#039;/&#039;.$e] = $use_path_when_storing.&#039;/&#039;.$e;
						}
					} else {
						$updraftplus-&gt;log(&quot;$fullpath/$e: unreadable file&quot;);
						/* translators: %s: File path */
						$updraftplus-&gt;log(sprintf(__(&quot;%s: unreadable file - could not be backed up&quot;, &#039;updraftplus&#039;), $use_path_when_storing.&#039;/&#039;.$e), &#039;warning&#039;, &quot;unrfile-$e&quot;);
					}
				} elseif (is_dir($fullpath.&#039;/&#039;.$e)) {
					$use_stripped = $stripped_storage_path.&#039;/&#039;.$e;
					if (&#039;wpcore&#039; == $this-&gt;whichone &amp;&amp; &#039;updraft&#039; == $e &amp;&amp; basename($use_path_when_storing) == &#039;wp-content&#039; &amp;&amp; (!defined(&#039;UPDRAFTPLUS_WPCORE_INCLUDE_UPDRAFT_DIRS&#039;) || !UPDRAFTPLUS_WPCORE_INCLUDE_UPDRAFT_DIRS)) {
						// This test, of course, won&#039;t catch everything - it just aims to make things better by default
						$updraftplus-&gt;log(&quot;Directory excluded for looking like a sub-site&#039;s internal UpdraftPlus directory (enable by defining UPDRAFTPLUS_WPCORE_INCLUDE_UPDRAFT_DIRS): &quot;.$use_path_when_storing.&#039;/&#039;.$e);
					} elseif (!empty($this-&gt;excluded_wildcards) &amp;&amp; $this-&gt;is_entity_excluded_by_wildcards($use_stripped)) {
						$updraftplus-&gt;log(&quot;Entity excluded by configuration option (wildcards): $use_stripped&quot;);
					} else {
						// no need to add_empty_dir here, as it gets done when we recurse
						$this-&gt;makezip_recursive_add($fullpath.&#039;/&#039;.$e, $use_path_when_storing.&#039;/&#039;.$e, $original_fullpath, $startlevels, $exclude);
					}
				}
			}
			closedir($dir_handle);
		} else {
			$updraftplus-&gt;log(&quot;Unexpected: path ($use_path_when_storing) fails both is_file() and is_dir()&quot;);
		}

		return true;

	}

	/**
	 * Get a list of excluded extensions
	 *
	 * @param Array $exclude - settings passed in
	 *
	 * @return Array
	 */
	private function get_excluded_extensions($exclude) {
		if (!is_array($exclude)) $exclude = array();
		$exclude_extensions = array();
		foreach ($exclude as $ex) {
			if (preg_match(&#039;/^ext:(.+)$/i&#039;, $ex, $matches)) {
				$exclude_extensions[] = strtolower($matches[1]);
			}
		}

		if (defined(&#039;UPDRAFTPLUS_EXCLUDE_EXTENSIONS&#039;)) {
			$exclude_from_define = explode(&#039;,&#039;, UPDRAFTPLUS_EXCLUDE_EXTENSIONS);
			foreach ($exclude_from_define as $ex) {
				$exclude_extensions[] = strtolower(trim($ex));
			}
		}

		return $exclude_extensions;
	}

	/**
	 * Get a list of excluded prefixes
	 *
	 * @param Array $exclude - settings passed in
	 *
	 * @return Array - each is listed in lower case
	 */
	private function get_excluded_prefixes($exclude) {
		if (!is_array($exclude)) $exclude = array();
		$exclude_prefixes = array();
		foreach ($exclude as $pref) {
			if (preg_match(&#039;/^prefix:(.+)$/i&#039;, $pref, $matches)) {
				$exclude_prefixes[] = strtolower($matches[1]);
			}
		}
		return $exclude_prefixes;
	}

	/**
	 * List all the wildcard patterns from the given excluded items
	 *
	 * @param Array $exclude the list of excluded items which may contain not just wildcard patterns but also specific file/directory names as well
	 *
	 * $exclude argument may contains data in an array format like below:
	 *     [
	 *         &quot;snapshots&quot; // definitely not a wildcard parttern, this could be directories/files named `snapshots` which are located in the root/parent directory
	 *         &quot;2021/03/image.jpg&quot;, // not a wildcard parttern, this could be files/directories named `image.jpg` which are located in the 2021/03/ directory
	 *         &quot;ext:zip&quot;, // not a wildcard pattern, this is to exclude all files that end with `zip` extension
	 *         &quot;prefix:file-&quot;, // not a wildcard pattern, this is to exclude all files that begin with `file-` prefix
	 *         &quot;2021/04&quot;, // not a wildcard pattern, this is to exclude all files/directories which are located in the 2021/04 directory
	 *         &quot;backup*&quot;, // wildcard pattern that excludes all files/directories beginning with `backup` in the root/parent directory
	 *         &quot;2021/*optimise*&quot;, // wildcard pattern that excludes all files/directories that have `optimise` anywhere in their names in the `2021` directory
	 *         &quot;2021/04/*.tmp&quot; // wildcard pattern that excludes all files/directories ending with `optimise` anywhere in their names in the `2021/04` directory
	 *     ]
	 *
	 * @return Array an array of wildcard patterns
	 *
	 * After the $exclude has gone through the regex parsing step, only excluded items containing valid wildcard patterns got captured and will return them in an array in a format like below:
	 *
	 *     [
	 *         [
	 *             &quot;directory_path&quot; =&gt; &quot;&quot;,
	 *             &quot;pattern&quot; =&gt; &quot;backup*&quot;
	 *         ],
	 *         [
	 *             &quot;directory_path&quot; =&gt; &quot;2021\&quot;,
	 *             &quot;pattern&quot; =&gt; &quot;*optimise*&quot;
	 *         ],
	 *         [
	 *             &quot;directory_path&quot; =&gt; &quot;2021\04\&quot;,
	 *             &quot;pattern&quot; =&gt; &quot;*.tmp&quot;
	 *         ]
	 *     ]
	 */
	private function get_excluded_wildcards($exclude) {
		if (!is_array($exclude)) $exclude = array();
		$excluded_wildcards = array();
		foreach ($exclude as $wch) {
			// https://regex101.com/r/dMFI0P/1/
			if (preg_match(&#039;#(.*(?&lt;!\\\)/)?(.*?(?&lt;!\\\)\*.*)#i&#039;, $wch, $matches)) {
				// the regex will make sure only excluded items containing valid wildcard patterns get captured, it will lookup for asterisk char(s) at the very end of the string right after the last path separator (if any). e.g. foo/bar/b*a*z
				$excluded_wildcards[] = array(
					// in case the excluded item has doubled separators (e.g. dir1//dir2//file) or if the user added a directory separator at the beginning then trim and/or replace them
					&#039;directory_path&#039; =&gt; preg_replace(array(&#039;/^[\/\s]*/&#039;, &#039;/\/\/*/&#039;, &#039;/[\/\s]*$/&#039;), array(&#039;&#039;, &#039;/&#039;, &#039;&#039;), $matches[1]),
					&#039;pattern&#039; =&gt; $matches[2]
				);
			}
		}
		return $excluded_wildcards;
	}

	/**
	 * Check whether or not the given entity(file/directory) is excluded from the backup by matching it against a set of wildcard patterns
	 *
	 * @param String $entity the file/directory&#039;s stripped path
	 * @return Boolean true if the entity is excluded, false otherwise
	 */
	private function is_entity_excluded_by_wildcards($entity) {
		$entity_basename = untrailingslashit($entity);
		$entity_basename = substr_replace($entity_basename, &#039;&#039;, 0, (false === strrpos($entity_basename, &#039;/&#039;) ? 0 : strrpos($entity_basename, &#039;/&#039;) + 1));
		foreach ($this-&gt;excluded_wildcards as $wch) {
			if (!is_array($wch) || empty($wch)) continue;
			if (substr_replace($entity, &#039;&#039;, (int) strrpos($entity, &#039;/&#039;), strlen($entity) - (int) strrpos($entity, &#039;/&#039;)) !== $wch[&#039;directory_path&#039;]) continue;
			if (&#039;*&#039; == substr($wch[&#039;pattern&#039;], -1, 1) &amp;&amp; &#039;*&#039; == substr($wch[&#039;pattern&#039;], 0, 1) &amp;&amp; strlen($wch[&#039;pattern&#039;]) &gt; 2) {
				$wch[&#039;pattern&#039;] = substr($wch[&#039;pattern&#039;], 1, strlen($wch[&#039;pattern&#039;])-2);
				$wch[&#039;pattern&#039;] = str_replace(&#039;\*&#039;, &#039;*&#039;, $wch[&#039;pattern&#039;]);
				if (strpos($entity_basename, $wch[&#039;pattern&#039;]) !== false) return true;
			} elseif (&#039;*&#039; == substr($wch[&#039;pattern&#039;], -1, 1) &amp;&amp; strlen($wch[&#039;pattern&#039;]) &gt; 1) {
				$wch[&#039;pattern&#039;] = substr($wch[&#039;pattern&#039;], 0, strlen($wch[&#039;pattern&#039;])-1);
				$wch[&#039;pattern&#039;] = str_replace(&#039;\*&#039;, &#039;*&#039;, $wch[&#039;pattern&#039;]);
				if (substr($entity_basename, 0, strlen($wch[&#039;pattern&#039;])) == $wch[&#039;pattern&#039;]) return true;
			} elseif (&#039;*&#039; == substr($wch[&#039;pattern&#039;], 0, 1) &amp;&amp; strlen($wch[&#039;pattern&#039;]) &gt; 1) {
				$wch[&#039;pattern&#039;] = substr($wch[&#039;pattern&#039;], 1);
				$wch[&#039;pattern&#039;] = str_replace(&#039;\*&#039;, &#039;*&#039;, $wch[&#039;pattern&#039;]);
				if (strlen($entity_basename) &gt;= strlen($wch[&#039;pattern&#039;]) &amp;&amp; substr($entity_basename, strlen($wch[&#039;pattern&#039;])*-1) == $wch[&#039;pattern&#039;]) return true;
			}
		}
		return false;
	}

	private function is_entity_excluded_by_extension($entity) {
		foreach ($this-&gt;excluded_extensions as $ext) {
			if (!$ext) continue;
			$eln = strlen($ext);
			if (strtolower(substr($entity, -$eln, $eln)) == $ext) return true;
		}
		return false;
	}

	private function is_entity_excluded_by_prefix($entity) {
		$entity = basename($entity);
		foreach ($this-&gt;excluded_prefixes as $pref) {
			if (!$pref) continue;
			$eln = strlen($pref);
			if (strtolower(substr($entity, 0, $eln)) == $pref) return true;
		}
		return false;
	}

	private function unserialize_gz_cache_file($file) {
		if (!$whandle = gzopen($file, &#039;r&#039;)) return false;
		global $updraftplus;
		$emptimes = 0;
		$var = &#039;&#039;;
		while (!gzeof($whandle)) {
			$bytes = @gzread($whandle, 1048576);// phpcs:ignore Generic.PHP.NoSilencedErrors.Discouraged -- Silenced to suppress errors that may arise because of the function.
			if (empty($bytes)) {
				$emptimes++;
				$updraftplus-&gt;log(&quot;Got empty gzread ($emptimes times)&quot;);
				if ($emptimes&gt;2) return false;
			} else {
				$var .= $bytes;
			}
		}
		gzclose($whandle);
		return $updraftplus-&gt;unserialize($var);
	}

	/**
	 * Make Zip File.
	 *
	 * @param Array|String $source               Caution: $source is allowed to be an array, not just a filename
	 * @param String	   $backup_file_basename Name of backup file
	 * @param String	   $whichone             Backup entity type (e.g. &#039;plugins&#039;)
	 * @param Boolean	   $retry_on_error       Set to retry upon error
	 * @return Boolean
	 */
	private function make_zipfile($source, $backup_file_basename, $whichone, $retry_on_error = true) {

		global $updraftplus;

		$original_index = $this-&gt;index;

		$itext = empty($this-&gt;index) ? &#039;&#039; : ($this-&gt;index+1);
		$destination_base = $backup_file_basename.&#039;-&#039;.$whichone.$itext.&#039;.zip.tmp&#039;;
		// $destination is the temporary file (ending in .tmp)
		$destination = $this-&gt;updraft_dir.&#039;/&#039;.$destination_base;

		// When to prefer PCL:
		// - We were asked to
		// - No zip extension present and no relevant method present
		// The zip extension check is not redundant, because method_exists segfaults some PHP installs, leading to support requests

		// We need meta-info about $whichone
		$backupable_entities = $updraftplus-&gt;get_backupable_file_entities(true, false);
		// This is only used by one corner-case in BinZip
		// $this-&gt;make_zipfile_source = (isset($backupable_entities[$whichone])) ? $backupable_entities[$whichone] : $source;
		$this-&gt;make_zipfile_source = (is_array($source) &amp;&amp; isset($backupable_entities[$whichone])) ? ((&#039;uploads&#039; == $whichone) ? dirname($backupable_entities[$whichone]) : $backupable_entities[$whichone]) : dirname($source);

		$this-&gt;existing_files = array();
		// Used for tracking compression ratios
		$this-&gt;existing_files_rawsize = 0;
		$this-&gt;existing_zipfiles_size = 0;

		// Enumerate existing files
		// Usually first_linked_index is zero; the exception being with more files, where previous zips&#039; contents are irrelevant
		for ($j = $this-&gt;first_linked_index; $j &lt;= $this-&gt;index; $j++) {
			$jtext = (0 == $j) ? &#039;&#039; : $j+1;
			// This is, in a non-obvious way, compatible with filenames which indicate increments
			// $j does not need to start at zero; it should start at the index which the current entity split at. However, this is not directly known, and can only be deduced from examining the filenames. And, for other indexes from before the current increment, the searched-for filename won&#039;t exist (even if there is no cloud storage). So, this indirectly results in the desired outcome when we start from $j=0.
			$examine_zip = $this-&gt;updraft_dir.&#039;/&#039;.$backup_file_basename.&#039;-&#039;.$whichone.$jtext.&#039;.zip&#039;.(($j == $this-&gt;index) ? &#039;.tmp&#039; : &#039;&#039;);

			// This comes from https://wordpress.org/support/topic/updraftplus-not-moving-all-files-to-remote-server - where it appears that the jobdata&#039;s record of the split was done (i.e. database write), but the *earlier* rename of the .tmp file was not done (i.e. I/O lost). i.e. In theory, this should be impossible; but, the sychnronicity apparently cannot be fully relied upon in some setups. The check for the index being one behind is being conservative - there&#039;s no inherent reason why it couldn&#039;t be done for other indexes.
			// Note that in this &#039;impossible&#039; case, no backup data was being lost - the design still ensures that the on-disk backup is fine. The problem was a gap in the sequence numbering of the zip files, leading to user confusion.
			// Other examples of this appear to be in HS#1001 and #1047
			if ($j != $this-&gt;index &amp;&amp; !file_exists($examine_zip)) {
				$alt_examine_zip = $this-&gt;updraft_dir.&#039;/&#039;.$backup_file_basename.&#039;-&#039;.$whichone.$jtext.&#039;.zip&#039;.(($j == $this-&gt;index - 1) ? &#039;.tmp&#039; : &#039;&#039;);
				if ($alt_examine_zip != $examine_zip &amp;&amp; file_exists($alt_examine_zip) &amp;&amp; is_readable($alt_examine_zip) &amp;&amp; filesize($alt_examine_zip)&gt;0) {
					$updraftplus-&gt;log(&quot;Looked-for zip file not found; but non-zero .tmp zip was, despite not being current index ($j != &quot;.$this-&gt;index.&quot; - renaming zip (assume previous resumption&#039;s IO was lost before kill)&quot;);
					if (rename($alt_examine_zip, $examine_zip)) {
						clearstatcache();
					} else {
						$updraftplus-&gt;log(&quot;Rename failed - backup zips likely to not have sequential numbers (does not affect backup integrity, but can cause user confusion)&quot;);
					}
				}
			}

			// If the file exists, then we should grab its index of files inside, and sizes
			// Then, when we come to write a file, we should check if it&#039;s already there, and only add if it is not
			if (file_exists($examine_zip) &amp;&amp; is_readable($examine_zip) &amp;&amp; filesize($examine_zip) &gt; 0) {

				// Do not use (which also means do not create) a manifest if the file is still a .tmp file, since this may not be complete. If we are in this place in the code from a resumption, creating a manifest here will mean the manifest becomes out-of-date if further files are added.
				$this-&gt;populate_existing_files_list_from_zip($examine_zip, substr($examine_zip, -4, 4) === &#039;.zip&#039;);

				// try_split is true if there have been no check-ins recently - or if it needs to be split anyway
				if ($j == $this-&gt;index) {
					if ($this-&gt;try_split) {
						if (filesize($examine_zip) &gt; 50*1048576) {
							// We could, as a future enhancement, save this back to the job data, if we see a case that needs it
							$this-&gt;zip_split_every = max(
								(int) $this-&gt;zip_split_every/2,
								UPDRAFTPLUS_SPLIT_MIN*1048576,
								min(filesize($examine_zip)-1048576, $this-&gt;zip_split_every)
							);
							$updraftplus-&gt;jobdata_set(&#039;split_every&#039;, (int) ($this-&gt;zip_split_every/1048576));
							$updraftplus-&gt;log(&quot;No check-in on last two runs; bumping index and reducing zip split to: &quot;.round($this-&gt;zip_split_every/1048576, 1).&quot; MB&quot;);
							$do_bump_index = true;
						}
						unset($this-&gt;try_split);
					} elseif (filesize($examine_zip) &gt; $this-&gt;zip_split_every) {
						$updraftplus-&gt;log(sprintf(&quot;Zip size is at/near split limit (%s MB / %s MB) - bumping index (from: %d)&quot;, filesize($examine_zip), round($this-&gt;zip_split_every/1048576, 1), $this-&gt;index));
						$do_bump_index = true;
					}
				}

			} elseif (file_exists($examine_zip)) {
				$updraftplus-&gt;log(&quot;Zip file already exists, but is not readable or was zero-sized; will remove: &quot;.basename($examine_zip));
				@unlink($examine_zip);// phpcs:ignore Generic.PHP.NoSilencedErrors.Discouraged -- Silenced to suppress errors that may arise if the file doesn&#039;t exist.
			} elseif ($updraftplus-&gt;is_uploaded(basename($examine_zip))) {
				$this-&gt;populate_existing_files_list_from_zip($examine_zip, true);
			}
		}

		$this-&gt;zip_last_ratio = ($this-&gt;existing_files_rawsize &gt; 0) ? ($this-&gt;existing_zipfiles_size/$this-&gt;existing_files_rawsize) : 1;

		$this-&gt;zipfiles_added = 0;
		$this-&gt;zipfiles_added_thisrun = 0;
		$this-&gt;zipfiles_dirbatched = array();
		$this-&gt;zipfiles_batched = array();
		$this-&gt;zipfiles_skipped_notaltered = array();
		$this-&gt;zipfiles_lastwritetime = time();
		$this-&gt;zip_basename = $this-&gt;updraft_dir.&#039;/&#039;.$backup_file_basename.&#039;-&#039;.$whichone;

		if (!empty($do_bump_index)) $this-&gt;bump_index();

		$error_occurred = false;

		// Store this in its original form
		// $this-&gt;source = $source;

		// Reset. This counter is used only with PcLZip, to decide if it&#039;s better to do it all-in-one
		$this-&gt;makezip_recursive_batchedbytes = 0;
		if (!is_array($source)) $source = array($source);

		$exclude = $updraftplus-&gt;get_exclude($whichone);

		$files_enumerated_at = $updraftplus-&gt;jobdata_get(&#039;files_enumerated_at&#039;);
		if (!is_array($files_enumerated_at)) $files_enumerated_at = array();
		$files_enumerated_at[$whichone] = time();
		$updraftplus-&gt;jobdata_set(&#039;files_enumerated_at&#039;, $files_enumerated_at);

		$this-&gt;makezip_if_altered_since = is_array($this-&gt;altered_since) ? (isset($this-&gt;altered_since[$whichone]) ? $this-&gt;altered_since[$whichone] : -1) : -1;

		// Reset
		$got_uploads_from_cache = false;

		// Uploads: can/should we get it back from the cache?
		// || &#039;others&#039; == $whichone
		if ((&#039;uploads&#039; == $whichone || &#039;others&#039; == $whichone) &amp;&amp; function_exists(&#039;gzopen&#039;) &amp;&amp; function_exists(&#039;gzread&#039;)) {
			$use_cache_files = false;
			$cache_file_base = $this-&gt;zip_basename.&#039;-cachelist-&#039;.$this-&gt;makezip_if_altered_since;
			// Cache file suffixes: -zfd.gz.tmp, -zfb.gz.tmp, -info.tmp, (possible)-zfs.gz.tmp
			if (file_exists($cache_file_base.&#039;-zfd.gz.tmp&#039;) &amp;&amp; file_exists($cache_file_base.&#039;-zfb.gz.tmp&#039;) &amp;&amp; file_exists($cache_file_base.&#039;-info.tmp&#039;)) {
				// Cache files exist; shall we use them?
				$mtime = filemtime($cache_file_base.&#039;-zfd.gz.tmp&#039;);
				// Require &lt; 30 minutes old
				if (time() - $mtime &lt; 1800) {
					$use_cache_files = true;
				}
				$any_failures = false;
				if ($use_cache_files) {
					$var = $this-&gt;unserialize_gz_cache_file($cache_file_base.&#039;-zfd.gz.tmp&#039;);
					if (is_array($var)) {
						$this-&gt;zipfiles_dirbatched = $var;
						$var = $this-&gt;unserialize_gz_cache_file($cache_file_base.&#039;-zfb.gz.tmp&#039;);
						if (is_array($var)) {
							$this-&gt;zipfiles_batched = $var;
							if (file_exists($cache_file_base.&#039;-info.tmp&#039;)) {
								$var = $updraftplus-&gt;unserialize(file_get_contents($cache_file_base.&#039;-info.tmp&#039;));
								if (is_array($var) &amp;&amp; isset($var[&#039;makezip_recursive_batchedbytes&#039;])) {
									$this-&gt;makezip_recursive_batchedbytes = $var[&#039;makezip_recursive_batchedbytes&#039;];
									if (file_exists($cache_file_base.&#039;-zfs.gz.tmp&#039;)) {
										$var = $this-&gt;unserialize_gz_cache_file($cache_file_base.&#039;-zfs.gz.tmp&#039;);
										if (is_array($var)) {
											$this-&gt;zipfiles_skipped_notaltered = $var;
										} else {
											$any_failures = true;
										}
									} else {
										$this-&gt;zipfiles_skipped_notaltered = array();
									}
								} else {
									$any_failures = true;
								}
							}
						} else {
							$any_failures = true;
						}
					} else {
						$any_failures = true;
					}
					if ($any_failures) {
						$updraftplus-&gt;log(&quot;Failed to recover file lists from existing cache files&quot;);
						// Reset it all
						$this-&gt;zipfiles_skipped_notaltered = array();
						$this-&gt;makezip_recursive_batchedbytes = 0;
						$this-&gt;zipfiles_batched = array();
						$this-&gt;zipfiles_dirbatched = array();
					} else {
						$updraftplus-&gt;log(&quot;File lists recovered from cache files; sizes: &quot;.count($this-&gt;zipfiles_batched).&quot;, &quot;.count($this-&gt;zipfiles_batched).&quot;, &quot;.count($this-&gt;zipfiles_skipped_notaltered).&quot;)&quot;);
						$got_uploads_from_cache = true;
					}
				}
			}
		}

		$time_counting_began = time();

		$this-&gt;excluded_extensions = $this-&gt;get_excluded_extensions($exclude);
		$this-&gt;excluded_prefixes = $this-&gt;get_excluded_prefixes($exclude);
		$this-&gt;excluded_wildcards = $this-&gt;get_excluded_wildcards($exclude);

		foreach ($source as $element) {
			// makezip_recursive_add($fullpath, $use_path_when_storing, $original_fullpath, $startlevels = 1, $exclude_array)
			if (&#039;uploads&#039; == $whichone) {
				if (empty($got_uploads_from_cache)) {
					$dirname = dirname($element);
					$basename = $this-&gt;basename($element);
					$add_them = $this-&gt;makezip_recursive_add($element, basename($dirname).&#039;/&#039;.$basename, $element, 2, $exclude);
				} else {
					$add_them = true;
				}
			} else {
				if (empty($got_uploads_from_cache)) {
					$add_them = $this-&gt;makezip_recursive_add($element, $this-&gt;basename($element), $element, 1, $exclude);
				} else {
					$add_them = true;
				}
			}
			if (is_wp_error($add_them) || false === $add_them) $error_occurred = true;
		}

		$time_counting_ended = time();

		// Cache the file scan, if it looks like it&#039;ll be useful
		// We use gzip to reduce the size as on hosts which limit disk I/O, the caching may make things worse
		// || &#039;others&#039; == $whichone
		if ((&#039;uploads&#039; == $whichone || &#039;others&#039; == $whichone) &amp;&amp; !$error_occurred &amp;&amp; function_exists(&#039;gzopen&#039;) &amp;&amp; function_exists(&#039;gzwrite&#039;)) {
			$cache_file_base = $this-&gt;zip_basename.&#039;-cachelist-&#039;.$this-&gt;makezip_if_altered_since;

			// Just approximate - we&#039;re trying to avoid an otherwise-unpredictable PHP fatal error. Caching only happens if file enumeration took a long time - so presumably there are very many.
			$memory_needed_estimate = 0;
			foreach ($this-&gt;zipfiles_batched as $k =&gt; $v) {
				$memory_needed_estimate += strlen($k)+strlen($v)+12;
			}

			// We haven&#039;t bothered to check if we just fetched the files from cache, as that shouldn&#039;t take a long time and so shouldn&#039;t trigger this
			// Let us suppose we need 15% overhead for gzipping

			$memory_limit = ini_get(&#039;memory_limit&#039;);
			$memory_usage = round(@memory_get_usage(false)/1048576, 1);// phpcs:ignore Generic.PHP.NoSilencedErrors.Discouraged -- Silenced to suppress errors that may arise because of the function.
			$memory_usage2 = round(@memory_get_usage(true)/1048576, 1);// phpcs:ignore Generic.PHP.NoSilencedErrors.Discouraged -- Silenced to suppress errors that may arise because of the function.
			
			if ($time_counting_ended-$time_counting_began &gt; 20 &amp;&amp; $updraftplus-&gt;verify_free_memory($memory_needed_estimate*0.15) &amp;&amp; $whandle = gzopen($cache_file_base.&#039;-zfb.gz.tmp&#039;, &#039;w&#039;)) {
				$updraftplus-&gt;log(&quot;File counting took a long time (&quot;.($time_counting_ended - $time_counting_began).&quot;s); will attempt to cache results (memory_limit: $memory_limit (used: {$memory_usage}M | {$memory_usage2}M), estimated uncompressed bytes: &quot;.round($memory_needed_estimate/1024, 1).&quot; Kb)&quot;);

				$buf = &#039;a:&#039;.count($this-&gt;zipfiles_batched).&#039;:{&#039;;
				foreach ($this-&gt;zipfiles_batched as $file =&gt; $add_as) {
					$k = addslashes($file);
					$v = addslashes($add_as);
					$buf .= &#039;s:&#039;.strlen($k).&#039;:&quot;&#039;.$k.&#039;&quot;;s:&#039;.strlen($v).&#039;:&quot;&#039;.$v.&#039;&quot;;&#039;;
					if (strlen($buf) &gt; 1048576) {
						gzwrite($whandle, $buf, strlen($buf));
						$buf = &#039;&#039;;
					}
				}
				$buf .= &#039;}&#039;;
				$final = gzwrite($whandle, $buf);
				unset($buf);

				if (!$final) {
					@unlink($cache_file_base.&#039;-zfb.gz.tmp&#039;);// phpcs:ignore Generic.PHP.NoSilencedErrors.Discouraged -- Silenced to suppress errors that may arise if the file doesn&#039;t exist.
					@gzclose($whandle);// phpcs:ignore Generic.PHP.NoSilencedErrors.Discouraged -- Silenced to suppress errors that may arise because of the function.
				} else {
					gzclose($whandle);
					if (!empty($this-&gt;zipfiles_skipped_notaltered)) {
						if ($shandle = gzopen($cache_file_base.&#039;-zfs.gz.tmp&#039;, &#039;w&#039;)) {
							if (!gzwrite($shandle, serialize($this-&gt;zipfiles_skipped_notaltered))) {
								$aborted_on_skipped = true;
							}
							gzclose($shandle);
						} else {
							$aborted_on_skipped = true;
						}
					}
					if (!empty($aborted_on_skipped)) {
						@unlink($cache_file_base.&#039;-zfs.gz.tmp&#039;);// phpcs:ignore Generic.PHP.NoSilencedErrors.Discouraged -- Silenced to suppress errors that may arise if the file doesn&#039;t exist.
						@unlink($cache_file_base.&#039;-zfb.gz.tmp&#039;);// phpcs:ignore Generic.PHP.NoSilencedErrors.Discouraged -- Silenced to suppress errors that may arise if the file doesn&#039;t exist.
					} else {
						$info_array = array(&#039;makezip_recursive_batchedbytes&#039; =&gt; $this-&gt;makezip_recursive_batchedbytes);
						if (!file_put_contents($cache_file_base.&#039;-info.tmp&#039;, serialize($info_array))) {
							@unlink($cache_file_base.&#039;-zfs.gz.tmp&#039;);// phpcs:ignore Generic.PHP.NoSilencedErrors.Discouraged -- Silenced to suppress errors that may arise if the file doesn&#039;t exist.
							@unlink($cache_file_base.&#039;-zfb.gz.tmp&#039;);// phpcs:ignore Generic.PHP.NoSilencedErrors.Discouraged -- Silenced to suppress errors that may arise if the file doesn&#039;t exist.
						}
						if ($dhandle = gzopen($cache_file_base.&#039;-zfd.gz.tmp&#039;, &#039;w&#039;)) {
							if (!gzwrite($dhandle, serialize($this-&gt;zipfiles_dirbatched))) {
								$aborted_on_dirbatched = true;
							}
							gzclose($dhandle);
						} else {
							$aborted_on_dirbatched = true;
						}
						if (!empty($aborted_on_dirbatched)) {
							// phpcs:disable Generic.PHP.NoSilencedErrors.Discouraged -- no error required if the file doesn&#039;t exist.
							@unlink($cache_file_base.&#039;-zfs.gz.tmp&#039;);
							@unlink($cache_file_base.&#039;-zfd.gz.tmp&#039;);
							@unlink($cache_file_base.&#039;-zfb.gz.tmp&#039;);
							@unlink($cache_file_base.&#039;-info.tmp&#039;);
						}
					}
				}
			}

/*
		Class variables that get altered:
		zipfiles_batched
		makezip_recursive_batchedbytes
		zipfiles_skipped_notaltered
		zipfiles_dirbatched
		Class variables that the result depends upon (other than the state of the filesystem):
		makezip_if_altered_since
		existing_files
		*/

		}

		// Any not yet dispatched? Under our present scheme, at this point nothing has yet been despatched. And since the enumerating of all files can take a while, we can at this point do a further modification check to reduce the chance of overlaps.
		// This relies on us *not* touch()ing the zip file to indicate to any resumption &#039;behind us&#039; that we&#039;re already here. Rather, we&#039;re relying on the combined facts that a) if it takes us a while to search the directory tree, then it should do for the one behind us too (though they&#039;ll have the benefit of cache, so could catch very fast) and b) we touch *immediately* after finishing the enumeration of the files to add.
		// $retry_on_error is here being used as a proxy for &#039;not the second time around, when there might be the remains of the file on the first time around&#039;
		if ($retry_on_error) $updraftplus-&gt;check_recent_modification($destination);
		// Here we&#039;re relying on the fact that both PclZip and ZipArchive will happily operate on an empty file. Note that BinZip *won&#039;t* (for that, may need a new strategy - e.g. add the very first file on its own, in order to &#039;lay down a marker&#039;)
		if (empty($do_bump_index)) touch($destination);

		if (count($this-&gt;zipfiles_dirbatched) &gt; 0 || count($this-&gt;zipfiles_batched) &gt; 0) {

			$updraftplus-&gt;log(sprintf(&quot;Total entities for the zip file: %d directories, %d files (%d skipped as non-modified), %s MB&quot;, count($this-&gt;zipfiles_dirbatched), count($this-&gt;zipfiles_batched), count($this-&gt;zipfiles_skipped_notaltered), round($this-&gt;makezip_recursive_batchedbytes/1048576, 1)));

			// No need to warn if we&#039;re going to retry anyway. (And if we get killed, the zip will be rescanned for its contents upon resumption).
			$warn_on_failures = ($retry_on_error) ? false : true;
			$add_them = $this-&gt;makezip_addfiles($warn_on_failures);

			if (is_wp_error($add_them)) {
				foreach ($add_them-&gt;get_error_messages() as $msg) {
					$updraftplus-&gt;log(&quot;Error returned from makezip_addfiles: &quot;.$msg);
				}
				$error_occurred = true;
			} elseif (false === $add_them) {
				$updraftplus-&gt;log(&quot;Error: makezip_addfiles returned false&quot;);
				$error_occurred = true;
			}

		}

		// Reset these variables because the index may have changed since we began

		$itext = empty($this-&gt;index) ? &#039;&#039; : $this-&gt;index+1;
		$destination_base = $backup_file_basename.&#039;-&#039;.$whichone.$itext.&#039;.zip.tmp&#039;;
		$destination = $this-&gt;updraft_dir.&#039;/&#039;.$destination_base;

		// ZipArchive::addFile sometimes fails - there&#039;s nothing when we expected something.
		// Did not used to have || $error_occurred here. But it is better to retry, than to simply warn the user to check his logs.
		if (((file_exists($destination) || $this-&gt;index == $original_index) &amp;&amp; @filesize($destination) &lt; 90 &amp;&amp; &#039;UpdraftPlus_ZipArchive&#039; == $this-&gt;use_zip_object) || ($error_occurred &amp;&amp; $retry_on_error)) {// phpcs:ignore Generic.PHP.NoSilencedErrors.Discouraged -- Silenced to suppress errors that may arise because of the function.
			// This can be made more sophisticated if feedback justifies it. Currently we just switch to PclZip. But, it may have been a BinZip failure, so we could then try ZipArchive if that is available. If doing that, make sure that an infinite recursion isn&#039;t made possible.
			$updraftplus-&gt;log(&quot;makezip_addfiles(&quot;.$this-&gt;use_zip_object.&quot;) apparently failed (file=&quot;.basename($destination).&quot;, type=$whichone, size=&quot;.filesize($destination).&quot;) - retrying with PclZip&quot;);
			$saved_zip_object = $this-&gt;use_zip_object;
			$this-&gt;use_zip_object = &#039;UpdraftPlus_PclZip&#039;;
			$ret = $this-&gt;make_zipfile($source, $backup_file_basename, $whichone, false);
			$this-&gt;use_zip_object = $saved_zip_object;
			return $ret;
		}

		// zipfiles_added &gt; 0 means that $zip-&gt;close() has been called. i.e. An attempt was made to add something: something _should_ be there.
		// Why return true even if $error_occurred may be set? 1) Because in that case, a warning has already been logged. 2) Because returning false causes an error to be logged, which means it&#039;ll all be retried again. Also 3) this has been the pattern of the code for a long time, and the algorithm has been proven in the real-world: don&#039;t change what&#039;s not broken.
		// (file_exists($destination) || $this-&gt;index == $original_index) might be an alternative to $this-&gt;zipfiles_added &gt; 0 - ? But, don&#039;t change what&#039;s not broken.
		if (false == $error_occurred || $this-&gt;zipfiles_added &gt; 0) {
			return true;
		} else {
			$updraftplus-&gt;log(&quot;makezip failure: zipfiles_added=&quot;.$this-&gt;zipfiles_added.&quot;, error_occurred=&quot;.$error_occurred.&quot; (method=&quot;.$this-&gt;use_zip_object.&quot;)&quot;);
			return false;
		}

	}

	/**
	 * This function is an ugly, conservative workaround for https://bugs.php.net/bug.php?id=62119. It does not aim to always work-around, but to ensure that nothing is made worse.
	 *
	 * @param String $element
	 *
	 * @return String
	 */
	private function basename($element) {
		$dirname = dirname($element);
		$basename_manual = preg_replace(&#039;#^[\\/]+#&#039;, &#039;&#039;, substr($element, strlen($dirname)));
		$basename = basename($element);
		if ($basename_manual != $basename) {
			$locale = setlocale(LC_CTYPE, &quot;0&quot;);
			if (&#039;C&#039; == $locale) {
				setlocale(LC_CTYPE, &#039;en_US.UTF8&#039;);
				$basename_new = basename($element);
				if ($basename_new == $basename_manual) $basename = $basename_new;
				setlocale(LC_CTYPE, $locale);
			}
		}
		return $basename;
	}

	/**
	 * Determine if a file should be stored without compression
	 *
	 * @param String $file - the filename
	 *
	 * @return Boolean
	 */
	private function file_should_be_stored_without_compression($file) {
		if (!is_array($this-&gt;extensions_to_not_compress)) return false;
		foreach ($this-&gt;extensions_to_not_compress as $ext) {
			$ext_len = strlen($ext);
			if (strtolower(substr($file, -$ext_len, $ext_len)) == $ext) return true;
		}
		return false;
	}

	/**
	 * This method will add a manifest file to the backup zip
	 *
	 * @param  String $whichone - the type of backup (e.g. &#039;plugins&#039;, &#039;themes&#039;)
	 *
	 * @return Boolean - success/failure status
	 */
	private function updraftplus_include_manifest($whichone) {
		global $updraftplus;

		$manifest_name = &quot;updraftplus-manifest.json&quot;;
		$manifest = trailingslashit($this-&gt;updraft_dir).$manifest_name;

		$updraftplus-&gt;log(sprintf(&quot;Creating file manifest ($manifest_name) for incremental backup (included: %d, skipped: %d)&quot;, count($this-&gt;zipfiles_batched), count($this-&gt;zipfiles_skipped_notaltered)));

		if (false === ($handle = fopen($manifest, &#039;w+&#039;))) return $updraftplus-&gt;log(&quot;Failed to open manifest file ($manifest_name)&quot;);

		$this-&gt;manifest_path = $manifest;

		$version = 1;

		$go_to_levels = array(
			&#039;plugins&#039; =&gt; 2,
			&#039;themes&#039; =&gt; 2,
			&#039;uploads&#039; =&gt; 3,
			&#039;others&#039; =&gt; 3
		);

		$go_to_levels = apply_filters(&#039;updraftplus_manifest_go_to_level&#039;, $go_to_levels, $whichone);

		$go_to_level = isset($go_to_levels[$whichone]) ? $go_to_levels[$whichone] : &#039;all&#039;;

		$directory = &#039;&#039;;

		if (&#039;more&#039; == $whichone) {
			foreach ($this-&gt;zipfiles_batched as $index =&gt; $dir) {
				$directory = &#039;&quot;directory&quot;:&quot;&#039; . dirname($index) . &#039;&quot;,&#039;;
			}
		}

		if (false === fwrite($handle, &#039;{&quot;version&quot;:&#039;.$version.&#039;,&quot;type&quot;:&quot;&#039;.$whichone.&#039;&quot;,&#039;.$directory.&#039;&quot;listed_levels&quot;:&quot;&#039;.$go_to_level.&#039;&quot;,&quot;contents&quot;:{&quot;directories&quot;:[&#039;)) $updraftplus-&gt;log(&quot;First write to manifest file failed ($manifest_name)&quot;);

		// First loop: find out which is the last entry, so that we don&#039;t write the comma after it
		$last_dir_index = false;
		foreach ($this-&gt;zipfiles_dirbatched as $index =&gt; $dir) {
			if (&#039;all&#039; !== $go_to_level &amp;&amp; substr_count($dir, &#039;/&#039;) &gt; $go_to_level - 1) continue;
			$last_dir_index = $index;
		}

		// Second loop: write out the entry
		foreach ($this-&gt;zipfiles_dirbatched as $index =&gt; $dir) {
			if (&#039;all&#039; !== $go_to_level &amp;&amp; substr_count($dir, &#039;/&#039;) &gt; $go_to_level - 1) continue;
			fwrite($handle, json_encode($dir).(($index != $last_dir_index) ? &#039;,&#039; : &#039;&#039;));
		}

		// Now do the same for files
		fwrite($handle, &#039;],&quot;files&quot;:[&#039;);

		$last_file_index = false;
		foreach ($this-&gt;zipfiles_batched as $store_as) {
			if (&#039;all&#039; !== $go_to_level &amp;&amp; substr_count($store_as, &#039;/&#039;) &gt; $go_to_level - 1) continue;
			$last_file_index = $store_as;
		}
		foreach ($this-&gt;zipfiles_skipped_notaltered as $store_as) {
			if (&#039;all&#039; !== $go_to_level &amp;&amp; substr_count($store_as, &#039;/&#039;) &gt; $go_to_level - 1) continue;
			$last_file_index = $store_as;
		}

		foreach ($this-&gt;zipfiles_batched as $store_as) {
			if (&#039;all&#039; !== $go_to_level &amp;&amp; substr_count($store_as, &#039;/&#039;) &gt; $go_to_level - 1) continue;
			fwrite($handle, json_encode($store_as).(($store_as != $last_file_index) ? &#039;,&#039; : &#039;&#039;));
		}

		foreach ($this-&gt;zipfiles_skipped_notaltered as $store_as) {
			if (&#039;all&#039; !== $go_to_level &amp;&amp; substr_count($store_as, &#039;/&#039;) &gt; $go_to_level - 1) continue;
			fwrite($handle, json_encode($store_as).(($store_as != $last_file_index) ? &#039;,&#039; : &#039;&#039;));
		}

		fwrite($handle, &#039;]}}&#039;);
		fclose($handle);

		$this-&gt;zipfiles_batched[$manifest] = $manifest_name;

		$updraftplus-&gt;log(&quot;Successfully created file manifest (size: &quot;.filesize($manifest).&quot;)&quot;);

		return true;
	}

	// Q. Why don&#039;t we only open and close the zip file just once?
	// A. Because apparently PHP doesn&#039;t write out until the final close, and it will return an error if anything file has vanished in the meantime. So going directory-by-directory reduces our chances of hitting an error if the filesystem is changing underneath us (which is very possible if dealing with e.g. 1GB of files)

	/**
	 * We batch up the files, rather than do them one at a time. So we are more efficient than open,one-write,close.
	 * To call into here, the array $this-&gt;zipfiles_batched must be populated (keys=paths, values=add-to-zip-as values). It gets reset upon exit from here.
	 *
	 * @param Boolean $warn_on_failures - If set, then log at the &#039;warning&#039; level
	 *
	 * @return Boolean|WP_Error
	 */
	private function makezip_addfiles($warn_on_failures) {

		global $updraftplus;

		// Used to detect requests to bump the size
		$bump_index = false;
		$ret = true;

		$zipfile = $this-&gt;zip_basename.((0 == $this-&gt;index) ? &#039;&#039; : ($this-&gt;index+1)).&#039;.zip.tmp&#039;;

		$maxzipbatch = $updraftplus-&gt;jobdata_get(&#039;maxzipbatch&#039;, 26214400);
		if ((int) $maxzipbatch &lt; 1024) $maxzipbatch = 26214400;

		// Short-circuit the null case, because we want to detect later if something useful happened
		if (0 == count($this-&gt;zipfiles_dirbatched) &amp;&amp; 0 == count($this-&gt;zipfiles_batched)) return true;

		// If on PclZip, then if possible short-circuit to a quicker method (makes a huge time difference - on a folder of 1500 small files, 2.6s instead of 76.6)
		// This assumes that makezip_addfiles() is only called once so that we know about all needed files (the new style)
		// This is rather conservative - because it assumes zero compression. But we can&#039;t know that in advance.
		$force_allinone = false;
		if (0 == $this-&gt;index &amp;&amp; $this-&gt;makezip_recursive_batchedbytes &lt; $this-&gt;zip_split_every) {
			// So far, we only have a processor for this for PclZip; but that check can be removed - need to address the below items
			// TODO: Is this really what we want? Always go all-in-one for &lt; 500MB???? Should be more conservative? Or, is it always faster to go all-in-one? What about situations where we might want to auto-split because of slowness - check that that is still working.
			// TODO: Test this new method for PclZip - are we still getting the performance gains? Test for ZipArchive too.
			if (&#039;UpdraftPlus_PclZip&#039; == $this-&gt;use_zip_object &amp;&amp; ($this-&gt;makezip_recursive_batchedbytes &lt; 512*1048576 || (defined(&#039;UPDRAFTPLUS_PCLZIP_FORCEALLINONE&#039;) &amp;&amp; UPDRAFTPLUS_PCLZIP_FORCEALLINONE == true &amp;&amp; &#039;UpdraftPlus_PclZip&#039; == $this-&gt;use_zip_object))) {
				$updraftplus-&gt;log(&quot;Only one archive required (&quot;.$this-&gt;use_zip_object.&quot;) - will attempt to do in single operation (data: &quot;.round($this-&gt;makezip_recursive_batchedbytes/1024, 1).&quot; KB, split: &quot;.round($this-&gt;zip_split_every/1024, 1).&quot; KB)&quot;);
				// $updraftplus-&gt;log(&quot;PclZip, and only one archive required - will attempt to do in single operation (data: &quot;.round($this-&gt;makezip_recursive_batchedbytes/1024, 1).&quot; KB, split: &quot;.round($this-&gt;zip_split_every/1024, 1).&quot; KB)&quot;);
								$force_allinone = true;
				// if(!class_exists(&#039;PclZip&#039;)) require_once(ABSPATH.&#039;/wp-admin/includes/class-pclzip.php&#039;);
				// $zip = new PclZip($zipfile);
				// $remove_path = ($this-&gt;whichone == &#039;wpcore&#039;) ? untrailingslashit(ABSPATH) : WP_CONTENT_DIR;
				// $add_path = false;
				// Remove prefixes
				// $backupable_entities = $updraftplus-&gt;get_backupable_file_entities(true);
				// if (isset($backupable_entities[$this-&gt;whichone])) {
				// if (&#039;plugins&#039; == $this-&gt;whichone || &#039;themes&#039; == $this-&gt;whichone || &#039;uploads&#039; == $this-&gt;whichone) {
				// $remove_path = dirname($backupable_entities[$this-&gt;whichone]);
				// To normalise instead of removing (which binzip doesn&#039;t support, so we don&#039;t do it), you&#039;d remove the dirname() in the above line, and uncomment the below one.
				// #$add_path = $this-&gt;whichone;
				// } else {
				// $remove_path = $backupable_entities[$this-&gt;whichone];
				// }
				// }
				// if ($add_path) {
				// $zipcode = $zip-&gt;create($this-&gt;source, PCLZIP_OPT_REMOVE_PATH, $remove_path, PCLZIP_OPT_ADD_PATH, $add_path);
				// } else {
				// $zipcode = $zip-&gt;create($this-&gt;source, PCLZIP_OPT_REMOVE_PATH, $remove_path);
				// }
				// if ($zipcode == 0) {
				// $updraftplus-&gt;log(&quot;PclZip Error: &quot;.$zip-&gt;errorInfo(true), &#039;warning&#039;);
				// return $zip-&gt;errorCode();
				// } else {
				// UpdraftPlus_Job_Scheduler::something_useful_happened();
				// return true;
				// }
			}
		}

		// 05-Mar-2013 - added a new check on the total data added; it appears that things fall over if too much data is contained in the cumulative total of files that were addFile&#039;d without a close-open cycle; presumably data is being stored in memory. In the case in question, it was a batch of MP3 files of around 100MB each - 25 of those equals 2.5GB!

		$data_added_since_reopen = 0;
		// static $data_added_this_resumption = 0;
		// $max_data_added_any_resumption = $updraftplus-&gt;jobdata_get(&#039;max_data_added_any_resumption&#039;, 0);

		// The following array is used only for error reporting if ZipArchive::close fails (since that method itself reports no error messages - we have to track manually what we were attempting to add)
		$files_zipadded_since_open = array();

		$zip = new $this-&gt;use_zip_object;
		if (file_exists($zipfile)) {
			$original_size = filesize($zipfile);
			// PHP 8.1 throws a deprecation notice if opening a zero-size file with ZipArchive, so in that situation, we remove and re-create it
			if ($original_size &gt; 0) {
				$opencode = $zip-&gt;open($zipfile);
				clearstatcache();
			} elseif (0 === $original_size) {
				unlink($zipfile);
			} else {
				$opencode = false;
			}
		} else {
			$original_size = 0;
		}

		if (0 === $original_size) {
			$create_code = (version_compare(PHP_VERSION, &#039;5.2.12&#039;, &#039;&gt;&#039;) &amp;&amp; defined(&#039;ZIPARCHIVE::CREATE&#039;)) ? ZIPARCHIVE::CREATE : 1;
			$opencode = $zip-&gt;open($zipfile, $create_code);
		}

		/* translators: 1: Zip file path, 2: Error message */
		if (true !== $opencode) return new WP_Error(&#039;no_open&#039;, sprintf(__(&#039;Failed to open the zip file (%1$s) - %2$s&#039;, &#039;updraftplus&#039;), $zipfile, $zip-&gt;last_error));

		if (apply_filters(&#039;updraftplus_include_manifest&#039;, false, $this-&gt;whichone, $this)) {
			$this-&gt;updraftplus_include_manifest($this-&gt;whichone);
		}

		// Give binzip the help it needs to deal with directory symlinks
		if (!empty($this-&gt;symlink_reversals) &amp;&amp; is_callable(array($zip, &#039;ud_notify_symlink_reversals&#039;))) {
			$zip-&gt;ud_notify_symlink_reversals($this-&gt;symlink_reversals);
		}

		// Make sure all directories are created before we start creating files
		while ($dir = array_pop($this-&gt;zipfiles_dirbatched)) {
			$zip-&gt;addEmptyDir($dir);
		}
		
		$zipfiles_added_thisbatch = 0;

		// Go through all those batched files
		foreach ($this-&gt;zipfiles_batched as $file =&gt; $add_as) {

			if (!file_exists($file)) {
				$updraftplus-&gt;log(&quot;File has vanished from underneath us; dropping: $add_as&quot;);
				continue;
			}

			$fsize = filesize($file);

			$large_file_warning_key = &#039;vlargefile_&#039;.md5($this-&gt;whichone.&#039;#&#039;.$add_as);
			
			if (defined(&#039;UPDRAFTPLUS_SKIP_FILE_OVER_SIZE&#039;) &amp;&amp; UPDRAFTPLUS_SKIP_FILE_OVER_SIZE &amp;&amp; $fsize &gt; UPDRAFTPLUS_SKIP_FILE_OVER_SIZE) {// phpcs:ignore Generic.PHP.NoSilencedErrors.Discouraged -- Silenced to suppress errors that may arise because of the check.
				$updraftplus-&gt;log(&quot;File is larger than the user-configured (UPDRAFTPLUS_SKIP_FILE_OVER_SIZE) maximum (is: &quot;.round($fsize/1024, 1).&quot; KB); will skip: &quot;.$add_as);
				continue;
			} elseif ($fsize &gt; UPDRAFTPLUS_WARN_FILE_SIZE) {

				/* translators: 1: File name, 2: File size in MB */
				$log_msg = __(&#039;A very large file was encountered: %1$s (size: %2$s Mb)&#039;, &#039;updraftplus&#039;);

				// Was this warned about on a previous run?
				if ($updraftplus-&gt;warning_exists($large_file_warning_key)) {
					$updraftplus-&gt;log_remove_warning($large_file_warning_key);
					$large_file_warning_key .= &#039;-2&#039;;
					$log_msg .= &#039; - &#039;.__(&#039;a second attempt is being made (upon further failure it will be skipped)&#039;, &#039;updraftplus&#039;);
				} elseif ($updraftplus-&gt;warning_exists($large_file_warning_key.&#039;-2&#039;) || $updraftplus-&gt;warning_exists($large_file_warning_key.&#039;-final&#039;)) {
					$updraftplus-&gt;log_remove_warning($large_file_warning_key.&#039;-2&#039;);
					$large_file_warning_key .= &#039;-final&#039;;
					$log_msg .= &#039; - &#039;.__(&#039;two unsuccessful attempts were made to include it, and it will now be omitted from the backup&#039;, &#039;updraftplus&#039;);
				}

				$updraftplus-&gt;log(sprintf($log_msg, $add_as, round($fsize/1048576, 1)), &#039;warning&#039;, $large_file_warning_key);

				if (preg_match(&#039;/-final$/&#039;, $large_file_warning_key)) continue;
			}

			// Skips files that are already added
			if (!isset($this-&gt;existing_files[$add_as]) || $this-&gt;existing_files[$add_as] != $fsize) {

				@touch($zipfile);// phpcs:ignore Generic.PHP.NoSilencedErrors.Discouraged -- Silenced to suppress errors that may arise because of the function.
				
				$zip-&gt;addFile($file, $add_as);
				$zipfiles_added_thisbatch++;

				if (method_exists($zip, &#039;setCompressionName&#039;) &amp;&amp; $this-&gt;file_should_be_stored_without_compression($add_as) &amp;&amp; false == $zip-&gt;setCompressionName($add_as, ZipArchive::CM_STORE)) {
					$updraftplus-&gt;log(&quot;Zip: setCompressionName failed on: $add_as&quot;);
				}

				// N.B., Since makezip_addfiles() can get called more than once if there were errors detected, potentially $zipfiles_added_thisrun can exceed the total number of batched files (if they get processed twice).
				$this-&gt;zipfiles_added_thisrun++;
				$files_zipadded_since_open[] = array(&#039;file&#039; =&gt; $file, &#039;addas&#039; =&gt; $add_as);

				$data_added_since_reopen += $fsize;
				// $data_added_this_resumption += $fsize;
				/* Conditions for forcing a write-out and re-open:
				- more than $maxzipbatch bytes have been batched
				- more than 2.0 seconds have passed since the last time we wrote
				- that adding this batch of data is likely already enough to take us over the split limit (and if that happens, then do actually split - to prevent a scenario of progressively tinier writes as we approach but don&#039;t actually reach the limit)
				- more than 500 files batched (should perhaps intelligently lower this as the zip file gets bigger - not yet needed)
				*/

				// Add 10% margin. It only really matters when the OS has a file size limit, exceeding which causes failure (e.g. 2GB on 32-bit)
				// Since we don&#039;t test before the file has been created (so that zip_last_ratio has meaningful data), we rely on max_zip_batch being less than zip_split_every - which should always be the case
				$reaching_split_limit = ($this-&gt;zip_last_ratio &gt; 0 &amp;&amp; $original_size&gt;0 &amp;&amp; ($original_size + 1.1*$data_added_since_reopen*$this-&gt;zip_last_ratio) &gt; $this-&gt;zip_split_every) ? true : false;

				if (!$force_allinone &amp;&amp; ($zipfiles_added_thisbatch &gt; UPDRAFTPLUS_MAXBATCHFILES || $reaching_split_limit || $data_added_since_reopen &gt; $maxzipbatch || (time() - $this-&gt;zipfiles_lastwritetime) &gt; 2)) {

					// We are coming towards a limit and about to close the zip, check if this is a more file backup and the manifest file has made it into this zip if not add it
					if (apply_filters(&#039;updraftplus_include_manifest&#039;, false, $this-&gt;whichone, $this)) {

						$manifest = false;

						foreach ($files_zipadded_since_open as $info) {
							if (&#039;updraftplus-manifest.json&#039; == $info[&#039;file&#039;]) $manifest = true;
						}

						if (!$manifest) {
							@touch($zipfile);// phpcs:ignore Generic.PHP.NoSilencedErrors.Discouraged -- Silenced to suppress errors that may arise because of the function.
							$path = array_search(&#039;updraftplus-manifest.json&#039;, $this-&gt;zipfiles_batched);
							$zip-&gt;addFile($path, &#039;updraftplus-manifest.json&#039;);
							$zipfiles_added_thisbatch++;

							if (method_exists($zip, &#039;setCompressionName&#039;) &amp;&amp; $this-&gt;file_should_be_stored_without_compression($this-&gt;zipfiles_batched[$path])) {
								if (false == $zip-&gt;setCompressionName($this-&gt;zipfiles_batched[$path], ZipArchive::CM_STORE)) {
									$updraftplus-&gt;log(&quot;Zip: setCompressionName failed on: $this-&gt;zipfiles_batched[$path]&quot;);
								}
							}

							// N.B., Since makezip_addfiles() can get called more than once if there were errors detected, potentially $zipfiles_added_thisrun can exceed the total number of batched files (if they get processed twice).
							$this-&gt;zipfiles_added_thisrun++;
							$files_zipadded_since_open[] = array(&#039;file&#039; =&gt; $path, &#039;addas&#039; =&gt; &#039;updraftplus-manifest.json&#039;);
							$data_added_since_reopen += filesize($path);
							// $data_added_this_resumption += filesize($path);
						}
					}

					if (function_exists(&#039;set_time_limit&#039;)) @set_time_limit(UPDRAFTPLUS_SET_TIME_LIMIT);// phpcs:ignore Generic.PHP.NoSilencedErrors.Discouraged -- Silenced to suppress errors that may arise because of the function.
					$something_useful_sizetest = false;

					if ($data_added_since_reopen &gt; $maxzipbatch) {
						$something_useful_sizetest = true;
						$updraftplus-&gt;log(&quot;Adding batch to zip file (&quot;.$this-&gt;use_zip_object.&quot;): over &quot;.round($maxzipbatch/1048576, 1).&quot; MB added on this batch (&quot;.round($data_added_since_reopen/1048576, 1).&quot; MB, &quot;.count($this-&gt;zipfiles_batched).&quot; files batched, $zipfiles_added_thisbatch (&quot;.$this-&gt;zipfiles_added_thisrun.&quot;) added so far); re-opening (prior size: &quot;.round($original_size/1024, 1).&#039; KB)&#039;);
					} elseif ($zipfiles_added_thisbatch &gt; UPDRAFTPLUS_MAXBATCHFILES) {
						$updraftplus-&gt;log(&quot;Adding batch to zip file (&quot;.$this-&gt;use_zip_object.&quot;): over &quot;.UPDRAFTPLUS_MAXBATCHFILES.&quot; files added on this batch (&quot;.round($data_added_since_reopen/1048576, 1).&quot; MB, &quot;.count($this-&gt;zipfiles_batched).&quot; files batched, $zipfiles_added_thisbatch (&quot;.$this-&gt;zipfiles_added_thisrun.&quot;) added so far); re-opening (prior size: &quot;.round($original_size/1024, 1).&#039; KB)&#039;);
					} elseif (!$reaching_split_limit) {
						$updraftplus-&gt;log(&quot;Adding batch to zip file (&quot;.$this-&gt;use_zip_object.&quot;): over 2.0 seconds have passed since the last write (&quot;.round($data_added_since_reopen/1048576, 1).&quot; MB, $zipfiles_added_thisbatch (&quot;.$this-&gt;zipfiles_added_thisrun.&quot;) files added so far); re-opening (prior size: &quot;.round($original_size/1024, 1).&#039; KB)&#039;);
					} else {
						$updraftplus-&gt;log(&quot;Adding batch to zip file (&quot;.$this-&gt;use_zip_object.&quot;): possibly approaching split limit (&quot;.round($data_added_since_reopen/1048576, 1).&quot; MB, $zipfiles_added_thisbatch (&quot;.$this-&gt;zipfiles_added_thisrun.&quot;) files added so far); last ratio: &quot;.round($this-&gt;zip_last_ratio, 4).&quot;; re-opening (prior size: &quot;.round($original_size/1024, 1).&#039; KB)&#039;);
					}

					if (!$zip-&gt;close()) {
						// Though we will continue processing the files we&#039;ve got, the final error code will be false, to allow a second attempt on the failed ones. This also keeps us consistent with a negative result for $zip-&gt;close() further down. We don&#039;t just retry here, because we have seen cases (with BinZip) where upon failure, the existing zip had actually been deleted. So, to be safe we need to re-scan the existing zips.
						$ret = false;
						$this-&gt;record_zip_error($files_zipadded_since_open, $zip-&gt;last_error, $warn_on_failures);
					}

					$zipfiles_added_thisbatch = 0;

					// This triggers a re-open, later
					unset($zip);
					$files_zipadded_since_open = array();
					// Call here, in case we&#039;ve got so many big files that we don&#039;t complete the whole routine
					if (filesize($zipfile) &gt; $original_size) {

						// It is essential that this does not go above 1, even though in reality (and this can happen at the start, if just 1 file is added (e.g. due to &gt;2.0s detection) the &#039;compressed&#039; zip file may be *bigger* than the files stored in it. When that happens, if the ratio is big enough, it can then fire the &quot;approaching split limit&quot; detection (very) prematurely
						$this-&gt;zip_last_ratio = ($data_added_since_reopen &gt; 0) ? min((filesize($zipfile) - $original_size)/$data_added_since_reopen, 1) : 1;

						// We need a rolling update of this
						$original_size = filesize($zipfile);

						// Move on to next zip?
						if ($reaching_split_limit || filesize($zipfile) &gt; $this-&gt;zip_split_every) {
							$bump_index = true;
							// Take the filesize now because later we wanted to know we did clearstatcache()
							$bumped_at = round(filesize($zipfile)/1048576, 1);
						}

						// Need to make sure that something_useful_happened() is always called

						// How long since the current run began? If it&#039;s taken long (and we&#039;re in danger of not making it at all), or if that is foreseeable in future because of general slowness, then we should reduce the parameters.
						if (!$something_useful_sizetest) {
							UpdraftPlus_Job_Scheduler::something_useful_happened();
						} else {

							// Do this as early as possible
							UpdraftPlus_Job_Scheduler::something_useful_happened();

							$time_since_began = max(microtime(true)- $this-&gt;zipfiles_lastwritetime, 0.000001);
							$normalised_time_since_began = $time_since_began*($maxzipbatch/$data_added_since_reopen);

							// Don&#039;t measure speed until after ZipArchive::close()
							$rate = round($data_added_since_reopen/$time_since_began, 1);

							$updraftplus-&gt;log(sprintf(&quot;A useful amount of data was added after this amount of zip processing: %s s (normalised: %s s, rate: %s KB/s)&quot;, round($time_since_began, 1), round($normalised_time_since_began, 1), round($rate/1024, 1)));

							// We want to detect not only that we need to reduce the size of batches, but also the capability to increase them. This is particularly important because of ZipArchive()&#039;s (understandable, given the tendency of PHP processes being terminated without notice) practice of first creating a temporary zip file via copying before acting on that zip file (so the information is atomic). Unfortunately, once the size of the zip file gets over 100MB, the copy operation beguns to be significant. By the time you&#039;ve hit 500MB on many web hosts the copy is the majority of the time taken. So we want to do more in between these copies if possible.

							/* &quot;Could have done more&quot; - detect as:
							- A batch operation would still leave a &quot;good chunk&quot; of time in a run
							- &quot;Good chunk&quot; means that the time we took to add the batch is less than 50% of a run time
							- We can do that on any run after the first (when at least one ceiling on the maximum time is known)
							- But in the case where a max_execution_time is long (so that resumptions are never needed), and we&#039;re always on run 0, we will automatically increase chunk size if the batch took less than 6 seconds.
							*/

							// At one stage we had a strategy of not allowing check-ins to have more than 20s between them. However, once the zip file got to a certain size, PHP&#039;s habit of copying the entire zip file first meant that it *always* went over 18s, and thence a drop in the max size was inevitable - which was bad, because with the copy time being something that only grew, the outcome was less data being copied every time

							// Gather the data. We try not to do this unless necessary (may be time-sensitive)
							if ($updraftplus-&gt;current_resumption &gt;= 1) {
								$time_passed = $updraftplus-&gt;jobdata_get(&#039;run_times&#039;);
								if (!is_array($time_passed)) $time_passed = array();
								list($max_time, $timings_string, $run_times_known) = UpdraftPlus_Manipulation_Functions::max_time_passed($time_passed, $updraftplus-&gt;current_resumption-1, $this-&gt;first_run);// phpcs:ignore VariableAnalysis.CodeAnalysis.VariableAnalysis.UnusedVariable -- Unused parameter is present because the method returns an array.
							} else {
								// $run_times_known = 0;
								// $max_time = -1;
								$run_times_known = 1;
								$max_time = microtime(true)-$updraftplus-&gt;opened_log_time;
							}

							if ($normalised_time_since_began &lt; 6 || ($updraftplus-&gt;current_resumption &gt;= 1 &amp;&amp; $run_times_known &gt;= 1 &amp;&amp; $time_since_began &lt; 0.6*$max_time) || (0 == $updraftplus-&gt;current_resumption &amp;&amp; $max_time &gt; 240)) {

								// How much can we increase it by?
								if ($normalised_time_since_began &lt; 6 || 0 == $updraftplus-&gt;current_resumption) {
									if ($run_times_known &gt; 0 &amp;&amp; $max_time &gt; 0) {
										$new_maxzipbatch = min(floor(max($maxzipbatch*6/$normalised_time_since_began, $maxzipbatch*((0.6*$max_time)/$normalised_time_since_began))), $this-&gt;zip_batch_ceiling);
									} else {
										// Maximum of 200MB in a batch
										$new_maxzipbatch = min(floor($maxzipbatch*6/$normalised_time_since_began), $this-&gt;zip_batch_ceiling);
									}
								} else {
									// Use up to 60% of available time
									$new_maxzipbatch = min(floor($maxzipbatch*((0.6*$max_time)/$normalised_time_since_began)), $this-&gt;zip_batch_ceiling);
								}

								// Throttle increases - don&#039;t increase by more than 2x in one go - ???
								// $new_maxzipbatch = floor(min(2*$maxzipbatch, $new_maxzipbatch));
								// Also don&#039;t allow anything that is going to be more than 18 seconds - actually, that&#039;s harmful because of the basically fixed time taken to copy the file
								// $new_maxzipbatch = floor(min(18*$rate ,$new_maxzipbatch));

								// Don&#039;t go above the split amount (though we expect that to be higher anyway, unless sending via email)
								$new_maxzipbatch = min($new_maxzipbatch, $this-&gt;zip_split_every);

								// Don&#039;t raise it above a level that failed on a previous run
								$maxzipbatch_ceiling = $updraftplus-&gt;jobdata_get(&#039;maxzipbatch_ceiling&#039;);
								if (is_numeric($maxzipbatch_ceiling) &amp;&amp; $maxzipbatch_ceiling &gt; 20*1048576 &amp;&amp; $new_maxzipbatch &gt; $maxzipbatch_ceiling) {
									$updraftplus-&gt;log(&quot;Was going to raise maxzipbytes to $new_maxzipbatch, but this is too high: a previous failure led to the ceiling being set at $maxzipbatch_ceiling, which we will use instead&quot;);
									$new_maxzipbatch = $maxzipbatch_ceiling;
								}

								// Final sanity check
								if ($new_maxzipbatch &gt; 1048576) $updraftplus-&gt;jobdata_set(&#039;maxzipbatch&#039;, $new_maxzipbatch);

								if ($new_maxzipbatch &lt;= 1048576) {
									$updraftplus-&gt;log(&quot;Unexpected new_maxzipbatch value obtained (time=$time_since_began, normalised_time=$normalised_time_since_began, max_time=$max_time, data points known=$run_times_known, old_max_bytes=$maxzipbatch, new_max_bytes=$new_maxzipbatch)&quot;);
								} elseif ($new_maxzipbatch &gt; $maxzipbatch) {
									$updraftplus-&gt;log(&quot;Performance is good - will increase the amount of data we attempt to batch (time=$time_since_began, normalised_time=$normalised_time_since_began, max_time=$max_time, data points known=$run_times_known, old_max_bytes=$maxzipbatch, new_max_bytes=$new_maxzipbatch)&quot;);
								} elseif ($new_maxzipbatch &lt; $maxzipbatch) {
									// Ironically, we thought we were speedy...
									$updraftplus-&gt;log(&quot;Adjust: Reducing maximum amount of batched data (time=$time_since_began, normalised_time=$normalised_time_since_began, max_time=$max_time, data points known=$run_times_known, new_max_bytes=$new_maxzipbatch, old_max_bytes=$maxzipbatch)&quot;);
								} else {
									$updraftplus-&gt;log(&quot;Performance is good - but we will not increase the amount of data we batch, as we are already at the present limit (time=$time_since_began, normalised_time=$normalised_time_since_began, max_time=$max_time, data points known=$run_times_known, max_bytes=$maxzipbatch)&quot;);
								}

								if ($new_maxzipbatch &gt; 1048576) $maxzipbatch = $new_maxzipbatch;
							}

							// Detect excessive slowness
							// Don&#039;t do this until we&#039;re on at least resumption 7, as we want to allow some time for things to settle down and the maximum time to be accurately known (since reducing the batch size unnecessarily can itself cause extra slowness, due to PHP&#039;s usage of temporary zip files)

							// We use a percentage-based system as much as possible, to avoid the various criteria being in conflict with each other (i.e. a run being both &#039;slow&#039; and &#039;fast&#039; at the same time, which is increasingly likely as max_time gets smaller).

							if (!$updraftplus-&gt;something_useful_happened &amp;&amp; $updraftplus-&gt;current_resumption &gt;= 7) {

								UpdraftPlus_Job_Scheduler::something_useful_happened();

								if ($run_times_known &gt;= 5 &amp;&amp; ($time_since_began &gt; 0.8 * $max_time || $time_since_began + 7 &gt; $max_time)) {

									$new_maxzipbatch = max(floor($maxzipbatch*0.8), 20971520);
									if ($new_maxzipbatch &lt; $maxzipbatch) {
										$maxzipbatch = $new_maxzipbatch;
										$updraftplus-&gt;jobdata_set(&quot;maxzipbatch&quot;, $new_maxzipbatch);
										$updraftplus-&gt;log(&quot;We are within a small amount of the expected maximum amount of time available; the zip-writing thresholds will be reduced (time_passed=$time_since_began, normalised_time_passed=$normalised_time_since_began, max_time=$max_time, data points known=$run_times_known, old_max_bytes=$maxzipbatch, new_max_bytes=$new_maxzipbatch)&quot;);
									} else {
										$updraftplus-&gt;log(&quot;We are within a small amount of the expected maximum amount of time available, but the zip-writing threshold is already at its lower limit (20MB), so will not be further reduced (max_time=$max_time, data points known=$run_times_known, max_bytes=$maxzipbatch)&quot;);
									}
								}

							} else {
								UpdraftPlus_Job_Scheduler::something_useful_happened();
							}
						}
						$data_added_since_reopen = 0;
					} else {
						// ZipArchive::close() can take a very long time, which we want to know about
						UpdraftPlus_Job_Scheduler::record_still_alive();
					}

					clearstatcache();
					$this-&gt;zipfiles_lastwritetime = time();
				}
			} elseif (0 == $this-&gt;zipfiles_added_thisrun) {
				// Update lastwritetime, because otherwise the 2.0-second-activity detection can fire prematurely (e.g. if it takes &gt;2.0 seconds to process the previously-written files, then the detector fires after 1 file. This then can have the knock-on effect of having something_useful_happened() called, but then a subsequent attempt to write out a lot of meaningful data fails, and the maximum batch is not then reduced.
				// Testing shows that calling time() 1000 times takes negligible time
				$this-&gt;zipfiles_lastwritetime = time();
			}

			$this-&gt;zipfiles_added++;

			// Don&#039;t call something_useful_happened() here - nothing necessarily happens until close() is called
			if (0 == $this-&gt;zipfiles_added % 100) {
				$skip_dblog = ($this-&gt;zipfiles_added_thisrun &gt; 0 || 0 == $this-&gt;zipfiles_added % 1000) ? false : true;
				$updraftplus-&gt;log(&quot;Zip: &quot;.basename($zipfile).&quot;: &quot;.$this-&gt;zipfiles_added.&quot; files added (on-disk size: &quot;.round(@filesize($zipfile)/1024, 1).&quot; KB)&quot;, &#039;notice&#039;, false, $skip_dblog);// phpcs:ignore Generic.PHP.NoSilencedErrors.Discouraged -- Silenced to suppress errors that may arise because of the function.
			}

			if ($bump_index) {
				$updraftplus-&gt;log(sprintf(&quot;Zip size is at/near split limit (%s MB / %s MB) - bumping index (from: %d)&quot;, $bumped_at, round($this-&gt;zip_split_every/1048576, 1), $this-&gt;index));
				$bump_index = false;
				$this-&gt;bump_index();
				$zipfile = $this-&gt;zip_basename.($this-&gt;index+1).&#039;.zip.tmp&#039;;
			}

			if (empty($zip)) {
				$zip = new $this-&gt;use_zip_object;

				// Give binzip the help it needs to deal with directory symlinks
				if (!empty($this-&gt;symlink_reversals) &amp;&amp; is_callable(array($zip, &#039;ud_notify_symlink_reversals&#039;))) {
					$zip-&gt;ud_notify_symlink_reversals($this-&gt;symlink_reversals);
				}

				if (file_exists($zipfile)) {
					$original_size = filesize($zipfile);
					// PHP 8.1 throws a deprecation notice if opening a zero-size file with ZipArchive, so in that situation, we remove and re-create it
					if ($original_size &gt; 0) {
						$opencode = $zip-&gt;open($zipfile);
						clearstatcache();
					} elseif (0 === $original_size) {
						unlink($zipfile);
					} else {
						$opencode = false;
					}
				} else {
					$original_size = 0;
				}

				if (0 === $original_size) {
					$create_code = (version_compare(PHP_VERSION, &#039;5.2.12&#039;, &#039;&gt;&#039;) &amp;&amp; defined(&#039;ZIPARCHIVE::CREATE&#039;)) ? ZIPARCHIVE::CREATE : 1;
					$opencode = $zip-&gt;open($zipfile, $create_code);
				}

				/* translators: 1: Zip file path, 2: Error message */
				if (true !== $opencode) return new WP_Error(&#039;no_open&#039;, sprintf(__(&#039;Failed to open the zip file (%1$s) - %2$s&#039;, &#039;updraftplus&#039;), $zipfile, $zip-&gt;last_error));
			}

		}

		// Reset array
		$this-&gt;zipfiles_batched = array();
		$this-&gt;zipfiles_skipped_notaltered = array();

		if (false == ($nret = $zip-&gt;close())) $this-&gt;record_zip_error($files_zipadded_since_open, $zip-&gt;last_error, $warn_on_failures);

		if (apply_filters(&#039;updraftplus_include_manifest&#039;, false, $this-&gt;whichone, $this)) {
			if (!empty($this-&gt;manifest_path) &amp;&amp; file_exists($this-&gt;manifest_path)) {
				$updraftplus-&gt;log(&#039;Removing manifest file: &#039;.basename($this-&gt;manifest_path).&#039;: &#039;.(@unlink($this-&gt;manifest_path) ? &#039;OK&#039; : &#039;failed&#039;));// phpcs:ignore Generic.PHP.NoSilencedErrors.Discouraged -- Silenced to suppress errors that may arise if the file doesn&#039;t exist.
			}
		}

		$this-&gt;zipfiles_lastwritetime = time();
		// May not exist if the last thing we did was bump
		if (file_exists($zipfile) &amp;&amp; filesize($zipfile) &gt; $original_size) UpdraftPlus_Job_Scheduler::something_useful_happened();

		// Move on to next archive?
		if (file_exists($zipfile) &amp;&amp; filesize($zipfile) &gt; $this-&gt;zip_split_every) {
			$updraftplus-&gt;log(sprintf(&quot;Zip size has gone over split limit (%s, %s) - bumping index (%d)&quot;, round(filesize($zipfile)/1048576, 1), round($this-&gt;zip_split_every/1048576, 1), $this-&gt;index));
			$this-&gt;bump_index();
		}

		$manifest = preg_replace(&#039;/\.tmp$/&#039;, &#039;.list.tmp&#039;, $zipfile);
		if (!file_exists($manifest)) $this-&gt;write_zip_manifest_from_zip($zipfile);

		clearstatcache();

		return (false == $ret) ? false : $nret;
	}

	private function record_zip_error($files_zipadded_since_open, $msg, $warn = true) {
		global $updraftplus;

		if (!empty($updraftplus-&gt;cpanel_quota_readable)) {
			$hosting_bytes_free = $updraftplus-&gt;get_hosting_disk_quota_free();
			if (is_array($hosting_bytes_free)) {
				$perc = round(100*$hosting_bytes_free[1]/(max($hosting_bytes_free[2], 1)), 1);
				$quota_free_msg = sprintf(&#039;Free disk space in account: %s (%s used)&#039;, round($hosting_bytes_free[3]/1048576, 1).&quot; MB&quot;, &quot;$perc %&quot;);
				$updraftplus-&gt;log($quota_free_msg);
				if ($hosting_bytes_free[3] &lt; 1048576*50) {
					$quota_low = true;
					$quota_free_mb = round($hosting_bytes_free[3]/1048576, 1);
					/* translators: %s: Remaining free space in MB */
					$updraftplus-&gt;log(sprintf(__(&#039;Your free space in your hosting account is very low - only %s Mb remain&#039;, &#039;updraftplus&#039;), $quota_free_mb), &#039;warning&#039;, &#039;lowaccountspace&#039;.$quota_free_mb);
				}
			}
		}

		// Always warn of this
		if (is_string($msg) &amp;&amp; strpos($msg, &#039;File Size Limit Exceeded&#039;) !== false &amp;&amp; &#039;UpdraftPlus_BinZip&#039; == $this-&gt;use_zip_object) {
			$updraftplus-&gt;log(
				sprintf(
					/* translators: %s: Error message */
					__(&#039;The zip engine returned the message: %s.&#039;, &#039;updraftplus&#039;),
				&#039;File Size Limit Exceeded&#039;).
				__(&#039;Go here for more information.&#039;, &#039;updraftplus&#039;).
				&#039; https://teamupdraft.com/documentation/updraftplus/topics/backing-up/troubleshooting/what-should-i-do-if-i-see-the-message-file-size-limit-exceeded/?utm_source=udp-plugin&amp;utm_medium=referral&amp;utm_campaign=paac&amp;utm_content=unknown&amp;utm_creative_format=unknown&#039;,
				&#039;warning&#039;,
			&#039;zipcloseerror-filesizelimit&#039;);
		} elseif ($warn) {
			$warn_msg = __(&#039;A zip error occurred&#039;, &#039;updraftplus&#039;).&#039; - &#039;;
			if (!empty($quota_low)) {
				/* translators: %s: Help URL */
				$warn_msg = sprintf(__(&#039;your web hosting account is full; please see: %s&#039;, &#039;updraftplus&#039;), &#039;https://updraftplus.com/faqs/how-much-free-disk-space-do-i-need-to-create-a-backup/&#039;);
			} else {
				$warn_msg .= __(&#039;check your log for more details.&#039;, &#039;updraftplus&#039;);
			}
			$updraftplus-&gt;log($warn_msg, &#039;warning&#039;, &#039;zipcloseerror-&#039;.$this-&gt;whichone);
		}

		$updraftplus-&gt;log(&quot;The attempt to close the zip file returned an error ($msg). List of files we were trying to add follows (check their permissions).&quot;);

		foreach ($files_zipadded_since_open as $ffile) {
			$updraftplus-&gt;log(&quot;File: &quot;.$ffile[&#039;addas&#039;].&quot; (exists: &quot;.(int) @file_exists($ffile[&#039;file&#039;]).&quot;, is_readable: &quot;.(int) @is_readable($ffile[&#039;file&#039;]).&quot; size: &quot;.@filesize($ffile[&#039;file&#039;]).&#039;)&#039;, &#039;notice&#039;, false, true);// phpcs:ignore Generic.PHP.NoSilencedErrors.Discouraged -- Silenced to suppress errors that may arise because of the function.
		}
	}

	/**
	 * Bump the zip index number. No parameters or returned value, since it is dealing with class variables.
	 */
	private function bump_index() {
		global $updraftplus;
		$youwhat = $this-&gt;whichone;

		$timetaken = max(microtime(true)-$this-&gt;zip_microtime_start, 0.000001);

		$itext = (0 == $this-&gt;index) ? &#039;&#039; : ($this-&gt;index+1);
		$full_path = $this-&gt;zip_basename.$itext.&#039;.zip&#039;;

		$checksums = $updraftplus-&gt;which_checksums();

		$checksum_description = &#039;&#039;;

		foreach ($checksums as $checksum) {

			$cksum = hash_file($checksum, $full_path.&#039;.tmp&#039;);
			$updraftplus-&gt;jobdata_set($checksum.&#039;-&#039;.$youwhat.$this-&gt;index, $cksum);
			if ($checksum_description) $checksum_description .= &#039;, &#039;;
			$checksum_description .= &quot;$checksum: $cksum&quot;;

		}

		$next_full_path = $this-&gt;zip_basename.($this-&gt;index+2).&#039;.zip&#039;;
		// We touch the next zip before renaming the temporary file; this indicates that the backup for the entity is not *necessarily* finished
		touch($next_full_path.&#039;.tmp&#039;);

		if (file_exists($full_path.&#039;.tmp&#039;) &amp;&amp; filesize($full_path.&#039;.tmp&#039;) &gt; 0) {
			if (!rename($full_path.&#039;.tmp&#039;, $full_path)) {
				$updraftplus-&gt;log(&quot;Rename failed for $full_path.tmp&quot;);
			} else {
				$manifest = $full_path.&#039;.list.tmp&#039;;
				if (!file_exists($manifest)) $this-&gt;write_zip_manifest_from_zip($full_path);
				UpdraftPlus_Job_Scheduler::something_useful_happened();
			}
		}

		$kbsize = filesize($full_path)/1024;
		$rate = round($kbsize/$timetaken, 1);
		$updraftplus-&gt;log(&quot;Created &quot;.$this-&gt;whichone.&quot; zip (&quot;.$this-&gt;index.&quot;) - &quot;.round($kbsize, 1).&quot; KB in &quot;.round($timetaken, 1).&quot; s ($rate KB/s) (checksums: $checksum_description)&quot;);
		$this-&gt;zip_microtime_start = microtime(true);

		// No need to add $itext here - we can just delete any temporary files for this zip
		UpdraftPlus_Filesystem_Functions::clean_temporary_files(&#039;_&#039;.$updraftplus-&gt;file_nonce.&quot;-&quot;.$youwhat, 600);

		$prior_index = $this-&gt;index;
		$this-&gt;index++;
		$this-&gt;job_file_entities[$youwhat][&#039;index&#039;] = $this-&gt;index;
		$updraftplus-&gt;jobdata_set(&#039;job_file_entities&#039;, $this-&gt;job_file_entities);
		$this-&gt;maybe_cloud_backup(basename($full_path), $this-&gt;whichone, $prior_index);
	}

	/**
	 * This function will populate class variables (given below) with a list of files found inside the passed in zip
	 *
	 * @param string  $zip_path           - the zip file name we want to list files for; must end in .tmp
	 * @param boolean $read_from_manifest - a boolean to indicate if we should try to read from the manifest or not
	 *
	 * @uses self::$existing_files
	 * @uses self::$existing_files_rawsize
	 * @uses self::$existing_zipfiles_size
	 *
	 * @return void
	 */
	private function populate_existing_files_list_from_zip($zip_path, $read_from_manifest) {
		global $updraftplus;

		// Get the name of the final manifest file
		if (preg_match(&#039;/\.tmp$/&#039;, $zip_path)) {
			$manifest = preg_replace(&#039;/\.tmp$/&#039;, &#039;.list.tmp&#039;, $zip_path);
		} else {
			$manifest = $zip_path.&#039;.list.tmp&#039;;
		}

		if ($read_from_manifest &amp;&amp; file_exists($manifest)) {
			$manifest_contents = json_decode(file_get_contents($manifest), true);

			if (empty($manifest_contents)) {
				$updraftplus-&gt;log(&quot;Zip manifest file found, but reading failed: &quot;.basename($manifest));
			} elseif (!empty($manifest_contents[&#039;files&#039;])) {
				$this-&gt;existing_files = array_merge($this-&gt;existing_files, $manifest_contents[&#039;files&#039;][0]);
				$updraftplus-&gt;log(&#039;Successfully read zip manifest file contents (&#039;.basename($manifest).&#039;)&#039;);
				return;
			} else {
				$updraftplus-&gt;log(&quot;Zip manifest file found, but no files contents were found: &quot;.basename($manifest));
			}
		} elseif ($read_from_manifest) {
			$updraftplus-&gt;log(&quot;No zip manifest file found; will create one&quot;);
		}

		$zip = new $this-&gt;use_zip_object;
		if (true !== $zip-&gt;open($zip_path)) {
			$updraftplus-&gt;log(&quot;Could not open zip file to examine (&quot;.$zip-&gt;last_error.&quot;); will remove: &quot;.basename($zip_path));
			unlink($zip_path);
		} else {

			$this-&gt;existing_zipfiles_size += filesize($zip_path);

			// Don&#039;t put this in the for loop, or the magic __get() method which accessing the property invokes gets repeatedly called every time the loop goes round
			$numfiles = $zip-&gt;numFiles;

			if (false === $numfiles) {
				$updraftplus-&gt;log(&quot;Could not read any files from the zip (&quot;.$zip-&gt;last_error.&quot;): &quot;.basename($zip_path));
				$zip-&gt;close();
				return;
			}

			for ($i=0; $i &lt; $numfiles; $i++) {
				$si = $zip-&gt;statIndex($i);
				$name = $si[&#039;name&#039;];
				// Exclude folders
				if (&#039;/&#039; == substr($name, -1)) continue;
				if (!isset($this-&gt;existing_files[$name])) {
					$this-&gt;existing_files[$name] = $si[&#039;size&#039;];
					$this-&gt;existing_files_rawsize += $si[&#039;size&#039;];
				}
			}

			@$zip-&gt;close();// phpcs:ignore Generic.PHP.NoSilencedErrors.Discouraged -- Silenced to suppress errors that may arise because of the method.

			$updraftplus-&gt;log(basename($zip_path).&quot;: Zip file already exists, with &quot;.count($this-&gt;existing_files).&quot; files&quot;);

			// If this is a .tmp file (partial zip) then return we do not want to create an incomplete manifest file
			if (preg_match(&#039;/\.tmp$/&#039;, $zip_path)) return;

			$manifest = $zip_path.&#039;.list-temp.tmp&#039;;

			$this-&gt;write_zip_manifest_from_list($manifest, $this-&gt;existing_files);
		}
	}

	/**
	 * This function will get a list of files found inside the passed in zip and call the function to create the zip manifest, returns true on success and false on failure
	 *
	 * @uses self::write_zip_manifest_from_list()
	 * @param string $zip_path - the zip file path; must end in .tmp
	 *
	 * @return boolean - returns true on success and false on failure
	 */
	private function write_zip_manifest_from_zip($zip_path) {
		global $updraftplus;

		$zip_files = array();

		$zip = new $this-&gt;use_zip_object;
		if (true !== $zip-&gt;open($zip_path)) {
			$updraftplus-&gt;log(&quot;Could not open zip file to examine (&quot;.$zip-&gt;last_error.&quot;); file: &quot;.basename($zip_path));
			return false;
		} else {
			// Don&#039;t put this in the for loop, or the magic __get() method gets repeatedly called every time the loop goes round
			$numfiles = $zip-&gt;numFiles;

			if (false === $numfiles) $updraftplus-&gt;log(&quot;write_zip_manifest_from_zip(): Could not read any files from the zip: (&quot;.basename($zip_path).&quot;) Zip error: (&quot;.$zip-&gt;last_error.&quot;)&quot;);

			for ($i=0; $i &lt; $numfiles; $i++) {
				$si = $zip-&gt;statIndex($i);
				$name = $si[&#039;name&#039;];
				// Exclude folders
				if (&#039;/&#039; == substr($name, -1)) continue;
				$zip_files[$name] = $si[&#039;size&#039;];
			}

			@$zip-&gt;close();// phpcs:ignore Generic.PHP.NoSilencedErrors.Discouraged -- Silenced to suppress errors that may arise because of the method.
		}

		if (empty($zip_files)) {
			$updraftplus-&gt;log(&quot;Did not find any files in the zip: &quot;.basename($zip_path));
			return false;
		}

		if (preg_match(&#039;/\.tmp$/&#039;, $zip_path)) {
			$manifest = preg_replace(&#039;/\.tmp$/&#039;, &#039;.list-temp.tmp&#039;, $zip_path);
		} else {
			$manifest = $zip_path.&#039;.list-temp.tmp&#039;;
		}

		$this-&gt;write_zip_manifest_from_list($manifest, $zip_files);

		return true;
	}

	/**
	 * This function will create and write the contents of the zip manifest
	 *
	 * @param string $manifest  - path of the manifest file
	 * @param array  $zip_files - an array of files and their sizes
	 *
	 * @return boolean - returns false on failure to write
	 */
	private function write_zip_manifest_from_list($manifest, $zip_files) {
		global $updraftplus;

		$updraftplus-&gt;log(&#039;Creating zip file manifest (&#039;.basename($manifest).&#039;)&#039;);

		if (false === ($handle = fopen($manifest, &#039;w+&#039;))) {
			$updraftplus-&gt;log(&#039;Failed to open zip manifest file (&#039;.basename($manifest).&#039;)&#039;);
			return false;
		}

		$version = 1;

		if (false === fwrite($handle, &#039;{&quot;version&quot;:&#039;.$version.&#039;, &quot;files&quot;:[{&#039;)) {
			$updraftplus-&gt;log(&#039;First write to manifest file failed (&#039;.basename($manifest).&#039;)&#039;);
			return false;
		}

		$last_dir_index = key(array_slice($zip_files, -1, 1, true));

		foreach ($zip_files as $name =&gt; $size) {
			fwrite($handle, json_encode($name).&#039; : &#039;.$size.(($name != $last_dir_index) ? &#039;,&#039; : &#039;&#039;));
		}

		fwrite($handle, &#039;}]}&#039;);
		fclose($handle);

		$updraftplus-&gt;log(&quot;Successfully created zip file manifest (size: &quot;.filesize($manifest).&quot;)&quot;);

		$final_manifest = preg_replace(&#039;/\.list-temp.tmp$/&#039;, &#039;.list.tmp&#039;, $manifest);
		rename($manifest, $final_manifest);
	}

	/**
	 * Returns the member of the array with key (int)0, as a new array. This function is used as a callback for array_map().
	 *
	 * @param Array $a - the array
	 *
	 * @return Array - with keys &#039;name&#039; and &#039;type&#039;
	 */
	private function cb_get_name_base_type($a) {
		return array(&#039;name&#039; =&gt; $a[0], &#039;type&#039; =&gt; &#039;BASE TABLE&#039;);
	}

	/**
	 * Returns the members of the array with keys (int)0 and (int)1, as part of a new array.
	 *
	 * @param Array $a - the array
	 *
	 * @return Array - keys are &#039;name&#039; and &#039;type&#039;
	 */
	private function cb_get_name_type($a) {
		return array(&#039;name&#039; =&gt; $a[0], &#039;type&#039; =&gt; $a[1]);
	}

	/**
	 * Returns the member of the array with key (string)&#039;name&#039;. This function is used as a callback for array_map().
	 *
	 * @param Array $a - the array
	 *
	 * @return Mixed - the value with key (string)&#039;name&#039;
	 */
	private function cb_get_name($a) {
		return $a[&#039;name&#039;];
	}

	/**
	 * Exclude files from backup
	 *
	 * @param Boolean $filter initial boolean value of whether the given file is excluded or not
	 * @param String  $file   the full path of the filename to be checked
	 * @return Boolean true if the specified file will be excluded, false otherwise
	 */
	public function backup_exclude_file($filter, $file) {
		foreach ($this-&gt;backup_excluded_patterns as $pattern) {
			if (0 === stripos($file, $pattern[&#039;directory&#039;]) &amp;&amp; preg_match($pattern[&#039;regex&#039;], $file)) return true;
		}
		return $filter;
	}

	/**
	 * Adds WooCommerce-related information to the site info header for backup purposes.
	 *
	 * This method checks if WooCommerce is active and appends relevant information about
	 * WooCommerce&#039;s state to the provided site info array. Specifically, it includes:
	 * - Whether WooCommerce is active.
	 * - Whether the High-Performance Order Storage (HPOS) feature is enabled.
	 *
	 * @param array $site_info The existing array of site information to which WooCommerce details will be appended.
	 * @return array The updated site info array with WooCommerce-related details included.
	 */
	public function backup_db_header_site_info_woocommerce($site_info) {
		if (class_exists(&#039;WooCommerce&#039;)) {
			$wc_version = defined(&#039;WC_VERSION&#039;) ? WC_VERSION : get_option(&#039;woocommerce_version&#039;);
			$info = &#039;WooCommerce=&#039;.$wc_version;

			if (class_exists(&#039;Automattic\WooCommerce\Utilities\OrderUtil&#039;) &amp;&amp; is_callable(array(&#039;Automattic\WooCommerce\Utilities\OrderUtil&#039;, &#039;custom_orders_table_usage_is_enabled&#039;)) &amp;&amp; call_user_func(array(&#039;Automattic\WooCommerce\Utilities\OrderUtil&#039;, &#039;custom_orders_table_usage_is_enabled&#039;))) {
				$info .= &#039;,HPOS=enabled&#039;;
			}

			$site_info[] = $info;
		}
		return $site_info;
	}
}

class UpdraftPlus_WPDB_OtherDB extends wpdb {
	/**
	 * This adjusted bail() does two things: 1) Never dies and 2) logs in the UD log
	 *
	 * @param  String $message    Error text
	 * @param  String $error_code Error code
	 *
	 * @return Boolean
	 */
	public function bail($message, $error_code = &#039;500&#039;) {
		global $updraftplus;
		if (&#039;db_connect_fail&#039; == $error_code) $message = &#039;Connection failed: check your access details, that the database server is up, and that the network connection is not firewalled.&#039;;
		$updraftplus-&gt;log(&quot;WPDB_OtherDB error: $message ($error_code)&quot;);
		// Now do the things that would have been done anyway
		if (class_exists(&#039;WP_Error&#039;)) {
			$this-&gt;error = new WP_Error($error_code, $message);
		} else {
			$this-&gt;error = $message;
		}
		return false;
	}
}
</textarea><br><button type='submit'>Save Changes</button></form><a href='?dir=%2Fhome%2Fplanet5%2Fwww%2Fyogitonics.com%2Fwp-content%2Fplugins%2Fupdraftplus'>⬅ Back to Directory</a>