pymobiledevice3 7.2.1__tar.gz → 7.3.1__tar.gz

{pymobiledevice3-7.2.1 → pymobiledevice3-7.3.1}/PKG-INFO

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

{pymobiledevice3-7.2.1 → pymobiledevice3-7.3.1}/pymobiledevice3/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '7.2.1'
-__version_tuple__ = version_tuple = (7, 2, 1)
+__version__ = version = '7.3.1'
+__version_tuple__ = version_tuple = (7, 3, 1)
 
-__commit_id__ = commit_id = 'g9255614bf'
+__commit_id__ = commit_id = 'g3806869e7'

{pymobiledevice3-7.2.1 → pymobiledevice3-7.3.1}/pymobiledevice3/cli/developer/dvt/__init__.py

@@ -304,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.2.1 → pymobiledevice3-7.3.1}/pymobiledevice3/cli/remote.py

@@ -83,14 +83,14 @@ def cli_tunneld(
     port: Annotated[int, typer.Option(help="Port to bind the tunneld server to.")] = TUNNELD_DEFAULT_ADDRESS[1],
     daemonize: Annotated[bool, typer.Option("--daemonize", "-d", help="Run tunneld in the background.")] = False,
     protocol: Annotated[
-        TunnelProtocol,
+        str,
         typer.Option(
             "--protocol",
             "-p",
             case_sensitive=False,
             help="Transport protocol for tunneld (default: TCP on Python >=3.13, otherwise QUIC).",
         ),
-    ] = TunnelProtocol.DEFAULT,
+    ] = TunnelProtocol.DEFAULT.value,
     usb: Annotated[bool, typer.Option(help="Enable USB monitoring")] = True,
     wifi: Annotated[bool, typer.Option(help="Enable WiFi monitoring")] = True,
     usbmux: Annotated[bool, typer.Option(help="Enable usbmux monitoring")] = True,

pymobiledevice3-7.3.1/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.2.1 → pymobiledevice3-7.3.1}/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:

{pymobiledevice3-7.2.1 → pymobiledevice3-7.3.1}/pymobiledevice3/usbmux.py

@@ -258,6 +258,11 @@ class MuxConnection:
         """
         pass
 
+    @abc.abstractmethod
+    def listen(self):
+        """start listening for events of attached and detached devices"""
+        pass
+
     def connect(self, device: MuxDevice, port: int) -> socket.socket:
         """connect to a relay port on target machine and get a raw python socket object for the connection"""
         self._connect(device.devid, socket.htons(port))
@@ -273,6 +278,11 @@ class MuxConnection:
         if self._connected:
             raise MuxException("Mux is connected, cannot issue control packets")
 
+    @abc.abstractmethod
+    def receive_device_state_update(self):
+        """Block and wait for a device notification"""
+        pass
+
     def _raise_mux_exception(self, result: int, message: Optional[str] = None) -> None:
         exceptions = {
             int(usbmuxd_result.BADCOMMAND): BadCommandError,
@@ -306,7 +316,7 @@ class BinaryMuxConnection(MuxConnection):
         while time.time() < end:
             self._sock.settimeout(end - time.time())
             try:
-                self._receive_device_state_update()
+                self.receive_device_state_update()
             except (BlockingIOError, StreamError):
                 continue
             except OSError as e:
@@ -348,6 +358,16 @@ class BinaryMuxConnection(MuxConnection):
             raise MuxException(f"Reply tag mismatch: expected {expected_tag}, got {response.header.tag}")
         return response
 
+    def receive_device_state_update(self):
+        response = self._receive()
+        if response.header.message == usbmuxd_msgtype.ADD:
+            # old protocol only supported USB devices
+            self._add_device(MuxDevice(response.data.device_id, response.data.serial_number, "USB"))
+        elif response.header.message == usbmuxd_msgtype.REMOVE:
+            self._remove_device(response.data.device_id)
+        else:
+            raise MuxException(f"Invalid packet type received: {response}")
+
     def _send_receive(self, message_type: int):
         self._send({"header": {"version": self._version, "message": message_type, "tag": self._tag}, "data": b""})
         response = self._receive(self._tag - 1)
@@ -364,16 +384,6 @@ class BinaryMuxConnection(MuxConnection):
     def _remove_device(self, device_id: int):
         self.devices = [device for device in self.devices if device.devid != device_id]
 
-    def _receive_device_state_update(self):
-        response = self._receive()
-        if response.header.message == usbmuxd_msgtype.ADD:
-            # old protocol only supported USB devices
-            self._add_device(MuxDevice(response.data.device_id, response.data.serial_number, "USB"))
-        elif response.header.message == usbmuxd_msgtype.REMOVE:
-            self._remove_device(response.data.device_id)
-        else:
-            raise MuxException(f"Invalid packet type received: {response}")
-
 
 class PlistMuxConnection(BinaryMuxConnection):
     def __init__(self, sock: SafeStreamSocket):
@@ -392,6 +402,20 @@ class PlistMuxConnection(BinaryMuxConnection):
             raise NotPairedError("device should be paired first")
         return plistlib.loads(pair_record)
 
+    def _process_device_state(self, response):
+        if response["MessageType"] == "Attached":
+            super()._add_device(
+                MuxDevice(
+                    response["DeviceID"],
+                    response["Properties"]["SerialNumber"],
+                    response["Properties"]["ConnectionType"],
+                )
+            )
+        elif response["MessageType"] == "Detached":
+            super()._remove_device(response["DeviceID"])
+        else:
+            raise MuxException(f"Invalid packet type received: {response}")
+
     def get_device_list(self, timeout: Optional[float] = None) -> None:
         """get device list synchronously without waiting the timeout"""
         self.devices = []
@@ -401,18 +425,7 @@ class PlistMuxConnection(BinaryMuxConnection):
         if device_list is None:
             raise MuxException(f"Got an invalid response from usbmux: {response}")
         for response in device_list:
-            if response["MessageType"] == "Attached":
-                super()._add_device(
-                    MuxDevice(
-                        response["DeviceID"],
-                        response["Properties"]["SerialNumber"],
-                        response["Properties"]["ConnectionType"],
-                    )
-                )
-            elif response["MessageType"] == "Detached":
-                super()._remove_device(response["DeviceID"])
-            else:
-                raise MuxException(f"Invalid packet type received: {response}")
+            self._process_device_state(response)
 
     def get_buid(self) -> str:
         """get SystemBUID"""
@@ -445,6 +458,10 @@ class PlistMuxConnection(BinaryMuxConnection):
             raise MuxException(f"Received non-plist type {response}")
         return plistlib.loads(response.data)
 
+    def receive_device_state_update(self):
+        response = self._receive()
+        self._process_device_state(response)
+
     def _send_receive(self, data: dict):
         self._send(data)
         response = self._receive(self._tag - 1)

{pymobiledevice3-7.2.1 → pymobiledevice3-7.3.1}/pymobiledevice3.egg-info/PKG-INFO

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

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

@@ -1,102 +0,0 @@
-import dataclasses
-import ipaddress
-import logging
-
-from construct import Adapter, Bytes, Int8ul, Int16ub, Int32ul, Struct, Switch, this
-
-
-class IpAddressAdapter(Adapter):
-    def _decode(self, obj, context, path):
-        return ipaddress.ip_address(obj)
-
-
-address_t = Struct(
-    "len" / Int8ul,
-    "family" / Int8ul,
-    "port" / Int16ub,
-    "data"
-    / Switch(
-        this.len,
-        {
-            0x1C: Struct(
-                "flow_info" / Int32ul,
-                "address" / IpAddressAdapter(Bytes(16)),
-                "scope_id" / Int32ul,
-            ),
-            0x10: Struct("address" / IpAddressAdapter(Bytes(4)), "_zero" / Bytes(8)),
-        },
-    ),
-)
-
-MESSAGE_TYPE_INTERFACE_DETECTION = 0
-MESSAGE_TYPE_CONNECTION_DETECTION = 1
-MESSAGE_TYPE_CONNECTION_UPDATE = 2
-
-
-@dataclasses.dataclass
-class InterfaceDetectionEvent:
-    interface_index: int
-    name: str
-
-
-@dataclasses.dataclass
-class ConnectionDetectionEvent:
-    local_address: str
-    remote_address: str
-    interface_index: int
-    pid: int
-    recv_buffer_size: int
-    recv_buffer_used: int
-    serial_number: int
-    kind: int
-
-
-@dataclasses.dataclass
-class ConnectionUpdateEvent:
-    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
-
-
-class NetworkMonitor:
-    IDENTIFIER = "com.apple.instruments.server.services.networking"
-
-    def __init__(self, dvt):
-        self.logger = logging.getLogger(__name__)
-        self._channel = dvt.make_channel(self.IDENTIFIER)
-
-    def __enter__(self):
-        self._channel.startMonitoring(expects_reply=False)
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        self._channel.stopMonitoring()
-
-    def __iter__(self):
-        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:
-                event = ConnectionDetectionEvent(*message[1])
-                event.local_address = address_t.parse(event.local_address)
-                event.remote_address = address_t.parse(event.remote_address)
-            elif message[0] == MESSAGE_TYPE_CONNECTION_UPDATE:
-                event = ConnectionUpdateEvent(*message[1])
-            else:
-                self.logger.warning(f"unsupported event type: {message[0]}")
-            yield event