]> git.meshlink.io Git - catta/blob - avahi-client/resolver.c
CVE-2009-0758: Reflector creates packet storm on legacy unicast traffic
[catta] / avahi-client / resolver.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 /* AvahiServiceResolver implementation */
42
43 DBusHandlerResult avahi_service_resolver_event (AvahiClient *client, AvahiResolverEvent event, DBusMessage *message) {
44     AvahiServiceResolver *r = NULL;
45     DBusError error;
46     const char *path;
47     AvahiStringList *strlst = NULL;
48
49     assert(client);
50     assert(message);
51     
52     dbus_error_init (&error);
53
54     if (!(path = dbus_message_get_path(message)))
55         goto fail;
56
57     for (r = client->service_resolvers; r; r = r->service_resolvers_next)
58         if (strcmp (r->path, path) == 0)
59             break;
60
61     if (!r)
62         goto fail;
63
64     switch (event) {
65         case AVAHI_RESOLVER_FOUND: {
66             int j;
67             int32_t interface, protocol, aprotocol;
68             uint32_t flags;
69             char *name, *type, *domain, *host, *address;
70             uint16_t port;
71             DBusMessageIter iter, sub;
72             AvahiAddress a;
73             
74             if (!dbus_message_get_args(
75                     message, &error,
76                     DBUS_TYPE_INT32, &interface,
77                     DBUS_TYPE_INT32, &protocol,
78                     DBUS_TYPE_STRING, &name,
79                     DBUS_TYPE_STRING, &type,
80                     DBUS_TYPE_STRING, &domain,
81                     DBUS_TYPE_STRING, &host,
82                     DBUS_TYPE_INT32, &aprotocol,
83                     DBUS_TYPE_STRING, &address,
84                     DBUS_TYPE_UINT16, &port,
85                     DBUS_TYPE_INVALID) ||
86                 dbus_error_is_set (&error)) {
87             
88                 fprintf(stderr, "Failed to parse resolver event.\n");
89                 goto fail;
90             }
91         
92             dbus_message_iter_init(message, &iter);
93         
94             for (j = 0; j < 9; j++)
95                 dbus_message_iter_next(&iter);
96         
97             if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
98                 dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_ARRAY) {
99                 fprintf(stderr, "Error parsing service resolving message\n");
100                 goto fail;
101             }
102         
103             strlst = NULL;
104             dbus_message_iter_recurse(&iter, &sub);
105         
106             for (;;) {
107                 DBusMessageIter sub2;
108                 int at;
109                 const uint8_t *k;
110                 int n;
111             
112                 if ((at = dbus_message_iter_get_arg_type(&sub)) == DBUS_TYPE_INVALID)
113                     break;
114             
115                 assert(at == DBUS_TYPE_ARRAY);
116             
117                 if (dbus_message_iter_get_element_type(&sub) != DBUS_TYPE_BYTE) {
118                     fprintf(stderr, "Error parsing service resolving message\n");
119                     goto fail;
120                 }
121             
122                 dbus_message_iter_recurse(&sub, &sub2);
123
124                 k = NULL; n = 0;
125                 dbus_message_iter_get_fixed_array(&sub2, &k, &n);
126                 if (k && n > 0)
127                     strlst = avahi_string_list_add_arbitrary(strlst, k, n);
128             
129                 dbus_message_iter_next(&sub);
130             }
131
132             dbus_message_iter_next(&iter);
133
134             if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_UINT32) {
135                 fprintf(stderr, "Failed to parse resolver event.\n");
136                 goto fail;
137             }
138
139             dbus_message_iter_get_basic(&iter, &flags);
140                                     
141             assert(address);
142
143             if (address[0] == 0)
144                 address = NULL;
145             else
146                 avahi_address_parse(address, (AvahiProtocol) aprotocol, &a);
147     
148             r->callback(r, (AvahiIfIndex) interface, (AvahiProtocol) protocol, AVAHI_RESOLVER_FOUND, name, type, domain, host, address ? &a : NULL, port, strlst, (AvahiLookupResultFlags) flags, r->userdata);
149         
150             avahi_string_list_free(strlst);
151             break;
152         }
153             
154         case AVAHI_RESOLVER_FAILURE: {
155             char *etxt;
156             
157             if (!dbus_message_get_args(
158                     message, &error,
159                     DBUS_TYPE_STRING, &etxt,
160                     DBUS_TYPE_INVALID) ||
161                 dbus_error_is_set (&error)) {
162                 fprintf(stderr, "Failed to parse resolver event.\n");
163                 goto fail;
164             }
165             
166             avahi_client_set_errno(r->client, avahi_error_dbus_to_number(etxt));
167             r->callback(r, r->interface, r->protocol, event, r->name, r->type, r->domain, NULL, NULL, 0, NULL, 0, r->userdata);
168             break;
169         }
170     }
171
172     return DBUS_HANDLER_RESULT_HANDLED;
173
174     
175 fail:
176     dbus_error_free (&error);
177     avahi_string_list_free(strlst);
178     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
179 }
180
181 AvahiServiceResolver * avahi_service_resolver_new(
182     AvahiClient *client,
183     AvahiIfIndex interface,
184     AvahiProtocol protocol,
185     const char *name,
186     const char *type,
187     const char *domain,
188     AvahiProtocol aprotocol,
189     AvahiLookupFlags flags,
190     AvahiServiceResolverCallback callback,
191     void *userdata) {
192
193     DBusError error;
194     AvahiServiceResolver *r = NULL;
195     DBusMessage *message = NULL, *reply = NULL;
196     int32_t i_interface, i_protocol, i_aprotocol;
197     uint32_t u_flags;
198     char *path;
199     
200     assert(client);
201     assert(type);
202
203     if (!domain)
204         domain = "";
205
206     if (!name)
207         name = "";
208     
209     dbus_error_init (&error);
210
211     if (!avahi_client_is_connected(client)) {
212         avahi_client_set_errno(client, AVAHI_ERR_BAD_STATE);
213         goto fail;
214     }
215
216     if (!(r = avahi_new(AvahiServiceResolver, 1))) {
217         avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
218         goto fail;
219     }
220
221     r->client = client;
222     r->callback = callback;
223     r->userdata = userdata;
224     r->path = NULL;
225     r->name = r->type = r->domain = NULL;
226     r->interface = interface;
227     r->protocol = protocol;
228     
229     AVAHI_LLIST_PREPEND(AvahiServiceResolver, service_resolvers, client->service_resolvers, r);
230
231     if (name && name[0])
232         if (!(r->name = avahi_strdup(name))) {
233             avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
234             goto fail;
235         }
236
237     if (!(r->type = avahi_strdup(type))) {
238         avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
239         goto fail;
240     }
241
242     if (domain && domain[0])
243         if (!(r->domain = avahi_strdup(domain))) {
244             avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
245             goto fail;
246         }
247     
248     
249     if (!(message = dbus_message_new_method_call(AVAHI_DBUS_NAME, AVAHI_DBUS_PATH_SERVER, AVAHI_DBUS_INTERFACE_SERVER, "ServiceResolverNew"))) {
250         avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
251         goto fail;
252     }
253
254     i_interface = (int32_t) interface;
255     i_protocol = (int32_t) protocol;
256     i_aprotocol = (int32_t) aprotocol;
257     u_flags = (uint32_t) flags;
258
259     if (!(dbus_message_append_args(
260               message,
261               DBUS_TYPE_INT32, &i_interface,
262               DBUS_TYPE_INT32, &i_protocol,
263               DBUS_TYPE_STRING, &name,
264               DBUS_TYPE_STRING, &type,
265               DBUS_TYPE_STRING, &domain,
266               DBUS_TYPE_INT32, &i_aprotocol,
267               DBUS_TYPE_UINT32, &u_flags,
268               DBUS_TYPE_INVALID))) {
269         avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
270         goto fail;
271     }
272
273     if (!(reply = dbus_connection_send_with_reply_and_block(client->bus, message, -1, &error)) ||
274         dbus_error_is_set(&error)) {
275         avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR);
276         goto fail;
277     }
278
279     if (!dbus_message_get_args (reply, &error, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID) ||
280         dbus_error_is_set(&error) ||
281         !path) {
282         avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR);
283         goto fail;
284     }
285
286     if (!(r->path = avahi_strdup(path))) {
287
288         /* FIXME: We don't remove the object on the server side */
289
290         avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
291         goto fail;
292     }
293         
294
295     dbus_message_unref(message);
296     dbus_message_unref(reply);
297
298     return r;
299     
300 fail:
301
302     if (dbus_error_is_set(&error)) {
303         avahi_client_set_dbus_error(client, &error);
304         dbus_error_free(&error);
305     }
306
307     if (r)
308         avahi_service_resolver_free(r);
309     
310     if (message)
311         dbus_message_unref(message);
312
313     if (reply)
314         dbus_message_unref(reply);
315     
316     return NULL;
317
318 }
319
320 AvahiClient* avahi_service_resolver_get_client (AvahiServiceResolver *r) {
321     assert (r);
322
323     return r->client;
324 }
325
326 int avahi_service_resolver_free(AvahiServiceResolver *r) {
327     AvahiClient *client;
328     int ret = AVAHI_OK;
329
330     assert(r);
331     client = r->client;
332
333     if (r->path && avahi_client_is_connected(client))
334         ret = avahi_client_simple_method_call(client, r->path, AVAHI_DBUS_INTERFACE_SERVICE_RESOLVER, "Free");
335
336     AVAHI_LLIST_REMOVE(AvahiServiceResolver, service_resolvers, client->service_resolvers, r);
337
338     avahi_free(r->path);
339     avahi_free(r->name);
340     avahi_free(r->type);
341     avahi_free(r->domain);
342     avahi_free(r);
343
344     return ret;
345 }
346
347 /* AvahiHostNameResolver implementation */
348
349 DBusHandlerResult avahi_host_name_resolver_event (AvahiClient *client, AvahiResolverEvent event, DBusMessage *message) {
350     AvahiHostNameResolver *r = NULL;
351     DBusError error;
352     const char *path;
353
354     assert(client);
355     assert(message);
356     
357     dbus_error_init (&error);
358
359     if (!(path = dbus_message_get_path(message)))
360         goto fail;
361
362     for (r = client->host_name_resolvers; r; r = r->host_name_resolvers_next)
363         if (strcmp (r->path, path) == 0)
364             break;
365
366     if (!r)
367         goto fail;
368
369     switch (event) {
370         case AVAHI_RESOLVER_FOUND: {
371             int32_t interface, protocol, aprotocol;
372             uint32_t flags;
373             char *name, *address;
374             AvahiAddress a;
375             
376             if (!dbus_message_get_args(
377                     message, &error,
378                     DBUS_TYPE_INT32, &interface,
379                     DBUS_TYPE_INT32, &protocol,
380                     DBUS_TYPE_STRING, &name,
381                     DBUS_TYPE_INT32, &aprotocol,
382                     DBUS_TYPE_STRING, &address,
383                     DBUS_TYPE_UINT32, &flags,
384                     DBUS_TYPE_INVALID) ||
385                 dbus_error_is_set (&error)) {
386                 fprintf(stderr, "Failed to parse resolver event.\n");
387                 goto fail;
388             }
389             
390             assert(address);
391             if (!avahi_address_parse(address, (AvahiProtocol) aprotocol, &a)) {
392                 fprintf(stderr, "Failed to parse address\n");
393                 goto fail;
394             }
395             
396             r->callback(r, (AvahiIfIndex) interface, (AvahiProtocol) protocol, AVAHI_RESOLVER_FOUND, name, &a, (AvahiLookupResultFlags) flags, r->userdata);
397             break;
398         }
399             
400         case AVAHI_RESOLVER_FAILURE: {
401             char *etxt;
402             
403             if (!dbus_message_get_args(
404                     message, &error,
405                     DBUS_TYPE_STRING, &etxt,
406                     DBUS_TYPE_INVALID) ||
407                 dbus_error_is_set (&error)) {
408                 fprintf(stderr, "Failed to parse resolver event.\n");
409                 goto fail;
410             }
411             
412             avahi_client_set_errno(r->client, avahi_error_dbus_to_number(etxt));
413             r->callback(r, r->interface, r->protocol, event, r->host_name, NULL, 0, r->userdata);
414             break;
415         }
416     }
417
418     return DBUS_HANDLER_RESULT_HANDLED;
419     
420 fail:
421     dbus_error_free (&error);
422     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
423 }
424
425
426 AvahiHostNameResolver * avahi_host_name_resolver_new(
427     AvahiClient *client,
428     AvahiIfIndex interface,
429     AvahiProtocol protocol,
430     const char *name,
431     AvahiProtocol aprotocol,
432     AvahiLookupFlags flags,
433     AvahiHostNameResolverCallback callback,
434     void *userdata) {
435
436     DBusError error;
437     AvahiHostNameResolver *r = NULL;
438     DBusMessage *message = NULL, *reply = NULL;
439     int32_t i_interface, i_protocol, i_aprotocol;
440     uint32_t u_flags;
441     char *path;
442     
443     assert(client);
444     assert(name);
445
446     dbus_error_init (&error);
447
448     if (!avahi_client_is_connected(client)) {
449         avahi_client_set_errno(client, AVAHI_ERR_BAD_STATE);
450         goto fail;
451     }
452
453     if (!(r = avahi_new(AvahiHostNameResolver, 1))) {
454         avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
455         goto fail;
456     }
457
458     r->client = client;
459     r->callback = callback;
460     r->userdata = userdata;
461     r->path = NULL;
462     r->interface = interface;
463     r->protocol = protocol;
464     r->host_name = NULL;
465     
466     AVAHI_LLIST_PREPEND(AvahiHostNameResolver, host_name_resolvers, client->host_name_resolvers, r);
467
468     if (!(r->host_name = avahi_strdup(name))) {
469         avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
470         goto fail;
471     }
472
473     if (!(message = dbus_message_new_method_call(AVAHI_DBUS_NAME, AVAHI_DBUS_PATH_SERVER, AVAHI_DBUS_INTERFACE_SERVER, "HostNameResolverNew"))) {
474         avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
475         goto fail;
476     }
477
478     i_interface = (int32_t) interface;
479     i_protocol = (int32_t) protocol;
480     i_aprotocol = (int32_t) aprotocol;
481     u_flags = (uint32_t) flags;
482
483     if (!(dbus_message_append_args(
484               message,
485               DBUS_TYPE_INT32, &i_interface,
486               DBUS_TYPE_INT32, &i_protocol,
487               DBUS_TYPE_STRING, &name,
488               DBUS_TYPE_INT32, &i_aprotocol,
489               DBUS_TYPE_UINT32, &u_flags,
490               DBUS_TYPE_INVALID))) {
491         avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
492         goto fail;
493     }
494
495     if (!(reply = dbus_connection_send_with_reply_and_block(client->bus, message, -1, &error)) ||
496         dbus_error_is_set(&error)) {
497         avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR);
498         goto fail;
499     }
500
501     if (!dbus_message_get_args (reply, &error, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID) ||
502         dbus_error_is_set(&error) ||
503         !path) {
504         avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR);
505         goto fail;
506     }
507
508     if (!(r->path = avahi_strdup(path))) {
509
510         /* FIXME: We don't remove the object on the server side */
511
512         avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
513         goto fail;
514     }
515
516     dbus_message_unref(message);
517     dbus_message_unref(reply);
518
519     return r;
520     
521 fail:
522
523     if (dbus_error_is_set(&error)) {
524         avahi_client_set_dbus_error(client, &error);
525         dbus_error_free(&error);
526     }
527
528     if (r)
529         avahi_host_name_resolver_free(r);
530     
531     if (message)
532         dbus_message_unref(message);
533
534     if (reply)
535         dbus_message_unref(reply);
536
537     return NULL;
538
539 }
540
541 int avahi_host_name_resolver_free(AvahiHostNameResolver *r) {
542     int ret = AVAHI_OK;
543     AvahiClient *client;
544
545     assert(r);
546     client = r->client;
547
548     if (r->path && avahi_client_is_connected(client))
549         ret = avahi_client_simple_method_call(client, r->path, AVAHI_DBUS_INTERFACE_HOST_NAME_RESOLVER, "Free");
550
551     AVAHI_LLIST_REMOVE(AvahiHostNameResolver, host_name_resolvers, client->host_name_resolvers, r);
552
553     avahi_free(r->path);
554     avahi_free(r->host_name);
555     avahi_free(r);
556
557     return ret;
558 }
559
560 AvahiClient* avahi_host_name_resolver_get_client (AvahiHostNameResolver *r) {
561     assert (r);
562
563     return r->client;
564 }
565
566 /* AvahiAddressResolver implementation */
567
568 DBusHandlerResult avahi_address_resolver_event (AvahiClient *client, AvahiResolverEvent event, DBusMessage *message) {
569     AvahiAddressResolver *r = NULL;
570     DBusError error;
571     const char *path;
572
573     assert(client);
574     assert(message);
575     
576     dbus_error_init (&error);
577
578     if (!(path = dbus_message_get_path(message)))
579         goto fail;
580
581     for (r = client->address_resolvers; r; r = r->address_resolvers_next)
582         if (strcmp (r->path, path) == 0)
583             break;
584
585     if (!r)
586         goto fail;
587
588     switch (event) {
589         case AVAHI_RESOLVER_FOUND: {
590             int32_t interface, protocol, aprotocol;
591             uint32_t flags;
592             char *name, *address;
593             AvahiAddress a;
594             
595             if (!dbus_message_get_args(
596                     message, &error,
597                     DBUS_TYPE_INT32, &interface,
598                     DBUS_TYPE_INT32, &protocol,
599                     DBUS_TYPE_INT32, &aprotocol,
600                     DBUS_TYPE_STRING, &address,
601                     DBUS_TYPE_STRING, &name,
602                     DBUS_TYPE_UINT32, &flags,
603                     DBUS_TYPE_INVALID) ||
604                 dbus_error_is_set (&error)) {
605                 fprintf(stderr, "Failed to parse resolver event.\n");
606                 goto fail;
607             }
608             
609             assert(address);
610             if (!avahi_address_parse(address, (AvahiProtocol) aprotocol, &a)) {
611                 fprintf(stderr, "Failed to parse address\n");
612                 goto fail;
613             }
614             
615             r->callback(r, (AvahiIfIndex) interface, (AvahiProtocol) protocol, AVAHI_RESOLVER_FOUND, &a, name, (AvahiLookupResultFlags) flags, r->userdata);
616             break;
617         }
618
619         case AVAHI_RESOLVER_FAILURE: {
620             char *etxt;
621             
622             if (!dbus_message_get_args(
623                     message, &error,
624                     DBUS_TYPE_STRING, &etxt,
625                     DBUS_TYPE_INVALID) ||
626                 dbus_error_is_set (&error)) {
627                 fprintf(stderr, "Failed to parse resolver event.\n");
628                 goto fail;
629             }
630             
631             avahi_client_set_errno(r->client, avahi_error_dbus_to_number(etxt));
632             r->callback(r, r->interface, r->protocol, event, &r->address, NULL, 0, r->userdata);
633             break;
634         }
635     }
636
637     return DBUS_HANDLER_RESULT_HANDLED;
638     
639 fail:
640     dbus_error_free (&error);
641     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
642 }
643
644 AvahiAddressResolver * avahi_address_resolver_new(
645     AvahiClient *client,
646     AvahiIfIndex interface,
647     AvahiProtocol protocol,
648     const AvahiAddress *a,
649     AvahiLookupFlags flags, 
650     AvahiAddressResolverCallback callback,
651     void *userdata) {
652
653     DBusError error;
654     AvahiAddressResolver *r = NULL;
655     DBusMessage *message = NULL, *reply = NULL;
656     int32_t i_interface, i_protocol;
657     uint32_t u_flags;
658     char *path;
659     char addr[AVAHI_ADDRESS_STR_MAX], *address = addr;
660
661     assert(client);
662     assert(a);
663
664     dbus_error_init (&error);
665
666     if (!avahi_address_snprint (addr, sizeof(addr), a)) {
667         avahi_client_set_errno(client, AVAHI_ERR_INVALID_ADDRESS);
668         return NULL;
669     }
670
671     if (!avahi_client_is_connected(client)) {
672         avahi_client_set_errno(client, AVAHI_ERR_BAD_STATE);
673         goto fail;
674     }
675
676     if (!(r = avahi_new(AvahiAddressResolver, 1))) {
677         avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
678         goto fail;
679     }
680
681     r->client = client;
682     r->callback = callback;
683     r->userdata = userdata;
684     r->path = NULL;
685     r->interface = interface;
686     r->protocol = protocol;
687     r->address = *a;
688     
689     AVAHI_LLIST_PREPEND(AvahiAddressResolver, address_resolvers, client->address_resolvers, r);
690
691     if (!(message = dbus_message_new_method_call(AVAHI_DBUS_NAME, AVAHI_DBUS_PATH_SERVER, AVAHI_DBUS_INTERFACE_SERVER, "AddressResolverNew"))) {
692         avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
693         goto fail;
694     }
695
696     i_interface = (int32_t) interface;
697     i_protocol = (int32_t) protocol;
698     u_flags = (uint32_t) flags;
699
700     if (!(dbus_message_append_args(
701               message,
702               DBUS_TYPE_INT32, &i_interface,
703               DBUS_TYPE_INT32, &i_protocol,
704               DBUS_TYPE_STRING, &address,
705               DBUS_TYPE_UINT32, &u_flags,
706               DBUS_TYPE_INVALID))) {
707         avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
708         goto fail;
709     }
710
711     if (!(reply = dbus_connection_send_with_reply_and_block(client->bus, message, -1, &error)) ||
712         dbus_error_is_set(&error)) {
713         avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR);
714         goto fail;
715     }
716
717     if (!dbus_message_get_args (reply, &error, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID) ||
718         dbus_error_is_set(&error) ||
719         !path) {
720         avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR);
721         goto fail;
722     }
723     
724     if (!(r->path = avahi_strdup(path))) {
725
726         /* FIXME: We don't remove the object on the server side */
727
728         avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
729         goto fail;
730     }
731
732     dbus_message_unref(message);
733     dbus_message_unref(reply);
734
735     return r;
736     
737 fail:
738
739     if (dbus_error_is_set(&error)) {
740         avahi_client_set_dbus_error(client, &error);
741         dbus_error_free(&error);
742     }
743
744     if (r)
745         avahi_address_resolver_free(r);
746     
747     if (message)
748         dbus_message_unref(message);
749
750     if (reply)
751         dbus_message_unref(reply);
752
753     return NULL;
754
755 }
756
757 AvahiClient* avahi_address_resolver_get_client (AvahiAddressResolver *r) {
758     assert (r);
759
760     return r->client;
761 }
762
763 int avahi_address_resolver_free(AvahiAddressResolver *r) {
764     AvahiClient *client;
765     int ret = AVAHI_OK;
766
767     assert(r);
768     client = r->client;
769
770     if (r->path && avahi_client_is_connected(client))
771         ret = avahi_client_simple_method_call(client, r->path, AVAHI_DBUS_INTERFACE_ADDRESS_RESOLVER, "Free");
772
773     AVAHI_LLIST_REMOVE(AvahiAddressResolver, address_resolvers, client->address_resolvers, r);
774
775     avahi_free(r->path);
776     avahi_free(r);
777
778     return ret;
779 }
780