static void lookup_destroy(AvahiWideAreaLookup *l) {
AvahiWideAreaLookup *t;
assert(l);
lookup_stop(l);
t = avahi_hashmap_lookup(l->engine->lookups_by_key, l->key);
AVAHI_LLIST_REMOVE(AvahiWideAreaLookup, by_key, t, l);
if (t)
avahi_hashmap_replace(l->engine->lookups_by_key, avahi_key_ref(l->key), t);
else
avahi_hashmap_remove(l->engine->lookups_by_key, l->key);
AVAHI_LLIST_REMOVE(AvahiWideAreaLookup, lookups, l->engine->lookups, l);
avahi_hashmap_remove(l->engine->lookups_by_id, &l->id);
avahi_dns_packet_free(l->packet);
if (l->key)
avahi_key_unref(l->key);
if (l->cname_key)
avahi_key_unref(l->cname_key);
avahi_free(l);
}
void avahi_entry_free(AvahiServer*s, AvahiEntry *e) {
AvahiEntry *t;
assert(s);
assert(e);
avahi_goodbye_entry(s, e, 1, 1);
/* Remove from linked list */
AVAHI_LLIST_REMOVE(AvahiEntry, entries, s->entries, e);
/* Remove from hash table indexed by name */
t = avahi_hashmap_lookup(s->entries_by_key, e->record->key);
AVAHI_LLIST_REMOVE(AvahiEntry, by_key, t, e);
if (t)
avahi_hashmap_replace(s->entries_by_key, t->record->key, t);
else
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);
avahi_free(e);
}
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);
}
static void add_to_cache(AvahiWideAreaLookupEngine *e, AvahiRecord *r) {
AvahiWideAreaCacheEntry *c;
int is_new;
assert(e);
assert(r);
if ((c = find_record_in_cache(e, r))) {
is_new = 0;
/* Update the existing entry */
avahi_record_unref(c->record);
} else {
AvahiWideAreaCacheEntry *t;
is_new = 1;
/* Enforce cache size */
if (e->cache_n_entries >= CACHE_ENTRIES_MAX)
/* Eventually we should improve the caching algorithm here */
goto finish;
c = avahi_new(AvahiWideAreaCacheEntry, 1);
c->engine = e;
c->time_event = NULL;
AVAHI_LLIST_PREPEND(AvahiWideAreaCacheEntry, cache, e->cache, c);
/* Add the new entry to the cache entry hash table */
t = avahi_hashmap_lookup(e->cache_by_key, r->key);
AVAHI_LLIST_PREPEND(AvahiWideAreaCacheEntry, by_key, t, c);
avahi_hashmap_replace(e->cache_by_key, avahi_key_ref(r->key), t);
e->cache_n_entries ++;
}
c->record = avahi_record_ref(r);
gettimeofday(&c->timestamp, NULL);
c->expiry = c->timestamp;
avahi_timeval_add(&c->expiry, r->ttl * 1000000);
if (c->time_event)
avahi_time_event_update(c->time_event, &c->expiry);
else
c->time_event = avahi_time_event_new(e->server->time_event_queue, &c->expiry, expiry_event, c);
finish:
if (is_new)
run_callbacks(e, r);
}
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);
}
AvahiWideAreaLookup *avahi_wide_area_lookup_new(
AvahiWideAreaLookupEngine *e,
AvahiKey *key,
AvahiWideAreaLookupCallback callback,
void *userdata) {
struct timeval tv;
AvahiWideAreaLookup *l, *t;
uint8_t *p;
assert(e);
assert(key);
assert(callback);
assert(userdata);
l = avahi_new(AvahiWideAreaLookup, 1);
l->engine = e;
l->dead = 0;
l->key = avahi_key_ref(key);
l->cname_key = avahi_key_new_cname(l->key);
l->callback = callback;
l->userdata = userdata;
/* If more than 65K wide area quries are issued simultaneously,
* this will break. This should be limited by some higher level */
for (;; e->next_id++)
if (!find_lookup(e, e->next_id))
break; /* This ID is not yet used. */
l->id = e->next_id++;
/* We keep the packet around in case we need to repeat our query */
l->packet = avahi_dns_packet_new(0);
avahi_dns_packet_set_field(l->packet, AVAHI_DNS_FIELD_ID, (uint16_t) l->id);
avahi_dns_packet_set_field(l->packet, AVAHI_DNS_FIELD_FLAGS, AVAHI_DNS_FLAGS(0, 0, 0, 0, 1, 0, 0, 0, 0, 0));
p = avahi_dns_packet_append_key(l->packet, key, 0);
assert(p);
avahi_dns_packet_set_field(l->packet, AVAHI_DNS_FIELD_QDCOUNT, 1);
if (send_to_dns_server(l, l->packet) < 0) {
avahi_log_error(__FILE__": Failed to send packet.");
avahi_dns_packet_free(l->packet);
avahi_key_unref(l->key);
if (l->cname_key)
avahi_key_unref(l->cname_key);
avahi_free(l);
return NULL;
}
l->n_send = 1;
l->time_event = avahi_time_event_new(e->server->time_event_queue, avahi_elapse_time(&tv, 500, 0), sender_timeout_callback, l);
avahi_hashmap_insert(e->lookups_by_id, &l->id, l);
t = avahi_hashmap_lookup(e->lookups_by_key, l->key);
AVAHI_LLIST_PREPEND(AvahiWideAreaLookup, by_key, t, l);
avahi_hashmap_replace(e->lookups_by_key, avahi_key_ref(l->key), t);
AVAHI_LLIST_PREPEND(AvahiWideAreaLookup, lookups, e->lookups, l);
return l;
}
static AvahiEntry * server_add_internal(
AvahiServer *s,
AvahiSEntryGroup *g,
AvahiIfIndex interface,
AvahiProtocol protocol,
AvahiPublishFlags flags,
AvahiRecord *r) {
AvahiEntry *e;
assert(s);
assert(r);
AVAHI_CHECK_VALIDITY_RETURN_NULL(s, s->state != AVAHI_SERVER_FAILURE && s->state != AVAHI_SERVER_INVALID, AVAHI_ERR_BAD_STATE);
AVAHI_CHECK_VALIDITY_RETURN_NULL(s, AVAHI_IF_VALID(interface), AVAHI_ERR_INVALID_INTERFACE);
AVAHI_CHECK_VALIDITY_RETURN_NULL(s, AVAHI_PROTO_VALID(protocol), AVAHI_ERR_INVALID_PROTOCOL);
AVAHI_CHECK_VALIDITY_RETURN_NULL(s, AVAHI_FLAGS_VALID(
flags,
AVAHI_PUBLISH_NO_ANNOUNCE|
AVAHI_PUBLISH_NO_PROBE|
AVAHI_PUBLISH_UNIQUE|
AVAHI_PUBLISH_ALLOW_MULTIPLE|
AVAHI_PUBLISH_UPDATE|
AVAHI_PUBLISH_USE_WIDE_AREA|
AVAHI_PUBLISH_USE_MULTICAST), AVAHI_ERR_INVALID_FLAGS);
AVAHI_CHECK_VALIDITY_RETURN_NULL(s, avahi_is_valid_domain_name(r->key->name), AVAHI_ERR_INVALID_HOST_NAME);
AVAHI_CHECK_VALIDITY_RETURN_NULL(s, r->ttl != 0, AVAHI_ERR_INVALID_TTL);
AVAHI_CHECK_VALIDITY_RETURN_NULL(s, !avahi_key_is_pattern(r->key), AVAHI_ERR_IS_PATTERN);
AVAHI_CHECK_VALIDITY_RETURN_NULL(s, avahi_record_is_valid(r), AVAHI_ERR_INVALID_RECORD);
AVAHI_CHECK_VALIDITY_RETURN_NULL(s, r->key->clazz == AVAHI_DNS_CLASS_IN, AVAHI_ERR_INVALID_DNS_CLASS);
AVAHI_CHECK_VALIDITY_RETURN_NULL(s,
(r->key->type != 0) &&
(r->key->type != AVAHI_DNS_TYPE_ANY) &&
(r->key->type != AVAHI_DNS_TYPE_OPT) &&
(r->key->type != AVAHI_DNS_TYPE_TKEY) &&
(r->key->type != AVAHI_DNS_TYPE_TSIG) &&
(r->key->type != AVAHI_DNS_TYPE_IXFR) &&
(r->key->type != AVAHI_DNS_TYPE_AXFR), AVAHI_ERR_INVALID_DNS_TYPE);
transport_flags_from_domain(s, &flags, r->key->name);
AVAHI_CHECK_VALIDITY_RETURN_NULL(s, flags & AVAHI_PUBLISH_USE_MULTICAST, AVAHI_ERR_NOT_SUPPORTED);
AVAHI_CHECK_VALIDITY_RETURN_NULL(s, !s->config.disable_publishing, AVAHI_ERR_NOT_PERMITTED);
AVAHI_CHECK_VALIDITY_RETURN_NULL(s,
!g ||
(g->state != AVAHI_ENTRY_GROUP_ESTABLISHED && g->state != AVAHI_ENTRY_GROUP_REGISTERING) ||
(flags & AVAHI_PUBLISH_UPDATE), AVAHI_ERR_BAD_STATE);
if (flags & AVAHI_PUBLISH_UPDATE) {
AvahiRecord *old_record;
int is_first = 1;
/* Update and existing record */
/* Find the first matching entry */
for (e = avahi_hashmap_lookup(s->entries_by_key, r->key); e; e = e->by_key_next) {
if (!e->dead && e->group == g && e->interface == interface && e->protocol == protocol)
break;
is_first = 0;
}
/* Hmm, nothing found? */
if (!e) {
avahi_server_set_errno(s, AVAHI_ERR_NOT_FOUND);
return NULL;
}
/* Update the entry */
old_record = e->record;
e->record = avahi_record_ref(r);
e->flags = flags;
/* Announce our changes when needed */
if (!avahi_record_equal_no_ttl(old_record, r) && (!g || g->state != AVAHI_ENTRY_GROUP_UNCOMMITED)) {
/* Remove the old entry from all caches, if needed */
if (!(e->flags & AVAHI_PUBLISH_UNIQUE))
avahi_goodbye_entry(s, e, 1, 0);
/* Reannounce our updated entry */
avahi_reannounce_entry(s, e);
}
/* If we were the first entry in the list, we need to update the key */
if (is_first)
avahi_hashmap_replace(s->entries_by_key, e->record->key, e);
avahi_record_unref(old_record);
} else {
AvahiEntry *t;
/* Add a new record */
if (check_record_conflict(s, interface, protocol, r, flags) < 0) {
avahi_server_set_errno(s, AVAHI_ERR_COLLISION);
return NULL;
}
if (!(e = avahi_new(AvahiEntry, 1))) {
avahi_server_set_errno(s, AVAHI_ERR_NO_MEMORY);
return NULL;
}
e->server = s;
e->record = avahi_record_ref(r);
e->group = g;
e->interface = interface;
e->protocol = protocol;
e->flags = flags;
e->dead = 0;
AVAHI_LLIST_HEAD_INIT(AvahiAnnouncer, e->announcers);
AVAHI_LLIST_PREPEND(AvahiEntry, entries, s->entries, e);
/* Insert into hash table indexed by name */
t = avahi_hashmap_lookup(s->entries_by_key, e->record->key);
AVAHI_LLIST_PREPEND(AvahiEntry, by_key, t, e);
avahi_hashmap_replace(s->entries_by_key, e->record->key, t);
/* Insert into group list */
if (g)
AVAHI_LLIST_PREPEND(AvahiEntry, by_group, g->entries, e);
avahi_announce_entry(s, e);
}
return e;
}
void avahi_cache_update(AvahiCache *c, AvahiRecord *r, int cache_flush, const AvahiAddress *a) {
/* char *txt; */
assert(c);
assert(r && r->ref >= 1);
/* txt = avahi_record_to_string(r); */
if (r->ttl == 0) {
/* This is a goodbye request */
AvahiCacheEntry *e;
if ((e = lookup_record(c, r)))
expire_in_one_second(c, e, AVAHI_CACHE_GOODBYE_FINAL);
} else {
AvahiCacheEntry *e = NULL, *first;
struct timeval now;
gettimeofday(&now, NULL);
/* This is an update request */
if ((first = lookup_key(c, r->key))) {
if (cache_flush) {
/* For unique entries drop all entries older than one second */
for (e = first; e; e = e->by_key_next) {
AvahiUsec t;
t = avahi_timeval_diff(&now, &e->timestamp);
if (t > 1000000)
expire_in_one_second(c, e, AVAHI_CACHE_REPLACE_FINAL);
}
}
/* Look for exactly the same entry */
for (e = first; e; e = e->by_key_next)
if (avahi_record_equal_no_ttl(e->record, r))
break;
}
if (e) {
/* avahi_log_debug("found matching cache entry"); */
/* We need to update the hash table key if we replace the
* record */
if (e->by_key_prev == NULL)
avahi_hashmap_replace(c->hashmap, r->key, e);
/* Update the record */
avahi_record_unref(e->record);
e->record = avahi_record_ref(r);
/* avahi_log_debug("cache: updating %s", txt); */
} else {
/* No entry found, therefore we create a new one */
/* avahi_log_debug("cache: couldn't find matching cache entry for %s", txt); */
if (c->n_entries >= AVAHI_CACHE_ENTRIES_MAX)
return;
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);
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_multicast_lookup_engine_notify(c->server->mdns.multicast_lookup_engine, c->interface, e->record, AVAHI_BROWSER_NEW);
}
e->origin = *a;
e->timestamp = now;
next_expiry(c, e, 80);
e->state = AVAHI_CACHE_VALID;
e->cache_flush = cache_flush;
}
/* avahi_free(txt); */
}
