frida 0.1.0 → 0.1.1

data/ext/c_frida/DeviceManager.c

@@ -0,0 +1,260 @@
+#include "DeviceManager.h"
+
+VALUE DeviceManager_from_FridaDeviceManager(FridaDeviceManager *handle)
+{
+    VALUE self;
+
+    if (!handle)
+        return (Qnil);
+    self = rb_class_new_instance(0, NULL, cDeviceManager);
+    GET_GOBJECT_DATA();
+    d->destroy(d->handle);
+    d->handle = handle;
+    return (self);
+}
+
+GVL_FREE_PROXY_FUNC(close_device_manager_err, FridaDeviceManager *device_manager)
+{
+    GError *gerr = NULL;
+
+    frida_device_manager_close_sync(device_manager, NULL, &gerr);
+    RETURN_GVL_FREE_RESULT(NULL);
+}
+
+GVL_FREE_PROXY_FUNC(close_device_manager, FridaDeviceManager *device_manager)
+{
+    frida_device_manager_close_sync(device_manager, NULL, NULL);
+    return (NULL);
+}
+
+static void DeviceManager_destroy(void *handle)
+{
+    CALL_GVL_FREE(close_device_manager, handle);
+    frida_unref(handle);
+}
+
+/*
+    call-seq:
+        #close() -> nil
+*/
+static VALUE DeviceManager_close(VALUE self)
+{
+    GET_GOBJECT_DATA();
+    REQUIRE_GOBJECT_HANDLE();
+    CALL_GVL_FREE_WITH_RET(void *dummy, close_device_manager_err, d->handle);
+    return (Qnil);
+
+    GERROR_BLOCK
+}
+
+GVL_FREE_PROXY_FUNC(enumerate_devices_sync, FridaDeviceManager *device_manager)
+{
+    GError *gerr = NULL;
+    FridaDeviceList * devices;
+
+    devices = frida_device_manager_enumerate_devices_sync(device_manager, NULL, &gerr);
+    RETURN_GVL_FREE_RESULT(devices);
+}
+
+/*
+    call-seq:
+        #enumerate_device() -> Array[Device]
+*/
+static VALUE DeviceManager_enumerate_devices(VALUE self)
+{
+    GET_GOBJECT_DATA();
+    REQUIRE_GOBJECT_HANDLE();
+    FridaDeviceList * devices;
+    int devices_count;
+    VALUE Devices_arr;
+
+    CALL_GVL_FREE_WITH_RET(devices, enumerate_devices_sync, d->handle);
+    devices_count = frida_device_list_size(devices);
+    Devices_arr = rb_ary_new_capa(devices_count);
+    for (int i = 0; i < devices_count; i++)
+        rb_ary_store(Devices_arr, i, Device_from_FridaDevice(frida_device_list_get(devices, i)));
+    frida_unref(devices);
+    return (Devices_arr);
+
+    GERROR_BLOCK
+}
+
+/*
+    call-seq:
+        #get_device_matching() {} -> Device
+*/
+static VALUE DeviceManager_get_device_matching(VALUE self)
+{
+    GET_GOBJECT_DATA();
+    REQUIRE_GOBJECT_HANDLE();
+    VALUE block;
+    VALUE devices, current_device, block_ret;
+    int	devices_count;
+
+    if (!rb_block_given_p()) {
+        raise_argerror("a block argument is required");
+        return (Qnil);
+    }
+    block = rb_block_proc();
+    // NOTE: Ruby does not support (currently) setting up a non Ruby created thread to be able
+    // to call its C APIs, frida_device_manager_get_device_sync() would call our filtering predicate from a frida thread
+    // which is not created by Ruby, and GET_EC() call in the Ruby's C APIs would return NULL.
+    // so the filtering is done in this thread that currently holds the GVL, mimicking frida_device_manager_get_device_sync().
+    devices = rb_funcall(self, rb_intern("enumerate_devices"), 0, NULL);
+    devices_count = RARRAY_LEN(devices);
+    for (int i = 0; i < devices_count; i++) {
+        current_device = rb_ary_entry(devices, i);
+        block_ret = rb_funcall(block, rb_intern("call"), 1, current_device);
+        if (block_ret == Qtrue) return (current_device);
+    }
+    return (Qnil);
+}
+
+static FridaRemoteDeviceOptions *parse_add_rdevice_kws_to_options(VALUE kws)
+{
+    FridaRemoteDeviceOptions *options;
+    VALUE cert, origin, token, keepalive_interval;
+
+    options = frida_remote_device_options_new();
+    cert = rb_hash_aref(kws, ID2SYM(rb_intern("certificate")));
+    if (!NIL_P(cert)) {
+        if (!RB_TYPE_P(cert, T_STRING)) {
+            raise_argerror("certificate should be a string.");
+            goto error;
+        }
+        GTlsCertificate * certificate;
+        if (!rbGObject_unmarshal_certificate(StringValueCStr(cert), &certificate))
+            goto error;
+        frida_remote_device_options_set_certificate(options, certificate);
+        g_object_unref(certificate);
+    }
+    origin = rb_hash_aref(kws, ID2SYM(rb_intern("origin")));
+    if (!NIL_P(origin)) {
+        if (!RB_TYPE_P(origin, T_STRING)) {
+            raise_argerror("origin should be a string.");
+            goto error;
+        }
+        frida_remote_device_options_set_origin(options, StringValueCStr(origin));
+    }
+    token = rb_hash_aref(kws, ID2SYM(rb_intern("token")));
+    if (!NIL_P(token)) {
+        if (!RB_TYPE_P(token, T_STRING)) {
+            raise_argerror("token should be a string.");
+            goto error;
+        }
+        frida_remote_device_options_set_token(options, StringValueCStr(token));
+    }
+    keepalive_interval = rb_hash_aref(kws, ID2SYM(rb_intern("keepalive_interval")));
+    if (!NIL_P(keepalive_interval)) {
+        if (!RB_TYPE_P(keepalive_interval, T_FIXNUM)) {
+            raise_argerror("keepalive_interval should be a number.");
+            goto error;
+        }
+        frida_remote_device_options_set_keepalive_interval(options, NUM2INT(keepalive_interval));
+    }
+    return (options);
+
+error:
+    g_object_unref(options);
+    return (NULL);
+}
+
+GVL_FREE_PROXY_FUNC(add_remote_device_sync, add_remote_device_proxy_args *args)
+{
+    GError *gerr = NULL;
+    FridaDevice	*device;
+
+    device = frida_device_manager_add_remote_device_sync(args->device_manager, args->address, args->options, NULL, &gerr);
+    RETURN_GVL_FREE_RESULT(device);
+}
+
+/*
+    call-seq:
+        #add_remote_device(address, certificate:, origin:, token:, keepalive_interval:) -> Device
+*/
+static VALUE DeviceManager_add_remote_device(int argc, VALUE *argv, VALUE self)
+{
+    GET_GOBJECT_DATA();
+    REQUIRE_GOBJECT_HANDLE();
+    VALUE	address, kws;
+    FridaRemoteDeviceOptions *options;
+    FridaDevice *device;
+
+    rb_scan_args(argc, argv, "1:", &address, &kws);
+    if (!RB_TYPE_P(address, T_STRING))
+        return (raise_argerror("address must be a string."), Qnil);
+    if (NIL_P(kws)) kws = rb_hash_new();
+    options = parse_add_rdevice_kws_to_options(kws);
+    if (!options)
+        return (Qnil);
+    add_remote_device_proxy_args args = {
+        .device_manager = d->handle,
+        .options = options,
+        .address = StringValueCStr(address)
+    };
+    CALL_GVL_FREE_WITH_RET(device, add_remote_device_sync, &args);
+    g_object_unref(options);
+    return (Device_from_FridaDevice(device));
+
+gerror:
+    g_object_unref(options);
+    raise_rerror(NULL, _gerr);
+    return (Qnil);
+}
+
+GVL_FREE_PROXY_FUNC(remove_remote_device_sync, remove_remote_devices_proxy_args *args)
+{
+    GError	*gerr = NULL;
+
+    frida_device_manager_remove_remote_device_sync(args->device_manager, args->address, NULL, &gerr);
+    RETURN_GVL_FREE_RESULT(NULL);
+}
+
+/*
+    call-seq:
+        #remove_remote_device(address) -> nil
+*/
+static VALUE DeviceManager_remove_remote_device(VALUE self, VALUE address)
+{
+    GET_GOBJECT_DATA();
+    REQUIRE_GOBJECT_HANDLE();
+
+    if (!RB_TYPE_P(address, T_STRING)) {
+        raise_argerror("address should be a string.");
+        return (Qnil);
+    }
+    remove_remote_devices_proxy_args args = {
+        .device_manager = d->handle,
+        .address = StringValueCStr(address)
+    };
+    CALL_GVL_FREE_WITH_RET(void *dummy, remove_remote_device_sync, &args);
+    return (Qnil);
+
+    GERROR_BLOCK
+}
+
+/*
+    call-seq:
+        #new() -> DeviceManager
+*/
+static VALUE DeviceManager_initialize(VALUE self)
+{
+    GET_GOBJECT_DATA();
+    d->handle = frida_device_manager_new();
+    if (!d->handle)
+        return (raise_rerror("failed to retrieve a device manager.", NULL), Qnil);
+    d->destroy = DeviceManager_destroy;
+    return (self);
+}
+
+void	define_DeviceManager()
+{
+    cDeviceManager = rb_define_class_under(mCFrida, "DeviceManager", cGObject);
+
+    rb_define_method(cDeviceManager, "initialize", DeviceManager_initialize, 0);
+    rb_define_method(cDeviceManager, "enumerate_devices", DeviceManager_enumerate_devices, 0);
+    rb_define_method(cDeviceManager, "get_device_matching", DeviceManager_get_device_matching, 0);
+    rb_define_method(cDeviceManager, "add_remote_device", DeviceManager_add_remote_device, -1);
+    rb_define_method(cDeviceManager, "remove_remote_device", DeviceManager_remove_remote_device, 1);
+    rb_define_method(cDeviceManager, "close", DeviceManager_close, 0);
+}

data/ext/c_frida/EndpointParameters.c

@@ -0,0 +1,189 @@
+#include "EndpointParameters.h"
+
+VALUE	EndpointParameters_from_FridaEndpointParameters(FridaEndpointParameters *handle)
+{
+    VALUE self;
+
+    if (!handle)
+        return (Qnil);
+    self = rb_class_new_instance(0, NULL, cEndpointParameters);
+    GET_GOBJECT_DATA();
+    d->handle = handle;
+    d->destroy = g_object_unref;
+    return (self);
+}
+
+static void frida_rb_authentication_service_iface_init (gpointer g_iface, gpointer iface_data);
+
+G_DEFINE_TYPE_EXTENDED (FridaRBAuthenticationService, frida_rb_authentication_service, G_TYPE_OBJECT, 0,
+                        G_IMPLEMENT_INTERFACE (FRIDA_TYPE_AUTHENTICATION_SERVICE, frida_rb_authentication_service_iface_init))
+
+static void frida_rb_authentication_service_dispose (GObject * object);
+static void frida_rb_authentication_service_authenticate (FridaAuthenticationService * service, const gchar * token, GCancellable * cancellable,
+        GAsyncReadyCallback callback, gpointer user_data);
+static gchar *frida_rb_authentication_service_authenticate_finish (FridaAuthenticationService * service, GAsyncResult * result, GError ** error);
+
+static FridaRBAuthenticationService *frida_rb_authentication_service_new(VALUE callback)
+{
+    FridaRBAuthenticationService *service;
+
+    service = g_object_new(FRIDA_TYPE_RB_AUTHENTICATION_SERVICE, NULL);
+    service->callback = callback;
+
+    return (service);
+}
+
+static void frida_rb_authentication_service_class_init(FridaRBAuthenticationServiceClass * klass)
+{
+    GObjectClass * object_class = G_OBJECT_CLASS (klass);
+
+    object_class->dispose = frida_rb_authentication_service_dispose;
+}
+
+static void frida_rb_authentication_service_iface_init (gpointer g_iface, gpointer iface_data)
+{
+    puts("frida_rb_authentication_service_iface_init");
+    FridaAuthenticationServiceIface * iface = g_iface;
+
+    iface->authenticate = frida_rb_authentication_service_authenticate;
+    iface->authenticate_finish = frida_rb_authentication_service_authenticate_finish;
+}
+
+static void frida_rb_authentication_service_init (FridaRBAuthenticationService * self)
+{
+    self->pool = g_thread_pool_new ((GFunc) gvl_bridge_forward_GT, self, 1, FALSE, NULL);
+}
+
+static void frida_rb_authentication_service_dispose (GObject * object)
+{
+    FridaRBAuthenticationService * self = FRIDA_RB_AUTHENTICATION_SERVICE (object);
+
+    if (self->pool != NULL) {
+        g_thread_pool_free (self->pool, FALSE, FALSE);
+        self->pool = NULL;
+    }
+
+    G_OBJECT_CLASS (frida_rb_authentication_service_parent_class)->dispose (object);
+}
+
+static void frida_rb_authentication_service_authenticate (FridaAuthenticationService * service, const gchar * token, GCancellable * cancellable,
+        GAsyncReadyCallback callback, gpointer user_data)
+{
+    FridaRBAuthenticationService * self;
+    GTask * task;
+
+    self = FRIDA_RB_AUTHENTICATION_SERVICE (service);
+
+    task = g_task_new (self, cancellable, callback, user_data);
+    g_task_set_task_data (task, g_strdup (token), g_free);
+
+    g_thread_pool_push (self->pool, task, NULL);
+}
+
+static gchar *frida_rb_authentication_service_authenticate_finish (FridaAuthenticationService * service, GAsyncResult * result, GError ** error)
+{
+    return g_task_propagate_pointer (G_TASK (result), error);
+}
+
+/*
+    call-seq:
+        #new(address:, port:, certificate:, origin:, auth_token:, auth_callback:, asset_root:) -> EndpointParameters
+*/
+static VALUE EndpointParameters_initialize(int argc, VALUE *argv, VALUE self)
+{
+    GET_GOBJECT_DATA();
+    GTlsCertificate *certificate = NULL;
+    FridaAuthenticationService *auth_service = NULL;
+    GFile *asset_root = NULL;
+    unsigned short port = 0;
+    char *address = NULL, *origin = NULL, *auth_token = NULL;
+    VALUE kws;
+
+    rb_scan_args(argc, argv, ":", &kws);
+    if (!NIL_P(kws)) {
+        VALUE raddress = rb_hash_aref(kws, ID2SYM(rb_intern("address")));
+        if (!NIL_P(raddress)) {
+            if (!RB_TYPE_P(raddress, T_STRING)) {
+                raise_argerror("address must be a string.");
+                goto invalid_arg;
+            }
+            address = StringValueCStr(raddress);
+        }
+        VALUE rport = rb_hash_aref(kws, ID2SYM(rb_intern("port")));
+        if (!NIL_P(rport)) {
+            if (!RB_TYPE_P(rport, T_FIXNUM)) {
+                raise_argerror("port must be a number.");
+                goto invalid_arg;
+            }
+            port = (unsigned short)NUM2USHORT(rport);
+        }
+        VALUE rcert = rb_hash_aref(kws, ID2SYM(rb_intern("certificate")));
+        if (!NIL_P(rcert)) {
+            if (!RB_TYPE_P(rcert, T_STRING)) {
+                raise_argerror("certificate must be a string.");
+                goto invalid_arg;
+            }
+            char *cert = StringValueCStr(rcert);
+            if (!rbGObject_unmarshal_certificate(cert, &certificate)) {
+                raise_argerror("invalid certificate.");
+                goto invalid_arg;
+            }
+        }
+        VALUE rorigin = rb_hash_aref(kws, ID2SYM(rb_intern("origin")));
+        if (!NIL_P(rorigin)) {
+            if (!RB_TYPE_P(rorigin, T_STRING)) {
+                raise_argerror("origin must be a string.");
+                goto invalid_arg;
+            }
+            origin = StringValueCStr(rorigin);
+        }
+        VALUE rauth_token = rb_hash_aref(kws, ID2SYM(rb_intern("auth_token")));
+        if (!NIL_P(rauth_token)) {
+            if (!RB_TYPE_P(rauth_token, T_STRING)) {
+                raise_argerror("auth_token must be a string.");
+                goto invalid_arg;
+            }
+            auth_token = StringValueCStr(rauth_token);
+        }
+        VALUE rauth_callback = rb_hash_aref(kws, ID2SYM(rb_intern("auth_callback")));
+        if (!NIL_P(rauth_callback)) {
+            // currently support only methods.
+            if (rb_obj_is_kind_of(rauth_callback, rb_const_get(rb_cObject, rb_intern("Method"))) == Qfalse || \
+                NUM2INT(rb_funcall(rauth_callback, rb_intern("arity"), 0, NULL)) != 1) {
+                raise_argerror("auth_callback must be a method with one argument.");
+                goto invalid_arg;
+            }
+            // don't GC
+            rb_ivar_set(self, rb_intern("auth_callback"), rauth_callback);
+        }
+        if (auth_token)
+            auth_service = FRIDA_AUTHENTICATION_SERVICE(frida_static_authentication_service_new(auth_token));
+        else if (rauth_callback != Qnil)
+            auth_service = FRIDA_AUTHENTICATION_SERVICE(frida_rb_authentication_service_new(rauth_callback));
+        VALUE rasset_root = rb_hash_aref(kws, ID2SYM(rb_intern("asset_root")));
+        if (!NIL_P(rasset_root)) {
+            if (!RB_TYPE_P(rasset_root, T_STRING)) {
+                raise_argerror("asset_root must be a string.");
+                goto invalid_arg;
+            }
+            asset_root = g_file_new_for_path(StringValueCStr(rasset_root));
+        }
+    } else
+        return (self);
+    d->handle = frida_endpoint_parameters_new(address, port, certificate, origin, auth_service, asset_root);
+    d->destroy = g_object_unref;
+    return (self);
+
+invalid_arg:
+    g_clear_object(&asset_root);
+    g_clear_object(&auth_service);
+    g_clear_object(&certificate);
+    return (Qnil);
+}
+
+void	define_EndpointParameters()
+{
+    cEndpointParameters = rb_define_class_under(mCFrida, "EndpointParameters", cGObject);
+
+    rb_define_method(cEndpointParameters, "initialize", EndpointParameters_initialize, -1);
+}

data/ext/c_frida/FileMonitor.c

@@ -0,0 +1,67 @@
+#include "FileMonitor.h"
+
+VALUE	FileMonitor_from_FridaFileMonitor(FridaFileMonitor *handle)
+{
+    VALUE self;
+
+    if (!handle)
+        return (Qnil);
+    self = rb_class_new_instance(0, NULL, cFileMonitor);
+    GET_GOBJECT_DATA();
+    d->handle = handle;
+    d->destroy = frida_unref;
+    return (self);
+}
+
+GVL_FREE_PROXY_FUNC(enable_sync, void *handle)
+{
+    GError *gerr = NULL;
+
+    frida_file_monitor_enable_sync(handle, NULL, &gerr);
+    RETURN_GVL_FREE_RESULT(NULL);
+}
+
+/*
+    call-seq:
+        #enable() -> nil
+*/
+static VALUE FileMonitor_enable(VALUE self)
+{
+    GET_GOBJECT_DATA();
+    REQUIRE_GOBJECT_HANDLE();
+
+    CALL_GVL_FREE_WITH_RET(void *dummy, enable_sync, d->handle);
+    return (Qnil);
+
+    GERROR_BLOCK
+}
+
+GVL_FREE_PROXY_FUNC(disable_sync, void *handle)
+{
+    GError *gerr = NULL;
+
+    frida_file_monitor_disable_sync(handle, NULL, &gerr);
+    RETURN_GVL_FREE_RESULT(NULL);
+}
+
+/*
+    call-seq:
+        #disable() -> nil
+*/
+static VALUE FileMonitor_disable(VALUE self)
+{
+    GET_GOBJECT_DATA();
+    REQUIRE_GOBJECT_HANDLE();
+
+    CALL_GVL_FREE_WITH_RET(void *dummy, disable_sync, d->handle);
+    return (Qnil);
+
+    GERROR_BLOCK
+}
+
+void	define_FileMonitor()
+{
+    cFileMonitor = rb_define_class_under(mCFrida, "FileMonitor", cGObject);
+    rb_define_method(cFileMonitor, "enable", FileMonitor_enable, 0);
+    rb_define_method(cFileMonitor, "disable", FileMonitor_disable, 0);
+}

data/ext/c_frida/GObject.c

@@ -0,0 +1,138 @@
+#include "GObject.h"
+
+DEFINE_KLASS_DATA_TYPE(GObject);
+
+void	GObject_free(GObject_d *d)
+{
+    if (d->handle)
+        d->destroy(d->handle);
+    xfree(d);
+}
+
+/*
+    call-seq:
+        #on(signal_name) {} -> nil
+        #on(signal_name, callback) -> nil
+*/
+static VALUE GObject_on(int argc, VALUE *argv, VALUE self)
+{
+    GET_DATA(GObject);
+    REQUIRE_GOBJECT_HANDLE();
+    VALUE signal_name, callback;
+    GType self_type = G_OBJECT_TYPE(d->handle);
+    guint signal_id;
+    bool is_lambda;
+    GSignalQuery squery;
+
+    if (rb_block_given_p()) {
+        // blocks are handy however we cannot compare them because they are unique
+        // so you cannot remove them later!
+        rb_scan_args(argc, argv, "1&", &signal_name, &callback);
+    } else {
+        rb_scan_args(argc, argv, "2", &signal_name, &callback);
+        // either a Method or Proc object.
+        if (!rb_respond_to(callback, rb_intern("call"))) {
+            raise_argerror("callback should be callable.");
+            return (Qnil);
+        }
+    }
+    if (!RB_TYPE_P(signal_name, T_STRING)) {
+        raise_argerror("signal name must be a string.");
+        return (Qnil);
+    }
+    signal_id = g_signal_lookup(StringValueCStr(signal_name), self_type);
+    if (!signal_id) {
+        raise_argerror("invalid signal name.");
+        return (Qnil);
+    }
+    is_lambda = (rb_obj_is_kind_of(callback, rb_const_get(rb_cObject, rb_intern("Method"))) == Qtrue) ? true : (rb_funcall(callback, rb_intern("lambda?"), 0, NULL) == Qtrue);
+    int arity = NUM2INT(rb_funcall(callback, rb_intern("arity"), 0, NULL));
+    g_signal_query(signal_id, &squery);
+    if (is_lambda && arity > (int)(squery.n_params + 1)) {
+        gchar *err = g_strdup_printf("callback expects too many arguments, signal expects %d.", squery.n_params);
+        raise_argerror(err);
+        g_free(err);
+        return (Qnil);
+    }
+    GClosure *closure = g_closure_new_simple(sizeof(RBClosure), (void*)callback);
+    g_closure_set_marshal(closure, (GClosureMarshal)gvl_bridge_forward_GC);
+    TO_RBCLOSURE(closure)->is_lambda = is_lambda;
+    TO_RBCLOSURE(closure)->signal_id = signal_id;
+    TO_RBCLOSURE(closure)->arity = arity;
+    g_signal_connect_closure_by_id(d->handle, signal_id, 0, closure, TRUE);
+    // objects generated on the fly (thus not referenced), e.g blocks `#on("signal", :id) {block}` / `#on("signal", &callable)`
+    // or Methods `#on("signal", method(:defined_fn))` or Procs `#on("signal", ->{})`
+    // will be picked up by the GC, since in Ruby's view there is no more usage/reference to them
+    // so we keep them in this hidden Hash.
+    if (rb_hash_aref(rb_iv_get(self, "callbacks"), signal_name) == Qnil)
+        rb_hash_aset(rb_iv_get(self, "callbacks"), signal_name, rb_ary_new());
+    rb_ary_push(rb_hash_aref(rb_iv_get(self, "callbacks"), signal_name), callback);
+    d->signal_closures = g_slist_prepend(d->signal_closures, closure);
+    return (Qnil);
+}
+
+static gint compare_callback(RBClosure *closure, VALUE callback)
+{
+    return (rb_equal((VALUE)closure->gclosure.data, callback) == Qtrue ? 0 : -1);
+}
+
+/*
+    call-seq:
+        #off(signal_name, callback) -> nil
+*/
+static VALUE GObject_off(int argc, VALUE *argv, VALUE self)
+{
+    GET_DATA(GObject);
+    REQUIRE_GOBJECT_HANDLE();
+    VALUE signal_name, callback;
+    GType self_type = G_OBJECT_TYPE(d->handle);
+    guint signal_id;
+    GSList *callback_entry;
+    int	is_block = rb_block_given_p();
+
+    // remember you cannot remove Proc objects that you do not hold reference to!
+    rb_scan_args(argc, argv, "2", &signal_name, &callback);
+    if (!RB_TYPE_P(signal_name, T_STRING)) {
+        raise_argerror("signal name must be a string.");
+        return (Qnil);
+    }
+    signal_id = g_signal_lookup(StringValueCStr(signal_name), self_type);
+    if (!signal_id) {
+        raise_argerror("invalid signal name.");
+        return (Qnil);
+    }
+    if (rb_respond_to(callback, rb_intern("call"))) {
+        callback_entry = g_slist_find_custom(d->signal_closures, (gpointer)callback, (GCompareFunc)compare_callback);
+        if (!callback_entry) {
+            raise_argerror("callback not found.");
+            return (Qnil);
+        }
+    } else {
+        raise_argerror("second argument should be callable.");
+        return (Qnil);
+    }
+    GClosure *closure = callback_entry->data;
+    d->signal_closures = g_slist_delete_link(d->signal_closures, callback_entry);
+    g_signal_handlers_disconnect_matched(d->handle, G_SIGNAL_MATCH_CLOSURE, signal_id, 0, closure, NULL, NULL);
+    // this will delete a duplicate callback for a signal, but that is fine ?
+    rb_ary_delete(rb_hash_aref(rb_iv_get(self, "callbacks"), signal_name), callback);
+    return (Qnil);
+}
+
+static VALUE GObject_alloc(VALUE klass)
+{
+    MAKE_DATA(GObject);
+    d->handle = NULL;
+    d->destroy = NULL;
+    d->signal_closures = NULL;
+    rb_ivar_set(obj, rb_intern("callbacks"), rb_hash_new());
+    return (obj);
+}
+
+void	define_GObject()
+{
+    cGObject = rb_define_class_under(mCFrida, "GObject", rb_cObject);
+    rb_define_alloc_func(cGObject, GObject_alloc);
+    rb_define_method(cGObject, "on", GObject_on, -1);
+    rb_define_method(cGObject, "off", GObject_off, -1);
+}