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

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/services/dvt/instruments/core_profile_session_tap.py

@@ -100,10 +100,24 @@ kcdata_types = {
     'STACKSHOT_KCTYPE_LATENCY_INFO_THREAD': 0x92d,
     'STACKSHOT_KCTYPE_LOADINFO64_TEXT_EXEC': 0x92e,
 
+    'STACKSHOT_KCTYPE_USER_ASYNC_START_INDEX': 0x932,
+    'STACKSHOT_KCTYPE_USER_ASYNC_STACKLR64': 0x933,
+
     'STACKSHOT_KCTYPE_TASK_DELTA_SNAPSHOT': 0x940,
     'STACKSHOT_KCTYPE_THREAD_DELTA_SNAPSHOT': 0x941,
-    'STACKSHOT_KCTYPE_UNKNOWN_0x942': 0x942,
+    'STACKSHOT_KCCONTAINER_SHAREDCACHE': 0x942,
     'STACKSHOT_KCTYPE_UNKNOWN_0x943': 0x943,
+    'STACKSHOT_KCCONTAINER_EXCLAVES': 0x949,
+    'STACKSHOT_KCCONTAINER_EXCLAVE_SCRESULT': 0x94a,
+
+    'STACKSHOT_KCCONTAINER_EXCLAVE_IPCSTACKENTRY': 0x94c,
+    'STACKSHOT_KCTYPE_EXCLAVE_IPCSTACKENTRY_INFO': 0x94d,
+    'STACKSHOT_KCTYPE_EXCLAVE_IPCSTACKENTRY_ECSTACK': 0x94e,
+    'STACKSHOT_KCCONTAINER_EXCLAVE_ADDRESSSPACE': 0x94f,
+
+    'STACKSHOT_KCCONTAINER_EXCLAVE_TEXTLAYOUT': 0x952,
+    'STACKSHOT_KCTYPE_EXCLAVE_TEXTLAYOUT_INFO': 0x953,
+    'STACKSHOT_KCTYPE_EXCLAVE_TEXTLAYOUT_SEGMENTS': 0x954,
 
     'KCDATA_TYPE_BUFFER_END': 0xF19158ED,
 
@@ -185,6 +199,16 @@ predefined_names = {
     kcdata_types_enum.STACKSHOT_KCTYPE_STACKSHOT_FAULT_STATS: 'stackshot_fault_stats',
     kcdata_types_enum.STACKSHOT_KCTYPE_STACKSHOT_DURATION: 'stackshot_duration',
     kcdata_types_enum.STACKSHOT_KCTYPE_LOADINFO64_TEXT_EXEC: 'dyld_load_info_text_exec',
+    kcdata_types_enum.STACKSHOT_KCTYPE_USER_ASYNC_STACKLR64: 'user_async_stack_lr',
+    kcdata_types_enum.STACKSHOT_KCCONTAINER_SHAREDCACHE: 'container_sharedcache',
+    kcdata_types_enum.STACKSHOT_KCCONTAINER_EXCLAVES: 'container_exclaves',
+    kcdata_types_enum.STACKSHOT_KCCONTAINER_EXCLAVE_SCRESULT: 'exclave_scresult',
+    kcdata_types_enum.STACKSHOT_KCCONTAINER_EXCLAVE_IPCSTACKENTRY: 'exclave_ipc_stack_entry',
+    kcdata_types_enum.STACKSHOT_KCTYPE_EXCLAVE_IPCSTACKENTRY_ECSTACK: 'exclave_ipc_stack_entry_ecstack',
+    kcdata_types_enum.STACKSHOT_KCCONTAINER_EXCLAVE_ADDRESSSPACE: 'exclave_address_space',
+    kcdata_types_enum.STACKSHOT_KCCONTAINER_EXCLAVE_TEXTLAYOUT: 'exclave_text_layout',
+    kcdata_types_enum.STACKSHOT_KCTYPE_EXCLAVE_TEXTLAYOUT_INFO: 'exclave_text_layout_info',
+    kcdata_types_enum.STACKSHOT_KCTYPE_EXCLAVE_TEXTLAYOUT_SEGMENTS: 'exclave_text_layout_segments',
 }
 
 predefined_name_substruct = 'name' / Computed(lambda ctx: predefined_names[ctx._.type])
@@ -443,6 +467,39 @@ loadinfo64_text_exec = Struct(
     ),
 )
 
