dbus 0.1.5 → 0.1.7

data/ext/extconf.rb

@@ -8,6 +8,7 @@ end
 PKGConfig.have_package('dbus-1')
 PKGConfig.have_package('dbus-glib-1')
 PKGConfig.have_package('glib-2.0')
+PKGConfig.have_package('gthread-2.0')
 
 %w[dbus_connection_setup_with_g_main dbus_server_setup_with_g_main dbus_bus_get].each do |f|
   unless have_func(f)
@@ -16,4 +17,10 @@ PKGConfig.have_package('glib-2.0')
   end
 end
 
+debug = ARGV.shift
+if debug == "--debug"
+  $CPPFLAGS << " -DRDBUS_DEBUG"
+  $CFLAGS << " -g"
+end
+
 create_makefile('dbus')

data/ext/ruby-dbus-bus.c

@@ -40,7 +40,7 @@ mDBusBinding_bus_get(int argc, VALUE *argv)
   conn = NULL;
   RDBUS_TRY(conn = dbus_bus_get(bus_type, &error));
   RDBUS_RAISE_IF(conn == NULL, "failed to open D-BUS connection");
-  return RDBUS_NEW(cDBusConnection, conn);
+  return CONN_NEW(conn);
 }
 
 /*

data/ext/ruby-dbus-connection.c

@@ -8,22 +8,38 @@
 
 #include "ruby-dbus.h"
 
-static void _free_connection(DBusConnection *conn);
-
 VALUE cDBusConnection;
 
-RDBUS_GENERATE_NEW(cDBusConnection, DBusConnection *, _free_connection)
-RDBUS_GENERATE_GET(DBusConnection)
+static void
+rdbus_free_connection(void *conn)
+{
+  DEBUG("DBusConnection.free <%p>", conn);
+  dbus_connection_unref((DBusConnection *)conn);
+}
 
-/* Helpers */
+VALUE 
+rdbus_new_connection(DBusConnection *conn, gboolean owner)
+{
+  if (!owner)
+    dbus_connection_ref(conn);
+  DEBUG("DBusConnection.new <%p> owner=%d", conn, owner);
+  return Data_Wrap_Struct(cDBusConnection, NULL, rdbus_free_connection, conn);
+}
 
-static void
-_free_connection(DBusConnection *conn)
+DBusConnection *
+rdbus_get_connection(VALUE obj)
 {
-  dbus_connection_disconnect(conn);
-  dbus_connection_unref(conn);
+  DBusConnection *conn;
+
+  conn = NULL;
+  Data_Get_Struct(obj, DBusConnection, conn);
+  if (conn == NULL)
+    rb_raise(eDBusError, "Failed to retrieve DATA object for DBusConnection");
+  return conn;
 }
 
