#include <stdlib.h>
#include <string.h>
+#include <stdio.h>
#include "droute.h"
#include "droute-pairhash.h"
new_path->properties = g_hash_table_new_full ((GHashFunc)str_pair_hash,
str_pair_equal,
g_free,
- NULL);
+ g_free);
new_path->introspect_children_cb = introspect_children_cb;
new_path->introspect_children_data = introspect_children_data;
g_free (path->path);
g_string_chunk_free (path->chunks);
g_ptr_array_free (path->interfaces, TRUE);
- g_ptr_array_free (path->introspection, FALSE);
+ g_free(g_ptr_array_free (path->introspection, FALSE));
g_hash_table_destroy (path->methods);
g_hash_table_destroy (path->properties);
+ g_free (path);
}
static void *
droute_free (DRouteContext *cnx)
{
g_ptr_array_foreach (cnx->registered_paths, (GFunc) path_free, NULL);
+ g_ptr_array_free (cnx->registered_paths, TRUE);
g_free (cnx);
}
const void *data)
{
DRoutePath *new_path;
- gboolean registered;
new_path = path_new (cnx, path, FALSE, (void *)data, NULL, NULL, NULL);
itf = g_string_chunk_insert (path->chunks, name);
g_ptr_array_add (path->interfaces, itf);
- g_ptr_array_add (path->introspection, introspect);
+ g_ptr_array_add (path->introspection, (gpointer) introspect);
for (; methods != NULL && methods->name != NULL; methods++)
{
dbus_error_init (&error);
if (!dbus_message_get_args
(message, &error, DBUS_TYPE_STRING, &iface, DBUS_TYPE_INVALID))
- return dbus_message_new_error (message, DBUS_ERROR_FAILED, error.message);
+ {
+ DBusMessage *ret;
+ ret = dbus_message_new_error (message, DBUS_ERROR_FAILED, error.message);
+ dbus_error_free (&error);
+ return ret;
+ }
reply = dbus_message_new_method_return (message);
if (!reply)
DBUS_TYPE_STRING,
&(pair.two),
DBUS_TYPE_INVALID))
- return dbus_message_new_error (message, DBUS_ERROR_FAILED, error.message);
+ {
+ DBusMessage *ret;
+ ret = dbus_message_new_error (message, DBUS_ERROR_FAILED, error.message);
+ dbus_error_free (&error);
+ }
_DROUTE_DEBUG ("DRoute (handle prop): %s|%s on %s\n", pair.one, pair.two, pathstr);
prop_funcs = (PropertyPair *) g_hash_table_lookup (path->properties, &pair);
if (!prop_funcs)
- return dbus_message_new_error (message, DBUS_ERROR_FAILED, "Property unavailable");
+ {
+ DBusMessage *ret;
+#ifdef DBUS_ERROR_UNKNOWN_PROPERTY
+ ret = dbus_message_new_error (message, DBUS_ERROR_UNKNOWN_PROPERTY, "Property unavailable");
+#else
+ ret = dbus_message_new_error (message, DBUS_ERROR_FAILED, "Property unavailable");
+#endif
+ dbus_error_free (&error);
+ return ret;
+ }
datum = path_get_datum (path, pathstr);
if (!datum)
reply = dbus_message_new_method_return (message);
}
+#ifdef DBUS_ERROR_PROPERTY_READ_ONLY
+ else if (!get)
+ {
+ reply = dbus_message_new_error (message, DBUS_ERROR_PROPERTY_READ_ONLY, "Property is read-only");
+ }
+#endif
else
{
reply = dbus_message_new_error (message, DBUS_ERROR_FAILED, "Getter or setter unavailable");
char *id_str = (char *) g_malloc(40);
DBusMessage *reply;
- if (strcmp (iface, DBUS_INTERFACE_DBUS) != 0 ||
- strcmp (member, "Hello") != 0)
- return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+ if (strcmp (iface, DBUS_INTERFACE_DBUS) != 0 ||
+ strcmp (member, "Hello") != 0)
+ {
+ g_free (id_str);
+ return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+ }
/* TODO: Fix this hack (we don't handle wrap-around, for instance) */
sprintf (id_str, ":1.%d", id++);
const gchar *member,
const gchar *pathstr)
{
- DBusMessage *reply;
+ DBusMessage *reply = NULL;
DBusHandlerResult result = DBUS_HANDLER_RESULT_HANDLED;
if (!g_strcmp0(member, "GetAll"))
else
reply = (func) (bus, message, datum);
- if (!reply)
+ /* All D-Bus method calls must have a reply.
+ * If one is not provided presume that the caller has already
+ * sent one.
+ */
+ if (reply)
{
- /* All D-Bus method calls must have a reply.
- * If one is not provided presume that the call has a void
- * return and no error has occured.
- */
- reply = dbus_message_new_method_return (message);
+ dbus_connection_send (bus, reply, NULL);
+ dbus_message_unref (reply);
}
- dbus_connection_send (bus, reply, NULL);
- dbus_message_unref (reply);
result = DBUS_HANDLER_RESULT_HANDLED;
}
dbus_message_get_signature (message),
dbus_message_get_interface (message),
dbus_message_get_path (message));
+#ifdef DBUS_ERROR_UNKNOWN_OBJECT
+ reply = dbus_message_new_error (message,
+ DBUS_ERROR_UNKNOWN_OBJECT,
+ errmsg);
+#else
reply = dbus_message_new_error (message,
DBUS_ERROR_FAILED,
errmsg);
+#endif
g_free (errmsg);
return reply;
}
}
void
+droute_path_unregister (DRoutePath *path, DBusConnection *bus)
+{
+ dbus_connection_unregister_object_path (bus, path->path);
+}
+
+void
droute_context_register (DRouteContext *cnx, DBusConnection *bus)
{
g_ptr_array_foreach (cnx->registered_paths, (GFunc) droute_path_register,
}
void
+droute_context_unregister (DRouteContext *cnx, DBusConnection *bus)
+{
+ g_ptr_array_foreach (cnx->registered_paths, (GFunc) droute_path_unregister,
+ bus);
+}
+
+void
+droute_context_deregister (DRouteContext *cnx, DBusConnection *bus)
+{
+ g_ptr_array_foreach (cnx->registered_paths, (GFunc) droute_path_unregister,
+ bus);
+}
+
+void
droute_intercept_dbus (DBusConnection *bus)
{
dbus_connection_register_object_path (bus, DBUS_PATH_DBUS,
&droute_vtable, NULL);
}
+
+void
+droute_unintercept_dbus (DBusConnection *bus)
+{
+ dbus_connection_unregister_object_path (bus, DBUS_PATH_DBUS);
+}
+
/*END------------------------------------------------------------------------*/