Refactor some code around watches and timeouts

Watches and Timeouts are now unified under one implementation that covers
both dbus server and connections.
In watches do not keep removing and adding file events simply toggle the
appropriate flags.
Also streamline some memory management within both timeout and watch related
functions, checking allocations and freeing the whole context not just
the events.

4 files changed, 324 insertions, 355 deletions

diff --git a/server/sbus/sssd_dbus_common.c b/server/sbus/sssd_dbus_common.c
index 3b8a3271b..6a7107685 100644
--- a/server/sbus/sssd_dbus_common.c
+++ b/server/sbus/sssd_dbus_common.c
@@ -3,8 +3,179 @@
 #include "dbus/dbus.h"
 #include "util/util.h"
 #include "util/btreemap.h"
+#include "sbus/sssd_dbus.h"
+#include "sbus/sssd_dbus_private.h"
 
-struct timeval _dbus_timeout_get_interval_tv(int interval) {
+/* =Watches=============================================================== */
+
+/*
+ * watch_handler
+ * Callback for D-BUS to handle messages on a file-descriptor
+ */
+static void sbus_watch_handler(struct tevent_context *ev,
+                               struct tevent_fd *fde,
+                               uint16_t flags, void *data)
+{
+    struct sbus_watch_ctx *watch = talloc_get_type(data,
+                                                   struct sbus_watch_ctx);
+
+    /* Take a reference while handling watch */
+    if (watch->dbus_type == SBUS_SERVER) {
+        dbus_server_ref(watch->dbus.server);
+    } else {
+        dbus_connection_ref(watch->dbus.conn);
+    }
+
+    /* Fire if readable */
+    if (flags & TEVENT_FD_READ) {
+        dbus_watch_handle(watch->dbus_watch, DBUS_WATCH_READABLE);
+    }
+
+    /* Fire if writeable */
+    if (flags & TEVENT_FD_WRITE) {
+        dbus_watch_handle(watch->dbus_watch, DBUS_WATCH_WRITABLE);
+    }
+
+    /* Release reference once done */
+    if (watch->dbus_type == SBUS_SERVER) {
+        dbus_server_unref(watch->dbus.server);
+    } else {
+        dbus_connection_unref(watch->dbus.conn);
+    }
+}
+
+/*
+ * add_watch
+ * Set up hooks into the libevents mainloop for
+ * D-BUS to add file descriptor-based events
+ */
+dbus_bool_t sbus_add_watch(DBusWatch *dbus_watch, void *data)
+{
+    unsigned int flags;
+    uint16_t event_flags;
+    struct sbus_generic_dbus_ctx *gen_ctx;
+    struct sbus_watch_ctx *watch;
+    int fd;
+
+    gen_ctx = talloc_get_type(data, struct sbus_generic_dbus_ctx);
+
+    watch = talloc_zero(gen_ctx, struct sbus_watch_ctx);
+    if (!watch) {
+        DEBUG(0, ("Outr of Memory!\n"));
+        return FALSE;
+    }
+    watch->dbus_watch = dbus_watch;
+    watch->dbus_type = gen_ctx->type;
+    watch->dbus = gen_ctx->dbus;
+
+#ifdef HAVE_DBUS_WATCH_GET_UNIX_FD
+    fd = dbus_watch_get_unix_fd(dbus_watch);
+#else
+    fd = dbus_watch_get_fd(dbus_watch);
+#endif
+
+    flags = dbus_watch_get_flags(dbus_watch);
+    event_flags = 0;
+
+    if (dbus_watch_get_enabled(dbus_watch)) {
+        if (flags & DBUS_WATCH_READABLE) {
+            event_flags |= TEVENT_FD_READ;
+        }
+        if (flags & DBUS_WATCH_WRITABLE) {
+            event_flags |= TEVENT_FD_WRITE;
+        }
+    }
+
+    DEBUG(8, ("%p: %d, %d=%s/%s\n",
+              dbus_watch, fd, flags,
+              ((event_flags & TEVENT_FD_READ)?"R":"-"),
+              ((event_flags & TEVENT_FD_WRITE)?"W":"-")));
+
+    /* Add the file descriptor to the event loop */
+    watch->fde = tevent_add_fd(gen_ctx->ev,
+                               watch, fd, event_flags,
+                               sbus_watch_handler, watch);
+    if (!watch->fde) {
+        DEBUG(0, ("Failed to set up fd event!\n"));
+        return FALSE;
+    }
+
+    /* Save the event to the watch object so it can be removed later */
+    dbus_watch_set_data(dbus_watch, watch, NULL);
+
+    return TRUE;
+}
+
+/*
+ * toggle_watch
+ * Hook for D-BUS to toggle the enabled/disabled state of
+ * an event in the mainloop
+ */
+void sbus_toggle_watch(DBusWatch *dbus_watch, void *data)
+{
+    struct sbus_watch_ctx *watch;
+    uint16_t event_flags = 0;
+    unsigned int flags;
+    void *watch_data;
+
+    watch_data = dbus_watch_get_data(dbus_watch);
+    watch = talloc_get_type(watch_data, struct sbus_watch_ctx);
+    if (!watch) {
+        DEBUG(0, ("Watch does not carry watch context?!\n"));
+        /* TODO: abort ? */
+        return;
+    }
+
+    flags = dbus_watch_get_flags(dbus_watch);
+
+    if (dbus_watch_get_enabled(dbus_watch)) {
+        if (flags & DBUS_WATCH_READABLE) {
+            TEVENT_FD_READABLE(watch->fde);
+        }
+        if (flags & DBUS_WATCH_WRITABLE) {
+            TEVENT_FD_WRITEABLE(watch->fde);
+        }
+    } else {
+        if (flags & DBUS_WATCH_READABLE) {
+            TEVENT_FD_NOT_READABLE(watch->fde);
+        }
+        if (flags & DBUS_WATCH_WRITABLE) {
+            TEVENT_FD_NOT_WRITEABLE(watch->fde);
+        }
+    }
+
+    if (debug_level >= 8) {
+        event_flags = tevent_fd_get_flags(watch->fde);
+    }
+    DEBUG(8, ("%p: %p, %d=%s/%s\n",
+              dbus_watch, watch, flags,
+              ((event_flags & TEVENT_FD_READ)?"R":"-"),
+              ((event_flags & TEVENT_FD_WRITE)?"W":"-")));
+}
+
+/*
+ * sbus_remove_watch
+ * Hook for D-BUS to remove file descriptor-based events
+ * from the libevents mainloop
+ */
+void sbus_remove_watch(DBusWatch *dbus_watch, void *data)
+{
+    void *watch;
+
+    DEBUG(8, ("%p\n", dbus_watch));
+
+    watch = dbus_watch_get_data(dbus_watch);
+
+    /* remove dbus watch data */
+    dbus_watch_set_data(dbus_watch, NULL, NULL);
+
+    /* Freeing the event object will remove it from the event loop */
+    talloc_free(watch);
+}
+
+/* =Timeouts============================================================== */
+
+static struct timeval _get_interval_tv(int interval) {
     struct timeval tv;
     struct timeval rightnow;
 
@@ -16,35 +187,96 @@ struct timeval _dbus_timeout_get_interval_tv(int interval) {
 }
 
 /*
- * sbus_remove_watch
- * Hook for D-BUS to remove file descriptor-based events
- * from the libevents mainloop
+ * timeout_handler
+ * Callback for D-BUS to handle timed events
  */
-void sbus_remove_watch(DBusWatch *watch, void *data) {
-    struct tevent_fd *fde;
+static void sbus_timeout_handler(struct tevent_context *ev,
+                                 struct tevent_timer *te,
+                                 struct timeval t, void *data)
+{
+    struct sbus_timeout_ctx *timeout;
+    timeout = talloc_get_type(data, struct sbus_timeout_ctx);
 
-    DEBUG(5, ("%lX\n", watch));
-    fde = talloc_get_type(dbus_watch_get_data(watch), struct tevent_fd);
+    dbus_timeout_handle(timeout->dbus_timeout);
+}
 
-    /* Freeing the event object will remove it from the event loop */
-    talloc_free(fde);
-    dbus_watch_set_data(watch, NULL, NULL);
+/*
+ * add_timeout
+ * Hook for D-BUS to add time-based events to the mainloop
+ */
+dbus_bool_t sbus_add_timeout(DBusTimeout *dbus_timeout, void *data)
+{
+    struct sbus_generic_dbus_ctx *gen_ctx;
+    struct sbus_timeout_ctx *timeout;
+    struct timeval tv;
+
+    DEBUG(8, ("%p\n", dbus_timeout));
+
+    if (!dbus_timeout_get_enabled(dbus_timeout)) {
+        return TRUE;
+    }
+
+    gen_ctx = talloc_get_type(data, struct sbus_generic_dbus_ctx);
+
+    timeout = talloc_zero(gen_ctx, struct sbus_timeout_ctx);
+    if (!timeout) {
+        DEBUG(0, ("Outr of Memory!\n"));
+        return FALSE;
+    }
+    timeout->dbus_timeout = dbus_timeout;
+
+    tv = _get_interval_tv(dbus_timeout_get_interval(dbus_timeout));
+    timeout->te = tevent_add_timer(gen_ctx->ev, timeout, tv,
+                                   sbus_timeout_handler, timeout);
+    if (!timeout->te) {
+        DEBUG(0, ("Failed to set up timeout event!\n"));
+        return FALSE;
+    }
+
+    /* Save the event to the watch object so it can be removed later */
+    dbus_timeout_set_data(timeout->dbus_timeout, timeout, NULL);
+
+    return TRUE;
 }
 
+/*
+ * sbus_toggle_timeout
+ * Hook for D-BUS to toggle the enabled/disabled state of a mainloop
+ * event
+ */
+void sbus_toggle_timeout(DBusTimeout *dbus_timeout, void *data)
+{
+    DEBUG(8, ("%p\n", dbus_timeout));
+
+    if (dbus_timeout_get_enabled(dbus_timeout)) {
+        sbus_add_timeout(dbus_timeout, data);
+    } else {
+        sbus_remove_timeout(dbus_timeout, data);
+    }
+}
 
 /*
  * sbus_remove_timeout
  * Hook for D-BUS to remove time-based events from the mainloop
  */
-void sbus_remove_timeout(DBusTimeout *timeout, void *data) {
-    struct tevent_timer *te;
-    te = talloc_get_type(dbus_timeout_get_data(timeout), struct tevent_timer);
+void sbus_remove_timeout(DBusTimeout *dbus_timeout, void *data)
+{
+    void *timeout;
+
+    DEBUG(8, ("%p\n", dbus_timeout));
+
+    timeout = dbus_timeout_get_data(dbus_timeout);
+
+    /* remove dbus timeout data */
+    dbus_timeout_set_data(dbus_timeout, NULL, NULL);
 
     /* Freeing the event object will remove it from the event loop */
-    talloc_free(te);
-    dbus_timeout_set_data(timeout, NULL, NULL);
+    talloc_free(timeout);
+
 }
 
+/* =Helpers=============================================================== */
+
 int sbus_is_dbus_fixed_type(int dbus_type)
 {
     switch (dbus_type) {
diff --git a/server/sbus/sssd_dbus_connection.c b/server/sbus/sssd_dbus_connection.c
index 3fb3f68a0..3ea09ca08 100644
--- a/server/sbus/sssd_dbus_connection.c
+++ b/server/sbus/sssd_dbus_connection.c
@@ -29,19 +29,6 @@ struct sbus_message_handler_ctx {
     struct sbus_method_ctx *method_ctx;
 };
 
-struct sbus_watch_ctx {
-    struct sbus_conn_ctx *conn_ctx;
-    DBusWatch *watch;
-    int fd;
-    struct tevent_fd *fde;
-};
-
-struct sbus_timeout_ctx {
-    struct sbus_conn_ctx *conn_ctx;
-    DBusTimeout *timeout;
-    struct tevent_timer *te;
-};
-
 static int _method_list_contains_path(struct sbus_method_ctx *list,
                                       struct sbus_method_ctx *method);
 static void sbus_unreg_object_paths(struct sbus_conn_ctx *conn_ctx);
@@ -49,8 +36,8 @@ static void sbus_unreg_object_paths(struct sbus_conn_ctx *conn_ctx);
 static int sbus_auto_reconnect(struct sbus_conn_ctx *conn_ctx);
 
 static void sbus_dispatch(struct tevent_context *ev,
-                               struct tevent_timer *te,
-                               struct timeval tv, void *data)
+                          struct tevent_timer *te,
+                          struct timeval tv, void *data)
 {
     struct tevent_timer *new_event;
     struct sbus_conn_ctx *conn_ctx;
@@ -126,160 +113,6 @@ static void sbus_dispatch(struct tevent_context *ev,
     }
 }
 
-/*
- * dbus_connection_read_write_handler
- * Callback for D-BUS to handle messages on a file-descriptor
- */
-static void sbus_conn_read_write_handler(struct tevent_context *ev,
-                                         struct tevent_fd *fde,
-                                         uint16_t flags, void *data)
-{
-    struct sbus_watch_ctx *watch_ctx;
-    watch_ctx = talloc_get_type(data, struct sbus_watch_ctx);
-
-    DEBUG(6,("Connection is open for read/write.\n"));
-    dbus_connection_ref(watch_ctx->conn_ctx->dbus_conn);
-    if (flags & TEVENT_FD_READ) {
-        dbus_watch_handle(watch_ctx->watch, DBUS_WATCH_READABLE);
-    }
-    if (flags & TEVENT_FD_WRITE) {
-        dbus_watch_handle(watch_ctx->watch, DBUS_WATCH_WRITABLE);
-    }
-    dbus_connection_unref(watch_ctx->conn_ctx->dbus_conn);
-}
-
-/*
- * add_connection_watch
- * Set up hooks into the libevents mainloop for
- * D-BUS to add file descriptor-based events
- */
-static dbus_bool_t sbus_add_conn_watch(DBusWatch *watch, void *data)
-{
-    unsigned int flags;
-    unsigned int event_flags;
-    struct sbus_conn_ctx *conn_ctx;
-    struct sbus_watch_ctx *watch_ctx;
-
-    if (!dbus_watch_get_enabled(watch)) {
-        return TRUE;
-    }
-
-    conn_ctx = talloc_get_type(data, struct sbus_conn_ctx);
-
-    watch_ctx = talloc_zero(conn_ctx, struct sbus_watch_ctx);
-    watch_ctx->conn_ctx = conn_ctx;
-    watch_ctx->watch = watch;
-
-    flags = dbus_watch_get_flags(watch);
-#ifdef HAVE_DBUS_WATCH_GET_UNIX_FD
-    watch_ctx->fd = dbus_watch_get_unix_fd(watch);
-#else
-    watch_ctx->fd = dbus_watch_get_fd(watch);
-#endif
-
-    event_flags = 0;
-
-    if (flags & DBUS_WATCH_READABLE)
-        event_flags |= TEVENT_FD_READ;
-
-    if (flags & DBUS_WATCH_WRITABLE)
-        event_flags |= TEVENT_FD_WRITE;
-
-    if (event_flags == 0)
-        return FALSE;
-
-    DEBUG(5,("%lX: %d, %d=%s\n",
-             watch, watch_ctx->fd, event_flags,
-             event_flags==TEVENT_FD_READ?"READ":"WRITE"));
-
-    /* Add the file descriptor to the event loop */
-    watch_ctx->fde = tevent_add_fd(watch_ctx->conn_ctx->ev, watch_ctx,
-                                   watch_ctx->fd, event_flags,
-                                   sbus_conn_read_write_handler,
-                                   watch_ctx);
-
-    /* Save the event to the watch object so it can be removed later */
-    dbus_watch_set_data(watch_ctx->watch, watch_ctx->fde, NULL);
-
-    return TRUE;
-}
-
-/*
- * toggle_connection_watch
- * Hook for D-BUS to toggle the enabled/disabled state of
- * an event in the mainloop
- */
-static void sbus_toggle_conn_watch(DBusWatch *watch, void *data)
-{
-    if (dbus_watch_get_enabled(watch)) {
-        sbus_add_conn_watch(watch, data);
-    } else {
-        sbus_remove_watch(watch, data);
-    }
-}
-
-/*
- * dbus_connection_timeout_handler
- * Callback for D-BUS to handle timed events
- */
-static void sbus_conn_timeout_handler(struct tevent_context *ev,
-                                            struct tevent_timer *te,
-                                            struct timeval t, void *data)
-{
-    struct sbus_timeout_ctx *timeout_ctx;
-    timeout_ctx = talloc_get_type(data, struct sbus_timeout_ctx);
-
-    dbus_timeout_handle(timeout_ctx->timeout);
-}
-
-
-/*
- * add_connection_timeout
- * Hook for D-BUS to add time-based events to the mainloop
- */
-static dbus_bool_t sbus_add_conn_timeout(DBusTimeout *timeout, void *data)
-{
-    struct sbus_conn_ctx *conn_ctx;
-    struct sbus_timeout_ctx *timeout_ctx;
-    struct timeval tv;
-
-    if (!dbus_timeout_get_enabled(timeout))
-        return TRUE;
-
-    conn_ctx = talloc_get_type(data, struct sbus_conn_ctx);
-
-    timeout_ctx = talloc_zero(conn_ctx,struct sbus_timeout_ctx);
-    timeout_ctx->conn_ctx = conn_ctx;
-    timeout_ctx->timeout = timeout;
-
-    tv = _dbus_timeout_get_interval_tv(dbus_timeout_get_interval(timeout));
-
-    struct timeval rightnow;
-    gettimeofday(&rightnow, NULL);
-
-    timeout_ctx->te = tevent_add_timer(conn_ctx->ev, timeout_ctx, tv,
-                                       sbus_conn_timeout_handler, timeout_ctx);
-
-    /* Save the event to the watch object so it can be removed later */
-    dbus_timeout_set_data(timeout_ctx->timeout, timeout_ctx->te, NULL);
-
-    return TRUE;
-}
-
-/*
- * sbus_toggle_conn_timeout
- * Hook for D-BUS to toggle the enabled/disabled state of a mainloop
- * event
- */
-void sbus_toggle_conn_timeout(DBusTimeout *timeout, void *data)
-{
-    if (dbus_timeout_get_enabled(timeout)) {
-        sbus_add_conn_timeout(timeout, data);
-    } else {
-        sbus_remove_timeout(timeout, data);
-    }
-}
-
 /* dbus_connection_wakeup_main
  * D-BUS makes a callback to the wakeup_main function when
  * it has data available for dispatching.
@@ -337,19 +170,20 @@ int sbus_add_connection(TALLOC_CTX *ctx,
     conn_ctx->max_retries = 0;
     conn_ctx->reconnect_callback = NULL;
 
-    ret = sbus_add_connection_int(&conn_ctx);
+    *_conn_ctx = conn_ctx;
+
+    ret = sbus_add_connection_int(_conn_ctx);
     if (ret != EOK) {
         talloc_free(conn_ctx);
-        return ret;
     }
-    *_conn_ctx = conn_ctx;
-    return EOK;
+    return ret;
 }
 
 static int sbus_add_connection_int(struct sbus_conn_ctx **_conn_ctx)
 {
-    dbus_bool_t dbret;
     struct sbus_conn_ctx *conn_ctx = *_conn_ctx;
+    struct sbus_generic_dbus_ctx *gen_ctx;
+    dbus_bool_t dbret;
 
     /*
      * Set the default destructor
@@ -358,12 +192,21 @@ static int sbus_add_connection_int(struct sbus_conn_ctx **_conn_ctx)
      */
     sbus_conn_set_destructor(conn_ctx, NULL);
 
+    gen_ctx = talloc_zero(conn_ctx, struct sbus_generic_dbus_ctx);
+    if (!gen_ctx) {
+        DEBUG(0, ("Out of memory!\n"));
+        return ENOMEM;
+    }
+    gen_ctx->ev = conn_ctx->ev;
+    gen_ctx->type = SBUS_CONNECTION;
+    gen_ctx->dbus.conn = conn_ctx->dbus_conn;
+
     /* Set up DBusWatch functions */
     dbret = dbus_connection_set_watch_functions(conn_ctx->dbus_conn,
-                                                sbus_add_conn_watch,
+                                                sbus_add_watch,
                                                 sbus_remove_watch,
-                                                sbus_toggle_conn_watch,
-                                                conn_ctx, NULL);
+                                                sbus_toggle_watch,
+                                                gen_ctx, NULL);
     if (!dbret) {
         DEBUG(2,("Error setting up D-BUS connection watch functions\n"));
         return EIO;
@@ -371,10 +214,10 @@ static int sbus_add_connection_int(struct sbus_conn_ctx **_conn_ctx)
 
     /* Set up DBusTimeout functions */
     dbret = dbus_connection_set_timeout_functions(conn_ctx->dbus_conn,
-                                                  sbus_add_conn_timeout,
+                                                  sbus_add_timeout,
                                                   sbus_remove_timeout,
-                                                  sbus_toggle_conn_timeout,
-                                                  conn_ctx, NULL);
+                                                  sbus_toggle_timeout,
+                                                  gen_ctx, NULL);
     if (!dbret) {
         DEBUG(2,("Error setting up D-BUS server timeout functions\n"));
         /* FIXME: free resources ? */
diff --git a/server/sbus/sssd_dbus_private.h b/server/sbus/sssd_dbus_private.h
index bcaee62cd..fdee121e9 100644
--- a/server/sbus/sssd_dbus_private.h
+++ b/server/sbus/sssd_dbus_private.h
@@ -1,8 +1,43 @@
 #ifndef _SSSD_DBUS_PRIVATE_H_
 #define _SSSD_DBUS_PRIVATE_H_
 
-struct timeval _dbus_timeout_get_interval_tv(int interval);
+union dbus_pointer {
+    DBusServer *server;
+    DBusConnection *conn;
+};
+enum dbus_pointer_type {
+    SBUS_SERVER,
+    SBUS_CONNECTION
+};
+
+struct sbus_generic_dbus_ctx {
+    struct tevent_context *ev;
+    enum dbus_pointer_type type;
+    union dbus_pointer dbus;
+};
+
+/* =Watches=============================================================== */
+
+struct sbus_watch_ctx {
+    DBusWatch *dbus_watch;
+    enum dbus_pointer_type dbus_type;
+    union dbus_pointer dbus;
+    struct tevent_fd *fde;
+};
+
+dbus_bool_t sbus_add_watch(DBusWatch *watch, void *data);
+void sbus_toggle_watch(DBusWatch *watch, void *data);
 void sbus_remove_watch(DBusWatch *watch, void *data);
-void sbus_remove_timeout(DBusTimeout *timeout, void *data);
+
+/* =Timeouts============================================================== */
+
+struct sbus_timeout_ctx {
+    DBusTimeout *dbus_timeout;
+    struct tevent_timer *te;
+};
+
+dbus_bool_t sbus_add_timeout(DBusTimeout *dbus_timeout, void *data);
+void sbus_toggle_timeout(DBusTimeout *dbus_timeout, void *data);
+void sbus_remove_timeout(DBusTimeout *dbus_timeout, void *data);
 
 #endif /* _SSSD_DBUS_PRIVATE_H_ */
diff --git a/server/sbus/sssd_dbus_server.c b/server/sbus/sssd_dbus_server.c
index cf668d332..6df004d31 100644
--- a/server/sbus/sssd_dbus_server.c
+++ b/server/sbus/sssd_dbus_server.c
@@ -43,160 +43,9 @@ struct sbus_srv_ctx {
     void *init_pvt_data;
 };
 
-struct sbus_srv_watch_ctx {
-    DBusWatch *watch;
-    int fd;
-    struct tevent_fd *fde;
-    struct sbus_srv_ctx *srv_ctx;
-};
-
-struct dbus_srv_timeout_ctx {
-    DBusTimeout *timeout;
-    struct tevent_timer *te;
-    struct sbus_srv_ctx *srv_ctx;
-};
-
 static int sbus_server_destructor(void *ctx);
 
 /*
- * dbus_server_read_write_handler
- * Callback for D-BUS to handle messages on a file-descriptor
- */
-static void sbus_srv_read_write_handler(struct tevent_context *ev,
-                                        struct tevent_fd *fde,
-                                        uint16_t flags, void *data)
-{
-    struct sbus_srv_watch_ctx *watch_ctx;
-    watch_ctx = talloc_get_type(data, struct sbus_srv_watch_ctx);
-
-    dbus_server_ref(watch_ctx->srv_ctx->dbus_server);
-    if (flags & TEVENT_FD_READ) {
-        dbus_watch_handle(watch_ctx->watch, DBUS_WATCH_READABLE);
-    }
-    if (flags & TEVENT_FD_WRITE) {
-        dbus_watch_handle(watch_ctx->watch, DBUS_WATCH_WRITABLE);
-    }
-    dbus_server_unref(watch_ctx->srv_ctx->dbus_server);
-}
-
-/*
- * add_server_watch
- * Set up hooks into the libevents mainloop for
- * D-BUS to add file descriptor-based events
- */
-static dbus_bool_t sbus_add_srv_watch(DBusWatch *watch, void *data)
-{
-    unsigned int flags;
-    unsigned int event_flags;
-    struct sbus_srv_ctx *srv_ctx;
-    struct sbus_srv_watch_ctx *watch_ctx;
-
-    if (!dbus_watch_get_enabled(watch)) {
-        return FALSE;
-    }
-
-    srv_ctx = talloc_get_type(data, struct sbus_srv_ctx);
-
-    watch_ctx = talloc_zero(srv_ctx, struct sbus_srv_watch_ctx);
-    watch_ctx->srv_ctx = srv_ctx;
-    watch_ctx->watch = watch;
-
-    flags = dbus_watch_get_flags(watch);
-#ifdef HAVE_DBUS_WATCH_GET_UNIX_FD
-    watch_ctx->fd = dbus_watch_get_unix_fd(watch);
-#else
-    watch_ctx->fd = dbus_watch_get_fd(watch);
-#endif
-
-    event_flags = 0;
-
-    if (flags & DBUS_WATCH_READABLE) {
-        event_flags |= TEVENT_FD_READ;
-    }
-
-    if (flags & DBUS_WATCH_WRITABLE) {
-        event_flags |= TEVENT_FD_WRITE;
-    }
-    DEBUG(5,("%lX: %d, %d=%s\n", watch, watch_ctx->fd, event_flags, event_flags==TEVENT_FD_READ?"READ":"WRITE"));
-
-    watch_ctx->fde = tevent_add_fd(srv_ctx->ev, watch_ctx, watch_ctx->fd,
-                                event_flags, sbus_srv_read_write_handler,
-                                watch_ctx);
-
-    /* Save the event to the watch object so it can be removed later */
-    dbus_watch_set_data(watch_ctx->watch, watch_ctx->fde, NULL);
-
-    return TRUE;
-}
-
-/*
- * server_watch_toggled
- * Hook for D-BUS to toggle the enabled/disabled state of
- * an event in the mainloop
- */
-static void sbus_toggle_srv_watch(DBusWatch *watch, void *data)
-{
-    if (dbus_watch_get_enabled(watch)) {
-        sbus_add_srv_watch(watch, data);
-    } else {
-        sbus_remove_watch(watch, data);
-    }
-}
-
-static void sbus_srv_timeout_handler(struct tevent_context *ev,
-                                     struct tevent_timer *te,
-                                     struct timeval t, void *data)
-{
-    struct dbus_srv_timeout_ctx *timeout_ctx;
-    timeout_ctx = talloc_get_type(data, struct dbus_srv_timeout_ctx);
-    dbus_timeout_handle(timeout_ctx->timeout);
-}
-
-/*
- * add_server_timeout
- * Hook for D-BUS to add time-based events to the mainloop
- */
-static dbus_bool_t sbus_add_srv_timeout(DBusTimeout *timeout, void *data)
-{
-    struct sbus_srv_ctx *srv_ctx;
-    struct dbus_srv_timeout_ctx *timeout_ctx;
-    struct timeval tv;
-
-    if (!dbus_timeout_get_enabled(timeout))
-        return TRUE;
-
-    srv_ctx = talloc_get_type(data, struct sbus_srv_ctx);
-
-    timeout_ctx = talloc_zero(srv_ctx,struct dbus_srv_timeout_ctx);
-    timeout_ctx->srv_ctx = srv_ctx;
-    timeout_ctx->timeout = timeout;
-
-    tv = _dbus_timeout_get_interval_tv(dbus_timeout_get_interval(timeout));
-
-    timeout_ctx->te = tevent_add_timer(srv_ctx->ev, timeout_ctx, tv,
-                                  sbus_srv_timeout_handler, timeout_ctx);
-
-    /* Save the event to the watch object so it can be removed later */
-    dbus_timeout_set_data(timeout_ctx->timeout, timeout_ctx->te, NULL);
-
-    return TRUE;
-}
-
-/*
- * server_timeout_toggled
- * Hook for D-BUS to toggle the enabled/disabled state of a mainloop
- * event
- */
-static void sbus_toggle_srv_timeout(DBusTimeout *timeout, void *data)
-{
-    if (dbus_timeout_get_enabled(timeout)) {
-        sbus_add_srv_timeout(timeout, data);
-    } else {
-        sbus_remove_timeout(timeout, data);
-    }
-}
-
-/*
  * new_connection_callback
  * Actions to be run upon each new client connection
  * Must either perform dbus_connection_ref() on the
@@ -262,6 +111,7 @@ int sbus_new_server(TALLOC_CTX *mem_ctx,
                     struct sbus_srv_ctx **_srv_ctx, const char *address,
                     sbus_server_conn_init_fn init_fn, void *init_pvt_data)
 {
+    struct sbus_generic_dbus_ctx *gen_ctx;
     struct sbus_srv_ctx *srv_ctx;
     DBusServer *dbus_server;
     DBusError dbus_error;
@@ -295,6 +145,15 @@ int sbus_new_server(TALLOC_CTX *mem_ctx,
     srv_ctx->init_fn = init_fn;
     srv_ctx->init_pvt_data = init_pvt_data;
 
+    gen_ctx = talloc_zero(srv_ctx, struct sbus_generic_dbus_ctx);
+    if (!gen_ctx) {
+        talloc_free(srv_ctx);
+        return ENOMEM;
+    }
+    gen_ctx->ev = ev;
+    gen_ctx->type = SBUS_SERVER;
+    gen_ctx->dbus.server = dbus_server;
+
     talloc_set_destructor((TALLOC_CTX *)srv_ctx, sbus_server_destructor);
 
     /* Set up D-BUS new connection handler */
@@ -304,10 +163,10 @@ int sbus_new_server(TALLOC_CTX *mem_ctx,
 
     /* Set up DBusWatch functions */
     dbret = dbus_server_set_watch_functions(srv_ctx->dbus_server,
-                                            sbus_add_srv_watch,
+                                            sbus_add_watch,
                                             sbus_remove_watch,
-                                            sbus_toggle_srv_watch,
-                                            srv_ctx, NULL);
+                                            sbus_toggle_watch,
+                                            gen_ctx, NULL);
     if (!dbret) {
         DEBUG(4, ("Error setting up D-BUS server watch functions"));
         talloc_free(srv_ctx);
@@ -316,10 +175,10 @@ int sbus_new_server(TALLOC_CTX *mem_ctx,
 
     /* Set up DBusTimeout functions */
     dbret = dbus_server_set_timeout_functions(srv_ctx->dbus_server,
-                                              sbus_add_srv_timeout,
+                                              sbus_add_timeout,
                                               sbus_remove_timeout,
-                                              sbus_toggle_srv_timeout,
-                                              srv_ctx, NULL);
+                                              sbus_toggle_timeout,
+                                              gen_ctx, NULL);
     if (!dbret) {
         DEBUG(4,("Error setting up D-BUS server timeout functions"));
         dbus_server_set_watch_functions(srv_ctx->dbus_server,