static void remove_entry(AvahiCache *c, AvahiCacheEntry *e) {
AvahiCacheEntry *t;
assert(c);
assert(e);
/* avahi_log_debug("removing from cache: %p %p", c, e); */
/* Remove from hash table */
t = avahi_hashmap_lookup(c->hashmap, e->record->key);
AVAHI_LLIST_REMOVE(AvahiCacheEntry, by_key, t, e);
if (t)
avahi_hashmap_replace(c->hashmap, t->record->key, t);
else
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_free(e->time_event);
avahi_multicast_lookup_engine_notify(c->server->mdns.multicast_lookup_engine, c->interface, e->record, AVAHI_BROWSER_REMOVE);
avahi_record_unref(e->record);
avahi_free(e);
assert(c->n_entries-- >= 1);
}
void avahi_s_service_resolver_free(AvahiSServiceResolver *r) {
assert(r);
AVAHI_LLIST_REMOVE(AvahiSServiceResolver, resolver, r->server->service_resolvers, r);
if (r->time_event)
avahi_time_event_free(r->time_event);
if (r->record_browser_srv)
avahi_s_record_browser_free(r->record_browser_srv);
if (r->record_browser_txt)
avahi_s_record_browser_free(r->record_browser_txt);
if (r->record_browser_a)
avahi_s_record_browser_free(r->record_browser_a);
if (r->record_browser_aaaa)
avahi_s_record_browser_free(r->record_browser_aaaa);
if (r->srv_record)
avahi_record_unref(r->srv_record);
if (r->txt_record)
avahi_record_unref(r->txt_record);
if (r->address_record)
avahi_record_unref(r->address_record);
avahi_free(r->service_name);
avahi_free(r->service_type);
avahi_free(r->domain_name);
avahi_free(r);
}
void avahi_s_entry_group_change_state(AvahiSEntryGroup *g, AvahiEntryGroupState state) {
assert(g);
if (g->state == state)
return;
assert(state <= AVAHI_ENTRY_GROUP_COLLISION);
if (g->state == AVAHI_ENTRY_GROUP_ESTABLISHED) {
/* If the entry group was established for a time longer then
* 5s, reset the establishment trial counter */
if (avahi_age(&g->established_at) > 5000000)
g->n_register_try = 0;
} else if (g->state == AVAHI_ENTRY_GROUP_REGISTERING) {
if (g->register_time_event) {
avahi_time_event_free(g->register_time_event);
g->register_time_event = NULL;
}
}
if (state == AVAHI_ENTRY_GROUP_ESTABLISHED)
/* If the entry group is now established, remember the time
* this happened */
gettimeofday(&g->established_at, NULL);
g->state = state;
if (g->callback)
g->callback(g->server, g, state, g->userdata);
}
static void defer_callback(AvahiTimeEvent *e, void *userdata) {
AvahiSDomainBrowser *b = userdata;
AvahiStringList *l;
assert(e);
assert(b);
assert(b->type == AVAHI_DOMAIN_BROWSER_BROWSE);
avahi_time_event_free(b->defer_event);
b->defer_event = NULL;
/* Increase ref counter */
inc_ref(b);
for (l = b->server->config.browse_domains; l; l = l->next) {
/* Check whether this object still exists outside our own
* stack frame */
if (b->ref <= 1)
break;
b->callback(b, AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC, AVAHI_BROWSER_NEW, (char*) l->text, AVAHI_LOOKUP_RESULT_STATIC, b->userdata);
}
if (b->ref > 1) {
/* If the ALL_FOR_NOW event has already been scheduled, execute it now */
if (b->all_for_now_scheduled)
b->callback(b, AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC, AVAHI_BROWSER_ALL_FOR_NOW, NULL, 0, b->userdata);
}
/* Decrease ref counter */
avahi_s_domain_browser_free(b);
}
static void defer_callback(AVAHI_GCC_UNUSED AvahiTimeEvent *e, void *userdata) {
AvahiSRecordBrowser *b = userdata;
int n = 0;
assert(b);
assert(!b->dead);
/* Remove the defer timeout */
if (b->defer_time_event) {
avahi_time_event_free(b->defer_time_event);
b->defer_time_event = NULL;
}
/* Create initial query */
assert(!b->root_lookup);
b->root_lookup = lookup_add(b, b->interface, b->protocol, b->flags, b->key);
assert(b->root_lookup);
n = lookup_go(b->root_lookup);
if (b->dead)
return;
if (n < 0) {
/* sending of the initial query failed */
avahi_server_set_errno(b->server, AVAHI_ERR_FAILURE);
b->callback(
b, b->interface, b->protocol, AVAHI_BROWSER_FAILURE, NULL,
b->flags & AVAHI_LOOKUP_USE_WIDE_AREA ? AVAHI_LOOKUP_RESULT_WIDE_AREA :
(b->flags & AVAHI_LOOKUP_RESULT_MULTICAST ? AVAHI_LOOKUP_RESULT_MULTICAST : AVAHI_LOOKUP_RESULT_LLMNR),
b->userdata);
browser_cancel(b);
return;
}
/* Tell the client that we're done with the cache */
b->callback(
b, b->interface, b->protocol, AVAHI_BROWSER_CACHE_EXHAUSTED, NULL,
b->flags & AVAHI_LOOKUP_USE_WIDE_AREA ? AVAHI_LOOKUP_RESULT_WIDE_AREA :
(b->flags & AVAHI_LOOKUP_RESULT_MULTICAST ? AVAHI_LOOKUP_RESULT_MULTICAST : AVAHI_LOOKUP_RESULT_LLMNR),
b->userdata);
if (!b->dead && b->root_lookup &&
(b->root_lookup->flags & AVAHI_LOOKUP_USE_WIDE_AREA) &&
n > 0 ) {
/* If we do wide area lookups and the the cache contained
* entries, we assume that it is complete, and tell the user
* so by firing ALL_FOR_NOW. */
b->callback(b, b->interface, b->protocol, AVAHI_BROWSER_ALL_FOR_NOW, NULL, AVAHI_LOOKUP_RESULT_LLMNR, b->userdata);
}
}
static void lookup_stop(AvahiWideAreaLookup *l) {
assert(l);
l->callback = NULL;
if (l->time_event) {
avahi_time_event_free(l->time_event);
l->time_event = NULL;
}
}
static void entry_group_register_time_event_callback(AVAHI_GCC_UNUSED AvahiTimeEvent *e, void* userdata) {
AvahiSEntryGroup *g = userdata;
assert(g);
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);
}
static void remove_announcer(AvahiServer *s, AvahiAnnouncer *a) {
assert(s);
assert(a);
if (a->time_event)
avahi_time_event_free(a->time_event);
AVAHI_LLIST_REMOVE(AvahiAnnouncer, by_interface, a->interface->announcers, a);
AVAHI_LLIST_REMOVE(AvahiAnnouncer, by_entry, a->entry->announcers, a);
avahi_free(a);
}
static void browser_cancel(AvahiSRecordBrowser *b) {
assert(b);
if (b->root_lookup) {
lookup_unref(b->root_lookup);
b->root_lookup = NULL;
}
if (b->defer_time_event) {
avahi_time_event_free(b->defer_time_event);
b->defer_time_event = NULL;
}
}
void avahi_entry_group_free(AvahiServer *s, AvahiSEntryGroup *g) {
assert(s);
assert(g);
while (g->entries)
avahi_entry_free(s, g->entries);
if (g->register_time_event)
avahi_time_event_free(g->register_time_event);
AVAHI_LLIST_REMOVE(AvahiSEntryGroup, groups, s->groups, g);
avahi_free(g);
}
static void job_free(AvahiProbeScheduler *s, AvahiProbeJob *pj) {
assert(pj);
if (pj->time_event)
avahi_time_event_free(pj->time_event);
if (pj->done)
AVAHI_LLIST_REMOVE(AvahiProbeJob, jobs, s->history, pj);
else
AVAHI_LLIST_REMOVE(AvahiProbeJob, jobs, s->jobs, pj);
avahi_record_unref(pj->record);
avahi_free(pj);
}
static void job_free(AvahiQueryScheduler *s, AvahiQueryJob *qj) {
assert(s);
assert(qj);
if (qj->time_event)
avahi_time_event_free(qj->time_event);
if (qj->done)
AVAHI_LLIST_REMOVE(AvahiQueryJob, jobs, s->history, qj);
else
AVAHI_LLIST_REMOVE(AvahiQueryJob, jobs, s->jobs, qj);
avahi_key_unref(qj->key);
avahi_free(qj);
}
static void set_timeout(AvahiAnnouncer *a, const struct timeval *tv) {
assert(a);
if (!tv) {
if (a->time_event) {
avahi_time_event_free(a->time_event);
a->time_event = NULL;
}
} else {
if (a->time_event)
avahi_time_event_update(a->time_event, tv);
else
a->time_event = avahi_time_event_new(a->server->time_event_queue, tv, elapse_announce, a);
}
}
static void job_free(AvahiResponseScheduler *s, AvahiResponseJob *rj) {
assert(s);
assert(rj);
if (rj->time_event)
avahi_time_event_free(rj->time_event);
if (rj->state == AVAHI_SCHEDULED)
AVAHI_LLIST_REMOVE(AvahiResponseJob, jobs, s->jobs, rj);
else if (rj->state == AVAHI_DONE)
AVAHI_LLIST_REMOVE(AvahiResponseJob, jobs, s->history, rj);
else /* rj->state == AVAHI_SUPPRESSED */
AVAHI_LLIST_REMOVE(AvahiResponseJob, jobs, s->suppressed, rj);
avahi_record_unref(rj->record);
avahi_free(rj);
}
void avahi_s_domain_browser_free(AvahiSDomainBrowser *b) {
assert(b);
assert(b->ref >= 1);
if (--b->ref > 0)
return;
AVAHI_LLIST_REMOVE(AvahiSDomainBrowser, browser, b->server->domain_browsers, b);
if (b->record_browser)
avahi_s_record_browser_free(b->record_browser);
if (b->defer_event)
avahi_time_event_free(b->defer_event);
avahi_free(b);
}
static void remove_announcer(AvahiServer *s, AvahiAnnouncer *a) {
AvahiEntry *e;
assert(s);
assert(a);
e = a->entry;
if (a->state == AVAHI_PROBING && e->group)
e->group->n_probing--;
if (a->time_event)
avahi_time_event_free(a->time_event);
AVAHI_LLIST_REMOVE(AvahiAnnouncer, by_interface, a->interface->announcers, a);
AVAHI_LLIST_REMOVE(AvahiAnnouncer, by_entry, a->entry->announcers, a);
avahi_free(a);
}
void avahi_s_address_resolver_free(AvahiSAddressResolver *r) {
assert(r);
AVAHI_LLIST_REMOVE(AvahiSAddressResolver, resolver, r->server->address_resolvers, r);
if (r->record_browser)
avahi_s_record_browser_free(r->record_browser);
if (r->time_event)
avahi_time_event_free(r->time_event);
if (r->ptr_record)
avahi_record_unref(r->ptr_record);
if (r->key)
avahi_key_unref(r->key);
avahi_free(r);
}
static void finish(AvahiSAddressResolver *r, AvahiResolverEvent event) {
assert(r);
if (r->time_event) {
avahi_time_event_free(r->time_event);
r->time_event = NULL;
}
switch (event) {
case AVAHI_RESOLVER_FAILURE:
r->callback(r, r->interface, r->protocol, event, &r->address, NULL, r->flags, r->userdata);
break;
case AVAHI_RESOLVER_FOUND:
assert(r->ptr_record);
r->callback(r, r->interface, r->protocol, event, &r->address, r->ptr_record->data.ptr.name, r->flags, r->userdata);
break;
}
}
void avahi_llmnr_query_job_destroy(AvahiLLMNRQueryScheduler *s, AvahiLLMNRQueryJob *qj) {
assert(s);
assert(qj);
/* Free lq */
avahi_llmnr_query_destroy(qj->lq);
/* Free dns packet and time_event */
if (qj->p)
avahi_dns_packet_free(qj->p);
if(qj->time_event)
avahi_time_event_free(qj->time_event);
/* Remove from the lists */
AVAHI_LLIST_REMOVE(AvahiLLMNRQueryJob, jobs_by_scheduler, s->jobs, qj);
AVAHI_LLIST_REMOVE(AvahiLLMNRQueryJob, jobs_by_interface, s->i->llmnr.queryjobs, qj);
avahi_free(qj);
}
static void cache_entry_free(AvahiWideAreaCacheEntry *c) {
AvahiWideAreaCacheEntry *t;
assert(c);
if (c->time_event)
avahi_time_event_free(c->time_event);
AVAHI_LLIST_REMOVE(AvahiWideAreaCacheEntry, cache, c->engine->cache, c);
t = avahi_hashmap_lookup(c->engine->cache_by_key, c->record->key);
AVAHI_LLIST_REMOVE(AvahiWideAreaCacheEntry, by_key, t, c);
if (t)
avahi_hashmap_replace(c->engine->cache_by_key, avahi_key_ref(c->record->key), t);
else
avahi_hashmap_remove(c->engine->cache_by_key, c->record->key);
c->engine->cache_n_entries --;
avahi_record_unref(c->record);
avahi_free(c);
}
void avahi_s_entry_group_free(AvahiSEntryGroup *g) {
AvahiEntry *e;
assert(g);
assert(g->server);
for (e = g->entries; e; e = e->by_group_next) {
if (!e->dead) {
avahi_goodbye_entry(g->server, e, 1, 1);
e->dead = 1;
}
}
if (g->register_time_event) {
avahi_time_event_free(g->register_time_event);
g->register_time_event = NULL;
}
g->dead = 1;
g->server->need_group_cleanup = 1;
g->server->need_entry_cleanup = 1;
}
static void finish(AvahiSServiceResolver *r, AvahiResolverEvent event) {
AvahiLookupResultFlags flags;
assert(r);
if (r->time_event) {
avahi_time_event_free(r->time_event);
r->time_event = NULL;
}
flags =
r->txt_flags |
r->srv_flags |
r->address_flags;
switch (event) {
case AVAHI_RESOLVER_FAILURE:
r->callback(
r,
r->interface,
r->protocol,
event,
r->service_name,
r->service_type,
r->domain_name,
NULL,
NULL,
0,
NULL,
flags,
r->userdata);
break;
case AVAHI_RESOLVER_FOUND: {
AvahiAddress a;
assert(event == AVAHI_RESOLVER_FOUND);
assert(r->srv_record);
if (r->address_record) {
switch (r->address_record->key->type) {
case AVAHI_DNS_TYPE_A:
a.proto = AVAHI_PROTO_INET;
a.data.ipv4 = r->address_record->data.a.address;
break;
case AVAHI_DNS_TYPE_AAAA:
a.proto = AVAHI_PROTO_INET6;
a.data.ipv6 = r->address_record->data.aaaa.address;
break;
default:
assert(0);
}
}
r->callback(
r,
r->interface,
r->protocol,
event,
r->service_name,
r->service_type,
r->domain_name,
r->srv_record->data.srv.name,
r->address_record ? &a : NULL,
r->srv_record->data.srv.port,
r->txt_record ? r->txt_record->data.txt.string_list : NULL,
flags,
r->userdata);
break;
}
}
}
