vmnet-cli 0.1.0__py3-none-any.whl

vmnet_cli/__init__.py

@@ -0,0 +1,2 @@
+# SPDX-License-Identifier: Apache-2.0
+"""vmnet_cli - CLI clone of vmnetcfg.exe over vnetlib.dll (RECON.md)."""

vmnet_cli/adapters.py

@@ -0,0 +1,236 @@
+# SPDX-License-Identifier: Apache-2.0
+"""vmnet_cli.adapters - see vmnet_cli.cli for the tool overview."""
+
+import csv
+import ctypes
+import io
+import subprocess
+import sys
+import time
+import winreg
+
+from .registry import CFG
+from .vnl import VL, VNetLib
+
+
+# ---- physical interface enumeration (PowerShell Get-NetAdapter) --------------
+def physical_interfaces():
+    """Return {friendly name: adapter GUID} for physical (non-VMware) interfaces."""
+    ps = (
+        "Get-NetAdapter | Where-Object { $_.InterfaceDescription -notlike 'VMware*' }"
+        " | Sort-Object ifIndex | ConvertTo-Csv -NoTypeInformation"
+    )
+    try:
+        out = subprocess.run(
+            ["powershell", "-NoProfile", "-Command", ps],
+            capture_output=True,
+            text=True,
+            check=True,
+            timeout=60,
+        ).stdout
+    except (FileNotFoundError, subprocess.CalledProcessError) as e:
+        sys.exit(f"adapter enumeration failed: {e}")
+    import csv
+    import io
+
+    result = {}
+    for row in csv.DictReader(io.StringIO(out)):
+        guid = (row.get("InterfaceGuid") or "").strip().upper()
+        name = (row.get("Name") or "").strip('"')
+        if guid and name:
+            result[name] = guid
+    return result
+
+
+# Real-hardware PnP bus prefixes. Software adapters (TAP, Wintun/WireGuard,
+# ZeroTier, VMware VMnet…) are ROOT\- or SWD\-enumerated and never appear here,
+# even when their driver masquerades as an 802.3 medium.
+PHYSICAL_BUSES = ("PCI", "VPCI", "USB", "PCMCIA", "SDIO", "SDCC", "SD", "IEEE1394", "MDIO", "ACPI")
+NET_CLASS = r"SYSTEM\CurrentControlSet\Control\Class\{4d36e972-e325-11ce-bfc1-08002be10318}"
+
+
+def _adapter_medium(guid):
+    """(*IfType, *PhysicalMediaType) from the adapter's registry class key.
+    71 = IEEE 802.11 in both fields; 6/14 = 802.3 Ethernet. (0, 0) = unknown
+    (some drivers omit the REV values; the bus gate already proved physical)."""
+    try:
+        with winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, NET_CLASS) as k:
+            for i in range(winreg.QueryInfoKey(k)[0]):
+                try:
+                    with winreg.OpenKey(k, winreg.EnumKey(k, i)) as sk:
+                        if winreg.QueryValueEx(sk, "NetCfgInstanceId")[0].upper() != guid:
+                            continue
+                        out = []
+                        for rev, plain in (
+                            ("*IfType", "IfType"),
+                            ("*PhysicalMediaType", "PhysicalMediaType"),
+                        ):
+                            for name in (rev, plain):
+                                try:
+                                    out.append(winreg.QueryValueEx(sk, name)[0])
+                                    break
+                                except OSError:
+                                    continue
+                            else:
+                                out.append(0)
+                        return tuple(out)
+                except OSError:
+                    continue
+    except OSError:
+        pass
+    return (0, 0)
+
+
+def classify_interfaces():
+    """Physical NICs only, in ifIndex order: [(guid, name, kind, desc)].
+    kind is 'wifi' for IEEE 802.11 (ifType/PhysicalMediaType 71) else 'ethernet'.
+    VPN/virtual adapters are filtered by requiring the adapter's PnP device to
+    sit on a real hardware bus: ROOT\\-enumerated drivers (TAP, WireGuard,
+    ZeroTier, VMware VMnet) and SWD\\ devices never qualify, whatever medium
+    their driver claims."""
+    ps = (
+        "Get-CimInstance -Namespace root/StandardCimv2 -ClassName MSFT_NetAdapter"
+        " | Sort-Object ifIndex | Select-Object Name,InterfaceGuid,PnPDeviceID,"
+        "InterfaceDescription | ConvertTo-Csv -NoTypeInformation"
+    )
+    out = subprocess.run(
+        ["powershell", "-NoProfile", "-Command", ps],
+        capture_output=True,
+        text=True,
+        check=True,
+        timeout=60,
+    ).stdout
+    result = []
+    for row in csv.DictReader(io.StringIO(out)):
+        guid = (row.get("InterfaceGuid") or "").strip().upper()
+        name = (row.get("Name") or "").strip('"')
+        desc = (row.get("InterfaceDescription") or "").strip('"')
+        pnp = (row.get("PnPDeviceID") or "").strip('"').upper()
+        if not guid or "VMware" in desc or not pnp:
+            continue
+        if not pnp.split("\\")[0].startswith(PHYSICAL_BUSES):
+            continue  # ROOT\/SWD\… = software driver
+        iftype, pmt = _adapter_medium(guid)
+        if iftype in (24, 131, 135, 136, 148, 154, 166, 181, 209):
+            continue  # ppp / tunnel / virtual ifTypes
+        kind = "wifi" if 71 in (iftype, pmt) else "ethernet"
+        result.append((guid, name, kind, desc))
+    return result
+
+
+def install_adapter_start(vnet):
+    """Kick the VNL adapter install; wait via install_adapter_finish."""
+    vl = VNetLib()
+    # 5-arg signature: (vnet, hwnd, flags, p4, p5*) — p5 is dereferenced if not NULL,
+    # so every trailing arg MUST be passed explicitly (stale-register AV otherwise).
+    vl._c("VNL_InstallNetworkAdapter", vnet.encode(), 0, 0, 0, 0)
+
+
+def install_adapter_finish(vnet, rounds=10):
+    """Wait for the PnP install; fall back to drvInst64 installRootDriver
+    (works headless, verified)."""
+    import time
+
+    for _ in range(rounds):  # PnP completes asynchronously; give it room
+        time.sleep(3)
+        if _adapter_present(vnet):
+            _name_adapter(vnet)  # headless VNL path also leaves generic names
+            return True
+    exe = VL.rsplit("\\", 1)[0] + "\\drvInst64.exe"
+    inf = VL.rsplit("\\", 1)[0] + "\\netadapter.inf"
+    subprocess.run(
+        [exe, "installRootDriver", "0", f"*{vnet.replace('vmnet', 'VMnetAdapter')}", inf, "1"],
+        capture_output=True,
+        timeout=120,
+    )
+    for _ in range(4):
+        time.sleep(3)
+        if _adapter_present(vnet):
+            _name_adapter(vnet)
+            return True
+    return False
+
+
+def install_adapter(vnet):
+    install_adapter_start(vnet)
+    return install_adapter_finish(vnet)
+
+
+def _adapter_present(vnet):
+    return int(vnet[5:]) in _adapters_present_set()
+
+
+def _name_adapter(vnet):
+    """drvInst installs with generic connection names; give it the VMnetN name."""
+    want = f"VMware Network Adapter {vnet.replace('vmnet', 'VMnet')}"
+    subprocess.run(
+        [
+            "powershell",
+            "-NoProfile",
+            "-Command",
+            f"$a = Get-NetAdapter | Where-Object {{ $_.InterfaceDescription -match 'VMnet{vnet[5:]}$' -and $_.Name -ne '{want}' }};"
+            f" if ($a) {{ Rename-NetAdapter -InputObject $a -NewName '{want}' -Confirm:$false }}",
+        ],
+        capture_output=True,
+        text=True,
+        timeout=60,
+    )
+
+
+def _adapters_present_set():
+    """VMnet segments that currently have an adapter device (one PS call)."""
+    r = subprocess.run(
+        [
+            "powershell",
+            "-NoProfile",
+            "-Command",
+            "(Get-NetAdapter | ForEach-Object { if ($_.InterfaceDescription -match 'VMnet(\\d+)$') { $Matches[1] } }) -join ' '",
+        ],
+        capture_output=True,
+        text=True,
+        timeout=60,
+    )
+    if r.returncode != 0:
+        raise RuntimeError("Get-NetAdapter failed: " + (r.stderr or "").strip()[:200])
+    return {int(x) for x in r.stdout.split()}
+
+
+def uninstall_adapter_start(vnet, n):
+    """Kick the VNL adapter removal; clear the config flag. Wait via finish."""
+    vl = VNetLib()
+    try:
+        vl._c("VNL_UninstallNetworkAdapter", vnet.encode(), 0, ctypes.byref(ctypes.c_int(0)))
+    except OSError:
+        pass
+    with winreg.CreateKey(winreg.HKEY_LOCAL_MACHINE, f"{CFG}\\{vnet}\\Adapter") as k:
+        winreg.SetValueEx(k, "UseAdapter", 0, winreg.REG_DWORD, 0)
+
+
+def uninstall_adapter_finish(n, present=None):
+    """Wait for device removal; pnputil fallback. present = live segment set."""
+    if present is None:
+        time.sleep(3)
+        present = _adapters_present_set()
+    if n in present:
+        r = subprocess.run(
+            [
+                "powershell",
+                "-NoProfile",
+                "-Command",
+                "Get-PnpDevice -Class Net -ErrorAction SilentlyContinue |"
+                f" Where-Object {{ $_.FriendlyName -match 'VMnet{n}$' }} | Select-Object -Expand InstanceId",
+            ],
+            capture_output=True,
+            text=True,
+            timeout=60,
+        )
+        for iid in r.stdout.split():
+            subprocess.run(["pnputil.exe", "/remove-device", iid], capture_output=True, timeout=120)
+        time.sleep(3)
+        present = _adapters_present_set()
+    return n not in present
+
+
+def uninstall_adapter(vnet, n):
+    uninstall_adapter_start(vnet, n)
+    return uninstall_adapter_finish(n)

