dbus 0.1.5

data/ext/ruby-dbus-common.c

@@ -0,0 +1,105 @@
+/*--------------------------------------------------
+ * D-BUS bindings for Ruby
+ * (C) Copyright 2004 Leon Breedt
+ * (C) Copyright 2004 Provenco Group Ltd
+ *
+ * Licensed under the same terms as the D-BUS library
+ *--------------------------------------------------*/
+
+#include "ruby-dbus.h"
+
+VALUE mDBus;
+VALUE mDBusBinding;
+VALUE eDBusError;
+
+/*
+ *  call-seq:
+ *      new => self
+ *  
+ *  The new method of this class is not available for invocation.
+ */
+VALUE
+rdbus_private_method(VALUE klass)
+{
+  rb_raise(rb_eNoMethodError, "Method is unavailable to non-native methods");
+  return Qnil;
+}
+
+/*
+ *  Initializes Glib GThreads for usage by D-BUS. 
+ *
+ *  This is only necessary for applications that will be using GThreads.
+ */
+static VALUE
+mDBusBinding_init_gthreads(VALUE klass)
+{
+  dbus_g_thread_init();
+  return Qnil;
+}
+
+/*
+ *  The DBus module contains all the classes and modules related to the D-BUS
+ *  bindings.
+ *
+ *  Some global D-BUS constants from dbus-shared.h[http://www.freedesktop.org/software/dbus/doc/api/html/dbus-shared_8h-source.html]
+ *  and dbus-protocol.h[http://www.freedesktop.org/software/dbus/doc/api/html/dbus-protocol_8h-source.html] are also defined in this
+ *  module.
+ *
+ *  It is recommended that you use the classes in the DBus module instead of
+ *  the classes in the DBus::Binding module unless you have more advanced
+ *  needs.
+ *
+ *  The DBus::Binding module classes map directly to the D-BUS C API.
+ */
+void
+Init_dbus()
+{
+  mDBus = rb_define_module("DBus");
+  mDBusBinding = rb_define_module_under(mDBus, "Binding");
+  eDBusError = rb_define_class_under(mDBus, "DBusError", rb_eStandardError);
+
+  rb_define_const(mDBus, "BUS_SESSION",    INT2FIX(DBUS_BUS_SESSION));
+  rb_define_const(mDBus, "BUS_SYSTEM",     INT2FIX(DBUS_BUS_SYSTEM));
+  rb_define_const(mDBus, "BUS_ACTIVATION", INT2FIX(DBUS_BUS_ACTIVATION));
+
+  rb_define_const(mDBus, "DISPATCH_DATA_REMAINS", INT2FIX(DBUS_DISPATCH_DATA_REMAINS));
+  rb_define_const(mDBus, "DISPATCH_COMPLETE",     INT2FIX(DBUS_DISPATCH_COMPLETE));
+  rb_define_const(mDBus, "DISPATCH_NEED_MEMORY",  INT2FIX(DBUS_DISPATCH_NEED_MEMORY));
+
+  rb_define_const(mDBus, "SERVICE_FLAG_PROHIBIT_REPLACEMENT", INT2FIX(DBUS_SERVICE_FLAG_PROHIBIT_REPLACEMENT));
+  rb_define_const(mDBus, "SERVICE_FLAG_REPLACE_EXISTING",     INT2FIX(DBUS_SERVICE_FLAG_REPLACE_EXISTING));
+
+  rb_define_const(mDBus, "HANDLER_RESULT_HANDLED",         INT2FIX(DBUS_HANDLER_RESULT_HANDLED));
+  rb_define_const(mDBus, "HANDLER_RESULT_NOT_YET_HANDLED", INT2FIX(DBUS_HANDLER_RESULT_NOT_YET_HANDLED));
+  rb_define_const(mDBus, "HANDLER_RESULT_NEED_MEMORY",     INT2FIX(DBUS_HANDLER_RESULT_NEED_MEMORY));
+
+  rb_define_const(mDBus, "MESSAGE_TYPE_INVALID",       INT2FIX(DBUS_MESSAGE_TYPE_INVALID));
+  rb_define_const(mDBus, "MESSAGE_TYPE_METHOD_CALL",   INT2FIX(DBUS_MESSAGE_TYPE_METHOD_CALL));
+  rb_define_const(mDBus, "MESSAGE_TYPE_METHOD_RETURN", INT2FIX(DBUS_MESSAGE_TYPE_METHOD_RETURN));
+  rb_define_const(mDBus, "MESSAGE_TYPE_ERROR",         INT2FIX(DBUS_MESSAGE_TYPE_ERROR));
+  rb_define_const(mDBus, "MESSAGE_TYPE_SIGNAL",        INT2FIX(DBUS_MESSAGE_TYPE_SIGNAL));
+
+  rb_define_const(mDBus, "TYPE_INVALID",     INT2FIX(DBUS_TYPE_INVALID));
+  rb_define_const(mDBus, "TYPE_NIL",         INT2FIX(DBUS_TYPE_NIL));
+  rb_define_const(mDBus, "TYPE_BYTE",        INT2FIX(DBUS_TYPE_BYTE));
+  rb_define_const(mDBus, "TYPE_BOOLEAN",     INT2FIX(DBUS_TYPE_BOOLEAN));
+  rb_define_const(mDBus, "TYPE_INT32",       INT2FIX(DBUS_TYPE_INT32));
+  rb_define_const(mDBus, "TYPE_UINT32",      INT2FIX(DBUS_TYPE_UINT32));
+  rb_define_const(mDBus, "TYPE_INT64",       INT2FIX(DBUS_TYPE_INT64));
+  rb_define_const(mDBus, "TYPE_UINT64",      INT2FIX(DBUS_TYPE_UINT64));
+  rb_define_const(mDBus, "TYPE_DOUBLE",      INT2FIX(DBUS_TYPE_DOUBLE));
+  rb_define_const(mDBus, "TYPE_STRING",      INT2FIX(DBUS_TYPE_STRING));
+  rb_define_const(mDBus, "TYPE_CUSTOM",      INT2FIX(DBUS_TYPE_CUSTOM));
+  rb_define_const(mDBus, "TYPE_ARRAY",       INT2FIX(DBUS_TYPE_ARRAY));
+  rb_define_const(mDBus, "TYPE_DICT",        INT2FIX(DBUS_TYPE_DICT));
+  rb_define_const(mDBus, "TYPE_OBJECT_PATH", INT2FIX(DBUS_TYPE_OBJECT_PATH));
+
+  rb_define_module_function(mDBusBinding, "init_gthreads", mDBusBinding_init_gthreads, 0);
+
+	Init_dbus_bus();
+  Init_dbus_connection();
+  Init_dbus_message();
+  Init_dbus_message_iter();
+  Init_dbus_pending_call();
+  Init_dbus_server();
+}

