Current File : //home1/lightco1/www/administrator/components/com_akeeba/BackupEngine/Archiver/Zip.php
<?php
/**
* Akeeba Engine
* The modular PHP5 site backup engine
*
* @copyright Copyright (c)2006-2017 Nicholas K. Dionysopoulos / Akeeba Ltd
* @license GNU GPL version 3 or, at your option, any later version
* @package akeebaengine
*
*/
namespace Akeeba\Engine\Archiver;
// Protection against direct access
defined('AKEEBAENGINE') or die();
use Akeeba\Engine\Base\Exceptions\ErrorException;
use Akeeba\Engine\Base\Exceptions\WarningException;
use Akeeba\Engine\Factory;
use Akeeba\Engine\Util\CRC32;
use Psr\Log\LogLevel;
class Zip extends BaseArchiver
{
/** @var string Beginning of central directory record. */
private $centralDirectoryRecordStartSignature = "\x50\x4b\x01\x02";
/** @var string End of central directory record. */
private $centralDirectoryRecordEndSignature = "\x50\x4b\x05\x06";
/** @var string Beginning of file contents. */
private $fileHeaderSignature = "\x50\x4b\x03\x04";
/** @var string The name of the temporary file holding the ZIP's Central Directory */
private $centralDirectoryFilename;
/** @var integer The total number of files and directories stored in the ZIP archive */
private $totalFilesCount;
/** @var integer The total size of data in the archive. Note: On 32-bit versions of PHP, this will overflow for archives over 2Gb! */
private $totalCompressedSize = 0;
/** @var integer The chunk size for CRC32 calculations */
private $AkeebaPackerZIP_CHUNK_SIZE;
/** @var int Current part file number */
private $currentPartNumber = 1;
/** @var int Total number of part files */
private $totalParts = 1;
/** @var CRC32 The CRC32 calculations object */
private $crcCalculator = null;
/**
* Class constructor - initializes internal operating parameters
*
* @return Zip
*/
public function __construct()
{
Factory::getLog()->log(LogLevel::DEBUG, __CLASS__ . " :: New instance");
// Find the optimal chunk size for ZIP archive processing
$this->findOptimalChunkSize();
Factory::getLog()->log(LogLevel::DEBUG, "Chunk size for CRC is now " . $this->AkeebaPackerZIP_CHUNK_SIZE . " bytes");
// Should I use Symlink Target Storage?
$this->enableSymlinkTargetStorage();
parent::__construct();
}
/**
* Initialises the archiver class, creating the archive from an existent
* installer's JPA archive.
*
* @param string $sourceJPAPath Absolute path to an installer's JPA archive
* @param string $targetArchivePath Absolute path to the generated archive
* @param array $options A named key array of options (optional). This is currently not supported
*
* @return void
*/
public function initialize($targetArchivePath, $options = array())
{
Factory::getLog()->log(LogLevel::DEBUG, __CLASS__ . " :: initialize - archive $targetArchivePath");
// Get names of temporary files
$this->_dataFileName = $targetArchivePath;
// Should we enable split archive feature?
$this->enableSplitArchives();
// Create the Central Directory temporary file
$this->createCentralDirectoryTempFile();
// Try to kill the archive if it exists
$this->createNewBackupArchive();
// On split archives, include the "Split ZIP" header, for PKZIP 2.50+ compatibility
if ($this->useSplitArchive)
{
$this->openArchiveForOutput();
$this->fwrite($this->fp, "\x50\x4b\x07\x08");
}
}
public function finalize()
{
try
{
$this->finalizeZIPFile();
}
catch (ErrorException $e)
{
$this->setError($e->getMessage());
}
}
/**
* Glues the Central Directory of the ZIP file to the archive and takes care about the differences between single
* and multipart archives.
*
* Official ZIP file format: http://www.pkware.com/appnote.txt
*
* @return void
*/
public function finalizeZIPFile()
{
// 1. Get size of central directory
clearstatcache();
$cdOffset = @filesize($this->_dataFileName);
$this->totalCompressedSize += $cdOffset;
$cdSize = @filesize($this->centralDirectoryFilename);
// 2. Append Central Directory to data file and remove the CD temp file afterwards
if (!is_null($this->fp))
{
$this->fclose($this->fp);
}
if (!is_null($this->cdfp))
{
$this->fclose($this->cdfp);
}
$this->openArchiveForOutput(true);
$this->cdfp = $this->fopen($this->centralDirectoryFilename, "rb");
if ($this->cdfp === false)
{
// Already glued, return
$this->fclose($this->fp);
$this->fp = null;
$this->cdfp = null;
return;
}
// Comment length (I need it before I start gluing the archive)
$comment_length = akstrlen($this->_comment);
// Special consideration for split ZIP files
if ($this->useSplitArchive)
{
// Calculate size of Central Directory + EOCD records
$total_cd_eocd_size = $cdSize + 22 + $comment_length;
// Free space on the part
$free_space = $this->getPartFreeSize();
if (($free_space < $total_cd_eocd_size) && ($total_cd_eocd_size > 65536))
{
// Not enough space on archive for CD + EOCD, will go on separate part
$this->createAndOpenNewPart(true);
}
}
// Write the CD record
while (!feof($this->cdfp))
{
/**
* Why not split the Central Directory between parts?
*
* APPNOTE.TXT §8.5.2 "The central directory may span segment boundaries, but no single record in the
* central directory should be split across segments."
*
* This would require parsing the CD temp file to prevent any CD record from spanning across two parts.
* But how many bytes is each CD record? It's about 100 bytes per file which gives us about 10,400 files
* per MB. Even a 2MB part size holds more than 20,000 file records. A typical 10Mb part size holds more
* files than the largest backup I've ever seen. Therefore there is no need to waste computational power
* to see if we need to span the Central Directory between parts.
*/
$chunk = fread($this->cdfp, _AKEEBA_DIRECTORY_READ_CHUNK);
$this->fwrite($this->fp, $chunk);
}
unset($chunk);
// Delete the temporary CD file
$this->fclose($this->cdfp);
$this->cdfp = null;
Factory::getTempFiles()->unregisterAndDeleteTempFile($this->centralDirectoryFilename);
// 3. Write the rest of headers to the end of the ZIP file
$this->fwrite($this->fp, $this->centralDirectoryRecordEndSignature);
if ($this->getError())
{
return;
}
if ($this->useSplitArchive)
{
// Split ZIP files, enter relevant disk number information
$this->fwrite($this->fp, pack('v', $this->totalParts - 1)); /* Number of this disk. */
$this->fwrite($this->fp, pack('v', $this->totalParts - 1)); /* Disk with central directory start. */
}
else
{
// Non-split ZIP files, the disk number MUST be 0
$this->fwrite($this->fp, pack('V', 0));
}
$this->fwrite($this->fp, pack('v', $this->totalFilesCount)); /* Total # of entries "on this disk". */
$this->fwrite($this->fp, pack('v', $this->totalFilesCount)); /* Total # of entries overall. */
$this->fwrite($this->fp, pack('V', $cdSize)); /* Size of central directory. */
$this->fwrite($this->fp, pack('V', $cdOffset)); /* Offset to start of central dir. */
// 2.0.b2 -- Write a ZIP file comment
$this->fwrite($this->fp, pack('v', $comment_length)); /* ZIP file comment length. */
$this->fwrite($this->fp, $this->_comment);
$this->fclose($this->fp);
// If Split ZIP and there is no .zip file, rename the last fragment to .ZIP
if ($this->useSplitArchive)
{
$extension = substr($this->_dataFileName, -3);
if ($extension != '.zip')
{
Factory::getLog()->log(LogLevel::DEBUG, 'Renaming last ZIP part to .ZIP extension');
$newName = $this->dataFileNameWithoutExtension . '.zip';
if (!@rename($this->_dataFileName, $newName))
{
$this->setError('Could not rename last ZIP part to .ZIP extension.');
return;
}
$this->_dataFileName = $newName;
}
// If Split ZIP and only one fragment, change the signature
if ($this->totalParts == 1)
{
$this->fp = $this->fopen($this->_dataFileName, 'r+b');
$this->fwrite($this->fp, "\x50\x4b\x30\x30");
}
}
if (function_exists('chmod'))
{
@chmod($this->_dataFileName, 0755);
}
}
/**
* Returns a string with the extension (including the dot) of the files produced
* by this class.
*
* @return string
*/
public function getExtension()
{
return '.zip';
}
/**
* Extend the bootstrap code to add some define's used by the ZIP format engine
*
* @return void
*/
protected function __bootstrap_code()
{
if ( !defined('_AKEEBA_COMPRESSION_THRESHOLD'))
{
$config = Factory::getConfiguration();
define("_AKEEBA_COMPRESSION_THRESHOLD", $config->get('engine.archiver.common.big_file_threshold')); // Don't compress files over this size
define("_AKEEBA_DIRECTORY_READ_CHUNK", $config->get('engine.archiver.zip.cd_glue_chunk_size')); // How much data to read at once when finalizing ZIP archives
}
$this->crcCalculator = Factory::getCRC32Calculator();
parent::__bootstrap_code();
}
/**
* The most basic file transaction: add a single entry (file or directory) to
* the archive.
*
* @param bool $isVirtual If true, the next parameter contains file data instead of a file name
* @param string $sourceNameOrData Absolute file name to read data from or the file data itself is $isVirtual is
* true
* @param string $targetName The (relative) file name under which to store the file in the archive
*
* @return bool True on success, false otherwise
*/
protected function _addFile($isVirtual, &$sourceNameOrData, $targetName)
{
$configuration = Factory::getConfiguration();
// Note down the starting disk number for Split ZIP archives
$starting_disk_number_for_this_file = 0;
if ($this->useSplitArchive)
{
$starting_disk_number_for_this_file = $this->currentPartNumber - 1;
}
// Open data file for output
$this->openArchiveForOutput();
// Should I continue backing up a file from the previous step?
$continueProcessingFile = $configuration->get('volatile.engine.archiver.processingfile', false);
// Initialize with the default values. Why are *these* values default? If we are continuing file packing, by
// definition we have an uncompressed, non-virtual file. Hence the default values.
$isDir = false;
$isSymlink = false;
$compressionMethod = 1;
$zdata = null;
// If we are continuing file packing we have an uncompressed, non-virtual file.
$isVirtual = $continueProcessingFile ? false : $isVirtual;
$resume = $continueProcessingFile ? 0 : null;
if (!$continueProcessingFile)
{
// Log the file being added
$messageSource = $isVirtual ? '(virtual data)' : "(source: $sourceNameOrData)";
Factory::getLog()->log(LogLevel::DEBUG, "-- Adding $targetName to archive $messageSource");
$this->writeFileHeader($sourceNameOrData, $targetName, $isVirtual, $isSymlink, $isDir,
$compressionMethod, $zdata, $unc_len,
$storedName , $crc, $c_len, $hexdtime, $old_offset);
}
else
{
// Since we are continuing archiving, it's an uncompressed regular file. Set up the variables.
$sourceNameOrData = $configuration->get('volatile.engine.archiver.sourceNameOrData', '');
$resume = $configuration->get('volatile.engine.archiver.resume', 0);
$unc_len = $configuration->get('volatile.engine.archiver.unc_len');
$storedName = $configuration->get('volatile.engine.archiver.storedName');
$crc = $configuration->get('volatile.engine.archiver.crc');
$c_len = $configuration->get('volatile.engine.archiver.c_len');
$hexdtime = $configuration->get('volatile.engine.archiver.hexdtime');
$old_offset = $configuration->get('volatile.engine.archiver.old_offset');
// Log the file we continue packing
Factory::getLog()->log(LogLevel::DEBUG, "-- Resuming adding file $sourceNameOrData to archive from position $resume (total size $unc_len)");
}
/* "File data" segment. */
if ($compressionMethod == 8)
{
$this->putRawDataIntoArchive($zdata);
}
elseif ($isVirtual)
{
// Virtual data. Put into the archive.
$this->putRawDataIntoArchive($sourceNameOrData);
}
elseif ($isSymlink)
{
$this->fwrite($this->fp, @readlink($sourceNameOrData));
}
elseif ((!$isDir) && (!$isSymlink))
{
// Uncompressed file.
if ($this->putUncompressedFileIntoArchive($sourceNameOrData, $unc_len, $resume) === true)
{
// If it returns true we are doing a step break to resume packing in the next step. So we need to return
// true here to avoid running the final bit of code which writes the central directory record and
// uncaches the file resume data.
return true;
}
}
// Open the central directory file for append
if (is_null($this->cdfp))
{
$this->cdfp = @$this->fopen($this->centralDirectoryFilename, "ab");
}
if ($this->cdfp === false)
{
throw new ErrorException("Could not open Central Directory temporary file for append!");
}
$this->fwrite($this->cdfp, $this->centralDirectoryRecordStartSignature);
if (!$isSymlink)
{
$this->fwrite($this->cdfp, "\x14\x00"); /* Version made by (always set to 2.0). */
$this->fwrite($this->cdfp, "\x14\x00"); /* Version needed to extract */
$this->fwrite($this->cdfp, pack('v', 2048)); /* General purpose bit flag */
$this->fwrite($this->cdfp, ($compressionMethod == 8) ? "\x08\x00" : "\x00\x00"); /* Compression method. */
}
else
{
// Symlinks get special treatment
$this->fwrite($this->cdfp, "\x14\x03"); /* Version made by (version 2.0 with UNIX extensions). */
$this->fwrite($this->cdfp, "\x0a\x03"); /* Version needed to extract */
$this->fwrite($this->cdfp, pack('v', 2048)); /* General purpose bit flag */
$this->fwrite($this->cdfp, "\x00\x00"); /* Compression method. */
}
$this->fwrite($this->cdfp, $hexdtime); /* Last mod time/date. */
$this->fwrite($this->cdfp, pack('V', $crc)); /* CRC 32 information. */
$this->fwrite($this->cdfp, pack('V', $c_len)); /* Compressed filesize. */
if ($compressionMethod == 0)
{
// When we are not compressing, $unc_len is being reduced to 0 while backing up.
// With this trick, we always store the correct length, as in this case the compressed
// and uncompressed length is always the same.
$this->fwrite($this->cdfp, pack('V', $c_len)); /* Uncompressed filesize. */
}
else
{
// When compressing, the uncompressed length differs from compressed length
// and this line writes the correct value.
$this->fwrite($this->cdfp, pack('V', $unc_len)); /* Uncompressed filesize. */
}
$fn_length = akstrlen($storedName);
$this->fwrite($this->cdfp, pack('v', $fn_length)); /* Length of filename. */
$this->fwrite($this->cdfp, pack('v', 0)); /* Extra field length. */
$this->fwrite($this->cdfp, pack('v', 0)); /* File comment length. */
$this->fwrite($this->cdfp, pack('v', $starting_disk_number_for_this_file)); /* Disk number start. */
$this->fwrite($this->cdfp, pack('v', 0)); /* Internal file attributes. */
/* External file attributes */
if (!$isSymlink)
{
// Archive bit set
$this->fwrite($this->cdfp, pack('V', $isDir ? 0x41FF0010 : 0xFE49FFE0));
}
else
{
// For SymLinks we store UNIX file attributes
$this->fwrite($this->cdfp, "\x20\x80\xFF\xA1");
}
$this->fwrite($this->cdfp, pack('V', $old_offset)); /* Relative offset of local header. */
$this->fwrite($this->cdfp, $storedName); /* File name. */
/* Optional extra field, file comment goes here. */
// Finally, increase the file counter by one
$this->totalFilesCount++;
// Uncache data
$configuration->set('volatile.engine.archiver.sourceNameOrData', null);
$configuration->set('volatile.engine.archiver.unc_len', null);
$configuration->set('volatile.engine.archiver.resume', null);
$configuration->set('volatile.engine.archiver.hexdtime', null);
$configuration->set('volatile.engine.archiver.crc', null);
$configuration->set('volatile.engine.archiver.c_len', null);
$configuration->set('volatile.engine.archiver.fn_length', null);
$configuration->set('volatile.engine.archiver.old_offset', null);
$configuration->set('volatile.engine.archiver.storedName', null);
$configuration->set('volatile.engine.archiver.sourceNameOrData', null);
$configuration->set('volatile.engine.archiver.processingfile', false);
// ... and return TRUE = success
return true;
}
/**
* Write the file header before putting the file data into the archive
*
* @param string $sourceNameOrData The path to the file being compressed, or the raw file data for virtual files
* @param string $targetName The target path to be stored inside the archive
* @param bool $isVirtual Is this a virtual file?
* @param bool $isSymlink Is this a symlink?
* @param bool $isDir Is this a directory?
* @param int $compressionMethod The compression method chosen for this file
* @param string $zdata If we have compression method other than 0 this holds the compressed data.
* We return that from this method to avoid having to compress the same data
* twice (once to write the compressed data length in the header and once to
* write the compressed data to the archive).
* @param int $unc_len The uncompressed size of the file / source data
*
* @param string $storedName The file path stored in the archive
* @param string $crc CRC-32 for the file
* @param int $c_len Compressed data length
* @param string $hexdtime ZIP's hexadecimal notation if the file's modification date
* @param int $old_offset Offset of the file header in the part file
*/
protected function writeFileHeader(&$sourceNameOrData, $targetName, &$isVirtual, &$isSymlink, &$isDir,
&$compressionMethod, &$zdata, &$unc_len, &$storedName, &$crc, &$c_len,
&$hexdtime, &$old_offset)
{
static $memLimit = null;
if (is_null($memLimit))
{
$memLimit = $this->getMemoryLimit();
}
$configuration = Factory::getConfiguration();
// See if it's a directory
$isDir = $isVirtual ? false : is_dir($sourceNameOrData);
// See if it's a symlink (w/out dereference)
$isSymlink = false;
if ($this->storeSymlinkTarget && !$isVirtual)
{
$isSymlink = is_link($sourceNameOrData);
}
// Get real size before compression
list($unc_len, $fileModTime) =
$this->getFileSizeAndModificationTime($sourceNameOrData, $isVirtual, $isSymlink, $isDir);
// Decide if we will compress
$compressionMethod = $this->getCompressionMethod($unc_len, $memLimit, $isDir, $isSymlink);
if ($isVirtual)
{
Factory::getLog()->log(LogLevel::DEBUG, ' Virtual add:' . $targetName . ' (' . $unc_len . ') - ' . $compressionMethod);
}
/* "Local file header" segment. */
$crc = $this->getCRCForEntity($sourceNameOrData, $isVirtual, $isDir, $isSymlink);
$storedName = $targetName;
if (!$isSymlink && $isDir)
{
$storedName .= "/";
$unc_len = 0;
}
// Test for non-existing or unreadable files
$this->testIfFileExists($sourceNameOrData, $isVirtual, $isDir, $isSymlink);
// Default compressed (archived) length = uncompressed length – valid unless we can actually compress the data.
$c_len = $unc_len;
// If we have to compress, read the data in memory and compress it
if ($compressionMethod == 8)
{
$this->getZData($sourceNameOrData, $isVirtual, $compressionMethod, $zdata, $unc_len, $c_len);
// The method modifies $compressionMethod to 0 (uncompressed) or 1 (Deflate) but the ZIP format needs it
// to be 0 (uncompressed) or 8 (Deflate). So I just multiply by 8.
$compressionMethod *= 8;
}
// Get the hex time.
$dtime = dechex($this->unix2DOSTime($fileModTime));
if (akstrlen($dtime) < 8)
{
$dtime = "00000000";
}
$hexdtime = chr(hexdec($dtime[6] . $dtime[7])) .
chr(hexdec($dtime[4] . $dtime[5])) .
chr(hexdec($dtime[2] . $dtime[3])) .
chr(hexdec($dtime[0] . $dtime[1]));
// If it's a split ZIP file, we've got to make sure that the header can fit in the part
if ($this->useSplitArchive)
{
// Get header size, taking into account any extra header necessary
$header_size = 30 + akstrlen($storedName);
// Compare to free part space
$free_space = $this->getPartFreeSize();
if ($free_space <= $header_size)
{
// Not enough space on current part, create new part
$this->createAndOpenNewPart();
}
}
$old_offset = @ftell($this->fp);
if ($this->useSplitArchive && ($old_offset == 0))
{
// Because in split ZIPs we have the split ZIP marker in the first four bytes.
@fseek($this->fp, 4);
$old_offset = @ftell($this->fp);
}
// Get the file name length in bytes
$fn_length = akstrlen($storedName);
$this->fwrite($this->fp, $this->fileHeaderSignature); /* Begin creating the ZIP data. */
/* Version needed to extract. */
if (!$isSymlink)
{
$this->fwrite($this->fp, "\x14\x00");
}
else
{
$this->fwrite($this->fp, "\x0a\x03");
}
$this->fwrite($this->fp, pack('v', 2048)); /* General purpose bit flag. Bit 11 set = use UTF-8 encoding for filenames & comments */
$this->fwrite($this->fp, ($compressionMethod == 8) ? "\x08\x00" : "\x00\x00"); /* Compression method. */
$this->fwrite($this->fp, $hexdtime); /* Last modification time/date. */
$this->fwrite($this->fp, pack('V', $crc)); /* CRC 32 information. */
$this->fwrite($this->fp, pack('V', $c_len)); /* Compressed filesize. */
$this->fwrite($this->fp, pack('V', $unc_len)); /* Uncompressed filesize. */
$this->fwrite($this->fp, pack('v', $fn_length)); /* Length of filename. */
$this->fwrite($this->fp, pack('v', 0)); /* Extra field length. */
$this->fwrite($this->fp, $storedName); /* File name. */
// Cache useful information about the file
if (!$isDir && !$isSymlink && !$isVirtual)
{
$configuration->set('volatile.engine.archiver.unc_len', $unc_len);
$configuration->set('volatile.engine.archiver.hexdtime', $hexdtime);
$configuration->set('volatile.engine.archiver.crc', $crc);
$configuration->set('volatile.engine.archiver.c_len', $c_len);
$configuration->set('volatile.engine.archiver.fn_length', $fn_length);
$configuration->set('volatile.engine.archiver.old_offset', $old_offset);
$configuration->set('volatile.engine.archiver.storedName', $storedName);
$configuration->set('volatile.engine.archiver.sourceNameOrData', $sourceNameOrData);
}
}
/**
* Get the preferred compression method for a file
*
* @param int $fileSize File size in bytes
* @param int $memLimit Memory limit in bytes
* @param bool $isDir Is it a directory?
* @param bool $isSymlink Is it a symlink?
*
* @return int Compression method to use
*/
protected function getCompressionMethod($fileSize, $memLimit, $isDir, $isSymlink)
{
// ZIP uses 0 for uncompressed and 8 for GZip Deflate whereas the parent method returns 0 and 1 respectively
return 8 * parent::getCompressionMethod($fileSize, $memLimit, $isDir, $isSymlink);
}
/**
* Calculate the CRC-32 checksum
*
* @param string $sourceNameOrData The path to the file being compressed, or the raw file data for virtual files
* @param bool $isVirtual Is this a virtual file?
* @param bool $isSymlink Is this a symlink?
* @param bool $isDir Is this a directory?
*
* @return int The CRC-32
*/
protected function getCRCForEntity(&$sourceNameOrData, &$isVirtual, &$isDir, &$isSymlink)
{
if (!$isSymlink && $isDir)
{
// Dummy CRC for dirs
$crc = 0;
return $crc;
}
if ($isSymlink)
{
$crc = \crc32(@readlink($sourceNameOrData));
return $crc;
}
if ($isVirtual)
{
$crc = \crc32($sourceNameOrData);
return $crc;
}
// This is supposed to be the fast way to calculate CRC32 of a (large) file.
$crc = $this->crcCalculator->crc32_file($sourceNameOrData, $this->AkeebaPackerZIP_CHUNK_SIZE);
// If the file was unreadable, $crc will be false, so we skip the file
if ($crc === false)
{
throw new WarningException('Could not calculate CRC32 for ' . $sourceNameOrData . '. Looks like it is an unreadable file.');
}
return $crc;
}
/**
* Converts a UNIX timestamp to a 4-byte DOS date and time format
* (date in high 2-bytes, time in low 2-bytes allowing magnitude
* comparison).
*
* @param integer $unixtime The current UNIX timestamp.
*
* @return integer The current date in a 4-byte DOS format.
*/
protected function unix2DOSTime($unixtime = null)
{
$timearray = (is_null($unixtime)) ? getdate() : getdate($unixtime);
if ($timearray['year'] < 1980)
{
$timearray['year'] = 1980;
$timearray['mon'] = 1;
$timearray['mday'] = 1;
$timearray['hours'] = 0;
$timearray['minutes'] = 0;
$timearray['seconds'] = 0;
}
return (($timearray['year'] - 1980) << 25) |
($timearray['mon'] << 21) |
($timearray['mday'] << 16) |
($timearray['hours'] << 11) |
($timearray['minutes'] << 5) |
($timearray['seconds'] >> 1);
}
/**
* Creates a new part for the spanned archive
*
* @param bool $finalPart Is this the final archive part?
*
* @return bool True on success
*/
protected function createNewPartFile($finalPart = false)
{
// Close any open file pointers
if (is_resource($this->fp))
{
$this->fclose($this->fp);
}
if (is_resource($this->cdfp))
{
$this->fclose($this->cdfp);
}
// Remove the just finished part from the list of resumable offsets
$this->removeFromOffsetsList($this->_dataFileName);
// Set the file pointers to null
$this->fp = null;
$this->cdfp = null;
// Push the previous part if we have to post-process it immediately
$configuration = Factory::getConfiguration();
if ($configuration->get('engine.postproc.common.after_part', 0))
{
$this->finishedPart[] = $this->_dataFileName;
}
// Add the part's size to our rolling sum
clearstatcache();
$this->totalCompressedSize += filesize($this->_dataFileName);
$this->totalParts++;
$this->currentPartNumber = $this->totalParts;
if ($finalPart)
{
$this->_dataFileName = $this->dataFileNameWithoutExtension . '.zip';
}
else
{
$this->_dataFileName = $this->dataFileNameWithoutExtension . '.z' . sprintf('%02d', $this->currentPartNumber);
}
Factory::getLog()->log(LogLevel::INFO, 'Creating new ZIP part #' . $this->currentPartNumber . ', file ' . $this->_dataFileName);
// Inform the backup engine that we have changed the multipart number
$statistics = Factory::getStatistics();
$statistics->updateMultipart($this->totalParts);
// Try to remove any existing file
@unlink($this->_dataFileName);
// Touch the new file
$result = @touch($this->_dataFileName);
if (function_exists('chmod'))
{
chmod($this->_dataFileName, 0666);
}
return $result;
}
/**
* Find the optimal chunk size for CRC32 calculations and file processing
*
* @return void
*/
private function findOptimalChunkSize()
{
$configuration = Factory::getConfiguration();
// The user has entered their own preference
if ($configuration->get('engine.archiver.common.chunk_size', 0) > 0)
{
$this->AkeebaPackerZIP_CHUNK_SIZE = AKEEBA_CHUNK;
return;
}
// Get the PHP memory limit
$memLimit = $this->getMemoryLimit();
// Can't get a PHP memory limit? Use 2Mb chunks (fairly large, right?)
if (is_null($memLimit))
{
$this->AkeebaPackerZIP_CHUNK_SIZE = 2097152;
return;
}
if (!function_exists("memory_get_usage"))
{
// PHP can't report memory usage, use a conservative 512Kb
$this->AkeebaPackerZIP_CHUNK_SIZE = 524288;
return;
}
// PHP *can* report memory usage, see if there's enough available memory
$availableRAM = $memLimit - memory_get_usage();
if ($availableRAM > 0)
{
$this->AkeebaPackerZIP_CHUNK_SIZE = $availableRAM * 0.5;
return;
}
// NEGATIVE AVAILABLE MEMORY?!! Some borked PHP implementations also return the size of the httpd footprint.
if (($memLimit - 6291456) > 0)
{
$this->AkeebaPackerZIP_CHUNK_SIZE = $memLimit - 6291456;
return;
}
// If all else fails, use 2Mb and cross your fingers
$this->AkeebaPackerZIP_CHUNK_SIZE = 2097152;
}
/**
* Create a Central Directory temporary file
*
* @return void
*
* @throws ErrorException
*/
private function createCentralDirectoryTempFile()
{
$configuration = Factory::getConfiguration();
$this->centralDirectoryFilename = tempnam($configuration->get('akeeba.basic.output_directory'), 'akzcd');
$this->centralDirectoryFilename = basename($this->centralDirectoryFilename);
$pos = strrpos($this->centralDirectoryFilename, '/');
if ($pos !== false)
{
$this->centralDirectoryFilename = substr($this->centralDirectoryFilename, $pos + 1);
}
$pos = strrpos($this->centralDirectoryFilename, '\\');
if ($pos !== false)
{
$this->centralDirectoryFilename = substr($this->centralDirectoryFilename, $pos + 1);
}
$this->centralDirectoryFilename = Factory::getTempFiles()->registerTempFile($this->centralDirectoryFilename);
Factory::getLog()->log(LogLevel::DEBUG, __CLASS__ . " :: CntDir Tempfile = " . $this->centralDirectoryFilename);
// Create temporary file
if (!@touch($this->centralDirectoryFilename))
{
throw new ErrorException("Could not open temporary file for ZIP archiver. Please check your temporary directory's permissions!");
}
if (function_exists('chmod'))
{
chmod($this->centralDirectoryFilename, 0666);
}
}
}
Mini Shell