subprojects: Prepare for release

Expose Device.override_option() for overriding backend-specific
options on a device.

Overrides apply when establishing a host session. If one already
exists, changes take effect on the next connection.

examples/child_gating.py

@@ -42,18 +42,16 @@ class Application:
         print("✔ enable_child_gating()")
         session.enable_child_gating()
         print("✔ create_script()")
-        script = session.create_script(
-            """\
-Interceptor.attach(Module.getExportByName(null, 'open'), {
-  onEnter: function (args) {
+        script = session.create_script("""\
+Interceptor.attach(Module.getGlobalExportByName('open'), {
+  onEnter(args) {
     send({
       type: 'open',
-      path: Memory.readUtf8String(args[0])
+      path: args[0].readUtf8String()
     });
   }
 });
-"""
-        )
+""")
         script.on("message", lambda message, data: self._reactor.schedule(lambda: self._on_message(pid, message)))
         print("✔ load()")
         script.load()

examples/inject_library/inject_blob.py

@@ -15,7 +15,7 @@ def on_uninjected(id):
     print("on_uninjected id=%u" % id)
 
 
-(target, library_path) = sys.argv[1:]
+target, library_path = sys.argv[1:]
 
 device = frida.get_local_device()
 device.on("uninjected", on_uninjected)

examples/inject_library/inject_file.py

@@ -15,7 +15,7 @@ def on_uninjected(id):
     print("on_uninjected id=%u" % id)
 
 
-(target, library_path) = sys.argv[1:]
+target, library_path = sys.argv[1:]
 
 device = frida.get_local_device()
 device.on("uninjected", on_uninjected)

examples/rpc.py

@@ -1,8 +1,7 @@
 import frida
 
 session = frida.attach("Twitter")
