initscript \
avahi-dnsconfd \
avahi-utils \
+ avahi-glib \
examples \
man
scp avahi-daemon/*.introspect avahi-daemon/introspect.dtd avahi-daemon/introspect.xsl\
man/*.xml man/xmltoman.dtd man/xmltoman.xsl \
fdo:public_html/
-
AM_CFLAGS=-I$(top_srcdir)
-# GLIB 2.0
-AM_CFLAGS+=$(GLIB20_CFLAGS)
-AM_LDADD=$(GLIB20_LIBS)
-
# This cool debug trap works on i386/gcc only
AM_CFLAGS+='-DDEBUG_TRAP=__asm__("int $$3")'
cdecl.h \
defs.h \
malloc.h
+ watch.h \
+ timeval.h \
+ simple-watch.h
noinst_HEADERS = llist.h
noinst_HEADERS += dbus.h
endif
-
noinst_PROGRAMS = \
strlst-test \
domain-test \
- alternative-test
+ alternative-test \
+ timeval-test \
+ watch-test
lib_LTLIBRARIES = \
libavahi-common.la
alternative.c alternative.h \
error.c error.h \
strlst.c strlst.h \
- domain.c domain.h
+ domain.c domain.h \
+ timeval.c timeval.h \
+ simple-watch.c simple-watch.h \
+ watch.h
libavahi_common_la_CFLAGS = $(AM_CFLAGS)
libavahi_common_la_LIBADD = $(AM_LDADD)
domain_test_CFLAGS = $(AM_CFLAGS)
domain_test_LDADD = $(AM_LDADD)
+watch_test_SOURCES = \
+ timeval.c timeval.h \
+ simple-watch.c simple-watch.h \
+ watch.h \
+ malloc.c malloc.h \
+ watch-test.c
+watch_test_CFLAGS = $(AM_CFLAGS)
+watch_test_LDADD = $(AM_LDADD)
+
+timeval_test_SOURCES = \
+ timeval.c timeval.h \
+ timeval-test.c
+timeval_test_CFLAGS = $(AM_CFLAGS)
+timeval_test_LDADD = $(AM_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 <sys/poll.h>
+#include <assert.h>
+#include <string.h>
+#include <errno.h>
+
+#include <avahi-common/llist.h>
+#include <avahi-common/malloc.h>
+
+#include "simple-watch.h"
+
+struct AvahiWatch {
+ AvahiSimplePoll *simple_poll;
+ int dead;
+ int idx;
+ struct pollfd pollfd;
+ AvahiWatchCallback callback;
+ void *userdata;
+
+ AVAHI_LLIST_FIELDS(AvahiWatch, watches);
+};
+
+struct AvahiSimplePoll {
+ AvahiPoll api;
+
+ struct pollfd* pollfds;
+ int n_pollfds, max_pollfds, rebuild_pollfds;
+
+ struct timeval wakeup;
+ int use_wakeup;
+
+ int req_cleanup;
+
+ int quit;
+
+ int n_watches;
+ AVAHI_LLIST_HEAD(AvahiWatch, watches);
+};
+
+static AvahiWatch* watch_new(AvahiPoll *api, int fd, AvahiWatchEvent event, AvahiWatchCallback callback, void *userdata) {
+ AvahiWatch *w;
+ AvahiSimplePoll *s;
+
+ assert(api);
+ assert(fd >= 0);
+ assert(callback);
+
+ s = api->userdata;
+ assert(s);
+
+ if (!(w = avahi_new(AvahiWatch, 1)))
+ return NULL;
+
+ w->simple_poll = s;
+ w->pollfd.fd = fd;
+ w->pollfd.events = event;
+ w->callback = callback;
+ w->userdata = userdata;
+ w->dead = 0;
+
+ if (s->n_pollfds < s->max_pollfds) {
+ /* If there's space for this pollfd, go on and allocate it */
+ w->idx = s->n_pollfds++;
+ s->pollfds[w->idx] = w->pollfd;
+
+ } else {
+ /* Unfortunately there's no place for this pollfd, so request a rebuild of the array */
+ w->idx = -1;
+ s->rebuild_pollfds = 1;
+ }
+
+ AVAHI_LLIST_PREPEND(AvahiWatch, watches, s->watches, w);
+ s->n_watches++;
+
+ return w;
+}
+
+static void watch_update(AvahiWatch *w, AvahiWatchEvent events) {
+ assert(w);
+ assert(!w->dead);
+
+ w->pollfd.events = events;
+
+ if (w->idx != -1) {
+ assert(w->simple_poll);
+ w->simple_poll->pollfds[w->idx] = w->pollfd;
+ } else
+ w->simple_poll->rebuild_pollfds = 1;
+}
+
+static void remove_pollfd(AvahiWatch *w) {
+ assert(w);
+
+ if (w->idx == -1)
+ return;
+
+ if (w->idx == w->simple_poll->n_pollfds-1) {
+
+ /* This pollfd is at the end of the array, so we can easily cut it */
+
+ assert(w->simple_poll->n_pollfds > 0);
+ w->simple_poll->n_pollfds -= 1;
+ } else
+
+ /* Unfortunately this pollfd is in the middle of the array, so request a rebuild of it */
+ w->simple_poll->rebuild_pollfds = 1;
+}
+
+static void watch_free(AvahiWatch *w) {
+ assert(w);
+ assert(!w->dead);
+
+ remove_pollfd(w);
+
+ w->dead = 1;
+ w->simple_poll->n_watches --;
+ w->simple_poll->req_cleanup = 1;
+}
+
+static void set_wakeup_time(AvahiPoll *api, const struct timeval *tv) {
+ AvahiSimplePoll *s;
+
+ assert(api);
+ s = api->userdata;
+
+ if (tv) {
+ s->wakeup = *tv;
+ s->use_wakeup = 1;
+ } else
+ s->use_wakeup = 0;
+}
+
+static void destroy_watch(AvahiWatch *w) {
+ assert(w);
+
+ remove_pollfd(w);
+ AVAHI_LLIST_REMOVE(AvahiWatch, watches, w->simple_poll->watches, w);
+
+ if (!w->dead)
+ w->simple_poll->n_watches --;
+
+ avahi_free(w);
+}
+
+static void cleanup(AvahiSimplePoll *s, int all) {
+ AvahiWatch *w, *next;
+ assert(s);
+
+ for (w = s->watches; w; w = next) {
+ next = w->watches_next;
+
+ if (all || w->dead)
+ destroy_watch(w);
+ }
+
+ s->req_cleanup = 0;
+}
+
+AvahiSimplePoll *avahi_simple_poll_new(void) {
+ AvahiSimplePoll *s;
+
+ if (!(s = avahi_new(AvahiSimplePoll, 1)))
+ return NULL;
+
+ s->api.userdata = s;
+ 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->pollfds = NULL;
+ s->max_pollfds = s->n_pollfds = 0;
+ s->use_wakeup = 0;
+ s->rebuild_pollfds = 0;
+ s->quit = 0;
+ s->n_watches = 0;
+ s->req_cleanup = 0;
+
+ AVAHI_LLIST_HEAD_INIT(AvahiWatch, s->watches);
+
+ return s;
+}
+
+void avahi_simple_poll_free(AvahiSimplePoll *s) {
+ assert(s);
+
+ cleanup(s, 1);
+
+ assert(s->n_watches == 0);
+
+ avahi_free(s->pollfds);
+ avahi_free(s);
+}
+
+static int rebuild(AvahiSimplePoll *s) {
+ AvahiWatch *w;
+ int idx;
+
+ assert(s);
+
+ if (s->n_watches > s->max_pollfds) {
+ struct pollfd *n;
+
+ s->max_pollfds = s->n_watches + 10;
+
+ if (!(n = avahi_realloc(s->pollfds, sizeof(struct pollfd) * s->max_pollfds)))
+ return -1;
+
+ s->pollfds = n;
+ }
+
+ for (idx = 0, w = s->watches; w; w = w->watches_next) {
+
+ if(w->dead)
+ continue;
+
+ assert(w->idx < s->max_pollfds);
+ s->pollfds[w->idx = idx++] = w->pollfd;
+ }
+
+ s->n_pollfds = idx;
+
+ s->rebuild_pollfds = 0;
+
+ return 0;
+}
+
+int avahi_simple_poll_iterate(AvahiSimplePoll *s, int block) {
+ int timeout, r, ret = 0;
+ assert(s);
+
+ if (s->quit)
+ return 1;
+
+ if (s->req_cleanup)
+ cleanup(s, 0);
+
+ if (s->rebuild_pollfds)
+ if (rebuild(s) < 0)
+ return -1;
+
+ if (block) {
+ if (s->use_wakeup) {
+ struct timeval now;
+ AvahiUsec usec;
+
+ gettimeofday(&now, NULL);
+
+ usec = avahi_timeval_diff(&s->wakeup, &now);
+
+ timeout = usec <= 0 ? 0 : (int) (usec / 1000);
+ } else
+ timeout = -1;
+ } else
+ timeout = 0;
+
+ if ((r = poll(s->pollfds, s->n_pollfds, timeout)) < 0)
+ return -1;
+
+ else if (r > 0) {
+ AvahiWatch *w;
+
+ for (w = s->watches; w; w = w->watches_next) {
+
+ if (w->dead)
+ continue;
+
+ assert(w->idx >= 0);
+ assert(w->idx < s->n_pollfds);
+
+ if (s->pollfds[w->idx].revents > 0)
+ w->callback(w, w->pollfd.fd, s->pollfds[w->idx].revents, w->userdata);
+
+ if (s->quit) {
+ ret = 1;
+ goto finish;
+ }
+ }
+ }
+
+ ret = 0;
+
+finish:
+
+ if (s->req_cleanup)
+ cleanup(s, 0);
+
+ return ret;
+}
+
+void avahi_simple_poll_quit(AvahiSimplePoll *w) {
+ assert(w);
+
+ w->quit = 1;
+}
+
+AvahiPoll* avahi_simple_poll_get(AvahiSimplePoll *s) {
+ assert(s);
+
+ return &s->api;
+}
--- /dev/null
+#ifndef foosimplewatchhfoo
+#define foosimplewatchhfoo
+
+/* $Id$ */
+
+/***
+ This file is part of avahi.
+
+ avahi is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as
+ published by the Free Software Foundation; either version 2.1 of the
+ License, or (at your option) any later version.
+
+ avahi is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General
+ Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with avahi; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+ USA.
+***/
+
+#include <avahi-common/cdecl.h>
+
+#include "watch.h"
+
+AVAHI_C_DECL_BEGIN
+
+typedef struct AvahiSimplePoll AvahiSimplePoll;
+
+AvahiSimplePoll *avahi_simple_poll_new(void);
+void avahi_simple_poll_free(AvahiSimplePoll *s);
+
+AvahiPoll* avahi_simple_poll_get(AvahiSimplePoll *s);
+
+int avahi_simple_poll_iterate(AvahiSimplePoll *s, int block);
+
+void avahi_simple_poll_quit(AvahiSimplePoll *s);
+
+AVAHI_C_DECL_END
+
+#endif
--- /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 <stdio.h>
+#include <unistd.h>
+#include <assert.h>
+#include <errno.h>
+#include <string.h>
+
+#include "watch.h"
+#include "simple-watch.h"
+#include "timeval.h"
+
+static AvahiPoll *api = NULL;
+
+static void callback(AvahiWatch *w, int fd, AvahiWatchEvent event, void *userdata) {
+
+ if (event & AVAHI_WATCH_IN) {
+ ssize_t r;
+ char c;
+
+ if ((r = read(fd, &c, 1)) <= 0) {
+ fprintf(stderr, "read() failed: %s\n", r < 0 ? strerror(errno) : "EOF");
+ api->watch_free(w);
+ return;
+ }
+
+ printf("Read: %c\n", c >= 32 && c < 127 ? c : '.');
+ }
+}
+
+int main(int argc, char *argv[]) {
+ int i = 0;
+ AvahiSimplePoll *s;
+
+ s = avahi_simple_poll_new();
+ assert(s);
+
+ api = avahi_simple_poll_get(s);
+
+ 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_time(api, &tv);
+
+ if (avahi_simple_poll_iterate(s, 1) != 0)
+ break;
+ }
+
+ return 0;
+}
--- /dev/null
+#ifndef foowatchhfoo
+#define foowatchhfoo
+
+/* $Id$ */
+
+/***
+ This file is part of avahi.
+
+ avahi is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as
+ published by the Free Software Foundation; either version 2.1 of the
+ License, or (at your option) any later version.
+
+ avahi is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General
+ Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with avahi; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+ USA.
+***/
+
+#include <sys/poll.h>
+#include <avahi-common/cdecl.h>
+
+#include "timeval.h"
+
+AVAHI_C_DECL_BEGIN
+
+typedef struct AvahiWatch AvahiWatch;
+typedef struct AvahiPoll AvahiPoll;
+
+typedef enum {
+ AVAHI_WATCH_IN = POLLIN,
+ AVAHI_WATCH_OUT = POLLOUT,
+ AVAHI_WATCH_ERR = POLLERR,
+ AVAHI_WATCH_HUP = POLLHUP
+} AvahiWatchEvent;
+
+typedef void (*AvahiWatchCallback)(AvahiWatch *w, int fd, AvahiWatchEvent event, void *userdata);
+
+struct AvahiPoll {
+ void* userdata;
+
+ AvahiWatch* (*watch_new)(AvahiPoll *api, int fd, AvahiWatchEvent event, AvahiWatchCallback callback, void *userdata);
+ void (*watch_update)(AvahiWatch *w, AvahiWatchEvent event);
+ void (*watch_free)(AvahiWatch *w);
+
+ void (*set_wakeup_time)(AvahiPoll *api, const struct timeval *tv);
+};
+
+AVAHI_C_DECL_END
+
+#endif
+
AM_LDADD=$(GLIB20_LIBS)
# Import stuff from avahi-common
-AM_CFLAGS+=-I$(top_srcdir)/avahi-common
COMMON_LDADD=../avahi-common/libavahi-common.la
# This cool debug trap works on i386/gcc only
conformance-test \
avahi-reflector \
dns-test \
- timeeventq-test \
- timeval-test
+ timeeventq-test
libavahi_core_la_SOURCES = \
timeeventq.c timeeventq.h\
log.c log.h \
browse-dns-server.c \
fdutil.h fdutil.c \
- timeval.h timeval.c \
util.c util.h
+
libavahi_core_la_CFLAGS = $(AM_CFLAGS)
libavahi_core_la_LIBADD = $(AM_LDADD) $(COMMON_LDADD)
timeeventq_test_SOURCES = \
timeeventq-test.c \
timeeventq.h timeeventq.c \
- timeval.c timeval.h \
prioq.h prioq.c
timeeventq_test_CFLAGS = $(AM_CFLAGS)
timeeventq_test_LDADD = $(AM_LDADD) $(COMMON_LDADD)
-timeval_test_SOURCES = \
- timeval.c timeval.h \
- timeval-test.c
-timeval_test_CFLAGS = $(AM_CFLAGS)
-timeval_test_LDADD = $(AM_LDADD)
-
valgrind: avahi-test
libtool --mode=execute valgrind ./avahi-test
#include <config.h>
#endif
+#include <avahi-common/timeval.h>
#include "announce.h"
-#include "timeval.h"
#define AVAHI_ANNOUNCEMENT_JITTER_MSEC 250
#define AVAHI_PROBE_JITTER_MSEC 250
group = NULL;
}
-static void hnr_callback(AvahiHostNameResolver *r, AvahiIfIndex iface, AvahiProtocol protocol, AvahiBrowserEvent event, const gchar *hostname, const AvahiAddress *a, gpointer userdata) {
+static void hnr_callback(AvahiHostNameResolver *r, AvahiIfIndex iface, AvahiProtocol protocol, AvahiResolverEvent event, const gchar *hostname, const AvahiAddress *a, gpointer userdata) {
gchar t[64];
if (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, AvahiBrowserEvent event, const AvahiAddress *a, const gchar *hostname, gpointer userdata) {
+static void ar_callback(AvahiAddressResolver *r, AvahiIfIndex iface, AvahiProtocol protocol, AvahiResolverEvent event, const AvahiAddress *a, const gchar *hostname, gpointer userdata) {
gchar t[64];
avahi_address_snprint(t, sizeof(t), a);
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, AvahiBrowserEvent 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 gchar *name, const gchar*service_type, const gchar*domain_name, const gchar*hostname, const AvahiAddress *a, guint16 port, AvahiStringList *txt, gpointer 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);
#include <config.h>
#endif
+#include <avahi-common/timeval.h>
#include "browse.h"
-#include "timeval.h"
#include "log.h"
struct AvahiRecordBrowser {
#include <string.h>
-#include "timeval.h"
+#include <avahi-common/timeval.h>
#include "cache.h"
#include "log.h"
}
static void next_expiry(AvahiCache *c, AvahiCacheEntry *e, guint percent) {
+ AvahiUsec usec;
g_assert(c);
g_assert(e);
g_assert(percent > 0 && percent <= 100);
- AvahiUsec usec;
/* gchar *txt; */
usec = ((AvahiUsec) e->record->ttl) * 10000;
#include <unistd.h>
#include <stdio.h>
+#include <avahi-common/alternative.h>
#include "core.h"
-#include "alternative.h"
#include "log.h"
static gchar *name = NULL;
typedef struct AvahiHwInterface AvahiHwInterface;
#include <avahi-common/llist.h>
-#include "address.h"
+#include <avahi-common/address.h>
#include "server.h"
#include "netlink.h"
#include "cache.h"
#endif
#include <avahi-common/domain.h>
+#include <avahi-common/timeval.h>
#include "probe-sched.h"
-#include "timeval.h"
#include "log.h"
#define AVAHI_PROBE_HISTORY_MSEC 150
typedef struct AvahiProbeScheduler AvahiProbeScheduler;
+#include <avahi-common/address.h>
#include "iface.h"
-#include "address.h"
AvahiProbeScheduler *avahi_probe_scheduler_new(AvahiInterface *i);
void avahi_probe_scheduler_free(AvahiProbeScheduler *s);
#include <config.h>
#endif
+#include <avahi-common/timeval.h>
#include "query-sched.h"
-#include "timeval.h"
#define AVAHI_QUERY_HISTORY_MSEC 100
#define AVAHI_QUERY_DEFER_MSEC 100
typedef struct AvahiQueryScheduler AvahiQueryScheduler;
+#include <avahi-common/address.h>
#include "iface.h"
-#include "address.h"
AvahiQueryScheduler *avahi_query_scheduler_new(AvahiInterface *i);
void avahi_query_scheduler_free(AvahiQueryScheduler *s);
#include <config.h>
#endif
+#include <avahi-common/timeval.h>
#include "browse.h"
-#include "timeval.h"
struct AvahiAddressResolver {
AvahiServer *server;
#endif
#include <avahi-common/domain.h>
-#include "timeval.h"
+#include <avahi-common/timeval.h>
#include "browse.h"
struct AvahiHostNameResolver {
#include <string.h>
#include <avahi-common/domain.h>
+#include <avahi-common/timeval.h>
#include "browse.h"
-#include "timeval.h"
struct AvahiServiceResolver {
AvahiServer *server;
#include <config.h>
#endif
+#include <avahi-common/timeval.h>
#include "response-sched.h"
-#include "timeval.h"
#include "log.h"
#define AVAHI_RESPONSE_HISTORY_MSEC 500
typedef struct AvahiResponseScheduler AvahiResponseScheduler;
+#include <avahi-common/address.h>
#include "iface.h"
-#include "address.h"
AvahiResponseScheduler *avahi_response_scheduler_new(AvahiInterface *i);
void avahi_response_scheduler_free(AvahiResponseScheduler *s);
#include <stdio.h>
#include <avahi-common/domain.h>
+#include <avahi-common/timeval.h>
#include "server.h"
-#include "timeval.h"
#include "iface.h"
#include "socket.h"
#include "browse.h"
reply = avahi_dns_packet_new_reply(p, size, FALSE, TRUE);
if (!avahi_dns_packet_append_record(reply, r, flush_cache, 0)) {
+ gchar *t;
avahi_dns_packet_free(reply);
-
- gchar *t = avahi_record_to_string(r);
+ t = avahi_record_to_string(r);
avahi_log_warn("Record [%s] too large, doesn't fit in any packet!", t);
g_free(t);
break;
#include <glib.h>
+#include <avahi-common/timeval.h>
#include "timeeventq.h"
-#include "timeval.h"
static AvahiTimeEventQueue *q = NULL;
#include <config.h>
#endif
+#include <avahi-common/timeval.h>
#include "timeeventq.h"
-#include "timeval.h"
static gint compare(gconstpointer _a, gconstpointer _b) {
const AvahiTimeEvent *a = _a, *b = _b;
--- /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 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 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.
+
+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
+
+# This cool debug trap works on i386/gcc only
+AM_CFLAGS+='-DDEBUG_TRAP=__asm__("int $$3")'
+
+avahiincludedir=$(includedir)/avahi-glib
+
+avahiinclude_HEADERS = \
+ glib-watch.h
+
+lib_LTLIBRARIES = \
+ libavahi-glib.la
+
+noinst_PROGRAMS = \
+ glib-watch-test
+
+libavahi_glib_la_SOURCES = \
+ glib-watch.c glib-watch.h
+libavahi_glib_la_CFLAGS = $(AM_CFLAGS)
+libavahi_glib_la_LIBADD = $(AM_LDADD) $(COMMON_LDADD)
+
+glib_watch_test_SOURCES = \
+ glib-watch.c glib-watch.h \
+ glib-watch-test.c
+glib_watch_test_CFLAGS = $(AM_CFLAGS)
+glib_watch_test_LDADD = $(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 <stdio.h>
+#include <unistd.h>
+#include <assert.h>
+#include <errno.h>
+#include <string.h>
+
+#include <avahi-common/watch.h>
+#include <avahi-common/timeval.h>
+#include "glib-watch.h"
+
+static AvahiPoll *api = NULL;
+static GMainLoop *loop = NULL;
+
+static void callback(AvahiWatch *w, int fd, AvahiWatchEvent event, void *userdata) {
+
+ if (event & AVAHI_WATCH_IN) {
+ ssize_t r;
+ char c;
+
+ if ((r = read(fd, &c, 1)) <= 0) {
+ fprintf(stderr, "read() failed: %s\n", r < 0 ? strerror(errno) : "EOF");
+ api->watch_free(w);
+ return;
+ }
+
+ printf("Read: %c\n", c >= 32 && c < 127 ? c : '.');
+ }
+}
+
+static void iteration(AvahiGLibPoll *p, void *userdata) {
+ struct timeval tv;
+ static int i = 0;
+
+ printf("Iteration %i\n", i++);
+
+ if (i > 100)
+ g_main_loop_quit(loop);
+
+ avahi_elapse_time(&tv, 1000, 0);
+ api->set_wakeup_time(api, &tv);
+}
+
+int main(int argc, char *argv[]) {
+ AvahiGLibPoll *s;
+ struct timeval tv;
+
+ s = avahi_glib_poll_new(NULL, iteration, 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);
+
+ loop = g_main_loop_new(NULL, FALSE);
+ g_main_loop_run(loop);
+ g_main_loop_unref(loop);
+
+ return 0;
+}
--- /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-watch.h"
+
+struct AvahiWatch {
+ AvahiGLibPoll *glib_poll;
+ int dead;
+ GPollFD pollfd;
+ int pollfd_added;
+ AvahiWatchCallback callback;
+ void *userdata;
+
+ AVAHI_LLIST_FIELDS(AvahiWatch, watches);
+};
+
+struct AvahiGLibPoll {
+ GSource source;
+ AvahiPoll api;
+ GMainContext *context;
+
+ struct timeval wakeup;
+ gboolean use_wakeup;
+ int req_cleanup;
+
+ AvahiGLibProcessCallback process_callback;
+ void *userdata;
+
+ AVAHI_LLIST_HEAD(AvahiWatch, watches);
+};
+
+static void destroy_watch(AvahiWatch *w) {
+ assert(w);
+
+ if (w->pollfd_added)
+ g_source_remove_poll(&w->glib_poll->source, &w->pollfd);
+
+ AVAHI_LLIST_REMOVE(AvahiWatch, watches, w->glib_poll->watches, w);
+
+ avahi_free(w);
+}
+
+static void cleanup(AvahiGLibPoll *g, int all) {
+ AvahiWatch *w, *next;
+ assert(g);
+
+ for (w = g->watches; w; w = next) {
+ next = w->watches_next;
+
+ if (all || w->dead)
+ destroy_watch(w);
+ }
+
+ g->req_cleanup = 0;
+}
+
+static AvahiWatch* watch_new(AvahiPoll *api, int fd, AvahiWatchEvent event, AvahiWatchCallback callback, void *userdata) {
+ AvahiWatch *w;
+ AvahiGLibPoll *g;
+
+ assert(api);
+ assert(fd >= 0);
+ assert(callback);
+
+ g = api->userdata;
+ assert(g);
+
+ if (!(w = avahi_new(AvahiWatch, 1)))
+ return NULL;
+
+ w->glib_poll = g;
+ w->pollfd.fd = fd;
+ w->pollfd.events =
+ (event & AVAHI_WATCH_IN ? G_IO_IN : 0) |
+ (event & AVAHI_WATCH_OUT ? G_IO_OUT : 0) |
+ (event & AVAHI_WATCH_ERR ? G_IO_ERR : 0) |
+ (event & AVAHI_WATCH_HUP ? G_IO_HUP : 0);
+ ;
+ w->callback = callback;
+ w->userdata = userdata;
+ w->dead = 0;
+
+ g_source_add_poll(&g->source, &w->pollfd);
+ w->pollfd_added = 1;
+
+ AVAHI_LLIST_PREPEND(AvahiWatch, watches, g->watches, w);
+
+ return w;
+}
+
+static void watch_update(AvahiWatch *w, AvahiWatchEvent events) {
+ assert(w);
+ assert(!w->dead);
+
+ w->pollfd.events = events;
+}
+
+static void watch_free(AvahiWatch *w) {
+ assert(w);
+ assert(!w->dead);
+
+ if (w->pollfd_added) {
+ g_source_remove_poll(&w->glib_poll->source, &w->pollfd);
+ w->pollfd_added = 0;
+ }
+
+ w->dead = 1;
+ w->glib_poll->req_cleanup = 1;
+}
+
+static void set_wakeup_time(AvahiPoll *api, const struct timeval *tv) {
+ AvahiGLibPoll *g;
+
+ assert(api);
+ g = api->userdata;
+
+ if (tv) {
+ g->wakeup = *tv;
+ g->use_wakeup = 1;
+ } else
+ g->use_wakeup = 0;
+}
+
+static gboolean prepare_func(GSource *source, gint *timeout) {
+ AvahiGLibPoll *g = (AvahiGLibPoll*) source;
+
+ g_assert(g);
+ g_assert(timeout);
+
+ if (g->use_wakeup) {
+ GTimeVal now;
+ struct timeval tvnow;
+ AvahiUsec usec;
+
+ g_source_get_current_time(source, &now);
+ tvnow.tv_sec = now.tv_sec;
+ tvnow.tv_usec = now.tv_usec;
+
+ usec = avahi_timeval_diff(&g->wakeup, &tvnow);
+
+ if (usec <= 0)
+ return TRUE;
+
+ *timeout = (gint) (usec / 1000);
+ }
+
+ return FALSE;
+}
+
+static gboolean check_func(GSource *source) {
+ AvahiGLibPoll *g = (AvahiGLibPoll*) source;
+ AvahiWatch *w;
+
+ g_assert(g);
+
+ for (w = g->watches; w; w = w->watches_next)
+ if (w->pollfd.revents > 0)
+ return TRUE;
+
+ return FALSE;
+}
+
+static gboolean dispatch_func(GSource *source, GSourceFunc callback, gpointer userdata) {
+ AvahiGLibPoll* g = (AvahiGLibPoll*) source;
+ AvahiWatch *w;
+
+ g_assert(g);
+
+ if (g->req_cleanup)
+ cleanup(g, 0);
+
+ if (g->process_callback)
+ g->process_callback(g, g->userdata);
+
+ 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;
+ }
+
+ if (g->req_cleanup)
+ cleanup(g, 0);
+
+ return TRUE;
+}
+
+AvahiGLibPoll *avahi_glib_poll_new(GMainContext *context, AvahiGLibProcessCallback callback, void *userdata) {
+ AvahiGLibPoll *g;
+
+ static GSourceFuncs source_funcs = {
+ prepare_func,
+ check_func,
+ dispatch_func,
+ NULL,
+ NULL,
+ NULL
+ };
+
+ g = (AvahiGLibPoll*) g_source_new(&source_funcs, sizeof(AvahiGLibPoll));
+ g_main_context_ref(g->context = context ? context : g_main_context_default());
+
+ g->api.userdata = g;
+ 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->use_wakeup = 0;
+ g->process_callback = callback;
+ g->userdata = userdata;
+ g->req_cleanup = 0;
+
+ AVAHI_LLIST_HEAD_INIT(AvahiWatch, g->watches);
+
+ g_source_attach(&g->source, g->context);
+
+ return g;
+}
+
+void avahi_glib_poll_free(AvahiGLibPoll *g) {
+ GSource *s = &g->source;
+ assert(g);
+
+ cleanup(g, 1);
+
+ g_main_context_unref(g->context);
+ g_source_destroy(s);
+ g_source_unref(s);
+}
+
+AvahiPoll* avahi_glib_poll_get(AvahiGLibPoll *g) {
+ assert(g);
+
+ return &g->api;
+}
--- /dev/null
+#ifndef fooglibwatchhfoo
+#define fooglibwatchhfoo
+
+/* $Id$ */
+
+/***
+ This file is part of avahi.
+
+ avahi is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as
+ published by the Free Software Foundation; either version 2.1 of the
+ License, or (at your option) any later version.
+
+ avahi is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General
+ Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with avahi; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+ USA.
+***/
+
+#include <avahi-common/cdecl.h>
+
+#include <glib.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);
+void avahi_glib_poll_free(AvahiGLibPoll *g);
+
+AvahiPoll* avahi_glib_poll_get(AvahiGLibPoll *g);
+
+AVAHI_C_DECL_END
+
+#endif
avahi-core.pc
avahi-common/Makefile
avahi-core/Makefile
+avahi-glib/Makefile
avahi-daemon/Makefile
avahi-daemon/avahi-dbus.conf
avahi-discover-standalone/Makefile
todo:
+* drop glib
+* allow srv port == 0
+* deal with no local interface
* release!
later:
projects / platform / upstream / avahi.git / commitdiff