mobster-cli 0.4.3__py3-none-any.whl

mobile_agent/wireless/cli.py

@@ -0,0 +1,287 @@
+"""`mobster wifi`: use an iPhone without the cable, over the encrypted Wi-Fi link."""
+
+import json
+import sys
+
+from . import GATE, store, switch, transport_on, words
+
+DONE, FAILED, USAGE, MISSING_EXIT = 0, 1, 2, 3
+
+
+def add_arguments(parser, helpers):
+    subs = parser.add_subparsers(dest="wifi_command", metavar="<subcommand>")
+    subs.required = True
+
+    def device(sub):
+        sub.add_argument("--device", metavar="NAME",
+                         help="the iPhone: an id, UDID or name from `mobster devices` (default: your iPhone)")
+
+    def as_json(sub):
+        sub.add_argument("--json", action="store_true", help="print one JSON object")
+
+    status = subs.add_parser("status", help="show how each iPhone is connected, and whether Wi-Fi is on for it",
+                             description="Show each iPhone set up here: on the cable, on Wi-Fi, or not reachable, "
+                                         "and whether Wi-Fi is on for it. Reads only; changes nothing.")
+    as_json(status)
+    on = subs.add_parser("on", help="let an iPhone be used over Wi-Fi (plug it in first)",
+                         description="Let Mobster reach an iPhone over Wi-Fi when it's unplugged, through the "
+                                     "encrypted link between this Mac and the phone. The iPhone must be plugged in "
+                                     "and trust this Mac; this is the same switch as Connect via network in Xcode.",
+                         epilog="exit codes: 0 on, 1 it couldn't be turned on, 2 usage, 3 no such iPhone")
+    device(on)
+    as_json(on)
+    off = subs.add_parser("off", help="use an iPhone only with the cable again",
+                          description="Stop using an iPhone over Wi-Fi. When Mobster turned on the iPhone's own "
+                                      "switch (Connect via network), it turns that off too, over the cable. When it "
+                                      "can't, or Xcode turned the switch on, it says what to do.",
+                          epilog="exit codes: 0 off, 1 it failed or the iPhone's own switch is still on (plug it in "
+                                 "and run this again), 2 usage, 3 no such iPhone")
+    device(off)
+    as_json(off)
+    probe = subs.add_parser("probe", help="check the encrypted Wi-Fi link to an unplugged iPhone, step by step",
+                            description="Check an unplugged iPhone over Wi-Fi: what Xcode's device service reports, "
+                                        "the encrypted tunnel, WebDriverAgent on the tunnel through this Mac's "
+                                        "relay, and that the phone's Wi-Fi address does not answer on 8100 or 9100. "
+                                        "It binds only 127.0.0.1 and changes nothing on the phone (with --start, it "
+                                        "launches Mobster's helper on it for the probe, then stops it).",
+                            epilog="exit codes: 0 every check passed, 1 a check failed, 2 usage, 3 couldn't run")
+    device(probe)
+    probe.add_argument("--start", action="store_true",
+                       help="launch Mobster's helper over Wi-Fi for the probe when it isn't running (quit the Mac "
+                            "app first)")
+    as_json(probe)
+
+
+def run(args):
+    as_json = bool(getattr(args, "json", False))
+    try:
+        command = args.wifi_command
+        if command == "status":
+            return _status(as_json)
+        if command == "probe":
+            return _probe(args, as_json)
+        return _switch(args, command == "on", as_json)
+    except KeyboardInterrupt:
+        return 130
+    except _Stop as stop:
+        return _fail(stop, as_json)
+
+
+class _Stop(Exception):
+    def __init__(self, code, message, fix="", exit_code=FAILED):
+        super().__init__(message)
+        self.code, self.message, self.fix, self.exit_code = code, message, fix, exit_code
+
+
+def _problem(code, name, exit_code=FAILED):
+    problem = words.problem(code, name)
+    return _Stop(code, problem["message"], problem["fix"], exit_code)
+
+
+def _fail(stop, as_json):
+    if as_json:
+        _print({"ok": False, "error": stop.message, "code": stop.code, **({"fix": stop.fix} if stop.fix else {})})
+    else:
+        print(stop.message, file=sys.stderr, flush=True)
+        if stop.fix:
+            print(stop.fix, file=sys.stderr, flush=True)
+    return stop.exit_code
+
+
+def _print(value):
+    try:
+        print(json.dumps(value, ensure_ascii=False), flush=True)
+    except BrokenPipeError:
+        pass
+
+
+def _data_dir():
+    from ..paths import user_data_dir
+    return user_data_dir()
+
+
+def _phones(data_dir):
+    """The USB iPhones set up here, primary first (devices.discover without probing)."""
+    from .. import devices
+    return [item for item in devices.discover(data_dir, sims=False, probe=False)
+            if item["kind"] == "usb" and item.get("wdaUrl")]
+
+
+def _choose(data_dir, name):
+    from .. import devices
+    records = devices.discover(data_dir, sims=False, probe=False)
+    if name:
+        try:
+            item = devices.resolve(records, name)
+        except LookupError as error:
+            raise _Stop("no_device", str(error), "", MISSING_EXIT) from None
+    else:
+        primary = [item for item in records if item.get("primary")]
+        usb = [item for item in records if item["kind"] == "usb"]
+        item = primary[0] if len(primary) == 1 else usb[0] if len(usb) == 1 else None
+        if item is None:
+            if not usb:
+                raise _Stop("no_device", "Mobster sees no iPhone set up here.",
+                            "Plug one in and set it up in the Mobster app first.", MISSING_EXIT)
+            raise _Stop("usage", "Several iPhones are here: " + ", ".join(f"{r['name']} ({r['id']})" for r in usb[:6])
+                        + ".", "Name one with --device.", USAGE)
+    if item["kind"] != "usb":
+        raise _Stop("usage", f"{item['name']} isn't an iPhone on a cable. Wi-Fi is for iPhones set up with a cable.",
+                    "", USAGE)
+    return item
+
+
+def _listing(data_dir, udid):
+    """The phone's USB listing entry (trusted or not), or None when it isn't plugged in."""
+    from ..device_manager import DeviceManager
+    try:
+        devices = DeviceManager(data_dir).devices()
+    except Exception:
+        devices = []
+    return next((item for item in devices if item.get("udid", "").upper() == udid.upper()), None)
+
+
+def _connection(item, enabled, peers):
+    """The words for how a phone is connected now, read from this Mac (the app's relay answering on its port)."""
+    from .. import devices
+    from ..mac_tools import usb_attached
+    if usb_attached(item["udid"]):
+        return "usb", words.ON_CABLE
+    if not enabled:
+        return None, words.OFF
+    if item.get("wdaUrl") and devices.wda_answers(item["wdaUrl"]):
+        return "wifi", words.ON_WIFI
+    peer = (peers or {}).get(item["udid"].upper())
+    if peer is not None and peer.network:
+        return None, f"{words.UNREACHABLE} yet (the encrypted link is {peer.tunnel})"
+    return None, words.UNREACHABLE
+
+
+def _status(as_json):
+    from . import devicectl
+    data_dir = _data_dir()
+    phones = _phones(data_dir)
+    settings = {item["udid"]: store.get(data_dir, item["udid"]) for item in phones}
+    peers = None
+    if any(value["enabled"] for value in settings.values()):
+        try:
+            peers = devicectl.list_devices()
+        except (devicectl.DevicectlError, RuntimeError):
+            peers = None
+    rows = []
+    for item in phones:
+        value = settings[item["udid"]]
+        now, text = _connection(item, value["enabled"], peers)
+        peer = (peers or {}).get(item["udid"].upper())
+        rows.append({"id": item["id"], "udid": item["udid"], "name": item["name"], "enabled": value["enabled"],
+                     "via": value["via"], "transport": now, "connection": text,
+                     "tunnel": peer.tunnel if peer is not None and peer.network else None})
+    if as_json:
+        _print({"wifiTransport": transport_on(), "devices": rows})
+        return DONE
+    if transport_on():
+        print("Wi-Fi for iPhones: on")
+    else:
+        print(f"Wi-Fi for iPhones: off in this Mobster. To try it, set {GATE}=1 in your env file.")
+    if not rows:
+        print("No iPhone is set up here yet. Plug one in and set it up in the Mobster app.")
+        return DONE
+    width = max(len(row["name"] or "") for row in rows) + 2
+    for row in rows:
+        switch = "Wi-Fi on" if row["enabled"] else "Wi-Fi off"
+        print(f"  {row['name'] or row['id']:<{width}} {row['connection']:<34} {switch}")
+    return DONE
+
+
+def _switch(args, on, as_json):
+    data_dir = _data_dir()
+    item = _choose(data_dir, getattr(args, "device", None))
+    udid, name = item["udid"], item["name"]
+    listing = _listing(data_dir, udid)
+    following = None
+    try:
+        if on:
+            if switch.turn_on(data_dir, udid, listing) == "xcode":
+                following = words.problem("needs_xcode", name)
+        elif left_on := switch.turn_off(data_dir, udid, listing):
+            following = words.problem(left_on, name)
+    except switch.SwitchRefused as error:
+        raise _problem(error.code, name) from None
+    except RuntimeError as error:
+        raise _Stop("devices_off", f"{error}.", "", MISSING_EXIT) from None
+    if not on:
+        return _switched_off(item, following, as_json)
+    if as_json:
+        _print({"ok": True, "device": {"id": item["id"], "udid": udid, "name": name, "enabled": on},
+                "wifiTransport": transport_on(), **({"next": following} if following else {})})
+        return DONE
+    if following:
+        print(following["message"])
+        print(following["fix"])
+    else:
+        print(f"Wi-Fi is on for {name}. Unplug it when you like: Mobster reaches it through the encrypted link "
+              "between this Mac and the phone.")
+    print(f"Check it, unplugged: mobster wifi probe --device {json.dumps(name, ensure_ascii=False)}")
+    if not transport_on():
+        print(f"Wi-Fi for iPhones is off in this Mobster: to use it for tasks, set {GATE}=1 in your env file.")
+    return DONE
+
+
+def _switched_off(item, left_on, as_json):
+    """Wi-Fi is off in Mobster; ``left_on`` is the problem of the phone's own switch still on, or None. A switch
+    Mobster turned on and couldn't turn off fails (exit 1); one Xcode turned on is the person's to turn off (exit 0,
+    like `on`'s Xcode step)."""
+    name = item["name"]
+    failed = left_on is not None and left_on["code"] != "xcode_on"
+    if as_json:
+        device = {"id": item["id"], "udid": item["udid"], "name": name, "enabled": False}
+        _print({"ok": False, "error": left_on["message"], "code": left_on["code"], "fix": left_on["fix"],
+                "device": device} if failed else
+               {"ok": True, "device": device, "wifiTransport": transport_on(),
+                **({"next": left_on} if left_on else {})})
+        return FAILED if failed else DONE
+    print(f"Wi-Fi is off for {name}. Mobster uses it only with the cable.")
+    if left_on:
+        stream = sys.stderr if failed else sys.stdout
+        print(left_on["message"], file=stream)
+        print(left_on["fix"], file=stream)
+    if failed:
+        print(f"Plugged in and unlocked: mobster wifi off --device {json.dumps(name, ensure_ascii=False)}",
+              file=sys.stderr)
+    return FAILED if failed else DONE
+
+
+def _probe(args, as_json):
+    from .. import devices, native_helpers
+    from ..mac_tools import usb_attached
+    from .probe import Probe, describe
+    if not native_helpers.devices_allowed():
+        raise _Stop("devices_off", "Devices are off in this process (MOBSTER_NO_DEVICES=1).", "", MISSING_EXIT)
+    data_dir = _data_dir()
+    item = _choose(data_dir, getattr(args, "device", None))
+    manager = None
+    if item.get("primary"):
+        from ..device_manager import DeviceManager
+        manager = DeviceManager(data_dir)
+    else:
+        manager = devices.manager_for(item["udid"], data_dir)
+    slot = devices.port_of(item.get("wdaUrl"))
+    if not as_json:
+        print(f"Probing {item['name']} over Wi-Fi "
+              f"({'Wi-Fi on' if store.enabled(data_dir, item['udid']) else 'Wi-Fi off'} "
+              f"for it; Wi-Fi for iPhones {'on' if transport_on() else 'off'} in this Mobster)")
+    probe = Probe(udid=item["udid"], name=item["name"], slot_port=slot, data_dir=data_dir,
+                  start=bool(getattr(args, "start", False)), manager=manager,
+                  out=None if as_json else (lambda step: print(describe(step), flush=True)))
+    try:
+        probe.run(usb_attached)
+    finally:
+        probe.stop_launched()
+    from . import result
+    result.record(data_dir, item["udid"], probe.public())   # the app's Wi-Fi tile reads it (GET /api/wireless)
+    if as_json:
+        _print(probe.public())
+    else:
+        print("")
+        print("Every check passed." if probe.ok else "Not every check passed: see the lines above.")
+    return DONE if probe.ok else FAILED

