static void
_resolver_callback(AvahiServiceResolver *r, AvahiIfIndex interface, AvahiProtocol protocol,
AvahiResolverEvent event, const char *name, const char *type, const char *domain,
const char *host_name, const AvahiAddress *a, uint16_t port, AvahiStringList *txt,
AvahiLookupResultFlags flags, void *userdata) {
BonjourBuddy *buddy;
PurpleAccount *account = userdata;
AvahiStringList *l;
size_t size;
char *key, *value;
int ret;
g_return_if_fail(r != NULL);
switch (event) {
case AVAHI_RESOLVER_FAILURE:
purple_debug_error("bonjour", "_resolve_callback - Failure: %s\n",
avahi_strerror(avahi_client_errno(avahi_service_resolver_get_client(r))));
avahi_service_resolver_free(r);
break;
case AVAHI_RESOLVER_FOUND:
/* create a buddy record */
buddy = bonjour_buddy_new(name, account);
((AvahiBuddyImplData *)buddy->mdns_impl_data)->resolver = r;
/* Get the ip as a string */
buddy->ip = g_malloc(AVAHI_ADDRESS_STR_MAX);
avahi_address_snprint(buddy->ip, AVAHI_ADDRESS_STR_MAX, a);
buddy->port_p2pj = port;
/* Obtain the parameters from the text_record */
clear_bonjour_buddy_values(buddy);
l = txt;
while (l != NULL) {
ret = avahi_string_list_get_pair(l, &key, &value, &size);
l = l->next;
if (ret < 0)
continue;
set_bonjour_buddy_value(buddy, key, value, size);
/* TODO: Since we're using the glib allocator, I think we
* can use the values instead of re-copying them */
avahi_free(key);
avahi_free(value);
}
if (!bonjour_buddy_check(buddy))
bonjour_buddy_delete(buddy);
else
/* Add or update the buddy in our buddy list */
bonjour_buddy_add_to_purple(buddy);
break;
default:
purple_debug_info("bonjour", "Unrecognized Service Resolver event: %d.\n", event);
}
}
void CZeroconfBrowserAvahi::resolveCallback(
AvahiServiceResolver *r, AvahiIfIndex interface, AvahiProtocol protocol, AvahiResolverEvent event,
const char *name, const char *type, const char *domain, const char *host_name,
const AvahiAddress *address, uint16_t port, AvahiStringList *txt, AvahiLookupResultFlags flags, void* userdata )
{
assert ( r );
assert ( userdata );
CZeroconfBrowserAvahi* p_instance = static_cast<CZeroconfBrowserAvahi*> ( userdata );
switch ( event )
{
case AVAHI_RESOLVER_FAILURE:
CLog::Log ( LOGERROR, "CZeroconfBrowserAvahi::resolveCallback Failed to resolve service '%s' of type '%s' in domain '%s': %s\n", name, type, domain, avahi_strerror ( avahi_client_errno ( avahi_service_resolver_get_client ( r ) ) ) );
break;
case AVAHI_RESOLVER_FOUND:
{
char a[AVAHI_ADDRESS_STR_MAX];
CLog::Log ( LOGDEBUG, "CZeroconfBrowserAvahi::resolveCallback resolved service '%s' of type '%s' in domain '%s':\n", name, type, domain );
avahi_address_snprint ( a, sizeof ( a ), address );
p_instance->m_resolving_service.SetIP(a);
p_instance->m_resolving_service.SetPort(port);
//get txt-record list
p_instance->m_resolving_service.SetTxtRecords(GetTxtRecords(txt));
break;
}
}
avahi_service_resolver_free ( r );
p_instance->m_resolved_event.Set();
}
static void
avahi_resolve_callback (AvahiServiceResolver * r,
AVAHI_GCC_UNUSED AvahiIfIndex interface,
AVAHI_GCC_UNUSED AvahiProtocol protocol, AvahiResolverEvent event,
AVAHI_GCC_UNUSED const char *name, AVAHI_GCC_UNUSED const char *type,
AVAHI_GCC_UNUSED const char *domain, const char *host_name,
AVAHI_GCC_UNUSED const AvahiAddress * address, uint16_t port,
AVAHI_GCC_UNUSED AvahiStringList * txt,
AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
AVAHI_GCC_UNUSED void *userdata)
{
SnraClient *client = userdata;
switch (event) {
case AVAHI_RESOLVER_FAILURE:
break;
case AVAHI_RESOLVER_FOUND:{
if (!client->connecting) {
/* FIXME: Build a list of servers and try each one in turn? */
connect_to_server (client, host_name, port);
}
}
}
avahi_service_resolver_free (r);
}
/**
* resolver: The avahi resolver
* iface: The avahi interface
* proto: The avahi protocol
* event: the avahi event
* name: name of the service
* type: must be HKP_SERVICE_TYPE
* domain: ignored
* host_name: ignored
* address: address of the service
* port: port of the service
* txt: ignored
* flags:
* data: userdata
*
* Resolves the avahi callback (AvahiServiceResolverCallback)
*
**/
static void
resolve_callback (AvahiServiceResolver *resolver, AvahiIfIndex iface, AvahiProtocol proto,
AvahiResolverEvent event, const char *name, const char *type, const char *domain,
const char *host_name, const AvahiAddress *address, uint16_t port,
AvahiStringList *txt, AvahiLookupResultFlags flags, void *data)
{
BastileServiceDiscovery *ssd = BASTILE_SERVICE_DISCOVERY (data);
gchar *service_name;
gchar *service_uri;
gchar *ipname;
g_assert (BASTILE_IS_SERVICE_DISCOVERY (ssd));
switch(event) {
case AVAHI_RESOLVER_FAILURE:
g_warning ("couldn't resolve service '%s': %s", name,
avahi_strerror (avahi_client_errno (ssd->priv->client)));
break;
case AVAHI_RESOLVER_FOUND:
/* Make sure it's our type ... */
/* XXX Is the service always guaranteed to be ascii? */
if (g_ascii_strcasecmp (HKP_SERVICE_TYPE, type) != 0)
break;
#ifndef DISCOVER_THIS_HOST
/* And that it's local */
if (flags & AVAHI_LOOKUP_RESULT_LOCAL)
break;
#endif
ipname = g_new0(gchar, AVAHI_ADDRESS_STR_MAX);
avahi_address_snprint (ipname, AVAHI_ADDRESS_STR_MAX, address);
service_uri = g_strdup_printf ("hkp://%s:%d", ipname, (int)port);
service_name = g_strdup (name);
g_hash_table_replace (ssd->services, service_name, service_uri);
g_signal_emit (ssd, signals[ADDED], 0, service_name);
/* Add it to the context */
if (!bastile_context_remote_source (SCTX_APP (), service_uri)) {
BastileServerSource *ssrc = bastile_server_source_new (service_uri);
g_return_if_fail (ssrc != NULL);
bastile_context_add_source (SCTX_APP (), BASTILE_SOURCE (ssrc));
}
DEBUG_DNSSD (("DNS-SD added: %s %s\n", service_name, service_uri));
break;
default:
break;
};
/* One result is enough for us */
avahi_service_resolver_free (resolver);
}
// Frees all resolvers for a given service name
static void
resolvers_cleanup(const char *name, AvahiProtocol proto)
{
struct mdns_resolver *r;
struct mdns_resolver *prev;
struct mdns_resolver *next;
prev = NULL;
for (r = resolver_list; r; r = next)
{
next = r->next;
if ((strcmp(name, r->name) != 0) || (proto != r->proto))
{
prev = r;
continue;
}
if (!prev)
resolver_list = r->next;
else
prev->next = r->next;
avahi_service_resolver_free(r->resolver);
free(r->name);
free(r);
}
}
static void avahi_resolver_callback(AvahiServiceResolver *resolver,
AvahiIfIndex iface, AvahiProtocol proto,
AvahiResolverEvent event, const char *name,
const char *type, const char *domain,
const char *host_name, const AvahiAddress *address,
uint16_t port, AvahiStringList *txt,
AvahiLookupResultFlags flags, void *d)
{
AvahiBrowserEntry *entry = (AvahiBrowserEntry*)d;
switch (event) {
case AVAHI_RESOLVER_FAILURE:
eDebug("[Avahi] Failed to resolve service '%s' of type '%s': %s",
name, type, avahi_strerror(avahi_client_errno(avahi_service_resolver_get_client(resolver))));
break;
case AVAHI_RESOLVER_FOUND:
if (flags & (AVAHI_LOOKUP_RESULT_LOCAL | AVAHI_LOOKUP_RESULT_OUR_OWN))
break; /* Skip local/own services, we don't want to see them */
eDebug("[Avahi] ADD Service '%s' of type '%s' at %s:%u", name, type, host_name, port);
entry->callback(entry->userdata, E2AVAHI_EVENT_ADD, name, type, host_name, port);
break;
}
avahi_service_resolver_free(resolver);
}
static void
g_vfs_dns_sd_resolver_finalize (GObject *object)
{
GVfsDnsSdResolver *resolver;
resolver = G_VFS_DNS_SD_RESOLVER (object);
g_free (resolver->encoded_triple);
g_free (resolver->service_name);
g_free (resolver->service_type);
g_free (resolver->domain);
g_free (resolver->required_txt_keys);
g_strfreev (resolver->required_txt_keys_broken_out);
g_free (resolver->address);
g_strfreev (resolver->txt_records);
if (resolver->avahi_resolver != NULL)
avahi_service_resolver_free (resolver->avahi_resolver);
resolvers = g_list_remove (resolvers, resolver);
/* free the global avahi client for the last resolver */
if (resolvers == NULL)
{
free_global_avahi_client ();
}
G_OBJECT_CLASS (g_vfs_dns_sd_resolver_parent_class)->finalize (object);
}
RemoteService::~RemoteService()
{
#ifdef HAVE_DNSSD
if (d->m_resolver) avahi_service_resolver_free(d->m_resolver);
#endif
delete d;
}
/* Called when a resolve call completes */
static void resolve_reply(
AvahiServiceResolver *UNUSED(r),
AvahiIfIndex UNUSED(interface),
AvahiProtocol UNUSED(protocol),
AvahiResolverEvent event,
const char *name,
const char *UNUSED(type),
const char *UNUSED(domain),
const char *UNUSED(host_name),
const AvahiAddress *a,
uint16_t port,
AvahiStringList *txt,
AvahiLookupResultFlags UNUSED(flags),
void *userdata) {
struct host *h = userdata;
switch (event) {
case AVAHI_RESOLVER_FOUND: {
AvahiStringList *i;
/* Look for the number of CPUs in TXT RRs */
for (i = txt; i; i = i->next) {
char *key, *value;
if (avahi_string_list_get_pair(i, &key, &value, NULL) < 0)
continue;
if (!strcmp(key, "cpus"))
if ((h->n_cpus = atoi(value)) <= 0)
h->n_cpus = 1;
avahi_free(key);
avahi_free(value);
}
h->address = *a;
h->port = port;
avahi_service_resolver_free(h->resolver);
h->resolver = NULL;
/* Write modified hosts file */
write_hosts(h->daemon_data);
break;
}
case AVAHI_RESOLVER_FAILURE:
rs_log_warning("Failed to resolve service '%s': %s\n", name,
avahi_strerror(avahi_client_errno(h->daemon_data->client)));
free_host(h);
break;
}
}
static void resolve_callback(
AvahiServiceResolver *r,
AVAHI_GCC_UNUSED AvahiIfIndex interface,
AVAHI_GCC_UNUSED AvahiProtocol protocol,
AvahiResolverEvent event,
const char *name,
const char *type,
const char *domain,
const char *host_name,
const AvahiAddress *address,
uint16_t port,
AvahiStringList *txt,
AvahiLookupResultFlags flags,
AVAHI_GCC_UNUSED void* userdata) {
assert(r);
/* Called whenever a service has been resolved successfully or timed out */
switch (event) {
case AVAHI_RESOLVER_FAILURE:
debug(2, "(Resolver) Failed to resolve service '%s' of type '%s' in domain '%s': %s\n", name, type, domain, avahi_strerror(avahi_client_errno(avahi_service_resolver_get_client(r))));
break;
case AVAHI_RESOLVER_FOUND: {
if (flags & AVAHI_LOOKUP_RESULT_OUR_OWN) {
char a[AVAHI_ADDRESS_STR_MAX], *t;
// debug(1, "avahi: service '%s' of type '%s' in domain '%s' added.", name, type, domain);
avahi_address_snprint(a, sizeof(a), address);
debug(1,"avahi: address advertised is: \"%s\".",a);
/*
t = avahi_string_list_to_string(txt);
debug(1,
"\t%s:%u (%s)\n"
"\tTXT=%s\n"
"\tcookie is %u\n"
"\tis_local: %i\n"
"\tour_own: %i\n"
"\twide_area: %i\n"
"\tmulticast: %i\n"
"\tcached: %i\n",
host_name, port, a,
t,
avahi_string_list_get_service_cookie(txt),
!!(flags & AVAHI_LOOKUP_RESULT_LOCAL),
!!(flags & AVAHI_LOOKUP_RESULT_OUR_OWN),
!!(flags & AVAHI_LOOKUP_RESULT_WIDE_AREA),
!!(flags & AVAHI_LOOKUP_RESULT_MULTICAST),
!!(flags & AVAHI_LOOKUP_RESULT_CACHED));
avahi_free(t);
*/
}
}
}
avahi_service_resolver_free(r);
}
void Browser::resolve_callback(AvahiServiceResolver *r,
AvahiIfIndex,
AvahiProtocol,
AvahiResolverEvent event,
const char *name,
const char *type,
const char *,
const char *host_name,
const AvahiAddress *address,
uint16_t port,
AvahiStringList *txt,
AvahiLookupResultFlags,
void *data)
{
assert(data);
Browser *browser = static_cast<Browser *>(data);
assert(r);
switch (event) {
case AVAHI_RESOLVER_FAILURE:
//cerr << "[Resolver] Failed to resolve service '" << name << "' of type '" << type << "' in domain '" << domain
// << "': " << avahi_strerror(avahi_client_errno(avahi_service_resolver_get_client(r))) << endl;
break;
case AVAHI_RESOLVER_FOUND:
//cerr << "[Resolver] Service '" << name << " (" << host_name << ":" << port << ")"
// << "' of type '" << type <<"' in domain '" << domain << "'" << endl;
//cout << a->browse_services_.size() << endl;
browser->add_service(name, Service(type, host_name, address, port, txt));
// XXX cache service, broadcast
#if 0
avahi_address_snprint(a, sizeof(a), address);
t = avahi_string_list_to_string(txt);
fprintf(stderr,
"\t%s:%u (%s)\n"
"\tTXT=%s\n"
"\tcookie is %u\n"
"\tis_local: %i\n"
"\tour_own: %i\n"
"\twide_area: %i\n"
"\tmulticast: %i\n"
"\tcached: %i\n",
host_name, port, a,
t,
avahi_string_list_get_service_cookie(txt),
!!(flags & AVAHI_LOOKUP_RESULT_LOCAL),
!!(flags & AVAHI_LOOKUP_RESULT_OUR_OWN),
!!(flags & AVAHI_LOOKUP_RESULT_WIDE_AREA),
!!(flags & AVAHI_LOOKUP_RESULT_MULTICAST),
!!(flags & AVAHI_LOOKUP_RESULT_CACHED));
avahi_free(t);
#endif
}
avahi_service_resolver_free(r);
}
static void
_cleanup_resolver_data(AvahiSvcResolverData *rd) {
if (rd->resolver)
avahi_service_resolver_free(rd->resolver);
g_free(rd->name);
g_free(rd->type);
g_free(rd->domain);
g_free(rd);
}
void resolve_callback(
AvahiServiceResolver *r,
AVAHI_GCC_UNUSED AvahiIfIndex interface,
AVAHI_GCC_UNUSED AvahiProtocol protocol,
AvahiResolverEvent event,
const char *name,
const char *type,
const char *domain,
const char *host_name,
const AvahiAddress *address,
uint16_t port,
AvahiStringList *txt,
AvahiLookupResultFlags flags,
AVAHI_GCC_UNUSED void* userdata) {
assert(r);
/* Called whenever a service has been resolved successfully or timed out */
switch (event) {
case AVAHI_RESOLVER_FAILURE:
std::cerr << "(Resolver) Failed to resolve service '" << name <<"' of type '" << type << "' in domain '" << domain << "': " << avahi_strerror(avahi_client_errno(avahi_service_resolver_get_client(r))) << std::endl;
break;
case AVAHI_RESOLVER_FOUND: {
char a[AVAHI_ADDRESS_STR_MAX], *t;
if (!(flags & AVAHI_LOOKUP_RESULT_LOCAL)) {
char sport[6];
std::cerr << "Service '" << name << "' of type '" << type << "' in domain '" << domain << "':" << std::endl;
avahi_address_snprint(a, sizeof(a), address);
t = avahi_string_list_to_string(txt);
std::cerr << host_name << ":" <<port << "(" << a << ")" << std::endl;
std::cerr << "TXT=" << t << std::endl;
std::cerr << "cookie is " << avahi_string_list_get_service_cookie(txt) << std::endl;
std::cerr << "is_local: " << !!(flags & AVAHI_LOOKUP_RESULT_LOCAL) << std::endl;
std::cerr << "our_own: " << !!(flags & AVAHI_LOOKUP_RESULT_OUR_OWN) << std::endl;
std::cerr << "wide_area: " << !!(flags & AVAHI_LOOKUP_RESULT_WIDE_AREA) << std::endl;
std::cerr << "multicast: " << !!(flags & AVAHI_LOOKUP_RESULT_MULTICAST) << std::endl;
std::cerr << "cached: " << !!(flags & AVAHI_LOOKUP_RESULT_CACHED) << std::endl;
sprintf(sport, "%i", port);
mn->addHost(new Host((char *)name, (char *)a, (char *)sport, (char *)t));
avahi_free(t);
//todo:create new host here;
}
break;
}
}
avahi_service_resolver_free(r);
}
/* Free host data */
static void free_host(struct host *h) {
assert(h);
if (h->resolver)
avahi_service_resolver_free(h->resolver);
free(h->service);
free(h->domain);
free(h);
}
void BrowseAvahi::resolve_callback(
AvahiServiceResolver *r,
AVAHI_GCC_UNUSED AvahiIfIndex interface,
AVAHI_GCC_UNUSED AvahiProtocol protocol,
AvahiResolverEvent event,
const char *name,
const char *type,
const char *domain,
const char *host_name,
const AvahiAddress *address,
uint16_t port,
AvahiStringList *txt,
AvahiLookupResultFlags flags,
AVAHI_GCC_UNUSED void* userdata)
{
BrowseAvahi* browseAvahi = static_cast<BrowseAvahi*>(userdata);
assert(r);
/* Called whenever a service has been resolved successfully or timed out */
switch (event)
{
case AVAHI_RESOLVER_FAILURE:
logE << "(Resolver) Failed to resolve service '" << name << "' of type '" << type << "' in domain '" << domain << "': " << avahi_strerror(avahi_client_errno(avahi_service_resolver_get_client(r))) << "\n";
break;
case AVAHI_RESOLVER_FOUND:
{
char a[AVAHI_ADDRESS_STR_MAX], *t;
logO << "Service '" << name << "' of type '" << type << "' in domain '" << domain << "':\n";
avahi_address_snprint(a, sizeof(a), address);
browseAvahi->result_.host_ = host_name;
browseAvahi->result_.ip_ = a;
browseAvahi->result_.port_ = port;
browseAvahi->result_.proto_ = protocol;
browseAvahi->result_.valid_ = true;
t = avahi_string_list_to_string(txt);
logO << "\t" << host_name << ":" << port << " (" << a << ")\n";
logD << "\tTXT=" << t << "\n";
logD << "\tProto=" << (int)protocol << "\n";
logD << "\tcookie is " << avahi_string_list_get_service_cookie(txt) << "\n";
logD << "\tis_local: " << !!(flags & AVAHI_LOOKUP_RESULT_LOCAL) << "\n";
logD << "\tour_own: " << !!(flags & AVAHI_LOOKUP_RESULT_OUR_OWN) << "\n";
logD << "\twide_area: " << !!(flags & AVAHI_LOOKUP_RESULT_WIDE_AREA) << "\n";
logD << "\tmulticast: " << !!(flags & AVAHI_LOOKUP_RESULT_MULTICAST) << "\n";
logD << "\tcached: " << !!(flags & AVAHI_LOOKUP_RESULT_CACHED) << "\n";
avahi_free(t);
}
}
avahi_service_resolver_free(r);
}
static void
remove_client_from_resolver (GVfsDnsSdResolver *resolver)
{
if (resolver->avahi_resolver != NULL)
{
avahi_service_resolver_free (resolver->avahi_resolver);
resolver->avahi_resolver = NULL;
}
clear_avahi_data (resolver);
}
Avahi::Heap::~Heap ()
{
if (resolver != NULL)
avahi_service_resolver_free (resolver);
if (client != NULL)
avahi_client_free (client);
if (poll != NULL)
avahi_glib_poll_free (poll);
}
static void resolveCallback( AvahiServiceResolver *r,
AVAHI_GCC_UNUSED AvahiIfIndex interface,
AVAHI_GCC_UNUSED AvahiProtocol protocol,
AvahiResolverEvent event,
const char *name,
const char *type,
const char *domain,
const char *host_name,
const AvahiAddress *address,
uint16_t port,
AvahiStringList *txt,
AvahiLookupResultFlags flags,
void* userdata )
{
TiVoUnit *tivo = userdata;
char addr[AVAHI_ADDRESS_STR_MAX];
AvahiStringList *list;
char *key, *value;
assert(r);
/* Called whenever a service has been resolved successfully, or timed out */
switch (event)
{
case AVAHI_RESOLVER_FAILURE:
logerror( "Failed to resolve service '%s' of type '%s' in domain '%s': %s\n",
name, type, domain, avahi_strerror( avahi_client_errno( avahi_service_resolver_get_client(r) ) ) );
break;
case AVAHI_RESOLVER_FOUND:
/* now we also have the TiVo's serial number and network address */
avahi_address_snprint( addr, sizeof(addr), address );
tivo->address = strdup( addr );
list = avahi_string_list_find( txt, "TSN" );
avahi_string_list_get_pair( list, &key, &value, NULL );
tivo->serial = strdup( value );
avahi_free( key );
avahi_free( value );
loginfo( "Resolved '%s' to TSN '%s' at %s", tivo->name, tivo->serial, tivo->address );
break;
}
/* all done with the resolver, so free it */
avahi_service_resolver_free( r );
}
/** Service resolution callback.
*/
static void sResolveCallback(
AvahiServiceResolver *r,
AvahiIfIndex interface,
AVAHI_GCC_UNUSED AvahiProtocol protocol,
AvahiResolverEvent event,
const char *name,
const char *type,
const char *domain,
const char *host_name,
const AvahiAddress *address,
uint16_t port,
AvahiStringList *txt,
AvahiLookupResultFlags flags,
void *userdata) {
Implementation *impl = (Implementation*)userdata;
AvahiClient *client = avahi_service_resolver_get_client(r);
// Service either resolved or timed out.
switch (event) {
case AVAHI_RESOLVER_FAILURE:
throw dub::Exception("Could not resolve service '%s' (%s).\n",
name,
avahi_strerror(avahi_client_errno(client)));
case AVAHI_RESOLVER_FOUND: {
Service *service = new Service(
impl->master_->service_type_,
name,
interface,
type,
domain,
true);
std::string t;
AvahiStringList *l = txt;
// This is idiotic. Why can't avahi just give us the
// raw txt record, eventually with a ctor for AvahiStringList.
// (The same goes for registration).
while (l) {
t.push_back(l->size);
t.append((const char *)l->text, l->size);
l = l->next;
}
service->set(host_name, port, t);
impl->pushService(service);
}
}
// Free resolver allocated in sBrowseCallback.
avahi_service_resolver_free(r);
}
static void remove_service(Config *c, ServiceInfo *i) {
assert(c);
assert(i);
AVAHI_LLIST_REMOVE(ServiceInfo, info, services, i);
if (i->resolver)
avahi_service_resolver_free(i->resolver);
avahi_free(i->name);
avahi_free(i->type);
avahi_free(i->domain);
avahi_free(i);
}
static void __avahi_resolver_cb(AvahiServiceResolver *resolver,
__notused AvahiIfIndex iface, __notused AvahiProtocol proto,
__notused AvahiResolverEvent event, __notused const char *name,
__notused const char *type, __notused const char *domain,
__notused const char *host_name, const AvahiAddress *address,
uint16_t port, __notused AvahiStringList *txt,
__notused AvahiLookupResultFlags flags, void *d)
{
struct avahi_discovery_data *ddata = (struct avahi_discovery_data *) d;
memcpy(ddata->address, address, sizeof(*address));
*ddata->port = port;
ddata->resolved = true;
avahi_service_resolver_free(resolver);
}
void _mdns_delete_buddy(BonjourBuddy *buddy) {
AvahiBuddyImplData *idata = buddy->mdns_impl_data;
g_return_if_fail(idata != NULL);
if (idata->buddy_icon_rec_browser != NULL)
avahi_record_browser_free(idata->buddy_icon_rec_browser);
if (idata->resolver != NULL)
avahi_service_resolver_free(idata->resolver);
g_free(idata);
buddy->mdns_impl_data = NULL;
}
static void
daap_mdns_resolve_browser_new_cb (
AvahiServiceResolver *resolv,
AvahiIfIndex iface,
AvahiProtocol proto,
AvahiResolverEvent event,
const gchar *name,
const gchar *type,
const gchar *domain,
const gchar *hostname,
const AvahiAddress *addr,
guint16 port,
AvahiStringList *text,
AvahiLookupResultFlags flags,
void *userdata)
{
gchar ad[ADDR_LEN];
daap_mdns_server_t *server;
if (!resolv) {
return;
}
switch (event) {
case AVAHI_RESOLVER_FOUND:
avahi_address_snprint (ad, sizeof (ad), addr);
server = g_new0 (daap_mdns_server_t, 1);
server->server_name = g_strdup (name);
server->address = g_strdup (ad);
server->mdns_hostname = g_strdup (hostname);
server->port = port;
g_static_mutex_lock (&serv_list_mut);
g_server_list = g_slist_prepend (g_server_list, server);
g_static_mutex_unlock (&serv_list_mut);
break;
case AVAHI_RESOLVER_FAILURE:
break;
default:
break;
}
avahi_service_resolver_free (resolv);
}
static void
browse_resolve_callback(AvahiServiceResolver *r, AvahiIfIndex intf, AvahiProtocol proto, AvahiResolverEvent event,
const char *name, const char *type, const char *domain, const char *hostname, const AvahiAddress *addr,
uint16_t port, AvahiStringList *txt, AvahiLookupResultFlags flags, void *userdata)
{
AvahiClient *c;
struct mdns_browser *mb;
int ret;
mb = (struct mdns_browser *)userdata;
switch (event)
{
case AVAHI_RESOLVER_FAILURE:
DPRINTF(E_LOG, L_MDNS, "Avahi Resolver failure: service '%s' type '%s': %s\n", name, type,
avahi_strerror(avahi_client_errno(mdns_client)));
break;
case AVAHI_RESOLVER_FOUND:
DPRINTF(E_DBG, L_MDNS, "Avahi Resolver: resolved service '%s' type '%s' proto %d\n", name, type, proto);
c = avahi_service_resolver_get_client(r);
if (mb->flags & (MDNS_WANT_V4 | MDNS_WANT_V4LL))
{
ret = spawn_record_browser(c, intf, proto, hostname, domain,
AVAHI_DNS_TYPE_A, mb, name, port, txt);
if (ret < 0)
DPRINTF(E_LOG, L_MDNS, "Failed to create record browser for type A\n");
}
if (mb->flags & (MDNS_WANT_V6 | MDNS_WANT_V6LL))
{
ret = spawn_record_browser(c, intf, proto, hostname, domain,
AVAHI_DNS_TYPE_AAAA, mb, name, port, txt);
if (ret < 0)
DPRINTF(E_LOG, L_MDNS, "Failed to create record browser for type A\n");
}
break;
}
avahi_service_resolver_free(r);
return;
}
void avahi_client_free(AvahiClient *client) {
assert(client);
if (client->bus)
/* Disconnect in advance, so that the free() functions won't
* issue needless server calls */
#ifdef HAVE_DBUS_CONNECTION_CLOSE
dbus_connection_close(client->bus);
#else
dbus_connection_disconnect(client->bus);
#endif
while (client->groups)
avahi_entry_group_free(client->groups);
while (client->domain_browsers)
avahi_domain_browser_free(client->domain_browsers);
while (client->service_browsers)
avahi_service_browser_free(client->service_browsers);
while (client->service_type_browsers)
avahi_service_type_browser_free(client->service_type_browsers);
while (client->service_resolvers)
avahi_service_resolver_free(client->service_resolvers);
while (client->host_name_resolvers)
avahi_host_name_resolver_free(client->host_name_resolvers);
while (client->address_resolvers)
avahi_address_resolver_free(client->address_resolvers);
while (client->record_browsers)
avahi_record_browser_free(client->record_browsers);
if (client->bus)
dbus_connection_unref(client->bus);
avahi_free(client->version_string);
avahi_free(client->host_name);
avahi_free(client->host_name_fqdn);
avahi_free(client->domain_name);
avahi_free(client);
}
static void resolve_callback(AvahiServiceResolver *r, AVAHI_GCC_UNUSED AvahiIfIndex interface,
AVAHI_GCC_UNUSED AvahiProtocol protocol, AvahiResolverEvent event,
const char *name, const char *type, const char *domain,
const char *host_name, const AvahiAddress *address, uint16_t port,
AvahiStringList *txt, AvahiLookupResultFlags flags, void *userdata) {
assert(r);
rtsp_conn_info *conn = (rtsp_conn_info *)userdata;
dacp_browser_struct *dbs = (dacp_browser_struct *)conn->mdns_private_pointer;
/* Called whenever a service has been resolved successfully or timed out */
switch (event) {
case AVAHI_RESOLVER_FAILURE:
debug(3, "(Resolver) Failed to resolve service '%s' of type '%s' in domain '%s': %s.", name,
type, domain, avahi_strerror(avahi_client_errno(avahi_service_resolver_get_client(r))));
break;
case AVAHI_RESOLVER_FOUND: {
char a[AVAHI_ADDRESS_STR_MAX], *t;
// debug(1, "Resolve callback: Service '%s' of type '%s' in domain '%s':", name, type, domain);
char *dacpid = strstr(name, "iTunes_Ctrl_");
if (dacpid) {
dacpid += strlen("iTunes_Ctrl_");
if (strcmp(dacpid, conn->dacp_id) == 0) {
if (conn->dacp_port != port) {
debug(3, "Client's DACP port: %u.", port);
conn->dacp_port = port;
#if defined(HAVE_DBUS) || defined(HAVE_MPRIS)
set_dacp_server_information(conn);
#endif
#ifdef CONFIG_METADATA
char portstring[20];
memset(portstring, 0, sizeof(portstring));
sprintf(portstring, "%u", port);
send_ssnc_metadata('dapo', strdup(portstring), strlen(portstring), 0);
#endif
}
}
} else {
debug(1, "Resolve callback: Can't see a DACP string in a DACP Record!");
}
}
}
avahi_service_resolver_free(r);
}
void NetworkServicesProviderAvahi::removeServiceInfo(ServiceInfo* i)
{
ASSERT(i);
NetworkServicesProviderAvahi* p = i->provider;
char* id;
id = (char*) avahi_malloc(strlen(i->name) + strlen(i->type) + strlen(i->domain) + 4);
sprintf(id, "%s.%s.%s.", i->name, i->type, i->domain);
p->removeServiceDescription(id);
AVAHI_LLIST_REMOVE(ServiceInfo, info, m_services, i);
if (i->resolver)
avahi_service_resolver_free(i->resolver);
avahi_free(i->name);
avahi_free(i->type);
avahi_free(i->domain);
avahi_free(i);
}
static void resolve_callback(
AvahiServiceResolver *r,
AVAHI_GCC_UNUSED AvahiIfIndex interface,
AVAHI_GCC_UNUSED AvahiProtocol protocol,
AvahiResolverEvent event,
const char *name,
const char *type,
const char *domain,
const char *host_name,
const AvahiAddress *address,
uint16_t port,
AvahiStringList *txt,
AvahiLookupResultFlags flags,
AVAHI_GCC_UNUSED void* userdata) {
assert(r);
/* Called whenever a service has been resolved successfully or timed out */
switch (event) {
case AVAHI_RESOLVER_FAILURE:
fprintf(stderr, "(Resolver) Failed to resolve service '%s' of type '%s' in domain '%s': %s\n", name, type, domain, avahi_strerror(avahi_client_errno(avahi_service_resolver_get_client(r))));
break;
case AVAHI_RESOLVER_FOUND: {
char a[AVAHI_ADDRESS_STR_MAX];
fprintf(stderr, "XMMS2 running on '%s@%s'\n", name, domain);
avahi_address_snprint(a, sizeof(a), address);
fprintf(stderr, "tcp://%s:%u\n", a, port);
}
}
n_pending_resolvers--;
avahi_service_resolver_free(r);
}
void resolve_callback(
AvahiServiceResolver *r,
AVAHI_GCC_UNUSED AvahiIfIndex interface,
AVAHI_GCC_UNUSED AvahiProtocol protocol,
AvahiResolverEvent event,
const char *name,
const char *type,
const char *domain,
const char *host_name,
const AvahiAddress *address,
uint16_t port,
AvahiStringList *txt,
AvahiLookupResultFlags flags,
AVAHI_GCC_UNUSED void* userdata) {
assert(r);
/* Called whenever a service has been resolved successfully or timed out */
switch (event) {
case AVAHI_RESOLVER_FAILURE:
l_debug("(Resolver) Failed to resolve service '%s' of type '%s' in domain '%s': %s\n", name, type, domain, avahi_strerror(avahi_client_errno(avahi_service_resolver_get_client(r))));
break;
case AVAHI_RESOLVER_FOUND: {
char a[AVAHI_ADDRESS_STR_MAX];
avahi_address_snprint(a, sizeof(a), address);
char *value;
char *type = NULL;
size_t *size=NULL;
AvahiStringList *type_txt = avahi_string_list_find(txt,"type");
if (type_txt != NULL){
avahi_string_list_get_pair(type_txt,&type, &value, size);
l_debug("Type = %s",value);
if ((g_strcmp0(value,"miniview") == 0) || (g_strcmp0(value,"android") == 0)) {
char *data="data";
char *extra_data;
size_t *size2=NULL;
AvahiStringList *data_txt = avahi_string_list_find(txt,"data");
if (data_txt != NULL) {
avahi_string_list_get_pair(data_txt,&data, &extra_data, size2);
gchar *myhost = g_strdup_printf("%s:%u",hostname,server_port);
if (g_strcmp0(extra_data, myhost)==0) {
gchar *host = g_strdup_printf("%s:%u",a, port);
l_debug("Found miniview on %s", host);
if (!g_hash_table_contains(miniviews,host)) {
g_hash_table_insert(miniviews, g_strdup(name), host);
}
}
avahi_free(data);
avahi_free(extra_data);
g_free(myhost);
}
}
avahi_free(value);
avahi_free(type);
}
}
}
avahi_service_resolver_free(r);
}
static void
resolve_callback(AvahiServiceResolver *r,
AvahiIfIndex interface,
AvahiProtocol protocol,
AvahiResolverEvent event,
const char *name,
const char *type,
const char *domain,
const char *host_name,
const AvahiAddress *address,
uint16_t port,
AvahiStringList *txt,
AvahiLookupResultFlags flags,
void *userdata)
{
service_instance_t *si = userdata;
service_aux_t *sa = si->si_opaque;
char a[AVAHI_ADDRESS_STR_MAX];
AvahiStringList *apath;
char *path;
AvahiStringList *acontents;
char *contents;
switch(event) {
case AVAHI_RESOLVER_FAILURE:
TRACE(TRACE_ERROR, "AVAHI",
"Failed to resolve service '%s' of type '%s' in domain '%s': %s\n",
name, type, domain,
avahi_strerror(avahi_client_errno(sa->sa_c)));
si_destroy(si);
break;
case AVAHI_RESOLVER_FOUND:
avahi_address_snprint(a, sizeof(a), address);
TRACE(TRACE_DEBUG, "AVAHI",
"Found service '%s' of type '%s' at %s:%d (%s)",
name, type, a, port, host_name);
switch(sa->sa_class) {
case SERVICE_HTSP:
sd_add_service_htsp(si, name, a, port);
break;
case SERVICE_WEBDAV:
apath = avahi_string_list_find(txt, "path");
if(apath == NULL ||
avahi_string_list_get_pair(apath, NULL, &path, NULL))
path = NULL;
acontents = avahi_string_list_find(txt, "contents");
if(acontents == NULL ||
avahi_string_list_get_pair(acontents, NULL, &contents, NULL))
contents = NULL;
sd_add_service_webdav(si, name, a, port, path, contents);
if(path)
avahi_free(path);
break;
}
}
avahi_service_resolver_free(r);
}
