pymobiledevice3 4.27.7__py3-none-any.whl → 5.0.0__py3-none-any.whl

pymobiledevice3/__main__.py

@@ -27,7 +27,6 @@ coloredlogs.install(level=logging.INFO)
 
 logging.getLogger('quic').disabled = True
 logging.getLogger('asyncio').disabled = True
-logging.getLogger('zeroconf').disabled = True
 logging.getLogger('parso.cache').disabled = True
 logging.getLogger('parso.cache.pickle').disabled = True
 logging.getLogger('parso.python.diff').disabled = True

pymobiledevice3/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '4.27.7'
-__version_tuple__ = version_tuple = (4, 27, 7)
+__version__ = version = '5.0.0'
+__version_tuple__ = version_tuple = (5, 0, 0)
 
 __commit_id__ = commit_id = None

pymobiledevice3/bonjour.py

@@ -1,145 +1,402 @@
+# Async, dependency-light mDNS browser returning dataclasses with per-address interface names.
+# Works for any DNS-SD type, e.g. "_remoted._tcp.local."
+# - Uses ifaddr (optional) to map IPs -> local interfaces; otherwise iface will be None.
+
 import asyncio
-import dataclasses
-from asyncio import CancelledError
-from socket import AF_INET, AF_INET6, inet_ntop
-from typing import Optional
+import ipaddress
+import socket
+import struct
+import sys
+from collections import defaultdict
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Set, Tuple
 
-from ifaddr import get_adapters
-from zeroconf import IPVersion, ServiceListener, ServiceStateChange, Zeroconf
-from zeroconf.asyncio import AsyncServiceBrowser, AsyncServiceInfo, AsyncZeroconf
+import ifaddr  # pip install ifaddr
 
 from pymobiledevice3.osu.os_utils import get_os_utils
 
-REMOTEPAIRING_SERVICE_NAMES = ['_remotepairing._tcp.local.']
-REMOTEPAIRING_MANUAL_PAIRING_SERVICE_NAMES = ['_remotepairing-manual-pairing._tcp.local.']
-MOBDEV2_SERVICE_NAMES = ['_apple-mobdev2._tcp.local.']
-REMOTED_SERVICE_NAMES = ['_remoted._tcp.local.']
+REMOTEPAIRING_SERVICE_NAME = '_remotepairing._tcp.local.'
+REMOTEPAIRING_MANUAL_PAIRING_SERVICE_NAME = '_remotepairing-manual-pairing._tcp.local.'
+MOBDEV2_SERVICE_NAME = '_apple-mobdev2._tcp.local.'
+REMOTED_SERVICE_NAME = '_remoted._tcp.local.'
 OSUTILS = get_os_utils()
 DEFAULT_BONJOUR_TIMEOUT = OSUTILS.bonjour_timeout
 
+MDNS_PORT = 5353
+MDNS_MCAST_V4 = "224.0.0.251"
+MDNS_MCAST_V6 = "ff02::fb"
 
-@dataclasses.dataclass
-class BonjourAnswer:
-    name: str
-    properties: dict[bytes, bytes]
-    ips: list[str]
-    port: int
-
-
-class BonjourListener(ServiceListener):
-    def __init__(self, ip: str):
-        super().__init__()
-        self.name: Optional[str] = None
-        self.properties: dict[bytes, bytes] = {}
-        self.ip = ip
-        self.port: Optional[int] = None
-        self.addresses: list[str] = []
-        self.queue: asyncio.Queue = asyncio.Queue()
-        self.querying_task: Optional[asyncio.Task] = asyncio.create_task(self.query_addresses())
-
-    def async_on_service_state_change(
-            self, zeroconf: Zeroconf, service_type: str, name: str, state_change: ServiceStateChange) -> None:
-        self.queue.put_nowait((zeroconf, service_type, name, state_change))
-
-    async def query_addresses(self) -> None:
-        zeroconf, service_type, name, state_change = await self.queue.get()
-        self.name = name
-        service_info = AsyncServiceInfo(service_type, name)
-        await service_info.async_request(zeroconf, 3000)
-        ipv4 = [inet_ntop(AF_INET, address.packed) for address in
-                service_info.ip_addresses_by_version(IPVersion.V4Only)]
-        ipv6 = []
-        if '%' in self.ip:
-            ipv6 = [inet_ntop(AF_INET6, address.packed) + '%' + self.ip.split('%')[1] for address in
-                    service_info.ip_addresses_by_version(IPVersion.V6Only)]
-        self.addresses = ipv4 + ipv6
-        self.properties = service_info.properties
-        self.port = service_info.port
-
-    async def close(self) -> None:
-        self.querying_task.cancel()
-        try:
-            await self.querying_task
-        except asyncio.CancelledError:
-            pass
+QTYPE_A = 1
+QTYPE_PTR = 12
+QTYPE_TXT = 16
+QTYPE_AAAA = 28
+QTYPE_SRV = 33
 
+CLASS_IN = 0x0001
+CLASS_QU = 0x8000  # unicast-response bit (we use multicast queries)
 
-@dataclasses.dataclass
-class BonjourQuery:
-    zc: AsyncZeroconf
-    service_browser: AsyncServiceBrowser
-    listener: BonjourListener
 
+# ---------------- Dataclasses ----------------
 
-def query_bonjour(service_names: list[str], ip: str) -> BonjourQuery:
-    aiozc = AsyncZeroconf(interfaces=[ip])
-    listener = BonjourListener(ip)
-    service_browser = AsyncServiceBrowser(aiozc.zeroconf, service_names,
-                                          handlers=[listener.async_on_service_state_change])
-    return BonjourQuery(aiozc, service_browser, listener)
+# --- Dataclass decorator shim (adds slots only on 3.10+)
+def dataclass_compat(*d_args, **d_kwargs):
+    if sys.version_info < (3, 10):
+        d_kwargs.pop("slots", None)  # ignore on 3.9
+    return dataclass(*d_args, **d_kwargs)
 
 
-async def browse(service_names: list[str], ips: list[str], timeout: float = DEFAULT_BONJOUR_TIMEOUT) \
-        -> list[BonjourAnswer]:
-    bonjour_queries = [query_bonjour(service_names, adapter) for adapter in ips]
-    answers = []
-    try:
-        await asyncio.sleep(timeout)
-    except CancelledError:
-        for bonjour_query in bonjour_queries:
-            await bonjour_query.listener.close()
-            await bonjour_query.service_browser.async_cancel()
-            await bonjour_query.zc.async_close()
-        raise
-    for bonjour_query in bonjour_queries:
-        if bonjour_query.listener.addresses:
-            answer = BonjourAnswer(
-                bonjour_query.listener.name, bonjour_query.listener.properties, bonjour_query.listener.addresses,
-                bonjour_query.listener.port)
-            if answer not in answers:
-                answers.append(answer)
-        await bonjour_query.listener.close()
-        await bonjour_query.service_browser.async_cancel()
-        await bonjour_query.zc.async_close()
-    return answers
-
-
-async def browse_ipv6(service_names: list[str], timeout: float = DEFAULT_BONJOUR_TIMEOUT) -> list[BonjourAnswer]:
-    return await browse(service_names, OSUTILS.get_ipv6_ips(), timeout=timeout)
-
-
-def get_ipv4_addresses() -> list[str]:
-    ips = []
-    for adapter in get_adapters():
-        if adapter.nice_name.startswith('tun'):
-            # skip browsing on already established tunnels
+@dataclass_compat(slots=True)
+class Address:
+    ip: str
+    iface: Optional[str]  # local interface name (e.g., "en0"), or None if unknown
+
+    @property
+    def full_ip(self) -> str:
+        if self.iface and self.ip.lower().startswith("fe80:"):
+            return f"{self.ip}%{self.iface}"
+        return self.ip
+
+
+@dataclass_compat(slots=True)
+class ServiceInstance:
+    instance: str  # "<Instance Name>._type._proto.local."
+    host: Optional[str]  # "host.local" (without trailing dot), or None if unresolved
+    port: Optional[int]  # SRV port
+    addresses: List[Address] = field(default_factory=list)  # IPs with interface names
+    properties: Dict[str, str] = field(default_factory=dict)  # TXT key/values
+
+
+# ---------------- DNS helpers ----------------
+
+
+def encode_name(name: str) -> bytes:
+    name = name.rstrip(".")
+    out = bytearray()
+    for label in name.split(".") if name else []:
+        b = label.encode("utf-8")
+        if len(b) > 63:
+            raise ValueError("label too long")
+        out.append(len(b))
+        out += b
+    out.append(0)
+    return bytes(out)
+
+
+def decode_name(data: bytes, off: int) -> Tuple[str, int]:
+    labels = []
+    jumped = False
+    orig_end = off
+    for _ in range(128):  # loop guard
+        if off >= len(data):
+            break
+        length = data[off]
+        if length == 0:
+            off += 1
+            break
+        if (length & 0xC0) == 0xC0:
+            if off + 1 >= len(data):
+                raise ValueError("truncated name pointer")
+            ptr = ((length & 0x3F) << 8) | data[off + 1]
+            if ptr >= len(data):
+                raise ValueError("bad name pointer")
+            if not jumped:
+                orig_end = off + 2
+            off = ptr
+            jumped = True
             continue