mobile_agent/wireless/devicectl.py

@@ -0,0 +1,229 @@
+"""What CoreDevice sees: ``xcrun devicectl``, always with a timeout and a kill (SPEC §3.7 item 2)."""
+
+import json
+import os
+import signal
+import subprocess
+import tempfile
+import threading
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Mapping, Optional
+
+from .. import native_helpers
+
+LIST_TIMEOUT = 8.0
+BRING_UP_TIMEOUT = 20.0
+APPS_TIMEOUT = 30.0
+DEVELOPER_TTL = 300.0
+# Apple doesn't document these field names: `mobster wifi probe` prints what the phone really reports.
+TUNNEL = {"connected": "up", "connecting": "connecting", "disconnected": "down", "disconnecting": "down",
+          "unavailable": "down"}
+ADDRESS_KEYS = ("tunnelIPAddress", "tunnelIPAddressString", "tunnelAddress")
+
+
+class DevicectlError(RuntimeError):
+    """devicectl couldn't answer. ``code``: "no_xcode" | "hang" | "failed" | "identity"."""
+
+    def __init__(self, message, code="failed"):
+        super().__init__(message)
+        self.code = code
+
+
+@dataclass(frozen=True)
+class Peer:
+    """One phone as CoreDevice reports it."""
+    udid: str
+    name: Optional[str] = None
+    transport: Optional[str] = None        # raw transportType: "wired", "localNetwork", ...
+    tunnel: str = "unknown"                # "up" | "connecting" | "down" | "unknown"
+    tunnel_state: Optional[str] = None     # raw tunnelState
+    address: Optional[str] = None          # the tunnel address as reported (checked again before any use)
+    developer_mode: Optional[str] = None
+    os_version: Optional[str] = None       # deviceProperties.osVersionNumber, e.g. "26.0"
+    hostnames: tuple = ()
+    fields: Mapping = field(default_factory=dict)   # connectionProperties as read, for the probe
+
+    @property
+    def network(self):
+        return self.transport == "localNetwork"
+
+    @property
+    def wired(self):
+        return self.transport == "wired"
+
+
+def _text(value):
+    return value if isinstance(value, str) and value else None
+
+
+def parse(document):
+    result = document.get("result") if isinstance(document, dict) else None
+    if not isinstance(result, dict):
+        return {}
+    devices = result.get("devices")
+    if devices is None and isinstance(result.get("device"), dict):
+        devices = [result["device"]]
+    peers = {}
+    for device in devices if isinstance(devices, list) else ():
+        if not isinstance(device, dict):
+            continue
+        hardware = device.get("hardwareProperties") if isinstance(device.get("hardwareProperties"), dict) else {}
+        properties = device.get("deviceProperties") if isinstance(device.get("deviceProperties"), dict) else {}
+        connection = device.get("connectionProperties") if isinstance(device.get("connectionProperties"), dict) else {}
+        udid = _text(hardware.get("udid")) or _text(device.get("udid"))
+        if not udid:
+            continue
+        state = _text(connection.get("tunnelState"))
+        address = next((_text(connection.get(key)) for key in ADDRESS_KEYS if _text(connection.get(key))), None)
+        names = []
+        for key in ("localHostnames", "potentialHostnames"):
+            value = connection.get(key)
+            names += [item for item in value if isinstance(item, str) and item] if isinstance(value, list) else []
+        peers[udid.upper()] = Peer(
+            udid=udid, name=_text(properties.get("name")), transport=_text(connection.get("transportType")),
+            tunnel=TUNNEL.get(state, "unknown"), tunnel_state=state, address=address,
+            developer_mode=_text(properties.get("developerModeStatus")),
+            os_version=_text(properties.get("osVersionNumber")),
+            hostnames=tuple(dict.fromkeys(names)),
+            fields={key: value for key, value in connection.items()
+                    if isinstance(value, (str, int, float, bool, list))})
+    return peers
+
+
+_developer = {"at": None, "dir": None}
+_developer_lock = threading.Lock()
+
+
+def developer_dir():
+    """Xcode's developer folder (mac_tools.developer_dir), looked up at most every 5 minutes; None without Xcode."""
+    with _developer_lock:
+        if _developer["at"] is None or time.monotonic() - _developer["at"] > DEVELOPER_TTL:
+            from ..mac_tools import developer_dir as lookup
+            try:
+                _developer["dir"] = lookup()[0]
+            except Exception:
+                _developer["dir"] = None
+            _developer["at"] = time.monotonic()
+        return _developer["dir"]
+
+
+def command(args, developer):
+    """The argv for ``xcrun devicectl <args>`` with Xcode's own xcrun."""
+    xcrun = Path(developer) / "usr" / "bin" / "xcrun"
+    return [str(xcrun) if xcrun.is_file() else "/usr/bin/xcrun", "devicectl", *args]
+
+
+def run_json(args, timeout, *, developer=None, runner=None):
+    native_helpers.require_devices()
+    developer = developer or developer_dir()
+    if not developer:
+        raise DevicectlError("Xcode isn't installed or set up on this Mac", "no_xcode")
+    with tempfile.TemporaryDirectory(prefix="mobster-devicectl-") as folder:
+        output = Path(folder) / "result.json"
+        argv = command([*args, "--json-output", str(output)], developer)
+        env = {**os.environ, "DEVELOPER_DIR": developer}
+        code, error = (runner or _run)(argv, env, timeout)
+        try:
+            document = json.loads(output.read_text())
+        except (OSError, ValueError):
+            document = None
+    if document is None:
+        raise DevicectlError(f"devicectl gave no answer (exit {code}): {error[-200:]}".strip(), "failed")
+    outcome = (document.get("info") or {}).get("outcome") if isinstance(document, dict) else None
+    if code != 0 and outcome != "success" and not parse(document):
+        raise DevicectlError(f"devicectl failed (exit {code}): {error[-200:]}".strip(), "failed")
+    return document
+
+
+# `devicectl list devices` can hang while it sets up a tunnel (Apple FB15184273).
+def _run(argv, env, timeout):
+    """(exit code, the end of stderr). Its own process group, killed on overrun: DevicectlError "hang"."""
+    with tempfile.TemporaryFile() as errors:
+        try:
+            process = subprocess.Popen(argv, stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=errors,
+                                       env=env, start_new_session=True)
+        except OSError as error:
+            raise DevicectlError(f"devicectl couldn't start: {error}", "no_xcode") from None
+        try:
+            code = process.wait(timeout=timeout)
+        except subprocess.TimeoutExpired:
+            kill(process)
+            raise DevicectlError(f"devicectl didn't answer in {timeout:g} s and was stopped", "hang") from None
+        errors.seek(0)
+        return code, errors.read()[-2000:].decode("utf-8", "replace")
+
+
+def kill(process):
+    """Kill a hung devicectl and everything it started."""
+    try:
+        os.killpg(process.pid, signal.SIGKILL)
+    except (ProcessLookupError, PermissionError):
+        pass
+    try:
+        process.wait(timeout=2)
+    except subprocess.TimeoutExpired:
+        pass
+
+
+def list_devices(timeout=LIST_TIMEOUT, **kwargs):
+    """{UDID: Peer} for every device CoreDevice knows (on USB, over the network, or neither now)."""
+    return parse(run_json(["list", "devices"], timeout, **kwargs))
+
+
+def _checked(udid):
+    from ..devices import UDID_PATTERN
+    if not isinstance(udid, str) or not UDID_PATTERN.fullmatch(udid):
+        raise ValueError("A UDID is 24 to 40 hex digits and dashes")
+    return udid
+
+
+def bring_up(udid, timeout=BRING_UP_TIMEOUT, **kwargs):
+    peers = parse(run_json(["device", "info", "details", "--device", _checked(udid)], timeout, **kwargs))
+    if peers and udid.upper() not in peers:
+        raise DevicectlError("CoreDevice answered for a different iPhone than the one asked for", "identity")
+    return peers
+
+
+def lock_state(document):
+    # None is never read as unlocked
+    result = document.get("result") if isinstance(document, dict) else None
+    value = result.get("passcodeRequired") if isinstance(result, dict) else None
+    return value if isinstance(value, bool) else None
+
+
+def read_lock_state(udid, timeout=LIST_TIMEOUT, **kwargs):
+    try:
+        return lock_state(run_json(["device", "info", "lockState", "--device", _checked(udid)], timeout, **kwargs))
+    except (DevicectlError, RuntimeError):   # RuntimeError: MOBSTER_NO_DEVICES=1
+        return None
+
+
+def parse_apps(document, kind="user"):
+    from ..installed_apps import MAX_APPS, NAME_LIMIT, _clean
+    from ..state import validate_bundle_id
+    result = document.get("result") if isinstance(document, dict) else None
+    items = result.get("apps") if isinstance(result, dict) else None
+    if not isinstance(items, list):
+        raise DevicectlError("devicectl printed no app list", "failed")
+    apps, seen = [], set()
+    for item in items[:MAX_APPS]:
+        if not isinstance(item, dict) or (item.get("defaultApp") is True) != (kind == "system"):
+            continue
+        try:
+            bundle = validate_bundle_id(item.get("bundleIdentifier"))
+        except ValueError:
+            continue
+        if bundle in seen:
+            continue
+        seen.add(bundle)
+        apps.append({"bundleId": bundle, "name": _clean(item.get("name")) or bundle[:NAME_LIMIT],
+                     "version": _clean(item.get("version"))})
+    apps.sort(key=lambda app: (app["name"].casefold(), app["bundleId"]))
+    return apps
+
+
+def read_apps(udid, kind="user", timeout=APPS_TIMEOUT, **kwargs):
+    """parse_apps for ``udid``, read through CoreDevice (USB or Wi-Fi). Raises DevicectlError."""
+    return parse_apps(run_json(["device", "info", "apps", "--device", _checked(udid)], timeout, **kwargs), kind)

