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); }