lxbfYeaa/LiveCartaWP
1
0
Fork 0
forked from LiveCarta/LiveCartaWP
Code Issues 238 Pull Requests Actions Packages Projects Releases Wiki Activity

Changed source root directory

Browse Source
This commit is contained in:
Artsiom Siamashka
2026-03-05 16:30:11 +01:00
parent dc85447ee1
commit 538f85d7a2
5868 changed files with 749734 additions and 99 deletions
Download Patch File Download Diff File Expand all files Collapse all files

217
html/wp-content/plugins/duplicator/ctrls/class.web.services.php Normal file
View File

@@ -0,0 +1,217 @@
<?php
use Duplicator\Libs\Snap\SnapUtil;
use Duplicator\Views\AdminNotices;
defined('ABSPATH') || defined('DUPXABSPATH') || exit;
class DUP_Web_Services
{
/**
* init ajax actions
*/
public static function init()
{
add_action('wp_ajax_duplicator_reset_all_settings', array(__CLASS__, 'ajax_reset_all'));
add_action('wp_ajax_duplicator_set_admin_notice_viewed', array(__CLASS__, 'set_admin_notice_viewed'));
add_action('wp_ajax_duplicator_admin_notice_to_dismiss', array(__CLASS__, 'admin_notice_to_dismiss'));
add_action('wp_ajax_duplicator_download_installer', array(__CLASS__, 'duplicator_download_installer'));
}
/**
*
* @param DUP_Package $package
*/
public static function package_delete_callback($package)
{
$package->delete();
}
/**
* reset all ajax action
*
* the output must be json
*/
public static function ajax_reset_all()
{
ob_start();
try {
DUP_Handler::init_error_handler();
if (!check_ajax_referer('duplicator_reset_all_settings', 'nonce', false)) {
DUP_LOG::Trace('Security issue');
throw new Exception('Security issue');
}
DUP_Util::hasCapability('export', DUP_Util::SECURE_ISSUE_THROW);
/* Execute function * */
$error = false;
$result = array(
'data' => array(),
'html' => '',
'message' => ''
);
DUP_Package::by_status_callback(array(__CLASS__, 'package_delete_callback'), array(
array('op' => '<', 'status' => DUP_PackageStatus::COMPLETE)
));
/* reset active package id * */
DUP_Settings::Set('active_package_id', -1);
DUP_Settings::Save();
/* Clean tmp folder * */
DUP_Package::not_active_files_tmp_cleanup();
//throw new Exception('force error test');
} catch (Exception $e) {
$error = true;
$result['message'] = $e->getMessage();
}
/* Intercept output * */
$result['html'] = ob_get_clean();
/* check error and return json * */
if ($error) {
wp_send_json_error($result);
} else {
wp_send_json_success($result);
}
}
public static function duplicator_download_installer()
{
check_ajax_referer('duplicator_download_installer', 'nonce');
$packageId = SnapUtil::sanitizeIntInput(INPUT_GET, 'id');
$hash = SnapUtil::sanitizeTextInput(INPUT_GET, 'hash');
try {
DUP_Util::hasCapability('export', DUP_Util::SECURE_ISSUE_THROW);
if (!$packageId || !$hash) {
throw new Exception(__('Invalid request.', 'duplicator'));
}
if (($package = DUP_Package::getByID($packageId)) == null) {
throw new Exception(__('Invalid request.', 'duplicator'));
}
if ($hash !== $package->Hash) {
throw new Exception(__('Invalid request.', 'duplicator'));
}
$fileName = $package->getInstDownloadName();
$realFileName = $package->Installer->File;
$backupDir = DUP_Settings::getSsdirPath();
if (DUP_STR::endsWith($realFileName, '.php')) {
$realFileName = basename($realFileName, '.php') . DUP_Installer::INSTALLER_SERVER_EXTENSION;
}
$filepath = "{$backupDir}/{$realFileName}";
// Process download
if (!file_exists($filepath)) {
throw new Exception(__('INVALID REQUEST: File not found, please check the backup folder for file.', 'duplicator'));
}
// Clean output buffer
if (ob_get_level() !== 0 && @ob_end_clean() === false) {
@ob_clean();
}
header('Content-Description: File Transfer');
header('Content-Type: application/octet-stream');
header('Content-Disposition: attachment; filename="' . $fileName . '"');
header('Expires: 0');
header('Cache-Control: must-revalidate');
header('Pragma: public');
header('Content-Length: ' . filesize($filepath));
flush(); // Flush system output buffer
try {
$fp = @fopen($filepath, 'r');
if (false === $fp) {
throw new Exception('Fail to open the file ' . $filepath);
}
while (!feof($fp) && ($data = fread($fp, DUPLICATOR_BUFFER_READ_WRITE_SIZE)) !== false) {
echo $data;
}
@fclose($fp);
} catch (Exception $e) {
readfile($filepath);
}
exit;
} catch (Exception $ex) {
//Prevent brute force
sleep(2);
wp_die($ex->getMessage());
}
}
public static function set_admin_notice_viewed()
{
DUP_Handler::init_error_handler();
try {
DUP_Util::hasCapability('export', DUP_Util::SECURE_ISSUE_THROW);
if (!wp_verify_nonce($_REQUEST['nonce'], 'duplicator_set_admin_notice_viewed')) {
DUP_Log::trace(__('Security issue', 'duplicator'));
throw new Exception('Security issue');
}
$notice_id = SnapUtil::sanitizeTextInput(SnapUtil::INPUT_REQUEST, 'notice_id', false);
if ($notice_id === false) {
throw new Exception(__('Invalid Request', 'duplicator'));
}
$notices = get_user_meta(get_current_user_id(), DUPLICATOR_ADMIN_NOTICES_USER_META_KEY, true);
if (empty($notices)) {
$notices = array();
}
if (!isset($notices[$notice_id])) {
throw new Exception(__("Notice with that ID doesn't exist.", 'duplicator'));
}
$notices[$notice_id] = 'true';
update_user_meta(get_current_user_id(), DUPLICATOR_ADMIN_NOTICES_USER_META_KEY, $notices);
} catch (Exception $ex) {
wp_die($ex->getMessage());
}
}
public static function admin_notice_to_dismiss()
{
try {
DUP_Util::hasCapability('export', DUP_Util::SECURE_ISSUE_THROW);
$nonce = SnapUtil::sanitizeTextInput(INPUT_POST, 'nonce', false);
if ($nonce === false || !wp_verify_nonce($nonce, 'duplicator_admin_notice_to_dismiss')) {
DUP_Log::trace('Security issue');
throw new Exception('Security issue');
}
$noticeToDismiss = SnapUtil::sanitizeTextInput(INPUT_POST, 'notice', false);
switch ($noticeToDismiss) {
case AdminNotices::OPTION_KEY_ACTIVATE_PLUGINS_AFTER_INSTALL:
case AdminNotices::OPTION_KEY_NEW_NOTICE_TEMPLATE:
delete_option($noticeToDismiss);
break;
case AdminNotices::OPTION_KEY_IS_ENABLE_NOTICE_DISMISSED:
case AdminNotices::OPTION_KEY_IS_MU_NOTICE_DISMISSED:
update_option($noticeToDismiss, true);
break;
default:
throw new Exception('Notice invalid');
}
} catch (Exception $e) {
wp_send_json_error($e->getMessage());
}
wp_send_json_success();
}
}

