Debian Codegraph @

embedded/faustremote/dns_avahi/avahi-client/browser.c

raw
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 <stdlib.h>
25 #include <stdio.h>
26 #include <string.h>
27
28 #include <dbus/dbus.h>
29
30 #include "dbus.h"
31 #include "llist.h"
32 #include "error.h"
33 #include "malloc.h"
34 #include "domain.h"
35
36 #include "client.h"
37 #include "internal.h"
38 #include "xdg-config.h"
39
40 static void parse_environment(AvahiDomainBrowser *b) {
41 char buf[AVAHI_DOMAIN_NAME_MAX*3], *e, *t, *p;
42
43 assert(b);
44
45 if (!(e = getenv("AVAHI_BROWSE_DOMAINS")))
46 return;
47
48 snprintf(buf, sizeof(buf), "%s", e);
49
50 for (t = strtok_r(buf, ":", &p); t; t = strtok_r(NULL, ":", &p)) {
51 char domain[AVAHI_DOMAIN_NAME_MAX];
52 if (avahi_normalize_name(t, domain, sizeof(domain)))
53 b->static_browse_domains = avahi_string_list_add(b->static_browse_domains, domain);
54 }
55 }
56
57 static void parse_domain_file(AvahiDomainBrowser *b) {
58 FILE *f;
59 char buf[AVAHI_DOMAIN_NAME_MAX];
60
61 assert(b);
62
63 if (!(f = avahi_xdg_config_open("avahi/browse-domains")))
64 return;
65
66
67 while (fgets(buf, sizeof(buf)-1, f)) {
68 char domain[AVAHI_DOMAIN_NAME_MAX];
69 buf[strcspn(buf, "\n\r")] = 0;
70
71 if (avahi_normalize_name(buf, domain, sizeof(domain)))
72 b->static_browse_domains = avahi_string_list_add(b->static_browse_domains, domain);
73 }
74 }
75
76 static void domain_browser_ref(AvahiDomainBrowser *db) {
77 assert(db);
78 assert(db->ref >= 1);
79 db->ref++;
80 }
81
82 static void defer_timeout_callback(AvahiTimeout *t, void *userdata) {
83 AvahiDomainBrowser *db = userdata;
84 AvahiStringList *l;
85 assert(t);
86
87 db->client->poll_api->timeout_free(db->defer_timeout);
88 db->defer_timeout = NULL;
89
90 domain_browser_ref(db);
91
92 for (l = db->static_browse_domains; l; l = l->next) {
93
94 if (db->ref <= 1)
95 break;
96
97 db->callback(db, AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC, AVAHI_BROWSER_NEW, (char*) l->text, AVAHI_LOOKUP_RESULT_STATIC, db->userdata);
98 }
99
100 avahi_domain_browser_free(db);
101 }
102
103 AvahiDomainBrowser* avahi_domain_browser_new(
104 AvahiClient *client,
105 AvahiIfIndex interface,
106 AvahiProtocol protocol,
107 const char *domain,
108 AvahiDomainBrowserType btype,
109 AvahiLookupFlags flags,
110 AvahiDomainBrowserCallback callback,
111 void *userdata) {
112
113 AvahiDomainBrowser *db = NULL;
114 DBusMessage *message = NULL, *reply = NULL;
115 DBusError error;
116 char *path;
117 int32_t i_interface, i_protocol, bt;
118 uint32_t u_flags;
119
120 assert(client);
121 assert(callback);
122
123 dbus_error_init (&error);
124
125 if (!avahi_client_is_connected(client)) {
126 avahi_client_set_errno(client, AVAHI_ERR_BAD_STATE);
127 goto fail;
128 }
129
130 if (!domain)
131 domain = "";
132
133 if (!(db = avahi_new (AvahiDomainBrowser, 1))) {
134 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
135 goto fail;
136 }
137
138 db->ref = 1;
139 db->client = client;
140 db->callback = callback;
141 db->userdata = userdata;
142 db->path = NULL;
143 db->interface = interface;
144 db->protocol = protocol;
145 db->static_browse_domains = NULL;
146 db->defer_timeout = NULL;
147
148 AVAHI_LLIST_PREPEND(AvahiDomainBrowser, domain_browsers, client->domain_browsers, db);
149
150 if (!(client->flags & AVAHI_CLIENT_IGNORE_USER_CONFIG)) {
151 parse_environment(db);
152 parse_domain_file(db);
153 }
154
155 db->static_browse_domains = avahi_string_list_reverse(db->static_browse_domains);
156
157 if (!(message = dbus_message_new_method_call (AVAHI_DBUS_NAME, AVAHI_DBUS_PATH_SERVER, AVAHI_DBUS_INTERFACE_SERVER, "DomainBrowserNew"))) {
158 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
159 goto fail;
160 }
161
162 i_interface = (int32_t) interface;
163 i_protocol = (int32_t) protocol;
164 u_flags = (uint32_t) flags;
165 bt = btype;
166
167 if (!(dbus_message_append_args(
168 message,
169 DBUS_TYPE_INT32, &i_interface,
170 DBUS_TYPE_INT32, &i_protocol,
171 DBUS_TYPE_STRING, &domain,
172 DBUS_TYPE_INT32, &bt,
173 DBUS_TYPE_UINT32, &u_flags,
174 DBUS_TYPE_INVALID))) {
175 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
176 goto fail;
177 }
178
179 if (!(reply = dbus_connection_send_with_reply_and_block (client->bus, message, -1, &error)) ||
180 dbus_error_is_set(&error)) {
181 avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR);
182 goto fail;
183 }
184
185 if (!dbus_message_get_args (reply, &error, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID) ||
186 dbus_error_is_set(&error) ||
187 !path) {
188 avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR);
189 goto fail;
190 }
191
192 if (!(db->path = avahi_strdup(path))) {
193
194 /* FIXME: We don't remove the object on the server side */
195
196 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
197 goto fail;
198 }
199
200 if (db->static_browse_domains && btype == AVAHI_DOMAIN_BROWSER_BROWSE) {
201 struct timeval tv = { 0, 0 };
202
203 if (!(db->defer_timeout = client->poll_api->timeout_new(client->poll_api, &tv, defer_timeout_callback, db))) {
204 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
205 goto fail;
206 }
207 }
208
209 dbus_message_unref(message);
210 dbus_message_unref(reply);
211
212 return db;
213
214 fail:
215
216 if (dbus_error_is_set(&error)) {
217 avahi_client_set_dbus_error(client, &error);
218 dbus_error_free(&error);
219 }
220
221 if (db)
222 avahi_domain_browser_free(db);
223
224 if (message)
225 dbus_message_unref(message);
226
227 if (reply)
228 dbus_message_unref(reply);
229
230 return NULL;
231 }
232
233 AvahiClient* avahi_domain_browser_get_client (AvahiDomainBrowser *b) {
234 assert(b);
235 return b->client;
236 }
237
238 int avahi_domain_browser_free (AvahiDomainBrowser *b) {
239 AvahiClient *client;
240 int r = AVAHI_OK;
241
242 assert(b);
243 assert(b->ref >= 1);
244
245 if (--(b->ref) >= 1)
246 return AVAHI_OK;
247
248 client = b->client;
249
250 if (b->path && avahi_client_is_connected(b->client))
251 r = avahi_client_simple_method_call(client, b->path, AVAHI_DBUS_INTERFACE_DOMAIN_BROWSER, "Free");
252
253 AVAHI_LLIST_REMOVE(AvahiDomainBrowser, domain_browsers, client->domain_browsers, b);
254
255 if (b->defer_timeout)
256 b->client->poll_api->timeout_free(b->defer_timeout);
257
258 avahi_string_list_free(b->static_browse_domains);
259 avahi_free(b->path);
260 avahi_free(b);
261
262 return r;
263 }
264
265 DBusHandlerResult avahi_domain_browser_event (AvahiClient *client, AvahiBrowserEvent event, DBusMessage *message) {
266 AvahiDomainBrowser *db = NULL;
267 DBusError error;
268 const char *path;
269 char *domain = NULL;
270 int32_t interface, protocol;
271 uint32_t flags = 0;
272 AvahiStringList *l;
273
274 assert(client);
275 assert(message);
276
277 dbus_error_init (&error);
278
279 if (!(path = dbus_message_get_path(message)))
280 goto fail;
281
282 for (db = client->domain_browsers; db; db = db->domain_browsers_next)
283 if (strcmp (db->path, path) == 0)
284 break;
285
286 if (!db)
287 goto fail;
288
289 interface = db->interface;
290 protocol = db->protocol;
291
292 switch (event) {
293 case AVAHI_BROWSER_NEW:
294 case AVAHI_BROWSER_REMOVE:
295
296 if (!dbus_message_get_args(
297 message, &error,
298 DBUS_TYPE_INT32, &interface,
299 DBUS_TYPE_INT32, &protocol,
300 DBUS_TYPE_STRING, &domain,
301 DBUS_TYPE_UINT32, &flags,
302 DBUS_TYPE_INVALID) ||
303 dbus_error_is_set (&error)) {
304 fprintf(stderr, "Failed to parse browser event.\n");
305 goto fail;
306 }
307
308 break;
309
310 case AVAHI_BROWSER_CACHE_EXHAUSTED:
311 case AVAHI_BROWSER_ALL_FOR_NOW:
312 break;
313
314 case AVAHI_BROWSER_FAILURE: {
315 char *etxt;
316
317 if (!dbus_message_get_args(
318 message, &error,
319 DBUS_TYPE_STRING, &etxt,
320 DBUS_TYPE_INVALID) ||
321 dbus_error_is_set (&error)) {
322 fprintf(stderr, "Failed to parse browser event.\n");
323 goto fail;
324 }
325
326 avahi_client_set_errno(db->client, avahi_error_dbus_to_number(etxt));
327 break;
328 }
329 }
330
331 if (domain)
332 for (l = db->static_browse_domains; l; l = l->next)
333 if (avahi_domain_equal((char*) l->text, domain)) {
334 /* We had this entry already in the static entries */
335 return DBUS_HANDLER_RESULT_HANDLED;
336 }
337
338 db->callback(db, (AvahiIfIndex) interface, (AvahiProtocol) protocol, event, domain, (AvahiLookupResultFlags) flags, db->userdata);
339
340 return DBUS_HANDLER_RESULT_HANDLED;
341
342 fail:
343 dbus_error_free (&error);
344 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
345 }
346
347 /* AvahiServiceTypeBrowser */
348
349 AvahiServiceTypeBrowser* avahi_service_type_browser_new(
350 AvahiClient *client,
351 AvahiIfIndex interface,
352 AvahiProtocol protocol,
353 const char *domain,
354 AvahiLookupFlags flags,
355 AvahiServiceTypeBrowserCallback callback,
356 void *userdata) {
357
358 AvahiServiceTypeBrowser *b = NULL;
359 DBusMessage *message = NULL, *reply = NULL;
360 DBusError error;
361 char *path;
362 int32_t i_interface, i_protocol;
363 uint32_t u_flags;
364
365 assert(client);
366 assert(callback);
367
368 dbus_error_init(&error);
369
370 if (!avahi_client_is_connected(client)) {
371 avahi_client_set_errno(client, AVAHI_ERR_BAD_STATE);
372 goto fail;
373 }
374
375 if (!domain)
376 domain = "";
377
378 if (!(b = avahi_new(AvahiServiceTypeBrowser, 1))) {
379 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
380 goto fail;
381 }
382
383 b->client = client;
384 b->callback = callback;
385 b->userdata = userdata;
386 b->path = NULL;
387 b->domain = NULL;
388 b->interface = interface;
389 b->protocol = protocol;
390
391 AVAHI_LLIST_PREPEND(AvahiServiceTypeBrowser, service_type_browsers, client->service_type_browsers, b);
392
393 if (domain[0])
394 if (!(b->domain = avahi_strdup(domain))) {
395 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
396 goto fail;
397 }
398
399 if (!(message = dbus_message_new_method_call (AVAHI_DBUS_NAME, AVAHI_DBUS_PATH_SERVER, AVAHI_DBUS_INTERFACE_SERVER, "ServiceTypeBrowserNew"))) {
400 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
401 goto fail;
402 }
403
404 i_interface = (int32_t) interface;
405 i_protocol = (int32_t) protocol;
406 u_flags = (uint32_t) flags;
407
408 if (!dbus_message_append_args(
409 message,
410 DBUS_TYPE_INT32, &i_interface,
411 DBUS_TYPE_INT32, &i_protocol,
412 DBUS_TYPE_STRING, &domain,
413 DBUS_TYPE_UINT32, &u_flags,
414 DBUS_TYPE_INVALID)) {
415 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
416 goto fail;
417 }
418
419 if (!(reply = dbus_connection_send_with_reply_and_block (client->bus, message, -1, &error)) ||
420 dbus_error_is_set(&error)) {
421 avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR);
422 goto fail;
423 }
424
425 if (!dbus_message_get_args (reply, &error, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID) ||
426 dbus_error_is_set(&error) ||
427 !path) {
428 avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR);
429 goto fail;
430 }
431
432 if (!(b->path = avahi_strdup(path))) {
433
434 /* FIXME: We don't remove the object on the server side */
435
436 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
437 goto fail;
438 }
439
440 dbus_message_unref(message);
441 dbus_message_unref(reply);
442
443 return b;
444
445 fail:
446
447 if (dbus_error_is_set(&error)) {
448 avahi_client_set_dbus_error(client, &error);
449 dbus_error_free(&error);
450 }
451
452 if (b)
453 avahi_service_type_browser_free(b);
454
455 if (message)
456 dbus_message_unref(message);
457
458 if (reply)
459 dbus_message_unref(reply);
460
461 return NULL;
462 }
463
464 AvahiClient* avahi_service_type_browser_get_client (AvahiServiceTypeBrowser *b) {
465 assert(b);
466 return b->client;
467 }
468
469 int avahi_service_type_browser_free (AvahiServiceTypeBrowser *b) {
470 AvahiClient *client;
471 int r = AVAHI_OK;
472
473 assert(b);
474 client = b->client;
475
476 if (b->path && avahi_client_is_connected(b->client))
477 r = avahi_client_simple_method_call(client, b->path, AVAHI_DBUS_INTERFACE_SERVICE_TYPE_BROWSER, "Free");
478
479 AVAHI_LLIST_REMOVE(AvahiServiceTypeBrowser, service_type_browsers, b->client->service_type_browsers, b);
480
481 avahi_free(b->path);
482 avahi_free(b->domain);
483 avahi_free(b);
484 return r;
485 }
486
487 DBusHandlerResult avahi_service_type_browser_event (AvahiClient *client, AvahiBrowserEvent event, DBusMessage *message) {
488 AvahiServiceTypeBrowser *b = NULL;
489 DBusError error;
490 const char *path;
491 char *domain, *type = NULL;
492 int32_t interface, protocol;
493 uint32_t flags = 0;
494
495 assert(client);
496 assert(message);
497
498 dbus_error_init (&error);
499
500 if (!(path = dbus_message_get_path(message)))
501 goto fail;
502
503 for (b = client->service_type_browsers; b; b = b->service_type_browsers_next)
504 if (strcmp (b->path, path) == 0)
505 break;
506
507 if (!b)
508 goto fail;
509
510 domain = b->domain;
511 interface = b->interface;
512 protocol = b->protocol;
513
514 switch (event) {
515 case AVAHI_BROWSER_NEW:
516 case AVAHI_BROWSER_REMOVE:
517 if (!dbus_message_get_args(
518 message, &error,
519 DBUS_TYPE_INT32, &interface,
520 DBUS_TYPE_INT32, &protocol,
521 DBUS_TYPE_STRING, &type,
522 DBUS_TYPE_STRING, &domain,
523 DBUS_TYPE_UINT32, &flags,
524 DBUS_TYPE_INVALID) ||
525 dbus_error_is_set(&error)) {
526 fprintf(stderr, "Failed to parse browser event.\n");
527 goto fail;
528 }
529 break;
530
531 case AVAHI_BROWSER_CACHE_EXHAUSTED:
532 case AVAHI_BROWSER_ALL_FOR_NOW:
533 break;
534
535 case AVAHI_BROWSER_FAILURE: {
536 char *etxt;
537
538 if (!dbus_message_get_args(
539 message, &error,
540 DBUS_TYPE_STRING, &etxt,
541 DBUS_TYPE_INVALID) ||
542 dbus_error_is_set (&error)) {
543 fprintf(stderr, "Failed to parse browser event.\n");
544 goto fail;
545 }
546
547 avahi_client_set_errno(b->client, avahi_error_dbus_to_number(etxt));
548 break;
549 }
550 }
551
552 b->callback(b, (AvahiIfIndex) interface, (AvahiProtocol) protocol, event, type, domain, (AvahiLookupResultFlags) flags, b->userdata);
553
554 return DBUS_HANDLER_RESULT_HANDLED;
555
556 fail:
557 dbus_error_free (&error);
558 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
559 }
560
561 /* AvahiServiceBrowser */
562
563 AvahiServiceBrowser* avahi_service_browser_new(
564 AvahiClient *client,
565 AvahiIfIndex interface,
566 AvahiProtocol protocol,
567 const char *type,
568 const char *domain,
569 AvahiLookupFlags flags,
570 AvahiServiceBrowserCallback callback,
571 void *userdata) {
572
573 AvahiServiceBrowser *b = NULL;
574 DBusMessage *message = NULL, *reply = NULL;
575 DBusError error;
576 char *path;
577 int32_t i_protocol, i_interface;
578 uint32_t u_flags;
579
580 assert(client);
581 assert(type);
582 assert(callback);
583
584 dbus_error_init(&error);
585
586 if (!avahi_client_is_connected(client)) {
587 avahi_client_set_errno(client, AVAHI_ERR_BAD_STATE);
588 goto fail;
589 }
590
591 if (!domain)
592 domain = "";
593
594 if (!(b = avahi_new(AvahiServiceBrowser, 1))) {
595 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
596 goto fail;
597 }
598
599 b->client = client;
600 b->callback = callback;
601 b->userdata = userdata;
602 b->path = NULL;
603 b->type = b->domain = NULL;
604 b->interface = interface;
605 b->protocol = protocol;
606
607 AVAHI_LLIST_PREPEND(AvahiServiceBrowser, service_browsers, client->service_browsers, b);
608
609 if (!(b->type = avahi_strdup(type))) {
610 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
611 goto fail;
612 }
613
614 if (domain && domain[0])
615 if (!(b->domain = avahi_strdup(domain))) {
616 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
617 goto fail;
618 }
619
620 if (!(message = dbus_message_new_method_call (AVAHI_DBUS_NAME, AVAHI_DBUS_PATH_SERVER, AVAHI_DBUS_INTERFACE_SERVER, "ServiceBrowserNew"))) {
621 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
622 goto fail;
623 }
624
625 i_interface = (int32_t) interface;
626 i_protocol = (int32_t) protocol;
627 u_flags = (uint32_t) flags;
628
629 if (!dbus_message_append_args(
630 message,
631 DBUS_TYPE_INT32, &i_interface,
632 DBUS_TYPE_INT32, &i_protocol,
633 DBUS_TYPE_STRING, &type,
634 DBUS_TYPE_STRING, &domain,
635 DBUS_TYPE_UINT32, &u_flags,
636 DBUS_TYPE_INVALID)) {
637 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
638 goto fail;
639 }
640
641 if (!(reply = dbus_connection_send_with_reply_and_block (client->bus, message, -1, &error)) ||
642 dbus_error_is_set(&error)) {
643 avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR);
644 goto fail;
645 }
646
647 if (!dbus_message_get_args (reply, &error, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID) ||
648 dbus_error_is_set(&error) ||
649 !path) {
650 avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR);
651 goto fail;
652 }
653
654 if (!(b->path = avahi_strdup(path))) {
655
656 /* FIXME: We don't remove the object on the server side */
657
658 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
659 goto fail;
660 }
661
662 dbus_message_unref(message);
663 dbus_message_unref(reply);
664
665 return b;
666
667 fail:
668 if (dbus_error_is_set(&error)) {
669 avahi_client_set_dbus_error(client, &error);
670 dbus_error_free(&error);
671 }
672
673 if (b)
674 avahi_service_browser_free(b);
675
676 if (message)
677 dbus_message_unref(message);
678
679 if (reply)
680 dbus_message_unref(reply);
681
682 return NULL;
683 }
684
685 AvahiClient* avahi_service_browser_get_client (AvahiServiceBrowser *b) {
686 assert(b);
687 return b->client;
688 }
689
690 int avahi_service_browser_free (AvahiServiceBrowser *b) {
691 AvahiClient *client;
692 int r = AVAHI_OK;
693
694 assert(b);
695 client = b->client;
696
697 if (b->path && avahi_client_is_connected(b->client))
698 r = avahi_client_simple_method_call(client, b->path, AVAHI_DBUS_INTERFACE_SERVICE_BROWSER, "Free");
699
700 AVAHI_LLIST_REMOVE(AvahiServiceBrowser, service_browsers, b->client->service_browsers, b);
701
702 avahi_free(b->path);
703 avahi_free(b->type);
704 avahi_free(b->domain);
705 avahi_free(b);
706 return r;
707 }
708
709 DBusHandlerResult avahi_service_browser_event(AvahiClient *client, AvahiBrowserEvent event, DBusMessage *message) {
710 AvahiServiceBrowser *b = NULL;
711 DBusError error;
712 const char *path;
713 char *name = NULL, *type, *domain;
714 int32_t interface, protocol;
715 uint32_t flags = 0;
716
717 dbus_error_init (&error);
718
719 if (!(path = dbus_message_get_path(message)))
720 goto fail;
721
722 for (b = client->service_browsers; b; b = b->service_browsers_next)
723 if (strcmp (b->path, path) == 0)
724 break;
725
726 if (!b)
727 goto fail;
728
729 type = b->type;
730 domain = b->domain;
731 interface = b->interface;
732 protocol = b->protocol;
733
734 switch (event) {
735 case AVAHI_BROWSER_NEW:
736 case AVAHI_BROWSER_REMOVE:
737
738 if (!dbus_message_get_args (
739 message, &error,
740 DBUS_TYPE_INT32, &interface,
741 DBUS_TYPE_INT32, &protocol,
742 DBUS_TYPE_STRING, &name,
743 DBUS_TYPE_STRING, &type,
744 DBUS_TYPE_STRING, &domain,
745 DBUS_TYPE_UINT32, &flags,
746 DBUS_TYPE_INVALID) ||
747 dbus_error_is_set(&error)) {
748 fprintf(stderr, "Failed to parse browser event.\n");
749 goto fail;
750 }
751 break;
752
753 case AVAHI_BROWSER_CACHE_EXHAUSTED:
754 case AVAHI_BROWSER_ALL_FOR_NOW:
755 break;
756
757 case AVAHI_BROWSER_FAILURE: {
758 char *etxt;
759
760 if (!dbus_message_get_args(
761 message, &error,
762 DBUS_TYPE_STRING, &etxt,
763 DBUS_TYPE_INVALID) ||
764 dbus_error_is_set (&error)) {
765 fprintf(stderr, "Failed to parse browser event.\n");
766 goto fail;
767 }
768
769 avahi_client_set_errno(b->client, avahi_error_dbus_to_number(etxt));
770 break;
771 }
772 }
773
774 b->callback(b, (AvahiIfIndex) interface, (AvahiProtocol) protocol, event, name, type, domain, (AvahiLookupResultFlags) flags, b->userdata);
775
776 return DBUS_HANDLER_RESULT_HANDLED;
777
778 fail:
779 dbus_error_free (&error);
780 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
781 }
782
783 /* AvahiRecordBrowser */
784
785 AvahiRecordBrowser* avahi_record_browser_new(
786 AvahiClient *client,
787 AvahiIfIndex interface,
788 AvahiProtocol protocol,
789 const char *name,
790 uint16_t clazz,
791 uint16_t type,
792 AvahiLookupFlags flags,
793 AvahiRecordBrowserCallback callback,
794 void *userdata) {
795
796 AvahiRecordBrowser *b = NULL;
797 DBusMessage *message = NULL, *reply = NULL;
798 DBusError error;
799 char *path;
800 int32_t i_protocol, i_interface;
801 uint32_t u_flags;
802
803 assert(client);
804 assert(name);
805 assert(callback);
806
807 dbus_error_init(&error);
808
809 if (!avahi_client_is_connected(client)) {
810 avahi_client_set_errno(client, AVAHI_ERR_BAD_STATE);
811 goto fail;
812 }
813
814 if (!(b = avahi_new(AvahiRecordBrowser, 1))) {
815 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
816 goto fail;
817 }
818
819 b->client = client;
820 b->callback = callback;
821 b->userdata = userdata;
822 b->path = NULL;
823 b->name = NULL;
824 b->clazz = clazz;
825 b->type = type;
826 b->interface = interface;
827 b->protocol = protocol;
828
829 AVAHI_LLIST_PREPEND(AvahiRecordBrowser, record_browsers, client->record_browsers, b);
830
831 if (!(b->name = avahi_strdup(name))) {
832 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
833 goto fail;
834 }
835
836 if (!(message = dbus_message_new_method_call(AVAHI_DBUS_NAME, AVAHI_DBUS_PATH_SERVER, AVAHI_DBUS_INTERFACE_SERVER, "RecordBrowserNew"))) {
837 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
838 goto fail;
839 }
840
841 i_interface = (int32_t) interface;
842 i_protocol = (int32_t) protocol;
843 u_flags = (uint32_t) flags;
844
845 if (!dbus_message_append_args(
846 message,
847 DBUS_TYPE_INT32, &i_interface,
848 DBUS_TYPE_INT32, &i_protocol,
849 DBUS_TYPE_STRING, &name,
850 DBUS_TYPE_UINT16, &clazz,
851 DBUS_TYPE_UINT16, &type,
852 DBUS_TYPE_UINT32, &u_flags,
853 DBUS_TYPE_INVALID)) {
854 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
855 goto fail;
856 }
857
858 if (!(reply = dbus_connection_send_with_reply_and_block (client->bus, message, -1, &error)) ||
859 dbus_error_is_set(&error)) {
860 avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR);
861 goto fail;
862 }
863
864 if (!dbus_message_get_args (reply, &error, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID) ||
865 dbus_error_is_set(&error) ||
866 !path) {
867 avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR);
868 goto fail;
869 }
870
871 if (!(b->path = avahi_strdup(path))) {
872
873 /* FIXME: We don't remove the object on the server side */
874
875 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
876 goto fail;
877 }
878
879 dbus_message_unref(message);
880 dbus_message_unref(reply);
881
882 return b;
883
884 fail:
885 if (dbus_error_is_set(&error)) {
886 avahi_client_set_dbus_error(client, &error);
887 dbus_error_free(&error);
888 }
889
890 if (b)
891 avahi_record_browser_free(b);
892
893 if (message)
894 dbus_message_unref(message);
895
896 if (reply)
897 dbus_message_unref(reply);
898
899 return NULL;
900 }
901
902 AvahiClient* avahi_record_browser_get_client (AvahiRecordBrowser *b) {
903 assert(b);
904 return b->client;
905 }
906
907 int avahi_record_browser_free (AvahiRecordBrowser *b) {
908 AvahiClient *client;
909 int r = AVAHI_OK;
910
911 assert(b);
912 client = b->client;
913
914 if (b->path && avahi_client_is_connected(b->client))
915 r = avahi_client_simple_method_call(client, b->path, AVAHI_DBUS_INTERFACE_RECORD_BROWSER, "Free");
916
917 AVAHI_LLIST_REMOVE(AvahiRecordBrowser, record_browsers, b->client->record_browsers, b);
918
919 avahi_free(b->path);
920 avahi_free(b->name);
921 avahi_free(b);
922 return r;
923 }
924
925 DBusHandlerResult avahi_record_browser_event(AvahiClient *client, AvahiBrowserEvent event, DBusMessage *message) {
926 AvahiRecordBrowser *b = NULL;
927 DBusError error;
928 const char *path;
929 char *name;
930 int32_t interface, protocol;
931 uint32_t flags = 0;
932 uint16_t clazz, type;
933 void *rdata = NULL;
934 int rdata_size = 0;
935
936 dbus_error_init (&error);
937
938 if (!(path = dbus_message_get_path(message)))
939 goto fail;
940
941 for (b = client->record_browsers; b; b = b->record_browsers_next)
942 if (strcmp (b->path, path) == 0)
943 break;
944
945 if (!b)
946 goto fail;
947
948 interface = b->interface;
949 protocol = b->protocol;
950 clazz = b->clazz;
951 type = b->type;
952 name = b->name;
953
954 switch (event) {
955 case AVAHI_BROWSER_NEW:
956 case AVAHI_BROWSER_REMOVE: {
957 DBusMessageIter iter, sub;
958 int j;
959
960 if (!dbus_message_get_args (
961 message, &error,
962 DBUS_TYPE_INT32, &interface,
963 DBUS_TYPE_INT32, &protocol,
964 DBUS_TYPE_STRING, &name,
965 DBUS_TYPE_UINT16, &clazz,
966 DBUS_TYPE_UINT16, &type,
967 DBUS_TYPE_INVALID) ||
968 dbus_error_is_set(&error)) {
969 fprintf(stderr, "Failed to parse browser event.\n");
970 goto fail;
971 }
972
973
974 dbus_message_iter_init(message, &iter);
975
976 for (j = 0; j < 5; j++)
977 dbus_message_iter_next(&iter);
978
979 if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
980 dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_BYTE)
981 goto fail;
982
983 dbus_message_iter_recurse(&iter, &sub);
984 dbus_message_iter_get_fixed_array(&sub, &rdata, &rdata_size);
985
986 dbus_message_iter_next(&iter);
987
988 if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_UINT32)
989 goto fail;
990
991 dbus_message_iter_get_basic(&iter, &flags);
992
993 break;
994 }
995
996 case AVAHI_BROWSER_CACHE_EXHAUSTED:
997 case AVAHI_BROWSER_ALL_FOR_NOW:
998 break;
999
1000 case AVAHI_BROWSER_FAILURE: {
1001 char *etxt;
1002
1003 if (!dbus_message_get_args(
1004 message, &error,
1005 DBUS_TYPE_STRING, &etxt,
1006 DBUS_TYPE_INVALID) ||
1007 dbus_error_is_set (&error)) {
1008 fprintf(stderr, "Failed to parse browser event.\n");
1009 goto fail;
1010 }
1011
1012 avahi_client_set_errno(b->client, avahi_error_dbus_to_number(etxt));
1013 break;
1014 }
1015 }
1016
1017 b->callback(b, (AvahiIfIndex) interface, (AvahiProtocol) protocol, event, name, clazz, type, rdata, (size_t) rdata_size, (AvahiLookupResultFlags) flags, b->userdata);
1018
1019 return DBUS_HANDLER_RESULT_HANDLED;
1020
1021 fail:
1022 dbus_error_free (&error);
1023 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1024 }