1 /***
2 This file is part of avahi.
3
4 avahi is free software; you can redistribute it and/or modify it
5 under the terms of the GNU Lesser General Public License as
6 published by the Free Software Foundation; either version 2.1 of the
7 License, or (at your option) any later version.
8
9 avahi is distributed in the hope that it will be useful, but WITHOUT
10 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
11 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General
12 Public License for more details.
13
14 You should have received a copy of the GNU Lesser General Public
15 License along with avahi; if not, write to the Free Software
16 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
17 USA.
18 ***/
19
20 #ifdef HAVE_CONFIG_H
21 #include <config.h>
22 #endif
23
24 #include <string.h>
25
26 #include <avahi-common/domain.h>
27 #include <avahi-common/malloc.h>
28 #include <avahi-common/error.h>
29
30 #include "browse.h"
31 #include "log.h"
32 #include "rr.h"
33
34 typedef struct AvahiDNSServerInfo AvahiDNSServerInfo;
35
36 struct AvahiDNSServerInfo {
37 AvahiSDNSServerBrowser *browser;
38
39 AvahiIfIndex interface;
40 AvahiProtocol protocol;
41 AvahiRecord *srv_record;
42 AvahiSHostNameResolver *host_name_resolver;
43 AvahiAddress address;
44 AvahiLookupResultFlags flags;
45
46 AVAHI_LLIST_FIELDS(AvahiDNSServerInfo, info);
47 };
48
49 struct AvahiSDNSServerBrowser {
50 AvahiServer *server;
51
52 AvahiSRecordBrowser *record_browser;
53 AvahiSDNSServerBrowserCallback callback;
54 void* userdata;
55 AvahiProtocol aprotocol;
56 AvahiLookupFlags user_flags;
57
58 unsigned n_info;
59
60 AVAHI_LLIST_FIELDS(AvahiSDNSServerBrowser, browser);
61 AVAHI_LLIST_HEAD(AvahiDNSServerInfo, info);
62 };
63
get_server_info(AvahiSDNSServerBrowser * b,AvahiIfIndex interface,AvahiProtocol protocol,AvahiRecord * r)64 static AvahiDNSServerInfo* get_server_info(AvahiSDNSServerBrowser *b, AvahiIfIndex interface, AvahiProtocol protocol, AvahiRecord *r) {
65 AvahiDNSServerInfo *i;
66
67 assert(b);
68 assert(r);
69
70 for (i = b->info; i; i = i->info_next)
71 if (i->interface == interface &&
72 i->protocol == protocol &&
73 avahi_record_equal_no_ttl(r, i->srv_record))
74 return i;
75
76 return NULL;
77 }
78
server_info_free(AvahiSDNSServerBrowser * b,AvahiDNSServerInfo * i)79 static void server_info_free(AvahiSDNSServerBrowser *b, AvahiDNSServerInfo *i) {
80 assert(b);
81 assert(i);
82
83 avahi_record_unref(i->srv_record);
84 if (i->host_name_resolver)
85 avahi_s_host_name_resolver_free(i->host_name_resolver);
86
87 AVAHI_LLIST_REMOVE(AvahiDNSServerInfo, info, b->info, i);
88
89 assert(b->n_info >= 1);
90 b->n_info--;
91
92 avahi_free(i);
93 }
94
host_name_resolver_callback(AvahiSHostNameResolver * r,AVAHI_GCC_UNUSED AvahiIfIndex interface,AVAHI_GCC_UNUSED AvahiProtocol protocol,AvahiResolverEvent event,const char * host_name,const AvahiAddress * a,AvahiLookupResultFlags flags,void * userdata)95 static void host_name_resolver_callback(
96 AvahiSHostNameResolver *r,
97 AVAHI_GCC_UNUSED AvahiIfIndex interface,
98 AVAHI_GCC_UNUSED AvahiProtocol protocol,
99 AvahiResolverEvent event,
100 const char *host_name,
101 const AvahiAddress *a,
102 AvahiLookupResultFlags flags,
103 void* userdata) {
104
105 AvahiDNSServerInfo *i = userdata;
106
107 assert(r);
108 assert(host_name);
109 assert(i);
110
111 switch (event) {
112 case AVAHI_RESOLVER_FOUND: {
113 i->address = *a;
114
115 i->browser->callback(
116 i->browser,
117 i->interface,
118 i->protocol,
119 AVAHI_BROWSER_NEW,
120 i->srv_record->data.srv.name,
121 &i->address,
122 i->srv_record->data.srv.port,
123 i->flags | flags,
124 i->browser->userdata);
125
126 break;
127 }
128
129 case AVAHI_RESOLVER_FAILURE:
130 /* Ignore */
131 break;
132 }
133
134 avahi_s_host_name_resolver_free(i->host_name_resolver);
135 i->host_name_resolver = NULL;
136 }
137
record_browser_callback(AvahiSRecordBrowser * rr,AvahiIfIndex interface,AvahiProtocol protocol,AvahiBrowserEvent event,AvahiRecord * record,AvahiLookupResultFlags flags,void * userdata)138 static void record_browser_callback(
139 AvahiSRecordBrowser*rr,
140 AvahiIfIndex interface,
141 AvahiProtocol protocol,
142 AvahiBrowserEvent event,
143 AvahiRecord *record,
144 AvahiLookupResultFlags flags,
145 void* userdata) {
146
147 AvahiSDNSServerBrowser *b = userdata;
148
149 assert(rr);
150 assert(b);
151
152 /* Filter flags */
153 flags &= AVAHI_LOOKUP_RESULT_CACHED | AVAHI_LOOKUP_RESULT_MULTICAST | AVAHI_LOOKUP_RESULT_WIDE_AREA;
154
155 switch (event) {
156 case AVAHI_BROWSER_NEW: {
157 AvahiDNSServerInfo *i;
158
159 assert(record);
160 assert(record->key->type == AVAHI_DNS_TYPE_SRV);
161
162 if (get_server_info(b, interface, protocol, record))
163 return;
164
165 if (b->n_info >= 10)
166 return;
167
168 if (!(i = avahi_new(AvahiDNSServerInfo, 1)))
169 return; /* OOM */
170
171 i->browser = b;
172 i->interface = interface;
173 i->protocol = protocol;
174 i->srv_record = avahi_record_ref(record);
175 i->host_name_resolver = avahi_s_host_name_resolver_prepare(
176 b->server,
177 interface, protocol,
178 record->data.srv.name,
179 b->aprotocol,
180 b->user_flags,
181 host_name_resolver_callback, i);
182 i->flags = flags;
183
184 if(i->host_name_resolver)
185 avahi_s_host_name_resolver_start(i->host_name_resolver);
186
187 AVAHI_LLIST_PREPEND(AvahiDNSServerInfo, info, b->info, i);
188
189 b->n_info++;
190 break;
191 }
192
193 case AVAHI_BROWSER_REMOVE: {
194 AvahiDNSServerInfo *i;
195
196 assert(record);
197 assert(record->key->type == AVAHI_DNS_TYPE_SRV);
198
199 if (!(i = get_server_info(b, interface, protocol, record)))
200 return;
201
202 if (!i->host_name_resolver)
203 b->callback(
204 b,
205 interface,
206 protocol,
207 event,
208 i->srv_record->data.srv.name,
209 &i->address,
210 i->srv_record->data.srv.port,
211 i->flags | flags,
212 b->userdata);
213
214 server_info_free(b, i);
215 break;
216 }
217
218 case AVAHI_BROWSER_FAILURE:
219 case AVAHI_BROWSER_ALL_FOR_NOW:
220 case AVAHI_BROWSER_CACHE_EXHAUSTED:
221
222 b->callback(
223 b,
224 interface,
225 protocol,
226 event,
227 NULL,
228 NULL,
229 0,
230 flags,
231 b->userdata);
232
233 break;
234 }
235 }
236
avahi_s_dns_server_browser_prepare(AvahiServer * server,AvahiIfIndex interface,AvahiProtocol protocol,const char * domain,AvahiDNSServerType type,AvahiProtocol aprotocol,AvahiLookupFlags flags,AvahiSDNSServerBrowserCallback callback,void * userdata)237 AvahiSDNSServerBrowser *avahi_s_dns_server_browser_prepare(
238 AvahiServer *server,
239 AvahiIfIndex interface,
240 AvahiProtocol protocol,
241 const char *domain,
242 AvahiDNSServerType type,
243 AvahiProtocol aprotocol,
244 AvahiLookupFlags flags,
245 AvahiSDNSServerBrowserCallback callback,
246 void* userdata) {
247
248 static const char * const type_table[AVAHI_DNS_SERVER_MAX] = {
249 "_domain._udp",
250 "_dns-update._udp"
251 };
252
253 AvahiSDNSServerBrowser *b;
254 AvahiKey *k = NULL;
255 char n[AVAHI_DOMAIN_NAME_MAX];
256 int r;
257
258 assert(server);
259 assert(callback);
260
261 AVAHI_CHECK_VALIDITY_RETURN_NULL(server, AVAHI_IF_VALID(interface), AVAHI_ERR_INVALID_INTERFACE);
262 AVAHI_CHECK_VALIDITY_RETURN_NULL(server, AVAHI_PROTO_VALID(protocol), AVAHI_ERR_INVALID_PROTOCOL);
263 AVAHI_CHECK_VALIDITY_RETURN_NULL(server, AVAHI_PROTO_VALID(aprotocol), AVAHI_ERR_INVALID_PROTOCOL);
264 AVAHI_CHECK_VALIDITY_RETURN_NULL(server, !domain || avahi_is_valid_domain_name(domain), AVAHI_ERR_INVALID_DOMAIN_NAME);
265 AVAHI_CHECK_VALIDITY_RETURN_NULL(server, AVAHI_FLAGS_VALID(flags, AVAHI_LOOKUP_USE_WIDE_AREA|AVAHI_LOOKUP_USE_MULTICAST), AVAHI_ERR_INVALID_FLAGS);
266 AVAHI_CHECK_VALIDITY_RETURN_NULL(server, type < AVAHI_DNS_SERVER_MAX, AVAHI_ERR_INVALID_FLAGS);
267
268 if (!domain)
269 domain = server->domain_name;
270
271 if ((r = avahi_service_name_join(n, sizeof(n), NULL, type_table[type], domain)) < 0) {
272 avahi_server_set_errno(server, r);
273 return NULL;
274 }
275
276 if (!(b = avahi_new(AvahiSDNSServerBrowser, 1))) {
277 avahi_server_set_errno(server, AVAHI_ERR_NO_MEMORY);
278 return NULL;
279 }
280
281 b->server = server;
282 b->callback = callback;
283 b->userdata = userdata;
284 b->aprotocol = aprotocol;
285 b->n_info = 0;
286 b->user_flags = flags;
287
288 AVAHI_LLIST_HEAD_INIT(AvahiDNSServerInfo, b->info);
289 AVAHI_LLIST_PREPEND(AvahiSDNSServerBrowser, browser, server->dns_server_browsers, b);
290
291 if (!(k = avahi_key_new(n, AVAHI_DNS_CLASS_IN, AVAHI_DNS_TYPE_SRV))) {
292 avahi_server_set_errno(server, AVAHI_ERR_NO_MEMORY);
293 goto fail;
294 }
295
296 if (!(b->record_browser = avahi_s_record_browser_prepare(server, interface, protocol, k, flags, record_browser_callback, b)))
297 goto fail;
298
299 avahi_key_unref(k);
300
301 return b;
302
303 fail:
304
305 if (k)
306 avahi_key_unref(k);
307
308 avahi_s_dns_server_browser_free(b);
309 return NULL;
310 }
311
avahi_s_dns_server_browser_start(AvahiSDNSServerBrowser * b)312 void avahi_s_dns_server_browser_start(AvahiSDNSServerBrowser *b) {
313 assert(b);
314
315 if(b->record_browser)
316 avahi_s_record_browser_start_query(b->record_browser);
317 }
318
avahi_s_dns_server_browser_free(AvahiSDNSServerBrowser * b)319 void avahi_s_dns_server_browser_free(AvahiSDNSServerBrowser *b) {
320 assert(b);
321
322 while (b->info)
323 server_info_free(b, b->info);
324
325 AVAHI_LLIST_REMOVE(AvahiSDNSServerBrowser, browser, b->server->dns_server_browsers, b);
326
327 if (b->record_browser)
328 avahi_s_record_browser_free(b->record_browser);
329
330 avahi_free(b);
331 }
332
avahi_s_dns_server_browser_new(AvahiServer * server,AvahiIfIndex interface,AvahiProtocol protocol,const char * domain,AvahiDNSServerType type,AvahiProtocol aprotocol,AvahiLookupFlags flags,AvahiSDNSServerBrowserCallback callback,void * userdata)333 AvahiSDNSServerBrowser *avahi_s_dns_server_browser_new(
334 AvahiServer *server,
335 AvahiIfIndex interface,
336 AvahiProtocol protocol,
337 const char *domain,
338 AvahiDNSServerType type,
339 AvahiProtocol aprotocol,
340 AvahiLookupFlags flags,
341 AvahiSDNSServerBrowserCallback callback,
342 void* userdata) {
343 AvahiSDNSServerBrowser* b;
344
345 b = avahi_s_dns_server_browser_prepare(server, interface, protocol, domain, type, aprotocol, flags, callback, userdata);
346 avahi_s_dns_server_browser_start(b);
347
348 return b;
349 }