152
html/wp-content/plugins/duplicator/ctrls/ctrl.base.php Normal file
View File

@@ -0,0 +1,152 @@
<?php
use Duplicator\Libs\Snap\SnapJson;
defined('ABSPATH') || defined('DUPXABSPATH') || exit;
// Exit if accessed directly
if (! defined('DUPLICATOR_VERSION')) {
exit;
}
require_once(DUPLICATOR_PLUGIN_PATH . '/classes/utilities/class.u.php');
//Enum used to define the various test statues
final class DUP_CTRL_Status
{
const ERROR = -2;
const FAILED = -1;
const UNDEFINED = 0;
const SUCCESS = 1;
}
/**
* Base class for all controllers
*
* @package Duplicator
* @subpackage classes/ctrls
*/
class DUP_CTRL_Base
{
//Represents the name of the Nonce Action
public $Action;
//The return type valiad options: PHP, JSON-AJAX, JSON
public $returnType = 'JSON-AJAX';
public function setResponseType($type)
{
$opts = array('PHP', 'JSON-AJAX', 'JSON');
if (!in_array($type, $opts)) {
throw new Exception('The $type param must be one of the following: ' . implode(',', $opts) . ' for the following function [' . __FUNCTION__ . ']');
}
$this->returnType = $type;
}
}
/**
* A class structer used to report on controller methods
*
* @package Duplicator
* @subpackage classes/ctrls
*/
class DUP_CTRL_Report
{
//Properties
public $runTime;
public $returnType;
public $results;
public $status;
}
/**
* A class used format all controller responses in a consistent format. Every controller response will
* have a Report and Payload structer. The Payload is an array of the result response. The Report is used
* report on the overall status of the controller method
*
* Standard: PSR-2
*
* @link http://www.php-fig.org/psr/psr-2
*
* @package Duplicator
* @subpackage classes/ctrls
* @copyright (c) 2017, Snapcreek LLC
*/
class DUP_CTRL_Result
{
//Properties
public $report;
public $payload;
private $timeStart;
private $timeEnd;
private $CTRL;
public function __construct(DUP_CTRL_Base $CTRL_OBJ)
{
DUP_Util::hasCapability('export');
$this->timeStart = $this->microtimeFloat();
$this->CTRL = $CTRL_OBJ;
//Report Data
$this->report = new DUP_CTRL_Report();
$this->report->returnType = $CTRL_OBJ->returnType;
}
/**
* Used to process a controller request
*
* @param object $payload The response object that will be returned
* @param enum $test The status of a response
*
* @return object || JSON Returns a PHP object or json encoded object
*/
public function process($payload, $test = DUP_CTRL_Status::UNDEFINED)
{
if (is_array($this->payload)) {
$this->payload[] = $payload;
$this->report->results = count($this->payload);
} else {
$this->payload = $payload;
$this->report->results = (is_array($payload)) ? count($payload) : 1;
}
$this->report->status = $test;
$this->getProcessTime();
switch ($this->CTRL->returnType) {
case 'JSON':
return SnapJson::jsonEncode($this);
break;
case 'PHP':
return $this;
break;
default:
wp_send_json($this);
break;
}
}
/**
* Used to process an error response
*
* @param object $exception The PHP exception object
*
* @return object || JSON Returns a PHP object or json encoded object
*/
public function processError($exception)
{
$payload = array();
$payload['Message'] = $exception->getMessage();
$payload['File'] = $exception->getFile();
$payload['Line'] = $exception->getLine();
$payload['Trace'] = $exception->getTraceAsString();
$this->process($payload, DUP_CTRL_Status::ERROR);
die(SnapJson::jsonEncode($this));
}
private function getProcessTime()
{
$this->timeEnd = $this->microtimeFloat();
$this->report->runTime = $this->timeEnd - $this->timeStart;
}
private function microtimeFloat()
{
list($usec, $sec) = explode(" ", microtime());
return ((float) $usec + (float) $sec);
}
}

