4 This file is part of avahi.
6 avahi is free software; you can redistribute it and/or modify it
7 under the terms of the GNU Lesser General Public License as
8 published by the Free Software Foundation; either version 2.1 of the
9 License, or (at your option) any later version.
11 avahi is distributed in the hope that it will be useful, but WITHOUT
12 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
13 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General
14 Public License for more details.
16 You should have received a copy of the GNU Lesser General Public
17 License along with avahi; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
30 #include <dbus/dbus.h>
32 #include <avahi-client/client.h>
33 #include <avahi-common/dbus.h>
34 #include <avahi-common/llist.h>
35 #include <avahi-common/error.h>
36 #include <avahi-common/malloc.h>
37 #include <avahi-common/domain.h>
41 #include "xdg-config.h"
43 static void parse_environment(AvahiDomainBrowser *b) {
44 char buf[AVAHI_DOMAIN_NAME_MAX*3], *e, *t, *p;
48 if (!(e = getenv("AVAHI_BROWSE_DOMAINS")))
51 snprintf(buf, sizeof(buf), "%s", e);
53 for (t = strtok_r(buf, ":", &p); t; t = strtok_r(NULL, ":", &p)) {
54 char domain[AVAHI_DOMAIN_NAME_MAX];
55 if (avahi_normalize_name(t, domain, sizeof(domain)))
56 b->static_browse_domains = avahi_string_list_add(b->static_browse_domains, domain);
60 static void parse_domain_file(AvahiDomainBrowser *b) {
62 char buf[AVAHI_DOMAIN_NAME_MAX];
66 if (!(f = avahi_xdg_config_open("avahi/browse-domains")))
70 while (fgets(buf, sizeof(buf)-1, f)) {
71 char domain[AVAHI_DOMAIN_NAME_MAX];
72 buf[strcspn(buf, "\n\r")] = 0;
74 if (avahi_normalize_name(buf, domain, sizeof(domain)))
75 b->static_browse_domains = avahi_string_list_add(b->static_browse_domains, domain);
79 static void domain_browser_ref(AvahiDomainBrowser *db) {
85 static void defer_timeout_callback(AvahiTimeout *t, void *userdata) {
86 AvahiDomainBrowser *db = userdata;
90 db->client->poll_api->timeout_free(db->defer_timeout);
91 db->defer_timeout = NULL;
93 domain_browser_ref(db);
95 for (l = db->static_browse_domains; l; l = l->next) {
100 db->callback(db, AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC, AVAHI_BROWSER_NEW, (char*) l->text, AVAHI_LOOKUP_RESULT_STATIC, db->userdata);
103 avahi_domain_browser_free(db);
106 AvahiDomainBrowser* avahi_domain_browser_new(
108 AvahiIfIndex interface,
109 AvahiProtocol protocol,
111 AvahiDomainBrowserType btype,
112 AvahiLookupFlags flags,
113 AvahiDomainBrowserCallback callback,
116 AvahiDomainBrowser *db = NULL;
117 DBusMessage *message = NULL, *reply = NULL;
120 int32_t i_interface, i_protocol, bt;
126 dbus_error_init (&error);
128 if (client->state == AVAHI_CLIENT_FAILURE) {
129 avahi_client_set_errno(client, AVAHI_ERR_BAD_STATE);
136 if (!(db = avahi_new (AvahiDomainBrowser, 1))) {
137 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
143 db->callback = callback;
144 db->userdata = userdata;
146 db->interface = interface;
147 db->protocol = protocol;
148 db->static_browse_domains = NULL;
149 db->defer_timeout = NULL;
151 AVAHI_LLIST_PREPEND(AvahiDomainBrowser, domain_browsers, client->domain_browsers, db);
153 parse_environment(db);
154 parse_domain_file(db);
156 db->static_browse_domains = avahi_string_list_reverse(db->static_browse_domains);
158 if (!(message = dbus_message_new_method_call (AVAHI_DBUS_NAME, AVAHI_DBUS_PATH_SERVER, AVAHI_DBUS_INTERFACE_SERVER, "DomainBrowserNew"))) {
159 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
163 i_interface = (int32_t) interface;
164 i_protocol = (int32_t) protocol;
165 u_flags = (uint32_t) flags;
168 if (!(dbus_message_append_args(
170 DBUS_TYPE_INT32, &i_interface,
171 DBUS_TYPE_INT32, &i_protocol,
172 DBUS_TYPE_STRING, &domain,
173 DBUS_TYPE_INT32, &bt,
174 DBUS_TYPE_UINT32, &flags,
175 DBUS_TYPE_INVALID))) {
176 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
180 if (!(reply = dbus_connection_send_with_reply_and_block (client->bus, message, -1, &error)) ||
181 dbus_error_is_set(&error)) {
182 avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR);
186 if (!dbus_message_get_args (reply, &error, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID) ||
187 dbus_error_is_set(&error) ||
189 avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR);
193 if (!(db->path = avahi_strdup(path))) {
195 /* FIXME: We don't remove the object on the server side */
197 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
201 if (db->static_browse_domains) {
202 struct timeval tv = { 0, 0 };
204 if (!(db->defer_timeout = client->poll_api->timeout_new(client->poll_api, &tv, defer_timeout_callback, db))) {
205 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
210 dbus_message_unref(message);
211 dbus_message_unref(reply);
217 if (dbus_error_is_set(&error)) {
218 avahi_client_set_dbus_error(client, &error);
219 dbus_error_free(&error);
223 avahi_domain_browser_free(db);
226 dbus_message_unref(message);
229 dbus_message_unref(reply);
234 AvahiClient* avahi_domain_browser_get_client (AvahiDomainBrowser *b) {
239 int avahi_domain_browser_free (AvahiDomainBrowser *b) {
251 if (b->path && client->state != AVAHI_CLIENT_FAILURE)
252 r = avahi_client_simple_method_call(client, b->path, AVAHI_DBUS_INTERFACE_DOMAIN_BROWSER, "Free");
254 AVAHI_LLIST_REMOVE(AvahiDomainBrowser, domain_browsers, client->domain_browsers, b);
256 if (b->defer_timeout)
257 b->client->poll_api->timeout_free(b->defer_timeout);
259 avahi_string_list_free(b->static_browse_domains);
266 DBusHandlerResult avahi_domain_browser_event (AvahiClient *client, AvahiBrowserEvent event, DBusMessage *message) {
267 AvahiDomainBrowser *db = NULL;
271 int32_t interface, protocol;
278 dbus_error_init (&error);
280 if (!(path = dbus_message_get_path(message)))
283 for (db = client->domain_browsers; db; db = db->domain_browsers_next)
284 if (strcmp (db->path, path) == 0)
290 interface = db->interface;
291 protocol = db->protocol;
294 case AVAHI_BROWSER_NEW:
295 case AVAHI_BROWSER_REMOVE:
297 if (!dbus_message_get_args(
299 DBUS_TYPE_INT32, &interface,
300 DBUS_TYPE_INT32, &protocol,
301 DBUS_TYPE_STRING, &domain,
302 DBUS_TYPE_UINT32, &flags,
303 DBUS_TYPE_INVALID) ||
304 dbus_error_is_set (&error)) {
305 fprintf(stderr, "Failed to parse browser event.\n");
311 case AVAHI_BROWSER_CACHE_EXHAUSTED:
312 case AVAHI_BROWSER_ALL_FOR_NOW:
315 case AVAHI_BROWSER_FAILURE: {
318 if (!dbus_message_get_args(
320 DBUS_TYPE_STRING, &etxt,
321 DBUS_TYPE_INVALID) ||
322 dbus_error_is_set (&error)) {
323 fprintf(stderr, "Failed to parse browser event.\n");
327 avahi_client_set_errno(db->client, avahi_error_dbus_to_number(etxt));
333 for (l = db->static_browse_domains; l; l = l->next)
334 if (avahi_domain_equal((char*) l->text, domain)) {
335 /* We had this entry already in the static entries */
336 return DBUS_HANDLER_RESULT_HANDLED;
339 db->callback(db, (AvahiIfIndex) interface, (AvahiProtocol) protocol, event, domain, (AvahiLookupResultFlags) flags, db->userdata);
341 return DBUS_HANDLER_RESULT_HANDLED;
344 dbus_error_free (&error);
345 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
348 /* AvahiServiceTypeBrowser */
349 AvahiServiceTypeBrowser* avahi_service_type_browser_new(
351 AvahiIfIndex interface,
352 AvahiProtocol protocol,
354 AvahiLookupFlags flags,
355 AvahiServiceTypeBrowserCallback callback,
358 AvahiServiceTypeBrowser *b = NULL;
359 DBusMessage *message = NULL, *reply = NULL;
362 int32_t i_interface, i_protocol;
368 dbus_error_init(&error);
370 if (client->state == AVAHI_CLIENT_FAILURE) {
371 avahi_client_set_errno(client, AVAHI_ERR_BAD_STATE);
378 if (!(b = avahi_new(AvahiServiceTypeBrowser, 1))) {
379 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
384 b->callback = callback;
385 b->userdata = userdata;
388 b->interface = interface;
389 b->protocol = protocol;
391 AVAHI_LLIST_PREPEND(AvahiServiceTypeBrowser, service_type_browsers, client->service_type_browsers, b);
394 if (!(b->domain = avahi_strdup(domain))) {
395 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
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);
404 i_interface = (int32_t) interface;
405 i_protocol = (int32_t) protocol;
406 u_flags = (uint32_t) flags;
408 if (!dbus_message_append_args(
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);
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);
425 if (!dbus_message_get_args (reply, &error, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID) ||
426 dbus_error_is_set(&error) ||
428 avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR);
432 if (!(b->path = avahi_strdup(path))) {
434 /* FIXME: We don't remove the object on the server side */
436 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
440 dbus_message_unref(message);
441 dbus_message_unref(reply);
447 if (dbus_error_is_set(&error)) {
448 avahi_client_set_dbus_error(client, &error);
449 dbus_error_free(&error);
453 avahi_service_type_browser_free(b);
456 dbus_message_unref(message);
459 dbus_message_unref(reply);
464 AvahiClient* avahi_service_type_browser_get_client (AvahiServiceTypeBrowser *b) {
469 int avahi_service_type_browser_free (AvahiServiceTypeBrowser *b) {
476 if (b->path && client->state != AVAHI_CLIENT_FAILURE)
477 r = avahi_client_simple_method_call(client, b->path, AVAHI_DBUS_INTERFACE_SERVICE_TYPE_BROWSER, "Free");
479 AVAHI_LLIST_REMOVE(AvahiServiceTypeBrowser, service_type_browsers, b->client->service_type_browsers, b);
482 avahi_free(b->domain);
487 DBusHandlerResult avahi_service_type_browser_event (AvahiClient *client, AvahiBrowserEvent event, DBusMessage *message) {
488 AvahiServiceTypeBrowser *b = NULL;
491 char *domain, *type = NULL;
492 int32_t interface, protocol;
498 dbus_error_init (&error);
500 if (!(path = dbus_message_get_path(message)))
503 for (b = client->service_type_browsers; b; b = b->service_type_browsers_next)
504 if (strcmp (b->path, path) == 0)
511 interface = b->interface;
512 protocol = b->protocol;
515 case AVAHI_BROWSER_NEW:
516 case AVAHI_BROWSER_REMOVE:
517 if (!dbus_message_get_args(
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");
531 case AVAHI_BROWSER_CACHE_EXHAUSTED:
532 case AVAHI_BROWSER_ALL_FOR_NOW:
535 case AVAHI_BROWSER_FAILURE: {
538 if (!dbus_message_get_args(
540 DBUS_TYPE_STRING, &etxt,
541 DBUS_TYPE_INVALID) ||
542 dbus_error_is_set (&error)) {
543 fprintf(stderr, "Failed to parse browser event.\n");
547 avahi_client_set_errno(b->client, avahi_error_dbus_to_number(etxt));
552 b->callback(b, (AvahiIfIndex) interface, (AvahiProtocol) protocol, event, type, domain, (AvahiLookupResultFlags) flags, b->userdata);
554 return DBUS_HANDLER_RESULT_HANDLED;
557 dbus_error_free (&error);
558 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
561 /* AvahiServiceBrowser */
563 AvahiServiceBrowser* avahi_service_browser_new(
565 AvahiIfIndex interface,
566 AvahiProtocol protocol,
569 AvahiLookupFlags flags,
570 AvahiServiceBrowserCallback callback,
573 AvahiServiceBrowser *b = NULL;
574 DBusMessage *message = NULL, *reply = NULL;
577 int32_t i_protocol, i_interface;
584 dbus_error_init(&error);
586 if (client->state == AVAHI_CLIENT_FAILURE) {
587 avahi_client_set_errno(client, AVAHI_ERR_BAD_STATE);
594 if (!(b = avahi_new(AvahiServiceBrowser, 1))) {
595 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
600 b->callback = callback;
601 b->userdata = userdata;
603 b->type = b->domain = NULL;
604 b->interface = interface;
605 b->protocol = protocol;
607 AVAHI_LLIST_PREPEND(AvahiServiceBrowser, service_browsers, client->service_browsers, b);
609 if (!(b->type = avahi_strdup(type))) {
610 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
614 if (domain && domain[0])
615 if (!(b->domain = avahi_strdup(domain))) {
616 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
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);
625 i_interface = (int32_t) interface;
626 i_protocol = (int32_t) protocol;
627 u_flags = (uint32_t) flags;
629 if (!dbus_message_append_args(
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);
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);
647 if (!dbus_message_get_args (reply, &error, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID) ||
648 dbus_error_is_set(&error) ||
650 avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR);
654 if (!(b->path = avahi_strdup(path))) {
656 /* FIXME: We don't remove the object on the server side */
658 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
662 dbus_message_unref(message);
663 dbus_message_unref(reply);
668 if (dbus_error_is_set(&error)) {
669 avahi_client_set_dbus_error(client, &error);
670 dbus_error_free(&error);
674 avahi_service_browser_free(b);
677 dbus_message_unref(message);
680 dbus_message_unref(reply);
685 AvahiClient* avahi_service_browser_get_client (AvahiServiceBrowser *b) {
690 int avahi_service_browser_free (AvahiServiceBrowser *b) {
697 if (b->path && client->state != AVAHI_CLIENT_FAILURE)
698 r = avahi_client_simple_method_call(client, b->path, AVAHI_DBUS_INTERFACE_SERVICE_BROWSER, "Free");
700 AVAHI_LLIST_REMOVE(AvahiServiceBrowser, service_browsers, b->client->service_browsers, b);
704 avahi_free(b->domain);
709 DBusHandlerResult avahi_service_browser_event(AvahiClient *client, AvahiBrowserEvent event, DBusMessage *message) {
710 AvahiServiceBrowser *b = NULL;
713 char *name = NULL, *type, *domain;
714 int32_t interface, protocol;
717 dbus_error_init (&error);
719 if (!(path = dbus_message_get_path(message)))
722 for (b = client->service_browsers; b; b = b->service_browsers_next)
723 if (strcmp (b->path, path) == 0)
731 interface = b->interface;
732 protocol = b->protocol;
735 case AVAHI_BROWSER_NEW:
736 case AVAHI_BROWSER_REMOVE:
738 if (!dbus_message_get_args (
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");
753 case AVAHI_BROWSER_CACHE_EXHAUSTED:
754 case AVAHI_BROWSER_ALL_FOR_NOW:
757 case AVAHI_BROWSER_FAILURE: {
760 if (!dbus_message_get_args(
762 DBUS_TYPE_STRING, &etxt,
763 DBUS_TYPE_INVALID) ||
764 dbus_error_is_set (&error)) {
765 fprintf(stderr, "Failed to parse browser event.\n");
769 avahi_client_set_errno(b->client, avahi_error_dbus_to_number(etxt));
774 b->callback(b, (AvahiIfIndex) interface, (AvahiProtocol) protocol, event, name, type, domain, (AvahiLookupResultFlags) flags, b->userdata);
776 return DBUS_HANDLER_RESULT_HANDLED;
779 dbus_error_free (&error);
780 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;