]> git.meshlink.io Git - catta/blob - avahi-client/browser.c
* Add a free function for AvahiEntryGroup in C api
[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 <avahi-client/client.h>
27 #include <avahi-common/dbus.h>
28 #include <avahi-common/llist.h>
29 #include <avahi-common/error.h>
30 #include <stdlib.h>
31 #include <stdio.h>
32 #include <string.h>
33
34 #define DBUS_API_SUBJECT_TO_CHANGE
35 #include <dbus/dbus.h>
36 #include <dbus/dbus-glib-lowlevel.h>
37
38 #include <stdlib.h>
39
40 #include "client.h"
41 #include "internal.h"
42
43 /* AvahiDomainBrowser */
44
45 AvahiDomainBrowser* avahi_domain_browser_new (AvahiClient *client, AvahiIfIndex interface, AvahiProtocol protocol, char *domain, AvahiDomainBrowserType btype, AvahiDomainBrowserCallback callback, void *user_data)
46 {
47     AvahiDomainBrowser *tmp = NULL;
48     DBusMessage *message = NULL, *reply;
49     DBusError error;
50     char *path;
51
52     if (client == NULL)
53         return NULL;
54
55     dbus_error_init (&error);
56
57     message = dbus_message_new_method_call (AVAHI_DBUS_NAME, AVAHI_DBUS_PATH_SERVER,
58             AVAHI_DBUS_INTERFACE_SERVER, "DomainBrowserNew");
59
60     if (!dbus_message_append_args (message, DBUS_TYPE_INT32, &interface, DBUS_TYPE_INT32, &protocol, DBUS_TYPE_STRING, &domain, DBUS_TYPE_INT32, &btype, DBUS_TYPE_INVALID))
61         goto dbus_error;
62
63     reply = dbus_connection_send_with_reply_and_block (client->bus, message, -1, &error);
64
65     if (dbus_error_is_set (&error) || reply == NULL)
66         goto dbus_error;
67
68     if (!dbus_message_get_args (reply, &error, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID))
69         goto dbus_error;
70
71     if (dbus_error_is_set (&error) || path == NULL)
72         goto dbus_error;
73
74     tmp = malloc (sizeof (AvahiDomainBrowser));
75     tmp->client = client;
76     tmp->callback = callback;
77     tmp->user_data = user_data;
78     tmp->path = strdup (path);
79
80     AVAHI_LLIST_PREPEND(AvahiDomainBrowser, domain_browsers, client->domain_browsers, tmp);
81
82     return tmp;
83
84 dbus_error:
85     dbus_error_free (&error);
86     avahi_client_set_errno (client, AVAHI_ERR_DBUS_ERROR);
87
88     return NULL;
89 }
90
91 int
92 avahi_domain_browser_free (AvahiDomainBrowser *b)
93 {
94     AvahiClient *client = b->client;
95     DBusMessage *message = NULL;
96
97     if (b == NULL || b->path == NULL)
98         return avahi_client_set_errno (client, AVAHI_ERR_INVALID_OBJECT);
99
100     message = dbus_message_new_method_call (AVAHI_DBUS_NAME,
101             b->path,
102             AVAHI_DBUS_INTERFACE_DOMAIN_BROWSER, "Free");
103
104     if (message == NULL)
105         return avahi_client_set_errno (client, AVAHI_ERR_DBUS_ERROR);
106
107     dbus_connection_send (client->bus, message, NULL);
108
109     AVAHI_LLIST_REMOVE(AvahiDomainBrowser, domain_browsers, client->domain_browsers, b);
110
111     free (b);
112
113     return avahi_client_set_errno (client, AVAHI_OK);
114 }
115
116 char*
117 avahi_domain_browser_path (AvahiDomainBrowser *b)
118 {
119     return b->path;
120 }
121
122 DBusHandlerResult
123 avahi_domain_browser_event (AvahiClient *client, AvahiBrowserEvent event, DBusMessage *message)
124 {
125     AvahiDomainBrowser *n, *db = NULL;
126     DBusError error;
127     const char *path;
128     char *domain;
129     int interface, protocol;
130
131     dbus_error_init (&error);
132
133     path = dbus_message_get_path (message);
134
135     if (path == NULL)
136         goto out;
137
138     for (n = client->domain_browsers; n != NULL; n = n->domain_browsers_next)
139     {
140         printf ("cmp: %s, %s\n", n->path, path);
141         if (strcmp (n->path, path) == 0) {
142             db = n;
143             break;
144         }
145     }
146
147     if (db == NULL)
148         goto out;
149
150     dbus_message_get_args (message, &error, DBUS_TYPE_INT32, &interface,
151             DBUS_TYPE_INT32, &protocol, DBUS_TYPE_STRING, &domain, DBUS_TYPE_INVALID);
152
153     if (dbus_error_is_set (&error))
154         goto out;
155
156     db->callback (db, interface, protocol, event, domain, db->user_data);
157
158     return DBUS_HANDLER_RESULT_HANDLED;
159
160 out:
161     dbus_error_free (&error);
162     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
163 }
164
165 /* AvahiServiceTypeBrowser */
166 AvahiServiceTypeBrowser* avahi_service_type_browser_new (AvahiClient *client, AvahiIfIndex interface, AvahiProtocol protocol, char *domain, AvahiServiceTypeBrowserCallback callback, void *user_data)
167 {
168     AvahiServiceTypeBrowser *tmp = NULL;
169     DBusMessage *message = NULL, *reply;
170     DBusError error;
171     char *path;
172
173     if (client == NULL)
174         return NULL;
175
176     dbus_error_init (&error);
177
178     message = dbus_message_new_method_call (AVAHI_DBUS_NAME,
179             AVAHI_DBUS_PATH_SERVER,
180             AVAHI_DBUS_INTERFACE_SERVER,
181             "ServiceTypeBrowserNew");
182
183     if (!dbus_message_append_args (message, DBUS_TYPE_INT32, &interface, DBUS_TYPE_INT32, &protocol, DBUS_TYPE_STRING, &domain, DBUS_TYPE_INVALID))
184         goto dbus_error;
185
186     reply = dbus_connection_send_with_reply_and_block (client->bus, message, -1, &error);
187
188     if (dbus_error_is_set (&error) || reply == NULL)
189         goto dbus_error;
190
191     if (!dbus_message_get_args (reply, &error, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID))
192         goto dbus_error;
193
194     if (dbus_error_is_set (&error) || path == NULL)
195         goto dbus_error;
196
197     tmp = malloc (sizeof (AvahiServiceTypeBrowser));
198     tmp->client = client;
199     tmp->callback = callback;
200     tmp->user_data = user_data;
201     tmp->path = strdup (path);
202
203     AVAHI_LLIST_PREPEND(AvahiServiceTypeBrowser, service_type_browsers, client->service_type_browsers, tmp);
204
205     return tmp;
206
207 dbus_error:
208     dbus_error_free (&error);
209     avahi_client_set_errno (client, AVAHI_ERR_DBUS_ERROR);
210
211     return NULL;
212 }
213
214 int
215 avahi_service_type_browser_free (AvahiServiceTypeBrowser *b)
216 {
217     AvahiClient *client = b->client;
218     DBusMessage *message = NULL;
219
220     if (b == NULL || b->path == NULL)
221         return avahi_client_set_errno (client, AVAHI_ERR_INVALID_OBJECT);
222
223     message = dbus_message_new_method_call (AVAHI_DBUS_NAME,
224             b->path,
225             AVAHI_DBUS_INTERFACE_SERVICE_TYPE_BROWSER, "Free");
226
227     if (message == NULL)
228         return avahi_client_set_errno (client, AVAHI_ERR_DBUS_ERROR);
229
230     dbus_connection_send (b->client->bus, message, NULL);
231
232     AVAHI_LLIST_REMOVE(AvahiServiceTypeBrowser, service_type_browsers, b->client->service_type_browsers, b);
233
234     free (b);
235
236     return avahi_client_set_errno (client, AVAHI_OK);
237 }
238
239 char*
240 avahi_service_type_browser_path (AvahiServiceTypeBrowser *b)
241 {
242     return b->path;
243 }
244
245 DBusHandlerResult
246 avahi_service_type_browser_event (AvahiClient *client, AvahiBrowserEvent event, DBusMessage *message)
247 {
248     AvahiServiceTypeBrowser *n, *db = NULL;
249     DBusError error;
250     const char *path;
251     char *domain, *type;
252     int interface, protocol;
253
254     dbus_error_init (&error);
255
256     path = dbus_message_get_path (message);
257
258     if (path == NULL)
259         goto out;
260
261     for (n = client->service_type_browsers; n != NULL; n = n->service_type_browsers_next)
262     {
263         printf ("cmp: %s, %s\n", n->path, path);
264         if (strcmp (n->path, path) == 0) {
265             db = n;
266             break;
267         }
268     }
269
270     if (db == NULL)
271         goto out;
272
273     dbus_message_get_args (message, &error,
274             DBUS_TYPE_INT32, &interface,
275             DBUS_TYPE_INT32, &protocol,
276             DBUS_TYPE_STRING, &type,
277             DBUS_TYPE_STRING, &domain,
278             DBUS_TYPE_INVALID);
279     
280     if (dbus_error_is_set (&error))
281         goto out;
282
283     db->callback (db, interface, protocol, event, type, domain, db->user_data);
284
285     return DBUS_HANDLER_RESULT_HANDLED;
286
287 out:
288     dbus_error_free (&error);
289     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
290 }
291
292 /* AvahiServiceBrowser */
293
294 AvahiServiceBrowser* avahi_service_browser_new (AvahiClient *client, AvahiIfIndex interface, AvahiProtocol protocol, char *type, char *domain, AvahiServiceBrowserCallback callback, void *user_data)
295 {
296     AvahiServiceBrowser *tmp = NULL;
297     DBusMessage *message = NULL, *reply;
298     DBusError error;
299     char *path;
300
301     if (client == NULL)
302         return NULL;
303
304     dbus_error_init (&error);
305
306     message = dbus_message_new_method_call (AVAHI_DBUS_NAME, AVAHI_DBUS_PATH_SERVER,
307             AVAHI_DBUS_INTERFACE_SERVER, "ServiceBrowserNew");
308
309     if (!dbus_message_append_args (message,
310                 DBUS_TYPE_INT32, &interface,
311                 DBUS_TYPE_INT32, &protocol,
312                 DBUS_TYPE_STRING, &type,
313                 DBUS_TYPE_STRING, &domain,
314                 DBUS_TYPE_INVALID))
315         goto dbus_error;
316
317     reply = dbus_connection_send_with_reply_and_block (client->bus, message, -1, &error);
318
319     if (dbus_error_is_set (&error) || reply == NULL)
320         goto dbus_error;
321
322     if (!dbus_message_get_args (reply, &error, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID))
323         goto dbus_error;
324
325     if (dbus_error_is_set (&error) || path == NULL)
326         goto dbus_error;
327
328     tmp = malloc (sizeof (AvahiServiceBrowser));
329     tmp->client = client;
330     tmp->callback = callback;
331     tmp->user_data = user_data;
332     tmp->path = strdup (path);
333
334     AVAHI_LLIST_PREPEND(AvahiServiceBrowser, service_browsers, client->service_browsers, tmp);
335
336     return tmp;
337
338 dbus_error:
339     dbus_error_free (&error);
340     avahi_client_set_errno (client, AVAHI_ERR_DBUS_ERROR);
341
342     return NULL;
343 }
344     
345 int
346 avahi_service_browser_free (AvahiServiceBrowser *b)
347 {
348     AvahiClient *client = b->client;
349     DBusMessage *message = NULL;
350     
351     if (b == NULL || b->path == NULL)
352         return avahi_client_set_errno (client, AVAHI_ERR_INVALID_OBJECT);
353
354     message = dbus_message_new_method_call (AVAHI_DBUS_NAME,
355             b->path,
356             AVAHI_DBUS_INTERFACE_SERVICE_BROWSER, "Free");
357
358     if (message == NULL)
359         return avahi_client_set_errno (client, AVAHI_ERR_DBUS_ERROR);
360
361     dbus_connection_send (b->client->bus, message, NULL);
362
363     AVAHI_LLIST_REMOVE(AvahiServiceBrowser, service_browsers, b->client->service_browsers, b);
364
365     free (b);
366
367     return avahi_client_set_errno (client, AVAHI_OK);
368 }
369
370 char*
371 avahi_service_browser_path (AvahiServiceBrowser *b)
372 {
373     return b->path;
374 }
375
376 DBusHandlerResult
377 avahi_service_browser_event (AvahiClient *client, AvahiBrowserEvent event, DBusMessage *message)
378 {
379     AvahiServiceBrowser *n, *db = NULL;
380     DBusError error;
381     const char *path;
382     char *name, *type, *domain;
383     int interface, protocol;
384
385     dbus_error_init (&error);
386
387     path = dbus_message_get_path (message);
388
389     if (path == NULL)
390         goto out;
391
392     for (n = client->service_browsers; n != NULL; n = n->service_browsers_next)
393     {
394         printf ("cmp: %s, %s\n", n->path, path);
395         if (strcmp (n->path, path) == 0) {
396             db = n;
397             break;
398         }
399     }
400
401     if (db == NULL)
402         goto out;
403
404     dbus_message_get_args (message, &error,
405             DBUS_TYPE_INT32, &interface,
406             DBUS_TYPE_INT32, &protocol,
407             DBUS_TYPE_STRING, &name,
408             DBUS_TYPE_STRING, &type,
409             DBUS_TYPE_STRING, &domain,
410             DBUS_TYPE_INVALID);
411
412     if (dbus_error_is_set (&error))
413         goto out;
414
415     db->callback (db, interface, protocol, event, name, type, domain, db->user_data);
416
417     return DBUS_HANDLER_RESULT_HANDLED;
418
419 out:
420     dbus_error_free (&error);
421     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
422 }
423
424