420
html/wp-content/plugins/duplicator/ctrls/ctrl.package.php Normal file
View File

@@ -0,0 +1,420 @@
<?php
use Duplicator\Libs\Snap\SnapJson;
defined('ABSPATH') || defined('DUPXABSPATH') || exit;
// Exit if accessed directly
if (!defined('DUPLICATOR_VERSION')) {
exit;
}
require_once(DUPLICATOR_PLUGIN_PATH . '/ctrls/ctrl.base.php');
require_once(DUPLICATOR_PLUGIN_PATH . '/classes/utilities/class.u.scancheck.php');
require_once(DUPLICATOR_PLUGIN_PATH . '/classes/utilities/class.u.json.php');
require_once(DUPLICATOR_PLUGIN_PATH . '/classes/package/class.pack.php');
require_once(DUPLICATOR_PLUGIN_PATH . '/classes/package/duparchive/class.pack.archive.duparchive.state.create.php');
require_once(DUPLICATOR_PLUGIN_PATH . '/classes/package/duparchive/class.pack.archive.duparchive.php');
/* @var $package DUP_Package */
/**
* Display error if any fatal error occurs occurs while scan ajax call
*
* @return void
*/
function duplicator_package_scan_shutdown()
{
$logMessage = DUP_Handler::getVarLog();
if (!empty($logMessage)) {
echo nl2br($logMessage);
}
}
/**
* DUPLICATOR_PACKAGE_SCAN
* Returns a JSON scan report object which contains data about the system
*
* @return json JSON report object
* @example to test: /wp-admin/admin-ajax.php?action=duplicator_package_scan
*/
function duplicator_package_scan()
{
DUP_Handler::init_error_handler();
DUP_Handler::setMode(DUP_Handler::MODE_VAR);
register_shutdown_function('duplicator_package_scan_shutdown');
check_ajax_referer('duplicator_package_scan', 'nonce');
DUP_Util::hasCapability('export');
header('Content-Type: application/json;');
@ob_flush();
@set_time_limit(0);
$errLevel = error_reporting();
error_reporting(E_ERROR);
DUP_Util::initSnapshotDirectory();
$package = DUP_Package::getActive();
$report = $package->runScanner();
$package->saveActiveItem('ScanFile', $package->ScanFile);
$package->Archive->saveActiveItem($package, 'dirsCount', $package->Archive->dirsCount);
$package->Archive->saveActiveItem($package, 'filesCount', $package->Archive->filesCount);
$json_response = DUP_JSON::safeEncode($report);
DUP_Package::tempFileCleanup();
error_reporting($errLevel);
die($json_response);
}
/**
* duplicator_package_build
* Returns the package result status
*
* @return json JSON object of package results
*/
function duplicator_package_build()
{
DUP_Handler::init_error_handler();
check_ajax_referer('duplicator_package_build', 'nonce');
header('Content-Type: application/json');
$Package = null;
try {
DUP_Util::hasCapability('export', DUP_Util::SECURE_ISSUE_THROW);
@set_time_limit(0);
$errLevel = error_reporting();
error_reporting(E_ERROR);
DUP_Util::initSnapshotDirectory();
$Package = DUP_Package::getActive();
$Package->save('zip');
DUP_Settings::Set('active_package_id', $Package->ID);
DUP_Settings::Save();
if (!is_readable(DUP_Settings::getSsdirTmpPath() . "/{$Package->ScanFile}")) {
die("The scan result file was not found. Please run the scan step before building the Backup.");
}
$Package->runZipBuild();
//JSON:Debug Response
//Pass = 1, Warn = 2, Fail = 3
$json = array();
$json['status'] = 1;
$json['error'] = '';
$json['package'] = $Package;
$json['instDownloadName'] = $Package->getInstDownloadName();
$json['runtime'] = $Package->Runtime;
$json['exeSize'] = $Package->ExeSize;
$json['archiveSize'] = $Package->ZipSize;
//Simulate a Host Build Interrupt
//die(0);
} catch (Exception $e) {
$Package->setStatus(DUP_PackageStatus::ERROR);
//JSON:Debug Response
//Pass = 1, Warn = 2, Fail = 3
$json = array();
$json['status'] = 3;
$json['error'] = $e->getMessage() . "\n" . "FILE: " . $e->getFile() . "[" . $e->getLine() . "]\n" . $e->getTraceAsString();
$json['package'] = $Package;
$json['instDownloadName'] = null;
$json['runtime'] = null;
$json['exeSize'] = null;
$json['archiveSize'] = null;
}
$json_response = SnapJson::jsonEncode($json);
error_reporting($errLevel);
die($json_response);
}
/**
* Returns the package result status
*
* @return json JSON object of package results
*/
function duplicator_duparchive_package_build()
{
DUP_Handler::init_error_handler();
DUP_Log::Info('[CTRL DUP ARCIVE] CALL TO ' . __FUNCTION__);
check_ajax_referer('duplicator_duparchive_package_build', 'nonce');
DUP_Util::hasCapability('export');
header('Content-Type: application/json');
@set_time_limit(0);
$errLevel = error_reporting();
error_reporting(E_ERROR);
// The DupArchive build process always works on a saved package so the first time through save the active package to the package table.
// After that, just retrieve it.
$active_package_id = DUP_Settings::Get('active_package_id');
DUP_Log::Info('[CTRL DUP ARCIVE] CURRENT PACKAGE ACTIVE ' . $active_package_id);
if ($active_package_id == -1) {
$package = DUP_Package::getActive();
$package->save('daf');
DUP_Log::Info('[CTRL DUP ARCIVE] PACKAGE AS NEW ID ' . $package->ID . ' SAVED | STATUS:' . $package->Status);
//DUP_Log::TraceObject("[CTRL DUP ARCIVE] PACKAGE SAVED:", $package);
DUP_Settings::Set('active_package_id', $package->ID);
DUP_Settings::Save();
} else {
if (($package = DUP_Package::getByID($active_package_id)) == null) {
DUP_Log::Info('[CTRL DUP ARCIVE] ERROR: Get package by id ' . $active_package_id . ' FAILED');
die('Get Backup by id ' . $active_package_id . ' FAILED');
}
DUP_Log::Info('[CTRL DUP ARCIVE] PACKAGE GET BY ID ' . $active_package_id . ' | STATUS:' . $package->Status);
// DUP_Log::TraceObject("getting active package by id {$active_package_id}", $package);
}
if (!is_readable(DUP_Settings::getSsdirTmpPath() . "/{$package->ScanFile}")) {
DUP_Log::Info('[CTRL DUP ARCIVE] ERROR: The scan result file was not found. Please run the scan step before building the Backup.');
die("The scan result file was not found. Please run the scan step before building the Backup.");
}
if ($package === null) {
DUP_Log::Info('[CTRL DUP ARCIVE] There is no active package.');
die("There is no active package.");
}
if ($package->Status == DUP_PackageStatus::ERROR) {
$package->setStatus(DUP_PackageStatus::ERROR);
$hasCompleted = true;
} else {
try {
$hasCompleted = $package->runDupArchiveBuild();
} catch (Exception $ex) {
DUP_Log::Info('[CTRL DUP ARCIVE] ERROR: caught exception');
Dup_Log::error('[CTRL DUP ARCIVE] Caught exception', $ex->getMessage(), Dup_ErrorBehavior::LogOnly);
DUP_Log::Info('[CTRL DUP ARCIVE] ERROR: after log');
$package->setStatus(DUP_PackageStatus::ERROR);
$hasCompleted = true;
}
}
$json = array();
$json['failures'] = array_merge($package->BuildProgress->build_failures, $package->BuildProgress->validation_failures);
if (!empty($json['failures'])) {
DUP_Log::Info('[CTRL DUP ARCIVE] FAILURES ' . print_r($json['failures'], true));
}
//JSON:Debug Response
//Pass = 1, Warn = 2, 3 = Failure, 4 = Not Done
if ($hasCompleted) {
DUP_Log::Info('[CTRL DUP ARCIVE] COMPLETED PACKAGE STATUS: ' . $package->Status);
if ($package->Status == DUP_PackageStatus::ERROR) {
DUP_Log::Info('[CTRL DUP ARCIVE] ERROR');
$error_message = __('Error building DupArchive Backup', 'duplicator') . '<br/>';
foreach ($json['failures'] as $failure) {
$error_message .= implode(',', $failure->description);
}
Dup_Log::error("Build failed so sending back error", esc_html($error_message), Dup_ErrorBehavior::LogOnly);
DUP_Log::Info('[CTRL DUP ARCIVE] ERROR AFTER LOG 2');
$json['status'] = 3;
} else {
Dup_Log::Info("sending back success status");
$json['status'] = 1;
}
Dup_Log::Trace('#### json package');
$json['package'] = $package;
$json['instDownloadName'] = $package->getInstDownloadName();
$json['runtime'] = $package->Runtime;
$json['exeSize'] = $package->ExeSize;
$json['archiveSize'] = $package->ZipSize;
DUP_Log::Trace('[CTRL DUP ARCIVE] JSON PACKAGE');
} else {
DUP_Log::Info('[CTRL DUP ARCIVE] sending back continue status PACKAGE STATUS: ' . $package->Status);
$json['status'] = 4;
}
$json_response = SnapJson::jsonEncode($json);
Dup_Log::TraceObject('json response', $json_response);
error_reporting($errLevel);
die($json_response);
}
/**
* DUPLICATOR_PACKAGE_DELETE
* Deletes the files and database record entries
*
* @return json A JSON message about the action.
* Use console.log to debug from client
*/
function duplicator_package_delete()
{
DUP_Handler::init_error_handler();
check_ajax_referer('duplicator_package_delete', 'nonce');
$json = array(
'success' => false,
'message' => ''
);
$package_ids = filter_input(INPUT_POST, 'package_ids', FILTER_VALIDATE_INT, array(
'flags' => FILTER_REQUIRE_ARRAY,
'options' => array(
'default' => false
)
));
$delCount = 0;
try {
DUP_Util::hasCapability('export', DUP_Util::SECURE_ISSUE_THROW);
if ($package_ids === false || in_array(false, $package_ids)) {
throw new Exception('Invalid Request.', 'duplicator');
}
foreach ($package_ids as $id) {
$package = DUP_Package::getByID($id);
if ($package === null) {
throw new Exception('Invalid Request.', 'duplicator');
}
$package->delete();
$delCount++;
}
$json['success'] = true;
$json['ids'] = $package_ids;
$json['removed'] = $delCount;
} catch (Exception $ex) {
$json['message'] = $ex->getMessage();
}
die(SnapJson::jsonEncode($json));
}
/**
* Active package info
* Returns a JSON scan report active package info or
* active_package_present == false if no active package is present.
*
* @return json
*/
function duplicator_active_package_info()
{
ob_start();
try {
DUP_Handler::init_error_handler();
DUP_Util::hasCapability('export', DUP_Util::SECURE_ISSUE_THROW);
if (!check_ajax_referer('duplicator_active_package_info', 'nonce', false)) {
throw new Exception(__('An unauthorized security request was made to this page. Please try again!', 'duplicator'));
}
global $wpdb;
$error = false;
$result = array(
'active_package' => array(
'present' => false,
'status' => 0,
'size' => 0
),
'html' => '',
'message' => ''
);
$result['active_package']['present'] = DUP_Package::isPackageRunning();
if ($result['active_package']['present']) {
$id = DUP_Settings::Get('active_package_id');
$package = DUP_Package::getByID($id);
if (is_null($package)) {
throw new Exception(__('Active Backup object error', 'duplicator'));
}
$result['active_package']['status'] = $package->Status;
$result['active_package']['size'] = $package->getArchiveSize();
$result['active_package']['size_format'] = DUP_Util::byteSize($package->getArchiveSize());
}
} catch (Exception $e) {
$error = true;
$result['message'] = $e->getMessage();
}
$result['html'] = ob_get_clean();
if ($error) {
wp_send_json_error($result);
} else {
wp_send_json_success($result);
}
}
/**
* Controller for Tools
*
* @package Duplicator\ctrls
*/
class DUP_CTRL_Package extends DUP_CTRL_Base
{
/**
* Init this instance of the object
*/
public function __construct()
{
add_action('wp_ajax_DUP_CTRL_Package_addQuickFilters', array($this, 'addQuickFilters'));
add_action('wp_ajax_DUP_CTRL_Package_getActivePackageStatus', array($this, 'getActivePackageStatus'));
}
/**
* Removed all reserved installer files names
*
* @param string $_POST['dir_paths'] A semi-colon separated list of directory paths
*
* @return string Returns all of the active directory filters as a ";" separated string
*/
public function addQuickFilters()
{
DUP_Handler::init_error_handler();
check_ajax_referer('DUP_CTRL_Package_addQuickFilters', 'nonce');
$result = new DUP_CTRL_Result($this);
$inputData = array(
'dir_paths' => sanitize_textarea_field($_POST['dir_paths'] ?? ''),
'file_paths' => sanitize_textarea_field($_POST['file_paths'] ?? '')
);
try {
DUP_Util::hasCapability('export', DUP_Util::SECURE_ISSUE_THROW);
//CONTROLLER LOGIC
$package = DUP_Package::getActive();
//DIRS
$dir_filters = ($package->Archive->FilterOn && strlen($package->Archive->FilterDirs) > 0)
? $package->Archive->FilterDirs . ';' . $inputData['dir_paths'] : $inputData['dir_paths'];
$dir_filters = $package->Archive->parseDirectoryFilter($dir_filters);
$changed = $package->Archive->saveActiveItem($package, 'FilterDirs', $dir_filters);
//FILES
$file_filters = ($package->Archive->FilterOn && strlen($package->Archive->FilterFiles) > 0)
? $package->Archive->FilterFiles . ';' . $inputData['file_paths'] : $inputData['file_paths'];
$file_filters = $package->Archive->parseFileFilter($file_filters);
$changed = $package->Archive->saveActiveItem($package, 'FilterFiles', $file_filters);
if (!$package->Archive->FilterOn && !empty($package->Archive->FilterExts)) {
$changed = $package->Archive->saveActiveItem($package, 'FilterExts', '');
}
$changed = $package->Archive->saveActiveItem($package, 'FilterOn', 1);
//Result
$package = DUP_Package::getActive();
$payload['dirs-in'] = esc_html(sanitize_text_field($inputData['dir_paths']));
$payload['dir-out'] = esc_html($package->Archive->FilterDirs);
$payload['files-in'] = esc_html(sanitize_text_field($inputData['file_paths']));
$payload['files-out'] = esc_html($package->Archive->FilterFiles);
//RETURN RESULT
$test = ($changed) ? DUP_CTRL_Status::SUCCESS : DUP_CTRL_Status::FAILED;
$result->process($payload, $test);
} catch (Exception $exc) {
$result->processError($exc);
}
}
/**
* Get active package status
*
* <code>
* //JavaScript Ajax Request
* Duplicator.Package.getActivePackageStatus()
* </code>
*/
public function getActivePackageStatus()
{
DUP_Handler::init_error_handler();
check_ajax_referer('DUP_CTRL_Package_getActivePackageStatus', 'nonce');
$result = new DUP_CTRL_Result($this);
try {
DUP_Util::hasCapability('export', DUP_Util::SECURE_ISSUE_THROW);
//CONTROLLER LOGIC
$active_package_id = DUP_Settings::Get('active_package_id');
$package = DUP_Package::getByID($active_package_id);
$payload = array();
if ($package != null) {
$test = DUP_CTRL_Status::SUCCESS;
$payload['status'] = $package->Status;
} else {
$test = DUP_CTRL_Status::FAILED;
}
//RETURN RESULT
return $result->process($payload, $test);
} catch (Exception $exc) {
$result->processError($exc);
}
}
}

