Your IP : 216.73.217.80
<?php
/**
* @version admin/classes/coreupdater.php 2024-03-27 zanardigit
* @package Watchful Client
* @author Watchful
* @authorUrl https://watchful.net
* @copyright Copyright (c) 2012-2025 Watchful
* @license GNU/GPL v3 or later
* @description adapted from com_joomlaupdate controller
*/
use Joomla\CMS\Installer\InstallerHelper;
use Joomla\CMS\Language\Text;
use Joomla\CMS\Log\Log;
use Joomla\CMS\Version;
use Joomla\Component\Joomlaupdate\Administrator\Model\UpdateModel;
defined('_JEXEC') or die;
class WatchfulliCoreUpdater
{
/** @var stdClass $extParams */
private $extParams;
private $options;
/** @var JoomlaupdateModelDefault|UpdateModel */
private $joomlaUpdateModel;
private $helper;
/** @var Joomla\CMS\Application\CMSWebApplicationInterface|Joomla\CMS\Application\CMSApplication */
private $application;
/** @var string */
private $tmpPath;
/**
* Performs the download of the update package
* @throws Exception
*/
public function __construct(stdClass $extParams)
{
$this->options['format'] = '{DATE}\t{TIME}\t{LEVEL}\t{CODE}\t{MESSAGE}';
$this->options['text_file'] = 'watchfulli';
$this->helper = new WatchfulliHelper();
$this->application = WatchfulliFactory::getApplication();
$this->tmpPath = $this->application->get('tmp_path');
$this->extParams = $extParams;
Log::addLogger($this->options, Log::INFO, ['Update', 'databasequery', 'jerror']);
}
/**
* Downloads the update package to the site.
*
* @param string $packageURL
*/
public function download($packageURL)
{
watchfulli::debug("downloading $packageURL");
$basename = basename($packageURL);
$target = $this->tmpPath . '/' . $basename;
if (!WatchfulliFileHelper::exists($target)) {
$this->downloadPackage($packageURL, $target);
}
// Is it a 0-byte file? If so, re-download please.
$filesize = @filesize($target);
if (empty($filesize)) {
$file = $this->downloadPackage($packageURL, $target);
} else {
$file = $basename;
}
if (!$file) {
$this->helper->response(
[
'task' => 'download',
'status' => 'error',
'message' => Text::_('COM_JOOMLAUPDATE_VIEW_UPDATE_DOWNLOADFAILED'),
]
);
}
watchfulli::debug("downloaded $file");
try {
$this->validateHash($target);
} catch (Exception $e) {
$this->helper->response(
[
'task' => 'download',
'status' => 'error',
'message' => $e->getMessage(),
]
);
}
watchfulli::debug("validated $file");
$this->helper->response(
[
'task' => 'download',
'status' => 'success',
'message' => $file,
]
);
}
/**
* @throws Exception
*/
private function validateHash(string $packagePath)
{
if (!$this->application->input->get('validatehash', 0)) {
return;
}
$hashes = [ 'sha256', 'sha384', 'sha512' ];
foreach ($hashes as $hash) {
if (empty($this->extParams->$hash)) {
continue;
}
$hashValue = hash_file($hash, $packagePath);
if ($hashValue !== $this->extParams->$hash) {
throw new Exception('COM_JMONITORING_UPDATE_CORE_ERROR_CHECKSUM_FAILED');
}
}
}
/**
* Start the installation of the new Joomla! version
*
* @param string $file
*
* @throws Exception
* @throws Exception
*/
public function install($file)
{
Log::add(Text::_('COM_JOOMLAUPDATE_UPDATE_LOG_INSTALL'), Log::INFO, 'Update');
watchfulli::debug("installing $file");
$this->setupCoreUpdateModel();
/** GH #1133 */
$useNewExtractor = version_compare(WatchfulliJoomlaVersion::getVersion(), '4.0.4', '>=');
$settingsMethod = $useNewExtractor ? 'createUpdateFile' : 'createRestorationFile';
$settingsFile = $useNewExtractor ? 'update.php' : 'restoration.php';
$extractor = $useNewExtractor ? 'extract.php' : 'restore.php';
watchfulli::debug("using $settingsMethod, $settingsFile, $extractor");
$this->joomlaUpdateModel->$settingsMethod($file);
watchfulli::debug("Done $settingsMethod");
// cannot continue unless we copy update settings file to com_joomlaupdate
// but we don't want to bother encrypting the JSON
$src = JPATH_COMPONENT_ADMINISTRATOR . '/' . $settingsFile ;
$dst = JPATH_ADMINISTRATOR . '/components/com_joomlaupdate/' . $settingsFile;
$res = preg_replace("/'kickstart\.security\.password' => '.*?'/", "'kickstart.security.password' => null", file_get_contents($src));
watchfulli::debug("Copying $src to $dst");
WatchfulliFileHelper::write($dst, $res);
watchfulli::debug("Copied $src to $dst");
// extractor expects to be running in its own directory
$cwd = getcwd();
chdir(dirname($dst));
// build JSON data
$json = json_encode(['task' => 'ping']);
WatchfulliFactory::getInput()->set('json', $json);
// capture the output from extractor
ob_start();
require_once JPATH_ADMINISTRATOR . '/components/com_joomlaupdate/' . $extractor;
$output = ob_get_clean();
// go back to our own directory
chdir($cwd);
$this->helper->response(
[
'task' => 'install',
'status' => 'success',
'message' => 'install ok',
'output' => $this->parseRestoreResponse($output),
]
);
}
/**
* Extract the update ZIP
*
* For issue #1002, testing using JInstallerHelper::unpack() in one go, instead of the Akeeba
* stepped extraction, due to issue with executing mismatched code during stepping.
*
* @param string $file
*
* @return void
*/
public function step($file)
{
$target = $this->tmpPath . '/' . $file;
watchfulli::debug("step $target");
try {
$extractionPath = $this->unpackFile($target);
watchfulli::debug("step $extractionPath");
} catch (Exception $ex) {
$this->helper->response(
[
'task' => 'step',
'status' => 'error',
'message' => $ex->getMessage(),
]
);
}
WatchfulliFileHelper::delete($target);
$this->helper->response(
[
'task' => 'step',
'status' => !empty($extractionPath) ? 'success' : 'error',
'message' => !empty($extractionPath) ? basename($extractionPath) : 'error',
'output' => [
'status' => true,
'message' => null,
'files' => 0,
'bytesIn' => 0,
'bytesOut' => 0,
'done' => true,
],
]
);
}
/**
* Unpack a given file
*
* @param string $file the name of the file to unpack
*
* @throws Exception
* @return string
*/
private function unpackFile($file)
{
watchfulli::debug("unpackFile $file");
if (!$file) {
throw new Exception('COM_JMONITORING_CANT_UNPACK_UPDATE_EMPTY_FILE');
}
if (!file_exists($file)) {
throw new Exception('COM_JMONITORING_CANT_UNPACK_UPDATE_MISSING_FILE');
}
if (extension_loaded('zip')) {
return $this->quickUnpack($file);
}
watchfulli::debug("unpackFile using JInstallerHelper::unpack()");
$package = InstallerHelper::unpack($file, true);
watchfulli::debug("unpackFile done");
if (empty($package)) {
throw new Exception('COM_JMONITORING_CANT_UNPACK_UPDATE');
}
return $package['dir'];
}
/**
* @throws Exception
*/
private function quickUnpack($file): string
{
watchfulli::debug("quickUnpack $file");
$zip = new ZipArchive();
$extractionPath = $this->tmpPath . '/' . uniqid('install_');
if (
!$zip->open($file) || !$zip->extractTo($extractionPath)
) {
throw new Exception('COM_JMONITORING_CANT_UNPACK_UPDATE');
}
$zip->close();
watchfulli::debug("quickUnpack done");
return $extractionPath;
}
/**
* Finalise the upgrade by running the necessary scripts
*
* @param string $directory
*
* @return void
* @throws Exception
*/
public function finalise($directory)
{
watchfulli::debug("finalise $directory");
// https://github.com/joomla/joomla-cms/issues/38474
if (file_exists(JPATH_ADMINISTRATOR . '/cache/autoload_psr4.php')) {
@unlink(JPATH_ADMINISTRATOR . '/cache/autoload_psr4.php');
}
$tmpDir = $this->tmpPath . '/' . $directory;
$this->setupCoreUpdateModel();
WatchfulliFileHelper::copyFolder($tmpDir, JPATH_ROOT);
watchfulli::debug("finalise copyFolder $tmpDir to JPATH_ROOT");
if ($this->joomlaUpdateModel->finaliseUpgrade())
{
$this->helper->response(
[
'task' => 'finalise',
'status' => 'success',
'message' => 'install ok',
]
);
}
$this->helper->response(
[
'task' => 'finalise',
'status' => 'error',
'message' => Text::_('COM_JOOMLAUPDATE_VIEW_UPDATE_DOWNLOADFAILED'),
]
);
}
/**
* Removes the extracted package file.
*
* @param string $directory
*
* @return void
* @throws Exception
*/
public function cleanup($directory)
{
watchfulli::debug("cleanup $directory");
$directory = $this->tmpPath . '/' . $directory;
// Remove joomla.xml from the site's root.
$target = JPATH_ROOT . '/joomla.xml';
WatchfulliFileHelper::delete($target);
InstallerHelper::cleanupInstall('', $directory);
watchfulli::debug("cleanup delete $directory");
// Remove the restoration.php file.
$target = JPATH_ADMINISTRATOR . '/components/com_joomlaupdate/restoration.php';
WatchfulliFileHelper::delete($target);
$this->helper->response(
[
'task' => 'cleanup',
'status' => 'success',
'message' => '',
]
);
}
/**
* Purges updates.
*
* @return void
* @throws Exception
* @throws Exception
*/
public function purge()
{
watchfulli::debug("purge");
JLoader::import('models.default', JPATH_ADMINISTRATOR . '/components/com_joomlaupdate');
$this->setupCoreUpdateModel();
// Purge updates
// Check for request forgeries
$this->joomlaUpdateModel->purge();
}
protected function parseRestoreResponse($response)
{
$delim = '###';
if (false === strpos($response, $delim))
{
return $response;
}
list($junk, $str) = explode('###', $response, 2);
list($junk, $str) = explode('###', strrev($str), 2);
unset($junk);
return json_decode(strrev($str));
}
/**
* Downloads a package file to a specific directory
*
* @param string $url The URL to download from
* @param string $target The directory to store the file
*
* @return string|bool True on success
*/
protected function downloadPackage($url, $target)
{
watchfulli::debug("downloadPackage $url $target");
Log::add(Text::sprintf('COM_JOOMLAUPDATE_UPDATE_LOG_URL', $url), Log::INFO, 'Update');
// Get the handler to download the package
try {
$http = WatchfulliFactory::getHttp();
} catch (Exception $e) {
return false;
}
watchfulli::debug("downloadPackage delete $target");
WatchfulliFileHelper::delete($target);
// Download the package
$result = $http->get($url);
$statusCode = $result->code ?? (method_exists($result, 'getStatusCode') ? $result->getStatusCode() : null);
watchfulli::debug("downloadPackage $url $target $statusCode");
if (!$result || ($statusCode != 200 && $statusCode != 310)) {
return false;
}
$body = $result->body ?? (method_exists($result, 'getBody') ? $result->getBody() : null);
// Write the file to disk
WatchfulliFileHelper::write($target, $body);
watchfulli::debug("downloadPackage done");
return basename($target);
}
/**
* @throws Exception
*/
private function setupCoreUpdateModel()
{
$this->joomlaUpdateModel = WatchfulliFactory::getUpdateModel();
}
}