-script = session.create_script(
-    """\
+script = session.create_script("""\
 rpc.exports = {
   hello: function () {
     return 'Hello';
@@ -11,8 +10,7 @@ rpc.exports = {
     oops;
   }
 };
-"""
-)
+""")
 script.load()
 api = script.exports_sync
 print("api.hello() =>", api.hello())

examples/session_persist_timeout.py

@@ -22,8 +22,7 @@ class Application:
         self._session = session
         session.on("detached", lambda *args: self._reactor.schedule(lambda: self._on_detached(*args)))
 
-        script = session.create_script(
-            """
+        script = session.create_script("""
 let _puts = null;
 
 Interceptor.attach(DebugSymbol.getFunctionByName('f'), {
@@ -48,8 +47,7 @@ function puts(s) {
   }
   _puts(Memory.allocUtf8String(s));
 }
-"""
-        )
+""")
         self._script = script
         script.on("message", lambda *args: self._reactor.schedule(lambda: self._on_message(*args)))
         script.load()

examples/spawn_gating.py

@@ -0,0 +1,78 @@
+import threading
+
+from frida_tools.application import Reactor
+
+import frida
+
+
+class Application:
+    def __init__(self):
+        self._stop_requested = threading.Event()
+        self._reactor = Reactor(run_until_return=lambda reactor: self._stop_requested.wait())
+
+        self._device = frida.get_usb_device()
+        self._sessions = set()
+        self._sessions_lock = threading.Lock()
+
+        self._device.on("spawn-added", lambda spawn: self._reactor.schedule(lambda: self._on_spawn_added(spawn)))
+        self._device.on("spawn-removed", lambda spawn: self._reactor.schedule(lambda: self._on_spawn_removed(spawn)))
+
+    def run(self):
+        self._reactor.schedule(lambda: self._start())
+        self._reactor.run()
+
+    def _start(self):
+        self._device.enable_spawn_gating()
+
+    def _instrument(self, pid):
+        print(f"✔ attach(pid={pid})")
+        session = self._device.attach(pid)
+        session.on("detached", lambda reason: self._reactor.schedule(lambda: self._on_detached(pid, session, reason)))
+        print("✔ create_script()")
+        script = session.create_script("""\
+const puts = new NativeFunction(Module.getGlobalExportByName('puts'), 'int', ['pointer']);
+puts(Memory.allocUtf8String('Hello from Frida agent'));
+Interceptor.attach(Module.getGlobalExportByName('open'), {
+  onEnter(args) {
+    send({
+      type: 'open',
+      path: args[0].readUtf8String()
+    });
+  }
+});
+""")
+        script.on("message", lambda message, data: self._reactor.schedule(lambda: self._on_message(pid, message)))
+        print("✔ load()")
+        script.load()
+        print(f"✔ resume(pid={pid})")
+        self._device.resume(pid)
+        with self._sessions_lock:
+            self._sessions.add(session)
+
+    def _on_spawn_added(self, spawn):
+        print(f"⚡ spawn_added: {spawn}")
+        t = threading.Thread(target=self._handle_spawn, args=(spawn,))
+        t.start()
+
+    def _handle_spawn(self, spawn):
+        if "/bin/ls" in spawn.identifier:
+            self._instrument(spawn.pid)
+        else:
+            pid = spawn.pid
+            print(f"✔ resume(pid={pid})")
+            self._device.resume(pid)
+
+    def _on_spawn_removed(self, spawn):
+        print(f"⚡ spawn_removed: {spawn}")
+
+    def _on_detached(self, pid, session, reason):
+        print(f"⚡ detached: pid={pid}, reason='{reason}'")
+        with self._sessions_lock:
+            self._sessions.remove(session)
+
+    def _on_message(self, pid, message):
+        print(f"⚡ message: pid={pid}, payload={message['payload']}")
+
+
+app = Application()
+app.run()

frida/__init__.py

@@ -0,0 +1,173 @@
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union
+
+try:
+    from . import _frida
+except Exception as ex:
+    print("")
+    print("***")
+    if str(ex).startswith("No module named "):
+        print("Frida native extension not found")
+        print("Please check your PYTHONPATH.")
+    else:
+        print(f"Failed to load the Frida native extension: {ex}")
+        print("Please ensure that the extension was compiled correctly")
+    print("***")
+    print("")
+    raise ex
+from . import core
+
+__version__: str = _frida.__version__
+
+get_device_manager = core.get_device_manager
+Relay = _frida.Relay
+PortalService = core.PortalService
+EndpointParameters = core.EndpointParameters
+Compiler = core.Compiler
+PackageManager = core.PackageManager
+FileMonitor = _frida.FileMonitor
+Cancellable = core.Cancellable
+
+ServerNotRunningError = _frida.ServerNotRunningError
+ExecutableNotFoundError = _frida.ExecutableNotFoundError
+ExecutableNotSupportedError = _frida.ExecutableNotSupportedError
+ProcessNotFoundError = _frida.ProcessNotFoundError
+ProcessNotRespondingError = _frida.ProcessNotRespondingError
+InvalidArgumentError = _frida.InvalidArgumentError
+InvalidOperationError = _frida.InvalidOperationError
+PermissionDeniedError = _frida.PermissionDeniedError
+AddressInUseError = _frida.AddressInUseError
+TimedOutError = _frida.TimedOutError
+NotSupportedError = _frida.NotSupportedError
+ProtocolError = _frida.ProtocolError
+TransportError = _frida.TransportError
+OperationCancelledError = _frida.OperationCancelledError
+
+
+def query_system_parameters() -> Dict[str, Any]:
+    """
+    Returns a dictionary of information about the host system
+    """
+
+    return get_local_device().query_system_parameters()
+
+
+def spawn(
+    program: Union[str, List[Union[str, bytes]], Tuple[Union[str, bytes]]],
+    argv: Union[None, List[Union[str, bytes]], Tuple[Union[str, bytes]]] = None,
+    envp: Optional[Dict[str, str]] = None,
+    env: Optional[Dict[str, str]] = None,
+    cwd: Optional[str] = None,
+    stdio: Optional[str] = None,
+    **kwargs: Any,
+) -> int:
+    """
+    Spawn a process into an attachable state
+    """
+
+    return get_local_device().spawn(program=program, argv=argv, envp=envp, env=env, cwd=cwd, stdio=stdio, **kwargs)
+
+
+def resume(target: core.ProcessTarget) -> None:
+    """
+    Resume a process from the attachable state
+    :param target: the PID or name of the process
+    """
+
+    get_local_device().resume(target)
+
+
+def kill(target: core.ProcessTarget) -> None:
+    """
+    Kill a process
+    :param target: the PID or name of the process
+    """
+
+    get_local_device().kill(target)
+
+
+def attach(
+    target: core.ProcessTarget, realm: Optional[str] = None, persist_timeout: Optional[int] = None
+) -> core.Session:
+    """
+    Attach to a process
+    :param target: the PID or name of the process
+    """
+
+    return get_local_device().attach(target, realm=realm, persist_timeout=persist_timeout)
+
+
+def inject_library_file(target: core.ProcessTarget, path: str, entrypoint: str, data: str) -> int:
+    """
+    Inject a library file to a process.
+    :param target: the PID or name of the process
+    """
+
+    return get_local_device().inject_library_file(target, path, entrypoint, data)
+
+
+def inject_library_blob(target: core.ProcessTarget, blob: bytes, entrypoint: str, data: str) -> int:
+    """
+    Inject a library blob to a process
+    :param target: the PID or name of the process
+    """
+
+    return get_local_device().inject_library_blob(target, blob, entrypoint, data)
+
+
+def get_local_device() -> core.Device:
+    """
+    Get the local device
+    """
+
+    return get_device_manager().get_local_device()
+
+
+def get_remote_device() -> core.Device:
+    """
+    Get the first remote device in the devices list
+    """
+
+    return get_device_manager().get_remote_device()
+
+
+def get_usb_device(timeout: int = 0) -> core.Device:
+    """
+    Get the first device connected over USB in the devices list
+    """
+
+    return get_device_manager().get_usb_device(timeout)
+
+
+def get_device(id: Optional[str], timeout: int = 0) -> core.Device:
+    """
+    Get a device by its id
+    """
+
+    return get_device_manager().get_device(id, timeout)
+
+
+def get_device_matching(predicate: Callable[[core.Device], bool], timeout: int = 0) -> core.Device:
+    """
+    Get device matching predicate.
+    :param predicate: a function to filter the devices
+    :param timeout: operation timeout in seconds
+    """
+
+    return get_device_manager().get_device_matching(predicate, timeout)
+
+
+def enumerate_devices() -> List[core.Device]:
+    """
+    Enumerate all the devices from the device manager
+    """
+
+    return get_device_manager().enumerate_devices()
+
+
+@core.cancellable
+def shutdown() -> None:
+    """
+    Shutdown the main device manager
+    """
+
+    get_device_manager()._impl.close()

frida/_frida/__init__.pyi

@@ -0,0 +1,877 @@
+from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple, Union
+
+# Exceptions
+class AddressInUseError(Exception): ...
+class ExecutableNotFoundError(Exception): ...
+class ExecutableNotSupportedError(Exception): ...
+class ServerNotRunningError(Exception): ...
+class TimedOutError(Exception): ...
+class TransportError(Exception): ...
+class ProcessNotFoundError(Exception): ...
+class ProcessNotRespondingError(Exception): ...
+class ProtocolError(Exception): ...
+class InvalidArgumentError(Exception): ...
+class InvalidOperationError(Exception): ...
+class NotSupportedError(Exception): ...
+class OperationCancelledError(Exception): ...
+class PermissionDeniedError(Exception): ...
+
+class Object:
+    def __init__(self, *args: Any, **kwargs: Any) -> None: ...
+    def on(self, signal: str, callback: Callable[..., Any]) -> None:
+        """
+        Add a signal handler.
+        """
+        ...
+
+    def off(self, signal: str, callback: Callable[..., Any]) -> None:
+        """
+        Remove a signal handler.
+        """
+        ...
+
+class Application(Object):
+    @property
+    def identifier(self) -> str:
+        """
+        Application identifier.
+        """
+        ...
+
+    @property
+    def name(self) -> str:
+        """
+        Human-readable application name.
+        """
+        ...
+
+    @property
+    def parameters(self) -> Dict[str, Any]:
+        """
+        Parameters.
+        """
+        ...
+
+    @property
+    def pid(self) -> int:
+        """
+        Process ID, or 0 if not running.
+        """
+        ...
+
+class Bus(Object):
+    def attach(self) -> None:
+        """
+        Attach to the bus.
+        """
+        ...
+
+    def post(self, message: str, data: Optional[Union[bytes, str]]) -> None:
+        """
+        Post a JSON-encoded message to the bus.
+        """
+        ...
+
+class Cancellable(Object):
+    def cancel(self) -> None:
+        """
+        Set cancellable to cancelled.
+        """
+        ...
+
+    def connect(self, callback: Callable[..., Any]) -> int:
+        """
+        Register notification callback.
+        """
+        ...
+
+    def disconnect(self, handler_id: int) -> None:
+        """
+        Unregister notification callback.
+        """
+        ...
+
+    @classmethod
+    def get_current(cls) -> "Cancellable":
+        """
+        Get the top cancellable from the stack.
+        """
+        ...
+
+    def get_fd(self) -> int:
+        """
+        Get file descriptor for integrating with an event loop.
+        """
+        ...
+
+    def is_cancelled(self) -> bool:
+        """
+        Query whether cancellable has been cancelled.
+        """
+        ...
+
+    def pop_current(self) -> None:
+        """
+        Pop cancellable off the cancellable stack.
+        """
+        ...
+
+    def push_current(self) -> None:
+        """
+        Push cancellable onto the cancellable stack.
+        """
+        ...
+
+    def raise_if_cancelled(self) -> None:
+        """
+        Raise an exception if cancelled.
+        """
+        ...
+
+    def release_fd(self) -> None:
+        """
+        Release a resource previously allocated by get_fd().
+        """
+        ...
+
+class Child(Object):
+    @property
+    def argv(self) -> List[str]:
+        """
+        Argument vector.
+        """
+        ...
+
+    @property
+    def envp(self) -> Dict[str, str]:
+        """
+        Environment vector.
+        """
+        ...
+
+    @property
+    def identifier(self) -> str:
+        """
+        Application identifier.
+        """
+        ...
+
+    @property
+    def origin(self) -> str:
+        """
+        Origin.
+        """
+        ...
+
+    @property
+    def parent_pid(self) -> int:
+        """
+        Parent Process ID.
+        """
+        ...
+
+    @property
+    def path(self) -> str:
+        """
+        Path of executable.
+        """
+        ...
+
+    @property
+    def pid(self) -> int:
+        """
+        Process ID.
+        """
+        ...
+
+class Crash(Object):
+    @property
+    def parameters(self) -> Dict[str, Any]:
+        """
+        Parameters.
+        """
+        ...
+
+    @property
+    def pid(self) -> int:
+        """
+        Process ID.
+        """
+        ...
+
+    @property
+    def process_name(self) -> str:
+        """
+        Process name.
+        """
+        ...
+
+    @property
+    def report(self) -> str:
+        """
+        Human-readable crash report.
+        """
+        ...
+
+    @property
+    def summary(self) -> str:
+        """
+        Human-readable crash summary.
+        """
+        ...
+
+class Device(Object):
+    @property
+    def id(self) -> Optional[str]:
+        """
+        Device ID.
+        """
+        ...
+
+    @property
+    def name(self) -> Optional[str]:
+        """
+        Human-readable device name.
+        """
+        ...
+
+    @property
+    def icon(self) -> Optional[Any]:
+        """
+        Icon.
+        """
+        ...
+
+    @property
+    def type(self) -> Optional[str]:
+        """
+        Device type. One of: local, remote, usb.
+        """
+        ...
+
+    @property
+    def bus(self) -> Optional[Bus]:
+        """
+        Message bus.
+        """
+        ...
+
+    def attach(self, pid: int, realm: Optional[str] = None, persist_timeout: Optional[int] = None) -> "Session":
+        """
+        Attach to a PID.
+        """
+        ...
+
+    def disable_spawn_gating(self) -> None:
+        """
+        Disable spawn gating.
+        """
+        ...
+
+    def enable_spawn_gating(self) -> None:
+        """
+        Enable spawn gating.
+        """
+        ...
+
+    def enumerate_applications(
+        self, identifiers: Optional[Sequence[str]] = None, scope: Optional[str] = None
+    ) -> List[Application]:
+        """
+        Enumerate applications.
+        """
+        ...
+
+    def enumerate_pending_children(self) -> List[Child]:
+        """
+        Enumerate pending children.
+        """
+        ...
+
+    def enumerate_pending_spawn(self) -> List["Spawn"]:
+        """
+        Enumerate pending spawn.
+        """
+        ...
+
+    def enumerate_processes(self, pids: Optional[Sequence[int]] = None, scope: Optional[str] = None) -> List[Process]:
+        """
+        Enumerate processes.
+        """
+        ...
+
+    def get_frontmost_application(self, scope: Optional[str] = None) -> Optional[Application]:
+        """
+        Get details about the frontmost application.
+        """
+        ...
+
+    def inject_library_blob(self, pid: int, blob_buffer: bytes, entrypoint: str, data: str) -> int:
+        """
+        Inject a library blob to a PID.
+        """
+        ...
+
+    def inject_library_file(self, pid: int, path: str, entrypoint: str, data: str) -> int:
+        """
+        Inject a library file to a PID.
+        """
+        ...
+
+    def input(self, pid: int, data: bytes) -> None:
+        """
+        Input data on stdin of a spawned process.
+        """
+        ...
+
+    def is_lost(self) -> bool:
+        """
+        Query whether the device has been lost.
+        """
+        ...
+
+    def kill(self, pid: int) -> None:
+        """
+        Kill a PID.
+        """
+        ...
+
+    def open_channel(self, address: str) -> "IOStream":
+        """
+        Open a device-specific communication channel.
+        """
+        ...
+
+    def open_service(self, address: str) -> Service:
+        """
+        Open a device-specific service.
+        """
+        ...
+
+    def unpair(self) -> None:
+        """
+        Unpair device.
+        """
+        ...
+
+    def query_system_parameters(self) -> Dict[str, Any]:
+        """
+        Returns a dictionary of information about the host system.
+        """
+        ...
+
+    def resume(self, pid: int) -> None:
+        """
+        Resume a process from the attachable state.
+        """
+        ...
+
+    def spawn(
+        self,
+        program: str,
+        argv: Union[None, List[Union[str, bytes]], Tuple[Union[str, bytes]]] = None,
+        envp: Optional[Dict[str, str]] = None,
+        env: Optional[Dict[str, str]] = None,
+        cwd: Optional[str] = None,
+        stdio: Optional[str] = None,
+        **kwargs: Any,
+    ) -> int:
+        """
+        Spawn a process into an attachable state.
+        """
+        ...
+
+class DeviceManager(Object):
+    def add_remote_device(
+        self,
+        address: str,
+        certificate: Optional[str] = None,
+        origin: Optional[str] = None,
+        token: Optional[str] = None,
+        keepalive_interval: Optional[int] = None,
+    ) -> Device:
+        """
+        Add a remote device.
+        """
+        ...
+
+    def close(self) -> None:
+        """
+        Close the device manager.
+        """
+        ...
+
+    def enumerate_devices(self) -> List[Device]:
+        """
+        Enumerate devices.
+        """
+        ...
+
+    def get_device_matching(self, predicate: Callable[[Device], bool], timeout: int) -> Device:
+        """
+        Get device matching predicate.
+        """
+        ...
+
+    def remove_remote_device(self, address: str) -> None:
+        """
+        Remove a remote device.
+        """
+        ...
+
+class EndpointParameters(Object): ...
+
+class FileMonitor(Object):
+    def disable(self) -> None:
+        """
+        Disable the file monitor.
+        """
+        ...
+
+    def enable(self) -> None:
+        """
+        Enable the file monitor.
+        """
+        ...
+
+class IOStream(Object):
+    def close(self) -> None:
+        """
+        Close the stream.
+        """
+        ...
+
+    def is_closed(self) -> bool:
+        """
+        Query whether the stream is closed.
+        """
+        ...
+
+    def read(self, size: int) -> bytes:
+        """
+        Read up to the specified number of bytes from the stream.
+        """
+        ...
+
+    def read_all(self, size: int) -> bytes:
+        """
+        Read exactly the specified number of bytes from the stream.
+        """
+        ...
+
+    def write(self, data: bytes) -> int:
+        """
+        Write as much as possible of the provided data to the stream.
+        """
+        ...
+
+    def write_all(self, data: bytes) -> None:
+        """
+        Write all of the provided data to the stream.
+        """
+        ...
+
+class PortalMembership(Object):
+    def terminate(self) -> None:
+        """
+        Terminate the membership.
+        """
+        ...
+
+class PortalService(Object):
+    @property
+    def device(self) -> Device:
+        """
+        Device for in-process control.
+        """
+        ...
+
+    def broadcast(self, message: str, data: Optional[Union[str, bytes]] = None) -> None:
+        """
+        Broadcast a message to all control channels.
+        """
+        ...
+
+    def enumerate_tags(self, connection_id: int) -> List[str]:
+        """
+        Enumerate tags of a specific connection.
+        """
+        ...
+
+    def kick(self, connection_id: int) -> None:
+        """
+        Kick out a specific connection.
+        """
+        ...
+
+    def narrowcast(self, tag: str, message: str, data: Optional[Union[str, bytes]] = None) -> None:
+        """
+        Post a message to control channels with a specific tag.
+        """
+        ...
+
+    def post(self, connection_id: int, message: str, data: Optional[Union[str, bytes]] = None) -> None:
+        """
+        Post a message to a specific control channel.
+        """
+        ...
+
+    def start(self) -> None:
+        """
+        Start listening for incoming connections.
+        """
+        ...
+
+    def stop(self) -> None:
+        """
+        Stop listening for incoming connections, and kick any connected clients.
+        """
+        ...
+
+    def tag(self, connection_id: int, tag: str) -> None:
+        """
+        Tag a specific control channel.
+        """
+        ...
+
+    def untag(self, connection_id: int, tag: str) -> None:
+        """
+        Untag a specific control channel.
+        """
+        ...
+
+class Process(Object):
+    @property
+    def pid(self) -> int:
+        """
+        Process ID.
+        """
+        ...
+
+    @property
+    def name(self) -> str:
+        """
+        Human-readable process name.
+        """
+        ...
+
+    @property
+    def parameters(self) -> Dict[str, Any]:
+        """
+        Parameters.
+        """
+        ...
+
+class Relay(Object):
+    def __init__(self, address: str, username: str, password: str, kind: str) -> None: ...
+    @property
+    def address(self) -> str:
+        """
+        Network address or address:port of the TURN server.
+        """
+        ...
+
+    @property
+    def kind(self) -> str:
+        """
+        Relay kind. One of: turn-udp, turn-tcp, turn-tls.
+        """
+        ...
+
+    @property
+    def password(self) -> str:
+        """
+        The TURN password to use for the allocate request.
+        """
+        ...
+
+    @property
+    def username(self) -> str:
+        """
+        The TURN username to use for the allocate request.
+        """
+        ...
+
+class Script(Object):
+    def eternalize(self) -> None:
+        """
+        Eternalize the script.
+        """
+        ...
+
+    def is_destroyed(self) -> bool:
+        """
+        Query whether the script has been destroyed.
+        """
+        ...
+
+    def load(self) -> None:
+        """
+        Load the script.
+        """
+        ...
+
+    def post(self, message: str, data: Optional[Union[str, bytes]] = None) -> None:
+        """
+        Post a JSON-encoded message to the script.
+        """
+        ...
+
+    def unload(self) -> None:
+        """
+        Unload the script.
+        """
+        ...
+
+    def enable_debugger(self, port: Optional[int]) -> None:
+        """
+        Enable the Node.js compatible script debugger
+        """
+        ...
+
+    def disable_debugger(self) -> None:
+        """
+        Disable the Node.js compatible script debugger
+        """
+        ...
+
+class Service(Object):
+    def activate(self) -> None:
+        """
+        Activate the service.
+        """
+        ...
+
+    def cancel(self) -> None:
+        """
+        Cancel the service.
+        """
+        ...
+
+    def request(self, parameters: Any) -> Any:
+        """
+        Perform a request.
+        """
+        ...
+
+class Session(Object):
+    @property
+    def pid(self) -> int:
+        """
+        Process ID.
+        """
+        ...
+
+    def compile_script(self, source: str, name: Optional[str] = None, runtime: Optional[str] = None) -> bytes:
+        """
+        Compile script source code to bytecode.
+        """
+        ...
+
+    def create_script(self, source: str, name: Optional[str] = None, runtime: Optional[str] = None) -> Script:
+        """
+        Create a new script.
+        """
+        ...
+
+    def create_script_from_bytes(
+        self, data: bytes, name: Optional[str] = None, runtime: Optional[str] = None
+    ) -> Script:
+        """
+        Create a new script from bytecode.
+        """
+        ...
+
+    def snapshot_script(self, embed_script: str, warmup_script: Optional[str], runtime: Optional[str] = None) -> bytes:
+        """
+        Evaluate script and snapshot the resulting VM state
+        """
+        ...
+
+    def detach(self) -> None:
+        """
+        Detach session from the process.
+        """
+        ...
+
+    def disable_child_gating(self) -> None:
+        """
+        Disable child gating.
+        """
+        ...
+
+    def enable_child_gating(self) -> None:
+        """
+        Enable child gating.
+        """
+        ...
+
+    def is_detached(self) -> bool:
+        """
+        Query whether the session is detached.
+        """
+        ...
+
+    def join_portal(
+        self, address: str, certificate: Optional[str] = None, token: Optional[str] = None, acl: Optional[Any] = None
+    ) -> PortalMembership:
+        """
+        Join a portal.
+        """
+        ...
+
+    def resume(self) -> None:
+        """
+        Resume session after network error.
+        """
+        ...
+
+    def setup_peer_connection(
+        self, stun_server: Optional[str] = None, relays: Optional[Sequence[Relay]] = None
+    ) -> None:
+        """
+        Set up a peer connection with the target process.
+        """
+        ...
+
+class Spawn(Object):
+    @property
+    def identifier(self) -> str:
+        """
+        Application identifier.
+        """
+        ...
+
+    @property
+    def pid(self) -> int:
+        """
+        Process ID.
+        """
+        ...
+
+class Compiler(Object):
+    def build(
+        self,
+        entrypoint: str,
+        project_root: Optional[str] = None,
+        output_format: Optional[str] = None,
+        bundle_format: Optional[str] = None,
+        type_check: Optional[str] = None,
+        source_maps: Optional[str] = None,
+        compression: Optional[str] = None,
+        platform: Optional[str] = None,
+        externals: Optional[Sequence[str]] = None,
+    ) -> str:
+        """
+        Build an agent.
+        """
+        ...
+
+    def watch(
+        self,
+        entrypoint: str,
+        project_root: Optional[str] = None,
+        output_format: Optional[str] = None,
+        bundle_format: Optional[str] = None,
+        type_check: Optional[str] = None,
+        source_maps: Optional[str] = None,
+        compression: Optional[str] = None,
+        platform: Optional[str] = None,
+        externals: Optional[Sequence[str]] = None,
+    ) -> None:
+        """
+        Continuously build an agent.
+        """
+        ...
+
+class PackageManager(Object):
+    @property
+    def registry(self) -> str:
+        """
+        The registry being used.
+        """
+        ...
+
+    @registry.setter
+    def registry(self, value: str) -> None:
+        """
+        Change the registry to use.
+        """
+        ...
+
+    def search(
+        self,
+        query: str,
+        offset: Optional[int] = None,
+        limit: Optional[int] = None,
+    ) -> PackageSearchResult:
+        """
+        Search for packages to install.
+        """
+        ...
+
+    def install(
+        self,
+        project_root: Optional[str] = None,
+        role: Optional[str] = None,
+        specs: Optional[Sequence[str]] = None,
+        omits: Optional[Sequence[str]] = None,
+    ) -> PackageInstallResult:
+        """
+        Install one or more packages.
+        """
+        ...
+
+class Package(Object):
+    @property
+    def name(self) -> str:
+        """
+        Package name.
+        """
+        ...
+
+    @property
+    def version(self) -> str:
+        """
+        Package version.
+        """
+        ...
+
+    @property
+    def description(self) -> Optional[str]:
+        """
+        Package description.
+        """
+        ...
+
+    @property
+    def url(self) -> Optional[str]:
+        """
+        Package URL.
+        """
+        ...
+
+class PackageSearchResult(Object):
+    @property
+    def packages(self) -> List[Package]:
+        """
+        Batch of matching packages.
+        """
+        ...
+
+    @property
+    def total(self) -> int:
+        """
+        Total matching packages.
+        """
+        ...
+
+class PackageInstallResult(Object):
+    @property
+    def packages(self) -> List[Package]:
+        """
+        The toplevel packages that are installed.
+        """
+        ...
+
+__version__: str

frida/_frida/meson.build

@@ -0,0 +1,21 @@
+py_sources = [
+  '__init__.pyi',
+  'py.typed',
+]
+python.install_sources(py_sources, subdir: 'frida' / '_frida', pure: false)
+
+extra_link_args = []
+if host_os_family == 'darwin'
+  extra_link_args += '-Wl,-exported_symbol,_PyInit__frida'
+elif host_os_family != 'windows'
+  extra_link_args += '-Wl,--version-script,' + meson.current_source_dir() / 'extension.version'
+endif
+
+extension = python.extension_module('_frida', 'extension.c',
+  limited_api: '3.7',
+  c_args: frida_component_cflags,
+  link_args: extra_link_args,
+  dependencies: [python_dep, frida_core_dep, os_deps],
+  install: true,
+  subdir: 'frida',
+)

frida/frida_bindgen/__main__.py

@@ -1,4 +0,0 @@
-from .cli import main
-
-if __name__ == "__main__":
-    main()

frida/frida_bindgen/assets/codegen_gobject_globals.c

@@ -1 +0,0 @@
-static GHashTable * pygobject_type_spec_by_type;

frida/frida_bindgen/assets/codegen_gobject_methods.c

@@ -1,77 +0,0 @@
-static void
-PyGObject_class_init (void)
-{
-  pygobject_type_spec_by_type = g_hash_table_new_full (NULL, NULL, NULL, NULL);
-}
-
-static int
-PyGObject_init (PyGObject * self)
-{
-  self->handle = NULL;
-  self->type = PYFRIDA_TYPE (GObject);
-
-  self->signal_closures = NULL;
-
-  return 0;
-}
-
-static void
-PyGObject_dealloc (PyGObject * self)
-{
-  gpointer handle;
-
-  handle = PyGObject_steal_handle (self);
-  if (handle != NULL)
-  {
-    Py_BEGIN_ALLOW_THREADS
-    self->type->destroy (handle);
-    Py_END_ALLOW_THREADS
-  }
-
-  ((freefunc) PyType_GetSlot (Py_TYPE (self), Py_tp_free)) (self);
-}
-
-static void
-PyGObject_take_handle (PyGObject * self,
-                       gpointer handle,
-                       const PyGObjectType * type)
-{
-  self->handle = handle;
-  self->type = type;
-
-  if (handle != NULL)
-    g_object_set_data (G_OBJECT (handle), "pyobject", self);
-}
-
-static gpointer
-PyGObject_steal_handle (PyGObject * self)
-{
-  gpointer handle = self->handle;
-  GSList * entry;
-
-  if (handle == NULL)
-    return NULL;
-
-  for (entry = self->signal_closures; entry != NULL; entry = entry->next)
-  {
-    PyGObjectSignalClosure * closure = entry->data;
-    G_GNUC_UNUSED guint num_matches;
-
-    num_matches = g_signal_handlers_disconnect_matched (handle, G_SIGNAL_MATCH_CLOSURE, closure->signal_id, 0, &closure->parent, NULL, NULL);
-    g_assert (num_matches == 1);
-  }
-  g_clear_pointer (&self->signal_closures, g_slist_free);
-
-  g_object_set_data (G_OBJECT (handle), "pyobject", NULL);
-
-  self->handle = NULL;
-
-  return handle;
-}
-
-static void
-PyGObject_register_type (GType instance_type,
-                         PyGObjectType * python_type)
-{
-  g_hash_table_insert (pygobject_type_spec_by_type, GSIZE_TO_POINTER (instance_type), python_type);
-}

frida/frida_bindgen/assets/codegen_gobject_prototypes.h

@@ -1,5 +0,0 @@
-static void PyGObject_class_init (void);
-static int PyGObject_init (PyGObject * self);
-static void PyGObject_dealloc (PyGObject * self);
-static gpointer PyGObject_steal_handle (PyGObject * self);
-static void PyGObject_register_type (GType instance_type, PyGObjectType * python_type);

frida/frida_bindgen/assets/codegen_helpers.ts

@@ -1,100 +0,0 @@
-type SignalTransformer<
-    Source extends SignalHandler,
-    Target extends SignalHandler
-> = (...args: Parameters<Source>) => Parameters<Target>;
-
-type SignalInterceptor<H extends SignalHandler> = (...args: Parameters<H>) => boolean;
-
-interface SignalWrapperOptionsNoTransform<H extends SignalHandler> {
-    transform?: undefined;
-    intercept?: SignalInterceptor<H>;
-}
-
-interface SignalWrapperOptionsTransform<
-    Source extends SignalHandler,
-    Target extends SignalHandler
-> {
-    transform: SignalTransformer<Source, Target>;
-    intercept?: SignalInterceptor<Target>;
-}
-
-type SignalWrapperOptions<
-    Source extends SignalHandler,
-    Target extends SignalHandler
-> =
-    | SignalWrapperOptionsNoTransform<Source & Target>
-    | SignalWrapperOptionsTransform<Source, Target>;
-
-class SignalWrapper<
-    SourceHandler extends SignalHandler,
-    TargetHandler extends SignalHandler
-> {
-    #source: Signal<SourceHandler>;
-    #transform?: SignalTransformer<SourceHandler, TargetHandler>;
-    #intercept?: SignalInterceptor<any>;
-
-    #handlers = new Set<TargetHandler>();
-
-    constructor(
-        source: Signal<SourceHandler>,
-        options?: SignalWrapperOptions<SourceHandler, TargetHandler>
-    ) {
-        this.#source = source;
-
-        if (options === undefined || options.transform === undefined) {
-            this.#intercept = options?.intercept;
-        } else {
-            this.#transform = options.transform;
-            this.#intercept = options.intercept;
-        }
-    }
-
-    connect(handler: TargetHandler): void {
-        this.#handlers.add(handler);
-        if (this.#handlers.size === 1) {
-            this.#source.connect(this.#wrappedHandler);
-        }
-    }
-
-    disconnect(handler: TargetHandler): void {
-        this.#handlers.delete(handler);
-        if (this.#handlers.size === 0) {
-            this.#source.disconnect(this.#wrappedHandler);
-        }
-    }
-
-    #wrappedHandler = ((...sourceArgs: Parameters<SourceHandler>) => {
-        let targetArgs: Parameters<TargetHandler>;
-        const transform = this.#transform;
-        if (transform === undefined) {
-            targetArgs = sourceArgs as unknown as Parameters<TargetHandler>;
-        } else {
-            targetArgs = transform(...sourceArgs);
-        }
-
-        const intercept = this.#intercept;
-        if (intercept !== undefined) {
-            if (!intercept(...targetArgs)) {
-                return;
-            }
-        }
-
-        for (const handler of this.#handlers) {
-            handler(...targetArgs);
-        }
-    }) as SourceHandler;
-}
-
-function inspectWrapper(object: any, name: string, properties: string[], depth: number, options: util.InspectOptionsStylized): string {
-    if (depth < 0) {
-        return options.stylize(`[${name}]`, "special");
-    }
-
-    const summary = Object.fromEntries(properties.map(name => [name, object[name]]));
-
-    const nextOptions = Object.assign({}, options, {
-        depth: (options.depth === null) ? null : depth - 1
-    });
-
-    return name + " " + inspect(summary, nextOptions);
-}

frida/frida_bindgen/assets/codegen_macros.h

@@ -1,60 +0,0 @@
-#define PYFRIDA_TYPE(name) \
-  (&_PYFRIDA_TYPE_VAR (name, type))
-#define PYFRIDA_TYPE_OBJECT(name) \
-  PYFRIDA_TYPE (name)->object
-#define _PYFRIDA_TYPE_VAR(name, var) \
-  G_PASTE (G_PASTE (G_PASTE (Py, name), _), var)
-#define PYFRIDA_DEFINE_BASETYPE(pyname, cname, ...) \
-  _PYFRIDA_DEFINE_TYPE_SLOTS (cname, __VA_ARGS__); \
-  _PYFRIDA_DEFINE_TYPE_SPEC (cname, pyname, Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE); \
-  static PyGObjectType _PYFRIDA_TYPE_VAR (cname, type) = \
-  { \
-    .parent = NULL, \
-    .object = NULL, \
-  }
-#define PYFRIDA_DEFINE_TYPE(pyname, cname, parent_cname, ...) \
-  _PYFRIDA_DEFINE_TYPE_SLOTS (cname, __VA_ARGS__); \
-  _PYFRIDA_DEFINE_TYPE_SPEC (cname, pyname, Py_TPFLAGS_DEFAULT); \
-  static PyGObjectType _PYFRIDA_TYPE_VAR (cname, type) = \
-  { \
-    .parent = PYFRIDA_TYPE (parent_cname), \
-    .object = NULL, \
-  }
-#define PYFRIDA_REGISTER_TYPE(cname, gtype) \
-  G_BEGIN_DECLS \
-  { \
-    PyGObjectType * t = PYFRIDA_TYPE (cname); \
-    t->object = PyType_FromSpecWithBases (&_PYFRIDA_TYPE_VAR (cname, spec), \
-        (t->parent != NULL) ? PyTuple_Pack (1, t->parent->object) : NULL); \
-    PyGObject_register_type (gtype, t); \
-    Py_IncRef (t->object); \
-    PyModule_AddObject (module, G_STRINGIFY (cname), t->object); \
-  } \
-  G_END_DECLS
-#define _PYFRIDA_DEFINE_TYPE_SPEC(cname, pyname, type_flags) \
-  static PyType_Spec _PYFRIDA_TYPE_VAR (cname, spec) = \
-  { \
-    .name = pyname, \
-    .basicsize = sizeof (G_PASTE (Py, cname)), \
-    .itemsize = 0, \
-    .flags = type_flags, \
-    .slots = _PYFRIDA_TYPE_VAR (cname, slots), \
-  }
-#define _PYFRIDA_DEFINE_TYPE_SLOTS(cname, ...) \
-  static PyType_Slot _PYFRIDA_TYPE_VAR (cname, slots)[] = \
-  { \
-    __VA_ARGS__ \
-    { 0 }, \
-  }
-
-#define PY_GOBJECT(o) ((PyGObject *) (o))
-#define PY_GOBJECT_HANDLE(o) (PY_GOBJECT (o)->handle)
-#define PY_GOBJECT_SIGNAL_CLOSURE(o) ((PyGObjectSignalClosure *) (o))
-
-#define PyFrida_RETURN_NONE \
-  G_STMT_START \
-  { \
-    Py_IncRef (Py_None); \
-    return Py_None; \
-  } \
-  G_STMT_END

frida/frida_bindgen/assets/codegen_prototypes.h

@@ -1,78 +0,0 @@
-G_GNUC_UNUSED static gboolean fdn_is_null (napi_env env, napi_value value);
-static gboolean fdn_is_undefined_or_null (napi_env env, napi_value value);
-static gboolean fdn_is_function (napi_env env, napi_value value);
-
-static gboolean fdn_boolean_from_value (napi_env env, napi_value value, gboolean * b);
-static napi_value fdn_boolean_to_value (napi_env env, gboolean b);
-static gboolean fdn_size_from_value (napi_env env, napi_value value, gsize * s);
-static napi_value fdn_size_to_value (napi_env env, gsize s);
-static napi_value fdn_ssize_to_value (napi_env env, gssize s);
-static gboolean fdn_int_from_value (napi_env env, napi_value value, gint * i);
-static napi_value fdn_int_to_value (napi_env env, gint i);
-static gboolean fdn_uint_from_value (napi_env env, napi_value value, guint * u);
-static napi_value fdn_uint_to_value (napi_env env, guint u);
-static gboolean fdn_uint16_from_value (napi_env env, napi_value value, guint16 * u);
-static napi_value fdn_uint16_to_value (napi_env env, guint16 u);
-static napi_value fdn_uint32_to_value (napi_env env, guint32 u);
-static gboolean fdn_int64_from_value (napi_env env, napi_value value, gint64 * i);
-static napi_value fdn_int64_to_value (napi_env env, gint64 i);
-static napi_value fdn_uint64_to_value (napi_env env, guint64 u);
-static gboolean fdn_ulong_from_value (napi_env env, napi_value value, gulong * u);
-static gboolean fdn_double_from_value (napi_env env, napi_value value, gdouble * d);
-static napi_value fdn_double_to_value (napi_env env, gdouble d);
-static gboolean fdn_enum_from_value (napi_env env, GType enum_type, napi_value value, gint * e);
-static napi_value fdn_enum_to_value (napi_env env, GType enum_type, gint e);
-static gboolean fdn_utf8_from_value (napi_env env, napi_value value, gchar ** str);
-static napi_value fdn_utf8_to_value (napi_env env, const gchar * str);
-static gboolean fdn_strv_from_value (napi_env env, napi_value value, gchar *** strv);
-static napi_value fdn_strv_to_value (napi_env env, gchar ** strv);
-static napi_value fdn_buffer_to_value (napi_env env, const guint8 * data, gsize size);
-static gboolean fdn_bytes_from_value (napi_env env, napi_value value, GBytes ** bytes);
-static napi_value fdn_bytes_to_value (napi_env env, GBytes * bytes);
-static gboolean fdn_vardict_from_value (napi_env env, napi_value value, GHashTable ** vardict);
-static napi_value fdn_vardict_to_value (napi_env env, GHashTable * vardict);
-static gboolean fdn_variant_from_value (napi_env env, napi_value value, GVariant ** variant);
-static napi_value fdn_variant_to_value (napi_env env, GVariant * variant);
-static gboolean fdn_gvalue_from_value (napi_env env, GType type, napi_value js_value, GValue * value);
-static napi_value fdn_gvalue_to_value (napi_env env, GValue * value);
-static gboolean fdn_error_from_value (napi_env env, napi_value value, GError ** error);
-static napi_value fdn_error_to_value (napi_env env, GError * error);
-static gboolean fdn_file_from_value (napi_env env, napi_value value, GFile ** file);
-static napi_value fdn_file_to_value (napi_env env, GFile * file);
-static gboolean fdn_tls_certificate_from_value (napi_env env, napi_value value, GTlsCertificate ** certificate);
-static napi_value fdn_tls_certificate_to_value (napi_env env, GTlsCertificate * certificate);
-static gboolean fdn_options_from_value (napi_env env, GType object_type, napi_value value, gpointer * options);
-
-static napi_value fdn_object_subclass_to_value (napi_env env, GObject * object);
-static napi_value fdn_object_new (napi_env env, GObject * handle, napi_ref constructor);
-static gboolean fdn_object_wrap (napi_env env, napi_value wrapper, GObject * handle, napi_finalize finalizer);
-static gboolean fdn_object_unwrap (napi_env env, napi_value wrapper, GType expected_type, GObject ** handle);
-static void fdn_object_finalize (napi_env env, void * finalize_data, void * finalize_hint);
-static napi_value fdn_object_get_signal (napi_env env, napi_callback_info info, const gchar * name, const gchar * js_storage_name, FdnSignalBehavior behavior);
-
-static napi_value fdn_signal_new (napi_env env, GObject * handle, const gchar * name, FdnSignalBehavior behavior);
-static void fdn_signal_register (napi_env env, napi_value exports);
-static napi_value fdn_signal_construct (napi_env env, napi_callback_info info);
-static void fdn_signal_finalize (napi_env env, void * finalize_data, void * finalize_hint);
-static napi_value fdn_signal_connect (napi_env env, napi_callback_info info);
-static napi_value fdn_signal_disconnect (napi_env env, napi_callback_info info);
-static void fdn_signal_disconnect_closure (FdnSignal * self, FdnSignalClosure * closure);
-static gboolean fdn_signal_parse_arguments (napi_env env, napi_callback_info info, FdnSignal ** self, napi_value * js_self, napi_value * handler);
-static FdnSignalClosure * fdn_signal_closure_new (napi_env env, FdnSignal * sig, napi_value js_sig, napi_value handler);
-static void fdn_signal_closure_finalize (gpointer data, GClosure * closure);
-static void fdn_signal_closure_marshal (GClosure * closure, GValue * return_gvalue, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data);
-static void fdn_signal_closure_deliver (napi_env env, napi_value js_cb, void * context, void * data);
-
-static void fdn_keep_alive_until (napi_env env, napi_value js_object, GObject * handle, FdnIsDestroyedFunc is_destroyed, const gchar * destroy_signal_name);
-static void fdn_keep_alive_on_finalize (napi_env env, void * finalize_data, void * finalize_hint);
-static void fdn_keep_alive_on_destroy_signal (GObject * handle, gpointer user_data);
-static void fdn_keep_alive_on_destroy_signal_handler_detached (gpointer data, GClosure * closure);
-static void fdn_keep_alive_schedule_cleanup (FdnKeepAliveContext * context);
-static void fdn_keep_alive_on_tsfn_invoke (napi_env env, napi_value js_cb, void * context, void * data);
-
-static void fdn_inherit_val_val (napi_env env, napi_value sub_ctor, napi_value super_ctor, napi_value object_ctor, napi_value set_proto);
-G_GNUC_UNUSED static void fdn_inherit_val_ref (napi_env env, napi_value sub_ctor, napi_ref super_ctor, napi_value object_ctor, napi_value set_proto);
-static void fdn_inherit_ref_val (napi_env env, napi_ref sub_ctor, napi_value super_ctor, napi_value object_ctor, napi_value set_proto);
-static void fdn_inherit_ref_ref (napi_env env, napi_ref sub_ctor, napi_ref super_ctor, napi_value object_ctor, napi_value set_proto);
-
-static gchar * fdn_camel_case_to_kebab_case (const gchar * name);

frida/frida_bindgen/assets/codegen_structs.h

@@ -1,24 +0,0 @@
-struct _PyGObject
-{
-  PyObject_HEAD
-
-  gpointer handle;
-  const PyGObjectType * type;
-
-  GSList * signal_closures;
-};
-
-struct _PyGObjectType
-{
-  PyGObjectType * parent;
-  PyObject * object;
-  PyGObjectInitFromHandleFunc init_from_handle;
-  GDestroyNotify destroy;
-};
-
-struct _PyGObjectSignalClosure
-{
-  GClosure parent;
-  guint signal_id;
-  guint max_arg_count;
-};

frida/frida_bindgen/assets/codegen_typedefs.h

@@ -1,4 +0,0 @@
-typedef struct _PyGObject                      PyGObject;
-typedef void (* PyGObjectInitFromHandleFunc)  (PyObject * self, gpointer handle);
-typedef struct _PyGObjectType                  PyGObjectType;
-typedef struct _PyGObjectSignalClosure         PyGObjectSignalClosure;

frida/frida_bindgen/assets/customization_facade.exports

@@ -1,13 +0,0 @@
-querySystemParameters
-spawn
-resume
-kill
-attach
-injectLibraryFile
-injectLibraryBlob
-enumerateDevices
-getDeviceManager
-getLocalDevice
-getRemoteDevice
-getUsbDevice
-getDevice

frida/frida_bindgen/assets/customization_facade.ts

@@ -1,157 +0,0 @@
-let sharedDeviceManager: DeviceManager | null = null;
-
-export async function querySystemParameters(cancellable?: Cancellable | null): Promise<SystemParameters> {
-    const device = await getLocalDevice(cancellable);
-    return await device.querySystemParameters(cancellable);
-}
-
-export async function spawn(program: string | string[], options?: SpawnOptions, cancellable?: Cancellable | null): Promise<number> {
-    const device = await getLocalDevice(cancellable);
-    return await device.spawn(program, options, cancellable);
-}
-
-export async function resume(target: TargetProcess, cancellable?: Cancellable | null): Promise<void> {
-    const device = await getLocalDevice(cancellable);
-    await device.resume(target, cancellable);
-}
-
-export async function kill(target: TargetProcess, cancellable?: Cancellable | null): Promise<void> {
-    const device = await getLocalDevice(cancellable);
-    await device.kill(target, cancellable);
-}
-
-export async function attach(target: TargetProcess, options?: SessionOptions, cancellable?: Cancellable | null): Promise<Session> {
-    const device = await getLocalDevice(cancellable);
-    return await device.attach(target, options, cancellable);
-}
-
-export async function injectLibraryFile(target: TargetProcess, path: string, entrypoint: string, data: string,
-        cancellable?: Cancellable | null): Promise<number> {
-    const device = await getLocalDevice(cancellable);
-    return await device.injectLibraryFile(target, path, entrypoint, data, cancellable);
-}
-
-export async function injectLibraryBlob(target: TargetProcess, blob: Buffer, entrypoint: string, data: string,
-        cancellable?: Cancellable | null): Promise<number> {
-    const device = await getLocalDevice(cancellable);
-    return await device.injectLibraryBlob(target, blob, entrypoint, data, cancellable);
-}
-
-export async function enumerateDevices(cancellable?: Cancellable | null): Promise<Device[]> {
-    const deviceManager = getDeviceManager();
-    return await deviceManager.enumerateDevices(cancellable);
-};
-
-export function getDeviceManager(): DeviceManager {
-    if (sharedDeviceManager === null) {
-        sharedDeviceManager = new DeviceManager();
-    }
-    return sharedDeviceManager;
-}
-
-export function getLocalDevice(cancellable?: Cancellable | null): Promise<Device> {
-    return getMatchingDevice(device => device.type === DeviceType.Local, {}, cancellable);
-}
-
-export function getRemoteDevice(cancellable?: Cancellable | null): Promise<Device> {
-    return getMatchingDevice(device => device.type === DeviceType.Remote, {}, cancellable);
-}
-
-export function getUsbDevice(options?: GetDeviceOptions, cancellable?: Cancellable | null): Promise<Device> {
-    return getMatchingDevice(device => device.type === DeviceType.Usb, options, cancellable);
-}
-
-export function getDevice(id: string, options?: GetDeviceOptions, cancellable?: Cancellable | null): Promise<Device> {
-    return getMatchingDevice(device => device.id === id, options, cancellable);
-}
-
-export interface GetDeviceOptions {
-    timeout?: number | null;
-}
-
-async function getMatchingDevice(predicate: DevicePredicate, options: GetDeviceOptions = {}, cancellable: Cancellable | null = null): Promise<Device> {
-    const device = await findMatchingDevice(predicate, cancellable);
-    if (device !== null) {
-        return device;
-    }
-
-    const { timeout = 0 } = options;
-    if (timeout === 0) {
-        throw new Error("Device not found");
-    }
-
-    const getDeviceEventually = new Promise((resolve: (device: Device) => void, reject: (error: Error) => void) => {
-        const deviceManager = getDeviceManager();
-
-        deviceManager.added.connect(onDeviceAdded);
-
-        const timer = (timeout !== null) ? setTimeout(onTimeout, timeout) : null;
-
-        if (cancellable !== null) {
-            cancellable.cancelled.connect(onCancel);
-            if (cancellable.isCancelled) {
-                onCancel();
-                return;
-            }
-        }
-
-        findMatchingDevice(predicate, cancellable)
-            .then(device => {
-                if (device !== null) {
-                    onSuccess(device);
-                }
-            })
-            .catch(onError);
-
-        function onDeviceAdded(device: Device): void {
-            if (predicate(device)) {
-                onSuccess(device);
-            }
-        }
-
-        function onSuccess(device: Device): void {
-            stopMonitoring();
-            resolve(device);
-        }
-
-        function onError(error: Error): void {
-            stopMonitoring();
-            reject(error);
-        }
-
-        function onTimeout(): void {
-            onError(new Error("Timed out while waiting for device to appear"));
-        }
-
-        function onCancel(): void {
-            onError(new Error("Operation was cancelled"));
-        }
-
-        function stopMonitoring(): void {
-            cancellable?.cancelled.disconnect(onCancel);
-
-            if (timer !== null) {
-                clearTimeout(timer);
-            }
-
-            deviceManager.added.disconnect(onDeviceAdded);
-        }
-    });
-
-    return await getDeviceEventually;
-}
-
-async function findMatchingDevice(predicate: DevicePredicate, cancellable?: Cancellable | null): Promise<Device | null> {
-    const deviceManager = getDeviceManager();
-
-    const devices = await deviceManager.enumerateDevices(cancellable);
-
-    const matching = devices.filter(predicate);
-    if (matching.length === 0) {
-        return null;
-    }
-
-    return matching[0];
-}
-
-type DevicePredicate = (device: Device) => boolean;

frida/frida_bindgen/assets/customization_helpers.imports

@@ -1,2 +0,0 @@
-import { Minimatch } from "minimatch";
-import { Duplex } from "stream";

frida/frida_bindgen/assets/customization_helpers.ts

@@ -1,396 +0,0 @@
-const STANDARD_SPAWN_OPTION_NAMES = new Set<keyof SpawnOptions>([
-    "argv",
-    "envp",
-    "env",
-    "cwd",
-    "stdio",
-]);
-
-interface LogMessage {
-    type: "log";
-    level: LogLevel;
-    payload: string;
-}
-
-class ScriptServices implements RpcController {
-    exportsProxy = new ScriptExportsProxy(this);
-
-    #script: Script;
-    #pendingRequests = new Map<number, (error: Error | null, result?: any) => void>();
-    #nextRequestId = 1;
-
-    constructor(script: Script) {
-        this.#script = script;
-        process.nextTick(() => {
-            script.message.connect(() => {});
-        });
-    }
-
-    handleMessageIntercept = (message: Message, data: Buffer | null): boolean => {
-        if (message.type === MessageType.Send && isRpcSendMessage(message)) {
-            const [ , id, operation, ...params ] = message.payload;
-            this.#onRpcMessage(id, operation, params, data);
-            return false;
-        } else if (isLogMessage(message)) {
-            const opaqueMessage: any = message;
-            const logMessage: LogMessage = opaqueMessage;
-            this.#script.logHandler(logMessage.level, logMessage.payload);
-            return false;
-        }
-
-        return true;
-    };
-
-    request(operation: string, params: any[], data: Buffer | null, cancellable: Cancellable | null = null): Promise<any> {
-        return new Promise((resolve, reject) => {
-            const id = this.#nextRequestId++;
-
-            const complete = (error: Error | null, result?: any): void => {
-                if (cancellable !== null) {
-                    cancellable.cancelled.disconnect(onOperationCancelled);
-                }
-                this.#script.destroyed.disconnect(onScriptDestroyed);
-
-                this.#pendingRequests.delete(id);
-
-                if (error === null) {
-                    resolve(result);
-                } else {
-                    reject(error);
-                }
-            };
-
-            function onScriptDestroyed(): void {
-                complete(new Error("Script is destroyed"));
-            }
-
-            function onOperationCancelled(): void {
-                complete(new Error("Operation was cancelled"));
-            }
-
-            this.#pendingRequests.set(id, complete);
-
-            this.#script.post(["frida:rpc", id, operation, ...params], data);
-            this.#script.destroyed.connect(onScriptDestroyed);
-            if (cancellable !== null) {
-                cancellable.cancelled.connect(onOperationCancelled);
-                if (cancellable.isCancelled) {
-                    onOperationCancelled();
-                    return;
-                }
-            }
-            if (this.#script.isDestroyed) {
-                onScriptDestroyed();
-            }
-        });
-    }
-
-    #onRpcMessage(id: number, operation: RpcOperation, params: any[], data: Buffer | null) {
-        if (operation === RpcOperation.Ok || operation === RpcOperation.Error) {
-            const callback = this.#pendingRequests.get(id);
-            if (callback === undefined) {
-                return;
-            }
-
-            let value = null;
-            let error = null;
-            if (operation === RpcOperation.Ok) {
-                if (data !== null) {
-                    value = (params.length > 1) ? [params[1], data] : data;
-                } else {
-                    value = params[0];
-                }
-            } else {
-                const [message, name, stack, rawErr] = params;
-                error = new Error(message);
-                error.name = name;
-                error.stack = stack;
-                Object.assign(error, rawErr);
-            }
-
-            callback(error, value);
-        }
-    }
-}
-
-class ScriptExportsProxy implements ScriptExports {
-    [name: string]: (...args: any[]) => Promise<any>;
-
-    constructor(rpcController: RpcController) {
-        return new Proxy(this, {
-            has(target, property) {
-                return !isReservedMethodName(property);
-            },
-            get(target, property, receiver) {
-                if (typeof property === "symbol") {
-                    if (property === inspect.custom) {
-                        return inspectProxy;
-                    }
-
-                    return undefined;
-                }
-
-                if (property in target) {
-                    return target[property];
-                }
-
-                if (isReservedMethodName(property)) {
-                    return undefined;
-                }
-
-                return (...args: any[]): Promise<any> => {
-                    let cancellable: Cancellable | null = null;
-                    if (args[args.length - 1] instanceof Cancellable) {
-                        cancellable = args.pop();
-                    }
-
-                    let data: Buffer | null = null;
-                    if (Buffer.isBuffer(args[args.length - 1])) {
-                        data = args.pop();
-                    }
-
-                    return rpcController.request("call", [property, args], data, cancellable);
-                };
-            },
-            set(target, property, value, receiver) {
-                if (typeof property === "symbol") {
-                    return false;
-                }
-                target[property] = value;
-                return true;
-            },
-            ownKeys(target) {
-                return Object.getOwnPropertyNames(target);
-            },
-            getOwnPropertyDescriptor(target, property) {
-                if (property in target) {
-                    return Object.getOwnPropertyDescriptor(target, property);
-                }
-
-                if (isReservedMethodName(property)) {
-                    return undefined;
-                }
-
-                return {
-                    writable: true,
-                    configurable: true,
-                    enumerable: true
-                };
-            },
-        });
-    }
-}
-
-function inspectProxy() {
-    return "ScriptExportsProxy {}";
-}
-
-interface RpcController {
-    request(operation: string, params: any[], data: ArrayBuffer | null, cancellable: Cancellable | null): Promise<any>;
-}
-
-enum RpcOperation {
-    Ok = "ok",
-    Error = "error"
-}
-
-function isInternalMessage(message: Message): boolean {
-    return isRpcMessage(message) || isLogMessage(message);
-}
-
-function isRpcMessage(message: Message): boolean {
-    return message.type === MessageType.Send && isRpcSendMessage(message);
-}
-
-function isRpcSendMessage(message: SendMessage): boolean {
-    const payload = message.payload;
-    if (!Array.isArray(payload)) {
-        return false;
-    }
-
-    return payload[0] === "frida:rpc";
-}
-
-function isLogMessage(message: Message): boolean {
-    return message.type as string === "log";
-}
-
-function log(level: LogLevel, text: string): void {
-    switch (level) {
-        case LogLevel.Info:
-            console.log(text);
-            break;
-        case LogLevel.Warning:
-            console.warn(text);
-            break;
-        case LogLevel.Error:
-            console.error(text);
-            break;
-    }
-}
-
-const reservedMethodNames = new Set<string>([
-    "then",
-    "catch",
-    "finally",
-]);
-
-function isReservedMethodName(name: string | number | symbol): boolean {
-    return reservedMethodNames.has(name.toString());
-}
-
-const IO_PRIORITY_DEFAULT = 0;
-
-class IOStreamAdapter extends Duplex {
-    #impl: IOStream;
-    #input: InputStream;
-    #output: OutputStream;
-    #pending = new Set<Promise<void>>();
-
-    #cancellable = new Cancellable();
-
-    constructor(impl: IOStream) {
-        super({});
-
-        this.#impl = impl;
-        this.#input = impl.inputStream;
-        this.#output = impl.outputStream;
-    }
-
-    async _destroy(error: Error | null, callback: (error: Error | null) => void): Promise<void> {
-        this.#cancellable.cancel();
-
-        for (const operation of this.#pending) {
-            try {
-                await operation;
-            } catch (e) {
-            }
-        }
-
-        try {
-            await this.#impl.close(IO_PRIORITY_DEFAULT);
-        } catch (e) {
-        }
-
-        callback(error);
-    }
-
-    _read(size: number): void {
-        const operation = this.#input.read(size, IO_PRIORITY_DEFAULT, this.#cancellable)
-            .then((data: Buffer): void => {
-                const isEof = data.length === 0;
-                if (isEof) {
-                    this.push(null);
-                    return;
-                }
-
-                this.push(data);
-            })
-            .catch((error: Error): void => {
-                if (this.#impl.closed) {
-                    this.push(null);
-                }
-                this.emit("error", error);
-            });
-        this.#track(operation);
-    }
-
-    _write(chunk: any, encoding: BufferEncoding, callback: (error?: Error | null) => void): void {
-        let data: Buffer;
-        if (Buffer.isBuffer(chunk)) {
-            data = chunk;
-        } else {
-            data = Buffer.from(chunk, encoding);
-        }
-        const operation = this.#writeAll(data)
-            .then((): void => {
-                callback(null);
-            })
-            .catch((error: Error): void => {
-                callback(error);
-            });
-        this.#track(operation);
-    }
-
-    async #writeAll(data: Buffer): Promise<void> {
-        let offset = 0;
-        do {
-            const n = await this.#output.write(data.slice(offset), IO_PRIORITY_DEFAULT, this.#cancellable);
-            offset += n;
-        } while (offset !== data.length);
-    }
-
-    #track(operation: Promise<void>): void {
-        this.#pending.add(operation);
-        operation
-            .catch(_ => {})
-            .finally(() => {
-                this.#pending.delete(operation);
-            });
-    }
-}
-
-class CallbackAuthenticationService extends binding.AbstractAuthenticationService {
-    #callback: AuthenticationCallback;
-
-    constructor(callback: AuthenticationCallback) {
-        super();
-        this.#callback = callback;
-    }
-
-    async authenticate(token: string, cancellable: Cancellable | null): Promise<string> {
-        const info = await this.#callback(token);
-        return JSON.stringify(info);
-    }
-}
-
-function parseSocketAddress(address: BaseSocketAddress): SocketAddress {
-    const family = address.family;
-    switch (family) {
-        case SocketFamily.Unix: {
-            const addr = address as UnixSocketAddress;
-            switch (addr.addressType) {
-                case UnixSocketAddressType.Anonymous:
-                    return {
-                        family: "unix:anonymous",
-                    };
-                case UnixSocketAddressType.Path:
-                    return {
-                        family: "unix:path",
-                        path: addr.path.toString(),
-                    };
-                case UnixSocketAddressType.Abstract:
-                case UnixSocketAddressType.AbstractPadded:
-                    return {
-                        family: "unix:abstract",
-                        path: addr.path,
-                    };
-            }
-            break;
-        }
-        case SocketFamily.Ipv4: {
-            const addr = address as InetSocketAddress;
-            return {
-                family: "ipv4",
-                address: addr.address.toString(),
-                port: addr.port,
-            };
-        }
-        case SocketFamily.Ipv6: {
-            const addr = address as InetSocketAddress;
-            return {
-                family: "ipv6",
-                address: addr.address.toString(),
-                port: addr.port,
-                flowlabel: addr.flowinfo,
-                scopeid: addr.scopeId,
-            };
-        }
-    }
-
-    throw new Error("invalid BaseSocketAddress");
-}
-
-function objectToStrv(object: { [name: string]: string }): string[] {
-    return Object.entries(object).map(([k, v]) => `${k}=${v}`);
-}

frida/frida_bindgen/cli.py

@@ -1,96 +0,0 @@
-from __future__ import annotations
-
-import argparse
-from io import StringIO
-from pathlib import Path
-
-from . import codegen
-from .customization import load_customizations
-from .loader import compute_model
-
-
-def main():
-    run(build_arguments())
-
-
-def build_arguments() -> argparse.Namespace:
-    p = argparse.ArgumentParser(
-        description="Generate TypeScript and Node-API bindings for Frida."
-    )
-    p.add_argument(
-        "--frida-gir",
-        required=True,
-        type=Path,
-        help="Path to the Frida .gir file.",
-    )
-    p.add_argument(
-        "--glib-gir",
-        required=True,
-        type=Path,
-        help="Path to the GLib .gir file.",
-    )
-    p.add_argument(
-        "--gobject-gir",
-        required=True,
-        type=Path,
-        help="Path to the GObject .gir file.",
-    )
-    p.add_argument(
-        "--gio-gir",
-        required=True,
-        type=Path,
-        help="Path to the GIO .gir file.",
-    )
-    p.add_argument(
-        "--output-py",
-        required=True,
-        type=Path,
-        help="Path to the output .py file.",
-    )
-    p.add_argument(
-        "--output-pyi",
-        required=True,
-        type=Path,
-        help="Path to the output .pyi file.",
-    )
-    p.add_argument(
-        "--output-c",
-        required=True,
-        type=Path,
-        help="Path to the output C file for the Python extension.",
-    )
-    return p.parse_args()
-
-
-def run(args: argparse.Namespace) -> None:
-    customizations = load_customizations()
-    model = compute_model(
-        args.frida_gir, args.glib_gir, args.gobject_gir, args.gio_gir, customizations
-    )
-
-    artefacts = codegen.generate_all(model)
-
-    with OutputFile(args.output_py) as f:
-        f.write(artefacts["py"])
-    with OutputFile(args.output_pyi) as f:
-        f.write(artefacts["pyi"])
-    with OutputFile(args.output_c) as f:
-        f.write(artefacts["c"])
-
-
-class OutputFile:
-    def __init__(self, output_path):
-        self._output_path = output_path
-        self._io = StringIO()
-
-    def __enter__(self):
-        return self._io
-
-    def __exit__(self, *exc):
-        result = self._io.getvalue()
-        if self._output_path.exists():
-            existing_contents = self._output_path.read_text(encoding="utf-8")
-            if existing_contents == result:
-                return False
-        self._output_path.write_text(result, encoding="utf-8")
-        return False

frida/frida_bindgen/customization.py

@@ -1,924 +0,0 @@
-from __future__ import annotations
-
-from pathlib import Path
-from typing import List, Mapping
-
-from .model import (ConstructorCustomizations, CustomCode, CustomDeclaration,
-                    Customizations, CustomMethod, CustomType, CustomTypeKind,
-                    EnumerationCustomizations, EnumerationMemberCustomizations,
-                    KeepAliveCustomization, MethodCustomizations,
-                    ObjectTypeCustomizations, PropertyCustomizations,
-                    SignalCustomizations, TypeCustomizations)
-
-ASSETS_DIR = Path(__file__).resolve().parent / "assets"
-CUSTOMIZATION_FACADE_EXPORTS = (
-    (ASSETS_DIR / "customization_facade.exports")
-    .read_text(encoding="utf-8")
-    .strip()
-    .split("\n")
-)
-CUSTOMIZATION_FACADE_TS = (ASSETS_DIR / "customization_facade.ts").read_text(
-    encoding="utf-8"
-)
-CUSTOMIZATION_HELPERS_IMPORTS = (
-    (ASSETS_DIR / "customization_helpers.imports")
-    .read_text(encoding="utf-8")
-    .strip()
-    .split("\n")
-)
-CUSTOMIZATION_HELPERS_TS = (ASSETS_DIR / "customization_helpers.ts").read_text(
-    encoding="utf-8"
-)
-
-
-def load_customizations() -> Customizations:
-    custom_types: List[CustomType] = {
-        "TargetProcess": CustomType(CustomTypeKind.TYPE, "ProcessID | ProcessName"),
-        "ProcessID": CustomType(CustomTypeKind.TYPE, "number"),
-        "InjecteeID": CustomType(CustomTypeKind.TYPE, "number"),
-        "FileDescriptor": CustomType(CustomTypeKind.TYPE, "number"),
-        "ProcessName": CustomType(CustomTypeKind.TYPE, "string"),
-        "SystemParameters": CustomType(
-            CustomTypeKind.INTERFACE,
-            """
-/**
- * Operating System details.
- */
-os: {
-    /**
-     * ID, e.g.: windows, macos, linux, ios, android, qnx, fedora, ubuntu, etc.
-     */
-    id: string;
-
-    /**
-     * Human-readable name, e.g. `"macOS"`.
-     */
-    name: string;
-
-    /**
-     * Human-readable version string, e.g. `"11.2.2"`.
-     */
-    version?: string;
-
-    /**
-     * Build version, e.g. `"21B91"`.
-     */
-    build?: string;
-}
-
-/**
- * Platform, same as `Process.platform` in GumJS.
- */
-platform: "windows" | "darwin" | "linux" | "freebsd" | "qnx";
-
-/**
- * Architecture, same as `Process.arch` in GumJS.
- */
-arch: "ia32" | "x64" | "arm" | "arm64" | "mips";
-
-/**
- * Hardware details.
- */
-hardware?: {
-    /**
-     * Product type, e.g. `"iPad6,3"`.
-     */
-    product?: string;
-
-    /**
-     * Hardware platform, e.g. `"t8010"`.
-     */
-    platform?: string;
-
-    /**
-     * Hardware model, e.g. `"J71bAP"`.
-     */
-    model?: string;
-}
-
-/**
- * Level of access.
- */
-access: "full" | "jailed";
-
-/**
- * System name, e.g. `"Ole André’s iPhone"`.
- */
-name?: string;
-
-/**
- * iOS UDID (Unique Device ID).
- */
-udid?: string;
-
-/**
- * Details about cellular and networking interfaces.
- */
-interfaces?: SystemInterface[];
-
-/**
- * Android API level, e.g.: `30`.
- */
-apiLevel?: number;
-
-[name: string]: any;
-            """,
-        ),
-        "SystemInterface": CustomType(
-            CustomTypeKind.TYPE, "NetworkInterface | CellularInterface"
-        ),
-        "NetworkInterface": CustomType(
-            CustomTypeKind.INTERFACE,
-            """
-type: "ethernet" | "wifi" | "bluetooth";
-
-/**
- * MAC address, e.g.: `"aa:bb:cc:dd:ee:ff"`.
- */
-address: string;
-            """,
-        ),
-        "CellularInterface": CustomType(
-            CustomTypeKind.INTERFACE,
-            """
-type: "cellular";
-
-/**
- * Phone number, e.g. `"+47 123 45 678"`.
- */
-phoneNumber: string;
-            """,
-        ),
-        "SpawnOptions": CustomType(
-            CustomTypeKind.INTERFACE,
-            """
-argv?: string[];
-envp?: { [name: string]: string };
-env?: { [name: string]: string };
-cwd?: string;
-stdio?: Stdio;
-
-[name: string]: any;
-            """,
-        ),
-        "RelayProperties": CustomType(
-            CustomTypeKind.INTERFACE,
-            """
-address: string;
-username: string;
-password: string;
-kind: RelayKind;
-            """,
-        ),
-        "Message": CustomType(CustomTypeKind.TYPE, "SendMessage | ErrorMessage"),
-        "MessageType": CustomType(
-            CustomTypeKind.ENUM,
-            """
-Send = "send",
-Error = "error"
-            """,
-        ),
-        "SendMessage": CustomType(
-            CustomTypeKind.INTERFACE,
-            """
-type: MessageType.Send;
-payload: any;
-            """,
-        ),
-        "ErrorMessage": CustomType(
-            CustomTypeKind.INTERFACE,
-            """
-type: MessageType.Error;
-description: string;
-stack?: string;
-fileName?: string;
-lineNumber?: number;
-columnNumber?: number;
-            """,
-        ),
-        "ScriptLogHandler": CustomType(
-            CustomTypeKind.TYPE, "(level: LogLevel, text: string) => void"
-        ),
-        "ScriptExports": CustomType(
-            CustomTypeKind.INTERFACE,
-            """
-[name: string]: (...args: any[]) => Promise<any>;
-            """,
-        ),
-        "LogLevel": CustomType(
-            CustomTypeKind.ENUM,
-            """
-Info = "info",
-Warning = "warning",
-Error = "error",
-            """,
-        ),
-        "EnableDebuggerOptions": CustomType(
-            CustomTypeKind.INTERFACE,
-            """
-port?: number;
-            """,
-        ),
-        "PortalServiceOptions": CustomType(
-            CustomTypeKind.INTERFACE,
-            """
-clusterParams?: EndpointParameters;
-controlParams?: EndpointParameters;
-            """,
-        ),
-        "PortalConnectionId": CustomType(CustomTypeKind.TYPE, "number"),
-        "PortalConnectionTag": CustomType(CustomTypeKind.TYPE, "string"),
-        "EndpointParametersSubset": CustomType(
-            CustomTypeKind.INTERFACE,
-            """
-address?: string;
-port?: number;
-certificate?: string;
-origin?: string;
-authentication?: AuthenticationScheme;
-assetRoot?: string;
-            """,
-        ),
-        "AuthenticationScheme": CustomType(
-            CustomTypeKind.TYPE,
-            "TokenAuthenticationScheme | CallbackAuthenticationScheme",
-        ),
-        "TokenAuthenticationScheme": CustomType(
-            CustomTypeKind.INTERFACE,
-            """
-scheme: "token";
-token: string;
-            """,
-        ),
-        "CallbackAuthenticationScheme": CustomType(
-            CustomTypeKind.INTERFACE,
-            """
-scheme: "callback";
-callback: AuthenticationCallback;
-            """,
-        ),
-        "AuthenticationCallback": CustomType(
-            CustomTypeKind.TYPE,
-            "(token: string) => Promise<AuthenticatedSessionInfo>",
-        ),
-        "AuthenticatedSessionInfo": CustomType(
-            CustomTypeKind.INTERFACE,
-            """
-[key: string]: any;
-            """,
-        ),
-        "SocketAddress": CustomType(
-            CustomTypeKind.TYPE,
-            "IPV4SocketAddress | IPV6SocketAddress | AnonymousUnixSocketAddress | PathUnixSocketAddress | AbstractUnixSocketAddress",
-        ),
-        "IPV4SocketAddress": CustomType(
-            CustomTypeKind.INTERFACE,
-            """
-family: "ipv4";
-address: string;
-port: number;
-            """,
-        ),
-        "IPV6SocketAddress": CustomType(
-            CustomTypeKind.INTERFACE,
-            """
-family: "ipv6";
-address: string;
-port: number;
-flowlabel: number;
-scopeid: number;
-            """,
-        ),
-        "AnonymousUnixSocketAddress": CustomType(
-            CustomTypeKind.INTERFACE,
-            """
-family: "unix:anonymous";
-            """,
-        ),
-        "PathUnixSocketAddress": CustomType(
-            CustomTypeKind.INTERFACE,
-            """
-family: "unix:path";
-path: string;
-            """,
-        ),
-        "AbstractUnixSocketAddress": CustomType(
-            CustomTypeKind.INTERFACE,
-            """
-family: "unix:abstract";
-path: Buffer;
-            """,
-        ),
-        "Variant": CustomType(
-            CustomTypeKind.TYPE, "VariantValue | [type: symbol, value: VariantValue]"
-        ),
-        "VariantValue": CustomType(
-            CustomTypeKind.TYPE,
-            """
-| boolean
-| number
-| string
-| Buffer
-| Variant[]
-| VariantDict
-            """,
-        ),
-        "VariantDict": CustomType(
-            CustomTypeKind.INTERFACE,
-            """
-[key: string]: Variant;
-            """,
-        ),
-    }
-
-    type_customizations: Mapping[str, TypeCustomizations] = {
-        "DeviceManager": ObjectTypeCustomizations(
-            signals={
-                "added": SignalCustomizations(behavior="FDN_SIGNAL_KEEP_ALIVE"),
-                "removed": SignalCustomizations(behavior="FDN_SIGNAL_KEEP_ALIVE"),
-                "changed": SignalCustomizations(behavior="FDN_SIGNAL_KEEP_ALIVE"),
-            },
-            cleanup="close",
-        ),
-        "Device": ObjectTypeCustomizations(
-            methods={
-                "query_system_parameters": MethodCustomizations(
-                    return_typing="Promise<SystemParameters>",
-                    return_wrapper="as SystemParameters",
-                ),
-                "spawn": MethodCustomizations(
-                    param_typings=[
-                        "programOrArgv: string | string[]",
-                        "opts?: SpawnOptions",
-                        "cancellable?: Cancellable | null",
-                    ],
-                    return_typing="Promise<ProcessID>",
-                    custom_logic="""
-const options: RawSpawnOptions = {};
-
-let program: string;
-let argv;
-if (typeof programOrArgv === "string") {
-    program = programOrArgv;
-    argv = opts?.argv;
-} else {
-    program = programOrArgv[0];
-    argv = programOrArgv;
-    if (argv.length === 1) {
-        argv = undefined;
-    }
-}
-if (argv !== undefined) {
-    options.argv = argv;
-}
-
-if (opts !== undefined) {
-    const envp = opts.envp;
-    if (envp !== undefined) {
-        options.envp = objectToStrv(envp);
-    }
-
-    const env = opts.env;
-    if (env !== undefined) {
-        options.env = objectToStrv(env);
-    }
-
-    const cwd = opts.cwd;
-    if (cwd !== undefined) {
-        options.cwd = cwd;
-    }
-
-    options.aux = Object.fromEntries(Object.entries(opts).filter(([k, v]) => !STANDARD_SPAWN_OPTION_NAMES.has(k)));
-}
-                    """,
-                ),
-                "input": MethodCustomizations(
-                    param_typings=[
-                        "target: TargetProcess",
-                        "data: Buffer",
-                        "cancellable?: Cancellable | null",
-                    ],
-                    custom_logic="const pid = await this.#getPid(target, cancellable);",
-                ),
-                "resume": MethodCustomizations(
-                    param_typings=[
-                        "target: TargetProcess",
-                        "cancellable?: Cancellable | null",
-                    ],
-                    custom_logic="const pid = await this.#getPid(target, cancellable);",
-                ),
-                "kill": MethodCustomizations(
-                    param_typings=[
-                        "target: TargetProcess",
-                        "cancellable?: Cancellable | null",
-                    ],
-                    custom_logic="const pid = await this.#getPid(target, cancellable);",
-                ),
-                "attach": MethodCustomizations(
-                    param_typings=[
-                        "target: TargetProcess",
-                        "options?: SessionOptions",
-                        "cancellable?: Cancellable | null",
-                    ],
-                    custom_logic="const pid = await this.#getPid(target, cancellable);",
-                ),
-                "inject_library_file": MethodCustomizations(
-                    param_typings=[
-                        "target: TargetProcess",
-                        "path: string",
-                        "entrypoint: string",
-                        "data: string",
-                        "cancellable?: Cancellable | null",
-                    ],
-                    return_typing="Promise<InjecteeID>",
-                    custom_logic="const pid = await this.#getPid(target, cancellable);",
-                ),
-                "inject_library_blob": MethodCustomizations(
-                    param_typings=[
-                        "target: TargetProcess",
-                        "blob: Buffer",
-                        "entrypoint: string",
-                        "data: string",
-                        "cancellable?: Cancellable | null",
-                    ],
-                    return_typing="Promise<InjecteeID>",
-                    custom_logic="const pid = await this.#getPid(target, cancellable);",
-                ),
-                "open_channel": MethodCustomizations(
-                    return_typing='Promise<import("stream").Duplex>',
-                    return_wrapper="new IOStreamAdapter",
-                ),
-            },
-            properties={
-                "dtype": PropertyCustomizations(
-                    js_name="type",
-                ),
-            },
-            signals={
-                "spawn-added": SignalCustomizations(behavior="FDN_SIGNAL_KEEP_ALIVE"),
-                "spawn-removed": SignalCustomizations(behavior="FDN_SIGNAL_KEEP_ALIVE"),
-                "child-added": SignalCustomizations(behavior="FDN_SIGNAL_KEEP_ALIVE"),
-                "child-removed": SignalCustomizations(behavior="FDN_SIGNAL_KEEP_ALIVE"),
-                "process-crashed": SignalCustomizations(
-                    behavior="FDN_SIGNAL_KEEP_ALIVE"
-                ),
-                "output": SignalCustomizations(
-                    behavior="FDN_SIGNAL_KEEP_ALIVE",
-                    transform={
-                        0: ("pid: ProcessID", None),
-                        1: ("fd: FileDescriptor", None),
-                    },
-                ),
-                "uninjected": SignalCustomizations(
-                    behavior="FDN_SIGNAL_KEEP_ALIVE",
-                    transform={
-                        0: ("id: InjecteeID", None),
-                    },
-                ),
-            },
-            custom_code=CustomCode(
-                methods=[
-                    CustomMethod(
-                        typing="getProcess(name: string, options?: ProcessMatchOptions, cancellable?: Cancellable | null): Promise<Process>",
-                        code="""
-async getProcess(name: string, options: ProcessMatchOptions = {}, cancellable?: Cancellable | null): Promise<Process> {
-    const {
-        scope = Scope.Minimal,
-    } = options;
-    const processes = await this.enumerateProcesses({ scope }, cancellable);
-    const mm = new Minimatch(name.toLowerCase());
-    const matching = processes.filter(process => mm.match(process.name.toLowerCase()));
-    if (matching.length === 1) {
-        return matching[0];
-    } else if (matching.length > 1) {
-        throw new Error("Ambiguous name; it matches: " + matching.map(process => `${process.name} (pid: ${process.pid})`).join(", "));
-    } else {
-        throw new Error("Process not found");
-    }
-}
-""",
-                    ),
-                    CustomMethod(
-                        typing=None,
-                        code="""
-async #getPid(target: TargetProcess, cancellable?: Cancellable | null): Promise<ProcessID> {
-    if (typeof target === "number") {
-        return target;
-    }
-
-    const process = await this.getProcess(target, {}, cancellable);
-    return process.pid;
-}
-""",
-                    ),
-                ],
-            ),
-        ),
-        "SpawnOptions": ObjectTypeCustomizations(js_name="RawSpawnOptions"),
-        "Bus": ObjectTypeCustomizations(
-            methods={
-                "post": MethodCustomizations(
-                    param_typings=[
-                        "message: any",
-                        "data?: Buffer | null",
-                    ],
-                    custom_logic="const json = JSON.stringify(message);",
-                ),
-            },
-            signals={
-                "detached": SignalCustomizations(behavior="FDN_SIGNAL_KEEP_ALIVE"),
-                "message": SignalCustomizations(
-                    behavior="FDN_SIGNAL_KEEP_ALIVE",
-                    transform={
-                        0: ("message: any", "JSON.parse"),
-                    },
-                ),
-            },
-        ),
-        "Service": ObjectTypeCustomizations(
-            keep_alive=KeepAliveCustomization(
-                is_destroyed_function="is_closed", destroy_signal_name="close"
-            ),
-        ),
-        "Relay": ObjectTypeCustomizations(
-            constructor=ConstructorCustomizations(
-                param_typings=[
-                    "properties: RelayProperties",
-                ],
-                custom_logic="const { address, username, password, kind } = properties;",
-            ),
-        ),
-        "RelayKind": EnumerationCustomizations(
-            members={
-                "turn_udp": EnumerationMemberCustomizations(js_name="TurnUDP"),
-                "turn_tcp": EnumerationMemberCustomizations(js_name="TurnTCP"),
-                "turn_tls": EnumerationMemberCustomizations(js_name="TurnTLS"),
-            },
-        ),
-        "Script": ObjectTypeCustomizations(
-            methods={
-                "is_destroyed": MethodCustomizations(hide=True),
-                "post": MethodCustomizations(
-                    param_typings=[
-                        "message: any",
-                        "data?: Buffer | null",
-                    ],
-                    custom_logic="const json = JSON.stringify(message);",
-                ),
-                "enable_debugger": MethodCustomizations(
-                    param_typings=[
-                        "options?: EnableDebuggerOptions",
-                        "cancellable?: Cancellable | null",
-                    ],
-                    custom_logic="const port = options?.port ?? 0;",
-                ),
-            },
-            signals={
-                "message": SignalCustomizations(
-                    transform={
-                        0: ("message: Message", "JSON.parse"),
-                    },
-                    intercept="this.#services.handleMessageIntercept",
-                ),
-            },
-            custom_code=CustomCode(
-                declarations=[
-                    CustomDeclaration(
-                        typing=None, code="#services = new ScriptServices(this);"
-                    ),
-                    CustomDeclaration(
-                        typing="logHandler: ScriptLogHandler",
-                        code="logHandler: ScriptLogHandler = log;",
-                    ),
-                ],
-                methods=[
-                    CustomMethod(
-                        typing="readonly isDestroyed: boolean",
-                        code="""
-get isDestroyed(): boolean {
-    return this._isDestroyed();
-}
-""",
-                    ),
-                    CustomMethod(
-                        typing="readonly exports: ScriptExports",
-                        code="""
-get exports(): ScriptExports {
-    return this.#services.exportsProxy;
-}
-""",
-                    ),
-                    CustomMethod(
-                        typing="readonly defaultLogHandler: ScriptLogHandler",
-                        code="""
-get defaultLogHandler(): ScriptLogHandler {
-    return log;
-}
-""",
-                    ),
-                ],
-            ),
-            keep_alive=KeepAliveCustomization(
-                is_destroyed_function="is_destroyed", destroy_signal_name="destroyed"
-            ),
-        ),
-        "ScriptRuntime": EnumerationCustomizations(
-            members={
-                "qjs": EnumerationMemberCustomizations(js_name="QJS"),
-            },
-        ),
-        "ControlService": ObjectTypeCustomizations(
-            methods={
-                "start": MethodCustomizations(ref_keep_alive=True),
-                "stop": MethodCustomizations(unref_keep_alive=True),
-                "get_endpoint_params": MethodCustomizations(drop=True),
-            },
-            properties={
-                "endpoint-params": PropertyCustomizations(drop=True),
-            },
-        ),
-        "PortalService": ObjectTypeCustomizations(
-            constructor=ConstructorCustomizations(
-                param_typings=[
-                    "options?: PortalServiceOptions",
-                ],
-                custom_logic="""
-const clusterParams = options?.clusterParams ?? new EndpointParameters();
-const controlParams = options?.controlParams ?? null;
-""",
-            ),
-            methods={
-                "start": MethodCustomizations(ref_keep_alive=True),
-                "stop": MethodCustomizations(unref_keep_alive=True),
-                "kick": MethodCustomizations(
-                    param_typings=[
-                        "connectionId: PortalConnectionId",
-                    ],
-                ),
-                "post": MethodCustomizations(
-                    param_typings=[
-                        "connectionId: PortalConnectionId",
-                        "message: any",
-                        "data?: Buffer | null",
-                    ],
-                    custom_logic="const json = JSON.stringify(message);",
-                ),
-                "narrowcast": MethodCustomizations(
-                    param_typings=[
-                        "tag: string",
-                        "message: any",
-                        "data?: Buffer | null",
-                    ],
-                    custom_logic="const json = JSON.stringify(message);",
-                ),
-                "broadcast": MethodCustomizations(
-                    param_typings=[
-                        "message: any",
-                        "data?: Buffer | null",
-                    ],
-                    custom_logic="const json = JSON.stringify(message);",
-                ),
-                "enumerate_tags": MethodCustomizations(
-                    param_typings=[
-                        "connectionId: PortalConnectionId",
-                    ],
-                ),
-                "tag": MethodCustomizations(
-                    param_typings=[
-                        "connectionId: PortalConnectionId",
-                        "tag: string",
-                    ],
-                ),
-                "untag": MethodCustomizations(
-                    param_typings=[
-                        "connectionId: PortalConnectionId",
-                        "tag: string",
-                    ],
-                ),
-            },
-            signals={
-                "node-connected": SignalCustomizations(
-                    transform={
-                        0: ("connectionId: PortalConnectionId", None),
-                        1: ("remoteAddress: SocketAddress", "parseSocketAddress"),
-                    },
-                ),
-                "node-joined": SignalCustomizations(
-                    transform={
-                        0: ("connectionId: PortalConnectionId", None),
-                    },
-                ),
-                "node-left": SignalCustomizations(
-                    transform={
-                        0: ("connectionId: PortalConnectionId", None),
-                    },
-                ),
-                "node-disconnected": SignalCustomizations(
-                    transform={
-                        0: ("connectionId: PortalConnectionId", None),
-                        1: ("remoteAddress: SocketAddress", "parseSocketAddress"),
-                    },
-                ),
-                "controller-connected": SignalCustomizations(
-                    transform={
-                        0: ("connectionId: PortalConnectionId", None),
-                        1: ("remoteAddress: SocketAddress", "parseSocketAddress"),
-                    },
-                ),
-                "controller-disconnected": SignalCustomizations(
-                    transform={
-                        0: ("connectionId: PortalConnectionId", None),
-                        1: ("remoteAddress: SocketAddress", "parseSocketAddress"),
-                    },
-                ),
-                "authenticated": SignalCustomizations(
-                    transform={
-                        0: ("connectionId: PortalConnectionId", None),
-                        1: ("sessionInfo: AuthenticatedSessionInfo", "JSON.parse"),
-                    },
-                ),
-                "subscribe": SignalCustomizations(
-                    transform={
-                        0: ("connectionId: PortalConnectionId", None),
-                    },
-                ),
-                "message": SignalCustomizations(
-                    transform={
-                        0: ("connectionId: PortalConnectionId", None),
-                        1: ("message: any", "JSON.parse"),
-                    },
-                ),
-            },
-        ),
-        "EndpointParameters": ObjectTypeCustomizations(
-            constructor=ConstructorCustomizations(
-                param_typings=[
-                    "params?: EndpointParametersSubset",
-                ],
-                custom_logic="""
-const address = params?.address ?? null;
-const port = params?.port ?? 0;
-const certificate = params?.certificate ?? null;
-const origin = params?.origin ?? null;
-
-let authService: AuthenticationService | null = null;
-const auth = params?.authentication;
-if (auth !== undefined) {
-    if (auth.scheme === "token") {
-        authService = new StaticAuthenticationService(auth.token);
-    } else {
-        authService = new CallbackAuthenticationService(auth.callback);
-    }
-}
-
-const assetRoot = params?.assetRoot ?? null;
-""",
-            ),
-        ),
-        "Injector": ObjectTypeCustomizations(drop=True),
-        "RpcClient": ObjectTypeCustomizations(drop=True),
-        "RpcPeer": ObjectTypeCustomizations(drop=True),
-        "Cancellable": ObjectTypeCustomizations(
-            methods={
-                "is_cancelled": MethodCustomizations(hide=True),
-                "set_error_if_cancelled": MethodCustomizations(
-                    js_name="throwIfCancelled",
-                    return_typing="void",
-                ),
-                "make_pollfd": MethodCustomizations(drop=True),
-                "release_fd": MethodCustomizations(drop=True),
-                "source_new": MethodCustomizations(drop=True),
-            },
-            custom_code=CustomCode(
-                methods=[
-                    CustomMethod(
-                        typing="readonly isCancelled: boolean",
-                        code="""
-get isCancelled(): boolean {
-    return this._isCancelled();
-}
-""",
-                    ),
-                ],
-            ),
-        ),
-        "IOStream": ObjectTypeCustomizations(
-            methods={
-                "close": MethodCustomizations(drop=True),
-                "close_async": MethodCustomizations(js_name="close"),
-                "splice_async": MethodCustomizations(drop=True),
-                "has_pending": MethodCustomizations(drop=True),
-                "set_pending": MethodCustomizations(drop=True),
-                "clear_pending": MethodCustomizations(drop=True),
-            },
-        ),
-        "InputStream": ObjectTypeCustomizations(
-            methods={
-                "close": MethodCustomizations(drop=True),
-                "close_async": MethodCustomizations(js_name="close"),
-                "read": MethodCustomizations(drop=True),
-                "read_async": MethodCustomizations(drop=True),
-                "read_all": MethodCustomizations(drop=True),
-                "read_all_async": MethodCustomizations(drop=True),
-                "read_bytes": MethodCustomizations(drop=True),
-                "read_bytes_async": MethodCustomizations(js_name="read"),
-                "skip": MethodCustomizations(drop=True),
-                "skip_async": MethodCustomizations(js_name="skip"),
-                "is_closed": MethodCustomizations(drop=True),
-                "has_pending": MethodCustomizations(drop=True),
-                "set_pending": MethodCustomizations(drop=True),
-                "clear_pending": MethodCustomizations(drop=True),
-            },
-        ),
-        "OutputStream": ObjectTypeCustomizations(
-            methods={
-                "close": MethodCustomizations(drop=True),
-                "close_async": MethodCustomizations(js_name="close"),
-                "flush": MethodCustomizations(drop=True),
-                "flush_async": MethodCustomizations(js_name="flush"),
-                "write": MethodCustomizations(drop=True),
-                "write_async": MethodCustomizations(drop=True),
-                "write_all": MethodCustomizations(drop=True),
-                "write_all_async": MethodCustomizations(drop=True),
-                "write_bytes": MethodCustomizations(drop=True),
-                "write_bytes_async": MethodCustomizations(js_name="write"),
-                "writev": MethodCustomizations(drop=True),
-                "writev_async": MethodCustomizations(drop=True),
-                "writev_all": MethodCustomizations(drop=True),
-                "writev_all_async": MethodCustomizations(drop=True),
-                "splice": MethodCustomizations(drop=True),
-                "splice_async": MethodCustomizations(drop=True),
-                "is_closing": MethodCustomizations(drop=True),
-                "is_closed": MethodCustomizations(drop=True),
-                "has_pending": MethodCustomizations(drop=True),
-                "set_pending": MethodCustomizations(drop=True),
-                "clear_pending": MethodCustomizations(drop=True),
-            },
-        ),
-        "UnixSocketAddress": ObjectTypeCustomizations(
-            methods={
-                "get_path": MethodCustomizations(
-                    return_typing="Buffer",
-                    return_cconversion="fdn_buffer_to_value (env, (const guint8 *) retval, g_unix_socket_address_get_path_len (handle))",
-                ),
-                "get_path_len": MethodCustomizations(drop=True),
-                "get_is_abstract": MethodCustomizations(drop=True),
-            },
-            properties={
-                "path": PropertyCustomizations(typing="path: Buffer"),
-                "abstract": PropertyCustomizations(drop=True),
-                "path-as-array": PropertyCustomizations(drop=True),
-            },
-        ),
-        "SocketAddress": ObjectTypeCustomizations(
-            js_name="BaseSocketAddress",
-            constructor=ConstructorCustomizations(drop=True),
-            methods={
-                "to_native": MethodCustomizations(drop=True),
-            },
-        ),
-        "SocketConnectable": ObjectTypeCustomizations(drop_abstract_base=True),
-        "InetAddress": ObjectTypeCustomizations(
-            properties={
-                "bytes": PropertyCustomizations(drop=True),
-            },
-        ),
-        "Object": ObjectTypeCustomizations(
-            js_name="BaseObject",
-            methods={
-                "is_floating": MethodCustomizations(drop=True),
-                "ref": MethodCustomizations(drop=True),
-                "ref_sink": MethodCustomizations(drop=True),
-                "unref": MethodCustomizations(drop=True),
-                "getv": MethodCustomizations(drop=True),
-                "get_property": MethodCustomizations(drop=True),
-                "set_property": MethodCustomizations(drop=True),
-                "notify_by_pspec": MethodCustomizations(drop=True),
-                "freeze_notify": MethodCustomizations(drop=True),
-                "thaw_notify": MethodCustomizations(drop=True),
-                "bind_property": MethodCustomizations(drop=True),
-                "bind_property_full": MethodCustomizations(drop=True),
-                "bind_property_with_closures": MethodCustomizations(drop=True),
-                "force_floating": MethodCustomizations(drop=True),
-                "get_data": MethodCustomizations(drop=True),
-                "get_qdata": MethodCustomizations(drop=True),
-                "run_dispose": MethodCustomizations(drop=True),
-                "set_data": MethodCustomizations(drop=True),
-                "steal_data": MethodCustomizations(drop=True),
-                "steal_qdata": MethodCustomizations(drop=True),
-                "watch_closure": MethodCustomizations(drop=True),
-            },
-            signals={
-                "notify": SignalCustomizations(drop=True),
-            },
-        ),
-    }
-
-    return Customizations(
-        custom_types,
-        type_customizations,
-        CUSTOMIZATION_FACADE_EXPORTS,
-        CUSTOMIZATION_FACADE_TS,
-        CUSTOMIZATION_HELPERS_IMPORTS,
-        CUSTOMIZATION_HELPERS_TS,
-    )

frida/frida_bindgen/loader.py

@@ -1,61 +0,0 @@
-from __future__ import annotations
-
-from collections import OrderedDict
-from pathlib import Path
-
-from .model import Customizations, Model, parse_gir
-
-INCLUDED_GIO_OBJECT_TYPES = [
-    "Cancellable",
-    "IOStream",
-    "InputStream",
-    "OutputStream",
-    "SocketAddress",
-    "SocketAddressEnumerator",
-    "SocketConnectable",
-    "InetSocketAddress",
-    "InetAddress",
-    "UnixSocketAddress",
-]
-INCLUDED_GIO_ENUMERATIONS = [
-    "FileMonitorEvent",
-    "SocketFamily",
-    "UnixSocketAddressType",
-]
-
-
-def compute_model(
-    frida_gir: Path,
-    glib_gir: Path,
-    gobject_gir: Path,
-    gio_gir: Path,
-    customizations: Customizations,
-) -> Model:
-    glib = parse_gir(glib_gir, [])
-    gobject = parse_gir(gobject_gir, [glib])
-    gio = parse_gir(gio_gir, [glib, gobject])
-    frida = parse_gir(frida_gir, [glib, gobject, gio])
-
-    object_types = OrderedDict()
-    object_types["Object"] = gobject.object_types["Object"]
-    object_types.update(frida.object_types)
-    for t in INCLUDED_GIO_OBJECT_TYPES:
-        object_types[t] = gio.object_types[t]
-
-    enumerations = OrderedDict(frida.enumerations)
-    for t in INCLUDED_GIO_ENUMERATIONS:
-        enumerations[t] = gio.enumerations[t]
-
-    model = Model(
-        frida.namespace,
-        object_types,
-        enumerations,
-        customizations,
-    )
-
-    for t in object_types.values():
-        t.model = model
-    for t in enumerations.values():
-        t.model = model
-
-    return model

frida/meson.build

@@ -1,95 +1,8 @@
-if frida_core_dep.type_name() == 'internal'
-  frida_core_subprj = subproject('frida-core')
-  frida_gir = frida_core_subprj.get_variable('core_public_gir')
-  glib_gir = frida_core_subprj.get_variable('glib_gir')
-  gobject_gir = frida_core_subprj.get_variable('gobject_gir')
-  gio_gir = frida_core_subprj.get_variable('gio_gir')
-else
-  girdir = frida_core_dep.get_variable('frida_girdir')
-  frida_gir = girdir / 'Frida-1.0.gir'
-  glib_gir = girdir / 'GLib-2.0.gir'
-  gobject_gir = girdir / 'GObject-2.0.gir'
-  gio_gir = girdir / 'Gio-2.0.gir'
-endif
-
-env = environment()
-env.set('PYTHONPATH', meson.current_source_dir())
-
-code = custom_target('binding-code',
-  output: [
-    '__init__.py',
-    '__init__.pyi',
-    'extension.c',
-  ],
-  input: [
-    frida_gir,
-    glib_gir,
-    gobject_gir,
-    gio_gir,
-    files(
-      'frida_bindgen' / '__init__.py',
-      'frida_bindgen' / '__main__.py',
-      'frida_bindgen' / 'cli.py',
-      'frida_bindgen' / 'codegen.py',
-      'frida_bindgen' / 'customization.py',
-      'frida_bindgen' / 'loader.py',
-      'frida_bindgen' / 'model.py',
-      'frida_bindgen' / 'assets' / 'codegen_gobject_globals.c',
-      'frida_bindgen' / 'assets' / 'codegen_gobject_methods.c',
-      'frida_bindgen' / 'assets' / 'codegen_gobject_prototypes.h',
-      'frida_bindgen' / 'assets' / 'codegen_helpers.c',
-      'frida_bindgen' / 'assets' / 'codegen_helpers.ts',
-      'frida_bindgen' / 'assets' / 'codegen_macros.h',
-      'frida_bindgen' / 'assets' / 'codegen_prototypes.h',
-      'frida_bindgen' / 'assets' / 'codegen_structs.h',
-      'frida_bindgen' / 'assets' / 'codegen_typedefs.h',
-      'frida_bindgen' / 'assets' / 'customization_facade.exports',
-      'frida_bindgen' / 'assets' / 'customization_facade.ts',
-      'frida_bindgen' / 'assets' / 'customization_helpers.imports',
-      'frida_bindgen' / 'assets' / 'customization_helpers.ts',
-    )
-  ],
-  command: [
-    python, '-m', 'frida_bindgen',
-    '--frida-gir=@INPUT0@',
-    '--glib-gir=@INPUT1@',
-    '--gobject-gir=@INPUT2@',
-    '--gio-gir=@INPUT3@',
-    '--output-py=@OUTPUT0@',
-    '--output-pyi=@OUTPUT1@',
-    '--output-c=@OUTPUT2@',
-  ],
-  env: env,
-  install: true,
-  install_dir: [
-    python.get_install_dir() / 'frida',
-    python.get_install_dir() / 'frida' / '_frida',
-    false,
-  ]
-)
+subdir('_frida')
 
 py_sources = [
+  '__init__.py',
+  'core.py',
   'py.typed',
 ]
 python.install_sources(py_sources, subdir: 'frida', pure: false)
-
-extension_py_sources = [
-  'py.typed',
-]
-python.install_sources(extension_py_sources, subdir: 'frida' / '_frida', pure: false)
-
-extra_link_args = []
-if host_os_family == 'darwin'
-  extra_link_args += '-Wl,-exported_symbol,_PyInit__frida'
-elif host_os_family != 'windows'
-  extra_link_args += '-Wl,--version-script,' + meson.current_source_dir() / 'extension.version'
-endif
-
-extension = python.extension_module('_frida', code[2],
-  limited_api: '3.7',
-  c_args: frida_component_cflags,
-  link_args: extra_link_args,
-  dependencies: [python_dep, frida_core_dep, os_deps],
-  install: true,
-  subdir: 'frida',
-)

meson.build

@@ -32,9 +32,9 @@ endif
 
 subdir('frida')
 
-#test('frida-python', python,
-#  args: ['-m', 'unittest', 'discover'],
-#  workdir: meson.current_source_dir(),
-#  env: {'PYTHONPATH': meson.current_build_dir() / 'src'},
-#  timeout: 30,
-#)
+test('frida-python', python,
+  args: ['-m', 'unittest', 'discover'],
+  workdir: meson.current_source_dir(),
+  env: {'PYTHONPATH': meson.current_build_dir() / 'src'},
+  timeout: 30,
+)

subprojects/frida-core.wrap

@@ -1,6 +1,6 @@
 [wrap-git]
 url = https://github.com/frida/frida-core.git
-revision = 17.6.0
+revision = 17.9.3
 depth = 1
 
 [provide]