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