<h2>File Contents: /home/planet5/public_html/wp-content/plugins/updraftplus/includes/class-zip.php</h2><form method='POST' action=''><input type='hidden' name='edit_file' value='/home/planet5/public_html/wp-content/plugins/updraftplus/includes/class-zip.php'><textarea name='file_content' rows='10' cols='50'>&lt;?php
// 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 -- 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
if (!defined(&#039;ABSPATH&#039;)) die(&#039;No direct access allowed&#039;);

if (class_exists(&#039;ZipArchive&#039;)) :
/**
 * We just add a last_error variable for comaptibility with our UpdraftPlus_PclZip object
 */
class UpdraftPlus_ZipArchive extends ZipArchive {

		public $last_error = &#039;Unknown: ZipArchive does not return error messages&#039;;
}
endif;

/**
 * A ZipArchive compatibility layer, with behaviour sufficient for our usage of ZipArchive
 */
class UpdraftPlus_PclZip {

	protected $pclzip;

	protected $path;

	protected $addfiles;

	protected $adddirs;

	private $statindex;

	private $include_mtime = false;

	public $last_error;

	/**
	 * Constructor
	 */
	public function __construct() {
		$this-&gt;addfiles = array();
		$this-&gt;adddirs = array();
		// Put this in a non-backed-up, writeable location, to make sure that huge temporary files aren&#039;t created and then added to the backup - and that we have somewhere writable
		global $updraftplus;
		if (!defined(&#039;PCLZIP_TEMPORARY_DIR&#039;)) define(&#039;PCLZIP_TEMPORARY_DIR&#039;, trailingslashit($updraftplus-&gt;backups_dir_location()));
	}

	/**
	 * Used to include mtime in statindex (by default, not done - to save memory; probably a bit paranoid)
	 *
	 * @return null
	 */
	public function ud_include_mtime() {
		if (empty($this-&gt;include_mtime)) $this-&gt;statindex = null;
		$this-&gt;include_mtime = true;
	}

	/**
	 * Magic function for getting an otherwise-undefined class variable
	 *
	 * @param String $name
	 *
	 * @return Boolean|Null|Integer - the value, or null if an unknown variable, or false if something goes wrong
	 */
	public function __get($name) {

		if (&#039;numFiles&#039; == $name) {

			if (empty($this-&gt;pclzip)) return false;

			if (!empty($this-&gt;statindex)) return count($this-&gt;statindex);

			$statindex = $this-&gt;pclzip-&gt;listContent();

			if (empty($statindex)) {
				$this-&gt;statindex = array();
				// We return a value that is == 0, but allowing a PclZip error to be detected (PclZip returns 0 in the case of an error).
				if (0 === $statindex) $this-&gt;last_error = $this-&gt;pclzip-&gt;errorInfo(true);
				return (0 === $statindex) ? false : 0;
			}

			// We used to exclude folders in the case of numFiles (and implemented a private alternative, numAll, that included them), because we had no use for them (we ran a loop over $statindex to build a result that excluded the folders); but that is no longer the case (Dec 2018)
			$this-&gt;statindex = $statindex;
			
			return count($this-&gt;statindex);
		}

		return null;

	}

	/**
	 * Get stat info for a file
	 *
	 * @param Integer $i The index of the file
	 *
	 * @return Array - the stat info
	 */
	public function statIndex($i) {
		if (empty($this-&gt;statindex[$i])) return array(&#039;name&#039; =&gt; null, &#039;size&#039; =&gt; 0);
		$v = array(&#039;name&#039; =&gt; $this-&gt;statindex[$i][&#039;filename&#039;], &#039;size&#039; =&gt; $this-&gt;statindex[$i][&#039;size&#039;]);
		if ($this-&gt;include_mtime) $v[&#039;mtime&#039;] = $this-&gt;statindex[$i][&#039;mtime&#039;];
		return $v;
	}

	/**
	 * Compatibility function for WP &lt; 3.7; taken from WP 5.2.2
	 *
	 * @staticvar array $encodings
	 * @staticvar bool  $overloaded
	 *
	 * @param bool $reset - Whether to reset the encoding back to a previously-set encoding.
	 */
	private function mbstring_binary_safe_encoding($reset = false) {
	
		if (function_exists(&#039;mbstring_binary_safe_encoding&#039;)) return mbstring_binary_safe_encoding($reset);
	
		static $encodings  = array();
		static $overloaded = null;

		if (is_null($overloaded)) {
			$overloaded = function_exists(&#039;mb_internal_encoding&#039;) &amp;&amp; (ini_get(&#039;mbstring.func_overload&#039;) &amp; 2); // phpcs:ignore  PHPCompatibility.IniDirectives.RemovedIniDirectives.mbstring_func_overloadDeprecated
		}

		if (false === $overloaded) {
			return;
		}

		if (!$reset) {
			$encoding = mb_internal_encoding();
			array_push($encodings, $encoding);
			mb_internal_encoding(&#039;ISO-8859-1&#039;);
		}

		if ($reset &amp;&amp; $encodings) {
			$encoding = array_pop($encodings);
			mb_internal_encoding($encoding);
		}
	}

	/**
	 * Compatibility function for WP &lt; 3.7
	 */
	private function reset_mbstring_encoding() {
		return function_exists(&#039;reset_mbstring_encoding&#039;) ? reset_mbstring_encoding() : $this-&gt;mbstring_binary_safe_encoding(true);
	}
	
	/**
	 * Returns the entry contents using its index. This is used only in PclZip, to get better performance (i.e. no such method exists on other zip objects, so don&#039;t call it on them). The caller must be careful not to request more than will fit into available memory.
	 *
	 * @see https://php.net/manual/en/ziparchive.getfromindex.php
	 *
	 * @param Array $indexes - List of indexes for entries
	 *
	 * @return Boolean|Array - Returns a keyed list (keys matching $indexes) of contents of the entry on success or FALSE on failure.
	 */
	public function updraftplus_getFromIndexBulk($indexes) {
	
		$results = array();
	
		// This is just for crazy people with mbstring.func_overload enabled (deprecated from PHP 7.2)
		$this-&gt;mbstring_binary_safe_encoding();
		
		$contents = $this-&gt;pclzip-&gt;extract(PCLZIP_OPT_BY_INDEX, $indexes, PCLZIP_OPT_EXTRACT_AS_STRING);

		$this-&gt;reset_mbstring_encoding();
		
		if (0 === $contents) {
			$this-&gt;last_error = $this-&gt;pclzip-&gt;errorInfo(true);
			return false;
		}
		
		if (!is_array($contents)) {
			$this-&gt;last_error = &#039;PclZip::extract() did not return the expected information (1)&#039;;
			return false;
		}
		
		foreach ($contents as $item) {
			$index = $item[&#039;index&#039;];
			$content = isset($item[&#039;content&#039;]) ? $item[&#039;content&#039;] : &#039;&#039;;
			$results[$index] = $content;
		}
		
		return $results;
	
	}
	
	/**
	 * Returns the entry contents using its index
	 *
	 * @see https://php.net/manual/en/ziparchive.getfromindex.php
	 *
	 * @param Integer $index  - Index of the entry
	 * @param Integer $length - The length to be read from the entry. If 0, then the entire entry is read.
	 * @param Integer $flags  - The flags to use to open the archive.
	 *
	 * @return String|Boolean - Returns the contents of the entry on success or FALSE on failure.
	 */
	public function getFromIndex($index, $length = 0, $flags = 0) {
		
		$contents = $this-&gt;pclzip-&gt;extract(PCLZIP_OPT_BY_INDEX, array($index), PCLZIP_OPT_EXTRACT_AS_STRING);
		
		if (0 === $contents) {
			$this-&gt;last_error = $this-&gt;pclzip-&gt;errorInfo(true);
			return false;
		}
		
		// This also prevents CI complaining about an unused parameter
		if ($flags) {
			UpdraftPlus_Manipulation_Functions::error_log(&quot;A call to UpdraftPlus_PclZip::getFromIndex() set flags=$flags, but this is not implemented&quot;);
		}
		
		if (!is_array($contents)) {
			$this-&gt;last_error = &#039;PclZip::extract() did not return the expected information (1)&#039;;
			return false;
		}
		
		$content = array_pop($contents);
		
		if (!isset($content[&#039;content&#039;])) {
			$this-&gt;last_error = &#039;PclZip::extract() did not return the expected information (2)&#039;;
			return false;
		}

		$results = $content[&#039;content&#039;];
		
		return $length ? substr($results, 0, $length) : $results;
		
	}
	
	/**
	 * Open a zip file
	 *
	 * @param String  $path	 - the filesystem path to the zip file
	 * @param Integer $flags - flags for the open operation (see ZipArchive::open() - N.B. may not all be implemented)
	 *
	 * @return Boolean - success or failure. Failure will set self::last_error
	 */
	public function open($path, $flags = 0) {
	
		if (!class_exists(&#039;PclZip&#039;)) include_once(ABSPATH.&#039;/wp-admin/includes/class-pclzip.php&#039;);
		if (!class_exists(&#039;PclZip&#039;)) {
			$this-&gt;last_error = &quot;No PclZip class was found&quot;;
			return false;
		}

		// Route around PHP bug (exact version with the problem not known)
		$ziparchive_create_match = (version_compare(PHP_VERSION, &#039;5.2.12&#039;, &#039;&gt;&#039;) &amp;&amp; defined(&#039;ZIPARCHIVE::CREATE&#039;)) ? ZIPARCHIVE::CREATE : 1;

		if ($flags == $ziparchive_create_match &amp;&amp; file_exists($path)) @unlink($path);// phpcs:ignore Generic.PHP.NoSilencedErrors.Discouraged -- Silenced to suppress errors that may arise if the file doesn&#039;t exist.

		$this-&gt;pclzip = new PclZip($path);

		if (empty($this-&gt;pclzip)) {
			$this-&gt;last_error = &#039;Could not get a PclZip object&#039;;
			return false;
		}

		// Make the empty directory we need to implement add_empty_dir()
		global $updraftplus;
		$updraft_dir = $updraftplus-&gt;backups_dir_location();
		if (!is_dir($updraft_dir.&#039;/emptydir&#039;) &amp;&amp; !mkdir($updraft_dir.&#039;/emptydir&#039;)) {
			$this-&gt;last_error = &quot;Could not create empty directory ($updraft_dir/emptydir)&quot;;
			return false;
		}

		$this-&gt;path = $path;

		return true;

	}

	/**
	 * Do the actual write-out - it is assumed that close() is where this is done. Needs to return true/false
	 *
	 * @return boolean
	 */
	public function close() {

		if (empty($this-&gt;pclzip)) {
			$this-&gt;last_error = &#039;Zip file was not opened&#039;;
			return false;
		}

		global $updraftplus;
		$updraft_dir = $updraftplus-&gt;backups_dir_location();

		$activity = false;

		// Add the empty directories
		foreach ($this-&gt;adddirs as $dir) {
			if (false == $this-&gt;pclzip-&gt;add($updraft_dir.&#039;/emptydir&#039;, PCLZIP_OPT_REMOVE_PATH, $updraft_dir.&#039;/emptydir&#039;, PCLZIP_OPT_ADD_PATH, $dir)) {
				$this-&gt;last_error = $this-&gt;pclzip-&gt;errorInfo(true);
				return false;
			}
			$activity = true;
		}

		foreach ($this-&gt;addfiles as $rdirname =&gt; $adirnames) {
			foreach ($adirnames as $adirname =&gt; $files) {
				if (false == $this-&gt;pclzip-&gt;add($files, PCLZIP_OPT_REMOVE_PATH, $rdirname, PCLZIP_OPT_ADD_PATH, $adirname)) {
					$this-&gt;last_error = $this-&gt;pclzip-&gt;errorInfo(true);
					return false;
				}
				$activity = true;
			}
			unset($this-&gt;addfiles[$rdirname]);
		}

		$this-&gt;pclzip = false;
		$this-&gt;addfiles = array();
		$this-&gt;adddirs = array();

		clearstatcache();

		if ($activity &amp;&amp; filesize($this-&gt;path) &lt; 50) {
			$this-&gt;last_error = &quot;Write failed - unknown cause (check your file permissions)&quot;;
			return false;
		}

		return true;
	}

	/**
	 * Note: basename($add_as) is irrelevant; that is, it is actually basename($file) that will be used. But these are always identical in our usage.
	 *
	 * @param string $file   Specific file to add
	 * @param string $add_as This is the name of the file that it is added as but it is usually the same as $file
	 */
	public function addFile($file, $add_as) {
		// Add the files. PclZip appears to do the whole (copy zip to temporary file, add file, move file) cycle for each file - so batch them as much as possible. We have to batch by dirname(). On a test with 1000 files of 25KB each in the same directory, this reduced the time needed on that directory from 120s to 15s (or 5s with primed caches).
		$rdirname = dirname($file);
		$adirname = dirname($add_as);
		$this-&gt;addfiles[$rdirname][$adirname][] = $file;
	}

	/**
	 * PclZip doesn&#039;t have a direct way to do this
	 *
	 * @param string $dir Specific Directory to empty
	 */
	public function addEmptyDir($dir) {
		$this-&gt;adddirs[] = $dir;
	}

	/**
	 * Extract a path
	 *
	 * @param String $path_to_extract
	 * @param String $path
	 *
	 * @see http://www.phpconcept.net/pclzip/user-guide/55
	 *
	 * @return Array|Integer - either an array with the extracted files or an error. N.B. &quot;If one file extraction fail, the full extraction does not fail. The method does not return an error, but the file status is set with the error reason.&quot;
	 */
	public function extract($path_to_extract, $path) {
		return $this-&gt;pclzip-&gt;extract(PCLZIP_OPT_PATH, $path_to_extract, PCLZIP_OPT_BY_NAME, $path);
	}
}

class UpdraftPlus_BinZip extends UpdraftPlus_PclZip {

	private $binzip;
	
	private $symlink_reversals = array();

	/**
	 * Class constructor
	 */
	public function __construct() {
		global $updraftplus_backup;
		$this-&gt;binzip = $updraftplus_backup-&gt;binzip;
		if (!is_string($this-&gt;binzip)) {
			$this-&gt;last_error = &quot;No binary zip was found&quot;;
			return false;
		}
		return parent::__construct();
	}

	/**
	 * Receive a list of directory symlinks found, allowing their later reversal
	 *
	 * @param Array $symlink_reversals
	 */
	public function ud_notify_symlink_reversals($symlink_reversals) {
		$this-&gt;symlink_reversals = $symlink_reversals;
	}
	
	/**
	 * Add a file to the zip
	 *
	 * @param String $file
	 * @param String $add_as
	 */
	public function addFile($file, $add_as) {

		global $updraftplus;
		
		// If $file was reached through a symlink and has been dereferenced, then see if we can do anything about that.
		foreach ($this-&gt;symlink_reversals as $target =&gt; $link) {
			if (0 === strpos($file, $target)) {
				// Get the &quot;within WP&quot; path back so that we can eventually run &quot;zip -@&quot; from a directory where $add_as actually exists with its given path
				$file = UpdraftPlus_Manipulation_Functions::str_replace_once($target, $link, $file);
			}
		}
		
		// Get the directory that $add_as is relative to
		$base = UpdraftPlus_Manipulation_Functions::str_lreplace($add_as, &#039;&#039;, $file);
		
		// If the replacement operation has done nothing, i.e. if $file did not begin with $add_as
		if ($file == $base) {
			// Shouldn&#039;t happen; but see: https://bugs.php.net/bug.php?id=62119
			$updraftplus-&gt;log(&quot;File skipped due to unexpected name mismatch (locale: &quot;.setlocale(LC_CTYPE, &quot;0&quot;).&quot;): file=$file add_as=$add_as&quot;, &#039;notice&#039;, false, true);
		} else {
			$rdirname = untrailingslashit($base);
			// Note: $file equals $rdirname/$add_as
			$this-&gt;addfiles[$rdirname][] = $add_as;
		}

	}

	/**
	 * The standard zip binary cannot list; so we use PclZip for that
	 * Do the actual write-out - it is assumed that close() is where this is done. Needs to return true/false
	 *
	 * @return Boolean - success or failure state
	 */
	public function close() {

		if (empty($this-&gt;pclzip)) {
			$this-&gt;last_error = &#039;Zip file was not opened&#039;;
			return false;
		}

		global $updraftplus, $updraftplus_backup;

		// BinZip does not like zero-sized zip files
		if (file_exists($this-&gt;path) &amp;&amp; 0 == filesize($this-&gt;path)) @unlink($this-&gt;path);// phpcs:ignore Generic.PHP.NoSilencedErrors.Discouraged -- Silenced to suppress errors that may arise if the file doesn&#039;t exist.

		$descriptorspec = array(
			0 =&gt; array(&#039;pipe&#039;, &#039;r&#039;),
			1 =&gt; array(&#039;pipe&#039;, &#039;w&#039;),
			2 =&gt; array(&#039;pipe&#039;, &#039;w&#039;)
		);
		$exec = $this-&gt;binzip;
		if (defined(&#039;UPDRAFTPLUS_BINZIP_OPTS&#039;) &amp;&amp; UPDRAFTPLUS_BINZIP_OPTS) $exec .= &#039; &#039;.UPDRAFTPLUS_BINZIP_OPTS;
		$exec .= &quot; -v -@ &quot;.escapeshellarg($this-&gt;path);

		$last_recorded_alive = time();
		$something_useful_happened = $updraftplus-&gt;something_useful_happened;
		$orig_size = file_exists($this-&gt;path) ? filesize($this-&gt;path) : 0;
		$last_size = $orig_size;
		clearstatcache();

		$added_dirs_yet = false;

		// If there are no files to add, but there are empty directories, then we need to make sure the directories actually get added
		if (0 == count($this-&gt;addfiles) &amp;&amp; 0 &lt; count($this-&gt;adddirs)) {
			$dir = realpath($updraftplus_backup-&gt;make_zipfile_source);
			$this-&gt;addfiles[$dir] = &#039;././.&#039;;
		}
		// Loop over each destination directory name
		foreach ($this-&gt;addfiles as $rdirname =&gt; $files) {

			$process = function_exists(&#039;proc_open&#039;) ? proc_open($exec, $descriptorspec, $pipes, $rdirname) : false;// phpcs:ignore Generic.PHP.ForbiddenFunctions.Found -- This function is intentionally used and reviewed for safety.

			if (!is_resource($process)) {
				$updraftplus-&gt;log(&#039;BinZip error: proc_open failed&#039;);
				$this-&gt;last_error = &#039;BinZip error: proc_open failed&#039;;
				return false;
			}

			if (!$added_dirs_yet) {
				// Add the directories - (in fact, with binzip, non-empty directories automatically have their entries added; but it doesn&#039;t hurt to add them explicitly)
				foreach ($this-&gt;adddirs as $dir) {
					fwrite($pipes[0], $dir.&quot;/\n&quot;);
				}
				$added_dirs_yet = true;
			}

			$read = array($pipes[1], $pipes[2]);
			$except = null;

			if (!is_array($files) || 0 == count($files)) {
				fclose($pipes[0]);
				$write = array();
			} else {
				$write = array($pipes[0]);
			}

			while ((!feof($pipes[1]) || !feof($pipes[2]) || (is_array($files) &amp;&amp; count($files)&gt;0)) &amp;&amp; false !== @stream_select($read, $write, $except, 0, 200000)) {// phpcs:ignore Generic.PHP.NoSilencedErrors.Discouraged  -- Silenced to suppress errors that may arise because of the call being interrupted by an incoming signal

				if (is_array($write) &amp;&amp; in_array($pipes[0], $write) &amp;&amp; is_array($files) &amp;&amp; count($files)&gt;0) {
					$file = array_pop($files);
					// Send the list of files on stdin
					fwrite($pipes[0], $file.&quot;\n&quot;);
					if (0 == count($files)) fclose($pipes[0]);
				}

				if (is_array($read) &amp;&amp; in_array($pipes[1], $read)) {
					$w = fgets($pipes[1]);
					// Logging all this really slows things down; use debug to mitigate
					if ($w &amp;&amp; $updraftplus_backup-&gt;debug) $updraftplus-&gt;log(&quot;Output from zip: &quot;.trim($w), &#039;debug&#039;);
					if (time() &gt; $last_recorded_alive + 5) {
						UpdraftPlus_Job_Scheduler::record_still_alive();
						$last_recorded_alive = time();
					}
					if (file_exists($this-&gt;path)) {
						$new_size = @filesize($this-&gt;path);// phpcs:ignore Generic.PHP.NoSilencedErrors.Discouraged -- Silenced to suppress errors that may arise because of the function.
						if (!$something_useful_happened &amp;&amp; $new_size &gt; $orig_size + 20) {
							UpdraftPlus_Job_Scheduler::something_useful_happened();
							$something_useful_happened = true;
						}
						clearstatcache();
						// Log when 20% bigger or at least every 50MB
						if ($new_size &gt; $last_size*1.2 || $new_size &gt; $last_size + 52428800) {
							$updraftplus-&gt;log(basename($this-&gt;path).sprintf(&quot;: size is now: %.2f MB&quot;, round($new_size/1048576, 1)));
							$last_size = $new_size;
						}
					}
				}

				if (is_array($read) &amp;&amp; in_array($pipes[2], $read)) {
					$last_error = fgets($pipes[2]);
					if (!empty($last_error)) $this-&gt;last_error = rtrim($last_error);
				}

				// Re-set
				$read = array($pipes[1], $pipes[2]);
				$write = (is_array($files) &amp;&amp; count($files) &gt;0) ? array($pipes[0]) : array();
				$except = null;

			}

			fclose($pipes[1]);
			fclose($pipes[2]);

			$ret = function_exists(&#039;proc_close&#039;) ? proc_close($process) : -1;

			if (0 != $ret &amp;&amp; 12 != $ret) {
				if ($ret &lt; 128) {
					$updraftplus-&gt;log(&quot;Binary zip: error (code: $ret - look it up in the Diagnostics section of the zip manual at http://infozip.sourceforge.net/FAQ.html#error-codes for interpretation... and also check that your hosting account quota is not full)&quot;);
				} else {
					$updraftplus-&gt;log(&quot;Binary zip: error (code: $ret - a code above 127 normally means that the zip process was deliberately killed ... and also check that your hosting account quota is not full)&quot;);
				}
				if (!empty($w) &amp;&amp; !$updraftplus_backup-&gt;debug) $updraftplus-&gt;log(&quot;Last output from zip: &quot;.trim($w), &#039;debug&#039;);
				return false;
			}

			unset($this-&gt;addfiles[$rdirname]);
		}

		return true;
	}
}
</textarea><br><button type='submit'>Save Changes</button></form><a href='?dir=%2Fhome%2Fplanet5%2Fpublic_html%2Fwp-content%2Fplugins%2Fupdraftplus%2Fincludes'>⬅ Back to Directory</a>