]> git.meshlink.io Git - catta/blob - avahi-client/browser.c
Add init script support for fedora from Alexander Larsson
[catta] / avahi-client / browser.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 AvahiDomainBrowser* avahi_domain_browser_new(
42     AvahiClient *client,
43     AvahiIfIndex interface,
44     AvahiProtocol protocol,
45     const char *domain,
46     AvahiDomainBrowserType btype,
47     AvahiLookupFlags flags,
48     AvahiDomainBrowserCallback callback,
49     void *userdata) {
50     
51     AvahiDomainBrowser *db = NULL;
52     DBusMessage *message = NULL, *reply = NULL;
53     DBusError error;
54     char *path;
55     int32_t i_interface, i_protocol, bt;
56     uint32_t u_flags;
57
58     assert(client);
59     assert(callback);
60
61     dbus_error_init (&error);
62
63     if (client->state == AVAHI_CLIENT_DISCONNECTED) {
64         avahi_client_set_errno(client, AVAHI_ERR_BAD_STATE);
65         goto fail;
66     }
67
68     if (!domain)
69         domain = "";
70
71     if (!(db = avahi_new (AvahiDomainBrowser, 1))) {
72         avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
73         goto fail;
74     }
75
76     db->client = client;
77     db->callback = callback;
78     db->userdata = userdata;
79     db->path = NULL;
80     db->interface = interface;
81     db->protocol = protocol;
82
83     AVAHI_LLIST_PREPEND(AvahiDomainBrowser, domain_browsers, client->domain_browsers, db);
84
85     if (!(message = dbus_message_new_method_call (AVAHI_DBUS_NAME, AVAHI_DBUS_PATH_SERVER, AVAHI_DBUS_INTERFACE_SERVER, "DomainBrowserNew"))) {
86         avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
87         goto fail;
88     }
89
90     i_interface = (int32_t) interface;
91     i_protocol = (int32_t) protocol;
92     u_flags = (uint32_t) flags;
93     bt = btype;
94
95     if (!(dbus_message_append_args(
96               message,
97               DBUS_TYPE_INT32, &i_interface,
98               DBUS_TYPE_INT32, &i_protocol,
99               DBUS_TYPE_STRING, &domain,
100               DBUS_TYPE_INT32, &bt,
101               DBUS_TYPE_UINT32, &flags,
102               DBUS_TYPE_INVALID))) {
103         avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
104         goto fail;
105     }
106
107     if (!(reply = dbus_connection_send_with_reply_and_block (client->bus, message, -1, &error)) ||
108         dbus_error_is_set(&error)) {
109         avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR);
110         goto fail;
111     }
112
113     if (!dbus_message_get_args (reply, &error, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID) ||
114         dbus_error_is_set(&error) ||
115         !path) {
116         avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR);
117         goto fail;
118     }
119
120     if (!(db->path = avahi_strdup(path))) {
121
122         /* FIXME: We don't remove the object on the server side */
123
124         avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
125         goto fail;
126     }
127
128     dbus_message_unref(message);
129     dbus_message_unref(reply);
130     
131     return db;
132
133 fail:
134
135     if (dbus_error_is_set(&error)) {
136         avahi_client_set_dbus_error(client, &error);
137         dbus_error_free(&error);
138     }
139
140     if (db)
141         avahi_domain_browser_free(db);
142     
143     if (message)
144         dbus_message_unref(message);
145
146     if (reply)
147         dbus_message_unref(reply);
148
149     return NULL;
150 }
151
152 AvahiClient* avahi_domain_browser_get_client (AvahiDomainBrowser *b) {
153     assert(b);
154     return b->client;
155 }
156
157 int avahi_domain_browser_free (AvahiDomainBrowser *b) {
158     AvahiClient *client;
159     int r = AVAHI_OK;
160
161     assert(b);
162     client = b->client;
163
164     if (b->path && client->state != AVAHI_CLIENT_DISCONNECTED)
165         r = avahi_client_simple_method_call(client, b->path, AVAHI_DBUS_INTERFACE_DOMAIN_BROWSER, "Free");
166
167     AVAHI_LLIST_REMOVE(AvahiDomainBrowser, domain_browsers, client->domain_browsers, b);
168
169     avahi_free(b->path);
170     avahi_free(b);
171
172     return r;
173 }
174
175 DBusHandlerResult avahi_domain_browser_event (AvahiClient *client, AvahiBrowserEvent event, DBusMessage *message) {
176     AvahiDomainBrowser *db = NULL;
177     DBusError error;
178     const char *path;
179     char *domain = NULL;
180     int32_t interface, protocol;
181     uint32_t flags = 0;
182
183     assert(client);
184     assert(message);
185     
186     dbus_error_init (&error);
187
188     if (!(path = dbus_message_get_path(message)))
189         goto fail;
190
191     for (db = client->domain_browsers; db; db = db->domain_browsers_next)
192         if (strcmp (db->path, path) == 0)
193             break;
194
195     if (!db)
196         goto fail;
197
198     interface = db->interface;
199     protocol = db->protocol;
200
201     switch (event) {
202         case AVAHI_BROWSER_NEW:
203         case AVAHI_BROWSER_REMOVE:
204             
205             if (!dbus_message_get_args(
206                     message, &error,
207                     DBUS_TYPE_INT32, &interface,
208                     DBUS_TYPE_INT32, &protocol,
209                     DBUS_TYPE_STRING, &domain,
210                     DBUS_TYPE_UINT32, &flags,
211                     DBUS_TYPE_INVALID) ||
212                 dbus_error_is_set (&error)) {
213                 fprintf(stderr, "Failed to parse browser event.\n");
214                 goto fail;
215             }
216
217             break;
218             
219         case AVAHI_BROWSER_CACHE_EXHAUSTED:
220         case AVAHI_BROWSER_ALL_FOR_NOW:
221             break;
222
223         case AVAHI_BROWSER_FAILURE: {
224             char *etxt;
225             
226             if (!dbus_message_get_args(
227                     message, &error,
228                     DBUS_TYPE_STRING, &etxt,
229                     DBUS_TYPE_INVALID) ||
230                 dbus_error_is_set (&error)) {
231                 fprintf(stderr, "Failed to parse browser event.\n");
232                 goto fail;
233             }
234             
235             avahi_client_set_errno(db->client, avahi_error_dbus_to_number(etxt));
236             break;
237         }
238     }
239
240     db->callback(db, (AvahiIfIndex) interface, (AvahiProtocol) protocol, event, domain, (AvahiLookupResultFlags) flags, db->userdata);
241
242     return DBUS_HANDLER_RESULT_HANDLED;
243
244 fail:
245     dbus_error_free (&error);
246     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
247 }
248
249 /* AvahiServiceTypeBrowser */
250 AvahiServiceTypeBrowser* avahi_service_type_browser_new(
251     AvahiClient *client,
252     AvahiIfIndex interface,
253     AvahiProtocol protocol,
254     const char *domain,
255     AvahiLookupFlags flags, 
256     AvahiServiceTypeBrowserCallback callback,
257     void *userdata) {
258         
259     AvahiServiceTypeBrowser *b = NULL;
260     DBusMessage *message = NULL, *reply = NULL;
261     DBusError error;
262     char *path;
263     int32_t i_interface, i_protocol;
264     uint32_t u_flags;
265
266     assert(client);
267     assert(callback);
268
269     dbus_error_init(&error);
270
271     if (client->state == AVAHI_CLIENT_DISCONNECTED) {
272         avahi_client_set_errno(client, AVAHI_ERR_BAD_STATE);
273         goto fail;
274     }
275
276     if (!domain)
277         domain = "";
278
279     if (!(b = avahi_new(AvahiServiceTypeBrowser, 1))) {
280         avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
281         goto fail;
282     }
283
284     b->client = client;
285     b->callback = callback;
286     b->userdata = userdata;
287     b->path = NULL;
288     b->domain = NULL;
289     b->interface = interface;
290     b->protocol = protocol;
291
292     AVAHI_LLIST_PREPEND(AvahiServiceTypeBrowser, service_type_browsers, client->service_type_browsers, b);
293
294     if (domain[0])
295         if (!(b->domain = avahi_strdup(domain))) {
296             avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
297             goto fail;
298         }
299           
300     if (!(message = dbus_message_new_method_call (AVAHI_DBUS_NAME, AVAHI_DBUS_PATH_SERVER, AVAHI_DBUS_INTERFACE_SERVER, "ServiceTypeBrowserNew"))) {
301         avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
302         goto fail;
303     }
304     
305     i_interface = (int32_t) interface;
306     i_protocol = (int32_t) protocol;
307     u_flags = (uint32_t) flags;
308
309     if (!dbus_message_append_args(
310             message,
311             DBUS_TYPE_INT32, &i_interface,
312             DBUS_TYPE_INT32, &i_protocol,
313             DBUS_TYPE_STRING, &domain,
314             DBUS_TYPE_UINT32, &u_flags,
315             DBUS_TYPE_INVALID)) {
316         avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
317         goto fail;
318     }
319
320     if (!(reply = dbus_connection_send_with_reply_and_block (client->bus, message, -1, &error)) ||
321         dbus_error_is_set(&error)) {
322         avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR);
323         goto fail;
324     }
325
326     if (!dbus_message_get_args (reply, &error, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID) ||
327         dbus_error_is_set(&error) ||
328         !path) {
329         avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR);
330         goto fail;
331     }
332
333     if (!(b->path = avahi_strdup(path))) {
334
335         /* FIXME: We don't remove the object on the server side */
336
337         avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
338         goto fail;
339     }
340
341     dbus_message_unref(message);
342     dbus_message_unref(reply);
343
344     return b;
345
346 fail:
347     
348     if (dbus_error_is_set(&error)) {
349         avahi_client_set_dbus_error(client, &error);
350         dbus_error_free(&error);
351     }
352
353     if (b)
354         avahi_service_type_browser_free(b);
355     
356     if (message)
357         dbus_message_unref(message);
358
359     if (reply)
360         dbus_message_unref(reply);
361
362     return NULL;
363 }
364
365 AvahiClient* avahi_service_type_browser_get_client (AvahiServiceTypeBrowser *b) {
366     assert(b);
367     return b->client;
368 }
369
370 int avahi_service_type_browser_free (AvahiServiceTypeBrowser *b) {
371     AvahiClient *client;
372     int r = AVAHI_OK;
373
374     assert(b);
375     client = b->client;
376
377     if (b->path && client->state != AVAHI_CLIENT_DISCONNECTED)
378         r = avahi_client_simple_method_call(client, b->path, AVAHI_DBUS_INTERFACE_SERVICE_TYPE_BROWSER, "Free");
379
380     AVAHI_LLIST_REMOVE(AvahiServiceTypeBrowser, service_type_browsers, b->client->service_type_browsers, b);
381
382     avahi_free(b->path);
383     avahi_free(b->domain);
384     avahi_free(b);
385     return r;
386 }
387
388 DBusHandlerResult avahi_service_type_browser_event (AvahiClient *client, AvahiBrowserEvent event, DBusMessage *message) {
389     AvahiServiceTypeBrowser *b = NULL;
390     DBusError error;
391     const char *path;
392     char *domain, *type = NULL;
393     int32_t interface, protocol;
394     uint32_t flags = 0;
395
396     assert(client);
397     assert(message);
398     
399     dbus_error_init (&error);
400
401     if (!(path = dbus_message_get_path(message)))
402         goto fail;
403
404     for (b = client->service_type_browsers; b; b = b->service_type_browsers_next)
405         if (strcmp (b->path, path) == 0)
406             break;
407
408     if (!b)
409         goto fail;
410
411     domain = b->domain;
412     interface = b->interface;
413     protocol = b->protocol;
414     
415     switch (event) {
416         case AVAHI_BROWSER_NEW:
417         case AVAHI_BROWSER_REMOVE:
418             if (!dbus_message_get_args(
419                     message, &error,
420                     DBUS_TYPE_INT32, &interface,
421                     DBUS_TYPE_INT32, &protocol,
422                     DBUS_TYPE_STRING, &type,
423                     DBUS_TYPE_STRING, &domain,
424                     DBUS_TYPE_UINT32, &flags,
425                     DBUS_TYPE_INVALID) ||
426                 dbus_error_is_set(&error)) {
427                 fprintf(stderr, "Failed to parse browser event.\n");
428                 goto fail;
429             }
430             break;
431             
432         case AVAHI_BROWSER_CACHE_EXHAUSTED:
433         case AVAHI_BROWSER_ALL_FOR_NOW:
434             break;
435
436         case AVAHI_BROWSER_FAILURE: {
437             char *etxt;
438             
439             if (!dbus_message_get_args(
440                     message, &error,
441                     DBUS_TYPE_STRING, &etxt,
442                     DBUS_TYPE_INVALID) ||
443                 dbus_error_is_set (&error)) {
444                 fprintf(stderr, "Failed to parse browser event.\n");
445                 goto fail;
446             }
447             
448             avahi_client_set_errno(b->client, avahi_error_dbus_to_number(etxt));
449             break;
450         }
451     }
452
453     b->callback(b, (AvahiIfIndex) interface, (AvahiProtocol) protocol, event, type, domain, (AvahiLookupResultFlags) flags, b->userdata);
454
455     return DBUS_HANDLER_RESULT_HANDLED;
456
457 fail:
458     dbus_error_free (&error);
459     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
460 }
461
462 /* AvahiServiceBrowser */
463
464 AvahiServiceBrowser* avahi_service_browser_new(
465     AvahiClient *client,
466     AvahiIfIndex interface,
467     AvahiProtocol protocol,
468     const char *type,
469     const char *domain,
470     AvahiLookupFlags flags, 
471     AvahiServiceBrowserCallback callback,
472     void *userdata) {
473     
474     AvahiServiceBrowser *b = NULL;
475     DBusMessage *message = NULL, *reply = NULL;
476     DBusError error;
477     char *path;
478     int32_t i_protocol, i_interface;
479     uint32_t u_flags;
480
481     assert(client);
482     assert(type);
483     assert(callback);
484
485     dbus_error_init(&error);
486
487     if (client->state == AVAHI_CLIENT_DISCONNECTED) {
488         avahi_client_set_errno(client, AVAHI_ERR_BAD_STATE);
489         goto fail;
490     }
491
492     if (!domain)
493         domain = "";
494
495     if (!(b = avahi_new(AvahiServiceBrowser, 1))) {
496         avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
497         goto fail;
498     }
499     
500     b->client = client;
501     b->callback = callback;
502     b->userdata = userdata;
503     b->path = NULL;
504     b->type = b->domain = NULL;
505     b->interface = interface;
506     b->protocol = protocol;
507
508     AVAHI_LLIST_PREPEND(AvahiServiceBrowser, service_browsers, client->service_browsers, b);
509
510     if (!(b->type = avahi_strdup(type))) {
511         avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
512         goto fail;
513     }
514     
515     if (domain && domain[0])
516         if (!(b->domain = avahi_strdup(domain))) {
517             avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
518             goto fail;
519         }
520     
521     if (!(message = dbus_message_new_method_call (AVAHI_DBUS_NAME, AVAHI_DBUS_PATH_SERVER, AVAHI_DBUS_INTERFACE_SERVER, "ServiceBrowserNew"))) {
522         avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
523         goto fail;
524     }
525
526     i_interface = (int32_t) interface;
527     i_protocol = (int32_t) protocol;
528     u_flags = (uint32_t) flags;
529
530     if (!dbus_message_append_args(
531             message,
532             DBUS_TYPE_INT32, &i_interface,
533             DBUS_TYPE_INT32, &i_protocol,
534             DBUS_TYPE_STRING, &type,
535             DBUS_TYPE_STRING, &domain,
536             DBUS_TYPE_UINT32, &u_flags,
537             DBUS_TYPE_INVALID)) {
538         avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
539         goto fail;
540     }
541
542     if (!(reply = dbus_connection_send_with_reply_and_block (client->bus, message, -1, &error)) ||
543         dbus_error_is_set(&error)) {
544         avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR);
545         goto fail;
546     }
547
548     if (!dbus_message_get_args (reply, &error, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID) ||
549         dbus_error_is_set(&error) ||
550         !path) {
551         avahi_client_set_errno(client, AVAHI_ERR_DBUS_ERROR);
552         goto fail;
553     }
554
555     if (!(b->path = avahi_strdup(path))) {
556
557         /* FIXME: We don't remove the object on the server side */
558
559         avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
560         goto fail;
561     }
562
563     dbus_message_unref(message);
564     dbus_message_unref(reply);
565     
566     return b;
567
568 fail:
569     if (dbus_error_is_set(&error)) {
570         avahi_client_set_dbus_error(client, &error);
571         dbus_error_free(&error);
572     }
573
574     if (b)
575         avahi_service_browser_free(b);
576     
577     if (message)
578         dbus_message_unref(message);
579
580     if (reply)
581         dbus_message_unref(reply);
582
583     return NULL;
584 }
585
586 AvahiClient* avahi_service_browser_get_client (AvahiServiceBrowser *b) {
587     assert(b);
588     return b->client;
589 }
590
591 int avahi_service_browser_free (AvahiServiceBrowser *b) {
592     AvahiClient *client;
593     int r = AVAHI_OK;
594
595     assert(b);
596     client = b->client;
597
598     if (b->path && client->state != AVAHI_CLIENT_DISCONNECTED)
599         r = avahi_client_simple_method_call(client, b->path, AVAHI_DBUS_INTERFACE_SERVICE_BROWSER, "Free");
600
601     AVAHI_LLIST_REMOVE(AvahiServiceBrowser, service_browsers, b->client->service_browsers, b);
602
603     avahi_free(b->path);
604     avahi_free(b->type);
605     avahi_free(b->domain);
606     avahi_free(b);
607     return r;
608 }
609
610 DBusHandlerResult avahi_service_browser_event(AvahiClient *client, AvahiBrowserEvent event, DBusMessage *message) {
611     AvahiServiceBrowser *b = NULL;
612     DBusError error;
613     const char *path;
614     char *name = NULL, *type, *domain;
615     int32_t interface, protocol;
616     uint32_t flags = 0;
617
618     dbus_error_init (&error);
619
620     if (!(path = dbus_message_get_path(message)))
621         goto fail;
622
623     for (b = client->service_browsers; b; b = b->service_browsers_next)
624         if (strcmp (b->path, path) == 0)
625             break;
626
627     if (!b)
628         goto fail;
629
630     type = b->type;
631     domain = b->domain;
632     interface = b->interface;
633     protocol = b->protocol;
634
635     switch (event) {
636         case AVAHI_BROWSER_NEW:
637         case AVAHI_BROWSER_REMOVE:
638             
639             if (!dbus_message_get_args (
640                     message, &error,
641                     DBUS_TYPE_INT32, &interface,
642                     DBUS_TYPE_INT32, &protocol,
643                     DBUS_TYPE_STRING, &name,
644                     DBUS_TYPE_STRING, &type,
645                     DBUS_TYPE_STRING, &domain,
646                     DBUS_TYPE_UINT32, &flags,
647                     DBUS_TYPE_INVALID) ||
648                 dbus_error_is_set(&error)) {
649                 fprintf(stderr, "Failed to parse browser event.\n");
650                 goto fail;
651             }
652             break;
653
654         case AVAHI_BROWSER_CACHE_EXHAUSTED:
655         case AVAHI_BROWSER_ALL_FOR_NOW:
656             break;
657
658         case AVAHI_BROWSER_FAILURE: {
659             char *etxt;
660             
661             if (!dbus_message_get_args(
662                     message, &error,
663                     DBUS_TYPE_STRING, &etxt,
664                     DBUS_TYPE_INVALID) ||
665                 dbus_error_is_set (&error)) {
666                 fprintf(stderr, "Failed to parse browser event.\n");
667                 goto fail;
668             }
669             
670             avahi_client_set_errno(b->client, avahi_error_dbus_to_number(etxt));
671             break;
672         }
673     }
674
675     b->callback(b, (AvahiIfIndex) interface, (AvahiProtocol) protocol, event, name, type, domain, (AvahiLookupResultFlags) flags, b->userdata);
676
677     return DBUS_HANDLER_RESULT_HANDLED;
678
679 fail:
680     dbus_error_free (&error);
681     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
682 }
683
684