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);
}
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);
}
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], *t;
fprintf(stderr, "Service '%s' of type '%s' in domain '%s':\n", name, type, domain);
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);
}
}
avahi_service_resolver_free(r);
}
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);
}
int main(int argc, char *argv[]) {
struct zc_published_service *service = malloc(sizeof(struct zc_published_service));
int ret = zc_rtp_publish(service);
struct zc_queue *queue = create_queue_pointer();
ret = (zc_rtp_browse(queue) == 0) ? ret : 1;
struct zc_queue_elem *cursor = NULL;
struct zc_element *zc_elem = NULL;
char *t= NULL;
cursor = queue_pop_front(queue);
while (cursor != NULL){
zc_elem = (struct zc_element *)cursor;
t = avahi_string_list_to_string(zc_elem->txt_options);
fprintf(stdout, "Elem : %s:%d %s %s %s %s \n", zc_elem->address, zc_elem->port, zc_elem->ifname, zc_elem->hostname, zc_elem->type, t);
cursor = queue_pop_front(queue);
}
zc_rtp_free_service(service);
queue_delete_queue_pointer(queue);
return ret;
}
void NetworkServicesProviderAvahi::serviceResolverCallback(
AVAHI_GCC_UNUSED 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* hostName,
const AvahiAddress* a,
AVAHI_GCC_UNUSED uint16_t port,
AvahiStringList* txt,
AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
void* userdata)
{
ServiceInfo* i = static_cast<ServiceInfo*>(userdata);
NetworkServicesProviderAvahi* p = i->provider;
ASSERT(r);
ASSERT(i);
switch (event) {
case AVAHI_RESOLVER_FOUND:
{
NetworkServiceDescription* desc;
char address[AVAHI_ADDRESS_STR_MAX];
char* id;
char* ztype;
char* url;
char* config;
avahi_address_snprint(address, sizeof(address), a);
config = avahi_string_list_to_string(txt);
printServiceLine('=', interface, protocol, name, type, domain);
LOG(Network,
" hostname = [%s]\n"
" address = [%s]\n"
" port = [%u]\n"
" txt = [%s]\n",
hostName,
address,
port,
config);
id = (char*) avahi_malloc(strlen(name) + strlen(type) + strlen(domain) + 4);
sprintf(id, "%s.%s.%s.", name, type, domain);
ztype = (char*) avahi_malloc(strlen(type) + strlen("zeroconf:") + 1);
sprintf(ztype, "zeroconf:%s", type);
url = (char*) avahi_malloc(strlen("http://") + strlen(hostName) + 1);
sprintf(url, "http://%s", hostName);
if (!(desc = p->getServiceDescriptionById(String::fromUTF8(id))))
p->addServiceDescription(id, name, ztype, url, config);
else {
desc->setOnline(true);
p->notifyNetworkServiceChanged(desc);
}
avahi_free(id);
avahi_free(ztype);
avahi_free(url);
avahi_free(config);
break;
}
case AVAHI_RESOLVER_FAILURE:
LOG_ERROR("Failed to resolve service '%s' of type '%s' in domain '%s': %s\n", name, type, domain, avahi_strerror(avahi_client_errno(p->m_avahiClient)));
break;
}
avahi_service_resolver_free(i->resolver);
i->resolver = 0;
p->m_resolving--;
p->checkTerminate();
}
void ofxAvahiCoreBrowser::resolve_cb(
AvahiSServiceResolver *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,
ofxAvahiCoreBrowser* browser) {
assert(r);
/* Called whenever a service has been resolved successfully or timed out */
switch (event) {
case AVAHI_RESOLVER_FAILURE:
ofLogError(LOG_NAME) << "(Resolver) Failed to resolve service '" << name << "' of type '" << type << "' in domain '" << domain << "':" << avahi_strerror(avahi_server_errno(browser->server));
break;
case AVAHI_RESOLVER_FOUND: {
char a[AVAHI_ADDRESS_STR_MAX], *t;
ofLogNotice(LOG_NAME) << "(Resolver) Service '" << name << "' of type '" << type << "' in domain '" << domain;
avahi_address_snprint(a, sizeof(a), address);
t = avahi_string_list_to_string(txt);
ofLogNotice(LOG_NAME) << ofVAArgsToString(
"\t%s:%u (%s)\n"
"\tTXT=%s\n"
"\tcookie is %u\n"
"\tis_local: %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_WIDE_AREA),
!!(flags & AVAHI_LOOKUP_RESULT_MULTICAST),
!!(flags & AVAHI_LOOKUP_RESULT_CACHED));
ofxAvahiService service;
service.domain = domain;
service.host_name = host_name;
service.ip = a;
service.name = name;
service.port = port;
ofNotifyEvent(browser->serviceNewE,service);
avahi_free(t);
break;
}
}
avahi_s_service_resolver_free(r);
}
static void service_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,
AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
void *userdata) {
ServiceInfo *i = userdata;
assert(r);
assert(i);
switch (event) {
case AVAHI_RESOLVER_FOUND: {
char address[AVAHI_ADDRESS_STR_MAX], *t;
avahi_address_snprint(address, sizeof(address), a);
t = avahi_string_list_to_string(txt);
print_service_line(i->config, '=', interface, protocol, name, type, domain, 0);
if (i->config->parsable)
printf(";%s;%s;%u;%s\n",
host_name,
address,
port,
t);
else
printf(" hostname = [%s]\n"
" address = [%s]\n"
" port = [%u]\n"
" txt = [%s]\n",
host_name,
address,
port,
t);
avahi_free(t);
break;
}
case AVAHI_RESOLVER_FAILURE:
fprintf(stderr, ("Failed to resolve service '%s' of type '%s' in domain '%s': %s\n"), name, type, domain, avahi_strerror(avahi_client_errno(client)));
break;
}
avahi_service_resolver_free(i->resolver);
i->resolver = NULL;
assert(n_resolving > 0);
n_resolving--;
check_terminate(i->config);
fflush(stdout);
}
int old_main(int argc, char *argv[]) {
struct zc_published_service service = {
.client = NULL,
.entry_group = NULL,
.config = NULL
};
char *zcp_argv[] = {"avahi-publish", "-s", "myservice", "_rtp._tcp", "12345", "Here it is"};
zc_publish_main(&service, 6, zcp_argv);
struct zc_queue *queue = create_queue_pointer();
char *zcb_argv[] = {"avahi-browse", "-a", "-p", "-r", "-t", "-v"};
zc_browse_main(queue, 6, zcb_argv);
struct zc_queue_elem *cursor = NULL;
struct zc_element *zc_elem = NULL;
char *t= NULL;
cursor = queue_pop_front(queue);
while (cursor != NULL){
zc_elem = (struct zc_element *)cursor;
t = avahi_string_list_to_string(zc_elem->txt_options);
fprintf(stdout, "Elem : %s:%d %s %s %s %s \n", zc_elem->address, zc_elem->port, zc_elem->ifname, zc_elem->hostname, zc_elem->type, t);
cursor = queue_pop_front(queue);
}
if (!service.entry_group) {
if (!(service.entry_group = avahi_entry_group_new(*(service.config->client), zcp_entry_group_callback, service.config))) {
fprintf(stdout, ("Failed to create entry group: %s\n"), avahi_strerror(avahi_client_errno(*(service.config->client))));
return -1;
}else{
fprintf(stdout, ("OK to create entry group: \n"));
}
}
//assert(avahi_entry_group_is_empty(service.entry_group));
fprintf(stderr, ("Name %s: \n"), service.config->name);
//
service.config->txt = avahi_string_list_add(NULL, "plop=ok");
avahi_entry_group_update_service_txt_strlst(service.entry_group, AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC, 0, service.config->name, service.config->stype, service.config->domain, service.config->txt);
//sleep(1);
char *zcb_argv2[] = {"avahi-browse", "-a", "-p", "-r", "-t", "-v"};
zc_browse_main(queue, 6, zcb_argv2);
cursor = queue_pop_front(queue);
while (cursor != NULL){
zc_elem = (struct zc_element *)cursor;
t = avahi_string_list_to_string(zc_elem->txt_options);
fprintf(stdout, "Elem : %s:%d %s %s %s \n", zc_elem->address, zc_elem->port, zc_elem->hostname, zc_elem->type, t);
cursor = queue_pop_front(queue);
}
// sleep(2);
// char *zcp_argv3[] = {"avahi-publish", "-s", "myservice", "_http._tcp", "12345", "Here it is 2 le retour"};
// zc_publish_main(&client, &simple_poll, &service2, 6, zcp_argv3);
//
// char *zcb_argv2[] = {"avahi-browse", "-a", "-p", "-r", "-t", "-v"};
// sleep(5);
// zc_browse_main(queue, 6, zcb_argv2);
queue_delete_queue_pointer(queue);
if (service.client){
fprintf(stderr, "Clean up client \n");
avahi_client_free(service.client);
}
if(service.config->simple_poll){
fprintf(stderr, "Clean up poll \n");
avahi_simple_poll_free(service.config->simple_poll);
}
if(service.config){
fprintf(stderr, "Clean up config \n");
free(service.config);
}
return 0;
}
int main(AVAHI_GCC_UNUSED int argc, AVAHI_GCC_UNUSED char *argv[]) {
char *t, *v;
uint8_t data[1024];
AvahiStringList *a = NULL, *b, *p;
size_t size, n;
int r;
a = avahi_string_list_new("prefix", "a", "b", NULL);
a = avahi_string_list_add(a, "start");
a = avahi_string_list_add(a, "foo=99");
a = avahi_string_list_add(a, "bar");
a = avahi_string_list_add(a, "");
a = avahi_string_list_add(a, "");
a = avahi_string_list_add(a, "quux");
a = avahi_string_list_add(a, "");
a = avahi_string_list_add_arbitrary(a, (const uint8_t*) "null\0null", 9);
a = avahi_string_list_add_printf(a, "seven=%i %c", 7, 'x');
a = avahi_string_list_add_pair(a, "blubb", "blaa");
a = avahi_string_list_add_pair(a, "uxknurz", NULL);
a = avahi_string_list_add_pair_arbitrary(a, "uxknurz2", (const uint8_t*) "blafasel\0oerks", 14);
a = avahi_string_list_add(a, "end");
t = avahi_string_list_to_string(a);
printf("--%s--\n", t);
avahi_free(t);
n = avahi_string_list_serialize(a, NULL, 0);
size = avahi_string_list_serialize(a, data, sizeof(data));
assert(size == n);
printf("%u\n", size);
for (t = (char*) data, n = 0; n < size; n++, t++) {
if (*t <= 32)
printf("(%u)", *t);
else
printf("%c", *t);
}
printf("\n");
assert(avahi_string_list_parse(data, size, &b) == 0);
printf("equal: %i\n", avahi_string_list_equal(a, b));
t = avahi_string_list_to_string(b);
printf("--%s--\n", t);
avahi_free(t);
avahi_string_list_free(b);
b = avahi_string_list_copy(a);
assert(avahi_string_list_equal(a, b));
t = avahi_string_list_to_string(b);
printf("--%s--\n", t);
avahi_free(t);
p = avahi_string_list_find(a, "seven");
assert(p);
r = avahi_string_list_get_pair(p, &t, &v, NULL);
assert(r >= 0);
assert(t);
assert(v);
printf("<%s>=<%s>\n", t, v);
avahi_free(t);
avahi_free(v);
p = avahi_string_list_find(a, "quux");
assert(p);
r = avahi_string_list_get_pair(p, &t, &v, NULL);
assert(r >= 0);
assert(t);
assert(!v);
printf("<%s>=<%s>\n", t, v);
avahi_free(t);
avahi_free(v);
avahi_string_list_free(a);
avahi_string_list_free(b);
n = avahi_string_list_serialize(NULL, NULL, 0);
size = avahi_string_list_serialize(NULL, data, sizeof(data));
assert(size == 1);
assert(size == n);
assert(avahi_string_list_parse(data, size, &a) == 0);
assert(!a);
return 0;
}
