1 files changed, 686 insertions, 0 deletions

diff --git a/src/lib/common/gnunet_dbus_lib_service.c b/src/lib/common/gnunet_dbus_lib_service.c
new file mode 100644
index 0000000..2151613
--- /dev/null
+++ b/src/lib/common/gnunet_dbus_lib_service.c
@@ -0,0 +1,686 @@
+#include "config.h"
+
+#include <stdbool.h>
+#include <dbus/dbus.h>
+
+#include <gnunet/platform.h>
+#include <gnunet/gnunet_common.h>
+#include <gnunet/gnunet_scheduler_lib.h>
+#include <gnunet/gnunet_container_lib.h>
+
+#include "gnunet_dbus_lib.h"
+
+#include "watch.h"
+#include "timeout.h"
+
+#define LOG(kind, ...) GNUNET_log_from (kind, "dbus-service", __VA_ARGS__)
+
+struct GNUNET_DBUS_Service
+{
+#if 0
+  struct GNUNET_DBUS_ObjectIterator *objects_front;
+  struct GNUNET_DBUS_ObjectIterator *objects_back;
+#else
+  struct GNUNET_DBUS_Object *root_object;
+#endif
+
+  DBusConnection *dbus_connection;
+  const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+  char *gnunet_name;
+  char *well_known_name;
+
+  /*
+   * Linked list of watches
+   */
+  struct WatchIter *watches_front;
+  struct WatchIter *watches_back;
+
+  /*
+   * Linked list of timeouts
+   */
+  struct TimeoutIter *timeouts_front;
+  struct TimeoutIter *timeouts_back;
+
+  /*
+   * Linked list of clients
+   */
+  struct GNUNET_DBUS_ClientIterator *clients_front;
+  struct GNUNET_DBUS_ClientIterator *clients_back;
+
+  GNUNET_DBUS_ClientConnectsHandler client_connects;
+  GNUNET_DBUS_ClientDisconnectsHandler client_disconnects;
+
+  unsigned ref_count;
+};
+
+static dbus_int32_t service_slot_id ()
+{
+  static dbus_int32_t id = -1;
+  if (-1 == id)
+  {
+    dbus_bool_t succ = dbus_connection_allocate_data_slot (&id);
+    if (! succ || -1 == id)
+    {
+      LOG (GNUNET_ERROR_TYPE_ERROR, "dbus_connection_allocate_data_slot failed. id == %lld\n", (long long)id);
+      GNUNET_abort_ ();
+    };
+  };
+
+  return id;
+};
+
+/*
+ * Called by DBus when it has a new watch that it wants us to watch.
+ *
+ * @param watch The DBus watch, created and passed to us by DBus.
+ * @param data the GNUNET_DBUS_Service we passed to dbus_connection_set_watch_functions
+ * @return true on success, false on an unrecoverable error.
+ */
+static dbus_bool_t
+watch_add (
+    DBusWatch *watch,
+    void *data)
+{
+  struct GNUNET_DBUS_Service *service = (struct GNUNET_DBUS_Service *)data;
+  struct Watch *w = watch_create (watch);
+
+  if (dbus_watch_get_enabled (watch))
+    watch_schedule (w);
+
+  struct WatchIter *wi = GNUNET_new (struct WatchIter);
+  wi->w = w;
+  GNUNET_CONTAINER_DLL_insert (service->watches_front,
+                               service->watches_back,
+                               wi);
+  return true;
+};
+
+/*
+ * Called by DBus when it want to permanently disable and remove a watch
+ *
+ * @param watch The DBus watch, passed to us by DBus.
+ * @param data the GNUNET_DBUS_Service we passed to dbus_connection_set_watch_functions
+ */
+static void
+watch_remove (
+    DBusWatch *watch,
+    void *data)
+{
+  struct GNUNET_DBUS_Service *service = (struct GNUNET_DBUS_Service *)data;
+  struct WatchIter *wi = watch_find (service->watches_front, watch);
+
+  if (NULL == wi)
+  {
+    LOG (GNUNET_ERROR_TYPE_ERROR, "Asked to remove watch that has not been added\n");
+    GNUNET_abort_ ();
+  };
+
+  struct Watch *w = wi->w;
+  watch_unschedule (w);
+  GNUNET_CONTAINER_DLL_remove (service->watches_front,
+                               service->watches_back,
+                               wi);
+  watch_unref (w);
+  GNUNET_free (wi);
+};
+
+/*
+ * Called by DBus when it wants to enable or disable a watch.
+ * Schedules or unschedules the scheduler to monitor this watch as appropriate.
+ *
+ * @param watch The DBus watch, passed to us by DBus.
+ * @param data the GNUNET_DBUS_Service we passed to dbus_connection_set_watch_functions
+ */
+static void
+watch_toggle (
+    DBusWatch *watch,
+    void *data)
+{
+  struct GNUNET_DBUS_Service *service = (struct GNUNET_DBUS_Service *)data;
+  struct WatchIter *wi = watch_find (service->watches_front, watch);
+
+  if (NULL == wi)
+  {
+    LOG (GNUNET_ERROR_TYPE_ERROR, "Asked to toggle watch that has not been added\n");
+    GNUNET_abort_ ();
+  };
+
+  struct Watch *w = wi->w;
+  if (dbus_watch_get_enabled (watch))
+    watch_unschedule (w);
+  else
+    watch_schedule (w);
+};
+
+static dbus_bool_t
+timeout_add (
+    DBusTimeout *timeout,
+    void *data)
+{
+  struct GNUNET_DBUS_Service *service = (struct GNUNET_DBUS_Service *)data;
+  struct Timeout *t = timeout_create (timeout);
+
+  if (dbus_timeout_get_enabled (timeout))
+    timeout_schedule (t);
+
+  struct TimeoutIter *ti = GNUNET_new (struct TimeoutIter);
+  ti->t = t;
+  GNUNET_CONTAINER_DLL_insert (service->timeouts_front,
+                               service->timeouts_back,
+                               ti);
+  return true;
+};
+
+static void
+timeout_remove (
+    DBusTimeout *timeout,
+    void *data)
+{
+  struct GNUNET_DBUS_Service *service = (struct GNUNET_DBUS_Service *)data;
+  struct TimeoutIter *ti = timeout_find (service->timeouts_front, timeout);
+
+  if (NULL == ti)
+  {
+    LOG (GNUNET_ERROR_TYPE_WARNING, "Asked to remove timeout that has not been added\n");
+    return;
+  };
+
+  struct Timeout *t = ti->t;
+  timeout_unschedule (t);
+  GNUNET_CONTAINER_DLL_remove (service->timeouts_front,
+                               service->timeouts_back,
+                               ti);
+  timeout_unref (t);
+  GNUNET_free (ti);
+};
+
+static void
+timeout_toggle (
+    DBusTimeout *timeout,
+    void *data)
+{
+  struct GNUNET_DBUS_Service *service = (struct GNUNET_DBUS_Service *)data;
+  struct TimeoutIter *ti = timeout_find (service->timeouts_front, timeout);
+
+  if (NULL == ti)
+  {
+    LOG (GNUNET_ERROR_TYPE_WARNING, "asked to toggle timeout that has not been added\n");
+    return;
+  };
+
+  struct Timeout *t = ti->t;
+  if (dbus_timeout_get_enabled (timeout))
+    timeout_unschedule (t);
+  else
+    timeout_schedule (t);
+};
+
+
+static void
+dispatch (
+    void *cls,
+    const struct GNUNET_SCHEDULER_TaskContext *tc);
+
+
+static void
+handle_dispatch (
+    DBusConnection *dbus_connection,
+    DBusDispatchStatus status)
+{
+  switch (status)
+  {
+  case DBUS_DISPATCH_DATA_REMAINS:
+    GNUNET_SCHEDULER_add_now (dispatch,
+                              dbus_connection);
+    break;
+  case DBUS_DISPATCH_COMPLETE:
+    break;
+  case DBUS_DISPATCH_NEED_MEMORY:
+    LOG (GNUNET_ERROR_TYPE_ERROR, "Out of memory!\n");
+    GNUNET_abort_ ();
+    break;
+  default:
+    LOG (GNUNET_ERROR_TYPE_ERROR, "Unrecognized dispatch status\n");
+    break;
+  };
+};
+
+
+static void
+dispatch (
+    void *cls,
+    const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  struct DBusConnection *dbus_connection = (struct DBusConnection *)cls;
+  dbus_connection_dispatch (dbus_connection);
+  handle_dispatch (dbus_connection, dbus_connection_get_dispatch_status (dbus_connection));
+};
+
+
+static void
+dispatch_status_changed (
+    DBusConnection *dbus_connection,
+    DBusDispatchStatus new_status,
+    void *data)
+{
+  (void)data;
+  handle_dispatch (dbus_connection, new_status);
+};
+
+/*
+ * Called whenever a message arrives from DBus
+ *
+ * @param conn The connection it arrived on.
+ * @param message The message
+ * @param cls The closure passed to dbus_connection_try_register_object_path
+ *            in our case this is the GNUNET_DBUS_Object that the message was
+ *            sent to.
+ *
+ * @return DBUS_HANDLER_RESULT_NEED_MEMORY if anything failed due to lack of
+ *         memory.
+ *         DBUS_HANDLER_RESULT_HANDLED if any method returned a reply.
+ *         DBUS_HANDLER_RESULT_NOT_YET_HANDLED otherwise.
+ */
+DBusHandlerResult
+handle_object_message (
+    DBusConnection *connection,
+    DBusMessage *dbus_message,
+    void *cls)
+{
+  //struct GNUNET_DBUS_Object *object = (struct GNUNET_DBUS_Object *)cls;
+  (void)cls;
+
+  const char *object_path    = dbus_message_get_path (dbus_message);
+  const char *type_string    = dbus_message_type_to_string (dbus_message_get_type (dbus_message));
+  const char *interface_name = dbus_message_get_interface (dbus_message);
+  const char *member_name    = dbus_message_get_member (dbus_message);
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Recieved DBus message for %s\n", object_path);
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "    type      == %s\n", type_string    ? type_string    : "(none)");
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "    interface == %s\n", interface_name ? interface_name : "(none)");
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "    member    == %s\n", member_name    ? member_name    : "(none)");
+
+  struct GNUNET_DBUS_Service *service = dbus_connection_get_data (connection, service_slot_id ());
+
+  const char *unique_name = dbus_message_get_sender (dbus_message);
+  struct GNUNET_DBUS_ClientIterator *client_it = service->clients_front;
+  struct GNUNET_DBUS_Client *client = NULL;
+  for (; client_it; client_it = client_it->next)
+  {
+    client = client_it->client;
+    const char *this_unique_name = GNUNET_DBUS_client_get_unique_name (client);
+    if (! strcmp (unique_name, this_unique_name))
+      break;
+  };
+  if (! client_it)
+  {
+    client = GNUNET_DBUS_client_create (unique_name);
+    client_it = GNUNET_new (struct GNUNET_DBUS_ClientIterator);
+    client_it->client = client;
+    GNUNET_CONTAINER_DLL_insert (service->clients_front,
+                                 service->clients_back,
+                                 client_it);
+    if (service->client_connects)
+      service->client_connects (service, client);
+    /*
+
+        ** TODO **
+
+        detect when a client is no longer on the bus and
+        destroy the client object. At the moment this will slowly
+        leak memory as clients come and go.
+
+    */
+  };
+
+  /*
+   * TODO:
+   *
+   * The code below could be more efficient. Avoid the allocation with
+   * dbus_message_get_path_decomposed and use tries to do
+   * object/method/interface lookups.
+   */
+  char **path_decomposed = NULL;
+  dbus_bool_t succ = dbus_message_get_path_decomposed (dbus_message, &path_decomposed);
+  if (! succ)
+  {
+    LOG (GNUNET_ERROR_TYPE_ERROR, "Ran out of memory in dbus_message_get_path_decomposed.\n");
+    GNUNET_abort_ ();
+  };
+
+  struct GNUNET_DBUS_Object *object = service->root_object;
+  char **path_element = path_decomposed;
+  while (*path_element)
+  {
+    const struct GNUNET_DBUS_ObjectIterator *start = GNUNET_DBUS_object_iterate_subobjects (object);
+    const struct GNUNET_DBUS_ObjectIterator *found = GNUNET_DBUS_object_find (start, *path_element);
+    if (! found)
+    {
+      const char *object_name = GNUNET_DBUS_object_get_name (object);
+      LOG (GNUNET_ERROR_TYPE_DEBUG, "No such object \"%s\" under \"%s\"\n", *path_element, object_name[0] ? object_name : "(root object)");
+      dbus_free_string_array (path_decomposed);
+      return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+    };
+
+    object = found->object;
+    path_element++;
+  };
+  dbus_free_string_array (path_decomposed);
+
+  if (! member_name)
+    return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+
+  if (! interface_name)
+    interface_name = service->well_known_name;
+
+  int dbus_message_type = dbus_message_get_type (dbus_message);
+  if (dbus_message_type != DBUS_MESSAGE_TYPE_METHOD_CALL)
+    return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+
+  const struct GNUNET_DBUS_InterfaceIterator *int_it = \
+      GNUNET_DBUS_interface_find ( \
+          GNUNET_DBUS_object_iterate_interfaces (object),
+          interface_name);
+  if (! int_it)
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG, "No such interface: %s\n", interface_name);
+    return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+  };
+  struct GNUNET_DBUS_Interface *interface = int_it->interface;
+
+  const struct GNUNET_DBUS_MethodIterator *meth_it = \
+      GNUNET_DBUS_method_find ( \
+          GNUNET_DBUS_interface_iterate_methods (interface),
+          member_name);
+  if (! meth_it)
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG, "No such method: %s\n", member_name);
+    return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+  };
+  struct GNUNET_DBUS_Method *method = meth_it->method;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Found method.\n");
+
+  struct GNUNET_DBUS_MethodContext *mc = GNUNET_DBUS_method_context_create (
+    client,
+    service,
+    object,
+    interface,
+    method,
+    dbus_message
+  );
+  GNUNET_DBUS_method_call (method, mc);
+  GNUNET_DBUS_method_context_unref (mc);
+  return DBUS_HANDLER_RESULT_HANDLED;
+};
+
+struct GNUNET_DBUS_Service *
+GNUNET_DBUS_service_create (
+    const struct GNUNET_CONFIGURATION_Handle *cfg,
+    const char *name)
+{
+  struct GNUNET_DBUS_Service *service = GNUNET_new (struct GNUNET_DBUS_Service);
+  service->cfg = cfg;
+  service->gnunet_name = GNUNET_strdup (name);
+  service->watches_front = NULL;
+  service->watches_back = NULL;
+  service->timeouts_front = NULL;
+  service->timeouts_back = NULL;
+  service->client_connects = NULL;
+  service->client_disconnects = NULL;
+  service->ref_count = 1;
+
+  DBusError err;
+  dbus_error_init(&err);
+
+  service->root_object = GNUNET_DBUS_object_create ("", NULL);
+  if (! service->root_object)
+    LOG (GNUNET_ERROR_TYPE_ERROR, "Failed to create root object for service.\n");
+  else
+  {
+    service->dbus_connection = dbus_bus_get_private (DBUS_BUS_SYSTEM, &err);
+    if (! service->dbus_connection)
+      LOG (GNUNET_ERROR_TYPE_ERROR, "Failed to connect to dbus system bus (%s)\n", dbus_error_is_set (&err) ? err.message : "dbus_bus_get_private returned NULL");
+    else
+    {
+      dbus_connection_set_exit_on_disconnect (service->dbus_connection,
+                                              false);
+      dbus_bool_t succ = dbus_connection_set_data (service->dbus_connection,
+                                                   service_slot_id (),
+                                                   service,
+                                                   NULL);
+      if (! succ)
+      {
+        LOG (GNUNET_ERROR_TYPE_ERROR, "dbus_connection_set_data returned false. Out of memory.\n");
+        GNUNET_abort_ ();
+      };
+
+      succ = dbus_connection_set_watch_functions (service->dbus_connection, watch_add, watch_remove, watch_toggle, service, NULL);
+      if(! succ)
+      {
+        LOG (GNUNET_ERROR_TYPE_ERROR, "dbus_connection_set_watch_functions returned false. Out of memory.\n");
+        GNUNET_abort_ ();
+      };
+
+      dbus_connection_set_dispatch_status_function (service->dbus_connection, dispatch_status_changed, service, NULL);
+      handle_dispatch (service->dbus_connection, dbus_connection_get_dispatch_status (service->dbus_connection));
+
+      succ = dbus_connection_set_timeout_functions (service->dbus_connection, timeout_add, timeout_remove, timeout_toggle, service, NULL);
+      if (! succ)
+      {
+        LOG (GNUNET_ERROR_TYPE_ERROR, "dbus_connection_set_timeout_functions returned false. Out of memory.\n");
+        GNUNET_abort_ ();
+      };
+
+      DBusObjectPathVTable vtable;
+      vtable.message_function = handle_object_message;
+      vtable.unregister_function = NULL;
+      succ = dbus_connection_try_register_fallback (service->dbus_connection, "/", &vtable, service, &err);
+      if (dbus_error_is_set (&err) || ! succ)
+        LOG (GNUNET_ERROR_TYPE_ERROR, "dbus_connection_try_register_fallback failed when registering root object.\n");
+      else
+      {
+        service->well_known_name = NULL;
+        GNUNET_asprintf (&service->well_known_name, "gnu.gnunet.%s", name);
+        int request_result = dbus_bus_request_name (service->dbus_connection, service->well_known_name, DBUS_NAME_FLAG_DO_NOT_QUEUE, &err);
+        if (dbus_error_is_set (&err))
+          LOG (GNUNET_ERROR_TYPE_ERROR, "Failed to request the bus name (%s)\n", err.message);
+        else
+        {
+          switch(request_result)
+          {
+          case DBUS_REQUEST_NAME_REPLY_EXISTS:
+            LOG (GNUNET_ERROR_TYPE_ERROR, "Failed to request the bus name \"%s\"; name is already taken.\n", service->well_known_name);
+            break;
+          default:
+            LOG (GNUNET_ERROR_TYPE_ERROR, "Unable to interpret result of dbus_request_name (%d)\n", request_result);
+            break;
+          case DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER:
+
+            /* Success! */
+            return service;
+
+          }
+        }
+        dbus_connection_unregister_object_path (service->dbus_connection, "/");
+      }
+      dbus_connection_close (service->dbus_connection);
+      dbus_connection_unref (service->dbus_connection);
+    }
+    GNUNET_DBUS_object_unref (service->root_object);
+  }
+  GNUNET_free (service->well_known_name);
+  GNUNET_free (service->gnunet_name);
+  GNUNET_free (service);
+  LOG (GNUNET_ERROR_TYPE_ERROR, "GNUNET_DBUS_service create failed.\n");
+  return NULL;
+};
+
+void
+GNUNET_DBUS_service_ref (
+    struct GNUNET_DBUS_Service *service)
+{
+  service->ref_count++;
+}
+
+void
+GNUNET_DBUS_service_unref (
+    struct GNUNET_DBUS_Service *service)
+{
+  if (service->ref_count == 0)
+  {
+    LOG (GNUNET_ERROR_TYPE_ERROR, "Tried to unref service with ref count 0\n");
+    LOG (GNUNET_ERROR_TYPE_ERROR, "  well_known_name == %s\n", service->well_known_name);
+    GNUNET_abort_ ();
+  }
+
+  if (0 == --(service->ref_count))
+  {
+    GNUNET_DBUS_object_unref (service->root_object);
+
+    GNUNET_free (service->well_known_name);
+    GNUNET_free (service->gnunet_name);
+
+    struct WatchIter *wi = service->watches_front;
+    while (wi)
+    {
+      struct WatchIter *next = wi->next;
+      watch_unref (wi->w);
+      GNUNET_free (wi);
+      wi = next;
+    }
+
+    struct TimeoutIter *ti = service->timeouts_front;
+    while (ti)
+    {
+      struct TimeoutIter *next = ti->next;
+      timeout_unref (ti->t);
+      GNUNET_free (ti);
+      ti = next;
+    }
+
+    struct GNUNET_DBUS_ClientIterator *ci = service->clients_front;
+    while (ci)
+    {
+      struct GNUNET_DBUS_ClientIterator *next = ci->next;
+      GNUNET_DBUS_client_unref (ci->client);
+      GNUNET_free (ci);
+      ci = next;
+    }
+
+    GNUNET_free (service);
+  }
+};
+
+const struct GNUNET_CONFIGURATION_Handle *
+GNUNET_DBUS_service_get_config (
+    struct GNUNET_DBUS_Service *service)
+{
+  return service->cfg;
+};
+
+#if 0
+int
+GNUNET_DBUS_service_add_object (
+    struct GNUNET_DBUS_Service *service,
+    struct GNUNET_DBUS_Object *object)
+{
+  DBusError err;
+  dbus_error_init(&err);
+
+  const char *path = GNUNET_DBUS_object_get_path (object);
+
+  DBusObjectPathVTable vtable;
+  vtable.message_function = handle_object_message;
+  vtable.unregister_function = NULL;
+  dbus_bool_t succ = dbus_connection_try_register_object_path (
+      service->dbus_connection,
+      path,
+      &vtable,
+      object,
+      &err);
+  if (dbus_error_is_set (&err))
+  {
+    LOG (
+        GNUNET_ERROR_TYPE_ERROR,
+        "dbus_connection_try_register failed to register path \"%s\": %s\n",
+          path,
+          err.message);
+    return GNUNET_SYSERR;
+  };
+  if (! succ)
+  {
+    LOG (
+        GNUNET_ERROR_TYPE_ERROR,
+        "dbus_connection_try_register returned false when registering path \"%s\"\n",
+          path);
+    return GNUNET_SYSERR;
+  };
+
+  struct GNUNET_DBUS_ObjectIterator *object_it = GNUNET_new (struct GNUNET_DBUS_ObjectIterator);
+  object_it->object = object;
+  GNUNET_DBUS_object_ref (object);
+  GNUNET_CONTAINER_DLL_insert (service->objects_front,
+                               service->objects_back,
+                               object_it);
+
+  return GNUNET_OK;
+};
+
+void
+GNUNET_DBUS_service_remove_object (
+    struct GNUNET_DBUS_Service *service,
+    struct GNUNET_DBUS_Object *object)
+{
+  struct GNUNET_DBUS_ObjectIterator *obj_it;
+  for (obj_it = service->objects_front; obj_it; obj_it = obj_it->next)
+  {
+    if (obj_it->object == object)
+      break;
+  };
+
+  if (! obj_it)
+  {
+    LOG (GNUNET_ERROR_TYPE_ERROR, "Tried to remove object that has not been added.\n");
+    GNUNET_abort_ ();
+  };
+
+  GNUNET_CONTAINER_DLL_remove (
+      service->objects_front,
+      service->objects_back,
+      obj_it);
+
+  GNUNET_free (obj_it);
+  GNUNET_DBUS_object_unref (object);
+}
+#endif
+
+void
+GNUNET_DBUS_service_send (
+    struct GNUNET_DBUS_Service *service,
+    DBusMessage *dbus_message)
+{
+  dbus_bool_t succ = dbus_connection_send (service->dbus_connection, dbus_message, NULL);
+  if (! succ)
+  {
+    LOG (GNUNET_ERROR_TYPE_ERROR, "dbus_connection_send failed. Out of memory.\n");
+    GNUNET_abort_ ();
+  };
+};
+
+void
+GNUNET_DBUS_service_set_client_handlers (
+    struct GNUNET_DBUS_Service *service,
+    GNUNET_DBUS_ClientConnectsHandler client_connects,
+    GNUNET_DBUS_ClientDisconnectsHandler client_disconnects)
+{
+  service->client_connects = client_connects;
+  service->client_disconnects = client_disconnects;
+};
+
+struct GNUNET_DBUS_Object *
+GNUNET_DBUS_service_get_root_object (
+    struct GNUNET_DBUS_Service *service)
+{
+  return service->root_object;
+}