-        for ip in adapter.ips:
-            if ip.ip == '127.0.0.1':
-                continue
-            if not ip.is_IPv4:
+        off += 1
+        end = off + length
+        if end > len(data):
+            raise ValueError("truncated label")
+        labels.append(data[off:end].decode("utf-8", errors="replace"))
+        off = end
+    return ".".join(labels) + ".", (orig_end if jumped else off)
+
+
+def build_query(name: str, qtype: int, unicast: bool = False) -> bytes:
+    hdr = struct.pack("!HHHHHH", 0, 0, 1, 0, 0, 0)  # TXID=0, flags=0, 1 question
+    qclass = CLASS_IN | (CLASS_QU if unicast else 0)
+    return hdr + encode_name(name) + struct.pack("!HH", qtype, qclass)
+
+
+def parse_rr(data: bytes, off: int):
+    name, off = decode_name(data, off)
+    if off + 10 > len(data):
+        raise ValueError("truncated RR header")
+    rtype, rclass, ttl, rdlen = struct.unpack("!HHIH", data[off: off + 10])
+    off += 10
+    rdata = data[off: off + rdlen]
+    off += rdlen
+
+    rr = {"name": name, "type": rtype, "class": rclass & 0x7FFF, "ttl": ttl}
+    if rtype == QTYPE_PTR:
+        target, _ = decode_name(data, off - rdlen)
+        rr["ptrdname"] = target
+    elif rtype == QTYPE_SRV and rdlen >= 6:
+        priority, weight, port = struct.unpack("!HHH", rdata[:6])
+        target, _ = decode_name(data, off - rdlen + 6)
+        rr.update(
+            {"priority": priority, "weight": weight, "port": port, "target": target}
+        )
+    elif rtype == QTYPE_TXT:
+        kv = {}
+        i = 0
+        while i < rdlen:
+            b = rdata[i]
+            i += 1
+            seg = rdata[i: i + b]
+            i += b
+            if not seg:
                 continue
-            ips.append(ip.ip)
-    return ips
+            if b"=" in seg:
+                k, v = seg.split(b"=", 1)
+                kv[k.decode()] = v.decode(errors="replace")
+            else:
+                kv[seg.decode()] = ""
+        rr["txt"] = kv
+    elif rtype == QTYPE_A and rdlen == 4:
+        rr["address"] = socket.inet_ntop(socket.AF_INET, rdata)
+    elif rtype == QTYPE_AAAA and rdlen == 16:
+        rr["address"] = socket.inet_ntop(socket.AF_INET6, rdata)
+    else:
+        rr["raw"] = rdata
+    return rr, off
+
+
+def parse_mdns_message(data: bytes):
+    if len(data) < 12:
+        return []
+    _, _, qd, an, ns, ar = struct.unpack("!HHHHHH", data[:12])
+    off = 12
+    for _ in range(qd):
+        _, off = decode_name(data, off)
+        off += 4
+    rrs = []
+    for _ in range(an + ns + ar):
+        rr, off = parse_rr(data, off)
+        rrs.append(rr)
+    return rrs
+
+
+# ---------------- Interface mapping helpers ----------------
+
+
+class _Adapters:
+    def __init__(self):
+        self.adapters = ifaddr.get_adapters() if ifaddr is not None else []
+
+    def pick_iface_for_ip(
+            self, ip_str: str, family: int, v6_scopeid: Optional[int]
+    ) -> Optional[str]:
+        # Prefer scope id for IPv6 link-local
+        if family == socket.AF_INET6 and ip_str.lower().startswith("fe80:"):
+            if v6_scopeid:
+                try:
+                    return socket.if_indextoname(v6_scopeid)
+                except OSError:
+                    pass
+
+        # Otherwise, try to match destination ip to local subnet via ifaddr
+        if not self.adapters:
+            return None
+        ip = ipaddress.ip_address(ip_str)
+        best = (None, -1)  # (name, prefix_len)
+        for ad in self.adapters:
+            for ipn in ad.ips:
+                if isinstance(ipn.ip, str):
+                    # IPv4
+                    fam = socket.AF_INET
+                    ipn_ip = ipn.ip
+                else:
+                    # IPv6
+                    fam = socket.AF_INET6
+                    ipn_ip = ipn.ip[0]
+                if fam != family:
+                    continue
+                net = ipaddress.ip_network(
+                    f"{ipn_ip}/{ipn.network_prefix}", strict=False
+                )
+                if ip in net and ipn.network_prefix > best[1]:
+                    best = (ad.nice_name or ad.name, ipn.network_prefix)
+        return best[0]
+
 