+/* Helpers */
+
 /*
  *  call-seq:
  *      new(address) => connection
@@ -45,7 +61,7 @@ cDBusConnection_open(VALUE klass, VALUE address)
   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);
+  return CONN_NEW_TAKE_OWNERSHIP(conn);
 }
 
 /*
@@ -150,7 +166,7 @@ cDBusConnection_borrow_message(VALUE self)
   message = dbus_connection_borrow_message(CONN_GET(self));
   if (message == NULL)
     return Qnil;
-  return RDBUS_NEW(cDBusMessage, message);
+  return MSG_NEW(message);
 }
 
 /*
@@ -167,7 +183,7 @@ cDBusConnection_return_message(VALUE self, VALUE message)
 {
   dbus_connection_return_message(
     CONN_GET(self),
-    RDBUS_GET(DBusMessage, message)
+    MSG_GET(message)
   );
   return Qnil;
 }
@@ -187,7 +203,7 @@ cDBusConnection_steal_borrowed_message(VALUE self, VALUE message)
 {
   dbus_connection_steal_borrowed_message(
     CONN_GET(self),
-    RDBUS_GET(DBusMessage, message)
+    MSG_GET(message)
   );
   return Qnil;
 }
@@ -211,7 +227,7 @@ cDBusConnection_pop_message(VALUE self)
   message = dbus_connection_pop_message(CONN_GET(self));
   if (message == NULL)
     return Qnil;
-  return RDBUS_NEW(cDBusMessage, message);
+  return MSG_NEW(message);
 }
 
 /*
@@ -261,7 +277,7 @@ cDBusConnection_dispatch(VALUE self)
 static VALUE
 cDBusConnection_send(VALUE self, VALUE message)
 {
-  if (dbus_connection_send(CONN_GET(self), RDBUS_GET(DBusMessage, message), NULL))
+  if (dbus_connection_send(CONN_GET(self), MSG_GET(message), NULL))
     return Qtrue;
   return Qfalse;
 }
@@ -294,10 +310,11 @@ cDBusConnection_send_with_reply(VALUE self, VALUE msg, VALUE 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
+  if (call != NULL) {
+    rb_ary_push(ary, CALL_NEW(call));
+  } else {
     rb_ary_push(ary, Qnil);
+  }
   return ary;
 }
 
@@ -321,7 +338,7 @@ cDBusConnection_send_with_reply_and_block(VALUE self, VALUE msg, VALUE timeout)
   )
   if (return_msg == NULL)
     return Qnil;
-  return RDBUS_NEW(cDBusMessage, return_msg);
+  return MSG_NEW(return_msg);
 }
 
 /*
@@ -397,9 +414,9 @@ cDBusConnection_get_outgoing_size(VALUE 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);
+  VALUE *argv = (VALUE*)args;
+  VALUE unregister_cb = argv[0];
+  return rb_funcall(unregister_cb, rb_intern("call"), 1, argv[1]);
 }
 
 static void
@@ -415,24 +432,26 @@ _on_object_path_unregister(DBusConnection *conn, void *user_data)
   unregister_cb = data[0];
   message_cb = data[1];
   args[0] = unregister_cb;
-  args[1] = RDBUS_NEW(cDBusConnection, conn);
+  args[1] = CONN_NEW(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);
+  VALUE *argv = (VALUE*)args;
+  VALUE message_cb = argv[0];
+  return rb_funcall(message_cb, rb_intern("call"), 2, argv[1], argv[2]);
 }
 
 static DBusHandlerResult
@@ -443,21 +462,24 @@ _on_object_path_message(DBusConnection *conn, DBusMessage *msg, void *user_data)
   VALUE ret;
   VALUE args[3];
   int exc;
+  DBusHandlerResult result;
 
   data = (VALUE *)user_data;
   message_cb = data[1];
   args[0] = message_cb;
-  args[1] = RDBUS_NEW(cDBusConnection, conn);
-  args[2] = RDBUS_NEW(cDBusMessage, msg);
+  args[1] = CONN_NEW(conn);
+  args[2] = MSG_NEW(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);
+    result = DBUS_HANDLER_RESULT_HANDLED;
+  result = NUM2INT(ret);
+  return result;
 }
 
 /*
@@ -482,6 +504,9 @@ cDBusConnection_register_object_path(VALUE self, VALUE path,
   DBusObjectPathVTable vtable;
   VALUE *user_data;
 
+  if (NIL_P(unregister_cb) || NIL_P(message_cb))
+    rb_raise(eDBusError, "Both unregister and message callbacks have to be supplied");
+
   vtable.unregister_function = _on_object_path_unregister;
   vtable.message_function = _on_object_path_message;
 
@@ -496,6 +521,7 @@ cDBusConnection_register_object_path(VALUE self, VALUE path,
     rb_gc_register_address(&message_cb);
     return Qtrue;
   }
+
   ruby_xfree(user_data);
   return Qfalse;
 }
@@ -522,12 +548,16 @@ cDBusConnection_register_fallback(VALUE self, VALUE path,
   DBusObjectPathVTable vtable;
   VALUE *user_data;
 
+  if (NIL_P(unregister_cb) || NIL_P(message_cb))
+    rb_raise(eDBusError, "Both unregister and message callbacks have to be supplied");
+
   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))
   {
@@ -535,6 +565,7 @@ cDBusConnection_register_fallback(VALUE self, VALUE path,
     rb_gc_register_address(&message_cb);
     return Qtrue;
   }
+
   ruby_xfree(user_data);
   return Qfalse;
 }
@@ -551,9 +582,9 @@ _free_filter_data(void *user_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);
+  VALUE *argv = (VALUE*)args;
+  VALUE filter_cb = argv[0];
+  return rb_funcall(filter_cb, rb_intern("call"), 2, argv[1], argv[2]);
 }
 
 static DBusHandlerResult
@@ -564,21 +595,24 @@ _on_filter_message(DBusConnection *conn, DBusMessage *msg, void *user_data)
   VALUE ret;
   VALUE args[3];
   int exc;
+  DBusHandlerResult result;
 
   data = (VALUE*)user_data;
   filter_cb = data[0];
   args[0] = filter_cb;
-  args[1] = RDBUS_NEW(cDBusConnection, conn);
-  args[2] = RDBUS_NEW(cDBusMessage, msg);
+  args[1] = CONN_NEW(conn);
+  args[2] = MSG_NEW(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);
+    result = DBUS_HANDLER_RESULT_HANDLED;
+  result = NUM2INT(ret);
+  return result;
 }
 
 /*
@@ -602,14 +636,19 @@ cDBusConnection_add_filter(VALUE self, VALUE filter_cb)
 {
   VALUE *data;
 
+  if (NIL_P(filter_cb))
+    rb_raise(eDBusError, "Callback must be supplied");
+
   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;
 }

data/ext/ruby-dbus-message-iter.c

@@ -18,12 +18,8 @@ struct _RubyDBusMessageIter {
 
 VALUE cDBusMessageIter;
 
-static void _free_message_iter(RubyDBusMessageIter *iter);
 static void _ensure_arg_type(DBusMessageIter *iter, int type);
 
-RDBUS_GENERATE_NEW(cDBusMessageIter, RubyDBusMessageIter *, _free_message_iter)
-RDBUS_GENERATE_GET(RubyDBusMessageIter)
-
 static RubyDBusMessageIter *
 _alloc_message_iter(DBusMessage *message, DBusMessageIter *real_iter)
 {
@@ -45,43 +41,70 @@ _alloc_message_iter(DBusMessage *message, DBusMessageIter *real_iter)
   }
 
   iter->message = message;
-  if (iter->message != NULL)
+  if (iter->message != NULL) {
     dbus_message_ref(iter->message);
+  }
 
   return iter;
 }
 
-RubyDBusMessageIter *
-rdbus_message_iter_new(DBusMessage *message, short is_append_iter)
+static void 
+_ensure_arg_type(DBusMessageIter *iter, int type)
 {
-  RubyDBusMessageIter *iter;
-
-  iter = _alloc_message_iter(message, NULL);
-  if (is_append_iter) {
-    dbus_message_append_iter_init(iter->message, iter->real_iter);
-  } else
-    dbus_message_iter_init(iter->message, iter->real_iter);
-  return iter;
+  if (dbus_message_iter_get_arg_type(iter) != type)
+    rb_raise(eDBusError, "argument type mismatch");
 }
 
 static void
-_free_message_iter(RubyDBusMessageIter *iter)
+rdbus_free_message_iter(void *iterp)
 {
-  if (iter->message != NULL)
+  RubyDBusMessageIter *iter = (RubyDBusMessageIter *)iterp;
+
+  if (iter->message != NULL) {
     dbus_message_unref(iter->message);
+  }
   ruby_xfree(iter->real_iter);
   iter->message = NULL;
   iter->real_iter = NULL;
   ruby_xfree(iter);
 }
 
-static void 
-_ensure_arg_type(DBusMessageIter *iter, int type)
+VALUE 
+rdbus_new_message_iter(DBusMessage *message, gboolean is_append)
 {
-  if (dbus_message_iter_get_arg_type(iter) != type)
-    rb_raise(eDBusError, "argument type mismatch");
+  RubyDBusMessageIter *iter;
+
+  iter = _alloc_message_iter(message, NULL);
+  if (is_append) {
+    dbus_message_append_iter_init(iter->message, iter->real_iter);
+  } else {
+    dbus_message_iter_init(iter->message, iter->real_iter);
+  }
+  return Data_Wrap_Struct(cDBusMessageIter, NULL, rdbus_free_message_iter, iter);
 }
 
+#define ITER_WRAPPER_GET(obj) \
+  rdbus_get_wrapping_message_iter(obj)
+
+RubyDBusMessageIter *
+rdbus_get_wrapping_message_iter(VALUE obj)
+{
+  RubyDBusMessageIter *iter;
+
+  iter = NULL;
+  Data_Get_Struct(obj, RubyDBusMessageIter, iter);
+  if (iter == NULL)
+    rb_raise(eDBusError, "Failed to retrieve DATA object for RubyDBusMessageIter");
+  return iter;
+}
+
+DBusMessageIter *
+rdbus_get_message_iter(VALUE obj)
+{
+  return rdbus_get_wrapping_message_iter(obj)->real_iter;
+}
+
+
 /*
  *  call-seq:
  *      has_next => true|false
@@ -300,11 +323,11 @@ cDBusMessageIter_array_iter_new(VALUE self)
   RubyDBusMessageIter *ary_iter = NULL;
   int array_type = DBUS_TYPE_INVALID;
 
-  self_iter = RDBUS_GET(RubyDBusMessageIter, self);
+  self_iter = ITER_WRAPPER_GET(self);
   _ensure_arg_type(self_iter->real_iter, DBUS_TYPE_ARRAY);
   ary_iter = _alloc_message_iter(self_iter->message, NULL);
   dbus_message_iter_init_array_iterator(self_iter->real_iter, ary_iter->real_iter, &array_type);
-  return RDBUS_NEW(cDBusMessageIter, ary_iter);
+  return Data_Wrap_Struct(cDBusMessageIter, NULL, rdbus_free_message_iter, ary_iter);
 }
 
 /*
@@ -322,11 +345,11 @@ cDBusMessageIter_dict_iter_new(VALUE self)
   RubyDBusMessageIter *self_iter = NULL;
   RubyDBusMessageIter *dict_iter = NULL;
 
-  self_iter = RDBUS_GET(RubyDBusMessageIter, self);
+  self_iter = ITER_WRAPPER_GET(self);
   _ensure_arg_type(self_iter->real_iter, DBUS_TYPE_DICT);
   dict_iter = _alloc_message_iter(self_iter->message, NULL);
   dbus_message_iter_init_dict_iterator(self_iter->real_iter, dict_iter->real_iter);
-  return RDBUS_NEW(cDBusMessageIter, dict_iter);
+  return Data_Wrap_Struct(cDBusMessageIter, NULL, rdbus_free_message_iter, dict_iter);
 }
 
 /*
@@ -560,11 +583,11 @@ cDBusMessageIter_append_array(VALUE self, VALUE type)
   RubyDBusMessageIter *parent = NULL;
   RubyDBusMessageIter *child = NULL;
 
-  parent = RDBUS_GET(RubyDBusMessageIter, self);
+  parent = ITER_WRAPPER_GET(self);
   child = _alloc_message_iter(parent->message, NULL);
   if (dbus_message_iter_append_array(parent->real_iter, child->real_iter, NUM2INT(type)))
-    return RDBUS_NEW(cDBusMessageIter, child);
-  _free_message_iter(child);
+    return Data_Wrap_Struct(cDBusMessageIter, NULL, rdbus_free_message_iter, child);
+  rdbus_free_message_iter(child);
   return Qnil;
 }
 
@@ -587,11 +610,11 @@ cDBusMessageIter_append_dict(VALUE self)
   RubyDBusMessageIter *parent = NULL;
   RubyDBusMessageIter *child = NULL;
 
-  parent = RDBUS_GET(RubyDBusMessageIter, self);
+  parent = ITER_WRAPPER_GET(self);
   child = _alloc_message_iter(parent->message, NULL);
   if (dbus_message_iter_append_dict(parent->real_iter, child->real_iter))
-    return RDBUS_NEW(cDBusMessageIter, child);
-  _free_message_iter(child);
+    return Data_Wrap_Struct(cDBusMessageIter, NULL, rdbus_free_message_iter, child);
+  rdbus_free_message_iter(child);
   return Qnil;
 }
 

data/ext/ruby-dbus-message.c

@@ -10,8 +10,60 @@
 
 VALUE cDBusMessage;
 
-RDBUS_GENERATE_NEW(cDBusMessage, DBusMessage *, dbus_message_unref)
-RDBUS_GENERATE_GET(DBusMessage)
+static const char *
+rdbus_message_type_string(DBusMessage *message)
+{
+  int type;
+
+  type = dbus_message_get_type(message);
+  switch (type) {
+    case DBUS_MESSAGE_TYPE_INVALID:
+      return "Invalid";
+    case DBUS_MESSAGE_TYPE_METHOD_CALL:
+      return "MethodCall";
+    case DBUS_MESSAGE_TYPE_METHOD_RETURN:
+      return "MethodReturn";
+    case DBUS_MESSAGE_TYPE_ERROR:
+      return "Error";
+    case DBUS_MESSAGE_TYPE_SIGNAL:
+      return "Signal";
+    default:
+      return "Unknown";
+  }
+}
+
+static void
+rdbus_free_message(void *message)
+{
+  DEBUG("DBusMessage.free <%p>", message);
+  dbus_message_unref((DBusMessage *)message);
+}
+
+VALUE
+rdbus_new_message(DBusMessage *message, gboolean owner)
+{
+#ifdef RDBUS_DEBUG
+  const char *path;
+  path = dbus_message_get_path(message);
+#endif
+
+  if (!owner)
+    dbus_message_ref(message);
+  DEBUG("DBusMessage.new <%p> owner=%d type=%s path=%s", message, owner, rdbus_message_type_string(message), path ? path : "<NULL>");
+  return Data_Wrap_Struct(cDBusMessage, NULL, rdbus_free_message, message);
+}
+
+DBusMessage *
+rdbus_get_message(VALUE obj)
+{
+  DBusMessage *msg;
+
+  msg = NULL;
+  Data_Get_Struct(obj, DBusMessage, msg);
+  if (msg == NULL)
+    rb_raise(eDBusError, "Failed to retrieve DATA object for DBusMessage");
+  return msg;
+}
 
 /*
  *  call-seq:
@@ -41,7 +93,7 @@ cDBusMessage_new(VALUE klass, VALUE type)
   message = NULL;
   message = dbus_message_new(message_type);
   RDBUS_RAISE_IF(message == NULL, "failed to create DBusMessage");
-  return RDBUS_NEW(cDBusMessage, message);
+  return MSG_NEW_TAKE_OWNERSHIP(message);
 }
 
 /*
@@ -72,7 +124,7 @@ cDBusMessage_new_method_call(VALUE klass, VALUE service, VALUE path,
     StringValuePtr(method)
   );
   RDBUS_RAISE_IF(message == NULL, "failed to create DBusMessage");
-  return RDBUS_NEW(cDBusMessage, message);
+  return MSG_NEW_TAKE_OWNERSHIP(message);
 }
 
 /*
@@ -92,7 +144,7 @@ cDBusMessage_new_method_return(VALUE klass, VALUE method_call_msg)
   message = NULL;
   message = dbus_message_new_method_return(MSG_GET(method_call_msg));
   RDBUS_RAISE_IF(!message, "failed to create DBusMessage");
-  return RDBUS_NEW(cDBusMessage, message);
+  return MSG_NEW_TAKE_OWNERSHIP(message);
 }
 
 /*
@@ -120,7 +172,7 @@ cDBusMessage_new_signal(VALUE klass, VALUE path, VALUE interface, VALUE name)
     StringValuePtr(name)
   );
   RDBUS_RAISE_IF(!message, "failed to create DBusMessage");
-  return RDBUS_NEW(cDBusMessage, message);
+  return MSG_NEW_TAKE_OWNERSHIP(message);
 }
 
 /*
@@ -146,7 +198,7 @@ cDBusMessage_new_error(VALUE klass, VALUE reply_to, VALUE error_name,
     StringValuePtr(error_message)
   );
   RDBUS_RAISE_IF(!message, "failed to create DBusMessage");
-  return RDBUS_NEW(cDBusMessage, message);
+  return MSG_NEW_TAKE_OWNERSHIP(message);
 }
 
 /*
@@ -566,7 +618,7 @@ cDBusMessage_get_auto_activation(VALUE self)
 static VALUE
 cDBusMessage_get_iter(VALUE self)
 {
-  return RDBUS_NEW(cDBusMessageIter, rdbus_message_iter_new(MSG_GET(self), 0));
+  return ITER_NEW(MSG_GET(self), FALSE);
 }
 
 /*
@@ -580,7 +632,7 @@ cDBusMessage_get_iter(VALUE self)
 static VALUE
 cDBusMessage_get_append_iter(VALUE self)
 {
-  return RDBUS_NEW(cDBusMessageIter, rdbus_message_iter_new(MSG_GET(self), 1));
+  return ITER_NEW(MSG_GET(self), TRUE);
 }
 
 /*

data/ext/ruby-dbus-pending-call.c

@@ -10,8 +10,32 @@
 
 VALUE cDBusPendingCall;
 
-RDBUS_GENERATE_NEW(cDBusPendingCall, DBusPendingCall *, dbus_pending_call_unref)
-RDBUS_GENERATE_GET(DBusPendingCall)
+static void
+rdbus_free_pending_call(void *call)
+{
+  DEBUG("DBusPendingCall.free <%p>", call);
+  dbus_pending_call_unref((DBusPendingCall *)call);
+}
+
+VALUE
+rdbus_new_pending_call(DBusPendingCall *call)
+{
+  dbus_pending_call_ref(call);
+  DEBUG("DBusPendingCall.new <%p>", call);
+  return Data_Wrap_Struct(cDBusPendingCall, NULL, rdbus_free_pending_call, call);
+}
+
+DBusPendingCall *
+rdbus_get_pending_call(VALUE obj)
+{
+  DBusPendingCall *call;
+
+  call = NULL;
+  Data_Get_Struct(obj, DBusPendingCall, call);
+  if (call == NULL)
+    rb_raise(eDBusError, "Failed to retrieve DATA object for DBusPendingCall");
+  return call;
+}
 
 /*
  *  call-seq:
@@ -55,7 +79,7 @@ cDBusPendingCall_get_reply(VALUE self)
 
   msg = dbus_pending_call_get_reply(CALL_GET(self));
   if (msg != NULL)
-    return RDBUS_NEW(cDBusMessage, msg);
+    return MSG_NEW(msg);
   return Qnil;
 }
 

data/ext/ruby-dbus-server.c

@@ -8,18 +8,34 @@
 
 #include "ruby-dbus.h"
 
-static void _server_free(DBusServer *server);
-
 VALUE cDBusServer;
 
-RDBUS_GENERATE_NEW(cDBusServer, DBusServer *, _server_free)
-RDBUS_GENERATE_GET(DBusServer)
-
 static void
-_server_free(DBusServer *server)
+rdbus_free_server(void *server)
+{
+  DEBUG("DBusServer.free <%p>", server);
+  dbus_server_unref((DBusServer *)server);
+}
+
+VALUE
+rdbus_new_server(DBusServer *server, gboolean owner)
 {
-  dbus_server_disconnect(server);
-  dbus_server_unref(server);
+  if (!owner)
+    dbus_server_ref(server);
+  DEBUG("DBusServer.new <%p> owner=%d", server, owner);
+  return Data_Wrap_Struct(cDBusServer, NULL, rdbus_free_server, server);
+}
+
+DBusServer *
+rdbus_get_server(VALUE obj)
+{
+  DBusServer *server;
+
+  server = NULL;
+  Data_Get_Struct(obj, DBusServer, server);
+  if (server == NULL)
+    rb_raise(eDBusError, "Failed to retrieve DATA object for DBusServer");
+  return server;
 }
 
 /*
@@ -38,7 +54,7 @@ cDBusServer_listen(VALUE klass, VALUE address)
 
   RDBUS_TRY(server = dbus_server_listen(StringValuePtr(address), &error));
   RDBUS_RAISE_IF(server == NULL, "failed to create DBusServer");
-  return RDBUS_NEW(cDBusServer, server);
+  return SERVER_NEW_TAKE_OWNERSHIP(server);
 }
 
 /*

data/ext/ruby-dbus.h

@@ -10,36 +10,16 @@
 #ifndef RUBY_DBUS_H
 #define RUBY_DBUS_H
 
-
 #define DBUS_API_SUBJECT_TO_CHANGE 1
 #include <dbus/dbus.h>
 #include <dbus/dbus-glib.h>
 #include "ruby.h"
 
-#define RDBUS_GENERATE_PROTO_NEW(klass, ctype) \
-  VALUE _rdbus_ ##klass## _new_from(ctype obj)
-
-#define RDBUS_GENERATE_PROTO_GET(ctype) \
-  ctype * _rdbus_ ##ctype## _get_wrapped(VALUE value)
-
-#define RDBUS_GENERATE_NEW(klass, ctype, free) \
-  RDBUS_GENERATE_NEW_WITH_MARK(klass, ctype, NULL, free)
-
-#define RDBUS_GENERATE_NEW_WITH_MARK(klass, ctype, mark, free) \
-  RDBUS_GENERATE_PROTO_NEW(klass, ctype)                       \
-  {                                                            \
-    return Data_Wrap_Struct(klass, mark, free, obj);           \
-  }
-
-#define RDBUS_GENERATE_GET(ctype)                         \
-  RDBUS_GENERATE_PROTO_GET(ctype)                         \
-  {                                                       \
-    ctype *obj = NULL;                                    \
-    Data_Get_Struct(value, ctype, obj);                   \
-    if (obj == NULL)                                      \
-      rb_raise(eDBusError, "failed to retrieve " #ctype); \
-    return obj;                                           \
-  }
+#ifdef RDBUS_DEBUG
+#define DEBUG(fmt, x...) fprintf(stderr, "[RDBUS] " fmt "\n", ##x)
+#else
+#define DEBUG(fmt, x...) 
+#endif
 
 #define RDBUS_TRY_ERR(expr, klass)    \
   do {                                \
@@ -53,33 +33,44 @@
 #define RDBUS_TRY(expr) \
   RDBUS_TRY_ERR((expr), eDBusError)
 
-#define RDBUS_NEW(klass, obj) \
-  _rdbus_ ##klass## _new_from(obj)
-
-#define RDBUS_GET(ctype, value) \
-  _rdbus_ ##ctype## _get_wrapped(value)
-
 #define RDBUS_RAISE_IF(cond, message) \
   if (cond) rb_raise(eDBusError, message)
 
+#define CONN_GET(obj) \
+  rdbus_get_connection(obj)
 
+#define CONN_NEW(obj) \
+  rdbus_new_connection(obj, FALSE)
 
-#define CONN_GET(obj) \
-  RDBUS_GET(DBusConnection, obj)
+#define CONN_NEW_TAKE_OWNERSHIP(obj) \
+  rdbus_new_connection(obj, TRUE)
 
 #define MSG_GET(obj) \
-  (RDBUS_GET(DBusMessage, obj))
+  rdbus_get_message(obj)
+
+#define MSG_NEW(obj) \
+  rdbus_new_message(obj, FALSE)
+
+#define MSG_NEW_TAKE_OWNERSHIP(obj) \
+  rdbus_new_message(obj, TRUE)
 
 #define ITER_GET(obj) \
-  (RDBUS_GET(RubyDBusMessageIter, obj)->real_iter)
+  rdbus_get_message_iter(obj)
+
+#define ITER_NEW(msg, append) \
+  rdbus_new_message_iter(msg, append)
 
 #define CALL_GET(obj) \
-  (RDBUS_GET(DBusPendingCall, obj))
+  rdbus_get_pending_call(obj)
 
-#define SERVER_GET(obj) \
-  (RDBUS_GET(DBusServer, obj))
+#define CALL_NEW(obj) \
+  rdbus_new_pending_call(obj)
 
+#define SERVER_GET(obj) \
+  rdbus_get_server(obj)
 
+#define SERVER_NEW_TAKE_OWNERSHIP(obj) \
+  rdbus_new_server(obj, TRUE)
 
 extern VALUE mDBus;
 extern VALUE mDBusBinding;
@@ -92,8 +83,6 @@ extern VALUE eDBusError;
 
 typedef struct _RubyDBusMessageIter RubyDBusMessageIter;
 
-
-
 void Init_dbus_bus();
 void Init_dbus_connection();
 void Init_dbus_message();
@@ -101,21 +90,19 @@ void Init_dbus_message_iter();
 void Init_dbus_pending_call();
 void Init_dbus_server();
 
-RDBUS_GENERATE_PROTO_NEW(cDBusConnection, DBusConnection *);
-RDBUS_GENERATE_PROTO_NEW(cDBusMessage, DBusMessage *);
-RDBUS_GENERATE_PROTO_NEW(cDBusMessageIter, RubyDBusMessageIter *);
-RDBUS_GENERATE_PROTO_NEW(cDBusPendingCall, DBusPendingCall *);
-RDBUS_GENERATE_PROTO_NEW(cDBusServer, DBusServer *);
-
-RDBUS_GENERATE_PROTO_GET(DBusConnection);
-RDBUS_GENERATE_PROTO_GET(DBusMessage);
-RDBUS_GENERATE_PROTO_GET(DBusMessageIter);
-RDBUS_GENERATE_PROTO_GET(DBusPendingCall);
-RDBUS_GENERATE_PROTO_GET(DBusServer);
+VALUE rdbus_new_connection   (DBusConnection *conn, gboolean is_owner);
+VALUE rdbus_new_message      (DBusMessage *msg, gboolean is_owner);
+VALUE rdbus_new_message_iter (DBusMessage *msg, gboolean is_append);
+VALUE rdbus_new_pending_call (DBusPendingCall *call);
+VALUE rdbus_new_server       (DBusServer *server, gboolean is_owner);
 
-RubyDBusMessageIter *rdbus_message_iter_new (DBusMessage *msg, short is_append_iter);
-VALUE                rdbus_private_method   (VALUE klass);
+DBusConnection  *rdbus_get_connection   (VALUE obj);
+DBusMessage     *rdbus_get_message      (VALUE obj);
+DBusMessageIter *rdbus_get_message_iter (VALUE obj);
+DBusPendingCall *rdbus_get_pending_call (VALUE obj);
+DBusServer      *rdbus_get_server       (VALUE obj);
 
+VALUE rdbus_private_method   (VALUE klass);
 
 /* --- Externals (copied from Python bindings) --- */
 void dbus_connection_setup_with_g_main (DBusConnection *connection,

data/lib/dbus/version.rb

@@ -13,7 +13,7 @@ module DBus
   module BindingVersion
     VERSION_MAJOR = 0
     VERSION_MINOR = 1
-    VERSION_PATCH = 4
+    VERSION_PATCH = 7
   end
   
   # Contains the string version of the D-BUS bindings

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.1
 specification_version: 1
 name: dbus
 version: !ruby/object:Gem::Version 
-  version: 0.1.5
-date: 2004-11-25
+  version: 0.1.7
+date: 2004-12-11
 summary: Ruby bindings for D-BUS.
 require_paths: 
   - lib