frida 16.2.5 → 16.3.0

package/dist/device.d.ts

@@ -8,6 +8,7 @@ import { Crash } from "./crash";
 import { Icon } from "./icon";
 import { IOStream } from "./iostream";
 import { Process } from "./process";
+import { Service } from "./service";
 import { Session } from "./session";
 import { Signal } from "./signals";
 import { Spawn } from "./spawn";
@@ -47,6 +48,7 @@ export declare class Device {
     injectLibraryFile(target: TargetProcess, path: string, entrypoint: string, data: string, cancellable?: Cancellable): Promise<InjecteeID>;
     injectLibraryBlob(target: TargetProcess, blob: Buffer, entrypoint: string, data: string, cancellable?: Cancellable): Promise<InjecteeID>;
     openChannel(address: string, cancellable?: Cancellable): Promise<IOStream>;
+    openService(address: string, cancellable?: Cancellable): Promise<Service>;
     unpair(cancellable?: Cancellable): Promise<void>;
     private getPid;
     [inspect.custom](depth: any, options: any): string;

package/dist/device.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Realm = exports.Stdio = exports.Scope = exports.DeviceType = exports.Device = void 0;
 const bus_1 = require("./bus");
 const iostream_1 = require("./iostream");
+const service_1 = require("./service");
 const session_1 = require("./session");
 const signals_1 = require("./signals");
 const minimatch_1 = require("minimatch");
@@ -131,6 +132,9 @@ class Device {
     async openChannel(address, cancellable) {
         return new iostream_1.IOStream(await this.impl.openChannel(address, cancellable));
     }
+    async openService(address, cancellable) {
+        return new service_1.Service(await this.impl.openService(address, cancellable));
+    }
     async unpair(cancellable) {
         await this.impl.unpair(cancellable);
     }

package/dist/index.d.ts

@@ -15,6 +15,7 @@ import * as portalServiceModule from "./portal_service";
 import * as processModule from "./process";
 import * as relayModule from "./relay";
 import * as scriptModule from "./script";
+import * as serviceModule from "./service";
 import * as sessionModule from "./session";
 import * as socketAddressModule from "./socket_address";
 import * as spawnModule from "./spawn";
@@ -132,6 +133,10 @@ export type Bus = busModule.Bus;
 export declare const Bus: typeof busModule.Bus;
 export type BusDetachedHandler = busModule.BusDetachedHandler;
 export type BusMessageHandler = busModule.BusMessageHandler;
+export type Service = serviceModule.Service;
+export declare const Service: typeof serviceModule.Service;
+export type ServiceCloseHandler = serviceModule.ServiceCloseHandler;
+export type ServiceMessageHandler = serviceModule.ServiceMessageHandler;
 export type SocketAddress = socketAddressModule.SocketAddress;
 export type IPV4SocketAddress = socketAddressModule.IPV4SocketAddress;
 export type IPV6SocketAddress = socketAddressModule.IPV6SocketAddress;

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDevice = exports.getUsbDevice = exports.getRemoteDevice = exports.getLocalDevice = exports.getDeviceManager = exports.enumerateDevices = exports.injectLibraryBlob = exports.injectLibraryFile = exports.attach = exports.kill = exports.resume = exports.spawn = exports.querySystemParameters = exports.Bus = exports.ChildOrigin = exports.Cancellable = exports.IOStream = exports.EndpointParameters = exports.PortalService = exports.PortalMembership = exports.RelayKind = exports.Relay = exports.LogLevel = exports.MessageType = exports.ScriptRuntime = exports.Script = exports.SessionDetachReason = exports.Session = exports.Realm = exports.Stdio = exports.Scope = exports.DeviceType = exports.Device = exports.DeviceManager = void 0;
+exports.getDevice = exports.getUsbDevice = exports.getRemoteDevice = exports.getLocalDevice = exports.getDeviceManager = exports.enumerateDevices = exports.injectLibraryBlob = exports.injectLibraryFile = exports.attach = exports.kill = exports.resume = exports.spawn = exports.querySystemParameters = exports.Service = exports.Bus = exports.ChildOrigin = exports.Cancellable = exports.IOStream = exports.EndpointParameters = exports.PortalService = exports.PortalMembership = exports.RelayKind = exports.Relay = exports.LogLevel = exports.MessageType = exports.ScriptRuntime = exports.Script = exports.SessionDetachReason = exports.Session = exports.Realm = exports.Stdio = exports.Scope = exports.DeviceType = exports.Device = exports.DeviceManager = void 0;
 const busModule = require("./bus");
 const cancellableModule = require("./cancellable");
 const childModule = require("./child");
@@ -12,6 +12,7 @@ const portalMembershipModule = require("./portal_membership");
 const portalServiceModule = require("./portal_service");
 const relayModule = require("./relay");
 const scriptModule = require("./script");
+const serviceModule = require("./service");
 const sessionModule = require("./session");
 exports.DeviceManager = deviceManagerModule.DeviceManager;
 exports.Device = deviceModule.Device;
@@ -34,6 +35,7 @@ exports.IOStream = iostreamModule.IOStream;
 exports.Cancellable = cancellableModule.Cancellable;
 exports.ChildOrigin = childModule.ChildOrigin;
 exports.Bus = busModule.Bus;
+exports.Service = serviceModule.Service;
 let sharedDeviceManager = null;
 async function querySystemParameters(cancellable) {
     const device = await getLocalDevice(cancellable);

package/dist/script.js

@@ -105,7 +105,7 @@ class ScriptServices extends signals_1.SignalAdapter {
         }
         return null;
     }
-    request(operation, params, cancellable) {
+    request(operation, params, data, cancellable) {
         return new Promise((resolve, reject) => {
             const id = this.nextRequestId++;
             const complete = (error, result) => {
@@ -128,7 +128,7 @@ class ScriptServices extends signals_1.SignalAdapter {
                 complete(new Error("Operation was cancelled"));
             }
             this.pendingRequests[id] = complete;
-            this.script.post(["frida:rpc", id, operation].concat(params));
+            this.script.post(["frida:rpc", id, operation, ...params], data);
             this.signals.connect("destroyed", onScriptDestroyed);
             if (cancellable !== undefined) {
                 cancellable.cancelled.connect(onOperationCancelled);
@@ -151,7 +151,12 @@ class ScriptServices extends signals_1.SignalAdapter {
             let value = null;
             let error = null;
             if (operation === RpcOperation.Ok) {
-                value = (data !== null) ? data : params[0];
+                if (data !== null) {
+                    value = (params.length > 1) ? [params[1], data] : data;
+                }
+                else {
+                    value = params[0];
+                }
             }
             else {
                 const [message, name, stack, rawErr] = params;
@@ -185,7 +190,11 @@ function ScriptExportsProxy(rpcController) {
                 if (args[args.length - 1] instanceof cancellable_1.Cancellable) {
                     cancellable = args.pop();
                 }
-                return rpcController.request("call", [property, args], cancellable);
+                let data = null;
+                if (Buffer.isBuffer(args[args.length - 1])) {
+                    data = args.pop();
+                }
+                return rpcController.request("call", [property, args], data, cancellable);
             };
         },
         set(target, property, value, receiver) {

package/dist/service.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" />
+import { Cancellable } from "./cancellable";
+import { Signal } from "./signals";
+import { inspect } from "util";
+export declare class Service {
+    private impl;
+    close: Signal<ServiceCloseHandler>;
+    message: Signal<ServiceMessageHandler>;
+    constructor(impl: any);
+    activate(cancellable?: Cancellable): Promise<void>;
+    cancel(cancellable?: Cancellable): Promise<void>;
+    request(parameters: any, cancellable?: Cancellable): Promise<any>;
+    [inspect.custom](depth: any, options: any): string;
+}
+export type ServiceCloseHandler = () => void;
+export type ServiceMessageHandler = (message: any) => void;

package/dist/service.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Service = void 0;
+const signals_1 = require("./signals");
+const util_1 = require("util");
+class Service {
+    constructor(impl) {
+        this.impl = impl;
+        const signals = impl.signals;
+        this.close = new signals_1.Signal(signals, "close");
+        this.message = new signals_1.Signal(signals, "message");
+    }
+    activate(cancellable) {
+        return this.impl.activate(cancellable);
+    }
+    cancel(cancellable) {
+        return this.impl.cancel(cancellable);
+    }
+    request(parameters, cancellable) {
+        return this.impl.request(parameters, cancellable);
+    }
+    [util_1.inspect.custom](depth, options) {
+        return "Service {}";
+    }
+}
+exports.Service = Service;

package/lib/device.ts

@@ -6,6 +6,7 @@ import { Crash } from "./crash";
 import { Icon } from "./icon";
 import { IOStream } from "./iostream";
 import { Process } from "./process";
+import { Service } from "./service";
 import { Session } from "./session";
 import { Signal } from "./signals";
 import { Spawn } from "./spawn";
@@ -190,6 +191,10 @@ export class Device {
         return new IOStream(await this.impl.openChannel(address, cancellable));
     }
 
+    async openService(address: string, cancellable?: Cancellable): Promise<Service> {
+        return new Service(await this.impl.openService(address, cancellable));
+    }
+
     async unpair(cancellable?: Cancellable): Promise<void> {
         await this.impl.unpair(cancellable);
     }

package/lib/index.ts

@@ -14,6 +14,7 @@ import * as portalServiceModule from "./portal_service";
 import * as processModule from "./process";
 import * as relayModule from "./relay";
 import * as scriptModule from "./script";
+import * as serviceModule from "./service";
 import * as sessionModule from "./session";
 import * as socketAddressModule from "./socket_address";
 import * as spawnModule from "./spawn";
@@ -143,6 +144,10 @@ export type Bus = busModule.Bus;
 export const Bus = busModule.Bus;
 export type BusDetachedHandler = busModule.BusDetachedHandler;
 export type BusMessageHandler = busModule.BusMessageHandler;
+export type Service = serviceModule.Service;
+export const Service = serviceModule.Service;
+export type ServiceCloseHandler = serviceModule.ServiceCloseHandler;
+export type ServiceMessageHandler = serviceModule.ServiceMessageHandler;
 export type SocketAddress = socketAddressModule.SocketAddress;
 export type IPV4SocketAddress = socketAddressModule.IPV4SocketAddress;
 export type IPV6SocketAddress = socketAddressModule.IPV6SocketAddress;

package/lib/meson.build

@@ -18,6 +18,7 @@ sources = [
   'process.ts',
   'relay.ts',
   'script.ts',
+  'service.ts',
   'session.ts',
   'signals.ts',
   'socket_address.ts',

package/lib/script.ts

@@ -173,7 +173,7 @@ class ScriptServices extends SignalAdapter implements RpcController {
         }
     }
 
-    request(operation: string, params: any[], cancellable?: Cancellable): Promise<any> {
+    request(operation: string, params: any[], data: Buffer | null, cancellable?: Cancellable): Promise<any> {
         return new Promise((resolve, reject) => {
             const id = this.nextRequestId++;
 
@@ -202,7 +202,7 @@ class ScriptServices extends SignalAdapter implements RpcController {
 
             this.pendingRequests[id] = complete;
 
-            this.script.post(["frida:rpc", id, operation].concat(params));
+            this.script.post(["frida:rpc", id, operation, ...params], data);
             this.signals.connect("destroyed", onScriptDestroyed);
             if (cancellable !== undefined) {
                 cancellable.cancelled.connect(onOperationCancelled);
@@ -227,7 +227,11 @@ class ScriptServices extends SignalAdapter implements RpcController {
             let value = null;
             let error = null;
             if (operation === RpcOperation.Ok) {
-                value = (data !== null) ? data : params[0];
+                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);
@@ -265,7 +269,12 @@ function ScriptExportsProxy(rpcController: RpcController): void {
                     cancellable = args.pop();
                 }
 
-                return rpcController.request("call", [property, args], cancellable);
+                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) {
@@ -298,7 +307,7 @@ function inspectProxy() {
 }
 
 interface RpcController {
-    request(operation: string, params: any[], cancellable?: Cancellable): Promise<any>;
+    request(operation: string, params: any[], data: ArrayBuffer | null, cancellable?: Cancellable): Promise<any>;
 }
 
 enum RpcOperation {

package/lib/service.ts

@@ -0,0 +1,34 @@
+import { Cancellable } from "./cancellable";
+import { Signals, Signal } from "./signals";
+
+import { inspect } from "util";
+
+export class Service {
+    close: Signal<ServiceCloseHandler>;
+    message: Signal<ServiceMessageHandler>;
+
+    constructor(private impl: any) {
+        const signals: Signals = impl.signals;
+        this.close = new Signal<ServiceCloseHandler>(signals, "close");
+        this.message = new Signal<ServiceMessageHandler>(signals, "message");
+    }
+
+    activate(cancellable?: Cancellable): Promise<void> {
+        return this.impl.activate(cancellable);
+    }
+
+    cancel(cancellable?: Cancellable): Promise<void> {
+        return this.impl.cancel(cancellable);
+    }
+
+    request(parameters: any, cancellable?: Cancellable): Promise<any> {
+        return this.impl.request(parameters, cancellable);
+    }
+
+    [inspect.custom](depth, options) {
+        return "Service {}";
+    }
+}
+
+export type ServiceCloseHandler = () => void;
+export type ServiceMessageHandler = (message: any) => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "frida",
-  "version": "16.2.5",
+  "version": "16.3.0",
   "authors": [
     "Frida Developers"
   ],

package/releng/deps.toml

@@ -1,6 +1,6 @@
 [dependencies]
-version = "20240514"
-bootstrap_version = "20240502"
+version = "20240601"
+bootstrap_version = "20240531"
 
 [ninja]
 scope = "toolchain"
@@ -176,7 +176,7 @@ dependencies = [
 
 [glib-networking]
 name = "glib-networking"
-version = "8321b417f1d7907ef5b24e62e7f176e42be9cf8e"
+version = "d276694f40cbadb7e19a3d82ceb7305c819fbda8"
 url = "https://github.com/frida/glib-networking.git"
 options = [
     "-Dgnutls=disabled",
@@ -192,7 +192,7 @@ dependencies = [
 
 [libnice]
 name = "libnice"
-version = "a0f43f0ea5755ce0374613b0a157be33a9f7d82e"
+version = "e12567b0a16a0c2eb5dfe5e0782baba8496772ff"
 url = "https://github.com/frida/libnice.git"
 options = [
     "-Dgupnp=disabled",
@@ -208,8 +208,8 @@ dependencies = [
 ]
 
 [lwip]
-name = "lwip"
-version = "f669c58256feff196aeeecc712761ce01a0b2a56"
+name = "lwIP"
+version = "9f64c40cac2e77eddf6b3913961fdd056d307716"
 url = "https://github.com/frida/lwip.git"
 options = [
     "-Dipv4=disabled",
@@ -284,7 +284,7 @@ options = [
 
 [ngtcp2]
 name = "ngtcp2"
-version = "21a9ba1667985ad60e9acafc07af493555deaf53"
+version = "cc5cf523615b7fa7a9340234c7eec3c3645ae969"
 url = "https://github.com/frida/ngtcp2.git"
 dependencies = [
     "openssl",
@@ -355,7 +355,7 @@ url = "https://github.com/frida/tinycc.git"
 
 [openssl]
 name = "OpenSSL"
-version = "95d037b2acc432039da4f506d25b6a01577d8bc5"
+version = "ca4781aaf7910b623d3ae21c6a017e7e9ca6936c"
 url = "https://github.com/frida/openssl.git"
 options = [
     "-Dcli=disabled",

package/src/addon.cc

@@ -14,6 +14,7 @@
 #include "relay.h"
 #include "runtime.h"
 #include "script.h"
+#include "service.h"
 #include "session.h"
 #include "signals.h"
 #include "spawn.h"
@@ -47,6 +48,7 @@ static void InitAll(Local<Object> exports,
   Child::Init(exports, runtime);
   Crash::Init(exports, runtime);
   Bus::Init(exports, runtime);
+  Service::Init(exports, runtime);
   Session::Init(exports, runtime);
   Script::Init(exports, runtime);
   Relay::Init(exports, runtime);

package/src/device.cc

@@ -7,6 +7,7 @@
 #include "iostream.h"
 #include "operation.h"
 #include "process.h"
+#include "service.h"
 #include "session.h"
 #include "signals.h"
 #include "spawn.h"
@@ -81,6 +82,7 @@ void Device::Init(Local<Object> exports, Runtime* runtime) {
   Nan::SetPrototypeMethod(tpl, "injectLibraryFile", InjectLibraryFile);
   Nan::SetPrototypeMethod(tpl, "injectLibraryBlob", InjectLibraryBlob);
   Nan::SetPrototypeMethod(tpl, "openChannel", OpenChannel);
+  Nan::SetPrototypeMethod(tpl, "openService", OpenService);
   Nan::SetPrototypeMethod(tpl, "unpair", Unpair);
 
   auto ctor = Nan::GetFunction(tpl).ToLocalChecked();
@@ -760,20 +762,8 @@ NAN_METHOD(Device::Spawn) {
 
         Nan::Utf8String key_str(key);
 
-        GVariant* raw_value;
-        if (value->IsBoolean()) {
-          raw_value = g_variant_new_boolean(
-              Local<Boolean>::Cast(value)->Value());
-        } else if (value->IsNumber()) {
-          raw_value = g_variant_new_int64(
-              static_cast<gint64>(Local<Number>::Cast(value)->Value()));
-        } else {
-          Nan::Utf8String value_str(value);
-          raw_value = g_variant_new_string(*value_str);
-        }
-
         g_hash_table_insert(aux, g_strdup(*key_str),
-            g_variant_ref_sink(raw_value));
+            g_variant_ref_sink(Runtime::ValueToVariant(value)));
       }
     } else {
       Nan::ThrowTypeError("Bad argument, 'aux' must be an object");
@@ -1230,6 +1220,56 @@ NAN_METHOD(Device::OpenChannel) {
 
 namespace {
 
+class OpenServiceOperation : public Operation<FridaDevice> {
+ public:
+  OpenServiceOperation(gchar* address)
+    : address_(address) {
+  }
+
+  ~OpenServiceOperation() {
+    g_free(address_);
+  }
+
+ protected:
+  void Begin() {
+    frida_device_open_service(handle_, address_, cancellable_, OnReady, this);
+  }
+
+  void End(GAsyncResult* result, GError** error) {
+    service_ = frida_device_open_service_finish(handle_, result, error);
+  }
+
+  Local<Value> Result(Isolate* isolate) {
+    auto wrapper = Service::New(service_, runtime_);
+    g_object_unref(service_);
+    return wrapper;
+  }
+
+ private:
+  gchar* address_;
+  FridaService* service_;
+};
+
+}
+
+NAN_METHOD(Device::OpenService) {
+  auto isolate = info.GetIsolate();
+  auto wrapper = ObjectWrap::Unwrap<Device>(info.Holder());
+
+  if (info.Length() < 1 || !info[0]->IsString()) {
+    Nan::ThrowTypeError("Bad argument");
+    return;
+  }
+  Nan::Utf8String address(info[0]);
+
+  auto operation = new OpenServiceOperation(g_strdup(*address));
+  operation->Schedule(isolate, wrapper, info);
+
+  info.GetReturnValue().Set(operation->GetPromise(isolate));
+}
+
+namespace {
+
 class UnpairOperation : public Operation<FridaDevice> {
  protected:
   void Begin() {

package/src/device.h

@@ -41,6 +41,7 @@ class Device : public GLibObject {
   static NAN_METHOD(InjectLibraryFile);
   static NAN_METHOD(InjectLibraryBlob);
   static NAN_METHOD(OpenChannel);
+  static NAN_METHOD(OpenService);
   static NAN_METHOD(Unpair);
 
   static v8::Local<v8::Value> TransformSignal(const gchar* name, guint index,

package/src/meson.build

@@ -8,6 +8,7 @@ frida_binding_sources = files(
   'child.cc',
   'crash.cc',
   'bus.cc',
+  'service.cc',
   'session.cc',
   'script.cc',
   'relay.cc',

package/src/runtime.cc

@@ -251,66 +251,155 @@ Local<Value> Runtime::ValueFromParametersDict(GHashTable* dict) {
   return result;
 }
 
-Local<Value> Runtime::ValueFromVariant(GVariant* v) {
-  if (g_variant_is_of_type(v, G_VARIANT_TYPE_STRING))
-    return Nan::New<String>(g_variant_get_string(v, NULL)).ToLocalChecked();
+GVariant* Runtime::ValueToVariant(Local<Value> value) {
+  if (value->IsString()) {
+    Nan::Utf8String str(value);
+    return g_variant_new_string(*str);
+  }
+
+  if (value->IsNumber()) {
+    return g_variant_new_int64(
+        static_cast<gint64>(Local<Number>::Cast(value)->Value()));
+  }
+
+  if (value->IsBoolean()) {
+    return g_variant_new_boolean(Local<Boolean>::Cast(value)->Value());
+  }
 
-  if (g_variant_is_of_type(v, G_VARIANT_TYPE_INT64))
-    return Nan::New<Number>(static_cast<double>(g_variant_get_int64(v)));
+  if (node::Buffer::HasInstance(value)) {
+    auto size = node::Buffer::Length(value);
+    auto copy = g_memdup2(node::Buffer::Data(value), size);
+    return g_variant_new_from_data(G_VARIANT_TYPE_BYTESTRING, copy, size, TRUE,
+        g_free, copy);
+  }
 
-  if (g_variant_is_of_type(v, G_VARIANT_TYPE_BOOLEAN))
-    return Nan::New<Boolean>(static_cast<bool>(g_variant_get_boolean(v)));
+  if (value->IsArray()) {
+    GVariantBuilder builder;
+    g_variant_builder_init(&builder, G_VARIANT_TYPE ("av"));
 
-  if (g_variant_is_of_type(v, G_VARIANT_TYPE("ay"))) {
-    gsize size;
-    gconstpointer data = g_variant_get_fixed_array(v, &size, sizeof(guint8));
+    auto array = Local<Array>::Cast(value);
+    uint32_t n = array->Length();
+    for (uint32_t i = 0; i != n; i++) {
+      auto element_value = Nan::Get(array, i).ToLocalChecked();
+      g_variant_builder_add(&builder, "v", ValueToVariant(element_value));
+    }
 
-    return Nan::CopyBuffer(static_cast<const char*>(data), size)
-        .ToLocalChecked();
+    return g_variant_builder_end(&builder);
   }
 
-  if (g_variant_is_of_type(v, G_VARIANT_TYPE_VARDICT)) {
-    auto dict = Nan::New<Object>();
+  if (value->IsObject()) {
+    GVariantBuilder builder;
+    g_variant_builder_init(&builder, G_VARIANT_TYPE_VARDICT);
 
-    GVariantIter iter;
-    gchar* raw_key;
-    GVariant* raw_value;
+    auto isolate = Isolate::GetCurrent();
+    auto context = isolate->GetCurrentContext();
 
-    g_variant_iter_init(&iter, v);
+    auto object = Local<Object>::Cast(value);
 
-    while (g_variant_iter_next(&iter, "{sv}", &raw_key, &raw_value)) {
-      char* canonicalized_key = ParameterNameFromC(raw_key);
+    Local<Array> names(object->GetOwnPropertyNames(context).ToLocalChecked());
+    uint32_t n = names->Length();
 
-      Local<String> key = Nan::New(canonicalized_key).ToLocalChecked();
-      Local<Value> value = ValueFromVariant(raw_value);
-      Nan::Set(dict, key, value);
+    for (uint32_t i = 0; i != n; i++) {
+      auto key = Nan::Get(names, i).ToLocalChecked();
+      auto val = Nan::Get(object, key).ToLocalChecked();
 
-      g_free(canonicalized_key);
-      g_variant_unref(raw_value);
-      g_free(raw_key);
+      Nan::Utf8String key_str(key);
+      g_variant_builder_add(&builder, "{sv}", *key_str, ValueToVariant(val));
     }
 
-    return dict;
+    return g_variant_builder_end(&builder);
   }
 
-  if (g_variant_is_of_type(v, G_VARIANT_TYPE_ARRAY)) {
-    GVariantIter iter;
-    g_variant_iter_init(&iter, v);
+  Nan::ThrowTypeError("Bad argument, expected value serializable to GVariant");
+  return NULL;
+}
 
-    auto array = Nan::New<Array>(g_variant_iter_n_children(&iter));
+Local<Value> Runtime::ValueFromVariant(GVariant* v) {
+  switch (g_variant_classify(v)) {
+    case G_VARIANT_CLASS_STRING:
+      return Nan::New<String>(g_variant_get_string(v, NULL)).ToLocalChecked();
+    case G_VARIANT_CLASS_INT64:
+      return Nan::New<Number>(static_cast<double>(g_variant_get_int64(v)));
+    case G_VARIANT_CLASS_UINT64:
+      return Nan::New<Number>(static_cast<double>(g_variant_get_uint64(v)));
+    case G_VARIANT_CLASS_DOUBLE:
+      return Nan::New<Number>(static_cast<double>(g_variant_get_double(v)));
+    case G_VARIANT_CLASS_BOOLEAN:
+      return Nan::New<Boolean>(static_cast<bool>(g_variant_get_boolean(v)));
+    case G_VARIANT_CLASS_ARRAY:
+      if (g_variant_is_of_type(v, G_VARIANT_TYPE("ay"))) {
+        return ValueFromVariantByteArray(v);
+      }
 
-    GVariant* child;
-    for (int i = 0; (child = g_variant_iter_next_value(&iter)) != NULL; i++) {
-      Nan::Set(array, i, ValueFromVariant(child));
-      g_variant_unref(child);
-    }
+      if (g_variant_is_of_type(v, G_VARIANT_TYPE_VARDICT)) {
+        return ValueFromVariantDict(v);
+      }
 
-    return array;
+      if (g_variant_is_of_type(v, G_VARIANT_TYPE_ARRAY)) {
+        return ValueFromVariantArray(v);
+      }
+
+      break;
+    case G_VARIANT_CLASS_TUPLE:
+      return Nan::Undefined();
+    default:
+      break;
   }
 
   return Nan::Null();
 }
 
+Local<Value> Runtime::ValueFromVariantByteArray(GVariant* v) {
+  gsize size;
+  gconstpointer data = g_variant_get_fixed_array(v, &size, sizeof(guint8));
+
+  return Nan::CopyBuffer(static_cast<const char*>(data), size).ToLocalChecked();
+}
+
+Local<Value> Runtime::ValueFromVariantDict(GVariant* v) {
+  auto dict = Nan::New<Object>();
+
+  GVariantIter iter;
+  gchar* raw_key;
+  GVariant* raw_value;
+
+  g_variant_iter_init(&iter, v);
+
+  while (g_variant_iter_next(&iter, "{sv}", &raw_key, &raw_value)) {
+    char* canonicalized_key = ParameterNameFromC(raw_key);
+
+    Local<String> key = Nan::New(canonicalized_key).ToLocalChecked();
+    Local<Value> value = ValueFromVariant(raw_value);
+    Nan::Set(dict, key, value);
+
+    g_free(canonicalized_key);
+    g_variant_unref(raw_value);
+    g_free(raw_key);
+  }
+
+  return dict;
+}
+
+Local<Value> Runtime::ValueFromVariantArray(GVariant* v) {
+  GVariantIter iter;
+  g_variant_iter_init(&iter, v);
+
+  auto array = Nan::New<Array>(g_variant_iter_n_children(&iter));
+
+  GVariant* child;
+  for (int i = 0; (child = g_variant_iter_next_value(&iter)) != NULL; i++) {
+    if (g_variant_is_of_type(child, G_VARIANT_TYPE_VARIANT)) {
+      GVariant* inner = g_variant_get_variant(child);
+      g_variant_unref(child);
+      child = inner;
+    }
+    Nan::Set(array, i, ValueFromVariant(child));
+    g_variant_unref(child);
+  }
+
+  return array;
+}
+
 Local<Object> Runtime::ValueFromSocketAddress(GSocketAddress* address) {
   auto result = Nan::New<Object>();
 

package/src/runtime.h

@@ -38,6 +38,7 @@ class Runtime {
 
   static v8::Local<v8::Value> ValueFromParametersDict(GHashTable* dict);
 
+  static GVariant* ValueToVariant(v8::Local<v8::Value> value);
   static v8::Local<v8::Value> ValueFromVariant(GVariant* v);
 
   static v8::Local<v8::Object> ValueFromSocketAddress(GSocketAddress* address);
@@ -49,6 +50,10 @@ class Runtime {
   static char* ParameterNameFromC(const char* cname);
 
  private:
+  static v8::Local<v8::Value> ValueFromVariantByteArray(GVariant* v);
+  static v8::Local<v8::Value> ValueFromVariantDict(GVariant* v);
+  static v8::Local<v8::Value> ValueFromVariantArray(GVariant* v);
+
   UVContext* uv_context_;
   GLibContext* glib_context_;
 

package/src/service.cc

@@ -0,0 +1,224 @@
+#include "service.h"
+
+#include "operation.h"
+#include "signals.h"
+#include "usage_monitor.h"
+
+#include <cstring>
+
+#define SERVICE_DATA_CONSTRUCTOR "service:ctor"
+
+using std::strcmp;
+using v8::External;
+using v8::Function;
+using v8::Isolate;
+using v8::Local;
+using v8::Object;
+using v8::Persistent;
+using v8::Value;
+
+namespace frida {
+
+Service::Service(FridaService* handle, Runtime* runtime)
+    : GLibObject(handle, runtime),
+      usage_monitor_created_(false) {
+  g_object_ref(handle_);
+}
+
+Service::~Service() {
+  g_object_unref(handle_);
+}
+
+void Service::Init(Local<Object> exports, Runtime* runtime) {
+  auto isolate = Isolate::GetCurrent();
+
+  auto name = Nan::New("Service").ToLocalChecked();
+  auto tpl = CreateTemplate(name, New, runtime);
+
+  Nan::SetPrototypeMethod(tpl, "activate", Activate);
+  Nan::SetPrototypeMethod(tpl, "cancel", Cancel);
+  Nan::SetPrototypeMethod(tpl, "request", Request);
+
+  auto ctor = Nan::GetFunction(tpl).ToLocalChecked();
+  Nan::Set(exports, name, ctor);
+  runtime->SetDataPointer(SERVICE_DATA_CONSTRUCTOR,
+      new Persistent<Function>(isolate, ctor));
+}
+
+Local<Object> Service::New(gpointer handle, Runtime* runtime) {
+  auto ctor = Nan::New<Function>(
+      *static_cast<Persistent<Function>*>(
+      runtime->GetDataPointer(SERVICE_DATA_CONSTRUCTOR)));
+  const int argc = 1;
+  Local<Value> argv[argc] = { Nan::New<External>(handle) };
+  return Nan::NewInstance(ctor, argc, argv).ToLocalChecked();
+}
+
+NAN_METHOD(Service::New) {
+  if (!info.IsConstructCall()) {
+    Nan::ThrowError("Use the `new` keyword to create a new instance");
+    return;
+  }
+
+  if (info.Length() != 1 || !info[0]->IsExternal()) {
+    Nan::ThrowTypeError("Bad argument, expected raw handle");
+    return;
+  }
+
+  auto runtime = GetRuntimeFromConstructorArgs(info);
+
+  auto handle = static_cast<FridaService*>(
+      Local<External>::Cast(info[0])->Value());
+  auto wrapper = new Service(handle, runtime);
+  auto obj = info.This();
+  wrapper->Wrap(obj);
+  auto signals_obj = Signals::New(handle, runtime, TransformSignal, runtime);
+
+  Nan::Set(obj, Nan::New("signals").ToLocalChecked(), signals_obj);
+
+  auto signals_wrapper = ObjectWrap::Unwrap<Signals>(signals_obj);
+  signals_wrapper->SetConnectCallback(OnConnect, wrapper);
+
+  info.GetReturnValue().Set(obj);
+}
+
+namespace {
+
+class ActivateOperation : public Operation<FridaService> {
+ protected:
+  void Begin() {
+    frida_service_activate(handle_, cancellable_, OnReady, this);
+  }
+
+  void End(GAsyncResult* result, GError** error) {
+    frida_service_activate_finish(handle_, result, error);
+  }
+
+  Local<Value> Result(Isolate* isolate) {
+    return Nan::Undefined();
+  }
+};
+
+}
+
+NAN_METHOD(Service::Activate) {
+  auto isolate = info.GetIsolate();
+  auto wrapper = ObjectWrap::Unwrap<Service>(info.Holder());
+
+  auto operation = new ActivateOperation();
+  operation->Schedule(isolate, wrapper, info);
+
+  info.GetReturnValue().Set(operation->GetPromise(isolate));
+}
+
+namespace {
+
+class CancelOperation : public Operation<FridaService> {
+ protected:
+  void Begin() {
+    frida_service_cancel(handle_, cancellable_, OnReady, this);
+  }
+
+  void End(GAsyncResult* result, GError** error) {
+    frida_service_cancel_finish(handle_, result, error);
+  }
+
+  Local<Value> Result(Isolate* isolate) {
+    return Nan::Undefined();
+  }
+};
+
+}
+
+NAN_METHOD(Service::Cancel) {
+  auto isolate = info.GetIsolate();
+  auto wrapper = ObjectWrap::Unwrap<Service>(info.Holder());
+
+  auto operation = new CancelOperation();
+  operation->Schedule(isolate, wrapper, info);
+
+  info.GetReturnValue().Set(operation->GetPromise(isolate));
+}
+
+namespace {
+
+class RequestOperation : public Operation<FridaService> {
+ public:
+  RequestOperation(GVariant* parameters)
+    : parameters_(parameters) {
+  }
+
+  ~RequestOperation() {
+    g_variant_unref(parameters_);
+  }
+
+ protected:
+  void Begin() {
+    frida_service_request(handle_, parameters_, cancellable_, OnReady, this);
+  }
+
+  void End(GAsyncResult* result, GError** error) {
+    response_ = frida_service_request_finish(handle_, result, error);
+  }
+
+  Local<Value> Result(Isolate* isolate) {
+    auto wrapper = Runtime::ValueFromVariant(response_);
+    g_variant_unref(response_);
+    return wrapper;
+  }
+
+ private:
+  GVariant* parameters_;
+  GVariant* response_;
+};
+
+}
+
+NAN_METHOD(Service::Request) {
+  auto isolate = info.GetIsolate();
+  auto wrapper = ObjectWrap::Unwrap<Service>(info.Holder());
+
+  if (info.Length() == 0) {
+    Nan::ThrowTypeError("Expected a parameters value");
+    return;
+  }
+
+  auto parameters = Runtime::ValueToVariant(info[0]);
+  if (parameters == NULL) {
+    return;
+  }
+
+  auto operation = new RequestOperation(parameters);
+  operation->Schedule(isolate, wrapper, info);
+
+  info.GetReturnValue().Set(operation->GetPromise(isolate));
+}
+
+Local<Value> Service::TransformSignal(const gchar* name, guint index,
+    const GValue* value, gpointer user_data) {
+  if (index != 0 || strcmp(name, "message") != 0)
+    return Local<Value>();
+  return Runtime::ValueFromVariant(g_value_get_variant(value));
+}
+
+void Service::OnConnect(const gchar* name, gpointer user_data) {
+  auto wrapper = static_cast<Service*>(user_data);
+
+  if (ShouldStayAliveToEmit(name))
+    wrapper->EnsureUsageMonitorCreated();
+}
+
+bool Service::ShouldStayAliveToEmit(const gchar* name) {
+  return strcmp(name, "close") == 0 || strcmp(name, "message") == 0;
+}
+
+void Service::EnsureUsageMonitorCreated() {
+  if (!usage_monitor_created_) {
+    usage_monitor_created_ = true;
+    auto monitor =
+        new UsageMonitor<FridaService>(frida_service_is_closed, "close");
+    monitor->Enable(this);
+  }
+}
+
+}

package/src/service.h

@@ -0,0 +1,36 @@
+#ifndef FRIDANODE_SERVICE_H
+#define FRIDANODE_SERVICE_H
+
+#include "glib_object.h"
+
+#include <frida-core.h>
+
+namespace frida {
+
+class Service : public GLibObject {
+ public:
+  static void Init(v8::Local<v8::Object> exports, Runtime* runtime);
+  static v8::Local<v8::Object> New(gpointer handle, Runtime* runtime);
+
+ private:
+  explicit Service(FridaService* handle, Runtime* runtime);
+  ~Service();
+
+  static NAN_METHOD(New);
+
+  static NAN_METHOD(Activate);
+  static NAN_METHOD(Cancel);
+  static NAN_METHOD(Request);
+
+  static v8::Local<v8::Value> TransformSignal(const gchar* name, guint index,
+      const GValue* value, gpointer user_data);
+  static void OnConnect(const gchar* signal, gpointer user_data);
+  static bool ShouldStayAliveToEmit(const gchar* signal);
+  void EnsureUsageMonitorCreated();
+
+  bool usage_monitor_created_;
+};
+
+}
+
+#endif

package/subprojects/frida-core.wrap

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

package/test/script.ts

@@ -21,22 +21,30 @@ describe("Script", function () {
     });
 
     it("should support rpc", async () => {
-        const script = await session.createScript(
-            "rpc.exports = {" +
-            "add: function (a, b) {" +
-            "var result = a + b;" +
-            "if (result < 0)" +
-            "throw new Error('No');" +
-            "return result;" +
-            "}," +
-            "sub: function (a, b) {" +
-            "return a - b;" +
-            "}," +
-            "speak: function () {" +
-            "var buf = Memory.allocUtf8String('Yo');" +
-            "return Memory.readByteArray(buf, 2);" +
-            "}" +
-            "};");
+        const script = await session.createScript(`
+            rpc.exports = {
+              add(a, b) {
+                const result = a + b;
+                if (result < 0)
+                  throw new Error('no');
+                return result;
+              },
+              sub(a, b) {
+                return a - b;
+              },
+              speak() {
+                const buf = Memory.allocUtf8String('Yo');
+                return Memory.readByteArray(buf, 2);
+              },
+              speakWithMetadata() {
+                const buf = Memory.allocUtf8String('Yo');
+                return ['soft', Memory.readByteArray(buf, 2)];
+              },
+              processData(val, data) {
+                return { val, dump: hexdump(data, { header: false }) };
+              },
+            };
+        `);
         await script.load();
 
         const agent = script.exports;
@@ -51,18 +59,27 @@ describe("Script", function () {
             thrownException = e;
         }
         expect(thrownException).to.not.be.equal(null);
-        expect(thrownException.message).to.equal("No");
+        expect(thrownException.message).to.equal("no");
 
         const buf = await agent.speak();
         expect(buf.toJSON().data).to.deep.equal([0x59, 0x6f]);
+
+        const [meta, data] = await agent.speakWithMetadata();
+        expect(meta).to.equal("soft");
+        expect(data.toJSON().data).to.deep.equal([0x59, 0x6f]);
+
+        const result = await agent.processData(1337, Buffer.from([0x13, 0x37]));
+        expect(result.val).to.equal(1337);
+        expect(result.dump).to.equal("00000000  13 37                                            .7");
     });
 
     it("should fail rpc request if post() fails", async () => {
-        const script = await session.createScript(
-            "rpc.exports = {" +
-            "init: function () {" +
-            "}" +
-            "};");
+        const script = await session.createScript(`
+            rpc.exports = {
+              init() {
+              }
+            };
+        `);
         await script.load();
 
         await session.detach();
@@ -78,12 +95,13 @@ describe("Script", function () {
     });
 
     it("should fail rpc request if script is unloaded mid-request", async () => {
-        const script = await session.createScript(
-            "rpc.exports = {" +
-            "waitForever: function () {" +
-            "return new Promise(function () {});" +
-            "}" +
-            "};");
+        const script = await session.createScript(`
+            rpc.exports = {
+              waitForever() {
+                return new Promise(() => {});
+              }
+            };
+        `);
         await script.load();
 
         setTimeout(() => script.unload(), 100);
@@ -99,12 +117,13 @@ describe("Script", function () {
     });
 
     it("should fail rpc request if session gets detached mid-request", async () => {
-        const script = await session.createScript(
-            "rpc.exports = {" +
-            "waitForever: function () {" +
-            "return new Promise(function () {});" +
-            "}" +
-            "};");
+        const script = await session.createScript(`
+            rpc.exports = {
+              waitForever() {
+                return new Promise(() => {});
+              }
+            };
+        `);
         await script.load();
 
         setTimeout(() => target.stop(), 100);
@@ -122,12 +141,13 @@ describe("Script", function () {
     it("should fail rpc request if cancelled mid-request", async () => {
         const cancellable = new frida.Cancellable();
 
-        const script = await session.createScript(
-            "rpc.exports = {" +
-            "waitForever: function () {" +
-            "return new Promise(function () {});" +
-            "}" +
-            "};", {}, cancellable);
+        const script = await session.createScript(`
+            rpc.exports = {
+              waitForever() {
+                return new Promise(() => {});
+              }
+            };
+        `, {}, cancellable);
         await script.load(cancellable);
 
         setTimeout(() => cancellable.cancel(), 100);
@@ -148,9 +168,10 @@ describe("Script", function () {
 
         async function load(): Promise<frida.ScriptExports> {
             const script = await session.createScript(`
-            rpc.exports.hello = function () {
-                return "Is it me you're looking for?";
-            };`);
+                rpc.exports.hello = function () {
+                  return "Is it me you're looking for?";
+                };`
+            );
             await script.load();
 
             const api = script.exports;