mobile_agent/wireless/exposure.py

@@ -0,0 +1,33 @@
+
+import socket
+
+from . import network
+
+PORTS = (8100, 9100)
+# What WebDriverAgent (and Mobster's patches to it) answer with; a router's own page says none of these.
+SIGNS = (b"WDA MJPEG Server", b"sessionId", b"Local clients only", b"WebDriverAgent")
+
+
+def speaks_wda(host, port, timeout=1.5, connect=None):
+    try:
+        with (connect or socket.create_connection)((host, port), timeout) as sock:
+            sock.settimeout(timeout)
+            # the local Host header: Mobster's patched helper refuses any other, and this only asks if it is there
+            sock.sendall(f"GET /status HTTP/1.0\r\nHost: 127.0.0.1:{port}\r\n\r\n".encode())
+            data = sock.recv(1024)
+    except OSError:
+        return False
+    return any(sign in data for sign in SIGNS)
+
+
+def exposed(hostnames, *, resolve=None, gateway=None, accepts=None, speaks=None):
+    resolve, gateway = resolve or network.resolve, gateway or network.default_gateway
+    accepts, speaks = accepts or network.port_open, speaks or speaks_wda
+    found = resolve(list(hostnames)) if hostnames else {"ipv4": [], "ipv6": []}
+    addresses = found["ipv4"] + found["ipv6"]
+    hits = [f"{address}:{port}" for address in addresses for port in PORTS if accepts(address, port)]
+    # a phone sharing its hotspot is the router and has no name: there only an answer from WebDriverAgent counts
+    router = gateway()
+    if router and router not in addresses:
+        hits += [f"{router}:{port}" for port in PORTS if speaks(router, port)]
+    return addresses, hits