+# ---------------- async sockets ----------------
+
+
+class _DatagramProtocol(asyncio.DatagramProtocol):
+    def __init__(self, queue: asyncio.Queue):
+        self.queue = queue
+
+    def datagram_received(self, data, addr):
+        # addr: IPv4 -> (host, port); IPv6 -> (host, port, flowinfo, scopeid)
+        self.queue.put_nowait((data, addr))
+
+
+async def _bind_ipv4(queue: asyncio.Queue):
+    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+    if hasattr(socket, "SO_REUSEPORT"):
+        try:
+            s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
+        except OSError:
+            pass
+    s.bind(("0.0.0.0", MDNS_PORT))
+    try:
+        mreq = struct.pack(
+            "=4s4s", socket.inet_aton(MDNS_MCAST_V4), socket.inet_aton("0.0.0.0")
+        )
+        s.setsockopt(socket.IPPROTO_IP, socket.IP_ADD_MEMBERSHIP, mreq)
+    except OSError:
+        pass
+    transport, _ = await asyncio.get_running_loop().create_datagram_endpoint(
+        lambda: _DatagramProtocol(queue), sock=s
+    )
+    return transport, s
+
+
+async def _bind_ipv6_all_ifaces(queue: asyncio.Queue):
+    s = socket.socket(socket.AF_INET6, socket.SOCK_DGRAM)
+    s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+    if hasattr(socket, "SO_REUSEPORT"):
+        try:
+            s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
+        except OSError:
+            pass
+    s.bind(("::", MDNS_PORT))
+    grp = socket.inet_pton(socket.AF_INET6, MDNS_MCAST_V6)
+    for ifindex, _ in socket.if_nameindex():
+        mreq6 = grp + struct.pack("@I", ifindex)
+        try:
+            s.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_JOIN_GROUP, mreq6)
+        except OSError:
+            continue
+    transport, _ = await asyncio.get_running_loop().create_datagram_endpoint(
+        lambda: _DatagramProtocol(queue), sock=s
+    )
+    return transport, s
+
+
+async def _open_mdns_sockets():
+    queue = asyncio.Queue()
+    transports: List[Tuple[asyncio.BaseTransport, socket.socket]] = []
+    t4, s4 = await _bind_ipv4(queue)
+    transports.append((t4, s4))
+    t6, s6 = await _bind_ipv6_all_ifaces(queue)
+    transports.append((t6, s6))
+    if not transports:
+        raise RuntimeError("Failed to open mDNS sockets (UDP/5353)")
+    return transports, queue
+
+
+async def _send_query_all(transports, pkt: bytes):
+    for transport, sock in transports:
+        if sock.family == socket.AF_INET:
+            transport.sendto(pkt, (MDNS_MCAST_V4, MDNS_PORT))
+        else:
+            # Send once per iface index for better reachability
+            for ifindex, _ in socket.if_nameindex():
+                transport.sendto(pkt, (MDNS_MCAST_V6, MDNS_PORT, 0, ifindex))
+
+
+# ---------------- Public API ----------------
+
+
+async def browse_service(
+        service_type: str, timeout: float = 4.0
+) -> List[ServiceInstance]:
+    """
+    Discover a DNS-SD/mDNS service type (e.g. "_remoted._tcp.local.") on the local network.
+
+    Returns: List[ServiceInstance] with Address(ip, iface) entries.
+    """
+    if not service_type.endswith("."):
+        service_type += "."
+
+    transports, queue = await _open_mdns_sockets()
+    adapters = _Adapters()
+
+    ptr_targets: Set[str] = set()
+    srv_map: Dict[str, Dict] = {}
+    txt_map: Dict[str, Dict] = {}
+    # host -> list[(ip, iface)]
+    host_addrs: Dict[str, List[Address]] = defaultdict(list)
+
+    def _record_addr(rr_name: str, ip_str: str, pkt_addr):
+        # Determine family and possible scopeid from the packet that delivered this RR
+        family = socket.AF_INET6 if ":" in ip_str else socket.AF_INET
+        scopeid = None
+        if isinstance(pkt_addr, tuple) and len(pkt_addr) == 4:  # IPv6 remote tuple
+            scopeid = pkt_addr[3]
+        iface = adapters.pick_iface_for_ip(ip_str, family, scopeid)
+        # avoid duplicates for the same host/ip
+        existing = host_addrs[rr_name]
+        if not any(a.ip == ip_str for a in existing):
+            existing.append(Address(ip=ip_str, iface=iface))
+
+    try:
+        await _send_query_all(
+            transports, build_query(service_type, QTYPE_PTR, unicast=False)
+        )
+        loop = asyncio.get_running_loop()
+        end = loop.time() + timeout
+        while loop.time() < end:
+            try:
+                data, pkt_addr = await asyncio.wait_for(
+                    queue.get(), timeout=end - loop.time()
+                )
+            except asyncio.TimeoutError:
+                break
+            for rr in parse_mdns_message(data):
+                t = rr.get("type")
+                if t == QTYPE_PTR and rr.get("name") == service_type:
+                    ptr_targets.add(rr.get("ptrdname"))
+                elif t == QTYPE_SRV:
+                    srv_map[rr["name"]] = {
+                        "target": rr.get("target"),
+                        "port": rr.get("port"),
+                    }
+                elif t == QTYPE_TXT:
+                    txt_map[rr["name"]] = rr.get("txt", {})
+                elif t == QTYPE_A and rr.get("address"):
+                    _record_addr(rr["name"], rr["address"], pkt_addr)
+                elif t == QTYPE_AAAA and rr.get("address"):
+                    _record_addr(rr["name"], rr["address"], pkt_addr)
+    finally:
+        for transport, _ in transports:
+            transport.close()
 
-async def browse_ipv4(service_names: list[str], timeout: float = DEFAULT_BONJOUR_TIMEOUT) -> list[BonjourAnswer]:
-    return await browse(service_names, get_ipv4_addresses(), timeout=timeout)
+    # Assemble dataclasses
+    results: List[ServiceInstance] = []
+    for inst in sorted(ptr_targets):
+        srv = srv_map.get(inst, {})
+        target = srv.get("target")
+        host = (target[:-1] if target and target.endswith(".") else target) or None
+        addrs = host_addrs.get(target, []) if target else []
+        props = txt_map.get(inst, {})
+        results.append(
+            ServiceInstance(
+                instance=inst,
+                host=host,
+                port=srv.get("port"),
+                addresses=addrs,
+                properties=props,
+            )
+        )
+    return results
 
 
-async def browse_remoted(timeout: float = DEFAULT_BONJOUR_TIMEOUT) -> list[BonjourAnswer]:
-    return await browse_ipv6(REMOTED_SERVICE_NAMES, timeout=timeout)
+async def browse_remoted(timeout: float = DEFAULT_BONJOUR_TIMEOUT) -> list[ServiceInstance]:
+    return await browse_service(REMOTED_SERVICE_NAME, timeout=timeout)
 
 
-async def browse_mobdev2(timeout: float = DEFAULT_BONJOUR_TIMEOUT, ips: Optional[list[str]] = None) -> list[BonjourAnswer]:
-    if ips is None:
-        ips = get_ipv4_addresses() + OSUTILS.get_ipv6_ips()
-    return await browse(MOBDEV2_SERVICE_NAMES, ips, timeout=timeout)
+async def browse_mobdev2(timeout: float = DEFAULT_BONJOUR_TIMEOUT) -> list[ServiceInstance]:
+    return await browse_service(MOBDEV2_SERVICE_NAME, timeout=timeout)
 
 
-async def browse_remotepairing(timeout: float = DEFAULT_BONJOUR_TIMEOUT) -> list[BonjourAnswer]:
-    return await browse_ipv4(REMOTEPAIRING_SERVICE_NAMES, timeout=timeout)
+async def browse_remotepairing(timeout: float = DEFAULT_BONJOUR_TIMEOUT) -> list[ServiceInstance]:
+    return await browse_service(REMOTEPAIRING_SERVICE_NAME, timeout=timeout)
 
 
-async def browse_remotepairing_manual_pairing(timeout: float = DEFAULT_BONJOUR_TIMEOUT) -> list[BonjourAnswer]:
-    return await browse_ipv4(REMOTEPAIRING_MANUAL_PAIRING_SERVICE_NAMES, timeout=timeout)
+async def browse_remotepairing_manual_pairing(timeout: float = DEFAULT_BONJOUR_TIMEOUT) -> list[ServiceInstance]:
+    return await browse_service(REMOTEPAIRING_MANUAL_PAIRING_SERVICE_NAME, timeout=timeout)

pymobiledevice3/cli/bonjour.py

@@ -41,8 +41,8 @@ def cli_mobdev2(timeout: float, pair_records: Optional[str]) -> None:
 async def cli_remotepairing_task(timeout: float) -> None:
     output = []
     for answer in await browse_remotepairing(timeout=timeout):