vmnet_cli/batch.py

@@ -0,0 +1,138 @@
+# SPDX-License-Identifier: Apache-2.0
+"""vmnet_cli.batch - see vmnet_cli.cli for the tool overview."""
+
+import time
+import winreg
+
+from .adapters import (
+    _adapters_present_set,
+    _name_adapter,
+    uninstall_adapter_finish,
+    uninstall_adapter_start,
+)
+from .conf import regen_nat_conf
+from .registry import CFG, reg_bridge_bindings, reg_bridge_del, reg_delete_tree, reg_flag
+from .services import cycle_bridge, restart_services
+from .vnl import FEATURE_BITS, VL
+
+
+def batch_new():
+    """Collects multi-network changes so every expensive wait/restart happens
+    once for the whole batch instead of once per network."""
+    return {"dhcp": False, "nat": False, "bridge": False, "gone": [], "added": [], "vnets": []}
+
+
+def remove_stage(vl, n, ctx):
+    """Cheap part of a removal: pins, adapter kick, config key, conf edits."""
+    vnet = f"vmnet{n}"
+    f = vl.features(vnet) or 0
+    pinned = any(v == n for v in reg_bridge_bindings().values())
+    had_dhcp = bool(f & 0x1000000) or reg_flag(vnet, "DHCP")
+    had_nat = bool(f & 0x10000) or reg_flag(vnet, "NAT")
+    had_adapter = bool(f & 0x100) or reg_flag(vnet, "Adapter")
+    try:
+        winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, CFG + "\\" + vnet).Close()
+        has_config = True
+    except OSError:
+        has_config = False
+    if f == 0 and not (had_dhcp or had_nat or had_adapter or pinned) and not has_config:
+        print(f"* {vnet} is not configured; nothing to remove")
+        return False
+    parts = [v for b, v in FEATURE_BITS.items() if f & b]
+    print(f"* removing {vnet}" + (f" ({', '.join(parts)})" if parts else ""))
+    ctx["vnets"].append(n)
+    for guid, v in reg_bridge_bindings().items():
+        if v == n:
+            reg_bridge_del(guid)
+            print(f"  - unbound {guid}")
+            ctx["bridge"] = True
+    if had_adapter:
+        uninstall_adapter_start(vnet, n)
+        ctx["gone"].append(n)
+    reg_delete_tree(CFG + "\\" + vnet)
+    print("  - deleted VMnetConfig\\" + vnet)
+    if had_dhcp:
+        rc = vl.update_dhcp(vnet)
+        print(f"  - vmnetdhcp.conf regenerated: {'ok' if rc == 1 else 'rc=' + str(rc)}")
+        ctx["dhcp"] = True
+    if had_nat:
+        ctx["nat"] = True  # conf regen once at apply (whole-file rewrite)
+    return True
+
+
+def _present_safe():
+    """Adapter enumeration must never abort a batch apply: a transient
+    failure degrades to 'nothing present' (matching the C tool, whose
+    enumeration just returns 0 on failure), with a warning. The service
+    and bridge phases below must always run."""
+    try:
+        return _adapters_present_set()
+    except Exception as e:
+        print(f"  WARNING: adapter enumeration failed: {e}")
+        return set()
+
+
+def batch_apply(vl, ctx):
+    """One wait for all PnP operations, one conf regen, one service restart,
+    one bridge cycle — regardless of batch size."""
+    if ctx["nat"]:
+        regen_nat_conf(vl)
+        print("  - vmnetnat.conf regenerated")
+    if ctx["gone"]:
+        try:
+            time.sleep(3)
+            present = _present_safe()
+            for n in ctx["gone"]:
+                if n in present:
+                    uninstall_adapter_finish(n, present=present)
+                    present = _present_safe()
+                print(
+                    f"  - host adapter device vmnet{n}: {'STILL PRESENT' if n in present else 'gone'}"
+                )
+        except Exception as e:
+            print(f"  WARNING: adapter removal step failed: {e} (continuing)")
+    if ctx["added"]:
+        try:
+            pending = list(ctx["added"])
+            for _ in range(10):
+                time.sleep(3)
+                present = _present_safe()
+                pending = [n for n in pending if n not in present]
+                if not pending:
+                    break
+            import subprocess
+
+            exe = VL.rsplit("\\", 1)[0] + "\\drvInst64.exe"
+            inf = VL.rsplit("\\", 1)[0] + "\\netadapter.inf"
+            for n in pending:
+                try:
+                    subprocess.run(
+                        [exe, "installRootDriver", "0", f"*VMnetAdapter{n}", inf, "1"],
+                        capture_output=True,
+                        timeout=120,
+                    )
+                except (subprocess.TimeoutExpired, OSError):
+                    pass  # keep waiting; do not abort the batch
+            time.sleep(3)
+            for _ in range(4):
+                if not pending:
+                    break
+                time.sleep(3)
+                present = _present_safe()
+                pending = [n for n in pending if n not in present]
+            present = _present_safe()
+            for n in ctx["added"]:
+                if n in present:
+                    _name_adapter(f"vmnet{n}")
+                print(
+                    f"  - host adapter device vmnet{n}: {'ok' if n in present else 'pending/failed (PnP is async)'}"
+                )
+        except Exception as e:
+            print(f"  WARNING: adapter install step failed: {e} (continuing)")
+    if ctx["dhcp"] or ctx["nat"]:
+        restart_services(dhcp=ctx["dhcp"], nat=ctx["nat"])
+    if ctx["bridge"]:
+        cycle_bridge()
+    for n in ctx["vnets"]:
+        left = vl.features(f"vmnet{n}") or 0  # absent (None) counts as removed
+        print(f"  {'OK' if left == 0 else 'WARNING'}: vmnet{n} features now 0x{left:08x}")