data/ext/ruby-dbus-connection.c

@@ -0,0 +1,704 @@
+/*--------------------------------------------------
+ * D-BUS bindings for Ruby
+ * (C) Copyright 2004 Leon Breedt
+ * (C) Copyright 2004 Provenco Group Ltd
+ *
+ * Licensed under the same terms as the D-BUS library
+ *--------------------------------------------------*/
+
+#include "ruby-dbus.h"
+
+static void _free_connection(DBusConnection *conn);
+
+VALUE cDBusConnection;
+
+RDBUS_GENERATE_NEW(cDBusConnection, DBusConnection *, _free_connection)
+RDBUS_GENERATE_GET(DBusConnection)
+
+/* Helpers */
+
+static void
+_free_connection(DBusConnection *conn)
+{
+  dbus_connection_disconnect(conn);
+  dbus_connection_unref(conn);
+}
+
+/*
+ *  call-seq:
+ *      new(address) => connection
+ *
+ *  Opens a connection to the D-BUS daemon located at the given +address+.
+ *  An address is a string in the format <tt>type:param1=value1,param2=value2</tt>.
+ *  DBusServer#get_address returns an address in this format.
+ *
+ *  Example:
+ *      unix:abstract=/tmp/dbus-X0XXgcf
+ *
+ *  Returns a DBusConnection instance.
+ */
+static VALUE
+cDBusConnection_open(VALUE klass, VALUE address)
+{
+  DBusConnection *conn;
+
+  conn = NULL;
+  RDBUS_TRY(conn = dbus_connection_open(StringValuePtr(address), &error));
+  RDBUS_RAISE_IF(conn == NULL, "failed to open D-BUS connection");
+  return RDBUS_NEW(cDBusConnection, conn);
+}
+
+/*
+ *  call-seq:
+ *      get_base_service => name
+ *
+ *  Gets the base service name of the connection. This value can be used 
+ *  for the +destination+ field of a DBusMessage.
+ */
+static VALUE
+cDBusConnection_get_base_service(VALUE self)
+{
+  return rb_str_new2(dbus_bus_get_base_service(CONN_GET(self)));
+}
+
+/*
+ *  call-seq:
+ *      setup_with_g_main => nil
+ *
+ *  Sets up the watch and timeout functionality of the connection to
+ *  integrate with the GLIB main loop.
+ */
+static VALUE
+cDBusConnection_setup_with_g_main(VALUE self)
+{
+  dbus_connection_setup_with_g_main(CONN_GET(self), NULL);
+  return Qnil;
+}
+
+/*
+ *  call-seq:
+ *      disconnect => nil
+ *
+ *  Disconnects this connection from the bus
+ */
+static VALUE
+cDBusConnection_disconnect(VALUE self)
+{
+  dbus_connection_disconnect(CONN_GET(self));
+  return Qnil;
+}
+
+/*
+ *  call-seq:
+ *      get_is_connected => true | false
+ *
+ *  Returns +true+ if this connection is connected to the bus
+ */
+static VALUE
+cDBusConnection_get_is_connected(VALUE self)
+{
+  if (dbus_connection_get_is_connected(CONN_GET(self)))
+    return Qtrue;
+  return Qfalse;
+}
+
+/*
+ *  call-seq:
+ *      get_is_authenticated => true | false
+ *
+ *  Returns +true+ if this connection was authenticated
+ */
+static VALUE
+cDBusConnection_get_is_authenticated(VALUE self)
+{
+  if (dbus_connection_get_is_authenticated(CONN_GET(self)))
+    return Qtrue;
+  return Qfalse;
+}
+
+/*
+ *  call-seq:
+ *      flush => nil
+ *
+ *  Blocks until the outgoing message queue is empty
+ */
+static VALUE
+cDBusConnection_flush(VALUE self)
+{
+  dbus_connection_flush(CONN_GET(self));
+  return Qnil;
+}
+
+/*
+ *  call-seq:
+ *      borrow_message => message
+ *
+ *  Returns the first message from the incoming message queue, while
+ *  leaving it in the queue. While borrowed, nothing else can get at
+ *  the message, so the message <i>has</i> to be returned with
+ *  DBusConnection#return_message or stolen with DBusConnection#steal_borrowed_message.
+ *
+ *  It is not recommended that you use this method, use the standard
+ *  dispatching mechanisms instead.
+ */
+static VALUE
+cDBusConnection_borrow_message(VALUE self)
+{
+  DBusMessage *message;
+
+  message = NULL;
+  message = dbus_connection_borrow_message(CONN_GET(self));
+  if (message == NULL)
+    return Qnil;
+  return RDBUS_NEW(cDBusMessage, message);
+}
+
+/*
+ *  call-seq:
+ *      return_message(message) => nil
+ *
+ *  Returns a previously borrowed message to the queue
+ *
+ *  It is not recommended that you use this method, use the standard
+ *  dispatching mechanisms instead.
+ */
+static VALUE
+cDBusConnection_return_message(VALUE self, VALUE message)
+{
+  dbus_connection_return_message(
+    CONN_GET(self),
+    RDBUS_GET(DBusMessage, message)
+  );
+  return Qnil;
+}
+
+/*
+ *  call-seq:
+ *      steal_borrowed_message(message) => nil
+ *
+ *  Steals a previously borrowed message (in other words, take ownership
+ *  of it and remove it from the queue).
+ *
+ *  It is not recommended that you use this method, use the standard
+ *  dispatching mechanisms instead.
+ */
+static VALUE
+cDBusConnection_steal_borrowed_message(VALUE self, VALUE message)
+{
+  dbus_connection_steal_borrowed_message(
+    CONN_GET(self),
+    RDBUS_GET(DBusMessage, message)
+  );
+  return Qnil;
+}
+
+/*
+ *  call-seq:
+ *      pop_message => message
+ *
+ *  Pops the first message from the incoming message queue, removing it
+ *  from the queue.
+ *
+ *  It is not recommended that you use this method, use the standard
+ *  dispatching mechanisms instead.
+ */
+static VALUE
+cDBusConnection_pop_message(VALUE self)
+{
+  DBusMessage *message;
+
+  message = NULL;
+  message = dbus_connection_pop_message(CONN_GET(self));
+  if (message == NULL)
+    return Qnil;
+  return RDBUS_NEW(cDBusMessage, message);
+}
+
+/*
+ *  call-seq:
+ *      get_dispatch_status => status
+ *
+ *  Returns the current status that would have been returned by
+ *  DBusConnection#dispatch, without performing any message dispatching.
+ */
+static VALUE
+cDBusConnection_get_dispatch_status(VALUE self)
+{
+  return INT2FIX(dbus_connection_get_dispatch_status(CONN_GET(self)));
+}
+
+/*
+ *  call-seq:
+ *      dispatch => status
+ *
+ *  Processes buffered data, handles watches and queues zero or more
+ *  incoming messages. Pops the first message on the incoming queue,
+ *  processes it by calling into its handlers, and then unrefs it.
+ *
+ *  Returns a status indicating whether more messages are available for
+ *  dispatching, more memory is needed, or all data has been processed.
+ *
+ *  It is not recommended that you use this directly, instead use the
+ *  wrapper APIs in DBus::Object, DBus::ObjectTree or DBus::Service and
+ *  integrate them with your mainloop.
+ */
+static VALUE
+cDBusConnection_dispatch(VALUE self)
+{
+  return INT2FIX(dbus_connection_dispatch(CONN_GET(self)));
+}
+
+/*
+ *  call-seq:
+ *      send(message) => true | false
+ *
+ *  Enqueues the given message for sending on the outgoing queue. Sending
+ *  happens asynchronously unless you force the issue by calling DBusConnection#flush.
+ *
+ *  Returns +false+ if the message could not be enqueued due to lack of
+ *  memory, +true+ otherwise.
+ */
+static VALUE
+cDBusConnection_send(VALUE self, VALUE message)
+{
+  if (dbus_connection_send(CONN_GET(self), RDBUS_GET(DBusMessage, message), NULL))
+    return Qtrue;
+  return Qfalse;
+}
+
+/*
+ *  call-seq:
+ *      send_with_reply(message, timeout_milliseconds) => [true|false, DBusPendingCall|nil]
+ *
+ *  Enqueues the given message for sending on the outgoing queue. The timeout
+ *  specified can also be <tt>-1</tt>, in which case a sane default value is
+ *  used.
+ *
+ *  If successfully queued, a <tt>[true, DBusPendingCall]</tt> tuple is returned.
+ *  Otherwise, a <tt>[false, nil]</tt> tuple is returned.
+ *
+ *  This method returns immediately.
+ */
+static VALUE
+cDBusConnection_send_with_reply(VALUE self, VALUE msg, VALUE timeout)
+{
+  VALUE ary;
+  VALUE ret;
+  DBusPendingCall *call;
+
+  ary = Qnil;
+  ret = Qfalse;
+  call = NULL;
+  if (dbus_connection_send_with_reply(CONN_GET(self), MSG_GET(msg), &call,
+                                      NUM2INT(timeout)))
+    ret = Qtrue;
+  ary = rb_ary_new2(2);
+  rb_ary_push(ary, ret);
+  if (call != NULL)
+    rb_ary_push(ary, RDBUS_NEW(cDBusPendingCall, call));
+  else
+    rb_ary_push(ary, Qnil);
+  return ary;
+}
+
+/*
+ *  call-seq:
+ *      send_with_reply_and_block(message, timeout_milliseconds) => message
+ *
+ *  Enqueues the given message for sending on the outgoing queue, and blocks
+ *  for the given timeout until a reply is received, or the timeout expires,
+ *  whichever comes first.
+ */
+static VALUE
+cDBusConnection_send_with_reply_and_block(VALUE self, VALUE msg, VALUE timeout)
+{
+  DBusMessage *return_msg;
+
+  return_msg = NULL;
+  RDBUS_TRY(
+    return_msg = dbus_connection_send_with_reply_and_block(
+      CONN_GET(self), MSG_GET(msg), NUM2INT(timeout), &error)
+  )
+  if (return_msg == NULL)
+    return Qnil;
+  return RDBUS_NEW(cDBusMessage, return_msg);
+}
+
+/*
+ *  call-seq:
+ *      get_max_message_size => size
+ *
+ *  Returns the maximum message size in bytes that this connection may
+ *  receive
+ */
+static VALUE
+cDBusConnection_get_max_message_size(VALUE self)
+{
+  return LONG2NUM(dbus_connection_get_max_message_size(CONN_GET(self)));
+}
+
+/*
+ *  call-seq:
+ *      set_max_message_size(value) => nil
+ *
+ *  Sets the maximum message size in bytes that this connection may
+ *  receive
+ */
+static VALUE
+cDBusConnection_set_max_message_size(VALUE self, VALUE size)
+{
+  dbus_connection_set_max_message_size(CONN_GET(self), NUM2LONG(size));
+  return Qnil;
+}
+
+/*
+ *  call-seq:
+ *      get_max_received_size => size
+ *
+ *  Returns the maximum number of bytes for all messages received on this
+ *  connection, see DBusConnection#set_max_received_size for more details. 
+ */
+static VALUE
+cDBusConnection_get_max_received_size(VALUE self)
+{
+  return LONG2NUM(dbus_connection_get_max_received_size(CONN_GET(self)));
+}
+
+
+/*
+ *  call-seq:
+ *      set_max_received_size(size) => nil
+ *
+ *  Sets the maximum number of bytes for all messages received on this
+ *  connection. Messages count toward the maximum until they are garbage
+ *  collected. When the maximum is reached, the connection will not read
+ *  more data until some messages are garbage collected.
+ */
+static VALUE
+cDBusConnection_set_max_received_size(VALUE self, VALUE size)
+{
+  dbus_connection_set_max_received_size(CONN_GET(self), NUM2LONG(size));
+  return Qnil;
+}
+
+/*
+ *  call-seq:
+ *      get_outgoing_size => size
+ *
+ *  Returns the approximate size in bytes of all messages in the outgoing
+ *  message queue.
+ */
+static VALUE
+cDBusConnection_get_outgoing_size(VALUE self)
+{
+  return LONG2NUM(dbus_connection_get_outgoing_size(CONN_GET(self)));
+}
+
+static VALUE
+_real_call_unregister_cb(VALUE args)
+{
+  VALUE *argp = (VALUE*)args;
+  VALUE unregister_cb = argp[0];
+  return rb_funcall2(unregister_cb, rb_intern("call"), 1, argp+1);
+}
+
+static void
+_on_object_path_unregister(DBusConnection *conn, void *user_data)
+{
+  VALUE *data;
+  VALUE unregister_cb;
+  VALUE message_cb;
+  VALUE args[2];
+  int exc;
+
+  data = (VALUE *)user_data;
+  unregister_cb = data[0];
+  message_cb = data[1];
+  args[0] = unregister_cb;
+  args[1] = RDBUS_NEW(cDBusConnection, conn);
+
+  exc = 0;
+  rb_protect(_real_call_unregister_cb, (VALUE)args, &exc);
+
+  if (exc)
+    rb_warn("Unregister callback raised exception (ignored)");
+  rb_gc_unregister_address(&unregister_cb);
+  rb_gc_unregister_address(&message_cb);
+  ruby_xfree(data);
+}
+
+static VALUE
+_real_call_message_cb(VALUE args)
+{
+  VALUE *argp = (VALUE*)args;
+  VALUE message_cb = argp[0];
+  return rb_funcall2(message_cb, rb_intern("call"), 2, argp+1);
+}
+
+static DBusHandlerResult
+_on_object_path_message(DBusConnection *conn, DBusMessage *msg, void *user_data)
+{
+  VALUE *data;
+  VALUE message_cb;
+  VALUE ret;
+  VALUE args[3];
+  int exc;
+
+  data = (VALUE *)user_data;
+  message_cb = data[1];
+  args[0] = message_cb;
+  args[1] = RDBUS_NEW(cDBusConnection, conn);
+  args[2] = RDBUS_NEW(cDBusMessage, msg);
+
+  exc = 0;
+  ret = rb_protect(_real_call_message_cb, (VALUE)args, &exc);
+
+  if (exc)
+    rb_warn("Message callback raised exception (ignored)");
+  if (ret == Qnil)
+    return DBUS_HANDLER_RESULT_HANDLED;
+  return NUM2INT(ret);
+}
+
+/*
+ *  call-seq:
+ *      register_object_path(path, unregister_proc, message_proc)
+ *
+ *  Registers a handler for the given path in the object hierarchy.
+ *
+ *  The +unregister_proc+ block will be called when the object path is being
+ *  unregistered with a +connection+ argument.
+ *  
+ *  The +message_proc+ block will be called for messages sent to the exact
+ *  path specified, with the arguments +connection, message+.
+ *
+ *  = Any exceptions thrown by your blocks will be silently ignored to ensure
+ *    D-BUS integrity, so keep the handler blocks simple
+ */
+static VALUE
+cDBusConnection_register_object_path(VALUE self, VALUE path,
+                                     VALUE unregister_cb, VALUE message_cb)
+{
+  DBusObjectPathVTable vtable;
+  VALUE *user_data;
+
+  vtable.unregister_function = _on_object_path_unregister;
+  vtable.message_function = _on_object_path_message;
+
+  user_data = ALLOC_N(VALUE, 2);
+  user_data[0] = unregister_cb;
+  user_data[1] = message_cb;
+
+  if (dbus_connection_register_object_path(CONN_GET(self), StringValuePtr(path),
+                                           &vtable, (void *)user_data))
+  {
+    rb_gc_register_address(&unregister_cb);
+    rb_gc_register_address(&message_cb);
+    return Qtrue;
+  }
+  ruby_xfree(user_data);
+  return Qfalse;
+}
+
+/*
+ *  call-seq:
+ *      register_fallback(path, unregister_proc, message_proc)
+ *
+ *  Registers a fallback handler for a section of the object hierarchy.
+ *
+ *  The +unregister_proc+ block will be called when the object path is being
+ *  unregistered with a +connection+ argument.
+ *
+ *  The +message_proc+ block will be called for messages at or below the
+ *  given object path, with the arguments +connection, message+.
+ *
+ *  = Any exceptions thrown by your blocks will be silently ignored to ensure
+ *    D-BUS integrity, so keep the handler blocks simple
+ */
+static VALUE
+cDBusConnection_register_fallback(VALUE self, VALUE path,
+                                  VALUE unregister_cb, VALUE message_cb)
+{
+  DBusObjectPathVTable vtable;
+  VALUE *user_data;
+
+  vtable.unregister_function = _on_object_path_unregister;
+  vtable.message_function = _on_object_path_message;
+
+  user_data = ALLOC_N(VALUE, 2);
+  user_data[0] = unregister_cb;
+  user_data[1] = message_cb;
+  if (dbus_connection_register_fallback(CONN_GET(self), StringValuePtr(path),
+                                        &vtable, (void *)user_data))
+  {
+    rb_gc_register_address(&unregister_cb);
+    rb_gc_register_address(&message_cb);
+    return Qtrue;
+  }
+  ruby_xfree(user_data);
+  return Qfalse;
+}
+
+static void
+_free_filter_data(void *user_data)
+{
+  VALUE *data = (VALUE*)user_data;
+  VALUE filter_cb = data[0];
+  rb_gc_unregister_address(&filter_cb);
+  ruby_xfree(data);
+}
+
+static VALUE
+_real_call_filter_cb(VALUE args)
+{
+  VALUE *argp = (VALUE*)args;
+  VALUE filter_cb = argp[0];
+  return rb_funcall2(filter_cb, rb_intern("call"), 2, argp+1);
+}
+
+static DBusHandlerResult
+_on_filter_message(DBusConnection *conn, DBusMessage *msg, void *user_data)
+{
+  VALUE *data;
+  VALUE filter_cb;
+  VALUE ret;
+  VALUE args[3];
+  int exc;
+
+  data = (VALUE*)user_data;
+  filter_cb = data[0];
+  args[0] = filter_cb;
+  args[1] = RDBUS_NEW(cDBusConnection, conn);
+  args[2] = RDBUS_NEW(cDBusMessage, msg);
+
+  exc = 0;
+  ret = rb_protect(_real_call_filter_cb, (VALUE)args, &exc);
+
+  if (exc)
+    rb_warn("Filter callback raised exception (ignored)");
+  if (ret == Qnil)
+    return DBUS_HANDLER_RESULT_HANDLED;
+  return NUM2INT(ret);
+}
+
+/*
+ *  call-seq:
+ *      add_filter(filter_proc) => true | false
+ *
+ *  Adds a message filter on this connection.
+ *
+ *  The +filter_proc+ block will be called for all incoming messages,
+ *  before any handlers registered using DBusConnection#register_object_path
+ *  or DBusConnection#register_fallback.
+ *
+ *  The same filter block can be added more than once, in which case it
+ *  will be called more than once.
+ *
+ *  Returns +true+ if the filter was added, +false+ if there was not enough
+ *  memory.
+ */
+static VALUE
+cDBusConnection_add_filter(VALUE self, VALUE filter_cb)
+{
+  VALUE *data;
+
+  data = ALLOC_N(VALUE, 1);
+  data[0] = filter_cb;
+  if (dbus_connection_add_filter(CONN_GET(self), _on_filter_message,
+                                 (void*)data, _free_filter_data))
+  {
+    rb_gc_register_address(&filter_cb);
+    return Qtrue;
+  }
+  ruby_xfree(data);
+  return Qfalse;
+}
+
+/*
+ *  call-seq:
+ *      list_registered(parent_path) => array
+ *
+ *  Returns a list of registered object path and fallback handlers for
+ *  the given parent path.
+ */
+static VALUE
+cDBusConnection_list_registered(VALUE self, VALUE parent_path)
+{
+  char **entries;
+  VALUE ret;
+
+  ret = rb_ary_new();
+  entries = NULL;
+  if (dbus_connection_list_registered(CONN_GET(self),
+      StringValuePtr(parent_path), &entries) && entries != NULL)
+  {
+    int i = 0;
+    while (entries[i] != NULL)
+      rb_ary_push(ret, rb_str_new2(entries[i++]));
+    dbus_free_string_array(entries);
+  }
+  return ret;
+}
+
+/*
+ *  Document-module: DBus::Binding
+ *
+ *  The DBus::Binding module contains the internal binding classes that
+ *  map directly to the D-BUS C API.
+ */
+
+/*
+ *  Document-class: DBus::Binding::DBusConnection
+ *
+ *  DBusConnection implements a connection to a D-BUS daemon.  D-BUS messages
+ *  are sent and received using this connection.
+ *
+ *  The recommended way of obtaining a DBusConnection instance for normal
+ *  usage is to use DBus::Binding#bus_get to obtain a connection to one of the
+ *  well-known message buses.
+ *
+ *  Messages are sent and received when the DBusConnection#dispatch method is
+ *  called, however, the recommended way to use this is to integrate into an
+ *  existing main loop such as that of GLib by using DBusConnection#setup_with_g_main, 
+ *  as this hides all the low level internals of dispatching and watch/timeout
+ *  monitoring from you.
+ */
+void
+Init_dbus_connection()
+{
+  cDBusConnection = rb_define_class_under(mDBusBinding, "DBusConnection", rb_cObject);
+
+  rb_define_singleton_method(cDBusConnection, "open", cDBusConnection_open, 1);
+  rb_define_singleton_method(cDBusConnection, "new", cDBusConnection_open, 1);
+
+  rb_define_method(cDBusConnection, "get_base_service", cDBusConnection_get_base_service, 0);
+  rb_define_method(cDBusConnection, "setup_with_g_main", cDBusConnection_setup_with_g_main, 0);
+  rb_define_method(cDBusConnection, "disconnect", cDBusConnection_disconnect, 0);
+  rb_define_method(cDBusConnection, "get_is_connected", cDBusConnection_get_is_connected, 0);
+  rb_define_method(cDBusConnection, "get_is_authenticated", cDBusConnection_get_is_authenticated, 0);
+  rb_define_method(cDBusConnection, "flush", cDBusConnection_flush, 0);
+
+  rb_define_method(cDBusConnection, "borrow_message", cDBusConnection_borrow_message, 0);
+  rb_define_method(cDBusConnection, "return_message", cDBusConnection_return_message, 1);
+  rb_define_method(cDBusConnection, "steal_borrowed_message", cDBusConnection_steal_borrowed_message, 1);
+  rb_define_method(cDBusConnection, "pop_message", cDBusConnection_pop_message, 0);
+
+  rb_define_method(cDBusConnection, "get_dispatch_status", cDBusConnection_get_dispatch_status, 0);
+  rb_define_method(cDBusConnection, "dispatch", cDBusConnection_dispatch, 0);
+
+  rb_define_method(cDBusConnection, "send", cDBusConnection_send, 1);
+  rb_define_method(cDBusConnection, "send_with_reply", cDBusConnection_send_with_reply, 2);
+  rb_define_method(cDBusConnection, "send_with_reply_and_block", cDBusConnection_send_with_reply_and_block, 2);
+
+  rb_define_method(cDBusConnection, "add_filter", cDBusConnection_add_filter, 1);
+
+  rb_define_method(cDBusConnection, "get_max_message_size", cDBusConnection_get_max_message_size, 0);
+  rb_define_method(cDBusConnection, "set_max_message_size", cDBusConnection_set_max_message_size, 1);
+  rb_define_method(cDBusConnection, "get_max_received_size", cDBusConnection_get_max_received_size, 0);
+  rb_define_method(cDBusConnection, "set_max_received_size", cDBusConnection_set_max_received_size, 1);
+  rb_define_method(cDBusConnection, "get_outgoing_size", cDBusConnection_get_outgoing_size, 0);
+
+  rb_define_method(cDBusConnection, "register_object_path", cDBusConnection_register_object_path, 3);
+  rb_define_method(cDBusConnection, "register_fallback", cDBusConnection_register_fallback, 3);
+  rb_define_method(cDBusConnection, "list_registered", cDBusConnection_list_registered, 1);
+}