mobile_agent/wireless/mobster-wifi-pair.c

@@ -0,0 +1,122 @@
+/*
+ * mobster-wifi-pair: let a trusted iPhone be reached over Wi-Fi, or stop it.
+ *
+ * It sets the lockdown value com.apple.mobile.wireless_lockdown/EnableWifiConnections, the same flag as Xcode's
+ * "Connect via network". Only over USB: the phone must be plugged in and trust this Mac. It never pairs a new
+ * Mac, never enters a passcode and changes nothing else on the phone.
+ *
+ *   mobster-wifi-pair --udid UDID --enable | --disable | --status
+ *
+ * Prints one JSON line, {"enabled": true|false}, and exits:
+ *   0 done, 2 usage, 3 no iPhone with that UDID on USB, 4 the iPhone doesn't trust this Mac (or is locked),
+ *   5 the iPhone refused the change, 6 anything else.
+ *
+ * This file is MIT, like Mobster. desktop/scripts/build-iphone-tools.sh compiles it against the static
+ * libimobiledevice and libplist it bundles (LGPL-2.1, like the iPhone tools already in the app).
+ */
+#include <stdio.h>
+#include <string.h>
+
+#include <libimobiledevice/libimobiledevice.h>
+#include <libimobiledevice/lockdown.h>
+#include <plist/plist.h>
+
+#define DOMAIN "com.apple.mobile.wireless_lockdown"
+#define KEY "EnableWifiConnections"
+
+enum { DONE = 0, USAGE = 2, NO_DEVICE = 3, NOT_TRUSTED = 4, REFUSED = 5, FAILED = 6 };
+
+static int usage(void)
+{
+	fprintf(stderr, "usage: mobster-wifi-pair --udid UDID --enable | --disable | --status\n");
+	return USAGE;
+}
+
+static int valid_udid(const char *udid)
+{
+	size_t length = strlen(udid);
+	if (length < 24 || length > 40)
+		return 0;
+	for (size_t i = 0; i < length; i++) {
+		char c = udid[i];
+		if (!((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F') || c == '-'))
+			return 0;
+	}
+	return 1;
+}
+
+static int handshake_code(lockdownd_error_t error)
+{
+	switch (error) {
+	case LOCKDOWN_E_PASSWORD_PROTECTED:
+	case LOCKDOWN_E_USER_DENIED_PAIRING:
+	case LOCKDOWN_E_PAIRING_DIALOG_RESPONSE_PENDING:
+	case LOCKDOWN_E_INVALID_HOST_ID:
+	case LOCKDOWN_E_MISSING_PAIR_RECORD:
+	case LOCKDOWN_E_INVALID_PAIR_RECORD:
+	case LOCKDOWN_E_PAIRING_FAILED:
+	case LOCKDOWN_E_SSL_ERROR:
+		return NOT_TRUSTED;
+	default:
+		return FAILED;
+	}
+}
+
+int main(int argc, char **argv)
+{
+	const char *udid = NULL;
+	int action = 0; /* 'e' enable, 'd' disable, 's' status */
+	for (int i = 1; i < argc; i++) {
+		if (!strcmp(argv[i], "--udid") && i + 1 < argc)
+			udid = argv[++i];
+		else if (!action && !strcmp(argv[i], "--enable"))
+			action = 'e';
+		else if (!action && !strcmp(argv[i], "--disable"))
+			action = 'd';
+		else if (!action && !strcmp(argv[i], "--status"))
+			action = 's';
+		else
+			return usage();
+	}
+	if (!udid || !action || !valid_udid(udid))
+		return usage();
+
+	idevice_t device = NULL;
+	/* USB only: the flag is turned on with the cable, never over the network. */
+	if (idevice_new_with_options(&device, udid, IDEVICE_LOOKUP_USBMUX) != IDEVICE_E_SUCCESS || !device) {
+		fprintf(stderr, "no iPhone with that UDID is on USB\n");
+		return NO_DEVICE;
+	}
+	lockdownd_client_t client = NULL;
+	lockdownd_error_t error = lockdownd_client_new_with_handshake(device, &client, "mobster-wifi-pair");
+	if (error != LOCKDOWN_E_SUCCESS) {
+		fprintf(stderr, "lockdown handshake failed (%d)\n", error);
+		idevice_free(device);
+		return handshake_code(error);
+	}
+	int code = DONE;
+	if (action != 's') {
+		/* lockdownd_set_value takes the node and frees it. */
+		error = lockdownd_set_value(client, DOMAIN, KEY, plist_new_bool(action == 'e'));
+		if (error != LOCKDOWN_E_SUCCESS) {
+			fprintf(stderr, "the iPhone refused the change (%d)\n", error);
+			code = error == LOCKDOWN_E_SET_PROHIBITED || error == LOCKDOWN_E_IMMUTABLE_VALUE ? REFUSED : FAILED;
+		}
+	}
+	if (code == DONE) {
+		plist_t value = NULL;
+		uint8_t enabled = 0;
+		error = lockdownd_get_value(client, DOMAIN, KEY, &value);
+		if (error == LOCKDOWN_E_SUCCESS && value && plist_get_node_type(value) == PLIST_BOOLEAN)
+			plist_get_bool_val(value, &enabled);
+		else if (error != LOCKDOWN_E_SUCCESS && error != LOCKDOWN_E_MISSING_VALUE && error != LOCKDOWN_E_MISSING_KEY)
+			code = FAILED;
+		if (value)
+			plist_free(value);
+		if (code == DONE)
+			printf("{\"enabled\": %s}\n", enabled ? "true" : "false");
+	}
+	lockdownd_client_free(client);
+	idevice_free(device);
+	return code;
+}