diff options
81 files changed, 3352 insertions, 2589 deletions
diff --git a/Makefile.am b/Makefile.am index 628a0ac..05b84bc 100644 --- a/Makefile.am +++ b/Makefile.am @@ -36,6 +36,7 @@ EXTRA_DIST = \ SUBDIRS = \ common \ avahi-common \ + avahi-glib \ avahi-core \ avahi-discover-standalone \ avahi-client \ @@ -43,7 +44,6 @@ SUBDIRS = \ initscript \ avahi-dnsconfd \ avahi-utils \ - avahi-glib \ examples \ man diff --git a/avahi-common/Makefile.am b/avahi-common/Makefile.am index c78e054..8ac6365 100644 --- a/avahi-common/Makefile.am +++ b/avahi-common/Makefile.am @@ -34,7 +34,8 @@ avahi_commoninclude_HEADERS = \ malloc.h watch.h \ timeval.h \ - simple-watch.h + simple-watch.h \ + gccmacro.h noinst_HEADERS = llist.h diff --git a/avahi-common/domain-test.c b/avahi-common/domain-test.c index fc310c7..76f806a 100644 --- a/avahi-common/domain-test.c +++ b/avahi-common/domain-test.c @@ -45,7 +45,7 @@ int main(int argc, char *argv[]) { printf("%i\n", avahi_domain_equal("a", "aaa")); -/* printf("%u = %u\n", avahi_domain_hash("\\Aaaab\\\\."), avahi_domain_hash("aaaa\\b\\\\")); */ + printf("%u = %u\n", avahi_domain_hash("\\Aaaab\\\\."), avahi_domain_hash("aaaa\\b\\\\")); return 0; } diff --git a/avahi-common/domain.c b/avahi-common/domain.c index 5a51a39..3703a04 100644 --- a/avahi-common/domain.c +++ b/avahi-common/domain.c @@ -320,3 +320,20 @@ int avahi_is_valid_host_name(const char *t) { return 1; } + +unsigned avahi_domain_hash(const char *s) { + unsigned hash = 0; + + for (;;) { + char c[65], *p; + + if (!avahi_unescape_label(&s, c, sizeof(c))) + return hash; + + if (!c[0]) + continue; + + for (p = c; *p; p++) + hash = 31 * hash + tolower(*p); + } +} diff --git a/avahi-common/domain.h b/avahi-common/domain.h index 83a9332..c9cc39e 100644 --- a/avahi-common/domain.h +++ b/avahi-common/domain.h @@ -65,6 +65,11 @@ int avahi_is_valid_service_name(const char *t); /** Return 1 when the specified string contains a valid non-FQDN host name (i.e. without dots), 0 otherwise */ int avahi_is_valid_host_name(const char *t); +/** Return some kind of hash value for the domain, useful for using domains as hash table keys. */ +unsigned avahi_domain_hash(const char *name); + + + AVAHI_C_DECL_END #endif diff --git a/avahi-common/error.c b/avahi-common/error.c index 3dca208..b845793 100644 --- a/avahi-common/error.c +++ b/avahi-common/error.c @@ -47,7 +47,8 @@ const char *avahi_strerror(int error) { "Access denied", "Invalid operation", "An unexpected DBUS error occured", - "Could not get a connection to the daemon" + "Could not get a connection to the daemon", + "Memory exhausted" }; if (-error < 0 || -error >= -AVAHI_ERR_MAX) diff --git a/avahi-common/error.h b/avahi-common/error.h index 223ba02..943b49c 100644 --- a/avahi-common/error.h +++ b/avahi-common/error.h @@ -54,7 +54,8 @@ enum { AVAHI_ERR_INVALID_OPERATION = -21, /**< Invalid operation */ AVAHI_ERR_DBUS_ERROR = -22, /**< An unexpected DBUS error occured */ AVAHI_ERR_NOT_CONNECTED = -23, /**< Could not get a connection to the daemon */ - AVAHI_ERR_MAX = -24 + AVAHI_ERR_NO_MEMORY = -24, /**< Memory exhausted */ + AVAHI_ERR_MAX = -25 }; /** Return a human readable error string for the specified error code */ diff --git a/avahi-common/gccmacro.h b/avahi-common/gccmacro.h new file mode 100644 index 0000000..42fb153 --- /dev/null +++ b/avahi-common/gccmacro.h @@ -0,0 +1,47 @@ +#ifndef foogccmacrohfoo +#define foogccmacrohfoo + +/* $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. +***/ + +#ifdef __GNUC__ +#define AVAHI_GCC_SENTINEL __attribute__ ((sentinel)) +#else +#define AVAHI_GCC_SENTINEL +#endif + +#ifdef __GNUC__ +#define AVAHI_GCC_PRINTF_ATTR(a,b) __attribute__ ((format (printf, a, b))) +#else +/** Macro for usage of GCC's printf compilation warnings */ +#define AVAHI_GCC_PRINTF_ATTR(a,b) +#endif + +#define AVAHI_GCC_PRINTF_ATTR12 AVAHI_GCC_PRINTF_ATTR(1,2) +#define AVAHI_GCC_PRINTF_ATTR23 AVAHI_GCC_PRINTF_ATTR(2,3) + +#ifdef __GNUC__ +#define AVAHI_GCC_NORETURN __attribute__((noreturn)) +#else +#define AVAHI_GCC_NORETURN +#endif + +#endif diff --git a/avahi-common/malloc.c b/avahi-common/malloc.c index 1883849..018a0c0 100644 --- a/avahi-common/malloc.c +++ b/avahi-common/malloc.c @@ -27,18 +27,78 @@ #include <string.h> #include <assert.h> #include <stdio.h> +#include <unistd.h> #include "malloc.h" static const AvahiAllocator *allocator = NULL; +static void oom(void) AVAHI_GCC_NORETURN; + +static void oom(void) { + + static const char msg[] = "Out of memory, aborting ...\n"; + const char *n = msg; + + while (strlen(n) > 0) { + ssize_t r; + + if ((r = write(2, n, strlen(n))) < 0) + break; + + n += r; + } + + abort(); +} + +/* Default implementation for avahi_malloc() */ +static void* xmalloc(size_t size) { + void *p; + + if (size == 0) + return NULL; + + if (!(p = malloc(size))) + oom(); + + return p; +} + +/* Default implementation for avahi_realloc() */ +static void *xrealloc(void *p, size_t size) { + + if (size == 0) { + free(p); + return NULL; + } + + if (!(p = realloc(p, size))) + oom(); + + return p; +} + +/* Default implementation for avahi_calloc() */ +static void *xcalloc(size_t nmemb, size_t size) { + void *p; + + if (size == 0 || nmemb == 0) + return NULL; + + if (!(p = calloc(nmemb, size))) + oom(); + + return p; +} + void *avahi_malloc(size_t size) { if (size <= 0) return NULL; if (!allocator) - return malloc(size); + return xmalloc(size); assert(allocator->malloc); return allocator->malloc(size); @@ -51,7 +111,7 @@ void *avahi_malloc0(size_t size) { return NULL; if (!allocator) - return calloc(1, size); + return xcalloc(1, size); if (allocator->calloc) return allocator->calloc(1, size); @@ -79,8 +139,13 @@ void avahi_free(void *p) { void *avahi_realloc(void *p, size_t size) { + if (size == 0) { + avahi_free(p); + return NULL; + } + if (!allocator) - return realloc(p, size); + return xrealloc(p, size); assert(allocator->realloc); return allocator->realloc(p, size); diff --git a/avahi-common/malloc.h b/avahi-common/malloc.h index b658357..6d10226 100644 --- a/avahi-common/malloc.h +++ b/avahi-common/malloc.h @@ -28,6 +28,7 @@ #include <stdarg.h> #include <avahi-common/cdecl.h> +#include <avahi-common/gccmacro.h> AVAHI_C_DECL_BEGIN @@ -73,12 +74,8 @@ struct AvahiAllocator { * allocators. The structure is not copied! */ void avahi_set_allocator(const AvahiAllocator *a); -#ifdef __GNUC__ -char *avahi_strdup_printf(const char *fmt, ... ) __attribute__ ((format(printf, 1, 2))); -#else /** Like sprintf() but store the result in a freshly allocated buffer. Free this with avahi_free() */ -char *avahi_strdup_printf(const char *fmt, ... ); -#endif +char *avahi_strdup_printf(const char *fmt, ... ) AVAHI_GCC_PRINTF_ATTR12; /** Same as avahi_strdup_printf() but take a va_list instead of varargs */ char *avahi_strdup_vprintf(const char *fmt, va_list ap); diff --git a/avahi-common/simple-watch.c b/avahi-common/simple-watch.c index acc0923..3caf371 100644 --- a/avahi-common/simple-watch.c +++ b/avahi-common/simple-watch.c @@ -51,7 +51,8 @@ struct AvahiSimplePoll { int n_pollfds, max_pollfds, rebuild_pollfds; struct timeval wakeup; - int use_wakeup; + AvahiWakeupCallback wakeup_callback; + void *wakeup_userdata; int req_cleanup; @@ -141,17 +142,24 @@ static void watch_free(AvahiWatch *w) { w->simple_poll->req_cleanup = 1; } -static void set_wakeup_time(AvahiPoll *api, const struct timeval *tv) { +static void set_wakeup(AvahiPoll *api, const struct timeval *tv, AvahiWakeupCallback callback, void *userdata) { AvahiSimplePoll *s; assert(api); s = api->userdata; - if (tv) { - s->wakeup = *tv; - s->use_wakeup = 1; + if (callback) { + if (tv) + s->wakeup = *tv; + else { + s->wakeup.tv_sec = 0; + s->wakeup.tv_usec = 0; + } + + s->wakeup_callback = callback; + s->wakeup_userdata = userdata; } else - s->use_wakeup = 0; + s->wakeup_callback = NULL; } static void destroy_watch(AvahiWatch *w) { @@ -190,10 +198,10 @@ AvahiSimplePoll *avahi_simple_poll_new(void) { s->api.watch_new = watch_new; s->api.watch_free = watch_free; s->api.watch_update = watch_update; - s->api.set_wakeup_time = set_wakeup_time; + s->api.set_wakeup = set_wakeup; s->pollfds = NULL; s->max_pollfds = s->n_pollfds = 0; - s->use_wakeup = 0; + s->wakeup_callback = NULL; s->rebuild_pollfds = 0; s->quit = 0; s->n_watches = 0; @@ -248,41 +256,84 @@ static int rebuild(AvahiSimplePoll *s) { return 0; } -int avahi_simple_poll_iterate(AvahiSimplePoll *s, int block) { - int timeout, r, ret = 0; +static int start_wakeup_callback(AvahiSimplePoll *s) { + AvahiWakeupCallback callback; + void *userdata; + assert(s); - if (s->quit) - return 1; + /* Reset the wakeup functions, but allow changing of the two + values from the callback function */ + + callback = s->wakeup_callback; + userdata = s->wakeup_userdata; + s->wakeup_callback = NULL; + s->wakeup_userdata = NULL; + + assert(callback); + + callback(&s->api, userdata); + return 0; +} + +int avahi_simple_poll_iterate(AvahiSimplePoll *s, int timeout) { + int r; + assert(s); + /* Cleanup things first */ if (s->req_cleanup) cleanup(s, 0); - + + /* Check whether a quit was requested */ + if (s->quit) + return 1; + + /* Do we need to rebuild our array of pollfds? */ if (s->rebuild_pollfds) if (rebuild(s) < 0) return -1; - if (block) { - if (s->use_wakeup) { - struct timeval now; - AvahiUsec usec; + /* Calculate the wakeup time */ + if (s->wakeup_callback) { + struct timeval now; + int t; + AvahiUsec usec; - gettimeofday(&now, NULL); + gettimeofday(&now, NULL); + usec = avahi_timeval_diff(&s->wakeup, &now); - usec = avahi_timeval_diff(&s->wakeup, &now); - - timeout = usec <= 0 ? 0 : (int) (usec / 1000); - } else - timeout = -1; - } else - timeout = 0; + if (usec <= 0) + /* Timeout elapsed */ + + return start_wakeup_callback(s); + + /* Calculate sleep time. We add 1ms because otherwise we'd + * wake up too early most of the time */ + t = (int) (usec / 1000) + 1; + + if (timeout < 0 || timeout > t) + timeout = t; + } if ((r = poll(s->pollfds, s->n_pollfds, timeout)) < 0) return -1; - else if (r > 0) { + /* Check whether the wakeup time has been reached now */ + if (s->wakeup_callback) { + struct timeval now; + + gettimeofday(&now, NULL); + + if (avahi_timeval_compare(&s->wakeup, &now) <= 0) + /* Time elapsed */ + return start_wakeup_callback(s); + } + + if (r > 0) { AvahiWatch *w; + /* Look for some kind of I/O event */ + for (w = s->watches; w; w = w->watches_next) { if (w->dead) @@ -291,24 +342,15 @@ int avahi_simple_poll_iterate(AvahiSimplePoll *s, int block) { assert(w->idx >= 0); assert(w->idx < s->n_pollfds); - if (s->pollfds[w->idx].revents > 0) + if (s->pollfds[w->idx].revents > 0) { + /* We execute only on callback in every iteration */ w->callback(w, w->pollfd.fd, s->pollfds[w->idx].revents, w->userdata); - - if (s->quit) { - ret = 1; - goto finish; + return 0; } } } - ret = 0; - -finish: - - if (s->req_cleanup) - cleanup(s, 0); - - return ret; + return 0; } void avahi_simple_poll_quit(AvahiSimplePoll *w) { diff --git a/avahi-common/simple-watch.h b/avahi-common/simple-watch.h index 600e5ce..127ddc5 100644 --- a/avahi-common/simple-watch.h +++ b/avahi-common/simple-watch.h @@ -35,7 +35,7 @@ void avahi_simple_poll_free(AvahiSimplePoll *s); AvahiPoll* avahi_simple_poll_get(AvahiSimplePoll *s); -int avahi_simple_poll_iterate(AvahiSimplePoll *s, int block); +int avahi_simple_poll_iterate(AvahiSimplePoll *s, int sleep_time); void avahi_simple_poll_quit(AvahiSimplePoll *s); diff --git a/avahi-common/strlst.h b/avahi-common/strlst.h index 56bf525..10b7aa6 100644 --- a/avahi-common/strlst.h +++ b/avahi-common/strlst.h @@ -29,6 +29,7 @@ #include <stdarg.h> #include <avahi-common/cdecl.h> +#include <avahi-common/gccmacro.h> AVAHI_C_DECL_BEGIN @@ -47,7 +48,7 @@ typedef struct AvahiStringList { /** Create a new string list by taking a variable list of NUL * terminated strings. The strings are copied using g_strdup(). The * argument list must be terminated by a NULL pointer. */ -AvahiStringList *avahi_string_list_new(const char *txt, ...); +AvahiStringList *avahi_string_list_new(const char *txt, ...) AVAHI_GCC_SENTINEL; /** Same as avahi_string_list_new() but pass a va_list structure */ AvahiStringList *avahi_string_list_new_va(va_list va); @@ -79,7 +80,7 @@ AvahiStringList*avahi_string_list_add_anonymous(AvahiStringList *l, size_t size) /** Same as avahi_string_list_add(), but takes a variable number of * NUL terminated strings. The argument list must be terminated by a * NULL pointer. Returns the new list start. */ -AvahiStringList *avahi_string_list_add_many(AvahiStringList *r, ...); +AvahiStringList *avahi_string_list_add_many(AvahiStringList *r, ...) AVAHI_GCC_SENTINEL; /** Same as avahi_string_list_add_many(), but use a va_list * structure. Returns the new list start. */ diff --git a/avahi-common/watch-test.c b/avahi-common/watch-test.c index f87a303..af46805 100644 --- a/avahi-common/watch-test.c +++ b/avahi-common/watch-test.c @@ -34,6 +34,7 @@ #include "timeval.h" static AvahiPoll *api = NULL; +static AvahiSimplePoll *simple_poll = NULL; static void callback(AvahiWatch *w, int fd, AvahiWatchEvent event, void *userdata) { @@ -51,31 +52,35 @@ static void callback(AvahiWatch *w, int fd, AvahiWatchEvent event, void *userdat } } +static void wakeup(AvahiPoll *_api, void *userdata) { + static int i = 0; + struct timeval tv; + + printf("Wakeup #%i\n", i++); + + if (i > 10) + avahi_simple_poll_quit(simple_poll); + else { + avahi_elapse_time(&tv, 1000, 0); + api->set_wakeup(api, &tv, wakeup, NULL); + } +} + int main(int argc, char *argv[]) { - int i = 0; - AvahiSimplePoll *s; + struct timeval tv; - s = avahi_simple_poll_new(); - assert(s); - - api = avahi_simple_poll_get(s); + simple_poll = avahi_simple_poll_new(); + api = avahi_simple_poll_get(simple_poll); api->watch_new(api, 0, AVAHI_WATCH_IN, callback, NULL); - for (;;) { - struct timeval tv; - printf("Iteration %i\n", i++); - - if (i > 100) - avahi_simple_poll_quit(s); + avahi_elapse_time(&tv, 1000, 0); + api->set_wakeup(api, &tv, wakeup, NULL); - avahi_elapse_time(&tv, 1000, 0); - - api->set_wakeup_time(api, &tv); - - if (avahi_simple_poll_iterate(s, 1) != 0) + /* Our main loop */ + for (;;) + if (avahi_simple_poll_iterate(simple_poll, -1) != 0) break; - } return 0; } diff --git a/avahi-common/watch.h b/avahi-common/watch.h index b26c2ba..70dedb7 100644 --- a/avahi-common/watch.h +++ b/avahi-common/watch.h @@ -40,6 +40,7 @@ typedef enum { } AvahiWatchEvent; typedef void (*AvahiWatchCallback)(AvahiWatch *w, int fd, AvahiWatchEvent event, void *userdata); +typedef void (*AvahiWakeupCallback)(AvahiPoll *api, void *userdata); struct AvahiPoll { void* userdata; @@ -48,7 +49,7 @@ struct AvahiPoll { void (*watch_update)(AvahiWatch *w, AvahiWatchEvent event); void (*watch_free)(AvahiWatch *w); - void (*set_wakeup_time)(AvahiPoll *api, const struct timeval *tv); + void (*set_wakeup)(AvahiPoll *api, const struct timeval *tv, AvahiWakeupCallback callback, void *userdata); }; AVAHI_C_DECL_END diff --git a/avahi-core/Makefile.am b/avahi-core/Makefile.am index e0e7d86..a300560 100644 --- a/avahi-core/Makefile.am +++ b/avahi-core/Makefile.am @@ -19,13 +19,12 @@ AM_CFLAGS=-I$(top_srcdir) -# GLIB 2.0 -AM_CFLAGS+=$(GLIB20_CFLAGS) -AM_LDADD=$(GLIB20_LIBS) - # Import stuff from avahi-common COMMON_LDADD=../avahi-common/libavahi-common.la +# Import stuff from avahi-glib +GLIB_LDADD=../avahi-glib/libavahi-glib.la + # This cool debug trap works on i386/gcc only AM_CFLAGS+='-DDEBUG_TRAP=__asm__("int $$3")' @@ -88,13 +87,13 @@ prioq_test_LDADD = $(AM_LDADD) $(COMMON_LDADD) avahi_test_SOURCES = \ avahi-test.c -avahi_test_CFLAGS = $(AM_CFLAGS) -avahi_test_LDADD = $(AM_LDADD) $(COMMON_LDADD) libavahi-core.la +avahi_test_CFLAGS = $(AM_CFLAGS) $(GLIB20_CFLAGS) +avahi_test_LDADD = $(AM_LDADD) $(COMMON_LDADD) libavahi-core.la $(GLIB_LDADD) $(GLIB20_LIBS) conformance_test_SOURCES = \ conformance-test.c -conformance_test_CFLAGS = $(AM_CFLAGS) -conformance_test_LDADD = $(AM_LDADD) $(COMMON_LDADD) libavahi-core.la +conformance_test_CFLAGS = $(AM_CFLAGS) $(GLIB20_CFLAGS) +conformance_test_LDADD = $(AM_LDADD) $(COMMON_LDADD) libavahi-core.la $(GLIB_LDADD) $(GLIB20_LIBS) avahi_reflector_SOURCES = \ avahi-reflector.c @@ -114,7 +113,8 @@ dns_test_LDADD = $(AM_LDADD) $(COMMON_LDADD) timeeventq_test_SOURCES = \ timeeventq-test.c \ timeeventq.h timeeventq.c \ - prioq.h prioq.c + prioq.h prioq.c \ + log.c log.h timeeventq_test_CFLAGS = $(AM_CFLAGS) timeeventq_test_LDADD = $(AM_LDADD) $(COMMON_LDADD) diff --git a/avahi-core/announce.c b/avahi-core/announce.c index 9a6d505..b6ded71 100644 --- a/avahi-core/announce.c +++ b/avahi-core/announce.c @@ -24,50 +24,53 @@ #endif #include <avahi-common/timeval.h> +#include <avahi-common/malloc.h> + #include "announce.h" +#include "log.h" #define AVAHI_ANNOUNCEMENT_JITTER_MSEC 250 #define AVAHI_PROBE_JITTER_MSEC 250 #define AVAHI_PROBE_INTERVAL_MSEC 250 static void remove_announcement(AvahiServer *s, AvahiAnnouncement *a) { - g_assert(s); - g_assert(a); + assert(s); + assert(a); if (a->time_event) - avahi_time_event_queue_remove(s->time_event_queue, a->time_event); + avahi_time_event_free(a->time_event); AVAHI_LLIST_REMOVE(AvahiAnnouncement, by_interface, a->interface->announcements, a); AVAHI_LLIST_REMOVE(AvahiAnnouncement, by_entry, a->entry->announcements, a); - g_free(a); + avahi_free(a); } static void elapse_announce(AvahiTimeEvent *e, void *userdata); static void set_timeout(AvahiAnnouncement *a, const struct timeval *tv) { - g_assert(a); + assert(a); if (!tv) { if (a->time_event) { - avahi_time_event_queue_remove(a->server->time_event_queue, a->time_event); + avahi_time_event_free(a->time_event); a->time_event = NULL; } } else { if (a->time_event) - avahi_time_event_queue_update(a->server->time_event_queue, a->time_event, tv); + avahi_time_event_update(a->time_event, tv); else - a->time_event = avahi_time_event_queue_add(a->server->time_event_queue, tv, elapse_announce, a); + a->time_event = avahi_time_event_new(a->server->time_event_queue, tv, elapse_announce, a); } } static void next_state(AvahiAnnouncement *a); -void avahi_entry_group_check_probed(AvahiEntryGroup *g, gboolean immediately) { +void avahi_entry_group_check_probed(AvahiEntryGroup *g, int immediately) { AvahiEntry *e; - g_assert(g); - g_assert(!g->dead); + assert(g); + assert(!g->dead); /* Check whether all group members have been probed */ @@ -105,28 +108,28 @@ void avahi_entry_group_check_probed(AvahiEntryGroup *g, gboolean immediately) { } static void next_state(AvahiAnnouncement *a) { - g_assert(a); + assert(a); /* avahi_log_debug("%i -- %u", a->state, a->n_iteration); */ if (a->state == AVAHI_WAITING) { - g_assert(a->entry->group); + assert(a->entry->group); - avahi_entry_group_check_probed(a->entry->group, TRUE); + avahi_entry_group_check_probed(a->entry->group, 1); } else if (a->state == AVAHI_PROBING) { if (a->n_iteration >= 4) { /* Probing done */ -/* gchar *t; */ +/* char *t; */ /* avahi_log_debug("Enough probes for record [%s]", t = avahi_record_to_string(a->entry->record)); */ -/* g_free(t); */ +/* avahi_free(t); */ if (a->entry->group) { - g_assert(a->entry->group->n_probing); + assert(a->entry->group->n_probing); a->entry->group->n_probing--; } @@ -142,7 +145,7 @@ static void next_state(AvahiAnnouncement *a) { } else { struct timeval tv; - avahi_interface_post_probe(a->interface, a->entry->record, FALSE); + avahi_interface_post_probe(a->interface, a->entry->record, 0); avahi_elapse_time(&tv, AVAHI_PROBE_INTERVAL_MSEC, 0); set_timeout(a, &tv); @@ -154,18 +157,18 @@ static void next_state(AvahiAnnouncement *a) { if (a->entry->flags & AVAHI_ENTRY_UNIQUE) /* Send the whole rrset at once */ - avahi_server_prepare_matching_responses(a->server, a->interface, a->entry->record->key, FALSE); + avahi_server_prepare_matching_responses(a->server, a->interface, a->entry->record->key, 0); else - avahi_server_prepare_response(a->server, a->interface, a->entry, FALSE, FALSE); + avahi_server_prepare_response(a->server, a->interface, a->entry, 0, 0); - avahi_server_generate_response(a->server, a->interface, NULL, NULL, 0, FALSE, FALSE); + avahi_server_generate_response(a->server, a->interface, NULL, NULL, 0, 0, 0); if (++a->n_iteration >= 4) { -/* gchar *t; */ +/* char *t; */ /* Announcing done */ /* avahi_log_debug("Enough announcements for record [%s]", t = avahi_record_to_string(a->entry->record)); */ -/* g_free(t); */ +/* avahi_free(t); */ a->state = AVAHI_ESTABLISHED; @@ -183,7 +186,7 @@ static void next_state(AvahiAnnouncement *a) { } static void elapse_announce(AvahiTimeEvent *e, void *userdata) { - g_assert(e); + assert(e); next_state(userdata); } @@ -191,9 +194,9 @@ static void elapse_announce(AvahiTimeEvent *e, void *userdata) { AvahiAnnouncement *avahi_get_announcement(AvahiServer *s, AvahiEntry *e, AvahiInterface *i) { AvahiAnnouncement *a; - g_assert(s); - g_assert(e); - g_assert(i); + assert(s); + assert(e); + assert(i); for (a = e->announcements; a; a = a->by_entry_next) if (a->interface == i) @@ -202,11 +205,11 @@ AvahiAnnouncement *avahi_get_announcement(AvahiServer *s, AvahiEntry *e, AvahiIn return NULL; } -static void go_to_initial_state(AvahiAnnouncement *a, gboolean immediately) { +static void go_to_initial_state(AvahiAnnouncement *a, int immediately) { AvahiEntry *e; struct timeval tv; - g_assert(a); + assert(a); e = a->entry; if ((e->flags & AVAHI_ENTRY_UNIQUE) && !(e->flags & AVAHI_ENTRY_NOPROBE)) @@ -239,24 +242,28 @@ static void go_to_initial_state(AvahiAnnouncement *a, gboolean immediately) { static void new_announcement(AvahiServer *s, AvahiInterface *i, AvahiEntry *e) { AvahiAnnouncement *a; -/* gchar *t; */ +/* char *t; */ - g_assert(s); - g_assert(i); - g_assert(e); - g_assert(!e->dead); + assert(s); + assert(i); + assert(e); + assert(!e->dead); /* avahi_log_debug("NEW ANNOUNCEMENT: %s.%i [%s]", i->hardware->name, i->protocol, t = avahi_record_to_string(e->record)); */ -/* g_free(t); */ +/* avahi_free(t); */ - if (!avahi_interface_match(i, e->interface, e->protocol) || !i->announcing || !avahi_entry_commited(e)) + if (!avahi_interface_match(i, e->interface, e->protocol) || !i->announcing || !avahi_entry_is_commited(e)) return; /* We don't want duplicate announcements */ if (avahi_get_announcement(s, e, i)) return; - a = g_new(AvahiAnnouncement, 1); + if ((!(a = avahi_new(AvahiAnnouncement, 1)))) { + avahi_log_error(__FILE__": Out of memory."); + return; + } + a->server = s; a->interface = i; a->entry = e; @@ -265,17 +272,17 @@ static void new_announcement(AvahiServer *s, AvahiInterface *i, AvahiEntry *e) { AVAHI_LLIST_PREPEND(AvahiAnnouncement, by_interface, i->announcements, a); AVAHI_LLIST_PREPEND(AvahiAnnouncement, by_entry, e->announcements, a); - go_to_initial_state(a, FALSE); + go_to_initial_state(a, 0); /* avahi_log_debug("New announcement on interface %s.%i for entry [%s] state=%i", i->hardware->name, i->protocol, t = avahi_record_to_string(e->record), a->state); */ -/* g_free(t); */ +/* avahi_free(t); */ } void avahi_announce_interface(AvahiServer *s, AvahiInterface *i) { AvahiEntry *e; - g_assert(s); - g_assert(i); + assert(s); + assert(i); if (!i->announcing) return; @@ -285,21 +292,21 @@ void avahi_announce_interface(AvahiServer *s, AvahiInterface *i) { new_announcement(s, i, e); } -static void announce_walk_callback(AvahiInterfaceMonitor *m, AvahiInterface *i, gpointer userdata) { +static void announce_walk_callback(AvahiInterfaceMonitor *m, AvahiInterface *i, void* userdata) { AvahiEntry *e = userdata; - g_assert(m); - g_assert(i); - g_assert(e); - g_assert(!e->dead); + assert(m); + assert(i); + assert(e); + assert(!e->dead); new_announcement(m->server, i, e); } void avahi_announce_entry(AvahiServer *s, AvahiEntry *e) { - g_assert(s); - g_assert(e); - g_assert(!e->dead); + assert(s); + assert(e); + assert(!e->dead); avahi_interface_monitor_walk(s->monitor, e->interface, e->protocol, announce_walk_callback, e); } @@ -307,24 +314,24 @@ void avahi_announce_entry(AvahiServer *s, AvahiEntry *e) { void avahi_announce_group(AvahiServer *s, AvahiEntryGroup *g) { AvahiEntry *e; - g_assert(s); - g_assert(g); + assert(s); + assert(g); for (e = g->entries; e; e = e->by_group_next) if (!e->dead) avahi_announce_entry(s, e); } -gboolean avahi_entry_registered(AvahiServer *s, AvahiEntry *e, AvahiInterface *i) { +int avahi_entry_is_registered(AvahiServer *s, AvahiEntry *e, AvahiInterface *i) { AvahiAnnouncement *a; - g_assert(s); - g_assert(e); - g_assert(i); - g_assert(!e->dead); + assert(s); + assert(e); + assert(i); + assert(!e->dead); if (!(a = avahi_get_announcement(s, e, i))) - return FALSE; + return 0; return a->state == AVAHI_ANNOUNCING || @@ -332,16 +339,16 @@ gboolean avahi_entry_registered(AvahiServer *s, AvahiEntry *e, AvahiInterface *i (a->state == AVAHI_WAITING && !(e->flags & AVAHI_ENTRY_UNIQUE)); } -gboolean avahi_entry_probing(AvahiServer *s, AvahiEntry *e, AvahiInterface *i) { +int avahi_entry_is_probing(AvahiServer *s, AvahiEntry *e, AvahiInterface *i) { AvahiAnnouncement *a; - g_assert(s); - g_assert(e); - g_assert(i); - g_assert(!e->dead); + assert(s); + assert(e); + assert(i); + assert(!e->dead); if (!(a = avahi_get_announcement(s, e, i))) - return FALSE; + return 0; /* avahi_log_debug("state: %i", a->state); */ @@ -353,9 +360,9 @@ gboolean avahi_entry_probing(AvahiServer *s, AvahiEntry *e, AvahiInterface *i) { void avahi_entry_return_to_initial_state(AvahiServer *s, AvahiEntry *e, AvahiInterface *i) { AvahiAnnouncement *a; - g_assert(s); - g_assert(e); - g_assert(i); + assert(s); + assert(e); + assert(i); if (!(a = avahi_get_announcement(s, e, i))) return; @@ -363,33 +370,35 @@ void avahi_entry_return_to_initial_state(AvahiServer *s, AvahiEntry *e, AvahiInt if (a->state == AVAHI_PROBING && a->entry->group) a->entry->group->n_probing--; - go_to_initial_state(a, TRUE); + go_to_initial_state(a, 1); } static AvahiRecord *make_goodbye_record(AvahiRecord *r) { -/* gchar *t; */ +/* char *t; */ AvahiRecord *g; - g_assert(r); + assert(r); /* avahi_log_debug("Preparing goodbye for record [%s]", t = avahi_record_to_string(r)); */ -/* g_free(t); */ +/* avahi_free(t); */ - g = avahi_record_copy(r); - g_assert(g->ref == 1); + if (!(g = avahi_record_copy(r))) + return NULL; /* OOM */ + + assert(g->ref == 1); g->ttl = 0; return g; } -static void send_goodbye_callback(AvahiInterfaceMonitor *m, AvahiInterface *i, gpointer userdata) { +static void send_goodbye_callback(AvahiInterfaceMonitor *m, AvahiInterface *i, void* userdata) { AvahiEntry *e = userdata; AvahiRecord *g; - g_assert(m); - g_assert(i); - g_assert(e); - g_assert(!e->dead); + assert(m); + assert(i); + assert(e); + assert(!e->dead); if (!avahi_interface_match(i, e->interface, e->protocol)) return; @@ -397,17 +406,19 @@ static void send_goodbye_callback(AvahiInterfaceMonitor *m, AvahiInterface *i, g if (e->flags & AVAHI_ENTRY_NOANNOUNCE) return; - if (!avahi_entry_registered(m->server, e, i)) + if (!avahi_entry_is_registered(m->server, e, i)) return; - g = make_goodbye_record(e->record); - avahi_interface_post_response(i, g, e->flags & AVAHI_ENTRY_UNIQUE, NULL, TRUE); + if (!(g = make_goodbye_record(e->record))) + return; /* OOM */ + + avahi_interface_post_response(i, g, e->flags & AVAHI_ENTRY_UNIQUE, NULL, 1); avahi_record_unref(g); } -void avahi_goodbye_interface(AvahiServer *s, AvahiInterface *i, gboolean goodbye) { - g_assert(s); - g_assert(i); +void avahi_goodbye_interface(AvahiServer *s, AvahiInterface *i, int goodbye) { + assert(s); + assert(i); /* avahi_log_debug("goodbye interface: %s.%u", i->hardware->name, i->protocol); */ @@ -423,12 +434,11 @@ void avahi_goodbye_interface(AvahiServer *s, AvahiInterface *i, gboolean goodbye remove_announcement(s, i->announcements); /* avahi_log_debug("goodbye interface done: %s.%u", i->hardware->name, i->protocol); */ - } -void avahi_goodbye_entry(AvahiServer *s, AvahiEntry *e, gboolean goodbye) { - g_assert(s); - g_assert(e); +void avahi_goodbye_entry(AvahiServer *s, AvahiEntry *e, int goodbye) { + assert(s); + assert(e); /* avahi_log_debug("goodbye entry: %p", e); */ @@ -442,10 +452,10 @@ void avahi_goodbye_entry(AvahiServer *s, AvahiEntry *e, gboolean goodbye) { } -void avahi_goodbye_all(AvahiServer *s, gboolean goodbye) { +void avahi_goodbye_all(AvahiServer *s, int goodbye) { AvahiEntry *e; - g_assert(s); + assert(s); /* avahi_log_debug("goodbye all"); */ diff --git a/avahi-core/announce.h b/avahi-core/announce.h index 9aee574..d5928be 100644 --- a/avahi-core/announce.h +++ b/avahi-core/announce.h @@ -22,8 +22,6 @@ USA. ***/ -#include <glib.h> - typedef struct AvahiAnnouncement AvahiAnnouncement; #include <avahi-common/llist.h> @@ -46,8 +44,8 @@ struct AvahiAnnouncement { AvahiTimeEvent *time_event; AvahiAnnouncementState state; - guint n_iteration; - guint sec_delay; + unsigned n_iteration; + unsigned sec_delay; AVAHI_LLIST_FIELDS(AvahiAnnouncement, by_interface); AVAHI_LLIST_FIELDS(AvahiAnnouncement, by_entry); @@ -59,15 +57,15 @@ void avahi_announce_group(AvahiServer *s, AvahiEntryGroup *g); void avahi_entry_return_to_initial_state(AvahiServer *s, AvahiEntry *e, AvahiInterface *i); -void avahi_entry_group_check_probed(AvahiEntryGroup *g, gboolean immediately); +void avahi_entry_group_check_probed(AvahiEntryGroup *g, int immediately); -gboolean avahi_entry_registered(AvahiServer *s, AvahiEntry *e, AvahiInterface *i); -gboolean avahi_entry_probing(AvahiServer *s, AvahiEntry *e, AvahiInterface *i); +int avahi_entry_is_registered(AvahiServer *s, AvahiEntry *e, AvahiInterface *i); +int avahi_entry_is_probing(AvahiServer *s, AvahiEntry *e, AvahiInterface *i); -void avahi_goodbye_interface(AvahiServer *s, AvahiInterface *i, gboolean send_goodbye); -void avahi_goodbye_entry(AvahiServer *s, AvahiEntry *e, gboolean send_goodbye); +void avahi_goodbye_interface(AvahiServer *s, AvahiInterface *i, int send_goodbye); +void avahi_goodbye_entry(AvahiServer *s, AvahiEntry *e, int send_goodbye); -void avahi_goodbye_all(AvahiServer *s, gboolean send_goodbye); +void avahi_goodbye_all(AvahiServer *s, int send_goodbye); AvahiAnnouncement *avahi_get_announcement(AvahiServer *s, AvahiEntry *e, AvahiInterface *i); diff --git a/avahi-core/avahi-reflector.c b/avahi-core/avahi-reflector.c index 0a91b87..33ae7e1 100644 --- a/avahi-core/avahi-reflector.c +++ b/avahi-core/avahi-reflector.c @@ -28,29 +28,32 @@ #include <arpa/inet.h> #include <stdlib.h> +#include <avahi-common/simple-watch.h> #include <avahi-core/core.h> int main(int argc, char*argv[]) { AvahiServer *server; AvahiServerConfig config; - GMainLoop *loop; - gint error; + int error; + AvahiSimplePoll *simple_poll; + simple_poll = avahi_simple_poll_new(); + avahi_server_config_init(&config); - config.publish_hinfo = FALSE; - config.publish_addresses = FALSE; - config.publish_workstation = FALSE; - config.publish_domain = FALSE; - config.use_ipv6 = FALSE; - config.enable_reflector = TRUE; + config.publish_hinfo = 0; + config.publish_addresses = 0; + config.publish_workstation = 0; + config.publish_domain = 0; + config.use_ipv6 = 0; + config.enable_reflector = 1; - server = avahi_server_new(NULL, &config, NULL, NULL, &error); + server = avahi_server_new(avahi_simple_poll_get(simple_poll), &config, NULL, NULL, &error); avahi_server_config_free(&config); - loop = g_main_loop_new(NULL, FALSE); - - g_main_loop_run(loop); - g_main_loop_unref(loop); + for (;;) + if (avahi_simple_poll_iterate(simple_poll, -1) != 0) + break; avahi_server_free(server); + avahi_simple_poll_free(simple_poll); } diff --git a/avahi-core/avahi-test.c b/avahi-core/avahi-test.c index 7156d06..cecd5bf 100644 --- a/avahi-core/avahi-test.c +++ b/avahi-core/avahi-test.c @@ -28,74 +28,79 @@ #include <arpa/inet.h> #include <stdlib.h> #include <stdio.h> +#include <assert.h> +#include <avahi-common/malloc.h> +#include <avahi-glib/glib-watch.h> +#include <avahi-glib/glib-malloc.h> #include <avahi-core/core.h> #include <avahi-core/log.h> + static AvahiEntryGroup *group = NULL; static AvahiServer *server = NULL; -static gchar *service_name = NULL; +static char *service_name = NULL; -static gboolean quit_timeout(gpointer data) { +static int quit_timeout(void* data) { g_main_loop_quit(data); - return FALSE; + return 0; } -static void dump_line(const gchar *text, gpointer userdata) { +static void dump_line(const char *text, void* userdata) { printf("%s\n", text); } -static gboolean dump_timeout(gpointer data) { +static int dump_timeout(void* data) { AvahiServer *Avahi = data; avahi_server_dump(Avahi, dump_line, NULL); - return TRUE; + return 1; } -static void record_browser_callback(AvahiRecordBrowser *r, AvahiIfIndex interface, AvahiProtocol protocol, AvahiBrowserEvent event, AvahiRecord *record, gpointer userdata) { - gchar *t; +static void record_browser_callback(AvahiRecordBrowser *r, AvahiIfIndex interface, AvahiProtocol protocol, AvahiBrowserEvent event, AvahiRecord *record, void* userdata) { + char *t; - g_assert(r); - g_assert(record); - g_assert(interface > 0); - g_assert(protocol != AVAHI_PROTO_UNSPEC); + assert(r); + assert(record); + assert(interface > 0); + assert(protocol != AVAHI_PROTO_UNSPEC); avahi_log_debug("SUBSCRIPTION: record [%s] on %i.%i is %s", t = avahi_record_to_string(record), interface, protocol, event == AVAHI_BROWSER_NEW ? "new" : "remove"); - g_free(t); + avahi_free(t); } static void remove_entries(void); -static void create_entries(gboolean new_name); +static void create_entries(int new_name); -static void entry_group_callback(AvahiServer *s, AvahiEntryGroup *g, AvahiEntryGroupState state, gpointer userdata) { +static void entry_group_callback(AvahiServer *s, AvahiEntryGroup *g, AvahiEntryGroupState state, void* userdata) { avahi_log_debug("entry group state: %i", state); if (state == AVAHI_ENTRY_GROUP_COLLISION) { remove_entries(); - create_entries(TRUE); + create_entries(1); avahi_log_debug("Service name conflict, retrying with <%s>", service_name); } else if (state == AVAHI_ENTRY_GROUP_ESTABLISHED) { avahi_log_debug("Service established under name <%s>", service_name); } } -static void server_callback(AvahiServer *s, AvahiServerState state, gpointer userdata) { +static void server_callback(AvahiServer *s, AvahiServerState state, void* userdata) { avahi_log_debug("server state: %i", state); if (state == AVAHI_SERVER_RUNNING) { avahi_log_debug("Server startup complete. Host name is <%s>", avahi_server_get_host_name_fqdn(s)); - create_entries(FALSE); + create_entries(0); } else if (state == AVAHI_SERVER_COLLISION) { - gchar *n; + char *n; remove_entries(); n = avahi_alternative_host_name(avahi_server_get_host_name(s)); avahi_log_debug("Host name conflict, retrying with <%s>", n); avahi_server_set_host_name(s, n); - g_free(n); + avahi_free(n); } } @@ -104,7 +109,7 @@ static void remove_entries(void) { avahi_entry_group_reset(group); } -static void create_entries(gboolean new_name) { +static void create_entries(int new_name) { AvahiAddress a; remove_entries(); @@ -112,13 +117,13 @@ static void create_entries(gboolean new_name) { if (!group) group = avahi_entry_group_new(server, entry_group_callback, NULL); - g_assert(avahi_entry_group_is_empty(group)); + assert(avahi_entry_group_is_empty(group)); if (!service_name) service_name = g_strdup("Test Service"); else if (new_name) { - gchar *n = avahi_alternative_service_name(service_name); - g_free(service_name); + char *n = avahi_alternative_service_name(service_name); + avahi_free(service_name); service_name = n; } @@ -152,8 +157,8 @@ fail: group = NULL; } -static void hnr_callback(AvahiHostNameResolver *r, AvahiIfIndex iface, AvahiProtocol protocol, AvahiResolverEvent event, const gchar *hostname, const AvahiAddress *a, gpointer userdata) { - gchar t[64]; +static void hnr_callback(AvahiHostNameResolver *r, AvahiIfIndex iface, AvahiProtocol protocol, AvahiResolverEvent event, const char *hostname, const AvahiAddress *a, void* userdata) { + char t[64]; if (a) avahi_address_snprint(t, sizeof(t), a); @@ -161,45 +166,45 @@ static void hnr_callback(AvahiHostNameResolver *r, AvahiIfIndex iface, AvahiProt avahi_log_debug("HNR: (%i.%i) <%s> -> %s [%s]", iface, protocol, hostname, a ? t : "n/a", event == AVAHI_RESOLVER_FOUND ? "found" : "timeout"); } -static void ar_callback(AvahiAddressResolver *r, AvahiIfIndex iface, AvahiProtocol protocol, AvahiResolverEvent event, const AvahiAddress *a, const gchar *hostname, gpointer userdata) { - gchar t[64]; +static void ar_callback(AvahiAddressResolver *r, AvahiIfIndex iface, AvahiProtocol protocol, AvahiResolverEvent event, const AvahiAddress *a, const char *hostname, void* userdata) { + char t[64]; avahi_address_snprint(t, sizeof(t), a); avahi_log_debug("AR: (%i.%i) %s -> <%s> [%s]", iface, protocol, t, hostname ? hostname : "n/a", event == AVAHI_RESOLVER_FOUND ? "found" : "timeout"); } -static void db_callback(AvahiDomainBrowser *b, AvahiIfIndex iface, AvahiProtocol protocol, AvahiBrowserEvent event, const gchar *domain, gpointer userdata) { +static void db_callback(AvahiDomainBrowser *b, AvahiIfIndex iface, AvahiProtocol protocol, AvahiBrowserEvent event, const char *domain, void* userdata) { avahi_log_debug("DB: (%i.%i) <%s> [%s]", iface, protocol, domain, event == AVAHI_BROWSER_NEW ? "new" : "remove"); } -static void stb_callback(AvahiServiceTypeBrowser *b, AvahiIfIndex iface, AvahiProtocol protocol, AvahiBrowserEvent event, const gchar *service_type, const gchar *domain, gpointer userdata) { +static void stb_callback(AvahiServiceTypeBrowser *b, AvahiIfIndex iface, AvahiProtocol protocol, AvahiBrowserEvent event, const char *service_type, const char *domain, void* userdata) { avahi_log_debug("STB: (%i.%i) %s in <%s> [%s]", iface, protocol, service_type, domain, event == AVAHI_BROWSER_NEW ? "new" : "remove"); } -static void sb_callback(AvahiServiceBrowser *b, AvahiIfIndex iface, AvahiProtocol protocol, AvahiBrowserEvent event, const gchar *name, const gchar *service_type, const gchar *domain, gpointer userdata) { +static void sb_callback(AvahiServiceBrowser *b, AvahiIfIndex iface, AvahiProtocol protocol, AvahiBrowserEvent event, const char *name, const char *service_type, const char *domain, void* userdata) { avahi_log_debug("SB: (%i.%i) <%s> as %s in <%s> [%s]", iface, protocol, name, service_type, domain, event == AVAHI_BROWSER_NEW ? "new" : "remove"); } -static void sr_callback(AvahiServiceResolver *r, AvahiIfIndex iface, AvahiProtocol protocol, AvahiResolverEvent event, const gchar *name, const gchar*service_type, const gchar*domain_name, const gchar*hostname, const AvahiAddress *a, guint16 port, AvahiStringList *txt, gpointer userdata) { +static void sr_callback(AvahiServiceResolver *r, AvahiIfIndex iface, AvahiProtocol protocol, AvahiResolverEvent event, const char *name, const char*service_type, const char*domain_name, const char*hostname, const AvahiAddress *a, uint16_t port, AvahiStringList *txt, void* userdata) { if (event == AVAHI_RESOLVER_TIMEOUT) avahi_log_debug("SR: (%i.%i) <%s> as %s in <%s> [timeout]", iface, protocol, name, service_type, domain_name); else { - gchar t[64], *s; + char t[64], *s; avahi_address_snprint(t, sizeof(t), a); s = avahi_string_list_to_string(txt); avahi_log_debug("SR: (%i.%i) <%s> as %s in <%s>: %s/%s:%i (%s) [found]", iface, protocol, name, service_type, domain_name, hostname, t, port, s); - g_free(s); + avahi_free(s); } } -static void dsb_callback(AvahiDNSServerBrowser *b, AvahiIfIndex iface, AvahiProtocol protocol, AvahiBrowserEvent event, const gchar*hostname, const AvahiAddress *a, guint16 port, gpointer userdata) { - gchar t[64]; +static void dsb_callback(AvahiDNSServerBrowser *b, AvahiIfIndex iface, AvahiProtocol protocol, AvahiBrowserEvent event, const char*hostname, const AvahiAddress *a, uint16_t port, void* userdata) { + char t[64]; avahi_address_snprint(t, sizeof(t), a); avahi_log_debug("DSB: (%i.%i): %s/%s:%i [%s]", iface, protocol, hostname, t, port, event == AVAHI_BROWSER_NEW ? "new" : "remove"); } @@ -217,11 +222,15 @@ int main(int argc, char *argv[]) { AvahiServiceBrowser *sb; AvahiServiceResolver *sr; AvahiDNSServerBrowser *dsb; - gint error; + AvahiGLibPoll *glib_poll; + int error; + + avahi_set_allocator(avahi_glib_allocator()); + glib_poll = avahi_glib_poll_new(NULL); avahi_server_config_init(&config); /* config.host_name = g_strdup("test"); */ - server = avahi_server_new(NULL, &config, server_callback, NULL, &error); + server = avahi_server_new(avahi_glib_poll_get(glib_poll), &config, server_callback, NULL, &error); avahi_server_config_free(&config); k = avahi_key_new("_http._tcp.local", AVAHI_DNS_CLASS_IN, AVAHI_DNS_TYPE_PTR); @@ -246,7 +255,7 @@ int main(int argc, char *argv[]) { g_timeout_add(1000*5, dump_timeout, server); g_timeout_add(1000*60, quit_timeout, loop); - loop = g_main_loop_new(NULL, FALSE); + loop = g_main_loop_new(NULL, 0); g_main_loop_run(loop); g_main_loop_unref(loop); @@ -264,7 +273,10 @@ int main(int argc, char *argv[]) { if (server) avahi_server_free(server); - g_free(service_name); + if (glib_poll) + avahi_glib_poll_free(glib_poll); + + avahi_free(service_name); return 0; } diff --git a/avahi-core/browse-dns-server.c b/avahi-core/browse-dns-server.c index 8f87887..720b491 100644 --- a/avahi-core/browse-dns-server.c +++ b/avahi-core/browse-dns-server.c @@ -26,6 +26,8 @@ #include <string.h> #include <avahi-common/domain.h> +#include <avahi-common/malloc.h> + #include "browse.h" #include "log.h" #include "rr.h" @@ -46,14 +48,14 @@ struct AvahiDNSServerInfo { struct AvahiDNSServerBrowser { AvahiServer *server; - gchar *domain_name; + char *domain_name; AvahiRecordBrowser *record_browser; AvahiDNSServerBrowserCallback callback; - gpointer userdata; + void* userdata; AvahiProtocol aprotocol; - guint n_info; + unsigned n_info; AVAHI_LLIST_FIELDS(AvahiDNSServerBrowser, browser); AVAHI_LLIST_HEAD(AvahiDNSServerInfo, info); @@ -62,8 +64,8 @@ struct AvahiDNSServerBrowser { static AvahiDNSServerInfo* get_server_info(AvahiDNSServerBrowser *b, AvahiIfIndex interface, AvahiProtocol protocol, AvahiRecord *r) { AvahiDNSServerInfo *i; - g_assert(b); - g_assert(r); + assert(b); + assert(r); for (i = b->info; i; i = i->info_next) if (i->interface == interface && @@ -75,8 +77,8 @@ static AvahiDNSServerInfo* get_server_info(AvahiDNSServerBrowser *b, AvahiIfInde } static void server_info_free(AvahiDNSServerBrowser *b, AvahiDNSServerInfo *i) { - g_assert(b); - g_assert(i); + assert(b); + assert(i); avahi_record_unref(i->srv_record); if (i->host_name_resolver) @@ -84,18 +86,18 @@ static void server_info_free(AvahiDNSServerBrowser *b, AvahiDNSServerInfo *i) { AVAHI_LLIST_REMOVE(AvahiDNSServerInfo, info, b->info, i); - g_assert(b->n_info >= 1); + assert(b->n_info >= 1); b->n_info--; - g_free(i); + avahi_free(i); } -static void host_name_resolver_callback(AvahiHostNameResolver *r, AvahiIfIndex interface, AvahiProtocol protocol, AvahiResolverEvent event, const gchar *host_name, const AvahiAddress *a, gpointer userdata) { +static void host_name_resolver_callback(AvahiHostNameResolver *r, AvahiIfIndex interface, AvahiProtocol protocol, AvahiResolverEvent event, const char *host_name, const AvahiAddress *a, void* userdata) { AvahiDNSServerInfo *i = userdata; - g_assert(r); - g_assert(host_name); - g_assert(i); + assert(r); + assert(host_name); + assert(i); if (event == AVAHI_RESOLVER_FOUND) { i->address = *a; @@ -107,14 +109,14 @@ static void host_name_resolver_callback(AvahiHostNameResolver *r, AvahiIfIndex i i->host_name_resolver = NULL; } -static void record_browser_callback(AvahiRecordBrowser*rr, AvahiIfIndex interface, AvahiProtocol protocol, AvahiBrowserEvent event, AvahiRecord *record, gpointer userdata) { +static void record_browser_callback(AvahiRecordBrowser*rr, AvahiIfIndex interface, AvahiProtocol protocol, AvahiBrowserEvent event, AvahiRecord *record, void* userdata) { AvahiDNSServerBrowser *b = userdata; - g_assert(rr); - g_assert(record); - g_assert(b); + assert(rr); + assert(record); + assert(b); - g_assert(record->key->type == AVAHI_DNS_TYPE_SRV); + assert(record->key->type == AVAHI_DNS_TYPE_SRV); if (event == AVAHI_BROWSER_NEW) { AvahiDNSServerInfo *i; @@ -125,7 +127,9 @@ static void record_browser_callback(AvahiRecordBrowser*rr, AvahiIfIndex interfac if (b->n_info >= 10) return; - i = g_new(AvahiDNSServerInfo, 1); + if (!(i = avahi_new(AvahiDNSServerInfo, 1))) + return; /* OOM */ + i->browser = b; i->interface = interface; i->protocol = protocol; @@ -148,21 +152,25 @@ static void record_browser_callback(AvahiRecordBrowser*rr, AvahiIfIndex interfac } } -AvahiDNSServerBrowser *avahi_dns_server_browser_new(AvahiServer *server, AvahiIfIndex interface, AvahiProtocol protocol, const gchar *domain, AvahiDNSServerType type, AvahiProtocol aprotocol, AvahiDNSServerBrowserCallback callback, gpointer userdata) { +AvahiDNSServerBrowser *avahi_dns_server_browser_new(AvahiServer *server, AvahiIfIndex interface, AvahiProtocol protocol, const char *domain, AvahiDNSServerType type, AvahiProtocol aprotocol, AvahiDNSServerBrowserCallback callback, void* userdata) { AvahiDNSServerBrowser *b; AvahiKey *k; - gchar *n = NULL; + char *n = NULL; - g_assert(server); - g_assert(callback); - g_assert(type == AVAHI_DNS_SERVER_RESOLVE || type == AVAHI_DNS_SERVER_UPDATE); + assert(server); + assert(callback); + assert(type == AVAHI_DNS_SERVER_RESOLVE || type == AVAHI_DNS_SERVER_UPDATE); if (domain && !avahi_is_valid_domain_name(domain)) { avahi_server_set_errno(server, AVAHI_ERR_INVALID_DOMAIN_NAME); return NULL; } - b = g_new(AvahiDNSServerBrowser, 1); + if (!(b = avahi_new(AvahiDNSServerBrowser, 1))) { + avahi_server_set_errno(server, AVAHI_ERR_NO_MEMORY); + return NULL; + } + b->server = server; b->domain_name = avahi_normalize_name(domain ? domain : "local"); b->callback = callback; @@ -173,9 +181,9 @@ AvahiDNSServerBrowser *avahi_dns_server_browser_new(AvahiServer *server, AvahiIf AVAHI_LLIST_HEAD_INIT(AvahiDNSServerInfo, b->info); AVAHI_LLIST_PREPEND(AvahiDNSServerBrowser, browser, server->dns_server_browsers, b); - n = g_strdup_printf("%s.%s",type == AVAHI_DNS_SERVER_RESOLVE ? "_domain._udp" : "_dns-update._udp", b->domain_name); + n = avahi_strdup_printf("%s.%s",type == AVAHI_DNS_SERVER_RESOLVE ? "_domain._udp" : "_dns-update._udp", b->domain_name); k = avahi_key_new(n, AVAHI_DNS_CLASS_IN, AVAHI_DNS_TYPE_SRV); - g_free(n); + avahi_free(n); b->record_browser = avahi_record_browser_new(server, interface, protocol, k, record_browser_callback, b); avahi_key_unref(k); @@ -189,7 +197,7 @@ AvahiDNSServerBrowser *avahi_dns_server_browser_new(AvahiServer *server, AvahiIf } void avahi_dns_server_browser_free(AvahiDNSServerBrowser *b) { - g_assert(b); + assert(b); while (b->info) server_info_free(b, b->info); @@ -198,7 +206,7 @@ void avahi_dns_server_browser_free(AvahiDNSServerBrowser *b) { if (b->record_browser) avahi_record_browser_free(b->record_browser); - g_free(b->domain_name); - g_free(b); + avahi_free(b->domain_name); + avahi_free(b); } diff --git a/avahi-core/browse-domain.c b/avahi-core/browse-domain.c index 09e1e50..44ff291 100644 --- a/avahi-core/browse-domain.c +++ b/avahi-core/browse-domain.c @@ -24,50 +24,56 @@ #endif #include <avahi-common/domain.h> +#include <avahi-common/malloc.h> + #include "browse.h" struct AvahiDomainBrowser { AvahiServer *server; - gchar *domain_name; + char *domain_name; AvahiRecordBrowser *record_browser; AvahiDomainBrowserCallback callback; - gpointer userdata; + void* userdata; AVAHI_LLIST_FIELDS(AvahiDomainBrowser, browser); }; -static void record_browser_callback(AvahiRecordBrowser*rr, AvahiIfIndex interface, AvahiProtocol protocol, AvahiBrowserEvent event, AvahiRecord *record, gpointer userdata) { +static void record_browser_callback(AvahiRecordBrowser*rr, AvahiIfIndex interface, AvahiProtocol protocol, AvahiBrowserEvent event, AvahiRecord *record, void* userdata) { AvahiDomainBrowser *b = userdata; - gchar *n; + char *n; - g_assert(rr); - g_assert(record); - g_assert(b); + assert(rr); + assert(record); + assert(b); - g_assert(record->key->type == AVAHI_DNS_TYPE_PTR); + assert(record->key->type == AVAHI_DNS_TYPE_PTR); n = avahi_normalize_name(record->data.ptr.name); b->callback(b, interface, protocol, event, n, b->userdata); - g_free(n); + avahi_free(n); } -AvahiDomainBrowser *avahi_domain_browser_new(AvahiServer *server, AvahiIfIndex interface, AvahiProtocol protocol, const gchar *domain, AvahiDomainBrowserType type, AvahiDomainBrowserCallback callback, gpointer userdata) { +AvahiDomainBrowser *avahi_domain_browser_new(AvahiServer *server, AvahiIfIndex interface, AvahiProtocol protocol, const char *domain, AvahiDomainBrowserType type, AvahiDomainBrowserCallback callback, void* userdata) { AvahiDomainBrowser *b; AvahiKey *k; - gchar *n = NULL; + char *n = NULL; - g_assert(server); - g_assert(callback); - g_assert(type >= AVAHI_DOMAIN_BROWSER_BROWSE && type <= AVAHI_DOMAIN_BROWSER_BROWSE_LEGACY); + assert(server); + assert(callback); + assert(type >= AVAHI_DOMAIN_BROWSER_BROWSE && type <= AVAHI_DOMAIN_BROWSER_BROWSE_LEGACY); if (domain && !avahi_is_valid_domain_name(domain)) { avahi_server_set_errno(server, AVAHI_ERR_INVALID_DOMAIN_NAME); return NULL; } - b = g_new(AvahiDomainBrowser, 1); + if (!(b = avahi_new(AvahiDomainBrowser, 1))) { + avahi_server_set_errno(server, AVAHI_ERR_NO_MEMORY); + return NULL; + } + b->server = server; b->domain_name = avahi_normalize_name(domain ? domain : "local"); b->callback = callback; @@ -77,30 +83,30 @@ AvahiDomainBrowser *avahi_domain_browser_new(AvahiServer *server, AvahiIfIndex i switch (type) { case AVAHI_DOMAIN_BROWSER_BROWSE: - n = g_strdup_printf("b._dns-sd._udp.%s", b->domain_name); + n = avahi_strdup_printf("b._dns-sd._udp.%s", b->domain_name); break; case AVAHI_DOMAIN_BROWSER_BROWSE_DEFAULT: - n = g_strdup_printf("db._dns-sd._udp.%s", b->domain_name); + n = avahi_strdup_printf("db._dns-sd._udp.%s", b->domain_name); break; case AVAHI_DOMAIN_BROWSER_REGISTER: - n = g_strdup_printf("r._dns-sd._udp.%s", b->domain_name); + n = avahi_strdup_printf("r._dns-sd._udp.%s", b->domain_name); break; case AVAHI_DOMAIN_BROWSER_REGISTER_DEFAULT: - n = g_strdup_printf("dr._dns-sd._udp.%s", b->domain_name); + n = avahi_strdup_printf("dr._dns-sd._udp.%s", b->domain_name); break; case AVAHI_DOMAIN_BROWSER_BROWSE_LEGACY: - n = g_strdup_printf("lb._dns-sd._udp.%s", b->domain_name); + n = avahi_strdup_printf("lb._dns-sd._udp.%s", b->domain_name); break; case AVAHI_DOMAIN_BROWSER_MAX: - g_assert(FALSE); + assert(0); break; } - g_assert(n); + assert(n); k = avahi_key_new(n, AVAHI_DNS_CLASS_IN, AVAHI_DNS_TYPE_PTR); - g_free(n); + avahi_free(n); b->record_browser = avahi_record_browser_new(server, interface, protocol, k, record_browser_callback, b); avahi_key_unref(k); @@ -114,13 +120,13 @@ AvahiDomainBrowser *avahi_domain_browser_new(AvahiServer *server, AvahiIfIndex i } void avahi_domain_browser_free(AvahiDomainBrowser *b) { - g_assert(b); + assert(b); AVAHI_LLIST_REMOVE(AvahiDomainBrowser, browser, b->server->domain_browsers, b); if (b->record_browser) avahi_record_browser_free(b->record_browser); - g_free(b->domain_name); - g_free(b); + avahi_free(b->domain_name); + avahi_free(b); } diff --git a/avahi-core/browse-service-type.c b/avahi-core/browse-service-type.c index 61364e9..303182e 100644 --- a/avahi-core/browse-service-type.c +++ b/avahi-core/browse-service-type.c @@ -26,30 +26,32 @@ #include <string.h> #include <avahi-common/domain.h> +#include <avahi-common/malloc.h> + #include "browse.h" #include "log.h" struct AvahiServiceTypeBrowser { AvahiServer *server; - gchar *domain_name; + char *domain_name; AvahiRecordBrowser *record_browser; AvahiServiceTypeBrowserCallback callback; - gpointer userdata; + void* userdata; AVAHI_LLIST_FIELDS(AvahiServiceTypeBrowser, browser); }; -static void record_browser_callback(AvahiRecordBrowser*rr, AvahiIfIndex interface, AvahiProtocol protocol, AvahiBrowserEvent event, AvahiRecord *record, gpointer userdata) { +static void record_browser_callback(AvahiRecordBrowser*rr, AvahiIfIndex interface, AvahiProtocol protocol, AvahiBrowserEvent event, AvahiRecord *record, void* userdata) { AvahiServiceTypeBrowser *b = userdata; - gchar *n, *e, *c; + char *n, *e, *c; - g_assert(rr); - g_assert(record); - g_assert(b); + assert(rr); + assert(record); + assert(b); - g_assert(record->key->type == AVAHI_DNS_TYPE_PTR); + assert(record->key->type == AVAHI_DNS_TYPE_PTR); n = avahi_normalize_name(record->data.ptr.name); @@ -62,7 +64,7 @@ static void record_browser_callback(AvahiRecordBrowser*rr, AvahiIfIndex interfac if (*c == 0) goto fail; - g_assert(*c == '.'); + assert(*c == '.'); e = c; c++; } @@ -73,29 +75,33 @@ static void record_browser_callback(AvahiRecordBrowser*rr, AvahiIfIndex interfac goto fail; b->callback(b, interface, protocol, event, n, c, b->userdata); - g_free(n); + avahi_free(n); return; fail: avahi_log_warn("Invalid service type '%s'", n); - g_free(n); + avahi_free(n); } -AvahiServiceTypeBrowser *avahi_service_type_browser_new(AvahiServer *server, gint interface, AvahiProtocol protocol, const gchar *domain, AvahiServiceTypeBrowserCallback callback, gpointer userdata) { +AvahiServiceTypeBrowser *avahi_service_type_browser_new(AvahiServer *server, AvahiIfIndex interface, AvahiProtocol protocol, const char *domain, AvahiServiceTypeBrowserCallback callback, void* userdata) { AvahiServiceTypeBrowser *b; AvahiKey *k; - gchar *n = NULL; + char *n = NULL; - g_assert(server); - g_assert(callback); + assert(server); + assert(callback); if (domain && !avahi_is_valid_domain_name(domain)) { avahi_server_set_errno(server, AVAHI_ERR_INVALID_DOMAIN_NAME); return NULL; } - b = g_new(AvahiServiceTypeBrowser, 1); + if (!(b = avahi_new(AvahiServiceTypeBrowser, 1))) { + avahi_server_set_errno(server, AVAHI_ERR_NO_MEMORY); + return NULL; + } + b->server = server; b->domain_name = avahi_normalize_name(domain ? domain : "local"); b->callback = callback; @@ -103,9 +109,9 @@ AvahiServiceTypeBrowser *avahi_service_type_browser_new(AvahiServer *server, gin AVAHI_LLIST_PREPEND(AvahiServiceTypeBrowser, browser, server->service_type_browsers, b); - n = g_strdup_printf("_services._dns-sd._udp.%s", b->domain_name); + n = avahi_strdup_printf("_services._dns-sd._udp.%s", b->domain_name); k = avahi_key_new(n, AVAHI_DNS_CLASS_IN, AVAHI_DNS_TYPE_PTR); - g_free(n); + avahi_free(n); b->record_browser = avahi_record_browser_new(server, interface, protocol, k, record_browser_callback, b); avahi_key_unref(k); @@ -117,15 +123,15 @@ AvahiServiceTypeBrowser *avahi_service_type_browser_new(AvahiServer *server, gin } void avahi_service_type_browser_free(AvahiServiceTypeBrowser *b) { - g_assert(b); + assert(b); AVAHI_LLIST_REMOVE(AvahiServiceTypeBrowser, browser, b->server->service_type_browsers, b); if (b->record_browser) avahi_record_browser_free(b->record_browser); - g_free(b->domain_name); - g_free(b); + avahi_free(b->domain_name); + avahi_free(b); } diff --git a/avahi-core/browse-service.c b/avahi-core/browse-service.c index 8b3aa4c..7ed6ded 100644 --- a/avahi-core/browse-service.c +++ b/avahi-core/browse-service.c @@ -26,36 +26,38 @@ #include <string.h> #include <avahi-common/domain.h> +#include <avahi-common/malloc.h> + #include "browse.h" #include "log.h" struct AvahiServiceBrowser { AvahiServer *server; - gchar *domain_name; - gchar *service_type; + char *domain_name; + char *service_type; AvahiRecordBrowser *record_browser; AvahiServiceBrowserCallback callback; - gpointer userdata; + void* userdata; AVAHI_LLIST_FIELDS(AvahiServiceBrowser, browser); }; -static void record_browser_callback(AvahiRecordBrowser*rr, AvahiIfIndex interface, AvahiProtocol protocol, AvahiBrowserEvent event, AvahiRecord *record, gpointer userdata) { +static void record_browser_callback(AvahiRecordBrowser*rr, AvahiIfIndex interface, AvahiProtocol protocol, AvahiBrowserEvent event, AvahiRecord *record, void* userdata) { AvahiServiceBrowser *b = userdata; - gchar *n, *e, *c, *s; - gchar service[128]; + char *n, *e, *c, *s; + char service[128]; - g_assert(rr); - g_assert(record); - g_assert(b); + assert(rr); + assert(record); + assert(b); - g_assert(record->key->type == AVAHI_DNS_TYPE_PTR); + assert(record->key->type == AVAHI_DNS_TYPE_PTR); c = n = avahi_normalize_name(record->data.ptr.name); - if (!(avahi_unescape_label((const gchar**) &c, service, sizeof(service)))) + if (!(avahi_unescape_label((const char**) &c, service, sizeof(service)))) goto fail; for (s = e = c; *c == '_';) { @@ -64,7 +66,7 @@ static void record_browser_callback(AvahiRecordBrowser*rr, AvahiIfIndex interfac if (*c == 0) goto fail; - g_assert(*c == '.'); + assert(*c == '.'); e = c; c++; } @@ -75,23 +77,23 @@ static void record_browser_callback(AvahiRecordBrowser*rr, AvahiIfIndex interfac goto fail; b->callback(b, interface, protocol, event, service, s, c, b->userdata); - g_free(n); + avahi_free(n); return; fail: avahi_log_warn("Invalid service '%s'", n); - g_free(n); + avahi_free(n); } -AvahiServiceBrowser *avahi_service_browser_new(AvahiServer *server, AvahiIfIndex interface, AvahiProtocol protocol, const gchar *service_type, const gchar *domain, AvahiServiceBrowserCallback callback, gpointer userdata) { +AvahiServiceBrowser *avahi_service_browser_new(AvahiServer *server, AvahiIfIndex interface, AvahiProtocol protocol, const char *service_type, const char *domain, AvahiServiceBrowserCallback callback, void* userdata) { AvahiServiceBrowser *b; AvahiKey *k; - gchar *n = NULL; + char *n = NULL; - g_assert(server); - g_assert(callback); - g_assert(service_type); + assert(server); + assert(callback); + assert(service_type); if (!avahi_is_valid_service_type(service_type)) { avahi_server_set_errno(server, AVAHI_ERR_INVALID_SERVICE_TYPE); @@ -103,7 +105,11 @@ AvahiServiceBrowser *avahi_service_browser_new(AvahiServer *server, AvahiIfIndex return NULL; } - b = g_new(AvahiServiceBrowser, 1); + if (!(b = avahi_new(AvahiServiceBrowser, 1))) { + avahi_server_set_errno(server, AVAHI_ERR_NO_MEMORY); + return NULL; + } + b->server = server; b->domain_name = avahi_normalize_name(domain ? domain : "local"); b->service_type = avahi_normalize_name(service_type); @@ -111,9 +117,9 @@ AvahiServiceBrowser *avahi_service_browser_new(AvahiServer *server, AvahiIfIndex b->userdata = userdata; AVAHI_LLIST_PREPEND(AvahiServiceBrowser, browser, server->service_browsers, b); - n = g_strdup_printf("%s.%s", b->service_type, b->domain_name); + n = avahi_strdup_printf("%s.%s", b->service_type, b->domain_name); k = avahi_key_new(n, AVAHI_DNS_CLASS_IN, AVAHI_DNS_TYPE_PTR); - g_free(n); + avahi_free(n); b->record_browser = avahi_record_browser_new(server, interface, protocol, k, record_browser_callback, b); @@ -128,14 +134,14 @@ AvahiServiceBrowser *avahi_service_browser_new(AvahiServer *server, AvahiIfIndex } void avahi_service_browser_free(AvahiServiceBrowser *b) { - g_assert(b); + assert(b); AVAHI_LLIST_REMOVE(AvahiServiceBrowser, browser, b->server->service_browsers, b); if (b->record_browser) avahi_record_browser_free(b->record_browser); - g_free(b->domain_name); - g_free(b->service_type); - g_free(b); + avahi_free(b->domain_name); + avahi_free(b->service_type); + avahi_free(b); } diff --git a/avahi-core/browse.c b/avahi-core/browse.c index f089cdd..d54e4ee 100644 --- a/avahi-core/browse.c +++ b/avahi-core/browse.c @@ -24,34 +24,36 @@ #endif #include <avahi-common/timeval.h> +#include <avahi-common/malloc.h> + #include "browse.h" #include "log.h" struct AvahiRecordBrowser { - gboolean dead; + int dead; AvahiServer *server; AvahiKey *key; AvahiIfIndex interface; AvahiProtocol protocol; - guint sec_delay; + unsigned sec_delay; - AvahiTimeEvent *time_event; + AvahiTimeEvent *query_time_event; + AvahiTimeEvent *scan_time_event; AvahiRecordBrowserCallback callback; - gpointer userdata; - guint scan_idle_source; + void* userdata; AVAHI_LLIST_FIELDS(AvahiRecordBrowser, browser); AVAHI_LLIST_FIELDS(AvahiRecordBrowser, by_key); }; -static void elapse(AvahiTimeEvent *e, void *userdata) { +static void elapse_callback(AvahiTimeEvent *e, void *userdata) { AvahiRecordBrowser *s = userdata; struct timeval tv; -/* gchar *t; */ +/* char *t; */ - g_assert(s); + assert(s); avahi_server_post_query(s->server, s->interface, s->protocol, s->key); @@ -61,10 +63,10 @@ static void elapse(AvahiTimeEvent *e, void *userdata) { s->sec_delay = 60*60; /* avahi_log_debug("Continuous querying for %s (%i)", t = avahi_key_to_string(s->key), s->sec_delay); */ -/* g_free(t); */ +/* avahi_free(t); */ avahi_elapse_time(&tv, s->sec_delay*1000, 0); - avahi_time_event_queue_update(s->server->time_event_queue, s->time_event, &tv); + avahi_time_event_update(s->query_time_event, &tv); } struct cbdata { @@ -72,13 +74,13 @@ struct cbdata { AvahiInterface *interface; }; -static gpointer scan_cache_callback(AvahiCache *c, AvahiKey *pattern, AvahiCacheEntry *e, gpointer userdata) { +static void* scan_cache_callback(AvahiCache *c, AvahiKey *pattern, AvahiCacheEntry *e, void* userdata) { struct cbdata *cbdata = userdata; - g_assert(c); - g_assert(pattern); - g_assert(e); - g_assert(cbdata); + assert(c); + assert(pattern); + assert(e); + assert(cbdata); if (cbdata->record_browser->dead) return NULL; @@ -94,35 +96,39 @@ static gpointer scan_cache_callback(AvahiCache *c, AvahiKey *pattern, AvahiCache return NULL; } -static void scan_interface_callback(AvahiInterfaceMonitor *m, AvahiInterface *i, gpointer userdata) { - AvahiRecordBrowser *s = userdata; - struct cbdata cbdata = { s, i }; +static void scan_interface_callback(AvahiInterfaceMonitor *m, AvahiInterface *i, void* userdata) { + AvahiRecordBrowser *b = userdata; + struct cbdata cbdata = { b, i }; - g_assert(m); - g_assert(i); - g_assert(s); + assert(m); + assert(i); + assert(b); - avahi_cache_walk(i->cache, s->key, scan_cache_callback, &cbdata); + if (!b->dead) + avahi_cache_walk(i->cache, b->key, scan_cache_callback, &cbdata); } -static gboolean scan_idle_callback(gpointer data) { - AvahiRecordBrowser *b = data; - g_assert(b); +static void scan_callback(AvahiTimeEvent *e, void *userdata) { + AvahiRecordBrowser *b = userdata; + assert(b); /* Scan the caches */ - avahi_interface_monitor_walk(b->server->monitor, b->interface, b->protocol, scan_interface_callback, b); - b->scan_idle_source = (guint) -1; + if (!b->dead) + avahi_interface_monitor_walk(b->server->monitor, b->interface, b->protocol, scan_interface_callback, b); - return FALSE; + if (b->scan_time_event) { + avahi_time_event_free(b->scan_time_event); + b->scan_time_event = NULL; + } } -AvahiRecordBrowser *avahi_record_browser_new(AvahiServer *server, AvahiIfIndex interface, AvahiProtocol protocol, AvahiKey *key, AvahiRecordBrowserCallback callback, gpointer userdata) { +AvahiRecordBrowser *avahi_record_browser_new(AvahiServer *server, AvahiIfIndex interface, AvahiProtocol protocol, AvahiKey *key, AvahiRecordBrowserCallback callback, void* userdata) { AvahiRecordBrowser *b, *t; struct timeval tv; - g_assert(server); - g_assert(key); - g_assert(callback); + assert(server); + assert(key); + assert(callback); if (avahi_key_is_pattern(key)) { avahi_server_set_errno(server, AVAHI_ERR_IS_PATTERN); @@ -134,8 +140,12 @@ AvahiRecordBrowser *avahi_record_browser_new(AvahiServer *server, AvahiIfIndex i return NULL; } - b = g_new(AvahiRecordBrowser, 1); - b->dead = FALSE; + if (!(b = avahi_new(AvahiRecordBrowser, 1))) { + avahi_server_set_errno(server, AVAHI_ERR_NO_MEMORY); + return NULL; + } + + b->dead = 0; b->server = server; b->key = avahi_key_ref(key); b->interface = interface; @@ -147,68 +157,68 @@ AvahiRecordBrowser *avahi_record_browser_new(AvahiServer *server, AvahiIfIndex i avahi_server_post_query(b->server, b->interface, b->protocol, b->key); avahi_elapse_time(&tv, b->sec_delay*1000, 0); - b->time_event = avahi_time_event_queue_add(server->time_event_queue, &tv, elapse, b); + b->query_time_event = avahi_time_event_new(server->time_event_queue, &tv, elapse_callback, b); AVAHI_LLIST_PREPEND(AvahiRecordBrowser, browser, server->record_browsers, b); /* Add the new entry to the record_browser hash table */ - t = g_hash_table_lookup(server->record_browser_hashtable, key); + t = avahi_hashmap_lookup(server->record_browser_hashmap, key); AVAHI_LLIST_PREPEND(AvahiRecordBrowser, by_key, t, b); - g_hash_table_replace(server->record_browser_hashtable, key, t); + avahi_hashmap_replace(server->record_browser_hashmap, key, t); /* The currenlty cached entries are scanned a bit later */ - b->scan_idle_source = g_idle_add_full(G_PRIORITY_HIGH, scan_idle_callback, b, NULL); + b->scan_time_event = avahi_time_event_new(server->time_event_queue, NULL, scan_callback, b); + assert(b->scan_time_event); return b; } void avahi_record_browser_free(AvahiRecordBrowser *b) { - g_assert(b); - g_assert(!b->dead); - - b->dead = TRUE; - b->server->need_browser_cleanup = TRUE; + assert(b); + assert(!b->dead); - if (b->time_event) { - avahi_time_event_queue_remove(b->server->time_event_queue, b->time_event); - b->time_event = NULL; + b->dead = 1; + b->server->need_browser_cleanup = 1; - if (b->scan_idle_source != (guint) -1) { - g_source_remove(b->scan_idle_source); - b->scan_idle_source = (guint) -1; - } + if (b->query_time_event) { + avahi_time_event_free(b->query_time_event); + b->query_time_event = NULL; + } + if (b->scan_time_event) { + avahi_time_event_free(b->scan_time_event); + b->scan_time_event = NULL; } } void avahi_record_browser_destroy(AvahiRecordBrowser *b) { AvahiRecordBrowser *t; - g_assert(b); + assert(b); AVAHI_LLIST_REMOVE(AvahiRecordBrowser, browser, b->server->record_browsers, b); - t = g_hash_table_lookup(b->server->record_browser_hashtable, b->key); + t = avahi_hashmap_lookup(b->server->record_browser_hashmap, b->key); AVAHI_LLIST_REMOVE(AvahiRecordBrowser, by_key, t, b); if (t) - g_hash_table_replace(b->server->record_browser_hashtable, t->key, t); + avahi_hashmap_replace(b->server->record_browser_hashmap, t->key, t); else - g_hash_table_remove(b->server->record_browser_hashtable, b->key); + avahi_hashmap_remove(b->server->record_browser_hashmap, b->key); - if (b->time_event) - avahi_time_event_queue_remove(b->server->time_event_queue, b->time_event); - avahi_key_unref(b->key); + if (b->query_time_event) + avahi_time_event_free(b->query_time_event); + if (b->scan_time_event) + avahi_time_event_free(b->scan_time_event); - if (b->scan_idle_source != (guint) -1) - g_source_remove(b->scan_idle_source); + avahi_key_unref(b->key); - g_free(b); + avahi_free(b); } void avahi_browser_cleanup(AvahiServer *server) { AvahiRecordBrowser *b; AvahiRecordBrowser *n; - g_assert(server); + assert(server); for (b = server->record_browsers; b; b = n) { n = b->browser_next; @@ -217,39 +227,39 @@ void avahi_browser_cleanup(AvahiServer *server) { avahi_record_browser_destroy(b); } - server->need_browser_cleanup = FALSE; + server->need_browser_cleanup = 0; } void avahi_browser_notify(AvahiServer *server, AvahiInterface *i, AvahiRecord *record, AvahiBrowserEvent event) { AvahiRecordBrowser *b; - g_assert(server); - g_assert(record); + assert(server); + assert(record); - for (b = g_hash_table_lookup(server->record_browser_hashtable, record->key); b; b = b->by_key_next) + for (b = avahi_hashmap_lookup(server->record_browser_hashmap, record->key); b; b = b->by_key_next) if (!b->dead && avahi_interface_match(i, b->interface, b->protocol)) b->callback(b, i->hardware->index, i->protocol, event, record, b->userdata); } -gboolean avahi_is_subscribed(AvahiServer *server, AvahiInterface *i, AvahiKey *k) { +int avahi_is_subscribed(AvahiServer *server, AvahiInterface *i, AvahiKey *k) { AvahiRecordBrowser *b; - g_assert(server); - g_assert(k); + assert(server); + assert(k); - for (b = g_hash_table_lookup(server->record_browser_hashtable, k); b; b = b->by_key_next) + for (b = avahi_hashmap_lookup(server->record_browser_hashmap, k); b; b = b->by_key_next) if (!b->dead && avahi_interface_match(i, b->interface, b->protocol)) - return TRUE; + return 1; - return FALSE; + return 0; } void avahi_browser_new_interface(AvahiServer*s, AvahiInterface *i) { AvahiRecordBrowser *b; - g_assert(s); - g_assert(i); + assert(s); + assert(i); for (b = s->record_browsers; b; b = b->browser_next) if (avahi_interface_match(i, b->interface, b->protocol)) - avahi_interface_post_query(i, b->key, FALSE); + avahi_interface_post_query(i, b->key, 0); } diff --git a/avahi-core/browse.h b/avahi-core/browse.h index 2c9a2ab..21f102a 100644 --- a/avahi-core/browse.h +++ b/avahi-core/browse.h @@ -30,7 +30,7 @@ void avahi_browser_cleanup(AvahiServer *server); void avahi_browser_notify(AvahiServer *s, AvahiInterface *i, AvahiRecord *record, AvahiBrowserEvent event); -gboolean avahi_is_subscribed(AvahiServer *s, AvahiInterface *i, AvahiKey *k); +int avahi_is_subscribed(AvahiServer *s, AvahiInterface *i, AvahiKey *k); void avahi_record_browser_destroy(AvahiRecordBrowser *b); diff --git a/avahi-core/cache.c b/avahi-core/cache.c index ebe78fc..924b8c9 100644 --- a/avahi-core/cache.c +++ b/avahi-core/cache.c @@ -24,8 +24,11 @@ #endif #include <string.h> +#include <stdlib.h> #include <avahi-common/timeval.h> +#include <avahi-common/malloc.h> + #include "cache.h" #include "log.h" @@ -34,42 +37,51 @@ static void remove_entry(AvahiCache *c, AvahiCacheEntry *e) { AvahiCacheEntry *t; - g_assert(c); - g_assert(e); + assert(c); + assert(e); /* avahi_log_debug("removing from cache: %p %p", c, e); */ /* Remove from hash table */ - t = g_hash_table_lookup(c->hash_table, e->record->key); + t = avahi_hashmap_lookup(c->hashmap, e->record->key); AVAHI_LLIST_REMOVE(AvahiCacheEntry, by_key, t, e); if (t) - g_hash_table_replace(c->hash_table, t->record->key, t); + avahi_hashmap_replace(c->hashmap, t->record->key, t); else - g_hash_table_remove(c->hash_table, e->record->key); + avahi_hashmap_remove(c->hashmap, e->record->key); /* Remove from linked list */ AVAHI_LLIST_REMOVE(AvahiCacheEntry, entry, c->entries, e); if (e->time_event) - avahi_time_event_queue_remove(c->server->time_event_queue, e->time_event); + avahi_time_event_free(e->time_event); avahi_browser_notify(c->server, c->interface, e->record, AVAHI_BROWSER_REMOVE); avahi_record_unref(e->record); - g_free(e); + avahi_free(e); - g_assert(c->n_entries-- >= 1); + assert(c->n_entries-- >= 1); } AvahiCache *avahi_cache_new(AvahiServer *server, AvahiInterface *iface) { AvahiCache *c; - g_assert(server); + assert(server); - c = g_new(AvahiCache, 1); + if (!(c = avahi_new(AvahiCache, 1))) { + avahi_log_error(__FILE__": Out of memory."); + return NULL; /* OOM */ + } + c->server = server; c->interface = iface; - c->hash_table = g_hash_table_new((GHashFunc) avahi_key_hash, (GEqualFunc) avahi_key_equal); + + if (!(c->hashmap = avahi_hashmap_new((AvahiHashFunc) avahi_key_hash, (AvahiEqualFunc) avahi_key_equal, NULL, NULL))) { + avahi_log_error(__FILE__": Out of memory."); + avahi_free(c); + return NULL; /* OOM */ + } AVAHI_LLIST_HEAD_INIT(AvahiCacheEntry, c->entries); c->n_entries = 0; @@ -78,32 +90,32 @@ AvahiCache *avahi_cache_new(AvahiServer *server, AvahiInterface *iface) { } void avahi_cache_free(AvahiCache *c) { - g_assert(c); + assert(c); while (c->entries) remove_entry(c, c->entries); - g_assert(c->n_entries == 0); + assert(c->n_entries == 0); - g_hash_table_destroy(c->hash_table); + avahi_hashmap_free(c->hashmap); - g_free(c); + avahi_free(c); } AvahiCacheEntry *avahi_cache_lookup_key(AvahiCache *c, AvahiKey *k) { - g_assert(c); - g_assert(k); + assert(c); + assert(k); - g_assert(!avahi_key_is_pattern(k)); + assert(!avahi_key_is_pattern(k)); - return g_hash_table_lookup(c->hash_table, k); + return avahi_hashmap_lookup(c->hashmap, k); } -gpointer avahi_cache_walk(AvahiCache *c, AvahiKey *pattern, AvahiCacheWalkCallback cb, gpointer userdata) { - gpointer ret; +void* avahi_cache_walk(AvahiCache *c, AvahiKey *pattern, AvahiCacheWalkCallback cb, void* userdata) { + void* ret; - g_assert(c); - g_assert(pattern); - g_assert(cb); + assert(c); + assert(pattern); + assert(cb); if (avahi_key_is_pattern(pattern)) { AvahiCacheEntry *e, *n; @@ -130,10 +142,10 @@ gpointer avahi_cache_walk(AvahiCache *c, AvahiKey *pattern, AvahiCacheWalkCallba return NULL; } -static gpointer lookup_record_callback(AvahiCache *c, AvahiKey *pattern, AvahiCacheEntry *e, void *userdata) { - g_assert(c); - g_assert(pattern); - g_assert(e); +static void* lookup_record_callback(AvahiCache *c, AvahiKey *pattern, AvahiCacheEntry *e, void *userdata) { + assert(c); + assert(pattern); + assert(e); if (avahi_record_equal_no_ttl(e->record, userdata)) return e; @@ -142,20 +154,20 @@ static gpointer lookup_record_callback(AvahiCache *c, AvahiKey *pattern, AvahiCa } AvahiCacheEntry *avahi_cache_lookup_record(AvahiCache *c, AvahiRecord *r) { - g_assert(c); - g_assert(r); + assert(c); + assert(r); return avahi_cache_walk(c, r->key, lookup_record_callback, r); } -static void next_expiry(AvahiCache *c, AvahiCacheEntry *e, guint percent); +static void next_expiry(AvahiCache *c, AvahiCacheEntry *e, unsigned percent); static void elapse_func(AvahiTimeEvent *t, void *userdata) { AvahiCacheEntry *e = userdata; -/* gchar *txt; */ +/* char *txt; */ - g_assert(t); - g_assert(e); + assert(t); + assert(e); /* txt = avahi_record_to_string(e->record); */ @@ -163,7 +175,7 @@ static void elapse_func(AvahiTimeEvent *t, void *userdata) { remove_entry(e->cache, e); /* avahi_log_debug("Removing entry from cache due to expiration (%s)", txt); */ } else { - guint percent = 0; + unsigned percent = 0; switch (e->state) { case AVAHI_CACHE_VALID: @@ -189,44 +201,44 @@ static void elapse_func(AvahiTimeEvent *t, void *userdata) { ; } - g_assert(percent > 0); + assert(percent > 0); /* Request a cache update, if we are subscribed to this entry */ if (avahi_is_subscribed(e->cache->server, e->cache->interface, e->record->key)) { /* avahi_log_debug("Requesting cache entry update at %i%% for %s.", percent, txt); */ - avahi_interface_post_query(e->cache->interface, e->record->key, TRUE); + avahi_interface_post_query(e->cache->interface, e->record->key, 1); } /* Check again later */ next_expiry(e->cache, e, percent); } -/* g_free(txt); */ +/* avahi_free(txt); */ } static void update_time_event(AvahiCache *c, AvahiCacheEntry *e) { - g_assert(c); - g_assert(e); + assert(c); + assert(e); if (e->time_event) - avahi_time_event_queue_update(c->server->time_event_queue, e->time_event, &e->expiry); + avahi_time_event_update(e->time_event, &e->expiry); else - e->time_event = avahi_time_event_queue_add(c->server->time_event_queue, &e->expiry, elapse_func, e); + e->time_event = avahi_time_event_new(c->server->time_event_queue, &e->expiry, elapse_func, e); } -static void next_expiry(AvahiCache *c, AvahiCacheEntry *e, guint percent) { - AvahiUsec usec; - g_assert(c); - g_assert(e); - g_assert(percent > 0 && percent <= 100); -/* gchar *txt; */ +static void next_expiry(AvahiCache *c, AvahiCacheEntry *e, unsigned percent) { + AvahiUsec usec, left, right; + + assert(c); + assert(e); + assert(percent > 0 && percent <= 100); + + usec = (AvahiUsec) e->record->ttl * 10000; - usec = ((AvahiUsec) e->record->ttl) * 10000; + left = usec * percent; + right = usec * (percent+2); /* 2% jitter */ - /* 2% jitter */ - usec = (AvahiUsec) g_random_double_range((gdouble) (usec*percent), (gdouble) (usec*(percent+2))); -/* g_message("next expiry: %lli (%s)", usec / 1000000, txt = avahi_record_to_string(e->record)); */ -/* g_free(txt); */ + usec = left + (AvahiUsec) ((double) (right-left) * rand() / (RAND_MAX+1.0)); e->expiry = e->timestamp; avahi_timeval_add(&e->expiry, usec); @@ -237,8 +249,8 @@ static void next_expiry(AvahiCache *c, AvahiCacheEntry *e, guint percent) { } static void expire_in_one_second(AvahiCache *c, AvahiCacheEntry *e) { - g_assert(c); - g_assert(e); + assert(c); + assert(e); e->state = AVAHI_CACHE_FINAL; gettimeofday(&e->expiry, NULL); @@ -246,11 +258,11 @@ static void expire_in_one_second(AvahiCache *c, AvahiCacheEntry *e) { update_time_event(c, e); } -void avahi_cache_update(AvahiCache *c, AvahiRecord *r, gboolean cache_flush, const AvahiAddress *a) { -/* gchar *txt; */ +void avahi_cache_update(AvahiCache *c, AvahiRecord *r, int cache_flush, const AvahiAddress *a) { +/* char *txt; */ - g_assert(c); - g_assert(r && r->ref >= 1); + assert(c); + assert(r && r->ref >= 1); /* txt = avahi_record_to_string(r); */ @@ -298,7 +310,7 @@ void avahi_cache_update(AvahiCache *c, AvahiRecord *r, gboolean cache_flush, con /* We need to update the hash table key if we replace the * record */ if (e->by_key_prev == NULL) - g_hash_table_replace(c->hash_table, r->key, e); + avahi_hashmap_replace(c->hashmap, r->key, e); /* Update the record */ avahi_record_unref(e->record); @@ -314,20 +326,24 @@ void avahi_cache_update(AvahiCache *c, AvahiRecord *r, gboolean cache_flush, con if (c->n_entries >= AVAHI_MAX_CACHE_ENTRIES) return; - c->n_entries++; - - e = g_new(AvahiCacheEntry, 1); + if (!(e = avahi_new(AvahiCacheEntry, 1))) { + avahi_log_error(__FILE__": Out of memory"); + return; + } + e->cache = c; e->time_event = NULL; e->record = avahi_record_ref(r); /* Append to hash table */ AVAHI_LLIST_PREPEND(AvahiCacheEntry, by_key, first, e); - g_hash_table_replace(c->hash_table, e->record->key, first); + avahi_hashmap_replace(c->hashmap, e->record->key, first); /* Append to linked list */ AVAHI_LLIST_PREPEND(AvahiCacheEntry, entry, c->entries, e); + c->n_entries++; + /* Notify subscribers */ avahi_browser_notify(c->server, c->interface, e->record, AVAHI_BROWSER_NEW); } @@ -339,54 +355,60 @@ void avahi_cache_update(AvahiCache *c, AvahiRecord *r, gboolean cache_flush, con e->cache_flush = cache_flush; } -/* g_free(txt); */ +/* avahi_free(txt); */ } struct dump_data { AvahiDumpCallback callback; - gpointer userdata; + void* userdata; }; -static void dump_callback(gpointer key, gpointer data, gpointer userdata) { +static void dump_callback(void* key, void* data, void* userdata) { AvahiCacheEntry *e = data; AvahiKey *k = key; struct dump_data *dump_data = userdata; - g_assert(k); - g_assert(e); - g_assert(data); + assert(k); + assert(e); + assert(data); for (; e; e = e->by_key_next) { - gchar *t = avahi_record_to_string(e->record); + char *t; + + if (!(t = avahi_record_to_string(e->record))) + continue; /* OOM */ + dump_data->callback(t, dump_data->userdata); - g_free(t); + avahi_free(t); } } -void avahi_cache_dump(AvahiCache *c, AvahiDumpCallback callback, gpointer userdata) { +int avahi_cache_dump(AvahiCache *c, AvahiDumpCallback callback, void* userdata) { struct dump_data data; - g_assert(c); - g_assert(callback); + assert(c); + assert(callback); callback(";;; CACHE DUMP FOLLOWS ;;;", userdata); data.callback = callback; data.userdata = userdata; - g_hash_table_foreach(c->hash_table, dump_callback, &data); + avahi_hashmap_foreach(c->hashmap, dump_callback, &data); + + return 0; } -gboolean avahi_cache_entry_half_ttl(AvahiCache *c, AvahiCacheEntry *e) { +int avahi_cache_entry_half_ttl(AvahiCache *c, AvahiCacheEntry *e) { struct timeval now; - AvahiUsec age; + unsigned age; - g_assert(c); - g_assert(e); + assert(c); + assert(e); gettimeofday(&now, NULL); - age = avahi_timeval_diff(&now, &e->timestamp)/1000000; + age = (unsigned) (avahi_timeval_diff(&now, &e->timestamp)/1000000); /* avahi_log_debug("age: %lli, ttl/2: %u", age, e->record->ttl); */ @@ -394,7 +416,7 @@ gboolean avahi_cache_entry_half_ttl(AvahiCache *c, AvahiCacheEntry *e) { } void avahi_cache_flush(AvahiCache *c) { - g_assert(c); + assert(c); while (c->entries) remove_entry(c, c->entries); diff --git a/avahi-core/cache.h b/avahi-core/cache.h index 2f4caa6..fa723e9 100644 --- a/avahi-core/cache.h +++ b/avahi-core/cache.h @@ -22,14 +22,13 @@ USA. ***/ -#include <glib.h> - typedef struct AvahiCache AvahiCache; #include <avahi-common/llist.h> #include "prioq.h" #include "server.h" #include "timeeventq.h" +#include "hashmap.h" typedef enum { AVAHI_CACHE_VALID, @@ -46,7 +45,7 @@ struct AvahiCacheEntry { AvahiRecord *record; struct timeval timestamp; struct timeval expiry; - gboolean cache_flush; + int cache_flush; AvahiAddress origin; @@ -62,11 +61,11 @@ struct AvahiCache { AvahiInterface *interface; - GHashTable *hash_table; + AvahiHashmap *hashmap; AVAHI_LLIST_HEAD(AvahiCacheEntry, entries); - guint n_entries; + unsigned n_entries; }; AvahiCache *avahi_cache_new(AvahiServer *server, AvahiInterface *interface); @@ -75,14 +74,14 @@ void avahi_cache_free(AvahiCache *c); AvahiCacheEntry *avahi_cache_lookup_key(AvahiCache *c, AvahiKey *k); AvahiCacheEntry *avahi_cache_lookup_record(AvahiCache *c, AvahiRecord *r); -void avahi_cache_update(AvahiCache *c, AvahiRecord *r, gboolean cache_flush, const AvahiAddress *a); +void avahi_cache_update(AvahiCache *c, AvahiRecord *r, int cache_flush, const AvahiAddress *a); -void avahi_cache_dump(AvahiCache *c, AvahiDumpCallback callback, gpointer userdata); +int avahi_cache_dump(AvahiCache *c, AvahiDumpCallback callback, void* userdata); -typedef gpointer AvahiCacheWalkCallback(AvahiCache *c, AvahiKey *pattern, AvahiCacheEntry *e, gpointer userdata); -gpointer avahi_cache_walk(AvahiCache *c, AvahiKey *pattern, AvahiCacheWalkCallback cb, gpointer userdata); +typedef void* AvahiCacheWalkCallback(AvahiCache *c, AvahiKey *pattern, AvahiCacheEntry *e, void* userdata); +void* avahi_cache_walk(AvahiCache *c, AvahiKey *pattern, AvahiCacheWalkCallback cb, void* userdata); -gboolean avahi_cache_entry_half_ttl(AvahiCache *c, AvahiCacheEntry *e); +int avahi_cache_entry_half_ttl(AvahiCache *c, AvahiCacheEntry *e); void avahi_cache_flush(AvahiCache *c); diff --git a/avahi-core/conformance-test.c b/avahi-core/conformance-test.c index c14a761..ebf9083 100644 --- a/avahi-core/conformance-test.c +++ b/avahi-core/conformance-test.c @@ -29,34 +29,38 @@ #include <stdlib.h> #include <unistd.h> #include <stdio.h> +#include <assert.h> #include <avahi-common/alternative.h> +#include <avahi-glib/glib-watch.h> +#include <avahi-glib/glib-malloc.h> + #include "core.h" #include "log.h" -static gchar *name = NULL; +static char *name = NULL; static AvahiEntryGroup *group = NULL; static int try = 0; static AvahiServer *avahi = NULL; -static void dump_line(const gchar *text, gpointer userdata) { +static void dump_line(const char *text, void* userdata) { printf("%s\n", text); } -static gboolean dump_timeout(gpointer data) { +static int dump_timeout(void* data) { avahi_server_dump(avahi, dump_line, NULL); - return TRUE; + return 1; } -static void entry_group_callback(AvahiServer *s, AvahiEntryGroup *g, AvahiEntryGroupState state, gpointer userdata); +static void entry_group_callback(AvahiServer *s, AvahiEntryGroup *g, AvahiEntryGroupState state, void* userdata); -static void create_service(const gchar *t) { - gchar *n; +static void create_service(const char *t) { + char *n; - g_assert(t || name); + assert(t || name); n = t ? g_strdup(t) : avahi_alternative_service_name(name); - g_free(name); + avahi_free(name); name = n; if (group) @@ -70,17 +74,17 @@ static void create_service(const gchar *t) { try++; } -static gboolean rename_timeout(gpointer data) { +static int rename_timeout(void* data) { if (access("flag", F_OK) == 0) { create_service("New - Bonjour Service Name"); - return FALSE; + return 0; } - return TRUE; + return 1; } -static void entry_group_callback(AvahiServer *s, AvahiEntryGroup *g, AvahiEntryGroupState state, gpointer userdata) { +static void entry_group_callback(AvahiServer *s, AvahiEntryGroup *g, AvahiEntryGroupState state, void* userdata) { if (state == AVAHI_ENTRY_GROUP_COLLISION) create_service(NULL); else if (state == AVAHI_ENTRY_GROUP_ESTABLISHED) { @@ -89,7 +93,7 @@ static void entry_group_callback(AvahiServer *s, AvahiEntryGroup *g, AvahiEntryG } } -static void server_callback(AvahiServer *s, AvahiServerState state, gpointer userdata) { +static void server_callback(AvahiServer *s, AvahiServerState state, void* userdata) { avahi_log_debug("server state: %i", state); if (state == AVAHI_SERVER_RUNNING) { @@ -101,10 +105,15 @@ static void server_callback(AvahiServer *s, AvahiServerState state, gpointer use int main(int argc, char *argv[]) { GMainLoop *loop = NULL; gint error; + AvahiGLibPoll *glib_poll; + + avahi_set_allocator(avahi_glib_allocator()); - avahi = avahi_server_new(NULL, NULL, server_callback, NULL, &error); + glib_poll = avahi_glib_poll_new(NULL); - loop = g_main_loop_new(NULL, FALSE); + avahi = avahi_server_new(avahi_glib_poll_get(glib_poll), NULL, server_callback, NULL, &error); + + loop = g_main_loop_new(NULL, 0); g_timeout_add(1000*5, dump_timeout, avahi); g_timeout_add(1000*5, rename_timeout, avahi); g_main_loop_run(loop); @@ -113,6 +122,8 @@ int main(int argc, char *argv[]) { if (group) avahi_entry_group_free(group); avahi_server_free(avahi); + + avahi_glib_poll_free(glib_poll); return 0; } diff --git a/avahi-core/core.h b/avahi-core/core.h index f51bd6b..4431d80 100644 --- a/avahi-core/core.h +++ b/avahi-core/core.h @@ -22,8 +22,6 @@ USA. ***/ -#include <glib.h> - /** \file core.h The Avahi Multicast DNS and DNS Service Discovery implmentation. */ /** \example publish-service.c Example how to register a DNS-SD @@ -57,6 +55,7 @@ AVAHI_C_DECL_END #include <avahi-common/alternative.h> #include <avahi-common/error.h> #include <avahi-common/defs.h> +#include <avahi-common/watch.h> #ifndef DOXYGEN_SHOULD_SKIP_THIS AVAHI_C_DECL_BEGIN @@ -72,34 +71,34 @@ typedef enum { } AvahiEntryFlags; /** Prototype for callback functions which are called whenever the state of an AvahiServer object changes */ -typedef void (*AvahiServerCallback) (AvahiServer *s, AvahiServerState state, gpointer userdata); +typedef void (*AvahiServerCallback) (AvahiServer *s, AvahiServerState state, void* userdata); /** Prototype for callback functions which are called whenever the state of an AvahiEntryGroup object changes */ -typedef void (*AvahiEntryGroupCallback) (AvahiServer *s, AvahiEntryGroup *g, AvahiEntryGroupState state, gpointer userdata); +typedef void (*AvahiEntryGroupCallback) (AvahiServer *s, AvahiEntryGroup *g, AvahiEntryGroupState state, void* userdata); /** Stores configuration options for a server instance */ typedef struct AvahiServerConfig { - gchar *host_name; /**< Default host name. If left empty defaults to the result of gethostname(2) of the libc */ - gchar *domain_name; /**< Default domain name. If left empty defaults to .local */ - gboolean use_ipv4; /**< Enable IPv4 support */ - gboolean use_ipv6; /**< Enable IPv6 support */ - gboolean publish_hinfo; /**< Register a HINFO record for the host containing the local OS and CPU type */ - gboolean publish_addresses; /**< Register A, AAAA and PTR records for all local IP addresses */ - gboolean publish_workstation; /**< Register a _workstation._tcp service */ - gboolean publish_domain; /**< Announce the local domain for browsing */ - gboolean check_response_ttl; /**< If enabled the server ignores all incoming responses with IP TTL != 255. Newer versions of the RFC do no longer contain this check, so it is disabled by default. */ - gboolean use_iff_running; /**< Require IFF_RUNNING on local network interfaces. This is the official way to check for link beat. Unfortunately this doesn't work with all drivers. So bettere leave this off. */ - gboolean enable_reflector; /**< Reflect incoming mDNS traffic to all local networks. This allows mDNS based network browsing beyond ethernet borders */ - gboolean reflect_ipv; /**< if enable_reflector is TRUE, enable/disable reflecting between IPv4 and IPv6 */ + char *host_name; /**< Default host name. If left empty defaults to the result of gethostname(2) of the libc */ + char *domain_name; /**< Default domain name. If left empty defaults to .local */ + int use_ipv4; /**< Enable IPv4 support */ + int use_ipv6; /**< Enable IPv6 support */ + int publish_hinfo; /**< Register a HINFO record for the host containing the local OS and CPU type */ + int publish_addresses; /**< Register A, AAAA and PTR records for all local IP addresses */ + int publish_workstation; /**< Register a _workstation._tcp service */ + int publish_domain; /**< Announce the local domain for browsing */ + int check_response_ttl; /**< If enabled the server ignores all incoming responses with IP TTL != 255. Newer versions of the RFC do no longer contain this check, so it is disabled by default. */ + int use_iff_running; /**< Require IFF_RUNNING on local network interfaces. This is the official way to check for link beat. Unfortunately this doesn't work with all drivers. So bettere leave this off. */ + int enable_reflector; /**< Reflect incoming mDNS traffic to all local networks. This allows mDNS based network browsing beyond ethernet borders */ + int reflect_ipv; /**< if enable_reflector is 1, enable/disable reflecting between IPv4 and IPv6 */ } AvahiServerConfig; /** Allocate a new mDNS responder object. */ AvahiServer *avahi_server_new( - GMainContext *c, /**< The GLIB main loop context to attach to */ + AvahiPoll *api, /**< The main loop adapter */ const AvahiServerConfig *sc, /**< If non-NULL a pointer to a configuration structure for the server. The server makes an internal deep copy of this structure, so you may free it using avahi_server_config_done() immediately after calling this function. */ AvahiServerCallback callback, /**< A callback which is called whenever the state of the server changes */ - gpointer userdata, /**< An opaque pointer which is passed to the callback function */ - gint *error); + void* userdata, /**< An opaque pointer which is passed to the callback function */ + int *error); /** Free an mDNS responder object */ void avahi_server_free(AvahiServer* s); @@ -111,7 +110,7 @@ void avahi_server_free(AvahiServer* s); * release this memory make sure to call * avahi_server_config_done(). If you want to replace any strings in * the structure be sure to free the strings filled in by this - * function with g_free() first and allocate the replacements with + * function with avahi_free() first and allocate the replacements with * g_malloc() (or g_strdup()).*/ AvahiServerConfig* avahi_server_config_init( AvahiServerConfig *c /**< A structure which shall be filled in */ ); @@ -128,15 +127,15 @@ void avahi_server_config_free(AvahiServerConfig *c); * return value points to an internally allocated string. Be sure to * make a copy of the string before calling any other library * functions. */ -const gchar* avahi_server_get_domain_name(AvahiServer *s); +const char* avahi_server_get_domain_name(AvahiServer *s); /** Return the currently chosen host name. The return value points to a internally allocated string. */ -const gchar* avahi_server_get_host_name(AvahiServer *s); +const char* avahi_server_get_host_name(AvahiServer *s); /** Return the currently chosen host name as a FQDN ("fully qualified * domain name", i.e. the concatenation of the host and domain * name). The return value points to a internally allocated string. */ -const gchar* avahi_server_get_host_name_fqdn(AvahiServer *s); +const char* avahi_server_get_host_name_fqdn(AvahiServer *s); /** Change the host name of a running mDNS responder. This will drop all automicatilly generated RRs and readd them with the new @@ -146,17 +145,17 @@ function is intended to be called when a host name conflict is reported using AvahiServerCallback. The caller should readd all user defined RRs too since they otherwise continue to point to the outdated host name..*/ -gint avahi_server_set_host_name(AvahiServer *s, const gchar *host_name); +int avahi_server_set_host_name(AvahiServer *s, const char *host_name); /** Change the domain name of a running mDNS responder. The same rules * as with avahi_server_set_host_name() apply. */ -gint avahi_server_set_domain_name(AvahiServer *s, const gchar *domain_name); +int avahi_server_set_domain_name(AvahiServer *s, const char *domain_name); /** Return the opaque user data pointer attached to a server object */ -gpointer avahi_server_get_data(AvahiServer *s); +void* avahi_server_get_data(AvahiServer *s); /** Change the opaque user data pointer attached to a server object */ -void avahi_server_set_data(AvahiServer *s, gpointer userdata); +void avahi_server_set_data(AvahiServer *s, void* userdata); /** Return the current state of the server object */ AvahiServerState avahi_server_get_state(AvahiServer *s); @@ -170,41 +169,41 @@ AvahiServerState avahi_server_get_state(AvahiServer *s); const AvahiRecord *avahi_server_iterate(AvahiServer *s, AvahiEntryGroup *g, void **state); /** Callback prototype for avahi_server_dump() */ -typedef void (*AvahiDumpCallback)(const gchar *text, gpointer userdata); +typedef void (*AvahiDumpCallback)(const char *text, void* userdata); /** Dump the current server status by calling "callback" for each line. */ -void avahi_server_dump(AvahiServer *s, AvahiDumpCallback callback, gpointer userdata); +int avahi_server_dump(AvahiServer *s, AvahiDumpCallback callback, void* userdata); /** Create a new entry group. The specified callback function is * called whenever the state of the group changes. Use entry group * objects to keep track of you RRs. Add new RRs to a group using * avahi_server_add_xxx(). Make sure to call avahi_entry_group_commit() * to start the registration process for your RRs */ -AvahiEntryGroup *avahi_entry_group_new(AvahiServer *s, AvahiEntryGroupCallback callback, gpointer userdata); +AvahiEntryGroup *avahi_entry_group_new(AvahiServer *s, AvahiEntryGroupCallback callback, void* userdata); /** Free an entry group. All RRs assigned to the group are removed from the server */ void avahi_entry_group_free(AvahiEntryGroup *g); /** Commit an entry group. This starts the probing and registration process for all RRs in the group */ -gint avahi_entry_group_commit(AvahiEntryGroup *g); +int avahi_entry_group_commit(AvahiEntryGroup *g); /** Remove all entries from the entry group and reset the state to AVAHI_ENTRY_GROUP_UNCOMMITED. */ void avahi_entry_group_reset(AvahiEntryGroup *g); -/** Return TRUE if the entry group is empty, i.e. has no records attached. */ -gboolean avahi_entry_group_is_empty(AvahiEntryGroup *g); +/** Return 1 if the entry group is empty, i.e. has no records attached. */ +int avahi_entry_group_is_empty(AvahiEntryGroup *g); /** Return the current state of the specified entry group */ AvahiEntryGroupState avahi_entry_group_get_state(AvahiEntryGroup *g); /** Change the opaque user data pointer attached to an entry group object */ -void avahi_entry_group_set_data(AvahiEntryGroup *g, gpointer userdata); +void avahi_entry_group_set_data(AvahiEntryGroup *g, void* userdata); /** Return the opaque user data pointer currently set for the entry group object */ -gpointer avahi_entry_group_get_data(AvahiEntryGroup *g); +void* avahi_entry_group_get_data(AvahiEntryGroup *g); /** Add a new resource record to the server. Returns 0 on success, negative otherwise. */ -gint avahi_server_add( +int avahi_server_add( AvahiServer *s, /**< The server object to add this record to */ AvahiEntryGroup *g, /**< An entry group object if this new record shall be attached to one, or NULL. If you plan to remove the record sometime later you a required to pass an entry group object here. */ AvahiIfIndex interface, /**< A numeric index of a network interface to attach this record to, or AVAHI_IF_UNSPEC to attach this record to all interfaces */ @@ -213,51 +212,51 @@ gint avahi_server_add( AvahiRecord *r /**< The record to add. This function increases the reference counter of this object. */ ); /** Add a PTR RR to the server. See avahi_server_add() for more information. */ -gint avahi_server_add_ptr( +int avahi_server_add_ptr( AvahiServer *s, AvahiEntryGroup *g, AvahiIfIndex interface, AvahiProtocol protocol, AvahiEntryFlags flags, - guint32 ttl, /**< DNS TTL for this record */ - const gchar *name, /**< PTR record name */ - const gchar *dest /**< pointer destination */ ); + uint32_t ttl, /**< DNS TTL for this record */ + const char *name, /**< PTR record name */ + const char *dest /**< pointer destination */ ); /** Add a PTR RR to the server. See avahi_server_add() for more information. */ -gint avahi_server_add_txt( +int avahi_server_add_txt( AvahiServer *s, AvahiEntryGroup *g, AvahiIfIndex interface, AvahiProtocol protocol, AvahiEntryFlags flags, - guint32 ttl, /**< DNS TTL for this record */ - const gchar *name, /**< TXT record name */ + uint32_t ttl, /**< DNS TTL for this record */ + const char *name, /**< TXT record name */ ... /**< Text record data, terminated by NULL */); /** Add a PTR RR to the server. Mostly identical to * avahi_server_add_text but takes a va_list instead of a variable * number of arguments */ -gint avahi_server_add_txt_va( +int avahi_server_add_txt_va( AvahiServer *s, AvahiEntryGroup *g, AvahiIfIndex interface, AvahiProtocol protocol, AvahiEntryFlags flags, - guint32 ttl, - const gchar *name, + uint32_t ttl, + const char *name, va_list va); /** Add a PTR RR to the server. Mostly identical to * avahi_server_add_text but takes an AvahiStringList record instead of a variable * number of arguments. */ -gint avahi_server_add_txt_strlst( +int avahi_server_add_txt_strlst( AvahiServer *s, AvahiEntryGroup *g, AvahiIfIndex interface, AvahiProtocol protocol, AvahiEntryFlags flags, - guint32 ttl, - const gchar *name, + uint32_t ttl, + const char *name, AvahiStringList *strlst /**< TXT decord data as a AvahiString. This routine makes a deep copy of this object. */ ); /** Add an IP address mapping to the server. This will add both the @@ -267,13 +266,13 @@ gint avahi_server_add_txt_strlst( * the other RR is deleted from the server or not. Therefore, you have * to free the AvahiEntryGroup and create a new one before * proceeding. */ -gint avahi_server_add_address( +int avahi_server_add_address( AvahiServer *s, AvahiEntryGroup *g, AvahiIfIndex interface, AvahiProtocol protocol, AvahiEntryFlags flags, - const gchar *name, + const char *name, AvahiAddress *a); /** Add an DNS-SD service to the Server. This will add all required @@ -282,42 +281,42 @@ gint avahi_server_add_address( * but it is not defined if the other RR is deleted from the server or * not. Therefore, you have to free the AvahiEntryGroup and create a * new one before proceeding. */ -gint avahi_server_add_service( +int avahi_server_add_service( AvahiServer *s, AvahiEntryGroup *g, AvahiIfIndex interface, AvahiProtocol protocol, - const gchar *name, /**< Service name, e.g. "Lennart's Files" */ - const gchar *type, /**< DNS-SD type, e.g. "_http._tcp" */ - const gchar *domain, - const gchar *host, /**< Host name where this servcie resides, or NULL if on the local host */ - guint16 port, /**< Port number of the service */ + const char *name, /**< Service name, e.g. "Lennart's Files" */ + const char *type, /**< DNS-SD type, e.g. "_http._tcp" */ + const char *domain, + const char *host, /**< Host name where this servcie resides, or NULL if on the local host */ + uint16_t port, /**< Port number of the service */ ... /**< Text records, terminated by NULL */); /** Mostly identical to avahi_server_add_service(), but takes an va_list for the TXT records. */ -gint avahi_server_add_service_va( +int avahi_server_add_service_va( AvahiServer *s, AvahiEntryGroup *g, AvahiIfIndex interface, AvahiProtocol protocol, - const gchar *name, - const gchar *type, - const gchar *domain, - const gchar *host, - guint16 port, + const char *name, + const char *type, + const char *domain, + const char *host, + uint16_t port, va_list va); /** Mostly identical to avahi_server_add_service(), but takes an AvahiStringList object for the TXT records. The AvahiStringList object is copied. */ -gint avahi_server_add_service_strlst( +int avahi_server_add_service_strlst( AvahiServer *s, AvahiEntryGroup *g, AvahiIfIndex interface, AvahiProtocol protocol, - const gchar *name, - const gchar *type, - const gchar *domain, - const gchar *host, - guint16 port, + const char *name, + const char *type, + const char *domain, + const char *host, + uint16_t port, AvahiStringList *strlst); /** The type of DNS server */ @@ -329,28 +328,28 @@ typedef enum { /** Publish the specified unicast DNS server address via mDNS. You may * browse for records create this way wit * avahi_dns_server_browser_new(). */ -gint avahi_server_add_dns_server_address( +int avahi_server_add_dns_server_address( AvahiServer *s, AvahiEntryGroup *g, AvahiIfIndex interface, AvahiProtocol protocol, - const gchar *domain, + const char *domain, AvahiDNSServerType type, const AvahiAddress *address, - guint16 port /** should be 53 */); + uint16_t port /** should be 53 */); /** Similar to avahi_server_add_dns_server_address(), but specify a host name instead of an address. The specified host name should be resolvable via mDNS */ -gint avahi_server_add_dns_server_name( +int avahi_server_add_dns_server_name( AvahiServer *s, AvahiEntryGroup *g, AvahiIfIndex interface, AvahiProtocol protocol, - const gchar *domain, + const char *domain, AvahiDNSServerType type, - const gchar *name, - guint16 port /** should be 53 */); + const char *name, + uint16_t port /** should be 53 */); /** A browsing object for arbitrary RRs */ typedef struct AvahiRecordBrowser AvahiRecordBrowser; @@ -362,7 +361,7 @@ typedef void (*AvahiRecordBrowserCallback)( AvahiProtocol protocol, /**< Protocol number the record was found. */ AvahiBrowserEvent event, /**< Browsing event, either AVAHI_BROWSER_NEW or AVAHI_BROWSER_REMOVE */ AvahiRecord *record, /**< The record that was found */ - gpointer userdata /**< Arbitrary user data passed to avahi_record_browser_new() */ ); + void* userdata /**< Arbitrary user data passed to avahi_record_browser_new() */ ); /** Create a new browsing object for arbitrary RRs */ AvahiRecordBrowser *avahi_record_browser_new( @@ -371,7 +370,7 @@ AvahiRecordBrowser *avahi_record_browser_new( AvahiProtocol protocol, /**< Protocol number to use when looking for the record, or AVAHI_PROTO_UNSPEC to look on all protocols */ AvahiKey *key, /**< The search key */ AvahiRecordBrowserCallback callback, /**< The callback to call on browsing events */ - gpointer userdata /**< Arbitrary use suppliable data which is passed to the callback */); + void* userdata /**< Arbitrary use suppliable data which is passed to the callback */); /** Free an AvahiRecordBrowser object */ void avahi_record_browser_free(AvahiRecordBrowser *b); @@ -385,19 +384,19 @@ typedef void (*AvahiHostNameResolverCallback)( AvahiIfIndex interface, AvahiProtocol protocol, AvahiResolverEvent event, /**< Resolving event */ - const gchar *host_name, /**< Host name which should be resolved. May differ in case from the query */ + const char *host_name, /**< Host name which should be resolved. May differ in case from the query */ const AvahiAddress *a, /**< The address, or NULL if the host name couldn't be resolved. */ - gpointer userdata); + void* userdata); /** Create an AvahiHostNameResolver object for resolving a host name to an adddress. See AvahiRecordBrowser for more info on the paramters. */ AvahiHostNameResolver *avahi_host_name_resolver_new( AvahiServer *server, AvahiIfIndex interface, AvahiProtocol protocol, - const gchar *host_name, /**< The host name to look for */ + const char *host_name, /**< The host name to look for */ AvahiProtocol aprotocol, /**< The address family of the desired address or AVAHI_PROTO_UNSPEC if doesn't matter. */ AvahiHostNameResolverCallback calback, - gpointer userdata); + void* userdata); /** Free a AvahiHostNameResolver object */ void avahi_host_name_resolver_free(AvahiHostNameResolver *r); @@ -412,8 +411,8 @@ typedef void (*AvahiAddressResolverCallback)( AvahiProtocol protocol, AvahiResolverEvent event, const AvahiAddress *a, - const gchar *host_name, /**< A host name for the specified address, if one was found, i.e. event == AVAHI_RESOLVER_FOUND */ - gpointer userdata); + const char *host_name, /**< A host name for the specified address, if one was found, i.e. event == AVAHI_RESOLVER_FOUND */ + void* userdata); /** Create an AvahiAddressResolver object. See AvahiRecordBrowser for more info on the paramters. */ AvahiAddressResolver *avahi_address_resolver_new( @@ -422,7 +421,7 @@ AvahiAddressResolver *avahi_address_resolver_new( AvahiProtocol protocol, const AvahiAddress *address, AvahiAddressResolverCallback calback, - gpointer userdata); + void* userdata); /** Free an AvahiAddressResolver object */ void avahi_address_resolver_free(AvahiAddressResolver *r); @@ -436,18 +435,18 @@ typedef void (*AvahiDomainBrowserCallback)( AvahiIfIndex interface, AvahiProtocol protocol, AvahiBrowserEvent event, - const gchar *domain, - gpointer userdata); + const char *domain, + void* userdata); /** Create a new AvahiDomainBrowser object */ AvahiDomainBrowser *avahi_domain_browser_new( AvahiServer *server, AvahiIfIndex interface, AvahiProtocol protocol, - const gchar *domain, + const char *domain, AvahiDomainBrowserType type, AvahiDomainBrowserCallback callback, - gpointer userdata); + void* userdata); /** Free an AvahiDomainBrowser object */ void avahi_domain_browser_free(AvahiDomainBrowser *b); @@ -461,18 +460,18 @@ typedef void (*AvahiServiceTypeBrowserCallback)( AvahiIfIndex interface, AvahiProtocol protocol, AvahiBrowserEvent event, - const gchar *type, - const gchar *domain, - gpointer userdata); + const char *type, + const char *domain, + void* userdata); /** Create a new AvahiServiceTypeBrowser object. */ AvahiServiceTypeBrowser *avahi_service_type_browser_new( AvahiServer *server, AvahiIfIndex interface, AvahiProtocol protocol, - const gchar *domain, + const char *domain, AvahiServiceTypeBrowserCallback callback, - gpointer userdata); + void* userdata); /** Free an AvahiServiceTypeBrowser object */ void avahi_service_type_browser_free(AvahiServiceTypeBrowser *b); @@ -486,20 +485,20 @@ typedef void (*AvahiServiceBrowserCallback)( AvahiIfIndex interface, AvahiProtocol protocol, AvahiBrowserEvent event, - const gchar *name /**< Service name, e.g. "Lennart's Files" */, - const gchar *type /**< DNS-SD type, e.g. "_http._tcp" */, - const gchar *domain /**< Domain of this service, e.g. "local" */, - gpointer userdata); + const char *name /**< Service name, e.g. "Lennart's Files" */, + const char *type /**< DNS-SD type, e.g. "_http._tcp" */, + const char *domain /**< Domain of this service, e.g. "local" */, + void* userdata); /** Create a new AvahiServiceBrowser object. */ AvahiServiceBrowser *avahi_service_browser_new( AvahiServer *server, AvahiIfIndex interface, AvahiProtocol protocol, - const gchar *service_type /** DNS-SD service type, e.g. "_http._tcp" */, - const gchar *domain, + const char *service_type /** DNS-SD service type, e.g. "_http._tcp" */, + const char *domain, AvahiServiceBrowserCallback callback, - gpointer userdata); + void* userdata); /** Free an AvahiServiceBrowser object */ void avahi_service_browser_free(AvahiServiceBrowser *b); @@ -513,26 +512,26 @@ typedef void (*AvahiServiceResolverCallback)( AvahiIfIndex interface, AvahiProtocol protocol, AvahiResolverEvent event, - const gchar *name, /**< Service name */ - const gchar *type, /**< Service Type */ - const gchar *domain, - const gchar *host_name, /**< Host name of the service */ + const char *name, /**< Service name */ + const char *type, /**< Service Type */ + const char *domain, + const char *host_name, /**< Host name of the service */ const AvahiAddress *a, /**< The resolved host name */ - guint16 port, /**< Service name */ + uint16_t port, /**< Service name */ AvahiStringList *txt, /**< TXT record data */ - gpointer userdata); + void* userdata); /** Create a new AvahiServiceResolver object */ AvahiServiceResolver *avahi_service_resolver_new( AvahiServer *server, AvahiIfIndex interface, AvahiProtocol protocol, - const gchar *name, - const gchar *type, - const gchar *domain, + const char *name, + const char *type, + const char *domain, AvahiProtocol aprotocol, /**< Address family of the desired service address. Use AVAHI_PROTO_UNSPEC if you don't care */ AvahiServiceResolverCallback calback, - gpointer userdata); + void* userdata); /** Free an AvahiServiceResolver object */ void avahi_service_resolver_free(AvahiServiceResolver *r); @@ -548,27 +547,27 @@ typedef void (*AvahiDNSServerBrowserCallback)( AvahiIfIndex interface, AvahiProtocol protocol, AvahiBrowserEvent event, - const gchar *host_name, /**< Host name of the DNS server, probably useless */ + const char *host_name, /**< Host name of the DNS server, probably useless */ const AvahiAddress *a, /**< Address of the DNS server */ - guint16 port, /**< Port number of the DNS servers, probably 53 */ - gpointer userdata); + uint16_t port, /**< Port number of the DNS servers, probably 53 */ + void* userdata); /** Create a new AvahiDNSServerBrowser object */ AvahiDNSServerBrowser *avahi_dns_server_browser_new( AvahiServer *server, AvahiIfIndex interface, AvahiProtocol protocol, - const gchar *domain, + const char *domain, AvahiDNSServerType type, AvahiProtocol aprotocol, /**< Address protocol for the DNS server */ AvahiDNSServerBrowserCallback callback, - gpointer userdata); + void* userdata); /** Free an AvahiDNSServerBrowser object */ void avahi_dns_server_browser_free(AvahiDNSServerBrowser *b); /** Return the last error code */ -gint avahi_server_errno(AvahiServer *s); +int avahi_server_errno(AvahiServer *s); #ifndef DOXYGEN_SHOULD_SKIP_THIS AVAHI_C_DECL_END diff --git a/avahi-core/dns-test.c b/avahi-core/dns-test.c index bf141f5..e5369a9 100644 --- a/avahi-core/dns-test.c +++ b/avahi-core/dns-test.c @@ -23,14 +23,17 @@ #include <config.h> #endif +#include <assert.h> + #include <avahi-common/domain.h> + #include "dns.h" #include "log.h" #include "util.h" int main(int argc, char *argv[]) { - gchar t[256]; - const gchar *a, *b, *c, *d; + char t[256]; + const char *a, *b, *c, *d; AvahiDnsPacket *p; p = avahi_dns_packet_new(0); @@ -44,19 +47,19 @@ int main(int argc, char *argv[]) { avahi_dns_packet_consume_name(p, t, sizeof(t)); avahi_log_debug(">%s<", t); - g_assert(avahi_domain_equal(a, t)); + assert(avahi_domain_equal(a, t)); avahi_dns_packet_consume_name(p, t, sizeof(t)); avahi_log_debug(">%s<", t); - g_assert(avahi_domain_equal(b, t)); + assert(avahi_domain_equal(b, t)); avahi_dns_packet_consume_name(p, t, sizeof(t)); avahi_log_debug(">%s<", t); - g_assert(avahi_domain_equal(c, t)); + assert(avahi_domain_equal(c, t)); avahi_dns_packet_consume_name(p, t, sizeof(t)); avahi_log_debug(">%s<", t); - g_assert(avahi_domain_equal(d, t)); + assert(avahi_domain_equal(d, t)); avahi_dns_packet_free(p); return 0; diff --git a/avahi-core/dns.c b/avahi-core/dns.c index 9663fc4..9bc7aec 100644 --- a/avahi-core/dns.c +++ b/avahi-core/dns.c @@ -28,13 +28,17 @@ #include <stdlib.h> #include <string.h> #include <stdio.h> +#include <assert.h> #include <avahi-common/domain.h> +#include <avahi-common/malloc.h> + #include "dns.h" +#include "log.h" -AvahiDnsPacket* avahi_dns_packet_new(guint mtu) { +AvahiDnsPacket* avahi_dns_packet_new(unsigned mtu) { AvahiDnsPacket *p; - guint max_size; + size_t max_size; if (mtu <= 0) max_size = AVAHI_DNS_PACKET_MAX_SIZE; @@ -46,7 +50,9 @@ AvahiDnsPacket* avahi_dns_packet_new(guint mtu) { if (max_size < AVAHI_DNS_PACKET_HEADER_SIZE) max_size = AVAHI_DNS_PACKET_HEADER_SIZE; - p = g_malloc(sizeof(AvahiDnsPacket) + max_size); + if (!(p = avahi_malloc(sizeof(AvahiDnsPacket) + max_size))) + return p; + p->size = p->rindex = AVAHI_DNS_PACKET_HEADER_SIZE; p->max_size = max_size; p->name_table = NULL; @@ -55,37 +61,43 @@ AvahiDnsPacket* avahi_dns_packet_new(guint mtu) { return p; } -AvahiDnsPacket* avahi_dns_packet_new_query(guint mtu) { +AvahiDnsPacket* avahi_dns_packet_new_query(unsigned mtu) { AvahiDnsPacket *p; - p = avahi_dns_packet_new(mtu); + if (!(p = avahi_dns_packet_new(mtu))) + return NULL; + avahi_dns_packet_set_field(p, AVAHI_DNS_FIELD_FLAGS, AVAHI_DNS_FLAGS(0, 0, 0, 0, 0, 0, 0, 0, 0, 0)); return p; } -AvahiDnsPacket* avahi_dns_packet_new_response(guint mtu, gboolean aa) { +AvahiDnsPacket* avahi_dns_packet_new_response(unsigned mtu, int aa) { AvahiDnsPacket *p; - p = avahi_dns_packet_new(mtu); + if (!(p = avahi_dns_packet_new(mtu))) + return NULL; + avahi_dns_packet_set_field(p, AVAHI_DNS_FIELD_FLAGS, AVAHI_DNS_FLAGS(1, 0, aa, 0, 0, 0, 0, 0, 0, 0)); return p; } -AvahiDnsPacket* avahi_dns_packet_new_reply(AvahiDnsPacket* p, guint mtu, gboolean copy_queries, gboolean aa) { +AvahiDnsPacket* avahi_dns_packet_new_reply(AvahiDnsPacket* p, unsigned mtu, int copy_queries, int aa) { AvahiDnsPacket *r; - g_assert(p); + assert(p); - r = avahi_dns_packet_new_response(mtu, aa); + if (!(r = avahi_dns_packet_new_response(mtu, aa))) + return NULL; if (copy_queries) { - guint n, saved_rindex; + unsigned saved_rindex; + uint32_t n; saved_rindex = p->rindex; p->rindex = AVAHI_DNS_PACKET_HEADER_SIZE; for (n = avahi_dns_packet_get_field(p, AVAHI_DNS_FIELD_QDCOUNT); n > 0; n--) { AvahiKey *k; - gboolean unicast_response; + int unicast_response; if ((k = avahi_dns_packet_consume_key(p, &unicast_response))) { avahi_dns_packet_append_key(r, k, unicast_response); @@ -109,66 +121,67 @@ AvahiDnsPacket* avahi_dns_packet_new_reply(AvahiDnsPacket* p, guint mtu, gboolea void avahi_dns_packet_free(AvahiDnsPacket *p) { - g_assert(p); + assert(p); if (p->name_table) - g_hash_table_destroy(p->name_table); + avahi_hashmap_free(p->name_table); - g_free(p); + avahi_free(p); } -void avahi_dns_packet_set_field(AvahiDnsPacket *p, guint idx, guint16 v) { - g_assert(p); - g_assert(idx < AVAHI_DNS_PACKET_HEADER_SIZE); +void avahi_dns_packet_set_field(AvahiDnsPacket *p, unsigned idx, uint16_t v) { + assert(p); + assert(idx < AVAHI_DNS_PACKET_HEADER_SIZE); - ((guint16*) AVAHI_DNS_PACKET_DATA(p))[idx] = g_htons(v); + ((uint16_t*) AVAHI_DNS_PACKET_DATA(p))[idx] = htons(v); } -guint16 avahi_dns_packet_get_field(AvahiDnsPacket *p, guint idx) { - g_assert(p); - g_assert(idx < AVAHI_DNS_PACKET_HEADER_SIZE); +uint16_t avahi_dns_packet_get_field(AvahiDnsPacket *p, unsigned idx) { + assert(p); + assert(idx < AVAHI_DNS_PACKET_HEADER_SIZE); - return g_ntohs(((guint16*) AVAHI_DNS_PACKET_DATA(p))[idx]); + return ntohs(((uint16_t*) AVAHI_DNS_PACKET_DATA(p))[idx]); } -void avahi_dns_packet_inc_field(AvahiDnsPacket *p, guint idx) { - g_assert(p); - g_assert(idx < AVAHI_DNS_PACKET_HEADER_SIZE); +void avahi_dns_packet_inc_field(AvahiDnsPacket *p, unsigned idx) { + assert(p); + assert(idx < AVAHI_DNS_PACKET_HEADER_SIZE); avahi_dns_packet_set_field(p, idx, avahi_dns_packet_get_field(p, idx) + 1); } -guint8* avahi_dns_packet_append_name(AvahiDnsPacket *p, const gchar *name) { - guint8 *d, *saved_ptr = NULL; - guint saved_size; +uint8_t* avahi_dns_packet_append_name(AvahiDnsPacket *p, const char *name) { + uint8_t *d, *saved_ptr = NULL; + size_t saved_size; - g_assert(p); - g_assert(name); + assert(p); + assert(name); saved_size = p->size; saved_ptr = avahi_dns_packet_extend(p, 0); while (*name) { - guint8* prev; - const gchar *pname; - gchar label[64]; + uint8_t* prev; + const char *pname; + char label[64], *u; + /* Check whether we can compress this name. */ - if (p->name_table && (prev = g_hash_table_lookup(p->name_table, name))) { - guint idx; + if (p->name_table && (prev = avahi_hashmap_lookup(p->name_table, name))) { + unsigned idx; - g_assert(prev >= AVAHI_DNS_PACKET_DATA(p)); - idx = (guint) (prev - AVAHI_DNS_PACKET_DATA(p)); + assert(prev >= AVAHI_DNS_PACKET_DATA(p)); + idx = (unsigned) (prev - AVAHI_DNS_PACKET_DATA(p)); - g_assert(idx < p->size); + assert(idx < p->size); if (idx < 0x4000) { - guint16 *t; - if (!(t = (guint16*) avahi_dns_packet_extend(p, sizeof(guint16)))) + uint16_t *t; + if (!(t = (uint16_t*) avahi_dns_packet_extend(p, sizeof(uint16_t)))) return NULL; - *t = g_htons((0xC000 | idx)); + *t = htons((0xC000 | idx)); return saved_ptr; } } @@ -183,9 +196,12 @@ guint8* avahi_dns_packet_append_name(AvahiDnsPacket *p, const gchar *name) { if (!p->name_table) /* This works only for normalized domain names */ - p->name_table = g_hash_table_new_full((GHashFunc) g_str_hash, (GEqualFunc) g_str_equal, g_free, NULL); + p->name_table = avahi_hashmap_new(avahi_string_hash, avahi_string_equal, avahi_free, NULL); - g_hash_table_insert(p->name_table, g_strdup(pname), d); + if (!(u = avahi_strdup(pname))) + avahi_log_error("avahi_strdup() failed."); + else + avahi_hashmap_insert(p->name_table, u, d); } if (!(d = avahi_dns_packet_extend(p, 1))) @@ -200,35 +216,35 @@ fail: return NULL; } -guint8* avahi_dns_packet_append_uint16(AvahiDnsPacket *p, guint16 v) { - guint8 *d; - g_assert(p); +uint8_t* avahi_dns_packet_append_uint16(AvahiDnsPacket *p, uint16_t v) { + uint8_t *d; + assert(p); - if (!(d = avahi_dns_packet_extend(p, sizeof(guint16)))) + if (!(d = avahi_dns_packet_extend(p, sizeof(uint16_t)))) return NULL; - *((guint16*) d) = g_htons(v); + *((uint16_t*) d) = htons(v); return d; } -guint8 *avahi_dns_packet_append_uint32(AvahiDnsPacket *p, guint32 v) { - guint8 *d; - g_assert(p); +uint8_t *avahi_dns_packet_append_uint32(AvahiDnsPacket *p, uint32_t v) { + uint8_t *d; + assert(p); - if (!(d = avahi_dns_packet_extend(p, sizeof(guint32)))) + if (!(d = avahi_dns_packet_extend(p, sizeof(uint32_t)))) return NULL; - *((guint32*) d) = g_htonl(v); + *((uint32_t*) d) = htonl(v); return d; } -guint8 *avahi_dns_packet_append_bytes(AvahiDnsPacket *p, gconstpointer b, guint l) { - guint8* d; +uint8_t *avahi_dns_packet_append_bytes(AvahiDnsPacket *p, const void *b, size_t l) { + uint8_t* d; - g_assert(p); - g_assert(b); - g_assert(l); + assert(p); + assert(b); + assert(l); if (!(d = avahi_dns_packet_extend(p, l))) return NULL; @@ -237,12 +253,12 @@ guint8 *avahi_dns_packet_append_bytes(AvahiDnsPacket *p, gconstpointer b, guint return d; } -guint8* avahi_dns_packet_append_string(AvahiDnsPacket *p, const gchar *s) { - guint8* d; - guint k; +uint8_t* avahi_dns_packet_append_string(AvahiDnsPacket *p, const char *s) { + uint8_t* d; + size_t k; - g_assert(p); - g_assert(s); + assert(p); + assert(s); if ((k = strlen(s)) >= 255) k = 255; @@ -250,16 +266,16 @@ guint8* avahi_dns_packet_append_string(AvahiDnsPacket *p, const gchar *s) { if (!(d = avahi_dns_packet_extend(p, k+1))) return NULL; - *d = (guint8) k; + *d = (uint8_t) k; memcpy(d+1, s, k); return d; } -guint8 *avahi_dns_packet_extend(AvahiDnsPacket *p, guint l) { - guint8 *d; +uint8_t *avahi_dns_packet_extend(AvahiDnsPacket *p, size_t l) { + uint8_t *d; - g_assert(p); + assert(p); if (p->size+l > p->max_size) return NULL; @@ -270,9 +286,9 @@ guint8 *avahi_dns_packet_extend(AvahiDnsPacket *p, guint l) { return d; } -gint avahi_dns_packet_check_valid(AvahiDnsPacket *p) { - guint16 flags; - g_assert(p); +int avahi_dns_packet_is_valid(AvahiDnsPacket *p) { + uint16_t flags; + assert(p); if (p->size < 12) return -1; @@ -285,20 +301,20 @@ gint avahi_dns_packet_check_valid(AvahiDnsPacket *p) { return 0; } -gint avahi_dns_packet_is_query(AvahiDnsPacket *p) { - g_assert(p); +int avahi_dns_packet_is_query(AvahiDnsPacket *p) { + assert(p); return !(avahi_dns_packet_get_field(p, AVAHI_DNS_FIELD_FLAGS) & AVAHI_DNS_FLAG_QR); } -static gint consume_labels(AvahiDnsPacket *p, guint idx, gchar *ret_name, guint l) { - gint ret = 0; +static int consume_labels(AvahiDnsPacket *p, unsigned idx, char *ret_name, size_t l) { + int ret = 0; int compressed = 0; int first_label = 1; - g_assert(p && ret_name && l); + assert(p && ret_name && l); for (;;) { - guint8 n; + uint8_t n; if (idx+1 > p->size) return -1; @@ -325,7 +341,7 @@ static gint consume_labels(AvahiDnsPacket *p, guint idx, gchar *ret_name, guint if (idx + n > p->size) return -1; - if ((guint) n + 1 > l) + if ((size_t) n + 1 > l) return -1; if (!first_label) { @@ -347,7 +363,7 @@ static gint consume_labels(AvahiDnsPacket *p, guint idx, gchar *ret_name, guint if (idx+2 > p->size) return -1; - idx = ((guint) (AVAHI_DNS_PACKET_DATA(p)[idx] & ~0xC0)) << 8 | AVAHI_DNS_PACKET_DATA(p)[idx+1]; + idx = ((unsigned) (AVAHI_DNS_PACKET_DATA(p)[idx] & ~0xC0)) << 8 | AVAHI_DNS_PACKET_DATA(p)[idx+1]; if (!compressed) ret += 2; @@ -358,8 +374,8 @@ static gint consume_labels(AvahiDnsPacket *p, guint idx, gchar *ret_name, guint } } -gint avahi_dns_packet_consume_name(AvahiDnsPacket *p, gchar *ret_name, guint l) { - gint r; +int avahi_dns_packet_consume_name(AvahiDnsPacket *p, char *ret_name, size_t l) { + int r; if ((r = consume_labels(p, p->rindex, ret_name, l)) < 0) return -1; @@ -368,36 +384,36 @@ gint avahi_dns_packet_consume_name(AvahiDnsPacket *p, gchar *ret_name, guint l) return 0; } -gint avahi_dns_packet_consume_uint16(AvahiDnsPacket *p, guint16 *ret_v) { - g_assert(p); - g_assert(ret_v); +int avahi_dns_packet_consume_uint16(AvahiDnsPacket *p, uint16_t *ret_v) { + assert(p); + assert(ret_v); - if (p->rindex + sizeof(guint16) > p->size) + if (p->rindex + sizeof(uint16_t) > p->size) return -1; - *ret_v = g_ntohs(*((guint16*) (AVAHI_DNS_PACKET_DATA(p) + p->rindex))); - p->rindex += sizeof(guint16); + *ret_v = ntohs(*((uint16_t*) (AVAHI_DNS_PACKET_DATA(p) + p->rindex))); + p->rindex += sizeof(uint16_t); return 0; } -gint avahi_dns_packet_consume_uint32(AvahiDnsPacket *p, guint32 *ret_v) { - g_assert(p); - g_assert(ret_v); +int avahi_dns_packet_consume_uint32(AvahiDnsPacket *p, uint32_t *ret_v) { + assert(p); + assert(ret_v); - if (p->rindex + sizeof(guint32) > p->size) + if (p->rindex + sizeof(uint32_t) > p->size) return -1; - *ret_v = g_ntohl(*((guint32*) (AVAHI_DNS_PACKET_DATA(p) + p->rindex))); - p->rindex += sizeof(guint32); + *ret_v = ntohl(*((uint32_t*) (AVAHI_DNS_PACKET_DATA(p) + p->rindex))); + p->rindex += sizeof(uint32_t); return 0; } -gint avahi_dns_packet_consume_bytes(AvahiDnsPacket *p, gpointer ret_data, guint l) { - g_assert(p); - g_assert(ret_data); - g_assert(l > 0); +int avahi_dns_packet_consume_bytes(AvahiDnsPacket *p, void * ret_data, size_t l) { + assert(p); + assert(ret_data); + assert(l > 0); if (p->rindex + l > p->size) return -1; @@ -408,12 +424,12 @@ gint avahi_dns_packet_consume_bytes(AvahiDnsPacket *p, gpointer ret_data, guint return 0; } -gint avahi_dns_packet_consume_string(AvahiDnsPacket *p, gchar *ret_string, guint l) { - guint k; +int avahi_dns_packet_consume_string(AvahiDnsPacket *p, char *ret_string, size_t l) { + size_t k; - g_assert(p); - g_assert(ret_string); - g_assert(l > 0); + assert(p); + assert(ret_string); + assert(l > 0); if (p->rindex >= p->size) return -1; @@ -428,15 +444,14 @@ gint avahi_dns_packet_consume_string(AvahiDnsPacket *p, gchar *ret_string, guint memcpy(ret_string, AVAHI_DNS_PACKET_DATA(p)+p->rindex+1, l-1); ret_string[l-1] = 0; - p->rindex += 1+k; return 0; } -gconstpointer avahi_dns_packet_get_rptr(AvahiDnsPacket *p) { - g_assert(p); +const void* avahi_dns_packet_get_rptr(AvahiDnsPacket *p) { + assert(p); if (p->rindex > p->size) return NULL; @@ -444,8 +459,8 @@ gconstpointer avahi_dns_packet_get_rptr(AvahiDnsPacket *p) { return AVAHI_DNS_PACKET_DATA(p) + p->rindex; } -gint avahi_dns_packet_skip(AvahiDnsPacket *p, guint length) { - g_assert(p); +int avahi_dns_packet_skip(AvahiDnsPacket *p, size_t length) { + assert(p); if (p->rindex + length > p->size) return -1; @@ -454,16 +469,16 @@ gint avahi_dns_packet_skip(AvahiDnsPacket *p, guint length) { return 0; } -AvahiRecord* avahi_dns_packet_consume_record(AvahiDnsPacket *p, gboolean *ret_cache_flush) { - gchar name[257], buf[257]; - guint16 type, class; - guint32 ttl; - guint16 rdlength; +AvahiRecord* avahi_dns_packet_consume_record(AvahiDnsPacket *p, int *ret_cache_flush) { + char name[257], buf[257]; + uint16_t type, class; + uint32_t ttl; + uint16_t rdlength; AvahiRecord *r = NULL; - gconstpointer start; + const void* start; - g_assert(p); - g_assert(ret_cache_flush); + assert(p); + assert(ret_cache_flush); /* avahi_log_debug("consume_record()"); */ @@ -482,7 +497,8 @@ AvahiRecord* avahi_dns_packet_consume_record(AvahiDnsPacket *p, gboolean *ret_ca start = avahi_dns_packet_get_rptr(p); - r = avahi_record_new_full(name, class, type, ttl); + if (!(r = avahi_record_new_full(name, class, type, ttl))) + return NULL; switch (type) { case AVAHI_DNS_TYPE_PTR: @@ -493,7 +509,7 @@ AvahiRecord* avahi_dns_packet_consume_record(AvahiDnsPacket *p, gboolean *ret_ca if (avahi_dns_packet_consume_name(p, buf, sizeof(buf)) < 0) goto fail; - r->data.ptr.name = g_strdup(buf); + r->data.ptr.name = avahi_strdup(buf); break; @@ -507,7 +523,7 @@ AvahiRecord* avahi_dns_packet_consume_record(AvahiDnsPacket *p, gboolean *ret_ca avahi_dns_packet_consume_name(p, buf, sizeof(buf)) < 0) goto fail; - r->data.srv.name = g_strdup(buf); + r->data.srv.name = avahi_strdup(buf); break; case AVAHI_DNS_TYPE_HINFO: @@ -517,12 +533,12 @@ AvahiRecord* avahi_dns_packet_consume_record(AvahiDnsPacket *p, gboolean *ret_ca if (avahi_dns_packet_consume_string(p, buf, sizeof(buf)) < 0) goto fail; - r->data.hinfo.cpu = g_strdup(buf); + r->data.hinfo.cpu = avahi_strdup(buf); if (avahi_dns_packet_consume_string(p, buf, sizeof(buf)) < 0) goto fail; - r->data.hinfo.os = g_strdup(buf); + r->data.hinfo.os = avahi_strdup(buf); break; case AVAHI_DNS_TYPE_TXT: @@ -563,7 +579,7 @@ AvahiRecord* avahi_dns_packet_consume_record(AvahiDnsPacket *p, gboolean *ret_ca if (rdlength > 0) { - r->data.generic.data = g_memdup(avahi_dns_packet_get_rptr(p), rdlength); + r->data.generic.data = avahi_memdup(avahi_dns_packet_get_rptr(p), rdlength); if (avahi_dns_packet_skip(p, rdlength) < 0) goto fail; @@ -572,10 +588,10 @@ AvahiRecord* avahi_dns_packet_consume_record(AvahiDnsPacket *p, gboolean *ret_ca break; } -/* avahi_log_debug("%i == %u ?", (guint8*) avahi_dns_packet_get_rptr(p) - (guint8*) start, rdlength); */ +/* avahi_log_debug("%i == %u ?", (uint8_t*) avahi_dns_packet_get_rptr(p) - (uint8_t*) start, rdlength); */ /* Check if we read enough data */ - if ((const guint8*) avahi_dns_packet_get_rptr(p) - (const guint8*) start != rdlength) + if ((const uint8_t*) avahi_dns_packet_get_rptr(p) - (const uint8_t*) start != rdlength) goto fail; return r; @@ -587,12 +603,12 @@ fail: return NULL; } -AvahiKey* avahi_dns_packet_consume_key(AvahiDnsPacket *p, gboolean *ret_unicast_response) { - gchar name[256]; - guint16 type, class; +AvahiKey* avahi_dns_packet_consume_key(AvahiDnsPacket *p, int *ret_unicast_response) { + char name[256]; + uint16_t type, class; - g_assert(p); - g_assert(ret_unicast_response); + assert(p); + assert(ret_unicast_response); if (avahi_dns_packet_consume_name(p, name, sizeof(name)) < 0 || avahi_dns_packet_consume_uint16(p, &type) < 0 || @@ -605,12 +621,12 @@ AvahiKey* avahi_dns_packet_consume_key(AvahiDnsPacket *p, gboolean *ret_unicast_ return avahi_key_new(name, class, type); } -guint8* avahi_dns_packet_append_key(AvahiDnsPacket *p, AvahiKey *k, gboolean unicast_response) { - guint8 *t; - guint size; +uint8_t* avahi_dns_packet_append_key(AvahiDnsPacket *p, AvahiKey *k, int unicast_response) { + uint8_t *t; + size_t size; - g_assert(p); - g_assert(k); + assert(p); + assert(k); size = p->size; @@ -624,12 +640,12 @@ guint8* avahi_dns_packet_append_key(AvahiDnsPacket *p, AvahiKey *k, gboolean uni return t; } -guint8* avahi_dns_packet_append_record(AvahiDnsPacket *p, AvahiRecord *r, gboolean cache_flush, guint max_ttl) { - guint8 *t, *l, *start; - guint size; +uint8_t* avahi_dns_packet_append_record(AvahiDnsPacket *p, AvahiRecord *r, int cache_flush, unsigned max_ttl) { + uint8_t *t, *l, *start; + size_t size; - g_assert(p); - g_assert(r); + assert(p); + assert(r); size = p->size; @@ -671,8 +687,8 @@ guint8* avahi_dns_packet_append_record(AvahiDnsPacket *p, AvahiRecord *r, gboole case AVAHI_DNS_TYPE_TXT: { - guint8 *data; - guint n; + uint8_t *data; + size_t n; n = avahi_string_list_serialize(r->data.txt.string_list, NULL, 0); @@ -713,11 +729,11 @@ guint8* avahi_dns_packet_append_record(AvahiDnsPacket *p, AvahiRecord *r, gboole size = avahi_dns_packet_extend(p, 0) - start; - g_assert(size <= 0xFFFF); + assert(size <= 0xFFFF); /* avahi_log_debug("appended %u", size); */ - * (guint16*) l = g_htons((guint16) size); + * (uint16_t*) l = htons((uint16_t) size); return t; @@ -727,16 +743,16 @@ fail: return NULL; } -gboolean avahi_dns_packet_is_empty(AvahiDnsPacket *p) { - g_assert(p); +int avahi_dns_packet_is_empty(AvahiDnsPacket *p) { + assert(p); return p->size <= AVAHI_DNS_PACKET_HEADER_SIZE; } -guint avahi_dns_packet_space(AvahiDnsPacket *p) { - g_assert(p); +size_t avahi_dns_packet_space(AvahiDnsPacket *p) { + assert(p); - g_assert(p->size <= p->max_size); + assert(p->size <= p->max_size); return p->max_size - p->size; } diff --git a/avahi-core/dns.h b/avahi-core/dns.h index bb132c1..9d93d33 100644 --- a/avahi-core/dns.h +++ b/avahi-core/dns.h @@ -22,59 +22,58 @@ USA. ***/ -#include <glib.h> - #include "rr.h" +#include "hashmap.h" #define AVAHI_DNS_PACKET_MAX_SIZE 9000 #define AVAHI_DNS_PACKET_HEADER_SIZE 12 #define AVAHI_DNS_PACKET_EXTRA_SIZE 48 typedef struct AvahiDnsPacket { - guint size, rindex, max_size; - GHashTable *name_table; /* for name compression */ + size_t size, rindex, max_size; + AvahiHashmap *name_table; /* for name compression */ } AvahiDnsPacket; -#define AVAHI_DNS_PACKET_DATA(p) (((guint8*) p) + sizeof(AvahiDnsPacket)) +#define AVAHI_DNS_PACKET_DATA(p) (((uint8_t*) p) + sizeof(AvahiDnsPacket)) -AvahiDnsPacket* avahi_dns_packet_new(guint mtu); -AvahiDnsPacket* avahi_dns_packet_new_query(guint mtu); -AvahiDnsPacket* avahi_dns_packet_new_response(guint mtu, gboolean aa); +AvahiDnsPacket* avahi_dns_packet_new(unsigned mtu); +AvahiDnsPacket* avahi_dns_packet_new_query(unsigned mtu); +AvahiDnsPacket* avahi_dns_packet_new_response(unsigned mtu, int aa); -AvahiDnsPacket* avahi_dns_packet_new_reply(AvahiDnsPacket* p, guint mtu, gboolean copy_queries, gboolean aa); +AvahiDnsPacket* avahi_dns_packet_new_reply(AvahiDnsPacket* p, unsigned mtu, int copy_queries, int aa); void avahi_dns_packet_free(AvahiDnsPacket *p); -void avahi_dns_packet_set_field(AvahiDnsPacket *p, guint idx, guint16 v); -guint16 avahi_dns_packet_get_field(AvahiDnsPacket *p, guint idx); -void avahi_dns_packet_inc_field(AvahiDnsPacket *p, guint idx); +void avahi_dns_packet_set_field(AvahiDnsPacket *p, unsigned idx, uint16_t v); +uint16_t avahi_dns_packet_get_field(AvahiDnsPacket *p, unsigned idx); +void avahi_dns_packet_inc_field(AvahiDnsPacket *p, unsigned idx); -guint8 *avahi_dns_packet_extend(AvahiDnsPacket *p, guint l); +uint8_t *avahi_dns_packet_extend(AvahiDnsPacket *p, unsigned l); -guint8 *avahi_dns_packet_append_uint16(AvahiDnsPacket *p, guint16 v); -guint8 *avahi_dns_packet_append_uint32(AvahiDnsPacket *p, guint32 v); -guint8 *avahi_dns_packet_append_name(AvahiDnsPacket *p, const gchar *name); -guint8 *avahi_dns_packet_append_bytes(AvahiDnsPacket *p, gconstpointer, guint l); -guint8* avahi_dns_packet_append_key(AvahiDnsPacket *p, AvahiKey *k, gboolean unicast_response); -guint8* avahi_dns_packet_append_record(AvahiDnsPacket *p, AvahiRecord *r, gboolean cache_flush, guint max_ttl); -guint8* avahi_dns_packet_append_string(AvahiDnsPacket *p, const gchar *s); +uint8_t *avahi_dns_packet_append_uint16(AvahiDnsPacket *p, uint16_t v); +uint8_t *avahi_dns_packet_append_uint32(AvahiDnsPacket *p, uint32_t v); +uint8_t *avahi_dns_packet_append_name(AvahiDnsPacket *p, const char *name); +uint8_t *avahi_dns_packet_append_bytes(AvahiDnsPacket *p, const void *d, size_t l); +uint8_t* avahi_dns_packet_append_key(AvahiDnsPacket *p, AvahiKey *k, int unicast_response); +uint8_t* avahi_dns_packet_append_record(AvahiDnsPacket *p, AvahiRecord *r, int cache_flush, unsigned max_ttl); +uint8_t* avahi_dns_packet_append_string(AvahiDnsPacket *p, const char *s); -gint avahi_dns_packet_is_query(AvahiDnsPacket *p); -gint avahi_dns_packet_check_valid(AvahiDnsPacket *p); +int avahi_dns_packet_is_query(AvahiDnsPacket *p); +int avahi_dns_packet_is_valid(AvahiDnsPacket *p); -gint avahi_dns_packet_consume_uint16(AvahiDnsPacket *p, guint16 *ret_v); -gint avahi_dns_packet_consume_uint32(AvahiDnsPacket *p, guint32 *ret_v); -gint avahi_dns_packet_consume_name(AvahiDnsPacket *p, gchar *ret_name, guint l); -gint avahi_dns_packet_consume_bytes(AvahiDnsPacket *p, gpointer ret_data, guint l); -AvahiKey* avahi_dns_packet_consume_key(AvahiDnsPacket *p, gboolean *ret_unicast_response); -AvahiRecord* avahi_dns_packet_consume_record(AvahiDnsPacket *p, gboolean *ret_cache_flush); -gint avahi_dns_packet_consume_string(AvahiDnsPacket *p, gchar *ret_string, guint l); +int avahi_dns_packet_consume_uint16(AvahiDnsPacket *p, uint16_t *ret_v); +int avahi_dns_packet_consume_uint32(AvahiDnsPacket *p, uint32_t *ret_v); +int avahi_dns_packet_consume_name(AvahiDnsPacket *p, char *ret_name, size_t l); +int avahi_dns_packet_consume_bytes(AvahiDnsPacket *p, void* ret_data, size_t l); +AvahiKey* avahi_dns_packet_consume_key(AvahiDnsPacket *p, int *ret_unicast_response); +AvahiRecord* avahi_dns_packet_consume_record(AvahiDnsPacket *p, int *ret_cache_flush); +int avahi_dns_packet_consume_string(AvahiDnsPacket *p, char *ret_string, size_t l); -gconstpointer avahi_dns_packet_get_rptr(AvahiDnsPacket *p); +const void* avahi_dns_packet_get_rptr(AvahiDnsPacket *p); -gint avahi_dns_packet_skip(AvahiDnsPacket *p, guint length); +int avahi_dns_packet_skip(AvahiDnsPacket *p, size_t length); -gboolean avahi_dns_packet_is_empty(AvahiDnsPacket *p); -guint avahi_dns_packet_space(AvahiDnsPacket *p); +int avahi_dns_packet_is_empty(AvahiDnsPacket *p); +size_t avahi_dns_packet_space(AvahiDnsPacket *p); #define AVAHI_DNS_FIELD_ID 0 #define AVAHI_DNS_FIELD_FLAGS 1 @@ -90,15 +89,15 @@ guint avahi_dns_packet_space(AvahiDnsPacket *p); #define AVAHI_DNS_FLAG_AA (1 << 10) #define AVAHI_DNS_FLAGS(qr, opcode, aa, tc, rd, ra, z, ad, cd, rcode) \ - (((guint16) !!qr << 15) | \ - ((guint16) (opcode & 15) << 11) | \ - ((guint16) !!aa << 10) | \ - ((guint16) !!tc << 9) | \ - ((guint16) !!rd << 8) | \ - ((guint16) !!ra << 7) | \ - ((guint16) !!ad << 5) | \ - ((guint16) !!cd << 4) | \ - ((guint16) (rd & 15))) + (((uint16_t) !!qr << 15) | \ + ((uint16_t) (opcode & 15) << 11) | \ + ((uint16_t) !!aa << 10) | \ + ((uint16_t) !!tc << 9) | \ + ((uint16_t) !!rd << 8) | \ + ((uint16_t) !!ra << 7) | \ + ((uint16_t) !!ad << 5) | \ + ((uint16_t) !!cd << 4) | \ + ((uint16_t) (rd & 15))) #endif diff --git a/avahi-core/hashmap.c b/avahi-core/hashmap.c index 0c44d4f..24df1f2 100644 --- a/avahi-core/hashmap.c +++ b/avahi-core/hashmap.c @@ -203,7 +203,6 @@ int avahi_hashmap_replace(AvahiHashmap *m, void *key, void *value) { return 0; } - void avahi_hashmap_remove(AvahiHashmap *m, const void *key) { Entry *e; @@ -215,6 +214,18 @@ void avahi_hashmap_remove(AvahiHashmap *m, const void *key) { entry_free(m, e, 0); } +void avahi_hashmap_foreach(AvahiHashmap *m, AvahiHashmapForeachCallback callback, void *userdata) { + Entry *e, *next; + assert(m); + assert(callback); + + for (e = m->entries_list; e; e = next) { + next = e->entries_next; + + callback(e->key, e->value, userdata); + } +} + unsigned avahi_string_hash(const void *data) { const char *p = data; unsigned hash = 0; @@ -231,19 +242,14 @@ int avahi_string_equal(const void *a, const void *b) { return strcmp(p, q) == 0; } -unsigned avahi_domain_hash(const void *data) { - unsigned hash = 0; - const char *s; - - for (;;) { - char c[65]; +unsigned avahi_int_hash(const void *data) { + const int *i = data; + + return (unsigned) *i; +} - if (!avahi_unescape_label(&s, c, sizeof(c))) - return hash; +int avahi_int_equal(const void *a, const void *b) { + const int *_a = a, *_b = b; - if (!c[0]) - continue; - - hash += avahi_string_hash(avahi_strdown(c)); - } + return *_a == *_b; } diff --git a/avahi-core/hashmap.h b/avahi-core/hashmap.h index c3000ba..f546dfc 100644 --- a/avahi-core/hashmap.h +++ b/avahi-core/hashmap.h @@ -37,14 +37,19 @@ AvahiHashmap* avahi_hashmap_new(AvahiHashFunc hash_func, AvahiEqualFunc equal_fu void avahi_hashmap_free(AvahiHashmap *m); void* avahi_hashmap_lookup(AvahiHashmap *m, const void *key); void* avahi_hashmap_steal(AvahiHashmap *m, const void *key); -int avahi_hashmap_insert(AvahiHashmap *m, void *key, void *data); -int avahi_hashmap_replace(AvahiHashmap *m, void *key, void *data); +int avahi_hashmap_insert(AvahiHashmap *m, void *key, void *value); +int avahi_hashmap_replace(AvahiHashmap *m, void *key, void *value); void avahi_hashmap_remove(AvahiHashmap *m, const void *key); +typedef void (*AvahiHashmapForeachCallback)(void *key, void *value, void *userdata); + +void avahi_hashmap_foreach(AvahiHashmap *m, AvahiHashmapForeachCallback callback, void *userdata); + unsigned avahi_string_hash(const void *data); int avahi_string_equal(const void *a, const void *b); -unsigned avahi_domain_hash(const void *data); +unsigned avahi_int_hash(const void *data); +int avahi_int_equal(const void *a, const void *b); AVAHI_C_DECL_END diff --git a/avahi-core/iface.c b/avahi-core/iface.c index 4376008..8671044 100644 --- a/avahi-core/iface.c +++ b/avahi-core/iface.c @@ -32,6 +32,8 @@ #include <net/if.h> #include <stdio.h> +#include <avahi-common/malloc.h> + #include "iface.h" #include "netlink.h" #include "dns.h" @@ -40,9 +42,9 @@ #include "util.h" #include "log.h" -static void update_address_rr(AvahiInterfaceMonitor *m, AvahiInterfaceAddress *a, gboolean remove_rrs) { - g_assert(m); - g_assert(a); +static void update_address_rr(AvahiInterfaceMonitor *m, AvahiInterfaceAddress *a, int remove_rrs) { + assert(m); + assert(a); if (avahi_interface_address_relevant(a) && !remove_rrs && @@ -54,10 +56,13 @@ static void update_address_rr(AvahiInterfaceMonitor *m, AvahiInterfaceAddress *a if (!a->entry_group) a->entry_group = avahi_entry_group_new(m->server, avahi_host_rr_entry_group_callback, NULL); + if (!a->entry_group) /* OOM */ + return; + if (avahi_entry_group_is_empty(a->entry_group)) { if (avahi_server_add_address(m->server, a->entry_group, a->interface->hardware->index, a->interface->protocol, 0, NULL, &a->address) < 0) { - avahi_log_warn(__FILE__": avahi_server_add_address() failed."); + avahi_log_warn(__FILE__": avahi_server_add_address() failed: %s", avahi_strerror(m->server->error)); avahi_entry_group_free(a->entry_group); a->entry_group = NULL; return; @@ -79,21 +84,21 @@ static void update_address_rr(AvahiInterfaceMonitor *m, AvahiInterfaceAddress *a } } -static void update_interface_rr(AvahiInterfaceMonitor *m, AvahiInterface *i, gboolean remove_rrs) { +static void update_interface_rr(AvahiInterfaceMonitor *m, AvahiInterface *i, int remove_rrs) { AvahiInterfaceAddress *a; - g_assert(m); - g_assert(i); + assert(m); + assert(i); for (a = i->addresses; a; a = a->address_next) update_address_rr(m, a, remove_rrs); } -static void update_hw_interface_rr(AvahiInterfaceMonitor *m, AvahiHwInterface *hw, gboolean remove_rrs) { +static void update_hw_interface_rr(AvahiInterfaceMonitor *m, AvahiHwInterface *hw, int remove_rrs) { AvahiInterface *i; - g_assert(m); - g_assert(hw); + assert(m); + assert(hw); for (i = hw->interfaces; i; i = i->by_hardware_next) update_interface_rr(m, i, remove_rrs); @@ -106,12 +111,21 @@ static void update_hw_interface_rr(AvahiInterfaceMonitor *m, AvahiHwInterface *h if (!hw->entry_group) hw->entry_group = avahi_entry_group_new(m->server, avahi_host_rr_entry_group_callback, NULL); + if (!hw->entry_group) + return; /* OOM */ + if (avahi_entry_group_is_empty(hw->entry_group)) { - gchar *name; - gchar *t = avahi_format_mac_address(hw->mac_address, hw->mac_address_size); - - name = g_strdup_printf("%s [%s]", m->server->host_name, t); - g_free(t); + char *name; + char *t; + + if (!(t = avahi_format_mac_address(hw->mac_address, hw->mac_address_size))) + return; /* OOM */ + + name = avahi_strdup_printf("%s [%s]", m->server->host_name, t); + avahi_free(t); + + if (!name) + return; /* OOM */ if (avahi_server_add_service(m->server, hw->entry_group, hw->index, AVAHI_PROTO_UNSPEC, name, "_workstation._tcp", NULL, NULL, 9, NULL) < 0) { avahi_log_warn(__FILE__": avahi_server_add_service() failed."); @@ -120,7 +134,7 @@ static void update_hw_interface_rr(AvahiInterfaceMonitor *m, AvahiHwInterface *h } else avahi_entry_group_commit(hw->entry_group); - g_free(name); + avahi_free(name); } } else { @@ -136,29 +150,29 @@ static void update_hw_interface_rr(AvahiInterfaceMonitor *m, AvahiHwInterface *h } static void free_address(AvahiInterfaceMonitor *m, AvahiInterfaceAddress *a) { - g_assert(m); - g_assert(a); - g_assert(a->interface); + assert(m); + assert(a); + assert(a->interface); - update_address_rr(m, a, TRUE); + update_address_rr(m, a, 1); AVAHI_LLIST_REMOVE(AvahiInterfaceAddress, address, a->interface->addresses, a); if (a->entry_group) avahi_entry_group_free(a->entry_group); - g_free(a); + avahi_free(a); } -static void free_interface(AvahiInterfaceMonitor *m, AvahiInterface *i, gboolean send_goodbye) { - g_assert(m); - g_assert(i); +static void free_interface(AvahiInterfaceMonitor *m, AvahiInterface *i, int send_goodbye) { + assert(m); + assert(i); avahi_goodbye_interface(m->server, i, send_goodbye); avahi_response_scheduler_force(i->response_scheduler); - g_assert(!i->announcements); + assert(!i->announcements); - update_interface_rr(m, i, TRUE); + update_interface_rr(m, i, 1); while (i->addresses) free_address(m, i->addresses); @@ -171,14 +185,14 @@ static void free_interface(AvahiInterfaceMonitor *m, AvahiInterface *i, gboolean AVAHI_LLIST_REMOVE(AvahiInterface, interface, m->interfaces, i); AVAHI_LLIST_REMOVE(AvahiInterface, by_hardware, i->hardware->interfaces, i); - g_free(i); + avahi_free(i); } -static void free_hw_interface(AvahiInterfaceMonitor *m, AvahiHwInterface *hw, gboolean send_goodbye) { - g_assert(m); - g_assert(hw); +static void free_hw_interface(AvahiInterfaceMonitor *m, AvahiHwInterface *hw, int send_goodbye) { + assert(m); + assert(hw); - update_hw_interface_rr(m, hw, TRUE); + update_hw_interface_rr(m, hw, 1); while (hw->interfaces) free_interface(m, hw->interfaces, send_goodbye); @@ -187,18 +201,18 @@ static void free_hw_interface(AvahiInterfaceMonitor *m, AvahiHwInterface *hw, gb avahi_entry_group_free(hw->entry_group); AVAHI_LLIST_REMOVE(AvahiHwInterface, hardware, m->hw_interfaces, hw); - g_hash_table_remove(m->hash_table, &hw->index); + avahi_hashmap_remove(m->hashmap, &hw->index); - g_free(hw->name); - g_free(hw); + avahi_free(hw->name); + avahi_free(hw); } static AvahiInterfaceAddress* get_address(AvahiInterfaceMonitor *m, AvahiInterface *i, const AvahiAddress *raddr) { AvahiInterfaceAddress *ia; - g_assert(m); - g_assert(i); - g_assert(raddr); + assert(m); + assert(i); + assert(raddr); for (ia = i->addresses; ia; ia = ia->address_next) if (avahi_address_cmp(&ia->address, raddr) == 0) @@ -207,10 +221,10 @@ static AvahiInterfaceAddress* get_address(AvahiInterfaceMonitor *m, AvahiInterfa return NULL; } -static int netlink_list_items(AvahiNetlink *nl, guint16 type, guint *ret_seq) { +static int netlink_list_items(AvahiNetlink *nl, uint16_t type, unsigned *ret_seq) { struct nlmsghdr *n; struct rtgenmsg *gen; - guint8 req[1024]; + uint8_t req[1024]; memset(&req, 0, sizeof(req)); n = (struct nlmsghdr*) req; @@ -229,15 +243,17 @@ static int netlink_list_items(AvahiNetlink *nl, guint16 type, guint *ret_seq) { static void new_interface(AvahiInterfaceMonitor *m, AvahiHwInterface *hw, AvahiProtocol protocol) { AvahiInterface *i; - g_assert(m); - g_assert(hw); - g_assert(protocol != AVAHI_PROTO_UNSPEC); + assert(m); + assert(hw); + assert(protocol != AVAHI_PROTO_UNSPEC); - i = g_new(AvahiInterface, 1); + if (!(i = avahi_new(AvahiInterface, 1))) + goto fail; /* OOM */ + i->monitor = m; i->hardware = hw; i->protocol = protocol; - i->announcing = FALSE; + i->announcing = 0; AVAHI_LLIST_HEAD_INIT(AvahiInterfaceAddress, i->addresses); AVAHI_LLIST_HEAD_INIT(AvahiAnnouncement, i->announcements); @@ -247,15 +263,33 @@ static void new_interface(AvahiInterfaceMonitor *m, AvahiHwInterface *hw, AvahiP i->query_scheduler = avahi_query_scheduler_new(i); i->probe_scheduler = avahi_probe_scheduler_new(i); + if (!i->cache || !i->response_scheduler || !i->query_scheduler || !i->probe_scheduler) + goto fail; /* OOM */ + AVAHI_LLIST_PREPEND(AvahiInterface, by_hardware, hw->interfaces, i); AVAHI_LLIST_PREPEND(AvahiInterface, interface, m->interfaces, i); + + return; +fail: + + if (i) { + if (i->cache) + avahi_cache_free(i->cache); + if (i->response_scheduler) + avahi_response_scheduler_free(i->response_scheduler); + if (i->query_scheduler) + avahi_query_scheduler_free(i->query_scheduler); + if (i->probe_scheduler) + avahi_probe_scheduler_free(i->probe_scheduler); + } + } static void check_interface_relevant(AvahiInterfaceMonitor *m, AvahiInterface *i) { - gboolean b; + int b; - g_assert(m); - g_assert(i); + assert(m); + assert(i); b = avahi_interface_relevant(i); @@ -267,7 +301,7 @@ static void check_interface_relevant(AvahiInterfaceMonitor *m, AvahiInterface *i if (i->protocol == AVAHI_PROTO_INET6) avahi_mdns_mcast_join_ipv6(m->server->fd_ipv6, i->hardware->index); - i->announcing = TRUE; + i->announcing = 1; avahi_announce_interface(m->server, i); avahi_browser_new_interface(m->server, i); } else if (!b && i->announcing) { @@ -278,32 +312,32 @@ static void check_interface_relevant(AvahiInterfaceMonitor *m, AvahiInterface *i if (i->protocol == AVAHI_PROTO_INET6) avahi_mdns_mcast_leave_ipv6(m->server->fd_ipv6, i->hardware->index); - avahi_goodbye_interface(m->server, i, FALSE); + avahi_goodbye_interface(m->server, i, 0); avahi_response_scheduler_clear(i->response_scheduler); avahi_query_scheduler_clear(i->query_scheduler); avahi_probe_scheduler_clear(i->probe_scheduler); avahi_cache_flush(i->cache); - i->announcing = FALSE; + i->announcing = 0; } } static void check_hw_interface_relevant(AvahiInterfaceMonitor *m, AvahiHwInterface *hw) { AvahiInterface *i; - g_assert(m); - g_assert(hw); + assert(m); + assert(hw); for (i = hw->interfaces; i; i = i->by_hardware_next) check_interface_relevant(m, i); } -static void netlink_callback(AvahiNetlink *nl, struct nlmsghdr *n, gpointer userdata) { +static void netlink_callback(AvahiNetlink *nl, struct nlmsghdr *n, void* userdata) { AvahiInterfaceMonitor *m = userdata; - g_assert(m); - g_assert(n); - g_assert(m->netlink == nl); + assert(m); + assert(n); + assert(m->netlink == nl); if (n->nlmsg_type == RTM_NEWLINK) { struct ifinfomsg *ifinfomsg = NLMSG_DATA(n); @@ -314,8 +348,11 @@ static void netlink_callback(AvahiNetlink *nl, struct nlmsghdr *n, gpointer user if (ifinfomsg->ifi_family != AF_UNSPEC) return; - if (!(hw = g_hash_table_lookup(m->hash_table, &ifinfomsg->ifi_index))) { - hw = g_new(AvahiHwInterface, 1); + if (!(hw = avahi_hashmap_lookup(m->hashmap, &ifinfomsg->ifi_index))) { + + if (!(hw = avahi_new(AvahiHwInterface, 1))) + return; /* OOM */ + hw->monitor = m; hw->name = NULL; hw->flags = 0; @@ -327,7 +364,7 @@ static void netlink_callback(AvahiNetlink *nl, struct nlmsghdr *n, gpointer user AVAHI_LLIST_HEAD_INIT(AvahiInterface, hw->interfaces); AVAHI_LLIST_PREPEND(AvahiHwInterface, hardware, m->hw_interfaces, hw); - g_hash_table_insert(m->hash_table, &hw->index, hw); + avahi_hashmap_insert(m->hashmap, &hw->index, hw); if (m->server->fd_ipv4 >= 0) new_interface(m, hw, AVAHI_PROTO_INET); @@ -343,12 +380,12 @@ static void netlink_callback(AvahiNetlink *nl, struct nlmsghdr *n, gpointer user while (RTA_OK(a, l)) { switch(a->rta_type) { case IFLA_IFNAME: - g_free(hw->name); - hw->name = g_strndup(RTA_DATA(a), RTA_PAYLOAD(a)); + avahi_free(hw->name); + hw->name = avahi_strndup(RTA_DATA(a), RTA_PAYLOAD(a)); break; case IFLA_MTU: - g_assert(RTA_PAYLOAD(a) == sizeof(unsigned int)); + assert(RTA_PAYLOAD(a) == sizeof(unsigned int)); hw->mtu = *((unsigned int*) RTA_DATA(a)); break; @@ -368,7 +405,7 @@ static void netlink_callback(AvahiNetlink *nl, struct nlmsghdr *n, gpointer user a = RTA_NEXT(a, l); } - update_hw_interface_rr(m, hw, FALSE); + update_hw_interface_rr(m, hw, 0); check_hw_interface_relevant(m, hw); } else if (n->nlmsg_type == RTM_DELLINK) { @@ -381,8 +418,8 @@ static void netlink_callback(AvahiNetlink *nl, struct nlmsghdr *n, gpointer user if (!(hw = avahi_interface_monitor_get_hw_interface(m, (AvahiIfIndex) ifinfomsg->ifi_index))) return; - update_hw_interface_rr(m, hw, TRUE); - free_hw_interface(m, hw, FALSE); + update_hw_interface_rr(m, hw, 1); + free_hw_interface(m, hw, 0); } else if (n->nlmsg_type == RTM_NEWADDR || n->nlmsg_type == RTM_DELADDR) { @@ -391,7 +428,7 @@ static void netlink_callback(AvahiNetlink *nl, struct nlmsghdr *n, gpointer user struct rtattr *a = NULL; size_t l; AvahiAddress raddr; - gboolean raddr_valid = FALSE; + int raddr_valid = 0; if (ifaddrmsg->ifa_family != AVAHI_PROTO_INET && ifaddrmsg->ifa_family != AVAHI_PROTO_INET6) return; @@ -413,7 +450,7 @@ static void netlink_callback(AvahiNetlink *nl, struct nlmsghdr *n, gpointer user return; memcpy(raddr.data.data, RTA_DATA(a), RTA_PAYLOAD(a)); - raddr_valid = TRUE; + raddr_valid = 1; break; @@ -431,7 +468,9 @@ static void netlink_callback(AvahiNetlink *nl, struct nlmsghdr *n, gpointer user AvahiInterfaceAddress *addr; if (!(addr = get_address(m, i, &raddr))) { - addr = g_new(AvahiInterfaceAddress, 1); + if (!(addr = avahi_new(AvahiInterfaceAddress, 1))) + return; /* OOM */ + addr->monitor = m; addr->address = raddr; addr->interface = i; @@ -444,14 +483,14 @@ static void netlink_callback(AvahiNetlink *nl, struct nlmsghdr *n, gpointer user addr->scope = ifaddrmsg->ifa_scope; addr->prefix_len = ifaddrmsg->ifa_prefixlen; - update_address_rr(m, addr, FALSE); + update_address_rr(m, addr, 0); } else { AvahiInterfaceAddress *addr; if (!(addr = get_address(m, i, &raddr))) return; - update_address_rr(m, addr, TRUE); + update_address_rr(m, addr, 1); free_address(m, addr); } @@ -482,12 +521,14 @@ static void netlink_callback(AvahiNetlink *nl, struct nlmsghdr *n, gpointer user AvahiInterfaceMonitor *avahi_interface_monitor_new(AvahiServer *s) { AvahiInterfaceMonitor *m = NULL; - m = g_new0(AvahiInterfaceMonitor, 1); + if (!(m = avahi_new0(AvahiInterfaceMonitor, 1))) + return NULL; /* OOM */ + m->server = s; - if (!(m->netlink = avahi_netlink_new(s->context, G_PRIORITY_DEFAULT-10, RTMGRP_LINK|RTMGRP_IPV4_IFADDR|RTMGRP_IPV6_IFADDR, netlink_callback, m))) + if (!(m->netlink = avahi_netlink_new(s->poll_api, RTMGRP_LINK|RTMGRP_IPV4_IFADDR|RTMGRP_IPV6_IFADDR, netlink_callback, m))) goto fail; - m->hash_table = g_hash_table_new(g_int_hash, g_int_equal); + m->hashmap = avahi_hashmap_new(avahi_int_hash, avahi_int_equal, NULL, NULL); AVAHI_LLIST_HEAD_INIT(AvahiInterface, m->interfaces); AVAHI_LLIST_HEAD_INIT(AvahiHwInterface, m->hw_interfaces); @@ -505,30 +546,30 @@ fail: } void avahi_interface_monitor_sync(AvahiInterfaceMonitor *m) { - g_assert(m); + assert(m); while (m->list != LIST_DONE) { - if (!avahi_netlink_work(m->netlink, TRUE)) + if (!avahi_netlink_work(m->netlink, 1)) break; } } void avahi_interface_monitor_free(AvahiInterfaceMonitor *m) { - g_assert(m); + assert(m); while (m->hw_interfaces) - free_hw_interface(m, m->hw_interfaces, TRUE); + free_hw_interface(m, m->hw_interfaces, 1); - g_assert(!m->interfaces); + assert(!m->interfaces); if (m->netlink) avahi_netlink_free(m->netlink); - if (m->hash_table) - g_hash_table_destroy(m->hash_table); + if (m->hashmap) + avahi_hashmap_free(m->hashmap); - g_free(m); + avahi_free(m); } @@ -536,9 +577,9 @@ AvahiInterface* avahi_interface_monitor_get_interface(AvahiInterfaceMonitor *m, AvahiHwInterface *hw; AvahiInterface *i; - g_assert(m); - g_assert(idx > 0); - g_assert(protocol != AVAHI_PROTO_UNSPEC); + assert(m); + assert(idx > 0); + assert(protocol != AVAHI_PROTO_UNSPEC); if (!(hw = avahi_interface_monitor_get_hw_interface(m, idx))) return NULL; @@ -551,22 +592,21 @@ AvahiInterface* avahi_interface_monitor_get_interface(AvahiInterfaceMonitor *m, } AvahiHwInterface* avahi_interface_monitor_get_hw_interface(AvahiInterfaceMonitor *m, AvahiIfIndex idx) { - g_assert(m); - g_assert(idx > 0); + assert(m); + assert(idx > 0); - return g_hash_table_lookup(m->hash_table, &idx); + return avahi_hashmap_lookup(m->hashmap, &idx); } - -void avahi_interface_send_packet_unicast(AvahiInterface *i, AvahiDnsPacket *p, const AvahiAddress *a, guint16 port) { - g_assert(i); - g_assert(p); +void avahi_interface_send_packet_unicast(AvahiInterface *i, AvahiDnsPacket *p, const AvahiAddress *a, uint16_t port) { + assert(i); + assert(p); /* char t[64]; */ if (!avahi_interface_relevant(i)) return; - g_assert(!a || a->family == i->protocol); + assert(!a || a->family == i->protocol); /* if (a) */ /* avahi_log_debug("unicast sending on '%s.%i' to %s:%u", i->hardware->name, i->protocol, avahi_address_snprint(t, sizeof(t), a), port); */ @@ -580,67 +620,70 @@ void avahi_interface_send_packet_unicast(AvahiInterface *i, AvahiDnsPacket *p, c } void avahi_interface_send_packet(AvahiInterface *i, AvahiDnsPacket *p) { - g_assert(i); - g_assert(p); + assert(i); + assert(p); avahi_interface_send_packet_unicast(i, p, NULL, 0); } -gboolean avahi_interface_post_query(AvahiInterface *i, AvahiKey *key, gboolean immediately) { - g_assert(i); - g_assert(key); +int avahi_interface_post_query(AvahiInterface *i, AvahiKey *key, int immediately) { + assert(i); + assert(key); if (avahi_interface_relevant(i)) return avahi_query_scheduler_post(i->query_scheduler, key, immediately); - return FALSE; + return 0; } -gboolean avahi_interface_post_response(AvahiInterface *i, AvahiRecord *record, gboolean flush_cache, const AvahiAddress *querier, gboolean immediately) { - g_assert(i); - g_assert(record); +int avahi_interface_post_response(AvahiInterface *i, AvahiRecord *record, int flush_cache, const AvahiAddress *querier, int immediately) { + assert(i); + assert(record); if (avahi_interface_relevant(i)) return avahi_response_scheduler_post(i->response_scheduler, record, flush_cache, querier, immediately); - return FALSE; + return 0; } -gboolean avahi_interface_post_probe(AvahiInterface *i, AvahiRecord *record, gboolean immediately) { - g_assert(i); - g_assert(record); +int avahi_interface_post_probe(AvahiInterface *i, AvahiRecord *record, int immediately) { + assert(i); + assert(record); if (avahi_interface_relevant(i)) return avahi_probe_scheduler_post(i->probe_scheduler, record, immediately); - return FALSE; + return 0; } -void avahi_dump_caches(AvahiInterfaceMonitor *m, AvahiDumpCallback callback, gpointer userdata) { +int avahi_dump_caches(AvahiInterfaceMonitor *m, AvahiDumpCallback callback, void* userdata) { AvahiInterface *i; - g_assert(m); + assert(m); for (i = m->interfaces; i; i = i->interface_next) { if (avahi_interface_relevant(i)) { char ln[256]; snprintf(ln, sizeof(ln), ";;; INTERFACE %s.%i ;;;", i->hardware->name, i->protocol); callback(ln, userdata); - avahi_cache_dump(i->cache, callback, userdata); + if (avahi_cache_dump(i->cache, callback, userdata) < 0) + return -1; } } + + return 0; } -gboolean avahi_interface_relevant(AvahiInterface *i) { +int avahi_interface_relevant(AvahiInterface *i) { AvahiInterfaceAddress *a; - gboolean relevant_address; + int relevant_address; - g_assert(i); + assert(i); - relevant_address = FALSE; + relevant_address = 0; for (a = i->addresses; a; a = a->address_next) if (avahi_interface_address_relevant(a)) { - relevant_address = TRUE; + relevant_address = 1; break; } @@ -660,28 +703,28 @@ gboolean avahi_interface_relevant(AvahiInterface *i) { relevant_address; } -gboolean avahi_interface_address_relevant(AvahiInterfaceAddress *a) { - g_assert(a); +int avahi_interface_address_relevant(AvahiInterfaceAddress *a) { + assert(a); return a->scope == RT_SCOPE_UNIVERSE; } -gboolean avahi_interface_match(AvahiInterface *i, AvahiIfIndex idx, AvahiProtocol protocol) { - g_assert(i); +int avahi_interface_match(AvahiInterface *i, AvahiIfIndex idx, AvahiProtocol protocol) { + assert(i); if (idx > 0 && idx != i->hardware->index) - return FALSE; + return 0; if (protocol != AVAHI_PROTO_UNSPEC && protocol != i->protocol) - return FALSE; + return 0; - return TRUE; + return 1; } -void avahi_interface_monitor_walk(AvahiInterfaceMonitor *m, AvahiIfIndex interface, AvahiProtocol protocol, AvahiInterfaceMonitorWalkCallback callback, gpointer userdata) { - g_assert(m); - g_assert(callback); +void avahi_interface_monitor_walk(AvahiInterfaceMonitor *m, AvahiIfIndex interface, AvahiProtocol protocol, AvahiInterfaceMonitorWalkCallback callback, void* userdata) { + assert(m); + assert(callback); if (interface > 0) { if (protocol != AVAHI_PROTO_UNSPEC) { @@ -709,59 +752,59 @@ void avahi_interface_monitor_walk(AvahiInterfaceMonitor *m, AvahiIfIndex interfa } } -void avahi_update_host_rrs(AvahiInterfaceMonitor *m, gboolean remove_rrs) { +void avahi_update_host_rrs(AvahiInterfaceMonitor *m, int remove_rrs) { AvahiHwInterface *hw; - g_assert(m); + assert(m); for (hw = m->hw_interfaces; hw; hw = hw->hardware_next) update_hw_interface_rr(m, hw, remove_rrs); } -gboolean avahi_address_is_local(AvahiInterfaceMonitor *m, const AvahiAddress *a) { +int avahi_address_is_local(AvahiInterfaceMonitor *m, const AvahiAddress *a) { AvahiInterface *i; AvahiInterfaceAddress *ia; - g_assert(m); - g_assert(a); + assert(m); + assert(a); for (i = m->interfaces; i; i = i->interface_next) for (ia = i->addresses; ia; ia = ia->address_next) if (avahi_address_cmp(a, &ia->address) == 0) - return TRUE; + return 1; - return FALSE; + return 0; } -gboolean avahi_interface_address_on_link(AvahiInterface *i, const AvahiAddress *a) { +int avahi_interface_address_on_link(AvahiInterface *i, const AvahiAddress *a) { AvahiInterfaceAddress *ia; - g_assert(i); - g_assert(a); + assert(i); + assert(a); if (a->family != i->protocol) - return FALSE; + return 0; for (ia = i->addresses; ia; ia = ia->address_next) { if (a->family == AVAHI_PROTO_INET) { - guint32 m; + uint32_t m; - m = ~(((guint32) -1) >> ia->prefix_len); + m = ~(((uint32_t) -1) >> ia->prefix_len); - if ((g_ntohl(a->data.ipv4.address) & m) == (g_ntohl(ia->address.data.ipv4.address) & m)) - return TRUE; + if ((ntohl(a->data.ipv4.address) & m) == (ntohl(ia->address.data.ipv4.address) & m)) + return 1; } else { - guint j; - guchar pl; - g_assert(a->family == AVAHI_PROTO_INET6); + unsigned j; + unsigned char pl; + assert(a->family == AVAHI_PROTO_INET6); pl = ia->prefix_len; for (j = 0; j < 16; j++) { - guint8 m; + uint8_t m; if (pl == 0) - return TRUE; + return 1; if (pl >= 8) { m = 0xFF; @@ -777,5 +820,5 @@ gboolean avahi_interface_address_on_link(AvahiInterface *i, const AvahiAddress * } } - return FALSE; + return 0; } diff --git a/avahi-core/iface.h b/avahi-core/iface.h index 47c54ba..627e13d 100644 --- a/avahi-core/iface.h +++ b/avahi-core/iface.h @@ -22,8 +22,6 @@ USA. ***/ -#include <glib.h> - typedef struct AvahiInterfaceMonitor AvahiInterfaceMonitor; typedef struct AvahiInterfaceAddress AvahiInterfaceAddress; typedef struct AvahiInterface AvahiInterface; @@ -31,6 +29,7 @@ typedef struct AvahiHwInterface AvahiHwInterface; #include <avahi-common/llist.h> #include <avahi-common/address.h> + #include "server.h" #include "netlink.h" #include "cache.h" @@ -45,12 +44,12 @@ typedef struct AvahiHwInterface AvahiHwInterface; struct AvahiInterfaceMonitor { AvahiServer *server; AvahiNetlink *netlink; - GHashTable *hash_table; + AvahiHashmap *hashmap; AVAHI_LLIST_HEAD(AvahiInterface, interfaces); AVAHI_LLIST_HEAD(AvahiHwInterface, hw_interfaces); - guint query_addr_seq, query_link_seq; + unsigned query_addr_seq, query_link_seq; enum { LIST_IFACE, @@ -63,13 +62,13 @@ struct AvahiHwInterface { AVAHI_LLIST_FIELDS(AvahiHwInterface, hardware); AvahiInterfaceMonitor *monitor; - gchar *name; + char *name; AvahiIfIndex index; - guint flags; - guint mtu; + unsigned flags; + unsigned mtu; - guint8 mac_address[AVAHI_MAX_MAC_ADDRESS]; - guint mac_address_size; + uint8_t mac_address[AVAHI_MAX_MAC_ADDRESS]; + size_t mac_address_size; AvahiEntryGroup *entry_group; @@ -83,7 +82,7 @@ struct AvahiInterface { AvahiHwInterface *hardware; AvahiProtocol protocol; - gboolean announcing; + int announcing; AvahiCache *cache; AvahiQueryScheduler *query_scheduler; @@ -98,9 +97,9 @@ struct AvahiInterfaceAddress { AVAHI_LLIST_FIELDS(AvahiInterfaceAddress, address); AvahiInterfaceMonitor *monitor; - guchar flags; - guchar scope; - guchar prefix_len; + unsigned char flags; + unsigned char scope; + unsigned char prefix_len; AvahiAddress address; AvahiEntryGroup *entry_group; @@ -113,31 +112,30 @@ void avahi_interface_monitor_free(AvahiInterfaceMonitor *m); void avahi_interface_monitor_sync(AvahiInterfaceMonitor *m); AvahiInterface* avahi_interface_monitor_get_interface(AvahiInterfaceMonitor *m, AvahiIfIndex idx, AvahiProtocol protocol); -AvahiHwInterface* avahi_interface_monitor_get_hw_interface(AvahiInterfaceMonitor *m, gint idx); +AvahiHwInterface* avahi_interface_monitor_get_hw_interface(AvahiInterfaceMonitor *m, int idx); void avahi_interface_send_packet(AvahiInterface *i, AvahiDnsPacket *p); -void avahi_interface_send_packet_unicast(AvahiInterface *i, AvahiDnsPacket *p, const AvahiAddress *a, guint16 port); +void avahi_interface_send_packet_unicast(AvahiInterface *i, AvahiDnsPacket *p, const AvahiAddress *a, uint16_t port); -gboolean avahi_interface_post_query(AvahiInterface *i, AvahiKey *k, gboolean immediately); -gboolean avahi_interface_post_response(AvahiInterface *i, AvahiRecord *record, gboolean flush_cache, const AvahiAddress *querier, gboolean immediately); -gboolean avahi_interface_post_probe(AvahiInterface *i, AvahiRecord *p, gboolean immediately); +int avahi_interface_post_query(AvahiInterface *i, AvahiKey *k, int immediately); +int avahi_interface_post_response(AvahiInterface *i, AvahiRecord *record, int flush_cache, const AvahiAddress *querier, int immediately); +int avahi_interface_post_probe(AvahiInterface *i, AvahiRecord *p, int immediately); -void avahi_dump_caches(AvahiInterfaceMonitor *m, AvahiDumpCallback callback, gpointer userdata); +int avahi_dump_caches(AvahiInterfaceMonitor *m, AvahiDumpCallback callback, void* userdata); -gboolean avahi_interface_relevant(AvahiInterface *i); -gboolean avahi_interface_address_relevant(AvahiInterfaceAddress *a); +int avahi_interface_relevant(AvahiInterface *i); +int avahi_interface_address_relevant(AvahiInterfaceAddress *a); -gboolean avahi_interface_match(AvahiInterface *i, AvahiIfIndex idx, AvahiProtocol protocol); +int avahi_interface_match(AvahiInterface *i, AvahiIfIndex idx, AvahiProtocol protocol); -typedef void (*AvahiInterfaceMonitorWalkCallback)(AvahiInterfaceMonitor *m, AvahiInterface *i, gpointer userdata); +typedef void (*AvahiInterfaceMonitorWalkCallback)(AvahiInterfaceMonitor *m, AvahiInterface *i, void* userdata); -void avahi_interface_monitor_walk(AvahiInterfaceMonitor *m, AvahiIfIndex idx, AvahiProtocol protocol, AvahiInterfaceMonitorWalkCallback callback, gpointer userdata); - -void avahi_update_host_rrs(AvahiInterfaceMonitor *m, gboolean remove_rrs); +void avahi_interface_monitor_walk(AvahiInterfaceMonitor *m, AvahiIfIndex idx, AvahiProtocol protocol, AvahiInterfaceMonitorWalkCallback callback, void* userdata); -gboolean avahi_address_is_local(AvahiInterfaceMonitor *m, const AvahiAddress *a); +void avahi_update_host_rrs(AvahiInterfaceMonitor *m, int remove_rrs); -gboolean avahi_interface_address_on_link(AvahiInterface *i, const AvahiAddress *a); +int avahi_address_is_local(AvahiInterfaceMonitor *m, const AvahiAddress *a); +int avahi_interface_address_on_link(AvahiInterface *i, const AvahiAddress *a); #endif diff --git a/avahi-core/log.c b/avahi-core/log.c index 09b87da..bfd4021 100644 --- a/avahi-core/log.c +++ b/avahi-core/log.c @@ -34,7 +34,7 @@ void avahi_set_log_function(AvahiLogFunction function) { log_function = function; } -void avahi_log_ap(AvahiLogLevel level, const gchar*format, va_list ap) { +void avahi_log_ap(AvahiLogLevel level, const char*format, va_list ap) { char txt[256]; vsnprintf(txt, sizeof(txt), format, ap); @@ -45,42 +45,42 @@ void avahi_log_ap(AvahiLogLevel level, const gchar*format, va_list ap) { fprintf(stderr, "%s\n", txt); } -void avahi_log(AvahiLogLevel level, const gchar*format, ...) { +void avahi_log(AvahiLogLevel level, const char*format, ...) { va_list ap; va_start(ap, format); avahi_log_ap(level, format, ap); va_end(ap); } -void avahi_log_error(const gchar*format, ...) { +void avahi_log_error(const char*format, ...) { va_list ap; va_start(ap, format); avahi_log_ap(AVAHI_LOG_ERROR, format, ap); va_end(ap); } -void avahi_log_warn(const gchar*format, ...) { +void avahi_log_warn(const char*format, ...) { va_list ap; va_start(ap, format); avahi_log_ap(AVAHI_LOG_WARN, format, ap); va_end(ap); } -void avahi_log_notice(const gchar*format, ...) { +void avahi_log_notice(const char*format, ...) { va_list ap; va_start(ap, format); avahi_log_ap(AVAHI_LOG_NOTICE, format, ap); va_end(ap); } -void avahi_log_info(const gchar*format, ...) { +void avahi_log_info(const char*format, ...) { va_list ap; va_start(ap, format); avahi_log_ap(AVAHI_LOG_INFO, format, ap); va_end(ap); } -void avahi_log_debug(const gchar*format, ...) { +void avahi_log_debug(const char*format, ...) { va_list ap; va_start(ap, format); avahi_log_ap(AVAHI_LOG_DEBUG, format, ap); diff --git a/avahi-core/log.h b/avahi-core/log.h index 064e418..bb32ccc 100644 --- a/avahi-core/log.h +++ b/avahi-core/log.h @@ -23,23 +23,14 @@ ***/ #include <stdarg.h> -#include <glib.h> + #include <avahi-common/cdecl.h> +#include <avahi-common/gccmacro.h> /** \file log.h Extensible logging subsystem */ AVAHI_C_DECL_BEGIN -#ifdef __GNUC__ -#define AVAHI_GCC_PRINTF_ATTR(a,b) __attribute__ ((format (printf, a, b))) -#else -/** Macro for usage of GCC's printf compilation warnings */ -#define AVAHI_GCC_PRINTF_ATTR(a,b) -#endif - -#define AVAHI_GCC_PRINTF_ATTR12 AVAHI_GCC_PRINTF_ATTR(1,2) -#define AVAHI_GCC_PRINTF_ATTR23 AVAHI_GCC_PRINTF_ATTR(2,3) - /** Log level for avahi_log_xxx() */ typedef enum { AVAHI_LOG_ERROR = 0, /**< Error messages */ @@ -51,7 +42,7 @@ typedef enum { } AvahiLogLevel; /** Prototype for a user supplied log function */ -typedef void (*AvahiLogFunction)(AvahiLogLevel level, const gchar *txt); +typedef void (*AvahiLogFunction)(AvahiLogLevel level, const char *txt); /** Set a user supplied log function, replacing the default which * prints to log messages unconditionally to STDERR. Pass NULL for @@ -59,25 +50,26 @@ typedef void (*AvahiLogFunction)(AvahiLogLevel level, const gchar *txt); void avahi_set_log_function(AvahiLogFunction function); /** Issue a log message using a va_list object */ -void avahi_log_ap(AvahiLogLevel level, const gchar *format, va_list ap); +void avahi_log_ap(AvahiLogLevel level, const char *format, va_list ap); /** Issue a log message by passing a log level and a format string */ -void avahi_log(AvahiLogLevel level, const gchar*format, ...) AVAHI_GCC_PRINTF_ATTR23; +void avahi_log(AvahiLogLevel level, const char*format, ...) AVAHI_GCC_PRINTF_ATTR23; /** Shortcut for avahi_log(AVAHI_LOG_ERROR, ...) */ -void avahi_log_error(const gchar*format, ...) AVAHI_GCC_PRINTF_ATTR12; +void avahi_log_error(const char*format, ...) AVAHI_GCC_PRINTF_ATTR12; /** Shortcut for avahi_log(AVAHI_LOG_WARN, ...) */ -void avahi_log_warn(const gchar*format, ...) AVAHI_GCC_PRINTF_ATTR12; +void avahi_log_warn(const char*format, ...) AVAHI_GCC_PRINTF_ATTR12; /** Shortcut for avahi_log(AVAHI_LOG_NOTICE, ...) */ -void avahi_log_notice(const gchar*format, ...) AVAHI_GCC_PRINTF_ATTR12; +void avahi_log_notice(const char*format, ...) AVAHI_GCC_PRINTF_ATTR12; /** Shortcut for avahi_log(AVAHI_LOG_INFO, ...) */ -void avahi_log_info(const gchar*format, ...) AVAHI_GCC_PRINTF_ATTR12; +void avahi_log_info(const char*format, ...) AVAHI_GCC_PRINTF_ATTR12; /** Shortcut for avahi_log(AVAHI_LOG_DEBUG, ...) */ -void avahi_log_debug(const gchar*format, ...) AVAHI_GCC_PRINTF_ATTR12; +void avahi_log_debug(const char*format, ...) AVAHI_GCC_PRINTF_ATTR12; + AVAHI_C_DECL_END diff --git a/avahi-core/netlink.c b/avahi-core/netlink.c index 119e195..92d614f 100644 --- a/avahi-core/netlink.c +++ b/avahi-core/netlink.c @@ -27,24 +27,26 @@ #include <errno.h> #include <string.h> #include <sys/ioctl.h> +#include <assert.h> +#include <avahi-common/malloc.h> #include "netlink.h" #include "log.h" struct AvahiNetlink { - GMainContext *context; - gint fd; - guint seq; - GPollFD poll_fd; - GSource *source; - void (*callback) (AvahiNetlink *nl, struct nlmsghdr *n, gpointer userdata); - gpointer userdata; - guint8* buffer; - guint buffer_length; + int fd; + unsigned seq; + AvahiNetlinkCallback callback; + void* userdata; + uint8_t* buffer; + size_t buffer_length; + + AvahiPoll *poll_api; + AvahiWatch *watch; }; -gboolean avahi_netlink_work(AvahiNetlink *nl, gboolean block) { - g_assert(nl); +int avahi_netlink_work(AvahiNetlink *nl, int block) { + assert(nl); for (;;) { ssize_t bytes; @@ -54,10 +56,10 @@ gboolean avahi_netlink_work(AvahiNetlink *nl, gboolean block) { if ((bytes = recv(nl->fd, nl->buffer, nl->buffer_length, block ? 0 : MSG_DONTWAIT)) < 0) { if (errno == EAGAIN || errno == EINTR) - return TRUE; + return 1; - avahi_log_warn("NETLINK: recv() failed: %s", strerror(errno)); - return FALSE; + avahi_log_error(__FILE__": recv() failed: %s", strerror(errno)); + return 0; } break; @@ -68,8 +70,8 @@ gboolean avahi_netlink_work(AvahiNetlink *nl, gboolean block) { if (nl->callback) { for (; bytes > 0; p = NLMSG_NEXT(p, bytes)) { if (!NLMSG_OK(p, (size_t) bytes)) { - avahi_log_warn("NETLINK: packet truncated"); - return FALSE; + avahi_log_warn(__FILE__": packet truncated"); + return 0; } nl->callback(nl, p, nl->userdata); @@ -77,56 +79,30 @@ gboolean avahi_netlink_work(AvahiNetlink *nl, gboolean block) { } if (block) - return TRUE; + return 1; } } -static gboolean prepare_func(GSource *source, gint *timeout) { - g_assert(source); - g_assert(timeout); - - *timeout = -1; - return FALSE; -} - -static gboolean check_func(GSource *source) { - AvahiNetlink* nl; - g_assert(source); +static void socket_event(AvahiWatch *w, int fd, AvahiWatchEvent event, void *userdata) { + AvahiNetlink *nl = userdata; - nl = *((AvahiNetlink**) (((guint8*) source) + sizeof(GSource))); - g_assert(nl); - - return nl->poll_fd.revents & (G_IO_IN|G_IO_HUP|G_IO_ERR); -} + assert(w); + assert(nl); + assert(fd == nl->fd); -static gboolean dispatch_func(GSource *source, GSourceFunc callback, gpointer user_data) { - AvahiNetlink* nl; - g_assert(source); - - nl = *((AvahiNetlink**) (((guint8*) source) + sizeof(GSource))); - g_assert(nl); - - return avahi_netlink_work(nl, FALSE); + avahi_netlink_work(nl, 0); } -AvahiNetlink *avahi_netlink_new(GMainContext *context, gint priority, guint32 groups, void (*cb) (AvahiNetlink *nl, struct nlmsghdr *n, gpointer userdata), gpointer userdata) { - int fd; +AvahiNetlink *avahi_netlink_new(AvahiPoll *poll_api, uint32_t groups, void (*cb) (AvahiNetlink *nl, struct nlmsghdr *n, void* userdata), void* userdata) { + int fd = -1; struct sockaddr_nl addr; - AvahiNetlink *nl; - - static GSourceFuncs source_funcs = { - prepare_func, - check_func, - dispatch_func, - NULL, - NULL, - NULL - }; - - g_assert(cb); + AvahiNetlink *nl = NULL; + + assert(poll_api); + assert(cb); if ((fd = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_ROUTE)) < 0) { - g_critical("NETLINK: socket(PF_NETLINK): %s", strerror(errno)); + avahi_log_error(__FILE__": socket(PF_NETLINK): %s", strerror(errno)); return NULL; } @@ -136,54 +112,70 @@ AvahiNetlink *avahi_netlink_new(GMainContext *context, gint priority, guint32 gr addr.nl_pid = getpid(); if (bind(fd, (struct sockaddr *) &addr, sizeof(addr)) < 0) { - close(fd); - g_critical("bind(): %s", strerror(errno)); - return NULL; + avahi_log_error(__FILE__": bind(): %s", strerror(errno)); + goto fail; + } + + if (!(nl = avahi_new(AvahiNetlink, 1))) { + avahi_log_error(__FILE__": avahi_new() failed."); + goto fail; } - nl = g_new(AvahiNetlink, 1); - g_main_context_ref(nl->context = context ? context : g_main_context_default()); + nl->poll_api = poll_api; nl->fd = fd; nl->seq = 0; nl->callback = cb; nl->userdata = userdata; - nl->buffer = g_new(guint8, nl->buffer_length = 64*1024); - nl->source = g_source_new(&source_funcs, sizeof(GSource) + sizeof(AvahiNetlink*)); - *((AvahiNetlink**) (((guint8*) nl->source) + sizeof(GSource))) = nl; + if (!(nl->buffer = avahi_new(uint8_t, nl->buffer_length = 64*1024))) { + avahi_log_error(__FILE__": avahi_new() failed."); + goto fail; + } - g_source_set_priority(nl->source, priority); - - memset(&nl->poll_fd, 0, sizeof(GPollFD)); - nl->poll_fd.fd = fd; - nl->poll_fd.events = G_IO_IN|G_IO_ERR|G_IO_HUP; - g_source_add_poll(nl->source, &nl->poll_fd); - - g_source_attach(nl->source, nl->context); + if (!(nl->watch = poll_api->watch_new(poll_api, fd, AVAHI_WATCH_IN, socket_event, nl))) { + avahi_log_error(__FILE__": Failed to create watch."); + goto fail; + } return nl; + +fail: + + if (fd >= 0) + close(fd); + + if (nl) { + if (nl->buffer) + avahi_free(nl); + + avahi_free(nl); + } + + return NULL; } void avahi_netlink_free(AvahiNetlink *nl) { - g_assert(nl); - - g_source_destroy(nl->source); - g_source_unref(nl->source); - g_main_context_unref(nl->context); - close(nl->fd); - g_free(nl->buffer); - g_free(nl); + assert(nl); + + if (nl->watch) + nl->poll_api->watch_free(nl->watch); + + if (nl->fd >= 0) + close(nl->fd); + + avahi_free(nl->buffer); + avahi_free(nl); } -int avahi_netlink_send(AvahiNetlink *nl, struct nlmsghdr *m, guint *ret_seq) { - g_assert(nl); - g_assert(m); +int avahi_netlink_send(AvahiNetlink *nl, struct nlmsghdr *m, unsigned *ret_seq) { + assert(nl); + assert(m); m->nlmsg_seq = nl->seq++; m->nlmsg_flags |= NLM_F_ACK; if (send(nl->fd, m, m->nlmsg_len, 0) < 0) { - avahi_log_warn("NETLINK: send(): %s\n", strerror(errno)); + avahi_log_error(__FILE__": send(): %s\n", strerror(errno)); return -1; } diff --git a/avahi-core/netlink.h b/avahi-core/netlink.h index 748eb5d..4768b6e 100644 --- a/avahi-core/netlink.h +++ b/avahi-core/netlink.h @@ -26,15 +26,15 @@ #include <asm/types.h> #include <linux/netlink.h> -#include <glib.h> +#include <avahi-common/watch.h> typedef struct AvahiNetlink AvahiNetlink; -AvahiNetlink *avahi_netlink_new(GMainContext *c, gint priority, guint32 groups, void (*cb) (AvahiNetlink *n, struct nlmsghdr *m, gpointer userdata), gpointer userdata); -void avahi_netlink_free(AvahiNetlink *n); - -int avahi_netlink_send(AvahiNetlink *n, struct nlmsghdr *m, guint *ret_seq); +typedef void (*AvahiNetlinkCallback)(AvahiNetlink *n, struct nlmsghdr *m, void* userdata); -gboolean avahi_netlink_work(AvahiNetlink *n, gboolean block); +AvahiNetlink *avahi_netlink_new(AvahiPoll *poll_api, uint32_t groups, AvahiNetlinkCallback callback, void* userdata); +void avahi_netlink_free(AvahiNetlink *n); +int avahi_netlink_send(AvahiNetlink *n, struct nlmsghdr *m, unsigned *ret_seq); +int avahi_netlink_work(AvahiNetlink *n, int block); #endif diff --git a/avahi-core/prioq-test.c b/avahi-core/prioq-test.c index 28c734b..0e43702 100644 --- a/avahi-core/prioq-test.c +++ b/avahi-core/prioq-test.c @@ -26,16 +26,20 @@ #include <time.h> #include <stdlib.h> #include <stdio.h> +#include <assert.h> #include "prioq.h" -static gint compare_int(gconstpointer a, gconstpointer b) { - gint i = GPOINTER_TO_INT(a), j = GPOINTER_TO_INT(b); +#define POINTER_TO_INT(p) ((int) (p)) +#define INT_TO_POINTER(i) ((void*) (i)) + +static int compare_int(const void* a, const void* b) { + int i = POINTER_TO_INT(a), j = POINTER_TO_INT(b); return i < j ? -1 : (i > j ? 1 : 0); } -static int compare_ptr(gconstpointer a, gconstpointer b) { +static int compare_ptr(const void* a, const void* b) { return a < b ? -1 : (a > b ? 1 : 0); } @@ -44,28 +48,28 @@ static void rec(AvahiPrioQueueNode *n) { return; if (n->left) - g_assert(n->left->parent == n); + assert(n->left->parent == n); if (n->right) - g_assert(n->right->parent == n); + assert(n->right->parent == n); if (n->parent) { - g_assert(n->parent->left == n || n->parent->right == n); + assert(n->parent->left == n || n->parent->right == n); if (n->parent->left == n) - g_assert(n->next == n->parent->right); + assert(n->next == n->parent->right); } if (!n->next) { - g_assert(n->queue->last == n); + assert(n->queue->last == n); if (n->parent && n->parent->left == n) - g_assert(n->parent->right == NULL); + assert(n->parent->right == NULL); } if (n->parent) { - int a = GPOINTER_TO_INT(n->parent->data), b = GPOINTER_TO_INT(n->data); + int a = POINTER_TO_INT(n->parent->data), b = POINTER_TO_INT(n->data); if (a > b) { printf("%i <= %i: NO\n", a, b); abort(); @@ -78,7 +82,7 @@ static void rec(AvahiPrioQueueNode *n) { int main(int argc, char *argv[]) { AvahiPrioQueue *q, *q2; - gint i; + int i; q = avahi_prio_queue_new(compare_int); q2 = avahi_prio_queue_new(compare_ptr); @@ -86,15 +90,15 @@ int main(int argc, char *argv[]) { srand(time(NULL)); for (i = 0; i < 10000; i++) - avahi_prio_queue_put(q2, avahi_prio_queue_put(q, GINT_TO_POINTER(random() & 0xFFFF))); + avahi_prio_queue_put(q2, avahi_prio_queue_put(q, INT_TO_POINTER(random() & 0xFFFF))); while (q2->root) { rec(q->root); rec(q2->root); - g_assert(q->n_nodes == q2->n_nodes); + assert(q->n_nodes == q2->n_nodes); - printf("%i\n", GPOINTER_TO_INT(((AvahiPrioQueueNode*)q2->root->data)->data)); + printf("%i\n", POINTER_TO_INT(((AvahiPrioQueueNode*)q2->root->data)->data)); avahi_prio_queue_remove(q, q2->root->data); avahi_prio_queue_remove(q2, q2->root); @@ -103,11 +107,11 @@ int main(int argc, char *argv[]) { /* prev = 0; */ /* while (q->root) { */ -/* gint v = GPOINTER_TO_INT(q->root->data); */ +/* int v = GPOINTER_TO_INT(q->root->data); */ /* rec(q->root); */ /* printf("%i\n", v); */ /* avahi_prio_queue_remove(q, q->root); */ -/* g_assert(v >= prev); */ +/* assert(v >= prev); */ /* prev = v; */ /* } */ diff --git a/avahi-core/prioq.c b/avahi-core/prioq.c index ba98d20..8d91d87 100644 --- a/avahi-core/prioq.c +++ b/avahi-core/prioq.c @@ -23,39 +23,47 @@ #include <config.h> #endif +#include <assert.h> +#include <stdlib.h> + +#include <avahi-common/malloc.h> + #include "prioq.h" -AvahiPrioQueue* avahi_prio_queue_new(gint (*compare) (gconstpointer a, gconstpointer b)) { +AvahiPrioQueue* avahi_prio_queue_new(AvahiPQCompareFunc compare) { AvahiPrioQueue *q; - g_assert(compare); + assert(compare); - q = g_new(AvahiPrioQueue, 1); + if (!(q = avahi_new(AvahiPrioQueue, 1))) + return NULL; /* OOM */ + q->root = q->last = NULL; q->n_nodes = 0; q->compare = compare; + return q; } void avahi_prio_queue_free(AvahiPrioQueue *q) { - g_assert(q); + assert(q); while (q->last) avahi_prio_queue_remove(q, q->last); - g_assert(!q->n_nodes); - g_free(q); + assert(!q->n_nodes); + avahi_free(q); } -static AvahiPrioQueueNode* get_node_at_xy(AvahiPrioQueue *q, guint x, guint y) { - guint r; +static AvahiPrioQueueNode* get_node_at_xy(AvahiPrioQueue *q, unsigned x, unsigned y) { + unsigned r; AvahiPrioQueueNode *n; - g_assert(q); + assert(q); n = q->root; - g_assert(n); + assert(n); for (r = 0; r < y; r++) { - g_assert(n); + assert(n); if ((x >> (y-r-1)) & 1) n = n->right; @@ -63,19 +71,19 @@ static AvahiPrioQueueNode* get_node_at_xy(AvahiPrioQueue *q, guint x, guint y) { n = n->left; } - g_assert(n->x == x); - g_assert(n->y == y); + assert(n->x == x); + assert(n->y == y); return n; } static void exchange_nodes(AvahiPrioQueue *q, AvahiPrioQueueNode *a, AvahiPrioQueueNode *b) { AvahiPrioQueueNode *l, *r, *p, *ap, *an, *bp, *bn; - gint t; - g_assert(q); - g_assert(a); - g_assert(b); - g_assert(a != b); + unsigned t; + assert(q); + assert(a); + assert(b); + assert(a != b); /* Swap positions */ t = a->x; a->x = b->x; b->x = t; @@ -250,8 +258,9 @@ static void exchange_nodes(AvahiPrioQueue *q, AvahiPrioQueueNode *a, AvahiPrioQu /* Move a node to the correct position */ void avahi_prio_queue_shuffle(AvahiPrioQueue *q, AvahiPrioQueueNode *n) { - g_assert(q); - g_assert(n); + assert(q); + assert(n); + assert(n->queue == q); /* Move up until the position is OK */ while (n->parent && q->compare(n->parent->data, n->data) > 0) @@ -263,7 +272,7 @@ void avahi_prio_queue_shuffle(AvahiPrioQueue *q, AvahiPrioQueueNode *n) { if (!(min = n->left)) { /* No children */ - g_assert(!n->right); + assert(!n->right); break; } @@ -280,22 +289,24 @@ void avahi_prio_queue_shuffle(AvahiPrioQueue *q, AvahiPrioQueueNode *n) { } } -AvahiPrioQueueNode* avahi_prio_queue_put(AvahiPrioQueue *q, gpointer data) { +AvahiPrioQueueNode* avahi_prio_queue_put(AvahiPrioQueue *q, void* data) { AvahiPrioQueueNode *n; - g_assert(q); + assert(q); - n = g_new(AvahiPrioQueueNode, 1); + if (!(n = avahi_new(AvahiPrioQueueNode, 1))) + return NULL; /* OOM */ + n->queue = q; n->data = data; if (q->last) { - g_assert(q->root); - g_assert(q->n_nodes); + assert(q->root); + assert(q->n_nodes); n->y = q->last->y; n->x = q->last->x+1; - if (n->x >= ((guint) 1 << n->y)) { + if (n->x >= ((unsigned) 1 << n->y)) { n->x = 0; n->y++; } @@ -303,7 +314,7 @@ AvahiPrioQueueNode* avahi_prio_queue_put(AvahiPrioQueue *q, gpointer data) { q->last->next = n; n->prev = q->last; - g_assert(n->y > 0); + assert(n->y > 0); n->parent = get_node_at_xy(q, n->x/2, n->y-1); if (n->x & 1) @@ -311,8 +322,8 @@ AvahiPrioQueueNode* avahi_prio_queue_put(AvahiPrioQueue *q, gpointer data) { else n->parent->left = n; } else { - g_assert(!q->root); - g_assert(!q->n_nodes); + assert(!q->root); + assert(!q->n_nodes); n->y = n->x = 0; q->root = n; @@ -329,8 +340,9 @@ AvahiPrioQueueNode* avahi_prio_queue_put(AvahiPrioQueue *q, gpointer data) { } void avahi_prio_queue_remove(AvahiPrioQueue *q, AvahiPrioQueueNode *n) { - g_assert(q); - g_assert(n); + assert(q); + assert(n); + assert(q == n->queue); if (n != q->last) { AvahiPrioQueueNode *replacement = q->last; @@ -340,39 +352,39 @@ void avahi_prio_queue_remove(AvahiPrioQueue *q, AvahiPrioQueueNode *n) { return; } - g_assert(n == q->last); - g_assert(!n->next); - g_assert(!n->left); - g_assert(!n->right); + assert(n == q->last); + assert(!n->next); + assert(!n->left); + assert(!n->right); q->last = n->prev; if (n->prev) { n->prev->next = NULL; - g_assert(n->parent); + assert(n->parent); } else - g_assert(!n->parent); + assert(!n->parent); if (n->parent) { - g_assert(n->prev); + assert(n->prev); if (n->parent->left == n) { - g_assert(n->parent->right == NULL); + assert(n->parent->right == NULL); n->parent->left = NULL; } else { - g_assert(n->parent->right == n); - g_assert(n->parent->left != NULL); + assert(n->parent->right == n); + assert(n->parent->left != NULL); n->parent->right = NULL; } } else { - g_assert(q->root == n); - g_assert(!n->prev); - g_assert(q->n_nodes == 1); + assert(q->root == n); + assert(!n->prev); + assert(q->n_nodes == 1); q->root = NULL; } - g_free(n); + avahi_free(n); - g_assert(q->n_nodes > 0); + assert(q->n_nodes > 0); q->n_nodes--; } diff --git a/avahi-core/prioq.h b/avahi-core/prioq.h index e6105d8..ace92f6 100644 --- a/avahi-core/prioq.h +++ b/avahi-core/prioq.h @@ -22,31 +22,28 @@ USA. ***/ -#include <glib.h> - typedef struct AvahiPrioQueue AvahiPrioQueue; - typedef struct AvahiPrioQueueNode AvahiPrioQueueNode; +typedef int (*AvahiPQCompareFunc)(const void* a, const void* b); + struct AvahiPrioQueue { AvahiPrioQueueNode *root, *last; - - guint n_nodes; - gint (*compare) (gconstpointer a, gconstpointer b); + unsigned n_nodes; + AvahiPQCompareFunc compare; }; struct AvahiPrioQueueNode { AvahiPrioQueue *queue; - gpointer data; - guint x, y; - + void* data; + unsigned x, y; AvahiPrioQueueNode *left, *right, *parent, *next, *prev; }; -AvahiPrioQueue* avahi_prio_queue_new(gint (*compare) (gconstpointer a, gconstpointer b)); +AvahiPrioQueue* avahi_prio_queue_new(AvahiPQCompareFunc compare); void avahi_prio_queue_free(AvahiPrioQueue *q); -AvahiPrioQueueNode* avahi_prio_queue_put(AvahiPrioQueue *q, gpointer data); +AvahiPrioQueueNode* avahi_prio_queue_put(AvahiPrioQueue *q, void* data); void avahi_prio_queue_remove(AvahiPrioQueue *q, AvahiPrioQueueNode *n); void avahi_prio_queue_shuffle(AvahiPrioQueue *q, AvahiPrioQueueNode *n); diff --git a/avahi-core/probe-sched.c b/avahi-core/probe-sched.c index a375c7b..8a4d8b0 100644 --- a/avahi-core/probe-sched.c +++ b/avahi-core/probe-sched.c @@ -25,6 +25,7 @@ #include <avahi-common/domain.h> #include <avahi-common/timeval.h> +#include <avahi-common/malloc.h> #include "probe-sched.h" #include "log.h" @@ -38,8 +39,8 @@ struct AvahiProbeJob { AvahiProbeScheduler *scheduler; AvahiTimeEvent *time_event; - gboolean chosen; /* Use for packet assembling */ - gboolean done; + int chosen; /* Use for packet assembling */ + int done; struct timeval delivery; AvahiRecord *record; @@ -55,17 +56,21 @@ struct AvahiProbeScheduler { AVAHI_LLIST_HEAD(AvahiProbeJob, history); }; -static AvahiProbeJob* job_new(AvahiProbeScheduler *s, AvahiRecord *record, gboolean done) { +static AvahiProbeJob* job_new(AvahiProbeScheduler *s, AvahiRecord *record, int done) { AvahiProbeJob *pj; - g_assert(s); - g_assert(record); + assert(s); + assert(record); - pj = g_new(AvahiProbeJob, 1); + if (!(pj = avahi_new(AvahiProbeJob, 1))) { + avahi_log_error(__FILE__": Out of memory"); + return NULL; /* OOM */ + } + pj->scheduler = s; pj->record = avahi_record_ref(record); pj->time_event = NULL; - pj->chosen = FALSE; + pj->chosen = 0; if ((pj->done = done)) AVAHI_LLIST_PREPEND(AvahiProbeJob, jobs, s->history, pj); @@ -76,10 +81,10 @@ static AvahiProbeJob* job_new(AvahiProbeScheduler *s, AvahiRecord *record, gbool } static void job_free(AvahiProbeScheduler *s, AvahiProbeJob *pj) { - g_assert(pj); + assert(pj); if (pj->time_event) - avahi_time_event_queue_remove(s->time_event_queue, pj->time_event); + avahi_time_event_free(pj->time_event); if (pj->done) AVAHI_LLIST_REMOVE(AvahiProbeJob, jobs, s->history, pj); @@ -87,35 +92,35 @@ static void job_free(AvahiProbeScheduler *s, AvahiProbeJob *pj) { AVAHI_LLIST_REMOVE(AvahiProbeJob, jobs, s->jobs, pj); avahi_record_unref(pj->record); - g_free(pj); + avahi_free(pj); } -static void elapse_callback(AvahiTimeEvent *e, gpointer data); +static void elapse_callback(AvahiTimeEvent *e, void* data); -static void job_set_elapse_time(AvahiProbeScheduler *s, AvahiProbeJob *pj, guint msec, guint jitter) { +static void job_set_elapse_time(AvahiProbeScheduler *s, AvahiProbeJob *pj, unsigned msec, unsigned jitter) { struct timeval tv; - g_assert(s); - g_assert(pj); + assert(s); + assert(pj); avahi_elapse_time(&tv, msec, jitter); if (pj->time_event) - avahi_time_event_queue_update(s->time_event_queue, pj->time_event, &tv); + avahi_time_event_update(pj->time_event, &tv); else - pj->time_event = avahi_time_event_queue_add(s->time_event_queue, &tv, elapse_callback, pj); + pj->time_event = avahi_time_event_new(s->time_event_queue, &tv, elapse_callback, pj); } static void job_mark_done(AvahiProbeScheduler *s, AvahiProbeJob *pj) { - g_assert(s); - g_assert(pj); + assert(s); + assert(pj); - g_assert(!pj->done); + assert(!pj->done); AVAHI_LLIST_REMOVE(AvahiProbeJob, jobs, s->jobs, pj); AVAHI_LLIST_PREPEND(AvahiProbeJob, jobs, s->history, pj); - pj->done = TRUE; + pj->done = 1; job_set_elapse_time(s, pj, AVAHI_PROBE_HISTORY_MSEC, 0); gettimeofday(&pj->delivery, NULL); @@ -124,9 +129,13 @@ static void job_mark_done(AvahiProbeScheduler *s, AvahiProbeJob *pj) { AvahiProbeScheduler *avahi_probe_scheduler_new(AvahiInterface *i) { AvahiProbeScheduler *s; - g_assert(i); + assert(i); - s = g_new(AvahiProbeScheduler, 1); + if (!(s = avahi_new(AvahiProbeScheduler, 1))) { + avahi_log_error(__FILE__": Out of memory"); + return NULL; + } + s->interface = i; s->time_event_queue = i->monitor->server->time_event_queue; @@ -137,14 +146,14 @@ AvahiProbeScheduler *avahi_probe_scheduler_new(AvahiInterface *i) { } void avahi_probe_scheduler_free(AvahiProbeScheduler *s) { - g_assert(s); + assert(s); avahi_probe_scheduler_clear(s); - g_free(s); + avahi_free(s); } void avahi_probe_scheduler_clear(AvahiProbeScheduler *s) { - g_assert(s); + assert(s); while (s->jobs) job_free(s, s->jobs); @@ -152,16 +161,16 @@ void avahi_probe_scheduler_clear(AvahiProbeScheduler *s) { job_free(s, s->history); } -static gboolean packet_add_probe_query(AvahiProbeScheduler *s, AvahiDnsPacket *p, AvahiProbeJob *pj) { - guint size; +static int packet_add_probe_query(AvahiProbeScheduler *s, AvahiDnsPacket *p, AvahiProbeJob *pj) { + size_t size; AvahiKey *k; - gboolean b; + int b; - g_assert(s); - g_assert(p); - g_assert(pj); + assert(s); + assert(p); + assert(pj); - g_assert(!pj->chosen); + assert(!pj->chosen); /* Estimate the size for this record */ size = @@ -170,15 +179,17 @@ static gboolean packet_add_probe_query(AvahiProbeScheduler *s, AvahiDnsPacket *p /* Too large */ if (size > avahi_dns_packet_space(p)) - return FALSE; + return 0; /* Create the probe query */ - k = avahi_key_new(pj->record->key->name, pj->record->key->clazz, AVAHI_DNS_TYPE_ANY); - b = !!avahi_dns_packet_append_key(p, k, FALSE); - g_assert(b); + if (!(k = avahi_key_new(pj->record->key->name, pj->record->key->clazz, AVAHI_DNS_TYPE_ANY))) + return 0; /* OOM */ + + b = !!avahi_dns_packet_append_key(p, k, 0); + assert(b); /* Mark this job for addition to the packet */ - pj->chosen = TRUE; + pj->chosen = 1; /* Scan for more jobs whith matching key pattern */ for (pj = s->jobs; pj; pj = pj->jobs_next) { @@ -194,21 +205,21 @@ static gboolean packet_add_probe_query(AvahiProbeScheduler *s, AvahiDnsPacket *p break; /* Mark this job for addition to the packet */ - pj->chosen = TRUE; + pj->chosen = 1; } avahi_key_unref(k); - return TRUE; + return 1; } -static void elapse_callback(AvahiTimeEvent *e, gpointer data) { +static void elapse_callback(AvahiTimeEvent *e, void* data) { AvahiProbeJob *pj = data, *next; AvahiProbeScheduler *s; AvahiDnsPacket *p; - guint n; + unsigned n; - g_assert(pj); + assert(pj); s = pj->scheduler; if (pj->done) { @@ -217,14 +228,15 @@ static void elapse_callback(AvahiTimeEvent *e, gpointer data) { return; } - p = avahi_dns_packet_new_query(s->interface->hardware->mtu); + if (!(p = avahi_dns_packet_new_query(s->interface->hardware->mtu))) + return; /* OOM */ n = 1; /* Add the import probe */ if (!packet_add_probe_query(s, p, pj)) { - guint size; + size_t size; AvahiKey *k; - gboolean b; + int b; avahi_dns_packet_free(p); @@ -237,11 +249,16 @@ static void elapse_callback(AvahiTimeEvent *e, gpointer data) { if (size > AVAHI_DNS_PACKET_MAX_SIZE) size = AVAHI_DNS_PACKET_MAX_SIZE; - - p = avahi_dns_packet_new_query(size); - k = avahi_key_new(pj->record->key->name, pj->record->key->clazz, AVAHI_DNS_TYPE_ANY); - b = avahi_dns_packet_append_key(p, k, FALSE) && avahi_dns_packet_append_record(p, pj->record, FALSE, 0); + if (!(p = avahi_dns_packet_new_query(size))) + return; /* OOM */ + + if (!(k = avahi_key_new(pj->record->key->name, pj->record->key->clazz, AVAHI_DNS_TYPE_ANY))) { + avahi_dns_packet_free(p); + return; /* OOM */ + } + + b = avahi_dns_packet_append_key(p, k, 0) && avahi_dns_packet_append_record(p, pj->record, 0, 0); avahi_key_unref(k); if (b) { @@ -281,12 +298,12 @@ static void elapse_callback(AvahiTimeEvent *e, gpointer data) { if (!pj->chosen) continue; - if (!avahi_dns_packet_append_record(p, pj->record, FALSE, 0)) { + if (!avahi_dns_packet_append_record(p, pj->record, 0, 0)) { avahi_log_warn("Bad probe size estimate!"); /* Unmark all following jobs */ for (; pj; pj = pj->jobs_next) - pj->chosen = FALSE; + pj->chosen = 0; break; } @@ -306,11 +323,11 @@ static void elapse_callback(AvahiTimeEvent *e, gpointer data) { static AvahiProbeJob* find_scheduled_job(AvahiProbeScheduler *s, AvahiRecord *record) { AvahiProbeJob *pj; - g_assert(s); - g_assert(record); + assert(s); + assert(record); for (pj = s->jobs; pj; pj = pj->jobs_next) { - g_assert(!pj->done); + assert(!pj->done); if (avahi_record_equal_no_ttl(pj->record, record)) return pj; @@ -322,11 +339,11 @@ static AvahiProbeJob* find_scheduled_job(AvahiProbeScheduler *s, AvahiRecord *re static AvahiProbeJob* find_history_job(AvahiProbeScheduler *s, AvahiRecord *record) { AvahiProbeJob *pj; - g_assert(s); - g_assert(record); + assert(s); + assert(record); for (pj = s->history; pj; pj = pj->jobs_next) { - g_assert(pj->done); + assert(pj->done); if (avahi_record_equal_no_ttl(pj->record, record)) { /* Check whether this entry is outdated */ @@ -344,16 +361,16 @@ static AvahiProbeJob* find_history_job(AvahiProbeScheduler *s, AvahiRecord *reco return NULL; } -gboolean avahi_probe_scheduler_post(AvahiProbeScheduler *s, AvahiRecord *record, gboolean immediately) { +int avahi_probe_scheduler_post(AvahiProbeScheduler *s, AvahiRecord *record, int immediately) { AvahiProbeJob *pj; struct timeval tv; - g_assert(s); - g_assert(record); - g_assert(!avahi_key_is_pattern(record->key)); + assert(s); + assert(record); + assert(!avahi_key_is_pattern(record->key)); if ((pj = find_history_job(s, record))) - return FALSE; + return 0; avahi_elapse_time(&tv, immediately ? 0 : AVAHI_PROBE_DEFER_MSEC, 0); @@ -362,19 +379,21 @@ gboolean avahi_probe_scheduler_post(AvahiProbeScheduler *s, AvahiRecord *record, if (avahi_timeval_compare(&tv, &pj->delivery) < 0) { /* If the new entry should be scheduled earlier, update the old entry */ pj->delivery = tv; - avahi_time_event_queue_update(s->time_event_queue, pj->time_event, &pj->delivery); + avahi_time_event_update(pj->time_event, &pj->delivery); } - return TRUE; + return 1; } else { /* Create a new job and schedule it */ - pj = job_new(s, record, FALSE); + if (!(pj = job_new(s, record, 0))) + return 0; /* OOM */ + pj->delivery = tv; - pj->time_event = avahi_time_event_queue_add(s->time_event_queue, &pj->delivery, elapse_callback, pj); + pj->time_event = avahi_time_event_new(s->time_event_queue, &pj->delivery, elapse_callback, pj); /* avahi_log_debug("Accepted new probe job."); */ - return TRUE; + return 1; } } diff --git a/avahi-core/probe-sched.h b/avahi-core/probe-sched.h index aae0f3a..3af1319 100644 --- a/avahi-core/probe-sched.h +++ b/avahi-core/probe-sched.h @@ -31,6 +31,6 @@ AvahiProbeScheduler *avahi_probe_scheduler_new(AvahiInterface *i); void avahi_probe_scheduler_free(AvahiProbeScheduler *s); void avahi_probe_scheduler_clear(AvahiProbeScheduler *s); -gboolean avahi_probe_scheduler_post(AvahiProbeScheduler *s, AvahiRecord *record, gboolean immediately); +int avahi_probe_scheduler_post(AvahiProbeScheduler *s, AvahiRecord *record, int immediately); #endif diff --git a/avahi-core/query-sched.c b/avahi-core/query-sched.c index 9a26dba..87553d6 100644 --- a/avahi-core/query-sched.c +++ b/avahi-core/query-sched.c @@ -24,7 +24,10 @@ #endif #include <avahi-common/timeval.h> +#include <avahi-common/malloc.h> + #include "query-sched.h" +#include "log.h" #define AVAHI_QUERY_HISTORY_MSEC 100 #define AVAHI_QUERY_DEFER_MSEC 100 @@ -36,7 +39,7 @@ struct AvahiQueryJob { AvahiQueryScheduler *scheduler; AvahiTimeEvent *time_event; - gboolean done; + int done; struct timeval delivery; AvahiKey *key; @@ -60,13 +63,17 @@ struct AvahiQueryScheduler { AVAHI_LLIST_HEAD(AvahiKnownAnswer, known_answers); }; -static AvahiQueryJob* job_new(AvahiQueryScheduler *s, AvahiKey *key, gboolean done) { +static AvahiQueryJob* job_new(AvahiQueryScheduler *s, AvahiKey *key, int done) { AvahiQueryJob *qj; - g_assert(s); - g_assert(key); + assert(s); + assert(key); - qj = g_new(AvahiQueryJob, 1); + if (!(qj = avahi_new(AvahiQueryJob, 1))) { + avahi_log_error(__FILE__": Out of memory"); + return NULL; + } + qj->scheduler = s; qj->key = avahi_key_ref(key); qj->time_event = NULL; @@ -80,11 +87,11 @@ static AvahiQueryJob* job_new(AvahiQueryScheduler *s, AvahiKey *key, gboolean do } static void job_free(AvahiQueryScheduler *s, AvahiQueryJob *qj) { - g_assert(s); - g_assert(qj); + assert(s); + assert(qj); if (qj->time_event) - avahi_time_event_queue_remove(s->time_event_queue, qj->time_event); + avahi_time_event_free(qj->time_event); if (qj->done) AVAHI_LLIST_REMOVE(AvahiQueryJob, jobs, s->history, qj); @@ -92,35 +99,35 @@ static void job_free(AvahiQueryScheduler *s, AvahiQueryJob *qj) { AVAHI_LLIST_REMOVE(AvahiQueryJob, jobs, s->jobs, qj); avahi_key_unref(qj->key); - g_free(qj); + avahi_free(qj); } -static void elapse_callback(AvahiTimeEvent *e, gpointer data); +static void elapse_callback(AvahiTimeEvent *e, void* data); -static void job_set_elapse_time(AvahiQueryScheduler *s, AvahiQueryJob *qj, guint msec, guint jitter) { +static void job_set_elapse_time(AvahiQueryScheduler *s, AvahiQueryJob *qj, unsigned msec, unsigned jitter) { struct timeval tv; - g_assert(s); - g_assert(qj); + assert(s); + assert(qj); avahi_elapse_time(&tv, msec, jitter); if (qj->time_event) - avahi_time_event_queue_update(s->time_event_queue, qj->time_event, &tv); + avahi_time_event_update(qj->time_event, &tv); else - qj->time_event = avahi_time_event_queue_add(s->time_event_queue, &tv, elapse_callback, qj); + qj->time_event = avahi_time_event_new(s->time_event_queue, &tv, elapse_callback, qj); } static void job_mark_done(AvahiQueryScheduler *s, AvahiQueryJob *qj) { - g_assert(s); - g_assert(qj); + assert(s); + assert(qj); - g_assert(!qj->done); + assert(!qj->done); AVAHI_LLIST_REMOVE(AvahiQueryJob, jobs, s->jobs, qj); AVAHI_LLIST_PREPEND(AvahiQueryJob, jobs, s->history, qj); - qj->done = TRUE; + qj->done = 1; job_set_elapse_time(s, qj, AVAHI_QUERY_HISTORY_MSEC, 0); gettimeofday(&qj->delivery, NULL); @@ -128,9 +135,13 @@ static void job_mark_done(AvahiQueryScheduler *s, AvahiQueryJob *qj) { AvahiQueryScheduler *avahi_query_scheduler_new(AvahiInterface *i) { AvahiQueryScheduler *s; - g_assert(i); + assert(i); - s = g_new(AvahiQueryScheduler, 1); + if (!(s = avahi_new(AvahiQueryScheduler, 1))) { + avahi_log_error(__FILE__": Out of memory"); + return NULL; /* OOM */ + } + s->interface = i; s->time_event_queue = i->monitor->server->time_event_queue; @@ -142,15 +153,15 @@ AvahiQueryScheduler *avahi_query_scheduler_new(AvahiInterface *i) { } void avahi_query_scheduler_free(AvahiQueryScheduler *s) { - g_assert(s); + assert(s); - g_assert(!s->known_answers); + assert(!s->known_answers); avahi_query_scheduler_clear(s); - g_free(s); + avahi_free(s); } void avahi_query_scheduler_clear(AvahiQueryScheduler *s) { - g_assert(s); + assert(s); while (s->jobs) job_free(s, s->jobs); @@ -158,19 +169,23 @@ void avahi_query_scheduler_clear(AvahiQueryScheduler *s) { job_free(s, s->history); } -static gpointer known_answer_walk_callback(AvahiCache *c, AvahiKey *pattern, AvahiCacheEntry *e, gpointer userdata) { +static void* known_answer_walk_callback(AvahiCache *c, AvahiKey *pattern, AvahiCacheEntry *e, void* userdata) { AvahiQueryScheduler *s = userdata; AvahiKnownAnswer *ka; - g_assert(c); - g_assert(pattern); - g_assert(e); - g_assert(s); + assert(c); + assert(pattern); + assert(e); + assert(s); if (avahi_cache_entry_half_ttl(c, e)) return NULL; - ka = g_new0(AvahiKnownAnswer, 1); + if (!(ka = avahi_new0(AvahiKnownAnswer, 1))) { + avahi_log_error(__FILE__": Out of memory"); + return NULL; + } + ka->scheduler = s; ka->record = avahi_record_ref(e->record); @@ -178,34 +193,34 @@ static gpointer known_answer_walk_callback(AvahiCache *c, AvahiKey *pattern, Ava return NULL; } -static gboolean packet_add_query_job(AvahiQueryScheduler *s, AvahiDnsPacket *p, AvahiQueryJob *qj) { - g_assert(s); - g_assert(p); - g_assert(qj); +static int packet_add_query_job(AvahiQueryScheduler *s, AvahiDnsPacket *p, AvahiQueryJob *qj) { + assert(s); + assert(p); + assert(qj); - if (!avahi_dns_packet_append_key(p, qj->key, FALSE)) - return FALSE; + if (!avahi_dns_packet_append_key(p, qj->key, 0)) + return 0; /* Add all matching known answers to the list */ avahi_cache_walk(s->interface->cache, qj->key, known_answer_walk_callback, s); job_mark_done(s, qj); - return TRUE; + return 1; } static void append_known_answers_and_send(AvahiQueryScheduler *s, AvahiDnsPacket *p) { AvahiKnownAnswer *ka; - guint n; - g_assert(s); - g_assert(p); + unsigned n; + assert(s); + assert(p); n = 0; while ((ka = s->known_answers)) { - gboolean too_large = FALSE; + int too_large = 0; - while (!avahi_dns_packet_append_record(p, ka->record, FALSE, 0)) { + while (!avahi_dns_packet_append_record(p, ka->record, 0, 0)) { if (avahi_dns_packet_is_empty(p)) { /* The record is too large to fit into one packet, so @@ -213,7 +228,7 @@ static void append_known_answers_and_send(AvahiQueryScheduler *s, AvahiDnsPacket the owner of the record send it as a response. This has the advantage of a cache refresh. */ - too_large = TRUE; + too_large = 1; break; } @@ -228,7 +243,7 @@ static void append_known_answers_and_send(AvahiQueryScheduler *s, AvahiDnsPacket AVAHI_LLIST_REMOVE(AvahiKnownAnswer, known_answer, s->known_answers, ka); avahi_record_unref(ka->record); - g_free(ka); + avahi_free(ka); if (!too_large) n++; @@ -239,14 +254,14 @@ static void append_known_answers_and_send(AvahiQueryScheduler *s, AvahiDnsPacket avahi_dns_packet_free(p); } -static void elapse_callback(AvahiTimeEvent *e, gpointer data) { +static void elapse_callback(AvahiTimeEvent *e, void* data) { AvahiQueryJob *qj = data; AvahiQueryScheduler *s; AvahiDnsPacket *p; - guint n; - gboolean b; + unsigned n; + int b; - g_assert(qj); + assert(qj); s = qj->scheduler; if (qj->done) { @@ -255,11 +270,13 @@ static void elapse_callback(AvahiTimeEvent *e, gpointer data) { return; } - g_assert(!s->known_answers); + assert(!s->known_answers); + + if (!(p = avahi_dns_packet_new_query(s->interface->hardware->mtu))) + return; /* OOM */ - p = avahi_dns_packet_new_query(s->interface->hardware->mtu); b = packet_add_query_job(s, p, qj); - g_assert(b); /* An query must always fit in */ + assert(b); /* An query must always fit in */ n = 1; /* Try to fill up packet with more queries, if available */ @@ -280,11 +297,11 @@ static void elapse_callback(AvahiTimeEvent *e, gpointer data) { static AvahiQueryJob* find_scheduled_job(AvahiQueryScheduler *s, AvahiKey *key) { AvahiQueryJob *qj; - g_assert(s); - g_assert(key); + assert(s); + assert(key); for (qj = s->jobs; qj; qj = qj->jobs_next) { - g_assert(!qj->done); + assert(!qj->done); if (avahi_key_equal(qj->key, key)) return qj; @@ -296,11 +313,11 @@ static AvahiQueryJob* find_scheduled_job(AvahiQueryScheduler *s, AvahiKey *key) static AvahiQueryJob* find_history_job(AvahiQueryScheduler *s, AvahiKey *key) { AvahiQueryJob *qj; - g_assert(s); - g_assert(key); + assert(s); + assert(key); for (qj = s->history; qj; qj = qj->jobs_next) { - g_assert(qj->done); + assert(qj->done); if (avahi_key_equal(qj->key, key)) { /* Check whether this entry is outdated */ @@ -318,16 +335,16 @@ static AvahiQueryJob* find_history_job(AvahiQueryScheduler *s, AvahiKey *key) { return NULL; } -gboolean avahi_query_scheduler_post(AvahiQueryScheduler *s, AvahiKey *key, gboolean immediately) { +int avahi_query_scheduler_post(AvahiQueryScheduler *s, AvahiKey *key, int immediately) { struct timeval tv; AvahiQueryJob *qj; - g_assert(s); - g_assert(key); + assert(s); + assert(key); if ((qj = find_history_job(s, key))) { /* avahi_log_debug("Query suppressed by local duplicate suppression (history)"); */ - return FALSE; + return 0; } avahi_elapse_time(&tv, immediately ? 0 : AVAHI_QUERY_DEFER_MSEC, 0); @@ -341,26 +358,28 @@ gboolean avahi_query_scheduler_post(AvahiQueryScheduler *s, AvahiKey *key, gbool /* If the new entry should be scheduled earlier, * update the old entry */ qj->delivery = tv; - avahi_time_event_queue_update(s->time_event_queue, qj->time_event, &qj->delivery); + avahi_time_event_update(qj->time_event, &qj->delivery); } - return TRUE; + return 1; } else { /* avahi_log_debug("Accepted new query job.\n"); */ - qj = job_new(s, key, FALSE); + if (!(qj = job_new(s, key, 0))) + return 0; /* OOM */ + qj->delivery = tv; - qj->time_event = avahi_time_event_queue_add(s->time_event_queue, &qj->delivery, elapse_callback, qj); + qj->time_event = avahi_time_event_new(s->time_event_queue, &qj->delivery, elapse_callback, qj); - return TRUE; + return 1; } } void avahi_query_scheduler_incoming(AvahiQueryScheduler *s, AvahiKey *key) { AvahiQueryJob *qj; - g_assert(s); - g_assert(key); + assert(s); + assert(key); /* This function is called whenever an incoming query was * receieved. We drop scheduled queries that match. The keyword is @@ -372,7 +391,9 @@ void avahi_query_scheduler_incoming(AvahiQueryScheduler *s, AvahiKey *key) { return; } - qj = job_new(s, key, TRUE); + if (!(qj = job_new(s, key, 1))) + return; /* OOM */ + gettimeofday(&qj->delivery, NULL); job_set_elapse_time(s, qj, AVAHI_QUERY_HISTORY_MSEC, 0); } diff --git a/avahi-core/query-sched.h b/avahi-core/query-sched.h index 2c373b1..7b281b6 100644 --- a/avahi-core/query-sched.h +++ b/avahi-core/query-sched.h @@ -31,7 +31,7 @@ AvahiQueryScheduler *avahi_query_scheduler_new(AvahiInterface *i); void avahi_query_scheduler_free(AvahiQueryScheduler *s); void avahi_query_scheduler_clear(AvahiQueryScheduler *s); -gboolean avahi_query_scheduler_post(AvahiQueryScheduler *s, AvahiKey *key, gboolean immediately); +int avahi_query_scheduler_post(AvahiQueryScheduler *s, AvahiKey *key, int immediately); void avahi_query_scheduler_incoming(AvahiQueryScheduler *s, AvahiKey *key); #endif diff --git a/avahi-core/resolve-address.c b/avahi-core/resolve-address.c index 6bd7cf2..e210285 100644 --- a/avahi-core/resolve-address.c +++ b/avahi-core/resolve-address.c @@ -24,6 +24,8 @@ #endif #include <avahi-common/timeval.h> +#include <avahi-common/malloc.h> + #include "browse.h" struct AvahiAddressResolver { @@ -33,7 +35,7 @@ struct AvahiAddressResolver { AvahiRecordBrowser *record_browser; AvahiAddressResolverCallback callback; - gpointer userdata; + void* userdata; AvahiTimeEvent *time_event; @@ -41,30 +43,30 @@ struct AvahiAddressResolver { }; static void finish(AvahiAddressResolver *r, AvahiIfIndex interface, AvahiProtocol protocol, AvahiResolverEvent event, AvahiRecord *record) { - g_assert(r); + assert(r); avahi_record_browser_free(r->record_browser); r->record_browser = NULL; if (r->time_event) { - avahi_time_event_queue_remove(r->server->time_event_queue, r->time_event); + avahi_time_event_free(r->time_event); r->time_event = NULL; } r->callback(r, interface, protocol, event, &r->address, record ? record->data.ptr.name : NULL, r->userdata); } -static void record_browser_callback(AvahiRecordBrowser*rr, AvahiIfIndex interface, AvahiProtocol protocol, AvahiBrowserEvent event, AvahiRecord *record, gpointer userdata) { +static void record_browser_callback(AvahiRecordBrowser*rr, AvahiIfIndex interface, AvahiProtocol protocol, AvahiBrowserEvent event, AvahiRecord *record, void* userdata) { AvahiAddressResolver *r = userdata; - g_assert(rr); - g_assert(record); - g_assert(r); + assert(rr); + assert(record); + assert(r); if (!(event == AVAHI_BROWSER_NEW)) return; - g_assert(record->key->type == AVAHI_DNS_TYPE_PTR); + assert(record->key->type == AVAHI_DNS_TYPE_PTR); finish(r, interface, protocol, AVAHI_RESOLVER_FOUND, record); } @@ -72,42 +74,63 @@ static void record_browser_callback(AvahiRecordBrowser*rr, AvahiIfIndex interfac static void time_event_callback(AvahiTimeEvent *e, void *userdata) { AvahiAddressResolver *r = userdata; - g_assert(e); - g_assert(r); + assert(e); + assert(r); finish(r, -1, AVAHI_PROTO_UNSPEC, AVAHI_RESOLVER_TIMEOUT, NULL); } -AvahiAddressResolver *avahi_address_resolver_new(AvahiServer *server, AvahiIfIndex interface, AvahiProtocol protocol, const AvahiAddress *address, AvahiAddressResolverCallback callback, gpointer userdata) { +AvahiAddressResolver *avahi_address_resolver_new(AvahiServer *server, AvahiIfIndex interface, AvahiProtocol protocol, const AvahiAddress *address, AvahiAddressResolverCallback callback, void* userdata) { AvahiAddressResolver *r; AvahiKey *k; - gchar *n; + char *n; struct timeval tv; - g_assert(server); - g_assert(address); - g_assert(callback); + assert(server); + assert(address); + assert(callback); + + assert(address->family == AVAHI_PROTO_INET || address->family == AVAHI_PROTO_INET6); + + if (address->family == AVAHI_PROTO_INET) + n = avahi_reverse_lookup_name_ipv4(&address->data.ipv4); + else + n = avahi_reverse_lookup_name_ipv6_arpa(&address->data.ipv6); + + if (!n) { + avahi_server_set_errno(server, AVAHI_ERR_NO_MEMORY); + return NULL; + } + + k = avahi_key_new(n, AVAHI_DNS_CLASS_IN, AVAHI_DNS_TYPE_PTR); + avahi_free(n); - g_assert(address->family == AVAHI_PROTO_INET || address->family == AVAHI_PROTO_INET6); + if (!k) { + avahi_server_set_errno(server, AVAHI_ERR_NO_MEMORY); + return NULL; + } - r = g_new(AvahiAddressResolver, 1); + if (!(r = avahi_new(AvahiAddressResolver, 1))) { + avahi_server_set_errno(server, AVAHI_ERR_NO_MEMORY); + avahi_key_unref(k); + return NULL; + } + r->server = server; r->address = *address; r->callback = callback; r->userdata = userdata; - avahi_elapse_time(&tv, 1000, 0); - r->time_event = avahi_time_event_queue_add(server->time_event_queue, &tv, time_event_callback, r); - + r->record_browser = NULL; AVAHI_LLIST_PREPEND(AvahiAddressResolver, resolver, server->address_resolvers, r); - - if (address->family == AVAHI_PROTO_INET) - n = avahi_reverse_lookup_name_ipv4(&address->data.ipv4); - else - n = avahi_reverse_lookup_name_ipv6_arpa(&address->data.ipv6); - - k = avahi_key_new(n, AVAHI_DNS_CLASS_IN, AVAHI_DNS_TYPE_PTR); - g_free(n); + + avahi_elapse_time(&tv, 1000, 0); + if (!(r->time_event = avahi_time_event_new(server->time_event_queue, &tv, time_event_callback, r))) { + avahi_server_set_errno(server, AVAHI_ERR_NO_MEMORY); + avahi_address_resolver_free(r); + avahi_key_unref(k); + return NULL; + } r->record_browser = avahi_record_browser_new(server, interface, protocol, k, record_browser_callback, r); avahi_key_unref(k); @@ -121,7 +144,7 @@ AvahiAddressResolver *avahi_address_resolver_new(AvahiServer *server, AvahiIfInd } void avahi_address_resolver_free(AvahiAddressResolver *r) { - g_assert(r); + assert(r); AVAHI_LLIST_REMOVE(AvahiAddressResolver, resolver, r->server->address_resolvers, r); @@ -129,7 +152,7 @@ void avahi_address_resolver_free(AvahiAddressResolver *r) { avahi_record_browser_free(r->record_browser); if (r->time_event) - avahi_time_event_queue_remove(r->server->time_event_queue, r->time_event); + avahi_time_event_free(r->time_event); - g_free(r); + avahi_free(r); } diff --git a/avahi-core/resolve-host-name.c b/avahi-core/resolve-host-name.c index 1e6dc9f..5ea1697 100644 --- a/avahi-core/resolve-host-name.c +++ b/avahi-core/resolve-host-name.c @@ -25,17 +25,20 @@ #include <avahi-common/domain.h> #include <avahi-common/timeval.h> +#include <avahi-common/malloc.h> + #include "browse.h" +#include "log.h" struct AvahiHostNameResolver { AvahiServer *server; - gchar *host_name; + char *host_name; AvahiRecordBrowser *record_browser_a; AvahiRecordBrowser *record_browser_aaaa; AvahiHostNameResolverCallback callback; - gpointer userdata; + void* userdata; AvahiTimeEvent *time_event; @@ -45,7 +48,7 @@ struct AvahiHostNameResolver { static void finish(AvahiHostNameResolver *r, AvahiIfIndex interface, AvahiProtocol protocol, AvahiResolverEvent event, AvahiRecord *record) { AvahiAddress a; - g_assert(r); + assert(r); if (r->record_browser_a) { avahi_record_browser_free(r->record_browser_a); @@ -58,7 +61,7 @@ static void finish(AvahiHostNameResolver *r, AvahiIfIndex interface, AvahiProtoc } if (r->time_event) { - avahi_time_event_queue_remove(r->server->time_event_queue, r->time_event); + avahi_time_event_free(r->time_event); r->time_event = NULL; } @@ -75,53 +78,57 @@ static void finish(AvahiHostNameResolver *r, AvahiIfIndex interface, AvahiProtoc break; default: - g_assert(FALSE); + assert(0); } } r->callback(r, interface, protocol, event, record ? record->key->name : r->host_name, record ? &a : NULL, r->userdata); } -static void record_browser_callback(AvahiRecordBrowser*rr, AvahiIfIndex interface, AvahiProtocol protocol, AvahiBrowserEvent event, AvahiRecord *record, gpointer userdata) { +static void record_browser_callback(AvahiRecordBrowser*rr, AvahiIfIndex interface, AvahiProtocol protocol, AvahiBrowserEvent event, AvahiRecord *record, void* userdata) { AvahiHostNameResolver *r = userdata; - g_assert(rr); - g_assert(record); - g_assert(r); + assert(rr); + assert(record); + assert(r); if (!(event == AVAHI_BROWSER_NEW)) return; - g_assert(record->key->type == AVAHI_DNS_TYPE_A || record->key->type == AVAHI_DNS_TYPE_AAAA); + assert(record->key->type == AVAHI_DNS_TYPE_A || record->key->type == AVAHI_DNS_TYPE_AAAA); finish(r, interface, protocol, AVAHI_RESOLVER_FOUND, record); } static void time_event_callback(AvahiTimeEvent *e, void *userdata) { AvahiHostNameResolver *r = userdata; - g_assert(e); - g_assert(r); + assert(e); + assert(r); finish(r, -1, AVAHI_PROTO_UNSPEC, AVAHI_RESOLVER_TIMEOUT, NULL); } -AvahiHostNameResolver *avahi_host_name_resolver_new(AvahiServer *server, AvahiIfIndex interface, AvahiProtocol protocol, const gchar *host_name, guchar aprotocol, AvahiHostNameResolverCallback callback, gpointer userdata) { +AvahiHostNameResolver *avahi_host_name_resolver_new(AvahiServer *server, AvahiIfIndex interface, AvahiProtocol protocol, const char *host_name, AvahiProtocol aprotocol, AvahiHostNameResolverCallback callback, void* userdata) { AvahiHostNameResolver *r; AvahiKey *k; struct timeval tv; - g_assert(server); - g_assert(host_name); - g_assert(callback); + assert(server); + assert(host_name); + assert(callback); - g_assert(aprotocol == AVAHI_PROTO_UNSPEC || aprotocol == AVAHI_PROTO_INET || aprotocol == AVAHI_PROTO_INET6); + assert(aprotocol == AVAHI_PROTO_UNSPEC || aprotocol == AVAHI_PROTO_INET || aprotocol == AVAHI_PROTO_INET6); if (!avahi_is_valid_domain_name(host_name)) { avahi_server_set_errno(server, AVAHI_ERR_INVALID_HOST_NAME); return NULL; } - r = g_new(AvahiHostNameResolver, 1); + if (!(r = avahi_new(AvahiHostNameResolver, 1))) { + avahi_server_set_errno(server, AVAHI_ERR_NO_MEMORY); + return NULL; + } + r->server = server; r->host_name = avahi_normalize_name(host_name); r->callback = callback; @@ -130,7 +137,7 @@ AvahiHostNameResolver *avahi_host_name_resolver_new(AvahiServer *server, AvahiIf r->record_browser_a = r->record_browser_aaaa = NULL; avahi_elapse_time(&tv, 1000, 0); - r->time_event = avahi_time_event_queue_add(server->time_event_queue, &tv, time_event_callback, r); + r->time_event = avahi_time_event_new(server->time_event_queue, &tv, time_event_callback, r); AVAHI_LLIST_PREPEND(AvahiHostNameResolver, resolver, server->host_name_resolvers, r); @@ -154,7 +161,7 @@ AvahiHostNameResolver *avahi_host_name_resolver_new(AvahiServer *server, AvahiIf goto fail; } - g_assert(r->record_browser_aaaa || r->record_browser_a); + assert(r->record_browser_aaaa || r->record_browser_a); return r; @@ -164,7 +171,7 @@ fail: } void avahi_host_name_resolver_free(AvahiHostNameResolver *r) { - g_assert(r); + assert(r); AVAHI_LLIST_REMOVE(AvahiHostNameResolver, resolver, r->server->host_name_resolvers, r); @@ -175,8 +182,8 @@ void avahi_host_name_resolver_free(AvahiHostNameResolver *r) { avahi_record_browser_free(r->record_browser_aaaa); if (r->time_event) - avahi_time_event_queue_remove(r->server->time_event_queue, r->time_event); + avahi_time_event_free(r->time_event); - g_free(r->host_name); - g_free(r); + avahi_free(r->host_name); + avahi_free(r); } diff --git a/avahi-core/resolve-service.c b/avahi-core/resolve-service.c index 9a142ae..194c245 100644 --- a/avahi-core/resolve-service.c +++ b/avahi-core/resolve-service.c @@ -24,16 +24,19 @@ #endif #include <string.h> +#include <stdio.h> #include <avahi-common/domain.h> #include <avahi-common/timeval.h> +#include <avahi-common/malloc.h> + #include "browse.h" struct AvahiServiceResolver { AvahiServer *server; - gchar *service_name; - gchar *service_type; - gchar *domain_name; + char *service_name; + char *service_type; + char *domain_name; AvahiProtocol address_protocol; AvahiIfIndex interface; @@ -47,7 +50,7 @@ struct AvahiServiceResolver { AvahiRecord *srv_record, *txt_record, *address_record; AvahiServiceResolverCallback callback; - gpointer userdata; + void* userdata; AvahiTimeEvent *time_event; @@ -55,7 +58,7 @@ struct AvahiServiceResolver { }; static void finish(AvahiServiceResolver *r, AvahiResolverEvent event) { - g_assert(r); + assert(r); if (r->record_browser_a) { avahi_record_browser_free(r->record_browser_a); @@ -78,7 +81,7 @@ static void finish(AvahiServiceResolver *r, AvahiResolverEvent event) { } if (r->time_event) { - avahi_time_event_queue_remove(r->server->time_event_queue, r->time_event); + avahi_time_event_free(r->time_event); r->time_event = NULL; } @@ -86,12 +89,12 @@ static void finish(AvahiServiceResolver *r, AvahiResolverEvent event) { r->callback(r, r->interface, r->protocol, event, r->service_name, r->service_type, r->domain_name, NULL, NULL, 0, NULL, r->userdata); else { AvahiAddress a; - gchar sn[256], st[256]; + char sn[256], st[256]; size_t i; - g_assert(r->srv_record); - g_assert(r->txt_record); - g_assert(r->address_record); + assert(r->srv_record); + assert(r->txt_record); + assert(r->address_record); switch (r->address_record->key->type) { case AVAHI_DNS_TYPE_A: @@ -105,11 +108,11 @@ static void finish(AvahiServiceResolver *r, AvahiResolverEvent event) { break; default: - g_assert(FALSE); + assert(0); } - g_snprintf(sn, sizeof(sn), r->service_name); - g_snprintf(st, sizeof(st), r->service_type); + snprintf(sn, sizeof(sn), r->service_name); + snprintf(st, sizeof(st), r->service_type); if ((i = strlen(sn)) > 0 && sn[i-1] == '.') sn[i-1] = 0; @@ -122,12 +125,12 @@ static void finish(AvahiServiceResolver *r, AvahiResolverEvent event) { } } -static void record_browser_callback(AvahiRecordBrowser*rr, AvahiIfIndex interface, AvahiProtocol protocol, AvahiBrowserEvent event, AvahiRecord *record, gpointer userdata) { +static void record_browser_callback(AvahiRecordBrowser*rr, AvahiIfIndex interface, AvahiProtocol protocol, AvahiBrowserEvent event, AvahiRecord *record, void* userdata) { AvahiServiceResolver *r = userdata; - g_assert(rr); - g_assert(record); - g_assert(r); + assert(rr); + assert(record); + assert(r); if (!(event == AVAHI_BROWSER_NEW)) return; @@ -149,7 +152,7 @@ static void record_browser_callback(AvahiRecordBrowser*rr, AvahiIfIndex interfac if (!r->srv_record) { r->srv_record = avahi_record_ref(record); - g_assert(!r->record_browser_a && !r->record_browser_aaaa); + assert(!r->record_browser_a && !r->record_browser_aaaa); if (r->address_protocol == AVAHI_PROTO_INET || r->address_protocol == AVAHI_PROTO_UNSPEC) { AvahiKey *k = avahi_key_new(r->srv_record->data.srv.name, AVAHI_DNS_CLASS_IN, AVAHI_DNS_TYPE_A); @@ -177,7 +180,7 @@ static void record_browser_callback(AvahiRecordBrowser*rr, AvahiIfIndex interfac break; default: - g_assert(FALSE); + assert(0); } if (r->txt_record && r->srv_record && r->address_record) @@ -187,25 +190,25 @@ static void record_browser_callback(AvahiRecordBrowser*rr, AvahiIfIndex interfac static void time_event_callback(AvahiTimeEvent *e, void *userdata) { AvahiServiceResolver *r = userdata; - g_assert(e); - g_assert(r); + assert(e); + assert(r); finish(r, AVAHI_RESOLVER_TIMEOUT); } -AvahiServiceResolver *avahi_service_resolver_new(AvahiServer *server, AvahiIfIndex interface, AvahiProtocol protocol, const gchar *name, const gchar *type, const gchar *domain, AvahiProtocol aprotocol, AvahiServiceResolverCallback callback, gpointer userdata) { +AvahiServiceResolver *avahi_service_resolver_new(AvahiServer *server, AvahiIfIndex interface, AvahiProtocol protocol, const char *name, const char *type, const char *domain, AvahiProtocol aprotocol, AvahiServiceResolverCallback callback, void* userdata) { AvahiServiceResolver *r; AvahiKey *k; struct timeval tv; - gchar t[256], *n; + char t[256], *n; size_t l; - g_assert(server); - g_assert(name); - g_assert(type); - g_assert(callback); + assert(server); + assert(name); + assert(type); + assert(callback); - g_assert(aprotocol == AVAHI_PROTO_UNSPEC || aprotocol == AVAHI_PROTO_INET || aprotocol == AVAHI_PROTO_INET6); + assert(aprotocol == AVAHI_PROTO_UNSPEC || aprotocol == AVAHI_PROTO_INET || aprotocol == AVAHI_PROTO_INET6); if (!avahi_is_valid_service_name(name)) { avahi_server_set_errno(server, AVAHI_ERR_INVALID_SERVICE_NAME); @@ -222,9 +225,13 @@ AvahiServiceResolver *avahi_service_resolver_new(AvahiServer *server, AvahiIfInd return NULL; } - r = g_new(AvahiServiceResolver, 1); + if (!(r = avahi_new(AvahiServiceResolver, 1))) { + avahi_server_set_errno(server, AVAHI_ERR_NO_MEMORY); + return NULL; + } + r->server = server; - r->service_name = g_strdup(name); + r->service_name = avahi_strdup(name); r->service_type = avahi_normalize_name(type); r->domain_name = avahi_normalize_name(domain); r->callback = callback; @@ -236,11 +243,11 @@ AvahiServiceResolver *avahi_service_resolver_new(AvahiServer *server, AvahiIfInd n = t; l = sizeof(t); - avahi_escape_label((const guint8*) name, strlen(name), &n, &l); - g_snprintf(n, l, ".%s.%s", r->service_type, r->domain_name); + avahi_escape_label((const uint8_t*) name, strlen(name), &n, &l); + snprintf(n, l, ".%s.%s", r->service_type, r->domain_name); avahi_elapse_time(&tv, 1000, 0); - r->time_event = avahi_time_event_queue_add(server->time_event_queue, &tv, time_event_callback, r); + r->time_event = avahi_time_event_new(server->time_event_queue, &tv, time_event_callback, r); AVAHI_LLIST_PREPEND(AvahiServiceResolver, resolver, server->service_resolvers, r); @@ -268,12 +275,12 @@ AvahiServiceResolver *avahi_service_resolver_new(AvahiServer *server, AvahiIfInd } void avahi_service_resolver_free(AvahiServiceResolver *r) { - g_assert(r); + assert(r); AVAHI_LLIST_REMOVE(AvahiServiceResolver, resolver, r->server->service_resolvers, r); if (r->time_event) - avahi_time_event_queue_remove(r->server->time_event_queue, r->time_event); + avahi_time_event_free(r->time_event); if (r->record_browser_srv) avahi_record_browser_free(r->record_browser_srv); @@ -291,8 +298,8 @@ void avahi_service_resolver_free(AvahiServiceResolver *r) { if (r->address_record) avahi_record_unref(r->address_record); - g_free(r->service_name); - g_free(r->service_type); - g_free(r->domain_name); - g_free(r); + avahi_free(r->service_name); + avahi_free(r->service_type); + avahi_free(r->domain_name); + avahi_free(r); } diff --git a/avahi-core/response-sched.c b/avahi-core/response-sched.c index efb6677..08598fc 100644 --- a/avahi-core/response-sched.c +++ b/avahi-core/response-sched.c @@ -24,6 +24,8 @@ #endif #include <avahi-common/timeval.h> +#include <avahi-common/malloc.h> + #include "response-sched.h" #include "log.h" @@ -48,9 +50,9 @@ struct AvahiResponseJob { struct timeval delivery; AvahiRecord *record; - gboolean flush_cache; + int flush_cache; AvahiAddress querier; - gboolean querier_valid; + int querier_valid; AVAHI_LLIST_FIELDS(AvahiResponseJob, jobs); }; @@ -67,15 +69,19 @@ struct AvahiResponseScheduler { static AvahiResponseJob* job_new(AvahiResponseScheduler *s, AvahiRecord *record, AvahiResponseJobState state) { AvahiResponseJob *rj; - g_assert(s); - g_assert(record); + assert(s); + assert(record); - rj = g_new(AvahiResponseJob, 1); + if (!(rj = avahi_new(AvahiResponseJob, 1))) { + avahi_log_error(__FILE__": Out of memory"); + return NULL; + } + rj->scheduler = s; rj->record = avahi_record_ref(record); rj->time_event = NULL; - rj->flush_cache = FALSE; - rj->querier_valid = FALSE; + rj->flush_cache = 0; + rj->querier_valid = 0; if ((rj->state = state) == AVAHI_SCHEDULED) AVAHI_LLIST_PREPEND(AvahiResponseJob, jobs, s->jobs, rj); @@ -88,11 +94,11 @@ static AvahiResponseJob* job_new(AvahiResponseScheduler *s, AvahiRecord *record, } static void job_free(AvahiResponseScheduler *s, AvahiResponseJob *rj) { - g_assert(s); - g_assert(rj); + assert(s); + assert(rj); if (rj->time_event) - avahi_time_event_queue_remove(s->time_event_queue, rj->time_event); + avahi_time_event_free(rj->time_event); if (rj->state == AVAHI_SCHEDULED) AVAHI_LLIST_REMOVE(AvahiResponseJob, jobs, s->jobs, rj); @@ -102,30 +108,30 @@ static void job_free(AvahiResponseScheduler *s, AvahiResponseJob *rj) { AVAHI_LLIST_REMOVE(AvahiResponseJob, jobs, s->suppressed, rj); avahi_record_unref(rj->record); - g_free(rj); + avahi_free(rj); } -static void elapse_callback(AvahiTimeEvent *e, gpointer data); +static void elapse_callback(AvahiTimeEvent *e, void* data); -static void job_set_elapse_time(AvahiResponseScheduler *s, AvahiResponseJob *rj, guint msec, guint jitter) { +static void job_set_elapse_time(AvahiResponseScheduler *s, AvahiResponseJob *rj, unsigned msec, unsigned jitter) { struct timeval tv; - g_assert(s); - g_assert(rj); + assert(s); + assert(rj); avahi_elapse_time(&tv, msec, jitter); if (rj->time_event) - avahi_time_event_queue_update(s->time_event_queue, rj->time_event, &tv); + avahi_time_event_update(rj->time_event, &tv); else - rj->time_event = avahi_time_event_queue_add(s->time_event_queue, &tv, elapse_callback, rj); + rj->time_event = avahi_time_event_new(s->time_event_queue, &tv, elapse_callback, rj); } static void job_mark_done(AvahiResponseScheduler *s, AvahiResponseJob *rj) { - g_assert(s); - g_assert(rj); + assert(s); + assert(rj); - g_assert(rj->state == AVAHI_SCHEDULED); + assert(rj->state == AVAHI_SCHEDULED); AVAHI_LLIST_REMOVE(AvahiResponseJob, jobs, s->jobs, rj); AVAHI_LLIST_PREPEND(AvahiResponseJob, jobs, s->history, rj); @@ -139,9 +145,13 @@ static void job_mark_done(AvahiResponseScheduler *s, AvahiResponseJob *rj) { AvahiResponseScheduler *avahi_response_scheduler_new(AvahiInterface *i) { AvahiResponseScheduler *s; - g_assert(i); + assert(i); - s = g_new(AvahiResponseScheduler, 1); + if (!(s = avahi_new(AvahiResponseScheduler, 1))) { + avahi_log_error(__FILE__": Out of memory"); + return NULL; + } + s->interface = i; s->time_event_queue = i->monitor->server->time_event_queue; @@ -153,14 +163,14 @@ AvahiResponseScheduler *avahi_response_scheduler_new(AvahiInterface *i) { } void avahi_response_scheduler_free(AvahiResponseScheduler *s) { - g_assert(s); + assert(s); avahi_response_scheduler_clear(s); - g_free(s); + avahi_free(s); } void avahi_response_scheduler_clear(AvahiResponseScheduler *s) { - g_assert(s); + assert(s); while (s->jobs) job_free(s, s->jobs); @@ -170,40 +180,41 @@ void avahi_response_scheduler_clear(AvahiResponseScheduler *s) { job_free(s, s->suppressed); } -static void enumerate_aux_records_callback(AvahiServer *s, AvahiRecord *r, gboolean flush_cache, gpointer userdata) { +static void enumerate_aux_records_callback(AvahiServer *s, AvahiRecord *r, int flush_cache, void* userdata) { AvahiResponseJob *rj = userdata; - g_assert(r); - g_assert(rj); + assert(r); + assert(rj); - avahi_response_scheduler_post(rj->scheduler, r, flush_cache, rj->querier_valid ? &rj->querier : NULL, FALSE); + avahi_response_scheduler_post(rj->scheduler, r, flush_cache, rj->querier_valid ? &rj->querier : NULL, 0); } -static gboolean packet_add_response_job(AvahiResponseScheduler *s, AvahiDnsPacket *p, AvahiResponseJob *rj) { - g_assert(s); - g_assert(p); - g_assert(rj); +static int packet_add_response_job(AvahiResponseScheduler *s, AvahiDnsPacket *p, AvahiResponseJob *rj) { + assert(s); + assert(p); + assert(rj); /* Try to add this record to the packet */ if (!avahi_dns_packet_append_record(p, rj->record, rj->flush_cache, 0)) - return FALSE; + return 0; /* Ok, this record will definitely be sent, so schedule the * auxilliary packets, too */ avahi_server_enumerate_aux_records(s->interface->monitor->server, s->interface, rj->record, enumerate_aux_records_callback, rj); job_mark_done(s, rj); - return TRUE; + return 1; } static void send_response_packet(AvahiResponseScheduler *s, AvahiResponseJob *rj) { AvahiDnsPacket *p; - guint n; + unsigned n; - g_assert(s); - g_assert(rj); + assert(s); + assert(rj); - p = avahi_dns_packet_new_response(s->interface->hardware->mtu, TRUE); + if (!(p = avahi_dns_packet_new_response(s->interface->hardware->mtu, 1))) + return; /* OOM */ n = 1; /* Put it in the packet. */ @@ -219,7 +230,7 @@ static void send_response_packet(AvahiResponseScheduler *s, AvahiResponseJob *rj } } else { - guint size; + size_t size; avahi_dns_packet_free(p); @@ -229,7 +240,8 @@ static void send_response_packet(AvahiResponseScheduler *s, AvahiResponseJob *rj if (size > AVAHI_DNS_PACKET_MAX_SIZE) size = AVAHI_DNS_PACKET_MAX_SIZE; - p = avahi_dns_packet_new_response(size, TRUE); + if (!(p = avahi_dns_packet_new_response(size, 1))) + return; /* OOM */ if (!packet_add_response_job(s, p, rj)) { avahi_dns_packet_free(p); @@ -245,10 +257,10 @@ static void send_response_packet(AvahiResponseScheduler *s, AvahiResponseJob *rj avahi_dns_packet_free(p); } -static void elapse_callback(AvahiTimeEvent *e, gpointer data) { +static void elapse_callback(AvahiTimeEvent *e, void* data) { AvahiResponseJob *rj = data; - g_assert(rj); + assert(rj); if (rj->state == AVAHI_DONE || rj->state == AVAHI_SUPPRESSED) job_free(rj->scheduler, rj); /* Lets drop this entry */ @@ -259,11 +271,11 @@ static void elapse_callback(AvahiTimeEvent *e, gpointer data) { static AvahiResponseJob* find_scheduled_job(AvahiResponseScheduler *s, AvahiRecord *record) { AvahiResponseJob *rj; - g_assert(s); - g_assert(record); + assert(s); + assert(record); for (rj = s->jobs; rj; rj = rj->jobs_next) { - g_assert(rj->state == AVAHI_SCHEDULED); + assert(rj->state == AVAHI_SCHEDULED); if (avahi_record_equal_no_ttl(rj->record, record)) return rj; @@ -275,11 +287,11 @@ static AvahiResponseJob* find_scheduled_job(AvahiResponseScheduler *s, AvahiReco static AvahiResponseJob* find_history_job(AvahiResponseScheduler *s, AvahiRecord *record) { AvahiResponseJob *rj; - g_assert(s); - g_assert(record); + assert(s); + assert(record); for (rj = s->history; rj; rj = rj->jobs_next) { - g_assert(rj->state == AVAHI_DONE); + assert(rj->state == AVAHI_DONE); if (avahi_record_equal_no_ttl(rj->record, record)) { /* Check whether this entry is outdated */ @@ -302,13 +314,13 @@ static AvahiResponseJob* find_history_job(AvahiResponseScheduler *s, AvahiRecord static AvahiResponseJob* find_suppressed_job(AvahiResponseScheduler *s, AvahiRecord *record, const AvahiAddress *querier) { AvahiResponseJob *rj; - g_assert(s); - g_assert(record); - g_assert(querier); + assert(s); + assert(record); + assert(querier); for (rj = s->suppressed; rj; rj = rj->jobs_next) { - g_assert(rj->state == AVAHI_SUPPRESSED); - g_assert(rj->querier_valid); + assert(rj->state == AVAHI_SUPPRESSED); + assert(rj->querier_valid); if (avahi_record_equal_no_ttl(rj->record, record) && avahi_address_cmp(&rj->querier, querier) == 0) { @@ -327,19 +339,19 @@ static AvahiResponseJob* find_suppressed_job(AvahiResponseScheduler *s, AvahiRec return NULL; } -gboolean avahi_response_scheduler_post(AvahiResponseScheduler *s, AvahiRecord *record, gboolean flush_cache, const AvahiAddress *querier, gboolean immediately) { +int avahi_response_scheduler_post(AvahiResponseScheduler *s, AvahiRecord *record, int flush_cache, const AvahiAddress *querier, int immediately) { AvahiResponseJob *rj; struct timeval tv; -/* gchar *t; */ +/* char *t; */ - g_assert(s); - g_assert(record); + assert(s); + assert(record); - g_assert(!avahi_key_is_pattern(record->key)); + assert(!avahi_key_is_pattern(record->key)); /* t = avahi_record_to_string(record); */ /* avahi_log_debug("post %i %s", immediately, t); */ -/* g_free(t); */ +/* avahi_free(t); */ /* Check whether this response is suppressed */ if (querier && @@ -348,7 +360,7 @@ gboolean avahi_response_scheduler_post(AvahiResponseScheduler *s, AvahiRecord *r rj->record->ttl >= record->ttl/2) { /* avahi_log_debug("Response suppressed by known answer suppression."); */ - return FALSE; + return 0; } /* Check if we already sent this response recently */ @@ -358,7 +370,7 @@ gboolean avahi_response_scheduler_post(AvahiResponseScheduler *s, AvahiRecord *r rj->record->ttl >= record->ttl/2 && (rj->flush_cache || !flush_cache)) { /* avahi_log_debug("Response suppressed by local duplicate suppression (history)"); */ - return FALSE; + return 0; } /* Outdated ... */ @@ -375,41 +387,43 @@ gboolean avahi_response_scheduler_post(AvahiResponseScheduler *s, AvahiRecord *r /* Update the time if the new is prior to the old */ if (avahi_timeval_compare(&tv, &rj->delivery) < 0) { rj->delivery = tv; - avahi_time_event_queue_update(s->time_event_queue, rj->time_event, &rj->delivery); + avahi_time_event_update(rj->time_event, &rj->delivery); } /* Update the flush cache bit */ if (flush_cache) - rj->flush_cache = TRUE; + rj->flush_cache = 1; /* Update the querier field */ if (!querier || (rj->querier_valid && avahi_address_cmp(querier, &rj->querier) != 0)) - rj->querier_valid = FALSE; + rj->querier_valid = 0; /* Update record data (just for the TTL) */ avahi_record_unref(rj->record); rj->record = avahi_record_ref(record); - return TRUE; + return 1; } else { /* avahi_log_debug("Accepted new response job."); */ /* Create a new job and schedule it */ - rj = job_new(s, record, AVAHI_SCHEDULED); + if (!(rj = job_new(s, record, AVAHI_SCHEDULED))) + return 0; /* OOM */ + rj->delivery = tv; - rj->time_event = avahi_time_event_queue_add(s->time_event_queue, &rj->delivery, elapse_callback, rj); + rj->time_event = avahi_time_event_new(s->time_event_queue, &rj->delivery, elapse_callback, rj); rj->flush_cache = flush_cache; if ((rj->querier_valid = !!querier)) rj->querier = *querier; - return TRUE; + return 1; } } -void avahi_response_scheduler_incoming(AvahiResponseScheduler *s, AvahiRecord *record, gboolean flush_cache) { +void avahi_response_scheduler_incoming(AvahiResponseScheduler *s, AvahiRecord *record, int flush_cache) { AvahiResponseJob *rj; - g_assert(s); + assert(s); /* This function is called whenever an incoming response was * receieved. We drop scheduled responses which match here. The @@ -435,10 +449,11 @@ void avahi_response_scheduler_incoming(AvahiResponseScheduler *s, AvahiRecord *r rj->record = avahi_record_ref(record); } else /* Found no existing history job, so let's create a new one */ - rj = job_new(s, record, AVAHI_DONE); + if (!(rj = job_new(s, record, AVAHI_DONE))) + return; /* OOM */ rj->flush_cache = flush_cache; - rj->querier_valid = FALSE; + rj->querier_valid = 0; gettimeofday(&rj->delivery, NULL); job_set_elapse_time(s, rj, AVAHI_RESPONSE_HISTORY_MSEC, 0); @@ -447,9 +462,9 @@ void avahi_response_scheduler_incoming(AvahiResponseScheduler *s, AvahiRecord *r void avahi_response_scheduler_suppress(AvahiResponseScheduler *s, AvahiRecord *record, const AvahiAddress *querier) { AvahiResponseJob *rj; - g_assert(s); - g_assert(record); - g_assert(querier); + assert(s); + assert(record); + assert(querier); if ((rj = find_scheduled_job(s, record))) { @@ -472,8 +487,9 @@ void avahi_response_scheduler_suppress(AvahiResponseScheduler *s, AvahiRecord *r } else { /* Create a new entry */ - rj = job_new(s, record, AVAHI_SUPPRESSED); - rj->querier_valid = TRUE; + if (!(rj = job_new(s, record, AVAHI_SUPPRESSED))) + return; /* OOM */ + rj->querier_valid = 1; rj->querier = *querier; } @@ -482,7 +498,7 @@ void avahi_response_scheduler_suppress(AvahiResponseScheduler *s, AvahiRecord *r } void avahi_response_scheduler_force(AvahiResponseScheduler *s) { - g_assert(s); + assert(s); /* Send all scheduled responses immediately */ while (s->jobs) diff --git a/avahi-core/response-sched.h b/avahi-core/response-sched.h index 3760a44..68c4a9d 100644 --- a/avahi-core/response-sched.h +++ b/avahi-core/response-sched.h @@ -32,8 +32,8 @@ void avahi_response_scheduler_free(AvahiResponseScheduler *s); void avahi_response_scheduler_clear(AvahiResponseScheduler *s); void avahi_response_scheduler_force(AvahiResponseScheduler *s); -gboolean avahi_response_scheduler_post(AvahiResponseScheduler *s, AvahiRecord *record, gboolean flush_cache, const AvahiAddress *querier, gboolean immediately); -void avahi_response_scheduler_incoming(AvahiResponseScheduler *s, AvahiRecord *record, gboolean flush_cache); +int avahi_response_scheduler_post(AvahiResponseScheduler *s, AvahiRecord *record, int flush_cache, const AvahiAddress *querier, int immediately); +void avahi_response_scheduler_incoming(AvahiResponseScheduler *s, AvahiRecord *record, int flush_cache); void avahi_response_scheduler_suppress(AvahiResponseScheduler *s, AvahiRecord *record, const AvahiAddress *querier); #endif diff --git a/avahi-core/rr.c b/avahi-core/rr.c index 821ca8f..704f5be 100644 --- a/avahi-core/rr.c +++ b/avahi-core/rr.c @@ -36,6 +36,7 @@ #include "rr.h" #include "log.h" #include "util.h" +#include "hashmap.h" AvahiKey *avahi_key_new(const char *name, uint16_t class, uint16_t type) { AvahiKey *k; @@ -263,12 +264,12 @@ char *avahi_record_to_string(const AvahiRecord *r) { return s; } -gboolean avahi_key_equal(const AvahiKey *a, const AvahiKey *b) { +int avahi_key_equal(const AvahiKey *a, const AvahiKey *b) { assert(a); assert(b); if (a == b) - return TRUE; + return 1; /* g_message("equal: %p %p", a, b); */ @@ -277,7 +278,7 @@ gboolean avahi_key_equal(const AvahiKey *a, const AvahiKey *b) { a->clazz == b->clazz; } -gboolean avahi_key_pattern_match(const AvahiKey *pattern, const AvahiKey *k) { +int avahi_key_pattern_match(const AvahiKey *pattern, const AvahiKey *k) { assert(pattern); assert(k); @@ -286,14 +287,14 @@ gboolean avahi_key_pattern_match(const AvahiKey *pattern, const AvahiKey *k) { assert(!avahi_key_is_pattern(k)); if (pattern == k) - return TRUE; + return 1; return avahi_domain_equal(pattern->name, k->name) && (pattern->type == k->type || pattern->type == AVAHI_DNS_TYPE_ANY) && (pattern->clazz == k->clazz || pattern->clazz == AVAHI_DNS_CLASS_ANY); } -gboolean avahi_key_is_pattern(const AvahiKey *k) { +int avahi_key_is_pattern(const AvahiKey *k) { assert(k); return @@ -301,7 +302,7 @@ gboolean avahi_key_is_pattern(const AvahiKey *k) { k->clazz == AVAHI_DNS_CLASS_ANY; } -guint avahi_key_hash(const AvahiKey *k) { +unsigned avahi_key_hash(const AvahiKey *k) { assert(k); return @@ -310,7 +311,7 @@ guint avahi_key_hash(const AvahiKey *k) { k->clazz; } -static gboolean rdata_equal(const AvahiRecord *a, const AvahiRecord *b) { +static int rdata_equal(const AvahiRecord *a, const AvahiRecord *b) { assert(a); assert(b); assert(a->key->type == b->key->type); @@ -357,12 +358,12 @@ static gboolean rdata_equal(const AvahiRecord *a, const AvahiRecord *b) { } -gboolean avahi_record_equal_no_ttl(const AvahiRecord *a, const AvahiRecord *b) { +int avahi_record_equal_no_ttl(const AvahiRecord *a, const AvahiRecord *b) { assert(a); assert(b); if (a == b) - return TRUE; + return 1; return avahi_key_equal(a->key, b->key) && @@ -446,7 +447,7 @@ size_t avahi_key_get_estimate_size(AvahiKey *k) { } size_t avahi_record_get_estimate_size(AvahiRecord *r) { - guint n; + size_t n; assert(r); n = avahi_key_get_estimate_size(r->key) + 4 + 2; @@ -552,12 +553,16 @@ int avahi_record_lexicographical_compare(AvahiRecord *a, AvahiRecord *b) { case AVAHI_DNS_TYPE_TXT: { - guint8 *ma, *mb; - guint asize, bsize; + uint8_t *ma = NULL, *mb = NULL; + size_t asize, bsize; - if (!(ma = avahi_new(guint8, asize = avahi_string_list_serialize(a->data.txt.string_list, NULL, 0)))) + asize = avahi_string_list_serialize(a->data.txt.string_list, NULL, 0); + bsize = avahi_string_list_serialize(b->data.txt.string_list, NULL, 0); + + if (asize > 0 && !(ma = avahi_new(uint8_t, asize))) goto fail; - if (!(mb = g_new(guint8, bsize = avahi_string_list_serialize(b->data.txt.string_list, NULL, 0)))) { + + if (bsize > 0 && !(mb = avahi_new(uint8_t, bsize))) { avahi_free(ma); goto fail; } @@ -593,7 +598,7 @@ int avahi_record_lexicographical_compare(AvahiRecord *a, AvahiRecord *b) { fail: - avahi_log_error("Out of memory"); + avahi_log_error(__FILE__": Out of memory"); return -1; /* or whatever ... */ } @@ -607,9 +612,9 @@ int avahi_key_is_valid(AvahiKey *k) { assert(k); if (!avahi_is_valid_domain_name(k->name)) - return FALSE; + return 0; - return TRUE; + return 1; } int avahi_record_is_valid(AvahiRecord *r) { diff --git a/avahi-core/rr.h b/avahi-core/rr.h index 5349076..9fdcb0e 100644 --- a/avahi-core/rr.h +++ b/avahi-core/rr.h @@ -169,12 +169,12 @@ const char *avahi_dns_class_to_string(uint16_t clazz); * returned pointer points to a read only internal string. */ const char *avahi_dns_type_to_string(uint16_t type); -/** Create a textual representation of the specified key. g_free() the +/** Create a textual representation of the specified key. avahi_free() the * result! */ char *avahi_key_to_string(const AvahiKey *k); /** Create a textual representation of the specified record, similar - * in style to BIND zone file data. g_free() the result! */ + * in style to BIND zone file data. avahi_free() the result! */ char *avahi_record_to_string(const AvahiRecord *r); /** Check whether two records are equal (regardless of the TTL */ @@ -196,7 +196,7 @@ size_t avahi_record_get_estimate_size(AvahiRecord *r); * zero if equal. */ int avahi_record_lexicographical_compare(AvahiRecord *a, AvahiRecord *b); -/** Return TRUE if the specified record is an mDNS goodbye record. i.e. TTL is zero. */ +/** Return 1 if the specified record is an mDNS goodbye record. i.e. TTL is zero. */ int avahi_record_is_goodbye(AvahiRecord *r); /** Check whether the specified key is valid */ diff --git a/avahi-core/rrlist.c b/avahi-core/rrlist.c index b05e1c6..fce21ff 100644 --- a/avahi-core/rrlist.c +++ b/avahi-core/rrlist.c @@ -106,7 +106,7 @@ AvahiRecord* avahi_record_list_next(AvahiRecordList *l, int *flush_cache, int *u AVAHI_LLIST_REMOVE(AvahiRecordListItem, items, l->unread, i); AVAHI_LLIST_PREPEND(AvahiRecordListItem, items, l->read, i); - i->read = TRUE; + i->read = 1; return r; } @@ -146,7 +146,7 @@ void avahi_record_list_push(AvahiRecordList *l, AvahiRecord *r, int flush_cache, i->flush_cache = flush_cache; i->auxiliary = auxiliary; i->record = avahi_record_ref(r); - i->read = FALSE; + i->read = 0; AVAHI_LLIST_PREPEND(AvahiRecordListItem, items, l->unread, i); } diff --git a/avahi-core/server.c b/avahi-core/server.c index 1a36e42..a3fac4b 100644 --- a/avahi-core/server.c +++ b/avahi-core/server.c @@ -30,15 +30,18 @@ #include <unistd.h> #include <errno.h> #include <stdio.h> +#include <assert.h> #include <avahi-common/domain.h> #include <avahi-common/timeval.h> +#include <avahi-common/malloc.h> #include "server.h" #include "iface.h" #include "socket.h" #include "browse.h" #include "log.h" +#include "util.h" #define AVAHI_RR_HOLDOFF_MSEC 1000 #define AVAHI_RR_HOLDOFF_MSEC_RATE_LIMIT 60000 @@ -47,101 +50,103 @@ static void free_entry(AvahiServer*s, AvahiEntry *e) { AvahiEntry *t; - g_assert(s); - g_assert(e); + assert(s); + assert(e); - avahi_goodbye_entry(s, e, TRUE); + avahi_goodbye_entry(s, e, 1); /* Remove from linked list */ AVAHI_LLIST_REMOVE(AvahiEntry, entries, s->entries, e); /* Remove from hash table indexed by name */ - t = g_hash_table_lookup(s->entries_by_key, e->record->key); + t = avahi_hashmap_lookup(s->entries_by_key, e->record->key); AVAHI_LLIST_REMOVE(AvahiEntry, by_key, t, e); if (t) - g_hash_table_replace(s->entries_by_key, t->record->key, t); + avahi_hashmap_replace(s->entries_by_key, t->record->key, t); else - g_hash_table_remove(s->entries_by_key, e->record->key); + avahi_hashmap_remove(s->entries_by_key, e->record->key); /* Remove from associated group */ if (e->group) AVAHI_LLIST_REMOVE(AvahiEntry, by_group, e->group->entries, e); avahi_record_unref(e->record); - g_free(e); + avahi_free(e); } static void free_group(AvahiServer *s, AvahiEntryGroup *g) { - g_assert(s); - g_assert(g); + assert(s); + assert(g); while (g->entries) free_entry(s, g->entries); if (g->register_time_event) - avahi_time_event_queue_remove(s->time_event_queue, g->register_time_event); + avahi_time_event_free(g->register_time_event); AVAHI_LLIST_REMOVE(AvahiEntryGroup, groups, s->groups, g); - g_free(g); + avahi_free(g); } static void cleanup_dead(AvahiServer *s) { - AvahiEntryGroup *g, *ng; - AvahiEntry *e, *ne; - g_assert(s); - + assert(s); if (s->need_group_cleanup) { - for (g = s->groups; g; g = ng) { - ng = g->groups_next; + AvahiEntryGroup *g, *next; + + for (g = s->groups; g; g = next) { + next = g->groups_next; if (g->dead) free_group(s, g); } - s->need_group_cleanup = FALSE; + s->need_group_cleanup = 0; } if (s->need_entry_cleanup) { - for (e = s->entries; e; e = ne) { - ne = e->entries_next; + AvahiEntry *e, *next; + + for (e = s->entries; e; e = next) { + next = e->entries_next; if (e->dead) free_entry(s, e); } - s->need_entry_cleanup = FALSE; + s->need_entry_cleanup = 0; } if (s->need_browser_cleanup) avahi_browser_cleanup(s); } -static void enum_aux_records(AvahiServer *s, AvahiInterface *i, const gchar *name, guint16 type, void (*callback)(AvahiServer *s, AvahiRecord *r, gboolean flush_cache, gpointer userdata), gpointer userdata) { +static void enum_aux_records(AvahiServer *s, AvahiInterface *i, const char *name, uint16_t type, void (*callback)(AvahiServer *s, AvahiRecord *r, int flush_cache, void* userdata), void* userdata) { AvahiKey *k; AvahiEntry *e; - g_assert(s); - g_assert(i); - g_assert(name); - g_assert(callback); + assert(s); + assert(i); + assert(name); + assert(callback); - g_assert(type != AVAHI_DNS_TYPE_ANY); + assert(type != AVAHI_DNS_TYPE_ANY); - k = avahi_key_new(name, AVAHI_DNS_CLASS_IN, type); + if (!(k = avahi_key_new(name, AVAHI_DNS_CLASS_IN, type))) + return; /** OOM */ - for (e = g_hash_table_lookup(s->entries_by_key, k); e; e = e->by_key_next) - if (!e->dead && avahi_entry_registered(s, e, i)) + for (e = avahi_hashmap_lookup(s->entries_by_key, k); e; e = e->by_key_next) + if (!e->dead && avahi_entry_is_registered(s, e, i)) callback(s, e->record, e->flags & AVAHI_ENTRY_UNIQUE, userdata); avahi_key_unref(k); } -void avahi_server_enumerate_aux_records(AvahiServer *s, AvahiInterface *i, AvahiRecord *r, void (*callback)(AvahiServer *s, AvahiRecord *r, gboolean flush_cache, gpointer userdata), gpointer userdata) { - g_assert(s); - g_assert(i); - g_assert(r); - g_assert(callback); +void avahi_server_enumerate_aux_records(AvahiServer *s, AvahiInterface *i, AvahiRecord *r, void (*callback)(AvahiServer *s, AvahiRecord *r, int flush_cache, void* userdata), void* userdata) { + assert(s); + assert(i); + assert(r); + assert(callback); if (r->key->clazz == AVAHI_DNS_CLASS_IN) { if (r->key->type == AVAHI_DNS_TYPE_PTR) { @@ -154,54 +159,54 @@ void avahi_server_enumerate_aux_records(AvahiServer *s, AvahiInterface *i, Avahi } } -void avahi_server_prepare_response(AvahiServer *s, AvahiInterface *i, AvahiEntry *e, gboolean unicast_response, gboolean auxiliary) { - g_assert(s); - g_assert(i); - g_assert(e); +void avahi_server_prepare_response(AvahiServer *s, AvahiInterface *i, AvahiEntry *e, int unicast_response, int auxiliary) { + assert(s); + assert(i); + assert(e); avahi_record_list_push(s->record_list, e->record, e->flags & AVAHI_ENTRY_UNIQUE, unicast_response, auxiliary); } -void avahi_server_prepare_matching_responses(AvahiServer *s, AvahiInterface *i, AvahiKey *k, gboolean unicast_response) { +void avahi_server_prepare_matching_responses(AvahiServer *s, AvahiInterface *i, AvahiKey *k, int unicast_response) { AvahiEntry *e; -/* gchar *txt; */ +/* char *txt; */ - g_assert(s); - g_assert(i); - g_assert(k); + assert(s); + assert(i); + assert(k); /* avahi_log_debug("Posting responses matching [%s]", txt = avahi_key_to_string(k)); */ -/* g_free(txt); */ +/* avahi_free(txt); */ if (avahi_key_is_pattern(k)) { /* Handle ANY query */ for (e = s->entries; e; e = e->entries_next) - if (!e->dead && avahi_key_pattern_match(k, e->record->key) && avahi_entry_registered(s, e, i)) - avahi_server_prepare_response(s, i, e, unicast_response, FALSE); + if (!e->dead && avahi_key_pattern_match(k, e->record->key) && avahi_entry_is_registered(s, e, i)) + avahi_server_prepare_response(s, i, e, unicast_response, 0); } else { /* Handle all other queries */ - for (e = g_hash_table_lookup(s->entries_by_key, k); e; e = e->by_key_next) - if (!e->dead && avahi_entry_registered(s, e, i)) - avahi_server_prepare_response(s, i, e, unicast_response, FALSE); + for (e = avahi_hashmap_lookup(s->entries_by_key, k); e; e = e->by_key_next) + if (!e->dead && avahi_entry_is_registered(s, e, i)) + avahi_server_prepare_response(s, i, e, unicast_response, 0); } } static void withdraw_entry(AvahiServer *s, AvahiEntry *e) { - g_assert(s); - g_assert(e); + assert(s); + assert(e); if (e->group) { AvahiEntry *k; for (k = e->group->entries; k; k = k->by_group_next) { if (!k->dead) { - avahi_goodbye_entry(s, k, FALSE); - k->dead = TRUE; + avahi_goodbye_entry(s, k, 0); + k->dead = 1; } } @@ -209,54 +214,54 @@ static void withdraw_entry(AvahiServer *s, AvahiEntry *e) { avahi_entry_group_change_state(e->group, AVAHI_ENTRY_GROUP_COLLISION); } else { - avahi_goodbye_entry(s, e, FALSE); - e->dead = TRUE; + avahi_goodbye_entry(s, e, 0); + e->dead = 1; } - s->need_entry_cleanup = TRUE; + s->need_entry_cleanup = 1; } static void withdraw_rrset(AvahiServer *s, AvahiKey *key) { AvahiEntry *e; - g_assert(s); - g_assert(key); + assert(s); + assert(key); - for (e = g_hash_table_lookup(s->entries_by_key, key); e; e = e->by_key_next) + for (e = avahi_hashmap_lookup(s->entries_by_key, key); e; e = e->by_key_next) if (!e->dead) withdraw_entry(s, e); } static void incoming_probe(AvahiServer *s, AvahiRecord *record, AvahiInterface *i) { AvahiEntry *e, *n; - gchar *t; - gboolean ours = FALSE, won = FALSE, lost = FALSE; + char *t; + int ours = 0, won = 0, lost = 0; - g_assert(s); - g_assert(record); - g_assert(i); + assert(s); + assert(record); + assert(i); t = avahi_record_to_string(record); /* avahi_log_debug("incoming_probe()"); */ - for (e = g_hash_table_lookup(s->entries_by_key, record->key); e; e = n) { - gint cmp; + for (e = avahi_hashmap_lookup(s->entries_by_key, record->key); e; e = n) { + int cmp; n = e->by_key_next; if (e->dead) continue; if ((cmp = avahi_record_lexicographical_compare(e->record, record)) == 0) { - ours = TRUE; + ours = 1; break; } else { - if (avahi_entry_probing(s, e, i)) { + if (avahi_entry_is_probing(s, e, i)) { if (cmp > 0) - won = TRUE; + won = 1; else /* cmp < 0 */ - lost = TRUE; + lost = 1; } } } @@ -273,21 +278,21 @@ static void incoming_probe(AvahiServer *s, AvahiRecord *record, AvahiInterface * /* avahi_log_debug("Not conflicting probe"); */ } - g_free(t); + avahi_free(t); } -static gboolean handle_conflict(AvahiServer *s, AvahiInterface *i, AvahiRecord *record, gboolean unique, const AvahiAddress *a) { - gboolean valid = TRUE, ours = FALSE, conflict = FALSE, withdraw_immediately = FALSE; +static int handle_conflict(AvahiServer *s, AvahiInterface *i, AvahiRecord *record, int unique, const AvahiAddress *a) { + int valid = 1, ours = 0, conflict = 0, withdraw_immediately = 0; AvahiEntry *e, *n, *conflicting_entry = NULL; - g_assert(s); - g_assert(i); - g_assert(record); + assert(s); + assert(i); + assert(record); /* avahi_log_debug("CHECKING FOR CONFLICT: [%s]", t); */ - for (e = g_hash_table_lookup(s->entries_by_key, record->key); e; e = n) { + for (e = avahi_hashmap_lookup(s->entries_by_key, record->key); e; e = n) { n = e->by_key_next; if (e->dead || (!(e->flags & AVAHI_ENTRY_UNIQUE) && !unique)) @@ -296,20 +301,20 @@ static gboolean handle_conflict(AvahiServer *s, AvahiInterface *i, AvahiRecord * /* Either our entry or the other is intended to be unique, so let's check */ if (avahi_record_equal_no_ttl(e->record, record)) { - ours = TRUE; /* We have an identical record, so this is no conflict */ + ours = 1; /* We have an identical record, so this is no conflict */ /* Check wheter there is a TTL conflict */ if (record->ttl <= e->record->ttl/2 && - avahi_entry_registered(s, e, i)) { - gchar *t; + avahi_entry_is_registered(s, e, i)) { + char *t; /* Refresh */ t = avahi_record_to_string(record); avahi_log_debug("Recieved record with bad TTL [%s]. Refreshing.", t); - avahi_server_prepare_matching_responses(s, i, e->record->key, FALSE); - valid = FALSE; + avahi_server_prepare_matching_responses(s, i, e->record->key, 0); + valid = 0; - g_free(t); + avahi_free(t); } /* There's no need to check the other entries of this RRset */ @@ -317,19 +322,19 @@ static gboolean handle_conflict(AvahiServer *s, AvahiInterface *i, AvahiRecord * } else { - if (avahi_entry_registered(s, e, i)) { + if (avahi_entry_is_registered(s, e, i)) { /* A conflict => we have to return to probe mode */ - conflict = TRUE; + conflict = 1; conflicting_entry = e; - } else if (avahi_entry_probing(s, e, i)) { + } else if (avahi_entry_is_probing(s, e, i)) { /* We are currently registering a matching record, but * someone else already claimed it, so let's * withdraw */ - conflict = TRUE; - withdraw_immediately = TRUE; + conflict = 1; + withdraw_immediately = 1; } } } @@ -337,9 +342,9 @@ static gboolean handle_conflict(AvahiServer *s, AvahiInterface *i, AvahiRecord * /* avahi_log_debug("ours=%i conflict=%i", ours, conflict); */ if (!ours && conflict) { - gchar *t; + char *t; - valid = FALSE; + valid = 0; t = avahi_record_to_string(record); @@ -347,7 +352,7 @@ static gboolean handle_conflict(AvahiServer *s, AvahiInterface *i, AvahiRecord * avahi_log_debug("Recieved conflicting record [%s] with local record to be. Withdrawing.", t); withdraw_rrset(s, record->key); } else { - g_assert(conflicting_entry); + assert(conflicting_entry); avahi_log_debug("Recieved conflicting record [%s]. Resetting our record.", t); avahi_entry_return_to_initial_state(s, conflicting_entry, i); @@ -355,51 +360,52 @@ static gboolean handle_conflict(AvahiServer *s, AvahiInterface *i, AvahiRecord * * state. Local shared records are reannounced. */ } - g_free(t); + avahi_free(t); } return valid; } -static void append_aux_callback(AvahiServer *s, AvahiRecord *r, gboolean flush_cache, gpointer userdata) { - gboolean *unicast_response = userdata; +static void append_aux_callback(AvahiServer *s, AvahiRecord *r, int flush_cache, void* userdata) { + int *unicast_response = userdata; - g_assert(s); - g_assert(r); - g_assert(unicast_response); + assert(s); + assert(r); + assert(unicast_response); - avahi_record_list_push(s->record_list, r, flush_cache, *unicast_response, TRUE); + avahi_record_list_push(s->record_list, r, flush_cache, *unicast_response, 1); } -static void append_aux_records_to_list(AvahiServer *s, AvahiInterface *i, AvahiRecord *r, gboolean unicast_response) { - g_assert(s); - g_assert(r); +static void append_aux_records_to_list(AvahiServer *s, AvahiInterface *i, AvahiRecord *r, int unicast_response) { + assert(s); + assert(r); avahi_server_enumerate_aux_records(s, i, r, append_aux_callback, &unicast_response); } -void avahi_server_generate_response(AvahiServer *s, AvahiInterface *i, AvahiDnsPacket *p, const AvahiAddress *a, guint16 port, gboolean legacy_unicast, gboolean immediately) { +void avahi_server_generate_response(AvahiServer *s, AvahiInterface *i, AvahiDnsPacket *p, const AvahiAddress *a, uint16_t port, int legacy_unicast, int immediately) { - g_assert(s); - g_assert(i); - g_assert(!legacy_unicast || (a && port > 0 && p)); + assert(s); + assert(i); + assert(!legacy_unicast || (a && port > 0 && p)); if (legacy_unicast) { AvahiDnsPacket *reply; AvahiRecord *r; - reply = avahi_dns_packet_new_reply(p, 512 /* unicast DNS maximum packet size is 512 */ , TRUE, TRUE); + if (!(reply = avahi_dns_packet_new_reply(p, 512 /* unicast DNS maximum packet size is 512 */ , 1, 1))) + return; /* OOM */ while ((r = avahi_record_list_next(s->record_list, NULL, NULL, NULL))) { - append_aux_records_to_list(s, i, r, FALSE); + append_aux_records_to_list(s, i, r, 0); - if (avahi_dns_packet_append_record(reply, r, FALSE, 10)) + if (avahi_dns_packet_append_record(reply, r, 0, 10)) avahi_dns_packet_inc_field(reply, AVAHI_DNS_FIELD_ANCOUNT); else { - gchar *t = avahi_record_to_string(r); + char *t = avahi_record_to_string(r); avahi_log_warn("Record [%s] not fitting in legacy unicast packet, dropping.", t); - g_free(t); + avahi_free(t); } avahi_record_unref(r); @@ -411,14 +417,14 @@ void avahi_server_generate_response(AvahiServer *s, AvahiInterface *i, AvahiDnsP avahi_dns_packet_free(reply); } else { - gboolean unicast_response, flush_cache, auxiliary; + int unicast_response, flush_cache, auxiliary; AvahiDnsPacket *reply = NULL; AvahiRecord *r; /* In case the query packet was truncated never respond immediately, because known answer suppression records might be contained in later packets */ - gboolean tc = p && !!(avahi_dns_packet_get_field(p, AVAHI_DNS_FIELD_FLAGS) & AVAHI_DNS_FLAG_TC); + int tc = p && !!(avahi_dns_packet_get_field(p, AVAHI_DNS_FIELD_FLAGS) & AVAHI_DNS_FLAG_TC); while ((r = avahi_record_list_next(s->record_list, &flush_cache, &unicast_response, &auxiliary))) { @@ -433,8 +439,10 @@ void avahi_server_generate_response(AvahiServer *s, AvahiInterface *i, AvahiDnsP for (;;) { if (!reply) { - g_assert(p); - reply = avahi_dns_packet_new_reply(p, i->hardware->mtu, FALSE, FALSE); + assert(p); + + if (!(reply = avahi_dns_packet_new_reply(p, i->hardware->mtu, 0, 0))) + break; /* OOM */ } if (avahi_dns_packet_append_record(reply, r, flush_cache, 0)) { @@ -448,7 +456,7 @@ void avahi_server_generate_response(AvahiServer *s, AvahiInterface *i, AvahiDnsP } if (avahi_dns_packet_get_field(reply, AVAHI_DNS_FIELD_ANCOUNT) == 0) { - guint size; + size_t size; /* The record is too large for one packet, so create a larger packet */ @@ -456,14 +464,16 @@ void avahi_server_generate_response(AvahiServer *s, AvahiInterface *i, AvahiDnsP size = avahi_record_get_estimate_size(r) + AVAHI_DNS_PACKET_HEADER_SIZE; if (size > AVAHI_DNS_PACKET_MAX_SIZE) size = AVAHI_DNS_PACKET_MAX_SIZE; - reply = avahi_dns_packet_new_reply(p, size, FALSE, TRUE); + + if (!(reply = avahi_dns_packet_new_reply(p, size, 0, 1))) + break; /* OOM */ if (!avahi_dns_packet_append_record(reply, r, flush_cache, 0)) { - gchar *t; + char *t; avahi_dns_packet_free(reply); t = avahi_record_to_string(r); avahi_log_warn("Record [%s] too large, doesn't fit in any packet!", t); - g_free(t); + avahi_free(t); break; } else avahi_dns_packet_inc_field(reply, AVAHI_DNS_FIELD_ANCOUNT); @@ -490,39 +500,39 @@ void avahi_server_generate_response(AvahiServer *s, AvahiInterface *i, AvahiDnsP } -static void reflect_response(AvahiServer *s, AvahiInterface *i, AvahiRecord *r, gboolean flush_cache) { +static void reflect_response(AvahiServer *s, AvahiInterface *i, AvahiRecord *r, int flush_cache) { AvahiInterface *j; - g_assert(s); - g_assert(i); - g_assert(r); + assert(s); + assert(i); + assert(r); if (!s->config.enable_reflector) return; for (j = s->monitor->interfaces; j; j = j->interface_next) if (j != i && (s->config.reflect_ipv || j->protocol == i->protocol)) - avahi_interface_post_response(j, r, flush_cache, NULL, TRUE); + avahi_interface_post_response(j, r, flush_cache, NULL, 1); } -static gpointer reflect_cache_walk_callback(AvahiCache *c, AvahiKey *pattern, AvahiCacheEntry *e, gpointer userdata) { +static void* reflect_cache_walk_callback(AvahiCache *c, AvahiKey *pattern, AvahiCacheEntry *e, void* userdata) { AvahiServer *s = userdata; - g_assert(c); - g_assert(pattern); - g_assert(e); - g_assert(s); + assert(c); + assert(pattern); + assert(e); + assert(s); - avahi_record_list_push(s->record_list, e->record, e->cache_flush, FALSE, FALSE); + avahi_record_list_push(s->record_list, e->record, e->cache_flush, 0, 0); return NULL; } static void reflect_query(AvahiServer *s, AvahiInterface *i, AvahiKey *k) { AvahiInterface *j; - g_assert(s); - g_assert(i); - g_assert(k); + assert(s); + assert(i); + assert(k); if (!s->config.enable_reflector) return; @@ -530,7 +540,7 @@ static void reflect_query(AvahiServer *s, AvahiInterface *i, AvahiKey *k) { for (j = s->monitor->interfaces; j; j = j->interface_next) if (j != i && (s->config.reflect_ipv || j->protocol == i->protocol)) { /* Post the query to other networks */ - avahi_interface_post_query(j, k, TRUE); + avahi_interface_post_query(j, k, 1); /* Reply from caches of other network. This is needed to * "work around" known answer suppression. */ @@ -542,37 +552,37 @@ static void reflect_query(AvahiServer *s, AvahiInterface *i, AvahiKey *k) { static void reflect_probe(AvahiServer *s, AvahiInterface *i, AvahiRecord *r) { AvahiInterface *j; - g_assert(s); - g_assert(i); - g_assert(r); + assert(s); + assert(i); + assert(r); if (!s->config.enable_reflector) return; for (j = s->monitor->interfaces; j; j = j->interface_next) if (j != i && (s->config.reflect_ipv || j->protocol == i->protocol)) - avahi_interface_post_probe(j, r, TRUE); + avahi_interface_post_probe(j, r, 1); } -static void handle_query_packet(AvahiServer *s, AvahiDnsPacket *p, AvahiInterface *i, const AvahiAddress *a, guint16 port, gboolean legacy_unicast) { - guint n; - gboolean is_probe; +static void handle_query_packet(AvahiServer *s, AvahiDnsPacket *p, AvahiInterface *i, const AvahiAddress *a, uint16_t port, int legacy_unicast) { + size_t n; + int is_probe; - g_assert(s); - g_assert(p); - g_assert(i); - g_assert(a); + assert(s); + assert(p); + assert(i); + assert(a); /* avahi_log_debug("query"); */ - g_assert(avahi_record_list_is_empty(s->record_list)); + assert(avahi_record_list_is_empty(s->record_list)); is_probe = avahi_dns_packet_get_field(p, AVAHI_DNS_FIELD_NSCOUNT) > 0; /* Handle the questions */ for (n = avahi_dns_packet_get_field(p, AVAHI_DNS_FIELD_QDCOUNT); n > 0; n --) { AvahiKey *key; - gboolean unicast_response = FALSE; + int unicast_response = 0; if (!(key = avahi_dns_packet_consume_key(p, &unicast_response))) { avahi_log_warn("Packet too short (1)"); @@ -595,7 +605,7 @@ static void handle_query_packet(AvahiServer *s, AvahiDnsPacket *p, AvahiInterfac /* Known Answer Suppression */ for (n = avahi_dns_packet_get_field(p, AVAHI_DNS_FIELD_ANCOUNT); n > 0; n --) { AvahiRecord *record; - gboolean unique = FALSE; + int unique = 0; if (!(record = avahi_dns_packet_consume_record(p, &unique))) { avahi_log_warn("Packet too short (2)"); @@ -613,7 +623,7 @@ static void handle_query_packet(AvahiServer *s, AvahiDnsPacket *p, AvahiInterfac /* Probe record */ for (n = avahi_dns_packet_get_field(p, AVAHI_DNS_FIELD_NSCOUNT); n > 0; n --) { AvahiRecord *record; - gboolean unique = FALSE; + int unique = 0; if (!(record = avahi_dns_packet_consume_record(p, &unique))) { avahi_log_warn("Packet too short (3)"); @@ -638,20 +648,20 @@ fail: } static void handle_response_packet(AvahiServer *s, AvahiDnsPacket *p, AvahiInterface *i, const AvahiAddress *a) { - guint n; + unsigned n; - g_assert(s); - g_assert(p); - g_assert(i); - g_assert(a); + assert(s); + assert(p); + assert(i); + assert(a); /* avahi_log_debug("response"); */ for (n = avahi_dns_packet_get_field(p, AVAHI_DNS_FIELD_ANCOUNT) + avahi_dns_packet_get_field(p, AVAHI_DNS_FIELD_ARCOUNT); n > 0; n--) { AvahiRecord *record; - gboolean cache_flush = FALSE; -/* gchar *txt; */ + int cache_flush = 0; +/* char *txt; */ if (!(record = avahi_dns_packet_consume_record(p, &cache_flush))) { avahi_log_warn("Packet too short (4)"); @@ -661,7 +671,7 @@ static void handle_response_packet(AvahiServer *s, AvahiDnsPacket *p, AvahiInter if (!avahi_key_is_pattern(record->key)) { /* avahi_log_debug("Handling response: %s", txt = avahi_record_to_string(record)); */ -/* g_free(txt); */ +/* avahi_free(txt); */ if (handle_conflict(s, i, record, cache_flush, a)) { reflect_response(s, i, record, cache_flush); @@ -677,17 +687,17 @@ static void handle_response_packet(AvahiServer *s, AvahiDnsPacket *p, AvahiInter records have been scheduling for sending. We need to flush them here. */ if (!avahi_record_list_is_empty(s->record_list)) - avahi_server_generate_response(s, i, NULL, NULL, 0, FALSE, TRUE); + avahi_server_generate_response(s, i, NULL, NULL, 0, 0, 1); } static AvahiLegacyUnicastReflectSlot* allocate_slot(AvahiServer *s) { - guint n, idx = (guint) -1; + unsigned n, idx = (unsigned) -1; AvahiLegacyUnicastReflectSlot *slot; - g_assert(s); + assert(s); if (!s->legacy_unicast_reflect_slots) - s->legacy_unicast_reflect_slots = g_new0(AvahiLegacyUnicastReflectSlot*, AVAHI_MAX_LEGACY_UNICAST_REFLECT_SLOTS); + s->legacy_unicast_reflect_slots = avahi_new0(AvahiLegacyUnicastReflectSlot*, AVAHI_MAX_LEGACY_UNICAST_REFLECT_SLOTS); for (n = 0; n < AVAHI_MAX_LEGACY_UNICAST_REFLECT_SLOTS; n++, s->legacy_unicast_reflect_id++) { idx = s->legacy_unicast_reflect_id % AVAHI_MAX_LEGACY_UNICAST_REFLECT_SLOTS; @@ -696,34 +706,37 @@ static AvahiLegacyUnicastReflectSlot* allocate_slot(AvahiServer *s) { break; } - if (idx == (guint) -1 || s->legacy_unicast_reflect_slots[idx]) + if (idx == (unsigned) -1 || s->legacy_unicast_reflect_slots[idx]) return NULL; - slot = s->legacy_unicast_reflect_slots[idx] = g_new(AvahiLegacyUnicastReflectSlot, 1); + if (!(slot = avahi_new(AvahiLegacyUnicastReflectSlot, 1))) + return NULL; /* OOM */ + + slot = s->legacy_unicast_reflect_slots[idx]; slot->id = s->legacy_unicast_reflect_id++; slot->server = s; return slot; } static void deallocate_slot(AvahiServer *s, AvahiLegacyUnicastReflectSlot *slot) { - guint idx; + unsigned idx; - g_assert(s); - g_assert(slot); + assert(s); + assert(slot); idx = slot->id % AVAHI_MAX_LEGACY_UNICAST_REFLECT_SLOTS; - g_assert(s->legacy_unicast_reflect_slots[idx] == slot); + assert(s->legacy_unicast_reflect_slots[idx] == slot); - avahi_time_event_queue_remove(s->time_event_queue, slot->time_event); + avahi_time_event_free(slot->time_event); - g_free(slot); + avahi_free(slot); s->legacy_unicast_reflect_slots[idx] = NULL; } static void free_slots(AvahiServer *s) { - guint idx; - g_assert(s); + unsigned idx; + assert(s); if (!s->legacy_unicast_reflect_slots) return; @@ -732,14 +745,14 @@ static void free_slots(AvahiServer *s) { if (s->legacy_unicast_reflect_slots[idx]) deallocate_slot(s, s->legacy_unicast_reflect_slots[idx]); - g_free(s->legacy_unicast_reflect_slots); + avahi_free(s->legacy_unicast_reflect_slots); s->legacy_unicast_reflect_slots = NULL; } -static AvahiLegacyUnicastReflectSlot* find_slot(AvahiServer *s, guint16 id) { - guint idx; +static AvahiLegacyUnicastReflectSlot* find_slot(AvahiServer *s, uint16_t id) { + unsigned idx; - g_assert(s); + assert(s); if (!s->legacy_unicast_reflect_slots) return NULL; @@ -755,23 +768,23 @@ static AvahiLegacyUnicastReflectSlot* find_slot(AvahiServer *s, guint16 id) { static void legacy_unicast_reflect_slot_timeout(AvahiTimeEvent *e, void *userdata) { AvahiLegacyUnicastReflectSlot *slot = userdata; - g_assert(e); - g_assert(slot); - g_assert(slot->time_event == e); + assert(e); + assert(slot); + assert(slot->time_event == e); deallocate_slot(slot->server, slot); } -static void reflect_legacy_unicast_query_packet(AvahiServer *s, AvahiDnsPacket *p, AvahiInterface *i, const AvahiAddress *a, guint16 port) { +static void reflect_legacy_unicast_query_packet(AvahiServer *s, AvahiDnsPacket *p, AvahiInterface *i, const AvahiAddress *a, uint16_t port) { AvahiLegacyUnicastReflectSlot *slot; AvahiInterface *j; - g_assert(s); - g_assert(p); - g_assert(i); - g_assert(a); - g_assert(port > 0); - g_assert(i->protocol == a->family); + assert(s); + assert(p); + assert(i); + assert(a); + assert(port > 0); + assert(i->protocol == a->family); if (!s->config.enable_reflector) return; @@ -798,7 +811,7 @@ static void reflect_legacy_unicast_query_packet(AvahiServer *s, AvahiDnsPacket * slot->interface = i->hardware->index; avahi_elapse_time(&slot->elapse_time, 2000, 0); - slot->time_event = avahi_time_event_queue_add(s->time_event_queue, &slot->elapse_time, legacy_unicast_reflect_slot_timeout, slot); + slot->time_event = avahi_time_event_new(s->time_event_queue, &slot->elapse_time, legacy_unicast_reflect_slot_timeout, slot); /* Patch the packet with our new locally generatedt id */ avahi_dns_packet_set_field(p, AVAHI_DNS_FIELD_ID, slot->id); @@ -818,18 +831,18 @@ static void reflect_legacy_unicast_query_packet(AvahiServer *s, AvahiDnsPacket * avahi_dns_packet_set_field(p, AVAHI_DNS_FIELD_ID, slot->original_id); } -static gboolean originates_from_local_legacy_unicast_socket(AvahiServer *s, const struct sockaddr *sa) { +static int originates_from_local_legacy_unicast_socket(AvahiServer *s, const struct sockaddr *sa) { AvahiAddress a; - g_assert(s); - g_assert(sa); + assert(s); + assert(sa); if (!s->config.enable_reflector) - return FALSE; + return 0; avahi_address_from_sockaddr(sa, &a); if (!avahi_address_is_local(s->monitor, &a)) - return FALSE; + return 0; if (sa->sa_family == AF_INET && s->fd_legacy_unicast_ipv4 >= 0) { struct sockaddr_in lsa; @@ -852,27 +865,27 @@ static gboolean originates_from_local_legacy_unicast_socket(AvahiServer *s, cons return lsa.sin6_port == ((const struct sockaddr_in6*) sa)->sin6_port; } - return FALSE; + return 0; } -static gboolean is_mdns_mcast_address(const AvahiAddress *a) { +static int is_mdns_mcast_address(const AvahiAddress *a) { AvahiAddress b; - g_assert(a); + assert(a); avahi_address_parse(a->family == AVAHI_PROTO_INET ? AVAHI_IPV4_MCAST_GROUP : AVAHI_IPV6_MCAST_GROUP, a->family, &b); return avahi_address_cmp(a, &b) == 0; } -static void dispatch_packet(AvahiServer *s, AvahiDnsPacket *p, const struct sockaddr *sa, AvahiAddress *dest, AvahiIfIndex iface, gint ttl) { +static void dispatch_packet(AvahiServer *s, AvahiDnsPacket *p, const struct sockaddr *sa, AvahiAddress *dest, AvahiIfIndex iface, int ttl) { AvahiInterface *i; AvahiAddress a; - guint16 port; + uint16_t port; - g_assert(s); - g_assert(p); - g_assert(sa); - g_assert(dest); - g_assert(iface > 0); + assert(s); + assert(p); + assert(sa); + assert(dest); + assert(iface > 0); if (!(i = avahi_interface_monitor_get_interface(s->monitor, iface, sa->sa_family)) || !avahi_interface_relevant(i)) { @@ -893,13 +906,13 @@ static void dispatch_packet(AvahiServer *s, AvahiDnsPacket *p, const struct sock /* This originates from our local reflector, so let's ignore it */ return; - if (avahi_dns_packet_check_valid(p) < 0) { + if (avahi_dns_packet_is_valid(p) < 0) { avahi_log_warn("Recieved invalid packet."); return; } if (avahi_dns_packet_is_query(p)) { - gboolean legacy_unicast = FALSE; + int legacy_unicast = 0; if (avahi_dns_packet_get_field(p, AVAHI_DNS_FIELD_ARCOUNT) != 0) { avahi_log_warn("Invalid query packet."); @@ -915,7 +928,7 @@ static void dispatch_packet(AvahiServer *s, AvahiDnsPacket *p, const struct sock return; } - legacy_unicast = TRUE; + legacy_unicast = 1; } if (legacy_unicast) @@ -953,16 +966,16 @@ static void dispatch_packet(AvahiServer *s, AvahiDnsPacket *p, const struct sock } } -static void dispatch_legacy_unicast_packet(AvahiServer *s, AvahiDnsPacket *p, const struct sockaddr *sa, AvahiIfIndex iface, gint ttl) { +static void dispatch_legacy_unicast_packet(AvahiServer *s, AvahiDnsPacket *p, const struct sockaddr *sa, AvahiIfIndex iface, int ttl) { AvahiInterface *i, *j; AvahiAddress a; - guint16 port; + uint16_t port; AvahiLegacyUnicastReflectSlot *slot; - g_assert(s); - g_assert(p); - g_assert(sa); - g_assert(iface > 0); + assert(s); + assert(p); + assert(sa); + assert(iface > 0); if (!(i = avahi_interface_monitor_get_interface(s->monitor, iface, sa->sa_family)) || !avahi_interface_relevant(i)) { @@ -979,7 +992,7 @@ static void dispatch_legacy_unicast_packet(AvahiServer *s, AvahiDnsPacket *p, co /* This is an IPv4 address encapsulated in IPv6, so let's ignore it. */ return; - if (avahi_dns_packet_check_valid(p) < 0 || avahi_dns_packet_is_query(p)) { + if (avahi_dns_packet_is_valid(p) < 0 || avahi_dns_packet_is_query(p)) { avahi_log_warn("Recieved invalid packet."); return; } @@ -1003,93 +1016,57 @@ static void dispatch_legacy_unicast_packet(AvahiServer *s, AvahiDnsPacket *p, co avahi_dns_packet_set_field(p, AVAHI_DNS_FIELD_ID, slot->id); } -static void work(AvahiServer *s) { - struct sockaddr_in6 sa6; - struct sockaddr_in sa; +static void socket_event(AvahiWatch *w, int fd, AvahiWatchEvent events, void *userdata) { + AvahiServer *s = userdata; AvahiAddress dest; AvahiDnsPacket *p; - gint iface = 0; - guint8 ttl; - - g_assert(s); + AvahiIfIndex iface; + uint8_t ttl; + struct sockaddr_in sa; + struct sockaddr_in6 sa6; - if (s->fd_ipv4 >= 0 && (s->pollfd_ipv4.revents & G_IO_IN)) { - dest.family = AVAHI_PROTO_INET; - if ((p = avahi_recv_dns_packet_ipv4(s->fd_ipv4, &sa, &dest.data.ipv4, &iface, &ttl))) { - dispatch_packet(s, p, (struct sockaddr*) &sa, &dest, iface, ttl); - avahi_dns_packet_free(p); - } - } + assert(w); + assert(fd >= 0); - if (s->fd_ipv6 >= 0 && (s->pollfd_ipv6.revents & G_IO_IN)) { - dest.family = AVAHI_PROTO_INET6; - if ((p = avahi_recv_dns_packet_ipv6(s->fd_ipv6, &sa6, &dest.data.ipv6, &iface, &ttl))) { - dispatch_packet(s, p, (struct sockaddr*) &sa6, &dest, iface, ttl); - avahi_dns_packet_free(p); - } - } + if (events & AVAHI_WATCH_IN) { + + if (fd == s->fd_ipv4) { + dest.family = AVAHI_PROTO_INET; + if ((p = avahi_recv_dns_packet_ipv4(s->fd_ipv4, &sa, &dest.data.ipv4, &iface, &ttl))) { + dispatch_packet(s, p, (struct sockaddr*) &sa, &dest, iface, ttl); + avahi_dns_packet_free(p); + } + } else if (fd == s->fd_ipv6) { + dest.family = AVAHI_PROTO_INET6; - if (s->fd_legacy_unicast_ipv4 >= 0 && (s->pollfd_legacy_unicast_ipv4.revents & G_IO_IN)) { - dest.family = AVAHI_PROTO_INET; - if ((p = avahi_recv_dns_packet_ipv4(s->fd_legacy_unicast_ipv4, &sa, &dest.data.ipv4, &iface, &ttl))) { - dispatch_legacy_unicast_packet(s, p, (struct sockaddr*) &sa, iface, ttl); - avahi_dns_packet_free(p); + if ((p = avahi_recv_dns_packet_ipv6(s->fd_ipv6, &sa6, &dest.data.ipv6, &iface, &ttl))) { + dispatch_packet(s, p, (struct sockaddr*) &sa6, &dest, iface, ttl); + avahi_dns_packet_free(p); + } + } else if (fd == s->fd_legacy_unicast_ipv4) { + dest.family = AVAHI_PROTO_INET; + + if ((p = avahi_recv_dns_packet_ipv4(s->fd_legacy_unicast_ipv4, &sa, &dest.data.ipv4, &iface, &ttl))) { + dispatch_legacy_unicast_packet(s, p, (struct sockaddr*) &sa, iface, ttl); + avahi_dns_packet_free(p); + } + } else if (fd == s->fd_legacy_unicast_ipv6) { + dest.family = AVAHI_PROTO_INET6; + + if ((p = avahi_recv_dns_packet_ipv6(s->fd_legacy_unicast_ipv6, &sa6, &dest.data.ipv6, &iface, &ttl))) { + dispatch_legacy_unicast_packet(s, p, (struct sockaddr*) &sa6, iface, ttl); + avahi_dns_packet_free(p); + } } - } - if (s->fd_legacy_unicast_ipv6 >= 0 && (s->pollfd_legacy_unicast_ipv6.revents & G_IO_IN)) { - dest.family = AVAHI_PROTO_INET6; - if ((p = avahi_recv_dns_packet_ipv6(s->fd_legacy_unicast_ipv6, &sa6, &dest.data.ipv6, &iface, &ttl))) { - dispatch_legacy_unicast_packet(s, p, (struct sockaddr*) &sa6, iface, ttl); - avahi_dns_packet_free(p); - } + cleanup_dead(s); + } else { + assert(0); } } -static gboolean prepare_func(GSource *source, gint *timeout) { - g_assert(source); - g_assert(timeout); - - *timeout = -1; - return FALSE; -} - -static gboolean check_func(GSource *source) { - AvahiServer* s; - gushort revents = 0; - - g_assert(source); - - s = *((AvahiServer**) (((guint8*) source) + sizeof(GSource))); - g_assert(s); - - if (s->fd_ipv4 >= 0) - revents |= s->pollfd_ipv4.revents; - if (s->fd_ipv6 >= 0) - revents |= s->pollfd_ipv6.revents; - if (s->fd_legacy_unicast_ipv4 >= 0) - revents |= s->pollfd_legacy_unicast_ipv4.revents; - if (s->fd_legacy_unicast_ipv6 >= 0) - revents |= s->pollfd_legacy_unicast_ipv6.revents; - - return !!(revents & (G_IO_IN | G_IO_HUP | G_IO_ERR)); -} - -static gboolean dispatch_func(GSource *source, GSourceFunc callback, gpointer user_data) { - AvahiServer* s; - g_assert(source); - - s = *((AvahiServer**) (((guint8*) source) + sizeof(GSource))); - g_assert(s); - - work(s); - cleanup_dead(s); - - return TRUE; -} - static void server_set_state(AvahiServer *s, AvahiServerState state) { - g_assert(s); + assert(s); if (s->state == state) return; @@ -1101,7 +1078,7 @@ static void server_set_state(AvahiServer *s, AvahiServerState state) { } static void withdraw_host_rrs(AvahiServer *s) { - g_assert(s); + assert(s); if (s->hinfo_entry_group) avahi_entry_group_reset(s->hinfo_entry_group); @@ -1109,28 +1086,28 @@ static void withdraw_host_rrs(AvahiServer *s) { if (s->browse_domain_entry_group) avahi_entry_group_reset(s->browse_domain_entry_group); - avahi_update_host_rrs(s->monitor, TRUE); + avahi_update_host_rrs(s->monitor, 1); s->n_host_rr_pending = 0; } void avahi_server_decrease_host_rr_pending(AvahiServer *s) { - g_assert(s); + assert(s); - g_assert(s->n_host_rr_pending > 0); + assert(s->n_host_rr_pending > 0); if (--s->n_host_rr_pending == 0) server_set_state(s, AVAHI_SERVER_RUNNING); } void avahi_server_increase_host_rr_pending(AvahiServer *s) { - g_assert(s); + assert(s); s->n_host_rr_pending ++; } void avahi_host_rr_entry_group_callback(AvahiServer *s, AvahiEntryGroup *g, AvahiEntryGroupState state, void *userdata) { - g_assert(s); - g_assert(g); + assert(s); + assert(g); if (state == AVAHI_ENTRY_GROUP_REGISTERING && s->state == AVAHI_SERVER_REGISTERING) @@ -1150,30 +1127,43 @@ static void register_hinfo(AvahiServer *s) { struct utsname utsname; AvahiRecord *r; - g_assert(s); + assert(s); if (!s->config.publish_hinfo) return; if (s->hinfo_entry_group) - g_assert(avahi_entry_group_is_empty(s->hinfo_entry_group)); + assert(avahi_entry_group_is_empty(s->hinfo_entry_group)); else s->hinfo_entry_group = avahi_entry_group_new(s, avahi_host_rr_entry_group_callback, NULL); + + if (!s->hinfo_entry_group) { + avahi_log_warn("Failed to create HINFO entry group: %s", avahi_strerror(s->error)); + return; + } /* Fill in HINFO rr */ - r = avahi_record_new_full(s->host_name_fqdn, AVAHI_DNS_CLASS_IN, AVAHI_DNS_TYPE_HINFO, AVAHI_DEFAULT_TTL_HOST_NAME); - uname(&utsname); - r->data.hinfo.cpu = g_strdup(g_strup(utsname.machine)); - r->data.hinfo.os = g_strdup(g_strup(utsname.sysname)); - avahi_server_add(s, s->hinfo_entry_group, AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC, AVAHI_ENTRY_UNIQUE, r); - avahi_record_unref(r); + if ((r = avahi_record_new_full(s->host_name_fqdn, AVAHI_DNS_CLASS_IN, AVAHI_DNS_TYPE_HINFO, AVAHI_DEFAULT_TTL_HOST_NAME))) { + uname(&utsname); + r->data.hinfo.cpu = avahi_strdup(avahi_strup(utsname.machine)); + r->data.hinfo.os = avahi_strdup(avahi_strup(utsname.sysname)); + + if (avahi_server_add(s, s->hinfo_entry_group, AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC, AVAHI_ENTRY_UNIQUE, r) < 0) { + avahi_log_warn("Failed to add HINFO RR: %s", avahi_strerror(s->error)); + return; + } + + avahi_record_unref(r); + } + + if (avahi_entry_group_commit(s->hinfo_entry_group) < 0) + avahi_log_warn("Failed to commit HINFO entry group: %s", avahi_strerror(s->error)); - avahi_entry_group_commit(s->hinfo_entry_group); } static void register_localhost(AvahiServer *s) { AvahiAddress a; - g_assert(s); + assert(s); /* Add localhost entries */ avahi_address_parse("127.0.0.1", AVAHI_PROTO_INET, &a); @@ -1184,52 +1174,66 @@ static void register_localhost(AvahiServer *s) { } static void register_browse_domain(AvahiServer *s) { - g_assert(s); + assert(s); if (!s->config.publish_domain) return; if (s->browse_domain_entry_group) - g_assert(avahi_entry_group_is_empty(s->browse_domain_entry_group)); + assert(avahi_entry_group_is_empty(s->browse_domain_entry_group)); else s->browse_domain_entry_group = avahi_entry_group_new(s, NULL, NULL); + + if (!s->browse_domain_entry_group) { + avahi_log_warn("Failed to create browse domain entry group: %s", avahi_strerror(s->error)); + return; + } - avahi_server_add_ptr(s, s->browse_domain_entry_group, AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC, 0, AVAHI_DEFAULT_TTL, "b._dns-sd._udp.local", s->domain_name); - avahi_entry_group_commit(s->browse_domain_entry_group); + if (avahi_server_add_ptr(s, s->browse_domain_entry_group, AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC, 0, AVAHI_DEFAULT_TTL, "b._dns-sd._udp.local", s->domain_name) < 0) { + avahi_log_warn("Failed to add browse domain RR: %s", avahi_strerror(s->error)); + return; + } + + if (avahi_entry_group_commit(s->browse_domain_entry_group) < 0) + avahi_log_warn("Failed to commit browse domain entry group: %s", avahi_strerror(s->error)); } static void register_stuff(AvahiServer *s) { - g_assert(s); + assert(s); server_set_state(s, AVAHI_SERVER_REGISTERING); register_hinfo(s); register_browse_domain(s); - avahi_update_host_rrs(s->monitor, FALSE); + avahi_update_host_rrs(s->monitor, 0); if (s->n_host_rr_pending == 0) server_set_state(s, AVAHI_SERVER_RUNNING); } static void update_fqdn(AvahiServer *s) { - g_assert(s); + char *n; - g_assert(s->host_name); - g_assert(s->domain_name); + assert(s); + assert(s->host_name); + assert(s->domain_name); + + if (!(n = avahi_strdup_printf("%s.%s", s->host_name, s->domain_name))) + return; /* OOM */ - g_free(s->host_name_fqdn); - s->host_name_fqdn = g_strdup_printf("%s.%s", s->host_name, s->domain_name); + avahi_free(s->host_name_fqdn); + s->host_name_fqdn = n; } -gint avahi_server_set_host_name(AvahiServer *s, const gchar *host_name) { - g_assert(s); - g_assert(host_name); +int avahi_server_set_host_name(AvahiServer *s, const char *host_name) { + assert(s); + assert(host_name); if (host_name && !avahi_is_valid_host_name(host_name)) return avahi_server_set_errno(s, AVAHI_ERR_INVALID_HOST_NAME); withdraw_host_rrs(s); - g_free(s->host_name); + avahi_free(s->host_name); s->host_name = host_name ? avahi_normalize_name(host_name) : avahi_get_host_name(); s->host_name[strcspn(s->host_name, ".")] = 0; update_fqdn(s); @@ -1238,35 +1242,24 @@ gint avahi_server_set_host_name(AvahiServer *s, const gchar *host_name) { return AVAHI_OK; } -gint avahi_server_set_domain_name(AvahiServer *s, const gchar *domain_name) { - g_assert(s); - g_assert(domain_name); +int avahi_server_set_domain_name(AvahiServer *s, const char *domain_name) { + assert(s); + assert(domain_name); if (domain_name && !avahi_is_valid_domain_name(domain_name)) return avahi_server_set_errno(s, AVAHI_ERR_INVALID_DOMAIN_NAME); withdraw_host_rrs(s); - g_free(s->domain_name); - s->domain_name = domain_name ? avahi_normalize_name(domain_name) : g_strdup("local"); + avahi_free(s->domain_name); + s->domain_name = domain_name ? avahi_normalize_name(domain_name) : avahi_strdup("local"); update_fqdn(s); register_stuff(s); return AVAHI_OK; } -static void prepare_pollfd(AvahiServer *s, GPollFD *pollfd, gint fd) { - g_assert(s); - g_assert(pollfd); - g_assert(fd >= 0); - - memset(pollfd, 0, sizeof(GPollFD)); - pollfd->fd = fd; - pollfd->events = G_IO_IN|G_IO_ERR|G_IO_HUP; - g_source_add_poll(s->source, pollfd); -} - -static gint valid_server_config(const AvahiServerConfig *sc) { +static int valid_server_config(const AvahiServerConfig *sc) { if (sc->host_name && !avahi_is_valid_host_name(sc->host_name)) return AVAHI_ERR_INVALID_HOST_NAME; @@ -1277,81 +1270,87 @@ static gint valid_server_config(const AvahiServerConfig *sc) { return AVAHI_OK; } -AvahiServer *avahi_server_new(GMainContext *c, const AvahiServerConfig *sc, AvahiServerCallback callback, gpointer userdata, gint *error) { - AvahiServer *s; - gint e; +static int setup_sockets(AvahiServer *s) { + assert(s); + + s->fd_ipv4 = s->config.use_ipv4 ? avahi_open_socket_ipv4() : -1; + s->fd_ipv6 = s->config.use_ipv6 ? avahi_open_socket_ipv6() : -1; - static GSourceFuncs source_funcs = { - prepare_func, - check_func, - dispatch_func, - NULL, - NULL, - NULL - }; + if (s->fd_ipv6 < 0 && s->fd_ipv4 < 0) + return AVAHI_ERR_NO_NETWORK; + if (s->fd_ipv4 < 0 && s->config.use_ipv4) + avahi_log_notice("Failed to create IPv4 socket, proceeding in IPv6 only mode"); + else if (s->fd_ipv6 < 0 && s->config.use_ipv6) + avahi_log_notice("Failed to create IPv6 socket, proceeding in IPv4 only mode"); + + s->fd_legacy_unicast_ipv4 = s->fd_ipv4 >= 0 && s->config.enable_reflector ? avahi_open_legacy_unicast_socket_ipv4() : -1; + s->fd_legacy_unicast_ipv6 = s->fd_ipv6 >= 0 && s->config.enable_reflector ? avahi_open_legacy_unicast_socket_ipv6() : -1; + + s->watch_ipv4 = s->watch_ipv6 = s->watch_legacy_unicast_ipv4 = s->watch_legacy_unicast_ipv6 = NULL; + + if (s->fd_ipv4 >= 0) + s->watch_ipv4 = s->poll_api->watch_new(s->poll_api, s->fd_ipv4, AVAHI_WATCH_IN, socket_event, s); + if (s->fd_ipv6 >= 0) + s->watch_ipv6 = s->poll_api->watch_new(s->poll_api, s->fd_ipv6, AVAHI_WATCH_IN, socket_event, s); + if (s->fd_legacy_unicast_ipv4 >= 0) + s->watch_legacy_unicast_ipv4 = s->poll_api->watch_new(s->poll_api, s->fd_legacy_unicast_ipv4, AVAHI_WATCH_IN, socket_event, s); + if (s->fd_legacy_unicast_ipv6 >= 0) + s->watch_legacy_unicast_ipv6 = s->poll_api->watch_new(s->poll_api, s->fd_legacy_unicast_ipv6, AVAHI_WATCH_IN, socket_event, s); + + return 0; +} + +AvahiServer *avahi_server_new(AvahiPoll *poll_api, const AvahiServerConfig *sc, AvahiServerCallback callback, void* userdata, int *error) { + AvahiServer *s; + int e; + if ((e = valid_server_config(sc)) < 0) { if (error) *error = e; return NULL; } - s = g_new(AvahiServer, 1); - s->n_host_rr_pending = 0; - s->need_entry_cleanup = s->need_group_cleanup = s->need_browser_cleanup = FALSE; + if (!(s = avahi_new(AvahiServer, 1))) { + if (error) + *error = AVAHI_ERR_NO_MEMORY; + + return NULL; + } + + s->poll_api = poll_api; if (sc) avahi_server_config_copy(&s->config, sc); else avahi_server_config_init(&s->config); - - s->fd_ipv4 = s->config.use_ipv4 ? avahi_open_socket_ipv4() : -1; - s->fd_ipv6 = s->config.use_ipv6 ? avahi_open_socket_ipv6() : -1; - - if (s->fd_ipv6 < 0 && s->fd_ipv4 < 0) { - avahi_server_config_free(&s->config); - g_free(s); + if ((e = setup_sockets(s)) < 0) { if (error) - *error = AVAHI_ERR_NO_NETWORK; + *error = e; + + avahi_server_config_free(&s->config); + avahi_free(s); return NULL; } - if (s->fd_ipv4 < 0 && s->config.use_ipv4) - avahi_log_notice("Failed to create IPv4 socket, proceeding in IPv6 only mode"); - else if (s->fd_ipv6 < 0 && s->config.use_ipv6) - avahi_log_notice("Failed to create IPv6 socket, proceeding in IPv4 only mode"); - - s->fd_legacy_unicast_ipv4 = s->fd_ipv4 >= 0 && s->config.enable_reflector ? avahi_open_legacy_unicast_socket_ipv4() : -1; - s->fd_legacy_unicast_ipv6 = s->fd_ipv6 >= 0 && s->config.enable_reflector ? avahi_open_legacy_unicast_socket_ipv6() : -1; - - g_main_context_ref(s->context = (c ? c : g_main_context_default())); - - /* Prepare IO source registration */ - s->source = g_source_new(&source_funcs, sizeof(GSource) + sizeof(AvahiServer*)); - *((AvahiServer**) (((guint8*) s->source) + sizeof(GSource))) = s; - - if (s->fd_ipv4 >= 0) - prepare_pollfd(s, &s->pollfd_ipv4, s->fd_ipv4); - if (s->fd_ipv6 >= 0) - prepare_pollfd(s, &s->pollfd_ipv6, s->fd_ipv6); - if (s->fd_legacy_unicast_ipv4 >= 0) - prepare_pollfd(s, &s->pollfd_legacy_unicast_ipv4, s->fd_legacy_unicast_ipv4); - if (s->fd_legacy_unicast_ipv6 >= 0) - prepare_pollfd(s, &s->pollfd_legacy_unicast_ipv6, s->fd_legacy_unicast_ipv6); + s->n_host_rr_pending = 0; + s->need_entry_cleanup = 0; + s->need_group_cleanup = 0; + s->need_browser_cleanup = 0; - g_source_attach(s->source, s->context); + s->time_event_queue = avahi_time_event_queue_new(poll_api); s->callback = callback; s->userdata = userdata; + s->entries_by_key = avahi_hashmap_new((AvahiHashFunc) avahi_key_hash, (AvahiEqualFunc) avahi_key_equal, NULL, NULL); AVAHI_LLIST_HEAD_INIT(AvahiEntry, s->entries); - s->entries_by_key = g_hash_table_new((GHashFunc) avahi_key_hash, (GEqualFunc) avahi_key_equal); AVAHI_LLIST_HEAD_INIT(AvahiGroup, s->groups); + s->record_browser_hashmap = avahi_hashmap_new((AvahiHashFunc) avahi_key_hash, (AvahiEqualFunc) avahi_key_equal, NULL, NULL); AVAHI_LLIST_HEAD_INIT(AvahiRecordBrowser, s->record_browsers); - s->record_browser_hashtable = g_hash_table_new((GHashFunc) avahi_key_hash, (GEqualFunc) avahi_key_equal); AVAHI_LLIST_HEAD_INIT(AvahiHostNameResolver, s->host_name_resolvers); AVAHI_LLIST_HEAD_INIT(AvahiAddressResolver, s->address_resolvers); AVAHI_LLIST_HEAD_INIT(AvahiDomainBrowser, s->domain_browsers); @@ -1366,14 +1365,12 @@ AvahiServer *avahi_server_new(GMainContext *c, const AvahiServerConfig *sc, Avah /* Get host name */ s->host_name = s->config.host_name ? avahi_normalize_name(s->config.host_name) : avahi_get_host_name(); s->host_name[strcspn(s->host_name, ".")] = 0; - s->domain_name = s->config.domain_name ? avahi_normalize_name(s->config.domain_name) : g_strdup("local"); + s->domain_name = s->config.domain_name ? avahi_normalize_name(s->config.domain_name) : avahi_strdup("local"); s->host_name_fqdn = NULL; update_fqdn(s); s->record_list = avahi_record_list_new(); - s->time_event_queue = avahi_time_event_queue_new(s->context, G_PRIORITY_DEFAULT+10); /* Slightly less priority than the FDs */ - s->state = AVAHI_SERVER_INVALID; s->monitor = avahi_interface_monitor_new(s); @@ -1391,7 +1388,7 @@ AvahiServer *avahi_server_new(GMainContext *c, const AvahiServerConfig *sc, Avah } void avahi_server_free(AvahiServer* s) { - g_assert(s); + assert(s); while(s->entries) free_entry(s, s->entries); @@ -1419,13 +1416,22 @@ void avahi_server_free(AvahiServer* s) { avahi_service_resolver_free(s->service_resolvers); while (s->record_browsers) avahi_record_browser_destroy(s->record_browsers); - g_hash_table_destroy(s->record_browser_hashtable); - - g_hash_table_destroy(s->entries_by_key); + + avahi_hashmap_free(s->record_browser_hashmap); + avahi_hashmap_free(s->entries_by_key); avahi_time_event_queue_free(s->time_event_queue); avahi_record_list_free(s->record_list); + + if (s->watch_ipv4) + s->poll_api->watch_free(s->watch_ipv4); + if (s->watch_ipv6) + s->poll_api->watch_free(s->watch_ipv6); + if (s->watch_legacy_unicast_ipv4) + s->poll_api->watch_free(s->watch_legacy_unicast_ipv4); + if (s->watch_legacy_unicast_ipv6) + s->poll_api->watch_free(s->watch_legacy_unicast_ipv6); if (s->fd_ipv4 >= 0) close(s->fd_ipv4); @@ -1436,26 +1442,22 @@ void avahi_server_free(AvahiServer* s) { if (s->fd_legacy_unicast_ipv6 >= 0) close(s->fd_legacy_unicast_ipv6); - g_free(s->host_name); - g_free(s->domain_name); - g_free(s->host_name_fqdn); - - g_source_destroy(s->source); - g_source_unref(s->source); - g_main_context_unref(s->context); + avahi_free(s->host_name); + avahi_free(s->domain_name); + avahi_free(s->host_name_fqdn); avahi_server_config_free(&s->config); - g_free(s); + avahi_free(s); } -static gint check_record_conflict(AvahiServer *s, AvahiIfIndex interface, AvahiProtocol protocol, AvahiRecord *r, AvahiEntryFlags flags) { +static int check_record_conflict(AvahiServer *s, AvahiIfIndex interface, AvahiProtocol protocol, AvahiRecord *r, AvahiEntryFlags flags) { AvahiEntry *e; - g_assert(s); - g_assert(r); + assert(s); + assert(r); - for (e = g_hash_table_lookup(s->entries_by_key, r->key); e; e = e->by_key_next) { + for (e = avahi_hashmap_lookup(s->entries_by_key, r->key); e; e = e->by_key_next) { if (e->dead) continue; @@ -1479,7 +1481,7 @@ static gint check_record_conflict(AvahiServer *s, AvahiIfIndex interface, AvahiP return 0; } -gint avahi_server_add( +int avahi_server_add( AvahiServer *s, AvahiEntryGroup *g, AvahiIfIndex interface, @@ -1489,8 +1491,8 @@ gint avahi_server_add( AvahiEntry *e, *t; - g_assert(s); - g_assert(r); + assert(s); + assert(r); if (r->ttl == 0) return avahi_server_set_errno(s, AVAHI_ERR_INVALID_TTL); @@ -1504,23 +1506,25 @@ gint avahi_server_add( if (check_record_conflict(s, interface, protocol, r, flags) < 0) return avahi_server_set_errno(s, AVAHI_ERR_LOCAL_COLLISION); - e = g_new(AvahiEntry, 1); + if (!(e = avahi_new(AvahiEntry, 1))) + return avahi_server_set_errno(s, AVAHI_ERR_NO_NETWORK); + e->server = s; e->record = avahi_record_ref(r); e->group = g; e->interface = interface; e->protocol = protocol; e->flags = flags; - e->dead = FALSE; + e->dead = 0; AVAHI_LLIST_HEAD_INIT(AvahiAnnouncement, e->announcements); AVAHI_LLIST_PREPEND(AvahiEntry, entries, s->entries, e); /* Insert into hash table indexed by name */ - t = g_hash_table_lookup(s->entries_by_key, e->record->key); + t = avahi_hashmap_lookup(s->entries_by_key, e->record->key); AVAHI_LLIST_PREPEND(AvahiEntry, by_key, t, e); - g_hash_table_replace(s->entries_by_key, e->record->key, t); + avahi_hashmap_replace(s->entries_by_key, e->record->key, t); /* Insert into group list */ if (g) @@ -1533,8 +1537,8 @@ gint avahi_server_add( const AvahiRecord *avahi_server_iterate(AvahiServer *s, AvahiEntryGroup *g, void **state) { AvahiEntry **e = (AvahiEntry**) state; - g_assert(s); - g_assert(e); + assert(s); + assert(e); if (!*e) *e = g ? g->entries : s->entries; @@ -1548,80 +1552,95 @@ const AvahiRecord *avahi_server_iterate(AvahiServer *s, AvahiEntryGroup *g, void return avahi_record_ref((*e)->record); } -void avahi_server_dump(AvahiServer *s, AvahiDumpCallback callback, gpointer userdata) { +int avahi_server_dump(AvahiServer *s, AvahiDumpCallback callback, void* userdata) { AvahiEntry *e; - g_assert(s); - g_assert(callback); + assert(s); + assert(callback); callback(";;; ZONE DUMP FOLLOWS ;;;", userdata); for (e = s->entries; e; e = e->entries_next) { - gchar *t; - gchar ln[256]; + char *t; + char ln[256]; if (e->dead) continue; - t = avahi_record_to_string(e->record); - g_snprintf(ln, sizeof(ln), "%s ; iface=%i proto=%i", t, e->interface, e->protocol); - g_free(t); + if (!(t = avahi_record_to_string(e->record))) + return avahi_server_set_errno(s, AVAHI_ERR_NO_MEMORY); + + snprintf(ln, sizeof(ln), "%s ; iface=%i proto=%i", t, e->interface, e->protocol); + avahi_free(t); callback(ln, userdata); } avahi_dump_caches(s->monitor, callback, userdata); + return AVAHI_OK; } -gint avahi_server_add_ptr( +int avahi_server_add_ptr( AvahiServer *s, AvahiEntryGroup *g, AvahiIfIndex interface, AvahiProtocol protocol, AvahiEntryFlags flags, - guint32 ttl, - const gchar *name, - const gchar *dest) { + uint32_t ttl, + const char *name, + const char *dest) { AvahiRecord *r; - gint ret; + int ret; - g_assert(s); - g_assert(dest); + assert(s); + assert(dest); - r = avahi_record_new_full(name ? name : s->host_name_fqdn, AVAHI_DNS_CLASS_IN, AVAHI_DNS_TYPE_PTR, ttl); + if (!(r = avahi_record_new_full(name ? name : s->host_name_fqdn, AVAHI_DNS_CLASS_IN, AVAHI_DNS_TYPE_PTR, ttl))) + return avahi_server_set_errno(s, AVAHI_ERR_NO_MEMORY); + r->data.ptr.name = avahi_normalize_name(dest); ret = avahi_server_add(s, g, interface, protocol, flags, r); avahi_record_unref(r); return ret; } -gint avahi_server_add_address( +int avahi_server_add_address( AvahiServer *s, AvahiEntryGroup *g, AvahiIfIndex interface, AvahiProtocol protocol, AvahiEntryFlags flags, - const gchar *name, + const char *name, AvahiAddress *a) { - gchar *n = NULL; - gint ret = AVAHI_OK; - g_assert(s); - g_assert(a); + char *n = NULL; + int ret = AVAHI_OK; + assert(s); + assert(a); - name = name ? (n = avahi_normalize_name(name)) : s->host_name_fqdn; + if (name) { + if (!(n = avahi_normalize_name(name))) + return avahi_server_set_errno(s, AVAHI_ERR_NO_MEMORY); + + name = n; + } else + name = s->host_name_fqdn; if (!avahi_is_valid_domain_name(name)) { - avahi_server_set_errno(s, AVAHI_ERR_INVALID_HOST_NAME); + ret = avahi_server_set_errno(s, AVAHI_ERR_INVALID_HOST_NAME); goto fail; } if (a->family == AVAHI_PROTO_INET) { - gchar *reverse; + char *reverse; AvahiRecord *r; - r = avahi_record_new_full(name, AVAHI_DNS_CLASS_IN, AVAHI_DNS_TYPE_A, AVAHI_DEFAULT_TTL_HOST_NAME); + if (!(r = avahi_record_new_full(name, AVAHI_DNS_CLASS_IN, AVAHI_DNS_TYPE_A, AVAHI_DEFAULT_TTL_HOST_NAME))) { + ret = avahi_server_set_errno(s, AVAHI_ERR_NO_MEMORY); + goto fail; + } + r->data.a.address = a->data.ipv4; ret = avahi_server_add(s, g, interface, protocol, flags | AVAHI_ENTRY_UNIQUE | AVAHI_ENTRY_ALLOWMUTIPLE, r); avahi_record_unref(r); @@ -1629,15 +1648,25 @@ gint avahi_server_add_address( if (ret < 0) goto fail; - reverse = avahi_reverse_lookup_name_ipv4(&a->data.ipv4); + if (!(reverse = avahi_reverse_lookup_name_ipv4(&a->data.ipv4))) { + ret = avahi_server_set_errno(s, AVAHI_ERR_NO_MEMORY); + goto fail; + } + ret = avahi_server_add_ptr(s, g, interface, protocol, flags | AVAHI_ENTRY_UNIQUE, AVAHI_DEFAULT_TTL_HOST_NAME, reverse, name); - g_free(reverse); + avahi_free(reverse); } else { - gchar *reverse; + char *reverse; AvahiRecord *r; + + assert(a->family == AVAHI_PROTO_INET6); - r = avahi_record_new_full(name, AVAHI_DNS_CLASS_IN, AVAHI_DNS_TYPE_AAAA, AVAHI_DEFAULT_TTL_HOST_NAME); + if (!(r = avahi_record_new_full(name, AVAHI_DNS_CLASS_IN, AVAHI_DNS_TYPE_AAAA, AVAHI_DEFAULT_TTL_HOST_NAME))) { + ret = avahi_server_set_errno(s, AVAHI_ERR_NO_MEMORY); + goto fail; + } + r->data.aaaa.address = a->data.ipv6; ret = avahi_server_add(s, g, interface, protocol, flags | AVAHI_ENTRY_UNIQUE | AVAHI_ENTRY_ALLOWMUTIPLE, r); avahi_record_unref(r); @@ -1645,41 +1674,51 @@ gint avahi_server_add_address( if (ret < 0) goto fail; - reverse = avahi_reverse_lookup_name_ipv6_arpa(&a->data.ipv6); + if (!(reverse = avahi_reverse_lookup_name_ipv6_arpa(&a->data.ipv6))) { + ret = avahi_server_set_errno(s, AVAHI_ERR_NO_MEMORY); + goto fail; + } + ret = avahi_server_add_ptr(s, g, interface, protocol, flags | AVAHI_ENTRY_UNIQUE, AVAHI_DEFAULT_TTL_HOST_NAME, reverse, name); - g_free(reverse); + avahi_free(reverse); if (ret < 0) goto fail; - reverse = avahi_reverse_lookup_name_ipv6_int(&a->data.ipv6); + if (!(reverse = avahi_reverse_lookup_name_ipv6_int(&a->data.ipv6))) { + ret = avahi_server_set_errno(s, AVAHI_ERR_NO_MEMORY); + goto fail; + } + ret = avahi_server_add_ptr(s, g, interface, protocol, flags | AVAHI_ENTRY_UNIQUE, AVAHI_DEFAULT_TTL_HOST_NAME, reverse, name); - g_free(reverse); + avahi_free(reverse); } fail: - g_free(n); + avahi_free(n); return ret; } -static gint server_add_txt_strlst_nocopy( +static int server_add_txt_strlst_nocopy( AvahiServer *s, AvahiEntryGroup *g, AvahiIfIndex interface, AvahiProtocol protocol, AvahiEntryFlags flags, - guint32 ttl, - const gchar *name, + uint32_t ttl, + const char *name, AvahiStringList *strlst) { AvahiRecord *r; - gint ret; + int ret; + + assert(s); - g_assert(s); + if (!(r = avahi_record_new_full(name ? name : s->host_name_fqdn, AVAHI_DNS_CLASS_IN, AVAHI_DNS_TYPE_TXT, ttl))) + return avahi_server_set_errno(s, AVAHI_ERR_NO_MEMORY); - r = avahi_record_new_full(name ? name : s->host_name_fqdn, AVAHI_DNS_CLASS_IN, AVAHI_DNS_TYPE_TXT, ttl); r->data.txt.string_list = strlst; ret = avahi_server_add(s, g, interface, protocol, flags, r); avahi_record_unref(r); @@ -1687,50 +1726,50 @@ static gint server_add_txt_strlst_nocopy( return ret; } -gint avahi_server_add_txt_strlst( +int avahi_server_add_txt_strlst( AvahiServer *s, AvahiEntryGroup *g, AvahiIfIndex interface, AvahiProtocol protocol, AvahiEntryFlags flags, - guint32 ttl, - const gchar *name, + uint32_t ttl, + const char *name, AvahiStringList *strlst) { - g_assert(s); + assert(s); return server_add_txt_strlst_nocopy(s, g, interface, protocol, flags, ttl, name, avahi_string_list_copy(strlst)); } -gint avahi_server_add_txt_va( +int avahi_server_add_txt_va( AvahiServer *s, AvahiEntryGroup *g, AvahiIfIndex interface, AvahiProtocol protocol, AvahiEntryFlags flags, - guint32 ttl, - const gchar *name, + uint32_t ttl, + const char *name, va_list va) { - g_assert(s); + assert(s); return server_add_txt_strlst_nocopy(s, g, interface, protocol, flags, ttl, name, avahi_string_list_new_va(va)); } -gint avahi_server_add_txt( +int avahi_server_add_txt( AvahiServer *s, AvahiEntryGroup *g, AvahiIfIndex interface, AvahiProtocol protocol, AvahiEntryFlags flags, - guint32 ttl, - const gchar *name, + uint32_t ttl, + const char *name, ...) { va_list va; - gint ret; + int ret; - g_assert(s); + assert(s); va_start(va, name); ret = avahi_server_add_txt_va(s, g, interface, protocol, flags, ttl, name, va); @@ -1739,10 +1778,10 @@ gint avahi_server_add_txt( return ret; } -static void escape_service_name(gchar *d, guint size, const gchar *s) { - g_assert(d); - g_assert(size); - g_assert(s); +static void escape_service_name(char *d, size_t size, const char *s) { + assert(d); + assert(size); + assert(s); while (*s && size >= 2) { if (*s == '.' || *s == '\\') { @@ -1757,30 +1796,30 @@ static void escape_service_name(gchar *d, guint size, const gchar *s) { size--; } - g_assert(size > 0); + assert(size > 0); *(d++) = 0; } -static gint server_add_service_strlst_nocopy( +static int server_add_service_strlst_nocopy( AvahiServer *s, AvahiEntryGroup *g, AvahiIfIndex interface, AvahiProtocol protocol, - const gchar *name, - const gchar *type, - const gchar *domain, - const gchar *host, - guint16 port, + const char *name, + const char *type, + const char *domain, + const char *host, + uint16_t port, AvahiStringList *strlst) { - gchar ptr_name[256], svc_name[256], ename[64], enum_ptr[256]; - gchar *t, *d; + char ptr_name[256], svc_name[256], ename[64], enum_ptr[256]; + char *t = NULL, *d = NULL, *h = NULL; AvahiRecord *r = NULL; - gint ret = 0; + int ret = AVAHI_OK; - g_assert(s); - g_assert(type); - g_assert(name); + assert(s); + assert(type); + assert(name); if (!avahi_is_valid_service_name(name)) return avahi_server_set_errno(s, AVAHI_ERR_INVALID_SERVICE_NAME); @@ -1805,20 +1844,29 @@ static gint server_add_service_strlst_nocopy( if (!host) host = s->host_name_fqdn; - d = avahi_normalize_name(domain); - t = avahi_normalize_name(type); - - g_snprintf(ptr_name, sizeof(ptr_name), "%s.%s", t, d); - g_snprintf(svc_name, sizeof(svc_name), "%s.%s.%s", ename, t, d); + if (!(d = avahi_normalize_name(domain)) || + !(t = avahi_normalize_name(type)) || + !(h = avahi_normalize_name(host))) { + ret = avahi_server_set_errno(s, AVAHI_ERR_NO_MEMORY); + goto fail; + } + + snprintf(ptr_name, sizeof(ptr_name), "%s.%s", t, d); + snprintf(svc_name, sizeof(svc_name), "%s.%s.%s", ename, t, d); if ((ret = avahi_server_add_ptr(s, g, interface, protocol, AVAHI_ENTRY_NULL, AVAHI_DEFAULT_TTL, ptr_name, svc_name)) < 0) goto fail; - r = avahi_record_new_full(svc_name, AVAHI_DNS_CLASS_IN, AVAHI_DNS_TYPE_SRV, AVAHI_DEFAULT_TTL_HOST_NAME); + if (!(r = avahi_record_new_full(svc_name, AVAHI_DNS_CLASS_IN, AVAHI_DNS_TYPE_SRV, AVAHI_DEFAULT_TTL_HOST_NAME))) { + ret = avahi_server_set_errno(s, AVAHI_ERR_NO_MEMORY); + goto fail; + } + r->data.srv.priority = 0; r->data.srv.weight = 0; r->data.srv.port = port; - r->data.srv.name = avahi_normalize_name(host); + r->data.srv.name = h; + h = NULL; ret = avahi_server_add(s, g, interface, protocol, AVAHI_ENTRY_UNIQUE, r); avahi_record_unref(r); @@ -1831,75 +1879,76 @@ static gint server_add_service_strlst_nocopy( if (ret < 0) goto fail; - g_snprintf(enum_ptr, sizeof(enum_ptr), "_services._dns-sd._udp.%s", d); + snprintf(enum_ptr, sizeof(enum_ptr), "_services._dns-sd._udp.%s", d); ret = avahi_server_add_ptr(s, g, interface, protocol, AVAHI_ENTRY_NULL, AVAHI_DEFAULT_TTL, enum_ptr, ptr_name); fail: - g_free(d); - g_free(t); + avahi_free(d); + avahi_free(t); + avahi_free(h); avahi_string_list_free(strlst); return ret; } -gint avahi_server_add_service_strlst( +int avahi_server_add_service_strlst( AvahiServer *s, AvahiEntryGroup *g, AvahiIfIndex interface, AvahiProtocol protocol, - const gchar *name, - const gchar *type, - const gchar *domain, - const gchar *host, - guint16 port, + const char *name, + const char *type, + const char *domain, + const char *host, + uint16_t port, AvahiStringList *strlst) { - g_assert(s); - g_assert(type); - g_assert(name); + assert(s); + assert(type); + assert(name); return server_add_service_strlst_nocopy(s, g, interface, protocol, name, type, domain, host, port, avahi_string_list_copy(strlst)); } -gint avahi_server_add_service_va( +int avahi_server_add_service_va( AvahiServer *s, AvahiEntryGroup *g, AvahiIfIndex interface, AvahiProtocol protocol, - const gchar *name, - const gchar *type, - const gchar *domain, - const gchar *host, - guint16 port, + const char *name, + const char *type, + const char *domain, + const char *host, + uint16_t port, va_list va){ - g_assert(s); - g_assert(type); - g_assert(name); + assert(s); + assert(type); + assert(name); return server_add_service_strlst_nocopy(s, g, interface, protocol, name, type, domain, host, port, avahi_string_list_new_va(va)); } -gint avahi_server_add_service( +int avahi_server_add_service( AvahiServer *s, AvahiEntryGroup *g, AvahiIfIndex interface, AvahiProtocol protocol, - const gchar *name, - const gchar *type, - const gchar *domain, - const gchar *host, - guint16 port, + const char *name, + const char *type, + const char *domain, + const char *host, + uint16_t port, ... ){ va_list va; - gint ret; + int ret; - g_assert(s); - g_assert(type); - g_assert(name); + assert(s); + assert(type); + assert(name); va_start(va, port); ret = avahi_server_add_service_va(s, g, interface, protocol, name, type, domain, host, port, va); @@ -1907,10 +1956,10 @@ gint avahi_server_add_service( return ret; } -static void hexstring(gchar *s, size_t sl, const void *p, size_t pl) { - static const gchar hex[] = "0123456789abcdef"; - gboolean b = FALSE; - const guint8 *k = p; +static void hexstring(char *s, size_t sl, const void *p, size_t pl) { + static const char hex[] = "0123456789abcdef"; + int b = 0; + const uint8_t *k = p; while (sl > 1 && pl > 0) { *(s++) = hex[(b ? *k : *k >> 4) & 0xF]; @@ -1929,24 +1978,24 @@ static void hexstring(gchar *s, size_t sl, const void *p, size_t pl) { *s = 0; } -gint avahi_server_add_dns_server_address( +int avahi_server_add_dns_server_address( AvahiServer *s, AvahiEntryGroup *g, AvahiIfIndex interface, AvahiProtocol protocol, - const gchar *domain, + const char *domain, AvahiDNSServerType type, const AvahiAddress *address, - guint16 port /** should be 53 */) { + uint16_t port /** should be 53 */) { AvahiRecord *r; - gint ret; - gchar n[64] = "ip-"; + int ret; + char n[64] = "ip-"; - g_assert(s); - g_assert(address); - g_assert(type == AVAHI_DNS_SERVER_UPDATE || type == AVAHI_DNS_SERVER_RESOLVE); - g_assert(address->family == AVAHI_PROTO_INET || address->family == AVAHI_PROTO_INET6); + assert(s); + assert(address); + assert(type == AVAHI_DNS_SERVER_UPDATE || type == AVAHI_DNS_SERVER_RESOLVE); + assert(address->family == AVAHI_PROTO_INET || address->family == AVAHI_PROTO_INET6); if (domain && !avahi_is_valid_domain_name(domain)) return avahi_server_set_errno(s, AVAHI_ERR_INVALID_DOMAIN_NAME); @@ -1963,6 +2012,9 @@ gint avahi_server_add_dns_server_address( r = avahi_record_new_full(n, AVAHI_DNS_CLASS_IN, AVAHI_DNS_TYPE_AAAA, AVAHI_DEFAULT_TTL_HOST_NAME); r->data.aaaa.address = address->data.ipv6; } + + if (!r) + return avahi_server_set_errno(s, AVAHI_ERR_NO_MEMORY); ret = avahi_server_add(s, g, interface, protocol, AVAHI_ENTRY_UNIQUE | AVAHI_ENTRY_ALLOWMUTIPLE, r); avahi_record_unref(r); @@ -1973,72 +2025,86 @@ gint avahi_server_add_dns_server_address( return avahi_server_add_dns_server_name(s, g, interface, protocol, domain, type, n, port); } -gint avahi_server_add_dns_server_name( +int avahi_server_add_dns_server_name( AvahiServer *s, AvahiEntryGroup *g, AvahiIfIndex interface, AvahiProtocol protocol, - const gchar *domain, + const char *domain, AvahiDNSServerType type, - const gchar *name, - guint16 port /** should be 53 */) { + const char *name, + uint16_t port /** should be 53 */) { - gint ret = -1; - gchar t[256], *d; + int ret = -1; + char t[256], *d = NULL, *n = NULL; AvahiRecord *r; - g_assert(s); - g_assert(name); - g_assert(type == AVAHI_DNS_SERVER_UPDATE || type == AVAHI_DNS_SERVER_RESOLVE); + assert(s); + assert(name); + assert(type == AVAHI_DNS_SERVER_UPDATE || type == AVAHI_DNS_SERVER_RESOLVE); + + if (port == 0) + return avahi_server_set_errno(s, AVAHI_ERR_INVALID_PORT); + + if (!avahi_is_valid_domain_name(name)) + return avahi_server_set_errno(s, AVAHI_ERR_INVALID_HOST_NAME); if (domain && !avahi_is_valid_domain_name(domain)) return avahi_server_set_errno(s, AVAHI_ERR_INVALID_DOMAIN_NAME); - if (port == 0) - return avahi_server_set_errno(s, AVAHI_ERR_INVALID_PORT); if (!domain) domain = s->domain_name; - d = avahi_normalize_name(domain); - g_snprintf(t, sizeof(t), "%s.%s", type == AVAHI_DNS_SERVER_RESOLVE ? "_domain._udp" : "_dns-update._udp", d); - g_free(d); + if (!(n = avahi_normalize_name(name)) || + !(d = avahi_normalize_name(domain))) { + avahi_free(n); + avahi_free(d); + return avahi_server_set_errno(s, AVAHI_ERR_NO_MEMORY); + } + + snprintf(t, sizeof(t), "%s.%s", type == AVAHI_DNS_SERVER_RESOLVE ? "_domain._udp" : "_dns-update._udp", d); + avahi_free(d); + + if (!(r = avahi_record_new_full(t, AVAHI_DNS_CLASS_IN, AVAHI_DNS_TYPE_SRV, AVAHI_DEFAULT_TTL_HOST_NAME))) { + avahi_free(n); + return avahi_server_set_errno(s, AVAHI_ERR_NO_MEMORY); + } - r = avahi_record_new_full(t, AVAHI_DNS_CLASS_IN, AVAHI_DNS_TYPE_SRV, AVAHI_DEFAULT_TTL_HOST_NAME); r->data.srv.priority = 0; r->data.srv.weight = 0; r->data.srv.port = port; - r->data.srv.name = avahi_normalize_name(name); + r->data.srv.name = n; ret = avahi_server_add(s, g, interface, protocol, AVAHI_ENTRY_NULL, r); avahi_record_unref(r); return ret; } -static void post_query_callback(AvahiInterfaceMonitor *m, AvahiInterface *i, gpointer userdata) { +static void post_query_callback(AvahiInterfaceMonitor *m, AvahiInterface *i, void* userdata) { AvahiKey *k = userdata; - g_assert(m); - g_assert(i); - g_assert(k); + assert(m); + assert(i); + assert(k); - avahi_interface_post_query(i, k, FALSE); + avahi_interface_post_query(i, k, 0); } void avahi_server_post_query(AvahiServer *s, AvahiIfIndex interface, AvahiProtocol protocol, AvahiKey *key) { - g_assert(s); - g_assert(key); + assert(s); + assert(key); avahi_interface_monitor_walk(s->monitor, interface, protocol, post_query_callback, key); } void avahi_entry_group_change_state(AvahiEntryGroup *g, AvahiEntryGroupState state) { - g_assert(g); + assert(g); if (g->state == state) return; - g_assert(state <= AVAHI_ENTRY_GROUP_COLLISION); + assert(state <= AVAHI_ENTRY_GROUP_COLLISION); g->state = state; @@ -2046,16 +2112,20 @@ void avahi_entry_group_change_state(AvahiEntryGroup *g, AvahiEntryGroupState sta g->callback(g->server, g, state, g->userdata); } -AvahiEntryGroup *avahi_entry_group_new(AvahiServer *s, AvahiEntryGroupCallback callback, gpointer userdata) { +AvahiEntryGroup *avahi_entry_group_new(AvahiServer *s, AvahiEntryGroupCallback callback, void* userdata) { AvahiEntryGroup *g; - g_assert(s); + assert(s); - g = g_new(AvahiEntryGroup, 1); + if (!(g = avahi_new(AvahiEntryGroup, 1))) { + avahi_server_set_errno(s, AVAHI_ERR_NO_MEMORY); + return NULL; + } + g->server = s; g->callback = callback; g->userdata = userdata; - g->dead = FALSE; + g->dead = 0; g->state = AVAHI_ENTRY_GROUP_UNCOMMITED; g->n_probing = 0; g->n_register_try = 0; @@ -2071,29 +2141,29 @@ AvahiEntryGroup *avahi_entry_group_new(AvahiServer *s, AvahiEntryGroupCallback c void avahi_entry_group_free(AvahiEntryGroup *g) { AvahiEntry *e; - g_assert(g); - g_assert(g->server); + assert(g); + assert(g->server); for (e = g->entries; e; e = e->by_group_next) { if (!e->dead) { - avahi_goodbye_entry(g->server, e, TRUE); - e->dead = TRUE; + avahi_goodbye_entry(g->server, e, 1); + e->dead = 1; } } if (g->register_time_event) { - avahi_time_event_queue_remove(g->server->time_event_queue, g->register_time_event); + avahi_time_event_free(g->register_time_event); g->register_time_event = NULL; } - g->dead = TRUE; + g->dead = 1; - g->server->need_group_cleanup = TRUE; - g->server->need_entry_cleanup = TRUE; + g->server->need_group_cleanup = 1; + g->server->need_entry_cleanup = 1; } static void entry_group_commit_real(AvahiEntryGroup *g) { - g_assert(g); + assert(g); gettimeofday(&g->register_time, NULL); @@ -2101,28 +2171,28 @@ static void entry_group_commit_real(AvahiEntryGroup *g) { if (!g->dead) { avahi_announce_group(g->server, g); - avahi_entry_group_check_probed(g, FALSE); + avahi_entry_group_check_probed(g, 0); } } -static void entry_group_register_time_event_callback(AvahiTimeEvent *e, gpointer userdata) { +static void entry_group_register_time_event_callback(AvahiTimeEvent *e, void* userdata) { AvahiEntryGroup *g = userdata; - g_assert(g); + assert(g); /* avahi_log_debug("Holdoff passed, waking up and going on."); */ - avahi_time_event_queue_remove(g->server->time_event_queue, g->register_time_event); + avahi_time_event_free(g->register_time_event); g->register_time_event = NULL; /* Holdoff time passed, so let's start probing */ entry_group_commit_real(g); } -gint avahi_entry_group_commit(AvahiEntryGroup *g) { +int avahi_entry_group_commit(AvahiEntryGroup *g) { struct timeval now; - g_assert(g); - g_assert(!g->dead); + assert(g); + assert(!g->dead); if (g->state != AVAHI_ENTRY_GROUP_UNCOMMITED && g->state != AVAHI_ENTRY_GROUP_COLLISION) return avahi_server_set_errno(g->server, AVAHI_ERR_BAD_STATE); @@ -2145,8 +2215,8 @@ gint avahi_entry_group_commit(AvahiEntryGroup *g) { /* avahi_log_debug("Holdoff not passed, sleeping."); */ /* Holdoff time has not yet passed, so let's wait */ - g_assert(!g->register_time_event); - g->register_time_event = avahi_time_event_queue_add(g->server->time_event_queue, &g->register_time, entry_group_register_time_event_callback, g); + assert(!g->register_time_event); + g->register_time_event = avahi_time_event_new(g->server->time_event_queue, &g->register_time, entry_group_register_time_event_callback, g); avahi_entry_group_change_state(g, AVAHI_ENTRY_GROUP_REGISTERING); } @@ -2156,34 +2226,34 @@ gint avahi_entry_group_commit(AvahiEntryGroup *g) { void avahi_entry_group_reset(AvahiEntryGroup *g) { AvahiEntry *e; - g_assert(g); + assert(g); if (g->register_time_event) { - avahi_time_event_queue_remove(g->server->time_event_queue, g->register_time_event); + avahi_time_event_free(g->register_time_event); g->register_time_event = NULL; } for (e = g->entries; e; e = e->by_group_next) { if (!e->dead) { - avahi_goodbye_entry(g->server, e, TRUE); - e->dead = TRUE; + avahi_goodbye_entry(g->server, e, 1); + e->dead = 1; } } if (g->register_time_event) { - avahi_time_event_queue_remove(g->server->time_event_queue, g->register_time_event); + avahi_time_event_free(g->register_time_event); g->register_time_event = NULL; } - g->server->need_entry_cleanup = TRUE; + g->server->need_entry_cleanup = 1; g->n_probing = 0; avahi_entry_group_change_state(g, AVAHI_ENTRY_GROUP_UNCOMMITED); } -gboolean avahi_entry_commited(AvahiEntry *e) { - g_assert(e); - g_assert(!e->dead); +int avahi_entry_is_commited(AvahiEntry *e) { + assert(e); + assert(!e->dead); return !e->group || e->group->state == AVAHI_ENTRY_GROUP_REGISTERING || @@ -2191,120 +2261,130 @@ gboolean avahi_entry_commited(AvahiEntry *e) { } AvahiEntryGroupState avahi_entry_group_get_state(AvahiEntryGroup *g) { - g_assert(g); - g_assert(!g->dead); + assert(g); + assert(!g->dead); return g->state; } -void avahi_entry_group_set_data(AvahiEntryGroup *g, gpointer userdata) { - g_assert(g); +void avahi_entry_group_set_data(AvahiEntryGroup *g, void* userdata) { + assert(g); g->userdata = userdata; } -gpointer avahi_entry_group_get_data(AvahiEntryGroup *g) { - g_assert(g); +void* avahi_entry_group_get_data(AvahiEntryGroup *g) { + assert(g); return g->userdata; } -gboolean avahi_entry_group_is_empty(AvahiEntryGroup *g) { +int avahi_entry_group_is_empty(AvahiEntryGroup *g) { AvahiEntry *e; - g_assert(g); + assert(g); /* Look for an entry that is not dead */ for (e = g->entries; e; e = e->by_group_next) if (!e->dead) - return FALSE; + return 0; - return TRUE; + return 1; } -const gchar* avahi_server_get_domain_name(AvahiServer *s) { - g_assert(s); +const char* avahi_server_get_domain_name(AvahiServer *s) { + assert(s); return s->domain_name; } -const gchar* avahi_server_get_host_name(AvahiServer *s) { - g_assert(s); +const char* avahi_server_get_host_name(AvahiServer *s) { + assert(s); return s->host_name; } -const gchar* avahi_server_get_host_name_fqdn(AvahiServer *s) { - g_assert(s); +const char* avahi_server_get_host_name_fqdn(AvahiServer *s) { + assert(s); return s->host_name_fqdn; } -gpointer avahi_server_get_data(AvahiServer *s) { - g_assert(s); +void* avahi_server_get_data(AvahiServer *s) { + assert(s); return s->userdata; } -void avahi_server_set_data(AvahiServer *s, gpointer userdata) { - g_assert(s); +void avahi_server_set_data(AvahiServer *s, void* userdata) { + assert(s); s->userdata = userdata; } AvahiServerState avahi_server_get_state(AvahiServer *s) { - g_assert(s); + assert(s); return s->state; } AvahiServerConfig* avahi_server_config_init(AvahiServerConfig *c) { - g_assert(c); + assert(c); memset(c, 0, sizeof(AvahiServerConfig)); - c->use_ipv6 = TRUE; - c->use_ipv4 = TRUE; + c->use_ipv6 = 1; + c->use_ipv4 = 1; c->host_name = NULL; c->domain_name = NULL; - c->check_response_ttl = FALSE; - c->publish_hinfo = TRUE; - c->publish_addresses = TRUE; - c->publish_workstation = TRUE; - c->publish_domain = TRUE; - c->use_iff_running = FALSE; - c->enable_reflector = FALSE; - c->reflect_ipv = FALSE; + c->check_response_ttl = 0; + c->publish_hinfo = 1; + c->publish_addresses = 1; + c->publish_workstation = 1; + c->publish_domain = 1; + c->use_iff_running = 0; + c->enable_reflector = 0; + c->reflect_ipv = 0; return c; } void avahi_server_config_free(AvahiServerConfig *c) { - g_assert(c); + assert(c); - g_free(c->host_name); - g_free(c->domain_name); + avahi_free(c->host_name); + avahi_free(c->domain_name); } AvahiServerConfig* avahi_server_config_copy(AvahiServerConfig *ret, const AvahiServerConfig *c) { - g_assert(ret); - g_assert(c); - + char *d = NULL, *h = NULL; + assert(ret); + assert(c); + + if (c->host_name) + if (!(h = avahi_strdup(c->host_name))) + return NULL; + + if (c->domain_name) + if (!(d = avahi_strdup(c->domain_name))) { + avahi_free(h); + return NULL; + } + *ret = *c; - - ret->host_name = g_strdup(c->host_name); - ret->domain_name = g_strdup(c->domain_name); + ret->host_name = h; + ret->domain_name = d; return ret; } -gint avahi_server_errno(AvahiServer *s) { - g_assert(s); +int avahi_server_errno(AvahiServer *s) { + assert(s); return s->error; } /* Just for internal use */ -gint avahi_server_set_errno(AvahiServer *s, gint error) { - g_assert(s); +int avahi_server_set_errno(AvahiServer *s, int error) { + assert(s); return s->error = error; } diff --git a/avahi-core/server.h b/avahi-core/server.h index f4c7d92..78a403e 100644 --- a/avahi-core/server.h +++ b/avahi-core/server.h @@ -23,6 +23,8 @@ ***/ #include <avahi-common/llist.h> +#include <avahi-common/watch.h> + #include "core.h" #include "iface.h" #include "prioq.h" @@ -31,6 +33,7 @@ #include "browse.h" #include "dns.h" #include "rrlist.h" +#include "hashmap.h" #define AVAHI_MAX_LEGACY_UNICAST_REFLECT_SLOTS 100 @@ -39,10 +42,10 @@ typedef struct AvahiLegacyUnicastReflectSlot AvahiLegacyUnicastReflectSlot; struct AvahiLegacyUnicastReflectSlot { AvahiServer *server; - guint16 id, original_id; + uint16_t id, original_id; AvahiAddress address; - guint16 port; - gint interface; + uint16_t port; + int interface; struct timeval elapse_time; AvahiTimeEvent *time_event; }; @@ -51,7 +54,7 @@ struct AvahiEntry { AvahiServer *server; AvahiEntryGroup *group; - gboolean dead; + int dead; AvahiEntryFlags flags; AvahiRecord *record; @@ -67,15 +70,15 @@ struct AvahiEntry { struct AvahiEntryGroup { AvahiServer *server; - gboolean dead; + int dead; AvahiEntryGroupState state; - gpointer userdata; + void* userdata; AvahiEntryGroupCallback callback; - guint n_probing; + unsigned n_probing; - guint n_register_try; + unsigned n_register_try; struct timeval register_time; AvahiTimeEvent *register_time_event; @@ -84,18 +87,18 @@ struct AvahiEntryGroup { }; struct AvahiServer { - GMainContext *context; + AvahiPoll *poll_api; + AvahiInterfaceMonitor *monitor; - AvahiServerConfig config; AVAHI_LLIST_HEAD(AvahiEntry, entries); - GHashTable *entries_by_key; + AvahiHashmap *entries_by_key; AVAHI_LLIST_HEAD(AvahiEntryGroup, groups); AVAHI_LLIST_HEAD(AvahiRecordBrowser, record_browsers); - GHashTable *record_browser_hashtable; + AvahiHashmap *record_browser_hashmap; AVAHI_LLIST_HEAD(AvahiHostNameResolver, host_name_resolvers); AVAHI_LLIST_HEAD(AvahiAddressResolver, address_resolvers); AVAHI_LLIST_HEAD(AvahiDomainBrowser, domain_browsers); @@ -104,56 +107,56 @@ struct AvahiServer { AVAHI_LLIST_HEAD(AvahiServiceResolver, service_resolvers); AVAHI_LLIST_HEAD(AvahiDNSServerBrowser, dns_server_browsers); - gboolean need_entry_cleanup, need_group_cleanup, need_browser_cleanup; + int need_entry_cleanup, need_group_cleanup, need_browser_cleanup; AvahiTimeEventQueue *time_event_queue; - gchar *host_name, *host_name_fqdn, *domain_name; + char *host_name, *host_name_fqdn, *domain_name; - gint fd_ipv4, fd_ipv6, + int fd_ipv4, fd_ipv6, /* The following two sockets two are used for reflection only */ fd_legacy_unicast_ipv4, fd_legacy_unicast_ipv6; - GPollFD pollfd_ipv4, pollfd_ipv6, pollfd_legacy_unicast_ipv4, pollfd_legacy_unicast_ipv6; - GSource *source; + AvahiWatch *watch_ipv4, *watch_ipv6, + *watch_legacy_unicast_ipv4, *watch_legacy_unicast_ipv6; AvahiServerState state; AvahiServerCallback callback; - gpointer userdata; + void* userdata; AvahiEntryGroup *hinfo_entry_group; AvahiEntryGroup *browse_domain_entry_group; - guint n_host_rr_pending; + unsigned n_host_rr_pending; /* Used for assembling responses */ AvahiRecordList *record_list; /* Used for reflection of legacy unicast packets */ AvahiLegacyUnicastReflectSlot **legacy_unicast_reflect_slots; - guint16 legacy_unicast_reflect_id; + uint16_t legacy_unicast_reflect_id; - gint error; + int error; }; -gboolean avahi_server_entry_match_interface(AvahiEntry *e, AvahiInterface *i); +int avahi_server_entry_match_interface(AvahiEntry *e, AvahiInterface *i); void avahi_server_post_query(AvahiServer *s, AvahiIfIndex interface, AvahiProtocol protocol, AvahiKey *key); -void avahi_server_prepare_response(AvahiServer *s, AvahiInterface *i, AvahiEntry *e, gboolean unicast_response, gboolean auxiliary); -void avahi_server_prepare_matching_responses(AvahiServer *s, AvahiInterface *i, AvahiKey *k, gboolean unicast_response); -void avahi_server_generate_response(AvahiServer *s, AvahiInterface *i, AvahiDnsPacket *p, const AvahiAddress *a, guint16 port, gboolean legacy_unicast, gboolean is_probe); +void avahi_server_prepare_response(AvahiServer *s, AvahiInterface *i, AvahiEntry *e, int unicast_response, int auxiliary); +void avahi_server_prepare_matching_responses(AvahiServer *s, AvahiInterface *i, AvahiKey *k, int unicast_response); +void avahi_server_generate_response(AvahiServer *s, AvahiInterface *i, AvahiDnsPacket *p, const AvahiAddress *a, uint16_t port, int legacy_unicast, int is_probe); void avahi_entry_group_change_state(AvahiEntryGroup *g, AvahiEntryGroupState state); -gboolean avahi_entry_commited(AvahiEntry *e); +int avahi_entry_is_commited(AvahiEntry *e); -void avahi_server_enumerate_aux_records(AvahiServer *s, AvahiInterface *i, AvahiRecord *r, void (*callback)(AvahiServer *s, AvahiRecord *r, gboolean flush_cache, gpointer userdata), gpointer userdata); +void avahi_server_enumerate_aux_records(AvahiServer *s, AvahiInterface *i, AvahiRecord *r, void (*callback)(AvahiServer *s, AvahiRecord *r, int flush_cache, void* userdata), void* userdata); void avahi_host_rr_entry_group_callback(AvahiServer *s, AvahiEntryGroup *g, AvahiEntryGroupState state, void *userdata); void avahi_server_decrease_host_rr_pending(AvahiServer *s); void avahi_server_increase_host_rr_pending(AvahiServer *s); -gint avahi_server_set_errno(AvahiServer *s, gint error); +int avahi_server_set_errno(AvahiServer *s, int error); #endif diff --git a/avahi-core/socket.c b/avahi-core/socket.c index fc312d5..b2d6e6f 100644 --- a/avahi-core/socket.c +++ b/avahi-core/socket.c @@ -35,6 +35,7 @@ #include <sys/time.h> #include <net/if.h> #include <sys/ioctl.h> +#include <assert.h> #include "dns.h" #include "fdutil.h" @@ -42,30 +43,27 @@ #include "log.h" static void mdns_mcast_group_ipv4(struct sockaddr_in *ret_sa) { - g_assert(ret_sa); + assert(ret_sa); memset(ret_sa, 0, sizeof(struct sockaddr_in)); - ret_sa->sin_family = AF_INET; ret_sa->sin_port = htons(AVAHI_MDNS_PORT); inet_pton(AF_INET, AVAHI_IPV4_MCAST_GROUP, &ret_sa->sin_addr); } static void mdns_mcast_group_ipv6(struct sockaddr_in6 *ret_sa) { - - g_assert(ret_sa); + assert(ret_sa); memset(ret_sa, 0, sizeof(struct sockaddr_in6)); - ret_sa->sin6_family = AF_INET6; ret_sa->sin6_port = htons(AVAHI_MDNS_PORT); inet_pton(AF_INET6, AVAHI_IPV6_MCAST_GROUP, &ret_sa->sin6_addr); } -static void ipv4_address_to_sockaddr(struct sockaddr_in *ret_sa, const AvahiIPv4Address *a, guint16 port) { - g_assert(ret_sa); - g_assert(a); - g_assert(port > 0); +static void ipv4_address_to_sockaddr(struct sockaddr_in *ret_sa, const AvahiIPv4Address *a, uint16_t port) { + assert(ret_sa); + assert(a); + assert(port > 0); memset(ret_sa, 0, sizeof(struct sockaddr_in)); ret_sa->sin_family = AF_INET; @@ -73,10 +71,10 @@ static void ipv4_address_to_sockaddr(struct sockaddr_in *ret_sa, const AvahiIPv4 memcpy(&ret_sa->sin_addr, a, sizeof(AvahiIPv4Address)); } -static void ipv6_address_to_sockaddr(struct sockaddr_in6 *ret_sa, const AvahiIPv6Address *a, guint16 port) { - g_assert(ret_sa); - g_assert(a); - g_assert(port > 0); +static void ipv6_address_to_sockaddr(struct sockaddr_in6 *ret_sa, const AvahiIPv6Address *a, uint16_t port) { + assert(ret_sa); + assert(a); + assert(port > 0); memset(ret_sa, 0, sizeof(struct sockaddr_in6)); ret_sa->sin6_family = AF_INET6; @@ -84,7 +82,7 @@ static void ipv6_address_to_sockaddr(struct sockaddr_in6 *ret_sa, const AvahiIPv memcpy(&ret_sa->sin6_addr, a, sizeof(AvahiIPv6Address)); } -int avahi_mdns_mcast_join_ipv4(gint fd, gint idx) { +int avahi_mdns_mcast_join_ipv4(int fd, int idx) { struct ip_mreqn mreq; struct sockaddr_in sa; @@ -102,7 +100,7 @@ int avahi_mdns_mcast_join_ipv4(gint fd, gint idx) { return 0; } -int avahi_mdns_mcast_join_ipv6(gint fd, gint idx) { +int avahi_mdns_mcast_join_ipv6(int fd, int idx) { struct ipv6_mreq mreq6; struct sockaddr_in6 sa6; @@ -120,7 +118,7 @@ int avahi_mdns_mcast_join_ipv6(gint fd, gint idx) { return 0; } -int avahi_mdns_mcast_leave_ipv4(gint fd, gint idx) { +int avahi_mdns_mcast_leave_ipv4(int fd, int idx) { struct ip_mreqn mreq; struct sockaddr_in sa; @@ -138,7 +136,7 @@ int avahi_mdns_mcast_leave_ipv4(gint fd, gint idx) { return 0; } -int avahi_mdns_mcast_leave_ipv6(gint fd, gint idx) { +int avahi_mdns_mcast_leave_ipv6(int fd, int idx) { struct ipv6_mreq mreq6; struct sockaddr_in6 sa6; @@ -156,12 +154,12 @@ int avahi_mdns_mcast_leave_ipv6(gint fd, gint idx) { return 0; } -static gint bind_with_warn(int fd, const struct sockaddr *sa, socklen_t l) { - gint yes; +static int bind_with_warn(int fd, const struct sockaddr *sa, socklen_t l) { + int yes; - g_assert(fd >= 0); - g_assert(sa); - g_assert(l > 0); + assert(fd >= 0); + assert(sa); + assert(l > 0); if (bind(fd, sa, l) < 0) { @@ -200,7 +198,7 @@ static gint bind_with_warn(int fd, const struct sockaddr *sa, socklen_t l) { return 0; } -gint avahi_open_socket_ipv4(void) { +int avahi_open_socket_ipv4(void) { struct sockaddr_in local; int fd = -1, ttl, yes; @@ -265,7 +263,7 @@ fail: return -1; } -gint avahi_open_socket_ipv6(void) { +int avahi_open_socket_ipv6(void) { struct sockaddr_in6 sa, local; int fd = -1, ttl, yes; @@ -338,9 +336,9 @@ fail: return -1; } -static gint sendmsg_loop(gint fd, struct msghdr *msg, gint flags) { - g_assert(fd >= 0); - g_assert(msg); +static int sendmsg_loop(int fd, struct msghdr *msg, int flags) { + assert(fd >= 0); + assert(msg); for (;;) { @@ -359,7 +357,7 @@ static gint sendmsg_loop(gint fd, struct msghdr *msg, gint flags) { return 0; } -gint avahi_send_dns_packet_ipv4(gint fd, gint interface, AvahiDnsPacket *p, const AvahiIPv4Address *a, guint16 port) { +int avahi_send_dns_packet_ipv4(int fd, int interface, AvahiDnsPacket *p, const AvahiIPv4Address *a, uint16_t port) { struct sockaddr_in sa; struct msghdr msg; struct iovec io; @@ -367,10 +365,10 @@ gint avahi_send_dns_packet_ipv4(gint fd, gint interface, AvahiDnsPacket *p, cons struct in_pktinfo *pkti; uint8_t cmsg_data[sizeof(struct cmsghdr) + sizeof(struct in_pktinfo)]; - g_assert(fd >= 0); - g_assert(p); - g_assert(avahi_dns_packet_check_valid(p) >= 0); - g_assert(!a || port > 0); + assert(fd >= 0); + assert(p); + assert(avahi_dns_packet_is_valid(p) >= 0); + assert(!a || port > 0); if (!a) mdns_mcast_group_ipv4(&sa); @@ -402,7 +400,7 @@ gint avahi_send_dns_packet_ipv4(gint fd, gint interface, AvahiDnsPacket *p, cons return sendmsg_loop(fd, &msg, 0 /*MSG_DONTROUTE*/); } -gint avahi_send_dns_packet_ipv6(gint fd, gint interface, AvahiDnsPacket *p, const AvahiIPv6Address *a, guint16 port) { +int avahi_send_dns_packet_ipv6(int fd, int interface, AvahiDnsPacket *p, const AvahiIPv6Address *a, uint16_t port) { struct sockaddr_in6 sa; struct msghdr msg; struct iovec io; @@ -410,9 +408,9 @@ gint avahi_send_dns_packet_ipv6(gint fd, gint interface, AvahiDnsPacket *p, cons struct in6_pktinfo *pkti; uint8_t cmsg_data[sizeof(struct cmsghdr) + sizeof(struct in6_pktinfo)]; - g_assert(fd >= 0); - g_assert(p); - g_assert(avahi_dns_packet_check_valid(p) >= 0); + assert(fd >= 0); + assert(p); + assert(avahi_dns_packet_is_valid(p) >= 0); if (!a) mdns_mcast_group_ipv6(&sa); @@ -444,21 +442,21 @@ gint avahi_send_dns_packet_ipv6(gint fd, gint interface, AvahiDnsPacket *p, cons return sendmsg_loop(fd, &msg, 0 /*MSG_DONTROUTE*/); } -AvahiDnsPacket* avahi_recv_dns_packet_ipv4(gint fd, struct sockaddr_in *ret_sa, AvahiIPv4Address *ret_dest_address, gint *ret_iface, guint8* ret_ttl) { +AvahiDnsPacket* avahi_recv_dns_packet_ipv4(int fd, struct sockaddr_in *ret_sa, AvahiIPv4Address *ret_dest_address, int *ret_iface, uint8_t* ret_ttl) { AvahiDnsPacket *p= NULL; struct msghdr msg; struct iovec io; uint8_t aux[1024]; ssize_t l; struct cmsghdr *cmsg; - gboolean found_ttl = FALSE, found_iface = FALSE; - gint ms; + int found_ttl = 0, found_iface = 0; + int ms; - g_assert(fd >= 0); - g_assert(ret_sa); - g_assert(ret_dest_address); - g_assert(ret_iface); - g_assert(ret_ttl); + assert(fd >= 0); + assert(ret_sa); + assert(ret_dest_address); + assert(ret_iface); + assert(ret_ttl); if (ioctl(fd, FIONREAD, &ms) < 0) { avahi_log_warn("ioctl(): %s", strerror(errno)); @@ -491,8 +489,8 @@ AvahiDnsPacket* avahi_recv_dns_packet_ipv4(gint fd, struct sockaddr_in *ret_sa, goto fail; } - g_assert(!(msg.msg_flags & MSG_CTRUNC)); - g_assert(!(msg.msg_flags & MSG_TRUNC)); + assert(!(msg.msg_flags & MSG_CTRUNC)); + assert(!(msg.msg_flags & MSG_TRUNC)); p->size = (size_t) l; *ret_ttl = 0; @@ -507,20 +505,20 @@ AvahiDnsPacket* avahi_recv_dns_packet_ipv4(gint fd, struct sockaddr_in *ret_sa, if (cmsg->cmsg_type == IP_TTL) { *ret_ttl = (uint8_t) (*(int *) CMSG_DATA(cmsg)); - found_ttl = TRUE; + found_ttl = 1; } else if (cmsg->cmsg_type == IP_PKTINFO) { struct in_pktinfo *i = (struct in_pktinfo*) CMSG_DATA(cmsg); - *ret_iface = (gint) i->ipi_ifindex; + *ret_iface = (int) i->ipi_ifindex; ret_dest_address->address = i->ipi_addr.s_addr; - found_iface = TRUE; + found_iface = 1; } } } /* avahi_log_debug("ttl=%u iface=%i", *ret_ttl, *ret_iface); */ - g_assert(found_iface); - g_assert(found_ttl); + assert(found_iface); + assert(found_ttl); return p; @@ -531,22 +529,22 @@ fail: return NULL; } -AvahiDnsPacket* avahi_recv_dns_packet_ipv6(gint fd, struct sockaddr_in6 *ret_sa, AvahiIPv6Address *ret_dest_address, gint *ret_iface, guint8* ret_ttl) { +AvahiDnsPacket* avahi_recv_dns_packet_ipv6(int fd, struct sockaddr_in6 *ret_sa, AvahiIPv6Address *ret_dest_address, int *ret_iface, uint8_t* ret_ttl) { AvahiDnsPacket *p = NULL; struct msghdr msg; struct iovec io; uint8_t aux[64]; ssize_t l; - gint ms; + int ms; struct cmsghdr *cmsg; - gboolean found_ttl = FALSE, found_iface = FALSE; + int found_ttl = 0, found_iface = 0; - g_assert(fd >= 0); - g_assert(ret_sa); - g_assert(ret_dest_address); - g_assert(ret_iface); - g_assert(ret_ttl); + assert(fd >= 0); + assert(ret_sa); + assert(ret_dest_address); + assert(ret_iface); + assert(ret_ttl); if (ioctl(fd, FIONREAD, &ms) < 0) { avahi_log_warn("ioctl(): %s", strerror(errno)); @@ -579,19 +577,19 @@ AvahiDnsPacket* avahi_recv_dns_packet_ipv6(gint fd, struct sockaddr_in6 *ret_sa, for (cmsg = CMSG_FIRSTHDR(&msg); cmsg != NULL; cmsg = CMSG_NXTHDR(&msg, cmsg)) { if (cmsg->cmsg_level == SOL_IPV6 && cmsg->cmsg_type == IPV6_HOPLIMIT) { *ret_ttl = (uint8_t) (*(int *) CMSG_DATA(cmsg)); - found_ttl = TRUE; + found_ttl = 1; } if (cmsg->cmsg_level == SOL_IPV6 && cmsg->cmsg_type == IPV6_PKTINFO) { struct in6_pktinfo *i = (struct in6_pktinfo*) CMSG_DATA(cmsg); *ret_iface = i->ipi6_ifindex; memcpy(ret_dest_address->address, i->ipi6_addr.s6_addr, 16); - found_iface = TRUE; + found_iface = 1; } } - g_assert(found_iface); - g_assert(found_ttl); + assert(found_iface); + assert(found_ttl); return p; @@ -602,7 +600,7 @@ fail: return NULL; } -gint avahi_open_legacy_unicast_socket_ipv4(void) { +int avahi_open_legacy_unicast_socket_ipv4(void) { struct sockaddr_in local; int fd = -1, yes; @@ -650,7 +648,7 @@ fail: return -1; } -gint avahi_open_legacy_unicast_socket_ipv6(void) { +int avahi_open_legacy_unicast_socket_ipv6(void) { struct sockaddr_in local; int fd = -1, yes; diff --git a/avahi-core/socket.h b/avahi-core/socket.h index 0643d79..d795156 100644 --- a/avahi-core/socket.h +++ b/avahi-core/socket.h @@ -23,6 +23,7 @@ ***/ #include <netinet/in.h> +#include <inttypes.h> #include "dns.h" @@ -30,22 +31,22 @@ #define AVAHI_IPV4_MCAST_GROUP "224.0.0.251" #define AVAHI_IPV6_MCAST_GROUP "ff02::fb" -gint avahi_open_socket_ipv4(void); -gint avahi_open_socket_ipv6(void); +int avahi_open_socket_ipv4(void); +int avahi_open_socket_ipv6(void); -gint avahi_open_legacy_unicast_socket_ipv4(void); -gint avahi_open_legacy_unicast_socket_ipv6(void); +int avahi_open_legacy_unicast_socket_ipv4(void); +int avahi_open_legacy_unicast_socket_ipv6(void); -gint avahi_send_dns_packet_ipv4(gint fd, gint iface, AvahiDnsPacket *p, const AvahiIPv4Address *a, guint16 port); -gint avahi_send_dns_packet_ipv6(gint fd, gint iface, AvahiDnsPacket *p, const AvahiIPv6Address *a, guint16 port); +int avahi_send_dns_packet_ipv4(int fd, int iface, AvahiDnsPacket *p, const AvahiIPv4Address *a, uint16_t port); +int avahi_send_dns_packet_ipv6(int fd, int iface, AvahiDnsPacket *p, const AvahiIPv6Address *a, uint16_t port); -AvahiDnsPacket *avahi_recv_dns_packet_ipv4(gint fd, struct sockaddr_in*ret_sa, AvahiIPv4Address *ret_dest_address, gint *ret_iface, guint8 *ret_ttl); -AvahiDnsPacket *avahi_recv_dns_packet_ipv6(gint fd, struct sockaddr_in6*ret_sa, AvahiIPv6Address *ret_dest_address, gint *ret_iface, guint8 *ret_ttl); +AvahiDnsPacket *avahi_recv_dns_packet_ipv4(int fd, struct sockaddr_in*ret_sa, AvahiIPv4Address *ret_dest_address, int *ret_iface, uint8_t *ret_ttl); +AvahiDnsPacket *avahi_recv_dns_packet_ipv6(int fd, struct sockaddr_in6*ret_sa, AvahiIPv6Address *ret_dest_address, int *ret_iface, uint8_t *ret_ttl); -int avahi_mdns_mcast_join_ipv4(gint fd, gint idx); -int avahi_mdns_mcast_join_ipv6(gint fd, gint idx); +int avahi_mdns_mcast_join_ipv4(int fd, int idx); +int avahi_mdns_mcast_join_ipv6(int fd, int idx); -int avahi_mdns_mcast_leave_ipv4(gint fd, gint idx); -int avahi_mdns_mcast_leave_ipv6(gint fd, gint idx); +int avahi_mdns_mcast_leave_ipv4(int fd, int idx); +int avahi_mdns_mcast_leave_ipv6(int fd, int idx); #endif diff --git a/avahi-core/timeeventq-test.c b/avahi-core/timeeventq-test.c index 613d438..46a948a 100644 --- a/avahi-core/timeeventq-test.c +++ b/avahi-core/timeeventq-test.c @@ -23,37 +23,47 @@ #include <config.h> #endif -#include <glib.h> +#include <assert.h> +#include <stdlib.h> #include <avahi-common/timeval.h> +#include <avahi-common/simple-watch.h> + #include "timeeventq.h" +#include "log.h" + +#define POINTER_TO_INT(p) ((int) (p)) +#define INT_TO_POINTER(i) ((void*) (i)) static AvahiTimeEventQueue *q = NULL; -static void callback(AvahiTimeEvent*e, gpointer userdata) { +static void callback(AvahiTimeEvent*e, void* userdata) { struct timeval tv = {0, 0}; - g_assert(e); - g_message("callback(%i)", GPOINTER_TO_INT(userdata)); + assert(e); + avahi_log_info("callback(%i)", POINTER_TO_INT(userdata)); avahi_elapse_time(&tv, 1000, 100); - avahi_time_event_queue_update(q, e, &tv); + avahi_time_event_update(e, &tv); } int main(int argc, char *argv[]) { - GMainLoop *loop = NULL; struct timeval tv; - - q = avahi_time_event_queue_new(NULL, 0); + AvahiSimplePoll *s; + + s = avahi_simple_poll_new(); + + q = avahi_time_event_queue_new(avahi_simple_poll_get(s)); + + avahi_time_event_new(q, avahi_elapse_time(&tv, 5000, 100), callback, INT_TO_POINTER(1)); + avahi_time_event_new(q, avahi_elapse_time(&tv, 5000, 100), callback, INT_TO_POINTER(2)); - avahi_time_event_queue_add(q, avahi_elapse_time(&tv, 5000, 100), callback, GINT_TO_POINTER(1)); - avahi_time_event_queue_add(q, avahi_elapse_time(&tv, 5000, 100), callback, GINT_TO_POINTER(2)); + avahi_log_info("starting"); - g_message("starting"); - - loop = g_main_loop_new(NULL, FALSE); - g_main_loop_run(loop); - g_main_loop_unref(loop); + for (;;) + if (avahi_simple_poll_iterate(s, -1) != 0) + break; avahi_time_event_queue_free(q); + avahi_simple_poll_free(s); return 0; } diff --git a/avahi-core/timeeventq.c b/avahi-core/timeeventq.c index 88e1779..b069ffd 100644 --- a/avahi-core/timeeventq.c +++ b/avahi-core/timeeventq.c @@ -23,12 +23,32 @@ #include <config.h> #endif +#include <assert.h> +#include <stdlib.h> + #include <avahi-common/timeval.h> -#include "timeeventq.h" +#include <avahi-common/malloc.h> -static gint compare(gconstpointer _a, gconstpointer _b) { +#include "timeeventq.h" +#include "log.h" + +struct AvahiTimeEvent { + AvahiTimeEventQueue *queue; + AvahiPrioQueueNode *node; + struct timeval expiry; + struct timeval last_run; + AvahiTimeEventCallback callback; + void* userdata; +}; + +struct AvahiTimeEventQueue { + AvahiPoll *poll_api; + AvahiPrioQueue *prioq; +}; + +static int compare(const void* _a, const void* _b) { const AvahiTimeEvent *a = _a, *b = _b; - gint ret; + int ret; if ((ret = avahi_timeval_compare(&a->expiry, &b->expiry)) != 0) return ret; @@ -38,198 +58,158 @@ static gint compare(gconstpointer _a, gconstpointer _b) { return avahi_timeval_compare(&a->last_run, &b->last_run); } -static void source_get_timeval(GSource *source, struct timeval *tv) { - GTimeVal gtv; - - g_assert(source); - g_assert(tv); - - g_source_get_current_time(source, >v); - tv->tv_sec = gtv.tv_sec; - tv->tv_usec = gtv.tv_usec; -} - -static gboolean prepare_func(GSource *source, gint *timeout) { - AvahiTimeEventQueue *q = (AvahiTimeEventQueue*) source; - AvahiTimeEvent *e; - struct timeval now; - - g_assert(source); - g_assert(timeout); - - if (!q->prioq->root) { - *timeout = -1; - return FALSE; - } - - e = q->prioq->root->data; - g_assert(e); - - source_get_timeval(source, &now); - - if (avahi_timeval_compare(&now, &e->expiry) >= 0 && /* Time elapsed */ - avahi_timeval_compare(&now, &e->last_run) != 0 /* Not yet run */) { - *timeout = -1; - return TRUE; - } +static void expiration_event(AvahiPoll *poll_api, void *userdata); - *timeout = (gint) (avahi_timeval_diff(&e->expiry, &now)/1000); +static void update_wakeup(AvahiTimeEventQueue *q) { + assert(q); - /* Wait at least 1 msec */ - if (*timeout <= 0) - *timeout = 1; - - return FALSE; + if (q->prioq->root) { + AvahiTimeEvent *e = q->prioq->root->data; + q->poll_api->set_wakeup(q->poll_api, &e->expiry, expiration_event, q); + } else + q->poll_api->set_wakeup(q->poll_api, NULL, NULL, NULL); } -static gboolean check_func(GSource *source) { - AvahiTimeEventQueue *q = (AvahiTimeEventQueue*) source; - AvahiTimeEvent *e; +void expiration_event(AvahiPoll *poll_api, void *userdata) { struct timeval now; + AvahiTimeEventQueue *q = userdata; + AvahiTimeEvent *e; - g_assert(source); - - if (!q->prioq->root) - return FALSE; - - e = q->prioq->root->data; - g_assert(e); - - source_get_timeval(source, &now); + gettimeofday(&now, NULL); - return - avahi_timeval_compare(&now, &e->expiry) >= 0 && /* Time elapsed */ - avahi_timeval_compare(&now, &e->last_run) != 0; /* Not yet run */ -} - -static gboolean dispatch_func(GSource *source, GSourceFunc callback, gpointer user_data) { - AvahiTimeEventQueue *q = (AvahiTimeEventQueue*) source; - struct timeval now; + if ((e = avahi_time_event_queue_root(q))) { - g_assert(source); + /* Check if expired */ + if (avahi_timeval_compare(&now, &e->expiry) >= 0) { - source_get_timeval(source, &now); + /* Make sure to move the entry away from the front */ + e->last_run = now; + avahi_prio_queue_shuffle(q->prioq, e->node); - while (q->prioq->root) { - AvahiTimeEvent *e = q->prioq->root->data; - - /* Not yet expired */ - if (avahi_timeval_compare(&now, &e->expiry) < 0) - break; - - /* Already ran */ - if (avahi_timeval_compare(&now, &e->last_run) == 0) - break; - - /* Make sure to move the entry away from the front */ - e->last_run = now; - avahi_prio_queue_shuffle(q->prioq, e->node); - - /* Run it */ - g_assert(e->callback); - e->callback(e, e->userdata); + /* Run it */ + assert(e->callback); + e->callback(e, e->userdata); + } } - return TRUE; + update_wakeup(q); } static void fix_expiry_time(AvahiTimeEvent *e) { struct timeval now; - g_assert(e); + assert(e); - source_get_timeval(&e->queue->source, &now); + gettimeofday(&now, NULL); if (avahi_timeval_compare(&now, &e->expiry) > 0) e->expiry = now; - } -AvahiTimeEventQueue* avahi_time_event_queue_new(GMainContext *context, gint priority) { +AvahiTimeEventQueue* avahi_time_event_queue_new(AvahiPoll *poll_api) { AvahiTimeEventQueue *q; - static GSourceFuncs source_funcs = { - prepare_func, - check_func, - dispatch_func, - NULL, - NULL, - NULL - }; + if (!(q = avahi_new(AvahiTimeEventQueue, 1))) { + avahi_log_error(__FILE__": Out of memory"); + goto oom; + } - q = (AvahiTimeEventQueue*) g_source_new(&source_funcs, sizeof(AvahiTimeEventQueue)); - q->prioq = avahi_prio_queue_new(compare); + if (!(q->prioq = avahi_prio_queue_new(compare))) + goto oom; - g_source_set_priority((GSource*) q, priority); - - g_source_attach(&q->source, context); - + q->poll_api = poll_api; return q; + +oom: + + if (q) + avahi_free(q); + + return NULL; } void avahi_time_event_queue_free(AvahiTimeEventQueue *q) { - g_assert(q); + assert(q); while (q->prioq->root) - avahi_time_event_queue_remove(q, q->prioq->root->data); + avahi_time_event_free(q->prioq->root->data); avahi_prio_queue_free(q->prioq); - g_source_destroy(&q->source); - g_source_unref(&q->source); + avahi_free(q); } -AvahiTimeEvent* avahi_time_event_queue_add(AvahiTimeEventQueue *q, const struct timeval *timeval, AvahiTimeEventCallback callback, gpointer userdata) { +AvahiTimeEvent* avahi_time_event_new( + AvahiTimeEventQueue *q, + const struct timeval *timeval, + AvahiTimeEventCallback callback, + void* userdata) { + AvahiTimeEvent *e; - g_assert(q); - g_assert(timeval); - g_assert(callback); - g_assert(userdata); + assert(q); + assert(callback); + assert(userdata); - e = g_new(AvahiTimeEvent, 1); + if (!(e = avahi_new(AvahiTimeEvent, 1))) { + avahi_log_error(__FILE__": Out of memory"); + return NULL; /* OOM */ + } + e->queue = q; e->callback = callback; e->userdata = userdata; - e->expiry = *timeval; + if (timeval) + e->expiry = *timeval; + else { + e->expiry.tv_sec = 0; + e->expiry.tv_usec = 0; + } + fix_expiry_time(e); e->last_run.tv_sec = 0; e->last_run.tv_usec = 0; - e->node = avahi_prio_queue_put(q->prioq, e); - + if (!(e->node = avahi_prio_queue_put(q->prioq, e))) { + avahi_free(e); + return NULL; + } + + update_wakeup(q); return e; } -void avahi_time_event_queue_remove(AvahiTimeEventQueue *q, AvahiTimeEvent *e) { - g_assert(q); - g_assert(e); - g_assert(e->queue == q); +void avahi_time_event_free(AvahiTimeEvent *e) { + AvahiTimeEventQueue *q; + assert(e); + + q = e->queue; avahi_prio_queue_remove(q->prioq, e->node); - g_free(e); + avahi_free(e); + + update_wakeup(q); } -void avahi_time_event_queue_update(AvahiTimeEventQueue *q, AvahiTimeEvent *e, const struct timeval *timeval) { - g_assert(q); - g_assert(e); - g_assert(e->queue == q); - g_assert(timeval); +void avahi_time_event_update(AvahiTimeEvent *e, const struct timeval *timeval) { + assert(e); + assert(timeval); e->expiry = *timeval; fix_expiry_time(e); - - avahi_prio_queue_shuffle(q->prioq, e->node); + avahi_prio_queue_shuffle(e->queue->prioq, e->node); + + update_wakeup(e->queue); } AvahiTimeEvent* avahi_time_event_queue_root(AvahiTimeEventQueue *q) { - g_assert(q); + assert(q); return q->prioq->root ? q->prioq->root->data : NULL; } AvahiTimeEvent* avahi_time_event_next(AvahiTimeEvent *e) { - g_assert(e); + assert(e); return e->node->next->data; } diff --git a/avahi-core/timeeventq.h b/avahi-core/timeeventq.h index 65f1420..b99c81f 100644 --- a/avahi-core/timeeventq.h +++ b/avahi-core/timeeventq.h @@ -27,31 +27,23 @@ typedef struct AvahiTimeEventQueue AvahiTimeEventQueue; typedef struct AvahiTimeEvent AvahiTimeEvent; -#include "prioq.h" - -typedef void (*AvahiTimeEventCallback)(AvahiTimeEvent *e, gpointer userdata); +#include <avahi-common/watch.h> -struct AvahiTimeEvent { - AvahiTimeEventQueue *queue; - AvahiPrioQueueNode *node; - struct timeval expiry; - struct timeval last_run; - AvahiTimeEventCallback callback; - gpointer userdata; -}; +#include "prioq.h" -struct AvahiTimeEventQueue { - GSource source; - AvahiPrioQueue *prioq; -}; +typedef void (*AvahiTimeEventCallback)(AvahiTimeEvent *e, void* userdata); -AvahiTimeEventQueue* avahi_time_event_queue_new(GMainContext *context, gint priority); +AvahiTimeEventQueue* avahi_time_event_queue_new(AvahiPoll *poll_api); void avahi_time_event_queue_free(AvahiTimeEventQueue *q); -AvahiTimeEvent* avahi_time_event_queue_add(AvahiTimeEventQueue *q, const struct timeval *timeval, AvahiTimeEventCallback callback, gpointer userdata); -void avahi_time_event_queue_remove(AvahiTimeEventQueue *q, AvahiTimeEvent *e); +AvahiTimeEvent* avahi_time_event_new( + AvahiTimeEventQueue *q, + const struct timeval *timeval, + AvahiTimeEventCallback callback, + void* userdata); -void avahi_time_event_queue_update(AvahiTimeEventQueue *q, AvahiTimeEvent *e, const struct timeval *timeval); +void avahi_time_event_free(AvahiTimeEvent *e); +void avahi_time_event_update(AvahiTimeEvent *e, const struct timeval *timeval); AvahiTimeEvent* avahi_time_event_queue_root(AvahiTimeEventQueue *q); AvahiTimeEvent* avahi_time_event_next(AvahiTimeEvent *e); diff --git a/avahi-core/util.c b/avahi-core/util.c index 4fe8737..77632fd 100644 --- a/avahi-core/util.c +++ b/avahi-core/util.c @@ -29,8 +29,7 @@ #include <assert.h> #include <ctype.h> -#include <glib.h> - +#include <avahi-common/malloc.h> #include "util.h" void avahi_hexdump(const void* p, size_t size) { @@ -73,7 +72,8 @@ char *avahi_format_mac_address(const uint8_t* mac, size_t size) { unsigned i; static const char hex[] = "0123456789abcdef"; - t = r = g_new(char, size > 0 ? size*3 : 1); + if (!(t = r = avahi_new(char, size > 0 ? size*3 : 1))) + return NULL; if (size <= 0) { *r = 0; @@ -92,8 +92,6 @@ char *avahi_format_mac_address(const uint8_t* mac, size_t size) { return r; } - - char *avahi_strdown(char *s) { char *c; @@ -114,4 +112,3 @@ char *avahi_strup(char *s) { return s; } - diff --git a/avahi-daemon/Makefile.am b/avahi-daemon/Makefile.am index 491e5ce..72a513d 100644 --- a/avahi-daemon/Makefile.am +++ b/avahi-daemon/Makefile.am @@ -97,7 +97,7 @@ introspection_DATA = \ endif avahi_daemon_CFLAGS = $(AM_CFLAGS) -avahi_daemon_LDADD = $(AM_LDADD) ../avahi-core/libavahi-core.la ../avahi-common/libavahi-common.la +avahi_daemon_LDADD = $(AM_LDADD) ../avahi-common/libavahi-common.la ../avahi-glib/libavahi-glib.la ../avahi-core/libavahi-core.la xmllint: xmllint --noout --valid example.service diff --git a/avahi-daemon/dbus-protocol.c b/avahi-daemon/dbus-protocol.c index 41cef18..6526d7d 100644 --- a/avahi-daemon/dbus-protocol.c +++ b/avahi-daemon/dbus-protocol.c @@ -587,13 +587,15 @@ static DBusHandlerResult msg_entry_group_impl(DBusConnection *c, DBusMessage *m, return DBUS_HANDLER_RESULT_HANDLED; } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "GetState")) { - + AvahiEntryGroupState state; + if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) { avahi_log_warn("Error parsing EntryGroup::GetState message"); goto fail; } - return respond_int32(c, m, (gint32) avahi_entry_group_get_state(i->entry_group)); + state = avahi_entry_group_get_state(i->entry_group); + return respond_int32(c, m, (gint32) state); } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "AddService")) { gint32 interface, protocol; @@ -1131,13 +1133,15 @@ static DBusHandlerResult msg_server_impl(DBusConnection *c, DBusMessage *m, void return respond_string(c, m, PACKAGE_STRING); } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "GetState")) { - + AvahiServerState state; + if (!(dbus_message_get_args(m, &error, DBUS_TYPE_INVALID))) { avahi_log_warn("Error parsing Server::GetState message"); goto fail; } - - return respond_int32(c, m, (gint32) avahi_server_get_state(avahi_server)); + + state = avahi_server_get_state(avahi_server); + return respond_int32(c, m, (gint32) state); } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "GetNetworkInterfaceNameByIndex")) { gint32 idx; @@ -1618,7 +1622,7 @@ int dbus_protocol_setup(GMainLoop *loop) { } dbus_connection_setup_with_g_main(server->bus, NULL); - dbus_connection_set_exit_on_disconnect(server->bus, FALSE); + dbus_connection_set_exit_on_disconnect(server->bus, TRUE); dbus_bus_request_name(server->bus, AVAHI_DBUS_NAME, 0, &error); if (dbus_error_is_set(&error)) { diff --git a/avahi-daemon/main.c b/avahi-daemon/main.c index 480753e..94f89b3 100644 --- a/avahi-daemon/main.c +++ b/avahi-daemon/main.c @@ -33,6 +33,9 @@ #include <pwd.h> #include <sys/stat.h> #include <stdio.h> +#include <fcntl.h> +#include <time.h> +#include <stdlib.h> #include <libdaemon/dfork.h> #include <libdaemon/dsignal.h> @@ -41,6 +44,8 @@ #include <avahi-core/core.h> #include <avahi-core/log.h> +#include <avahi-glib/glib-malloc.h> +#include <avahi-glib/glib-watch.h> #include "main.h" #include "simple-protocol.h" @@ -169,7 +174,7 @@ static void remove_dns_server_entry_groups(void) { avahi_entry_group_reset(dns_servers_entry_group); } -static void server_callback(AvahiServer *s, AvahiServerState state, gpointer userdata) { +static void server_callback(AvahiServer *s, AvahiServerState state, void *userdata) { DaemonConfig *c = userdata; g_assert(s); @@ -502,9 +507,11 @@ static gint run_server(DaemonConfig *c) { GIOChannel *io = NULL; guint watch_id = (guint) -1; gint error; + AvahiGLibPoll *poll_api; g_assert(c); - + + poll_api = avahi_glib_poll_new(NULL); loop = g_main_loop_new(NULL, FALSE); if (daemon_signal_init(SIGINT, SIGQUIT, SIGHUP, SIGTERM, SIGUSR1, 0) < 0) { @@ -518,7 +525,7 @@ static gint run_server(DaemonConfig *c) { } g_io_channel_set_close_on_unref(io, FALSE); - g_io_add_watch(io, G_IO_IN, signal_callback, loop); + watch_id = g_io_add_watch(io, G_IO_IN, signal_callback, loop); if (simple_protocol_setup(NULL) < 0) goto finish; @@ -529,7 +536,7 @@ static gint run_server(DaemonConfig *c) { goto finish; #endif - if (!(avahi_server = avahi_server_new(NULL, &c->server_config, server_callback, c, &error))) { + if (!(avahi_server = avahi_server_new(avahi_glib_poll_get(poll_api), &c->server_config, server_callback, c, &error))) { avahi_log_error("Failed to create server: %s", avahi_strerror(error)); goto finish; } @@ -569,10 +576,12 @@ finish: if (io) g_io_channel_unref(io); - + if (poll_api) + avahi_glib_poll_free(poll_api); + if (loop) g_main_loop_unref(loop); - + if (r != 0 && c->daemonize) daemon_retval_send(1); @@ -689,12 +698,35 @@ fail: } +#define RANDOM_DEVICE "/dev/urandom" + +static void init_rand_seed(void) { + int fd; + unsigned seed = 0; + + /* Try to initialize seed from /dev/urandom, to make it a little + * less predictable, and to make sure that multiple machines + * booted at the same time choose different random seeds. */ + if ((fd = open(RANDOM_DEVICE, O_RDONLY)) >= 0) { + read(fd, &seed, sizeof(seed)); + close(fd); + } + + /* If the initialization failed by some reason, we add the time to the seed*/ + seed |= (unsigned) time(NULL); + + srand(seed); +} + int main(int argc, char *argv[]) { gint r = 255; const gchar *argv0; gboolean wrote_pid_file = FALSE; avahi_set_log_function(log_function); + avahi_set_allocator(avahi_glib_allocator()); + + init_rand_seed(); avahi_server_config_init(&config.server_config); config.command = DAEMON_RUN; diff --git a/avahi-daemon/simple-protocol.c b/avahi-daemon/simple-protocol.c index 39af043..12d8adb 100644 --- a/avahi-daemon/simple-protocol.c +++ b/avahi-daemon/simple-protocol.c @@ -164,12 +164,19 @@ static void client_output_printf(Client *c, const gchar *format, ...) { } -static void host_name_resolver_callback(AvahiHostNameResolver *r, AvahiIfIndex iface, AvahiProtocol protocol, AvahiBrowserEvent event, const gchar *hostname, const AvahiAddress *a, gpointer userdata) { +static void host_name_resolver_callback( + AvahiHostNameResolver *r, + AvahiIfIndex iface, + AvahiProtocol protocol, + AvahiResolverEvent event, + const char *hostname, + const AvahiAddress *a, + void* userdata) { + Client *c = userdata; g_assert(c); - if (event == AVAHI_RESOLVER_TIMEOUT) client_output_printf(c, "%+i Query timed out\n", AVAHI_ERR_TIMEOUT); else { @@ -181,9 +188,16 @@ static void host_name_resolver_callback(AvahiHostNameResolver *r, AvahiIfIndex i c->state = CLIENT_DEAD; } -static void address_resolver_callback(AvahiAddressResolver *r, AvahiIfIndex iface, AvahiProtocol protocol, AvahiBrowserEvent event, const AvahiAddress *a, const gchar *hostname, gpointer userdata) { - Client *c = userdata; +static void address_resolver_callback( + AvahiAddressResolver *r, + AvahiIfIndex iface, + AvahiProtocol protocol, + AvahiResolverEvent event, + const AvahiAddress *a, + const char *hostname, + void* userdata) { + Client *c = userdata; g_assert(c); @@ -195,7 +209,7 @@ static void address_resolver_callback(AvahiAddressResolver *r, AvahiIfIndex ifac c->state = CLIENT_DEAD; } -static void dns_server_browser_callback(AvahiDNSServerBrowser *b, AvahiIfIndex interface, AvahiProtocol protocol, AvahiBrowserEvent event, const gchar *host_name, const AvahiAddress *a, guint16 port, gpointer userdata) { +static void dns_server_browser_callback(AvahiDNSServerBrowser *b, AvahiIfIndex interface, AvahiProtocol protocol, AvahiBrowserEvent event, const char *host_name, const AvahiAddress *a, uint16_t port, void* userdata) { Client *c = userdata; gchar t[64]; diff --git a/avahi-discover-standalone/Makefile.am b/avahi-discover-standalone/Makefile.am index 1d54211..dbff50f 100644 --- a/avahi-discover-standalone/Makefile.am +++ b/avahi-discover-standalone/Makefile.am @@ -34,7 +34,7 @@ avahi_discover_standalone_SOURCES = \ main.c avahi_discover_standalone_CFLAGS = $(AM_CFLAGS) -avahi_discover_standalone_LDADD = $(AM_LDADD) ../avahi-core/libavahi-core.la ../avahi-common/libavahi-common.la +avahi_discover_standalone_LDADD = $(AM_LDADD) ../avahi-common/libavahi-common.la ../avahi-glib/libavahi-glib.la ../avahi-core/libavahi-core.la interfaces = \ avahi-discover.glade diff --git a/avahi-discover-standalone/main.c b/avahi-discover-standalone/main.c index 00984ec..926f4c4 100644 --- a/avahi-discover-standalone/main.c +++ b/avahi-discover-standalone/main.c @@ -29,7 +29,9 @@ #include <glade/glade.h> #include <avahi-core/core.h> #include <avahi-common/strlst.h> -#include <avahi-common/util.h> +#include <avahi-common/domain.h> +#include <avahi-glib/glib-watch.h> +#include <avahi-glib/glib-malloc.h> struct ServiceType; @@ -268,10 +270,15 @@ int main(int argc, char *argv[]) { AvahiServerConfig config; GtkTreeViewColumn *c; gint error; + AvahiGLibPoll *poll_api; gtk_init(&argc, &argv); glade_init(); + avahi_set_allocator(avahi_glib_allocator()); + + poll_api = avahi_glib_poll_new(NULL); + xml = glade_xml_new(AVAHI_INTERFACES_DIR"avahi-discover.glade", NULL, NULL); main_window = glade_xml_get_widget(xml, "main_window"); g_signal_connect(main_window, "delete-event", (GCallback) main_window_on_delete_event, NULL); @@ -294,7 +301,7 @@ int main(int argc, char *argv[]) { avahi_server_config_init(&config); config.publish_hinfo = config.publish_addresses = config.publish_domain = config.publish_workstation = FALSE; - server = avahi_server_new(NULL, &config, NULL, NULL, &error); + server = avahi_server_new(avahi_glib_poll_get(poll_api), &config, NULL, NULL, &error); avahi_server_config_free(&config); g_assert(server); @@ -304,6 +311,7 @@ int main(int argc, char *argv[]) { gtk_main(); avahi_server_free(server); + avahi_glib_poll_free(poll_api); return 0; } diff --git a/avahi-dnsconfd/main.c b/avahi-dnsconfd/main.c index 99bae64..a76aa71 100644 --- a/avahi-dnsconfd/main.c +++ b/avahi-dnsconfd/main.c @@ -237,11 +237,12 @@ finish: static void run_script(gboolean new, gint interface, guchar protocol, const gchar *address) { gchar *p; - g_assert(interface > 0); gint ret; gchar ia[16], pa[16]; gchar name[IFNAMSIZ+1]; + g_assert(interface > 0); + if (!getifname(interface, name, sizeof(name))) return; diff --git a/avahi-glib/Makefile.am b/avahi-glib/Makefile.am index 6cfc46e..dd5a14f 100644 --- a/avahi-glib/Makefile.am +++ b/avahi-glib/Makefile.am @@ -33,6 +33,7 @@ avahiincludedir=$(includedir)/avahi-glib avahiinclude_HEADERS = \ glib-watch.h + glib-malloc.h lib_LTLIBRARIES = \ libavahi-glib.la @@ -41,7 +42,8 @@ noinst_PROGRAMS = \ glib-watch-test libavahi_glib_la_SOURCES = \ - glib-watch.c glib-watch.h + glib-watch.c glib-watch.h \ + glib-malloc.h glib-malloc.c libavahi_glib_la_CFLAGS = $(AM_CFLAGS) libavahi_glib_la_LIBADD = $(AM_LDADD) $(COMMON_LDADD) diff --git a/avahi-glib/glib-malloc.c b/avahi-glib/glib-malloc.c new file mode 100644 index 0000000..2968abc --- /dev/null +++ b/avahi-glib/glib-malloc.c @@ -0,0 +1,57 @@ +/* $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. +***/ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif + +#include <avahi-common/llist.h> +#include <avahi-common/malloc.h> + +#include "glib-malloc.h" + +static void* malloc_glue(size_t l) { + return g_malloc(l); +} + +static void* realloc_glue(void *p, size_t l) { + return g_realloc(p, l); +} + +static void* calloc_glue(size_t nmemb, size_t size) { + return g_malloc0(nmemb * size); +} + +const AvahiAllocator *avahi_glib_allocator(void) { + + static AvahiAllocator allocator; + static int allocator_initialized = 0; + + if (!allocator_initialized) { + allocator.malloc = malloc_glue; + allocator.free = g_free; + allocator.realloc = realloc_glue; + allocator.calloc = calloc_glue; + allocator_initialized = 1; + } + + return &allocator; +} diff --git a/avahi-glib/glib-malloc.h b/avahi-glib/glib-malloc.h new file mode 100644 index 0000000..7ce8269 --- /dev/null +++ b/avahi-glib/glib-malloc.h @@ -0,0 +1,45 @@ +#ifndef fooglibmallochfoo +#define fooglibmallochfoo + +/* $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. +***/ + +/** \file glib-malloc.h GLib's memory allocator for Avahi */ + +#include <glib.h> + +#include <avahi-common/cdecl.h> +#include <avahi-common/malloc.h> + +#ifndef DOXYGEN_SHOULD_SKIP_THIS +AVAHI_C_DECL_BEGIN +#endif + +/** Return a pointer to a memory allocator that uses GLib's g_malloc() + and frinds. Th returned structure is statically allocated, and needs + not to be copied or freed. Pass this directly to avahi_set_allocator(). */ +const AvahiAllocator * avahi_glib_allocator(void); + +#ifndef DOXYGEN_SHOULD_SKIP_THIS +AVAHI_C_DECL_END +#endif + +#endif diff --git a/avahi-glib/glib-watch-test.c b/avahi-glib/glib-watch-test.c index 5072321..bd111dd 100644 --- a/avahi-glib/glib-watch-test.c +++ b/avahi-glib/glib-watch-test.c @@ -52,24 +52,24 @@ static void callback(AvahiWatch *w, int fd, AvahiWatchEvent event, void *userdat } } -static void iteration(AvahiGLibPoll *p, void *userdata) { +static void wakeup(AvahiPoll *_api, void *userdata) { struct timeval tv; static int i = 0; - printf("Iteration %i\n", i++); + printf("Wakeup #%i\n", i++); - if (i > 100) + if (i > 10) g_main_loop_quit(loop); avahi_elapse_time(&tv, 1000, 0); - api->set_wakeup_time(api, &tv); + api->set_wakeup(api, &tv, wakeup, NULL); } int main(int argc, char *argv[]) { AvahiGLibPoll *s; struct timeval tv; - s = avahi_glib_poll_new(NULL, iteration, NULL); + s = avahi_glib_poll_new(NULL); assert(s); api = avahi_glib_poll_get(s); @@ -77,7 +77,7 @@ int main(int argc, char *argv[]) { api->watch_new(api, 0, AVAHI_WATCH_IN, callback, NULL); avahi_elapse_time(&tv, 1000, 0); - api->set_wakeup_time(api, &tv); + api->set_wakeup(api, &tv, wakeup, NULL); loop = g_main_loop_new(NULL, FALSE); g_main_loop_run(loop); diff --git a/avahi-glib/glib-watch.c b/avahi-glib/glib-watch.c index 7eab84b..4af2390 100644 --- a/avahi-glib/glib-watch.c +++ b/avahi-glib/glib-watch.c @@ -45,13 +45,12 @@ struct AvahiGLibPoll { GMainContext *context; struct timeval wakeup; - gboolean use_wakeup; - int req_cleanup; + AvahiWakeupCallback wakeup_callback; + void *wakeup_userdata; - AvahiGLibProcessCallback process_callback; - void *userdata; + int req_cleanup; - AVAHI_LLIST_HEAD(AvahiWatch, watches); + AVAHI_LLIST_HEAD(AvahiWatch, watches); }; static void destroy_watch(AvahiWatch *w) { @@ -133,17 +132,43 @@ static void watch_free(AvahiWatch *w) { w->glib_poll->req_cleanup = 1; } -static void set_wakeup_time(AvahiPoll *api, const struct timeval *tv) { +static void set_wakeup(AvahiPoll *api, const struct timeval *tv, AvahiWakeupCallback callback, void *userdata) { AvahiGLibPoll *g; assert(api); g = api->userdata; - if (tv) { - g->wakeup = *tv; - g->use_wakeup = 1; + if (callback) { + if (tv) + g->wakeup = *tv; + else { + g->wakeup.tv_sec = 0; + g->wakeup.tv_usec = 0; + } + + g->wakeup_callback = callback; + g->wakeup_userdata = userdata; } else - g->use_wakeup = 0; + g->wakeup_callback = NULL; +} + +static void start_wakeup_callback(AvahiGLibPoll *g) { + AvahiWakeupCallback callback; + void *userdata; + + assert(g); + + /* Reset the wakeup functions, but allow changing of the two + values from the callback function */ + + callback = g->wakeup_callback; + userdata = g->wakeup_userdata; + g->wakeup_callback = NULL; + g->wakeup_userdata = NULL; + + assert(callback); + + callback(&g->api, userdata); } static gboolean prepare_func(GSource *source, gint *timeout) { @@ -152,7 +177,10 @@ static gboolean prepare_func(GSource *source, gint *timeout) { g_assert(g); g_assert(timeout); - if (g->use_wakeup) { + if (g->req_cleanup) + cleanup(g, 0); + + if (g->wakeup_callback) { GTimeVal now; struct timeval tvnow; AvahiUsec usec; @@ -178,6 +206,17 @@ static gboolean check_func(GSource *source) { g_assert(g); + if (g->wakeup_callback) { + GTimeVal now; + struct timeval tvnow; + g_source_get_current_time(source, &now); + tvnow.tv_sec = now.tv_sec; + tvnow.tv_usec = now.tv_usec; + + if (avahi_timeval_compare(&g->wakeup, &tvnow) < 0) + return TRUE; + } + for (w = g->watches; w; w = w->watches_next) if (w->pollfd.revents > 0) return TRUE; @@ -191,26 +230,31 @@ static gboolean dispatch_func(GSource *source, GSourceFunc callback, gpointer us g_assert(g); - if (g->req_cleanup) - cleanup(g, 0); - - if (g->process_callback) - g->process_callback(g, g->userdata); + if (g->wakeup_callback) { + GTimeVal now; + struct timeval tvnow; + g_source_get_current_time(source, &now); + tvnow.tv_sec = now.tv_sec; + tvnow.tv_usec = now.tv_usec; + + if (avahi_timeval_compare(&g->wakeup, &tvnow) < 0) { + start_wakeup_callback(g); + return TRUE; + } + } for (w = g->watches; w; w = w->watches_next) if (w->pollfd.revents > 0) { assert(w->callback); w->callback(w, w->pollfd.fd, w->pollfd.revents, w->userdata); w->pollfd.revents = 0; + return TRUE; } - if (g->req_cleanup) - cleanup(g, 0); - return TRUE; } -AvahiGLibPoll *avahi_glib_poll_new(GMainContext *context, AvahiGLibProcessCallback callback, void *userdata) { +AvahiGLibPoll *avahi_glib_poll_new(GMainContext *context) { AvahiGLibPoll *g; static GSourceFuncs source_funcs = { @@ -229,11 +273,9 @@ AvahiGLibPoll *avahi_glib_poll_new(GMainContext *context, AvahiGLibProcessCallba g->api.watch_new = watch_new; g->api.watch_free = watch_free; g->api.watch_update = watch_update; - g->api.set_wakeup_time = set_wakeup_time; + g->api.set_wakeup = set_wakeup; - g->use_wakeup = 0; - g->process_callback = callback; - g->userdata = userdata; + g->wakeup_callback = NULL; g->req_cleanup = 0; AVAHI_LLIST_HEAD_INIT(AvahiWatch, g->watches); @@ -247,11 +289,14 @@ void avahi_glib_poll_free(AvahiGLibPoll *g) { GSource *s = &g->source; assert(g); +/* g_message("BEFORE"); */ cleanup(g, 1); - + +/* g_message("MIDDLE"); */ g_main_context_unref(g->context); g_source_destroy(s); g_source_unref(s); +/* g_message("AFTER"); */ } AvahiPoll* avahi_glib_poll_get(AvahiGLibPoll *g) { diff --git a/avahi-glib/glib-watch.h b/avahi-glib/glib-watch.h index 9df58b5..9e6bd68 100644 --- a/avahi-glib/glib-watch.h +++ b/avahi-glib/glib-watch.h @@ -22,20 +22,17 @@ USA. ***/ -#include <avahi-common/cdecl.h> - #include <glib.h> + +#include <avahi-common/cdecl.h> #include <avahi-common/watch.h> AVAHI_C_DECL_BEGIN typedef struct AvahiGLibPoll AvahiGLibPoll; -typedef void (*AvahiGLibProcessCallback)(AvahiGLibPoll *g, void *userdata); - -AvahiGLibPoll *avahi_glib_poll_new(GMainContext *context, AvahiGLibProcessCallback callback, void *userdata); +AvahiGLibPoll *avahi_glib_poll_new(GMainContext *context); void avahi_glib_poll_free(AvahiGLibPoll *g); - AvahiPoll* avahi_glib_poll_get(AvahiGLibPoll *g); AVAHI_C_DECL_END diff --git a/docs/MALLOC b/docs/MALLOC new file mode 100644 index 0000000..5c7db9e --- /dev/null +++ b/docs/MALLOC @@ -0,0 +1,10 @@ +Avahi supports pluggable memory allocator implemenations. See +<avahi-common/malloc.h> for more information. + +Currently, Avahi does not deal well with out-of-memory +situations. Therefore we recommend the usage of memory allocators that +abort() in case of OOM. The default allocator used by Avahi does this. + +Eventually we will improve Avahi to deal with these things better. + +$Id$ diff --git a/doxygen.cfg b/doxygen.cfg index 0e2c6be..27a40d1 100644 --- a/doxygen.cfg +++ b/doxygen.cfg @@ -67,7 +67,7 @@ WARN_LOGFILE = #--------------------------------------------------------------------------- # configuration options related to the input files #--------------------------------------------------------------------------- -INPUT = $(SRCDIR)/avahi-common/cdecl.h $(SRCDIR)/avahi-core/core.h $(SRCDIR)/avahi-common/address.h $(SRCDIR)/avahi-core/rr.h $(SRCDIR)/avahi-common/strlst.h $(SRCDIR)/avahi-common/alternative.h $(SRCDIR)/avahi-core/log.h $(SRCDIR)/avahi-common/defs.h $(SRCDIR)/avahi-client/client.h $(SRCDIR)/avahi-common/error.h $(SRCDIR)/avahi-common/malloc.h $(SRCDIR)/avahi-common/domain.h +INPUT = $(SRCDIR)/avahi-common/cdecl.h $(SRCDIR)/avahi-core/core.h $(SRCDIR)/avahi-common/address.h $(SRCDIR)/avahi-core/rr.h $(SRCDIR)/avahi-common/strlst.h $(SRCDIR)/avahi-common/alternative.h $(SRCDIR)/avahi-core/log.h $(SRCDIR)/avahi-common/defs.h $(SRCDIR)/avahi-client/client.h $(SRCDIR)/avahi-common/error.h $(SRCDIR)/avahi-common/malloc.h $(SRCDIR)/avahi-common/domain.h $(SRCDIR)/avahi-common/gccmacro.h $(SRCDIR)/avahi-common/watch.h $(SRCDIR)/avahi-common/simple-watch.h $(SRCDIR)/avahi-glib/glib-watch.h $(SRCDIR)/avahi-glib/glib-malloc.h FILE_PATTERNS = RECURSIVE = NO EXCLUDE = diff --git a/examples/browse-services.c b/examples/browse-services.c index f2707fd..472b053 100644 --- a/examples/browse-services.c +++ b/examples/browse-services.c @@ -23,46 +23,74 @@ #include <config.h> #endif -#include <avahi-core/core.h> - -static GMainLoop *main_loop = NULL; +#include <stdio.h> +#include <assert.h> +#include <stdlib.h> +#include <time.h> -static void resolve_callback(AvahiServiceResolver *r, AvahiIfIndex interface, AvahiProtocol protocol, AvahiResolverEvent event, const gchar *name,const gchar *type,const gchar *domain, const gchar *host_name, const AvahiAddress *address, guint16 port, AvahiStringList *txt, gpointer userdata) { - g_assert(r); +#include <avahi-core/core.h> +#include <avahi-common/simple-watch.h> +#include <avahi-common/malloc.h> + +static AvahiSimplePoll *simple_poll = NULL; + +static void resolve_callback( + AvahiServiceResolver *r, + AvahiIfIndex interface, + AvahiProtocol protocol, + AvahiResolverEvent event, + const char *name, + const char *type, + const char *domain, + const char *host_name, + const AvahiAddress *address, + uint16_t port, + AvahiStringList *txt, + void* userdata) { + + assert(r); /* Called whenever a service has been resolved successfully or timed out */ if (event == AVAHI_RESOLVER_TIMEOUT) - g_message("Failed to resolve service '%s' of type '%s' in domain '%s'.", name, type, domain); + fprintf(stderr, "Failed to resolve service '%s' of type '%s' in domain '%s'.\n", name, type, domain); else { - gchar a[128], *t; + char a[128], *t; - g_assert(event == AVAHI_RESOLVER_FOUND); + assert(event == AVAHI_RESOLVER_FOUND); - g_message("Service '%s' of type '%s' in domain '%s':", name, type, domain); + fprintf(stderr, "Service '%s' of type '%s' in domain '%s':\n", name, type, domain); avahi_address_snprint(a, sizeof(a), address); t = avahi_string_list_to_string(txt); - g_message("\t%s:%u (%s) TXT=%s", host_name, port, a, t); - g_free(t); + fprintf(stderr, "\t%s:%u (%s) TXT=%s\n", host_name, port, a, t); + avahi_free(t); } avahi_service_resolver_free(r); } -static void browse_callback(AvahiServiceBrowser *b, AvahiIfIndex interface, AvahiProtocol protocol, AvahiBrowserEvent event, const gchar *name, const gchar *type, const gchar *domain, gpointer userdata) { - g_assert(b); +static void browse_callback( + AvahiServiceBrowser *b, + AvahiIfIndex interface, + AvahiProtocol protocol, + AvahiBrowserEvent event, + const char *name, + const char *type, + const char *domain, + void* userdata) { AvahiServer *s = userdata; + assert(b); /* Called whenever a new services becomes available on the LAN or is removed from the LAN */ - g_message("%s: service '%s' of type '%s' in domain '%s'", - event == AVAHI_BROWSER_NEW ? "NEW" : "REMOVED", - name, - type, - domain); - + fprintf(stderr, "%s: service '%s' of type '%s' in domain '%s'\n", + event == AVAHI_BROWSER_NEW ? "NEW" : "REMOVED", + name, + type, + domain); + /* If it's new, let's resolve it */ if (event == AVAHI_BROWSER_NEW) @@ -71,45 +99,55 @@ static void browse_callback(AvahiServiceBrowser *b, AvahiIfIndex interface, Avah function is called the server will free the resolver for us. */ if (!(avahi_service_resolver_new(s, interface, protocol, name, type, domain, AVAHI_PROTO_UNSPEC, resolve_callback, s))) - g_message("Failed to resolve service '%s': %s", name, avahi_strerror(avahi_server_errno(s))); + fprintf(stderr, "Failed to resolve service '%s': %s\n", name, avahi_strerror(avahi_server_errno(s))); } int main(int argc, char*argv[]) { AvahiServerConfig config; AvahiServer *server = NULL; AvahiServiceBrowser *sb; - gint error; + int error; int ret = 1; + /* Initialize the psuedo-RNG */ + srand(time(NULL)); + + /* Allocate main loop object */ + if (!(simple_poll = avahi_simple_poll_new())) { + fprintf(stderr, "Failed to create simple poll object.\n"); + goto fail; + } + /* Do not publish any local records */ avahi_server_config_init(&config); - config.publish_hinfo = FALSE; - config.publish_addresses = FALSE; - config.publish_workstation = FALSE; - config.publish_domain = FALSE; + config.publish_hinfo = 0; + config.publish_addresses = 0; + config.publish_workstation = 0; + config.publish_domain = 0; /* Allocate a new server */ - server = avahi_server_new(NULL, &config, NULL, NULL, &error); + server = avahi_server_new(avahi_simple_poll_get(simple_poll), &config, NULL, NULL, &error); /* Free the configuration data */ avahi_server_config_free(&config); /* Check wether creating the server object succeeded */ if (!server) { - g_message("Failed to create server: %s", avahi_strerror(error)); + fprintf(stderr, "Failed to create server: %s\n", avahi_strerror(error)); goto fail; } /* Create the service browser */ if (!(sb = avahi_service_browser_new(server, AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC, "_http._tcp", NULL, browse_callback, server))) { - g_message("Failed to create service browser: %s", avahi_strerror(avahi_server_errno(server))); + fprintf(stderr, "Failed to create service browser: %s\n", avahi_strerror(avahi_server_errno(server))); goto fail; } /* Run the main loop */ - main_loop = g_main_loop_new(NULL, FALSE); - g_main_loop_run(main_loop); - + for (;;) + if (avahi_simple_poll_iterate(simple_poll, -1) != 0) + break; + ret = 0; fail: @@ -121,8 +159,8 @@ fail: if (server) avahi_server_free(server); - if (main_loop) - g_main_loop_unref(main_loop); + if (simple_poll) + avahi_simple_poll_free(simple_poll); return ret; } diff --git a/examples/publish-service.c b/examples/publish-service.c index 37ecc02..4a78402 100644 --- a/examples/publish-service.c +++ b/examples/publish-service.c @@ -26,34 +26,37 @@ #include <time.h> #include <stdio.h> #include <stdlib.h> +#include <assert.h> #include <avahi-core/core.h> +#include <avahi-common/simple-watch.h> +#include <avahi-common/malloc.h> static AvahiEntryGroup *group = NULL; -static GMainLoop *main_loop = NULL; -static gchar *name = NULL; +static AvahiSimplePoll *simple_poll = NULL; +static char *name = NULL; static void create_services(AvahiServer *s); -static void entry_group_callback(AvahiServer *s, AvahiEntryGroup *g, AvahiEntryGroupState state, gpointer userdata) { - g_assert(s); - g_assert(g == group); +static void entry_group_callback(AvahiServer *s, AvahiEntryGroup *g, AvahiEntryGroupState state, void *userdata) { + assert(s); + assert(g == group); /* Called whenever the entry group state changes */ if (state == AVAHI_ENTRY_GROUP_ESTABLISHED) /* The entry group has been established successfully */ - g_message("Service '%s' successfully established.", name); + fprintf(stderr, "Service '%s' successfully established.\n", name); else if (state == AVAHI_ENTRY_GROUP_COLLISION) { - gchar *n; + char *n; /* A service name collision happened. Let's pick a new name */ n = avahi_alternative_service_name(name); - g_free(name); + avahi_free(name); name = n; - g_message("Service name collision, renaming service to '%s'", name); + fprintf(stderr, "Service name collision, renaming service to '%s'\n", name); /* And recreate the services */ create_services(s); @@ -61,50 +64,50 @@ static void entry_group_callback(AvahiServer *s, AvahiEntryGroup *g, AvahiEntryG } static void create_services(AvahiServer *s) { - gchar r[128]; - gint ret; - g_assert(s); + char r[128]; + int ret; + assert(s); /* If this is the first time we're called, let's create a new entry group */ if (!group) { if (!(group = avahi_entry_group_new(s, entry_group_callback, NULL))) { - g_message("avahi_entry_group_new() failed: %s", avahi_strerror(avahi_server_errno(s))); + fprintf(stderr, "avahi_entry_group_new() failed: %s\n", avahi_strerror(avahi_server_errno(s))); goto fail; } } - g_message("Adding service '%s'", name); + fprintf(stderr, "Adding service '%s'\n", name); /* Create some random TXT data */ snprintf(r, sizeof(r), "random=%i", rand()); /* Add the service for IPP */ if ((ret = avahi_server_add_service(s, group, AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC, name, "_ipp._tcp", NULL, NULL, 651, "test=blah", r, NULL)) < 0) { - g_message("Failed to add _ipp._tcp service: %s", avahi_strerror(ret)); + fprintf(stderr, "Failed to add _ipp._tcp service: %s\n", avahi_strerror(ret)); goto fail; } /* Add the same service for BSD LPR */ if ((ret = avahi_server_add_service(s, group, AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC, name, "_printer._tcp", NULL, NULL, 515, NULL)) < 0) { - g_message("Failed to add _printer._tcp service: %s", avahi_strerror(ret)); + fprintf(stderr, "Failed to add _printer._tcp service: %s\n", avahi_strerror(ret)); goto fail; } /* Tell the server to register the service */ if ((ret = avahi_entry_group_commit(group)) < 0) { - g_message("Failed to commit entry_group: %s", avahi_strerror(ret)); + fprintf(stderr, "Failed to commit entry_group: %s\n", avahi_strerror(ret)); goto fail; } return; fail: - g_main_loop_quit(main_loop); + avahi_simple_poll_quit(simple_poll); return; } -static void server_callback(AvahiServer *s, AvahiServerState state, gpointer userdata) { - g_assert(s); +static void server_callback(AvahiServer *s, AvahiServerState state, void * userdata) { + assert(s); /* Called whenever the server state changes */ @@ -114,19 +117,19 @@ static void server_callback(AvahiServer *s, AvahiServerState state, gpointer use create_services(s); else if (state == AVAHI_SERVER_COLLISION) { - gchar *n; - gint r; + char *n; + int r; /* A host name collision happened. Let's pick a new name for the server */ n = avahi_alternative_host_name(avahi_server_get_host_name(s)); - g_message("Host name collision, retrying with '%s'", n); + fprintf(stderr, "Host name collision, retrying with '%s'\n", n); r = avahi_server_set_host_name(s, n); - g_free(n); + avahi_free(n); if (r < 0) { - g_message("Failed to set new host name: %s", avahi_strerror(r)); + fprintf(stderr, "Failed to set new host name: %s\n", avahi_strerror(r)); - g_main_loop_quit(main_loop); + avahi_simple_poll_quit(simple_poll); return; } @@ -141,34 +144,42 @@ static void server_callback(AvahiServer *s, AvahiServerState state, gpointer use int main(int argc, char*argv[]) { AvahiServerConfig config; AvahiServer *server = NULL; - gint error; + int error; int ret = 1; + /* Initialize the pseudo-RNG */ srand(time(NULL)); + + /* Allocate main loop object */ + if (!(simple_poll = avahi_simple_poll_new())) { + fprintf(stderr, "Failed to create simple poll object.\n"); + goto fail; + } - name = g_strdup("MegaPrinter"); + name = avahi_strdup("MegaPrinter"); /* Let's set the host name for this server. */ avahi_server_config_init(&config); - config.host_name = g_strdup("gurkiman"); - config.publish_workstation = FALSE; + config.host_name = avahi_strdup("gurkiman"); + config.publish_workstation = 0; /* Allocate a new server */ - server = avahi_server_new(NULL, &config, server_callback, NULL, &error); + server = avahi_server_new(avahi_simple_poll_get(simple_poll), &config, server_callback, NULL, &error); /* Free the configuration data */ avahi_server_config_free(&config); /* Check wether creating the server object succeeded */ if (!server) { - g_message("Failed to create server: %s", avahi_strerror(error)); + fprintf(stderr, "Failed to create server: %s", avahi_strerror(error)); goto fail; } /* Run the main loop */ - main_loop = g_main_loop_new(NULL, FALSE); - g_main_loop_run(main_loop); - + for (;;) + if (avahi_simple_poll_iterate(simple_poll, -1) != 0) + break; + ret = 0; fail: @@ -180,10 +191,10 @@ fail: if (server) avahi_server_free(server); - if (main_loop) - g_main_loop_unref(main_loop); + if (simple_poll) + avahi_simple_poll_free(simple_poll); - g_free(name); + avahi_free(name); return ret; } |