-        for ip in answer.ips:
-            output.append({'hostname': ip, 'port': answer.port})
+        for address in answer.addresses:
+            output.append({'hostname': address.full_ip, 'port': answer.port})
     print_json(output)
 
 
@@ -56,8 +56,8 @@ def cli_remotepairing(timeout: float) -> None:
 async def cli_remotepairing_manual_pairing_task(timeout: float) -> None:
     output = []
     for answer in await browse_remotepairing_manual_pairing(timeout=timeout):
-        for ip in answer.ips:
-            output.append({'hostname': ip, 'port': answer.port, 'name': answer.properties[b'name'].decode()})
+        for address in answer.addresses:
+            output.append({'hostname': address.full_ip, 'port': answer.port, 'name': answer.properties[b'name'].decode()})
     print_json(output)
 
 

pymobiledevice3/cli/lockdown.py

@@ -161,6 +161,12 @@ def lockdown_wifi_connections(service_provider: LockdownClient, state):
         service_provider.enable_wifi_connections = state == 'on'
 
 
+async def async_cli_start_tunnel(
+        service_provider: LockdownServiceProvider, script_mode: bool) -> None:
+    await tunnel_task(await CoreDeviceTunnelProxy.create(service_provider),
+                      script_mode=script_mode, secrets=None, protocol=TunnelProtocol.TCP)
+
+
 @lockdown_group.command('start-tunnel', cls=Command)
 @click.option('--script-mode', is_flag=True,
               help='Show only HOST and port number to allow easy parsing from external shell scripts')
@@ -168,8 +174,7 @@ def lockdown_wifi_connections(service_provider: LockdownClient, state):
 def cli_start_tunnel(
         service_provider: LockdownServiceProvider, script_mode: bool) -> None:
     """ start tunnel """
-    service = CoreDeviceTunnelProxy(service_provider)
-    asyncio.run(tunnel_task(service, script_mode=script_mode, secrets=None, protocol=TunnelProtocol.TCP), debug=True)
+    asyncio.run(async_cli_start_tunnel(service_provider, script_mode), debug=True)
 
 
 @lockdown_group.command('assistive-touch', cls=Command)

pymobiledevice3/cli/remote.py

@@ -220,9 +220,10 @@ async def start_remote_pair_task(device_name: str) -> None:
         if device_name is not None and current_device_name != device_name:
             continue
 
-        for ip in answer.ips:
-            devices.append(RemotePairingManualPairingDevice(ip=ip, port=answer.port, device_name=current_device_name,
-                                                            identifier=answer.properties[b'identifier'].decode()))
+        for address in answer.addresses:
+            devices.append(
+                RemotePairingManualPairingDevice(ip=address.full_ip, port=answer.port, device_name=current_device_name,
+                                                 identifier=answer.properties[b'identifier'].decode()))
 
     if len(devices) > 0:
         device = prompt_device_list(devices)

pymobiledevice3/lockdown.py

@@ -848,7 +848,7 @@ def create_using_remote(service: ServiceConnection, identifier: str = None, labe
 
 async def get_mobdev2_lockdowns(
         udid: Optional[str] = None, pair_records: Optional[Path] = None, only_paired: bool = False,
-        timeout: float = DEFAULT_BONJOUR_TIMEOUT, ips: Optional[list[str]] = None) \
+        timeout: float = DEFAULT_BONJOUR_TIMEOUT) \
         -> AsyncIterable[tuple[str, TcpLockdownClient]]:
     records = {}
     if pair_records is None:
