#!/usr/bin/python3
"""Build a reproducible newc initramfs without root, cpio, dracut or modprobe."""

import argparse
import ctypes
import errno
import gzip
from graphlib import CycleError, TopologicalSorter
import lzma
import os
from pathlib import Path, PurePosixPath
import platform
import stat
import subprocess
import sys
import tempfile

DEFAULT_INIT = '/usr/libexec/autoinit'
DEFAULT_CONFIG = "/usr/lib/composefs/setup-root-conf.toml"


class OpenHow(ctypes.Structure):
    _fields_ = [(name, ctypes.c_uint64) for name in ("flags", "mode", "resolve")]


class SourceRoot:
    """Read and run within an image root, or the real root when omitted."""

    def __init__(self, root=None):
        # Both RPM architectures use syscall 437; Python/glibc have no wrapper.
        if sys.platform != "linux" or platform.machine() not in ("x86_64", "aarch64"):
            raise OSError(
                errno.ENOSYS, "openat2 binding requires Linux x86_64 or aarch64"
            )
        self.root = Path(root).resolve(strict=True) if root is not None else Path("/")
        self.cwd = Path("/") if root is not None else Path.cwd()
        self._syscall = ctypes.CDLL(None, use_errno=True).syscall
        self._syscall.restype = ctypes.c_long
        self._fd = os.open(self.root, os.O_PATH | os.O_DIRECTORY | os.O_CLOEXEC)

    def __enter__(self):
        return self

    def __exit__(self, *args):
        self.close()

    def close(self):
        if self._fd is not None:
            os.close(self._fd)
            self._fd = None

    def _open_fd(self, name, flags):
        if self._fd is None:
            raise ValueError("source root is closed")
        path = os.fsencode(self.cwd / name)
        if b"\0" in path:
            raise ValueError("embedded null byte")
        # RESOLVE_IN_ROOT | RESOLVE_NO_MAGICLINKS: follow ordinary symlinks,
        # interpreting absolute targets and .. relative to the root descriptor.
        how = OpenHow(flags=flags | os.O_CLOEXEC, resolve=0x10 | 0x02)
        while True:
            fd = self._syscall(
                ctypes.c_long(437),
                ctypes.c_int(self._fd),
                ctypes.c_char_p(path),
                ctypes.byref(how),
                ctypes.c_size_t(ctypes.sizeof(how)),
            )
            if fd >= 0:
                return fd
            error = ctypes.get_errno()
            if error != errno.EINTR:
                raise OSError(error, os.strerror(error), os.fspath(name))

    def open(self, name, mode="rb"):
        if mode not in ("r", "rb"):
            raise ValueError("source files are read-only")
        return os.fdopen(self._open_fd(name, os.O_RDONLY), mode)

    def read_bytes(self, name):
        with self.open(name) as file:
            return file.read()

    def read_text(self, name):
        with self.open(name, "r") as file:
            return file.read()

    def files(self, directory):
        """Enumerate regular files without recursing through directory symlinks."""
        yield from sorted(self._files(Path(directory)))

    def _files(self, directory):
        fd = self._open_fd(directory, os.O_RDONLY | os.O_DIRECTORY)
        try:
            with os.scandir(fd) as entries:
                for entry in entries:
                    path = directory / entry.name
                    if entry.is_dir(follow_symlinks=False):
                        yield from self._files(path)
                    else:
                        child = self._open_fd(path, os.O_PATH)
                        try:
                            if stat.S_ISREG(os.fstat(child).st_mode):
                                yield path
                        finally:
                            os.close(child)
        finally:
            os.close(fd)

    def run(self, command, **kwargs):
        """Run in the source root, mapping an unprivileged caller to root if needed."""
        if self._fd is None:
            raise ValueError("source root is closed")
        if self.root == Path("/"):
            kwargs.setdefault("cwd", self.cwd)
        else:
            # Anchor chroot to the same opened directory used for file access.
            command = ["chroot", f"/proc/self/fd/{self._fd}", *command]
            if os.geteuid() != 0:
                command = ["unshare", "--user", "--map-root-user", *command]
            kwargs["pass_fds"] = (*kwargs.get("pass_fds", ()), self._fd)
        return subprocess.run(command, **kwargs)


def module_name(path):
    return Path(path).name.split(".ko", 1)[0].replace("-", "_")


def decompress(path, source):
    """Decode according to the module path, even if its symlink target differs."""
    with source.open(path) as file:
        if path.suffix == ".xz":
            return lzma.decompress(file.read())
        if path.suffix == ".gz":
            return gzip.decompress(file.read())
        if path.suffix == ".zst":
            return subprocess.check_output(["zstd", "-q", "-d", "-c"], stdin=file)
        return file.read()


