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-common/dbus.h>
33 #include <avahi-common/llist.h>
34 #include <avahi-common/error.h>
35 #include <avahi-common/dbus.h>
36 #include <avahi-common/malloc.h>
37 #include <avahi-common/dbus-watch-glue.h>
42 static int init_server(AvahiClient *client, int *ret_error);
44 int avahi_client_set_errno (AvahiClient *client, int error) {
47 return client->error = error;
50 int avahi_client_set_dbus_error(AvahiClient *client, DBusError *error) {
54 return avahi_client_set_errno(client, avahi_error_dbus_to_number(error->name));
57 static void client_set_state (AvahiClient *client, AvahiServerState state) {
60 if (client->state == state)
63 client->state = state;
65 switch (client->state) {
66 case AVAHI_CLIENT_FAILURE:
68 dbus_connection_disconnect(client->bus);
69 dbus_connection_unref(client->bus);
75 case AVAHI_CLIENT_S_COLLISION:
76 case AVAHI_CLIENT_S_REGISTERING:
78 /* Clear cached strings */
79 avahi_free(client->host_name);
80 avahi_free(client->host_name_fqdn);
81 avahi_free(client->domain_name);
83 client->host_name = NULL;
84 client->host_name_fqdn = NULL;
85 client->domain_name = NULL;
88 case AVAHI_CLIENT_S_RUNNING:
89 case AVAHI_CLIENT_CONNECTING:
95 client->callback (client, state, client->userdata);
98 static DBusHandlerResult filter_func(DBusConnection *bus, DBusMessage *message, void *userdata) {
99 AvahiClient *client = userdata;
105 dbus_error_init(&error);
107 /* fprintf(stderr, "dbus: interface=%s, path=%s, member=%s\n", */
108 /* dbus_message_get_interface (message), */
109 /* dbus_message_get_path (message), */
110 /* dbus_message_get_member (message)); */
112 if (dbus_message_is_signal(message, DBUS_INTERFACE_LOCAL, "Disconnected")) {
114 /* The DBUS server died or kicked us */
115 avahi_client_set_errno(client, AVAHI_ERR_DISCONNECTED);
118 } else if (dbus_message_is_signal(message, DBUS_INTERFACE_DBUS, "NameAcquired")) {
120 /* Ignore this message */
122 } else if (dbus_message_is_signal(message, DBUS_INTERFACE_DBUS, "NameOwnerChanged")) {
123 char *name, *old, *new;
125 if (!dbus_message_get_args(
127 DBUS_TYPE_STRING, &name,
128 DBUS_TYPE_STRING, &old,
129 DBUS_TYPE_STRING, &new,
130 DBUS_TYPE_INVALID) || dbus_error_is_set(&error)) {
132 fprintf(stderr, "WARNING: Failed to parse NameOwnerChanged signal: %s\n", error.message);
133 avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR);
137 if (strcmp(name, AVAHI_DBUS_NAME) == 0) {
139 if (avahi_client_is_connected(client)) {
141 /* Regardless if the server lost or acquired its name or
142 * if the name was transfered: our services are no longer
143 * available, so we disconnect ourselves */
144 avahi_client_set_errno(client, AVAHI_ERR_DISCONNECTED);
147 } else if (client->state == AVAHI_CLIENT_CONNECTING && (!old || *old == 0)) {
150 /* Server appeared */
152 if ((ret = init_server(client, NULL)) < 0) {
153 avahi_client_set_errno(client, ret);
159 } else if (!avahi_client_is_connected(client)) {
161 /* Ignore messages we get in unconnected state */
163 } else if (dbus_message_is_signal (message, AVAHI_DBUS_INTERFACE_SERVER, "StateChanged")) {
168 if (!dbus_message_get_args(
170 DBUS_TYPE_INT32, &state,
171 DBUS_TYPE_STRING, &e,
172 DBUS_TYPE_INVALID) || dbus_error_is_set (&error)) {
174 fprintf(stderr, "WARNING: Failed to parse Server.StateChanged signal: %s\n", error.message);
175 avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR);
179 if ((c = avahi_error_dbus_to_number(e)) != AVAHI_OK)
180 avahi_client_set_errno(client, c);
182 client_set_state(client, (AvahiClientState) state);
184 } else if (dbus_message_is_signal (message, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "StateChanged")) {
187 path = dbus_message_get_path(message);
189 for (g = client->groups; g; g = g->groups_next)
190 if (strcmp(g->path, path) == 0)
198 if (!dbus_message_get_args(
200 DBUS_TYPE_INT32, &state,
201 DBUS_TYPE_STRING, &e,
202 DBUS_TYPE_INVALID) ||
203 dbus_error_is_set(&error)) {
205 fprintf(stderr, "WARNING: Failed to parse EntryGroup.StateChanged signal: %s\n", error.message);
206 avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR);
210 if ((c = avahi_error_dbus_to_number(e)) != AVAHI_OK)
211 avahi_client_set_errno(client, c);
213 avahi_entry_group_set_state(g, state);
216 } else if (dbus_message_is_signal(message, AVAHI_DBUS_INTERFACE_DOMAIN_BROWSER, "ItemNew"))
217 return avahi_domain_browser_event(client, AVAHI_BROWSER_NEW, message);
218 else if (dbus_message_is_signal (message, AVAHI_DBUS_INTERFACE_DOMAIN_BROWSER, "ItemRemove"))
219 return avahi_domain_browser_event(client, AVAHI_BROWSER_REMOVE, message);
220 else if (dbus_message_is_signal (message, AVAHI_DBUS_INTERFACE_DOMAIN_BROWSER, "CacheExhausted"))
221 return avahi_domain_browser_event(client, AVAHI_BROWSER_CACHE_EXHAUSTED, message);
222 else if (dbus_message_is_signal (message, AVAHI_DBUS_INTERFACE_DOMAIN_BROWSER, "AllForNow"))
223 return avahi_domain_browser_event(client, AVAHI_BROWSER_ALL_FOR_NOW, message);
224 else if (dbus_message_is_signal (message, AVAHI_DBUS_INTERFACE_DOMAIN_BROWSER, "Failure"))
225 return avahi_domain_browser_event(client, AVAHI_BROWSER_FAILURE, message);
227 else if (dbus_message_is_signal(message, AVAHI_DBUS_INTERFACE_SERVICE_TYPE_BROWSER, "ItemNew"))
228 return avahi_service_type_browser_event (client, AVAHI_BROWSER_NEW, message);
229 else if (dbus_message_is_signal(message, AVAHI_DBUS_INTERFACE_SERVICE_TYPE_BROWSER, "ItemRemove"))
230 return avahi_service_type_browser_event (client, AVAHI_BROWSER_REMOVE, message);
231 else if (dbus_message_is_signal(message, AVAHI_DBUS_INTERFACE_SERVICE_TYPE_BROWSER, "CacheExhausted"))
232 return avahi_service_type_browser_event (client, AVAHI_BROWSER_CACHE_EXHAUSTED, message);
233 else if (dbus_message_is_signal(message, AVAHI_DBUS_INTERFACE_SERVICE_TYPE_BROWSER, "AllForNow"))
234 return avahi_service_type_browser_event (client, AVAHI_BROWSER_ALL_FOR_NOW, message);
235 else if (dbus_message_is_signal(message, AVAHI_DBUS_INTERFACE_SERVICE_TYPE_BROWSER, "Failure"))
236 return avahi_service_type_browser_event (client, AVAHI_BROWSER_FAILURE, message);
238 else if (dbus_message_is_signal(message, AVAHI_DBUS_INTERFACE_SERVICE_BROWSER, "ItemNew"))
239 return avahi_service_browser_event (client, AVAHI_BROWSER_NEW, message);
240 else if (dbus_message_is_signal(message, AVAHI_DBUS_INTERFACE_SERVICE_BROWSER, "ItemRemove"))
241 return avahi_service_browser_event (client, AVAHI_BROWSER_REMOVE, message);
242 else if (dbus_message_is_signal(message, AVAHI_DBUS_INTERFACE_SERVICE_BROWSER, "CacheExhausted"))
243 return avahi_service_browser_event (client, AVAHI_BROWSER_CACHE_EXHAUSTED, message);
244 else if (dbus_message_is_signal(message, AVAHI_DBUS_INTERFACE_SERVICE_BROWSER, "AllForNow"))
245 return avahi_service_browser_event (client, AVAHI_BROWSER_ALL_FOR_NOW, message);
246 else if (dbus_message_is_signal(message, AVAHI_DBUS_INTERFACE_SERVICE_BROWSER, "Failure"))
247 return avahi_service_browser_event (client, AVAHI_BROWSER_FAILURE, message);
249 else if (dbus_message_is_signal(message, AVAHI_DBUS_INTERFACE_SERVICE_RESOLVER, "Found"))
250 return avahi_service_resolver_event (client, AVAHI_RESOLVER_FOUND, message);
251 else if (dbus_message_is_signal(message, AVAHI_DBUS_INTERFACE_SERVICE_RESOLVER, "Failure"))
252 return avahi_service_resolver_event (client, AVAHI_RESOLVER_FAILURE, message);
254 else if (dbus_message_is_signal(message, AVAHI_DBUS_INTERFACE_HOST_NAME_RESOLVER, "Found"))
255 return avahi_host_name_resolver_event (client, AVAHI_RESOLVER_FOUND, message);
256 else if (dbus_message_is_signal(message, AVAHI_DBUS_INTERFACE_HOST_NAME_RESOLVER, "Failure"))
257 return avahi_host_name_resolver_event (client, AVAHI_RESOLVER_FAILURE, message);
259 else if (dbus_message_is_signal(message, AVAHI_DBUS_INTERFACE_ADDRESS_RESOLVER, "Found"))
260 return avahi_address_resolver_event (client, AVAHI_RESOLVER_FOUND, message);
261 else if (dbus_message_is_signal(message, AVAHI_DBUS_INTERFACE_ADDRESS_RESOLVER, "Failure"))
262 return avahi_address_resolver_event (client, AVAHI_RESOLVER_FAILURE, message);
265 fprintf(stderr, "WARNING: Unhandled message: interface=%s, path=%s, member=%s\n",
266 dbus_message_get_interface(message),
267 dbus_message_get_path(message),
268 dbus_message_get_member(message));
270 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
273 return DBUS_HANDLER_RESULT_HANDLED;
277 if (dbus_error_is_set(&error)) {
278 avahi_client_set_errno(client, avahi_error_dbus_to_number(error.name));
279 dbus_error_free(&error);
282 client_set_state(client, AVAHI_CLIENT_FAILURE);
284 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
287 static int get_server_state(AvahiClient *client, int *ret_error) {
288 DBusMessage *message = NULL, *reply = NULL;
291 int e = AVAHI_ERR_NO_MEMORY;
295 dbus_error_init(&error);
297 if (!(message = dbus_message_new_method_call(AVAHI_DBUS_NAME, AVAHI_DBUS_PATH_SERVER, AVAHI_DBUS_INTERFACE_SERVER, "GetState")))
300 reply = dbus_connection_send_with_reply_and_block (client->bus, message, -1, &error);
302 if (!reply || dbus_error_is_set (&error))
305 if (!dbus_message_get_args(reply, &error, DBUS_TYPE_INT32, &state, DBUS_TYPE_INVALID) ||
306 dbus_error_is_set (&error))
309 client_set_state(client, (AvahiServerState) state);
311 dbus_message_unref(message);
312 dbus_message_unref(reply);
317 if (dbus_error_is_set(&error)) {
318 e = avahi_error_dbus_to_number (error.name);
319 dbus_error_free(&error);
326 dbus_message_unref(message);
328 dbus_message_unref(reply);
333 static int check_version(AvahiClient *client, int *ret_error) {
334 DBusMessage *message = NULL, *reply = NULL;
337 int e = AVAHI_ERR_NO_MEMORY;
341 dbus_error_init(&error);
343 if (!(message = dbus_message_new_method_call(AVAHI_DBUS_NAME, AVAHI_DBUS_PATH_SERVER, AVAHI_DBUS_INTERFACE_SERVER, "GetVersionString")))
346 reply = dbus_connection_send_with_reply_and_block (client->bus, message, -1, &error);
348 if (!reply || dbus_error_is_set (&error))
351 if (!dbus_message_get_args (reply, &error, DBUS_TYPE_STRING, &version, DBUS_TYPE_INVALID) ||
352 dbus_error_is_set (&error))
355 if (strcmp(version, PACKAGE_STRING) != 0) {
356 e = AVAHI_ERR_VERSION_MISMATCH;
360 dbus_message_unref(message);
361 dbus_message_unref(reply);
366 if (dbus_error_is_set(&error)) {
367 e = avahi_error_dbus_to_number (error.name);
368 dbus_error_free(&error);
375 dbus_message_unref(message);
377 dbus_message_unref(reply);
382 static int init_server(AvahiClient *client, int *ret_error) {
385 if ((r = check_version(client, ret_error)) < 0)
388 if ((r = get_server_state(client, ret_error)) < 0)
394 /* This function acts like dbus_bus_get but creates a private
395 * connection instead */
396 static DBusConnection* avahi_dbus_bus_get(DBusError *error) {
400 if (!(a = getenv("DBUS_SYSTEM_BUS_ADDRESS")) || !*a)
401 a = DBUS_SYSTEM_BUS_DEFAULT_ADDRESS;
403 if (!(c = dbus_connection_open_private(a, error)))
406 dbus_connection_set_exit_on_disconnect(c, FALSE);
408 if (!dbus_bus_register(c, error)) {
409 dbus_connection_close(c);
410 dbus_connection_unref(c);
417 AvahiClient *avahi_client_new(const AvahiPoll *poll_api, AvahiClientFlags flags, AvahiClientCallback callback, void *userdata, int *ret_error) {
418 AvahiClient *client = NULL;
421 dbus_error_init(&error);
423 if (!(client = avahi_new(AvahiClient, 1))) {
425 *ret_error = AVAHI_ERR_NO_MEMORY;
429 client->poll_api = poll_api;
430 client->error = AVAHI_OK;
431 client->callback = callback;
432 client->userdata = userdata;
433 client->state = (AvahiClientState) -1;
434 client->flags = flags;
436 client->host_name = NULL;
437 client->host_name_fqdn = NULL;
438 client->domain_name = NULL;
439 client->version_string = NULL;
440 client->local_service_cookie_valid = 0;
442 AVAHI_LLIST_HEAD_INIT(AvahiEntryGroup, client->groups);
443 AVAHI_LLIST_HEAD_INIT(AvahiDomainBrowser, client->domain_browsers);
444 AVAHI_LLIST_HEAD_INIT(AvahiServiceBrowser, client->service_browsers);
445 AVAHI_LLIST_HEAD_INIT(AvahiServiceTypeBrowser, client->service_type_browsers);
446 AVAHI_LLIST_HEAD_INIT(AvahiServiceResolver, client->service_resolvers);
447 AVAHI_LLIST_HEAD_INIT(AvahiHostNameResolver, client->host_name_resolvers);
448 AVAHI_LLIST_HEAD_INIT(AvahiAddressResolver, client->address_resolvers);
450 if (!(client->bus = avahi_dbus_bus_get(&error)) || dbus_error_is_set(&error)) {
452 *ret_error = AVAHI_ERR_DBUS_ERROR;
456 if (avahi_dbus_connection_glue(client->bus, poll_api) < 0) {
458 *ret_error = AVAHI_ERR_NO_MEMORY; /* Not optimal */
462 if (!dbus_connection_add_filter (client->bus, filter_func, client, NULL)) {
464 *ret_error = AVAHI_ERR_NO_MEMORY;
471 "interface='" AVAHI_DBUS_INTERFACE_SERVER "', "
472 "sender='" AVAHI_DBUS_NAME "', "
473 "path='" AVAHI_DBUS_PATH_SERVER "'",
476 if (dbus_error_is_set(&error))
482 "interface='" DBUS_INTERFACE_DBUS "', "
483 "sender='" DBUS_SERVICE_DBUS "', "
484 "path='" DBUS_PATH_DBUS "'",
487 if (dbus_error_is_set(&error))
493 "interface='" DBUS_INTERFACE_LOCAL "'",
496 if (dbus_error_is_set(&error))
500 if (!(dbus_bus_name_has_owner(client->bus, AVAHI_DBUS_NAME, &error)) ||
501 dbus_error_is_set(&error)) {
503 /* We free the error so its not set, that way the fail target
504 * will return the NO_DAEMON error rather than a DBUS error */
505 dbus_error_free(&error);
507 if (!(flags & AVAHI_CLIENT_NO_FAIL)) {
510 *ret_error = AVAHI_ERR_NO_DAEMON;
515 /* The user doesn't want this call to fail if the daemon is not
516 * available, so let's return succesfully */
517 client_set_state(client, AVAHI_CLIENT_CONNECTING);
521 if (init_server(client, ret_error) < 0)
530 avahi_client_free(client);
532 if (dbus_error_is_set(&error)) {
535 *ret_error = avahi_error_dbus_to_number(error.name);
537 dbus_error_free(&error);
543 void avahi_client_free(AvahiClient *client) {
546 while (client->groups)
547 avahi_entry_group_free(client->groups);
549 while (client->domain_browsers)
550 avahi_domain_browser_free(client->domain_browsers);
552 while (client->service_browsers)
553 avahi_service_browser_free(client->service_browsers);
555 while (client->service_type_browsers)
556 avahi_service_type_browser_free(client->service_type_browsers);
558 while (client->service_resolvers)
559 avahi_service_resolver_free(client->service_resolvers);
562 dbus_connection_disconnect(client->bus);
563 dbus_connection_unref(client->bus);
566 avahi_free(client->version_string);
567 avahi_free(client->host_name);
568 avahi_free(client->host_name_fqdn);
569 avahi_free(client->domain_name);
574 static char* avahi_client_get_string_reply_and_block (AvahiClient *client, const char *method, const char *param) {
575 DBusMessage *message = NULL, *reply = NULL;
582 dbus_error_init (&error);
584 if (!(message = dbus_message_new_method_call (AVAHI_DBUS_NAME, AVAHI_DBUS_PATH_SERVER, AVAHI_DBUS_INTERFACE_SERVER, method))) {
585 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
590 if (!dbus_message_append_args (message, DBUS_TYPE_STRING, ¶m, DBUS_TYPE_INVALID)) {
591 avahi_client_set_errno (client, AVAHI_ERR_NO_MEMORY);
596 reply = dbus_connection_send_with_reply_and_block (client->bus, message, -1, &error);
598 if (!reply || dbus_error_is_set (&error))
601 if (!dbus_message_get_args (reply, &error, DBUS_TYPE_STRING, &ret, DBUS_TYPE_INVALID) ||
602 dbus_error_is_set (&error))
605 if (!(n = avahi_strdup(ret))) {
606 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
610 dbus_message_unref(message);
611 dbus_message_unref(reply);
618 dbus_message_unref(message);
620 dbus_message_unref(reply);
622 if (dbus_error_is_set(&error)) {
623 avahi_client_set_dbus_error(client, &error);
624 dbus_error_free(&error);
630 const char* avahi_client_get_version_string(AvahiClient *client) {
633 if (!avahi_client_is_connected(client)) {
634 avahi_client_set_errno(client, AVAHI_ERR_BAD_STATE);
638 if (!client->version_string)
639 client->version_string = avahi_client_get_string_reply_and_block(client, "GetVersionString", NULL);
641 return client->version_string;
644 const char* avahi_client_get_domain_name(AvahiClient *client) {
647 if (!avahi_client_is_connected(client)) {
648 avahi_client_set_errno(client, AVAHI_ERR_BAD_STATE);
652 if (!client->domain_name)
653 client->domain_name = avahi_client_get_string_reply_and_block(client, "GetDomainName", NULL);
655 return client->domain_name;
658 const char* avahi_client_get_host_name(AvahiClient *client) {
661 if (!avahi_client_is_connected(client)) {
662 avahi_client_set_errno(client, AVAHI_ERR_BAD_STATE);
666 if (!client->host_name)
667 client->host_name = avahi_client_get_string_reply_and_block(client, "GetHostName", NULL);
669 return client->host_name;
672 const char* avahi_client_get_host_name_fqdn (AvahiClient *client) {
675 if (!avahi_client_is_connected(client)) {
676 avahi_client_set_errno(client, AVAHI_ERR_BAD_STATE);
680 if (!client->host_name_fqdn)
681 client->host_name_fqdn = avahi_client_get_string_reply_and_block(client, "GetHostNameFqdn", NULL);
683 return client->host_name_fqdn;
686 AvahiClientState avahi_client_get_state(AvahiClient *client) {
689 return client->state;
692 int avahi_client_errno(AvahiClient *client) {
695 return client->error;
698 /* Just for internal use */
699 int avahi_client_simple_method_call(AvahiClient *client, const char *path, const char *interface, const char *method) {
700 DBusMessage *message = NULL, *reply = NULL;
704 dbus_error_init(&error);
711 if (!(message = dbus_message_new_method_call(AVAHI_DBUS_NAME, path, interface, method))) {
712 r = avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
716 if (!(reply = dbus_connection_send_with_reply_and_block(client->bus, message, -1, &error)) ||
717 dbus_error_is_set (&error)) {
718 r = avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR);
722 if (!dbus_message_get_args(reply, &error, DBUS_TYPE_INVALID) ||
723 dbus_error_is_set (&error)) {
724 r = avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR);
728 dbus_message_unref(message);
729 dbus_message_unref(reply);
734 if (dbus_error_is_set(&error)) {
735 r = avahi_client_set_dbus_error(client, &error);
736 dbus_error_free(&error);
740 dbus_message_unref(message);
743 dbus_message_unref(reply);
748 uint32_t avahi_client_get_local_service_cookie(AvahiClient *client) {
749 DBusMessage *message = NULL, *reply = NULL;
753 if (!avahi_client_is_connected(client)) {
754 avahi_client_set_errno(client, AVAHI_ERR_BAD_STATE);
755 return AVAHI_SERVICE_COOKIE_INVALID;
758 if (client->local_service_cookie_valid)
759 return client->local_service_cookie;
761 dbus_error_init (&error);
763 if (!(message = dbus_message_new_method_call(AVAHI_DBUS_NAME, AVAHI_DBUS_PATH_SERVER, AVAHI_DBUS_INTERFACE_SERVER, "GetLocalServiceCookie"))) {
764 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
768 reply = dbus_connection_send_with_reply_and_block (client->bus, message, -1, &error);
770 if (!reply || dbus_error_is_set (&error))
773 if (!dbus_message_get_args (reply, &error, DBUS_TYPE_UINT32, &client->local_service_cookie, DBUS_TYPE_INVALID) ||
774 dbus_error_is_set (&error))
777 dbus_message_unref(message);
778 dbus_message_unref(reply);
780 client->local_service_cookie_valid = 1;
781 return client->local_service_cookie;
786 dbus_message_unref(message);
788 dbus_message_unref(reply);
790 if (dbus_error_is_set(&error)) {
791 avahi_client_set_dbus_error(client, &error);
792 dbus_error_free(&error);
795 return AVAHI_SERVICE_COOKIE_INVALID;
798 int avahi_client_is_connected(AvahiClient *client) {
801 return client->state == AVAHI_CLIENT_S_RUNNING || client->state == AVAHI_CLIENT_S_REGISTERING || client->state == AVAHI_CLIENT_S_COLLISION;