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;
341 dbus_message_iter_init_append(message, &iter);
343 /* Reverse the string list, so that we can pass it in-order to the server */
344 txt = avahi_string_list_reverse(txt);
346 if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "ay", &sub))
349 /* Assemble the AvahiStringList into an Array of Array of Bytes to send over dbus */
350 for (p = txt; p != NULL; p = p->next) {
351 DBusMessageIter sub2;
352 const uint8_t *data = p->text;
354 if (!(dbus_message_iter_open_container(&sub, DBUS_TYPE_ARRAY, "y", &sub2)) ||
355 !(dbus_message_iter_append_fixed_array(&sub2, DBUS_TYPE_BYTE, &data, p->size)) ||
356 !(dbus_message_iter_close_container(&sub, &sub2)))
360 if (!dbus_message_iter_close_container(&iter, &sub))
367 /* Reverse the string list to the original state */
368 txt = avahi_string_list_reverse(txt);
373 int avahi_entry_group_add_service_strlst(
374 AvahiEntryGroup *group,
375 AvahiIfIndex interface,
376 AvahiProtocol protocol,
377 AvahiPublishFlags flags,
383 AvahiStringList *txt) {
385 DBusMessage *message = NULL, *reply = NULL;
389 int32_t i_interface, i_protocol;
396 client = group->client;
398 if (!group->path || group->client->state == AVAHI_CLIENT_DISCONNECTED)
399 return avahi_client_set_errno(group->client, AVAHI_ERR_BAD_STATE);
407 dbus_error_init(&error);
409 if (!(message = dbus_message_new_method_call (AVAHI_DBUS_NAME, group->path, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "AddService"))) {
410 r = avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
414 i_interface = (int32_t) interface;
415 i_protocol = (int32_t) protocol;
416 u_flags = (uint32_t) flags;
418 if (!dbus_message_append_args(
420 DBUS_TYPE_INT32, &i_interface,
421 DBUS_TYPE_INT32, &i_protocol,
422 DBUS_TYPE_UINT32, &u_flags,
423 DBUS_TYPE_STRING, &name,
424 DBUS_TYPE_STRING, &type,
425 DBUS_TYPE_STRING, &domain,
426 DBUS_TYPE_STRING, &host,
427 DBUS_TYPE_UINT16, &port,
428 DBUS_TYPE_INVALID) ||
429 append_string_list(message, txt) < 0) {
430 r = avahi_client_set_errno(group->client, AVAHI_ERR_NO_MEMORY);
434 if (!(reply = dbus_connection_send_with_reply_and_block(client->bus, message, -1, &error)) ||
435 dbus_error_is_set (&error)) {
436 r = avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR);
440 if (!dbus_message_get_args(reply, &error, DBUS_TYPE_INVALID) ||
441 dbus_error_is_set (&error)) {
442 r = avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR);
446 dbus_message_unref(message);
447 dbus_message_unref(reply);
453 if (dbus_error_is_set(&error)) {
454 r = avahi_client_set_dbus_error(client, &error);
455 dbus_error_free(&error);
459 dbus_message_unref(message);
462 dbus_message_unref(reply);
467 int avahi_entry_group_add_service(
468 AvahiEntryGroup *group,
469 AvahiIfIndex interface,
470 AvahiProtocol protocol,
471 AvahiPublishFlags flags,
485 r = avahi_entry_group_add_service_va(group, interface, protocol, flags, name, type, domain, host, port, va);
490 int avahi_entry_group_add_service_va(
491 AvahiEntryGroup *group,
492 AvahiIfIndex interface,
493 AvahiProtocol protocol,
494 AvahiPublishFlags flags,
503 AvahiStringList *txt;
507 txt = avahi_string_list_new_va(va);
508 r = avahi_entry_group_add_service_strlst(group, interface, protocol, flags, name, type, domain, host, port, txt);
509 avahi_string_list_free(txt);
514 int avahi_entry_group_add_service_subtype(
515 AvahiEntryGroup *group,
516 AvahiIfIndex interface,
517 AvahiProtocol protocol,
518 AvahiPublishFlags flags,
522 const char *subtype) {
524 DBusMessage *message = NULL, *reply = NULL;
528 int32_t i_interface, i_protocol;
536 client = group->client;
538 if (!group->path || group->client->state == AVAHI_CLIENT_DISCONNECTED)
539 return avahi_client_set_errno(group->client, AVAHI_ERR_BAD_STATE);
544 dbus_error_init(&error);
546 if (!(message = dbus_message_new_method_call (AVAHI_DBUS_NAME, group->path, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "AddServiceSubtype"))) {
547 r = avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
551 i_interface = (int32_t) interface;
552 i_protocol = (int32_t) protocol;
553 u_flags = (uint32_t) flags;
555 if (!dbus_message_append_args(
557 DBUS_TYPE_INT32, &i_interface,
558 DBUS_TYPE_INT32, &i_protocol,
559 DBUS_TYPE_UINT32, &u_flags,
560 DBUS_TYPE_STRING, &name,
561 DBUS_TYPE_STRING, &type,
562 DBUS_TYPE_STRING, &domain,
563 DBUS_TYPE_STRING, &subtype,
564 DBUS_TYPE_INVALID)) {
565 r = avahi_client_set_errno(group->client, AVAHI_ERR_NO_MEMORY);
569 if (!(reply = dbus_connection_send_with_reply_and_block(client->bus, message, -1, &error)) ||
570 dbus_error_is_set (&error)) {
571 r = avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR);
575 if (!dbus_message_get_args(reply, &error, DBUS_TYPE_INVALID) ||
576 dbus_error_is_set (&error)) {
577 r = avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR);
581 dbus_message_unref(message);
582 dbus_message_unref(reply);
588 if (dbus_error_is_set(&error)) {
589 r = avahi_client_set_dbus_error(client, &error);
590 dbus_error_free(&error);
594 dbus_message_unref(message);
597 dbus_message_unref(reply);
603 int avahi_entry_group_update_service_txt(
604 AvahiEntryGroup *group,
605 AvahiIfIndex interface,
606 AvahiProtocol protocol,
607 AvahiPublishFlags flags,
616 va_start(va, domain);
617 r = avahi_entry_group_update_service_txt_va(group, interface, protocol, flags, name, type, domain, va);
622 int avahi_entry_group_update_service_txt_va(
623 AvahiEntryGroup *group,
624 AvahiIfIndex interface,
625 AvahiProtocol protocol,
626 AvahiPublishFlags flags,
633 AvahiStringList *txt;
635 txt = avahi_string_list_new_va(va);
636 r = avahi_entry_group_update_service_txt_strlst(group, interface, protocol, flags, name, type, domain, txt);
637 avahi_string_list_free(txt);
642 int avahi_entry_group_update_service_txt_strlst(
643 AvahiEntryGroup *group,
644 AvahiIfIndex interface,
645 AvahiProtocol protocol,
646 AvahiPublishFlags flags,
650 AvahiStringList *txt) {
652 DBusMessage *message = NULL, *reply = NULL;
656 int32_t i_interface, i_protocol;
663 client = group->client;
665 if (!group->path || group->client->state == AVAHI_CLIENT_DISCONNECTED)
666 return avahi_client_set_errno(group->client, AVAHI_ERR_BAD_STATE);
671 dbus_error_init(&error);
673 if (!(message = dbus_message_new_method_call (AVAHI_DBUS_NAME, group->path, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "UpdateServiceTxt"))) {
674 r = avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
678 i_interface = (int32_t) interface;
679 i_protocol = (int32_t) protocol;
680 u_flags = (uint32_t) flags;
682 if (!dbus_message_append_args(
684 DBUS_TYPE_INT32, &i_interface,
685 DBUS_TYPE_INT32, &i_protocol,
686 DBUS_TYPE_UINT32, &u_flags,
687 DBUS_TYPE_STRING, &name,
688 DBUS_TYPE_STRING, &type,
689 DBUS_TYPE_STRING, &domain,
690 DBUS_TYPE_INVALID) ||
691 append_string_list(message, txt) < 0) {
692 r = avahi_client_set_errno(group->client, AVAHI_ERR_NO_MEMORY);
696 if (!(reply = dbus_connection_send_with_reply_and_block(client->bus, message, -1, &error)) ||
697 dbus_error_is_set (&error)) {
698 r = avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR);
702 if (!dbus_message_get_args(reply, &error, DBUS_TYPE_INVALID) ||
703 dbus_error_is_set (&error)) {
704 r = avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR);
708 dbus_message_unref(message);
709 dbus_message_unref(reply);
715 if (dbus_error_is_set(&error)) {
716 r = avahi_client_set_dbus_error(client, &error);
717 dbus_error_free(&error);
721 dbus_message_unref(message);
724 dbus_message_unref(reply);