class Modules:
    def __init__(self, directory, source=None):
        self.directory = directory
        self.paths = {}
        self.dependencies = {}
        if source is None:
            with SourceRoot() as source:
                self._load(source)
        else:
            self._load(source)

    def _load(self, source):
        directory = self.directory
        dependencies = source.read_text(directory / "modules.dep")
        for line in dependencies.splitlines():
            path, deps = line.split(":", 1)
            name = module_name(path)
            if name in self.paths:
                raise ValueError(f"ambiguous module name: {name}")
            self.paths[name] = path
            self.dependencies[name] = [module_name(d) for d in deps.split()]

        builtins = source.read_text(directory / "modules.builtin")
        self.builtin = {module_name(p) for p in builtins.splitlines()}

        self.soft = {}
        try:
            softdeps = source.read_text(directory / "modules.softdep")
        except FileNotFoundError:
            softdeps = ""

        for line in softdeps.splitlines():
            words = line.split()
            if not words or words[0] != "softdep":
                continue

            pre, post, current = [], [], None
            for word in words[2:]:
                if word == "pre:":
                    current = pre
                elif word == "post:":
                    current = post
                elif current is not None:
                    current.append(word.replace("-", "_"))

            self.soft[words[1].replace("-", "_")] = (pre, post)

    def plan(self, requested):
        """Select modules and retain hard and soft load-order constraints."""
        selected = {}

        def visit(name, required=True):
            name = name.replace("-", "_")
            if name in selected or name in self.builtin:
                return

            if name not in self.paths:
                if required:
                    raise ValueError(
                        f"module dependency {name} missing from {self.directory}"
                    )

                print(
                    f"mkautoinitrd: warning: module {name} missing from {self.directory}; skipping",
                    file=sys.stderr,
                )
                return

            selected[name] = None
            pre, post = self.soft.get(name, ([], []))
            for dependency in pre:
                visit(dependency, required=False)

            for dependency in self.dependencies[name]:
                visit(dependency)

            for dependency in post:
                visit(dependency, required=False)

        for name in requested:
            visit(name, required=False)

        dependencies = {}
        for name in selected:
            pre, _ = self.soft.get(name, ([], []))
            dependencies[name] = dict.fromkeys(
                dep for dep in [*pre, *self.dependencies[name]] if dep in selected
            )
        for name in selected:
            _, post = self.soft.get(name, ([], []))
            for dep in post:
                if dep in dependencies:
                    dependencies[dep][name] = None

        # Keep the manifest topologically ordered for simple serial consumers,
        # while the runtime uses the explicit edges to schedule parallel loads.
        try:
            order = list(TopologicalSorter(dependencies).static_order())
        except CycleError as error:
            raise ValueError(f"module dependency cycle: {error.args[1]}") from error
        return {name: list(dependencies[name]) for name in order}

    def target(self, name):
        # Preserve the kernel's paths and filenames, removing only compression.
        path = Path(self.paths[name])
        if path.suffix in (".gz", ".xz", ".zst"):
            path = path.with_suffix("")
        return f"usr/lib/modules/{self.directory.name}/{path}"


def safe_path(name):
    path = PurePosixPath(name)
    if path.is_absolute() or ".." in path.parts or not path.parts:
        raise ValueError(f"invalid archive path: {name}")
    return str(path)


class Archive:
    def __init__(self):
        self.entries = {}

    def add(self, name, data=b"", mode=stat.S_IFREG | 0o644, major=0, minor=0):
        name = safe_path(name)
        for parent in reversed(PurePosixPath(name).parents):
            if str(parent) != ".":
                self.entries.setdefault(str(parent), (b"", stat.S_IFDIR | 0o755, 0, 0))

        self.entries[name] = (data, mode, major, minor)

    def add_file(self, source, path):
        # Materialize symlinks at their runtime path, without the source root.
        with source.open(path) as file:
            self.add(
                str(path).lstrip("/"),
                file.read(),
                stat.S_IFREG | stat.S_IMODE(os.fstat(file.fileno()).st_mode),
            )

    def write(self, output):
        for inode, (name, (data, mode, major, minor)) in enumerate(
            sorted(self.entries.items()) + [("TRAILER!!!", (b"", 0, 0, 0))], 1
        ):
            encoded = name.encode() + b"\0"
            fields = (
                inode,
                mode,
                0,
                0,
                1,
                0,
                len(data),
                0,
                0,
                major,
                minor,
                len(encoded),
                0,
            )
            header = b"070701" + b"".join(f"{n:08x}".encode() for n in fields)

            output.write(header + encoded)
            output.write(b"\0" * (-(len(header) + len(encoded)) % 4))

            output.write(data)
            output.write(b"\0" * (-len(data) % 4))


