Файловый менеджер

Файловый менеджер - Редактировать - /home/infrafs/INFRABIKEIT/wp-content/plugins/dup_archive.zip

Назад
PK��c&4\R�?� �� +��classes/util/class.duparchive.util.scan.phpnu��[��<?php defined('ABSPATH') \|\| defined('DUPXABSPATH') \|\| exit; /* * To change this license header, choose License Headers in Project Properties. * To change this template file, choose Tools \| Templates * and open the template in the editor. / require_once(dirname(__FILE__).'/class.duparchive.u.json.php'); if(!class_exists('DupArchiveScanUtil')) { /* * Description of class * * @author Robert / class DupArchiveScanUtil { public static function getScan($scanFilepath) //put your code here private function get_scan() { DupArchiveUtil::tlog("Getting scen"); $scan_handle = fopen($scanFilepath, 'r'); if ($scan_handle === false) { throw new Exception("Can't open {$scanFilepath}"); } $scan_file = fread($scan_handle, filesize($scanFilepath)); if ($scan_file === false) { throw new Exception("Can't read from {$scanFilepath}"); } // $scan = json_decode($scan_file); $scan = DupArchiveJsonU::decode($scan_file); if ($scan == null) { throw new Exception("Error decoding scan file"); } fclose($scan_handle); return $scan; } public static function createScanObject($sourceDirectory) { $scan = new stdClass(); $scan->Dirs = DupArchiveUtil::expandDirectories($sourceDirectory, true); $scan->Files = DupArchiveUtil::expandFiles($sourceDirectory, true); return $scan; } public static function createScan($scanFilepath, $sourceDirectory) { DupArchiveUtil::tlog("Creating scan"); // $scan = new stdClass(); // // $scan->Dirs = DupArchiveUtil::expandDirectories($sourceDirectory, true); // $scan->Files = DupArchiveUtil::expandFiles($sourceDirectory, true); ////$scan->Files = array(); $scan = self::createScanObject($sourceDirectory); $scan_handle = fopen($scanFilepath, 'w'); if ($scan_handle === false) { echo "Couldn't create scan file"; die(); } $jsn = DupArchiveJsonU::customEncode($scan); fwrite($scan_handle, $jsn); // DupArchiveUtil::tlogObject('jsn', $jsn); return $scan; } } }PK��c&4\�/V:��classes/util/index.phpnu��[��<?php //silentPK��c&4\�N R��R��(��classes/util/class.duparchive.u.json.phpnu��[��<?php defined('ABSPATH') \|\| defined('DUPXABSPATH') \|\| exit; if(!class_exists('DupArchiveJsonU')) { class DupArchiveJsonU { protected static $_messages = array( JSON_ERROR_NONE => 'No error has occurred', JSON_ERROR_DEPTH => 'The maximum stack depth has been exceeded', JSON_ERROR_STATE_MISMATCH => 'Invalid or malformed JSON', JSON_ERROR_CTRL_CHAR => 'Control character error, possibly incorrectly encoded', JSON_ERROR_SYNTAX => 'Syntax error', JSON_ERROR_UTF8 => 'Malformed UTF-8 characters, possibly incorrectly encoded. To resolve see https://snapcreek.com/duplicator/docs/faqs-tech/#faq-package-170-q' ); public static function customEncode($value, $iteration = 1) { $encoded = DupLiteSnapJsonU::wp_json_encode($value); switch (json_last_error()) { case JSON_ERROR_NONE: return $encoded; case JSON_ERROR_DEPTH: throw new RuntimeException('Maximum stack depth exceeded'); // or trigger_error() or throw new Exception() case JSON_ERROR_STATE_MISMATCH: throw new RuntimeException('Underflow or the modes mismatch'); // or trigger_error() or throw new Exception() case JSON_ERROR_CTRL_CHAR: throw new RuntimeException('Unexpected control character found'); case JSON_ERROR_SYNTAX: throw new RuntimeException('Syntax error, malformed JSON'); // or trigger_error() or throw new Exception() case JSON_ERROR_UTF8: if ($iteration == 1) { $clean = self::makeUTF8($value); return self::customEncode($clean, $iteration + 1); } else { throw new RuntimeException('UTF-8 error loop'); } default: throw new RuntimeException('Unknown error'); // or trigger_error() or throw new Exception() } } public static function encode($value, $options = 0) { $result = DupLiteSnapJsonU::wp_json_encode($value, $options); if ($result !== FALSE) { return $result; } if (function_exists('json_last_error')) { $message = self::$_messages[json_last_error()]; } else { $message = 'One or more filenames isn\'t compatible with JSON encoding'; } throw new RuntimeException($message); } public static function decode($json, $assoc = false) { $result = json_decode($json, $assoc); if ($result) { return $result; } throw new RuntimeException(self::$_messages[json_last_error()]); } /* ======================================================== * PRIVATE METHODS * ===================================================== / private static function makeUTF8($mixed) { if (is_array($mixed)) { foreach ($mixed as $key => $value) { $mixed[$key] = self::makeUTF8($value); } } else if (is_string($mixed)) { return utf8_encode($mixed); } return $mixed; } private static function escapeString($str) { return addcslashes($str, "\v\t\n\r\f\"\\/"); } private static function oldCustomEncode($in) { $out = ""; if (is_object($in)) { //$class_vars = get_object_vars(($in)); //$arr = array(); //foreach ($class_vars as $key => $val) //{ $arr[$key] = "\"".self::escapeString($key)."\":\"{$val}\""; //} //$val = implode(',', $arr); //$out .= "{{$val}}"; $in = get_object_vars($in); } //else if (is_array($in)) { $obj = false; $arr = array(); foreach ($in AS $key => $val) { if (!is_numeric($key)) { $obj = true; } $arr[$key] = self::oldCustomEncode($val); } if ($obj) { foreach ($arr AS $key => $val) { $arr[$key] = "\"".self::escapeString($key)."\":{$val}"; } $val = implode(',', $arr); $out .= "{{$val}}"; } else { $val = implode(',', $arr); $out .= "[{$val}]"; } } elseif (is_bool($in)) { $out .= $in ? 'true' : 'false'; } elseif (is_null($in)) { $out .= 'null'; } elseif (is_string($in)) { $out .= "\"".self::escapeString($in)."\""; } else { $out .= $in; } return "{$out}"; } private static function oldMakeUTF8($val) { if (is_array($val)) { foreach ($val as $k => $v) { $val[$k] = self::oldMakeUTF8($v); } } else if (is_object($val)) { foreach ($val as $k => $v) { $val->$k = self::oldMakeUTF8($v); } } else { if (mb_detect_encoding($val, 'UTF-8', true)) { return $val; } else { return utf8_encode($val); } } return $val; } } }PK��c&4\l��]v��v��&��classes/util/class.duparchive.util.phpnu��[��<?php defined('ABSPATH') \|\| defined('DUPXABSPATH') \|\| exit; / * To change this license header, choose License Headers in Project Properties. * To change this template file, choose Tools \| Templates * and open the template in the editor. / /* * Description of Util * * @author Bob / require_once(dirname(__FILE__).'/../class.duparchive.constants.php'); require_once(DupArchiveConstants::$LibRoot.'/snaplib/class.snaplib.u.util.php'); if(!class_exists('DupArchiveUtil')) { class DupArchiveUtil { public static $TRACE_ON = false; //rodo rework this public static $logger = null; public static $profilingFunction = null; public static function boolToString($b) { return ($b ? 'true' : 'false'); } public static function expandFiles($base_dir, $recurse) { $files = array(); foreach (scandir($base_dir) as $file) { if (($file == '.') \|\| ($file == '..')) { continue; } $file = "{$base_dir}/{$file}"; if (is_file($file)) { $files [] = $file; } else if (is_dir($file) && $recurse) { $files = array_merge($files, self::expandFiles($file, $recurse)); } } return $files; } public static function expandDirectories($base_dir, $recurse) { $directories = array(); foreach (scandir($base_dir) as $candidate) { if (($candidate == '.') \|\| ($candidate == '..')) { continue; } $candidate = "{$base_dir}/{$candidate}"; // if (is_file($file)) { // $directories [] = $file; if (is_dir($candidate)) { $directories[] = $candidate; if ($recurse) { $directories = array_merge($directories, self::expandDirectories($candidate, $recurse)); } } } return $directories; } public static function getRelativePath($from, $to, $newBasePath = null) { // some compatibility fixes for Windows paths $from = is_dir($from) ? rtrim($from, '\/').'/' : $from; $to = is_dir($to) ? rtrim($to, '\/').'/' : $to; $from = str_replace('\\', '/', $from); $to = str_replace('\\', '/', $to); $from = explode('/', $from); $to = explode('/', $to); $relPath = $to; foreach ($from as $depth => $dir) { // find first non-matching dir if ($dir === $to[$depth]) { // ignore this directory array_shift($relPath); } else { // get number of remaining dirs to $from $remaining = count($from) - $depth; if ($remaining > 1) { // add traversals up to first matching dir $padLength = (count($relPath) + $remaining - 1) -1; $relPath = array_pad($relPath, $padLength, '..'); break; } else { //$relPath[0] = './' . $relPath[0]; } } } $r = implode('/', $relPath); if($newBasePath != null) { $r = $newBasePath . $r; } return $r; } public static function log($s, $flush = false, $callingFunctionName = null) { if(self::$logger != null) { if($callingFunctionName === null) { $callingFunctionName = DupLiteSnapLibUtil::getCallingFunctionName(); } self::$logger->log($s, $flush, $callingFunctionName); } else { // throw new Exception('Logging object not initialized'); } } // rodo fold into log public static function tlog($s, $flush = false, $callingFunctionName = null) { if (self::$TRACE_ON) { if($callingFunctionName === null) { $callingFunctionName = DupLiteSnapLibUtil::getCallingFunctionName(); } self::log("####{$s}", $flush, $callingFunctionName); } } public static function profileEvent($s, $start) { if(self::$profilingFunction != null) { call_user_func(self::$profilingFunction, $s, $start); } } // rodo fold into logObject public static function tlogObject($s, $o, $flush = false, $callingFunctionName = null) { if(is_object($o)) { $o = get_object_vars($o); } $ostring = print_r($o, true); if($callingFunctionName === null) { $callingFunctionName = DupLiteSnapLibUtil::getCallingFunctionName(); } self::tlog($s, $flush, $callingFunctionName); self::tlog($ostring, $flush, $callingFunctionName); } public static function logObject($s, $o, $flush = false, $callingFunctionName = null) { $ostring = print_r($o, true); if($callingFunctionName === null) { $callingFunctionName = DupLiteSnapLibUtil::getCallingFunctionName(); } self::log($s, $flush, $callingFunctionName); self::log($ostring, $flush, $callingFunctionName); } } }PK��c&4\c20Ĭs��s��#��classes/class.duparchive.engine.phpnu��[��<?php defined('ABSPATH') \|\| defined('DUPXABSPATH') \|\| exit; /* * To change this license header, choose License Headers in Project Properties. * To change this template file, choose Tools \| Templates * and open the template in the editor. / require_once(dirname(__FILE__) . '/class.duparchive.constants.php'); require_once(DupArchiveConstants::$LibRoot . '/snaplib/class.snaplib.u.io.php'); require_once(DupArchiveConstants::$LibRoot . '/snaplib/class.snaplib.u.stream.php'); require_once(dirname(__FILE__) . '/headers/class.duparchive.header.php'); require_once(dirname(__FILE__) . '/states/class.duparchive.state.create.php'); require_once(dirname(__FILE__) . '/states/class.duparchive.state.simplecreate.php'); require_once(dirname(__FILE__) . '/states/class.duparchive.state.simpleexpand.php'); require_once(dirname(__FILE__) . '/states/class.duparchive.state.expand.php'); require_once(dirname(__FILE__) . '/processors/class.duparchive.processor.file.php'); require_once(dirname(__FILE__) . '/processors/class.duparchive.processor.directory.php'); require_once(dirname(__FILE__) . '/class.duparchive.processing.failure.php'); require_once(dirname(__FILE__) . '/util/class.duparchive.util.php'); require_once(dirname(__FILE__) . '/util/class.duparchive.util.scan.php'); if(!class_exists('DupArchiveInfo')) { class DupArchiveInfo { public $archiveHeader; public $fileHeaders; public $directoryHeaders; public function __construct() { $this->fileHeaders = array(); $this->directoryHeaders = array(); } } } if(!class_exists('DupArchiveItemAlias')) { class DupArchiveItemAlias { public $oldName; public $newName; } } if(!class_exists('DupArchiveItemHeaderType')) { class DupArchiveItemHeaderType { const None = 0; const File = 1; const Directory = 2; const Glob = 3; } } if(!class_exists('DupArchiveEngine')) { class DupArchiveEngine { public static $archive; public static function init($logger, $profilingFunction = null, $archive = null) { DupArchiveUtil::$logger = $logger; DupArchiveUtil::$profilingFunction = $profilingFunction; self::$archive = $archive; } public static function getNextHeaderType($archiveHandle) { $retVal = DupArchiveItemHeaderType::None; $marker = fgets($archiveHandle, 4); if (feof($archiveHandle) === false) { switch ($marker) { case '<D>': $retVal = DupArchiveItemHeaderType::Directory; break; case '<F>': $retVal = DupArchiveItemHeaderType::File; break; case '<G>': $retVal = DupArchiveItemHeaderType::Glob; break; default: throw new Exception("Invalid header marker {$marker}. Location:" . ftell($archiveHandle)); } } return $retVal; } public static function getArchiveInfo($filepath) { $archiveInfo = new DupArchiveInfo(); DupArchiveUtil::log("archive size=" . filesize($filepath)); $archiveHandle = DupLiteSnapLibIOU::fopen($filepath, 'rb'); $moreFiles = true; $archiveInfo->archiveHeader = DupArchiveHeader::readFromArchive($archiveHandle); $moreToRead = true; while ($moreToRead) { $headerType = self::getNextHeaderType($archiveHandle); // DupArchiveUtil::log("next header type=$headerType: " . ftell($archiveHandle)); switch ($headerType) { case DupArchiveItemHeaderType::File: $fileHeader = DupArchiveFileHeader::readFromArchive($archiveHandle, true, true); $archiveInfo->fileHeaders[] = $fileHeader; DupArchiveUtil::log("file" . $fileHeader->relativePath); break; case DupArchiveItemHeaderType::Directory: $directoryHeader = DupArchiveDirectoryHeader::readFromArchive($archiveHandle, true); $archiveInfo->directoryHeaders[] = $directoryHeader; break; case DupArchiveItemHeaderType::None: $moreToRead = false; } } return $archiveInfo; } // can't span requests since create state can't store list of files public static function addDirectoryToArchiveST($archiveFilepath, $directory, $basepath, $includeFiles = false, $newBasepath = null, $globSize = DupArchiveCreateState::DEFAULT_GLOB_SIZE) { if ($includeFiles) { $scan = DupArchiveScanUtil::createScanObject($directory); } else { $scan->Files = array(); $scan->Dirs = array(); } $createState = new DupArchiveSimpleCreateState(); $createState->archiveOffset = filesize($archiveFilepath); $createState->archivePath = $archiveFilepath; $createState->basePath = $basepath; $createState->timerEnabled = false; $createState->globSize = $globSize; $createState->newBasePath = $newBasepath; self::addItemsToArchive($createState, $scan); $retVal = new stdClass(); $retVal->numDirsAdded = $createState->currentDirectoryIndex; $retVal->numFilesAdded = $createState->currentFileIndex; if($createState->skippedFileCount > 0) { throw new Exception("One or more files were were not able to be added when adding {$directory} to {$archiveFilepath}"); } else if($createState->skippedDirectoryCount > 0) { throw new Exception("One or more directories were not able to be added when adding {$directory} to {$archiveFilepath}"); } return $retVal; } public static function addRelativeFileToArchiveST($archiveFilepath, $filepath, $relativePath, $globSize = DupArchiveCreateState::DEFAULT_GLOB_SIZE) { $createState = new DupArchiveSimpleCreateState(); $createState->archiveOffset = filesize($archiveFilepath); $createState->archivePath = $archiveFilepath; $createState->basePath = null; $createState->timerEnabled = false; $createState->globSize = $globSize; $scan = new stdClass(); $scan->Files = array(); $scan->Dirs = array(); $scan->Files[] = $filepath; if ($relativePath != null) { $scan->FileAliases = array(); $scan->FileAliases[$filepath] = $relativePath; } self::addItemsToArchive($createState, $scan); } public static function addFileToArchiveUsingBaseDirST($archiveFilepath, $basePath, $filepath, $globSize = DupArchiveCreateState::DEFAULT_GLOB_SIZE) { $createState = new DupArchiveSimpleCreateState(); $createState->archiveOffset = filesize($archiveFilepath); $createState->archivePath = $archiveFilepath; $createState->basePath = $basePath; $createState->timerEnabled = false; $createState->globSize = $globSize; $scan = new stdClass(); $scan->Files = array(); $scan->Dirs = array(); $scan->Files[] = $filepath; self::addItemsToArchive($createState, $scan); } public static function createArchive($archivePath, $isCompressed) { $archiveHandle = DupLiteSnapLibIOU::fopen($archivePath, 'w+b'); / @var $archiveHeader DupArchiveHeader / $archiveHeader = DupArchiveHeader::create($isCompressed); $archiveHeader->writeToArchive($archiveHandle); // Intentionally do not write build state since if something goes wrong we went it to start over on the archive DupLiteSnapLibIOU::fclose($archiveHandle); } public static function addItemsToArchive($createState, $scanFSInfo) { if ($createState->globSize == -1) { $createState->globSize = DupArchiveCreateState::DEFAULT_GLOB_SIZE; } / @var $createState DupArchiveCreateState / DupArchiveUtil::tlogObject("addItemsToArchive start", $createState); $directoryCount = count($scanFSInfo->Dirs); $fileCount = count($scanFSInfo->Files); $createState->startTimer(); / @var $createState DupArchiveCreateState / $basepathLength = strlen($createState->basePath); $archiveHandle = DupLiteSnapLibIOU::fopen($createState->archivePath, 'r+b'); DupArchiveUtil::tlog("Archive size=", filesize($createState->archivePath)); DupArchiveUtil::tlog("Archive location is now " . DupLiteSnapLibIOU::ftell($archiveHandle)); $archiveHeader = DupArchiveHeader::readFromArchive($archiveHandle); $createState->isCompressed = $archiveHeader->isCompressed; if ($createState->archiveOffset == filesize($createState->archivePath)) { DupArchiveUtil::tlog("Seeking to end of archive location because of offset {$createState->archiveOffset} for file size " . filesize($createState->archivePath)); DupLiteSnapLibIOU::fseek($archiveHandle, 0, SEEK_END); } else { DupArchiveUtil::tlog("Seeking archive offset {$createState->archiveOffset} for file size " . filesize($createState->archivePath)); DupLiteSnapLibIOU::fseek($archiveHandle, $createState->archiveOffset); } while (($createState->currentDirectoryIndex < $directoryCount) && (!$createState->timedOut())) { if ($createState->throttleDelayInUs !== 0) { usleep($createState->throttleDelayInUs); } $directory = $scanFSInfo->Dirs[$createState->currentDirectoryIndex]; try { $relativeDirectoryPath = null; if (isset($scanFSInfo->DirectoryAliases) && array_key_exists($directory, $scanFSInfo->DirectoryAliases)) { $relativeDirectoryPath = $scanFSInfo->DirectoryAliases[$directory]; } else { if (null === self::$archive) { $relativeDirectoryPath = substr($directory, $basepathLength); $relativeDirectoryPath = ltrim($relativeDirectoryPath, '/'); if ($createState->newBasePath !== null) { $relativeDirectoryPath = $createState->newBasePath . $relativeDirectoryPath; } } else { $relativeDirectoryPath = self::$archive->getLocalDirPath($directory, $createState->newBasePath); } } if($relativeDirectoryPath !== '') { DupArchiveDirectoryProcessor::writeDirectoryToArchive($createState, $archiveHandle, $directory, $relativeDirectoryPath); } else { $createState->skippedDirectoryCount++; $createState->currentDirectoryIndex++; } } catch (Exception $ex) { DupArchiveUtil::log("Failed to add {$directory} to archive. Error: " . $ex->getMessage(), true); $createState->addFailure(DupArchiveFailureTypes::Directory, $directory, $ex->getMessage(), false); $createState->currentDirectoryIndex++; $createState->skippedDirectoryCount++; $createState->save(); } } $createState->archiveOffset = DupLiteSnapLibIOU::ftell($archiveHandle); $workTimestamp = time(); while (($createState->currentFileIndex < $fileCount) && (!$createState->timedOut())) { $filepath = $scanFSInfo->Files[$createState->currentFileIndex]; try { $relativeFilePath = null; if (isset($scanFSInfo->FileAliases) && array_key_exists($filepath, $scanFSInfo->FileAliases)) { $relativeFilePath = $scanFSInfo->FileAliases[$filepath]; } else { if (null === self::$archive) { $relativeFilePath = substr($filepath, $basepathLength); $relativeFilePath = ltrim($relativeFilePath, '/'); if ($createState->newBasePath !== null) { $relativeFilePath = $createState->newBasePath . $relativeFilePath; } } else { $relativeFilePath = self::$archive->getLocalFilePath($filepath, $createState->newBasePath); } } // Uncomment when testing error handling // if((strpos($relativeFilePath, 'dup-installer') !== false) \|\| (strpos($relativeFilePath, 'lib') !== false)) { // Dup_Log::Trace("Was going to do intentional error to {$relativeFilePath} but skipping"); // } else { // throw new Exception("#### intentional file error when writing " . $relativeFilePath); // } // } DupArchiveFileProcessor::writeFilePortionToArchive($createState, $archiveHandle, $filepath, $relativeFilePath); if(($createState->isRobust) && (time() - $workTimestamp >= 1)){ DupArchiveUtil::log("Robust mode create state save"); // When in robustness mode save the state every second $workTimestamp = time(); $createState->working = ($createState->currentDirectoryIndex < $directoryCount) \|\| ($createState->currentFileIndex < $fileCount); $createState->save(); } } catch (Exception $ex) { DupArchiveUtil::log("Failed to add {$filepath} to archive. Error: " . $ex->getMessage() . $ex->getTraceAsString(), true); $createState->currentFileIndex++; $createState->skippedFileCount++; $createState->addFailure(DupArchiveFailureTypes::File, $filepath, $ex->getMessage(), ($ex->getCode() === DupArchiveExceptionCodes::Fatal)); $createState->save(); } } $createState->working = ($createState->currentDirectoryIndex < $directoryCount) \|\| ($createState->currentFileIndex < $fileCount); $createState->save(); DupLiteSnapLibIOU::fclose($archiveHandle); if (!$createState->working) { DupArchiveUtil::log("compress done"); } else { DupArchiveUtil::tlog("compress not done so continuing later"); } } public static function expandDirectory($archivePath, $relativePath, $destPath) { self::expandItems($archivePath, $relativePath, $destPath); } public static function expandArchive($expandState) { / @var $expandState DupArchiveExpandState / $expandState->startTimer(); $archiveHandle = DupLiteSnapLibIOU::fopen($expandState->archivePath, 'rb'); DupLiteSnapLibIOU::fseek($archiveHandle, $expandState->archiveOffset); if ($expandState->archiveOffset == 0) { DupArchiveUtil::log("#### seeking to start of archive"); $expandState->archiveHeader = DupArchiveHeader::readFromArchive($archiveHandle); $expandState->isCompressed = $expandState->archiveHeader->isCompressed; $expandState->archiveOffset = DupLiteSnapLibIOU::ftell($archiveHandle); $expandState->save(); } else { DupArchiveUtil::log("#### seeking archive offset {$expandState->archiveOffset}"); } if ((!$expandState->validateOnly) \|\| ($expandState->validationType == DupArchiveValidationTypes::Full)) { $moreItems = self::expandItems($expandState, $archiveHandle); } else { // profile ok $moreItems = self::standardValidateItems($expandState, $archiveHandle); // end profile ok } $expandState->working = $moreItems; $expandState->save(); DupLiteSnapLibIOU::fclose($archiveHandle, false); if (!$expandState->working) { DupArchiveUtil::log("expand done"); DupArchiveUtil::logObject('expandstate', $expandState); if (($expandState->expectedFileCount != -1) && ($expandState->expectedFileCount != $expandState->fileWriteCount)) { $expandState->addFailure(DupArchiveFailureTypes::File, 'Archive', "Number of files expected ({$expandState->expectedFileCount}) doesn't equal number written ({$expandState->fileWriteCount})."); } if (($expandState->expectedDirectoryCount != -1) && ($expandState->expectedDirectoryCount != $expandState->directoryWriteCount)) { $expandState->addFailure(DupArchiveFailureTypes::Directory, 'Archive', "Number of directories expected ({$expandState->expectedDirectoryCount}) doesn't equal number written ({$expandState->directoryWriteCount})."); } } else { DupArchiveUtil::tlogObject("expand not done so continuing later", $expandState); } } private static function skipFileInArchive($archiveHandle, $fileHeader) { if ($fileHeader->fileSize > 0) { $dataSize = 0; do { $globHeader = DupArchiveGlobHeader::readFromArchive($archiveHandle, true); $dataSize += $globHeader->originalSize; $moreGlobs = ($dataSize < $fileHeader->fileSize); } while ($moreGlobs); } } // Assumes we are on one header and just need to get to the next private static function skipToNextHeader($archiveHandle) { $headerType = self::getNextHeaderType($archiveHandle); switch ($headerType) { case DupArchiveItemHeaderType::File: $fileHeader = DupArchiveFileHeader::readFromArchive($archiveHandle, false, true); self::skipFileInArchive($archiveHandle, $fileHeader); break; case DupArchiveItemHeaderType::Directory: $directoryHeader = DupArchiveDirectoryHeader::readFromArchive($archiveHandle, true); break; case DupArchiveItemHeaderType::None: $moreToRead = false; } } // Single-threaded file expansion public static function expandFiles($archiveFilePath, $relativeFilePaths, $destPath) { // Not setting timeout timestamp so it will never timeout DupArchiveUtil::tlog("opening archive {$archiveFilePath}"); $archiveHandle = DupLiteSnapLibIOU::fopen($archiveFilePath, 'r'); / @var $expandState DupArchiveSimpleExpandState / $expandState = new DupArchiveSimpleExpandState(); $expandState->archiveHeader = DupArchiveHeader::readFromArchive($archiveHandle); $expandState->isCompressed = $expandState->archiveHeader->isCompressed; $expandState->archiveOffset = DupLiteSnapLibIOU::ftell($archiveHandle); $expandState->includedFiles = $relativeFilePaths; $expandState->filteredDirectories = array(''); $expandState->filteredFiles = array(''); // $expandState->basePath = $destPath . '/tempExtract'; // RSR remove once extract works $expandState->basePath = $destPath; // RSR remove once extract works // TODO: Filter out all directories/files except those in the list self::expandItems($expandState, $archiveHandle); } private static function expandItems(&$expandState, $archiveHandle) { / @var $expandState DupArchiveExpandState / $moreToRead = true; $workTimestamp = time(); while ($moreToRead && (!$expandState->timedOut())) { if ($expandState->throttleDelayInUs !== 0) { usleep($expandState->throttleDelayInUs); } if ($expandState->currentFileHeader != null) { DupArchiveUtil::tlog("Writing file {$expandState->currentFileHeader->relativePath}"); if (self::filePassesFilters($expandState->filteredDirectories, $expandState->filteredFiles, $expandState->includedFiles, $expandState->currentFileHeader->relativePath)) { try { $fileCompleted = DupArchiveFileProcessor::writeToFile($expandState, $archiveHandle); } catch (Exception $ex) { DupArchiveUtil::log("Failed to write to {$expandState->currentFileHeader->relativePath}. Error: " . $ex->getMessage(), true); // Reset things - skip over this file within the archive. DupLiteSnapLibIOU::fseek($archiveHandle, $expandState->lastHeaderOffset); self::skipToNextHeader($archiveHandle, $expandState->currentFileHeader); $expandState->archiveOffset = ftell($archiveHandle); $expandState->addFailure(DupArchiveFailureTypes::File, $expandState->currentFileHeader->relativePath, $ex->getMessage(), false); $expandState->resetForFile(); $expandState->lastHeaderOffset = -1; $expandState->save(); } } else { DupArchiveUtil::log("skipping {$expandState->currentFileHeader->relativePath} because its part of the exclusion filter"); self::skipFileInArchive($archiveHandle, $expandState->currentFileHeader); $expandState->resetForFile(); } } else { // Header is null so read in the next one $expandState->lastHeaderOffset = @ftell($archiveHandle); // profile ok $headerType = self::getNextHeaderType($archiveHandle); // end profile ok DupArchiveUtil::tlog('header type ' . $headerType); switch ($headerType) { case DupArchiveItemHeaderType::File: DupArchiveUtil::tlog('File header'); $expandState->currentFileHeader = DupArchiveFileHeader::readFromArchive($archiveHandle, false, true); $expandState->archiveOffset = @ftell($archiveHandle); DupArchiveUtil::tlog('Just read file header from archive'); break; case DupArchiveItemHeaderType::Directory: DupArchiveUtil::tlog('Directory Header'); $directoryHeader = DupArchiveDirectoryHeader::readFromArchive($archiveHandle, true); if (self::passesDirectoryExclusion($expandState->filteredDirectories, $directoryHeader->relativePath)) { $createdDirectory = true; if (!$expandState->validateOnly) { $directory = $expandState->basePath . '/' . $directoryHeader->relativePath; $mode = 'u+rwx'; if ($expandState->directoryModeOverride != -1) { $mode = $expandState->directoryModeOverride; } $createdDirectory = DupLiteSnapLibIOU::dirWriteCheckOrMkdir($directory, $mode, true); } if ($createdDirectory) { $expandState->directoryWriteCount++; } else { $expandState->addFailure(DupArchiveFailureTypes::Directory, $directory, "Unable to create directory $directory", false); } } $expandState->archiveOffset = ftell($archiveHandle); DupArchiveUtil::tlog('Just read directory header ' . $directoryHeader->relativePath . ' from archive'); break; case DupArchiveItemHeaderType::None: $moreToRead = false; } } if(($expandState->isRobust) && (time() - $workTimestamp >= 1)){ DupArchiveUtil::log("Robust mode extract state save for standard validate"); // When in robustness mode save the state every second $workTimestamp = time(); $expandState->save(); } } $expandState->save(); return $moreToRead; } private static function passesDirectoryExclusion($directoryFilters, $candidate) { foreach ($directoryFilters as $directoryFilter) { if($directoryFilter === '') { return false; } if (substr($candidate, 0, strlen($directoryFilter)) == $directoryFilter) { return false; } } return true; } private static function filePassesFilters($excludedDirectories, $excludedFiles, $includedFiles, $candidate) { $retVal = true; // Included files trumps all exclusion filters foreach($includedFiles as $includedFile) { if($includedFile === $candidate) { return true; } } if (self::passesDirectoryExclusion($excludedDirectories, $candidate)) { foreach ($excludedFiles as $fileFilter) { if($fileFilter === '') { return false; } if ($fileFilter === $candidate) { $retVal = false; break; } } } else { $retVal = false;; } return $retVal; } private static function standardValidateItems(&$expandState, $archiveHandle) { $moreToRead = true; // profile ok $to = $expandState->timedOut(); // end profile ok $workTimestamp = time(); while ($moreToRead && (!$to)) { if ($expandState->throttleDelayInUs !== 0) { usleep($expandState->throttleDelayInUs); } if ($expandState->currentFileHeader != null) { try { $fileCompleted = DupArchiveFileProcessor::standardValidateFileEntry($expandState, $archiveHandle); if ($fileCompleted) { $expandState->resetForFile(); } // Expand state taken care of within the write to file to ensure consistency } catch (Exception $ex) { DupArchiveUtil::log("Failed validate file in archive. Error: " . $ex->getMessage(), true); DupArchiveUtil::logObject("expand state", $expandState, true); // $expandState->currentFileIndex++; // RSR TODO: Need way to skip past that file $expandState->addFailure(DupArchiveFailureTypes::File, $expandState->currentFileHeader->relativePath, $ex->getMessage()); $expandState->save(); $moreToRead = false; } } else { // profile ok $headerType = self::getNextHeaderType($archiveHandle); switch ($headerType) { case DupArchiveItemHeaderType::File: // profile ok $expandState->currentFileHeader = DupArchiveFileHeader::readFromArchive($archiveHandle, false, true); $expandState->archiveOffset = ftell($archiveHandle); // end profile ok break; case DupArchiveItemHeaderType::Directory: // profile ok $directoryHeader = DupArchiveDirectoryHeader::readFromArchive($archiveHandle, true); $expandState->directoryWriteCount++; $expandState->archiveOffset = ftell($archiveHandle); break; case DupArchiveItemHeaderType::None: $moreToRead = false; } } if(($expandState->isRobust) && (time() - $workTimestamp >= 1)){ DupArchiveUtil::log("Robust mdoe extract state save for standard validate"); // When in robustness mode save the state every second $workTimestamp = time(); $expandState->save(); } // profile ok $to = $expandState->timedOut(); } // profile ok $expandState->save(); return $moreToRead; } } } PK��c&4\�/V:��classes/headers/index.phpnu��[��<?php //silentPK��c&4\��B!��0��classes/headers/class.duparchive.header.file.phpnu��[��<?php defined('ABSPATH') \|\| defined('DUPXABSPATH') \|\| exit; require_once(dirname(__FILE__).'/../util/class.duparchive.util.php'); require_once(dirname(__FILE__).'/class.duparchive.header.u.php'); if(!class_exists('DupArchiveFileHeader')) { // Format class DupArchiveFileHeader// extends HeaderBase { public $fileSize; public $mtime; public $permissions; public $hash; public $relativePathLength; public $relativePath; const MaxHeaderSize = 8192; const MaxPathLength = 4100; // const MaxStandardHeaderFieldLength = 128; private function __construct() { // Prevent direct instantiation } static function createFromFile($filepath, $relativeFilePath) { $instance = new DupArchiveFileHeader(); // RSR TODO Populate fields based on file already on system // profile ok $instance->fileSize = DupLiteSnapLibIOU::filesize($filepath); // end profile ok // profile ok $instance->permissions = substr(sprintf('%o', fileperms($filepath)), -4); // end profile ok // profile ok $instance->mtime = DupLiteSnapLibIOU::filemtime($filepath); // end profile ok if($instance->fileSize > DupArchiveConstants::$MaxFilesizeForHashing) { $instance->hash = false; } else { $instance->hash = hash_file('crc32b', $filepath); } $instance->relativePath = $relativeFilePath; $instance->relativePathLength = strlen($instance->relativePath); // DupArchiveUtil::tlog("paths=$filepath, {$instance->relativePath}"); if ($instance->hash === false) { // RSR TODO: Best thing to do here? $instance->hash = "00000000000000000000000000000000"; } return $instance; } / * delta = 84-22 = 62 bytes per file -> 20000 files -> 1.2MB larger * <F><FS>x</FS><MT>x</<MT><FP>x</FP><HA>x</HA><RFPL>x</RFPL><RFP>x</RFP></F> # F#x#x#x#x#x#x! * / static function readFromArchive($archiveHandle, $skipContents, $skipMarker = false) { // RSR TODO Read header from archive handle and populate members // TODO: return null if end of archive or throw exception if can read something but its not a file header $instance = new DupArchiveFileHeader(); if (!$skipMarker) { $marker = @fread($archiveHandle, 3); if ($marker === false) { if (feof($archiveHandle)) { return false; } else { throw new Exception('Error reading file header'); } } if ($marker != '<F>') { throw new Exception("Invalid file header marker found [{$marker}] : location ".ftell($archiveHandle)); } } $instance->fileSize = DupArchiveHeaderU::readStandardHeaderField($archiveHandle, 'FS'); $instance->mtime = DupArchiveHeaderU::readStandardHeaderField($archiveHandle, 'MT'); $instance->permissions = DupArchiveHeaderU::readStandardHeaderField($archiveHandle, 'P'); $instance->hash = DupArchiveHeaderU::readStandardHeaderField($archiveHandle, 'HA'); $instance->relativePathLength = DupArchiveHeaderU::readStandardHeaderField($archiveHandle, 'RPL'); // Skip <RP> fread($archiveHandle, 4); $instance->relativePath = fread($archiveHandle, $instance->relativePathLength); // Skip </RP> // fread($archiveHandle, 5); // Skip the </F> // fread($archiveHandle, 4); // Skip the </RP> and the </F> fread($archiveHandle, 9); if ($skipContents && ($instance->fileSize > 0)) { $dataSize = 0; $moreGlobs = true; while ($moreGlobs) { //echo 'read glob<br/>'; / @var $globHeader DupArchiveGlobHeader / $globHeader = DupArchiveGlobHeader::readFromArchive($archiveHandle, true); $dataSize += $globHeader->originalSize; $moreGlobs = ($dataSize < $instance->fileSize); } } return $instance; } public function writeToArchive($archiveHandle) { $headerString = '<F><FS>'.$this->fileSize.'</FS><MT>'.$this->mtime.'</MT><P>'.$this->permissions.'</P><HA>'.$this->hash.'</HA><RPL>'.$this->relativePathLength.'</RPL><RP>'.$this->relativePath.'</RP></F>'; //DupLiteSnapLibIOU::fwrite($archiveHandle, $headerString); $bytes_written = @fwrite($archiveHandle, $headerString); if ($bytes_written === false) { throw new Exception('Error writing to file.'); } else { return $bytes_written; } } } }PK��c&4\ϡ9O��O��0��classes/headers/class.duparchive.header.glob.phpnu��[��<?php defined('ABSPATH') \|\| defined('DUPXABSPATH') \|\| exit; require_once(dirname(__FILE__).'/../util/class.duparchive.util.php'); require_once(dirname(__FILE__).'/class.duparchive.header.u.php'); if(!class_exists('DupArchiveGlobHeader')) { // Format // #C#{$originalSize}#{$storedSize}! class DupArchiveGlobHeader //extends HeaderBase { // public $marker; public $originalSize; public $storedSize; public $hash; const MaxHeaderSize = 255; public function __construct() { } public static function readFromArchive($archiveHandle, $skipGlob) { $instance = new DupArchiveGlobHeader(); DupArchiveUtil::log('Reading glob starting at ' . ftell($archiveHandle)); $startElement = fread($archiveHandle, 3); //if ($marker != '?G#') { if ($startElement !== '<G>') { throw new Exception("Invalid glob header marker found {$startElement}. location:" . ftell($archiveHandle)); } $instance->originalSize = DupArchiveHeaderU::readStandardHeaderField($archiveHandle, 'OS'); $instance->storedSize = DupArchiveHeaderU::readStandardHeaderField($archiveHandle, 'SS'); $instance->hash = DupArchiveHeaderU::readStandardHeaderField($archiveHandle, 'HA'); // Skip the </G> fread($archiveHandle, 4); if ($skipGlob) { DupLiteSnapLibIOU::fseek($archiveHandle, $instance->storedSize, SEEK_CUR); } return $instance; } public function writeToArchive($archiveHandle) { // <G><OS>x</OS>x<SS>x</SS><HA>x</HA></G> $headerString = '<G><OS>'.$this->originalSize.'</OS><SS>'.$this->storedSize.'</SS><HA>'.$this->hash.'</HA></G>'; //DupLiteSnapLibIOU::fwrite($archiveHandle, $headerString); $bytes_written = @fwrite($archiveHandle, $headerString); if ($bytes_written === false) { throw new Exception('Error writing to file.'); } else { return $bytes_written; } } } }PK��c&4\{��W� �� +��classes/headers/class.duparchive.header.phpnu��[��<?php defined('ABSPATH') \|\| defined('DUPXABSPATH') \|\| exit; / * To change this license header, choose License Headers in Project Properties. * To change this template file, choose Tools \| Templates * and open the template in the editor. / require_once(dirname(__FILE__).'/../util/class.duparchive.util.php'); require_once(dirname(__FILE__).'/class.duparchive.header.u.php'); require_once(dirname(__FILE__).'/../../define.php'); if(!class_exists('DupArchiveHeader')) { //require_once(dirname(__FILE__).'/class.HeaderBase.php'); // Format: #A#{version:5}#{isCompressed}! class DupArchiveHeader// extends HeaderBase { public $version; public $isCompressed; // public $directoryCount; // public $fileCount; // Format Version History // 1 = Initial alpha format // 2 = Pseudo xml based format //const LatestVersion = 2; const MaxHeaderSize = 60; private function __construct() { // Prevent instantiation } // public static function create($isCompressed, $directoryCount, $fileCount, $version = self::LatestVersion) public static function create($isCompressed) { $instance = new DupArchiveHeader(); // $instance->directoryCount = $directoryCount; // $instance->fileCount = $fileCount; $instance->version = DUPARCHIVE_VERSION; $instance->isCompressed = $isCompressed; return $instance; } public static function readFromArchive($archiveHandle) { $instance = new DupArchiveHeader(); $startElement = fgets($archiveHandle, 4); if ($startElement != '<A>') { throw new Exception("Invalid archive header marker found {$startElement}"); } $instance->version = DupArchiveHeaderU::readStandardHeaderField($archiveHandle, 'V'); $instance->isCompressed = DupArchiveHeaderU::readStandardHeaderField($archiveHandle, 'C') == 'true' ? true : false; // Skip the </A> fgets($archiveHandle, 5); return $instance; } public function writeToArchive($archiveHandle) { $isCompressedString = DupArchiveUtil::boolToString($this->isCompressed); //DupLiteSnapLibIOU::fwrite($archiveHandle, "<A><V>{$this->version}</V><C>{$isCompressedString}</C></A>"); DupLiteSnapLibIOU::fwrite($archiveHandle, '<A><V>'.$this->version.'</V><C>'.$isCompressedString.'</C></A>'); } } }PK��c&4\��s� �� 5��classes/headers/class.duparchive.header.directory.phpnu��[��<?php defined('ABSPATH') \|\| defined('DUPXABSPATH') \|\| exit; require_once(dirname(__FILE__).'/../util/class.duparchive.util.php'); require_once(dirname(__FILE__).'/class.duparchive.header.u.php'); if(!class_exists('DupArchiveDirectoryHeader')) { // Format class DupArchiveDirectoryHeader// extends HeaderBase { public $mtime; public $permissions; public $relativePathLength; public $relativePath; const MaxHeaderSize = 8192; const MaxPathLength = 4100; //const MaxStandardHeaderFieldLength = 128; public function __construct() { // Prevent direct instantiation } // static function createFromDirectory($directoryPath, $relativePath) // { // $instance = new DupArchiveDirectoryHeader(); // // $instance->permissions = substr(sprintf('%o', fileperms($directoryPath)), -4); // $instance->mtime = DupLiteSnapLibIOU::filemtime($directoryPath); // $instance->relativePath = $relativePath; // $instance->relativePathLength = strlen($instance->relativePath); // // return $instance; // } static function readFromArchive($archiveHandle, $skipStartElement = false) { $instance = new DupArchiveDirectoryHeader(); if(!$skipStartElement) { // <A> $startElement = fread($archiveHandle, 3); if ($startElement === false) { if (feof($archiveHandle)) { return false; } else { throw new Exception('Error reading directory header'); } } if ($startElement != '<D>') { throw new Exception("Invalid directory header marker found [{$startElement}] : location ".ftell($archiveHandle)); } } $instance->mtime = DupArchiveHeaderU::readStandardHeaderField($archiveHandle, 'MT'); $instance->permissions = DupArchiveHeaderU::readStandardHeaderField($archiveHandle, 'P'); $instance->relativePathLength = DupArchiveHeaderU::readStandardHeaderField($archiveHandle, 'RPL'); // Skip the <RP> fread($archiveHandle, 4); $instance->relativePath = fread($archiveHandle, $instance->relativePathLength); // Skip the </RP> // fread($archiveHandle, 5); // // // Skip the </D> // fread($archiveHandle, 4); // Skip the </RP> and the </D> fread($archiveHandle, 9); return $instance; } public function writeToArchive($archiveHandle) { if($this->relativePathLength == 0) { // Don't allow a base path to be written to the archive return; } $headerString = '<D><MT>'.$this->mtime.'</MT><P>'.$this->permissions.'</P><RPL>'.$this->relativePathLength.'</RPL><RP>'.$this->relativePath.'</RP></D>'; //DupLiteSnapLibIOU::fwrite($archiveHandle, $headerString); $bytes_written = @fwrite($archiveHandle, $headerString); if ($bytes_written === false) { throw new Exception('Error writing to file.'); } else { return $bytes_written; } } } }PK��c&4\dZx��-��classes/headers/class.duparchive.header.u.phpnu��[��<?php defined('ABSPATH') \|\| defined('DUPXABSPATH') \|\| exit; / * To change this license header, choose License Headers in Project Properties. * To change this template file, choose Tools \| Templates * and open the template in the editor. / if(!class_exists('DupArchiveHeaderU')) { class DupArchiveHeaderU { const MaxStandardHeaderFieldLength = 128; public static function readStandardHeaderField($archiveHandle, $ename) { $expectedStart = '<'.$ename.'>'; $expectedEnd = '</'.$ename.'>'; $startingElement = fread($archiveHandle, strlen($expectedStart)); if($startingElement !== $expectedStart) { throw new Exception("Invalid starting element. Was expecting {$expectedStart} but got {$startingElement}"); } //return DupLiteSnapLibStreamU::streamGetLine($archiveHandle, self::MaxStandardHeaderFieldLength, $expectedEnd); $headerString = stream_get_line($archiveHandle, self::MaxStandardHeaderFieldLength, $expectedEnd); if ($headerString === false) { throw new Exception('Error reading line.'); } return $headerString; } } }PK��c&4\��]x7��x7����classes/class.duparchive.mini.expander.phpnu��[��<?php defined('ABSPATH') \|\| defined('DUPXABSPATH') \|\| exit; //---------- DUPARCHIVE MINI EXPANDER: The contents of this file will be injected into the installer bootlog at build time ------------------------ class DupArchiveHeaderMiniU { const MaxStandardHeaderFieldLength = 128; public static function readStandardHeaderField($archiveHandle, $ename) { $expectedStart = "<{$ename}>"; $expectedEnd = "</{$ename}>"; $startingElement = fread($archiveHandle, strlen($expectedStart)); if($startingElement !== $expectedStart) { throw new Exception("Invalid starting element. Was expecting {$expectedStart} but got {$startingElement}"); } return stream_get_line($archiveHandle, self::MaxStandardHeaderFieldLength, $expectedEnd); } } class DupArchiveMiniItemHeaderType { const None = 0; const File = 1; const Directory = 2; const Glob = 3; } class DupArchiveMiniFileHeader { public $fileSize; public $mtime; public $permissions; public $hash; public $relativePathLength; public $relativePath; static function readFromArchive($archiveHandle) { $instance = new DupArchiveMiniFileHeader(); $instance->fileSize = DupArchiveHeaderMiniU::readStandardHeaderField($archiveHandle, 'FS'); $instance->mtime = DupArchiveHeaderMiniU::readStandardHeaderField($archiveHandle, 'MT'); $instance->permissions = DupArchiveHeaderMiniU::readStandardHeaderField($archiveHandle, 'P'); $instance->hash = DupArchiveHeaderMiniU::readStandardHeaderField($archiveHandle, 'HA'); $instance->relativePathLength = DupArchiveHeaderMiniU::readStandardHeaderField($archiveHandle, 'RPL'); // Skip <RP> fread($archiveHandle, 4); $instance->relativePath = fread($archiveHandle, $instance->relativePathLength); // Skip </RP> fread($archiveHandle, 5); // Skip the #F! //fread($archiveHandle, 3); // Skip the </F> fread($archiveHandle, 4); return $instance; } } class DupArchiveMiniDirectoryHeader { public $mtime; public $permissions; public $relativePathLength; public $relativePath; // const MaxHeaderSize = 8192; // const MaxStandardHeaderFieldLength = 128; static function readFromArchive($archiveHandle) { $instance = new DupArchiveMiniDirectoryHeader(); $instance->mtime = DupArchiveHeaderMiniU::readStandardHeaderField($archiveHandle, 'MT'); $instance->permissions = DupArchiveHeaderMiniU::readStandardHeaderField($archiveHandle, 'P'); $instance->relativePathLength = DupArchiveHeaderMiniU::readStandardHeaderField($archiveHandle, 'RPL'); // Skip the <RP> fread($archiveHandle, 4); $instance->relativePath = fread($archiveHandle, $instance->relativePathLength); // Skip the </RP> fread($archiveHandle, 5); // Skip the </D> fread($archiveHandle, 4); return $instance; } } class DupArchiveMiniGlobHeader //extends HeaderBase { public $originalSize; public $storedSize; public $hash; // const MaxHeaderSize = 255; public static function readFromArchive($archiveHandle, $skipGlob) { $instance = new DupArchiveMiniGlobHeader(); // DupArchiveUtil::log('Reading glob starting at ' . ftell($archiveHandle)); $startElement = fread($archiveHandle, 3); //if ($marker != '?G#') { if ($startElement != '<G>') { throw new Exception("Invalid glob header marker found {$startElement}. location:" . ftell($archiveHandle)); } $instance->originalSize = DupArchiveHeaderMiniU::readStandardHeaderField($archiveHandle, 'OS'); $instance->storedSize = DupArchiveHeaderMiniU::readStandardHeaderField($archiveHandle, 'SS'); $instance->hash = DupArchiveHeaderMiniU::readStandardHeaderField($archiveHandle, 'HA'); // Skip the </G> fread($archiveHandle, 4); if ($skipGlob) { // DupLiteSnapLibIOU::fseek($archiveHandle, $instance->storedSize, SEEK_CUR); if(fseek($archiveHandle, $instance->storedSize, SEEK_CUR) === -1) { throw new Exception("Can't fseek when skipping glob at location:".ftell($archiveHandle)); } } return $instance; } } class DupArchiveMiniHeader { public $version; public $isCompressed; // const MaxHeaderSize = 50; private function __construct() { // Prevent instantiation if (!class_exists('DUPX_Bootstrap')) { throw new Exception('Class DUPX_Bootstrap not found'); } } public static function readFromArchive($archiveHandle) { $instance = new DupArchiveMiniHeader(); $startElement = fgets($archiveHandle, 4); if ($startElement != '<A>') { throw new Exception("Invalid archive header marker found {$startElement}"); } $instance->version = DupArchiveHeaderMiniU::readStandardHeaderField($archiveHandle, 'V'); $instance->isCompressed = DupArchiveHeaderMiniU::readStandardHeaderField($archiveHandle, 'C') == 'true' ? true : false; // Skip the </A> fgets($archiveHandle, 5); return $instance; } } class DupArchiveMiniWriteInfo { public $archiveHandle = null; public $currentFileHeader = null; public $destDirectory = null; public $directoryWriteCount = 0; public $fileWriteCount = 0; public $isCompressed = false; public $enableWrite = false; public function getCurrentDestFilePath() { if($this->destDirectory != null) { return "{$this->destDirectory}/{$this->currentFileHeader->relativePath}"; } else { return null; } } } class DupArchiveMiniExpander { public static $loggingFunction = null; public static function init($loggingFunction) { self::$loggingFunction = $loggingFunction; } public static function log($s, $flush=false) { if(self::$loggingFunction != null) { call_user_func(self::$loggingFunction, "MINI EXPAND:$s", $flush); } } public static function expandDirectory($archivePath, $relativePath, $destPath) { self::expandItems($archivePath, $relativePath, $destPath); } private static function expandItems($archivePath, $inclusionFilter, $destDirectory, $ignoreErrors = false) { $archiveHandle = fopen($archivePath, 'rb'); if ($archiveHandle === false) { throw new Exception("Can’t open archive at $archivePath!"); } $archiveHeader = DupArchiveMiniHeader::readFromArchive($archiveHandle); $writeInfo = new DupArchiveMiniWriteInfo(); $writeInfo->destDirectory = $destDirectory; $writeInfo->isCompressed = $archiveHeader->isCompressed; $moreToRead = true; while ($moreToRead) { if ($writeInfo->currentFileHeader != null) { try { if (self::passesInclusionFilter($inclusionFilter, $writeInfo->currentFileHeader->relativePath)) { self::writeToFile($archiveHandle, $writeInfo); $writeInfo->fileWriteCount++; } else if($writeInfo->currentFileHeader->fileSize > 0) { // self::log("skipping {$writeInfo->currentFileHeader->relativePath} since it doesn’t match the filter"); // Skip the contents since the it isn't a match $dataSize = 0; do { $globHeader = DupArchiveMiniGlobHeader::readFromArchive($archiveHandle, true); $dataSize += $globHeader->originalSize; $moreGlobs = ($dataSize < $writeInfo->currentFileHeader->fileSize); } while ($moreGlobs); } $writeInfo->currentFileHeader = null; // Expand state taken care of within the write to file to ensure consistency } catch (Exception $ex) { if (!$ignoreErrors) { throw $ex; } } } else { $headerType = self::getNextHeaderType($archiveHandle); switch ($headerType) { case DupArchiveMiniItemHeaderType::File: //$writeInfo->currentFileHeader = DupArchiveMiniFileHeader::readFromArchive($archiveHandle, $inclusionFilter); $writeInfo->currentFileHeader = DupArchiveMiniFileHeader::readFromArchive($archiveHandle); break; case DupArchiveMiniItemHeaderType::Directory: $directoryHeader = DupArchiveMiniDirectoryHeader::readFromArchive($archiveHandle); // self::log("considering $inclusionFilter and {$directoryHeader->relativePath}"); if (self::passesInclusionFilter($inclusionFilter, $directoryHeader->relativePath)) { // self::log("passed"); $directory = "{$writeInfo->destDirectory}/{$directoryHeader->relativePath}"; // $mode = $directoryHeader->permissions; // rodo handle this more elegantly @mkdir($directory, $directoryHeader->permissions, true); DUPX_Bootstrap::mkdir($directory, 'u+rwx', true); $writeInfo->directoryWriteCount++; } else { // self::log("didnt pass"); } break; case DupArchiveMiniItemHeaderType::None: $moreToRead = false; } } } fclose($archiveHandle); } private static function getNextHeaderType($archiveHandle) { $retVal = DupArchiveMiniItemHeaderType::None; $marker = fgets($archiveHandle, 4); if (feof($archiveHandle) === false) { switch ($marker) { case '<D>': $retVal = DupArchiveMiniItemHeaderType::Directory; break; case '<F>': $retVal = DupArchiveMiniItemHeaderType::File; break; case '<G>': $retVal = DupArchiveMiniItemHeaderType::Glob; break; default: throw new Exception("Invalid header marker {$marker}. Location:".ftell($archiveHandle)); } } return $retVal; } private static function writeToFile($archiveHandle, $writeInfo) { $destFilePath = $writeInfo->getCurrentDestFilePath(); if($writeInfo->currentFileHeader->fileSize > 0) { /* @var $writeInfo DupArchiveMiniWriteInfo / $parentDir = dirname($destFilePath); if (!file_exists($parentDir)) { if (!DUPX_Bootstrap::mkdir($parentDir, 'u+rwx', true)) { throw new Exception("Couldn't create {$parentDir}"); } } $destFileHandle = fopen($destFilePath, 'wb+'); if ($destFileHandle === false) { throw new Exception("Couldn't open {$destFilePath} for writing."); } do { self::appendGlobToFile($archiveHandle, $destFileHandle, $writeInfo); $currentFileOffset = ftell($destFileHandle); $moreGlobstoProcess = $currentFileOffset < $writeInfo->currentFileHeader->fileSize; } while ($moreGlobstoProcess); fclose($destFileHandle); DUPX_Bootstrap::chmod($destFilePath, 'u+rw'); self::validateExpandedFile($writeInfo); } else { if(touch($destFilePath) === false) { throw new Exception("Couldn't create $destFilePath"); } DUPX_Bootstrap::chmod($destFilePath, 'u+rw'); } } private static function validateExpandedFile($writeInfo) { / @var $writeInfo DupArchiveMiniWriteInfo / if ($writeInfo->currentFileHeader->hash !== '00000000000000000000000000000000') { $hash = hash_file('crc32b', $writeInfo->getCurrentDestFilePath()); if ($hash !== $writeInfo->currentFileHeader->hash) { throw new Exception("MD5 validation fails for {$writeInfo->getCurrentDestFilePath()}"); } } } // Assumption is that archive handle points to a glob header on this call private static function appendGlobToFile($archiveHandle, $destFileHandle, $writeInfo) { / @var $writeInfo DupArchiveMiniWriteInfo / $globHeader = DupArchiveMiniGlobHeader::readFromArchive($archiveHandle, false); $globContents = fread($archiveHandle, $globHeader->storedSize); if ($globContents === false) { throw new Exception("Error reading glob from {$writeInfo->getDestFilePath()}"); } if ($writeInfo->isCompressed) { $globContents = gzinflate($globContents); } if (fwrite($destFileHandle, $globContents) === false) { throw new Exception("Error writing data glob to {$destFileHandle}"); } } private static function passesInclusionFilter($filter, $candidate) { return (substr($candidate, 0, strlen($filter)) == $filter); } } ?>PK��c&4\�/V:��classes/processors/index.phpnu��[��<?php //silentPK��c&4\��C��C��6��classes/processors/class.duparchive.processor.file.phpnu��[��<?php defined('ABSPATH') \|\| defined('DUPXABSPATH') \|\| exit; / * To change this license header, choose License Headers in Project Properties. * To change this template file, choose Tools \| Templates * and open the template in the editor. / require_once(dirname(__FILE__).'/../headers/class.duparchive.header.file.php'); require_once(dirname(__FILE__).'/../headers/class.duparchive.header.glob.php'); if(!class_exists('DupArchiveFileProcessor')) { class DupArchiveFileProcessor { public static function writeFilePortionToArchive($createState, $archiveHandle, $sourceFilepath, $relativeFilePath) { / @var $createState DupArchiveCreateState / DupArchiveUtil::tlog("writeFileToArchive for {$sourceFilepath}"); // profile ok // switching to straight call for speed $sourceHandle = @fopen($sourceFilepath, 'rb'); // end profile ok if(!is_resource($sourceHandle)) { $createState->archiveOffset = DupLiteSnapLibIOU::ftell($archiveHandle); $createState->currentFileIndex++; $createState->currentFileOffset = 0; $createState->skippedFileCount++; $createState->addFailure(DupArchiveFailureTypes::File, $sourceFilepath, "Couldn't open $sourceFilepath", false); return; } if ($createState->currentFileOffset > 0) { DupArchiveUtil::tlog("Continuing {$sourceFilepath} so seeking to {$createState->currentFileOffset}"); DupLiteSnapLibIOU::fseek($sourceHandle, $createState->currentFileOffset); } else { DupArchiveUtil::tlog("Starting new file entry for {$sourceFilepath}"); // profile ok $fileHeader = DupArchiveFileHeader::createFromFile($sourceFilepath, $relativeFilePath); // end profile ok // profile ok $fileHeader->writeToArchive($archiveHandle); // end profile ok } // profile ok $sourceFileSize = filesize($sourceFilepath); DupArchiveUtil::tlog("writeFileToArchive for {$sourceFilepath}, size {$sourceFileSize}"); $moreFileDataToProcess = true; while ((!$createState->timedOut()) && $moreFileDataToProcess) { if($createState->throttleDelayInUs !== 0) { usleep($createState->throttleDelayInUs); } DupArchiveUtil::tlog("Writing offset={$createState->currentFileOffset}"); // profile ok $moreFileDataToProcess = self::appendGlobToArchive($createState, $archiveHandle, $sourceHandle, $sourceFilepath, $sourceFileSize); // end profile ok // profile ok if ($moreFileDataToProcess) { DupArchiveUtil::tlog("Need to keep writing {$sourceFilepath} to archive"); $createState->currentFileOffset += $createState->globSize; $createState->archiveOffset = DupLiteSnapLibIOU::ftell($archiveHandle); //?? } else { DupArchiveUtil::tlog("Completed writing {$sourceFilepath} to archive"); $createState->archiveOffset = DupLiteSnapLibIOU::ftell($archiveHandle); $createState->currentFileIndex++; $createState->currentFileOffset = 0; } // end profile ok if ($createState->currentFileIndex % 100 == 0) { DupArchiveUtil::log("Archive Offset={$createState->archiveOffset}; Current File Index={$createState->currentFileIndex}; Current File Offset={$createState->currentFileOffset}"); } // Only writing state after full group of files have been written - less reliable but more efficient // $createState->save(); } // profile ok DupLiteSnapLibIOU::fclose($sourceHandle); // end profile ok } // Assumption is that this is called at the beginning of a glob header since file header already writtern public static function writeToFile($expandState, $archiveHandle) { / @var $expandState DupArchiveExpandState / $destFilepath = $expandState->basePath.'/'.$expandState->currentFileHeader->relativePath; $parentDir = dirname($destFilepath); $moreGlobstoProcess = true; DupLiteSnapLibIOU::dirWriteCheckOrMkdir($parentDir, 'u+rwx'); if ($expandState->currentFileHeader->fileSize > 0) { if ($expandState->currentFileOffset > 0) { $destFileHandle = DupLiteSnapLibIOU::fopen($destFilepath, 'r+b'); DupArchiveUtil::tlog('Continuing '.$destFilepath.' so seeking to '.$expandState->currentFileOffset); DupLiteSnapLibIOU::fseek($destFileHandle, $expandState->currentFileOffset); } else { DupArchiveUtil::tlog('Starting to write new file '.$destFilepath); $destFileHandle = DupLiteSnapLibIOU::fopen($destFilepath, 'w+b'); } DupArchiveUtil::tlog('writeToFile for '.$destFilepath.', size '.$expandState->currentFileHeader->fileSize); while (!$expandState->timedOut()) { $moreGlobstoProcess = $expandState->currentFileOffset < $expandState->currentFileHeader->fileSize; if ($moreGlobstoProcess) { DupArchiveUtil::tlog('Need to keep writing to '.$destFilepath.' because current file offset='.$expandState->currentFileOffset.' and file size='.$expandState->currentFileHeader->fileSize); if($expandState->throttleDelayInUs !== 0) { usleep($expandState->throttleDelayInUs); } DupArchiveUtil::tlog('Writing offset='.$expandState->currentFileOffset); self::appendGlobToFile($expandState, $archiveHandle, $destFileHandle, $destFilepath); DupArchiveUtil::tlog('After glob write'); $expandState->currentFileOffset = ftell($destFileHandle); $expandState->archiveOffset = DupLiteSnapLibIOU::ftell($archiveHandle); $moreGlobstoProcess = $expandState->currentFileOffset < $expandState->currentFileHeader->fileSize; if(!$moreGlobstoProcess) { break; } if (rand(0, 1000) > 990) { DupArchiveUtil::log("Archive Offset={$expandState->archiveOffset}; Current File={$destFilepath}; Current File Offset={$expandState->currentFileOffset}"); } } else { // No more globs to process // Reset the expand state here to ensure it stays consistent DupArchiveUtil::tlog('Writing of '.$destFilepath.' to archive is done'); // rsr todo record fclose error @fclose($destFileHandle); $destFileHandle = null; self::setFileMode($expandState, $destFilepath); if ($expandState->validationType == DupArchiveValidationTypes::Full) { self::validateExpandedFile($expandState); } break; } } DupArchiveUtil::tlog('Out of glob loop'); if ($destFileHandle != null) { // rsr todo record file close error @fclose($destFileHandle); $destFileHandle = null; } if (!$moreGlobstoProcess && $expandState->validateOnly && ($expandState->validationType == DupArchiveValidationTypes::Full)) { if (!is_writable($destFilepath)) { DupLiteSnapLibIOU::chmod($destFilepath, 'u+rw'); } if (@unlink($destFilepath) === false) { // $expandState->addFailure(DupArchiveFailureTypes::File, $destFilepath, "Couldn't delete {$destFilepath} during validation", false); // TODO: Have to know how to handle this - want to report it but don’t want to mess up validation - some non critical errors could be important to validation } } } else { // 0 length file so just touch it $moreGlobstoProcess = false; if(file_exists($destFilepath)) { @unlink($destFilepath); } if (touch($destFilepath) === false) { throw new Exception("Couldn't create {$destFilepath}"); } self::setFileMode($expandState, $destFilepath); } if(!$moreGlobstoProcess) { DupArchiveUtil::tlog('No more globs to process'); if((!$expandState->validateOnly) && (isset($expandState->fileRenames[$expandState->currentFileHeader->relativePath]))) { $newRelativePath = $expandState->fileRenames[$expandState->currentFileHeader->relativePath]; $newFilepath = $expandState->basePath.'/'.$newRelativePath; $perform_rename = true; if(@file_exists($newFilepath)) { if(@unlink($newFilepath) === false) { $perform_rename = false; $error_message = "Couldn't delete {$newFilepath} when trying to rename {$destFilepath}"; $expandState->addFailure(DupArchiveFailureTypes::File, $expandState->currentFileHeader->relativePath, $error_message, true); DupArchiveUtil::tlog($error_message); } } if($perform_rename && @rename($destFilepath, $newFilepath) === false) { $error_message = "Couldn't rename {$destFilepath} to {$newFilepath}"; $expandState->addFailure(DupArchiveFailureTypes::File, $expandState->currentFileHeader->relativePath, $error_message, true); DupArchiveUtil::tlog($error_message); } } $expandState->fileWriteCount++; $expandState->resetForFile(); } return !$moreGlobstoProcess; } public static function setFileMode($expandState, $filePath) { $mode = 'u+rw'; if($expandState->fileModeOverride !== -1) { $mode = $expandState->fileModeOverride; } DupLiteSnapLibIOU::chmod($filePath, $mode); } public static function standardValidateFileEntry(&$expandState, $archiveHandle) { / @var $expandState DupArchiveExpandState / $moreGlobstoProcess = $expandState->currentFileOffset < $expandState->currentFileHeader->fileSize; if (!$moreGlobstoProcess) { // Not a 'real' write but indicates that we actually did fully process a file in the archive $expandState->fileWriteCount++; } else { while ((!$expandState->timedOut()) && $moreGlobstoProcess) { // Read in the glob header but leave the pointer at the payload // profile ok $globHeader = DupArchiveGlobHeader::readFromArchive($archiveHandle, false); // profile ok $globContents = fread($archiveHandle, $globHeader->storedSize); if ($globContents === false) { throw new Exception("Error reading glob from $destFilePath"); } $hash = hash('crc32b', $globContents); if ($hash != $globHeader->hash) { $expandState->addFailure(DupArchiveFailureTypes::File, $expandState->currentFileHeader->relativePath, 'Hash mismatch on DupArchive file entry', true); DupArchiveUtil::tlog("Glob hash mismatch during standard check of {$expandState->currentFileHeader->relativePath}"); } else { // DupArchiveUtil::tlog("Glob MD5 passes"); } $expandState->currentFileOffset += $globHeader->originalSize; // profile ok $expandState->archiveOffset = DupLiteSnapLibIOU::ftell($archiveHandle); $moreGlobstoProcess = $expandState->currentFileOffset < $expandState->currentFileHeader->fileSize; if (!$moreGlobstoProcess) { $expandState->fileWriteCount++; // profile ok $expandState->resetForFile(); } } } return !$moreGlobstoProcess; } private static function validateExpandedFile(&$expandState) { / @var $expandState DupArchiveExpandState / $destFilepath = $expandState->basePath.'/'.$expandState->currentFileHeader->relativePath; if ($expandState->currentFileHeader->hash !== '00000000000000000000000000000000') { $hash = hash_file('crc32b', $destFilepath); if ($hash !== $expandState->currentFileHeader->hash) { $expandState->addFailure(DupArchiveFailureTypes::File, $destFilepath, "MD5 mismatch for {$destFilepath}", false); } else { DupArchiveUtil::tlog('MD5 Match for '.$destFilepath); } } else { DupArchiveUtil::tlog('MD5 non match is 0\'s'); } } private static function appendGlobToArchive($createState, $archiveHandle, $sourceFilehandle, $sourceFilepath, $fileSize) { DupArchiveUtil::tlog("Appending file glob to archive for file {$sourceFilepath} at file offset {$createState->currentFileOffset}"); if ($fileSize > 0) { $fileSize -= $createState->currentFileOffset; // profile ok $globContents = @fread($sourceFilehandle, $createState->globSize); // end profile ok if ($globContents === false) { throw new Exception("Error reading $sourceFilepath"); } // profile ok $originalSize = strlen($globContents); // end profile ok if ($createState->isCompressed) { // profile ok $globContents = gzdeflate($globContents, 2); // 2 chosen as best compromise between speed and size $storeSize = strlen($globContents); // end profile ok } else { $storeSize = $originalSize; } $globHeader = new DupArchiveGlobHeader(); $globHeader->originalSize = $originalSize; $globHeader->storedSize = $storeSize; $globHeader->hash = hash('crc32b',$globContents); // profile ok $globHeader->writeToArchive($archiveHandle); // end profile ok // profile ok if (@fwrite($archiveHandle, $globContents) === false) { // Considered fatal since we should always be able to write to the archive - plus the header has already been written (could back this out later though) throw new Exception("Error writing $sourceFilepath to archive. Ensure site still hasn't run out of space.", DupArchiveExceptionCodes::Fatal); } // end profile ok $fileSizeRemaining = $fileSize - $createState->globSize; $moreFileRemaining = $fileSizeRemaining > 0; return $moreFileRemaining; } else { // 0 Length file return false; } } // Assumption is that archive handle points to a glob header on this call private static function appendGlobToFile($expandState, $archiveHandle, $destFileHandle, $destFilePath) { / @var $expandState DupArchiveExpandState / DupArchiveUtil::tlog('Appending file glob to file '.$destFilePath.' at file offset '.$expandState->currentFileOffset); // Read in the glob header but leave the pointer at the payload $globHeader = DupArchiveGlobHeader::readFromArchive($archiveHandle, false); $globContents = @fread($archiveHandle, $globHeader->storedSize); if ($globContents === false) { throw new Exception("Error reading glob from $destFilePath"); } if ($expandState->isCompressed) { $globContents = gzinflate($globContents); } if (@fwrite($destFileHandle, $globContents) === false) { throw new Exception("Error writing glob to $destFilePath"); } else { DupArchiveUtil::tlog('Successfully wrote glob'); } } } }PK��c&4\�,ͤ��;��classes/processors/class.duparchive.processor.directory.phpnu��[��<?php defined('ABSPATH') \|\| defined('DUPXABSPATH') \|\| exit; require_once(dirname(__FILE__).'/../headers/class.duparchive.header.directory.php'); if(!class_exists('DupArchiveDirectoryProcessor')) { class DupArchiveDirectoryProcessor { public static function writeDirectoryToArchive($createState, $archiveHandle, $sourceDirectoryPath, $relativeDirectoryPath) { / @var $createState DupArchiveCreateState / $directoryHeader = new DupArchiveDirectoryHeader(); $directoryHeader->permissions = substr(sprintf('%o', fileperms($sourceDirectoryPath)), -4); $directoryHeader->mtime = DupLiteSnapLibIOU::filemtime($sourceDirectoryPath); $directoryHeader->relativePath = $relativeDirectoryPath; $directoryHeader->relativePathLength = strlen($directoryHeader->relativePath); $directoryHeader->writeToArchive($archiveHandle); // Just increment this here - the actual state save is on the outside after timeout or completion of all directories $createState->currentDirectoryIndex++; } } }PK��c&4\uM�\|��6��classes/states/class.duparchive.state.simplecreate.phpnu��[��<?php defined('ABSPATH') \|\| defined('DUPXABSPATH') \|\| exit; / * To change this license header, choose License Headers in Project Properties. * To change this template file, choose Tools \| Templates * and open the template in the editor. / require_once(dirname(__FILE__).'/class.duparchive.state.create.php'); if (!class_exists('DupArchiveSimpleCreateState')) { class DupArchiveSimpleCreateState extends DupArchiveCreateState { function __construct() { $this->currentDirectoryIndex = 0; $this->currentFileIndex = 0; $this->currentFileOffset = 0; } public function save() { } } }PK��c&4\f8�pp ��p ��.��classes/states/class.duparchive.state.base.phpnu��[��<?php defined('ABSPATH') \|\| defined('DUPXABSPATH') \|\| exit; / * To change this license header, choose License Headers in Project Properties. * To change this template file, choose Tools \| Templates * and open the template in the editor. / require_once(dirname(__FILE__).'/../class.duparchive.processing.failure.php'); if(!class_exists('DupArchiveStateBase')) { abstract class DupArchiveStateBase { public $basePath = ''; public $archivePath = ''; public $isCompressed = false; public $currentFileOffset = -1; public $archiveOffset = -1; public $timeSliceInSecs = -1; public $working = false; public $failures = null; public $startTimestamp = -1; public $throttleDelayInUs = 0; public $timeoutTimestamp = -1; public $timerEnabled = true; public $isRobust = false; public function __construct() { $this->failures = array(); } public function isCriticalFailurePresent() { if(count($this->failures) > 0) { foreach($this->failures as $failure) { / @var $failure DupArchiveProcessingFailure / if($failure->isCritical) { return true; } } } return false; } public function getFailureSummary($includeCritical = true, $includeWarnings = false) { if(count($this->failures) > 0) { $message = ''; foreach($this->failures as $failure) { / @var $failure DupArchiveProcessingFailure / if($includeCritical \|\| !$failure->isCritical) { $message .= "\n" . $this->getFailureString($failure); } } return $message; } else { if($includeCritical) { if($includeWarnings) { return 'No errors or warnings.'; } else { return 'No errors.'; } } else { return 'No warnings.'; } } } public function getFailureString($failure) { $s = ''; if($failure->isCritical) { $s = 'CRITICAL: '; } return "{$s}{$failure->subject} : {$failure->description}"; } public function addFailure($type, $subject, $description, $isCritical = true) { $failure = new DupArchiveProcessingFailure(); $failure->type = $type; $failure->subject = $subject; $failure->description = $description; $failure->isCritical = $isCritical; $this->failures[] = $failure; return $failure; } public function startTimer() { if ($this->timerEnabled) { $this->timeoutTimestamp = time() + $this->timeSliceInSecs; } } public function timedOut() { if ($this->timerEnabled) { if ($this->timeoutTimestamp != -1) { return time() >= $this->timeoutTimestamp; } else { return false; } } else { return false; } } // abstract public function save(); } }PK��c&4\��X8%��%��6��classes/states/class.duparchive.state.simpleexpand.phpnu��[��<?php defined('ABSPATH') \|\| defined('DUPXABSPATH') \|\| exit; / * To change this license header, choose License Headers in Project Properties. * To change this template file, choose Tools \| Templates * and open the template in the editor. / require_once(dirname(__FILE__).'/class.duparchive.state.expand.php'); if (!class_exists('DupArchiveSimpleExpandState')) { class DupArchiveSimpleExpandState extends DupArchiveExpandState { function __construct() { } public function save() { } } }PK��c&4\� ��0��classes/states/class.duparchive.state.create.phpnu��[��<?php defined('ABSPATH') \|\| defined('DUPXABSPATH') \|\| exit; / * To change this license header, choose License Headers in Project Properties. * To change this template file, choose Tools \| Templates * and open the template in the editor. / require_once(dirname(__FILE__).'/class.duparchive.state.base.php'); if (!class_exists('DupArchiveCreateState')) { abstract class DupArchiveCreateState extends DupArchiveStateBase { //const DEFAULT_GLOB_SIZE = 4180000; //512000; const DEFAULT_GLOB_SIZE = 1048576; public $currentDirectoryIndex = -1; public $currentFileIndex = -1; public $globSize = self::DEFAULT_GLOB_SIZE; public $newBasePath = null; public $skippedFileCount = 0; public $skippedDirectoryCount = 0; } }PK��c&4\{�E-��-��0��classes/states/class.duparchive.state.expand.phpnu��[��<?php defined('ABSPATH') \|\| defined('DUPXABSPATH') \|\| exit; / * To change this license header, choose License Headers in Project Properties. * To change this template file, choose Tools \| Templates * and open the template in the editor. / require_once(dirname(__FILE__).'/class.duparchive.state.base.php'); if (!class_exists('DupArchiveValidationTypes')) { class DupArchiveValidationTypes { const None = 0; const Standard = 1; const Full = 2; } } if (!class_exists('DupArchiveExpandState')) { abstract class DupArchiveExpandState extends DupArchiveStateBase { public $archiveHeader = null; public $currentFileHeader = null; public $validateOnly = false; public $validationType = DupArchiveValidationTypes::Standard; public $fileWriteCount = 0; public $directoryWriteCount = 0; public $expectedFileCount = -1; public $expectedDirectoryCount = -1; public $filteredDirectories = array(); public $filteredFiles = array(); public $includedFiles = array(); public $fileRenames = array(); public $directoryModeOverride = -1; public $fileModeOverride = -1; public $lastHeaderOffset = -1; public function resetForFile() { $this->currentFileHeader = null; $this->currentFileOffset = 0; } } }PK��c&4\�/V:��classes/states/index.phpnu��[��<?php //silentPK��c&4\�/V:��classes/index.phpnu��[��<?php //silentPK��c&4\�޸ig��g��/��classes/class.duparchive.processing.failure.phpnu��[��<?php defined('ABSPATH') \|\| defined('DUPXABSPATH') \|\| exit; / * To change this license header, choose License Headers in Project Properties. * To change this template file, choose Tools \| Templates * and open the template in the editor. / if(!class_exists('DupArchiveProcessingFailure')) { abstract class DupArchiveFailureTypes { const Unknown = 0; const File = 1; const Directory = 2; } class DupArchiveProcessingFailure { public $type = DupArchiveFailureTypes::Unknown; public $description = ''; public $subject = ''; public $isCritical = false; } }PK��c&4\z�K��'��classes/class.duparchive.loggerbase.phpnu��[��<?php defined('ABSPATH') \|\| defined('DUPXABSPATH') \|\| exit; if(!class_exists('DupArchiveLoggerBase')) { abstract class DupArchiveLoggerBase { abstract public function log($s, $flush = false, $callingFunctionOverride = null); } } PK��c&4\Nn�2$��$��&��classes/class.duparchive.constants.phpnu��[��<?php defined('ABSPATH') \|\| defined('DUPXABSPATH') \|\| exit; / * To change this license header, choose License Headers in Project Properties. * To change this template file, choose Tools \| Templates * and open the template in the editor. / if(!class_exists('DupArchiveConstants')) { class DupArchiveConstants { public static $DARoot; public static $LibRoot; public static $MaxFilesizeForHashing; public static function init() { self::$LibRoot = dirname(__FILE__).'/../../'; self::$DARoot = dirname(__FILE__).'/../'; self::$MaxFilesizeForHashing = 1000000000; } } DupArchiveConstants::init(); } if(!class_exists('DupArchiveExceptionCodes')) { class DupArchiveExceptionCodes { const NonFatal = 0; const Fatal = 1; } } PK��c&4\�/V:�� index.phpnu��[��<?php //silentPK��c&4\A;m\��\��daws/class.daws.constants.phpnu��[��<?php defined('ABSPATH') \|\| defined('DUPXABSPATH') \|\| exit; / * To change this license header, choose License Headers in Project Properties. * To change this template file, choose Tools \| Templates * and open the template in the editor. / class DAWSConstants { public static $DAWS_ROOT; public static $DUPARCHIVE_DIR; public static $DUPARCHIVE_CLASSES_DIR; public static $DUPARCHIVE_STATES_DIR; public static $DUPARCHIVE_UTIL_DIR; public static $DEFAULT_WORKER_TIME = 18; public static $LIB_DIR; public static $PROCESS_LOCK_FILEPATH; public static $PROCESS_CANCEL_FILEPATH; public static $LOG_FILEPATH; public static function init() { self::$DAWS_ROOT = dirname(__FILE__); self::$DUPARCHIVE_DIR = self::$DAWS_ROOT.'/..'; self::$DUPARCHIVE_CLASSES_DIR = self::$DUPARCHIVE_DIR.'/classes'; self::$DUPARCHIVE_STATES_DIR = self::$DUPARCHIVE_CLASSES_DIR.'/states'; self::$DUPARCHIVE_UTIL_DIR = self::$DUPARCHIVE_CLASSES_DIR.'/util'; self::$LIB_DIR = self::$DAWS_ROOT.'/../..'; self::$PROCESS_LOCK_FILEPATH = self::$DAWS_ROOT.'/dawslock.bin'; self::$PROCESS_CANCEL_FILEPATH = self::$DAWS_ROOT.'/dawscancel.bin'; self::$LOG_FILEPATH = dirname(__FILE__).'/daws.log'; } } DAWSConstants::init();PK��c&4\�/V:��daws/index.phpnu��[��<?php //silentPK��c&4\��daws/dawslock.binnu��[��PK��c&4\\|ܘ\�� daws/class.daws.state.expand.phpnu��[��<?php defined('ABSPATH') \|\| defined('DUPXABSPATH') \|\| exit; / * To change this license header, choose License Headers in Project Properties. * To change this template file, choose Tools \| Templates * and open the template in the editor. / require_once(DAWSConstants::$DUPARCHIVE_STATES_DIR.'/class.duparchive.state.expand.php'); class DAWSExpandState extends DupArchiveExpandState { public static $instance = null; const StateFilename = 'expandstate.json'; public static function purgeStatefile() { $stateFilepath = dirname(__FILE__).'/'.self::StateFilename; DupLiteSnapLibIOU::rm($stateFilepath, false); } public static function getInstance($reset = false) { if ((self::$instance == null) && (!$reset)) { $stateFilepath = dirname(__FILE__).'/'.self::StateFilename; self::$instance = new DAWSExpandState(); if (file_exists($stateFilepath)) { $stateHandle = DupLiteSnapLibIOU::fopen($stateFilepath, 'rb'); // RSR we shouldn't need read locks and it seems to screw up on some boxes anyway.. DupLiteSnapLibIOU::flock($stateHandle, LOCK_EX); $stateString = fread($stateHandle, filesize($stateFilepath)); $data = json_decode($stateString); self::$instance->setFromData($data); self::$instance->fileRenames = (array)(self::$instance->fileRenames); // DupLiteSnapLibIOU::flock($stateHandle, LOCK_UN); DupLiteSnapLibIOU::fclose($stateHandle); } else { $reset = true; } } if ($reset) { self::$instance = new DAWSExpandState(); self::$instance->reset(); } return self::$instance; } private function setFromData($data) { $this->currentFileHeader = $data->currentFileHeader; $this->archiveHeader = $data->archiveHeader; $this->archiveOffset = $data->archiveOffset; $this->archivePath = $data->archivePath; $this->basePath = $data->basePath; $this->currentFileOffset = $data->currentFileOffset; $this->failures = $data->failures; $this->isCompressed = $data->isCompressed; $this->startTimestamp = $data->startTimestamp; $this->timeSliceInSecs = $data->timeSliceInSecs; $this->validateOnly = $data->validateOnly; $this->fileWriteCount = $data->fileWriteCount; $this->directoryWriteCount = $data->directoryWriteCount; $this->working = $data->working; $this->filteredDirectories = $data->filteredDirectories; $this->filteredFiles = $data->filteredFiles; $this->fileRenames = $data->fileRenames; $this->directoryModeOverride = $data->directoryModeOverride; $this->fileModeOverride = $data->fileModeOverride; $this->lastHeaderOffset = $data->lastHeaderOffset; $this->throttleDelayInUs = $data->throttleDelayInUs; $this->timerEnabled = $data->timerEnabled; } public function reset() { $stateFilepath = dirname(__FILE__).'/'.self::StateFilename; $stateHandle = DupLiteSnapLibIOU::fopen($stateFilepath, 'w'); DupLiteSnapLibIOU::flock($stateHandle, LOCK_EX); $this->initMembers(); DupLiteSnapLibIOU::fwrite($stateHandle, DupLiteSnapJsonU::wp_json_encode($this)); DupLiteSnapLibIOU::flock($stateHandle, LOCK_UN); DupLiteSnapLibIOU::fclose($stateHandle); } public function save() { $stateFilepath = dirname(__FILE__).'/'.self::StateFilename; $stateHandle = DupLiteSnapLibIOU::fopen($stateFilepath, 'w'); DupLiteSnapLibIOU::flock($stateHandle, LOCK_EX); DupArchiveUtil::tlog("saving state"); DupLiteSnapLibIOU::fwrite($stateHandle, DupLiteSnapJsonU::wp_json_encode($this)); DupLiteSnapLibIOU::flock($stateHandle, LOCK_UN); DupLiteSnapLibIOU::fclose($stateHandle); } private function initMembers() { $this->currentFileHeader = null; $this->archiveOffset = 0; $this->archiveHeader = 0; $this->archivePath = null; $this->basePath = null; $this->currentFileOffset = 0; $this->failures = array(); $this->isCompressed = false; $this->startTimestamp = time(); $this->timeSliceInSecs = -1; $this->working = false; $this->validateOnly = false; $this->filteredDirectories = array(); $this->filteredFiles = array(); $this->fileRenames = array(); $this->directoryModeOverride = -1; $this->fileModeOverride = -1; $this->lastHeaderOffset = -1; $this->throttleDelayInUs = 0; $this->timerEnabled = true; } } PK��c&4\\��+��+�� daws/daws.phpnu��[��<?php /* * * * Standard: PSR-2 * @link http://www.php-fig.org/psr/psr-2 Full Documentation * * @package daws * / defined('ABSPATH') \|\| defined('DUPXABSPATH') \|\| exit; if (DupLiteSnapLibUtil::wp_is_ini_value_changeable('display_errors')) { @ini_set('display_errors', 1); } error_reporting(E_ALL); set_error_handler("terminate_missing_variables"); require_once(dirname(__FILE__) . '/class.daws.constants.php'); require_once(DAWSConstants::$LIB_DIR . '/snaplib/snaplib.all.php'); require_once(DAWSConstants::$DUPARCHIVE_CLASSES_DIR . '/class.duparchive.loggerbase.php'); require_once(DAWSConstants::$DUPARCHIVE_CLASSES_DIR . '/class.duparchive.engine.php'); require_once(DAWSConstants::$DUPARCHIVE_CLASSES_DIR . '/class.duparchive.mini.expander.php'); require_once(DAWSConstants::$DUPARCHIVE_STATES_DIR . '/class.duparchive.state.simplecreate.php'); require_once(DAWSConstants::$DAWS_ROOT . '/class.daws.state.expand.php'); DupArchiveUtil::$TRACE_ON = false; class DAWS_Logger extends DupArchiveLoggerBase { public function log($s, $flush = false, $callingFunctionOverride = null) { DupLiteSnapLibLogger::log($s, $flush, $callingFunctionOverride); } } class DAWS { private $lock_handle = null; function __construct() { date_default_timezone_set('UTC'); // Some machines don’t have this set so just do it here. DupLiteSnapLibLogger::init(DAWSConstants::$LOG_FILEPATH); DupArchiveEngine::init(new DAWS_Logger()); } public function processRequest($params) { try { DupLiteSnapLibLogger::log('process request'); $retVal = new StdClass(); $retVal->pass = false; DupLiteSnapLibLogger::logObject('params', $params); DupLiteSnapLibLogger::logObject('keys', array_keys($params)); $action = $params['action']; $initializeState = false; $isClientDriven = DupLiteSnapLibUtil::getArrayValue($params, 'client_driven', false); if ($action == 'start_expand') { $initializeState = true; DAWSExpandState::purgeStatefile(); DupLiteSnapLibLogger::clearLog(); DupLiteSnapLibIOU::rm(DAWSConstants::$PROCESS_CANCEL_FILEPATH); $archiveFilepath = DupLiteSnapLibUtil::getArrayValue($params, 'archive_filepath'); $restoreDirectory = DupLiteSnapLibUtil::getArrayValue($params, 'restore_directory'); $workerTime = DupLiteSnapLibUtil::getArrayValue($params, 'worker_time', false, DAWSConstants::$DEFAULT_WORKER_TIME); $filteredDirectories = DupLiteSnapLibUtil::getArrayValue($params, 'filtered_directories', false, array()); $filteredFiles = DupLiteSnapLibUtil::getArrayValue($params, 'filtered_files', false, array()); $fileRenames = DupLiteSnapLibUtil::getArrayValue($params, 'file_renames', false, array()); $action = 'expand'; DupLiteSnapLibLogger::log('startexpand->expand'); } else if($action == 'start_create') { $archiveFilepath = DupLiteSnapLibUtil::getArrayValue($params, 'archive_filepath'); $workerTime = DupLiteSnapLibUtil::getArrayValue($params, 'worker_time', false, DAWSConstants::$DEFAULT_WORKER_TIME); $createState->basePath = $dataDirectory; $createState->isCompressed = $isCompressed; $sourceDirectory = DupLiteSnapLibUtil::getArrayValue($params, 'source_directory'); $isCompressed = DupLiteSnapLibUtil::getArrayValue($params, 'is_compressed') === 'true' ? true : false; } $throttleDelayInMs = DupLiteSnapLibUtil::getArrayValue($params, 'throttle_delay', false, 0); if ($action == 'expand') { DupLiteSnapLibLogger::log('expand action'); / @var $expandState DAWSExpandState / $expandState = DAWSExpandState::getInstance($initializeState); $this->lock_handle = DupLiteSnapLibIOU::fopen(DAWSConstants::$PROCESS_LOCK_FILEPATH, 'c+'); DupLiteSnapLibIOU::flock($this->lock_handle, LOCK_EX); if($initializeState \|\| $expandState->working) { if ($initializeState) { DupLiteSnapLibLogger::logObject('file renames', $fileRenames); $expandState->archivePath = $archiveFilepath; $expandState->working = true; $expandState->timeSliceInSecs = $workerTime; $expandState->basePath = $restoreDirectory; $expandState->working = true; $expandState->filteredDirectories = $filteredDirectories; $expandState->filteredFiles = $filteredFiles; $expandState->fileRenames = $fileRenames; $expandState->fileModeOverride = 0644; $expandState->directoryModeOverride = 'u+rwx'; $expandState->save(); } $expandState->throttleDelayInUs = 1000 $throttleDelayInMs; DupLiteSnapLibLogger::logObject('Expand State In', $expandState); DupArchiveEngine::expandArchive($expandState); } if (!$expandState->working) { $deltaTime = time() - $expandState->startTimestamp; DupLiteSnapLibLogger::log("###### Processing ended. Seconds taken:$deltaTime"); if (count($expandState->failures) > 0) { DupLiteSnapLibLogger::log('Errors detected'); foreach ($expandState->failures as $failure) { DupLiteSnapLibLogger::log("{$failure->subject}:{$failure->description}"); } } else { DupLiteSnapLibLogger::log('Expansion done, archive checks out!'); } } else { DupLiteSnapLibLogger::log("Processing will continue"); } DupLiteSnapLibIOU::flock($this->lock_handle, LOCK_UN); $retVal->pass = true; $retVal->status = $this->getStatus($expandState); } else if ($action == 'create') { DupLiteSnapLibLogger::log('create action'); /* @var $expandState DAWSExpandState / $createState = DAWSCreateState::getInstance($initializeState); $this->lock_handle = DupLiteSnapLibIOU::fopen(DAWSConstants::$PROCESS_LOCK_FILEPATH, 'c+'); DupLiteSnapLibIOU::flock($this->lock_handle, LOCK_EX); if($initializeState \|\| $createState->working) { DupArchiveEngine::createArchive($archiveFilepath, $isCompressed); $createState->archivePath = $archiveFilepath; $createState->archiveOffset = DupLiteSnapLibIOU::filesize($archiveFilepath); $createState->working = true; $createState->timeSliceInSecs = $workerTime; $createState->basePath = $dataDirectory; $createState->isCompressed = $isCompressed; $createState->throttleDelayInUs = $throttleDelayInUs; // $daTesterCreateState->globSize = self::GLOB_SIZE; $createState->save(); $scan = DupArchiveScanUtil::createScan($this->paths->scanFilepath, $this->paths->dataDirectory); } $createState->throttleDelayInUs = 1000 $throttleDelayInMs; if (!$createState->working) { $deltaTime = time() - $createState->startTimestamp; DupLiteSnapLibLogger::log("###### Processing ended. Seconds taken:$deltaTime"); if (count($createState->failures) > 0) { DupLiteSnapLibLogger::log('Errors detected'); foreach ($createState->failures as $failure) { DupLiteSnapLibLogger::log("{$failure->subject}:{$failure->description}"); } } else { DupLiteSnapLibLogger::log('Creation done, archive checks out!'); } } else { DupLiteSnapLibLogger::log("Processing will continue"); } DupLiteSnapLibIOU::flock($this->lock_handle, LOCK_UN); $retVal->pass = true; $retVal->status = $this->getStatus($createState); } else if ($action == 'get_status') { /* @var $expandState DAWSExpandState / $expandState = DAWSExpandState::getInstance($initializeState); $retVal->pass = true; $retVal->status = $this->getStatus($expandState); } else if ($action == 'cancel') { if (!DupLiteSnapLibIOU::touch(DAWSConstants::$PROCESS_CANCEL_FILEPATH)) { throw new Exception("Couldn't update time on ".DAWSConstants::$PROCESS_CANCEL_FILEPATH); } $retVal->pass = true; } else { throw new Exception('Unknown command.'); } session_write_close(); } catch (Exception $ex) { $error_message = "Error Encountered:" . $ex->getMessage() . '<br/>' . $ex->getTraceAsString(); DupLiteSnapLibLogger::log($error_message); $retVal->pass = false; $retVal->error = $error_message; } DupLiteSnapLibLogger::logObject("before json encode retval", $retVal); $jsonRetVal = DupLiteSnapJsonU::wp_json_encode($retVal); DupLiteSnapLibLogger::logObject("json encoded retval", $jsonRetVal); echo $jsonRetVal; } private function getStatus($state) { / @var $state DupArchiveStateBase / $ret_val = new stdClass(); $ret_val->archive_offset = $state->archiveOffset; $ret_val->archive_size = @filesize($state->archivePath); $ret_val->failures = $state->failures; $ret_val->file_index = $state->fileWriteCount; $ret_val->is_done = !$state->working; $ret_val->timestamp = time(); return $ret_val; } } function generateCallTrace() { $e = new Exception(); $trace = explode("\n", $e->getTraceAsString()); // reverse array to make steps line up chronologically $trace = array_reverse($trace); array_shift($trace); // remove {main} array_pop($trace); // remove call to this method $length = count($trace); $result = array(); for ($i = 0; $i < $length; $i++) { $result[] = ($i + 1) . ')' . substr($trace[$i], strpos($trace[$i], ' ')); // replace '#someNum' with '$i)', set the right ordering } return "\t" . implode("\n\t", $result); } function terminate_missing_variables($errno, $errstr, $errfile, $errline) { DupLiteSnapLibLogger::log("ERROR $errno, $errstr, {$errfile}:{$errline}"); DupLiteSnapLibLogger::log(generateCallTrace()); // DaTesterLogging::clearLog(); /* * INTERCEPT ON processRequest AND RETURN JSON STATUS / throw new Exception("ERROR:{$errfile}:{$errline} \| ".$errstr , $errno); } PK��c&4\&��.��tester/classes/class.datester.state.create.phpnu��[��<?php defined('ABSPATH') \|\| defined('DUPXABSPATH') \|\| exit; / * To change this license header, choose License Headers in Project Properties. * To change this template file, choose Tools \| Templates * and open the template in the editor. / require_once(DUPARCHIVE_STATES_DIR.'/class.duparchive.state.create.php'); /* * Description of BuildState * * @author Bob / // Note: All this stuff needs to be stored in the processstate of the package class DaTesterCreateState extends DupArchiveCreateState { public static $instance = null; const StateFilename = 'createstate.json'; public static function getInstance($reset = false) { if ((self::$instance == null) && (!$reset)) { $stateFilepath = dirname(__FILE__).'/'.self::StateFilename; self::$instance = new DaTesterCreateState(); if (file_exists($stateFilepath)) { $stateHandle = DupLiteSnapLibIOU::fopen($stateFilepath, 'r'); DupLiteSnapLibIOU::flock($stateHandle, LOCK_EX); $stateString = fread($stateHandle, filesize($stateFilepath)); $data = json_decode($stateString); self::$instance->setFromData($data); DupLiteSnapLibIOU::flock($stateHandle, LOCK_UN); DupLiteSnapLibIOU::fclose($stateHandle); } else { $reset = true; } } if ($reset) { self::$instance = new DaTesterCreateState(); self::$instance->reset(); } return self::$instance; } private function setFromData($data) { $this->archiveOffset = $data->archiveOffset; $this->archivePath = $data->archivePath; $this->basePath = $data->basePath; $this->globSize = $data->globSize; $this->currentFileIndex = $data->currentFileIndex; $this->currentDirectoryIndex = $data->currentDirectoryIndex; $this->currentFileOffset = $data->currentFileOffset; $this->failures = $data->failures; $this->isCompressed = $data->isCompressed; $this->startTimestamp = $data->startTimestamp; $this->timeSliceInSecs = $data->timeSliceInSecs; $this->working = $data->working; $this->throttleDelayInUs = $data->throttleDelayInUs; } public function reset() { $stateFilepath = dirname(__FILE__).'/'.self::StateFilename; $stateHandle = DupLiteSnapLibIOU::fopen($stateFilepath, 'w'); DupLiteSnapLibIOU::flock($stateHandle, LOCK_EX); $this->initMembers(); DupLiteSnapLibIOU::fwrite($stateHandle, json_encode($this)); DupLiteSnapLibIOU::fclose($stateHandle); } public function save() { $stateFilepath = dirname(__FILE__).'/'.self::StateFilename; $stateHandle = DupLiteSnapLibIOU::fopen($stateFilepath, 'w'); DupLiteSnapLibIOU::flock($stateHandle, LOCK_EX); DupArchiveUtil::tlog("saving state"); DupLiteSnapLibIOU::fwrite($stateHandle, json_encode($this)); DupLiteSnapLibIOU::fclose($stateHandle); } private function initMembers() { $this->archiveOffset = 0; $this->archivePath = null; $this->basePath = null; $this->globSize = -1; $this->currentFileIndex = 0; $this->currentFileOffset = 0; $this->currentDirectoryIndex = 0; $this->fileWriteCount = 0; $this->directoryWriteCount = 0; $this->failures = array(); $this->isCompressed = false; $this->startTimestamp = time(); $this->timeSliceInSecs = -1; $this->working = false; $this->throttleDelayInUs = 0; } }PK��c&4\.}�\|, ��, ��)��tester/classes/class.datester.logging.phpnu��[��<?php defined('ABSPATH') \|\| defined('DUPXABSPATH') \|\| exit; / * To change this license header, choose License Headers in Project Properties. * To change this template file, choose Tools \| Templates * and open the template in the editor. / /* * Description of class * * @author Robert / class DaTesterLogging extends DupArchiveLoggerBase { private $logFilepath = null; private $logHandle = null; public function __construct($logFilepath) { $this->logFilepath = $logFilepath; } public function clearLog() { if (file_exists($this->logFilepath)) { if ($this->logHandle !== null) { fflush($this->logHandle); fclose($this->logHandle); $this->logHandle = null; } @unlink($this->logFilepath); } } public function logObject($s, $o, $flush = false, $callingFunctionOverride = null) { $this->log($s, false, $callingFunctionOverride); $this->log(print_r($o, true), false, $callingFunctionOverride); if ($flush) { fflush($this->logHandle); } } public function log($s, $flush = false, $callingFunctionOverride = null) { $lfp = $this->logFilepath; if ($this->logFilepath === null) { error_log('logging not initialized'); throw new Exception('Logging not initialized'); } if(isset($_SERVER['REQUEST_TIME_FLOAT'])){ $timepart = $_SERVER['REQUEST_TIME_FLOAT']; } else { $timepart = $_SERVER['REQUEST_TIME']; } $thread_id = sprintf("%08x", abs(crc32($_SERVER['REMOTE_ADDR'].$timepart.$_SERVER['REMOTE_PORT']))); $s = $thread_id.' '.date('h:i:s').":$s"; if ($this->logHandle === null) { $this->logHandle = fopen($this->logFilepath, 'a'); } fwrite($this->logHandle, "$s\n"); if ($flush) { fflush($this->logHandle); fclose($this->logHandle); $this->logHandle = fopen($this->logFilepath, 'a'); } } private static $profileLogArray = null; public static function initProfiling() { self::$profileLogArray = array(); } }PK��c&4\J_��tester/classes/state.jsonnu��[��{"archiveHeader":0,"currentFileHeader":null,"validateOnly":false,"fileWriteCount":0,"directoryWriteCount":0,"basePath":null,"archivePath":null,"isCompressed":false,"currentFileOffset":0,"archiveOffset":0,"timeSliceInSecs":-1,"working":false,"failures":[],"startTimestamp":1491848703}PK��c&4\�/V:��tester/classes/index.phpnu��[��<?php //silentPK��c&4\e,��S��S��.��tester/classes/class.datester.state.expand.phpnu��[��<?php defined('ABSPATH') \|\| defined('DUPXABSPATH') \|\| exit; / * To change this license header, choose License Headers in Project Properties. * To change this template file, choose Tools \| Templates * and open the template in the editor. / require_once(DUPARCHIVE_STATES_DIR.'/class.duparchive.state.expand.php'); class DaTesterExpandState extends DupArchiveExpandState { public static $instance = null; const StateFilename = 'expandstate.json'; public static function getInstance($reset = false) { if ((self::$instance == null) && (!$reset)) { $stateFilepath = dirname(__FILE__).'/'.self::StateFilename; self::$instance = new DaTesterExpandState(); if (file_exists($stateFilepath)) { $stateHandle = DupLiteSnapLibIOU::fopen($stateFilepath, 'r'); DupLiteSnapLibIOU::flock($stateHandle, LOCK_EX); $stateString = fread($stateHandle, filesize($stateFilepath)); $data = json_decode($stateString); self::$instance->setFromData($data); DupLiteSnapLibIOU::flock($stateHandle, LOCK_UN); DupLiteSnapLibIOU::fclose($stateHandle); } else { $reset = true; } } if ($reset) { self::$instance = new DaTesterExpandState(); self::$instance->reset(); } return self::$instance; } private function setFromData($data) { $this->currentFileHeader = $data->currentFileHeader; $this->archiveHeader = $data->archiveHeader; $this->archiveOffset = $data->archiveOffset; $this->archivePath = $data->archivePath; $this->basePath = $data->basePath; $this->currentFileOffset = $data->currentFileOffset; $this->failures = $data->failures; $this->isCompressed = $data->isCompressed; $this->startTimestamp = $data->startTimestamp; $this->timeSliceInSecs = $data->timeSliceInSecs; $this->validateOnly = $data->validateOnly; $this->fileWriteCount = $data->fileWriteCount; $this->directoryWriteCount = $data->directoryWriteCount; $this->working = $data->working; $this->directoryModeOverride = $data->directoryModeOverride; $this->fileModeOverride = $data->fileModeOverride; $this->throttleDelayInUs = $data->throttleDelayInUs; } public function reset() { $stateFilepath = dirname(__FILE__).'/'.self::StateFilename; $stateHandle = DupLiteSnapLibIOU::fopen($stateFilepath, 'w'); DupLiteSnapLibIOU::flock($stateHandle, LOCK_EX); $this->initMembers(); DupLiteSnapLibIOU::fwrite($stateHandle, json_encode($this)); DupLiteSnapLibIOU::fclose($stateHandle); } public function save() { $stateFilepath = dirname(__FILE__).'/'.self::StateFilename; $stateHandle = DupLiteSnapLibIOU::fopen($stateFilepath, 'w'); DupLiteSnapLibIOU::flock($stateHandle, LOCK_EX); DupArchiveUtil::tlog("saving state"); DupLiteSnapLibIOU::fwrite($stateHandle, json_encode($this)); DupLiteSnapLibIOU::fclose($stateHandle); } private function initMembers() { $this->currentFileHeader = null; $this->archiveOffset = 0; $this->archiveHeader = 0; $this->archivePath = null; $this->basePath = null; $this->currentFileOffset = 0; $this->failures = array(); $this->isCompressed = false; $this->startTimestamp = time(); $this->timeSliceInSecs = -1; $this->working = false; $this->validateOnly = false; $this->directoryModeOverride = -1; $this->fileModeOverride = -1; $this->throttleDelayInUs = 0; } }PK��c&4\��>��tester/classes/expandstate.jsonnu��[��{"archiveHeader":{"version":2,"isCompressed":true},"currentFileHeader":null,"validateOnly":true,"validationType":2,"fileWriteCount":6,"directoryWriteCount":0,"expectedFileCount":6,"expectedDirectoryCount":0,"filteredDirectories":[],"directoryModeOverride":-1,"fileModeOverride":-1,"lastHeaderOffset":196796990,"basePath":"C:\\Users\\Bob\\AppData\\Local\\Temp\/duparchivetester\/temp","archivePath":"C:\\Users\\Bob\\AppData\\Local\\Temp\/duparchivetester\/archive.daf","isCompressed":true,"currentFileOffset":0,"archiveOffset":196796990,"timeSliceInSecs":10,"working":false,"failures":[],"startTimestamp":1501534630,"throttleDelayInUs":0,"timeoutTimestamp":1501534640,"timerEnabled":true}PK��c&4\�/�S��S��tester/datester.phpnu��[��<?php defined('ABSPATH') \|\| defined('DUPXABSPATH') \|\| exit; if (DupLiteSnapLibUtil::wp_is_ini_value_changeable('display_errors')) ini_set('display_errors', 1); error_reporting(E_ALL); error_reporting(E_ALL); set_error_handler("terminate_missing_variables"); define('LIB_DIR', dirname(__FILE__).'/../..'); define('DUPARCHIVE_DIR', dirname(__FILE__).'/..'); define("ABSPATH", DUPARCHIVE_DIR); define('DUPARCHIVE_CLASSES_DIR', DUPARCHIVE_DIR.'/classes'); define('DUPARCHIVE_STATES_DIR', DUPARCHIVE_CLASSES_DIR.'/states'); define('DUPARCHIVE_UTIL_DIR', DUPARCHIVE_CLASSES_DIR.'/util'); require_once(LIB_DIR.'/snaplib/snaplib.all.php'); require_once(DUPARCHIVE_UTIL_DIR.'/class.duparchive.util.php'); require_once(DUPARCHIVE_CLASSES_DIR.'/class.duparchive.loggerbase.php'); require_once(DUPARCHIVE_CLASSES_DIR.'/class.duparchive.engine.php'); require_once(DUPARCHIVE_CLASSES_DIR.'/class.duparchive.mini.expander.php'); require_once(DUPARCHIVE_UTIL_DIR.'/class.duparchive.util.scan.php'); require_once(DUPARCHIVE_STATES_DIR.'/class.duparchive.state.simplecreate.php'); require_once(dirname(__FILE__).'/classes/class.datester.state.create.php'); require_once(dirname(__FILE__).'/classes/class.datester.state.expand.php'); require_once(dirname(__FILE__).'/classes/class.datester.logging.php'); DupArchiveUtil::$TRACE_ON = true; class DaTesterPaths { public $dataRoot; public $scanFilepath; public $processLockFilepath; public $dataDirectory; public $restoreDirectory; public $tempDirectory; public $archiveFilepath; public $logFilepath; function __construct($isSmallArchive) { $this->dataRoot = getenv("TEMP").'/duparchivetester'; $this->scanFilepath = "{$this->dataRoot}/scan.json"; $this->processLockFilepath = "{$this->dataRoot}/lock.bin"; if ($isSmallArchive) { $this->dataDirectory = "{$this->dataRoot}/smalldata"; $this->archiveFilepath = "{$this->dataRoot}/archivesmall.daf"; } else { $this->dataDirectory = "{$this->dataRoot}/data"; $this->archiveFilepath = "{$this->dataRoot}/archive.daf"; } $this->restoreDirectory = "{$this->dataRoot}/restore"; $this->tempDirectory = "{$this->dataRoot}/temp"; $this->logFilepath = "{$this->dataRoot}/tester.log"; if (!file_exists($this->dataRoot)) { @mkdir($this->dataRoot); } if (!file_exists($this->dataDirectory)) { @mkdir($this->dataDirectory); } if (!file_exists($this->restoreDirectory)) { @mkdir($this->restoreDirectory); } if (!file_exists($this->tempDirectory)) { @mkdir($this->tempDirectory); } } } class DaTesterParams { public $compress = true; public $isSmallArchive = true; public $action; public $p1 = null; public $workerTime = 10; public $throttleDelayInUs = 100000; function __construct() { if (isset($_REQUEST['worker_time'])) { $this->workerTime = (int) $_REQUEST['worker_time']; } if (isset($_REQUEST['small_archive'])) { $this->isSmallArchive = ($_REQUEST['small_archive'] == 1); } if (isset($_REQUEST['compress'])) { $this->compress = ($_REQUEST['compress'] == 1); } if (isset($_REQUEST['action'])) { $this->action = $_REQUEST['action']; } else { $this->action = 'get_archive_info'; } if (isset($_REQUEST['p1'])) { $this->p1 = $_REQUEST['p1']; } } public function getQueryStringData() { $qsa = array(); $qsa['worker_time'] = $this->workerTime; $qsa['small_archive'] = ($this->isSmallArchive ? 1 : 0); $qsa['compress'] = ($this->compress ? 1 : 0); $qsa['action'] = $this->action; if ($this->p1 != null) { $qsa['p1'] = $this->p1; } return $qsa; } } class DaTester { private $paths; private $params; private $lockHandle; private $logger; public function __construct() { $this->params = new DaTesterParams(); $this->paths = new DaTesterPaths($this->params->isSmallArchive); } public function processRequest() { try { $this->lockHandle = DupLiteSnapLibIOU::fopen($this->paths->processLockFilepath, 'c+'); DupLiteSnapLibIOU::flock($this->lockHandle, LOCK_EX); $this->logger = new DaTesterLogging($this->paths->logFilepath); $this->logger->log("incoming request"); DupArchiveEngine::init($this->logger); $this->logger->log("Got file lock"); $this->logger->log("Action set to {$this->params->action}"); $initializeState = false; if ($this->params->action == 'start_create_test') { $initializeState = true; $this->params->action = 'create_test'; } else if ($this->params->action == 'start_expand_test') { $initializeState = true; $this->params->action = 'expand_test'; } else if ($this->params->action == 'start_validate_test') { $initializeState = true; $this->params->action = 'validate_test'; } $this->logger->log("incoming request after lock"); $spawnAnotherThread = false; echo "action={$this->params->action}<br/>"; if ($this->params->action == 'get_status') { $this->get_status(); } else if ($this->params->action == 'create_test') { / @var $daTesterCreateState DaTesterCreateState / $daTesterCreateState = DaTesterCreateState::getInstance($initializeState); $daTesterState = &$daTesterCreateState; if ($initializeState) { $this->logger->log("Clearing files"); $this->clearCreateFiles(); DupArchiveEngine::createArchive($this->paths->archiveFilepath, $this->params->compress); $daTesterCreateState->archivePath = $this->paths->archiveFilepath; $daTesterCreateState->archiveOffset = DupLiteSnapLibIOU::filesize($this->paths->archiveFilepath); $daTesterCreateState->working = true; $daTesterCreateState->timeSliceInSecs = $this->params->workerTime; $daTesterCreateState->basePath = $this->paths->dataDirectory; $daTesterCreateState->isCompressed = $this->params->compress; $daTesterCreateState->throttleDelayInUs = $this->params->throttleDelayInUs; // $daTesterCreateState->globSize = self::GLOB_SIZE; $daTesterCreateState->save(); $this->logger->log("Cleared files"); $scan = DupArchiveScanUtil::createScan($this->paths->scanFilepath, $this->paths->dataDirectory); } else { $scan = DupArchiveScanUtil::getScan($this->paths->scanFilepath); } $this->logger->logObject("createstate", $daTesterCreateState); DupArchiveEngine::addItemsToArchive($daTesterCreateState, $scan); $spawnAnotherThread = $daTesterCreateState->working; if (!$spawnAnotherThread) { $this->logger->logObject("Done. Failures:", $daTesterCreateState->failures, true); } } else if ($this->params->action == 'start_add_file_test') { //DupArchiveUtil::writeToPLog("Start add file test"); $this->logger->clearLog(); $tmpname = tempnam($this->paths->dataDirectory, 'tmp'); $this->logger->log("tempname $tmpname"); file_put_contents($tmpname, 'test'); DupArchiveEngine::addFileToArchiveUsingBaseDirST($this->paths->archiveFilepath, $this->paths->dataDirectory, $tmpname); echo "$tmpname added"; unlink($tmpname); exit(1); } else if ($this->params->action == 'mini_expand_test') { $this->logger->log("Clearing files"); $this->clearExpandFiles(); $this->logger->log("Cleared files"); try { DupArchiveMiniExpander::init("$this->logger->log"); DupArchiveMiniExpander::expandDirectory($this->paths->archiveFilepath, 'dup-installer', $this->paths->restoreDirectory); } catch (Exception $ex) { $message = $ex->getMessage(); echo "Exception: {$ex} ".$ex->getTraceAsString(); } echo "Mini-extract done.<br/>"; exit(1); } else if ($this->params->action == 'expand_test') { / @var $daTesterExpandState DaTesterExpandState / $daTesterExpandState = DaTesterExpandState::getInstance($initializeState); $daTesterState = &$daTesterExpandState; if ($initializeState) { $this->logger->log("Clearing files"); $this->clearExpandFiles(); $this->logger->log("Cleared files"); $daTesterExpandState->archivePath = $this->paths->archiveFilepath; $daTesterExpandState->working = true; $daTesterExpandState->timeSliceInSecs = $this->params->workerTime; $daTesterExpandState->basePath = $this->paths->restoreDirectory; $daTesterExpandState->working = true; $daTesterExpandState->throttleDelayInUs = $this->params->throttleDelayInUs;; $daTesterExpandState->save(); } DupArchiveEngine::expandArchive($daTesterExpandState); $spawnAnotherThread = $daTesterExpandState->working; if (!$spawnAnotherThread) { if (count($daTesterExpandState->failures) > 0) { $this->logger->log('Errors detected'); echo 'Expanson done, but errors detected!'; echo '<br/><br/>'; foreach ($daTesterExpandState->failures as $failure) { $this->logger->log($failure->description); echo $failure->description; echo '<br/><br/>'; } } else { echo 'Expansion done, archive checks out!'; $this->logger->log('Expansion done, archive checks out!'); } } } else if ($this->params->action == 'validate_test') { $validationType = DupArchiveValidationTypes::Full; if ($this->params->p1 != null) { if ($this->params->p1 == 's') { $validationType = DupArchiveValidationTypes::Standard; } } / @var $daTesterExpandState DaTesterExpandState / $daTesterExpandState = DaTesterExpandState::getInstance($initializeState); $daTesterState = &$daTesterExpandState; if ($initializeState) { $this->logger->log("Clearing files"); $this->clearExpandFiles(); $this->logger->log("Cleared files"); $this->logger->log("Validation Type:" . (($validationType == DupArchiveValidationTypes::Full) ? 'Full' : 'Quick')); $scan = DupArchiveScanUtil::getScan($this->paths->scanFilepath); $daTesterExpandState->archivePath = $this->paths->archiveFilepath; $daTesterExpandState->working = true; $daTesterExpandState->timeSliceInSecs = $this->params->workerTime; $daTesterExpandState->basePath = $this->paths->tempDirectory; $daTesterExpandState->validateOnly = true; $daTesterExpandState->validationType = $validationType; $daTesterExpandState->working = true; $daTesterExpandState->expectedDirectoryCount = count($scan->Dirs); $daTesterExpandState->expectedFileCount = count($scan->Files); $daTesterExpandState->save(); } DupArchiveEngine::expandArchive($daTesterExpandState); $spawnAnotherThread = $daTesterExpandState->working; if (!$spawnAnotherThread) { if (count($daTesterExpandState->failures) > 0) { echo 'Errors detected!'; echo '<br/><br/>'; foreach ($daTesterExpandState->failures as $failure) { echo esc_html($failure->description); echo '<br/><br/>'; } } else { echo 'Archive checks out!'; } } } else if ($this->params->action == 'get_archive_info') { $this->logger->log("get_archive_info()"); $this->logger->clearLog(); $archiveInfo = DupArchiveEngine::getArchiveInfo($this->paths->archiveFilepath); $sizeInArchive = 0; foreach($archiveInfo->fileHeaders as $fileHeader) { $sizeInArchive += $fileHeader->fileSize; } $archiveSize = filesize($this->paths->archiveFilepath); echo "Version: {$archiveInfo->archiveHeader->version}"; echo '<br/>'; echo "IsCompressed: ".DupArchiveUtil::boolToString($archiveInfo->archiveHeader->isCompressed); echo '<br/>'; // echo "Expected Directory Count: {$archiveInfo->archiveHeader->directoryCount}"; // echo '<br/>'; echo "Total file size: {$sizeInArchive} bytes"; echo '<br/>'; echo "Archive size: {$archiveSize} bytes"; echo '<br/>'; $directoryCount = count($archiveInfo->directoryHeaders); echo "Actual Directory Count: {$directoryCount}"; echo '<br/>'; // echo "Expected File Count: {$archiveInfo->archiveHeader->fileCount}"; // echo '<br/>'; $fileCount = count($archiveInfo->fileHeaders); echo "Actual File Count: {$fileCount}"; echo '<br/>'; echo '<br/>'; echo 'DIRECTORIES'; echo '<br/>'; $c = 1; //print_r($archiveInfo); foreach ($archiveInfo->directoryHeaders as $directoryHeader) { / @var $directoryHeader DupArchiveDirectoryHeader / echo "{$c}:{$directoryHeader->relativePath} P:{$directoryHeader->permissions} <br/>"; $c++; } echo '<br/>'; echo 'FILES'; echo '<br/>'; $c = 1; //print_r($archiveInfo); foreach ($archiveInfo->fileHeaders as $fileHeader) { / @var $fileHeader DupArchiveFileHeader / echo "{$c}:{$fileHeader->relativePath} ({$fileHeader->fileSize} bytes)<br/>"; $c++; } exit(1); } else { echo 'unknown command.'; exit(1); } DupLiteSnapLibIOU::flock($this->lockHandle, LOCK_UN); $this->logger->log("Unlocked file"); session_write_close(); if ($spawnAnotherThread) { $url = "http://$_SERVER[HTTP_HOST]".strtok($_SERVER["REQUEST_URI"], '?'); $data = $this->params->getQueryStringData(); $this->logger->logObject("SPAWNING CUSTOM WORKER AT $url FOR ACTION {$this->params->action}", $data); DupLiteSnapLibNetU::postWithoutWait($url, $data); $this->logger->log('After post without wait'); } else { $this->logger->log("start timestamp {$daTesterState->startTimestamp}"); $deltaTime = time() - $daTesterState->startTimestamp; $this->logger->log("###### Processing ended. Seconds taken:$deltaTime"); $this->logger->logObject("##### FAILURES:", $daTesterState->failures); } } catch (Exception $ex) { $error_message = "Error Encountered:".$ex->getMessage().'<br/>'.$ex->getTraceAsString(); $this->logger->log($error_message); echo $error_message; } } // Returns json // { // status: 0\|-1 (success, failure) // data : true\|false (for working) \|\| {failure message} // } function get_status() { $error_message = null; $ret_val = new stdClass(); try { $build_state = CompressExtractState::getInstance(); $ret_val->status = 0; $ret_val->data = $build_state; } catch (Exception $ex) { $ret_val->status = -1; $ret_val->data = $error_message; } echo json_encode($ret_val); // JSON_U::customEncode($ret_val); } private function clearCreateFiles() { if (file_exists($this->paths->scanFilepath)) { @unlink($this->paths->scanFilepath); } $handle = DupLiteSnapLibIOU::fopen($this->paths->archiveFilepath, 'w'); DupLiteSnapLibIOU::fclose($handle); //$this->logger->clearLog(); } private function clearExpandFiles() { if (file_exists($this->paths->restoreDirectory)) { DupLiteSnapLibIOU::rrmdir($this->paths->restoreDirectory); } if (file_exists($this->paths->tempDirectory)) { DupLiteSnapLibIOU::rrmdir($this->paths->tempDirectory); } mkdir($this->paths->restoreDirectory); // $this->logger->clearLog(); } // private function fake_crash($worker_string, $next_scan_index, $next_file_offset) // { // $url = "http://$_SERVER[HTTP_HOST]$_SERVER[REQUEST_URI]"; // $data = array('action' => $worker_string, 'next_scan_index' => $next_scan_index, // 'next_file_offset' => $next_file_offset); // // $this->logger->log("spawning new custom worker at $url"); // $this->post_without_wait($url, $data); // // exit(); // } // private function try_crash($source_filepath, $next_file_offset) // { // $should_crash = (self::CRASH_PROBABILITY >= rand(1, 100)); // // $should_crash = false; // // if ($should_crash) { // $this->logger->log("##### Crashing for $source_filepath at $next_file_offset"); // // $this->fake_crash('compress', $next_scan_index, $next_file_offset); // } // } } function generateCallTrace() { $e = new Exception(); $trace = explode("\n", $e->getTraceAsString()); // reverse array to make steps line up chronologically $trace = array_reverse($trace); array_shift($trace); // remove {main} array_pop($trace); // remove call to this method $length = count($trace); $result = array(); for ($i = 0; $i < $length; $i++) { $result[] = ($i + 1).')'.substr($trace[$i], strpos($trace[$i], ' ')); // replace '#someNum' with '$i)', set the right ordering } return "\t".implode("\n\t", $result); } function terminate_missing_variables($errno, $errstr, $errfile, $errline) { echo "<br/>ERROR: $errstr $errfile $errline<br/>"; // if (($errno == E_NOTICE) and ( strstr($errstr, "Undefined variable"))) die("$errstr in $errfile line $errline"); $logfilepath = getenv("TEMP").'/duparchivetester'; $logfilepath = "{$logfilepath}/tester2.log"; $logger = new DaTesterLogging($this->paths->logFilepath); $logger->log("ERROR $errno, $errstr, {$errfile}:{$errline}"); $logger->log(generateCallTrace()); // $this->logger->clearLog(); exit(1); //return false; // Let the PHP error handler handle all the rest } $daTester = new DaTester(); $daTester->processRequest(); PK��c&4\�/V:��tester/index.phpnu��[��<?php //silentPK��c&4\�fƴ�� define.phpnu��[��<?php defined('ABSPATH') \|\| defined('DUPXABSPATH') \|\| exit; //Prevent directly browsing to the file if(!defined('DUPARCHIVE_VERSION')) { // Should always match the version of Duplicator Pro that includes the library define('DUPARCHIVE_VERSION', '3.7.5.0'); } PK��c&4\R�?� �� +��classes/util/class.duparchive.util.scan.phpnu��[��PK��c&4\�/V:��d ��classes/util/index.phpnu��[��PK��c&4\�N R��R��(�� classes/util/class.duparchive.u.json.phpnu��[��PK��c&4\l��]v��v��&��c��classes/util/class.duparchive.util.phpnu��[��PK��c&4\c20Ĭs��s��#��/5��classes/class.duparchive.engine.phpnu��[��PK��c&4\�/V:��.��classes/headers/index.phpnu��[��PK��c&4\��B!��0��classes/headers/class.duparchive.header.file.phpnu��[��PK��c&4\ϡ9O��O��0��classes/headers/class.duparchive.header.glob.phpnu��[��PK��c&4\{��W� �� +��8��classes/headers/class.duparchive.header.phpnu��[��PK��c&4\��s� �� 5��Y��classes/headers/class.duparchive.header.directory.phpnu��[��PK��c&4\dZx��-��classes/headers/class.duparchive.header.u.phpnu��[��PK��c&4\��]x7��x7����classes/class.duparchive.mini.expander.phpnu��[��PK��c&4\�/V:��classes/processors/index.phpnu��[��PK��c&4\��C��C��6��classes/processors/class.duparchive.processor.file.phpnu��[��PK��c&4\�,ͤ��;��^�classes/processors/class.duparchive.processor.directory.phpnu��[��PK��c&4\uM�\|��6��^c�classes/states/class.duparchive.state.simplecreate.phpnu��[��PK��c&4\f8�pp ��p ��.��Yf�classes/states/class.duparchive.state.base.phpnu��[��PK��c&4\��X8%��%��6��'t�classes/states/class.duparchive.state.simpleexpand.phpnu��[��PK��c&4\� ��0��v�classes/states/class.duparchive.state.create.phpnu��[��PK��c&4\{�E-��-��0��z�classes/states/class.duparchive.state.expand.phpnu��[��PK��c&4\�/V:��classes/states/index.phpnu��[��PK��c&4\�/V:��classes/index.phpnu��[��PK��c&4\�޸ig��g��/��L��classes/class.duparchive.processing.failure.phpnu��[��PK��c&4\z�K��'��classes/class.duparchive.loggerbase.phpnu��[��PK��c&4\Nn�2$��$��&��Z��classes/class.duparchive.constants.phpnu��[��PK��c&4\�/V:�� ԇ�index.phpnu��[��PK��c&4\A;m\��\��daws/class.daws.constants.phpnu��[��PK��c&4\�/V:��ō�daws/index.phpnu��[��PK��c&4\��daws/dawslock.binnu��[��PK��c&4\\|ܘ\�� S��daws/class.daws.state.expand.phpnu��[��PK��c&4\\��+��+�� =��daws/daws.phpnu��[��PK��c&4\&��.��W��tester/classes/class.datester.state.create.phpnu��[��PK��c&4\.}�\|, ��, ��)��tester/classes/class.datester.logging.phpnu��[��PK��c&4\J_�� tester/classes/state.jsonnu��[��PK��c&4\�/V:��m��tester/classes/index.phpnu��[��PK��c&4\e,��S��S��.��tester/classes/class.datester.state.expand.phpnu��[��PK��c&4\��>��u��tester/classes/expandstate.jsonnu��[��PK��c&4\�/�S��S��s��tester/datester.phpnu��[��PK��c&4\�/V:��R�tester/index.phpnu��[��PK��c&4\�fƴ�� R�define.phpnu��[��PK��(�(��1T��

| ver. 1.4 | Github | . | PHP 8.2.29 | Генерация страницы: 0 | proxy | phpinfo | Настройка