#!/usr/bin/python3 -IS
# OTScan 3 – Netzwerk-Helfer für das Umstellen des Scan-Adapters (Linux).
# Wird über sudo aufgerufen (Regel in /etc/sudoers.d/otscan3) und führt NUR die Befehle aus, die OTScan 3 braucht:
# ip, arping, nmcli, dhclient, dhcpcd, networkctl – jeweils mit fest geprüften Argumenten. Alles andere wird abgelehnt.
# Installiert von install_linux.sh nach /usr/local/lib/otscan3/otsp-netz (root, 0755).
#
# ot32o (12.11.2026):
#   - Nur Adapter aus der root-eigenen Liste /etc/otscan3/adapter (vom Installer abgefragt) und deren
#     VLAN-Unterschnittstellen otv<N> dürfen umgestellt werden. Fehlt die Liste oder ist sie für andere schreibbar,
#     ist kein Adapter freigegeben (nur die Prüfung „ip link show lo“ geht).
#   - otv<N> löschen nur, wenn es wirklich eine VLAN-Unterschnittstelle eines freigegebenen Adapters ist.
#   - Ziffern nur 0-9 (keine Unicode-Ziffern), Schnittstellennamen ohne führendes „-“, IPv4 genau geprüft.
#   - nmcli connection up: Profile „OTScan 3 …“ oder ein beliebiges Profil, aber nur gebunden an einen freigegebenen
#     Adapter (ifname) – sonst könnte das Zurücksetzen die vorherige Verbindung nicht wieder aktivieren.
#   - Python startet isoliert (-I -S): keine Umgebungsvariablen, kein site/sitecustomize.
import os
import re
import sys

ADAPTER_LISTE = "/etc/otscan3/adapter"
PFADE = ("/usr/sbin", "/usr/bin", "/sbin", "/bin")
BEFEHLE = ("ip", "arping", "nmcli", "dhclient", "dhcpcd", "networkctl")

A = re.ASCII
IF = r"[A-Za-z0-9_][A-Za-z0-9_.:@-]{0,14}"
OTV = r"otv[0-9]{1,4}"
OKT = r"(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])"
IP = r"(?:%s\.){3}%s" % (OKT, OKT)
CIDR = IP + r"/(?:3[0-2]|[12]?[0-9])"
MAC = r"(?:[0-9A-Fa-f]{2}:){5}[0-9A-Fa-f]{2}"
OTSP = r"OTScan 3 [A-Za-z0-9_.\- ]{1,64}"
NM_SCHLUESSEL = {"type": r"ethernet", "ifname": IF, "con-name": OTSP, "ipv4.method": r"manual|disabled",
                 "ipv4.addresses": r"(%s)?" % CIDR, "ipv4.never-default": r"yes", "ipv4.dad-timeout": r"[0-9]{1,5}",
                 "ipv6.method": r"disabled", "connection.autoconnect": r"yes|no", "connection.autoconnect-priority": r"[0-9]{1,3}",
                 "802-3-ethernet.cloned-mac-address": r"%s|permanent" % MAC}


class Abgelehnt(Exception):
    pass


def passt(muster, text):
    return re.fullmatch(muster, text, A) is not None


def freigegeben():
    """Adapter aus /etc/otscan3/adapter – nur, wenn Datei und Ordner root gehören und nicht fremd-schreibbar sind."""
    try:
        for p in (os.path.dirname(ADAPTER_LISTE), ADAPTER_LISTE):
            st = os.stat(p)
            if st.st_uid != 0 or st.st_mode & 0o022:
                return set()
        erg = set()
        with open(ADAPTER_LISTE, encoding="ascii", errors="replace") as fh:
            for z in fh:
                z = z.split("#", 1)[0].strip()
                if z and passt(IF, z):
                    erg.add(z)
        return erg
    except OSError:
        return set()


def vlan_eltern(name):
    """Eltern-Adapter einer VLAN-Unterschnittstelle (Kernel-Angaben) oder None, wenn name kein VLAN ist."""
    try:
        with open("/proc/net/vlan/" + name, encoding="ascii", errors="replace") as fh:
            for z in fh:
                m = re.match(r"\s*Device:\s*(\S+)", z, A)
                if m:
                    return m.group(1)
    except OSError:
        pass
    try:   # ohne /proc/net/vlan: sysfs (DEVTYPE=vlan, lower_<eltern>)
        with open("/sys/class/net/%s/uevent" % name, encoding="ascii", errors="replace") as fh:
            if "DEVTYPE=vlan" not in fh.read():
                return None
        unten = [n[6:] for n in os.listdir("/sys/class/net/%s" % name) if n.startswith("lower_")]
        return unten[0] if len(unten) == 1 else None
    except OSError:
        return None


def adapter_ok(name, frei, neu_vlan=False):
    """name ist ein freigegebener Adapter oder eine vorhandene VLAN-Unterschnittstelle otv<N> eines solchen."""
    if not passt(IF, name):
        return False
    if name in frei:
        return True
    if passt(OTV, name) and not neu_vlan:
        return vlan_eltern(name) in frei
    return False


def pruefe_if(name, frei):
    if not adapter_ok(name, frei):
        raise Abgelehnt("Adapter %s ist für OTScan 3 nicht freigegeben (%s)" % (name, ADAPTER_LISTE))


