static ServiceInfo *find_service(AvahiIfIndex interface, AvahiProtocol protocol, const char *name, const char *type, const char *domain) {
ServiceInfo *i;
for (i = services; i; i = i->info_next)
if (i->interface == interface &&
i->protocol == protocol &&
strcasecmp(i->name, name) == 0 &&
avahi_domain_equal(i->type, type) &&
avahi_domain_equal(i->domain, domain))
return i;
return NULL;
}
void NetworkServicesProviderAvahi::browseServiceType(const char* stype, const char* domain)
{
AvahiServiceBrowser* b;
AvahiStringList* i;
ASSERT(stype);
for (i = m_browsedTypes; i; i = i->next)
if (avahi_domain_equal(stype, (char*) i->text))
return;
if (!(b = avahi_service_browser_new(
m_avahiClient,
AVAHI_IF_UNSPEC,
AVAHI_PROTO_UNSPEC,
stype,
domain,
(AvahiLookupFlags)0,
serviceBrowserCallback,
static_cast<void*>(this))))
{
LOG_ERROR("avahi_service_browser_new() failed: %s\n", avahi_strerror(avahi_client_errno(m_avahiClient)));
}
m_browsedTypes = avahi_string_list_add(m_browsedTypes, stype);
m_allForNow++;
}
static void browse_service_type(Config *c, const char *stype, const char *domain) {
AvahiServiceBrowser *b;
AvahiStringList *i;
assert(c);
assert(client);
assert(stype);
for (i = browsed_types; i; i = i->next)
if (avahi_domain_equal(stype, (char*) i->text))
return;
if (!(b = avahi_service_browser_new(
client,
AVAHI_IF_UNSPEC,
AVAHI_PROTO_UNSPEC,
stype,
domain,
0,
service_browser_callback,
c))) {
fprintf(stderr, ("avahi_service_browser_new() failed: %s\n"), avahi_strerror(avahi_client_errno(client)));
avahi_simple_poll_quit(simple_poll);
}
browsed_types = avahi_string_list_add(browsed_types, stype);
n_all_for_now++;
n_cache_exhausted++;
}
static struct Service *get_service(const gchar *service_type, const gchar *service_name, const gchar*domain_name, AvahiIfIndex interface, AvahiProtocol protocol) {
struct ServiceType *st;
GList *l;
if (!(st = g_hash_table_lookup(service_type_hash_table, service_type)))
return NULL;
for (l = st->services; l; l = l->next) {
struct Service *s = l->data;
if (s->interface == interface &&
s->protocol == protocol &&
avahi_domain_equal(s->service_name, service_name) &&
avahi_domain_equal(s->domain_name, domain_name))
return s;
}
return NULL;
}
static int packet_add_probe_query(AvahiProbeScheduler *s, AvahiDnsPacket *p, AvahiProbeJob *pj) {
size_t size;
AvahiKey *k;
int b;
assert(s);
assert(p);
assert(pj);
assert(!pj->chosen);
/* Estimate the size for this record */
size =
avahi_key_get_estimate_size(pj->record->key) +
avahi_record_get_estimate_size(pj->record);
/* Too large */
if (size > avahi_dns_packet_space(p))
return 0;
/* Create the probe query */
if (!(k = avahi_key_new(pj->record->key->name, pj->record->key->clazz, AVAHI_DNS_TYPE_ANY)))
return 0; /* OOM */
b = !!avahi_dns_packet_append_key(p, k, 0);
assert(b);
/* Mark this job for addition to the packet */
pj->chosen = 1;
/* Scan for more jobs whith matching key pattern */
for (pj = s->jobs; pj; pj = pj->jobs_next) {
if (pj->chosen)
continue;
/* Does the record match the probe? */
if (k->clazz != pj->record->key->clazz || !avahi_domain_equal(k->name, pj->record->key->name))
continue;
/* This job wouldn't fit in */
if (avahi_record_get_estimate_size(pj->record) > avahi_dns_packet_space(p))
break;
/* Mark this job for addition to the packet */
pj->chosen = 1;
}
avahi_key_unref(k);
return 1;
}
ServiceInfo* NetworkServicesProviderAvahi::findService(
AvahiIfIndex interface,
AvahiProtocol protocol,
const char* name,
const char* type,
const char* domain)
{
ServiceInfo* i;
for (i = m_services; i; i = i->info_next) {
// TODO : Need to deal case of several interface
if (i->interface == interface
&& !strcasecmp(i->name, name)
&& avahi_domain_equal(i->type, type)
&& avahi_domain_equal(i->domain, domain)) {
// check protocol IPv4 / IPv6
if (i->protocol == protocol)
i->notify = true;
return i;
}
}
return 0;
}
int avahi_domain_ends_with(const char *domain, const char *suffix) {
assert(domain);
assert(suffix);
for (;;) {
char dummy[AVAHI_LABEL_MAX], *r;
if (*domain == 0)
return 0;
if (avahi_domain_equal(domain, suffix))
return 1;
r = avahi_unescape_label(&domain, dummy, sizeof(dummy));
assert(r);
}
}
static AvahiStringList *filter_duplicate_domains(AvahiStringList *l) {
AvahiStringList *e, *n, *p;
if (!l)
return l;
for (p = l, e = l->next; e; e = n) {
n = e->next;
if (avahi_domain_equal((char*) e->text, (char*) l->text)) {
p->next = e->next;
avahi_free(e);
} else
p = e;
}
l->next = filter_duplicate_domains(l->next);
return l;
}
static void record_browser_callback(
AvahiSRecordBrowser*rr,
AvahiIfIndex interface,
AvahiProtocol protocol,
AvahiBrowserEvent event,
AvahiRecord *record,
AvahiLookupResultFlags flags,
void* userdata) {
AvahiSDomainBrowser *b = userdata;
char *n = NULL;
assert(rr);
assert(b);
if (event == AVAHI_BROWSER_ALL_FOR_NOW &&
b->defer_event) {
b->all_for_now_scheduled = 1;
return;
}
/* Filter flags */
flags &= AVAHI_LOOKUP_RESULT_CACHED | AVAHI_LOOKUP_RESULT_MULTICAST | AVAHI_LOOKUP_RESULT_WIDE_AREA;
if (record) {
assert(record->key->type == AVAHI_DNS_TYPE_PTR);
n = record->data.ptr.name;
if (b->type == AVAHI_DOMAIN_BROWSER_BROWSE) {
AvahiStringList *l;
/* Filter out entries defined statically */
for (l = b->server->config.browse_domains; l; l = l->next)
if (avahi_domain_equal((char*) l->text, n))
return;
}
}
b->callback(b, interface, protocol, event, n, flags, b->userdata);
}
/* Remove a service from the host list */
static void remove_service(struct daemon_data *d, AvahiIfIndex interface, AvahiProtocol protocol, const char *name, const char *domain) {
struct host *h, *p = NULL;
assert(d);
for (h = d->hosts; h; h = h->next) {
if (h->interface == interface &&
h->protocol == protocol &&
!strcmp(h->service, name) &&
avahi_domain_equal(h->domain, domain)) {
if (p)
p->next = h->next;
else
d->hosts = h->next;
free_host(h);
break;
} else
p = h;
}
}
int main(int argc, char*argv[]) {
GtkWidget *d;
gtk_init(&argc, &argv);
if (g_str_has_suffix(argv[0], "bvnc")) {
d = aui_service_dialog_new("Choose VNC server", NULL, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_CONNECT, GTK_RESPONSE_ACCEPT, NULL);
aui_service_dialog_set_browse_service_types(AUI_SERVICE_DIALOG(d), "_rfb._tcp", NULL);
} else {
d = aui_service_dialog_new("Choose SSH server", NULL, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_CONNECT, GTK_RESPONSE_ACCEPT, NULL);
aui_service_dialog_set_browse_service_types(AUI_SERVICE_DIALOG(d), "_ssh._tcp", NULL);
}
aui_service_dialog_set_resolve_service(AUI_SERVICE_DIALOG(d), TRUE);
aui_service_dialog_set_resolve_host_name(AUI_SERVICE_DIALOG(d), !avahi_nss_support());
gtk_window_present(GTK_WINDOW(d));
if (gtk_dialog_run(GTK_DIALOG(d)) == GTK_RESPONSE_ACCEPT) {
char a[AVAHI_ADDRESS_STR_MAX], *u = NULL, *n = NULL;
char *h = NULL, *t = NULL;
const AvahiStringList *txt;
t = g_strdup(aui_service_dialog_get_service_type(AUI_SERVICE_DIALOG(d)));
n = g_strdup(aui_service_dialog_get_service_name(AUI_SERVICE_DIALOG(d)));
if (avahi_nss_support())
h = g_strdup(aui_service_dialog_get_host_name(AUI_SERVICE_DIALOG(d)));
else
h = g_strdup(avahi_address_snprint(a, sizeof(a), aui_service_dialog_get_address(AUI_SERVICE_DIALOG(d))));
g_print("Connecting to '%s' ...\n", n);
if (avahi_domain_equal(t, "_rfb._tcp")) {
char p[AVAHI_DOMAIN_NAME_MAX+16];
snprintf(p, sizeof(p), "%s:%u", h, aui_service_dialog_get_port(AUI_SERVICE_DIALOG(d))-5900);
gtk_widget_destroy(d);
g_print("xvncviewer %s\n", p);
execlp("xvncviewer", "xvncviewer", p, NULL);
} else {
char p[16];
snprintf(p, sizeof(p), "%u", aui_service_dialog_get_port(AUI_SERVICE_DIALOG(d)));
for (txt = aui_service_dialog_get_txt_data(AUI_SERVICE_DIALOG(d)); txt; txt = txt->next) {
char *key, *value;
if (avahi_string_list_get_pair((AvahiStringList*) txt, &key, &value, NULL) < 0)
break;
if (strcmp(key, "u") == 0)
u = g_strdup(value);
avahi_free(key);
avahi_free(value);
}
gtk_widget_destroy(d);
if (u) {
g_print("ssh -p %s -l %s %s\n", p, u, h);
if (isatty(0) || !getenv("DISPLAY"))
execlp("ssh", "ssh", "-p", p, "-l", u, h, NULL);
else {
execlp("x-terminal-emulator", "x-terminal-emulator", "-T", n, "-e", "ssh", "-p", p, "-l", u, h, NULL);
execlp("gnome-terminal", "gnome-terminal", "-t", n, "-x", "ssh", "-p", p, "-l", u, h, NULL);
execlp("xterm", "xterm", "-T", n, "-e", "ssh", "-p", p, "-l", u, h, NULL);
}
} else {
g_print("ssh -p %s %s\n", p, h);
if (isatty(0) || !getenv("DISPLAY"))
execlp("ssh", "ssh", "-p", p, h, NULL);
else {
execlp("x-terminal-emulator", "x-terminal-emulator", "-T", n, "-e", "ssh", "-p", p, h, NULL);
execlp("gnome-terminal", "gnome-terminal", "-t", n, "-x", "ssh", "-p", p, h, NULL);
execlp("xterm", "xterm", "-T", n, "-e", "ssh", "-p", p, h, NULL);
}
}
}
g_warning("execlp() failed: %s\n", strerror(errno));
g_free(h);
g_free(u);
g_free(t);
g_free(n);
} else {
gtk_widget_destroy(d);
g_print("Canceled.\n");
}
return 1;
}
int main(AVAHI_GCC_UNUSED int argc, AVAHI_GCC_UNUSED char *argv[]) {
char t[AVAHI_DOMAIN_NAME_MAX], *m;
const char *a, *b, *c, *d;
AvahiDnsPacket *p;
AvahiRecord *r, *r2;
uint8_t rdata[AVAHI_DNS_RDATA_MAX];
size_t l;
p = avahi_dns_packet_new(0);
assert(avahi_dns_packet_append_name(p, a = "Ahello.hello.hello.de."));
assert(avahi_dns_packet_append_name(p, b = "Bthis is a test.hello.de."));
assert(avahi_dns_packet_append_name(p, c = "Cthis\\.is\\.a\\.test\\.with\\.dots.hello.de."));
assert(avahi_dns_packet_append_name(p, d = "Dthis\\\\is another test.hello.de."));
avahi_hexdump(AVAHI_DNS_PACKET_DATA(p), p->size);
assert(avahi_dns_packet_consume_name(p, t, sizeof(t)) == 0);
avahi_log_debug(">%s<", t);
assert(avahi_domain_equal(a, t));
assert(avahi_dns_packet_consume_name(p, t, sizeof(t)) == 0);
avahi_log_debug(">%s<", t);
assert(avahi_domain_equal(b, t));
assert(avahi_dns_packet_consume_name(p, t, sizeof(t)) == 0);
avahi_log_debug(">%s<", t);
assert(avahi_domain_equal(c, t));
assert(avahi_dns_packet_consume_name(p, t, sizeof(t)) == 0);
avahi_log_debug(">%s<", t);
assert(avahi_domain_equal(d, t));
avahi_dns_packet_free(p);
/* RDATA PARSING AND SERIALIZATION */
/* Create an AvahiRecord with some usful data */
r = avahi_record_new_full("foobar.local", AVAHI_DNS_CLASS_IN, AVAHI_DNS_TYPE_HINFO, AVAHI_DEFAULT_TTL);
assert(r);
r->data.hinfo.cpu = avahi_strdup("FOO");
r->data.hinfo.os = avahi_strdup("BAR");
/* Serialize it into a blob */
assert((l = avahi_rdata_serialize(r, rdata, sizeof(rdata))) != (size_t) -1);
/* Print it */
avahi_hexdump(rdata, l);
/* Create a new record and fill in the data from the blob */
r2 = avahi_record_new(r->key, AVAHI_DEFAULT_TTL);
assert(r2);
assert(avahi_rdata_parse(r2, rdata, l) >= 0);
/* Compare both versions */
assert(avahi_record_equal_no_ttl(r, r2));
/* Free the records */
avahi_record_unref(r);
avahi_record_unref(r2);
r = avahi_record_new_full("foobar", 77, 77, AVAHI_DEFAULT_TTL);
assert(r);
assert(r->data.generic.data = avahi_memdup("HALLO", r->data.generic.size = 5));
m = avahi_record_to_string(r);
assert(m);
avahi_log_debug(">%s<", m);
avahi_free(m);
avahi_record_unref(r);
return 0;
}
DBusHandlerResult avahi_domain_browser_event (AvahiClient *client, AvahiBrowserEvent event, DBusMessage *message) {
AvahiDomainBrowser *db = NULL;
DBusError error;
const char *path;
char *domain = NULL;
int32_t interface, protocol;
uint32_t flags = 0;
AvahiStringList *l;
assert(client);
assert(message);
dbus_error_init (&error);
if (!(path = dbus_message_get_path(message)))
goto fail;
for (db = client->domain_browsers; db; db = db->domain_browsers_next)
if (strcmp (db->path, path) == 0)
break;
if (!db)
goto fail;
interface = db->interface;
protocol = db->protocol;
switch (event) {
case AVAHI_BROWSER_NEW:
case AVAHI_BROWSER_REMOVE:
if (!dbus_message_get_args(
message, &error,
DBUS_TYPE_INT32, &interface,
DBUS_TYPE_INT32, &protocol,
DBUS_TYPE_STRING, &domain,
DBUS_TYPE_UINT32, &flags,
DBUS_TYPE_INVALID) ||
dbus_error_is_set (&error)) {
fprintf(stderr, "Failed to parse browser event.\n");
goto fail;
}
break;
case AVAHI_BROWSER_CACHE_EXHAUSTED:
case AVAHI_BROWSER_ALL_FOR_NOW:
break;
case AVAHI_BROWSER_FAILURE: {
char *etxt;
if (!dbus_message_get_args(
message, &error,
DBUS_TYPE_STRING, &etxt,
DBUS_TYPE_INVALID) ||
dbus_error_is_set (&error)) {
fprintf(stderr, "Failed to parse browser event.\n");
goto fail;
}
avahi_client_set_errno(db->client, avahi_error_dbus_to_number(etxt));
break;
}
}
if (domain)
for (l = db->static_browse_domains; l; l = l->next)
if (avahi_domain_equal((char*) l->text, domain)) {
/* We had this entry already in the static entries */
return DBUS_HANDLER_RESULT_HANDLED;
}
db->callback(db, (AvahiIfIndex) interface, (AvahiProtocol) protocol, event, domain, (AvahiLookupResultFlags) flags, db->userdata);
return DBUS_HANDLER_RESULT_HANDLED;
fail:
dbus_error_free (&error);
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