@@ -863,26 +863,21 @@ async def get_mobdev2_lockdowns(
         record = plistlib.loads(file.read_bytes())
         records[record['WiFiMACAddress']] = record
 
-    iterated_ips = set()
-    for answer in await browse_mobdev2(timeout=timeout, ips=ips):
-        if '@' not in answer.name:
+    for answer in await browse_mobdev2(timeout=timeout):
+        if '@' not in answer.instance:
             continue
-        wifi_mac_address = answer.name.split('@', 1)[0]
+        wifi_mac_address = answer.instance.split('@', 1)[0]
         record = records.get(wifi_mac_address)
 
         if only_paired and record is None:
             continue
 
-        for ip in answer.ips:
-            if ip in iterated_ips:
-                # skip ips we already iterated over, possibly from previous queries
-                continue
-            iterated_ips.add(ip)
+        for address in answer.addresses:
             try:
-                lockdown = create_using_tcp(hostname=ip, autopair=False, pair_record=record)
+                lockdown = create_using_tcp(hostname=address.full_ip, autopair=False, pair_record=record)
             except Exception:
                 continue
             if only_paired and not lockdown.paired:
                 lockdown.close()
                 continue
-            yield ip, lockdown
+            yield address.full_ip, lockdown

pymobiledevice3/remote/tunnel_service.py

@@ -190,7 +190,7 @@ class RemotePairingTunnel(ABC):
         self._tun_read_task = asyncio.create_task(self.tun_read_task(), name=f'tun-read-{address}')
 
     async def stop_tunnel(self) -> None:
-        self._logger.debug('stopping tunnel')
+        self._logger.debug(f'[{asyncio.current_task().get_name()}] stopping tunnel')
         self._tun_read_task.cancel()
         with suppress(CancelledError):
             await self._tun_read_task
@@ -223,6 +223,9 @@ class RemotePairingQuicTunnel(RemotePairingTunnel, QuicConnectionProtocol):
         self._quic.send_datagram_frame(packet)
         self.transmit()
 
+        # Allow other tasks to run
+        await asyncio.sleep(0)
+
     async def request_tunnel_establish(self) -> dict:
         stream_id = self._quic.get_next_available_stream_id()
         # pad the data with random data to force the MTU size correctly
@@ -939,17 +942,21 @@ class RemotePairingManualPairingService(RemotePairingTunnelService):
 class CoreDeviceTunnelProxy(StartTcpTunnel):
     SERVICE_NAME = 'com.apple.internal.devicecompute.CoreDeviceProxy'
 
-    def __init__(self, lockdown: LockdownServiceProvider) -> None:
-        self._lockdown = lockdown
-        self._service: Optional[ServiceConnection] = None
+    @classmethod
+    async def create(cls, lockdown: LockdownServiceProvider) -> 'CoreDeviceTunnelProxy':
+        return cls(await lockdown.aio_start_lockdown_service(cls.SERVICE_NAME), lockdown.udid)
+
+    def __init__(self, service: ServiceConnection, remote_identifier: str) -> None:
+        self._service: ServiceConnection = service
+        self._remote_identifier: str = remote_identifier
 
     @property
     def remote_identifier(self) -> str:
-        return self._lockdown.udid
+        return self._remote_identifier
 
     @asynccontextmanager
     async def start_tcp_tunnel(self) -> AsyncGenerator['TunnelResult', None]:
-        self._service = await self._lockdown.aio_start_lockdown_service(self.SERVICE_NAME)
+        assert self._service is not None, 'service must be connected first'
         tunnel = RemotePairingTcpTunnel(self._service.reader, self._service.writer)
         handshake_response = await tunnel.request_tunnel_establish()
         tunnel.start_tunnel(handshake_response['clientParameters']['address'],
@@ -1078,13 +1085,14 @@ async def get_remote_pairing_tunnel_services(
         udid: Optional[str] = None) -> list[RemotePairingTunnelService]:
     result = []
     for answer in await browse_remotepairing(timeout=bonjour_timeout):
-        for ip in answer.ips:
+        for address in answer.addresses:
             for identifier in iter_remote_paired_identifiers():
                 if udid is not None and identifier != udid:
                     continue
                 conn = None
                 try:
-                    conn = await create_core_device_tunnel_service_using_remotepairing(identifier, ip, answer.port)
+                    conn = await create_core_device_tunnel_service_using_remotepairing(
+                        identifier, address.full_ip, answer.port)
                     result.append(conn)
                     break
                 except ConnectionAbortedError:

pymobiledevice3/remote/utils.py

@@ -17,8 +17,8 @@ async def get_rsds(bonjour_timeout: float = DEFAULT_BONJOUR_TIMEOUT, udid: Optio
     result = []
     with stop_remoted():
         for answer in await browse_remoted(timeout=bonjour_timeout):
-            for ip in answer.ips:
-                rsd = RemoteServiceDiscoveryService((ip, RSD_PORT))
+            for address in answer.addresses:
+                rsd = RemoteServiceDiscoveryService((address.full_ip, RSD_PORT))
                 try:
                     await rsd.connect()
                 except ConnectionRefusedError:

pymobiledevice3/tunneld/server.py

@@ -7,10 +7,13 @@ import signal
 import traceback
 import warnings
 from contextlib import asynccontextmanager, suppress
+from ssl import SSLEOFError
 from typing import Optional, Union
 
 import construct
 
+from pymobiledevice3.bonjour import browse_remoted
+
 with warnings.catch_warnings():
     # Ignore: "Core Pydantic V1 functionality isn't compatible with Python 3.14 or greater."
     warnings.simplefilter('ignore', category=UserWarning)
@@ -22,9 +25,9 @@ from fastapi import FastAPI
 from packaging.version import Version
 
 from pymobiledevice3 import usbmux
-from pymobiledevice3.bonjour import REMOTED_SERVICE_NAMES, browse
 from pymobiledevice3.exceptions import ConnectionFailedError, ConnectionFailedToUsbmuxdError, DeviceNotFoundError, \
-    GetProhibitedError, IncorrectModeError, InvalidServiceError, LockdownError, MuxException, PairingError
+    GetProhibitedError, IncorrectModeError, InvalidServiceError, LockdownError, MuxException, PairingError, \
+    StreamClosedError
 from pymobiledevice3.lockdown import create_using_usbmux, get_mobdev2_lockdowns
 from pymobiledevice3.osu.os_utils import get_os_utils
 from pymobiledevice3.remote.common import TunnelProtocol
@@ -42,7 +45,7 @@ REATTEMPT_INTERVAL = 5
 REATTEMPT_COUNT = 5
 
 REMOTEPAIRING_INTERVAL = 5
-MOVDEV2_INTERVAL = 5
+MOBDEV2_INTERVAL = 5
 
 USBMUX_INTERVAL = 2
 OSUTILS = get_os_utils()
@@ -91,50 +94,75 @@ class TunneldCore:
 
     @asyncio_print_traceback
     async def monitor_usb_task(self) -> None:
-        previous_ips = []
-        while True:
-            current_ips = OSUTILS.get_ipv6_ips()
-            added = [ip for ip in current_ips if ip not in previous_ips]
-            removed = [ip for ip in previous_ips if ip not in current_ips]
-
-            previous_ips = current_ips
-
-            logger.debug(f'added interfaces: {added}')
-            logger.debug(f'removed interfaces: {removed}')
-
-            for ip in removed:
-                if ip in self.tunnel_tasks:
-                    self.tunnel_tasks[ip].task.cancel()
-                    await self.tunnel_tasks[ip].task
-
-            for ip in added:
-                self.tunnel_tasks[ip] = TunnelTask(
-                    task=asyncio.create_task(self.handle_new_potential_usb_cdc_ncm_interface_task(ip),
-                                             name=f'handle-new-potential-usb-cdc-ncm-interface-task-{ip}'))
-
-            # wait before re-iterating
-            await asyncio.sleep(1)
+        try:
+            previous_ips = []
+            while True:
+                current_ips = OSUTILS.get_ipv6_ips()
+                added = [ip for ip in current_ips if ip not in previous_ips]
+                removed = [ip for ip in previous_ips if ip not in current_ips]
+
+                previous_ips = current_ips
+
+                # logger.debug(f'added interfaces: {added}')
+                # logger.debug(f'removed interfaces: {removed}')
+
+                for ip in removed:
+                    if ip in self.tunnel_tasks:
+                        self.tunnel_tasks[ip].task.cancel()
+                        with suppress(asyncio.CancelledError):
+                            await self.tunnel_tasks[ip].task
+
+                if added:
+                    # A new interface was attached
+                    for answer in await browse_remoted():
+                        for address in answer.addresses:
+                            if address.iface.startswith('utun'):
+                                # Skip already established tunnels
+                                continue
+                            if address.full_ip in self.tunnel_tasks.keys():
+                                # Skip already established tunnels
+                                continue
+                            self.tunnel_tasks[address.full_ip] = TunnelTask(
+                                task=asyncio.create_task(
+                                    self.handle_new_potential_usb_cdc_ncm_interface_task(address.full_ip),
+                                    name=f'handle-new-potential-usb-cdc-ncm-interface-task-{address.full_ip}'))
+
+                # wait before re-iterating
+                await asyncio.sleep(1)
+        except asyncio.CancelledError:
+            pass
 
     @asyncio_print_traceback
     async def monitor_wifi_task(self) -> None:
         try:
             while True:
-                for service in await get_remote_pairing_tunnel_services():
-                    if service.hostname in self.tunnel_tasks:
-                        # skip tunnel if already exists for this ip
-                        await service.close()
-                        continue
-                    if self.tunnel_exists_for_udid(service.remote_identifier):
-                        # skip tunnel if already exists for this udid
-                        await service.close()
-                        continue
-                    self.tunnel_tasks[service.hostname] = TunnelTask(
-                        task=asyncio.create_task(self.start_tunnel_task(service.hostname, service),
-                                                 name=f'start-tunnel-task-wifi-{service.hostname}'),
-                        udid=service.remote_identifier
-                    )
+                try:
+                    remote_pairing_tunnel_services = await get_remote_pairing_tunnel_services()
+                    for service in remote_pairing_tunnel_services:
+                        if service.hostname in self.tunnel_tasks:
+                            # skip tunnel if already exists for this ip
+                            await service.close()
+                            continue
+                        if self.tunnel_exists_for_udid(service.remote_identifier):
+                            # skip tunnel if already exists for this udid
+                            await service.close()
+                            continue
+                        self.tunnel_tasks[service.hostname] = TunnelTask(
+                            task=asyncio.create_task(self.start_tunnel_task(service.hostname, service),
+                                                     name=f'start-tunnel-task-wifi-{service.hostname}'),
+                            udid=service.remote_identifier
+                        )
+                except asyncio.exceptions.IncompleteReadError:
+                    continue
+                except asyncio.CancelledError:
+                    # Raise and cancel gracefully
+                    raise
+                except Exception:
+                    logger.error(f'Got exception from {asyncio.current_task().get_name()}: {traceback.format_exc()}')
+                    continue
                 await asyncio.sleep(REMOTEPAIRING_INTERVAL)
         except asyncio.CancelledError:
+            # Cancel gracefully
             pass
 
     @asyncio_print_traceback
@@ -145,11 +173,20 @@ class TunneldCore:
                     for mux_device in usbmux.list_devices():
                         task_identifier = f'usbmux-{mux_device.serial}-{mux_device.connection_type}'
                         if self.tunnel_exists_for_udid(mux_device.serial):
+                            # Skip if already established a tunnel for this udid
                             continue
+                        if task_identifier in self.tunnel_tasks:
+                            # Skip if already trying to establish a tunnel for this device
+                            continue
+                        service = None
                         try:
-                            service = CoreDeviceTunnelProxy(create_using_usbmux(mux_device.serial))
+                            with create_using_usbmux(mux_device.serial) as lockdown:
+                                service = await CoreDeviceTunnelProxy.create(lockdown)
                         except (MuxException, InvalidServiceError, GetProhibitedError, construct.core.StreamError,
-                                ConnectionAbortedError, DeviceNotFoundError, LockdownError, IncorrectModeError):
+                                ConnectionAbortedError, DeviceNotFoundError, LockdownError, IncorrectModeError,
+                                SSLEOFError):
+                            if service is not None:
+                                await service.close()
                             continue
                         self.tunnel_tasks[task_identifier] = TunnelTask(
                             udid=mux_device.serial,
@@ -172,22 +209,26 @@ class TunneldCore:
         try:
             while True:
                 async for ip, lockdown in get_mobdev2_lockdowns(only_paired=True):
-                    if self.tunnel_exists_for_udid(lockdown.udid):
-                        # skip tunnel if already exists for this udid
-                        continue
-                    task_identifier = f'mobdev2-{lockdown.udid}-{ip}'
-                    try:
-                        tunnel_service = CoreDeviceTunnelProxy(lockdown)
-                    except InvalidServiceError:
-                        logger.warning(f'[{task_identifier}] failed to start CoreDeviceTunnelProxy - skipping')
-                        lockdown.close()
-                        continue
+                    with lockdown:
+                        udid = lockdown.udid
+                        task_identifier = f'mobdev2-{udid}-{ip}'
+                        if self.tunnel_exists_for_udid(udid):
+                            # Skip tunnel if already exists for this udid
+                            continue
+                        if task_identifier in self.tunnel_tasks:
+                            # Skip if already trying to establish a tunnel for this device
+                            continue
+                        try:
+                            tunnel_service = await CoreDeviceTunnelProxy.create(lockdown)
+                        except InvalidServiceError:
+                            logger.warning(f'[{task_identifier}] failed to start CoreDeviceTunnelProxy - skipping')
+                            continue
                     self.tunnel_tasks[task_identifier] = TunnelTask(
                         task=asyncio.create_task(self.start_tunnel_task(task_identifier, tunnel_service),
                                                  name=f'start-tunnel-task-{task_identifier}'),
-                        udid=lockdown.udid
+                        udid=udid
                     )
-                await asyncio.sleep(MOVDEV2_INTERVAL)
+                await asyncio.sleep(MOBDEV2_INTERVAL)
         except asyncio.CancelledError:
             pass
 
@@ -219,8 +260,8 @@ class TunneldCore:
                 else:
                     bailed_out = True
                     logger.debug(
-                        f'not establishing tunnel from {asyncio.current_task().get_name()} '
-                        f'since there is already an active one for same udid')
+                        f'[{asyncio.current_task().get_name()}] Not establishing tunnel since there is already an '
+                        f'active one for same udid')
         except asyncio.CancelledError:
             pass
         except (asyncio.exceptions.IncompleteReadError, TimeoutError, OSError, ConnectionResetError, StreamError,
@@ -254,30 +295,28 @@ class TunneldCore:
     async def handle_new_potential_usb_cdc_ncm_interface_task(self, ip: str) -> None:
         rsd = None
         try:
-            answers = None
-            for i in range(REATTEMPT_COUNT):
-                answers = await browse(REMOTED_SERVICE_NAMES, [ip])
-                if answers:
-                    break
-                logger.debug(f'No addresses found for: {ip}')
-                await asyncio.sleep(REATTEMPT_INTERVAL)
-
-            if not answers:
-                raise asyncio.CancelledError()
-
-            peer_address = answers[0].ips[0]
-
             # establish an untrusted RSD handshake
-            rsd = RemoteServiceDiscoveryService((peer_address, RSD_PORT))
+            rsd = RemoteServiceDiscoveryService((ip, RSD_PORT))
 
             with stop_remoted():
-                try:
-                    await rsd.connect()
-                except (ConnectionRefusedError, TimeoutError):
-                    raise asyncio.CancelledError()
+                first_time = True
+                retry = False
+                while retry or first_time:
+                    retry = False
+                    try:
+                        await rsd.connect()
+                    except StreamClosedError:
+                        # Could be on first try because of remoted race
+                        if first_time:
+                            retry = True
+                    except (ConnectionRefusedError, TimeoutError, OSError):
+                        raise asyncio.CancelledError()
+                    finally:
+                        first_time = False
 
             if (self.protocol == TunnelProtocol.QUIC) and (Version(rsd.product_version) < Version('17.0.0')):
                 await rsd.close()
+                rsd = None
                 raise asyncio.CancelledError()
 
             await asyncio.create_task(
@@ -299,7 +338,7 @@ class TunneldCore:
                     pass
 
             if ip in self.tunnel_tasks:
-                # in case the tunnel was removed just now
+                # In case the tunnel was removed just now
                 self.tunnel_tasks.pop(ip)
 
     async def close(self) -> None:
@@ -325,7 +364,7 @@ class TunneldCore:
         """ Cancel active tunnels """
         for tunnel_ip in self.get_tunnels_ips().get(udid, []):
             self.tunnel_tasks.pop(tunnel_ip).task.cancel()
-            logger.info(f'canceling tunnel {tunnel_ip}')
+            logger.info(f'Canceling tunnel {tunnel_ip}')
 
     def clear(self) -> None:
         """ Clear active tunnels """
@@ -348,7 +387,6 @@ class TunneldRunner:
                  wifi_monitor: bool = True, usbmux_monitor: bool = True, mobdev2_monitor: bool = True):
         @asynccontextmanager
         async def lifespan(app: FastAPI):
-            logging.getLogger('zeroconf').disabled = True
             self._tunneld_core.start()
             yield
             logger.info('Closing tunneld tasks...')
@@ -427,7 +465,8 @@ class TunneldRunner:
                 if not created_task and connection_type in ('usbmux', None):
                     task_identifier = f'usbmux-{udid}'
                     try:
-                        service = CoreDeviceTunnelProxy(create_using_usbmux(udid))
+                        with create_using_usbmux(udid) as lockdown:
+                            service = await CoreDeviceTunnelProxy.create(lockdown)
                         task = asyncio.create_task(
                             self._tunneld_core.start_tunnel_task(task_identifier, service, protocol=TunnelProtocol.TCP,
                                                                  queue=queue),
@@ -469,7 +508,7 @@ class TunneldRunner:
                                         }}))
 
             if not created_task:
