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 #include <stdio.h>
26 #include <stdlib.h>
27
28 #include <avahi-common/domain.h>
29 #include <avahi-common/timeval.h>
30 #include <avahi-common/malloc.h>
31 #include <avahi-common/error.h>
32
33 #include "browse.h"
34 #include "log.h"
35
36 #define TIMEOUT_MSEC 5000
37
38 struct AvahiSServiceResolver {
39 AvahiServer *server;
40 char *service_name;
41 char *service_type;
42 char *domain_name;
43 AvahiProtocol address_protocol;
44
45 AvahiIfIndex interface;
46 AvahiProtocol protocol;
47
48 AvahiSRecordBrowser *record_browser_srv;
49 AvahiSRecordBrowser *record_browser_txt;
50 AvahiSRecordBrowser *record_browser_a;
51 AvahiSRecordBrowser *record_browser_aaaa;
52
53 AvahiRecord *srv_record, *txt_record, *address_record;
54 AvahiLookupResultFlags srv_flags, txt_flags, address_flags;
55
56 AvahiSServiceResolverCallback callback;
57 void* userdata;
58 AvahiLookupFlags user_flags;
59
60 AvahiTimeEvent *time_event;
61
62 AVAHI_LLIST_FIELDS(AvahiSServiceResolver, resolver);
63 };
64
finish(AvahiSServiceResolver * r,AvahiResolverEvent event)65 static void finish(AvahiSServiceResolver *r, AvahiResolverEvent event) {
66 AvahiLookupResultFlags flags;
67
68 assert(r);
69
70 if (r->time_event) {
71 avahi_time_event_free(r->time_event);
72 r->time_event = NULL;
73 }
74
75 flags =
76 r->txt_flags |
77 r->srv_flags |
78 r->address_flags;
79
80 switch (event) {
81 case AVAHI_RESOLVER_FAILURE:
82
83 r->callback(
84 r,
85 r->interface,
86 r->protocol,
87 event,
88 r->service_name,
89 r->service_type,
90 r->domain_name,
91 NULL,
92 NULL,
93 0,
94 NULL,
95 flags,
96 r->userdata);
97
98 break;
99
100 case AVAHI_RESOLVER_FOUND: {
101 AvahiAddress a;
102
103 assert(event == AVAHI_RESOLVER_FOUND);
104
105 assert(r->srv_record);
106
107 if (r->address_record) {
108 switch (r->address_record->key->type) {
109 case AVAHI_DNS_TYPE_A:
110 a.proto = AVAHI_PROTO_INET;
111 a.data.ipv4 = r->address_record->data.a.address;
112 break;
113
114 case AVAHI_DNS_TYPE_AAAA:
115 a.proto = AVAHI_PROTO_INET6;
116 a.data.ipv6 = r->address_record->data.aaaa.address;
117 break;
118
119 default:
120 assert(0);
121 }
122 }
123
124 r->callback(
125 r,
126 r->interface,
127 r->protocol,
128 event,
129 r->service_name,
130 r->service_type,
131 r->domain_name,
132 r->srv_record->data.srv.name,
133 r->address_record ? &a : NULL,
134 r->srv_record->data.srv.port,
135 r->txt_record ? r->txt_record->data.txt.string_list : NULL,
136 flags,
137 r->userdata);
138
139 break;
140 }
141 }
142 }
143
time_event_callback(AvahiTimeEvent * e,void * userdata)144 static void time_event_callback(AvahiTimeEvent *e, void *userdata) {
145 AvahiSServiceResolver *r = userdata;
146
147 assert(e);
148 assert(r);
149
150 avahi_server_set_errno(r->server, AVAHI_ERR_TIMEOUT);
151 finish(r, AVAHI_RESOLVER_FAILURE);
152 }
153
start_timeout(AvahiSServiceResolver * r)154 static void start_timeout(AvahiSServiceResolver *r) {
155 struct timeval tv;
156 assert(r);
157
158 if (r->time_event)
159 return;
160
161 avahi_elapse_time(&tv, TIMEOUT_MSEC, 0);
162
163 r->time_event = avahi_time_event_new(r->server->time_event_queue, &tv, time_event_callback, r);
164 }
165
record_browser_callback(AvahiSRecordBrowser * rr,AvahiIfIndex interface,AvahiProtocol protocol,AvahiBrowserEvent event,AvahiRecord * record,AvahiLookupResultFlags flags,void * userdata)166 static void record_browser_callback(
167 AvahiSRecordBrowser*rr,
168 AvahiIfIndex interface,
169 AvahiProtocol protocol,
170 AvahiBrowserEvent event,
171 AvahiRecord *record,
172 AvahiLookupResultFlags flags,
173 void* userdata) {
174
175 AvahiSServiceResolver *r = userdata;
176
177 assert(rr);
178 assert(r);
179
180 if (rr == r->record_browser_aaaa || rr == r->record_browser_a)
181 r->address_flags = flags;
182 else if (rr == r->record_browser_srv)
183 r->srv_flags = flags;
184 else if (rr == r->record_browser_txt)
185 r->txt_flags = flags;
186
187 switch (event) {
188
189 case AVAHI_BROWSER_NEW: {
190 int changed = 0;
191 assert(record);
192
193 if (r->interface > 0 && interface > 0 && interface != r->interface)
194 return;
195
196 if (r->protocol != AVAHI_PROTO_UNSPEC && protocol != AVAHI_PROTO_UNSPEC && protocol != r->protocol)
197 return;
198
199 if (r->interface <= 0)
200 r->interface = interface;
201
202 if (r->protocol == AVAHI_PROTO_UNSPEC)
203 r->protocol = protocol;
204
205 switch (record->key->type) {
206 case AVAHI_DNS_TYPE_SRV:
207 if (!r->srv_record) {
208 r->srv_record = avahi_record_ref(record);
209 changed = 1;
210
211 if (r->record_browser_a) {
212 avahi_s_record_browser_free(r->record_browser_a);
213 r->record_browser_a = NULL;
214 }
215
216 if (r->record_browser_aaaa) {
217 avahi_s_record_browser_free(r->record_browser_aaaa);
218 r->record_browser_aaaa = NULL;
219 }
220
221 if (!(r->user_flags & AVAHI_LOOKUP_NO_ADDRESS)) {
222
223 if (r->address_protocol == AVAHI_PROTO_INET || r->address_protocol == AVAHI_PROTO_UNSPEC) {
224 AvahiKey *k = avahi_key_new(r->srv_record->data.srv.name, AVAHI_DNS_CLASS_IN, AVAHI_DNS_TYPE_A);
225 r->record_browser_a = avahi_s_record_browser_prepare(r->server, r->interface, r->protocol, k, r->user_flags & ~(AVAHI_LOOKUP_NO_TXT|AVAHI_LOOKUP_NO_ADDRESS), record_browser_callback, r);
226 if(r->record_browser_a)
227 avahi_s_record_browser_start_query(r->record_browser_a);
228 avahi_key_unref(k);
229 }
230
231 if (r->address_protocol == AVAHI_PROTO_INET6 || r->address_protocol == AVAHI_PROTO_UNSPEC) {
232 AvahiKey *k = avahi_key_new(r->srv_record->data.srv.name, AVAHI_DNS_CLASS_IN, AVAHI_DNS_TYPE_AAAA);
233 r->record_browser_aaaa = avahi_s_record_browser_prepare(r->server, r->interface, r->protocol, k, r->user_flags & ~(AVAHI_LOOKUP_NO_TXT|AVAHI_LOOKUP_NO_ADDRESS), record_browser_callback, r);
234 if(r->record_browser_aaaa)
235 avahi_s_record_browser_start_query(r->record_browser_aaaa);
236 avahi_key_unref(k);
237 }
238 }
239 }
240 break;
241
242 case AVAHI_DNS_TYPE_TXT:
243
244 assert(!(r->user_flags & AVAHI_LOOKUP_NO_TXT));
245
246 if (!r->txt_record) {
247 r->txt_record = avahi_record_ref(record);
248 changed = 1;
249 }
250 break;
251
252 case AVAHI_DNS_TYPE_A:
253 case AVAHI_DNS_TYPE_AAAA:
254
255 assert(!(r->user_flags & AVAHI_LOOKUP_NO_ADDRESS));
256
257 if (!r->address_record) {
258 r->address_record = avahi_record_ref(record);
259 changed = 1;
260 }
261 break;
262
263 default:
264 abort();
265 }
266
267
268 if (changed &&
269 r->srv_record &&
270 (r->txt_record || (r->user_flags & AVAHI_LOOKUP_NO_TXT)) &&
271 (r->address_record || (r->user_flags & AVAHI_LOOKUP_NO_ADDRESS)))
272 finish(r, AVAHI_RESOLVER_FOUND);
273
274 break;
275
276 }
277
278 case AVAHI_BROWSER_REMOVE:
279
280 assert(record);
281
282 switch (record->key->type) {
283 case AVAHI_DNS_TYPE_SRV:
284
285 if (r->srv_record && avahi_record_equal_no_ttl(record, r->srv_record)) {
286 avahi_record_unref(r->srv_record);
287 r->srv_record = NULL;
288
289 if (r->record_browser_a) {
290 avahi_s_record_browser_free(r->record_browser_a);
291 r->record_browser_a = NULL;
292 }
293
294 if (r->record_browser_aaaa) {
295 avahi_s_record_browser_free(r->record_browser_aaaa);
296 r->record_browser_aaaa = NULL;
297 }
298
299 /** Look for a replacement */
300 avahi_s_record_browser_restart(r->record_browser_srv);
301 start_timeout(r);
302 }
303
304 break;
305
306 case AVAHI_DNS_TYPE_TXT:
307
308 assert(!(r->user_flags & AVAHI_LOOKUP_NO_TXT));
309
310 if (r->txt_record && avahi_record_equal_no_ttl(record, r->txt_record)) {
311 avahi_record_unref(r->txt_record);
312 r->txt_record = NULL;
313
314 /** Look for a replacement */
315 avahi_s_record_browser_restart(r->record_browser_txt);
316 start_timeout(r);
317 }
318 break;
319
320 case AVAHI_DNS_TYPE_A:
321 case AVAHI_DNS_TYPE_AAAA:
322
323 assert(!(r->user_flags & AVAHI_LOOKUP_NO_ADDRESS));
324
325 if (r->address_record && avahi_record_equal_no_ttl(record, r->address_record)) {
326 avahi_record_unref(r->address_record);
327 r->address_record = NULL;
328
329 /** Look for a replacement */
330 if (r->record_browser_aaaa)
331 avahi_s_record_browser_restart(r->record_browser_aaaa);
332 if (r->record_browser_a)
333 avahi_s_record_browser_restart(r->record_browser_a);
334 start_timeout(r);
335 }
336 break;
337
338 default:
339 abort();
340 }
341
342 break;
343
344 case AVAHI_BROWSER_CACHE_EXHAUSTED:
345 case AVAHI_BROWSER_ALL_FOR_NOW:
346 break;
347
348 case AVAHI_BROWSER_FAILURE:
349
350 if (rr == r->record_browser_a && r->record_browser_aaaa) {
351 /* We were looking for both AAAA and A, and the other query is still living, so we'll not die */
352 avahi_s_record_browser_free(r->record_browser_a);
353 r->record_browser_a = NULL;
354 break;
355 }
356
357 if (rr == r->record_browser_aaaa && r->record_browser_a) {
358 /* We were looking for both AAAA and A, and the other query is still living, so we'll not die */
359 avahi_s_record_browser_free(r->record_browser_aaaa);
360 r->record_browser_aaaa = NULL;
361 break;
362 }
363
364 /* Hmm, everything's lost, tell the user */
365
366 if (r->record_browser_srv)
367 avahi_s_record_browser_free(r->record_browser_srv);
368 if (r->record_browser_txt)
369 avahi_s_record_browser_free(r->record_browser_txt);
370 if (r->record_browser_a)
371 avahi_s_record_browser_free(r->record_browser_a);
372 if (r->record_browser_aaaa)
373 avahi_s_record_browser_free(r->record_browser_aaaa);
374
375 r->record_browser_srv = r->record_browser_txt = r->record_browser_a = r->record_browser_aaaa = NULL;
376
377 finish(r, AVAHI_RESOLVER_FAILURE);
378 break;
379 }
380 }
381
avahi_s_service_resolver_prepare(AvahiServer * server,AvahiIfIndex interface,AvahiProtocol protocol,const char * name,const char * type,const char * domain,AvahiProtocol aprotocol,AvahiLookupFlags flags,AvahiSServiceResolverCallback callback,void * userdata)382 AvahiSServiceResolver *avahi_s_service_resolver_prepare(
383 AvahiServer *server,
384 AvahiIfIndex interface,
385 AvahiProtocol protocol,
386 const char *name,
387 const char *type,
388 const char *domain,
389 AvahiProtocol aprotocol,
390 AvahiLookupFlags flags,
391 AvahiSServiceResolverCallback callback,
392 void* userdata) {
393
394 AvahiSServiceResolver *r;
395 AvahiKey *k;
396 char n[AVAHI_DOMAIN_NAME_MAX];
397 int ret;
398
399 assert(server);
400 assert(type);
401 assert(callback);
402
403 AVAHI_CHECK_VALIDITY_RETURN_NULL(server, AVAHI_IF_VALID(interface), AVAHI_ERR_INVALID_INTERFACE);
404 AVAHI_CHECK_VALIDITY_RETURN_NULL(server, AVAHI_PROTO_VALID(protocol), AVAHI_ERR_INVALID_PROTOCOL);
405 AVAHI_CHECK_VALIDITY_RETURN_NULL(server, AVAHI_PROTO_VALID(aprotocol), AVAHI_ERR_INVALID_PROTOCOL);
406 AVAHI_CHECK_VALIDITY_RETURN_NULL(server, !domain || avahi_is_valid_domain_name(domain), AVAHI_ERR_INVALID_DOMAIN_NAME);
407 AVAHI_CHECK_VALIDITY_RETURN_NULL(server, !name || avahi_is_valid_service_name(name), AVAHI_ERR_INVALID_SERVICE_NAME);
408 AVAHI_CHECK_VALIDITY_RETURN_NULL(server, avahi_is_valid_service_type_strict(type), AVAHI_ERR_INVALID_SERVICE_TYPE);
409 AVAHI_CHECK_VALIDITY_RETURN_NULL(server, AVAHI_FLAGS_VALID(flags, AVAHI_LOOKUP_USE_WIDE_AREA|AVAHI_LOOKUP_USE_MULTICAST|AVAHI_LOOKUP_NO_TXT|AVAHI_LOOKUP_NO_ADDRESS), AVAHI_ERR_INVALID_FLAGS);
410
411 if (!domain)
412 domain = server->domain_name;
413
414 if ((ret = avahi_service_name_join(n, sizeof(n), name, type, domain)) < 0) {
415 avahi_server_set_errno(server, ret);
416 return NULL;
417 }
418
419 if (!(r = avahi_new(AvahiSServiceResolver, 1))) {
420 avahi_server_set_errno(server, AVAHI_ERR_NO_MEMORY);
421 return NULL;
422 }
423
424 r->server = server;
425 r->service_name = avahi_strdup(name);
426 r->service_type = avahi_normalize_name_strdup(type);
427 r->domain_name = avahi_normalize_name_strdup(domain);
428 r->callback = callback;
429 r->userdata = userdata;
430 r->address_protocol = aprotocol;
431 r->srv_record = r->txt_record = r->address_record = NULL;
432 r->srv_flags = r->txt_flags = r->address_flags = 0;
433 r->interface = interface;
434 r->protocol = protocol;
435 r->user_flags = flags;
436 r->record_browser_a = r->record_browser_aaaa = r->record_browser_srv = r->record_browser_txt = NULL;
437 r->time_event = NULL;
438 AVAHI_LLIST_PREPEND(AvahiSServiceResolver, resolver, server->service_resolvers, r);
439
440 k = avahi_key_new(n, AVAHI_DNS_CLASS_IN, AVAHI_DNS_TYPE_SRV);
441 r->record_browser_srv = avahi_s_record_browser_new(server, interface, protocol, k, flags & ~(AVAHI_LOOKUP_NO_TXT|AVAHI_LOOKUP_NO_ADDRESS), record_browser_callback, r);
442 avahi_key_unref(k);
443
444 if (!r->record_browser_srv) {
445 avahi_s_service_resolver_free(r);
446 return NULL;
447 }
448
449 if (!(flags & AVAHI_LOOKUP_NO_TXT)) {
450 k = avahi_key_new(n, AVAHI_DNS_CLASS_IN, AVAHI_DNS_TYPE_TXT);
451 r->record_browser_txt = avahi_s_record_browser_new(server, interface, protocol, k, flags & ~(AVAHI_LOOKUP_NO_TXT|AVAHI_LOOKUP_NO_ADDRESS), record_browser_callback, r);
452 avahi_key_unref(k);
453
454 if (!r->record_browser_txt) {
455 avahi_s_service_resolver_free(r);
456 return NULL;
457 }
458 }
459
460 start_timeout(r);
461
462 return r;
463 }
464
avahi_s_service_resolver_start(AvahiSServiceResolver * r)465 void avahi_s_service_resolver_start(AvahiSServiceResolver *r) {
466 assert(r);
467
468 if (r->record_browser_srv)
469 avahi_s_record_browser_start_query(r->record_browser_srv);
470 if (r->record_browser_txt)
471 avahi_s_record_browser_start_query(r->record_browser_txt);
472 if (r->record_browser_a)
473 avahi_s_record_browser_start_query(r->record_browser_a);
474 if (r->record_browser_aaaa)
475 avahi_s_record_browser_start_query(r->record_browser_aaaa);
476 }
477
avahi_s_service_resolver_free(AvahiSServiceResolver * r)478 void avahi_s_service_resolver_free(AvahiSServiceResolver *r) {
479 assert(r);
480
481 AVAHI_LLIST_REMOVE(AvahiSServiceResolver, resolver, r->server->service_resolvers, r);
482
483 if (r->time_event)
484 avahi_time_event_free(r->time_event);
485
486 if (r->record_browser_srv)
487 avahi_s_record_browser_free(r->record_browser_srv);
488 if (r->record_browser_txt)
489 avahi_s_record_browser_free(r->record_browser_txt);
490 if (r->record_browser_a)
491 avahi_s_record_browser_free(r->record_browser_a);
492 if (r->record_browser_aaaa)
493 avahi_s_record_browser_free(r->record_browser_aaaa);
494
495 if (r->srv_record)
496 avahi_record_unref(r->srv_record);
497 if (r->txt_record)
498 avahi_record_unref(r->txt_record);
499 if (r->address_record)
500 avahi_record_unref(r->address_record);
501
502 avahi_free(r->service_name);
503 avahi_free(r->service_type);
504 avahi_free(r->domain_name);
505 avahi_free(r);
506 }
507
avahi_s_service_resolver_new(AvahiServer * server,AvahiIfIndex interface,AvahiProtocol protocol,const char * name,const char * type,const char * domain,AvahiProtocol aprotocol,AvahiLookupFlags flags,AvahiSServiceResolverCallback callback,void * userdata)508 AvahiSServiceResolver *avahi_s_service_resolver_new(
509 AvahiServer *server,
510 AvahiIfIndex interface,
511 AvahiProtocol protocol,
512 const char *name,
513 const char *type,
514 const char *domain,
515 AvahiProtocol aprotocol,
516 AvahiLookupFlags flags,
517 AvahiSServiceResolverCallback callback,
518 void* userdata) {
519 AvahiSServiceResolver *b;
520
521 b = avahi_s_service_resolver_prepare(server, interface, protocol, name, type, domain, aprotocol, flags, callback, userdata);
522 avahi_s_service_resolver_start(b);
523
524 return b;
525 }