1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
|
#include "subscribe.h"
#include "util.h"
static void elapse(AvahiTimeEvent *e, void *userdata) {
AvahiSubscription *s = userdata;
GTimeVal tv;
gchar *t;
g_assert(s);
avahi_server_post_query(s->server, s->interface, s->protocol, s->key);
if (s->n_query++ <= 8)
s->sec_delay *= 2;
g_message("%i. Continuous querying for %s", s->n_query, t = avahi_key_to_string(s->key));
g_free(t);
avahi_elapse_time(&tv, s->sec_delay*1000, 0);
avahi_time_event_queue_update(s->server->time_event_queue, s->time_event, &tv);
}
struct cbdata {
AvahiSubscription *subscription;
AvahiInterface *interface;
};
static gpointer scan_cache_callback(AvahiCache *c, AvahiKey *pattern, AvahiCacheEntry *e, gpointer userdata) {
struct cbdata *cbdata = userdata;
g_assert(c);
g_assert(pattern);
g_assert(e);
g_assert(cbdata);
cbdata->subscription->callback(
cbdata->subscription,
e->record,
cbdata->interface->hardware->index,
cbdata->interface->protocol,
AVAHI_SUBSCRIPTION_NEW,
cbdata->subscription->userdata);
return NULL;
}
static void scan_interface_callback(AvahiInterfaceMonitor *m, AvahiInterface *i, gpointer userdata) {
AvahiSubscription *s = userdata;
struct cbdata cbdata = { s, i };
g_assert(m);
g_assert(i);
g_assert(s);
avahi_cache_walk(i->cache, s->key, scan_cache_callback, &cbdata);
}
AvahiSubscription *avahi_subscription_new(AvahiServer *server, AvahiKey *key, gint interface, guchar protocol, AvahiSubscriptionCallback callback, gpointer userdata) {
AvahiSubscription *s, *t;
GTimeVal tv;
g_assert(server);
g_assert(key);
g_assert(callback);
g_assert(!avahi_key_is_pattern(key));
s = g_new(AvahiSubscription, 1);
s->server = server;
s->key = avahi_key_ref(key);
s->interface = interface;
s->protocol = protocol;
s->callback = callback;
s->userdata = userdata;
s->n_query = 1;
s->sec_delay = 1;
avahi_server_post_query(s->server, s->interface, s->protocol, s->key);
avahi_elapse_time(&tv, s->sec_delay*1000, 0);
s->time_event = avahi_time_event_queue_add(server->time_event_queue, &tv, elapse, s);
AVAHI_LLIST_PREPEND(AvahiSubscription, subscriptions, server->subscriptions, s);
/* Add the new entry to the subscription hash table */
t = g_hash_table_lookup(server->subscription_hashtable, key);
AVAHI_LLIST_PREPEND(AvahiSubscription, by_key, t, s);
g_hash_table_replace(server->subscription_hashtable, key, t);
/* Scan the caches */
avahi_interface_monitor_walk(s->server->monitor, s->interface, s->protocol, scan_interface_callback, s);
return s;
}
void avahi_subscription_free(AvahiSubscription *s) {
AvahiSubscription *t;
g_assert(s);
AVAHI_LLIST_REMOVE(AvahiSubscription, subscriptions, s->server->subscriptions, s);
t = g_hash_table_lookup(s->server->subscription_hashtable, s->key);
AVAHI_LLIST_REMOVE(AvahiSubscription, by_key, t, s);
if (t)
g_hash_table_replace(s->server->subscription_hashtable, t->key, t);
else
g_hash_table_remove(s->server->subscription_hashtable, s->key);
avahi_time_event_queue_remove(s->server->time_event_queue, s->time_event);
avahi_key_unref(s->key);
g_free(s);
}
void avahi_subscription_notify(AvahiServer *server, AvahiInterface *i, AvahiRecord *record, AvahiSubscriptionEvent event) {
AvahiSubscription *s;
AvahiKey *pattern;
g_assert(server);
g_assert(record);
for (s = g_hash_table_lookup(server->subscription_hashtable, record->key); s; s = s->by_key_next)
if (avahi_interface_match(i, s->interface, s->protocol))
s->callback(s, record, i->hardware->index, i->protocol, event, s->userdata);
}
gboolean avahi_is_subscribed(AvahiServer *server, AvahiKey *k) {
g_assert(server);
g_assert(k);
return !!g_hash_table_lookup(server->subscription_hashtable, k);
}
|