def kv_ok(args, frei):
    if len(args) % 2:
        return False
    for k, v in zip(args[::2], args[1::2]):
        if k not in NM_SCHLUESSEL or not passt(NM_SCHLUESSEL[k], v):
            return False
        if k == "ifname":
            pruefe_if(v, frei)
    return True


def erlaubt(cmd, a, frei=None):
    """True, wenn der Befehl erlaubt ist. Abgelehnt-Ausnahme mit Grund, wenn nur der Adapter nicht freigegeben ist."""
    frei = freigegeben() if frei is None else frei
    s = " ".join(a)
    if any("\n" in x or "\r" in x or "\0" in x for x in a):
        return False
    if cmd == "ip":
        if s == "link show lo":
            return True
        for m_, gruppe in ((r"link set dev (%s) (down|up)" % IF, 1), (r"link set dev (%s) address %s" % (IF, MAC), 1),
                           (r"-4 addr flush dev (%s)" % IF, 1), (r"addr (?:add|del) %s dev (%s)" % (CIDR, IF), 1),
                           (r"route (?:add|del) default via %s dev (%s)" % (IP, IF), 1)):
            m = re.fullmatch(m_, s, A)
            if m:
                pruefe_if(m.group(gruppe), frei)
                return True
        m = re.fullmatch(r"link add link (%s) name (%s) type vlan id ([0-9]{1,4})" % (IF, OTV), s, A)
        if m:
            if m.group(1) not in frei:
                raise Abgelehnt("Adapter %s ist für OTScan 3 nicht freigegeben (%s)" % (m.group(1), ADAPTER_LISTE))
            return 1 <= int(m.group(3)) <= 4094
        m = re.fullmatch(r"link del dev (%s)" % OTV, s, A)
        if m:
            eltern = vlan_eltern(m.group(1))
            if eltern is None:
                raise Abgelehnt("%s ist keine VLAN-Unterschnittstelle – wird nicht gelöscht" % m.group(1))
            if eltern not in frei:
                raise Abgelehnt("%s gehört zu Adapter %s, der nicht freigegeben ist (%s)" % (m.group(1), eltern, ADAPTER_LISTE))
            return True
        return False
    if cmd == "arping":
        m = re.fullmatch(r"(?:-D )?-c [0-9] -w [0-9]{1,2} -I (%s) %s" % (IF, IP), s, A)
        if m:
            pruefe_if(m.group(1), frei)
            return True
        return False
    if cmd == "nmcli":
        if a[:2] == ["connection", "add"]:
            return "con-name" in a[2::2] and "ifname" in a[2::2] and kv_ok(a[2:], frei)
        if a[:2] == ["connection", "modify"] and len(a) >= 3:
            return passt(OTSP, a[2]) and kv_ok(a[3:], frei)
        if a[:2] == ["connection", "delete"] and len(a) == 3:
            return passt(OTSP, a[2])
        if a[:2] == ["connection", "up"] and len(a) == 3:
            return passt(OTSP, a[2])
        if a[:2] == ["connection", "up"] and len(a) == 5 and a[3] == "ifname":
            if not a[2] or a[2].startswith("-") or len(a[2]) > 100:
                return False
            pruefe_if(a[4], frei)
            return True
        m = re.fullmatch(r"(?:dev|device) (?:set (%s) (?:autoconnect|managed) (?:yes|no)|(?:connect|disconnect) (%s))" % (IF, IF), s, A)
        if m:
            pruefe_if(m.group(1) or m.group(2), frei)
            return True
        return False
    if cmd in ("dhclient", "dhcpcd", "networkctl"):
        muster = {"dhclient": r"(?:-r|-nw) (%s)", "dhcpcd": r"(?:-k|-n) (%s)", "networkctl": r"reconfigure (%s)"}[cmd] % IF
        m = re.fullmatch(muster, s, A)
        if m:
            pruefe_if(m.group(1), frei)
            return True
        return False
    return False


def befehl(arg):
    """Programmname: nackt („ip“) oder mit Pfad aus den Systemordnern („/usr/sbin/ip“)."""
    d, n = os.path.split(arg)
    if n not in BEFEHLE or (d and d not in PFADE):
        return None
    return n


def finden(n):
    for d in PFADE:
        p = os.path.join(d, n)
        if os.path.isfile(p) and os.access(p, os.X_OK):
            return p
    return None


def main():
    if len(sys.argv) < 2:
        sys.exit("otsp-netz: Befehl fehlt")
    cmd = befehl(sys.argv[1])
    a = sys.argv[2:]
    try:
        ok = cmd is not None and erlaubt(cmd, a)
        grund = ""
    except Abgelehnt as e:
        ok, grund = False, str(e)
    if not ok:
        sys.stderr.write("otsp-netz: abgelehnt: %s %s%s\n" % (sys.argv[1], " ".join(a)[:300], (" – " + grund) if grund else ""))
        sys.exit(126)
    pfad = finden(cmd)
    if not pfad:
        sys.stderr.write("otsp-netz: %s nicht installiert\n" % cmd)
        sys.exit(127)
    os.execv(pfad, [pfad] + a)


if __name__ == "__main__":
    main()
