#include "browse.h"
#include "log.h"
-#define AVAHI_HOST_RR_HOLDOFF_MSEC 2000
+#define AVAHI_RR_HOLDOFF_MSEC 1000
+#define AVAHI_RR_HOLDOFF_MSEC_RATE_LIMIT 60000
+#define AVAHI_RR_RATE_LIMIT_COUNT 15
static void free_entry(AvahiServer*s, AvahiEntry *e) {
AvahiEntry *t;
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_LLIST_REMOVE(AvahiEntryGroup, groups, s->groups, g);
g_free(g);
}
AvahiEntry *k;
for (k = e->group->entries; k; k = k->by_group_next) {
- avahi_goodbye_entry(s, k, FALSE);
- k->dead = TRUE;
+ if (!k->dead) {
+ avahi_goodbye_entry(s, k, FALSE);
+ k->dead = TRUE;
+ }
}
-
+
+ e->group->n_probing = 0;
+
avahi_entry_group_change_state(e->group, AVAHI_ENTRY_GROUP_COLLISION);
} else {
avahi_goodbye_entry(s, e, FALSE);
g_assert(key);
for (e = g_hash_table_lookup(s->entries_by_key, key); e; e = e->by_key_next)
- withdraw_entry(s, e);
+ if (!e->dead)
+ withdraw_entry(s, e);
}
static void incoming_probe(AvahiServer *s, AvahiRecord *record, AvahiInterface *i) {
}
}
+
if (!ours) {
if (won)
if (!s->config.enable_reflector)
return;
-/* avahi_log_debug("legacy unicast reflectr"); */
+/* avahi_log_debug("legacy unicast reflector"); */
/* Reflecting legacy unicast queries is a little more complicated
than reflecting normal queries, since we must route the
static void withdraw_host_rrs(AvahiServer *s) {
g_assert(s);
- if (s->hinfo_entry_group) {
- avahi_entry_group_free(s->hinfo_entry_group);
- s->hinfo_entry_group = NULL;
- }
+ if (s->hinfo_entry_group)
+ avahi_entry_group_reset(s->hinfo_entry_group);
- if (s->browse_domain_entry_group) {
- avahi_entry_group_free(s->browse_domain_entry_group);
- s->browse_domain_entry_group = NULL;
- }
+ if (s->browse_domain_entry_group)
+ avahi_entry_group_reset(s->browse_domain_entry_group);
avahi_update_host_rrs(s->monitor, TRUE);
s->n_host_rr_pending = 0;
if (state == AVAHI_ENTRY_GROUP_REGISTERING &&
s->state == AVAHI_SERVER_REGISTERING)
avahi_server_increase_host_rr_pending(s);
+
else if (state == AVAHI_ENTRY_GROUP_COLLISION &&
(s->state == AVAHI_SERVER_REGISTERING || s->state == AVAHI_SERVER_RUNNING)) {
withdraw_host_rrs(s);
server_set_state(s, AVAHI_SERVER_COLLISION);
+
} else if (state == AVAHI_ENTRY_GROUP_ESTABLISHED &&
s->state == AVAHI_SERVER_REGISTERING)
avahi_server_decrease_host_rr_pending(s);
g_assert(s);
- if (!s->config.publish_hinfo || s->hinfo_entry_group)
+ if (!s->config.publish_hinfo)
return;
-
- s->hinfo_entry_group = avahi_entry_group_new(s, avahi_host_rr_entry_group_callback, NULL);
+
+ if (s->hinfo_entry_group)
+ g_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);
/* 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);
static void register_browse_domain(AvahiServer *s) {
g_assert(s);
- if (!s->config.publish_domain || s->browse_domain_entry_group)
+ if (!s->config.publish_domain)
return;
- s->browse_domain_entry_group = avahi_entry_group_new(s, NULL, NULL);
+ if (s->browse_domain_entry_group)
+ g_assert(avahi_entry_group_is_empty(s->browse_domain_entry_group));
+ else
+ s->browse_domain_entry_group = avahi_entry_group_new(s, NULL, NULL);
+
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);
}
s->host_name_fqdn = g_strdup_printf("%s.%s", s->host_name, s->domain_name);
}
-static void register_time_event_callback(AvahiTimeEvent *e, gpointer userdata) {
- AvahiServer *s = userdata;
-
- g_assert(e);
- g_assert(s);
-
- g_assert(e == s->register_time_event);
- avahi_time_event_queue_remove(s->time_event_queue, s->register_time_event);
- s->register_time_event = NULL;
-
- if (s->state == AVAHI_SERVER_SLEEPING)
- register_stuff(s);
-}
-
-static void delayed_register_stuff(AvahiServer *s) {
- GTimeVal tv;
-
- g_assert(s);
-
- avahi_elapse_time(&tv, AVAHI_HOST_RR_HOLDOFF_MSEC, 0);
-
- if (s->register_time_event)
- avahi_time_event_queue_update(s->time_event_queue, s->register_time_event, &tv);
- else
- s->register_time_event = avahi_time_event_queue_add(s->time_event_queue, &tv, register_time_event_callback, s);
-}
-
gint avahi_server_set_host_name(AvahiServer *s, const gchar *host_name) {
g_assert(s);
g_assert(host_name);
- server_set_state(s, AVAHI_SERVER_SLEEPING);
+ if (host_name && !avahi_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);
s->host_name[strcspn(s->host_name, ".")] = 0;
update_fqdn(s);
- delayed_register_stuff(s);
- return 0;
+ register_stuff(s);
+ return AVAHI_OK;
}
gint avahi_server_set_domain_name(AvahiServer *s, const gchar *domain_name) {
g_assert(s);
g_assert(domain_name);
- server_set_state(s, AVAHI_SERVER_SLEEPING);
+ if (domain_name && !avahi_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");
update_fqdn(s);
- delayed_register_stuff(s);
- return 0;
+ register_stuff(s);
+ return AVAHI_OK;
}
-
static void prepare_pollfd(AvahiServer *s, GPollFD *pollfd, gint fd) {
g_assert(s);
g_assert(pollfd);
g_source_add_poll(s->source, pollfd);
}
-AvahiServer *avahi_server_new(GMainContext *c, const AvahiServerConfig *sc, AvahiServerCallback callback, gpointer userdata) {
+static gint valid_server_config(const AvahiServerConfig *sc) {
+
+ if (sc->host_name && !avahi_valid_host_name(sc->host_name))
+ return AVAHI_ERR_INVALID_HOST_NAME;
+
+ if (sc->domain_name && !avahi_valid_domain_name(sc->domain_name))
+ return AVAHI_ERR_INVALID_DOMAIN_NAME;
+
+ return AVAHI_OK;
+}
+
+AvahiServer *avahi_server_new(GMainContext *c, const AvahiServerConfig *sc, AvahiServerCallback callback, gpointer userdata, gint *error) {
AvahiServer *s;
+ gint e;
static GSourceFuncs source_funcs = {
prepare_func,
NULL
};
+ 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;
s->fd_ipv6 = s->config.use_ipv6 ? avahi_open_socket_ipv6() : -1;
if (s->fd_ipv6 < 0 && s->fd_ipv4 < 0) {
- g_critical("Selected neither IPv6 nor IPv4 support, aborting.\n");
avahi_server_config_free(&s->config);
g_free(s);
+
+ if (error)
+ *error = AVAHI_ERR_NO_NETWORK;
+
return NULL;
}
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->register_time_event = NULL;
s->state = AVAHI_SERVER_INVALID;
s->hinfo_entry_group = NULL;
s->browse_domain_entry_group = NULL;
register_stuff(s);
+
+ s->error = AVAHI_OK;
return s;
}
g_hash_table_destroy(s->entries_by_key);
- if (s->register_time_event)
- avahi_time_event_queue_remove(s->time_event_queue, s->register_time_event);
avahi_time_event_queue_free(s->time_event_queue);
avahi_record_list_free(s->record_list);
g_free(s);
}
-static gint check_record_conflict(AvahiServer *s, gint interface, guchar protocol, AvahiRecord *r, AvahiEntryFlags flags) {
+static gint check_record_conflict(AvahiServer *s, AvahiIfIndex interface, AvahiProtocol protocol, AvahiRecord *r, AvahiEntryFlags flags) {
AvahiEntry *e;
g_assert(s);
gint avahi_server_add(
AvahiServer *s,
AvahiEntryGroup *g,
- gint interface,
- guchar protocol,
+ AvahiIfIndex interface,
+ AvahiProtocol protocol,
AvahiEntryFlags flags,
AvahiRecord *r) {
g_assert(r);
if (r->ttl == 0)
- return -1;
+ return avahi_server_set_errno(s, AVAHI_ERR_INVALID_TTL);
if (avahi_key_is_pattern(r->key))
- return -1;
+ return avahi_server_set_errno(s, AVAHI_ERR_IS_PATTERN);
+
+ if (!avahi_record_valid(r))
+ return avahi_server_set_errno(s, AVAHI_ERR_INVALID_RECORD);
if (check_record_conflict(s, interface, protocol, r, flags) < 0)
- return -1;
+ return avahi_server_set_errno(s, AVAHI_ERR_LOCAL_COLLISION);
e = g_new(AvahiEntry, 1);
e->server = s;
gint avahi_server_add_ptr(
AvahiServer *s,
AvahiEntryGroup *g,
- gint interface,
- guchar protocol,
+ AvahiIfIndex interface,
+ AvahiProtocol protocol,
AvahiEntryFlags flags,
guint32 ttl,
const gchar *name,
AvahiRecord *r;
gint ret;
+ g_assert(s);
g_assert(dest);
r = avahi_record_new_full(name ? name : s->host_name_fqdn, AVAHI_DNS_CLASS_IN, AVAHI_DNS_TYPE_PTR, ttl);
gint avahi_server_add_address(
AvahiServer *s,
AvahiEntryGroup *g,
- gint interface,
- guchar protocol,
+ AvahiIfIndex interface,
+ AvahiProtocol protocol,
AvahiEntryFlags flags,
const gchar *name,
AvahiAddress *a) {
gchar *n = NULL;
- gint ret = 0;
+ gint ret = AVAHI_OK;
g_assert(s);
g_assert(a);
name = name ? (n = avahi_normalize_name(name)) : s->host_name_fqdn;
+
+ if (!avahi_valid_domain_name(name)) {
+ avahi_server_set_errno(s, AVAHI_ERR_INVALID_HOST_NAME);
+ goto fail;
+ }
if (a->family == AVAHI_PROTO_INET) {
gchar *reverse;
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);
- ret |= avahi_server_add_ptr(s, g, interface, protocol, flags | AVAHI_ENTRY_UNIQUE, AVAHI_DEFAULT_TTL_HOST_NAME, reverse, name);
+ ret = avahi_server_add_ptr(s, g, interface, protocol, flags | AVAHI_ENTRY_UNIQUE, AVAHI_DEFAULT_TTL_HOST_NAME, reverse, name);
g_free(reverse);
-
+
} else {
gchar *reverse;
AvahiRecord *r;
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);
- ret |= avahi_server_add_ptr(s, g, interface, protocol, flags | AVAHI_ENTRY_UNIQUE, AVAHI_DEFAULT_TTL_HOST_NAME, reverse, name);
+ ret = avahi_server_add_ptr(s, g, interface, protocol, flags | AVAHI_ENTRY_UNIQUE, AVAHI_DEFAULT_TTL_HOST_NAME, reverse, name);
g_free(reverse);
+
+ if (ret < 0)
+ goto fail;
reverse = avahi_reverse_lookup_name_ipv6_int(&a->data.ipv6);
- ret |= avahi_server_add_ptr(s, g, interface, protocol, flags | AVAHI_ENTRY_UNIQUE, AVAHI_DEFAULT_TTL_HOST_NAME, reverse, name);
+ ret = avahi_server_add_ptr(s, g, interface, protocol, flags | AVAHI_ENTRY_UNIQUE, AVAHI_DEFAULT_TTL_HOST_NAME, reverse, name);
g_free(reverse);
}
+
+fail:
g_free(n);
return ret;
}
-gint avahi_server_add_txt_strlst(
+static gint server_add_txt_strlst_nocopy(
AvahiServer *s,
AvahiEntryGroup *g,
- gint interface,
- guchar protocol,
+ AvahiIfIndex interface,
+ AvahiProtocol protocol,
AvahiEntryFlags flags,
guint32 ttl,
const gchar *name,
return ret;
}
+gint avahi_server_add_txt_strlst(
+ AvahiServer *s,
+ AvahiEntryGroup *g,
+ AvahiIfIndex interface,
+ AvahiProtocol protocol,
+ AvahiEntryFlags flags,
+ guint32 ttl,
+ const gchar *name,
+ AvahiStringList *strlst) {
+
+ g_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(
AvahiServer *s,
AvahiEntryGroup *g,
- gint interface,
- guchar protocol,
+ AvahiIfIndex interface,
+ AvahiProtocol protocol,
AvahiEntryFlags flags,
guint32 ttl,
const gchar *name,
va_list va) {
-
+
g_assert(s);
- return avahi_server_add_txt_strlst(s, g, interface, protocol, flags, ttl, name, avahi_string_list_new_va(va));
+ return server_add_txt_strlst_nocopy(s, g, interface, protocol, flags, ttl, name, avahi_string_list_new_va(va));
}
gint avahi_server_add_txt(
AvahiServer *s,
AvahiEntryGroup *g,
- gint interface,
- guchar protocol,
+ AvahiIfIndex interface,
+ AvahiProtocol protocol,
AvahiEntryFlags flags,
guint32 ttl,
const gchar *name,
*(d++) = 0;
}
-gint avahi_server_add_service_strlst(
+static gint server_add_service_strlst_nocopy(
AvahiServer *s,
AvahiEntryGroup *g,
- gint interface,
- guchar protocol,
+ AvahiIfIndex interface,
+ AvahiProtocol protocol,
const gchar *name,
const gchar *type,
const gchar *domain,
gchar ptr_name[256], svc_name[256], ename[64], enum_ptr[256];
gchar *t, *d;
- AvahiRecord *r;
+ AvahiRecord *r = NULL;
gint ret = 0;
g_assert(s);
g_assert(type);
g_assert(name);
+ if (!avahi_valid_service_name(name))
+ return avahi_server_set_errno(s, AVAHI_ERR_INVALID_SERVICE_NAME);
+
+ if (!avahi_valid_service_type(type))
+ return avahi_server_set_errno(s, AVAHI_ERR_INVALID_SERVICE_TYPE);
+
+ if (domain && !avahi_valid_domain_name(domain))
+ return avahi_server_set_errno(s, AVAHI_ERR_INVALID_DOMAIN_NAME);
+
+ if (host && !avahi_valid_domain_name(host))
+ return avahi_server_set_errno(s, AVAHI_ERR_INVALID_HOST_NAME);
+
+ if (port == 0)
+ return avahi_server_set_errno(s, AVAHI_ERR_INVALID_PORT);
+
escape_service_name(ename, sizeof(ename), name);
- if (domain) {
- while (domain[0] == '.')
- domain++;
- } else
+ if (!domain)
domain = s->domain_name;
if (!host)
g_snprintf(ptr_name, sizeof(ptr_name), "%s.%s", t, d);
g_snprintf(svc_name, sizeof(svc_name), "%s.%s.%s", ename, t, d);
- ret = avahi_server_add_ptr(s, g, interface, protocol, AVAHI_ENTRY_NULL, AVAHI_DEFAULT_TTL, ptr_name, svc_name);
+ 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);
r->data.srv.priority = 0;
r->data.srv.weight = 0;
r->data.srv.port = port;
r->data.srv.name = avahi_normalize_name(host);
- ret |= avahi_server_add(s, g, interface, protocol, AVAHI_ENTRY_UNIQUE, r);
+ ret = avahi_server_add(s, g, interface, protocol, AVAHI_ENTRY_UNIQUE, r);
avahi_record_unref(r);
- ret |= avahi_server_add_txt_strlst(s, g, interface, protocol, AVAHI_ENTRY_UNIQUE, AVAHI_DEFAULT_TTL, svc_name, strlst);
+ if (ret < 0)
+ goto fail;
+
+ ret = server_add_txt_strlst_nocopy(s, g, interface, protocol, AVAHI_ENTRY_UNIQUE, AVAHI_DEFAULT_TTL, svc_name, strlst);
+ strlst = NULL;
+
+ if (ret < 0)
+ goto fail;
g_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);
+ 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_string_list_free(strlst);
return ret;
}
+gint 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,
+ AvahiStringList *strlst) {
+
+ g_assert(s);
+ g_assert(type);
+ g_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(
AvahiServer *s,
AvahiEntryGroup *g,
- gint interface,
- guchar protocol,
+ AvahiIfIndex interface,
+ AvahiProtocol protocol,
const gchar *name,
const gchar *type,
const gchar *domain,
g_assert(type);
g_assert(name);
- return avahi_server_add_service_strlst(s, g, interface, protocol, name, type, domain, host, port, avahi_string_list_new_va(va));
+ 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(
AvahiServer *s,
AvahiEntryGroup *g,
- gint interface,
- guchar protocol,
+ AvahiIfIndex interface,
+ AvahiProtocol protocol,
const gchar *name,
const gchar *type,
const gchar *domain,
gint avahi_server_add_dns_server_address(
AvahiServer *s,
AvahiEntryGroup *g,
- gint interface,
- guchar protocol,
+ AvahiIfIndex interface,
+ AvahiProtocol protocol,
const gchar *domain,
AvahiDNSServerType type,
const AvahiAddress *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);
+ if (domain && !avahi_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 (address->family == AVAHI_PROTO_INET) {
hexstring(n+3, sizeof(n)-3, &address->data, 4);
r = avahi_record_new_full(n, AVAHI_DNS_CLASS_IN, AVAHI_DNS_TYPE_A, AVAHI_DEFAULT_TTL_HOST_NAME);
ret = avahi_server_add(s, g, interface, protocol, AVAHI_ENTRY_UNIQUE | AVAHI_ENTRY_ALLOWMUTIPLE, r);
avahi_record_unref(r);
-
- ret |= avahi_server_add_dns_server_name(s, g, interface, protocol, domain, type, n, port);
- return ret;
+ if (ret < 0)
+ return ret;
+
+ return avahi_server_add_dns_server_name(s, g, interface, protocol, domain, type, n, port);
}
gint avahi_server_add_dns_server_name(
AvahiServer *s,
AvahiEntryGroup *g,
- gint interface,
- guchar protocol,
+ AvahiIfIndex interface,
+ AvahiProtocol protocol,
const gchar *domain,
AvahiDNSServerType type,
const gchar *name,
g_assert(name);
g_assert(type == AVAHI_DNS_SERVER_UPDATE || type == AVAHI_DNS_SERVER_RESOLVE);
- if (domain) {
- while (domain[0] == '.')
- domain++;
- } else
+ if (domain && !avahi_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);
avahi_interface_post_query(i, k, FALSE);
}
-void avahi_server_post_query(AvahiServer *s, gint interface, guchar protocol, AvahiKey *key) {
+void avahi_server_post_query(AvahiServer *s, AvahiIfIndex interface, AvahiProtocol protocol, AvahiKey *key) {
g_assert(s);
g_assert(key);
if (g->state == state)
return;
+ g_assert(state >= AVAHI_ENTRY_GROUP_UNCOMMITED && state <= AVAHI_ENTRY_GROUP_COLLISION);
+
g->state = state;
- if (g->callback) {
+ if (g->callback)
g->callback(g->server, g, state, g->userdata);
- return;
- }
}
AvahiEntryGroup *avahi_entry_group_new(AvahiServer *s, AvahiEntryGroupCallback callback, gpointer userdata) {
g->dead = FALSE;
g->state = AVAHI_ENTRY_GROUP_UNCOMMITED;
g->n_probing = 0;
+ g->n_register_try = 0;
+ g->register_time_event = NULL;
+ g->register_time.tv_sec = 0;
+ g->register_time.tv_usec = 0;
AVAHI_LLIST_HEAD_INIT(AvahiEntry, g->entries);
AVAHI_LLIST_PREPEND(AvahiEntryGroup, groups, s->groups, g);
g_assert(g->server);
for (e = g->entries; e; e = e->by_group_next) {
- avahi_goodbye_entry(g->server, e, TRUE);
- e->dead = TRUE;
+ if (!e->dead) {
+ avahi_goodbye_entry(g->server, e, TRUE);
+ e->dead = TRUE;
+ }
+ }
+
+ if (g->register_time_event) {
+ avahi_time_event_queue_remove(g->server->time_event_queue, g->register_time_event);
+ g->register_time_event = NULL;
}
g->dead = TRUE;
g->server->need_entry_cleanup = TRUE;
}
+static void entry_group_commit_real(AvahiEntryGroup *g) {
+ g_assert(g);
+
+ g_get_current_time(&g->register_time);
+
+ avahi_entry_group_change_state(g, AVAHI_ENTRY_GROUP_REGISTERING);
+
+ if (!g->dead) {
+ avahi_announce_group(g->server, g);
+ avahi_entry_group_check_probed(g, FALSE);
+ }
+}
+
+static void entry_group_register_time_event_callback(AvahiTimeEvent *e, gpointer userdata) {
+ AvahiEntryGroup *g = userdata;
+ 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);
+ 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) {
+ GTimeVal now;
+
g_assert(g);
g_assert(!g->dead);
- if (g->state != AVAHI_ENTRY_GROUP_UNCOMMITED)
- return -1;
+ 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_entry_group_change_state(g, AVAHI_ENTRY_GROUP_REGISTERING);
- avahi_announce_group(g->server, g);
- avahi_entry_group_check_probed(g, FALSE);
+ g->n_register_try++;
- return 0;
+ avahi_timeval_add(&g->register_time,
+ 1000*(g->n_register_try >= AVAHI_RR_RATE_LIMIT_COUNT ?
+ AVAHI_RR_HOLDOFF_MSEC_RATE_LIMIT :
+ AVAHI_RR_HOLDOFF_MSEC));
+
+ g_get_current_time(&now);
+
+ if (avahi_timeval_compare(&g->register_time, &now) <= 0) {
+ /* Holdoff time passed, so let's start probing */
+/* avahi_log_debug("Holdoff passed, directly going on."); */
+
+ entry_group_commit_real(g);
+ } else {
+/* 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);
+
+ avahi_entry_group_change_state(g, AVAHI_ENTRY_GROUP_REGISTERING);
+ }
+
+ return AVAHI_OK;
+}
+
+void avahi_entry_group_reset(AvahiEntryGroup *g) {
+ AvahiEntry *e;
+ g_assert(g);
+
+ if (g->register_time_event) {
+ avahi_time_event_queue_remove(g->server->time_event_queue, 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;
+ }
+ }
+
+ if (g->register_time_event) {
+ avahi_time_event_queue_remove(g->server->time_event_queue, g->register_time_event);
+ g->register_time_event = NULL;
+ }
+
+ g->server->need_entry_cleanup = TRUE;
+ g->n_probing = 0;
+
+ avahi_entry_group_change_state(g, AVAHI_ENTRY_GROUP_UNCOMMITED);
}
gboolean avahi_entry_commited(AvahiEntry *e) {
return g->userdata;
}
+gboolean avahi_entry_group_is_empty(AvahiEntryGroup *g) {
+ AvahiEntry *e;
+ 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 TRUE;
+}
+
const gchar* avahi_server_get_domain_name(AvahiServer *s) {
g_assert(s);
return ret;
}
+
+const gchar *avahi_strerror(gint error) {
+ g_assert(-error >= 0 && -error < -AVAHI_ERR_MAX);
+
+ const gchar * const msg[- AVAHI_ERR_MAX] = {
+ "OK",
+ "Operation failed",
+ "Bad state",
+ "Invalid host name",
+ "Invalid domain name",
+ "No suitable network protocol available",
+ "Invalid DNS TTL",
+ "Resource record key is pattern",
+ "Local name collision",
+ "Invalid record",
+ "Invalid service name",
+ "Invalid service type",
+ "Invalid port number",
+ "Invalid record key",
+ "Invalid address",
+ "Timeout reached",
+ "Too many clients",
+ "Too many objects",
+ "Too many entries",
+ "OS Error",
+ "Access denied"
+ };
+
+ return msg[-error];
+}
+
+gint avahi_server_errno(AvahiServer *s) {
+ g_assert(s);
+
+ return s->error;
+}
+
+/* Just for internal use */
+gint avahi_server_set_errno(AvahiServer *s, gint error) {
+ g_assert(s);
+
+ return s->error = error;
+}
+
projects / catta / blobdiff