NOISSUE add archived projects

Signed-off-by: Mehmet Samet Duman <yongdohyun@projecttick.org>

1 files changed, 872 insertions, 0 deletions

diff --git a/archived/projt-launcher/launcher/MMCZip.cpp b/archived/projt-launcher/launcher/MMCZip.cpp
new file mode 100644
index 0000000000..9c5c095092
--- /dev/null
+++ b/archived/projt-launcher/launcher/MMCZip.cpp
@@ -0,0 +1,872 @@
+// SPDX-License-Identifier: GPL-3.0-only
+// SPDX-FileCopyrightText: 2026 Project Tick
+// SPDX-FileContributor: Project Tick Team
+/*
+ *  ProjT Launcher - Minecraft Launcher
+ *  Copyright (C) 2026 Project Tick
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, version 3.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * === Upstream License Block (Do Not Modify) ==============================
+ *
+ *
+ *
+ *  Prism Launcher - Minecraft Launcher
+ *  Copyright (C) 2022 Sefa Eyeoglu <contact@scrumplex.net>
+ *  Copyright (c) 2023-2024 Trial97 <alexandru.tripon97@gmail.com>
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, version 3.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * This file incorporates work covered by the following copyright and
+ * permission notice:
+ *
+ *      Copyright 2013-2021 MultiMC Contributors
+ *
+ *      Licensed under the Apache License, Version 2.0 (the "License");
+ *      you may not use this file except in compliance with the License.
+ *      You may obtain a copy of the License at
+ *
+ *          http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *      Unless required by applicable law or agreed to in writing, software
+ *      distributed under the License is distributed on an "AS IS" BASIS,
+ *      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *      See the License for the specific language governing permissions and
+ *      limitations under the License.
+ *
+ * ======================================================================== */
+
+#include "MMCZip.h"
+#include <quazip/quazip.h>
+#include <quazip/quazipdir.h>
+#include <quazip/quazipfile.h>
+#include <quazip/quazipfileinfo.h>
+#include "FileSystem.h"
+
+#include <QCoreApplication>
+#include <QDebug>
+#include <QFileInfo>
+#include <QUrl>
+
+#if defined(LAUNCHER_APPLICATION)
+#include <QtConcurrentRun>
+#endif
+
+namespace
+{
+	bool isWithinExtractionRoot(const QDir& root, const QString& path)
+	{
+		const auto cleanRoot = QDir::cleanPath(root.absolutePath());
+		const auto cleanPath = QDir::cleanPath(path);
+		return cleanPath == cleanRoot || cleanPath.startsWith(cleanRoot + '/');
+	}
+
+	bool symlinkEscapesExtractionRoot(QuaZip* zip, const QString& outputPath, const QDir& root)
+	{
+		QuaZipFileInfo64 info;
+		if (!zip->getCurrentFileInfo(&info) || !info.isSymbolicLink())
+		{
+			return false;
+		}
+
+		QuaZipFile linkFile(zip);
+		if (!linkFile.open(QIODevice::ReadOnly))
+		{
+			return true;
+		}
+
+		const auto linkTarget = QFile::decodeName(linkFile.readAll());
+		linkFile.close();
+
+		QString resolvedTarget;
+		if (QDir::isAbsolutePath(linkTarget))
+		{
+			resolvedTarget = QDir::cleanPath(linkTarget);
+		}
+		else
+		{
+			const auto outputDir = QFileInfo(outputPath).dir();
+			resolvedTarget	   = QDir::cleanPath(outputDir.absoluteFilePath(linkTarget));
+		}
+
+		return !isWithinExtractionRoot(root, resolvedTarget);
+	}
+} // namespace
+
+namespace MMCZip
+{
+	// ours
+	bool mergeZipFiles(QuaZip* into, QFileInfo from, QSet<QString>& contained, const Filter& filter)
+	{
+		QuaZip modZip(from.filePath());
+		modZip.open(QuaZip::mdUnzip);
+
+		QuaZipFile fileInsideMod(&modZip);
+		QuaZipFile zipOutFile(into);
+		for (bool more = modZip.goToFirstFile(); more; more = modZip.goToNextFile())
+		{
+			QString filename = modZip.getCurrentFileName();
+			if (filter && !filter(filename))
+			{
+				qDebug() << "Skipping file " << filename << " from " << from.fileName() << " - filtered";
+				continue;
+			}
+			if (contained.contains(filename))
+			{
+				qDebug() << "Skipping already contained file " << filename << " from " << from.fileName();
+				continue;
+			}
+			contained.insert(filename);
+
+			if (!fileInsideMod.open(QIODevice::ReadOnly))
+			{
+				qCritical() << "Failed to open " << filename << " from " << from.fileName();
+				return false;
+			}
+
+			QuaZipNewInfo info_out(fileInsideMod.getActualFileName());
+
+			if (!zipOutFile.open(QIODevice::WriteOnly, info_out))
+			{
+				qCritical() << "Failed to open " << filename << " in the jar";
+				fileInsideMod.close();
+				return false;
+			}
+			if (!JlCompress::copyData(fileInsideMod, zipOutFile))
+			{
+				zipOutFile.close();
+				fileInsideMod.close();
+				qCritical() << "Failed to copy data of " << filename << " into the jar";
+				return false;
+			}
+			zipOutFile.close();
+			fileInsideMod.close();
+		}
+		return true;
+	}
+
+	bool compressDirFiles(QuaZip* zip, QString dir, QFileInfoList files, bool followSymlinks)
+	{
+		QDir directory(dir);
+		if (!directory.exists())
+			return false;
+
+		for (auto e : files)
+		{
+			auto filePath = directory.relativeFilePath(e.absoluteFilePath());
+			auto srcPath  = e.absoluteFilePath();
+			if (followSymlinks)
+			{
+				if (e.isSymLink())
+				{
+					srcPath = e.symLinkTarget();
+				}
+				else
+				{
+					srcPath = e.canonicalFilePath();
+				}
+			}
+			if (!JlCompress::compressFile(zip, srcPath, filePath))
+				return false;
+		}
+
+		return true;
+	}
+
+	bool compressDirFiles(QString fileCompressed, QString dir, QFileInfoList files, bool followSymlinks)
+	{
+		QuaZip zip(fileCompressed);
+		zip.setUtf8Enabled(true);
+		QDir().mkpath(QFileInfo(fileCompressed).absolutePath());
+		if (!zip.open(QuaZip::mdCreate))
+		{
+			FS::deletePath(fileCompressed);
+			return false;
+		}
+
+		auto result = compressDirFiles(&zip, dir, files, followSymlinks);
+
+		zip.close();
+		if (zip.getZipError() != 0)
+		{
+			FS::deletePath(fileCompressed);
+			return false;
+		}
+
+		return result;
+	}
+
+#if defined(LAUNCHER_APPLICATION)
+	// ours
+	bool createModdedJar(QString sourceJarPath, QString targetJarPath, const QList<Mod*>& mods)
+	{
+		QuaZip zipOut(targetJarPath);
+		zipOut.setUtf8Enabled(true);
+		if (!zipOut.open(QuaZip::mdCreate))
+		{
+			FS::deletePath(targetJarPath);
+			qCritical() << "Failed to open the minecraft.jar for modding";
+			return false;
+		}
+		// Files already added to the jar.
+		// These files will be skipped.
+		QSet<QString> addedFiles;
+
+		// Modify the jar
+		// This needs to be done in reverse-order to ensure we respect the loading order of components
+		for (auto i = mods.crbegin(); i != mods.crend(); i++)
+		{
+			const auto* mod = *i;
+			// do not merge disabled mods.
+			if (!mod->enabled())
+				continue;
+			if (mod->type() == ResourceType::ZIPFILE)
+			{
+				if (!mergeZipFiles(&zipOut, mod->fileinfo(), addedFiles))
+				{
+					zipOut.close();
+					FS::deletePath(targetJarPath);
+					qCritical() << "Failed to add" << mod->fileinfo().fileName() << "to the jar.";
+					return false;
+				}
+			}
+			else if (mod->type() == ResourceType::SINGLEFILE)
+			{
+				auto filename = mod->fileinfo();
+				// Check if file already added to avoid duplicates
+				if (addedFiles.contains(filename.fileName()))
+				{
+					qDebug() << "Skipping duplicate file" << filename.fileName();
+					continue;
+				}
+				if (!JlCompress::compressFile(&zipOut, filename.absoluteFilePath(), filename.fileName()))
+				{
+					zipOut.close();
+					FS::deletePath(targetJarPath);
+					qCritical() << "Failed to add" << mod->fileinfo().fileName() << "to the jar.";
+					return false;
+				}
+				addedFiles.insert(filename.fileName());
+			}
+			else if (mod->type() == ResourceType::FOLDER)
+			{
+				// untested, but seems to be unused / not possible to reach
+				auto filename		= mod->fileinfo();
+				QString what_to_zip = filename.absoluteFilePath();
+				QDir dir(what_to_zip);
+				dir.cdUp();
+				QString parent_dir = dir.absolutePath();
+				auto files		   = QFileInfoList();
+				collectFileListRecursively(what_to_zip, nullptr, &files, nullptr);
+
+				// Remove files that have already been added to avoid duplicates
+				for (auto e : files)
+				{
+					if (addedFiles.contains(e.filePath()))
+						files.removeAll(e);
+				}
+
+				if (!compressDirFiles(&zipOut, parent_dir, files))
+				{
+					zipOut.close();
+					FS::deletePath(targetJarPath);
+					qCritical() << "Failed to add" << mod->fileinfo().fileName() << "to the jar.";
+					return false;
+				}
+				qDebug() << "Adding folder " << filename.fileName() << " from " << filename.absoluteFilePath();
+			}
+			else
+			{
+				// Make sure we do not continue launching when something is missing or undefined...
+				zipOut.close();
+				FS::deletePath(targetJarPath);
+				qCritical() << "Failed to add unknown mod type" << mod->fileinfo().fileName() << "to the jar.";
+				return false;
+			}
+		}
+
+		if (!mergeZipFiles(&zipOut,
+						   QFileInfo(sourceJarPath),
+						   addedFiles,
+						   [](const QString key) { return !key.contains("META-INF"); }))
+		{
+			zipOut.close();
+			FS::deletePath(targetJarPath);
+			qCritical() << "Failed to insert minecraft.jar contents.";
+			return false;
+		}
+
+		// Recompress the jar
+		zipOut.close();
+		if (zipOut.getZipError() != 0)
+		{
+			FS::deletePath(targetJarPath);
+			qCritical() << "Failed to finalize minecraft.jar!";
+			return false;
+		}
+		return true;
+	}
+#endif
+
+	// ours
+	QString findFolderOfFileInZip(QuaZip* zip,
+								  const QString& what,
+								  const QStringList& ignore_paths,
+								  const QString& root)
+	{
+		QuaZipDir rootDir(zip, root);
+		for (auto&& fileName : rootDir.entryList(QDir::Files))
+		{
+			if (fileName == what)
+				return root;
+
+			QCoreApplication::processEvents();
+		}
+
+		// Recurse the search to non-ignored subfolders
+		for (auto&& fileName : rootDir.entryList(QDir::Dirs))
+		{
+			if (ignore_paths.contains(fileName))
+				continue;
+
+			QString result = findFolderOfFileInZip(zip, what, ignore_paths, root + fileName);
+			if (!result.isEmpty())
+				return result;
+		}
+
+		return {};
+	}
+
+	// ours
+	bool findFilesInZip(QuaZip* zip, const QString& what, QStringList& result, const QString& root)
+	{
+		QuaZipDir rootDir(zip, root);
+		for (auto fileName : rootDir.entryList(QDir::Files))
+		{
+			if (fileName == what)
+			{
+				result.append(root);
+				return true;
+			}
+		}
+		for (auto fileName : rootDir.entryList(QDir::Dirs))
+		{
+			findFilesInZip(zip, what, result, root + fileName);
+		}
+		return !result.isEmpty();
+	}
+
+	// ours
+	std::optional<QStringList> extractSubDir(QuaZip* zip, const QString& subdir, const QString& target)
+	{
+		auto target_top_dir = QUrl::fromLocalFile(target);
+
+		QStringList extracted;
+
+		qDebug() << "Extracting subdir" << subdir << "from" << zip->getZipName() << "to" << target;
+		auto numEntries = zip->getEntriesCount();
+		if (numEntries < 0)
+		{
+			qWarning() << "Failed to enumerate files in archive";
+			return std::nullopt;
+		}
+		else if (numEntries == 0)
+		{
+			qDebug() << "Extracting empty archives seems odd...";
+			return extracted;
+		}
+		else if (!zip->goToFirstFile())
+		{
+			qWarning() << "Failed to seek to first file in zip";
+			return std::nullopt;
+		}
+
+		do
+		{
+			QString file_name = zip->getCurrentFileName();
+			file_name		  = FS::RemoveInvalidPathChars(file_name);
+			if (!file_name.startsWith(subdir))
+				continue;
+
+			auto relative_file_name = QDir::fromNativeSeparators(file_name.mid(subdir.size()));
+			auto original_name		= relative_file_name;
+
+			// Fix subdirs/files ending with a / getting transformed into absolute paths
+			if (relative_file_name.startsWith('/'))
+				relative_file_name = relative_file_name.mid(1);
+
+			// Fix weird "folders with a single file get squashed" thing
+			QString sub_path;
+			if (relative_file_name.contains('/') && !relative_file_name.endsWith('/'))
+			{
+				sub_path = relative_file_name.section('/', 0, -2) + '/';
+				FS::ensureFolderPathExists(FS::PathCombine(target, sub_path));
+
+				relative_file_name = relative_file_name.split('/').last();
+			}
+
+			QString target_file_path;
+			if (relative_file_name.isEmpty())
+			{
+				target_file_path = target + '/';
+			}
+			else
+			{
+				target_file_path = FS::PathCombine(target_top_dir.toLocalFile(), sub_path, relative_file_name);
+				if (relative_file_name.endsWith('/') && !target_file_path.endsWith('/'))
+					target_file_path += '/';
+			}
+
+			if (!target_top_dir.isParentOf(QUrl::fromLocalFile(target_file_path)))
+			{
+				qWarning() << "Extracting" << relative_file_name
+						   << "was cancelled, because it was effectively outside of the target path" << target;
+				return std::nullopt;
+			}
+
+			if (!JlCompress::extractFile(zip, "", target_file_path))
+			{
+				qWarning() << "Failed to extract file" << original_name << "to" << target_file_path;
+				JlCompress::removeFile(extracted);
+				return std::nullopt;
+			}
+
+			extracted.append(target_file_path);
+			auto fileInfo = QFileInfo(target_file_path);
+			if (fileInfo.isFile())
+			{
+				auto permissions   = fileInfo.permissions();
+				auto maxPermisions = QFileDevice::Permission::ReadUser | QFileDevice::Permission::WriteUser
+								   | QFileDevice::Permission::ExeUser | QFileDevice::Permission::ReadGroup
+								   | QFileDevice::Permission::ReadOther;
+				auto minPermisions = QFileDevice::Permission::ReadUser | QFileDevice::Permission::WriteUser;
+
+				auto newPermisions = (permissions & maxPermisions) | minPermisions;
+				if (newPermisions != permissions)
+				{
+					if (!QFile::setPermissions(target_file_path, newPermisions))
+					{
+						qWarning() << (QObject::tr("Could not fix permissions for %1").arg(target_file_path));
+					}
+				}
+			}
+			else if (fileInfo.isDir())
+			{
+				// Ensure the folder has the minimal required permissions
+				QFile::Permissions minimalPermissions = QFile::ReadOwner | QFile::WriteOwner | QFile::ExeOwner
+													  | QFile::ReadGroup | QFile::ExeGroup | QFile::ReadOther
+													  | QFile::ExeOther;
+
+				QFile::Permissions currentPermissions = fileInfo.permissions();
+				if ((currentPermissions & minimalPermissions) != minimalPermissions)
+				{
+					if (!QFile::setPermissions(target_file_path, minimalPermissions))
+					{
+						qWarning() << (QObject::tr("Could not fix permissions for %1").arg(target_file_path));
+					}
+				}
+			}
+			qDebug() << "Extracted file" << relative_file_name << "to" << target_file_path;
+		}
+		while (zip->goToNextFile());
+
+		return extracted;
+	}
+
+	// ours
+	bool extractRelFile(QuaZip* zip, const QString& file, const QString& target)
+	{
+		return JlCompress::extractFile(zip, file, target);
+	}
+
+	// ours
+	std::optional<QStringList> extractDir(QString fileCompressed, QString dir)
+	{
+		QuaZip zip(fileCompressed);
+		if (!zip.open(QuaZip::mdUnzip))
+		{
+			// check if this is a minimum size empty zip file...
+			QFileInfo fileInfo(fileCompressed);
+			if (fileInfo.size() == 22)
+			{
+				return QStringList();
+			}
+			qWarning() << "Could not open archive for unpacking:" << fileCompressed << "Error:" << zip.getZipError();
+			;
+			return std::nullopt;
+		}
+		return extractSubDir(&zip, "", dir);
+	}
+
+	// ours
+	std::optional<QStringList> extractDir(QString fileCompressed, QString subdir, QString dir)
+	{
+		QuaZip zip(fileCompressed);
+		if (!zip.open(QuaZip::mdUnzip))
+		{
+			// check if this is a minimum size empty zip file...
+			QFileInfo fileInfo(fileCompressed);
+			if (fileInfo.size() == 22)
+			{
+				return QStringList();
+			}
+			qWarning() << "Could not open archive for unpacking:" << fileCompressed << "Error:" << zip.getZipError();
+			;
+			return std::nullopt;
+		}
+		return extractSubDir(&zip, subdir, dir);
+	}
+
+	// ours
+	bool extractFile(QString fileCompressed, QString file, QString target)
+	{
+		QuaZip zip(fileCompressed);
+		if (!zip.open(QuaZip::mdUnzip))
+		{
+			// check if this is a minimum size empty zip file...
+			QFileInfo fileInfo(fileCompressed);
+			if (fileInfo.size() == 22)
+			{
+				return true;
+			}
+			qWarning() << "Could not open archive for unpacking:" << fileCompressed << "Error:" << zip.getZipError();
+			return false;
+		}
+		return extractRelFile(&zip, file, target);
+	}
+
+	bool collectFileListRecursively(const QString& rootDir,
+									const QString& subDir,
+									QFileInfoList* files,
+									FilterFileFunction excludeFilter)
+	{
+		QDir rootDirectory(rootDir);
+		if (!rootDirectory.exists())
+			return false;
+
+		QDir directory;
+		if (subDir == nullptr)
+			directory = rootDirectory;
+		else
+			directory = QDir(subDir);
+
+		if (!directory.exists())
+			return false; // shouldn't ever happen
+
+		// recurse directories
+		QFileInfoList entries = directory.entryInfoList(QDir::AllDirs | QDir::NoDotAndDotDot | QDir::Hidden);
+		for (const auto& e : entries)
+		{
+			if (!collectFileListRecursively(rootDir, e.filePath(), files, excludeFilter))
+				return false;
+		}
+
+		// collect files
+		entries = directory.entryInfoList(QDir::Files);
+		for (const auto& e : entries)
+		{
+			if (excludeFilter && excludeFilter(e))
+			{
+				QString relativeFilePath = rootDirectory.relativeFilePath(e.absoluteFilePath());
+				qDebug() << "Skipping file " << relativeFilePath;
+				continue;
+			}
+
+			files->append(e); // we want the original paths for compressDirFiles
+		}
+		return true;
+	}
+
+#if defined(LAUNCHER_APPLICATION)
+	void ExportToZipTask::executeTask()
+	{
+		setStatus("Adding files...");
+		setProgress(0, m_files.length());
+		m_build_zip_future = QtConcurrent::run(QThreadPool::globalInstance(), [this]() { return exportZip(); });
+		connect(&m_build_zip_watcher, &QFutureWatcher<ZipResult>::finished, this, &ExportToZipTask::finish);
+		m_build_zip_watcher.setFuture(m_build_zip_future);
+	}
+
+	auto ExportToZipTask::exportZip() -> ZipResult
+	{
+		if (!m_dir.exists())
+		{
+			return ZipResult(tr("Folder doesn't exist"));
+		}
+		if (!m_output.isOpen() && !m_output.open(QuaZip::mdCreate))
+		{
+			return ZipResult(tr("Could not create file"));
+		}
+
+		for (auto fileName : m_extra_files.keys())
+		{
+			if (m_build_zip_future.isCanceled())
+				return ZipResult();
+			QuaZipFile indexFile(&m_output);
+			if (!indexFile.open(QIODevice::WriteOnly, QuaZipNewInfo(fileName)))
+			{
+				return ZipResult(tr("Could not create:") + fileName);
+			}
+			indexFile.write(m_extra_files[fileName]);
+		}
+
+		for (const QFileInfo& file : m_files)
+		{
+			if (m_build_zip_future.isCanceled())
+				return ZipResult();
+
+			auto absolute = file.absoluteFilePath();
+			auto relative = m_dir.relativeFilePath(absolute);
+			setStatus("Compressing: " + relative);
+			setProgress(m_progress + 1, m_progressTotal);
+			if (m_follow_symlinks)
+			{
+				if (file.isSymLink())
+					absolute = file.symLinkTarget();
+				else
+					absolute = file.canonicalFilePath();
+			}
+
+			if (!m_exclude_files.contains(relative)
+				&& !JlCompress::compressFile(&m_output, absolute, m_destination_prefix + relative))
+			{
+				return ZipResult(tr("Could not read and compress %1").arg(relative));
+			}
+		}
+
+		m_output.close();
+		if (m_output.getZipError() != 0)
+		{
+			return ZipResult(tr("A zip error occurred"));
+		}
+		return ZipResult();
+	}
+
+	void ExportToZipTask::finish()
+	{
+		if (!isRunning())
+		{
+			FS::deletePath(m_output_path);
+			return;
+		}
+		if (m_build_zip_future.isCanceled())
+		{
+			FS::deletePath(m_output_path);
+			emitAborted();
+		}
+		else if (auto result = m_build_zip_future.result(); result.has_value())
+		{
+			FS::deletePath(m_output_path);
+			emitFailed(result.value());
+		}
+		else
+		{
+			emitSucceeded();
+		}
+	}
+
+	bool ExportToZipTask::abort()
+	{
+		if (m_build_zip_future.isRunning())
+		{
+			m_build_zip_future.cancel();
+			emitAborted();
+			return true;
+		}
+		return false;
+	}
+
+	void ExtractZipTask::executeTask()
+	{
+		if (!m_input->isOpen() && !m_input->open(QuaZip::mdUnzip))
+		{
+			emitFailed(tr("Unable to open supplied zip file."));
+			return;
+		}
+		m_zip_future = QtConcurrent::run(QThreadPool::globalInstance(), [this]() { return extractZip(); });
+		connect(&m_zip_watcher, &QFutureWatcher<ZipResult>::finished, this, &ExtractZipTask::finish);
+		m_zip_watcher.setFuture(m_zip_future);
+	}
+
+	auto ExtractZipTask::extractZip() -> ZipResult
+	{
+		auto target			= m_output_dir.absolutePath();
+		auto target_top_dir = QUrl::fromLocalFile(target);
+		QDir target_dir(target);
+
+		QStringList extracted;
+
+		qDebug() << "Extracting subdir" << m_subdirectory << "from" << m_input->getZipName() << "to" << target;
+		auto numEntries = m_input->getEntriesCount();
+		if (numEntries < 0)
+		{
+			return ZipResult(tr("Failed to enumerate files in archive"));
+		}
+		if (numEntries == 0)
+		{
+			logWarning(tr("Extracting empty archives seems odd..."));
+			return ZipResult();
+		}
+		if (!m_input->goToFirstFile())
+		{
+			return ZipResult(tr("Failed to seek to first file in zip"));
+		}
+
+		setStatus("Extracting files...");
+		setProgress(0, numEntries);
+		do
+		{
+			if (m_zip_future.isCanceled())
+				return ZipResult();
+			setProgress(m_progress + 1, m_progressTotal);
+			QString file_name = m_input->getCurrentFileName();
+			if (!file_name.startsWith(m_subdirectory))
+				continue;
+
+			auto relative_file_name = QDir::fromNativeSeparators(file_name.mid(m_subdirectory.size()));
+			auto original_name		= relative_file_name;
+			setStatus("Unpacking: " + relative_file_name);
+
+			// Fix subdirs/files ending with a / getting transformed into absolute paths
+			if (relative_file_name.startsWith('/'))
+				relative_file_name = relative_file_name.mid(1);
+
+			// Fix weird "folders with a single file get squashed" thing
+			QString sub_path;
+			if (relative_file_name.contains('/') && !relative_file_name.endsWith('/'))
+			{
+				sub_path = relative_file_name.section('/', 0, -2) + '/';
+				FS::ensureFolderPathExists(FS::PathCombine(target, sub_path));
+
+				relative_file_name = relative_file_name.split('/').last();
+			}
+
+			QString target_file_path;
+			if (relative_file_name.isEmpty())
+			{
+				target_file_path = target + '/';
+			}
+			else
+			{
+				target_file_path = FS::PathCombine(target_top_dir.toLocalFile(), sub_path, relative_file_name);
+				if (relative_file_name.endsWith('/') && !target_file_path.endsWith('/'))
+					target_file_path += '/';
+			}
+
+			if (!target_top_dir.isParentOf(QUrl::fromLocalFile(target_file_path)))
+			{
+				return ZipResult(
+					tr("Extracting %1 was cancelled, because it was effectively outside of the target path %2")
+						.arg(relative_file_name, target));
+			}
+			if (symlinkEscapesExtractionRoot(m_input.get(), target_file_path, target_dir))
+			{
+				return ZipResult(
+					tr("Extracting %1 was cancelled, because it links outside of the target path %2")
+						.arg(relative_file_name, target));
+			}
+
+			if (!JlCompress::extractFile(m_input.get(), "", target_file_path))
+			{
+				JlCompress::removeFile(extracted);
+				return ZipResult(tr("Failed to extract file %1 to %2").arg(original_name, target_file_path));
+			}
+
+			extracted.append(target_file_path);
+			auto fileInfo = QFileInfo(target_file_path);
+			if (fileInfo.isFile())
+			{
+				auto permissions   = fileInfo.permissions();
+				auto maxPermisions = QFileDevice::Permission::ReadUser | QFileDevice::Permission::WriteUser
+								   | QFileDevice::Permission::ExeUser | QFileDevice::Permission::ReadGroup
+								   | QFileDevice::Permission::ReadOther;
+				auto minPermisions = QFileDevice::Permission::ReadUser | QFileDevice::Permission::WriteUser;
+
+				auto newPermisions = (permissions & maxPermisions) | minPermisions;
+				if (newPermisions != permissions)
+				{
+					if (!QFile::setPermissions(target_file_path, newPermisions))
+					{
+						logWarning(tr("Could not fix permissions for %1").arg(target_file_path));
+					}
+				}
+			}
+			else if (fileInfo.isDir())
+			{
+				// Ensure the folder has the minimal required permissions
+				QFile::Permissions minimalPermissions = QFile::ReadOwner | QFile::WriteOwner | QFile::ExeOwner
+													  | QFile::ReadGroup | QFile::ExeGroup | QFile::ReadOther
+													  | QFile::ExeOther;
+
+				QFile::Permissions currentPermissions = fileInfo.permissions();
+				if ((currentPermissions & minimalPermissions) != minimalPermissions)
+				{
+					if (!QFile::setPermissions(target_file_path, minimalPermissions))
+					{
+						logWarning(tr("Could not fix permissions for %1").arg(target_file_path));
+					}
+				}
+			}
+
+			qDebug() << "Extracted file" << relative_file_name << "to" << target_file_path;
+		}
+		while (m_input->goToNextFile());
+
+		return ZipResult();
+	}
+
+	void ExtractZipTask::finish()
+	{
+		if (!isRunning())
+		{
+			return;
+		}
+		if (m_zip_future.isCanceled())
+		{
+			emitAborted();
+		}
+		else if (auto result = m_zip_future.result(); result.has_value())
+		{
+			emitFailed(result.value());
+		}
+		else
+		{
+			emitSucceeded();
+		}
+	}
+
+	bool ExtractZipTask::abort()
+	{
+		if (m_zip_future.isRunning())
+		{
+			m_zip_future.cancel();
+			emitAborted();
+			return true;
+		}
+		return false;
+	}
+
+#endif
+} // namespace MMCZip