iproxy programatic connection

[morellexf13]

Hi, I have a question.

Currently, by using tunnels (for example: fd7b:e5b:6f53::1 64337), this is the way we programmatically make the necessary callback to collect performance data.

  def _run_async_rsd_connection(self, address, port, callback):
      async def async_connection():
          async with RemoteServiceDiscoveryService((address, port)) as rsd:
              loop = asyncio.get_running_loop()

              def run_blocking_callback():
                  with DvtSecureSocketProxyService(rsd) as dvt:
                      callback(dvt)

              await loop.run_in_executor(None, run_blocking_callback)

      try:
          loop = asyncio.get_event_loop()
          if loop.is_running():
              with concurrent.futures.ThreadPoolExecutor() as executor:
                  future = executor.submit(asyncio.run, async_connection())
                  future.result()
          else:
              loop.run_until_complete(async_connection())
      except RuntimeError:
          asyncio.run(async_connection())

  def connection_context(self, callback):
      try:
          if Version(self.device_info.os.version) >= Version('17.0'):
              available_address = tunnel_creator.get_available_address()
              if available_address:
                  self._run_async_rsd_connection(available_address["address"], available_address["port"], callback)
              else:
                  raise Exception("An error occurred getting tunnels addresses...")
          else:
              # Use USB Mux
              lockdown = self.get_lockdown()
              with DvtSecureSocketProxyService(lockdown=lockdown) as dvt:
                  callback(dvt)
      except OSError:  # no route to host (Intel fix)
          pass
      except DeviceLockedError:
          raise
      except Exception as e:
          raise Exception(f"Connection not established... {e}")

We handle 6 different “monitors,” which means we have different contexts, and that forces me to open 6 tunnels in parallel, and it works perfectly.

My problem is that now I’m running this on a computer where I don’t have the necessary permissions to open that type of addresses/tunnels. What I do have available is iproxy (for example: iproxy 1716 juan 3u IPv4 0xe039a78a75d7935b 0t0 TCP 127.0.0.1:8200 (LISTEN)).

How can I use this type of address with pymobiledevice? What would be the programmatic way to obtain that dvt/context in this case? I’ve tried passing this type of address/port to the same code (above), but it doesn’t work. I’m no expert in this, and I need some help to figure this out.

[doronz88]

What do you mean by monitors? The tunneld internal monitor? If so, you can simply run it without all of them. This is just for best effort.

What is the permission problem?

I'm not sure why you believe iproxy is related or if it can somehow solve something related to tunnels.
You can connect to any device port using pymobiledevice3 in pure python as mentioned in the project's docs:
https://github.com/doronz88/pymobiledevice3/blob/master/misc/understanding_idevice_protocol_layers.md#usbmuxd

[morellexf13]

What do you mean by monitors? The tunneld internal monitor? If so, you can simply run it without all of them. This is just for best effort.

What is the permission problem?

I'm not sure why you believe iproxy is related or if it can somehow solve something related to tunnels. You can connect to any device port using pymobiledevice3 in pure python as mentioned in the project's docs: https://github.com/doronz88/pymobiledevice3/blob/master/misc/understanding_idevice_protocol_layers.md#usbmuxd

class IOSGenericMonitor(GenericMonitor):

    def monitor_logic(self, dvt):
        pass

    def monitor_thread(self):
        while base_profiler.running:
            try:
                self.device.connection_context(self.monitor_logic)
            except StreamClosedError:
                pass
            except Exception as exc:
                logger.exception(f'An error occurred executing {self.__class__.__name__}. {exc}')



class IOSDisplayMonitor(IOSGenericMonitor):

    def monitor_logic(self, dvt):
        self.file_manager.create_tsv_from_model(IOSFPSModel())
        with Graphics(dvt) as graphics:
            for stats in graphics:
                if not self.running:
                    break
                fps_model = IOSFPSModel(
                    device_id=self.device.id,
                    time=self.get_general_runtime(),
                    fps=stats['CoreAnimationFramesPerSecond']
                )
                self.file_manager.append_tsv_from_model(fps_model)

The monitors I was referring to are a concept from my code, each monitor refers to a particular metric. For example, I have a monitor for FPS, another for memory, another for energy, and so on. As you can see, each monitor has a dvt as a parameter, which means that my 6 monitors will each need 1 tunnel in order to run in parallel. I already tried with a single tunnel for all, but it simply doesn’t work, so I assumed that each context must be handled independently: 1 tunnel per monitor.

The thing is that locally this works fine, but in this uncontrolled environment where I currently have to run it, I don’t have sudo permissions to spin up as many tunnels as I want. These are the solutions they gave me:

=====Option 1: Pre-installed Proxy Tools (Recommended)=====
We provide built-in proxy utilities that offer stable port forwarding. You can implement this using either iproxy or go-iOS:

For iproxy implementation=: iproxy [OPTIONS] LOCAL_PORT:DEVICE_PORT

For go-iOS implementation=: ios forward [options] <hostPort> <targetPort>

=====Option 2: RSD Tunnel Connection=====
We automatically creates a tunnel connection between your device and host. You can access this connection using the following command:

ios tunnel ls 2>/dev/null | jq ".[0] | {address, port: .rsdPort}"

You will receive a response similar to this:
{
  "address": "fde1:4c3a:f100::1",
  "port": 59610
}
In the example above for option 2, the device is available at address "fde1:4c3a:f100::1" just as how it would be available on localhost for option 1.

Important Considerations:
We recommend using the Pre-installed Proxy Tools option (First Option) for your implementation. This approach offers greater stability for long-term use. While the RSD tunnel option is currently available, please note that its functionality may change in future updates.

This is the reason why I saw iproxy as something related, and regarding the tunnel command they mention (option 2), when I run it I just get 1 tunnel created (whereas I’m using 6 locally).

Is there a solution to connect my monitors with what’s proposed in option 1?
Or am I missing something and in fact it is possible to run those 6 routines in parallel with a single tunnel?