diff options
Diffstat (limited to 'server/sbus')
| -rw-r--r-- | server/sbus/sbus_client.c | 57 | ||||
| -rw-r--r-- | server/sbus/sbus_client.h | 36 | ||||
| -rw-r--r-- | server/sbus/sssd_dbus.h | 153 | ||||
| -rw-r--r-- | server/sbus/sssd_dbus_common.c | 444 | ||||
| -rw-r--r-- | server/sbus/sssd_dbus_connection.c | 692 | ||||
| -rw-r--r-- | server/sbus/sssd_dbus_private.h | 98 | ||||
| -rw-r--r-- | server/sbus/sssd_dbus_server.c | 171 |
7 files changed, 0 insertions, 1651 deletions
diff --git a/server/sbus/sbus_client.c b/server/sbus/sbus_client.c deleted file mode 100644 index df5c0712..00000000 --- a/server/sbus/sbus_client.c +++ /dev/null @@ -1,57 +0,0 @@ -/* - SSSD - - Data Provider Helpers - - Copyright (C) Stephen Gallagher <sgallagh@redhat.com> 2009 - - This program is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 3 of the License, or - (at your option) any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program. If not, see <http://www.gnu.org/licenses/>. -*/ - -#include "util/util.h" -#include "talloc.h" -#include "sbus_client.h" - -int sbus_client_init(TALLOC_CTX *mem_ctx, - struct tevent_context *ev, - const char *server_address, - struct sbus_interface *intf, - struct sbus_connection **_conn, - sbus_conn_destructor_fn destructor, - void *conn_pvt_data) -{ - struct sbus_connection *conn = NULL; - int ret; - - /* Validate input */ - if (server_address == NULL) { - return EINVAL; - } - - ret = sbus_new_connection(mem_ctx, ev, server_address, intf, &conn); - if (ret != EOK) { - goto fail; - } - - /* Set connection destructor and private data */ - sbus_conn_set_destructor(conn, destructor); - sbus_conn_set_private_data(conn, conn_pvt_data); - - *_conn = conn; - return EOK; - -fail: - talloc_free(conn); - return ret; -} diff --git a/server/sbus/sbus_client.h b/server/sbus/sbus_client.h deleted file mode 100644 index 742f8a10..00000000 --- a/server/sbus/sbus_client.h +++ /dev/null @@ -1,36 +0,0 @@ -/* - SSSD - - Data Provider Helpers - - Copyright (C) Stephen Gallagher <sgallagh@redhat.com> 2009 - - This program is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 3 of the License, or - (at your option) any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program. If not, see <http://www.gnu.org/licenses/>. -*/ - -#ifndef SBUS_CLIENT_H_ -#define SBUS_CLIENT_H_ - -#include "tevent.h" -#include "sbus/sssd_dbus.h" - -int sbus_client_init(TALLOC_CTX *mem_ctx, - struct tevent_context *ev, - const char *server_address, - struct sbus_interface *intf, - struct sbus_connection **_conn, - sbus_conn_destructor_fn destructor, - void *conn_pvt_data); - -#endif /* SBUS_CLIENT_H_ */ diff --git a/server/sbus/sssd_dbus.h b/server/sbus/sssd_dbus.h deleted file mode 100644 index ac02c444..00000000 --- a/server/sbus/sssd_dbus.h +++ /dev/null @@ -1,153 +0,0 @@ -/* - SSSD - - SSSD - D-BUS interface - - Copyright (C) Stephen Gallagher 2008 - - This program is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 3 of the License, or - (at your option) any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program. If not, see <http://www.gnu.org/licenses/>. -*/ - -#ifndef _SSSD_DBUS_H_ -#define _SSSD_DBUS_H_ - -struct sbus_connection; - -#include "dbus/dbus.h" - -typedef int (*sbus_msg_handler_fn)(DBusMessage *, struct sbus_connection *); - -/* - * sbus_conn_destructor_fn - * Function to be called when a connection is finalized - */ -typedef int (*sbus_conn_destructor_fn)(void *); - -typedef void (*sbus_conn_reconn_callback_fn)(struct sbus_connection *, int, void *); - -/* - * sbus_server_conn_init_fn - * Set up function for connection-specific activities - * This function should define the sbus_conn_destructor_fn - * for this connection at a minimum - */ -typedef int (*sbus_server_conn_init_fn)(struct sbus_connection *, void *); - -enum { - SBUS_CONN_TYPE_PRIVATE = 1, - SBUS_CONN_TYPE_SHARED -}; - -enum { - SBUS_RECONNECT_SUCCESS = 1, - SBUS_RECONNECT_EXCEEDED_RETRIES, - SBUS_RECONNECT_ERROR -}; - -/* Special interface and method for D-BUS introspection */ -#define DBUS_INTROSPECT_INTERFACE "org.freedesktop.DBus.Introspectable" -#define DBUS_INTROSPECT_METHOD "Introspect" - -#define SBUS_DEFAULT_VTABLE { NULL, sbus_message_handler, NULL, NULL, NULL, NULL } - -struct sbus_method { - const char *method; - sbus_msg_handler_fn fn; -}; - -struct sbus_interface { - const char *interface; - const char *path; - DBusObjectPathVTable vtable; - struct sbus_method *methods; - sbus_msg_handler_fn introspect_fn; -}; - -/* Server Functions */ -int sbus_new_server(TALLOC_CTX *mem_ctx, - struct tevent_context *ev, - const char *address, - struct sbus_interface *intf, - struct sbus_connection **server, - sbus_server_conn_init_fn init_fn, void *init_pvt_data); - -/* Connection Functions */ - -/* sbus_new_connection - * Use this function when connecting a new process to - * the standard SSSD interface. - * This will connect to the address specified and then - * call sbus_add_connection to integrate with the main - * loop. - */ -int sbus_new_connection(TALLOC_CTX *ctx, - struct tevent_context *ev, - const char *address, - struct sbus_interface *intf, - struct sbus_connection **conn); - -/* sbus_add_connection - * Integrates a D-BUS connection with the TEvent main - * loop. Use this function when you already have a - * DBusConnection object (for example from dbus_bus_get) - * Connection type can be either: - * SBUS_CONN_TYPE_PRIVATE: Used only from within a D-BUS - * server such as the Monitor in the - * new_connection_callback - * SBUS_CONN_TYPE_SHARED: Used for all D-BUS client - * connections, including those retrieved from - * dbus_bus_get - */ -int sbus_init_connection(TALLOC_CTX *ctx, - struct tevent_context *ev, - DBusConnection *dbus_conn, - struct sbus_interface *intf, - int connection_type, - struct sbus_connection **_conn); - -void sbus_conn_set_destructor(struct sbus_connection *conn, - sbus_conn_destructor_fn destructor); - -int sbus_default_connection_destructor(void *ctx); - -DBusConnection *sbus_get_connection(struct sbus_connection *conn); -void sbus_disconnect(struct sbus_connection *conn); -void sbus_conn_set_private_data(struct sbus_connection *conn, void *pvt_data); -void *sbus_conn_get_private_data(struct sbus_connection *conn); -int sbus_conn_add_interface(struct sbus_connection *conn, - struct sbus_interface *intf); -bool sbus_conn_disconnecting(struct sbus_connection *conn); - -/* max_retries < 0: retry forever - * max_retries = 0: never retry (why are you calling this function?) - * max_retries > 0: obvious - */ -void sbus_reconnect_init(struct sbus_connection *conn, - int max_retries, - sbus_conn_reconn_callback_fn callback, - void *pvt); - -/* Default message handler - * Should be usable for most cases */ -DBusHandlerResult sbus_message_handler(DBusConnection *conn, - DBusMessage *message, - void *user_data); - -void sbus_conn_send_reply(struct sbus_connection *conn, - DBusMessage *reply); - -int sbus_is_dbus_fixed_type(int dbus_type); -int sbus_is_dbus_string_type(int dbus_type); -size_t sbus_get_dbus_type_size(int dbus_type); -#endif /* _SSSD_DBUS_H_*/ diff --git a/server/sbus/sssd_dbus_common.c b/server/sbus/sssd_dbus_common.c deleted file mode 100644 index d446632d..00000000 --- a/server/sbus/sssd_dbus_common.c +++ /dev/null @@ -1,444 +0,0 @@ -/* - Authors: - Simo Sorce <ssorce@redhat.com> - Stephen Gallagher <sgallagh@redhat.com> - - Copyright (C) 2009 Red Hat - - This program is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 3 of the License, or - (at your option) any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program. If not, see <http://www.gnu.org/licenses/>. -*/ - -#include <sys/time.h> -#include "tevent.h" -#include "dbus/dbus.h" -#include "util/util.h" -#include "sbus/sssd_dbus.h" -#include "sbus/sssd_dbus_private.h" - -/* =Watches=============================================================== */ - -/* DBUS may ask us to add a watch to a file descriptor that already had a watch - * associated. Need to check if that's the case */ -static struct sbus_watch_ctx *fd_to_watch(struct sbus_watch_ctx *list, int fd) -{ - struct sbus_watch_ctx *watch_iter; - - watch_iter = list; - while (watch_iter != NULL) { - if (watch_iter->fd == fd) { - return watch_iter; - } - - watch_iter = watch_iter->next; - } - - return NULL; -} - -static int watch_destructor(void *mem) -{ - struct sbus_watch_ctx *watch; - - watch = talloc_get_type(mem, struct sbus_watch_ctx); - DLIST_REMOVE(watch->conn->watch_list, watch); - - return 0; -} - -/* - * 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); - enum dbus_conn_type type; - union dbus_conn_pointer dbus_p; - - /* conn may get freed inside a handle, save the data we need for later */ - type = watch->conn->type; - dbus_p = watch->conn->dbus; - - /* Take a reference while handling watch */ - if (type == SBUS_SERVER) { - dbus_server_ref(dbus_p.server); - } else { - dbus_connection_ref(dbus_p.conn); - } - - /* Fire if readable */ - if (flags & TEVENT_FD_READ) { - if (watch->dbus_read_watch) { - dbus_watch_handle(watch->dbus_read_watch, DBUS_WATCH_READABLE); - } - } - - /* Fire if writeable */ - if (flags & TEVENT_FD_WRITE) { - if (watch->dbus_write_watch) { - dbus_watch_handle(watch->dbus_write_watch, DBUS_WATCH_WRITABLE); - } - } - - /* Release reference once done */ - if (type == SBUS_SERVER) { - dbus_server_unref(dbus_p.server); - } else { - dbus_connection_unref(dbus_p.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_connection *conn; - struct sbus_watch_ctx *watch; - dbus_bool_t enabled; - int fd; - - conn = talloc_get_type(data, struct sbus_connection); - -#ifdef HAVE_DBUS_WATCH_GET_UNIX_FD - fd = dbus_watch_get_unix_fd(dbus_watch); -#else - fd = dbus_watch_get_fd(dbus_watch); -#endif - - watch = fd_to_watch(conn->watch_list, fd); - if (!watch) { - /* does not exist, allocate new one */ - watch = talloc_zero(conn, struct sbus_watch_ctx); - if (!watch) { - DEBUG(0, ("Out of Memory!\n")); - return FALSE; - } - watch->conn = conn; - watch->fd = fd; - } - - enabled = dbus_watch_get_enabled(dbus_watch); - flags = dbus_watch_get_flags(dbus_watch); - - /* Save the event to the watch object so it can be found later */ - if (flags & DBUS_WATCH_READABLE) { - watch->dbus_read_watch = dbus_watch; - } - if (flags & DBUS_WATCH_WRITABLE) { - watch->dbus_write_watch = dbus_watch; - } - dbus_watch_set_data(dbus_watch, watch, NULL); - - if (watch->fde) { - /* pre-existing event, just toggle flags */ - sbus_toggle_watch(dbus_watch, data); - return TRUE; - } - - event_flags = 0; - if (enabled) { - if (flags & DBUS_WATCH_READABLE) { - event_flags |= TEVENT_FD_READ; - } - if (flags & DBUS_WATCH_WRITABLE) { - event_flags |= TEVENT_FD_WRITE; - } - } - - /* Add the file descriptor to the event loop */ - watch->fde = tevent_add_fd(conn->ev, - watch, fd, event_flags, - sbus_watch_handler, watch); - if (!watch->fde) { - DEBUG(0, ("Failed to set up fd event!\n")); - talloc_zfree(watch); - return FALSE; - } - - DLIST_ADD(conn->watch_list, watch); - talloc_set_destructor((TALLOC_CTX *)watch, watch_destructor); - - DEBUG(8, ("%p/%p (%d), %s/%s (%s)\n", - watch, dbus_watch, fd, - ((flags & DBUS_WATCH_READABLE)?"R":"-"), - ((flags & DBUS_WATCH_WRITABLE)?"W":"-"), - enabled?"enabled":"disabled")); - - 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; - unsigned int flags; - dbus_bool_t enabled; - void *watch_data; - int fd; - - enabled = dbus_watch_get_enabled(dbus_watch); - flags = dbus_watch_get_flags(dbus_watch); - - watch_data = dbus_watch_get_data(dbus_watch); - watch = talloc_get_type(watch_data, struct sbus_watch_ctx); - if (!watch) { - DEBUG(2, ("[%p] does not carry watch context?!\n", dbus_watch)); - /* abort ? */ - return; - } - - if (enabled) { - 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) { -#ifdef HAVE_DBUS_WATCH_GET_UNIX_FD - fd = dbus_watch_get_unix_fd(dbus_watch); -#else - fd = dbus_watch_get_fd(dbus_watch); -#endif - } - DEBUG(8, ("%p/%p (%d), %s/%s (%s)\n", - watch, dbus_watch, fd, - ((flags & DBUS_WATCH_READABLE)?"R":"-"), - ((flags & DBUS_WATCH_WRITABLE)?"W":"-"), - enabled?"enabled":"disabled")); -} - -/* - * 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) -{ - struct sbus_watch_ctx *watch; - void *watch_data; - - watch_data = dbus_watch_get_data(dbus_watch); - watch = talloc_get_type(watch_data, struct sbus_watch_ctx); - - DEBUG(8, ("%p/%p\n", watch, dbus_watch)); - - if (!watch) { - DEBUG(2, ("DBUS trying to remove unknown watch!\n")); - return; - } - - /* remove dbus watch data */ - dbus_watch_set_data(dbus_watch, NULL, NULL); - - /* check which watch to remove, or free if none left */ - if (watch->dbus_read_watch == dbus_watch) { - watch->dbus_read_watch = NULL; - } - if (watch->dbus_write_watch == dbus_watch) { - watch->dbus_write_watch = NULL; - } - if (!watch->dbus_read_watch && !watch->dbus_write_watch) { - talloc_free(watch); - } -} - -/* =Timeouts============================================================== */ - -static struct timeval _get_interval_tv(int interval) { - struct timeval tv; - struct timeval rightnow; - - gettimeofday(&rightnow,NULL); - - tv.tv_sec = interval / 1000 + rightnow.tv_sec; - tv.tv_usec = (interval % 1000) * 1000 + rightnow.tv_usec; - return tv; -} - -/* - * timeout_handler - * Callback for D-BUS to handle timed events - */ -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); - - dbus_timeout_handle(timeout->dbus_timeout); -} - -/* - * 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_connection *conn; - struct sbus_timeout_ctx *timeout; - struct timeval tv; - - DEBUG(8, ("%p\n", dbus_timeout)); - - if (!dbus_timeout_get_enabled(dbus_timeout)) { - return TRUE; - } - - conn = talloc_get_type(data, struct sbus_connection); - - timeout = talloc_zero(conn, struct sbus_timeout_ctx); - if (!timeout) { - DEBUG(0, ("Out 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(conn->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 *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(timeout); - -} - -/* =Helpers=============================================================== */ - -int sbus_is_dbus_fixed_type(int dbus_type) -{ - switch (dbus_type) { - case DBUS_TYPE_BYTE: - case DBUS_TYPE_BOOLEAN: - case DBUS_TYPE_INT16: - case DBUS_TYPE_UINT16: - case DBUS_TYPE_INT32: - case DBUS_TYPE_UINT32: - case DBUS_TYPE_INT64: - case DBUS_TYPE_UINT64: - case DBUS_TYPE_DOUBLE: - return true; - } - return false; -} - -int sbus_is_dbus_string_type(int dbus_type) -{ - switch(dbus_type) { - case DBUS_TYPE_STRING: - case DBUS_TYPE_OBJECT_PATH: - case DBUS_TYPE_SIGNATURE: - return true; - } - return false; -} - -size_t sbus_get_dbus_type_size(int dbus_type) -{ - size_t ret; - - switch(dbus_type) { - /* 1-byte types */ - case DBUS_TYPE_BYTE: - ret = 1; - break; - - /* 2-byte types */ - case DBUS_TYPE_INT16: - case DBUS_TYPE_UINT16: - ret = 2; - break; - - /* 4-byte types */ - case DBUS_TYPE_BOOLEAN: - case DBUS_TYPE_INT32: - case DBUS_TYPE_UINT32: - ret = 4; - break; - - /* 8-byte types */ - case DBUS_TYPE_INT64: - case DBUS_TYPE_UINT64: - case DBUS_TYPE_DOUBLE: - ret = 8; - break; - - default: - ret = 0; - } - return ret; -} diff --git a/server/sbus/sssd_dbus_connection.c b/server/sbus/sssd_dbus_connection.c deleted file mode 100644 index 38ccc6ab..00000000 --- a/server/sbus/sssd_dbus_connection.c +++ /dev/null @@ -1,692 +0,0 @@ -/* - Authors: - Simo Sorce <ssorce@redhat.com> - Stephen Gallagher <sgallagh@redhat.com> - - Copyright (C) 2009 Red Hat - - This program is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 3 of the License, or - (at your option) any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program. If not, see <http://www.gnu.org/licenses/>. -*/ - -#include <sys/time.h> -#include "util/util.h" -#include "dbus/dbus.h" -#include "sbus/sssd_dbus.h" -#include "sbus/sssd_dbus_private.h" - -/* Types */ -struct dbus_ctx_list; - -struct sbus_interface_p { - struct sbus_interface_p *prev, *next; - struct sbus_connection *conn; - struct sbus_interface *intf; -}; - -static bool path_in_interface_list(struct sbus_interface_p *list, - const char *path); -static void sbus_unreg_object_paths(struct sbus_connection *conn); - -static int sbus_auto_reconnect(struct sbus_connection *conn); - -static void sbus_dispatch(struct tevent_context *ev, - struct tevent_timer *te, - struct timeval tv, void *data) -{ - struct tevent_timer *new_event; - struct sbus_connection *conn; - DBusConnection *dbus_conn; - int ret; - - if (data == NULL) return; - - conn = talloc_get_type(data, struct sbus_connection); - - dbus_conn = conn->dbus.conn; - DEBUG(9, ("dbus conn: %lX\n", dbus_conn)); - - if (conn->retries > 0) { - DEBUG(6, ("SBUS is reconnecting. Deferring.\n")); - /* Currently trying to reconnect, defer dispatch */ - new_event = tevent_add_timer(ev, conn, tv, sbus_dispatch, conn); - if (new_event == NULL) { - DEBUG(0,("Could not defer dispatch!\n")); - } - return; - } - - if ((!dbus_connection_get_is_connected(dbus_conn)) && - (conn->max_retries != 0)) { - /* Attempt to reconnect automatically */ - ret = sbus_auto_reconnect(conn); - if (ret == EOK) { - DEBUG(1, ("Performing auto-reconnect\n")); - return; - } - - DEBUG(0, ("Cannot start auto-reconnection.\n")); - conn->reconnect_callback(conn, - SBUS_RECONNECT_ERROR, - conn->reconnect_pvt); - return; - } - - if ((conn->disconnect) || - (!dbus_connection_get_is_connected(dbus_conn))) { - DEBUG(3,("Connection is not open for dispatching.\n")); - /* - * Free the connection object. - * This will invoke the destructor for the connection - */ - talloc_free(conn); - conn = NULL; - return; - } - - /* Dispatch only once each time through the mainloop to avoid - * starving other features - */ - ret = dbus_connection_get_dispatch_status(dbus_conn); - if (ret != DBUS_DISPATCH_COMPLETE) { - DEBUG(9,("Dispatching.\n")); - dbus_connection_dispatch(dbus_conn); - } - - /* If other dispatches are waiting, queue up the dispatch function - * for the next loop. - */ - ret = dbus_connection_get_dispatch_status(dbus_conn); - if (ret != DBUS_DISPATCH_COMPLETE) { - new_event = tevent_add_timer(ev, conn, tv, sbus_dispatch, conn); - if (new_event == NULL) { - DEBUG(2,("Could not add dispatch event!\n")); - - /* TODO: Calling exit here is bad */ - exit(1); - } - } -} - -/* dbus_connection_wakeup_main - * D-BUS makes a callback to the wakeup_main function when - * it has data available for dispatching. - * In order to avoid blocking, this function will create a now() - * timed event to perform the dispatch during the next iteration - * through the mainloop - */ -static void sbus_conn_wakeup_main(void *data) -{ - struct sbus_connection *conn; - struct timeval tv; - struct tevent_timer *te; - - conn = talloc_get_type(data, struct sbus_connection); - - tv = tevent_timeval_current(); - - /* D-BUS calls this function when it is time to do a dispatch */ - te = tevent_add_timer(conn->ev, conn, tv, sbus_dispatch, conn); - if (te == NULL) { - DEBUG(2,("Could not add dispatch event!\n")); - /* TODO: Calling exit here is bad */ - exit(1); - } -} - -static int sbus_conn_set_fns(struct sbus_connection *conn); - -/* - * integrate_connection_with_event_loop - * Set up a D-BUS connection to use the libevents mainloop - * for handling file descriptor and timed events - */ -int sbus_init_connection(TALLOC_CTX *ctx, - struct tevent_context *ev, - DBusConnection *dbus_conn, - struct sbus_interface *intf, - int connection_type, - struct sbus_connection **_conn) -{ - struct sbus_connection *conn; - int ret; - - DEBUG(5,("Adding connection %lX\n", dbus_conn)); - conn = talloc_zero(ctx, struct sbus_connection); - - conn->ev = ev; - conn->type = SBUS_CONNECTION; - conn->dbus.conn = dbus_conn; - conn->connection_type = connection_type; - - ret = sbus_conn_add_interface(conn, intf); - if (ret != EOK) { - talloc_free(conn); - return ret; - } - - ret = sbus_conn_set_fns(conn); - if (ret != EOK) { - talloc_free(conn); - return ret; - } - - *_conn = conn; - return ret; -} - -static int sbus_conn_set_fns(struct sbus_connection *conn) -{ - dbus_bool_t dbret; - - /* - * Set the default destructor - * Connections can override this with - * sbus_conn_set_destructor - */ - sbus_conn_set_destructor(conn, NULL); - - /* Set up DBusWatch functions */ - dbret = dbus_connection_set_watch_functions(conn->dbus.conn, - sbus_add_watch, - sbus_remove_watch, - sbus_toggle_watch, - conn, NULL); - if (!dbret) { - DEBUG(2,("Error setting up D-BUS connection watch functions\n")); - return EIO; - } - - /* Set up DBusTimeout functions */ - dbret = dbus_connection_set_timeout_functions(conn->dbus.conn, - sbus_add_timeout, - sbus_remove_timeout, - sbus_toggle_timeout, - conn, NULL); - if (!dbret) { - DEBUG(2,("Error setting up D-BUS server timeout functions\n")); - /* FIXME: free resources ? */ - return EIO; - } - - /* Set up dispatch handler */ - dbus_connection_set_wakeup_main_function(conn->dbus.conn, - sbus_conn_wakeup_main, - conn, NULL); - - /* Set up any method_contexts passed in */ - - /* Attempt to dispatch immediately in case of opportunistic - * services connecting before the handlers were all up. - * If there are no messages to be dispatched, this will do - * nothing. - */ - sbus_conn_wakeup_main(conn); - - return EOK; -} - -int sbus_new_connection(TALLOC_CTX *ctx, struct tevent_context *ev, - const char *address, struct sbus_interface *intf, - struct sbus_connection **_conn) -{ - struct sbus_connection *conn; - DBusConnection *dbus_conn; - DBusError dbus_error; - int ret; - - dbus_error_init(&dbus_error); - - /* Open a shared D-BUS connection to the address */ - dbus_conn = dbus_connection_open(address, &dbus_error); - if (!dbus_conn) { - DEBUG(1, ("Failed to open connection: name=%s, message=%s\n", - dbus_error.name, dbus_error.message)); - if (dbus_error_is_set(&dbus_error)) dbus_error_free(&dbus_error); - return EIO; - } - - ret = sbus_init_connection(ctx, ev, dbus_conn, intf, - SBUS_CONN_TYPE_SHARED, &conn); - if (ret != EOK) { - /* FIXME: release resources */ - } - - /* Store the address for later reconnection */ - conn->address = talloc_strdup(conn, address); - - dbus_connection_set_exit_on_disconnect(conn->dbus.conn, FALSE); - - *_conn = conn; - return ret; -} - -/* - * sbus_conn_set_destructor - * Configures a callback to clean up this connection when it - * is finalized. - * @param conn The sbus_connection 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 sbus_conn_set_destructor(struct sbus_connection *conn, - sbus_conn_destructor_fn destructor) -{ - if (!conn) return; - - conn->destructor = destructor; - /* TODO: Should we try to handle the talloc_destructor too? */ -} - -int sbus_default_connection_destructor(void *ctx) -{ - struct sbus_connection *conn; - conn = talloc_get_type(ctx, struct sbus_connection); - - DEBUG(5, ("Invoking default destructor on connection %lX\n", - conn->dbus.conn)); - if (conn->connection_type == SBUS_CONN_TYPE_PRIVATE) { - /* Private connections must be closed explicitly */ - dbus_connection_close(conn->dbus.conn); - } - else if (conn->connection_type == SBUS_CONN_TYPE_SHARED) { - /* Shared connections are destroyed when their last reference is removed */ - } - else { - /* Critical Error! */ - DEBUG(1,("Critical Error, connection_type is neither shared nor private!\n")); - return -1; - } - - /* Remove object path */ - /* TODO: Remove object paths */ - - dbus_connection_unref(conn->dbus.conn); - return 0; -} - -/* - * sbus_get_connection - * Utility function to retreive the DBusConnection object - * from a sbus_connection - */ -DBusConnection *sbus_get_connection(struct sbus_connection *conn) -{ - return conn->dbus.conn; -} - -void sbus_disconnect (struct sbus_connection *conn) -{ - if (conn == NULL) { - return; - } - - DEBUG(5,("Disconnecting %lX\n", conn->dbus.conn)); - - /******************************* - * Referencing conn->dbus.conn */ - dbus_connection_ref(conn->dbus.conn); - - conn->disconnect = 1; - - /* Invoke the custom destructor, if it exists */ - if (conn->destructor) { - conn->destructor(conn); - } - - /* Unregister object paths */ - sbus_unreg_object_paths(conn); - - /* Disable watch functions */ - dbus_connection_set_watch_functions(conn->dbus.conn, - NULL, NULL, NULL, - NULL, NULL); - /* Disable timeout functions */ - dbus_connection_set_timeout_functions(conn->dbus.conn, - NULL, NULL, NULL, - NULL, NULL); - - /* Disable dispatch status function */ - dbus_connection_set_dispatch_status_function(conn->dbus.conn, - NULL, NULL, NULL); - - /* Disable wakeup main function */ - dbus_connection_set_wakeup_main_function(conn->dbus.conn, - NULL, NULL, NULL); - - /* Finalize the connection */ - sbus_default_connection_destructor(conn); - - dbus_connection_unref(conn->dbus.conn); - /* Unreferenced conn->dbus_conn * - ******************************/ - - DEBUG(5,("Disconnected %lX\n", conn->dbus.conn)); -} - -static int sbus_reply_internal_error(DBusMessage *message, - struct sbus_connection *conn) { - DBusMessage *reply = dbus_message_new_error(message, DBUS_ERROR_IO_ERROR, - "Internal Error"); - if (reply) { - sbus_conn_send_reply(conn, reply); - dbus_message_unref(reply); - return DBUS_HANDLER_RESULT_HANDLED; - } - return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; -} - -/* messsage_handler - * Receive messages and process them - */ -DBusHandlerResult sbus_message_handler(DBusConnection *dbus_conn, - DBusMessage *message, - void *user_data) -{ - struct sbus_interface_p *intf_p; - const char *method; - const char *path; - const char *msg_interface; - DBusMessage *reply = NULL; - int i, ret; - int found; - - if (!user_data) { - return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; - } - intf_p = talloc_get_type(user_data, struct sbus_interface_p); - - method = dbus_message_get_member(message); - DEBUG(9, ("Received SBUS method [%s]\n", method)); - path = dbus_message_get_path(message); - msg_interface = dbus_message_get_interface(message); - - if (!method || !path || !msg_interface) - return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; - - /* Validate the D-BUS path */ - if (strcmp(path, intf_p->intf->path) != 0) - return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; - - /* Validate the method interface */ - if (strcmp(msg_interface, intf_p->intf->interface) == 0) { - found = 0; - for (i = 0; intf_p->intf->methods[i].method != NULL; i++) { - if (strcmp(method, intf_p->intf->methods[i].method) == 0) { - found = 1; - ret = intf_p->intf->methods[i].fn(message, intf_p->conn); - if (ret != EOK) { - return sbus_reply_internal_error(message, intf_p->conn); - } - break; - } - } - - if (!found) { - /* Reply DBUS_ERROR_UNKNOWN_METHOD */ - DEBUG(1, ("No matching method found for %s.\n", method)); - reply = dbus_message_new_error(message, DBUS_ERROR_UNKNOWN_METHOD, NULL); - sbus_conn_send_reply(intf_p->conn, reply); - dbus_message_unref(reply); - } - } - else { - /* Special case: check for Introspection request - * This is usually only useful for system bus connections - */ - if (strcmp(msg_interface, DBUS_INTROSPECT_INTERFACE) == 0 && - strcmp(method, DBUS_INTROSPECT_METHOD) == 0) - { - if (intf_p->intf->introspect_fn) { - /* If we have been asked for introspection data and we have - * an introspection function registered, user that. - */ - ret = intf_p->intf->introspect_fn(message, intf_p->conn); - if (ret != EOK) { - return sbus_reply_internal_error(message, intf_p->conn); - } - } - } - else - return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; - } - - return DBUS_HANDLER_RESULT_HANDLED; -} - -/* Adds a new D-BUS path message handler to the connection - * Note: this must be a unique path. - */ -int sbus_conn_add_interface(struct sbus_connection *conn, - struct sbus_interface *intf) -{ - struct sbus_interface_p *intf_p; - dbus_bool_t dbret; - const char *path; - - if (!conn || !intf || !intf->vtable.message_function) { - return EINVAL; - } - - path = intf->path; - - if (path_in_interface_list(conn->intf_list, path)) { - DEBUG(0, ("Cannot add method context with identical path.\n")); - return EINVAL; - } - - intf_p = talloc_zero(conn, struct sbus_interface_p); - if (!intf_p) { - return ENOMEM; - } - intf_p->conn = conn; - intf_p->intf = intf; - - DLIST_ADD(conn->intf_list, intf_p); - - dbret = dbus_connection_register_object_path(conn->dbus.conn, - path, &intf->vtable, intf_p); - if (!dbret) { - DEBUG(0, ("Could not register object path to the connection.\n")); - return ENOMEM; - } - - return EOK; -} - -static bool path_in_interface_list(struct sbus_interface_p *list, - const char *path) -{ - struct sbus_interface_p *iter; - - if (!list || !path) { - return false; - } - - iter = list; - while (iter != NULL) { - if (strcmp(iter->intf->path, path) == 0) { - return true; - } - iter = iter->next; - } - - return false; -} - -static void sbus_unreg_object_paths(struct sbus_connection *conn) -{ - struct sbus_interface_p *iter = conn->intf_list; - - while (iter != NULL) { - dbus_connection_unregister_object_path(conn->dbus.conn, - iter->intf->path); - iter = iter->next; - } -} - -void sbus_conn_set_private_data(struct sbus_connection *conn, void *pvt_data) -{ - conn->pvt_data = pvt_data; -} - -void *sbus_conn_get_private_data(struct sbus_connection *conn) -{ - return conn->pvt_data; -} - -static void sbus_reconnect(struct tevent_context *ev, - struct tevent_timer *te, - struct timeval tv, void *data) -{ - struct sbus_connection *conn; - struct sbus_interface_p *iter; - DBusError dbus_error; - dbus_bool_t dbret; - int ret; - - conn = talloc_get_type(data, struct sbus_connection); - dbus_error_init(&dbus_error); - - DEBUG(3, ("Making reconnection attempt %d to [%s]\n", - conn->retries, conn->address)); - conn->dbus.conn = dbus_connection_open(conn->address, &dbus_error); - if (conn->dbus.conn) { - /* We successfully reconnected. Set up mainloop integration. */ - DEBUG(3, ("Reconnected to [%s]\n", conn->address)); - ret = sbus_conn_set_fns(conn); - if (ret != EOK) { - dbus_connection_unref(conn->dbus.conn); - goto failed; - } - - /* Re-register object paths */ - iter = conn->intf_list; - while (iter) { - dbret = dbus_connection_register_object_path(conn->dbus.conn, - iter->intf->path, - &iter->intf->vtable, - iter); - if (!dbret) { - DEBUG(0, ("Could not register object path.\n")); - dbus_connection_unref(conn->dbus.conn); - goto failed; - } - iter = iter->next; - } - - /* Reset retries to 0 to resume dispatch processing */ - conn->retries = 0; - - /* Notify the owner of this connection that the - * reconnection was successful - */ - conn->reconnect_callback(conn, - SBUS_RECONNECT_SUCCESS, - conn->reconnect_pvt); - return; - } - -failed: - /* Reconnection failed, try again in a few seconds */ - DEBUG(1, ("Failed to open connection: name=%s, message=%s\n", - dbus_error.name, dbus_error.message)); - if (dbus_error_is_set(&dbus_error)) dbus_error_free(&dbus_error); - - conn->retries++; - - /* Check if we've passed our last chance or if we've lost track of - * our retry count somehow - */ - if ((conn->retries > conn->max_retries) || (conn->retries <= 0)) { - conn->reconnect_callback(conn, - SBUS_RECONNECT_EXCEEDED_RETRIES, - conn->reconnect_pvt); - } - - if (conn->retries == 2) { - /* Wait 3 seconds before the second reconnect attempt */ - tv.tv_sec += 3; - } - else if (conn->retries == 3) { - /* Wait 10 seconds before the third reconnect attempt */ - tv.tv_sec += 10; - } - else { - /* Wait 30 seconds before all subsequent reconnect attempts */ - tv.tv_sec += 30; - } - - te = tevent_add_timer(conn->ev, conn, tv, sbus_reconnect, conn); - if (!te) { - conn->reconnect_callback(conn, - SBUS_RECONNECT_ERROR, - conn->reconnect_pvt); - } -} - -/* This function will free and recreate the sbus_connection, - * calling functions need to be aware of this (and whether - * they have attached a talloc destructor to the - * sbus_connection. - */ -static int sbus_auto_reconnect(struct sbus_connection *conn) -{ - struct tevent_timer *te = NULL; - struct timeval tv; - - conn->retries++; - if (conn->retries >= conn->max_retries) { - /* Return EIO (to tell the calling process it - * needs to create a new connection from scratch - */ - return EIO; - } - - gettimeofday(&tv, NULL); - tv.tv_sec += 1; /* Wait 1 second before the first reconnect attempt */ - te = tevent_add_timer(conn->ev, conn, tv, sbus_reconnect, conn); - if (!te) { - return EIO; - } - - return EOK; -} - -/* Max retries */ -void sbus_reconnect_init(struct sbus_connection *conn, - int max_retries, - sbus_conn_reconn_callback_fn callback, - void *pvt) -{ - if (max_retries < 0 || callback == NULL) return; - - conn->retries = 0; - conn->max_retries = max_retries; - conn->reconnect_callback = callback; - conn->reconnect_pvt = pvt; -} - -bool sbus_conn_disconnecting(struct sbus_connection *conn) -{ - if (conn->disconnect == 1) return true; - return false; -} - -void sbus_conn_send_reply(struct sbus_connection *conn, DBusMessage *reply) -{ - dbus_connection_send(conn->dbus.conn, reply, NULL); -} - diff --git a/server/sbus/sssd_dbus_private.h b/server/sbus/sssd_dbus_private.h deleted file mode 100644 index 78a2fe5c..00000000 --- a/server/sbus/sssd_dbus_private.h +++ /dev/null @@ -1,98 +0,0 @@ -/* - Authors: - Simo Sorce <ssorce@redhat.com> - Stephen Gallagher <sgallagh@redhat.com> - - Copyright (C) 2009 Red Hat - - This program is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 3 of the License, or - (at your option) any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program. If not, see <http://www.gnu.org/licenses/>. -*/ - -#ifndef _SSSD_DBUS_PRIVATE_H_ -#define _SSSD_DBUS_PRIVATE_H_ - -union dbus_conn_pointer { - DBusServer *server; - DBusConnection *conn; -}; -enum dbus_conn_type { - SBUS_SERVER, - SBUS_CONNECTION -}; - -struct sbus_interface_p; -struct sbus_watch_ctx; - -struct sbus_connection { - struct tevent_context *ev; - - enum dbus_conn_type type; - union dbus_conn_pointer dbus; - - char *address; - int connection_type; - int disconnect; - - sbus_conn_destructor_fn destructor; - void *pvt_data; /* Private data for this connection */ - - /* dbus tables and handlers */ - struct sbus_interface_p *intf_list; - - /* reconnect settings */ - int retries; - int max_retries; - sbus_conn_reconn_callback_fn reconnect_callback; - /* Private data needed to reinit after reconnection */ - void *reconnect_pvt; - - /* server related stuff */ - struct sbus_interface *server_intf; - sbus_server_conn_init_fn srv_init_fn; - void *srv_init_data; - - /* watches list */ - struct sbus_watch_ctx *watch_list; -}; - -/* =Watches=============================================================== */ - -struct sbus_watch_ctx { - struct sbus_watch_ctx *prev, *next; - - struct sbus_connection *conn; - - struct tevent_fd *fde; - int fd; - - DBusWatch *dbus_read_watch; - DBusWatch *dbus_write_watch; -}; - -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); - -/* =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 deleted file mode 100644 index a859cbab..00000000 --- a/server/sbus/sssd_dbus_server.c +++ /dev/null @@ -1,171 +0,0 @@ -/* - SSSD - - Service monitor - D-BUS features - - Copyright (C) Stephen Gallagher 2008 - - This program is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 3 of the License, or - (at your option) any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program. If not, see <http://www.gnu.org/licenses/>. -*/ -#include <sys/time.h> -#include "tevent.h" -#include "util/util.h" -#include "dbus/dbus.h" -#include "sbus/sssd_dbus.h" -#include "sbus/sssd_dbus_private.h" - -static int sbus_server_destructor(void *ctx); - -/* - * new_connection_callback - * Actions to be run upon each new client connection - * Must either perform dbus_connection_ref() on the - * new connection or else close the connection with - * dbus_connection_close() - */ -static void sbus_server_init_new_connection(DBusServer *dbus_server, - DBusConnection *dbus_conn, - void *data) -{ - struct sbus_connection *server; - struct sbus_connection *conn; - int ret; - - DEBUG(5,("Entering.\n")); - server = talloc_get_type(data, struct sbus_connection); - if (!server) { - return; - } - - DEBUG(5,("Adding connection %p.\n", dbus_conn)); - ret = sbus_init_connection(server, server->ev, - dbus_conn, server->server_intf, - SBUS_CONN_TYPE_PRIVATE, &conn); - if (ret != 0) { - dbus_connection_close(dbus_conn); - DEBUG(5,("Closing connection (failed setup)")); - return; - } - - dbus_connection_ref(dbus_conn); - - DEBUG(5,("Got a connection\n")); - - /* - * Initialize connection-specific features - * This may set a more detailed destructor, but - * the default destructor will always be chained - * to handle connection cleanup. - * This function (or its callbacks) should also - * set up connection-specific methods. - */ - ret = server->srv_init_fn(conn, server->srv_init_data); - if (ret != EOK) { - DEBUG(1,("Initialization failed!\n")); - dbus_connection_close(dbus_conn); - talloc_zfree(conn); - } -} - -/* - * dbus_new_server - * Set up a D-BUS server, integrate with the event loop - * for handling file descriptor and timed events - */ -int sbus_new_server(TALLOC_CTX *mem_ctx, - struct tevent_context *ev, - const char *address, - struct sbus_interface *intf, - struct sbus_connection **_server, - sbus_server_conn_init_fn init_fn, void *init_pvt_data) -{ - struct sbus_connection *server; - DBusServer *dbus_server; - DBusError dbus_error; - dbus_bool_t dbret; - char *tmp; - - *_server = NULL; - - /* Set up D-BUS server */ - dbus_error_init(&dbus_error); - dbus_server = dbus_server_listen(address, &dbus_error); - if (!dbus_server) { - DEBUG(1,("dbus_server_listen failed! (name=%s, message=%s)\n", - dbus_error.name, dbus_error.message)); - if (dbus_error_is_set(&dbus_error)) dbus_error_free(&dbus_error); - return EIO; - } - - tmp = dbus_server_get_address(dbus_server); - DEBUG(3, ("D-BUS Server listening on %s\n", tmp)); - free(tmp); - - server = talloc_zero(mem_ctx, struct sbus_connection); - if (!server) { - return ENOMEM; - } - - server->ev = ev; - server->type = SBUS_SERVER; - server->dbus.server = dbus_server; - server->server_intf = intf; - server->srv_init_fn = init_fn; - server->srv_init_data = init_pvt_data; - - talloc_set_destructor((TALLOC_CTX *)server, sbus_server_destructor); - - /* Set up D-BUS new connection handler */ - dbus_server_set_new_connection_function(server->dbus.server, - sbus_server_init_new_connection, - server, NULL); - - /* Set up DBusWatch functions */ - dbret = dbus_server_set_watch_functions(server->dbus.server, - sbus_add_watch, - sbus_remove_watch, - sbus_toggle_watch, - server, NULL); - if (!dbret) { - DEBUG(4, ("Error setting up D-BUS server watch functions")); - talloc_free(server); - return EIO; - } - - /* Set up DBusTimeout functions */ - dbret = dbus_server_set_timeout_functions(server->dbus.server, - sbus_add_timeout, - sbus_remove_timeout, - sbus_toggle_timeout, - server, NULL); - if (!dbret) { - DEBUG(4,("Error setting up D-BUS server timeout functions")); - dbus_server_set_watch_functions(server->dbus.server, - NULL, NULL, NULL, NULL, NULL); - talloc_free(server); - return EIO; - } - - *_server = server; - return EOK; -} - -static int sbus_server_destructor(void *ctx) -{ - struct sbus_connection *server; - - server = talloc_get_type(ctx, struct sbus_connection); - dbus_server_disconnect(server->dbus.server); - return 0; -} |