]> git.meshlink.io Git - catta/blob - avahi-client/entrygroup.c
Add init script support for fedora from Alexander Larsson
[catta] / avahi-client / entrygroup.c
1 /* $Id$ */
2
3 /***
4   This file is part of avahi.
5  
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.
10  
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.
15  
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
19   USA.
20 ***/
21
22 #ifdef HAVE_CONFIG_H
23 #include <config.h>
24 #endif
25
26 #include <stdlib.h>
27 #include <stdio.h>
28 #include <string.h>
29
30 #include <dbus/dbus.h>
31
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
38 #include "client.h"
39 #include "internal.h"
40
41 void avahi_entry_group_set_state(AvahiEntryGroup *group, AvahiEntryGroupState state) {
42     assert(group);
43
44     if (group->state == state)
45         return;
46
47     group->state = state;
48
49     if (group->callback)
50         group->callback(group, state, group->userdata);
51 }
52
53 static int retrieve_state(AvahiEntryGroup *group) {
54     DBusMessage *message, *reply;
55     DBusError error;
56     int r = AVAHI_OK;
57     int32_t state;
58     AvahiClient *client;
59     
60     dbus_error_init(&error);
61
62     assert(group);
63     client = group->client;
64     
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);
67         goto fail;
68     }
69         
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);
73         goto fail;
74     }
75     
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);
79         goto fail;
80     }
81
82     dbus_message_unref(message);
83     dbus_message_unref(reply);
84
85     avahi_entry_group_set_state(group, (AvahiEntryGroupState) state);
86     
87     return AVAHI_OK;
88     
89 fail:
90     if (dbus_error_is_set(&error)) {
91         r = avahi_client_set_dbus_error(client, &error);
92         dbus_error_free(&error);
93     }
94
95     if (message)
96         dbus_message_unref(message);
97
98     if (reply)
99         dbus_message_unref(reply);
100
101     return r;
102 }
103
104 AvahiEntryGroup* avahi_entry_group_new (AvahiClient *client, AvahiEntryGroupCallback callback, void *userdata) {
105     AvahiEntryGroup *group = NULL;
106     DBusMessage *message = NULL, *reply = NULL;
107     DBusError error;
108     char *path;
109
110     assert(client);
111
112     dbus_error_init (&error);
113
114     if (client->state == AVAHI_CLIENT_DISCONNECTED) {
115         avahi_client_set_errno(client, AVAHI_ERR_BAD_STATE);
116         goto fail;
117     }
118
119     if (!(group = avahi_new(AvahiEntryGroup, 1))) {
120         avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
121         goto fail;
122     }
123     
124     group->client = client;
125     group->callback = callback;
126     group->userdata = userdata;
127     group->state = AVAHI_ENTRY_GROUP_UNCOMMITED;
128     group->path = NULL;
129     AVAHI_LLIST_PREPEND(AvahiEntryGroup, groups, client->groups, group);
130     
131     if (!(message = dbus_message_new_method_call(
132               AVAHI_DBUS_NAME,
133               AVAHI_DBUS_PATH_SERVER,
134               AVAHI_DBUS_INTERFACE_SERVER,
135               "EntryGroupNew"))) {
136         avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
137         goto fail;
138     }
139
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);
143         goto fail;
144     }
145
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);
149         goto fail;
150     }
151     
152     if (!(group->path = avahi_strdup (path))) {
153
154         /* FIXME: We don't remove the object on the server side */
155
156         avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
157         goto fail;
158     }
159
160     if (retrieve_state(group) < 0)
161         goto fail;
162
163     dbus_message_unref(message);
164     dbus_message_unref(reply);
165
166     return group;
167
168 fail:
169     if (dbus_error_is_set(&error)) {
170         avahi_client_set_dbus_error(client, &error);
171         dbus_error_free(&error);
172     }
173
174     if (group)
175         avahi_entry_group_free(group);
176     
177     if (message)
178         dbus_message_unref(message);
179
180     if (reply)
181         dbus_message_unref(reply);
182     
183     return NULL;
184 }
185
186 static int entry_group_simple_method_call(AvahiEntryGroup *group, const char *method) {
187     DBusMessage *message = NULL, *reply = NULL;
188     DBusError error;
189     int r = AVAHI_OK;
190     AvahiClient *client;
191     
192     dbus_error_init(&error);
193
194     assert(group);
195     client = group->client;
196     
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);
199         goto fail;
200     }
201         
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);
205         goto fail;
206     }
207     
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);
211         goto fail;
212     }
213
214     dbus_message_unref(message);
215     dbus_message_unref(reply);
216
217     return AVAHI_OK;
218     
219 fail:
220     if (dbus_error_is_set(&error)) {
221         r = avahi_client_set_dbus_error(client, &error);
222         dbus_error_free(&error);
223     }
224
225     if (message)
226         dbus_message_unref(message);
227
228     if (reply)
229         dbus_message_unref(reply);
230
231     return r;
232 }
233
234 int avahi_entry_group_free(AvahiEntryGroup *group) {
235     AvahiClient *client = group->client;
236     int r = AVAHI_OK;
237         
238     assert(group);
239     
240     if (group->path && client->state != AVAHI_CLIENT_DISCONNECTED)
241         r = entry_group_simple_method_call(group, "Free");
242     
243     AVAHI_LLIST_REMOVE(AvahiEntryGroup, groups, client->groups, group);
244
245     avahi_free(group->path);
246     avahi_free(group);
247
248     return r;
249 }
250
251 int avahi_entry_group_commit(AvahiEntryGroup *group) {
252     assert(group);
253     
254     if (!group->path || group->client->state == AVAHI_CLIENT_DISCONNECTED)
255         return avahi_client_set_errno(group->client, AVAHI_ERR_BAD_STATE);
256
257     return entry_group_simple_method_call(group, "Commit");
258 }
259
260 int avahi_entry_group_reset(AvahiEntryGroup *group) {
261     assert(group);
262     
263     if (!group->path || group->client->state == AVAHI_CLIENT_DISCONNECTED)
264         return avahi_client_set_errno(group->client, AVAHI_ERR_BAD_STATE);
265
266     return entry_group_simple_method_call(group, "Reset");
267 }
268
269 int avahi_entry_group_get_state (AvahiEntryGroup *group) {
270     assert (group);
271
272     return group->state;
273 }
274
275 AvahiClient* avahi_entry_group_get_client (AvahiEntryGroup *group) {
276     assert(group);
277     
278     return group->client;
279 }
280
281 int avahi_entry_group_is_empty (AvahiEntryGroup *group) {
282     DBusMessage *message, *reply;
283     DBusError error;
284     int r = AVAHI_OK;
285     int b;
286     AvahiClient *client;
287     
288     assert(group);
289     client = group->client;
290
291     if (!group->path || group->client->state == AVAHI_CLIENT_DISCONNECTED)
292         return avahi_client_set_errno(group->client, AVAHI_ERR_BAD_STATE);
293
294     dbus_error_init(&error);
295     
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);
298         goto fail;
299     }
300         
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);
304         goto fail;
305     }
306     
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);
310         goto fail;
311     }
312
313     dbus_message_unref(message);
314     dbus_message_unref(reply);
315
316     return !!b;
317     
318 fail:
319     if (dbus_error_is_set(&error)) {
320         r = avahi_client_set_dbus_error(client, &error);
321         dbus_error_free(&error);
322     }
323
324     if (message)
325         dbus_message_unref(message);
326
327     if (reply)
328         dbus_message_unref(reply);
329
330     return r;
331 }
332
333 static int append_string_list(DBusMessage *message, AvahiStringList *txt) {
334     DBusMessageIter iter, sub;
335     int r = -1;
336     AvahiStringList *p;
337
338     assert(message);
339
340     dbus_message_iter_init_append(message, &iter);
341
342     /* Reverse the string list, so that we can pass it in-order to the server */
343     txt = avahi_string_list_reverse(txt);
344     
345     if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "ay", &sub))
346         goto fail;
347
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;
352         
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)))
356             goto fail;
357     }
358
359     if (!dbus_message_iter_close_container(&iter, &sub))
360         goto fail;
361
362     r = 0;
363
364 fail:
365
366     /* Reverse the string list to the original state */
367     txt = avahi_string_list_reverse(txt);
368
369     return r;
370 }
371
372 int avahi_entry_group_add_service_strlst(
373     AvahiEntryGroup *group,
374     AvahiIfIndex interface,
375     AvahiProtocol protocol,
376     AvahiPublishFlags flags,
377     const char *name,
378     const char *type,
379     const char *domain,
380     const char *host,
381     uint16_t port,
382     AvahiStringList *txt) {
383     
384     DBusMessage *message = NULL, *reply = NULL;
385     int r = AVAHI_OK;
386     DBusError error;
387     AvahiClient *client;
388     int32_t i_interface, i_protocol;
389     uint32_t u_flags;
390
391     assert(group);
392     assert(name);
393     assert(type);
394
395     client = group->client;
396
397     if (!group->path || group->client->state == AVAHI_CLIENT_DISCONNECTED)
398         return avahi_client_set_errno(group->client, AVAHI_ERR_BAD_STATE);
399
400     if (!domain)
401         domain = "";
402
403     if (!host)
404         host = "";
405     
406     dbus_error_init(&error);
407     
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);
410         goto fail;
411     }
412
413     i_interface = (int32_t) interface;
414     i_protocol = (int32_t) protocol;
415     u_flags = (uint32_t) flags;
416
417     if (!dbus_message_append_args(
418             message,
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);
430         goto fail;
431     }
432     
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);
436         goto fail;
437     }
438     
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);
442         goto fail;
443     }
444
445     dbus_message_unref(message);
446     dbus_message_unref(reply);
447
448     return AVAHI_OK;
449
450 fail:
451     
452     if (dbus_error_is_set(&error)) {
453         r = avahi_client_set_dbus_error(client, &error);
454         dbus_error_free(&error);
455     }
456
457     if (message)
458         dbus_message_unref(message);
459
460     if (reply)
461         dbus_message_unref(reply);
462
463     return r;
464 }
465
466 int avahi_entry_group_add_service(
467     AvahiEntryGroup *group,
468     AvahiIfIndex interface,
469     AvahiProtocol protocol,
470     AvahiPublishFlags flags,
471     const char *name,
472     const char *type,
473     const char *domain,
474     const char *host,
475     uint16_t port,
476     ...) {
477     
478     va_list va;
479     int r;
480     AvahiStringList *txt;
481
482     assert(group);
483
484     va_start(va, port);
485     txt = avahi_string_list_new_va(va);
486     r = avahi_entry_group_add_service_strlst(group, interface, protocol, flags, name, type, domain, host, port, txt);
487     avahi_string_list_free(txt);
488     va_end(va);
489     return r;
490 }
491
492 int avahi_entry_group_add_service_subtype(
493     AvahiEntryGroup *group,
494     AvahiIfIndex interface,
495     AvahiProtocol protocol,
496     AvahiPublishFlags flags,
497     const char *name,
498     const char *type,
499     const char *domain,
500     const char *subtype) {
501
502     DBusMessage *message = NULL, *reply = NULL;
503     int r = AVAHI_OK;
504     DBusError error;
505     AvahiClient *client;
506     int32_t i_interface, i_protocol;
507     uint32_t u_flags;
508
509     assert(group);
510     assert(name);
511     assert(type);
512     assert(subtype);
513
514     client = group->client;
515
516     if (!group->path || group->client->state == AVAHI_CLIENT_DISCONNECTED)
517         return avahi_client_set_errno(group->client, AVAHI_ERR_BAD_STATE);
518
519     if (!domain)
520         domain = "";
521
522     dbus_error_init(&error);
523     
524     if (!(message = dbus_message_new_method_call (AVAHI_DBUS_NAME, group->path, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "AddServiceSubtype"))) {
525         r = avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
526         goto fail;
527     }
528
529     i_interface = (int32_t) interface;
530     i_protocol = (int32_t) protocol;
531     u_flags = (uint32_t) flags;
532
533     if (!dbus_message_append_args(
534             message,
535             DBUS_TYPE_INT32, &i_interface,
536             DBUS_TYPE_INT32, &i_protocol,
537             DBUS_TYPE_UINT32, &u_flags,
538             DBUS_TYPE_STRING, &name,
539             DBUS_TYPE_STRING, &type,
540             DBUS_TYPE_STRING, &domain,
541             DBUS_TYPE_STRING, &subtype,
542             DBUS_TYPE_INVALID)) {
543         r = avahi_client_set_errno(group->client, AVAHI_ERR_NO_MEMORY);
544         goto fail;
545     }
546     
547     if (!(reply = dbus_connection_send_with_reply_and_block(client->bus, message, -1, &error)) ||
548         dbus_error_is_set (&error)) {
549         r = avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR);
550         goto fail;
551     }
552     
553     if (!dbus_message_get_args(reply, &error, DBUS_TYPE_INVALID) ||
554         dbus_error_is_set (&error)) {
555         r = avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR);
556         goto fail;
557     }
558
559     dbus_message_unref(message);
560     dbus_message_unref(reply);
561
562     return AVAHI_OK;
563
564 fail:
565     
566     if (dbus_error_is_set(&error)) {
567         r = avahi_client_set_dbus_error(client, &error);
568         dbus_error_free(&error);
569     }
570
571     if (message)
572         dbus_message_unref(message);
573
574     if (reply)
575         dbus_message_unref(reply);
576
577     return r;
578
579 }
580
581 int avahi_entry_group_update_service_txt(
582     AvahiEntryGroup *group,
583     AvahiIfIndex interface,
584     AvahiProtocol protocol,
585     AvahiPublishFlags flags,
586     const char *name,     
587     const char *type,     
588     const char *domain,   
589     ...) {
590
591     va_list va;
592     int r;
593     AvahiStringList *txt;
594
595     va_start(va, domain);
596     txt = avahi_string_list_new_va(va);
597     r = avahi_entry_group_update_service_txt_strlst(group, interface, protocol, flags, name, type, domain, txt);
598     avahi_string_list_free(txt);
599     va_end(va);
600     return r;
601 }
602
603 int avahi_entry_group_update_service_txt_strlst(
604     AvahiEntryGroup *group,
605     AvahiIfIndex interface,
606     AvahiProtocol protocol,
607     AvahiPublishFlags flags,
608     const char *name,     
609     const char *type,     
610     const char *domain,   
611     AvahiStringList *txt) {
612
613     DBusMessage *message = NULL, *reply = NULL;
614     int r = AVAHI_OK;
615     DBusError error;
616     AvahiClient *client;
617     int32_t i_interface, i_protocol;
618     uint32_t u_flags;
619
620     assert(group);
621     assert(name);
622     assert(type);
623
624     client = group->client;
625
626     if (!group->path || group->client->state == AVAHI_CLIENT_DISCONNECTED)
627         return avahi_client_set_errno(group->client, AVAHI_ERR_BAD_STATE);
628
629     if (!domain)
630         domain = "";
631     
632     dbus_error_init(&error);
633     
634     if (!(message = dbus_message_new_method_call (AVAHI_DBUS_NAME, group->path, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "UpdateServiceTxt"))) {
635         r = avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
636         goto fail;
637     }
638
639     i_interface = (int32_t) interface;
640     i_protocol = (int32_t) protocol;
641     u_flags = (uint32_t) flags;
642
643     if (!dbus_message_append_args(
644             message,
645             DBUS_TYPE_INT32, &i_interface,
646             DBUS_TYPE_INT32, &i_protocol,
647             DBUS_TYPE_UINT32, &u_flags,
648             DBUS_TYPE_STRING, &name,
649             DBUS_TYPE_STRING, &type,
650             DBUS_TYPE_STRING, &domain,
651             DBUS_TYPE_INVALID) ||
652         append_string_list(message, txt) < 0) {
653         r = avahi_client_set_errno(group->client, AVAHI_ERR_NO_MEMORY);
654         goto fail;
655     }
656
657     if (!(reply = dbus_connection_send_with_reply_and_block(client->bus, message, -1, &error)) ||
658         dbus_error_is_set (&error)) {
659         r = avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR);
660         goto fail;
661     }
662     
663     if (!dbus_message_get_args(reply, &error, DBUS_TYPE_INVALID) ||
664         dbus_error_is_set (&error)) {
665         r = avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR);
666         goto fail;
667     }
668
669     dbus_message_unref(message);
670     dbus_message_unref(reply);
671
672     return AVAHI_OK;
673
674 fail:
675     
676     if (dbus_error_is_set(&error)) {
677         r = avahi_client_set_dbus_error(client, &error);
678         dbus_error_free(&error);
679     }
680
681     if (message)
682         dbus_message_unref(message);
683
684     if (reply)
685         dbus_message_unref(reply);
686
687     return r;
688     
689     
690 }
691
692 /** Add a host/address pair */
693 int avahi_entry_group_add_address(
694     AvahiEntryGroup *group,
695     AvahiIfIndex interface,
696     AvahiProtocol protocol,
697     AvahiPublishFlags flags,
698     const char *name,
699     const AvahiAddress *a) {
700
701     DBusMessage *message = NULL, *reply = NULL;
702     int r = AVAHI_OK;
703     DBusError error;
704     AvahiClient *client;
705     int32_t i_interface, i_protocol;
706     uint32_t u_flags;
707     char s_address[AVAHI_ADDRESS_STR_MAX];
708     char *p_address = s_address;
709
710     assert(name);
711
712     client = group->client;
713
714     if (!group->path || group->client->state == AVAHI_CLIENT_DISCONNECTED)
715         return avahi_client_set_errno(group->client, AVAHI_ERR_BAD_STATE);
716
717     dbus_error_init(&error);
718     
719     if (!(message = dbus_message_new_method_call (AVAHI_DBUS_NAME, group->path, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "AddAddress"))) {
720         r = avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
721         goto fail;
722     }
723
724     i_interface = (int32_t) interface;
725     i_protocol = (int32_t) protocol;
726     u_flags = (uint32_t) flags;
727         
728     if (!avahi_address_snprint (s_address, sizeof (s_address), a))
729     {
730         r = avahi_client_set_errno(client, AVAHI_ERR_INVALID_ADDRESS);
731         goto fail;
732     }
733
734     if (!dbus_message_append_args(
735             message,
736             DBUS_TYPE_INT32, &i_interface,
737             DBUS_TYPE_INT32, &i_protocol,
738             DBUS_TYPE_UINT32, &u_flags,
739             DBUS_TYPE_STRING, &name,
740             DBUS_TYPE_STRING, &p_address,
741             DBUS_TYPE_INVALID)) {
742         r = avahi_client_set_errno(group->client, AVAHI_ERR_NO_MEMORY);
743         goto fail;
744     }
745     
746     if (!(reply = dbus_connection_send_with_reply_and_block(client->bus, message, -1, &error)) ||
747         dbus_error_is_set (&error)) {
748         r = avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR);
749         goto fail;
750     }
751     
752     if (!dbus_message_get_args(reply, &error, DBUS_TYPE_INVALID) ||
753         dbus_error_is_set (&error)) {
754         r = avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR);
755         goto fail;
756     }
757
758     dbus_message_unref(message);
759     dbus_message_unref(reply);
760
761     return AVAHI_OK;
762
763 fail:
764     
765     if (dbus_error_is_set(&error)) {
766         r = avahi_client_set_dbus_error(client, &error);
767         dbus_error_free(&error);
768     }
769
770     if (message)
771         dbus_message_unref(message);
772
773     if (reply)
774         dbus_message_unref(reply);
775
776     return r;
777 }