vmnet_cli/cli.py

@@ -0,0 +1,196 @@
+# SPDX-License-Identifier: Apache-2.0
+"""vmnet_cli.cli - see vmnet_cli.cli for the tool overview."""
+
+import argparse
+import sys
+
+if sys.platform != "win32":
+    sys.exit(
+        "vmnet-cli must run on a Windows host with VMware Workstation "
+        "installed (it drives vnetlib.dll)."
+    )
+
+from .commands import (
+    cmd_adapters,
+    cmd_add,
+    cmd_autobridge,
+    cmd_bridged,
+    cmd_clear,
+    cmd_edit,
+    cmd_list,
+    cmd_remove,
+    cmd_restore,
+    cmd_unpin,
+)
+from .commands_nat import cmd_export, cmd_import, cmd_natcfg, cmd_natfw, cmd_setip
+from .vnl import VNetLib
+
+"""
+vmnet-cli — unofficial command-line interface to the VMware Workstation
+Virtual Network Editor, built on the reverse-engineered vnetlib.dll VNL_* API
+(Workstation 26H1,
+build 25688693; API v1.0). Run elevated on the Windows host running Workstation.
+
+Usage (full vmnetcfg.exe Network Editor parity):
+  vmnet-cli.py adapters                          list physical interfaces
+  vmnet-cli.py list                              list vmnet segments + features
+  vmnet-cli.py add hostonly --name X [--subnet A [--mask M]] [--vnet N] [--dhcp on|off]
+  vmnet-cli.py add nat     --name X [--subnet A [--mask M]] [--vnet N]
+  vmnet-cli.py bridged --name LAN  --adapter Ethernet [--vnet N]
+  vmnet-cli.py edit --vnet N [--name X] [--subnet A] [--mask M] [--dhcp on|off] [--nat on|off]
+                   [--type bridged|hostonly|nat] [--adapter on|off]
+                   [--dhcp-begin A --dhcp-end A] [--lease S --max-lease S]
+  vmnet-cli.py set-ip --vnet N --addr A          host adapter IP
+  vmnet-cli.py natfw list  --vnet N --proto tcp|udp --hport P
+  vmnet-cli.py natfw add   --vnet N --proto tcp|udp --hport P --vm-ip A --vm-port P [--desc D]
+  vmnet-cli.py natfw remove --vnet N --proto tcp|udp --hport P
+  vmnet-cli.py natcfg show|set --vnet N [--gateway-ip A] [--host-ip A] [--configport P]
+                   [--ipv6 on|off] [--active-ftp on|off] [--allow-any-oui on|off]
+                   [--udp-timeout S] [--dns-auto on|off] [--dns1 A --dns2 A --dns3 A]
+                   [--dns-policy order|rotate|burst] [--dns-retries N] [--dns-timeout S]
+                   [--nbns-timeout S]
+  vmnet-cli.py remove --vnet N [--force]         delete a vmnet network entirely
+  vmnet-cli.py unpin --vnet N                    drop bridge binding(s), keep network
+  vmnet-cli.py autobridge [--dry-run]            bridge each physical NIC:
+                                                 Ethernet->LAN<n>, Wi-Fi->WLAN<n>
+  vmnet-cli.py restore-defaults --force          wipe custom nets, recreate vmnet1+vmnet8
+  vmnet-cli.py clear|flush --force               remove EVERY network (vmnet0 stays)
+  vmnet-cli.py export --file F                   save config (registry hive)
+  vmnet-cli.py import --file F                   restore config
+"""
+
+
+def parse_vnet(s):
+    """Accept only '2' or 'vmnet2' (letters then digits, nothing else) —
+    mirrors the C tool's strict strtol parse; vnetlib's index resolution
+    clamps, so sloppy parses would silently target other segments."""
+    t = str(s)
+    i = 0
+    while i < len(t) and t[i].isascii() and t[i].isalpha():
+        i += 1
+    rest = t[i:]
+    if not rest.isascii() or not rest.isdigit() or int(rest) > 1000000:
+        raise argparse.ArgumentTypeError(
+            f"expected a segment number or name (e.g. 2 or vmnet2), got {s!r}"
+        )
+    return int(rest)
+
+
+def require_elevated():
+    """Same bar as vmnetcfg.exe: full elevated Administrator token.
+    SYSTEM is not required; Network Configuration Operators is not enough."""
+    import ctypes
+
+    if not ctypes.windll.shell32.IsUserAnAdmin():
+        sys.exit(
+            "vmnet-cli must run elevated as an Administrator "
+            "(elevated prompt or Run as administrator); SYSTEM not required"
+        )
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    sub = ap.add_subparsers(dest="cmd", required=True)
+    sub.add_parser("adapters")
+    sub.add_parser("list")
+    a = sub.add_parser("add")
+    a.add_argument("kind", choices=["hostonly", "nat"])
+    a.add_argument("--name", required=True)
+    a.add_argument("--subnet")
+    a.add_argument("--mask")
+    a.add_argument("--vnet", type=parse_vnet)
+    a.add_argument("--dhcp", choices=["on", "off"], default="on", help="hostonly only")
+    b = sub.add_parser("bridged")
+    b.add_argument("--name", required=True)
+    b.add_argument("--adapter", required=True)
+    b.add_argument("--vnet", type=parse_vnet)
+    e = sub.add_parser("edit")
+    e.add_argument("--vnet", type=parse_vnet, required=True)
+    e.add_argument("--name")
+    e.add_argument("--subnet")
+    e.add_argument("--mask")
+    e.add_argument("--dhcp", choices=["on", "off"])
+    e.add_argument("--nat", choices=["on", "off"])
+    e.add_argument("--type", choices=["bridged", "hostonly", "nat"])
+    e.add_argument("--adapter", choices=["on", "off"], help="host adapter checkbox")
+    e.add_argument("--dhcp-begin")
+    e.add_argument("--dhcp-end")
+    e.add_argument("--lease", type=int, help="default lease seconds")
+    e.add_argument("--max-lease", type=int)
+    fw = sub.add_parser("natfw", help="NAT port forwarding (mapPortDlg)")
+    fw.add_argument("action", choices=["list", "add", "remove"])
+    fw.add_argument("--vnet", type=parse_vnet, required=True)
+    fw.add_argument("--proto", choices=["tcp", "udp"])
+    fw.add_argument("--hport", type=int)
+    fw.add_argument("--vm-ip")
+    fw.add_argument("--vm-port", type=int)
+    fw.add_argument("--desc")
+    nc = sub.add_parser("natcfg", help="NAT/DNS/NetBIOS advanced settings (natDlg)")
+    nc.add_argument("action", choices=["show", "set"])
+    nc.add_argument("--vnet", type=parse_vnet, required=True)
+    for flag, typ in (
+        ("gateway-ip", str),
+        ("host-ip", str),
+        ("configport", int),
+        ("udp-timeout", int),
+        ("dns1", str),
+        ("dns2", str),
+        ("dns3", str),
+        ("dns-policy", str),
+        ("dns-retries", int),
+        ("dns-timeout", int),
+        ("nbns-timeout", int),
+    ):
+        nc.add_argument("--" + flag, type=typ)
+    for flag in ("ipv6", "active-ftp", "allow-any-oui", "dns-auto"):
+        nc.add_argument("--" + flag, choices=["on", "off"])
+    rd = sub.add_parser("restore-defaults", help="wipe custom nets, recreate vmnet1+vmnet8")
+    rd.add_argument("--force", action="store_true")
+    cl = sub.add_parser(
+        "clear", aliases=["flush"], help="remove ALL vmnet networks incl. stock (vmnet0 stays)"
+    )
+    cl.add_argument("--force", action="store_true")
+    i = sub.add_parser("set-ip")
+    i.add_argument("--vnet", type=parse_vnet, required=True)
+    i.add_argument("--addr", required=True)
+    r = sub.add_parser(
+        "remove",
+        help="delete vmnet networks (adapter, config, conf, services) — batched across all --vnet args",
+    )
+    r.add_argument("--vnet", type=parse_vnet, required=True, action="append")
+    r.add_argument("--force", action="store_true", help="allow removing stock vmnet1/vmnet8")
+    u = sub.add_parser("unpin", help="only remove bridge binding(s) of a vnet, keep the network")
+    u.add_argument("--vnet", type=parse_vnet, required=True)
+    ab = sub.add_parser(
+        "autobridge", help="bridge every physical NIC: Ethernet->LAN<n>, Wi-Fi->WLAN<n>"
+    )
+    ab.add_argument("--dry-run", action="store_true", help="show the plan, change nothing")
+    x = sub.add_parser("export")
+    x.add_argument("--file", required=True)
+    m = sub.add_parser("import")
+    m.add_argument("--file", required=True)
+    args = ap.parse_args()
+    require_elevated()
+    vl = VNetLib()
+    {
+        "adapters": lambda: cmd_adapters(vl),
+        "list": lambda: cmd_list(vl),
+        "add": lambda: cmd_add(vl, args),
+        "bridged": lambda: cmd_bridged(vl, args),
+        "edit": lambda: cmd_edit(vl, args),
+        "set-ip": lambda: cmd_setip(vl, args),
+        "remove": lambda: cmd_remove(vl, args),
+        "unpin": lambda: cmd_unpin(vl, args),
+        "autobridge": lambda: cmd_autobridge(vl, args),
+        "natfw": lambda: cmd_natfw(vl, args),
+        "natcfg": lambda: cmd_natcfg(vl, args),
+        "restore-defaults": lambda: cmd_restore(vl, args),
+        "clear": lambda: cmd_clear(vl, args),
+        "flush": lambda: cmd_clear(vl, args),
+        "export": lambda: cmd_export(vl, args),
+        "import": lambda: cmd_import(vl, args),
+    }[args.cmd]()
+
+
+if __name__ == "__main__":
+    main()