+user_async_stacklr64 = Struct(
+    predefined_name_substruct,
+    'obj' / Struct(
+        'lr' / Int64ul,
+    ),
+)
+
+exclave_ipcstackentry_ecstack = Struct(
+    predefined_name_substruct,
+    'obj' / Struct(
+        'addr' / Int64ul,
+    ),
+)
+
+exclave_textlayout_info = Struct(
+    predefined_name_substruct,
+    'obj' / Struct(
+        'layout_id' / Int64ul,
+        'etl_flags' / Int64ul,
+        'sharedcache_index' / Int32ul,
+    ),
+)
+
+exclave_textlayout_segments = Struct(
+    predefined_name_substruct,
+    'obj' / Struct(
+        '_imageUUID' / Bytes(16),
+        'imageUUID' / Computed(lambda ctx: uuid.UUID(bytes=ctx._imageUUID)),
+        'layoutSegment_loadAddress' / Int64ul,
+        'layoutSegment_rawLoadAddress' / Int64ul,
+    ),
+)
+
 kcdata_types_structures = {
     kcdata_types_enum.KCDATA_TYPE_UINT32_DESC: uint32_desc,
     kcdata_types_enum.KCDATA_TYPE_UINT64_DESC: uint64_desc,
@@ -482,6 +539,10 @@ kcdata_types_structures = {
     kcdata_types_enum.KCDATA_TYPE_BUFFER_END: Pass,
     kcdata_types_enum.STACKSHOT_KCTYPE_STACKSHOT_DURATION: stackshot_duration,
     kcdata_types_enum.STACKSHOT_KCTYPE_LOADINFO64_TEXT_EXEC: loadinfo64_text_exec,
+    kcdata_types_enum.STACKSHOT_KCTYPE_USER_ASYNC_STACKLR64: user_async_stacklr64,
+    kcdata_types_enum.STACKSHOT_KCTYPE_EXCLAVE_IPCSTACKENTRY_ECSTACK: exclave_ipcstackentry_ecstack,
+    kcdata_types_enum.STACKSHOT_KCTYPE_EXCLAVE_TEXTLAYOUT_INFO: exclave_textlayout_info,
+    kcdata_types_enum.STACKSHOT_KCTYPE_EXCLAVE_TEXTLAYOUT_SEGMENTS: exclave_textlayout_segments,
 }
 
 kcdata_item = Struct(

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.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pymobiledevice3
-Version: 4.27.7
+Version: 5.0.1
 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.1.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=MpPN0ZsEisc17aqn7bpe-bL3iBKNBaREenP6NUe6-4s,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
@@ -138,7 +138,7 @@ pymobiledevice3/services/dvt/instruments/__init__.py,sha256=47DEQpj8HBSa-_TImW-5
 pymobiledevice3/services/dvt/instruments/activity_trace_tap.py,sha256=SARFCaEhDxams9slRKZBBiZDCmR6WDlRdho3mxZGNLY,8769
 pymobiledevice3/services/dvt/instruments/application_listing.py,sha256=6zWnYUyaxNFudrZo0oKGMTYG3T4sTm2w2XKi-jK-59E,666
 pymobiledevice3/services/dvt/instruments/condition_inducer.py,sha256=u7CfKvS2dkL3xzbmU9e8zWY29RKRPuAqi3PT6REErpQ,1243
-pymobiledevice3/services/dvt/instruments/core_profile_session_tap.py,sha256=YeV4xiI8QMc8O6Su0s6h7GiS27RhE14z9U9dlr7mV5k,27877
+pymobiledevice3/services/dvt/instruments/core_profile_session_tap.py,sha256=XYV_b-LiryH7UEoeyIlMJ7UFVmRAabp6RT7RLJQ_57o,30499
 pymobiledevice3/services/dvt/instruments/device_info.py,sha256=dP6PEW62MsRS8hUy3i000wwI2tE8jek_GvOmT1cjMUE,3085
 pymobiledevice3/services/dvt/instruments/energy_monitor.py,sha256=ZzkoC1wyK1zYskiXDtUoEa9PPWnDM9WLl4tZWxfVl-k,892
 pymobiledevice3/services/dvt/instruments/graphics.py,sha256=KjdO6o_rDsD1YfvW8rW2nOj0N7JfPblFTOlR9XIwwXY,588
@@ -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.1.dist-info/licenses/LICENSE,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
+pymobiledevice3-5.0.1.dist-info/METADATA,sha256=s8IX_VJnsx5y6tqtiY5JleNQhacBm6kN3eJVvur2GqY,17416
+pymobiledevice3-5.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pymobiledevice3-5.0.1.dist-info/entry_points.txt,sha256=jJMlOanHlVwUxcY__JwvKeWPrvBJr_wJyEq4oHIZNKE,66
+pymobiledevice3-5.0.1.dist-info/top_level.txt,sha256=MjZoRqcWPOh5banG-BbDOnKEfsS3kCxqV9cv-nzyg2Q,21
+pymobiledevice3-5.0.1.dist-info/RECORD,,