-                return fastapi.Response(status_code=501, content=json.dumps({'error': 'task not not created'}))
+                return fastapi.Response(status_code=501, content=json.dumps({'error': 'task not created'}))
 
             tunnel: Optional[TunnelResult] = await queue.get()
             if tunnel is not None:

pymobiledevice3/usbmux.py

@@ -174,15 +174,17 @@ class MuxConnection:
         # first attempt to connect with possibly the wrong version header (plist protocol)
         sock = MuxConnection.create_usbmux_socket(usbmux_address=usbmux_address)
 
-        message = usbmuxd_request.build({
-            'header': {'version': usbmuxd_version.PLIST, 'message': usbmuxd_msgtype.PLIST, 'tag': 1},
-            'data': plistlib.dumps({'MessageType': 'ReadBUID'})
-        })
-        sock.send(message)
-        response = usbmuxd_response.parse_stream(sock)
-
-        # if we sent a bad request, we should re-create the socket in the correct version this time
-        sock.close()
+        try:
+            message = usbmuxd_request.build({
+                'header': {'version': usbmuxd_version.PLIST, 'message': usbmuxd_msgtype.PLIST, 'tag': 1},
+                'data': plistlib.dumps({'MessageType': 'ReadBUID'})
+            })
+            sock.send(message)
+            response = usbmuxd_response.parse_stream(sock)
+
+        finally:
+            # If we sent a bad request, we should re-create the socket in the correct version this time
+            sock.close()
         sock = MuxConnection.create_usbmux_socket(usbmux_address=usbmux_address)
 
         if response.header.version == usbmuxd_version.BINARY:
