#!/usr/bin/python3
# Centre KemmOS 1.16.0 — « Préparer une clé USB KemmOS » : écrit une ISO KemmOS sur une clé USB. Lancé par pkexec :
#   ecrire-cle <fichier.iso> <sha256 attendu> </dev/sdX>
# Refuse tout ce qui n'est pas une clé USB (disque entier, branché en USB, amovible) ou qui porte le système.
# Sortie ligne par ligne pour l'appli : « ECRITURE <octets> <total> », « VERIFICATION <octets> <total> »,
# « TERMINE » ; en cas d'échec, la dernière ligne explique pourquoi.
# Vérification : l'ISO est d'abord comparée à la somme attendue (déjà vérifiée par l'appli, mais le fichier a pu
# changer entre-temps), puis la clé est relue et comparée à la même somme.
# Code 0 = clé prête, 1 = échec, 2 = usage.
import hashlib
import json
import os
import re
import subprocess
import sys

BLOC = 4 * 1024 * 1024


def echec(texte):
    print(texte, flush=True)
    sys.exit(1)


def disque(chemin):
    """Description lsblk du disque entier chemin, avec ses partitions (children)."""
    r = subprocess.run(["lsblk", "-J", "-b", "-o", "PATH,TYPE,TRAN,RM,HOTPLUG,SIZE,MOUNTPOINTS,PKNAME", chemin],
                       capture_output=True, text=True)
    if r.returncode != 0:
        echec(f"périphérique inconnu : {chemin}")
    return json.loads(r.stdout)["blockdevices"][0]


def points_de_montage(d):
    pts = [m for m in d.get("mountpoints") or [] if m]
    for c in d.get("children") or []:
        pts += points_de_montage(c)
    return pts


def main():
    if os.geteuid() != 0:
        echec("droits administrateur nécessaires")
    if len(sys.argv) != 4 or not re.fullmatch(r"[0-9a-f]{64}", sys.argv[2]) \
            or not re.fullmatch(r"/dev/sd[a-z]+", sys.argv[3]):
        print("usage : ecrire-cle <fichier.iso> <sha256> </dev/sdX>", file=sys.stderr)
        sys.exit(2)
    iso, attendu, dev = sys.argv[1:]
    if not os.path.isfile(iso):
        echec(f"fichier introuvable : {iso}")
    taille = os.path.getsize(iso)

    d = disque(dev)
    if d.get("type") != "disk":
        echec("ce n'est pas un disque entier")
    if d.get("tran") != "usb" or not (d.get("rm") or d.get("hotplug")):
        echec("ce n'est pas une clé USB : rien n'a été écrit")
    if int(d.get("size") or 0) < taille:
        echec("la clé est trop petite pour KemmOS")
    systeme = {"/", "/boot", "/boot/efi", "/home", "/var", "/usr", "/.snapshots", "[SWAP]"}
    pts = points_de_montage(d)
    if systeme & set(pts):
        echec("cette clé porte une partie du système : rien n'a été écrit")
    for p in sorted(pts, key=len, reverse=True):
        r = subprocess.run(["umount", p], capture_output=True, text=True)
        if r.returncode != 0:
            echec(f"la clé est utilisée (fermez les fichiers ouverts dessus) : {p}")

    # ISO relue et comparée à la somme attendue, puis écrite (même passe pour l'écriture : ce qui est écrit est
    # exactement ce qui a été vérifié)
    h = hashlib.sha256()
    with open(iso, "rb") as f:
        while b := f.read(BLOC):
            h.update(b)
    if h.hexdigest() != attendu:
        echec("le fichier ISO a changé depuis sa vérification : rien n'a été écrit")

    fait = 0
    h = hashlib.sha256()
    with open(iso, "rb") as src, open(dev, "r+b", buffering=0) as dst:
        while b := src.read(BLOC):
            dst.write(b)
            h.update(b)
            fait += len(b)
            print(f"ECRITURE {fait} {taille}", flush=True)
        os.fsync(dst.fileno())
    if h.hexdigest() != attendu:
        echec("le fichier ISO a changé pendant l'écriture : recommencez")
    subprocess.run(["blockdev", "--flushbufs", dev], capture_output=True)

    # relecture : pages du cache vidées (sinon on relirait la mémoire au lieu de la clé)
    with open("/proc/sys/vm/drop_caches", "w") as f:
        f.write("1\n")
    fait = 0
    h = hashlib.sha256()
    with open(dev, "rb", buffering=0) as f:
        while fait < taille:
            b = f.read(min(BLOC, taille - fait))
            if not b:
                break
            h.update(b)
            fait += len(b)
            print(f"VERIFICATION {fait} {taille}", flush=True)
    if h.hexdigest() != attendu:
        echec("la clé relue ne correspond pas à l'ISO : clé défectueuse ? Essayez-en une autre")
    # partitions de l'ISO visibles tout de suite par le système (sinon au prochain branchement)
    subprocess.run(["partprobe", dev], capture_output=True)
    print("TERMINE", flush=True)
    return 0


if __name__ == "__main__":
    sys.exit(main())
