From deb6bcac8d1e1ecec4aafaee2d27dbe467e4f461 Mon Sep 17 00:00:00 2001 From: Lennart Poettering Date: Mon, 15 Aug 2005 02:42:59 +0000 Subject: * implement ini file parser * strip glib usage from avahi-daemon * make dbus-watch-glue a static library so that both avahi-client and avahi-daemon can make use of it git-svn-id: file:///home/lennart/svn/public/avahi/trunk@327 941a03a8-eaeb-0310-b9a0-b1bbd8fe43fe --- avahi-common/Makefile.am | 23 +++- avahi-common/dbus-watch-glue.c | 235 +++++++++++++++++++++++++++++++++++++++++ avahi-common/dbus-watch-glue.h | 31 ++++++ avahi-common/malloc.h | 4 +- avahi-common/simple-watch.c | 1 + 5 files changed, 287 insertions(+), 7 deletions(-) create mode 100644 avahi-common/dbus-watch-glue.c create mode 100644 avahi-common/dbus-watch-glue.h (limited to 'avahi-common') diff --git a/avahi-common/Makefile.am b/avahi-common/Makefile.am index 7c41ea3..4310797 100644 --- a/avahi-common/Makefile.am +++ b/avahi-common/Makefile.am @@ -37,11 +37,8 @@ avahi_commoninclude_HEADERS = \ simple-watch.h \ gccmacro.h -noinst_HEADERS = llist.h - -if ENABLE_DBUS -noinst_HEADERS += dbus.h -endif +noinst_HEADERS = \ + llist.h noinst_PROGRAMS = \ strlst-test \ @@ -105,3 +102,19 @@ timeval_test_CFLAGS = $(AM_CFLAGS) timeval_test_LDADD = $(AM_LDADD) + +if ENABLE_DBUS +noinst_HEADERS += \ + dbus.h \ + dbus-watch-glue.h + +noinst_LIBRARIES = \ + libdbus-watch-glue.a + +libdbus_watch_glue_a_SOURCES = \ + dbus-watch-glue.h dbus-watch-glue.c + +libdbus_watch_glue_a_CFLAGS = $(AM_CFLAGS) $(DBUS_CFLAGS) + +endif + diff --git a/avahi-common/dbus-watch-glue.c b/avahi-common/dbus-watch-glue.c new file mode 100644 index 0000000..20f8796 --- /dev/null +++ b/avahi-common/dbus-watch-glue.c @@ -0,0 +1,235 @@ +/* $Id$ */ + +/*** + This file is part of avahi. + + avahi is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as + published by the Free Software Foundation; either version 2.1 of the + License, or (at your option) any later version. + + avahi 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 Lesser General + Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with avahi; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 + USA. +***/ + +#include + +#include + +#include "dbus-watch-glue.h" + +static AvahiWatchEvent translate_dbus_to_avahi(unsigned int f) { + AvahiWatchEvent e = 0; + + if (f & DBUS_WATCH_READABLE) + e |= AVAHI_WATCH_IN; + if (f & DBUS_WATCH_WRITABLE) + e |= AVAHI_WATCH_OUT; + if (f & DBUS_WATCH_ERROR) + e |= AVAHI_WATCH_ERR; + if (f & DBUS_WATCH_HANGUP) + e |= AVAHI_WATCH_HUP; + + return e; +} + +static unsigned int translate_avahi_to_dbus(AvahiWatchEvent e) { + unsigned int f = 0; + + if (e & AVAHI_WATCH_IN) + f |= DBUS_WATCH_READABLE; + if (e & AVAHI_WATCH_OUT) + f |= DBUS_WATCH_WRITABLE; + if (e & AVAHI_WATCH_ERR) + f |= DBUS_WATCH_ERROR; + if (e & AVAHI_WATCH_HUP) + f |= DBUS_WATCH_HANGUP; + + return f; +} + +static void watch_callback(AvahiWatch *avahi_watch, int fd, AvahiWatchEvent events, void *userdata) { + DBusWatch *dbus_watch = userdata; + assert(avahi_watch); + assert(dbus_watch); + + dbus_watch_handle(dbus_watch, translate_avahi_to_dbus(events)); + /* Ignore the return value */ +} + +static dbus_bool_t update_watch(const AvahiPoll *poll_api, DBusWatch *dbus_watch) { + AvahiWatch *avahi_watch; + dbus_bool_t b; + + assert(dbus_watch); + + avahi_watch = dbus_watch_get_data(dbus_watch); + + b = dbus_watch_get_enabled(dbus_watch); + + if (b && !avahi_watch) { + + if (!(avahi_watch = poll_api->watch_new( + poll_api, + dbus_watch_get_fd(dbus_watch), + translate_dbus_to_avahi(dbus_watch_get_flags(dbus_watch)), + watch_callback, + dbus_watch))) + return FALSE; + + dbus_watch_set_data(dbus_watch, avahi_watch, NULL); + + } else if (!b && avahi_watch) { + + poll_api->watch_free(avahi_watch); + dbus_watch_set_data(dbus_watch, NULL, NULL); + + } else if (avahi_watch) { + + /* Update flags */ + poll_api->watch_update(avahi_watch, dbus_watch_get_flags(dbus_watch)); + } + + return TRUE; +} + +static dbus_bool_t add_watch(DBusWatch *dbus_watch, void *userdata) { + const AvahiPoll *poll_api = (const AvahiPoll*) userdata; + + assert(dbus_watch); + assert(poll_api); + + return update_watch(poll_api, dbus_watch); +} + +static void remove_watch(DBusWatch *dbus_watch, void *userdata) { + const AvahiPoll *poll_api = (const AvahiPoll*) userdata; + AvahiWatch *avahi_watch; + + assert(dbus_watch); + assert(poll_api); + + if ((avahi_watch = dbus_watch_get_data(dbus_watch))) { + poll_api->watch_free(avahi_watch); + dbus_watch_set_data(dbus_watch, NULL, NULL); + } +} + +static void watch_toggled(DBusWatch *dbus_watch, void *userdata) { + const AvahiPoll *poll_api = (const AvahiPoll*) userdata; + + assert(dbus_watch); + assert(poll_api); + + update_watch(poll_api, dbus_watch); +} + +typedef struct TimeoutData { + const AvahiPoll *poll_api; + AvahiTimeout *avahi_timeout; + DBusTimeout *dbus_timeout; +} TimeoutData; + +static void update_timeout(TimeoutData *timeout) { + assert(timeout); + + if (dbus_timeout_get_enabled(timeout->dbus_timeout)) { + struct timeval tv; + avahi_elapse_time(&tv, dbus_timeout_get_interval(timeout->dbus_timeout), 0); + timeout->poll_api->timeout_update(timeout-> + avahi_timeout, &tv); + } else + timeout->poll_api->timeout_update(timeout->avahi_timeout, NULL); + +} + +static void timeout_callback(AvahiTimeout *avahi_timeout, void *userdata) { + TimeoutData *timeout = userdata; + + assert(avahi_timeout); + assert(timeout); + + dbus_timeout_handle(timeout->dbus_timeout); + /* Ignore the return value */ + + update_timeout(timeout); +} + +static dbus_bool_t add_timeout(DBusTimeout *dbus_timeout, void *userdata) { + TimeoutData *timeout; + const AvahiPoll *poll_api = (const AvahiPoll*) userdata; + struct timeval tv; + dbus_bool_t b; + + assert(dbus_timeout); + assert(poll_api); + + if (!(timeout = avahi_new(TimeoutData, 1))) + return FALSE; + + timeout->dbus_timeout = dbus_timeout; + timeout->poll_api = poll_api; + + if ((b = dbus_timeout_get_enabled(dbus_timeout))) + avahi_elapse_time(&tv, dbus_timeout_get_interval(dbus_timeout), 0); + + if (!(timeout->avahi_timeout = poll_api->timeout_new( + poll_api, + b ? &tv : NULL, + timeout_callback, + dbus_timeout))) { + avahi_free(timeout); + return FALSE; + } + + dbus_timeout_set_data(dbus_timeout, timeout, NULL); + return TRUE; +} + +static void remove_timeout(DBusTimeout *dbus_timeout, void *userdata) { + TimeoutData *timeout; + const AvahiPoll *poll_api = (const AvahiPoll*) userdata; + + assert(dbus_timeout); + assert(poll_api); + + timeout = dbus_timeout_get_data(dbus_timeout); + assert(timeout); + + poll_api->timeout_free(timeout->avahi_timeout); + avahi_free(timeout); + dbus_timeout_set_data(dbus_timeout, NULL, NULL); +} + +static void timeout_toggled(DBusTimeout *dbus_timeout, void *userdata) { + TimeoutData *timeout; + const AvahiPoll *poll_api = (const AvahiPoll*) userdata; + + assert(dbus_timeout); + assert(poll_api); + + timeout = dbus_timeout_get_data(dbus_timeout); + assert(timeout); + + update_timeout(timeout); +} + +int avahi_dbus_connection_glue(DBusConnection *c, const AvahiPoll *poll_api) { + assert(c); + assert(poll_api); + + if (!(dbus_connection_set_watch_functions(c, add_watch, remove_watch, watch_toggled, (void*) poll_api, NULL))) + return -1; + + if (!(dbus_connection_set_timeout_functions(c, add_timeout, remove_timeout, timeout_toggled, (void*) poll_api, NULL))) + return -1; + + return 0; +} diff --git a/avahi-common/dbus-watch-glue.h b/avahi-common/dbus-watch-glue.h new file mode 100644 index 0000000..e815b45 --- /dev/null +++ b/avahi-common/dbus-watch-glue.h @@ -0,0 +1,31 @@ +#ifndef foodbuswatchgluehfoo +#define foodbuswatchgluehfoo + +/* $Id$ */ + +/*** + This file is part of avahi. + + avahi is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as + published by the Free Software Foundation; either version 2.1 of the + License, or (at your option) any later version. + + avahi 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 Lesser General + Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with avahi; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 + USA. +***/ + +#include + +#include + +int avahi_dbus_connection_glue(DBusConnection *c, const AvahiPoll *poll_api); + +#endif diff --git a/avahi-common/malloc.h b/avahi-common/malloc.h index 6d10226..d0e620a 100644 --- a/avahi-common/malloc.h +++ b/avahi-common/malloc.h @@ -45,10 +45,10 @@ void avahi_free(void *p); void *avahi_realloc(void *p, size_t size); /** Allocate n new structures of the specified type. */ -#define avahi_new(type, n) (type*) avahi_malloc(n*sizeof(type)) +#define avahi_new(type, n) ((type*) avahi_malloc((n)*sizeof(type))) /** Same as avahi_new() but set the memory to zero */ -#define avahi_new0(type, n) (type*) avahi_malloc0(n*sizeof(type)) +#define avahi_new0(type, n) ((type*) avahi_malloc0((n)*sizeof(type))) /** Just like libc's strdup() */ char *avahi_strdup(const char *s); diff --git a/avahi-common/simple-watch.c b/avahi-common/simple-watch.c index c3ed86f..770cf4f 100644 --- a/avahi-common/simple-watch.c +++ b/avahi-common/simple-watch.c @@ -158,6 +158,7 @@ static void remove_pollfd(AvahiWatch *w) { static void watch_free(AvahiWatch *w) { assert(w); + assert(!w->dead); remove_pollfd(w); -- cgit