184
html/wp-content/plugins/duplicator/ctrls/ctrl.tools.php Normal file
View File

@@ -0,0 +1,184 @@
<?php
use Duplicator\Core\Controllers\ControllersManager;
use Duplicator\Libs\Snap\SnapURL;
use Duplicator\Libs\Snap\SnapUtil;
defined('ABSPATH') || defined('DUPXABSPATH') || exit;
// Exit if accessed directly
if (! defined('DUPLICATOR_VERSION')) {
exit;
}
require_once(DUPLICATOR_PLUGIN_PATH . '/ctrls/ctrl.base.php');
require_once(DUPLICATOR_PLUGIN_PATH . '/classes/utilities/class.u.scancheck.php');
/**
* Controller for Tools
*
* @package Duplicator\ctrls
*/
class DUP_CTRL_Tools extends DUP_CTRL_Base
{
/**
* Init this instance of the object
*/
public function __construct()
{
add_action('wp_ajax_DUP_CTRL_Tools_runScanValidator', array($this, 'runScanValidator'));
add_action('wp_ajax_DUP_CTRL_Tools_getTraceLog', array($this, 'getTraceLog'));
}
/**
*
* @return boolean
*/
public static function isToolPage()
{
return ControllersManager::isCurrentPage(ControllersManager::TOOLS_SUBMENU_SLUG);
}
/**
*
* @return boolean
*/
public static function isDiagnosticPage()
{
return ControllersManager::isCurrentPage(ControllersManager::TOOLS_SUBMENU_SLUG, 'diagnostics');
}
/**
* Return diagnostic URL
*
* @param bool $relative if true return relative URL else absolute
*
* @return string
*/
public static function getDiagnosticURL($relative = true)
{
return ControllersManager::getMenuLink(
ControllersManager::TOOLS_SUBMENU_SLUG,
'diagnostics',
'',
array(),
$relative
);
}
/**
* Return clean installer files action URL
*
* @param bool $relative if true return relative URL else absolute
*
* @return string
*/
public static function getCleanFilesAcrtionUrl($relative = true)
{
return ControllersManager::getMenuLink(
ControllersManager::TOOLS_SUBMENU_SLUG,
'diagnostics',
'',
array(
'action' => 'installer',
'_wpnonce' => wp_create_nonce('duplicator_cleanup_page')
),
$relative
);
}
/**
* Calls the ScanValidator and returns a JSON result
*
* @notes: Testing = /wp-admin/admin-ajax.php?action=DUP_CTRL_Tools_runScanValidator
*/
public function runScanValidator()
{
DUP_Handler::init_error_handler();
check_ajax_referer('DUP_CTRL_Tools_runScanValidator', 'nonce');
@set_time_limit(0);
$isValid = true;
$inputData = filter_input_array(INPUT_POST, array(
'recursive_scan' => array(
'filter' => FILTER_VALIDATE_BOOLEAN,
'flags' => FILTER_NULL_ON_FAILURE
)
));
if (is_null($inputData['recursive_scan'])) {
$isValid = false;
}
$result = new DUP_CTRL_Result($this);
try {
DUP_Util::hasCapability('export', DUP_Util::SECURE_ISSUE_THROW);
if (!$isValid) {
throw new Exception(__('Invalid Request.', 'duplicator'));
}
//CONTROLLER LOGIC
$path = duplicator_get_abs_path();
if (!is_dir($path)) {
throw new Exception("Invalid directory provided '{$path}'!");
}
$scanner = new DUP_ScanCheck();
$scanner->recursion = $inputData['recursive_scan'];
$payload = $scanner->run($path);
//RETURN RESULT
$test = ($payload->fileCount > 0)
? DUP_CTRL_Status::SUCCESS
: DUP_CTRL_Status::FAILED;
$result->process($payload, $test);
} catch (Exception $exc) {
$result->processError($exc);
}
}
public function getTraceLog()
{
DUP_Log::Trace("enter");
check_ajax_referer('DUP_CTRL_Tools_getTraceLog', 'nonce');
Dup_Util::hasCapability('export');
$file_path = DUP_Log::GetTraceFilepath();
$backup_path = DUP_Log::GetBackupTraceFilepath();
$zip_path = DUP_Settings::getSsdirPath() . "/" . DUPLICATOR_ZIPPED_LOG_FILENAME;
$zipped = DUP_Zip_U::zipFile($file_path, $zip_path, true, null, true);
if ($zipped && file_exists($backup_path)) {
$zipped = DUP_Zip_U::zipFile($backup_path, $zip_path, false, null, true);
}
header("Pragma: public");
header("Expires: 0");
header("Cache-Control: must-revalidate, post-check=0, pre-check=0");
header("Cache-Control: private", false);
header("Content-Transfer-Encoding: binary");
$fp = fopen($zip_path, 'rb');
if (($fp !== false) && $zipped) {
$zip_filename = basename($zip_path);
header("Content-Type: application/octet-stream");
header("Content-Disposition: attachment; filename=\"$zip_filename\";");
// required or large files wont work
if (ob_get_length()) {
ob_end_clean();
}
DUP_Log::trace("streaming $zip_path");
if (fpassthru($fp) === false) {
DUP_Log::trace("Error with fpassthru for $zip_path");
}
fclose($fp);
@unlink($zip_path);
} else {
header("Content-Type: text/plain");
header("Content-Disposition: attachment; filename=\"error.txt\";");
if ($zipped === false) {
$message = "Couldn't create zip file.";
} else {
$message = "Couldn't open $file_path.";
}
DUP_Log::trace($message);
echo esc_html($message);
}
exit;
}
}

