mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-21 05:46:03 +00:00
Windows components: lay out installer .exe wrappers without running them (#480)
* Windows components: lay out installer .exe wrappers without running them
The components page could only take .msi packages apart; most catalog entries ship an
installer .exe, so VC++ runtimes, .NET Framework 4.0-4.8 and the .NET Core/5+ runtimes sat
under 'Need a Windows installer'. droiddeck-msi-install now opens those wrappers and lays
out the packages inside the same way:
- WiX bundles (Visual C++ 2012-2022, .NET Core/5+ desktop runtimes): the .wixburn section
names the containers, each a cabinet found by its header (signing moves them); payloads
get the names the bundle manifest lists, so each package finds its cab1.cab beside it.
ARM64 packages are skipped, x86 and x64 both laid out.
- Self-extracting cabinets (Visual C++ 2005-2010): cabextract, external cabinet beside the
package (vc_red.cab).
- Self-extracting 7-Zip archives (.NET Framework 4.0-4.8): 7-Zip, now bundled with the
msitools (Arch Linux ARM 7zip 26.04: 7z + its 7z.so plugin, licences beside the others).
The complete product (netfx_Full_*) wins over the 4.0 parts and the per-Windows copies.
- An .exe that is its own setup program (NSIS, InnoSetup) reports that it holds no package.
- --unpack opens an archive for the app: DirectX's redistributable for XACT's cabinet picks.
The app executes the remaining catalog steps offline: set_windows (HKCU\Software\Wine
Version), set_register_key, get_from_cab (through --unpack) and 'uninstall Wine Mono' (the
mscoree override beside it is what matters), and reads url/file_name the catalog nests under
'environment' on a few .NET entries. Setup-program installers stay in the waiting section
with a note that says what they are.
Verified on this branch's engine with msitools, cabextract and 7z: VC++ 2010 x64 (19 files,
61 values), VC++ 2022 x64 bundle (26 files, 66 values), .NET 4.0 (1053 files, 6056 values,
Framework64\v4.0.30319 with clr.dll and mscorlib.dll, NDP\v4 keys) and .NET 4.8 (1633
files, 522 GAC assemblies, 6495 values). Not yet run on a device.
* Windows components: the pressed row greys out and shows its own two-step progress bar
Pressing a switch now greys that row at once and runs a thin bar across it: the download
0..100, then the install 0..100, with a caption naming the file or the stage (a dependency's
name in front while that installs first). Turning a component off greys the row the same way
until the pick is saved. The page-wide bar at the bottom is gone; Done waits on the busy row.
droiddeck-msi-install reports how far along it is ('progress 37% placing files'): reading,
each cabinet, every 5% of files placed, the registry, done - and a wrapper maps each package
into its share, so a bundle's two packages run 10..55 and 55..100. The app parses the percent
and passes a typed Progress (component, stage, phase, percent) up to the editor.
* Windows components: the ones turned on sort to the top of the list
In 'All components' the picks for this game come first, in their usual alphabetical order
among themselves; turning one off returns it to its place. The row moves once the install has
finished and the pick is saved, not while its progress bar is running.
* Windows components: an 'Installed for this game' section under the recommendations
What is turned on for this game gets its own section between Recommended and All components,
alphabetical; the recommendations stay where they are (a recommended pick stays there). A
component in the section leaves All components, and goes back to its place when turned off.
LB/RB jump through the new section too.
This commit is contained in:
1 parent
e99d5f9505
commit
06e108a726
11 files changed
+803
-92
No files matched your search
@@ -1,7 +1,8 @@
|
||||
#!/usr/bin/python3
|
||||
"""Installs a Windows Installer package (.msi) the way Wine's own msiexec would, without running it.
|
||||
|
||||
droiddeck-msi-install <package.msi> <component dir>
|
||||
droiddeck-msi-install <package.msi | installer.exe> <component dir>
|
||||
droiddeck-msi-install --unpack <archive | installer.exe | cabinet> <dir>
|
||||
|
||||
A .msi is a database: which files go to which folder, which registry values to write, which .NET
|
||||
and side-by-side assemblies to register. This reads those tables (msiinfo), unpacks the package's
|
||||
@@ -11,15 +12,26 @@ for droiddeck-wincomponents, which puts it into a game's prefix at launch:
|
||||
<component dir>/drive_c/... the files, at the paths they get on 64-bit Windows
|
||||
<component dir>/registry.json the registry values, in the view (32/64-bit) Windows uses
|
||||
|
||||
An installer .exe is opened the same way when it is a wrapper around packages: a WiX bundle
|
||||
(Visual C++ 2012 and later, the .NET Core and 5+ runtimes: the packages sit in a cabinet the
|
||||
bundle's own header locates, named in its manifest), a self-extracting cabinet (Visual C++ 2005
|
||||
to 2010) or a self-extracting 7-Zip archive (.NET Framework 4.0 to 4.8). The packages inside are
|
||||
laid out one after the other into the same component dir; the 32- and 64-bit ones both, an ARM64
|
||||
one never. An .exe that is its own setup program (NSIS, InnoSetup) holds no package: an error says so.
|
||||
|
||||
What a package does by running its own code (custom actions such as DXSETUP, self-registering
|
||||
DLLs) cannot be done this way; each is named in the notes, so nothing is left out silently.
|
||||
|
||||
--unpack opens an archive or installer for the caller to take files out of (cabextract for a
|
||||
cabinet or self-extracting cabinet, 7-Zip for the rest) and prints the files it found.
|
||||
|
||||
Prints "progress <text>" lines while it works and ends with "result <json>": the counts and notes.
|
||||
"""
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import shutil
|
||||
import struct
|
||||
import subprocess
|
||||
import sys
|
||||
import tempfile
|
||||
@@ -28,6 +40,11 @@ from pathlib import Path
|
||||
TOOLS = Path(os.environ.get("DROIDDECK_MSITOOLS", "/usr/local/lib/droiddeck-msitools"))
|
||||
MSIINFO = os.environ.get("DROIDDECK_MSIINFO", str(TOOLS / "msiinfo"))
|
||||
CABEXTRACT = os.environ.get("DROIDDECK_CABEXTRACT", str(TOOLS / "cabextract"))
|
||||
SEVENZIP = os.environ.get("DROIDDECK_7Z", str(TOOLS / "7z"))
|
||||
MSI_MAGIC = b"\xd0\xcf\x11\xe0\xa1\xb1\x1a\xe1"
|
||||
BURN_MAGIC = 0x00F14300
|
||||
# A bundle's manifest names ARM64 packages too; a game's prefix wants the x86 and x64 ones.
|
||||
SKIP_PLATFORMS = ("arm64", "arm")
|
||||
|
||||
|
||||
def tool_env():
|
||||
@@ -89,8 +106,21 @@ class MsiError(Exception):
|
||||
pass
|
||||
|
||||
|
||||
def progress(text):
|
||||
print("progress " + text, flush=True)
|
||||
def progress(text, fraction=None):
|
||||
"""A progress line: "progress <text>", or "progress NN% <text>" when how far along is known."""
|
||||
if fraction is None:
|
||||
print("progress " + text, flush=True)
|
||||
else:
|
||||
print("progress %d%% %s" % (max(0, min(100, int(fraction * 100))), text), flush=True)
|
||||
|
||||
|
||||
class Span:
|
||||
"""The slice of the whole job one package's progress maps into (a wrapper runs several)."""
|
||||
def __init__(self, lo=0.0, hi=1.0):
|
||||
self.lo, self.hi = lo, hi
|
||||
|
||||
def report(self, fraction, text):
|
||||
progress(text, self.lo + (self.hi - self.lo) * max(0.0, min(1.0, fraction)))
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- reading the package
|
||||
@@ -339,9 +369,10 @@ def clr_version(path):
|
||||
|
||||
|
||||
class Installer:
|
||||
def __init__(self, msi, out, package=None):
|
||||
def __init__(self, msi, out, package=None, span=None):
|
||||
self.pkg = package or Package(msi)
|
||||
self.out = Path(out)
|
||||
self.span = span or Span()
|
||||
self.notes = []
|
||||
self.registry = []
|
||||
self.files = {} # File key -> rel path it was installed to
|
||||
@@ -539,23 +570,30 @@ class Installer:
|
||||
def unpack(self, work):
|
||||
"""Every cabinet in the package, unpacked; returns File key -> unpacked file."""
|
||||
found = {}
|
||||
for index, row in enumerate(self.pkg.table("Media")):
|
||||
media = [row for row in self.pkg.table("Media") if row.get("Cabinet", "")]
|
||||
for index, row in enumerate(media):
|
||||
cabinet = row.get("Cabinet", "")
|
||||
if not cabinet:
|
||||
continue
|
||||
if not cabinet.startswith("#"):
|
||||
self.notes.append("external cabinet %s is not part of the package; its files are missing" % cabinet)
|
||||
continue
|
||||
progress("unpacking %s" % cabinet[1:])
|
||||
cab = Path(work) / ("media%d.cab" % index)
|
||||
self.pkg.stream(cabinet[1:], cab)
|
||||
self.span.report(0.05 + 0.3 * index / max(1, len(media)), "unpacking %s" % cabinet.lstrip("#"))
|
||||
dest = Path(work) / ("media%d" % index)
|
||||
dest.mkdir()
|
||||
if cabinet.startswith("#"):
|
||||
cab = Path(work) / ("media%d.cab" % index)
|
||||
self.pkg.stream(cabinet[1:], cab)
|
||||
own = True
|
||||
else:
|
||||
# An external cabinet: a file beside the package, as an installer wrapper lays it out
|
||||
# (vc_red.cab beside vc_red.msi, netfx_Full.mzz beside netfx_Full_x64.msi).
|
||||
cab = sibling(Path(self.pkg.path), cabinet)
|
||||
if cab is None:
|
||||
self.notes.append("external cabinet %s is not part of the package; its files are missing" % cabinet)
|
||||
continue
|
||||
own = False
|
||||
result = subprocess.run([CABEXTRACT, "-q", "-d", str(dest), str(cab)], capture_output=True, timeout=1800,
|
||||
env=tool_env())
|
||||
if result.returncode != 0:
|
||||
raise MsiError("cabextract: %s" % result.stderr.decode("utf-8", "replace").strip()[:300])
|
||||
cab.unlink()
|
||||
if own:
|
||||
cab.unlink()
|
||||
for entry in dest.rglob("*"):
|
||||
if entry.is_file():
|
||||
found.setdefault(entry.relative_to(dest).as_posix(), entry)
|
||||
@@ -604,9 +642,13 @@ class Installer:
|
||||
if rel:
|
||||
self.files[key] = rel
|
||||
assembly_folders = set()
|
||||
for key, rel in destinations.items():
|
||||
if not rel:
|
||||
continue
|
||||
todo = [(key, rel) for key, rel in destinations.items() if rel]
|
||||
last = -1
|
||||
for done, (key, rel) in enumerate(todo):
|
||||
step = done * 20 // max(1, len(todo))
|
||||
if step != last:
|
||||
last = step
|
||||
self.span.report(0.35 + 0.55 * done / max(1, len(todo)), "placing files (%d of %d)" % (done, len(todo)))
|
||||
source = unpacked.get(key)
|
||||
if source is None:
|
||||
missing += 1
|
||||
@@ -728,13 +770,14 @@ class Installer:
|
||||
self.notes.append("%d %s" % (count, what))
|
||||
|
||||
def install(self):
|
||||
progress("reading %s" % (self.pkg.summary.get("subject") or Path(self.pkg.path).name))
|
||||
self.span.report(0.0, "reading %s" % (self.pkg.summary.get("subject") or Path(self.pkg.path).name))
|
||||
self.run_set_actions()
|
||||
self.select()
|
||||
with tempfile.TemporaryDirectory(dir=str(self.out.parent), prefix=".msi-") as work:
|
||||
unpacked = self.unpack(work)
|
||||
progress("placing files")
|
||||
self.span.report(0.35, "placing files")
|
||||
self.install_files(unpacked)
|
||||
self.span.report(0.9, "writing the registry values")
|
||||
self.install_registry()
|
||||
self.check()
|
||||
if not self.counts["files"] and not self.registry:
|
||||
@@ -748,18 +791,235 @@ class Installer:
|
||||
pass
|
||||
with open(self.out / "registry.json", "w", encoding="utf-8") as out:
|
||||
json.dump({"version": 1, "values": values + self.registry}, out, indent=1)
|
||||
self.span.report(1.0, "done")
|
||||
return {"product": self.props.get("ProductName", ""), "version": self.props.get("ProductVersion", ""),
|
||||
"counts": self.counts, "notes": self.notes}
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- installer wrappers
|
||||
|
||||
def sibling(path, name):
|
||||
"""A file next to [path] called [name], whatever its case; None when there is none."""
|
||||
folder = path.parent
|
||||
candidate = folder / name
|
||||
if candidate.is_file():
|
||||
return candidate
|
||||
lower = name.lower()
|
||||
for entry in folder.iterdir():
|
||||
if entry.is_file() and entry.name.lower() == lower:
|
||||
return entry
|
||||
return None
|
||||
|
||||
|
||||
def kind_of(path):
|
||||
"""What a file is by its first bytes: msi, exe, cab or other."""
|
||||
with open(path, "rb") as source:
|
||||
head = source.read(8)
|
||||
if head.startswith(MSI_MAGIC):
|
||||
return "msi"
|
||||
if head[:2] == b"MZ":
|
||||
return "exe"
|
||||
if head[:4] == b"MSCF":
|
||||
return "cab"
|
||||
return "other"
|
||||
|
||||
|
||||
def run_tool(args, timeout=1800):
|
||||
try:
|
||||
return subprocess.run(args, capture_output=True, timeout=timeout, env=tool_env())
|
||||
except OSError as error:
|
||||
raise MsiError("%s is not available (%s)" % (Path(args[0]).name, error))
|
||||
|
||||
|
||||
def burn_containers(data):
|
||||
"""A WiX bundle's containers as (offset, size) pairs: the .wixburn section of the stub names
|
||||
their sizes; each is a cabinet laid out after the stub, found by its header since signing can
|
||||
move them. None when the file is no bundle."""
|
||||
try:
|
||||
pe = struct.unpack_from("<I", data, 0x3C)[0]
|
||||
if data[pe:pe + 4] != b"PE\0\0":
|
||||
return None
|
||||
count, optional = struct.unpack_from("<H", data, pe + 6)[0], struct.unpack_from("<H", data, pe + 20)[0]
|
||||
table = pe + 24 + optional
|
||||
section = None
|
||||
for i in range(count):
|
||||
name, _, _, raw_size, raw_offset = struct.unpack_from("<8sIIII", data, table + 40 * i)
|
||||
if name.rstrip(b"\0") == b".wixburn":
|
||||
section = (raw_offset, raw_size)
|
||||
if section is None or section[1] < 52:
|
||||
return None
|
||||
offset = section[0]
|
||||
if struct.unpack_from("<I", data, offset)[0] != BURN_MAGIC:
|
||||
return None
|
||||
stub, _, _, _, _, containers = struct.unpack_from("<IIIIII", data, offset + 24)
|
||||
sizes = struct.unpack_from("<%dI" % containers, data, offset + 48)
|
||||
except (struct.error, IndexError):
|
||||
return None
|
||||
found = []
|
||||
position = stub
|
||||
for size in sizes:
|
||||
while True:
|
||||
start = data.find(b"MSCF", position)
|
||||
if start < 0 or start + 12 > len(data):
|
||||
return None
|
||||
if struct.unpack_from("<I", data, start + 8)[0] == size:
|
||||
break
|
||||
position = start + 4
|
||||
found.append((start, size))
|
||||
position = start + size
|
||||
return found
|
||||
|
||||
|
||||
def unpack_burn(path, dest, containers):
|
||||
"""Unpacks a bundle's containers into [dest] and gives the payloads the names its manifest
|
||||
lists (a9 -> packages/vcRuntimeMinimum_amd64/vc_runtimeMinimum_x64.msi)."""
|
||||
data = path.read_bytes()
|
||||
names = {}
|
||||
for index, (start, size) in enumerate(containers):
|
||||
progress("unpacking the bundle, part %d of %d" % (index + 1, len(containers)), 0.02 + 0.08 * index / max(1, len(containers)))
|
||||
cab = dest / ("container%d.cab" % index)
|
||||
cab.write_bytes(data[start:start + size])
|
||||
folder = dest / ("container%d" % index)
|
||||
folder.mkdir()
|
||||
result = run_tool([CABEXTRACT, "-q", "-d", str(folder), str(cab)])
|
||||
cab.unlink()
|
||||
if result.returncode != 0:
|
||||
raise MsiError("cabextract: %s" % result.stderr.decode("utf-8", "replace").strip()[:300])
|
||||
if index == 0:
|
||||
manifest = folder / "0"
|
||||
if manifest.is_file():
|
||||
text = manifest.read_text("utf-8", "replace")
|
||||
for file_path, source in re.findall(r'<Payload\b[^>]*?\bFilePath="([^"]+)"[^>]*?\bSourcePath="([^"]+)"', text):
|
||||
names[source] = file_path
|
||||
continue
|
||||
for entry in list(folder.iterdir()):
|
||||
wanted = names.get(entry.name)
|
||||
if not wanted:
|
||||
continue
|
||||
rel = Path(*[part for part in wanted.replace("\\", "/").split("/") if part not in ("", ".", "..")])
|
||||
target = folder / rel
|
||||
target.parent.mkdir(parents=True, exist_ok=True)
|
||||
entry.rename(target)
|
||||
|
||||
|
||||
def unpack_installer(path, dest):
|
||||
"""Opens an installer or archive into [dest]: a bundle by its header, a cabinet (or
|
||||
self-extracting one) with cabextract, anything else with 7-Zip."""
|
||||
kind = kind_of(path)
|
||||
if kind == "exe":
|
||||
containers = burn_containers(path.read_bytes())
|
||||
if containers:
|
||||
unpack_burn(path, dest, containers)
|
||||
return "bundle"
|
||||
if kind == "cab" or kind == "exe" and b"MSCF" in path.read_bytes():
|
||||
result = run_tool([CABEXTRACT, "-q", "-d", str(dest), str(path)])
|
||||
if result.returncode == 0 and any(dest.rglob("*")):
|
||||
return "cabinet"
|
||||
for stale in list(dest.iterdir()):
|
||||
shutil.rmtree(stale) if stale.is_dir() else stale.unlink()
|
||||
progress("unpacking %s" % path.name, 0.02)
|
||||
result = run_tool([SEVENZIP, "x", "-y", "-bd", "-bso0", "-bsp0", "-o" + str(dest), str(path)])
|
||||
if result.returncode not in (0, 1) or not any(dest.rglob("*")):
|
||||
raise MsiError("could not open %s: %s" % (path.name, (result.stderr or result.stdout).decode("utf-8", "replace").strip()[:200]
|
||||
or "nothing inside it can be unpacked"))
|
||||
return "archive"
|
||||
|
||||
|
||||
def packages_in(root):
|
||||
"""The Windows Installer packages an unpacked installer holds, shallowest first, by name."""
|
||||
found = []
|
||||
for entry in sorted(root.rglob("*")):
|
||||
if entry.is_file() and kind_of(entry) == "msi":
|
||||
found.append(entry)
|
||||
found.sort(key=lambda entry: (len(entry.relative_to(root).parts), entry.name.lower()))
|
||||
return found
|
||||
|
||||
|
||||
def choose_packages(found, root):
|
||||
"""Which packages make up the install: the ones at the top of the installer (a bundle keeps
|
||||
each in its own folder, so there every level counts), for the x86 and x64 platforms. The .NET
|
||||
Framework 4.5+ installers carry a complete product (netfx_Full_*) beside the 4.0 parts they
|
||||
patch (netfx_Core_*, netfx_Extended_*) and per-Windows-version copies in NetFx* folders: the
|
||||
complete product wins, the copies are left out."""
|
||||
if not found:
|
||||
return []
|
||||
depth = min(len(entry.relative_to(root).parts) for entry in found)
|
||||
bundle = (root / "container1").is_dir()
|
||||
top = [entry for entry in found if bundle or len(entry.relative_to(root).parts) == depth]
|
||||
names = [entry.name.lower() for entry in top]
|
||||
if any("full" in name for name in names) and any("_core" in name or "_extended" in name for name in names):
|
||||
top = [entry for entry in top if not ("_core" in entry.name.lower() or "_extended" in entry.name.lower())]
|
||||
chosen = []
|
||||
for entry in top:
|
||||
template = Package(entry).summary.get("template", "").split(";")[0].strip().lower()
|
||||
if template in SKIP_PLATFORMS:
|
||||
continue
|
||||
chosen.append(entry)
|
||||
return chosen
|
||||
|
||||
|
||||
def install_wrapper(path, out):
|
||||
"""Lays out every package inside an installer wrapper; the result is the sum of them."""
|
||||
total = {"product": "", "version": "", "counts": {"files": 0, "assemblies": 0, "registry": 0}, "notes": [], "packages": []}
|
||||
with tempfile.TemporaryDirectory(dir=str(out.parent), prefix=".unpack-") as work:
|
||||
dest = Path(work) / "x"
|
||||
dest.mkdir()
|
||||
how = unpack_installer(path, dest)
|
||||
packages = choose_packages(packages_in(dest), dest)
|
||||
if not packages:
|
||||
raise MsiError("%s holds no installer package: it is its own setup program, which cannot be run here" % path.name)
|
||||
for index, package in enumerate(packages):
|
||||
lo, hi = 0.1 + 0.9 * index / len(packages), 0.1 + 0.9 * (index + 1) / len(packages)
|
||||
progress("package %d of %d: %s" % (index + 1, len(packages), package.name), lo)
|
||||
try:
|
||||
result = Installer(str(package), out, span=Span(lo, hi)).install()
|
||||
except MsiError as error:
|
||||
# A package with nothing for this prefix (a patch for another Windows) is skipped,
|
||||
# unless it is the only one; anything else is the whole installer's failure.
|
||||
if "installs nothing" in str(error) and len(packages) > 1:
|
||||
total["notes"].append("%s: %s" % (package.name, error))
|
||||
continue
|
||||
raise
|
||||
total["packages"].append(package.name)
|
||||
if not total["product"]:
|
||||
total["product"], total["version"] = result["product"], result["version"]
|
||||
for key in total["counts"]:
|
||||
total["counts"][key] += result["counts"].get(key, 0)
|
||||
for note in result["notes"]:
|
||||
if note not in total["notes"]:
|
||||
total["notes"].append(note)
|
||||
total["how"] = how
|
||||
return total
|
||||
|
||||
|
||||
def unpack_only(path, dest):
|
||||
dest.mkdir(parents=True, exist_ok=True)
|
||||
how = unpack_installer(path, dest)
|
||||
files = sorted(str(entry.relative_to(dest)) for entry in dest.rglob("*") if entry.is_file())
|
||||
return {"how": how, "files": len(files), "names": files[:2000]}
|
||||
|
||||
|
||||
def main():
|
||||
if len(sys.argv) != 3:
|
||||
print("usage: droiddeck-msi-install <package.msi> <component dir>", file=sys.stderr)
|
||||
args = sys.argv[1:]
|
||||
if len(args) == 3 and args[0] == "--unpack":
|
||||
try:
|
||||
result = unpack_only(Path(args[1]), Path(args[2]))
|
||||
except MsiError as error:
|
||||
print("error " + str(error), flush=True)
|
||||
return 1
|
||||
print("result " + json.dumps(result), flush=True)
|
||||
return 0
|
||||
if len(args) != 2:
|
||||
print("usage: droiddeck-msi-install <package.msi | installer.exe> <component dir>\n"
|
||||
" droiddeck-msi-install --unpack <archive> <dir>", file=sys.stderr)
|
||||
return 2
|
||||
out = Path(sys.argv[2])
|
||||
source, out = Path(args[0]), Path(args[1])
|
||||
out.mkdir(parents=True, exist_ok=True)
|
||||
try:
|
||||
result = Installer(sys.argv[1], out).install()
|
||||
if kind_of(source) == "msi":
|
||||
result = Installer(str(source), out).install()
|
||||
else:
|
||||
result = install_wrapper(source, out)
|
||||
except MsiError as error:
|
||||
print("error " + str(error), flush=True)
|
||||
return 1
|
||||
|
||||
@@ -0,0 +1,151 @@
|
||||
7-Zip source code
|
||||
~~~~~~~~~~~~~~~~~
|
||||
License for use and distribution
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
7-Zip Copyright (C) 1999-2026 Igor Pavlov.
|
||||
|
||||
The licenses for files are:
|
||||
|
||||
- CPP/7zip/Compress/Rar* files: the "GNU LGPL" with "unRAR license restriction"
|
||||
- CPP/7zip/Compress/LzfseDecoder.cpp: the "BSD 3-clause License"
|
||||
- C/ZstdDec.c: the "BSD 3-clause License"
|
||||
- C/Xxh64.c: the "BSD 2-clause License"
|
||||
- Some files are "public domain" files, if "public domain" status is stated in source file.
|
||||
- the "GNU LGPL" for all other files. If there is no license information in
|
||||
some source file, that file is under the "GNU LGPL".
|
||||
|
||||
The "GNU LGPL" with "unRAR license restriction" means that you must follow both
|
||||
"GNU LGPL" rules and "unRAR license restriction" rules.
|
||||
|
||||
|
||||
|
||||
|
||||
GNU LGPL information
|
||||
--------------------
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library 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
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not,
|
||||
you can get a copy of the GNU Lesser General Public License from
|
||||
http://www.gnu.org/
|
||||
|
||||
|
||||
|
||||
|
||||
BSD 3-clause License in 7-Zip code
|
||||
----------------------------------
|
||||
|
||||
The "BSD 3-clause License" is used for the following code in 7z.dll
|
||||
1) LZFSE data decompression.
|
||||
CPP/7zip/Compress/LzfseDecoder.cpp.
|
||||
That code was derived from the code in the "LZFSE compression library" developed by Apple Inc,
|
||||
that also uses the "BSD 3-clause License".
|
||||
2) ZSTD data decompression.
|
||||
C/ZstdDec.c
|
||||
that code was developed using original zstd decoder code as reference code.
|
||||
The original zstd decoder code was developed by Facebook Inc,
|
||||
that also uses the "BSD 3-clause License".
|
||||
|
||||
Copyright (c) 2015-2016, Apple Inc. All rights reserved.
|
||||
Copyright (c) Facebook, Inc. All rights reserved.
|
||||
Copyright (c) 2023-2026 Igor Pavlov.
|
||||
|
||||
Text of the "BSD 3-clause License"
|
||||
----------------------------------
|
||||
|
||||
Redistribution and use in source and binary forms, with or without modification,
|
||||
are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice, this
|
||||
list of conditions and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the copyright holder nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
||||
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
|
||||
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
|
||||
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
---
|
||||
|
||||
|
||||
|
||||
|
||||
BSD 2-clause License in 7-Zip code
|
||||
----------------------------------
|
||||
|
||||
The "BSD 2-clause License" is used for the XXH64 code in 7-Zip.
|
||||
C/Xxh64.c
|
||||
|
||||
XXH64 code in 7-Zip was derived from the original XXH64 code developed by Yann Collet.
|
||||
|
||||
Copyright (c) 2012-2021 Yann Collet.
|
||||
Copyright (c) 2023-2026 Igor Pavlov.
|
||||
|
||||
Text of the "BSD 2-clause License"
|
||||
----------------------------------
|
||||
|
||||
Redistribution and use in source and binary forms, with or without modification,
|
||||
are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice, this
|
||||
list of conditions and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
||||
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
|
||||
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
|
||||
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
---
|
||||
|
||||
|
||||
|
||||
|
||||
unRAR license restriction
|
||||
-------------------------
|
||||
|
||||
The decompression engine for RAR archives was developed using source
|
||||
code of unRAR program.
|
||||
All copyrights to original unRAR code are owned by Alexander Roshal.
|
||||
|
||||
The license for original unRAR code has the following restriction:
|
||||
|
||||
The unRAR sources cannot be used to re-create the RAR compression algorithm,
|
||||
which is proprietary. Distribution of modified unRAR sources in separate form
|
||||
or as a part of other software is permitted, provided that it is clearly
|
||||
stated in the documentation and source comments that the code may
|
||||
not be used to develop a RAR (WinRAR) compatible archiver.
|
||||
|
||||
--
|
||||
@@ -0,0 +1,41 @@
|
||||
****** ***** ****** unRAR - free utility for RAR archives
|
||||
** ** ** ** ** ** ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
****** ******* ****** License for use and distribution of
|
||||
** ** ** ** ** ** ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
** ** ** ** ** ** FREE portable version
|
||||
~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
The source code of unRAR utility is freeware. This means:
|
||||
|
||||
1. All copyrights to RAR and the utility unRAR are exclusively
|
||||
owned by the author - Alexander Roshal.
|
||||
|
||||
2. The unRAR sources may be used in any software to handle RAR
|
||||
archives without limitations free of charge, but cannot be used
|
||||
to re-create the RAR compression algorithm, which is proprietary.
|
||||
Distribution of modified unRAR sources in separate form or as a
|
||||
part of other software is permitted, provided that it is clearly
|
||||
stated in the documentation and source comments that the code may
|
||||
not be used to develop a RAR (WinRAR) compatible archiver.
|
||||
|
||||
3. The unRAR utility may be freely distributed. No person or company
|
||||
may charge a fee for the distribution of unRAR without written
|
||||
permission from the copyright holder.
|
||||
|
||||
4. THE RAR ARCHIVER AND THE UNRAR UTILITY ARE DISTRIBUTED "AS IS".
|
||||
NO WARRANTY OF ANY KIND IS EXPRESSED OR IMPLIED. YOU USE AT
|
||||
YOUR OWN RISK. THE AUTHOR WILL NOT BE LIABLE FOR DATA LOSS,
|
||||
DAMAGES, LOSS OF PROFITS OR ANY OTHER KIND OF LOSS WHILE USING
|
||||
OR MISUSING THIS SOFTWARE.
|
||||
|
||||
5. Installing and using the unRAR utility signifies acceptance of
|
||||
these terms and conditions of the license.
|
||||
|
||||
6. If you don't agree with terms of the license you must remove
|
||||
unRAR files from your storage devices and cease to use the
|
||||
utility.
|
||||
|
||||
Thank you for your interest in RAR and unRAR.
|
||||
|
||||
|
||||
Alexander L. Roshal
|
||||
@@ -9,6 +9,9 @@ builds, unchanged:
|
||||
https://gitlab.gnome.org/GNOME/gcab
|
||||
cabextract cabextract 1.11 GPL-3.0-or-later
|
||||
https://www.cabextract.org.uk/
|
||||
7z, 7z.so 7-Zip 26.04 LGPL-2.1-or-later, with the unRAR restriction
|
||||
(7zip-License, 7zip-unRarLicense); https://7-zip.org/
|
||||
|
||||
The packages and their sources: https://github.com/Droid-Deck/DroidDeck/releases/tag/msitools-0.106-r1,
|
||||
The packages and their sources: https://github.com/Droid-Deck/DroidDeck/releases/tag/msitools-0.106-r1
|
||||
(7-Zip from Arch Linux ARM's mirror, see tools/msitools/packages.txt),
|
||||
https://github.com/archlinuxarm/PKGBUILDs. The licence texts are beside this file.
|
||||
@@ -1,6 +1,7 @@
|
||||
# What droiddeck-msi-install runs: msitools' msiinfo reads a Windows Installer package's tables
|
||||
# and streams, cabextract unpacks its cabinets (every compression a cabinet can use, which gcab
|
||||
# alone cannot). Arch Linux ARM's aarch64 packages, hosted unchanged on this repo's
|
||||
# alone cannot), 7-Zip (7z + its 7z.so format plugin) opens the installer .exe wrappers around
|
||||
# packages (self-extracting 7-Zip and cabinet files, WiX bundles). Arch Linux ARM's aarch64 packages, hosted unchanged on this repo's
|
||||
# msitools-0.106-r1 release because the mirror keeps only the newest of each. CI fetches each,
|
||||
# checks the sha256 and stages the files below into the apk under usr/local/lib/droiddeck-msitools;
|
||||
# SessionFiles copies them into the runtime at every launch. Everything else they need (glib, gio,
|
||||
@@ -10,3 +11,4 @@
|
||||
4028f44d83b2956ba2931d32aee8cceecbd6481e2febf86a3b6bfed69ef403d5 https://github.com/Droid-Deck/DroidDeck/releases/download/msitools-0.106-r1/libgsf-1.14.60-1-aarch64.pkg.tar.xz
|
||||
3d7bd103313cb36d6cb703a5e583363e56ff255f105bcc0727916d195967976d https://github.com/Droid-Deck/DroidDeck/releases/download/msitools-0.106-r1/gcab-1.6-2-aarch64.pkg.tar.xz
|
||||
87fe375a22de1519982234ce99f909ae13c06500784baaa1e8d7a0c0be0d14ee https://github.com/Droid-Deck/DroidDeck/releases/download/msitools-0.106-r1/cabextract-1.11-3-aarch64.pkg.tar.xz
|
||||
e3bc83ac5960a4363f7ce05eb1d50b03d60d627a4a29f9b02c8e0466a5381b1f http://mirror.archlinuxarm.org/aarch64/extra/7zip-26.04-1-aarch64.pkg.tar.xz
|
||||
Reference in new issue
Block a user