summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--server/dbus/sssd_dbus.h60
-rw-r--r--server/dbus/sssd_dbus_common.c8
-rw-r--r--server/dbus/sssd_dbus_connection.c190
-rw-r--r--server/dbus/sssd_dbus_private.h8
-rw-r--r--server/dbus/sssd_dbus_server.c100
-rw-r--r--server/dbus/tests/test_client.c24
-rw-r--r--server/monitor.c22
7 files changed, 205 insertions, 207 deletions
diff --git a/server/dbus/sssd_dbus.h b/server/dbus/sssd_dbus.h
index 2b8a7787..1bd062d4 100644
--- a/server/dbus/sssd_dbus.h
+++ b/server/dbus/sssd_dbus.h
@@ -21,68 +21,66 @@
#ifndef _SSSD_DBUS_H_
#define _SSSD_DBUS_H_
-struct dbus_connection_toplevel_context;
-typedef int (*sssd_dbus_msg_handler_fn)(DBusMessage *msg, void *data,
+struct sbus_conn_ctx;
+typedef int (*sbus_msg_handler_fn)(DBusMessage *msg, void *data,
DBusMessage **reply);
/*
- * sssd_dbus_connection_destructor_fn
+ * sbus_conn_destructor_fn
* Function to be called when a connection is finalized
*/
-typedef int (*sssd_dbus_connection_destructor_fn)(
+typedef int (*sbus_conn_destructor_fn)(
void *ctx);
/*
- * sssd_dbus_server_connection_init_fn
+ * sbus_server_conn_init_fn
* Set up function for connection-specific activities
- * This function should define the sssd_dbus_connection_destructor_fn
+ * This function should define the sbus_conn_destructor_fn
* for this connection at a minimum
*/
-typedef int (*sssd_dbus_server_connection_init_fn)(
- struct dbus_connection_toplevel_context *dct_ctx);
-
-extern int connection_type_slot;
+typedef int (*sbus_server_conn_init_fn)(
+ struct sbus_conn_ctx *dct_ctx);
enum {
- DBUS_CONNECTION_TYPE_PRIVATE = 1,
- DBUS_CONNECTION_TYPE_SHARED
+ SBUS_CONN_TYPE_PRIVATE = 1,
+ SBUS_CONN_TYPE_SHARED
};
-struct sssd_dbus_method {
+struct sbus_method {
const char *method;
- sssd_dbus_msg_handler_fn fn;
+ sbus_msg_handler_fn fn;
};
-struct sssd_dbus_method_ctx {
- struct sssd_dbus_method_ctx *prev, *next;
+struct sbus_method_ctx {
+ struct sbus_method_ctx *prev, *next;
/*struct event_context *ev;*/
char *interface;
char *path;
/* If a non-default message_handler is desired, set it in this
- * object before calling dbus_connection_add_method_ctx()
+ * object before calling sbus_conn_add_method_ctx()
* Otherwise it will default to message_handler() in
* sssd_dbus_connection.c
*/
DBusObjectPathMessageFunction message_handler;
- struct sssd_dbus_method *methods;
+ struct sbus_method *methods;
};
/* Server Functions */
-int sssd_new_dbus_server(struct event_context *ev, struct sssd_dbus_method_ctx *ctx, const char *address, sssd_dbus_server_connection_init_fn init_fn);
+int sbus_new_server(struct event_context *ev, struct sbus_method_ctx *ctx, const char *address, sbus_server_conn_init_fn init_fn);
/* Connection Functions */
-int sssd_new_dbus_connection(TALLOC_CTX *ctx, struct event_context *ev, const char *address,
- struct dbus_connection_toplevel_context **dct_ctx,
- sssd_dbus_connection_destructor_fn destructor);
-
-void sssd_dbus_connection_set_destructor(struct dbus_connection_toplevel_context *dct_ctx,
- sssd_dbus_connection_destructor_fn destructor);
-int default_connection_destructor(void *ctx);
-
-DBusConnection *sssd_get_dbus_connection(struct dbus_connection_toplevel_context *dct_ctx);
-void sssd_dbus_disconnect (struct dbus_connection_toplevel_context *dct_ctx);
-void sssd_connection_set_private_data(struct dbus_connection_toplevel_context *dct_ctx, void *private);
-int dbus_connection_add_method_ctx(struct dbus_connection_toplevel_context *dct_ctx, struct sssd_dbus_method_ctx *method_ctx);
+int sbus_new_connection(TALLOC_CTX *ctx, struct event_context *ev, const char *address,
+ struct sbus_conn_ctx **dct_ctx,
+ sbus_conn_destructor_fn destructor);
+
+void sbus_conn_set_destructor(struct sbus_conn_ctx *dct_ctx,
+ sbus_conn_destructor_fn destructor);
+int sbus_default_connection_destructor(void *ctx);
+
+DBusConnection *sbus_get_connection(struct sbus_conn_ctx *dct_ctx);
+void sbus_disconnect (struct sbus_conn_ctx *dct_ctx);
+void sbus_conn_set_private_data(struct sbus_conn_ctx *dct_ctx, void *private);
+int sbus_conn_add_method_ctx(struct sbus_conn_ctx *dct_ctx, struct sbus_method_ctx *method_ctx);
#endif /* _SSSD_DBUS_H_*/
diff --git a/server/dbus/sssd_dbus_common.c b/server/dbus/sssd_dbus_common.c
index c7af4b0b..0ea66ccb 100644
--- a/server/dbus/sssd_dbus_common.c
+++ b/server/dbus/sssd_dbus_common.c
@@ -15,11 +15,11 @@ struct timeval _dbus_timeout_get_interval_tv(int interval) {
}
/*
- * remove_watch
+ * sbus_remove_watch
* Hook for D-BUS to remove file descriptor-based events
* from the libevents mainloop
*/
-void remove_watch(DBusWatch *watch, void *data) {
+void sbus_remove_watch(DBusWatch *watch, void *data) {
struct fd_event *fde;
DEBUG(2, ("%lX\n", watch));
@@ -32,10 +32,10 @@ void remove_watch(DBusWatch *watch, void *data) {
/*
- * remove_timeout
+ * sbus_remove_timeout
* Hook for D-BUS to remove time-based events from the mainloop
*/
-void remove_timeout(DBusTimeout *timeout, void *data) {
+void sbus_remove_timeout(DBusTimeout *timeout, void *data) {
struct timed_event *te;
te = talloc_get_type(dbus_timeout_get_data(timeout), struct timed_event);
diff --git a/server/dbus/sssd_dbus_connection.c b/server/dbus/sssd_dbus_connection.c
index e9289e04..3a169f79 100644
--- a/server/dbus/sssd_dbus_connection.c
+++ b/server/dbus/sssd_dbus_connection.c
@@ -8,38 +8,38 @@
/* Types */
struct dbus_ctx_list;
-struct dbus_connection_toplevel_context {
+struct sbus_conn_ctx {
DBusConnection *conn;
struct event_context *ev;
int connection_type;
int disconnect;
- struct sssd_dbus_method_ctx *method_ctx_list;
- sssd_dbus_connection_destructor_fn destructor;
+ struct sbus_method_ctx *method_ctx_list;
+ sbus_conn_destructor_fn destructor;
void *private; /* Private data for this connection */
};
-struct dbus_connection_watch_context {
+struct sbus_conn_watch_ctx {
DBusWatch *watch;
int fd;
struct fd_event *fde;
- struct dbus_connection_toplevel_context *top;
+ struct sbus_conn_ctx *top;
};
-struct dbus_connection_timeout_context {
+struct sbus_conn_timeout_ctx {
DBusTimeout *timeout;
struct timed_event *te;
- struct dbus_connection_toplevel_context *top;
+ struct sbus_conn_ctx *top;
};
-static int method_list_contains_path(struct sssd_dbus_method_ctx *list, struct sssd_dbus_method_ctx *method);
-static void sssd_unregister_object_paths(struct dbus_connection_toplevel_context *dct_ctx);
+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 *dct_ctx);
-static void do_dispatch(struct event_context *ev,
+static void sbus_dispatch(struct event_context *ev,
struct timed_event *te,
struct timeval tv, void *data)
{
struct timed_event *new_event;
- struct dbus_connection_toplevel_context *dct_ctx;
+ struct sbus_conn_ctx *dct_ctx;
DBusConnection *conn;
int ret;
@@ -47,7 +47,7 @@ static void do_dispatch(struct event_context *ev,
return;
}
- dct_ctx = talloc_get_type(data, struct dbus_connection_toplevel_context);
+ dct_ctx = talloc_get_type(data, struct sbus_conn_ctx);
conn = dct_ctx->conn;
DEBUG(3, ("conn: %lX\n", conn));
@@ -77,7 +77,7 @@ static void do_dispatch(struct event_context *ev,
*/
ret = dbus_connection_get_dispatch_status(conn);
if (ret != DBUS_DISPATCH_COMPLETE) {
- new_event = event_add_timed(ev, ev, tv, do_dispatch, dct_ctx);
+ new_event = event_add_timed(ev, dct_ctx, tv, sbus_dispatch, dct_ctx);
if (new_event == NULL) {
DEBUG(0,("Could not add dispatch event!\n"));
@@ -91,12 +91,12 @@ static void do_dispatch(struct event_context *ev,
* dbus_connection_read_write_handler
* Callback for D-BUS to handle messages on a file-descriptor
*/
-static void dbus_connection_read_write_handler(struct event_context *ev,
+static void sbus_conn_read_write_handler(struct event_context *ev,
struct fd_event *fde,
uint16_t flags, void *data)
{
- struct dbus_connection_watch_context *conn_w_ctx;
- conn_w_ctx = talloc_get_type(data, struct dbus_connection_watch_context);
+ struct sbus_conn_watch_ctx *conn_w_ctx;
+ conn_w_ctx = talloc_get_type(data, struct sbus_conn_watch_ctx);
DEBUG(0,("Connection is open for read/write.\n"));
dbus_connection_ref(conn_w_ctx->top->conn);
@@ -114,20 +114,20 @@ static void dbus_connection_read_write_handler(struct event_context *ev,
* Set up hooks into the libevents mainloop for
* D-BUS to add file descriptor-based events
*/
-static dbus_bool_t add_connection_watch(DBusWatch *watch, void *data)
+static dbus_bool_t sbus_add_conn_watch(DBusWatch *watch, void *data)
{
unsigned int flags;
unsigned int event_flags;
- struct dbus_connection_toplevel_context *dt_ctx;
- struct dbus_connection_watch_context *conn_w_ctx;
+ struct sbus_conn_ctx *dt_ctx;
+ struct sbus_conn_watch_ctx *conn_w_ctx;
if (!dbus_watch_get_enabled(watch)) {
return TRUE;
}
- dt_ctx = talloc_get_type(data, struct dbus_connection_toplevel_context);
+ dt_ctx = talloc_get_type(data, struct sbus_conn_ctx);
- conn_w_ctx = talloc_zero(dt_ctx, struct dbus_connection_watch_context);
+ conn_w_ctx = talloc_zero(dt_ctx, struct sbus_conn_watch_ctx);
conn_w_ctx->top = dt_ctx;
conn_w_ctx->watch = watch;
@@ -150,7 +150,7 @@ static dbus_bool_t add_connection_watch(DBusWatch *watch, void *data)
/* Add the file descriptor to the event loop */
conn_w_ctx->fde = event_add_fd(conn_w_ctx->top->ev, conn_w_ctx,
conn_w_ctx->fd, event_flags,
- dbus_connection_read_write_handler,
+ sbus_conn_read_write_handler,
conn_w_ctx);
/* Save the event to the watch object so it can be removed later */
@@ -164,12 +164,12 @@ static dbus_bool_t add_connection_watch(DBusWatch *watch, void *data)
* Hook for D-BUS to toggle the enabled/disabled state of
* an event in the mainloop
*/
-static void toggle_connection_watch(DBusWatch *watch, void *data)
+static void sbus_toggle_conn_watch(DBusWatch *watch, void *data)
{
if (dbus_watch_get_enabled(watch)) {
- add_connection_watch(watch, data);
+ sbus_add_conn_watch(watch, data);
} else {
- remove_watch(watch, data);
+ sbus_remove_watch(watch, data);
}
}
@@ -177,12 +177,12 @@ static void toggle_connection_watch(DBusWatch *watch, void *data)
* dbus_connection_timeout_handler
* Callback for D-BUS to handle timed events
*/
-static void dbus_connection_timeout_handler(struct event_context *ev,
+static void sbus_conn_timeout_handler(struct event_context *ev,
struct timed_event *te,
struct timeval t, void *data)
{
- struct dbus_connection_timeout_context *conn_t_ctx;
- conn_t_ctx = talloc_get_type(data, struct dbus_connection_timeout_context);
+ struct sbus_conn_timeout_ctx *conn_t_ctx;
+ conn_t_ctx = talloc_get_type(data, struct sbus_conn_timeout_ctx);
dbus_timeout_handle(conn_t_ctx->timeout);
}
@@ -192,18 +192,18 @@ static void dbus_connection_timeout_handler(struct event_context *ev,
* add_connection_timeout
* Hook for D-BUS to add time-based events to the mainloop
*/
-static dbus_bool_t add_connection_timeout(DBusTimeout *timeout, void *data)
+static dbus_bool_t sbus_add_conn_timeout(DBusTimeout *timeout, void *data)
{
- struct dbus_connection_toplevel_context *dt_ctx;
- struct dbus_connection_timeout_context *conn_t_ctx;
+ struct sbus_conn_ctx *dt_ctx;
+ struct sbus_conn_timeout_ctx *conn_t_ctx;
struct timeval tv;
if (!dbus_timeout_get_enabled(timeout))
return TRUE;
- dt_ctx = talloc_get_type(data, struct dbus_connection_toplevel_context);
+ dt_ctx = talloc_get_type(data, struct sbus_conn_ctx);
- conn_t_ctx = talloc_zero(dt_ctx,struct dbus_connection_timeout_context);
+ conn_t_ctx = talloc_zero(dt_ctx,struct sbus_conn_timeout_ctx);
conn_t_ctx->top = dt_ctx;
conn_t_ctx->timeout = timeout;
@@ -213,7 +213,7 @@ static dbus_bool_t add_connection_timeout(DBusTimeout *timeout, void *data)
gettimeofday(&rightnow, NULL);
conn_t_ctx->te = event_add_timed(conn_t_ctx->top->ev, conn_t_ctx, tv,
- dbus_connection_timeout_handler, conn_t_ctx);
+ sbus_conn_timeout_handler, conn_t_ctx);
/* Save the event to the watch object so it can be removed later */
dbus_timeout_set_data(conn_t_ctx->timeout,conn_t_ctx->te,NULL);
@@ -222,16 +222,16 @@ static dbus_bool_t add_connection_timeout(DBusTimeout *timeout, void *data)
}
/*
- * toggle_connection_timeout
+ * sbus_toggle_conn_timeout
* Hook for D-BUS to toggle the enabled/disabled state of a mainloop
* event
*/
-void toggle_connection_timeout(DBusTimeout *timeout, void *data)
+void sbus_toggle_conn_timeout(DBusTimeout *timeout, void *data)
{
if (dbus_timeout_get_enabled(timeout)) {
- add_connection_timeout(timeout, data);
+ sbus_add_conn_timeout(timeout, data);
} else {
- remove_timeout(timeout, data);
+ sbus_remove_timeout(timeout, data);
}
}
@@ -242,17 +242,17 @@ void toggle_connection_timeout(DBusTimeout *timeout, void *data)
* timed event to perform the dispatch during the next iteration
* through the mainloop
*/
-static void dbus_connection_wakeup_main(void *data) {
- struct dbus_connection_toplevel_context *dct_ctx;
+static void sbus_conn_wakeup_main(void *data) {
+ struct sbus_conn_ctx *dct_ctx;
struct timeval tv;
struct timed_event *te;
- dct_ctx = talloc_get_type(data, struct dbus_connection_toplevel_context);
+ dct_ctx = talloc_get_type(data, struct sbus_conn_ctx);
gettimeofday(&tv, NULL);
/* D-BUS calls this function when it is time to do a dispatch */
- te = event_add_timed(dct_ctx->ev, dct_ctx->ev,
- tv, do_dispatch, dct_ctx);
+ te = event_add_timed(dct_ctx->ev, dct_ctx,
+ tv, sbus_dispatch, dct_ctx);
if (te == NULL) {
DEBUG(0,("Could not add dispatch event!\n"));
exit(1);
@@ -264,36 +264,36 @@ static void dbus_connection_wakeup_main(void *data) {
* Set up a D-BUS connection to use the libevents mainloop
* for handling file descriptor and timed events
*/
-int sssd_add_dbus_connection(TALLOC_CTX *ctx,
- struct event_context *ev,
- DBusConnection *dbus_conn,
- struct dbus_connection_toplevel_context **dct_ctx,
- int connection_type)
+int sbus_add_connection(TALLOC_CTX *ctx,
+ struct event_context *ev,
+ DBusConnection *dbus_conn,
+ struct sbus_conn_ctx **dct_ctx,
+ int connection_type)
{
dbus_bool_t dbret;
- struct dbus_connection_toplevel_context *dt_ctx;
+ struct sbus_conn_ctx *dt_ctx;
DEBUG(0,("Adding connection %lX\n", dbus_conn));
- dt_ctx = talloc_zero(ctx, struct dbus_connection_toplevel_context);
+ dt_ctx = talloc_zero(ctx, struct sbus_conn_ctx);
dt_ctx->ev = ev;
dt_ctx->conn = dbus_conn;
dt_ctx->connection_type = connection_type;
dt_ctx->disconnect = 0;
- /* This will be replaced on the first call to dbus_connection_add_method_ctx() */
+ /* This will be replaced on the first call to sbus_conn_add_method_ctx() */
dt_ctx->method_ctx_list = NULL;
/*
* Set the default destructor
* Connections can override this with
- * sssd_dbus_connection_set_destructor
+ * sbus_conn_set_destructor
*/
- sssd_dbus_connection_set_destructor(dt_ctx, NULL);
+ sbus_conn_set_destructor(dt_ctx, NULL);
/* Set up DBusWatch functions */
dbret = dbus_connection_set_watch_functions(dt_ctx->conn,
- add_connection_watch,
- remove_watch,
- toggle_connection_watch,
+ sbus_add_conn_watch,
+ sbus_remove_watch,
+ sbus_toggle_conn_watch,
dt_ctx, NULL);
if (!dbret) {
DEBUG(0,("Error setting up D-BUS connection watch functions\n"));
@@ -302,9 +302,9 @@ int sssd_add_dbus_connection(TALLOC_CTX *ctx,
/* Set up DBusTimeout functions */
dbret = dbus_connection_set_timeout_functions(dt_ctx->conn,
- add_connection_timeout,
- remove_timeout,
- toggle_connection_timeout,
+ sbus_add_conn_timeout,
+ sbus_remove_timeout,
+ sbus_toggle_conn_timeout,
dt_ctx, NULL);
if (!dbret) {
DEBUG(0,("Error setting up D-BUS server timeout functions\n"));
@@ -314,7 +314,7 @@ int sssd_add_dbus_connection(TALLOC_CTX *ctx,
/* Set up dispatch handler */
dbus_connection_set_wakeup_main_function(dt_ctx->conn,
- dbus_connection_wakeup_main,
+ sbus_conn_wakeup_main,
dt_ctx, NULL);
/* Set up any method_contexts passed in */
@@ -324,7 +324,7 @@ int sssd_add_dbus_connection(TALLOC_CTX *ctx,
* If there are no messages to be dispatched, this will do
* nothing.
*/
- dbus_connection_wakeup_main(dt_ctx);
+ sbus_conn_wakeup_main(dt_ctx);
/* Return the new toplevel object */
*dct_ctx = dt_ctx;
@@ -332,12 +332,12 @@ int sssd_add_dbus_connection(TALLOC_CTX *ctx,
return EOK;
}
-/*int sssd_new_dbus_connection(struct sssd_dbus_method_ctx *ctx, const char *address,
+/*int sbus_new_connection(struct sbus_method_ctx *ctx, const char *address,
DBusConnection **connection,
- sssd_dbus_connection_destructor_fn destructor)*/
-int sssd_new_dbus_connection(TALLOC_CTX *ctx, struct event_context *ev, const char *address,
- struct dbus_connection_toplevel_context **dct_ctx,
- sssd_dbus_connection_destructor_fn destructor)
+ sbus_conn_destructor_fn destructor)*/
+int sbus_new_connection(TALLOC_CTX *ctx, struct event_context *ev, const char *address,
+ struct sbus_conn_ctx **dct_ctx,
+ sbus_conn_destructor_fn destructor)
{
DBusConnection *dbus_conn;
DBusError dbus_error;
@@ -353,7 +353,7 @@ int sssd_new_dbus_connection(TALLOC_CTX *ctx, struct event_context *ev, const ch
return EIO;
}
- ret = sssd_add_dbus_connection(ctx, ev, dbus_conn, dct_ctx, DBUS_CONNECTION_TYPE_SHARED);
+ ret = sbus_add_connection(ctx, ev, dbus_conn, dct_ctx, SBUS_CONN_TYPE_SHARED);
if (ret != EOK) {
/* FIXME: release resources */
}
@@ -361,23 +361,23 @@ int sssd_new_dbus_connection(TALLOC_CTX *ctx, struct event_context *ev, const ch
dbus_connection_set_exit_on_disconnect((*dct_ctx)->conn, FALSE);
/* Set connection destructor */
- sssd_dbus_connection_set_destructor(*dct_ctx, destructor);
+ sbus_conn_set_destructor(*dct_ctx, destructor);
return ret;
}
/*
- * sssd_dbus_connection_set_destructor
+ * sbus_conn_set_destructor
* Configures a callback to clean up this connection when it
* is finalized.
- * @param dct_ctx The dbus_connection_toplevel_context created
+ * @param dct_ctx The sbus_conn_ctx created
* when this connection was established
* @param destructor The destructor function that should be
* called when the connection is finalized. If passed NULL,
* this will reset the connection to the default destructor.
*/
-void sssd_dbus_connection_set_destructor(struct dbus_connection_toplevel_context *dct_ctx,
- sssd_dbus_connection_destructor_fn destructor) {
+void sbus_conn_set_destructor(struct sbus_conn_ctx *dct_ctx,
+ sbus_conn_destructor_fn destructor) {
if (!dct_ctx) {
return;
}
@@ -386,15 +386,15 @@ void sssd_dbus_connection_set_destructor(struct dbus_connection_toplevel_context
/* TODO: Should we try to handle the talloc_destructor too? */
}
-int default_connection_destructor(void *ctx) {
- struct dbus_connection_toplevel_context *dct_ctx;
- dct_ctx = talloc_get_type(ctx, struct dbus_connection_toplevel_context);
+int sbus_default_connection_destructor(void *ctx) {
+ struct sbus_conn_ctx *dct_ctx;
+ dct_ctx = talloc_get_type(ctx, struct sbus_conn_ctx);
DEBUG(3, ("Invoking default destructor on connection %lX\n", dct_ctx->conn));
- if (dct_ctx->connection_type == DBUS_CONNECTION_TYPE_PRIVATE) {
+ if (dct_ctx->connection_type == SBUS_CONN_TYPE_PRIVATE) {
/* Private connections must be closed explicitly */
dbus_connection_close(dct_ctx->conn);
- } else if (dct_ctx->connection_type == DBUS_CONNECTION_TYPE_SHARED) {
+ } else if (dct_ctx->connection_type == SBUS_CONN_TYPE_SHARED) {
/* Shared connections are destroyed when their last reference is removed */
}
else {
@@ -404,7 +404,7 @@ int default_connection_destructor(void *ctx) {
}
/* Remove object path */
-
+ /* TODO: Remove object paths */
dbus_connection_unref(dct_ctx->conn);
@@ -412,15 +412,15 @@ int default_connection_destructor(void *ctx) {
}
/*
- * sssd_get_dbus_connection
+ * sbus_get_connection
* Utility function to retreive the DBusConnection object
- * from a dbus_connection_toplevel_context
+ * from a sbus_conn_ctx
*/
-DBusConnection *sssd_get_dbus_connection(struct dbus_connection_toplevel_context *dct_ctx) {
+DBusConnection *sbus_get_connection(struct sbus_conn_ctx *dct_ctx) {
return dct_ctx->conn;
}
-void sssd_dbus_disconnect (struct dbus_connection_toplevel_context *dct_ctx) {
+void sbus_disconnect (struct sbus_conn_ctx *dct_ctx) {
if (dct_ctx == NULL) {
return;
}
@@ -435,7 +435,7 @@ void sssd_dbus_disconnect (struct dbus_connection_toplevel_context *dct_ctx) {
}
/* Unregister object paths */
- sssd_unregister_object_paths(dct_ctx);
+ sbus_unreg_object_paths(dct_ctx);
/* Disable watch functions */
dbus_connection_set_watch_functions(dct_ctx->conn,
@@ -453,7 +453,7 @@ void sssd_dbus_disconnect (struct dbus_connection_toplevel_context *dct_ctx) {
dbus_connection_set_wakeup_main_function(dct_ctx->conn, NULL, NULL, NULL);
/* Finalize the connection */
- default_connection_destructor(dct_ctx);
+ sbus_default_connection_destructor(dct_ctx);
dbus_connection_unref(dct_ctx->conn);
DEBUG(2,("Disconnected %lX\n", dct_ctx->conn));
}
@@ -465,14 +465,14 @@ static DBusHandlerResult message_handler(DBusConnection *conn,
DBusMessage *message,
void *user_data)
{
- struct sssd_dbus_method_ctx *ctx;
+ struct sbus_method_ctx *ctx;
const char *method;
const char *path;
const char *msg_interface;
DBusMessage *reply = NULL;
int i, ret;
- ctx = talloc_get_type(user_data, struct sssd_dbus_method_ctx);
+ ctx = talloc_get_type(user_data, struct sbus_method_ctx);
method = dbus_message_get_member(message);
path = dbus_message_get_path(message);
@@ -497,7 +497,7 @@ static DBusHandlerResult message_handler(DBusConnection *conn,
/* FIXME: check if we didn't find any matching method */
}
- DEBUG(2, ("Method %s complete. Reply %sneeded.\n", method, reply?"":"not "));
+ DEBUG(2, ("Method %s complete. Reply was %srequested.\n", method, reply?"":"not "));
if (reply) {
dbus_connection_send(conn, reply, NULL);
@@ -511,14 +511,14 @@ static DBusHandlerResult message_handler(DBusConnection *conn,
/* Adds a new D-BUS path message handler to the connection
* Note: this must be a unique path.
*/
-int dbus_connection_add_method_ctx(struct dbus_connection_toplevel_context *dct_ctx, struct sssd_dbus_method_ctx *method_ctx) {
+int sbus_conn_add_method_ctx(struct sbus_conn_ctx *dct_ctx, struct sbus_method_ctx *method_ctx) {
DBusObjectPathVTable *connection_vtable;
dbus_bool_t dbret;
if (!method_ctx) {
return EINVAL;
}
- if (method_list_contains_path(dct_ctx->method_ctx_list, method_ctx)) {
+ if (_method_list_contains_path(dct_ctx->method_ctx_list, method_ctx)) {
return EINVAL;
}
@@ -540,8 +540,8 @@ int dbus_connection_add_method_ctx(struct dbus_connection_toplevel_context *dct_
return EOK;
}
-static int method_list_contains_path(struct sssd_dbus_method_ctx *list, struct sssd_dbus_method_ctx *method) {
- struct sssd_dbus_method_ctx *iter;
+static int _method_list_contains_path(struct sbus_method_ctx *list, struct sbus_method_ctx *method) {
+ struct sbus_method_ctx *iter;
if (!list || !method) {
return 0; /* FALSE */
@@ -558,9 +558,9 @@ static int method_list_contains_path(struct sssd_dbus_method_ctx *list, struct s
return 0; /* FALSE */
}
-static void sssd_unregister_object_paths(struct dbus_connection_toplevel_context *dct_ctx) {
- struct sssd_dbus_method_ctx *iter = dct_ctx->method_ctx_list;
- struct sssd_dbus_method_ctx *purge;
+static void sbus_unreg_object_paths(struct sbus_conn_ctx *dct_ctx) {
+ struct sbus_method_ctx *iter = dct_ctx->method_ctx_list;
+ struct sbus_method_ctx *purge;
while(iter != NULL) {
dbus_connection_unregister_object_path(dct_ctx->conn, iter->path);
@@ -571,6 +571,6 @@ static void sssd_unregister_object_paths(struct dbus_connection_toplevel_context
}
}
-void sssd_connection_set_private_data(struct dbus_connection_toplevel_context *dct_ctx, void *private) {
+void sbus_conn_set_private_data(struct sbus_conn_ctx *dct_ctx, void *private) {
dct_ctx->private = private;
}
diff --git a/server/dbus/sssd_dbus_private.h b/server/dbus/sssd_dbus_private.h
index ea1b719b..d102c8c9 100644
--- a/server/dbus/sssd_dbus_private.h
+++ b/server/dbus/sssd_dbus_private.h
@@ -1,14 +1,14 @@
#ifndef _SSSD_DBUS_PRIVATE_H_
#define _SSSD_DBUS_PRIVATE_H_
-int sssd_add_dbus_connection(TALLOC_CTX *ctx,
+int sbus_add_connection(TALLOC_CTX *ctx,
struct event_context *ev,
DBusConnection *dbus_conn,
- struct dbus_connection_toplevel_context **dct_ctx,
+ struct sbus_conn_ctx **dct_ctx,
int connection_type);
struct timeval _dbus_timeout_get_interval_tv(int interval);
-void remove_watch(DBusWatch *watch, void *data);
-void remove_timeout(DBusTimeout *timeout, void *data);
+void sbus_remove_watch(DBusWatch *watch, void *data);
+void sbus_remove_timeout(DBusTimeout *timeout, void *data);
#endif /* _SSSD_DBUS_PRIVATE_H_ */
diff --git a/server/dbus/sssd_dbus_server.c b/server/dbus/sssd_dbus_server.c
index 8bdccf8e..633e4b7e 100644
--- a/server/dbus/sssd_dbus_server.c
+++ b/server/dbus/sssd_dbus_server.c
@@ -26,7 +26,7 @@
#include "dbus/sssd_dbus_private.h"
/* Types */
-struct dbus_server_toplevel_context {
+struct sbus_srv_ctx {
DBusServer *server;
/*
* sd_ctx here describes the object path that will be
@@ -38,35 +38,35 @@ struct dbus_server_toplevel_context {
* simplicity's sake)
*/
struct event_context *ev;
- struct sssd_dbus_method_ctx *sd_ctx;
- sssd_dbus_server_connection_init_fn init_fn;
+ struct sbus_method_ctx *sd_ctx;
+ sbus_server_conn_init_fn init_fn;
};
-struct dbus_server_watch_context {
+struct sbus_srv_watch_ctx {
DBusWatch *watch;
int fd;
struct fd_event *fde;
- struct dbus_server_toplevel_context *top;
+ struct sbus_srv_ctx *top;
};
-struct dbus_server_timeout_context {
+struct dbus_srv_timeout_ctx {
DBusTimeout *timeout;
struct timed_event *te;
- struct dbus_server_toplevel_context *top;
+ struct sbus_srv_ctx *top;
};
-static int dbus_server_destructor(void **server);
+static int sbus_server_destructor(void **server);
/*
* dbus_server_read_write_handler
* Callback for D-BUS to handle messages on a file-descriptor
*/
-static void dbus_server_read_write_handler(struct event_context *ev,
+static void sbus_srv_read_write_handler(struct event_context *ev,
struct fd_event *fde,
uint16_t flags, void *data)
{
- struct dbus_server_watch_context *svw_ctx;
- svw_ctx = talloc_get_type(data, struct dbus_server_watch_context);
+ struct sbus_srv_watch_ctx *svw_ctx;
+ svw_ctx = talloc_get_type(data, struct sbus_srv_watch_ctx);
dbus_server_ref(svw_ctx->top->server);
if (flags & EVENT_FD_READ) {
@@ -83,20 +83,20 @@ static void dbus_server_read_write_handler(struct event_context *ev,
* Set up hooks into the libevents mainloop for
* D-BUS to add file descriptor-based events
*/
-static dbus_bool_t add_server_watch(DBusWatch *watch, void *data)
+static dbus_bool_t sbus_add_srv_watch(DBusWatch *watch, void *data)
{
unsigned int flags;
unsigned int event_flags;
- struct dbus_server_toplevel_context *dt_ctx;
- struct dbus_server_watch_context *svw_ctx;
+ struct sbus_srv_ctx *dt_ctx;
+ struct sbus_srv_watch_ctx *svw_ctx;
if (!dbus_watch_get_enabled(watch)) {
return FALSE;
}
- dt_ctx = talloc_get_type(data, struct dbus_server_toplevel_context);
+ dt_ctx = talloc_get_type(data, struct sbus_srv_ctx);
- svw_ctx = talloc_zero(dt_ctx, struct dbus_server_watch_context);
+ svw_ctx = talloc_zero(dt_ctx, struct sbus_srv_watch_ctx);
svw_ctx->top = dt_ctx;
svw_ctx->watch = watch;
@@ -115,7 +115,7 @@ static dbus_bool_t add_server_watch(DBusWatch *watch, void *data)
DEBUG(2,("%lX: %d, %d=%s\n", watch, svw_ctx->fd, event_flags, event_flags==EVENT_FD_READ?"READ":"WRITE"));
svw_ctx->fde = event_add_fd(dt_ctx->ev, svw_ctx, svw_ctx->fd,
- event_flags, dbus_server_read_write_handler,
+ event_flags, sbus_srv_read_write_handler,
svw_ctx);
/* Save the event to the watch object so it can be removed later */
@@ -129,21 +129,21 @@ static dbus_bool_t add_server_watch(DBusWatch *watch, void *data)
* Hook for D-BUS to toggle the enabled/disabled state of
* an event in the mainloop
*/
-static void toggle_server_watch(DBusWatch *watch, void *data)
+static void sbus_toggle_srv_watch(DBusWatch *watch, void *data)
{
if (dbus_watch_get_enabled(watch)) {
- add_server_watch(watch, data);
+ sbus_add_srv_watch(watch, data);
} else {
- remove_watch(watch, data);
+ sbus_remove_watch(watch, data);
}
}
-static void dbus_server_timeout_handler(struct event_context *ev,
+static void sbus_srv_timeout_handler(struct event_context *ev,
struct timed_event *te,
struct timeval t, void *data)
{
- struct dbus_server_timeout_context *svt_ctx;
- svt_ctx = talloc_get_type(data, struct dbus_server_timeout_context);
+ struct dbus_srv_timeout_ctx *svt_ctx;
+ svt_ctx = talloc_get_type(data, struct dbus_srv_timeout_ctx);
dbus_timeout_handle(svt_ctx->timeout);
}
@@ -151,25 +151,25 @@ static void dbus_server_timeout_handler(struct event_context *ev,
* add_server_timeout
* Hook for D-BUS to add time-based events to the mainloop
*/
-static dbus_bool_t add_server_timeout(DBusTimeout *timeout, void *data)
+static dbus_bool_t sbus_add_srv_timeout(DBusTimeout *timeout, void *data)
{
- struct dbus_server_toplevel_context *dt_ctx;
- struct dbus_server_timeout_context *svt_ctx;
+ struct sbus_srv_ctx *dt_ctx;
+ struct dbus_srv_timeout_ctx *svt_ctx;
struct timeval tv;
if (!dbus_timeout_get_enabled(timeout))
return TRUE;
- dt_ctx = talloc_get_type(data, struct dbus_server_toplevel_context);
+ dt_ctx = talloc_get_type(data, struct sbus_srv_ctx);
- svt_ctx = talloc_zero(dt_ctx,struct dbus_server_timeout_context);
+ svt_ctx = talloc_zero(dt_ctx,struct dbus_srv_timeout_ctx);
svt_ctx->top = dt_ctx;
svt_ctx->timeout = timeout;
tv = _dbus_timeout_get_interval_tv(dbus_timeout_get_interval(timeout));
svt_ctx->te = event_add_timed(dt_ctx->ev, svt_ctx, tv,
- dbus_server_timeout_handler, svt_ctx);
+ sbus_srv_timeout_handler, svt_ctx);
/* Save the event to the watch object so it can be removed later */
dbus_timeout_set_data(svt_ctx->timeout, svt_ctx->te, NULL);
@@ -182,12 +182,12 @@ static dbus_bool_t add_server_timeout(DBusTimeout *timeout, void *data)
* Hook for D-BUS to toggle the enabled/disabled state of a mainloop
* event
*/
-static void toggle_server_timeout(DBusTimeout *timeout, void *data)
+static void sbus_toggle_srv_timeout(DBusTimeout *timeout, void *data)
{
if (dbus_timeout_get_enabled(timeout)) {
- add_server_timeout(timeout, data);
+ sbus_add_srv_timeout(timeout, data);
} else {
- remove_timeout(timeout, data);
+ sbus_remove_timeout(timeout, data);
}
}
@@ -198,23 +198,23 @@ static void toggle_server_timeout(DBusTimeout *timeout, void *data)
* new connection or else close the connection with
* dbus_connection_close()
*/
-static void new_connection_callback(DBusServer *server, DBusConnection *conn,
+static void sbus_server_init_new_connection(DBusServer *server, DBusConnection *conn,
void *data)
{
- struct dbus_server_toplevel_context *dst_ctx;
- struct dbus_connection_toplevel_context *dct_ctx;
- struct sssd_dbus_method_ctx *iter;
+ struct sbus_srv_ctx *dst_ctx;
+ struct sbus_conn_ctx *dct_ctx;
+ struct sbus_method_ctx *iter;
/*DBusObjectPathVTable *connection_vtable;*/
int ret;
DEBUG(0,("Entering.\n"));
- dst_ctx = talloc_get_type(data,struct dbus_server_toplevel_context);
+ dst_ctx = talloc_get_type(data,struct sbus_srv_ctx);
if(dst_ctx == NULL) {
return;
}
DEBUG(0,("Adding connection %lX.\n", conn));
- ret = sssd_add_dbus_connection(dst_ctx, dst_ctx->ev, conn, &dct_ctx, DBUS_CONNECTION_TYPE_PRIVATE);
+ ret = sbus_add_connection(dst_ctx, dst_ctx->ev, conn, &dct_ctx, SBUS_CONN_TYPE_PRIVATE);
if (ret != 0) {
dbus_connection_close(conn);
DEBUG(0,("Closing connection (failed setup)"));
@@ -228,7 +228,7 @@ static void new_connection_callback(DBusServer *server, DBusConnection *conn,
/* Set up global methods */
iter = dst_ctx->sd_ctx;
while (iter != NULL) {
- dbus_connection_add_method_ctx(dct_ctx, iter);
+ sbus_conn_add_method_ctx(dct_ctx, iter);
iter = iter->next;
}
@@ -248,9 +248,9 @@ static void new_connection_callback(DBusServer *server, DBusConnection *conn,
* Set up a D-BUS server, integrate with the event loop
* for handling file descriptor and timed events
*/
-int sssd_new_dbus_server(struct event_context *ev, struct sssd_dbus_method_ctx *ctx, const char *address, sssd_dbus_server_connection_init_fn init_fn)
+int sbus_new_server(struct event_context *ev, struct sbus_method_ctx *ctx, const char *address, sbus_server_conn_init_fn init_fn)
{
- struct dbus_server_toplevel_context *dst_ctx;
+ struct sbus_srv_ctx *dst_ctx;
DBusServer *dbus_server;
DBusServer **dbus_server_talloc;
DBusError dbus_error;
@@ -268,12 +268,12 @@ int sssd_new_dbus_server(struct event_context *ev, struct sssd_dbus_method_ctx *
DEBUG(2, ("D-BUS Server listening on %s\n",
dbus_server_get_address(dbus_server)));
- dst_ctx = talloc_zero(ev, struct dbus_server_toplevel_context);
+ dst_ctx = talloc_zero(ev, struct sbus_srv_ctx);
if (!dst_ctx) {
return ENOMEM;
}
- dbus_server_talloc = talloc_takeover(ctx, dbus_server, dbus_server_destructor);
+ dbus_server_talloc = talloc_takeover(ctx, dbus_server, sbus_server_destructor);
dst_ctx->ev = ev;
dst_ctx->server = dbus_server;
dst_ctx->sd_ctx = ctx;
@@ -281,12 +281,12 @@ int sssd_new_dbus_server(struct event_context *ev, struct sssd_dbus_method_ctx *
/* Set up D-BUS new connection handler */
dbus_server_set_new_connection_function(dst_ctx->server,
- new_connection_callback,
+ sbus_server_init_new_connection,
dst_ctx, NULL);
/* Set up DBusWatch functions */
- dbret = dbus_server_set_watch_functions(dst_ctx->server, add_server_watch,
- remove_watch, toggle_server_watch,
+ dbret = dbus_server_set_watch_functions(dst_ctx->server, sbus_add_srv_watch,
+ sbus_remove_watch, sbus_toggle_srv_watch,
dst_ctx, NULL);
if (!dbret) {
DEBUG(0, ("Error setting up D-BUS server watch functions"));
@@ -296,9 +296,9 @@ int sssd_new_dbus_server(struct event_context *ev, struct sssd_dbus_method_ctx *
/* Set up DBusTimeout functions */
dbret = dbus_server_set_timeout_functions(dst_ctx->server,
- add_server_timeout,
- remove_timeout,
- toggle_server_timeout,
+ sbus_add_srv_timeout,
+ sbus_remove_timeout,
+ sbus_toggle_srv_timeout,
dst_ctx, NULL);
if (!dbret) {
DEBUG(0,("Error setting up D-BUS server timeout functions"));
@@ -310,7 +310,7 @@ int sssd_new_dbus_server(struct event_context *ev, struct sssd_dbus_method_ctx *
return EOK;
}
-static int dbus_server_destructor(void **server) {
+static int sbus_server_destructor(void **server) {
dbus_server_disconnect(*server);
return 0;
}
diff --git a/server/dbus/tests/test_client.c b/server/dbus/tests/test_client.c
index daf80db9..34e74018 100644
--- a/server/dbus/tests/test_client.c
+++ b/server/dbus/tests/test_client.c
@@ -24,15 +24,15 @@
#define SERVICE_METHOD_IDENTITY "getIdentity"
struct test_cli_ctx {
- struct sssd_dbus_method_ctx *sd_ctx;
+ struct sbus_method_ctx *sd_ctx;
/*DBusConnection *conn;*/
struct event_context *ev;
- struct dbus_connection_toplevel_context *dct_ctx;
+ struct sbus_conn_ctx *dct_ctx;
};
static int provide_identity(DBusMessage *message, void *data, DBusMessage **r);
-struct sssd_dbus_method monitor_service_methods [] = {
+struct sbus_method monitor_service_methods [] = {
{SERVICE_METHOD_IDENTITY, provide_identity},
{NULL, NULL}
};
@@ -92,7 +92,7 @@ static void test_timed_handler(struct event_context *ev,
struct timeval tv, void *data)
{
struct test_cli_ctx *test_ctx;
- struct sssd_dbus_method_ctx *ctx;
+ struct sbus_method_ctx *ctx;
DBusPendingCall *pending_reply;
DBusMessage *vmsg;
DBusError error;
@@ -109,7 +109,7 @@ static void test_timed_handler(struct event_context *ev,
ctx->path, ctx->interface,
MONITOR_METHOD_VERSION);
- dbret = dbus_connection_send_with_reply(sssd_get_dbus_connection(test_ctx->dct_ctx), vmsg,
+ dbret = dbus_connection_send_with_reply(sbus_get_connection(test_ctx->dct_ctx), vmsg,
&pending_reply, -1);
if (!dbret) {
/* Critical failure */
@@ -142,9 +142,9 @@ static void request_version_timed(struct test_cli_ctx *ctx)
int main (int argc, const char *argv[])
{
struct event_context *event_ctx;
- struct sssd_dbus_method_ctx *ctx;
+ struct sbus_method_ctx *ctx;
struct test_cli_ctx *test_ctx;
- struct sssd_dbus_method_ctx *service_methods;
+ struct sbus_method_ctx *service_methods;
int ret;
event_ctx = event_context_init(talloc_autofree_context());
@@ -153,7 +153,7 @@ int main (int argc, const char *argv[])
exit(1);
}
- ctx = talloc_zero(event_ctx, struct sssd_dbus_method_ctx);
+ ctx = talloc_zero(event_ctx, struct sbus_method_ctx);
if (!ctx) {
printf("Out of memory!?\n");
exit(1);
@@ -173,14 +173,14 @@ int main (int argc, const char *argv[])
exit(1);
}
- ret = sssd_new_dbus_connection(test_ctx, test_ctx->ev, DBUS_ADDRESS, &(test_ctx->dct_ctx), NULL);
+ ret = sbus_new_connection(test_ctx, test_ctx->ev, DBUS_ADDRESS, &(test_ctx->dct_ctx), NULL);
if (ret != EOK) {
exit(1);
}
test_ctx->sd_ctx = ctx;
- dbus_connection_set_exit_on_disconnect(sssd_get_dbus_connection(test_ctx->dct_ctx), TRUE);
+ dbus_connection_set_exit_on_disconnect(sbus_get_connection(test_ctx->dct_ctx), TRUE);
/* Set up a timed event to request the server version every
* five seconds and print it to the screen.
@@ -188,11 +188,11 @@ int main (int argc, const char *argv[])
request_version_timed(test_ctx);
/* Set up handler for service methods */
- service_methods = talloc_zero(test_ctx, struct sssd_dbus_method_ctx);
+ service_methods = talloc_zero(test_ctx, struct sbus_method_ctx);
service_methods->interface = talloc_strdup(service_methods, SERVICE_INTERFACE);
service_methods->path = talloc_strdup(service_methods, SERVICE_PATH);
service_methods->methods = monitor_service_methods;
- dbus_connection_add_method_ctx(test_ctx->dct_ctx, service_methods);
+ sbus_conn_add_method_ctx(test_ctx->dct_ctx, service_methods);
/* Enter the main loop (and hopefully never return) */
event_loop_wait(event_ctx);
diff --git a/server/monitor.c b/server/monitor.c
index cf628754..12e1b2fb 100644
--- a/server/monitor.c
+++ b/server/monitor.c
@@ -53,7 +53,7 @@ struct mt_srv {
int restarts;
};
-static int dbus_service_init(struct dbus_connection_toplevel_context *dct_ctx);
+static int dbus_service_init(struct sbus_conn_ctx *dct_ctx);
static void identity_check(DBusPendingCall *pending, void *data);
/* dbus_get_monitor_version
@@ -78,7 +78,7 @@ static int dbus_get_monitor_version(DBusMessage *message,
return EOK;
}
-struct sssd_dbus_method monitor_methods[] = {
+struct sbus_method monitor_methods[] = {
{ MONITOR_METHOD_VERSION, dbus_get_monitor_version},
{NULL, NULL}
};
@@ -87,10 +87,10 @@ struct sssd_dbus_method monitor_methods[] = {
* Set up the monitor service as a D-BUS Server */
static int monitor_dbus_init(struct mt_ctx *ctx)
{
- struct sssd_dbus_method_ctx *sd_ctx;
+ struct sbus_method_ctx *sd_ctx;
int ret;
- sd_ctx = talloc_zero(ctx, struct sssd_dbus_method_ctx);
+ sd_ctx = talloc_zero(ctx, struct sbus_method_ctx);
if (!sd_ctx) {
return ENOMEM;
}
@@ -109,7 +109,7 @@ static int monitor_dbus_init(struct mt_ctx *ctx)
sd_ctx->methods = monitor_methods;
sd_ctx->message_handler = NULL; /* Use the default message_handler */
- ret = sssd_new_dbus_server(ctx->ev, sd_ctx, DBUS_ADDRESS, dbus_service_init);
+ ret = sbus_new_server(ctx->ev, sd_ctx, DBUS_ADDRESS, dbus_service_init);
return ret;
}
@@ -249,7 +249,7 @@ int start_monitor(TALLOC_CTX *mem_ctx,
* method on the new client). The reply callback for this request
* should set the connection destructor appropriately.
*/
-static int dbus_service_init(struct dbus_connection_toplevel_context *dct_ctx) {
+static int dbus_service_init(struct sbus_conn_ctx *dct_ctx) {
DBusMessage *msg;
DBusPendingCall *pending_reply;
DBusConnection *conn;
@@ -257,7 +257,7 @@ static int dbus_service_init(struct dbus_connection_toplevel_context *dct_ctx) {
dbus_bool_t dbret;
DEBUG(0,("Initializing D-BUS Service"));
- conn = sssd_get_dbus_connection(dct_ctx);
+ conn = sbus_get_connection(dct_ctx);
dbus_error_init(&dbus_error);
/*
@@ -288,12 +288,12 @@ static int dbus_service_init(struct dbus_connection_toplevel_context *dct_ctx) {
}
static void identity_check(DBusPendingCall *pending, void *data) {
- struct dbus_connection_toplevel_context *dct_ctx;
+ struct sbus_conn_ctx *dct_ctx;
DBusMessage *reply;
DBusError dbus_error;
int type;
- dct_ctx = talloc_get_type(data, struct dbus_connection_toplevel_context);
+ dct_ctx = talloc_get_type(data, struct sbus_conn_ctx);
dbus_error_init(&dbus_error);
reply = dbus_pending_call_steal_reply(pending);
@@ -305,7 +305,7 @@ static void identity_check(DBusPendingCall *pending, void *data) {
DEBUG(0, ("Serious error. A reply callback was called but no reply was received and no timeout occurred\n"));
/* Destroy this connection */
- sssd_dbus_disconnect(dct_ctx);
+ sbus_disconnect(dct_ctx);
return;
}
@@ -327,7 +327,7 @@ static void identity_check(DBusPendingCall *pending, void *data) {
* know that this connection isn't trustworthy.
* We'll destroy it now.
*/
- sssd_dbus_disconnect(dct_ctx);
+ sbus_disconnect(dct_ctx);
break;
}
}