@@ -414,9 +416,11 @@ def create_mux(usbmux_address: Optional[str] = None) -> MuxConnection:
 
 def list_devices(usbmux_address: Optional[str] = None) -> list[MuxDevice]:
     mux = create_mux(usbmux_address=usbmux_address)
-    mux.get_device_list(0.1)
-    devices = mux.devices
-    mux.close()
+    try:
+        mux.get_device_list(0.1)
+        devices = mux.devices
+    finally:
+        mux.close()
     return devices
 
 

pymobiledevice3/utils.py

@@ -45,7 +45,7 @@ def asyncio_print_traceback(f: Callable):
     async def wrapper(*args, **kwargs):
         try:
             return await f(*args, **kwargs)
-        except Exception as e:  # noqa: E72
+        except (Exception, RuntimeError) as e:  # noqa: E72
             if not isinstance(e, asyncio.CancelledError):
                 traceback.print_exc()
             raise

{pymobiledevice3-4.27.7.dist-info → pymobiledevice3-5.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pymobiledevice3
-Version: 4.27.7
+Version: 5.0.0
 Summary: Pure python3 implementation for working with iDevices (iPhone, etc...)
 Author-email: doronz88 <doron88@gmail.com>, matan <matan1008@gmail.com>
 Maintainer-email: doronz88 <doron88@gmail.com>, matan <matan1008@gmail.com>
@@ -47,7 +47,6 @@ Requires-Dist: nest_asyncio>=1.5.5
 Requires-Dist: Pillow
 Requires-Dist: inquirer3>=0.6.0
 Requires-Dist: ipsw_parser>=1.3.4
-Requires-Dist: zeroconf>=0.132.2
 Requires-Dist: ifaddr
 Requires-Dist: hyperframe
 Requires-Dist: srptools

{pymobiledevice3-4.27.7.dist-info → pymobiledevice3-5.0.0.dist-info}/RECORD

@@ -7,35 +7,35 @@ misc/remotexpc_sniffer.py,sha256=EThsKN0Vbs-mnLKCDXeooqg0MdpSkjwhAZHZwvhI458,797
 misc/understanding_idevice_protocol_layers.md,sha256=8tEqRXWOUPoxOJLZVh7C7H9JGCh2sQ3B5UH8_AymaQc,18805
 misc/usbmux_sniff.sh,sha256=iWtbucOEQ9_UEFXk9x-2VNt48Jg5zrPsnUbZ_LfZxwA,212
 pymobiledevice3/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pymobiledevice3/__main__.py,sha256=1nv18QRgR_FDq5rE95uhdZGOQ6xkPzNDrcMzQQs8ZZ4,11697
-pymobiledevice3/_version.py,sha256=o71ypd5ta4I52mZXxyMHxfYh6TBRnN5IHKzT1nOt2gI,706
-pymobiledevice3/bonjour.py,sha256=-Q_TLBGJ6qW3CX_DgBcz-CXfWSwxWVQ2L64hk6PxnDY,5631
+pymobiledevice3/__main__.py,sha256=viUbhGzaoDi18zu5crX33PMws4qNBjBTwnaK5rAaObY,11651
+pymobiledevice3/_version.py,sha256=cF99FZpN-aTdrzTHYCxKJsYbLYzvaOLuf8fkq4yEuRk,704
+pymobiledevice3/bonjour.py,sha256=_f5RQs9uLDjDFsXMvykQs8vFoGJXiw6xfth86qewEGA,13719
 pymobiledevice3/ca.py,sha256=mTvWdSjTZw6Eb-22-IZ323GyA1G6CXYmdPedImTjm3A,10542
 pymobiledevice3/common.py,sha256=-PG6oaUkNFlB3jb7E0finMrX8wqhkS-cuTAfmLvZUmc,329
 pymobiledevice3/exceptions.py,sha256=VqWB6WWoMrXt8GDdKqRHeJ1otP-eZIThoHERswXWqpw,10347
 pymobiledevice3/irecv.py,sha256=FoEln1_zHkAiNcEctB5bStfhKNgniOSg7lg9xcX1U2Q,10596
 pymobiledevice3/irecv_devices.py,sha256=BG30ecXSChxdyYCCGIrIO0sVWT31hbKymB78nZWVfWc,38506
-pymobiledevice3/lockdown.py,sha256=xejqmSLhJsvM-F4rs4InxtVVtSYYSN3VJXnxd-ijspI,38814
+pymobiledevice3/lockdown.py,sha256=jVrw--ifD8ewGwp5fZVYdoQDuaUiSckZ7fnB8dDtc58,38615
 pymobiledevice3/lockdown_service_provider.py,sha256=l5N72tiuI-2uowk8wu6B7qkjY2UmqQsnhdJqvJy3I8A,1744
 pymobiledevice3/pair_records.py,sha256=Tr28mlBWPXvOF7vdKBDOuw1rCRwm6RViDTGbikfP77I,6034
 pymobiledevice3/service_connection.py,sha256=_-PTLFr3krtwEBNHEKXCd_2eOGwMpbsfPbB8AX2uN-g,14861
 pymobiledevice3/tcp_forwarder.py,sha256=TVtIHn4hFlNIMEYXW9nwdSEhLfHaEHf4jkMsfJXLrTA,8906
-pymobiledevice3/usbmux.py,sha256=CvJ_NgH77wcfF7ZAQuLGHTIYkuWvhXPYZNQNR7-Jf8A,16820
-pymobiledevice3/utils.py,sha256=ybli_l8JIG2usFiToAsVYe0Ymg3q0bcpKqmYUF_wpi8,2179
+pymobiledevice3/usbmux.py,sha256=NSgcgEbaFxGqyyYuZm4SgLx1DPdkP1oeGRLZ8bEkXes,16916
+pymobiledevice3/utils.py,sha256=X3hU3wf_REUPRS-XtLgGgI2pxIwDGZP0RpZvZf7hOBY,2195
 pymobiledevice3/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pymobiledevice3/cli/activation.py,sha256=mF64abX7d0bbyALVC-f_9rjc1DuB6mukP3Zwg9Hoj1Y,1321
 pymobiledevice3/cli/afc.py,sha256=z-qnBVUPA4uOnXADkYVyRJxeibRDFF3j5LejHt_6UW4,2129
 pymobiledevice3/cli/amfi.py,sha256=6hlqKrKOFj0secUnLQ8grDDnnh3fRsO6x_vo40oy22w,963
 pymobiledevice3/cli/apps.py,sha256=LH75A1gDRGP0nWO4QFcOUDg0EdphkGuYnWJgIQHrIBg,3859
 pymobiledevice3/cli/backup.py,sha256=SyHojiRRguxdkAPMz_Rp_9-zJNeuOtmpa0imdPN12-4,6691
-pymobiledevice3/cli/bonjour.py,sha256=qWFH05BZ-FlnSilVP0PMzPUidfBs5LPdepMhPyIliFE,2806
+pymobiledevice3/cli/bonjour.py,sha256=X5W-5rPLX3xAwEeQJLPB_iOhdHcOL9ePkrm3xx4-Qic,2854
 pymobiledevice3/cli/cli_common.py,sha256=lQFhkTwPfi1UYFkMiDc-jrId2s2yHwzF5lFTK0dXM_s,12945
 pymobiledevice3/cli/companion_proxy.py,sha256=ey0X3moJ49zVJoNCpRMMHmf9fBZfdqimhz2VCA35oII,581
 pymobiledevice3/cli/completions.py,sha256=t8oryezQTcWDno_E2Cch7o1f-qURVL9M1Z4o6uLA_kM,1722
 pymobiledevice3/cli/crash.py,sha256=m1vs0_KUy4cxu8vHYjn7olay8oPQGTFZqMCHspnGpVs,3181
 pymobiledevice3/cli/developer.py,sha256=qSGvUZPVCwJZQaE9jF2vk-0Fp3x_2-wIlFjy-QoM5cI,61471
 pymobiledevice3/cli/diagnostics.py,sha256=VDWr41ryIZcpuQp47nQSzCiSuIILExqGSrwFizXCIkI,3641
-pymobiledevice3/cli/lockdown.py,sha256=498SgKdIC_YaoEjVtQQvo8bvv8GDeUTY8yWh4isy_qc,6941
+pymobiledevice3/cli/lockdown.py,sha256=AV_7snLEkc9mbwWVlWg1Ki0tWQMtPHReziun_lxjNvY,7133
 pymobiledevice3/cli/mounter.py,sha256=AnNneNF_kW7XnBMe4V5cvlbLYd_mAP4tuB3PXLQpeiA,7724
 pymobiledevice3/cli/notification.py,sha256=vqn8uPslr7A9HiZ4yrs7YKF2VLS7Nk4G7ab5ELljpVQ,1962
 pymobiledevice3/cli/pcap.py,sha256=KzFxXWFRYWNOEJE1XAuMF2cG8I4k5wFVcMRhSdY4GQg,2188
@@ -43,7 +43,7 @@ pymobiledevice3/cli/power_assertion.py,sha256=aTlesowRyrbd9JXebEZe9SomTkDkZaAXIO
 pymobiledevice3/cli/processes.py,sha256=XNJe2KaacP7c-1NtR_HF6Gd5rByyj3vpyyT_xEntIbA,1102
 pymobiledevice3/cli/profile.py,sha256=WT8hgYOmkOHUlWtEz-BoBelCerT70TpwBBzJC8wRLmY,7939
 pymobiledevice3/cli/provision.py,sha256=yWabJrieISrBfFo7vCFIAM8xXLG-8_9qRe1igkTHIA0,1967
-pymobiledevice3/cli/remote.py,sha256=2XFa0x1EwPoRpndizM70QrKgPPj4BELpnoN1VZZUB5Q,11969
+pymobiledevice3/cli/remote.py,sha256=n_PbPnUqnQRYxVG-y8rERmWu__64OY0mDx12mX62pRg,11999
 pymobiledevice3/cli/restore.py,sha256=vg3yjKOjsONUUzPp-XHIjNGMV8qCfptJrz6eJzG2diY,8172
 pymobiledevice3/cli/springboard.py,sha256=pYMqnD0zN_ETIASPqxBohi54F2HMC9jCILW4epVaaIk,3140
 pymobiledevice3/cli/syslog.py,sha256=JfLhjyVAeRx16VC4BsAu308rABjcIQX8DB7vbVKGiic,7462
@@ -60,8 +60,8 @@ pymobiledevice3/remote/module_imports.py,sha256=DwExSL1r4kkFIWmXiQpqPo-cGl4duYd3
 pymobiledevice3/remote/remote_service.py,sha256=fCyzm4oT_WEorAXVHVLYnIOyTOuMGhX69Co3HkUdRYY,867
 pymobiledevice3/remote/remote_service_discovery.py,sha256=iqPE1PiDDB2ISK-ThuUPEiSU9ETZ-FGTcANhb6MrWmo,7156
 pymobiledevice3/remote/remotexpc.py,sha256=KbFHaH4D3RnaATve6kaIpJMHNF8H-kdhbRbEbxFmO6w,8082
-pymobiledevice3/remote/tunnel_service.py,sha256=zVg9t7Z_zzK4Rav8Xn_UEanIXTzBvcjEsd_-bBYs1CE,46451
-pymobiledevice3/remote/utils.py,sha256=BgUODRwkET5lyloZxJ-PrVZqTvyOlBuJ-MM7OCSqZ9g,2506
+pymobiledevice3/remote/tunnel_service.py,sha256=LhPCduH4mNU8sACGI3aJeXpH0UjPfvsjm0FGA4QIV_4,46830
+pymobiledevice3/remote/utils.py,sha256=PV9tICVY6-L7eoqRF1yNmOGxdC2kp9h0kBqeoIAo4pA,2530
 pymobiledevice3/remote/xpc_message.py,sha256=-nVbf88ZN4ZNxLg6cOq4FfeKXYAoVRKnwGdfe7s-sZE,9336
 pymobiledevice3/remote/core_device/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pymobiledevice3/remote/core_device/app_service.py,sha256=x_K-3IA4NWG-skyffKyeGrS7slAbn3MsVLhdY62FSh0,5066
@@ -164,10 +164,10 @@ pymobiledevice3/services/web_protocol/session_protocol.py,sha256=7dJkFyivu554K6I
 pymobiledevice3/services/web_protocol/switch_to.py,sha256=hDddJUEePbRN-8xlllOeGhnYvE4NEnd8JJIlosLMB9c,2880
 pymobiledevice3/tunneld/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pymobiledevice3/tunneld/api.py,sha256=EfGKXEWhsMSB__menPmRmL9R6dpazVJDUy7B3pn05MM,2357
-pymobiledevice3/tunneld/server.py,sha256=L_98QatvVuyiXexoHF5rA0V56wC84VLeKhLyiFWwHrc,22960
-pymobiledevice3-4.27.7.dist-info/licenses/LICENSE,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
-pymobiledevice3-4.27.7.dist-info/METADATA,sha256=SeVtOrCTF3zAP9RVUQWVMVUsbhFVazGwlJutdprYp08,17450
-pymobiledevice3-4.27.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pymobiledevice3-4.27.7.dist-info/entry_points.txt,sha256=jJMlOanHlVwUxcY__JwvKeWPrvBJr_wJyEq4oHIZNKE,66
-pymobiledevice3-4.27.7.dist-info/top_level.txt,sha256=MjZoRqcWPOh5banG-BbDOnKEfsS3kCxqV9cv-nzyg2Q,21
-pymobiledevice3-4.27.7.dist-info/RECORD,,
+pymobiledevice3/tunneld/server.py,sha256=fbwnKrm4d84MpopWKIWoQF1_ZEUB4vONKmHih6qce_U,25206
+pymobiledevice3-5.0.0.dist-info/licenses/LICENSE,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
+pymobiledevice3-5.0.0.dist-info/METADATA,sha256=kQKKC-FV5BNQqQUIOctTPVLa6wSnLgZXD06kbC9QLiI,17416
+pymobiledevice3-5.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pymobiledevice3-5.0.0.dist-info/entry_points.txt,sha256=jJMlOanHlVwUxcY__JwvKeWPrvBJr_wJyEq4oHIZNKE,66
+pymobiledevice3-5.0.0.dist-info/top_level.txt,sha256=MjZoRqcWPOh5banG-BbDOnKEfsS3kCxqV9cv-nzyg2Q,21
+pymobiledevice3-5.0.0.dist-info/RECORD,,