pymobiledevice3 7.0.7__tar.gz → 7.3.0__tar.gz

{pymobiledevice3-7.0.7 → pymobiledevice3-7.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pymobiledevice3
-Version: 7.0.7
+Version: 7.3.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>

{pymobiledevice3-7.0.7 → pymobiledevice3-7.3.0}/pymobiledevice3/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '7.0.7'
-__version_tuple__ = version_tuple = (7, 0, 7)
+__version__ = version = '7.3.0'
+__version_tuple__ = version_tuple = (7, 3, 0)
 
-__commit_id__ = commit_id = 'g2e159e580'
+__commit_id__ = commit_id = 'gdbcb99cc3'

{pymobiledevice3-7.0.7 → pymobiledevice3-7.3.0}/pymobiledevice3/cli/developer/accessibility/settings.py

@@ -1,3 +1,4 @@
+import ast
 import logging
 
 from typer_injector import InjectingTyper
@@ -30,7 +31,7 @@ def accessibility_settings_set(service_provider: ServiceProviderDep, setting: st
     in order to list all available use the "show" command
     """
     service = AccessibilityAudit(service_provider)
-    service.set_setting(setting, eval(value))
+    service.set_setting(setting, ast.literal_eval(value))
     OSUTILS.wait_return()
 
 

pymobiledevice3-7.3.0/pymobiledevice3/cli/developer/debugserver.py

@@ -0,0 +1,286 @@
+import logging
+import os
+import plistlib
+import signal
+import struct
+import subprocess
+import sys
+from pathlib import Path
+from tempfile import TemporaryDirectory
+from typing import Annotated, Optional
+from zipfile import ZipFile
+
+import typer
+from packaging.version import Version
+from plumbum import local
+from typer_injector import InjectingTyper
+
+from pymobiledevice3.cli.cli_common import RSDServiceProviderDep, ServiceProviderDep, print_json
+from pymobiledevice3.exceptions import RSDRequiredError
+from pymobiledevice3.lockdown import create_using_usbmux
+from pymobiledevice3.remote.remote_service_discovery import RemoteServiceDiscoveryService
+from pymobiledevice3.services.debugserver_applist import DebugServerAppList
+from pymobiledevice3.services.installation_proxy import InstallationProxyService
+from pymobiledevice3.tcp_forwarder import LockdownTcpForwarder
+
+DEBUGSERVER_CONNECTION_STEPS = """
+Follow the following connections steps from LLDB:
+
+(lldb) platform select remote-ios
+(lldb) target create /path/to/local/application.app
+(lldb) script lldb.target.module[0].SetPlatformFileSpec(lldb.SBFileSpec('/private/var/containers/Bundle/Application/<APP-UUID>/application.app'))
+(lldb) process connect connect://[{host}]:{port}   <-- ACTUAL CONNECTION DETAILS!
+(lldb) process launch
+"""
+
+
+logger = logging.getLogger(__name__)
+
+
+cli = InjectingTyper(
+    name="debugserver",
+    help="Start and drive debugserver sessions (RSD for iOS 17+, usbmux for older).",
+    no_args_is_help=True,
+)
+
+
+@cli.command("applist")
+def debugserver_applist(service_provider: ServiceProviderDep) -> None:
+    """Print the debugserver applist XML for the device."""
+    print_json(DebugServerAppList(service_provider).get())
+
+
+@cli.command("start-server")
+def debugserver_start_server(
+    service_provider: ServiceProviderDep,
+    local_port: Optional[int] = None,
+    host: Annotated[
+        str,
+        typer.Option(help="Address to bind the local port to."),
+    ] = "127.0.0.1",
+) -> None:
+    """
+    Start debugserver and print the LLDB connect string.
+
+    - For iOS < 17, you must forward to a local port (--local-port).
+    - For iOS >= 17, if connected over RSD, the remote host:port is printed for LLDB.
+    Connect quickly with your own LLDB client using the printed steps.
+    """
+
+    if Version(service_provider.product_version) < Version("17.0"):
+        service_name = "com.apple.debugserver.DVTSecureSocketProxy"
+    else:
+        service_name = "com.apple.internal.dt.remote.debugproxy"
+
+    if local_port is not None:
+        print(DEBUGSERVER_CONNECTION_STEPS.format(host=host, port=local_port))
+        print("Started port forwarding. Press Ctrl-C to close this shell when done")
+        sys.stdout.flush()
+        LockdownTcpForwarder(service_provider, local_port, service_name).start(address=host)
+    elif Version(service_provider.product_version) >= Version("17.0"):
+        if not isinstance(service_provider, RemoteServiceDiscoveryService):
+            raise RSDRequiredError(service_provider.identifier)
+        debugserver_port = service_provider.get_service_port(service_name)
+        print(DEBUGSERVER_CONNECTION_STEPS.format(host=service_provider.service.address[0], port=debugserver_port))
+    else:
+        print("local_port is required for iOS < 17.0")
+
+
+@cli.command("lldb")
+def debugserver_lldb(
+    service_provider: RSDServiceProviderDep,
+    project_or_ipa_path: Annotated[
+        Path,
+        typer.Argument(exists=True, file_okay=True, dir_okay=True),
+    ],
+    configuration: Annotated[
+        str,
+        typer.Option(help="Build configuration to invoke (e.g., Debug or Release)."),
+    ] = "Debug",
+    lldb_command: Annotated[
+        str,
+        typer.Option(help="Path to the lldb executable to run."),
+    ] = "lldb",
+    launch: Annotated[
+        bool,
+        typer.Option(help="Automatically launch the app after attaching."),
+    ] = False,
+    breakpoints: Annotated[
+        Optional[list[str]],
+        typer.Option("--break", "-b", help="Add multiple startup breakpoints"),
+    ] = None,
+    user_commands: Annotated[
+        Optional[list[str]],
+        typer.Option("--command", "-c", help="Additional commands to run at startup"),
+    ] = None,
+) -> None:
+    """
+    Automate lldb launch for a given xcodeproj or IPA.
+
+    \b
+    This will:
+    - Build the given xcodeproj (if provided)
+    - Extract the given IPA (if provided)
+    - Install it
+    - Start a debugserver attached to it
+    - Place breakpoints if given any
+    - Launch the application if requested
+    - Execute any additional commands if requested
+    - Switch to lldb shell
+    """
+    if Version(service_provider.product_version) < Version("17.0"):
+        logger.error("lldb is only supported on iOS >= 17.0")
+        return
+
+    commands = []
+    temp_dir = None
+    local_app = None
+    install_source = None
+
+    if project_or_ipa_path.suffix == ".xcodeproj":
+        with local.cwd(project_or_ipa_path.parent):
+            logger.info(f"Building {project_or_ipa_path} for {configuration} configuration")
+            local["xcodebuild"]["-project", str(project_or_ipa_path), "-configuration", configuration, "build"]()
+            app_candidates = [app for app in Path("build").rglob("*.app") if (app / "Info.plist").exists()]
+            if not app_candidates:
+                logger.error("No built .app with Info.plist found under build/.")
+                return
+            app_candidates.sort(key=lambda p: p.stat().st_mtime, reverse=True)
+            local_app = app_candidates[0].absolute()
+            install_source = local_app
+    elif project_or_ipa_path.suffix == ".ipa":
+        temp_dir = TemporaryDirectory()
+        with ZipFile(project_or_ipa_path, "r") as ipa_zip:
+            ipa_zip.extractall(temp_dir.name)
+        payload_dir = Path(temp_dir.name) / "Payload"
+        apps = list(payload_dir.glob("*.app"))
+        if not apps:
+            logger.error("No .app bundle found in IPA Payload.")
+            temp_dir.cleanup()
+            return
+        if len(apps) > 1:
+            logger.error("Multiple .app bundles found in IPA Payload; please provide a single-app IPA.")
+            temp_dir.cleanup()
+            return
+        local_app = apps[0].absolute()
+        install_source = project_or_ipa_path
+    else:
+        logger.error("Expected an .xcodeproj directory or an .ipa file.")
+        return
+
+    logger.info(f"Using app: {local_app}")
+
+    info_plist_path = local_app / "Info.plist"
+    info_plist = plistlib.loads(info_plist_path.read_bytes())
+    bundle_identifier = info_plist["CFBundleIdentifier"]
+    logger.info(f"Bundle identifier: {bundle_identifier}")
+
+    commands.append("platform select remote-ios")
+    commands.append(f'target create "{local_app.absolute()}"')
+
+    with InstallationProxyService(create_using_usbmux()) as installation_proxy:
+        logger.info("Installing app")
+        installation_proxy.install_from_local(install_source)
+        remote_path = installation_proxy.get_apps(bundle_identifiers=[bundle_identifier])[bundle_identifier]["Path"]
+        logger.info(f"Remote path: {remote_path}")
+        commands.append(f'script lldb.target.module[0].SetPlatformFileSpec(lldb.SBFileSpec("{remote_path}"))')
+
+    debugserver_port = service_provider.get_service_port("com.apple.internal.dt.remote.debugproxy")
+
+    # Add connection and launch commands
+    commands.append(f"process connect connect://[{service_provider.service.address[0]}]:{debugserver_port}")
+
+    if breakpoints:
+        for bp in breakpoints:
+            commands.append(f'breakpoint set -n "{bp}"')
+
+    if launch:
+        commands.append("process launch")
+
+    if user_commands:
+        # Add user commands
+        commands += user_commands
+
+    logger.info("Starting lldb with automated setup and connection")
+
+    # Works only on unix-based systems, so keep these imports here
+    import fcntl
+    import pty
+    import select as select_module
+    import termios
+    import tty
+
+    master, slave = pty.openpty()
+
+    process = None  # Initialize process variable for signal handler
+
+    # Copy terminal size from the current terminal to PTY
+    def resize_pty() -> None:
+        """Update PTY size to match current terminal size"""
+        size = struct.unpack(
+            "HHHH", fcntl.ioctl(sys.stdout.fileno(), termios.TIOCGWINSZ, struct.pack("HHHH", 0, 0, 0, 0))
+        )
+        fcntl.ioctl(master, termios.TIOCSWINSZ, struct.pack("HHHH", *size))
+        # Send SIGWINCH to the child process to notify it of the resize
+        if process is not None and process.poll() is None:
+            process.send_signal(signal.SIGWINCH)
+
+    # Initial resize
+    resize_pty()
+
+    # Set up signal handler for window resize
+    def handle_sigwinch(signum, frame):
+        resize_pty()
+
+    old_sigwinch_handler = signal.signal(signal.SIGWINCH, handle_sigwinch)
+
+    # Save original terminal settings
+    old_tty = termios.tcgetattr(sys.stdin)
+
+    try:
+        # Set TERM environment variable to enable colors
+        env = os.environ.copy()
+        env["TERM"] = os.environ.get("TERM", "xterm-256color")
+
+        process = subprocess.Popen([lldb_command], stdin=slave, stdout=slave, stderr=slave, env=env)
+        os.close(slave)
+
+        # Put terminal in raw mode for proper interaction
+        tty.setraw(sys.stdin.fileno())
+        # Send all commands through stdin
+        for command in commands:
+            os.write(master, (command + "\n").encode())
+
+        # Now redirect stdin from the terminal to lldb so user can interact
+        while True:
+            rlist, _, _ = select_module.select([sys.stdin, master], [], [])
+
+            if sys.stdin in rlist:
+                # User typed something
+                data = os.read(sys.stdin.fileno(), 1024)
+                if not data:
+                    break
+                os.write(master, data)
+
+            if master in rlist:
+                # lldb has output
+                try:
+                    data = os.read(master, 1024)
+                    if not data:
+                        break
+                    os.write(sys.stdout.fileno(), data)
+                except OSError:
+                    break
+    except (KeyboardInterrupt, OSError):
+        pass
+    finally:
+        # Restore terminal settings
+        termios.tcsetattr(sys.stdin, termios.TCSADRAIN, old_tty)
+        # Restore original SIGWINCH handler
+        signal.signal(signal.SIGWINCH, old_sigwinch_handler)
+        os.close(master)
+        if process is not None:
+            process.terminate()
+            process.wait()
+        if temp_dir is not None:
+            temp_dir.cleanup()

{pymobiledevice3-7.0.7 → pymobiledevice3-7.3.0}/pymobiledevice3/cli/developer/dvt/__init__.py

@@ -166,46 +166,49 @@ def process_id_for_bundle_id(service_provider: ServiceProviderDep, app_bundle_id
 
 
 def get_matching_processes(
-    service_provider: ServiceProviderDep,
+    device_info: DeviceInfo,
     name: Optional[str] = None,
     bundle_identifier: Optional[str] = None,
 ) -> list[MatchedProcessByPid]:
     result: list[MatchedProcessByPid] = []
-    with DvtSecureSocketProxyService(lockdown=service_provider) as dvt:
-        device_info = DeviceInfo(dvt)
-        for process in device_info.proclist():
-            current_name = process["name"]
-            current_bundle_identifier = process.get("bundleIdentifier", "")
-            pid = process["pid"]
-            if (bundle_identifier is not None and bundle_identifier in current_bundle_identifier) or (
-                name is not None and name in current_name
-            ):
-                result.append(MatchedProcessByPid(name=current_name, pid=pid))
+    for process in device_info.proclist():
+        current_name = process["name"]
+        current_bundle_identifier = process.get("bundleIdentifier", "")
+        pid = process["pid"]
+        if (bundle_identifier is not None and bundle_identifier in current_bundle_identifier) or (
+            name is not None and name in current_name
+        ):
+            result.append(MatchedProcessByPid(name=current_name, pid=pid))
     return result
 
 
 @cli.command("pkill")
 def pkill(
     service_provider: ServiceProviderDep,
-    expression: str,
+    expressions: Annotated[
+        list[str],
+        typer.Argument(help="One or more process-name (or bundle id) expressions to match."),
+    ],
     bundle: Annotated[
         bool,
-        typer.Option(help="Treat given expression as a bundle-identifier instead of a process name"),
+        typer.Option(help="Treat given expressions as bundle-identifiers instead of process names"),
     ] = False,
 ) -> None:
-    """Kill all processes containing `expression` in their name."""
-    matching_name = expression if not bundle else None
-    matching_bundle_identifier = expression if bundle else None
-    matching_processes = get_matching_processes(
-        service_provider, name=matching_name, bundle_identifier=matching_bundle_identifier
-    )
-
+    """Kill all processes containing each expression in their name."""
     with DvtSecureSocketProxyService(lockdown=service_provider) as dvt:
+        device_info = DeviceInfo(dvt)
         process_control = ProcessControl(dvt)
 
-        for process in matching_processes:
-            logger.info(f"killing {process.name}({process.pid})")
-            process_control.kill(process.pid)
+        for expression in expressions:
+            matching_name = expression if not bundle else None
+            matching_bundle_identifier = expression if bundle else None
+            matching_processes = get_matching_processes(
+                device_info, name=matching_name, bundle_identifier=matching_bundle_identifier
+            )
+
+            for process in matching_processes:
+                logger.info(f"Killing {process.name}({process.pid})")
+                process_control.kill(process.pid)
 
 
 @cli.command("launch")
@@ -301,9 +304,10 @@ def netstat(service_provider: ServiceProviderDep) -> None:
     with DvtSecureSocketProxyService(lockdown=service_provider) as dvt, NetworkMonitor(dvt) as monitor:
         for event in monitor:
             if isinstance(event, ConnectionDetectionEvent):
-                local_host, local_port = event.local_address.split(":")
-                remote_host, remote_port = event.local_address.split(":")
-                logger.info(f"Connection detected: {local_host}:{local_port} -> {remote_host}:{remote_port}")
+                logger.info(
+                    f"Connection detected: {event.local_address.data.address}:{event.local_address.port} -> "
+                    f"{event.remote_address.data.address}:{event.remote_address.port}"
+                )
 
 
 @cli.command("screenshot")

{pymobiledevice3-7.0.7 → pymobiledevice3-7.3.0}/pymobiledevice3/cli/lockdown.py

@@ -1,3 +1,4 @@
+import ast
 import asyncio
 import logging
 import plistlib
@@ -61,8 +62,8 @@ def lockdown_set(
     domain: Optional[str] = None,
     key: Optional[str] = None,
 ) -> None:
-    """set a lockdown value using python's eval()"""
-    print_json(service_provider.set_value(value=eval(value), domain=domain, key=key))
+    """set a lockdown value using python's ast.literal_eval()"""
+    print_json(service_provider.set_value(value=ast.literal_eval(value), domain=domain, key=key))
 
 
 @cli.command("remove")

{pymobiledevice3-7.0.7 → pymobiledevice3-7.3.0}/pymobiledevice3/cli/usbmux.py

@@ -43,6 +43,10 @@ def usbmux_forward(
         Optional[str],
         typer.Option(help="Device serial/UDID to forward traffic to."),
     ] = None,
+    host: Annotated[
+        str,
+        typer.Option(help="Address to bind the local port to."),
+    ] = "127.0.0.1",
     daemonize: Annotated[
         bool,
         typer.Option("--daemonize", "-d", help="Run the forwarder in the background."),
@@ -58,10 +62,12 @@ def usbmux_forward(
             raise NotImplementedError("daemonizing is only supported on unix platforms") from e
 
         with tempfile.NamedTemporaryFile("wt") as pid_file:
-            daemon = Daemonize(app=f"forwarder {src_port}->{dst_port}", pid=pid_file.name, action=forwarder.start)
+            daemon = Daemonize(
+                app=f"forwarder {src_port}->{dst_port}", pid=pid_file.name, action=lambda: forwarder.start(address=host)
+            )
             daemon.start()
     else:
-        forwarder.start()
+        forwarder.start(address=host)
 
 
 @cli.command("list")

pymobiledevice3-7.3.0/pymobiledevice3/services/dvt/instruments/network_monitor.py

@@ -0,0 +1,158 @@
+import ipaddress
+import logging
+from collections.abc import Iterator
+from dataclasses import dataclass
+from typing import Union
+
+from construct import Adapter, Bytes, Int8ul, Int16ub, Int32ul, Switch, this
+from construct_typed import DataclassMixin, TStruct, csfield
+
+from pymobiledevice3.services.dvt.dvt_secure_socket_proxy import DvtSecureSocketProxyService
+
+
+class IpAddressAdapter(Adapter):
+    """Decode raw address bytes into ipaddress objects."""
+
+    def _decode(self, obj, context, path):
+        return ipaddress.ip_address(obj)
+
+
+@dataclass
+class AddressV6(DataclassMixin):
+    """IPv6 payload for a socket address."""
+
+    flow_info: int = csfield(Int32ul)
+    address: ipaddress.IPv6Address = csfield(IpAddressAdapter(Bytes(16)))
+    scope_id: int = csfield(Int32ul)
+
+
+@dataclass
+class AddressV4(DataclassMixin):
+    """IPv4 payload for a socket address."""
+
+    address: ipaddress.IPv4Address = csfield(IpAddressAdapter(Bytes(4)))
+    _zero: bytes = csfield(Bytes(8))
+
+
+@dataclass
+class SocketAddress(DataclassMixin):
+    """Parsed socket address with family-specific payload."""
+
+    length: int = csfield(Int8ul)
+    family: int = csfield(Int8ul)
+    port: int = csfield(Int16ub)
+    data: Union[AddressV4, AddressV6] = csfield(
+        Switch(
+            this.length,
+            {
+                0x1C: TStruct(AddressV6),
+                0x10: TStruct(AddressV4),
+            },
+        )
+    )
+
+
+address_t = TStruct(SocketAddress)
+
+MESSAGE_TYPE_INTERFACE_DETECTION = 0
+MESSAGE_TYPE_CONNECTION_DETECTION = 1
+MESSAGE_TYPE_CONNECTION_UPDATE = 2
+
+
+@dataclass
+class InterfaceDetectionEvent:
+    """Interface detection event emitted by Instruments."""
+
+    interface_index: int
+    name: str
+
+
+@dataclass
+class ConnectionDetectionEvent:
+    """Connection detection event emitted by Instruments."""
+
+    local_address: SocketAddress
+    remote_address: SocketAddress
+    interface_index: int
+    pid: int
+    recv_buffer_size: int
+    recv_buffer_used: int
+    serial_number: int
+    kind: int
+
+
+@dataclass
+class ConnectionUpdateEvent:
+    """Connection update event emitted by Instruments."""
+
+    rx_packets: int
+    rx_bytes: int
+    tx_packets: int
+    tx_bytes: int
+    rx_dups: int
+    rx000: int
+    tx_retx: int
+    min_rtt: int
+    avg_rtt: int
+    connection_serial: int
+    time: int
+
+
+NetworkMonitorEvent = Union[InterfaceDetectionEvent, ConnectionDetectionEvent, ConnectionUpdateEvent]
+
+
+class NetworkMonitor:
+    """Iterate over network monitoring events from the Instruments service."""
+
+    IDENTIFIER = "com.apple.instruments.server.services.networking"
+
+    def __init__(self, dvt: DvtSecureSocketProxyService):
+        self.logger = logging.getLogger(__name__)
+        self._channel = dvt.make_channel(self.IDENTIFIER)
+
+    def __enter__(self) -> "NetworkMonitor":
+        self._channel.startMonitoring(expects_reply=False)
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+        self._channel.stopMonitoring()
+
+    def __iter__(self) -> Iterator[NetworkMonitorEvent]:
+        """Yield network events as they arrive from the service."""
+
+        while True:
+            message = self._channel.receive_plist()
+
+            event = None
+
+            if message is None:
+                continue
+
+            if message[0] == MESSAGE_TYPE_INTERFACE_DETECTION:
+                event = InterfaceDetectionEvent(*message[1])
+            elif message[0] == MESSAGE_TYPE_CONNECTION_DETECTION:
+                (
+                    local_address,
+                    remote_address,
+                    interface_index,
+                    pid,
+                    recv_buffer_size,
+                    recv_buffer_used,
+                    serial_number,
+                    kind,
+                ) = message[1]
+                event = ConnectionDetectionEvent(
+                    local_address=address_t.parse(local_address),
+                    remote_address=address_t.parse(remote_address),
+                    interface_index=interface_index,
+                    pid=pid,
+                    recv_buffer_size=recv_buffer_size,
+                    recv_buffer_used=recv_buffer_used,
+                    serial_number=serial_number,
+                    kind=kind,
+                )
+            elif message[0] == MESSAGE_TYPE_CONNECTION_UPDATE:
+                event = ConnectionUpdateEvent(*message[1])
+            else:
+                self.logger.warning(f"unsupported event type: {message[0]}")
+            yield event

{pymobiledevice3-7.0.7 → pymobiledevice3-7.3.0}/pymobiledevice3/tcp_forwarder.py

@@ -38,7 +38,7 @@ class TcpForwarderBase:
         # socket to its remote socket and vice versa
         self.connections = {}
 
-    def start(self, address="0.0.0.0"):
+    def start(self, address="127.0.0.1"):
         """forward each connection from given local machine port to remote device port"""
         # create local tcp server socket
         self.server_socket = socket.socket()

{pymobiledevice3-7.0.7 → pymobiledevice3-7.3.0}/pymobiledevice3/tunneld/server.py

@@ -191,10 +191,16 @@ class TunneldCore:
 
     @asyncio_print_traceback
     async def monitor_usbmux_task(self) -> None:
-        try:
-            while True:
-                try:
-                    for mux_device in usbmux.list_devices():
+        while True:
+            mux = None
+            try:
+                mux = usbmux.create_mux()
+                mux.listen()
+
+                while True:
+                    await asyncio.to_thread(mux.receive_device_state_update)
+
+                    for mux_device in mux.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
@@ -227,14 +233,19 @@ class TunneldCore:
                                 name=f"start-tunnel-task-{task_identifier}",
                             ),
                         )
-                except ConnectionFailedToUsbmuxdError:
-                    # This is exception is expected to occur repeatedly on linux running usbmuxd
-                    # as long as there isn't any physical iDevice connected
-                    logger.debug("failed to connect to usbmux. waiting for it to restart")
-                finally:
-                    await asyncio.sleep(USBMUX_INTERVAL)
-        except asyncio.CancelledError:
-            pass
+            except (BlockingIOError, StreamError, OSError) as e:
+                # Connection lost - will reconnect on next iteration
+                logger.debug(f"usbmux connection error: {e}, reconnecting...")
+            except ConnectionFailedToUsbmuxdError:
+                # This is exception is expected to occur repeatedly on linux running usbmuxd
+                # as long as there isn't any physical iDevice connected
+                logger.debug("failed to connect to usbmux. waiting for it to restart")
+                await asyncio.sleep(USBMUX_INTERVAL)
+            except asyncio.CancelledError:
+                break
+            finally:
+                if mux is not None:
+                    mux.close()
 
     @asyncio_print_traceback
     async def monitor_mobdev2_task(self) -> None: