pymobiledevice3 4.14.6__py3-none-any.whl → 7.0.6__py3-none-any.whl

pymobiledevice3/tcp_forwarder.py

@@ -2,6 +2,7 @@ import logging
 import select
 import socket
 import threading
+import time
 from abc import abstractmethod
 from typing import Optional
 
@@ -18,7 +19,7 @@ class TcpForwarderBase:
     MAX_FORWARDED_CONNECTIONS = 200
     TIMEOUT = 1
 
-    def __init__(self, src_port: int, listening_event: threading.Event = None):
+    def __init__(self, src_port: int, listening_event: Optional[threading.Event] = None):
         """
         Initialize a new tcp forwarder
 
@@ -37,8 +38,8 @@ class TcpForwarderBase:
         # socket to its remote socket and vice versa
         self.connections = {}
 
-    def start(self, address='0.0.0.0'):
-        """ forward each connection from given local machine port to remote device port """
+    def start(self, address="0.0.0.0"):
+        """forward each connection from given local machine port to remote device port"""
         # create local tcp server socket
         self.server_socket = socket.socket()
         self.server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
@@ -50,40 +51,41 @@ class TcpForwarderBase:
         if self.listening_event:
             self.listening_event.set()
 
-        while self.inputs:
-            # will only perform the socket select on the inputs. the outputs will handled
-            # as synchronous blocking
-            readable, writable, exceptional = select.select(self.inputs, [], self.inputs, self.TIMEOUT)
-            if self.stopped.is_set():
-                self.logger.debug("Closing since stopped is set")
-                break
-
-            closed_sockets = set()
-            for current_sock in readable:
-                self.logger.debug("Processing %r", current_sock)
-                if current_sock is self.server_socket:
-                    self._handle_server_connection()
-                else:
-                    if current_sock not in closed_sockets:
-                        try:
-                            self._handle_data(current_sock, closed_sockets)
-                        except ConnectionResetError:
-                            self.logger.exception("Error when handling data")
-                            self._handle_close_or_error(current_sock)
+        try:
+            while self.inputs:
+                # will only perform the socket select on the inputs. the outputs will handled
+                # as synchronous blocking
+                readable, _writable, exceptional = select.select(self.inputs, [], self.inputs, self.TIMEOUT)
+                if self.stopped.is_set():
+                    self.logger.debug("Closing since stopped is set")
+                    break
+
+                closed_sockets = set()
+                for current_sock in readable:
+                    self.logger.debug("Processing %r", current_sock)
+                    if current_sock is self.server_socket:
+                        self._handle_server_connection()
                     else:
-                        self.logger.debug("Is closed")
-
-            for current_sock in exceptional:
-                self.logger.error("Sock failed: %r", current_sock)
-                self._handle_close_or_error(current_sock)
-
-        self.logger.info("Closing everything")
-        # on stop, close all currently opened sockets
-        for current_sock in self.inputs:
-            current_sock.close()
+                        if current_sock not in closed_sockets:
+                            try:
+                                self._handle_data(current_sock, closed_sockets)
+                            except ConnectionResetError:
+                                self.logger.error("Error when handling data")
+                                self._handle_close_or_error(current_sock)
+                        else:
+                            self.logger.debug("Is closed")
+
+                for current_sock in exceptional:
+                    self.logger.error("Sock failed: %r", current_sock)
+                    self._handle_close_or_error(current_sock)
+        finally:
+            self.logger.info("Closing everything")
+            # on stop, close all currently opened sockets
+            for current_sock in self.inputs:
+                current_sock.close()
 
     def _handle_close_or_error(self, from_sock):
-        """ if an error occurred its time to close the two sockets """
+        """if an error occurred its time to close the two sockets"""
         other_sock = self.connections[from_sock]
 
         other_sock.close()
@@ -91,56 +93,59 @@ class TcpForwarderBase:
         self.inputs.remove(other_sock)
         self.inputs.remove(from_sock)
 
-        self.logger.info(f'connection {other_sock} was closed')
+        self.logger.info(f"connection {other_sock} was closed")
 
     def _handle_data(self, from_sock, closed_sockets):
-        self.logger.debug("Handling data from %s", from_sock)
-        data = None
+        self.logger.debug(f"Handling data from {from_sock}")
         try:
             data = from_sock.recv(1024)
+            if not data:
+                raise ConnectionResetError("Connection closed by the peer.")
+        except BlockingIOError:
+            self.logger.warning(f"Non-blocking read failed on {from_sock}, retrying later.")
+            return
         except OSError:
-            # Socket closing is handled in another if block
-            pass
-
-        if data is None or len(data) == 0:
-            if data is None:
-                # data is none means we had an error reading from socket
-                self.logger.debug("oserror when reading from_sock")
-            else:
-                # Empty data means socket was closed
-                self.logger.info("No data was read from the socket")
+            self.logger.error(f"Error reading from socket {from_sock}")
             self._handle_close_or_error(from_sock)
             closed_sockets.add(from_sock)
-            closed_sockets.add(self.connections[from_sock])
             return
 
-        # when data is received from one end, just forward it to the other
-        other_sock = self.connections[from_sock]
+        other_sock = self.connections.get(from_sock)
+        if not other_sock:
+            self.logger.error(f"No connection mapping found for {from_sock}.")
+            return
+
         try:
-            # send the data in blocking manner
-            other_sock.setblocking(True)
-            other_sock.sendall(data)
-            other_sock.setblocking(False)
+            total_sent = 0
+            while total_sent < len(data):
+                try:
+                    sent = other_sock.send(data[total_sent:])
+                    total_sent += sent
+                except BlockingIOError:
+                    self.logger.warning(f"Socket buffer full for {other_sock}, retrying in 100ms.")
+                    time.sleep(0.1)  # Introduce a small delay
+                except BrokenPipeError:
+                    self.logger.error(f"Broken pipe error on {other_sock}.")
+                    raise
         except OSError:
-            # Tried writing to closed socket
-            self.logger.exception("Exception when sending data to socket")
-            self._handle_close_or_error(other_sock)
+            self.logger.error("Unhandled error while forwarding data")
+            self._handle_close_or_error(from_sock)
             closed_sockets.add(from_sock)
-            closed_sockets.add(self.connections[from_sock])
+            closed_sockets.add(other_sock)
 
     @abstractmethod
     def _establish_remote_connection(self) -> socket.socket:
         pass
 
     def _handle_server_connection(self):
-        """ accept the connection from local machine and attempt to connect at remote """
-        local_connection, client_address = self.server_socket.accept()
+        """accept the connection from local machine and attempt to connect at remote"""
+        local_connection, _client_address = self.server_socket.accept()
         local_connection.setblocking(False)
 
         try:
             remote_connection = self._establish_remote_connection()
         except ConnectionFailedError:
-            self.logger.error(f'failed to connect to port: {self.dst_port}')
+            self.logger.error(f"failed to connect to port: {self.dst_port}")
             local_connection.close()
             return
 
@@ -154,10 +159,10 @@ class TcpForwarderBase:
         self.connections[remote_connection] = local_connection
         self.connections[local_connection] = remote_connection
 
-        self.logger.info('connection established from local to remote')
+        self.logger.info("connection established from local to remote")
 
     def stop(self):
-        """ stop forwarding """
+        """stop forwarding"""
         self.stopped.set()
 
 
@@ -166,8 +171,15 @@ class UsbmuxTcpForwarder(TcpForwarderBase):
     Allows forwarding local tcp connection into the device via a given lockdown connection
     """
 
-    def __init__(self, serial: str, dst_port: int, src_port: int, listening_event: threading.Event = None,
-                 usbmux_connection_type: str = None, usbmux_address: Optional[str] = None):
+    def __init__(
+        self,
+        serial: str,
+        dst_port: int,
+        src_port: int,
+        listening_event: Optional[threading.Event] = None,
+        usbmux_connection_type: Optional[str] = None,
+        usbmux_address: Optional[str] = None,
+    ):
         """
         Initialize a new tcp forwarder
 
@@ -186,8 +198,9 @@ class UsbmuxTcpForwarder(TcpForwarderBase):
 
     def _establish_remote_connection(self) -> socket.socket:
         # connect directly using usbmuxd
-        mux_device = usbmux.select_device(self.serial, connection_type=self.usbmux_connection_type,
-                                          usbmux_address=self.usbmux_address)
+        mux_device = usbmux.select_device(
+            self.serial, connection_type=self.usbmux_connection_type, usbmux_address=self.usbmux_address
+        )
         self.logger.debug("Selected device: %r", mux_device)
         if mux_device is None:
             raise ConnectionFailedError()
@@ -199,8 +212,13 @@ class LockdownTcpForwarder(TcpForwarderBase):
     Allows forwarding local tcp connection into the device via a given lockdown connection
     """
 
-    def __init__(self, service_provider: LockdownServiceProvider, src_port: int, service_name: str,
-                 listening_event: threading.Event = None):
+    def __init__(
+        self,
+        service_provider: LockdownServiceProvider,
+        src_port: int,
+        service_name: str,
+        listening_event: Optional[threading.Event] = None,
+    ):
         """
         Initialize a new tcp forwarder
 

pymobiledevice3/tunneld/api.py

@@ -0,0 +1,63 @@
+from typing import Optional
+
+import requests
+
+from pymobiledevice3.exceptions import TunneldConnectionError
+from pymobiledevice3.remote.remote_service_discovery import RemoteServiceDiscoveryService
+from pymobiledevice3.utils import get_asyncio_loop
+
+TUNNELD_DEFAULT_ADDRESS = ("127.0.0.1", 49151)
+
+
+async def async_get_tunneld_devices(
+    tunneld_address: tuple[str, int] = TUNNELD_DEFAULT_ADDRESS,
+) -> list[RemoteServiceDiscoveryService]:
+    tunnels = _list_tunnels(tunneld_address)
+    return await _create_rsds_from_tunnels(tunnels)
+
+
+def get_tunneld_devices(
+    tunneld_address: tuple[str, int] = TUNNELD_DEFAULT_ADDRESS,
+) -> list[RemoteServiceDiscoveryService]:
+    return get_asyncio_loop().run_until_complete(async_get_tunneld_devices(tunneld_address))
+
+
+async def async_get_tunneld_device_by_udid(
+    udid: str, tunneld_address: tuple[str, int] = TUNNELD_DEFAULT_ADDRESS
+) -> Optional[RemoteServiceDiscoveryService]:
+    tunnels = _list_tunnels(tunneld_address)
+    if udid not in tunnels:
+        return None
+    rsds = await _create_rsds_from_tunnels({udid: tunnels[udid]})
+    return rsds[0]
+
+
+def get_tunneld_device_by_udid(
+    udid: str, tunneld_address: tuple[str, int] = TUNNELD_DEFAULT_ADDRESS
+) -> Optional[RemoteServiceDiscoveryService]:
+    return get_asyncio_loop().run_until_complete(async_get_tunneld_device_by_udid(udid, tunneld_address))
+
+
+def _list_tunnels(tunneld_address: tuple[str, int] = TUNNELD_DEFAULT_ADDRESS) -> dict[str, list[dict]]:
+    try:
+        # Get the list of tunnels from the specified address
+        resp = requests.get(f"http://{tunneld_address[0]}:{tunneld_address[1]}")
+        tunnels = resp.json()
+    except requests.exceptions.ConnectionError as e:
+        raise TunneldConnectionError() from e
+    return tunnels
+
+
+async def _create_rsds_from_tunnels(tunnels: dict[str, list[dict]]) -> list[RemoteServiceDiscoveryService]:
+    rsds = []
+    for _udid, details in tunnels.items():
+        for tunnel_details in details:
+            rsd = RemoteServiceDiscoveryService(
+                (tunnel_details["tunnel-address"], tunnel_details["tunnel-port"]), name=tunnel_details["interface"]
+            )
+            try:
+                await rsd.connect()
+                rsds.append(rsd)
+            except (TimeoutError, ConnectionError):
+                continue
+    return rsds