SUBDIRS = \
common \
avahi-common \
+ avahi-glib \
avahi-core \
avahi-discover-standalone \
avahi-client \
initscript \
avahi-dnsconfd \
avahi-utils \
- avahi-glib \
examples \
man
malloc.h
watch.h \
timeval.h \
- simple-watch.h
+ simple-watch.h \
+ gccmacro.h
noinst_HEADERS = llist.h
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;
}
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);
+ }
+}
/** 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
"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)
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 */
--- /dev/null
+#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
#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);
return NULL;
if (!allocator)
- return calloc(1, size);
+ return xcalloc(1, size);
if (allocator->calloc)
return allocator->calloc(1, size);
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);
#include <stdarg.h>
#include <avahi-common/cdecl.h>
+#include <avahi-common/gccmacro.h>
AVAHI_C_DECL_BEGIN
* 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);
int n_pollfds, max_pollfds, rebuild_pollfds;
struct timeval wakeup;
- int use_wakeup;
+ AvahiWakeupCallback wakeup_callback;
+ void *wakeup_userdata;
int req_cleanup;
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) {
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;
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)
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) {
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);
#include <stdarg.h>
#include <avahi-common/cdecl.h>
+#include <avahi-common/gccmacro.h>
AVAHI_C_DECL_BEGIN
/** 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);
/** 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. */
#include "timeval.h"
static AvahiPoll *api = NULL;
+static AvahiSimplePoll *simple_poll = NULL;
static void callback(AvahiWatch *w, int fd, AvahiWatchEvent event, void *userdata) {
}
}
+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;
}
} AvahiWatchEvent;
typedef void (*AvahiWatchCallback)(AvahiWatch *w, int fd, AvahiWatchEvent event, void *userdata);
+typedef void (*AvahiWakeupCallback)(AvahiPoll *api, void *userdata);
struct AvahiPoll {
void* userdata;
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
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")'
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
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)
#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 */
}
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--;
}
} 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);
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;
}
static void elapse_announce(AvahiTimeEvent *e, void *userdata) {
- g_assert(e);
+ assert(e);
next_state(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)
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))
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;
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;
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);
}
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 ||
(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); */
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;
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;
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); */
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); */
}
-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"); */
USA.
***/
-#include <glib.h>
-
typedef struct AvahiAnnouncement AvahiAnnouncement;
#include <avahi-common/llist.h>
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);
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);
#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);
}
#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);
}
}
avahi_entry_group_reset(group);
}
-static void create_entries(gboolean new_name) {
+static void create_entries(int new_name) {
AvahiAddress a;
remove_entries();
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;
}
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);
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");
}
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);
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);
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;
}
#include <string.h>
#include <avahi-common/domain.h>
+#include <avahi-common/malloc.h>
+
#include "browse.h"
#include "log.h"
#include "rr.h"
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);
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 &&
}
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)
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;
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;
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;
}
}
-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;
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);
}
void avahi_dns_server_browser_free(AvahiDNSServerBrowser *b) {
- g_assert(b);
+ assert(b);
while (b->info)
server_info_free(b, b->info);
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);
}
#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;
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);
}
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);
}
#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);
if (*c == 0)
goto fail;
- g_assert(*c == '.');
+ assert(*c == '.');
e = c;
c++;
}
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;
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);
}
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);
}
#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 == '_';) {
if (*c == 0)
goto fail;
- g_assert(*c == '.');
+ assert(*c == '.');
e = c;
c++;
}
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);
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);
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);
}
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);
}
#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);
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 {
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;
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);
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;
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;
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);
}
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);
#endif
#include <string.h>
+#include <stdlib.h>
#include <avahi-common/timeval.h>
+#include <avahi-common/malloc.h>
+
#include "cache.h"
#include "log.h"
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;
}
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;
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;
}
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); */
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:
;
}
- 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);
}
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);
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); */
/* 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);
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);
}
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); */
}
void avahi_cache_flush(AvahiCache *c) {
- g_assert(c);
+ assert(c);
while (c->entries)
remove_entry(c, c->entries);
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,
AvahiRecord *record;
struct timeval timestamp;
struct timeval expiry;
- gboolean cache_flush;
+ int cache_flush;
AvahiAddress origin;
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);
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);
#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)
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) {
}
}
-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) {
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);
if (group)
avahi_entry_group_free(group);
avahi_server_free(avahi);
+
+ avahi_glib_poll_free(glib_poll);
return 0;
}
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
#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
} 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);
* 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 */ );
* 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
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);
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 */
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
* 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
* 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 */
/** 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;
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(
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);
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);
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(
AvahiProtocol protocol,
const AvahiAddress *address,
AvahiAddressResolverCallback calback,
- gpointer userdata);
+ void* userdata);
/** Free an AvahiAddressResolver object */
void avahi_address_resolver_free(AvahiAddressResolver *r);
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);
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);
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);
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);
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
#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);
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;
#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;
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;
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);
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;
}
}
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)))
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;
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;
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;
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;
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;
if (idx + n > p->size)
return -1;
- if ((guint) n + 1 > l)
+ if ((size_t) n + 1 > l)
return -1;
if (!first_label) {
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;
}
}
-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;
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;
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;
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;
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;
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()"); */
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:
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;
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:
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:
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;
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;
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 ||
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;
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;
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);
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;
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;
}
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
#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
return 0;
}
-
void avahi_hashmap_remove(AvahiHashmap *m, const void *key) {
Entry *e;
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;
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;
}
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
#include <net/if.h>
#include <stdio.h>
+#include <avahi-common/malloc.h>
+
#include "iface.h"
#include "netlink.h"
#include "dns.h"
#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 &&
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;
}
}
-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);
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.");
} else
avahi_entry_group_commit(hw->entry_group);
- g_free(name);
+ avahi_free(name);
}
} else {
}
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);
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);
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)
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;
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);
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);
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) {
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);
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;
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);
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;
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) {
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) {
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;
return;
memcpy(raddr.data.data, RTA_DATA(a), RTA_PAYLOAD(a));
- raddr_valid = TRUE;
+ raddr_valid = 1;
break;
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;
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);
}
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);
}
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);
}
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;
}
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); */
}
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;
}
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) {
}
}
-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;
}
}
- return FALSE;
+ return 0;
}
USA.
***/
-#include <glib.h>
-
typedef struct AvahiInterfaceMonitor AvahiInterfaceMonitor;
typedef struct AvahiInterfaceAddress AvahiInterfaceAddress;
typedef struct AvahiInterface AvahiInterface;
#include <avahi-common/llist.h>
#include <avahi-common/address.h>
+
#include "server.h"
#include "netlink.h"
#include "cache.h"
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,
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;
AvahiHwInterface *hardware;
AvahiProtocol protocol;
- gboolean announcing;
+ int announcing;
AvahiCache *cache;
AvahiQueryScheduler *query_scheduler;
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;
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
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);
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);
***/
#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 */
} 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
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
#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;
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;
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);
}
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;
}
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;
}
#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
#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);
}
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();
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);
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);
/* 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; */
/* } */
#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;
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;
/* 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)
if (!(min = n->left)) {
/* No children */
- g_assert(!n->right);
+ assert(!n->right);
break;
}
}
}
-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++;
}
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)
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;
}
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;
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--;
}
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);
#include <avahi-common/domain.h>
#include <avahi-common/timeval.h>
+#include <avahi-common/malloc.h>
#include "probe-sched.h"
#include "log.h"
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;
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);
}
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);
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);
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;
}
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);
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 =
/* 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) {
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) {
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);
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) {
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;
}
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;
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 */
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);
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;
}
}
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
#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
AvahiQueryScheduler *scheduler;
AvahiTimeEvent *time_event;
- gboolean done;
+ int done;
struct timeval delivery;
AvahiKey *key;
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;
}
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);
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);
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;
}
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);
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);
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
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;
}
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++;
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) {
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 */
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;
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 */
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);
/* 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
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);
}
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
#endif
#include <avahi-common/timeval.h>
+#include <avahi-common/malloc.h>
+
#include "browse.h"
struct AvahiAddressResolver {
AvahiRecordBrowser *record_browser;
AvahiAddressResolverCallback callback;
- gpointer userdata;
+ void* userdata;
AvahiTimeEvent *time_event;
};
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);
}
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);
}
void avahi_address_resolver_free(AvahiAddressResolver *r) {
- g_assert(r);
+ assert(r);
AVAHI_LLIST_REMOVE(AvahiAddressResolver, resolver, r->server->address_resolvers, 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);
}
#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;
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);
}
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;
}
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;
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);
goto fail;
}
- g_assert(r->record_browser_aaaa || r->record_browser_a);
+ assert(r->record_browser_aaaa || r->record_browser_a);
return r;
}
void avahi_host_name_resolver_free(AvahiHostNameResolver *r) {
- g_assert(r);
+ assert(r);
AVAHI_LLIST_REMOVE(AvahiHostNameResolver, resolver, r->server->host_name_resolvers, 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);
}
#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;
AvahiRecord *srv_record, *txt_record, *address_record;
AvahiServiceResolverCallback callback;
- gpointer userdata;
+ void* userdata;
AvahiTimeEvent *time_event;
};
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);
}
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, 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:
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;
}
}
-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;
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);
break;
default:
- g_assert(FALSE);
+ assert(0);
}
if (r->txt_record && r->srv_record && r->address_record)
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);
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;
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);
}
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);
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);
}
#endif
#include <avahi-common/timeval.h>
+#include <avahi-common/malloc.h>
+
#include "response-sched.h"
#include "log.h"
struct timeval delivery;
AvahiRecord *record;
- gboolean flush_cache;
+ int flush_cache;
AvahiAddress querier;
- gboolean querier_valid;
+ int querier_valid;
AVAHI_LLIST_FIELDS(AvahiResponseJob, jobs);
};
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);
}
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);
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);
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;
}
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);
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. */
}
} else {
- guint size;
+ size_t size;
avahi_dns_packet_free(p);
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);
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 */
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;
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 */
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) {
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 &&
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 */
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 ... */
/* 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
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);
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))) {
} 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;
}
}
void avahi_response_scheduler_force(AvahiResponseScheduler *s) {
- g_assert(s);
+ assert(s);
/* Send all scheduled responses immediately */
while (s->jobs)
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
#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;
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); */
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);
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
k->clazz == AVAHI_DNS_CLASS_ANY;
}
-guint avahi_key_hash(const AvahiKey *k) {
+unsigned avahi_key_hash(const AvahiKey *k) {
assert(k);
return
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);
}
-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) &&
}
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;
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;
}
fail:
- avahi_log_error("Out of memory");
+ avahi_log_error(__FILE__": Out of memory");
return -1; /* or whatever ... */
}
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) {
* 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 */
* 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 */
AVAHI_LLIST_REMOVE(AvahiRecordListItem, items, l->unread, i);
AVAHI_LLIST_PREPEND(AvahiRecordListItem, items, l->read, i);
- i->read = TRUE;
+ i->read = 1;
return r;
}
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);
}
#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
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) {
}
}
-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;
}
}
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;
}
}
}
/* 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))
/* 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 */
} 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;
}
}
}
/* 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);
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);
* 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);
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))) {
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)) {
}
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 */
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);
}
-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;
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. */
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)");
/* 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)");
/* 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)");
}
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)");
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);
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;
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;
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;
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;
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);
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;
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)) {
/* 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.");
return;
}
- legacy_unicast = TRUE;
+ legacy_unicast = 1;
}
if (legacy_unicast)
}
}
-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)) {
/* 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;
}
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;
}
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);
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)
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);
}
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);
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;
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);
/* 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);
}
void avahi_server_free(AvahiServer* s) {
- g_assert(s);
+ assert(s);
while(s->entries)
free_entry(s, s->entries);
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);
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;
return 0;
}
-gint avahi_server_add(
+int avahi_server_add(
AvahiServer *s,
AvahiEntryGroup *g,
AvahiIfIndex interface,
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);
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)
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;
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);
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);
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);
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);
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 == '\\') {
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);
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);
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);
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];
*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);
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);
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;
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;
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);
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);
/* 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);
}
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 ||
}
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;
}
***/
#include <avahi-common/llist.h>
+#include <avahi-common/watch.h>
+
#include "core.h"
#include "iface.h"
#include "prioq.h"
#include "browse.h"
#include "dns.h"
#include "rrlist.h"
+#include "hashmap.h"
#define AVAHI_MAX_LEGACY_UNICAST_REFLECT_SLOTS 100
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;
};
AvahiServer *server;
AvahiEntryGroup *group;
- gboolean dead;
+ int dead;
AvahiEntryFlags flags;
AvahiRecord *record;
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;
};
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);
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
#include <sys/time.h>
#include <net/if.h>
#include <sys/ioctl.h>
+#include <assert.h>
#include "dns.h"
#include "fdutil.h"
#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;
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;
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;
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;
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;
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;
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) {
return 0;
}
-gint avahi_open_socket_ipv4(void) {
+int avahi_open_socket_ipv4(void) {
struct sockaddr_in local;
int fd = -1, ttl, yes;
return -1;
}
-gint avahi_open_socket_ipv6(void) {
+int avahi_open_socket_ipv6(void) {
struct sockaddr_in6 sa, local;
int fd = -1, ttl, yes;
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 (;;) {
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;
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);
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;
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);
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));
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;
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;
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));
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;
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;
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;
***/
#include <netinet/in.h>
+#include <inttypes.h>
#include "dns.h"
#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
#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;
}
#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;
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;
}
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);
#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) {
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;
return r;
}
-
-
char *avahi_strdown(char *s) {
char *c;
return s;
}
-
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
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;
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;
}
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)) {
#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>
#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"
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);
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) {
}
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;
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;
}
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);
}
+#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;
}
-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 {
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);
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];
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
#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;
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);
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);
gtk_main();
avahi_server_free(server);
+ avahi_glib_poll_free(poll_api);
return 0;
}
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;
avahiinclude_HEADERS = \
glib-watch.h
+ glib-malloc.h
lib_LTLIBRARIES = \
libavahi-glib.la
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)
--- /dev/null
+/* $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;
+}
--- /dev/null
+#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
}
}
-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);
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);
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) {
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) {
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;
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;
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 = {
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);
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) {
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
--- /dev/null
+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$
#---------------------------------------------------------------------------
# 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 =
#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)
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:
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;
}
#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);
}
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 */
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;
}
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:
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;
}
projects / catta / commitdiff