pymobiledevice3 4.27.7__tar.gz → 5.0.0__tar.gz

{pymobiledevice3-4.27.7 → pymobiledevice3-5.0.0}/PKG-INFO

@@ -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 → pymobiledevice3-5.0.0}/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-4.27.7 → pymobiledevice3-5.0.0}/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 = 'g0f0840055'
+__commit_id__ = commit_id = 'ga2babc5a5'

pymobiledevice3-5.0.0/pymobiledevice3/bonjour.py

@@ -0,0 +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 ipaddress
+import socket
+import struct
+import sys
+from collections import defaultdict
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Set, Tuple
+
+import ifaddr  # pip install ifaddr
+
+from pymobiledevice3.osu.os_utils import get_os_utils
+
+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"
+
+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 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)
+
+
+@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
+        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
+            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()
+
+    # 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[ServiceInstance]:
+    return await browse_service(REMOTED_SERVICE_NAME, 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[ServiceInstance]:
+    return await browse_service(REMOTEPAIRING_SERVICE_NAME, 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-4.27.7 → pymobiledevice3-5.0.0}/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-4.27.7 → pymobiledevice3-5.0.0}/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-4.27.7 → pymobiledevice3-5.0.0}/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-4.27.7 → pymobiledevice3-5.0.0}/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-4.27.7 → pymobiledevice3-5.0.0}/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-4.27.7 → pymobiledevice3-5.0.0}/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: