frida 0.1.0 → 0.1.1

data/ext/c_frida/IOStream.c

@@ -0,0 +1,228 @@
+#include "IOStream.h"
+
+DEFINE_GOBJECT_CHILD_KLASS_DATA_TYPE(IOStream);
+
+VALUE	IOStream_from_GIOStream(GIOStream *stream)
+{
+    VALUE self;
+
+    if (!stream) return (Qnil);
+    self = rb_class_new_instance(0, NULL, cIOStream);
+    GET_GOBJECT_DATA();
+    d->handle = stream;
+    GET_DATA_EX(IOStream, self, io_d);
+    io_d->input = g_io_stream_get_input_stream(d->handle);
+    io_d->output = g_io_stream_get_output_stream(d->handle);
+    return (self);
+}
+
+void IOStream_free(IOStream_d *d)
+{
+    if (d->base.handle)
+        g_object_unref(d->base.handle);
+    xfree(d);
+}
+
+/*
+    call-seq:
+        #is_closed() -> [TrueClass, FalseClass]
+*/
+static VALUE IOStream_is_closed(VALUE self)
+{
+    GET_GOBJECT_DATA();
+    REQUIRE_GOBJECT_HANDLE();
+    return (g_io_stream_is_closed(d->handle) ? Qtrue : Qfalse);
+}
+
+static VALUE IOStream_inspect(VALUE self)
+{
+    GET_GOBJECT_DATA();
+    VALUE s;
+
+    s = rb_sprintf("#<IOStream: handle=\"%p\", is_closed=%+"PRIsVALUE">", d->handle, rb_funcall(self, rb_intern("is_closed"), 0, NULL));
+    return (s);
+}
+
+GVL_FREE_PROXY_FUNC(write, write_proxy_args *args)
+{
+    GError *gerr = NULL;
+    gsize written;
+
+    written = g_output_stream_write(args->output, args->data, args->size, NULL, &gerr);
+    RETURN_GVL_FREE_RESULT((void*)written);
+}
+
+/*
+    call-seq:
+        #write(data) -> Fixnum
+*/
+static VALUE IOStream_write(VALUE self, VALUE data)
+{
+    GET_GOBJECT_DATA();
+    REQUIRE_GOBJECT_HANDLE();
+    GET_DATA_EX(IOStream, self, io_d);
+
+    if (!RB_TYPE_P(data, T_STRING)) {
+        raise_argerror("data should be a string.");
+        return (Qnil);
+    }
+    write_proxy_args args = {
+        .output = io_d->output,
+        .data = RSTRING_PTR(data),
+        .size = RSTRING_LEN(data)
+    };
+    CALL_GVL_FREE_WITH_RET(void *written, write, &args);
+    return (ULONG2NUM((gsize)written));
+
+    GERROR_BLOCK
+}
+
+GVL_FREE_PROXY_FUNC(write_all, write_proxy_args *args)
+{
+    GError *gerr = NULL;
+
+    g_output_stream_write_all(args->output, args->data, args->size, NULL, NULL, &gerr);
+    RETURN_GVL_FREE_RESULT(NULL);
+}
+
+/*
+    call-seq:
+        #write_all(data) -> nil
+*/
+static VALUE IOStream_write_all(VALUE self, VALUE data)
+{
+    GET_GOBJECT_DATA();
+    REQUIRE_GOBJECT_HANDLE();
+    GET_DATA_EX(IOStream, self, io_d);
+
+    if (!RB_TYPE_P(data, T_STRING)) {
+        raise_argerror("data should be a string.");
+        return (Qnil);
+    }
+    write_proxy_args args = {
+        .output = io_d->output,
+        .data = RSTRING_PTR(data),
+        .size = RSTRING_LEN(data)
+    };
+    CALL_GVL_FREE_WITH_RET(void *dummy, write_all, &args);
+    return (Qnil);
+
+    GERROR_BLOCK
+}
+
+GVL_FREE_PROXY_FUNC(read, read_proxy_args *args)
+{
+    GError *gerr = NULL;
+    gsize read;
+
+    read = g_input_stream_read(args->input, args->buffer, args->count, NULL, &gerr);
+    RETURN_GVL_FREE_RESULT((void*)read);
+}
+
+/*
+    call-seq:
+        #read(count) -> String
+*/
+static VALUE IOStream_read(VALUE self, VALUE count)
+{
+    GET_GOBJECT_DATA();
+    REQUIRE_GOBJECT_HANDLE();
+    GET_DATA_EX(IOStream, self, io_d);
+
+    if (!FIXNUM_P(count)) {
+        raise_argerror("count should be a number.");
+        return (Qnil);
+    }
+    VALUE buffer = rb_str_new(NULL, NUM2ULONG(count));
+    read_proxy_args args = {
+        .input = io_d->input,
+        .buffer = RSTRING_PTR(buffer),
+        .count = NUM2ULONG(count)
+    };
+    CALL_GVL_FREE_WITH_RET(void *read, read, &args);
+    if ((gsize)read != NUM2ULONG(count))
+        buffer = rb_str_new(RSTRING_PTR(buffer), (gsize)read);
+    return (buffer);
+
+    GERROR_BLOCK
+}
+
+GVL_FREE_PROXY_FUNC(read_all, read_proxy_args *args)
+{
+    GError *gerr = NULL;
+    gsize	read;
+
+    g_input_stream_read_all(args->input, args->buffer, args->count, &read, NULL, &gerr);
+    RETURN_GVL_FREE_RESULT(NULL);
+}
+
+/*
+    call-seq:
+        #read_all(count) -> String
+*/
+static VALUE IOStream_read_all(VALUE self, VALUE count)
+{
+    GET_GOBJECT_DATA();
+    REQUIRE_GOBJECT_HANDLE();
+    GET_DATA_EX(IOStream, self, io_d);
+
+    if (!FIXNUM_P(count)) {
+        raise_argerror("count should be a number.");
+        return (Qnil);
+    }
+    VALUE buffer = rb_str_new(NULL, NUM2ULONG(count));
+    read_proxy_args args = {
+        .input = io_d->input,
+        .buffer = RSTRING_PTR(buffer),
+        .count = NUM2ULONG(count)
+    };
+    CALL_GVL_FREE_WITH_RET(void *dummy, read_all, &args);
+    return (buffer);
+
+    GERROR_BLOCK
+}
+
+GVL_FREE_PROXY_FUNC(close, GIOStream *handle)
+{
+    GError *gerr = NULL;
+
+    g_io_stream_close(handle, NULL, &gerr);
+    RETURN_GVL_FREE_RESULT(NULL);
+}
+
+/*
+    call-seq:
+        #close() -> nil
+*/
+static VALUE IOStream_close(VALUE self)
+{
+    GET_GOBJECT_DATA();
+    REQUIRE_GOBJECT_HANDLE();
+
+    CALL_GVL_FREE_WITH_RET(void *dummy, close, d->handle);
+    return (Qnil);
+
+    GERROR_BLOCK
+}
+
+static VALUE IOStream_alloc(VALUE klass)
+{
+    MAKE_DATA(IOStream);
+    memset(d, 0, sizeof(IOStream_d));
+    rb_ivar_set(obj, rb_intern("callbacks"), rb_hash_new());
+    return (obj);
+}
+
+void	define_IOStream()
+{
+    cIOStream = rb_define_class_under(mCFrida, "IOStream", cGObject);
+    rb_define_alloc_func(cIOStream, IOStream_alloc);
+    rb_define_method(cIOStream, "inspect", IOStream_inspect, 0);
+    rb_define_alias(cIOStream, "to_s", "inspect");
+    rb_define_method(cIOStream, "is_closed", IOStream_is_closed, 0);
+    rb_define_method(cIOStream, "read", IOStream_read, 1);
+    rb_define_method(cIOStream, "read_all", IOStream_read_all, 1);
+    rb_define_method(cIOStream, "write", IOStream_write, 1);
+    rb_define_method(cIOStream, "write_all", IOStream_write_all, 1);
+    rb_define_method(cIOStream, "close", IOStream_close, 0);
+}

data/ext/c_frida/PortalMembership.c

@@ -0,0 +1,43 @@
+#include "PortalMembership.h"
+
+VALUE	PortalMembership_from_FridaPortalMembership(FridaPortalMembership *handle)
+{
+    VALUE self;
+
+    if (!handle)
+        return (Qnil);
+    self = rb_class_new_instance(0, NULL, cPortalMembership);
+    GET_GOBJECT_DATA();
+    d->handle = handle;
+    d->destroy = frida_unref;
+    return (self);
+}
+
+GVL_FREE_PROXY_FUNC(terminate_sync, FridaPortalMembership *handle)
+{
+    GError *gerr = NULL;
+
+    frida_portal_membership_terminate_sync(handle, NULL, &gerr);
+    RETURN_GVL_FREE_RESULT(NULL);
+}
+
+/*
+    call-seq:
+        #terminate() -> nil
+*/
+static VALUE PortalMembership_terminate(VALUE self)
+{
+    GET_GOBJECT_DATA();
+    REQUIRE_GOBJECT_HANDLE();
+    CALL_GVL_FREE_WITH_RET(void *dummy, terminate_sync, d->handle);
+    return (Qnil);
+
+    GERROR_BLOCK
+}
+
+void	define_PortalMembership()
+{
+    cPortalMembership = rb_define_class_under(mCFrida, "PortalMembership", cGObject);
+
+    rb_define_method(cPortalMembership, "terminate", PortalMembership_terminate, 0);
+}

data/ext/c_frida/PortalService.c

@@ -0,0 +1,413 @@
+#include "PortalService.h"
+
+GVL_FREE_PROXY_FUNC(stop_sync, FridaPortalService *handle)
+{
+    GError *gerr = NULL;
+
+    frida_portal_service_stop_sync(handle, NULL, &gerr);
+    RETURN_GVL_FREE_RESULT(NULL);
+}
+
+static void PortalService_destroy(void *handle)
+{
+    CALL_GVL_FREE_WITH_RET(void *dummy, stop_sync, handle);
+    frida_unref(handle);
+    return ;
+
+gerror:
+    g_error_free(_gerr);
+    frida_unref(handle);
+}
+
+/*
+    call-seq:
+        #device() -> Device
+*/
+static VALUE PortalService_device(VALUE self)
+{
+    return (rb_ivar_get(self, rb_intern("device")));
+}
+
+/*
+    call-seq:
+        #stop() -> nil
+*/
+static VALUE PortalService_stop(VALUE self)
+{
+    GET_GOBJECT_DATA();
+    REQUIRE_GOBJECT_HANDLE();
+
+    CALL_GVL_FREE_WITH_RET(void *dummy, stop_sync, d->handle);
+    return (Qnil);
+
+    GERROR_BLOCK
+}
+
+
+GVL_FREE_PROXY_FUNC(start_sync, FridaPortalService *handle)
+{
+    GError *gerr = NULL;
+
+    frida_portal_service_start_sync(handle, NULL, &gerr);
+    RETURN_GVL_FREE_RESULT(NULL);
+}
+
+/*
+    call-seq:
+        #start() -> nil
+*/
+static VALUE PortalService_start(VALUE self)
+{
+    GET_GOBJECT_DATA();
+    REQUIRE_GOBJECT_HANDLE();
+
+    CALL_GVL_FREE_WITH_RET(void *dummy, start_sync, d->handle);
+    return (Qnil);
+
+    GERROR_BLOCK
+}
+
+GVL_FREE_PROXY_FUNC(kick, kick_proxy_args *args)
+{
+    GError *gerr = NULL;
+
+    frida_portal_service_kick(args->handle, args->connection_id);
+    RETURN_GVL_FREE_RESULT(NULL);
+}
+
+/*
+    call-seq:
+        #kick(connection_id) -> nil
+*/
+static VALUE PortalService_kick(VALUE self, VALUE connection_id)
+{
+    GET_GOBJECT_DATA();
+    REQUIRE_GOBJECT_HANDLE();
+
+    if (!RB_TYPE_P(connection_id, T_FIXNUM)) {
+        raise_argerror("connection_id must be an integer.");
+        return (Qnil);
+    }
+    kick_proxy_args args = {
+        .handle = d->handle,
+        .connection_id = NUM2UINT(connection_id)
+    };
+    CALL_GVL_FREE_WITH_RET(void *dummy, kick, &args);
+    return (Qnil);
+
+    UNREACHABLE_GERROR_BLOCK
+}
+
+GVL_FREE_PROXY_FUNC(post, _post_proxy_args *args)
+{
+    GError *gerr = NULL;
+
+    frida_portal_service_post(args->handle, args->connection_id, args->message, args->data);
+    RETURN_GVL_FREE_RESULT(NULL);
+}
+
+/*
+    call-seq:
+        #post(connection_id, message, data:) -> nil
+*/
+static VALUE PortalService_post(int argc, VALUE *argv, VALUE self)
+{
+    GET_GOBJECT_DATA();
+    REQUIRE_GOBJECT_HANDLE();
+    VALUE connection_id, message, kws;
+    GBytes *gdata = NULL;
+
+    rb_scan_args(argc, argv, "2:", &connection_id, &message, &kws);
+    if (!RB_TYPE_P(connection_id, T_FIXNUM)) {
+        raise_argerror("tag must be a number.");
+        return (Qnil);
+    }
+    if (!RB_TYPE_P(message, T_STRING)) {
+        raise_argerror("message must be a String.");
+        return (Qnil);
+    }
+    if (!NIL_P(kws)) {
+        VALUE data = rb_hash_aref(kws, ID2SYM(rb_intern("data")));
+        if (!NIL_P(data)) {
+            if (!RB_TYPE_P(data, T_STRING)) {
+                raise_argerror("data must be a String.");
+                return (Qnil);
+            }
+        }
+        gdata = g_bytes_new(RSTRING_PTR(data), RSTRING_LEN(data));
+    }
+    _post_proxy_args args = {
+        .handle = d->handle,
+        .connection_id = NUM2UINT(connection_id),
+        .message = StringValueCStr(message),
+        .data = gdata
+    };
+    CALL_GVL_FREE_WITH_RET(void *dummy, post, &args);
+    g_bytes_unref(gdata);
+    return (Qnil);
+
+    UNREACHABLE_GERROR_BLOCK
+}
+
+GVL_FREE_PROXY_FUNC(narrowcast, narrowcast_proxy_args *args)
+{
+    GError *gerr = NULL;
+
+    frida_portal_service_narrowcast(args->handle, args->tag, args->message, args->data);
+    RETURN_GVL_FREE_RESULT(NULL);
+}
+
+/*
+    call-seq:
+        #narrowcast(tag, message, data:) -> nil
+*/
+static VALUE PortalService_narrowcast(int argc, VALUE *argv, VALUE self)
+{
+    GET_GOBJECT_DATA();
+    REQUIRE_GOBJECT_HANDLE();
+    VALUE tag, message, kws;
+    GBytes *gdata = NULL;
+
+    rb_scan_args(argc, argv, "2:", &tag, &message, &kws);
+    if (!RB_TYPE_P(tag, T_STRING)) {
+        raise_argerror("tag must be a String.");
+        return (Qnil);
+    }
+    if (!RB_TYPE_P(message, T_STRING)) {
+        raise_argerror("message must be a String.");
+        return (Qnil);
+    }
+    if (!NIL_P(kws)) {
+        VALUE data = rb_hash_aref(kws, ID2SYM(rb_intern("data")));
+        if (!NIL_P(data)) {
+            if (!RB_TYPE_P(data, T_STRING)) {
+                raise_argerror("data must be a String.");
+                return (Qnil);
+            }
+        }
+        gdata = g_bytes_new(RSTRING_PTR(data), RSTRING_LEN(data));
+    }
+    narrowcast_proxy_args args = {
+        .handle = d->handle,
+        .tag = StringValueCStr(tag),
+        .message = StringValueCStr(message),
+        .data = gdata
+    };
+    CALL_GVL_FREE_WITH_RET(void *dummy, narrowcast, &args);
+    g_bytes_unref(gdata);
+    return (Qnil);
+
+    UNREACHABLE_GERROR_BLOCK
+}
+
+GVL_FREE_PROXY_FUNC(broadcast, broadcast_proxy_args *args)
+{
+    GError *gerr = NULL;
+
+    frida_portal_service_broadcast(args->handle, args->message, args->data);
+    RETURN_GVL_FREE_RESULT(NULL);
+}
+
+/*
+    call-seq:
+        #broadcast(message, data:) -> nil
+*/
+static VALUE PortalService_broadcast(int argc, VALUE *argv, VALUE self)
+{
+    GET_GOBJECT_DATA();
+    REQUIRE_GOBJECT_HANDLE();
+    VALUE message, kws;
+    GBytes *gdata = NULL;
+
+    rb_scan_args(argc, argv, "1:", &message, &kws);
+    if (!RB_TYPE_P(message, T_STRING)) {
+        raise_argerror("message must be a String.");
+        return (Qnil);
+    }
+    if (!NIL_P(kws)) {
+        VALUE data = rb_hash_aref(kws, ID2SYM(rb_intern("data")));
+        if (!NIL_P(data)) {
+            if (!RB_TYPE_P(data, T_STRING)) {
+                raise_argerror("data must be a String.");
+                return (Qnil);
+            }
+        }
+        gdata = g_bytes_new(RSTRING_PTR(data), RSTRING_LEN(data));
+    }
+    broadcast_proxy_args args = {
+        .handle = d->handle,
+        .message = StringValueCStr(message),
+        .data = gdata
+    };
+    CALL_GVL_FREE_WITH_RET(void *dummy, broadcast, &args);
+    g_bytes_unref(gdata);
+    return (Qnil);
+
+    UNREACHABLE_GERROR_BLOCK
+}
+
+GVL_FREE_PROXY_FUNC(enumerate_tags, enumerate_tags_proxy_args *args)
+{
+    GError *gerr = NULL;
+    gchar **tags;
+
+    tags = frida_portal_service_enumerate_tags(args->handle, args->connection_id, args->tags_count);
+    RETURN_GVL_FREE_RESULT(tags);
+}
+
+/*
+    call-seq:
+        #enumerate_tags(connection_id) -> Array
+*/
+static VALUE PortalService_enumerate_tags(VALUE self, VALUE connection_id)
+{
+    GET_GOBJECT_DATA();
+    REQUIRE_GOBJECT_HANDLE();
+    gint tags_count;
+
+    if (!RB_TYPE_P(connection_id, T_FIXNUM)) {
+        raise_argerror("connection_id must be an integer.");
+        return (Qnil);
+    }
+    enumerate_tags_proxy_args args = {
+        .handle = d->handle,
+        .connection_id = NUM2UINT(connection_id),
+        .tags_count = &tags_count
+    };
+    CALL_GVL_FREE_WITH_RET(gchar **tags, enumerate_tags, &args);
+    VALUE rtags = rbGObject_marshal_strv(tags, tags_count);
+    g_strfreev(tags);
+    return (rtags);
+
+    UNREACHABLE_GERROR_BLOCK
+}
+
+GVL_FREE_PROXY_FUNC(tag, tag_proxy_args *args)
+{
+    GError *gerr = NULL;
+
+    frida_portal_service_tag(args->handle, args->connection_id, args->tag);
+    RETURN_GVL_FREE_RESULT(NULL);
+}
+
+/*
+    call-seq:
+        #tag(connection_id, tag) -> nil
+*/
+static VALUE PortalService_tag(VALUE self, VALUE connection_id, VALUE tag)
+{
+    GET_GOBJECT_DATA();
+    REQUIRE_GOBJECT_HANDLE();
+
+    if (!RB_TYPE_P(connection_id, T_FIXNUM)) {
+        raise_argerror("connection_id must be an integer.");
+        return (Qnil);
+    }
+    if (!RB_TYPE_P(tag, T_STRING)) {
+        raise_argerror("tag must be a String.");
+        return (Qnil);
+    }
+    tag_proxy_args args = {
+        .handle = d->handle,
+        .connection_id = NUM2UINT(connection_id),
+        .tag = StringValueCStr(tag)
+    };
+    CALL_GVL_FREE_WITH_RET(void *dummy, tag, &args);
+    return (Qnil);
+
+    UNREACHABLE_GERROR_BLOCK
+}
+
+GVL_FREE_PROXY_FUNC(untag, untag_proxy_args *args)
+{
+    GError *gerr = NULL;
+
+    frida_portal_service_untag(args->handle, args->connection_id, args->tag);
+    RETURN_GVL_FREE_RESULT(NULL);
+}
+
+/*
+    call-seq:
+        #untag(connection_id, tag) -> nil
+*/
+static VALUE PortalService_untag(VALUE self, VALUE connection_id, VALUE tag)
+{
+    GET_GOBJECT_DATA();
+    REQUIRE_GOBJECT_HANDLE();
+
+    if (!RB_TYPE_P(connection_id, T_FIXNUM)) {
+        raise_argerror("connection_id must be an integer.");
+        return (Qnil);
+    }
+    if (!RB_TYPE_P(tag, T_STRING)) {
+        raise_argerror("tag must be a String.");
+        return (Qnil);
+    }
+    untag_proxy_args args = {
+        .handle = d->handle,
+        .connection_id = NUM2UINT(connection_id),
+        .tag = StringValueCStr(tag)
+    };
+    CALL_GVL_FREE_WITH_RET(void *dummy, untag, &args);
+    return (Qnil);
+
+    UNREACHABLE_GERROR_BLOCK
+}
+
+/*
+    call-seq:
+        #new(cluster_params, control_params:) -> PortalService
+*/
+static VALUE PortalService_initialize(int argc, VALUE *argv, VALUE self)
+{
+    GET_GOBJECT_DATA();
+    VALUE cluster_params, kws;
+    FridaEndpointParameters *c, *cc = NULL;
+
+    rb_scan_args(argc, argv, "1:", &cluster_params, &kws);
+    if (!rb_obj_is_instance_of(cluster_params, cEndpointParameters)) {
+        raise_argerror("cluster_params must be an instance of EndpointParameters.");
+        return (Qnil);
+    }
+    GET_DATA_EX(GObject, cluster_params, c_d);
+    c = c_d->handle;
+    // we support creating classes without a handle for marshaling purposes, but those instances should not work here.
+    if (!c) {
+        raise_argerror("cluster_params must be an instance of a valid EndpointParameters.");
+        return (Qnil);
+    }
+    if (!NIL_P(kws)) {
+        VALUE control_params = rb_hash_aref(kws, ID2SYM(rb_intern("control_params")));
+        if (!NIL_P(control_params)) {
+            if (!rb_obj_is_instance_of(control_params, cEndpointParameters)) {
+                raise_argerror("control_params must be an instance of EndpointParameters.");
+                return (Qnil);
+            }
+            GET_DATA_EX(GObject, control_params, cc_d);
+            cc = cc_d->handle;
+        }
+    }
+    FridaPortalService *handle = frida_portal_service_new(c, cc);
+    d->handle = handle;
+    d->destroy = PortalService_destroy;
+    rb_ivar_set(self, rb_intern("device"), Device_from_FridaDevice(g_object_ref(frida_portal_service_get_device(d->handle))));
+    return (self);
+}
+
+void	define_PortalService()
+{
+    cPortalService = rb_define_class_under(mCFrida, "PortalService", cGObject);
+
+    rb_define_method(cPortalService, "initialize", PortalService_initialize, -1);
+    rb_define_method(cPortalService, "device", PortalService_device, 0);
+
+    rb_define_method(cPortalService, "start", PortalService_start, 0);
+    rb_define_method(cPortalService, "stop", PortalService_stop, 0);
+    rb_define_method(cPortalService, "kick", PortalService_kick, 1);
+    rb_define_method(cPortalService, "post", PortalService_post, -1);
+    rb_define_method(cPortalService, "narrowcast", PortalService_narrowcast, -1);
+    rb_define_method(cPortalService, "broadcast", PortalService_broadcast, -1);
+    rb_define_method(cPortalService, "enumerate_tags", PortalService_enumerate_tags, 1);
+    rb_define_method(cPortalService, "tag", PortalService_tag, 2);
+    rb_define_method(cPortalService, "untag", PortalService_untag, 2);
+}