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>
41 void avahi_entry_group_set_state(AvahiEntryGroup *group, AvahiEntryGroupState state) {
44 if (group->state == state)
50 group->callback(group, state, group->userdata);
53 static int retrieve_state(AvahiEntryGroup *group) {
54 DBusMessage *message, *reply;
60 dbus_error_init(&error);
63 client = group->client;
65 if (!(message = dbus_message_new_method_call(AVAHI_DBUS_NAME, group->path, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "GetState"))) {
66 r = avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
70 if (!(reply = dbus_connection_send_with_reply_and_block(client->bus, message, -1, &error)) ||
71 dbus_error_is_set (&error)) {
72 r = avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR);
76 if (!dbus_message_get_args(reply, &error, DBUS_TYPE_INT32, &state, DBUS_TYPE_INVALID) ||
77 dbus_error_is_set (&error)) {
78 r = avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR);
82 dbus_message_unref(message);
83 dbus_message_unref(reply);
85 avahi_entry_group_set_state(group, (AvahiEntryGroupState) state);
90 if (dbus_error_is_set(&error)) {
91 r = avahi_client_set_dbus_error(client, &error);
92 dbus_error_free(&error);
96 dbus_message_unref(message);
99 dbus_message_unref(reply);
104 AvahiEntryGroup* avahi_entry_group_new (AvahiClient *client, AvahiEntryGroupCallback callback, void *userdata) {
105 AvahiEntryGroup *group = NULL;
106 DBusMessage *message = NULL, *reply = NULL;
112 dbus_error_init (&error);
114 if (client->state == AVAHI_CLIENT_DISCONNECTED) {
115 avahi_client_set_errno(client, AVAHI_ERR_BAD_STATE);
119 if (!(group = avahi_new(AvahiEntryGroup, 1))) {
120 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
124 group->client = client;
125 group->callback = callback;
126 group->userdata = userdata;
127 group->state = AVAHI_ENTRY_GROUP_UNCOMMITED;
129 AVAHI_LLIST_PREPEND(AvahiEntryGroup, groups, client->groups, group);
131 if (!(message = dbus_message_new_method_call(
133 AVAHI_DBUS_PATH_SERVER,
134 AVAHI_DBUS_INTERFACE_SERVER,
136 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
140 if (!(reply = dbus_connection_send_with_reply_and_block (client->bus, message, -1, &error)) ||
141 dbus_error_is_set (&error)) {
142 avahi_client_set_errno (client, AVAHI_ERR_DBUS_ERROR);
146 if (!dbus_message_get_args(reply, &error, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID) ||
147 dbus_error_is_set (&error)) {
148 avahi_client_set_errno (client, AVAHI_ERR_DBUS_ERROR);
152 if (!(group->path = avahi_strdup (path))) {
154 /* FIXME: We don't remove the object on the server side */
156 avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
160 if (retrieve_state(group) < 0)
163 dbus_message_unref(message);
164 dbus_message_unref(reply);
169 if (dbus_error_is_set(&error)) {
170 avahi_client_set_dbus_error(client, &error);
171 dbus_error_free(&error);
175 avahi_entry_group_free(group);
178 dbus_message_unref(message);
181 dbus_message_unref(reply);
186 static int entry_group_simple_method_call(AvahiEntryGroup *group, const char *method) {
187 DBusMessage *message = NULL, *reply = NULL;
192 dbus_error_init(&error);
195 client = group->client;
197 if (!(message = dbus_message_new_method_call(AVAHI_DBUS_NAME, group->path, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, method))) {
198 r = avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
202 if (!(reply = dbus_connection_send_with_reply_and_block(client->bus, message, -1, &error)) ||
203 dbus_error_is_set (&error)) {
204 r = avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR);
208 if (!dbus_message_get_args(reply, &error, DBUS_TYPE_INVALID) ||
209 dbus_error_is_set (&error)) {
210 r = avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR);
214 dbus_message_unref(message);
215 dbus_message_unref(reply);
220 if (dbus_error_is_set(&error)) {
221 r = avahi_client_set_dbus_error(client, &error);
222 dbus_error_free(&error);
226 dbus_message_unref(message);
229 dbus_message_unref(reply);
234 int avahi_entry_group_free(AvahiEntryGroup *group) {
235 AvahiClient *client = group->client;
240 if (group->path && client->state != AVAHI_CLIENT_DISCONNECTED)
241 r = entry_group_simple_method_call(group, "Free");
243 AVAHI_LLIST_REMOVE(AvahiEntryGroup, groups, client->groups, group);
245 avahi_free(group->path);
251 int avahi_entry_group_commit(AvahiEntryGroup *group) {
254 if (!group->path || group->client->state == AVAHI_CLIENT_DISCONNECTED)
255 return avahi_client_set_errno(group->client, AVAHI_ERR_BAD_STATE);
257 return entry_group_simple_method_call(group, "Commit");
260 int avahi_entry_group_reset(AvahiEntryGroup *group) {
263 if (!group->path || group->client->state == AVAHI_CLIENT_DISCONNECTED)
264 return avahi_client_set_errno(group->client, AVAHI_ERR_BAD_STATE);
266 return entry_group_simple_method_call(group, "Reset");
269 int avahi_entry_group_get_state (AvahiEntryGroup *group) {
275 AvahiClient* avahi_entry_group_get_client (AvahiEntryGroup *group) {
278 return group->client;
281 int avahi_entry_group_is_empty (AvahiEntryGroup *group) {
282 DBusMessage *message, *reply;
289 client = group->client;
291 if (!group->path || group->client->state == AVAHI_CLIENT_DISCONNECTED)
292 return avahi_client_set_errno(group->client, AVAHI_ERR_BAD_STATE);
294 dbus_error_init(&error);
296 if (!(message = dbus_message_new_method_call(AVAHI_DBUS_NAME, group->path, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "IsEmpty"))) {
297 r = avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
301 if (!(reply = dbus_connection_send_with_reply_and_block(client->bus, message, -1, &error)) ||
302 dbus_error_is_set (&error)) {
303 r = avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR);
307 if (!dbus_message_get_args(reply, &error, DBUS_TYPE_BOOLEAN, &b, DBUS_TYPE_INVALID) ||
308 dbus_error_is_set (&error)) {
309 r = avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR);
313 dbus_message_unref(message);
314 dbus_message_unref(reply);
319 if (dbus_error_is_set(&error)) {
320 r = avahi_client_set_dbus_error(client, &error);
321 dbus_error_free(&error);
325 dbus_message_unref(message);
328 dbus_message_unref(reply);
333 static int append_string_list(DBusMessage *message, AvahiStringList *txt) {
334 DBusMessageIter iter, sub;
340 dbus_message_iter_init_append(message, &iter);
342 /* Reverse the string list, so that we can pass it in-order to the server */
343 txt = avahi_string_list_reverse(txt);
345 if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "ay", &sub))
348 /* Assemble the AvahiStringList into an Array of Array of Bytes to send over dbus */
349 for (p = txt; p != NULL; p = p->next) {
350 DBusMessageIter sub2;
351 const uint8_t *data = p->text;
353 if (!(dbus_message_iter_open_container(&sub, DBUS_TYPE_ARRAY, "y", &sub2)) ||
354 !(dbus_message_iter_append_fixed_array(&sub2, DBUS_TYPE_BYTE, &data, p->size)) ||
355 !(dbus_message_iter_close_container(&sub, &sub2)))
359 if (!dbus_message_iter_close_container(&iter, &sub))
366 /* Reverse the string list to the original state */
367 txt = avahi_string_list_reverse(txt);
372 int avahi_entry_group_add_service_strlst(
373 AvahiEntryGroup *group,
374 AvahiIfIndex interface,
375 AvahiProtocol protocol,
376 AvahiPublishFlags flags,
382 AvahiStringList *txt) {
384 DBusMessage *message = NULL, *reply = NULL;
388 int32_t i_interface, i_protocol;
395 client = group->client;
397 if (!group->path || group->client->state == AVAHI_CLIENT_DISCONNECTED)
398 return avahi_client_set_errno(group->client, AVAHI_ERR_BAD_STATE);
406 dbus_error_init(&error);
408 if (!(message = dbus_message_new_method_call (AVAHI_DBUS_NAME, group->path, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "AddService"))) {
409 r = avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
413 i_interface = (int32_t) interface;
414 i_protocol = (int32_t) protocol;
415 u_flags = (uint32_t) flags;
417 if (!dbus_message_append_args(
419 DBUS_TYPE_INT32, &i_interface,
420 DBUS_TYPE_INT32, &i_protocol,
421 DBUS_TYPE_UINT32, &u_flags,
422 DBUS_TYPE_STRING, &name,
423 DBUS_TYPE_STRING, &type,
424 DBUS_TYPE_STRING, &domain,
425 DBUS_TYPE_STRING, &host,
426 DBUS_TYPE_UINT16, &port,
427 DBUS_TYPE_INVALID) ||
428 append_string_list(message, txt) < 0) {
429 r = avahi_client_set_errno(group->client, AVAHI_ERR_NO_MEMORY);
433 if (!(reply = dbus_connection_send_with_reply_and_block(client->bus, message, -1, &error)) ||
434 dbus_error_is_set (&error)) {
435 r = avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR);
439 if (!dbus_message_get_args(reply, &error, DBUS_TYPE_INVALID) ||
440 dbus_error_is_set (&error)) {
441 r = avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR);
445 dbus_message_unref(message);
446 dbus_message_unref(reply);
452 if (dbus_error_is_set(&error)) {
453 r = avahi_client_set_dbus_error(client, &error);
454 dbus_error_free(&error);
458 dbus_message_unref(message);
461 dbus_message_unref(reply);
466 int avahi_entry_group_add_service(
467 AvahiEntryGroup *group,
468 AvahiIfIndex interface,
469 AvahiProtocol protocol,
470 AvahiPublishFlags flags,
484 r = avahi_entry_group_add_service_va(group, interface, protocol, flags, name, type, domain, host, port, va);
489 int avahi_entry_group_add_service_va(
490 AvahiEntryGroup *group,
491 AvahiIfIndex interface,
492 AvahiProtocol protocol,
493 AvahiPublishFlags flags,
502 AvahiStringList *txt;
506 txt = avahi_string_list_new_va(va);
507 r = avahi_entry_group_add_service_strlst(group, interface, protocol, flags, name, type, domain, host, port, txt);
508 avahi_string_list_free(txt);
513 int avahi_entry_group_add_service_subtype(
514 AvahiEntryGroup *group,
515 AvahiIfIndex interface,
516 AvahiProtocol protocol,
517 AvahiPublishFlags flags,
521 const char *subtype) {
523 DBusMessage *message = NULL, *reply = NULL;
527 int32_t i_interface, i_protocol;
535 client = group->client;
537 if (!group->path || group->client->state == AVAHI_CLIENT_DISCONNECTED)
538 return avahi_client_set_errno(group->client, AVAHI_ERR_BAD_STATE);
543 dbus_error_init(&error);
545 if (!(message = dbus_message_new_method_call (AVAHI_DBUS_NAME, group->path, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "AddServiceSubtype"))) {
546 r = avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
550 i_interface = (int32_t) interface;
551 i_protocol = (int32_t) protocol;
552 u_flags = (uint32_t) flags;
554 if (!dbus_message_append_args(
556 DBUS_TYPE_INT32, &i_interface,
557 DBUS_TYPE_INT32, &i_protocol,
558 DBUS_TYPE_UINT32, &u_flags,
559 DBUS_TYPE_STRING, &name,
560 DBUS_TYPE_STRING, &type,
561 DBUS_TYPE_STRING, &domain,
562 DBUS_TYPE_STRING, &subtype,
563 DBUS_TYPE_INVALID)) {
564 r = avahi_client_set_errno(group->client, AVAHI_ERR_NO_MEMORY);
568 if (!(reply = dbus_connection_send_with_reply_and_block(client->bus, message, -1, &error)) ||
569 dbus_error_is_set (&error)) {
570 r = avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR);
574 if (!dbus_message_get_args(reply, &error, DBUS_TYPE_INVALID) ||
575 dbus_error_is_set (&error)) {
576 r = avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR);
580 dbus_message_unref(message);
581 dbus_message_unref(reply);
587 if (dbus_error_is_set(&error)) {
588 r = avahi_client_set_dbus_error(client, &error);
589 dbus_error_free(&error);
593 dbus_message_unref(message);
596 dbus_message_unref(reply);
602 int avahi_entry_group_update_service_txt(
603 AvahiEntryGroup *group,
604 AvahiIfIndex interface,
605 AvahiProtocol protocol,
606 AvahiPublishFlags flags,
615 va_start(va, domain);
616 r = avahi_entry_group_update_service_txt_va(group, interface, protocol, flags, name, type, domain, va);
621 int avahi_entry_group_update_service_txt_va(
622 AvahiEntryGroup *group,
623 AvahiIfIndex interface,
624 AvahiProtocol protocol,
625 AvahiPublishFlags flags,
632 AvahiStringList *txt;
634 txt = avahi_string_list_new_va(va);
635 r = avahi_entry_group_update_service_txt_strlst(group, interface, protocol, flags, name, type, domain, txt);
636 avahi_string_list_free(txt);
641 int avahi_entry_group_update_service_txt_strlst(
642 AvahiEntryGroup *group,
643 AvahiIfIndex interface,
644 AvahiProtocol protocol,
645 AvahiPublishFlags flags,
649 AvahiStringList *txt) {
651 DBusMessage *message = NULL, *reply = NULL;
655 int32_t i_interface, i_protocol;
662 client = group->client;
664 if (!group->path || group->client->state == AVAHI_CLIENT_DISCONNECTED)
665 return avahi_client_set_errno(group->client, AVAHI_ERR_BAD_STATE);
670 dbus_error_init(&error);
672 if (!(message = dbus_message_new_method_call (AVAHI_DBUS_NAME, group->path, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "UpdateServiceTxt"))) {
673 r = avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
677 i_interface = (int32_t) interface;
678 i_protocol = (int32_t) protocol;
679 u_flags = (uint32_t) flags;
681 if (!dbus_message_append_args(
683 DBUS_TYPE_INT32, &i_interface,
684 DBUS_TYPE_INT32, &i_protocol,
685 DBUS_TYPE_UINT32, &u_flags,
686 DBUS_TYPE_STRING, &name,
687 DBUS_TYPE_STRING, &type,
688 DBUS_TYPE_STRING, &domain,
689 DBUS_TYPE_INVALID) ||
690 append_string_list(message, txt) < 0) {
691 r = avahi_client_set_errno(group->client, AVAHI_ERR_NO_MEMORY);
695 if (!(reply = dbus_connection_send_with_reply_and_block(client->bus, message, -1, &error)) ||
696 dbus_error_is_set (&error)) {
697 r = avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR);
701 if (!dbus_message_get_args(reply, &error, DBUS_TYPE_INVALID) ||
702 dbus_error_is_set (&error)) {
703 r = avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR);
707 dbus_message_unref(message);
708 dbus_message_unref(reply);
714 if (dbus_error_is_set(&error)) {
715 r = avahi_client_set_dbus_error(client, &error);
716 dbus_error_free(&error);
720 dbus_message_unref(message);
723 dbus_message_unref(reply);
730 /** Add a host/address pair */
731 int avahi_entry_group_add_address(
732 AvahiEntryGroup *group,
733 AvahiIfIndex interface,
734 AvahiProtocol protocol,
735 AvahiPublishFlags flags,
737 const AvahiAddress *a) {
739 DBusMessage *message = NULL, *reply = NULL;
743 int32_t i_interface, i_protocol;
745 char s_address[AVAHI_ADDRESS_STR_MAX];
746 char *p_address = s_address;
750 client = group->client;
752 if (!group->path || group->client->state == AVAHI_CLIENT_DISCONNECTED)
753 return avahi_client_set_errno(group->client, AVAHI_ERR_BAD_STATE);
755 dbus_error_init(&error);
757 if (!(message = dbus_message_new_method_call (AVAHI_DBUS_NAME, group->path, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "AddAddress"))) {
758 r = avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
762 i_interface = (int32_t) interface;
763 i_protocol = (int32_t) protocol;
764 u_flags = (uint32_t) flags;
766 if (!avahi_address_snprint (s_address, sizeof (s_address), a))
768 r = avahi_client_set_errno(client, AVAHI_ERR_INVALID_ADDRESS);
772 if (!dbus_message_append_args(
774 DBUS_TYPE_INT32, &i_interface,
775 DBUS_TYPE_INT32, &i_protocol,
776 DBUS_TYPE_UINT32, &u_flags,
777 DBUS_TYPE_STRING, &name,
778 DBUS_TYPE_STRING, &p_address,
779 DBUS_TYPE_INVALID)) {
780 r = avahi_client_set_errno(group->client, AVAHI_ERR_NO_MEMORY);
784 if (!(reply = dbus_connection_send_with_reply_and_block(client->bus, message, -1, &error)) ||
785 dbus_error_is_set (&error)) {
786 r = avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR);
790 if (!dbus_message_get_args(reply, &error, DBUS_TYPE_INVALID) ||
791 dbus_error_is_set (&error)) {
792 r = avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR);
796 dbus_message_unref(message);
797 dbus_message_unref(reply);
803 if (dbus_error_is_set(&error)) {
804 r = avahi_client_set_dbus_error(client, &error);
805 dbus_error_free(&error);
809 dbus_message_unref(message);
812 dbus_message_unref(reply);