144
html/wp-content/plugins/duplicator/ctrls/ctrl.ui.php Normal file
View File

@@ -0,0 +1,144 @@
<?php
use Duplicator\Libs\Snap\SnapUtil;
defined('ABSPATH') || defined('DUPXABSPATH') || exit;
// Exit if accessed directly
if (! defined('DUPLICATOR_VERSION')) {
exit;
}
require_once(DUPLICATOR_PLUGIN_PATH . '/ctrls/ctrl.base.php');
require_once(DUPLICATOR_PLUGIN_PATH . '/classes/ui/class.ui.viewstate.php');
/**
* Controller for Tools
*
* @package Duplicator\ctrls
*/
class DUP_CTRL_UI extends DUP_CTRL_Base
{
public function __construct()
{
add_action('wp_ajax_DUP_CTRL_UI_SaveViewState', array($this, 'SaveViewState'));
}
/**
* Calls the SaveViewState and returns a JSON result
*
* @param string $_POST['key'] A unique key that identifies the state of the UI element
* @param bool $_POST['value'] The value to store for the state of the UI element
*
* @notes: Testing: See Testing Interface
* URL = /wp-admin/admin-ajax.php?action=DUP_CTRL_UI_SaveViewState
*
* <code>
* //JavaScript Ajax Request
* Duplicator.UI.SaveViewState('dup-pack-archive-panel', 1);
*
* //Call PHP Code
* $view_state = DUP_UI_ViewState::getValue('dup-pack-archive-panel');
* $ui_css_archive = ($view_state == 1) ? 'display:block' : 'display:none';
* </code>
*/
public function SaveViewState()
{
DUP_Handler::init_error_handler();
check_ajax_referer('DUP_CTRL_UI_SaveViewState', 'nonce');
DUP_Util::hasCapability('export');
$payload = array(
'success' => false,
'message' => '',
'key' => '',
'value' => ''
);
$isValid = true;
$states = false;
if (isset($_POST['states'])) {
$states = is_scalar($_POST['states']) ? [$_POST['states']] : $_POST['states'];
}
$mainKey = SnapUtil::sanitizeTextInput(INPUT_POST, 'key', false);
$mainValue = SnapUtil::sanitizeTextInput(INPUT_POST, 'value', false);
if ($states !== false) {
foreach ($states as $index => $state) {
$key = isset($state['key']) ? SnapUtil::sanitizeNSCharsNewline($state['key']) : false;
$value = isset($state['value']) ? SnapUtil::sanitizeNSCharsNewline($state['value']) : false;
if ($key == false && $value == false) {
$isValid = false;
break;
}
$states[$index] = [
'key' => $key,
'value' => $value,
];
}
}
if ($states === false && ($mainKey === false || $mainValue === false)) {
$isValid = false;
}
$result = new DUP_CTRL_Result($this);
try {
if (!$isValid) {
throw new Exception(__('Invalid Request.', 'duplicator'));
}
if ($states !== false && count($states) > 0) {
$view_state = DUP_UI_ViewState::getArray();
$last_key = '';
foreach ($states as $state) {
$view_state[$state['key']] = $state['value'];
$last_key = $state['key'];
}
$payload['success'] = DUP_UI_ViewState::setArray($view_state);
$payload['key'] = esc_html($last_key);
$payload['value'] = esc_html($view_state[$last_key]);
} else {
$payload['success'] = DUP_UI_ViewState::save($mainKey, $mainValue);
$payload['key'] = esc_html($mainKey);
$payload['value'] = esc_html($mainValue);
}
//RETURN RESULT
$test = ($payload['success'])
? DUP_CTRL_Status::SUCCESS
: DUP_CTRL_Status::FAILED;
return $result->process($payload, $test);
} catch (Exception $exc) {
$result->processError($exc);
}
}
/**
* Returns a JSON list of all saved view state items
*
* <code>
* See SaveViewState()
* </code>
*/
public function GetViewStateList()
{
$result = new DUP_CTRL_Result($this);
try {
//CONTROLLER LOGIC
$payload = DUP_UI_ViewState::getArray();
//RETURN RESULT
$test = (is_array($payload) && count($payload))
? DUP_CTRL_Status::SUCCESS
: DUP_CTRL_Status::FAILED;
return $result->process($payload, $test);
} catch (Exception $exc) {
$result->processError($exc);
}
}
}

3
html/wp-content/plugins/duplicator/ctrls/index.php Normal file
View File

@@ -0,0 +1,3 @@
<?php
//silent