AvahiNetlink *avahi_netlink_new(const 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 = NULL;
assert(poll_api);
assert(cb);
if ((fd = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_ROUTE)) < 0) {
avahi_log_error(__FILE__": socket(PF_NETLINK): %s", strerror(errno));
return NULL;
}
memset(&addr, 0, sizeof(addr));
addr.nl_family = AF_NETLINK;
addr.nl_groups = groups;
addr.nl_pid = getpid();
if (bind(fd, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
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->poll_api = poll_api;
nl->fd = fd;
nl->seq = 0;
nl->callback = cb;
nl->userdata = userdata;
if (!(nl->buffer = avahi_new(uint8_t, nl->buffer_length = 64*1024))) {
avahi_log_error(__FILE__": avahi_new() failed.");
goto fail;
}
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) {
avahi_free(nl->buffer);
avahi_free(nl);
}
return NULL;
}
void DNSSD_API TXTRecordCreate(
TXTRecordRef *txtref,
uint16_t length,
void *buffer) {
TXTRecordInternal *t;
AVAHI_WARN_LINKAGE;
assert(txtref);
/* Apple's API design is flawed in so many ways, including the
* fact that it isn't compatible with 64 bit processors. To work
* around this we need some magic here which involves allocating
* our own memory. Please, Apple, do your homework next time
* before designing an API! */
if ((t = avahi_new(TXTRecordInternal, 1))) {
t->buffer = buffer;
t->max_size = buffer ? length : (size_t)0;
t->size = 0;
t->malloc_buffer = NULL;
}
/* If we were unable to allocate memory, we store a NULL pointer
* and return a NoMemory error later, is somewhat unclean, but
* should work. */
INTERNAL_PTR(txtref) = t;
}
static AvahiLLMNRQueryJob *job_new(AvahiLLMNRQueryScheduler *s, AvahiLLMNRQuery *lq) {
AvahiLLMNRQueryJob *qj;
assert(s);
assert(lq);
if(!(qj = avahi_new(AvahiLLMNRQueryJob, 1)))
return NULL;
qj->scheduler = s;
qj->lq = lq;
/* Set lq parameters */
lq->post_id_valid = 1;
lq->post_id = s->next_id++;
/* qj parameters */
qj->n_sent = 0;
qj->prev_scheduled = 0;
qj->time_event = NULL;
/* Prepend in Lists */
AVAHI_LLIST_PREPEND(AvahiLLMNRQueryJob, jobs_by_scheduler, s->jobs, qj);
AVAHI_LLIST_PREPEND(AvahiLLMNRQueryJob, jobs_by_interface, s->i->llmnr.queryjobs, qj);
/*Just prepare dns packet, don't send it */
avahi_prepare_llmnr_query_job_packet(qj);
return qj;
}
static dbus_bool_t add_timeout(DBusTimeout *dbus_timeout, void *userdata) {
TimeoutData *timeout;
ConnectionData *d = userdata;
struct timeval tv;
dbus_bool_t b;
assert(dbus_timeout);
assert(d);
if (!(timeout = avahi_new(TimeoutData, 1)))
return FALSE;
timeout->dbus_timeout = dbus_timeout;
timeout->poll_api = d->poll_api;
timeout->ref = 1;
if ((b = dbus_timeout_get_enabled(dbus_timeout)))
avahi_elapse_time(&tv, dbus_timeout_get_interval(dbus_timeout), 0);
if (!(timeout->avahi_timeout = d->poll_api->timeout_new(
d->poll_api,
b ? &tv : NULL,
timeout_callback,
timeout))) {
avahi_free(timeout);
return FALSE;
}
dbus_timeout_set_data(dbus_timeout, timeout, (DBusFreeFunction) timeout_data_unref);
return TRUE;
}
static ServiceInfo *add_service(Config *c, AvahiIfIndex interface, AvahiProtocol protocol, const char *name, const char *type, const char *domain) {
ServiceInfo *i;
i = avahi_new(ServiceInfo, 1);
if (c->resolve) {
if (!(i->resolver = avahi_service_resolver_new(client, interface, protocol, name, type, domain, AVAHI_PROTO_UNSPEC, 0, service_resolver_callback, i))) {
avahi_free(i);
fprintf(stderr, ("Failed to resolve service '%s' of type '%s' in domain '%s': %s\n"), name, type, domain, avahi_strerror(avahi_client_errno(client)));
return NULL;
}
n_resolving++;
} else
i->resolver = NULL;
i->interface = interface;
i->protocol = protocol;
i->name = avahi_strdup(name);
i->type = avahi_strdup(type);
i->domain = avahi_strdup(domain);
i->config = c;
AVAHI_LLIST_PREPEND(ServiceInfo, info, services, i);
return i;
}
AvahiCache *avahi_cache_new(AvahiServer *server, AvahiInterface *iface) {
AvahiCache *c;
assert(server);
if (!(c = avahi_new(AvahiCache, 1))) {
avahi_log_error(__FILE__": Out of memory.");
return NULL; /* OOM */
}
c->server = server;
c->interface = iface;
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;
c->last_rand_timestamp = 0;
return c;
}
static void new_verifier(AvahiServer *s, AvahiInterface *i, AvahiEntry *e) {
AvahiLLMNREntryVerify *ev;
assert(s);
assert(i);
assert(e);
assert(!e->dead);
assert(e->type == AVAHI_ENTRY_LLMNR);
if( !avahi_interface_match (i, e->interface, e->protocol) ||
!i->llmnr.verifying ||
!avahi_entry_is_commited(e) )
/* start verifying rr's only when group has been commited */
return;
if(get_verifier(s, i, e))
return;
if(!(ev = avahi_new(AvahiLLMNREntryVerify, 1)))
return;
ev->s= s;
ev->interface = i;
ev->e = e;
ev->lq = NULL;
AVAHI_LLIST_PREPEND(AvahiLLMNREntryVerify, by_interface, i->llmnr.verifiers, ev);
AVAHI_LLIST_PREPEND(AvahiLLMNREntryVerify, by_entry, e->proto.llmnr.verifiers, ev);
set_state(ev);
}
static AvahiWatch* watch_new(const 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;
/* If there is a background thread running the poll() for us, tell it to exit the poll() */
avahi_simple_poll_wakeup(s);
w->simple_poll = s;
w->dead = 0;
w->pollfd.fd = fd;
w->pollfd.events = event;
w->pollfd.revents = 0;
w->callback = callback;
w->userdata = userdata;
w->idx = -1;
s->rebuild_pollfds = 1;
AVAHI_LLIST_PREPEND(AvahiWatch, watches, s->watches, w);
s->n_watches++;
return w;
}
int avahi_hashmap_replace(AvahiHashmap *m, void *key, void *value) {
unsigned idx;
Entry *e;
assert(m);
if ((e = entry_get(m, key))) {
if (m->key_free_func)
m->key_free_func(e->key);
if (m->value_free_func)
m->value_free_func(e->value);
e->key = key;
e->value = value;
return 1;
}
if (!(e = avahi_new(Entry, 1)))
return -1;
e->hashmap = m;
e->key = key;
e->value = value;
AVAHI_LLIST_PREPEND(Entry, entries, m->entries_list, e);
idx = m->hash_func(key) % HASH_MAP_SIZE;
AVAHI_LLIST_PREPEND(Entry, bucket, m->entries[idx], e);
return 0;
}
static AvahiTimeout* timeout_new(const AvahiPoll *api, const struct timeval *tv, AvahiTimeoutCallback callback, void *userdata) {
AvahiTimeout *t;
AvahiSimplePoll *s;
assert(api);
assert(callback);
s = api->userdata;
assert(s);
if (!(t = avahi_new(AvahiTimeout, 1)))
return NULL;
/* If there is a background thread running the poll() for us, tell it to exit the poll() */
avahi_simple_poll_wakeup(s);
t->simple_poll = s;
t->dead = 0;
if ((t->enabled = !!tv))
t->expiry = *tv;
t->callback = callback;
t->userdata = userdata;
AVAHI_LLIST_PREPEND(AvahiTimeout, timeouts, s->timeouts, t);
return t;
}
AvahiSEntryGroup *avahi_s_entry_group_new(AvahiServer *s, AvahiSEntryGroupCallback callback, void* userdata) {
AvahiSEntryGroup *g;
assert(s);
if (!(g = avahi_new(AvahiSEntryGroup, 1))) {
avahi_server_set_errno(s, AVAHI_ERR_NO_MEMORY);
return NULL;
}
g->server = s;
g->callback = callback;
g->userdata = userdata;
g->dead = 0;
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(AvahiSEntryGroup, groups, s->groups, g);
return g;
}
static void new_announcer(AvahiServer *s, AvahiInterface *i, AvahiEntry *e) {
AvahiAnnouncer *a;
assert(s);
assert(i);
assert(e);
assert(!e->dead);
if (!avahi_interface_match(i, e->interface, e->protocol) || !i->announcing || !avahi_entry_is_commited(e))
return;
/* We don't want duplicate announcers */
if (get_announcer(s, e, i))
return;
if ((!(a = avahi_new(AvahiAnnouncer, 1)))) {
avahi_log_error(__FILE__": Out of memory.");
return;
}
a->server = s;
a->interface = i;
a->entry = e;
a->time_event = NULL;
AVAHI_LLIST_PREPEND(AvahiAnnouncer, by_interface, i->announcers, a);
AVAHI_LLIST_PREPEND(AvahiAnnouncer, by_entry, e->announcers, a);
go_to_initial_state(a);
}
static AvahiResponseJob* job_new(AvahiResponseScheduler *s, AvahiRecord *record, AvahiResponseJobState state) {
AvahiResponseJob *rj;
assert(s);
assert(record);
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 = 0;
rj->querier_valid = 0;
if ((rj->state = state) == AVAHI_SCHEDULED)
AVAHI_LLIST_PREPEND(AvahiResponseJob, jobs, s->jobs, rj);
else if (rj->state == AVAHI_DONE)
AVAHI_LLIST_PREPEND(AvahiResponseJob, jobs, s->history, rj);
else /* rj->state == AVAHI_SUPPRESSED */
AVAHI_LLIST_PREPEND(AvahiResponseJob, jobs, s->suppressed, rj);
return rj;
}
static AvahiTimeout* timeout_new(const AvahiPoll *api, const struct timeval *tv, AvahiTimeoutCallback callback, void *userdata) {
AvahiTimeout *t;
AvahiGLibPoll *g;
assert(api);
assert(callback);
g = api->userdata;
assert(g);
if (!(t = avahi_new(AvahiTimeout, 1)))
return NULL;
t->glib_poll = g;
t->dead = FALSE;
if ((t->enabled = !!tv))
t->expiry = *tv;
t->callback = callback;
t->userdata = userdata;
AVAHI_LLIST_PREPEND(AvahiTimeout, timeouts, g->timeouts, t);
return t;
}
static AvahiWatch* watch_new(const AvahiPoll *api, int fd, AvahiWatchEvent events, 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 = map_events_to_glib(events);
w->pollfd.revents = 0;
w->callback = callback;
w->userdata = userdata;
w->dead = FALSE;
g_source_add_poll(&g->source, &w->pollfd);
w->pollfd_added = TRUE;
AVAHI_LLIST_PREPEND(AvahiWatch, watches, g->watches, w);
return w;
}
AvahiLLMNRQuery* avahi_llmnr_query_add(AvahiInterface *i, AvahiKey *key, AvahiLLMNRQueryType type, AvahiLLMNRQueryCallback callback, void *userdata) {
AvahiLLMNRQuery *lq;
int c;
/* Engine maintains a hashmap of 'AvahiLLMNRQuery' objects by id */
AvahiLLMNRLookupEngine *e = i->monitor->server->llmnr.llmnr_lookup_engine;
assert(i);
assert(key);
assert(callback);
if(!(lq = avahi_new(AvahiLLMNRQuery, 1)))
return NULL;
/* Initialize parameters */
lq->dead = 0;
lq->key = avahi_key_ref(key);
lq->type = type;
lq->interface = i;
lq->callback = callback;
lq->post_id_valid = 0;
lq->post_id = 0;
lq->userdata = userdata;
/* Initialize record lists for this query object */
lq->c_bit_set = avahi_record_list_new();
lq->c_bit_clear = avahi_record_list_new();
c = avahi_record_list_is_empty(lq->c_bit_set);
assert(c);
assert(lq->c_bit_clear);
/* Set ID */
/* KEEP IT 32 BIT for HASHMAP */
for (;; e->next_id++)
if(!(find_query(e, e->next_id)))
break;
lq->id = e->next_id++;
/* AvahiLLMNRLookupEngine hashmap of queries by ID,
'engine-AvahiLLMNRQuery'. (lq->id and lq) */
avahi_hashmap_insert(e->queries_by_id, &(lq->id), lq);
/* Schedule this LLMNR query. This will create an
'AvahiLLMNRQueryJob' for this query and will issue
further queries there only. im0 */
if(!avahi_interface_post_llmnr_query(i, lq, 0))
return NULL;
return lq;
}
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 StaticHost *static_host_new(void) {
StaticHost *s;
s = avahi_new(StaticHost, 1);
s->group = NULL;
s->host = NULL;
s->ip = NULL;
AVAHI_LLIST_PREPEND(StaticHost, hosts, hosts, s);
return s;
}
static DNSServerInfo* new_server_info(AvahiIfIndex interface, AvahiProtocol protocol, const char *address) {
DNSServerInfo *i;
assert(address);
i = avahi_new(DNSServerInfo, 1);
i->interface = interface;
i->protocol = protocol;
i->address = avahi_strdup(address);
AVAHI_LLIST_PREPEND(DNSServerInfo, servers, servers, i);
return i;
}
AvahiWideAreaLookupEngine *avahi_wide_area_engine_new(AvahiServer *s) {
AvahiWideAreaLookupEngine *e;
assert(s);
e = avahi_new(AvahiWideAreaLookupEngine, 1);
e->server = s;
e->cleanup_dead = 0;
/* Create sockets */
e->fd_ipv4 = s->config.use_ipv4 ? avahi_open_unicast_socket_ipv4() : -1;
e->fd_ipv6 = s->config.use_ipv6 ? avahi_open_unicast_socket_ipv6() : -1;
if (e->fd_ipv4 < 0 && e->fd_ipv6 < 0) {
avahi_log_error(__FILE__": Failed to create wide area sockets: %s", strerror(errno));
if (e->fd_ipv6 >= 0)
close(e->fd_ipv6);
if (e->fd_ipv4 >= 0)
close(e->fd_ipv4);
avahi_free(e);
return NULL;
}
/* Create watches */
e->watch_ipv4 = e->watch_ipv6 = NULL;
if (e->fd_ipv4 >= 0)
e->watch_ipv4 = s->poll_api->watch_new(e->server->poll_api, e->fd_ipv4, AVAHI_WATCH_IN, socket_event, e);
if (e->fd_ipv6 >= 0)
e->watch_ipv6 = s->poll_api->watch_new(e->server->poll_api, e->fd_ipv6, AVAHI_WATCH_IN, socket_event, e);
e->n_dns_servers = e->current_dns_server = 0;
e->next_id = (uint16_t) rand();
/* Initialize cache */
AVAHI_LLIST_HEAD_INIT(AvahiWideAreaCacheEntry, e->cache);
e->cache_by_key = avahi_hashmap_new((AvahiHashFunc) avahi_key_hash, (AvahiEqualFunc) avahi_key_equal, (AvahiFreeFunc) avahi_key_unref, NULL);
e->cache_n_entries = 0;
/* Initialize lookup list */
e->lookups_by_id = avahi_hashmap_new((AvahiHashFunc) avahi_int_hash, (AvahiEqualFunc) avahi_int_equal, NULL, NULL);
e->lookups_by_key = avahi_hashmap_new((AvahiHashFunc) avahi_key_hash, (AvahiEqualFunc) avahi_key_equal, (AvahiFreeFunc) avahi_key_unref, NULL);
AVAHI_LLIST_HEAD_INIT(AvahiWideAreaLookup, e->lookups);
return e;
}
static void avahi_reverify(AvahiLLMNREntryVerify *ev) {
AvahiEntry *e;
AvahiVerifierData *vdata;
assert(ev);
if (!(vdata = avahi_new(AvahiVerifierData, 1)))
return;
e = ev->e;
if (e->group)
assert(e->group->type == AVAHI_GROUP_LLMNR);
/* Group has not been commited yet, nothing to reverify*/
if(e->group && (e->group->state = AVAHI_ENTRY_GROUP_LLMNR_UNCOMMITED || e->group->state == AVAHI_ENTRY_GROUP_LLMNR_COLLISION))
return;
/* STATE == AVAHI_VERIFYING : Free the lq object and if entry belongs to
a group decrease the n_verifying counter. NEW STATE : _VERIFYING*/
if (ev->state == AVAHI_VERIFYING) {
if (e->group)
e->group->proto.llmnr.n_verifying--;
} else if ((ev->state == AVAHI_ESTABLISHED) && (e->flags & AVAHI_PUBLISH_UNIQUE) && !(e->flags & AVAHI_PUBLISH_NO_VERIFY))
/* _ESTABLISHED but _VERIFY again*/
ev->state = AVAHI_VERIFYING;
else
ev->state = AVAHI_ESTABLISHED;
/* New state has been decided */
if(ev->state == AVAHI_VERIFYING) {
vdata->ev = ev;
vdata->address = NULL;
vdata->t_bit = 0;
/* Start the queries */
avahi_llmnr_query_add(ev->interface, e->record->key, AVAHI_LLMNR_UNIQUENESS_VERIFICATION_QUERY, query_callback, vdata);
/* Increase the counter if it belongs to a group */
if(e->group)
e->group->proto.llmnr.n_verifying++;
} else
if (e->group)
check_established(e->group);
}
AvahiLLMNRQueryScheduler *avahi_llmnr_query_scheduler_new(AvahiInterface *i) {
AvahiLLMNRQueryScheduler *s;
assert(i);
if(!(s = avahi_new(AvahiLLMNRQueryScheduler, 1)))
return NULL;
s->i = i;
s->time_event_queue = i->monitor->server->time_event_queue;
s->next_id = 1;
AVAHI_LLIST_HEAD_INIT(AvahiLLMNRQueryJob, s->jobs);
return s;
}
AvahiSimplePoll *avahi_simple_poll_new(void) {
AvahiSimplePoll *s;
if (!(s = avahi_new(AvahiSimplePoll, 1)))
return NULL;
if (pipe(s->wakeup_pipe) < 0) {
avahi_free(s);
return NULL;
}
set_nonblock(s->wakeup_pipe[0]);
set_nonblock(s->wakeup_pipe[1]);
s->api.userdata = s;
s->api.watch_new = watch_new;
s->api.watch_free = watch_free;
s->api.watch_update = watch_update;
s->api.watch_get_events = watch_get_events;
s->api.timeout_new = timeout_new;
s->api.timeout_free = timeout_free;
s->api.timeout_update = timeout_update;
s->pollfds = NULL;
s->max_pollfds = s->n_pollfds = 0;
s->rebuild_pollfds = 1;
s->quit = 0;
s->n_watches = 0;
s->events_valid = 0;
s->watch_req_cleanup = 0;
s->timeout_req_cleanup = 0;
s->prepared_timeout = 0;
s->state = STATE_INIT;
s->wakeup_issued = 0;
avahi_simple_poll_set_func(s, NULL, NULL);
AVAHI_LLIST_HEAD_INIT(AvahiWatch, s->watches);
AVAHI_LLIST_HEAD_INIT(AvahiTimeout, s->timeouts);
return s;
}
static StaticServiceGroup *static_service_group_new(char *filename) {
StaticServiceGroup *g;
assert(filename);
g = avahi_new(StaticServiceGroup, 1);
g->filename = avahi_strdup(filename);
g->mtime = 0;
g->name = g->chosen_name = NULL;
g->replace_wildcards = 0;
g->entry_group = NULL;
AVAHI_LLIST_HEAD_INIT(StaticService, g->services);
AVAHI_LLIST_PREPEND(StaticServiceGroup, groups, groups, g);
return g;
}
AvahiSRecordBrowser *avahi_s_record_browser_new(
AvahiServer *server,
AvahiIfIndex interface,
AvahiProtocol protocol,
AvahiKey *key,
AvahiLookupFlags flags,
AvahiSRecordBrowserCallback callback,
void* userdata) {
AvahiSRecordBrowser *b;
assert(server);
assert(key);
assert(callback);
AVAHI_CHECK_VALIDITY_RETURN_NULL(server, AVAHI_IF_VALID(interface), AVAHI_ERR_INVALID_INTERFACE);
AVAHI_CHECK_VALIDITY_RETURN_NULL(server, AVAHI_PROTO_VALID(protocol), AVAHI_ERR_INVALID_PROTOCOL);
AVAHI_CHECK_VALIDITY_RETURN_NULL(server, !avahi_key_is_pattern(key), AVAHI_ERR_IS_PATTERN);
AVAHI_CHECK_VALIDITY_RETURN_NULL(server, avahi_key_is_valid(key), AVAHI_ERR_INVALID_KEY);
AVAHI_CHECK_VALIDITY_RETURN_NULL(server, AVAHI_FLAGS_VALID(flags, AVAHI_LOOKUP_USE_WIDE_AREA|AVAHI_LOOKUP_USE_MULTICAST), AVAHI_ERR_INVALID_FLAGS);
AVAHI_CHECK_VALIDITY_RETURN_NULL(server, !(flags & AVAHI_LOOKUP_USE_WIDE_AREA) || !(flags & AVAHI_LOOKUP_USE_MULTICAST), AVAHI_ERR_INVALID_FLAGS);
if (!(b = avahi_new(AvahiSRecordBrowser, 1))) {
avahi_server_set_errno(server, AVAHI_ERR_NO_MEMORY);
return NULL;
}
b->dead = 0;
b->server = server;
b->interface = interface;
b->protocol = protocol;
b->key = avahi_key_ref(key);
b->flags = flags;
b->callback = callback;
b->userdata = userdata;
b->n_lookups = 0;
AVAHI_LLIST_HEAD_INIT(AvahiSRBLookup, b->lookups);
b->root_lookup = NULL;
AVAHI_LLIST_PREPEND(AvahiSRecordBrowser, browser, server->record_browsers, b);
/* The currently cached entries are scanned a bit later, and than we will start querying, too */
b->defer_time_event = avahi_time_event_new(server->time_event_queue, NULL, defer_callback, b);
assert(b->defer_time_event);
return b;
}
AvahiProbeScheduler *avahi_probe_scheduler_new(AvahiInterface *i) {
AvahiProbeScheduler *s;
assert(i);
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;
AVAHI_LLIST_HEAD_INIT(AvahiProbeJob, s->jobs);
AVAHI_LLIST_HEAD_INIT(AvahiProbeJob, s->history);
return s;
}
static StaticService *static_service_new(StaticServiceGroup *group) {
StaticService *s;
assert(group);
s = avahi_new(StaticService, 1);
s->group = group;
s->type = s->host_name = s->domain_name = NULL;
s->port = 0;
s->protocol = AVAHI_PROTO_UNSPEC;
s->txt_records = NULL;
s->subtypes = NULL;
AVAHI_LLIST_PREPEND(StaticService, services, group->services, s);
return s;
}
AvahiQueryScheduler *avahi_query_scheduler_new(AvahiInterface *i) {
AvahiQueryScheduler *s;
assert(i);
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;
s->next_id = 0;
AVAHI_LLIST_HEAD_INIT(AvahiQueryJob, s->jobs);
AVAHI_LLIST_HEAD_INIT(AvahiQueryJob, s->history);
AVAHI_LLIST_HEAD_INIT(AvahiKnownAnswer, s->known_answers);
return s;
}
ServiceInfo* NetworkServicesProviderAvahi::addServiceInfo(
AvahiIfIndex interface,
AvahiProtocol protocol,
const char* name,
const char* type,
const char* domain)
{
ServiceInfo* i;
m_currentService = i = avahi_new(ServiceInfo, 1);
if (!(i->resolver = avahi_service_resolver_new(
m_avahiClient,
interface,
protocol,
name,
type,
domain,
AVAHI_PROTO_UNSPEC,
(AvahiLookupFlags)0,
&serviceResolverCallback,
static_cast<void*>(i))))
{
avahi_free(i);
LOG_ERROR("Failed to resolve service '%s' of type '%s' in domain '%s': %s\n",
name, type, domain, avahi_strerror(avahi_client_errno(m_avahiClient)));
return 0;
}
m_resolving++;
i->interface = interface;
i->protocol = protocol;
i->name = avahi_strdup(name);
i->type = avahi_strdup(type);
i->domain = avahi_strdup(domain);
i->provider = this;
i->notify = false;
AVAHI_LLIST_PREPEND(ServiceInfo, info, m_services, i);
return i;
}
static void set_state(AvahiLLMNREntryVerify *ev) {
AvahiEntry *e;
assert(ev);
e = ev->e;
assert(e->type == AVAHI_ENTRY_LLMNR);
if((e->flags & AVAHI_PUBLISH_UNIQUE) && !(e->flags & AVAHI_PUBLISH_NO_VERIFY))
ev->state = AVAHI_VERIFYING;
else
ev->state = AVAHI_ESTABLISHED;
if(ev->state == AVAHI_VERIFYING) {
/* Structure to send in AvahiLLMNRQuery*/
struct AvahiVerifierData *vdata;
vdata = avahi_new(AvahiVerifierData, 1);
/* Fill AvahiLLMNREntryVerify*/
vdata->ev = ev;
/* Both these fields are filled by handle_response*/
vdata->address = NULL;
/* If we get the response with t bit clear we don't touch this entry*/
/* If we get the response with t bit set we set it so bt edfault keep it zero.*/
vdata->t_bit = 0;
/* Initiate Query */
ev->lq = avahi_llmnr_query_add(ev->interface, e->record->key, AVAHI_LLMNR_UNIQUENESS_VERIFICATION_QUERY, query_callback, vdata);
/* Increase n_verify */
if(e->group) {
assert(e->group->type == AVAHI_GROUP_LLMNR);
e->group->proto.llmnr.n_verifying++;
}
} else { /*ev->state == AVAHI_ESTABLISHED */
if (ev->e->group)
check_established(ev->e->group);
}
}