def include_binary(archive, path, source):
    """Resolve libraries inside the image; only ldd runs in the chroot."""
    env = {k: v for k, v in os.environ.items() if not k.startswith("LD_")}
    env["LC_ALL"] = "C"
    result = source.run(
        ["/usr/bin/ldd", path],
        stdout=subprocess.PIPE,
        stderr=subprocess.STDOUT,
        text=True,
        env=env,
    )
    if "=> not found" in result.stdout:
        raise ValueError(f"missing dependencies for {path}:\n{result.stdout}")
    if result.returncode and result.stdout.strip() not in (
        "not a dynamic executable",
        "statically linked",
    ):
        raise ValueError(f"library lookup failed for {path}:\n{result.stdout}")

    archive.add_file(source, path)
    for line in result.stdout.splitlines():
        dependency = line.split("=>", 1)[-1].rsplit(" (", 1)[0].strip()
        if dependency.startswith("/"):
            archive.add_file(source, dependency)


def build(args):
    with SourceRoot(args.root) as source:
        _build(args, source)


def _build(args, source):
    modules = Modules(args.modules_directory, source)
    plan = modules.plan(args.module)

    archive = Archive()
    init = args.init
    if init is None:
        init = Path(DEFAULT_INIT + ("-nmstate" if args.nmstate_file else ""))

    archive.add("init", init.read_bytes(), stat.S_IFREG | 0o755)
    # composefs mount compatibility before Linux 6.15 uses /tmp for TempDir.
    for path in ["sysroot", "proc", "sys", "dev", "run", "tmp"]:
        archive.add(path, mode=stat.S_IFDIR | (0o1777 if path == "tmp" else 0o755))
    archive.add("dev/console", mode=stat.S_IFCHR | 0o600, major=5, minor=1)

    manifest = []
    for name, dependencies in plan.items():
        module = args.modules_directory / modules.paths[name]
        target = modules.target(name)

        archive.add(target, decompress(module, source))
        prerequisites = " ".join("/" + modules.target(dep) for dep in dependencies)
        manifest.append(f"/{target}: {prerequisites}".rstrip())

    archive.add("etc/autoinit.modules", ("\n".join(manifest) + "\n").encode())
    config = args.config or Path(DEFAULT_CONFIG)
    try:
        config_data = source.read_bytes(config)
    except FileNotFoundError:
        if args.config is not None:
            raise
    else:
        archive.add("usr/lib/composefs/setup-root-conf.toml", config_data)

    if args.nmstate_file:
        archive.add("etc/autoinit.nmstate", source.read_bytes(args.nmstate_file))

    if args.repart:
        definitions = Path("/usr/lib/repart.d")
        files = list(source.files(definitions))
        if not any(
            path.parent == definitions and path.suffix == ".conf" for path in files
        ):
            raise ValueError(f"no repart definitions in {definitions}")

        include_binary(archive, "/usr/bin/systemd-repart", source)
        for path in files:
            archive.add_file(source, path)

        archive.add("etc/autoinit.repart")

    if args.growfs:
        archive.add("etc/autoinit.growfs")

    args.output.parent.mkdir(parents=True, exist_ok=True)
    with tempfile.NamedTemporaryFile(dir=args.output.parent, delete=False) as out:
        temporary = Path(out.name)
        try:
            if args.compress == "gzip":
                with gzip.GzipFile(
                    filename="", fileobj=out, mode="wb", mtime=0
                ) as compressed:
                    archive.write(compressed)
            else:
                archive.write(out)

            out.flush()
            os.chmod(temporary, 0o644)
            os.replace(temporary, args.output)
        finally:
            temporary.unlink(missing_ok=True)

    print(f"{args.output}: {args.output.stat().st_size:,} bytes, {len(plan)} modules")


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument(
        "--root",
        type=Path,
        help="read modules, configuration and repart files relative to this image root",
    )
    parser.add_argument(
        "--module",
        action="append",
        default=[],
        help="module to preload, with dependencies (repeatable; no modules by default)",
    )

    parser.add_argument(
        "--config",
        type=Path,
        help=f"target's setup-root configuration (default: {DEFAULT_CONFIG} if present)",
    )
    parser.add_argument("--compress", choices=["gzip", "none"], default="gzip")

    parser.add_argument(
        "--nmstate-file",
        type=Path,
        help="select the nmstate init and apply this configuration after loading modules",
    )
    parser.add_argument(
        "--repart",
        action="store_true",
        help="run systemd-repart with /usr/lib/repart.d and grow ext4 if root grows",
    )
    parser.add_argument(
        "--growfs",
        action="store_true",
        help="grow ext4 to the current root device size on every boot",
    )

    parser.add_argument(
        "--init",
        type=Path,
        help=f"host init binary, unaffected by --root (default: {DEFAULT_INIT}, or its -nmstate variant)",
    )
    parser.add_argument("modules_directory", type=Path)
    parser.add_argument("output", type=Path)
    args = parser.parse_args()

    try:
        build(args)
    except (OSError, ValueError, subprocess.CalledProcessError) as error:
        parser.exit(1, f"mkautoinitrd: {error}\n")


if __name__ == "__main__":
    main()
