]> git.meshlink.io Git - catta/blob - avahi-client/client.c
* Work on avahi-client
[catta] / avahi-client / client.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 int
44 avahi_client_set_errno (AvahiClient *client, int errno)
45 {
46     if (client == NULL) return errno;
47
48     client->errno = errno;
49
50     return errno;
51 }
52     
53 static
54 void avahi_client_state_change (AvahiClient *client, int state)
55 {
56     if (client == NULL || client->callback == NULL) 
57         return;
58
59     client->callback (client, state, client->user_data);
60 }
61
62 void
63 avahi_client_state_request_callback (DBusPendingCall *call, void *data)
64 {
65     AvahiClient *client = data;
66     DBusError error;
67     DBusMessage *reply;
68     int state, type;
69
70     dbus_error_init (&error);
71
72     reply = dbus_pending_call_steal_reply (call);
73
74     type = dbus_message_get_type (reply);
75
76     if (type == DBUS_MESSAGE_TYPE_METHOD_RETURN)
77     {
78         dbus_message_get_args (reply, &error, DBUS_TYPE_INT32, &state, DBUS_TYPE_INVALID);
79         
80         if (dbus_error_is_set (&error))
81         {
82             fprintf (stderr, "internal error parsing client state change for client\n");
83             return;
84         }
85         
86         printf ("statechange (client) to %d\n", state);
87         
88         avahi_client_state_change (client, state);
89     } else if (type == DBUS_MESSAGE_TYPE_ERROR) {
90         dbus_set_error_from_message (&error, reply);
91         fprintf (stderr, "Error from reply: %s\n", error.message);
92     }
93
94     dbus_pending_call_unref (call);
95 }
96
97 void
98 avahi_client_schedule_state_request (AvahiClient *client)
99 {
100     DBusMessage *message;
101     DBusPendingCall *pcall;
102
103     if (client == NULL) return;
104
105     message = dbus_message_new_method_call (AVAHI_DBUS_NAME, AVAHI_DBUS_PATH_SERVER, AVAHI_DBUS_INTERFACE_SERVER, "GetState");
106
107     dbus_connection_send_with_reply (client->bus, message, &pcall, -1);
108
109     dbus_pending_call_set_notify (pcall, avahi_client_state_request_callback, client, NULL);
110 }
111
112 static DBusHandlerResult
113 filter_func (DBusConnection *bus, DBusMessage *message, void *data)
114 {
115     AvahiClient *client = data;
116     DBusError error;
117     
118     printf ("dbus: interface=%s, path=%s, member=%s\n",
119             dbus_message_get_interface (message),
120             dbus_message_get_path (message),
121             dbus_message_get_member (message));
122
123     dbus_error_init (&error);
124
125     if (dbus_message_is_signal(message, DBUS_INTERFACE_DBUS, "NameOwnerChanged")) {
126         gchar *name, *old, *new;
127         dbus_message_get_args(message, &error, DBUS_TYPE_STRING, &name, DBUS_TYPE_STRING, &old, DBUS_TYPE_STRING, &new, DBUS_TYPE_INVALID);
128         
129         if (dbus_error_is_set (&error)) {
130             fprintf(stderr, "Failed to parse NameOwnerChanged message: %s", error.message);
131             dbus_error_free (&error);
132             goto out;
133         }
134
135         if (strcmp (name, AVAHI_DBUS_NAME) == 0) {
136
137             if (old == NULL && new != NULL) {
138                 fprintf(stderr, "Avahi Daemon connected\n");
139                 avahi_client_state_change (client, AVAHI_CLIENT_RECONNECTED);
140             } else if (old != NULL && new == NULL) {
141                 fprintf(stderr, "Avahi Daemon disconnected\n");
142                 avahi_client_state_change (client, AVAHI_CLIENT_DISCONNECTED);
143                 /* XXX: we really need to expire all entry groups */
144             }
145         }
146     } else if (dbus_message_is_signal (message, AVAHI_DBUS_NAME, "StateChanged")) {
147         printf ("server statehcange\n");
148     } else if (dbus_message_is_signal (message, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "StateChanged")) {
149         const char *path;
150         AvahiEntryGroup *n, *group = NULL;
151         path = dbus_message_get_path (message);
152
153         for (n = client->groups; n != NULL; n = n->groups_next)
154         {
155             if (strcmp (n->path, path) == 0)
156             {
157                 group = n;
158                 break;
159             }
160         }
161
162         if (group == NULL)
163         {
164             fprintf (stderr, "Received state change for unknown EntryGroup object (%s)\n", path);
165         } else {
166             int state;
167             DBusError error;
168
169             dbus_error_init (&error);
170
171             dbus_message_get_args (message, &error, DBUS_TYPE_INT32, &state, DBUS_TYPE_INVALID);
172
173             if (dbus_error_is_set (&error))
174             {
175                 fprintf (stderr, "internal error parsing entrygroup statechange for %s\n", group->path);
176                 goto out;
177             }
178
179             printf ("statechange (%s) to %d\n", group->path, state);
180             
181             avahi_entry_group_state_change (group, state);
182         }
183     }
184
185     return DBUS_HANDLER_RESULT_HANDLED;
186
187 out: 
188     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
189 }
190
191 AvahiClient *
192 avahi_client_new (AvahiClientCallback callback, void *user_data)
193 {
194     AvahiClient *tmp = NULL;
195     DBusError error;
196
197     tmp = g_new (AvahiClient, 1);
198
199     if (tmp == NULL)
200         goto fail;
201
202     AVAHI_LLIST_HEAD_INIT(AvahiEntryGroup, tmp->groups);
203
204     dbus_error_init (&error);
205
206     tmp->bus = dbus_bus_get (DBUS_BUS_SYSTEM, &error);
207
208     dbus_connection_setup_with_g_main (tmp->bus, NULL);
209
210     if (dbus_error_is_set (&error)) {
211         fprintf(stderr, "Error getting system d-bus: %s\n", error.message);
212         dbus_error_free (&error);
213         goto fail;
214     }
215
216     dbus_connection_set_exit_on_disconnect (tmp->bus, FALSE);
217
218     if (!dbus_connection_add_filter (tmp->bus, filter_func, tmp, NULL))
219     {
220         fprintf (stderr, "Failed to add d-bus filter\n");
221         goto fail;
222     }
223
224     dbus_bus_add_match (tmp->bus,
225             "type='signal', "
226             "interface='" AVAHI_DBUS_INTERFACE_SERVER "', "
227             "sender='" AVAHI_DBUS_NAME "', "
228             "path='" AVAHI_DBUS_PATH_SERVER "'",
229             &error);
230
231     if (dbus_error_is_set (&error))
232     {
233         fprintf (stderr, "Error adding filter match: %s\n", error.message);
234         dbus_error_free (&error);
235         goto fail;
236
237     }   
238
239     dbus_bus_add_match (tmp->bus,
240             "type='signal', "
241             "interface='" DBUS_INTERFACE_DBUS "', "
242             "sender='" DBUS_SERVICE_DBUS "', "
243             "path='" DBUS_PATH_DBUS "'",
244             &error);
245
246     if (dbus_error_is_set (&error))
247     {
248         fprintf (stderr, "Error adding filter match: %s\n", error.message);
249         dbus_error_free (&error);
250         goto fail;
251     }
252
253     tmp->callback = callback;
254     tmp->user_data = user_data;
255
256     avahi_client_schedule_state_request (tmp);
257
258     avahi_client_set_errno (tmp, AVAHI_OK);
259     return tmp;
260
261 fail:
262     if (tmp) free (tmp);
263     return NULL;
264 }
265
266 static char*
267 avahi_client_get_string_reply_and_block (AvahiClient *client, char *method, char *param)
268 {
269     DBusMessage *message;
270     DBusMessage *reply;
271     DBusError error;
272     char *ret, *new;
273
274     if (client == NULL || method == NULL) return NULL;
275
276     dbus_error_init (&error);
277
278     message = dbus_message_new_method_call (AVAHI_DBUS_NAME, AVAHI_DBUS_PATH_SERVER, AVAHI_DBUS_INTERFACE_SERVER, method);
279
280     if (param != NULL)
281     {
282         if (!dbus_message_append_args (message, DBUS_TYPE_STRING, &param, DBUS_TYPE_INVALID))
283         {
284             avahi_client_set_errno (client, AVAHI_ERR_DBUS_ERROR);
285             fprintf (stderr, "Failed to append string argument to %s message\n", method);
286             return NULL;
287         }
288     }
289     
290     reply = dbus_connection_send_with_reply_and_block (client->bus, message, -1, &error);
291
292     if (dbus_error_is_set (&error))
293     {
294         fprintf (stderr, "Error sending %s message: %s\n", method, error.message);
295         dbus_error_free (&error);
296         dbus_message_unref (message);
297
298         avahi_client_set_errno (client, AVAHI_ERR_DBUS_ERROR);
299         return NULL;
300     }
301
302     if (reply == NULL)
303     {
304         dbus_message_unref (message);
305         fprintf (stderr, "Could not connect to Avahi daemon\n");
306
307         avahi_client_set_errno (client, AVAHI_ERR_DBUS_ERROR);
308         return NULL;
309     }
310
311     dbus_message_get_args (reply, &error, DBUS_TYPE_STRING, &ret, DBUS_TYPE_INVALID);
312
313     if (dbus_error_is_set (&error))
314     {
315         fprintf (stderr, "Failed to parse %s reply: %s\n", method, error.message);
316         dbus_error_free (&error);
317
318         avahi_client_set_errno (client, AVAHI_ERR_DBUS_ERROR);
319         return NULL;
320     }
321
322     new = strdup (ret);
323
324     avahi_client_set_errno (client, AVAHI_OK);
325     return new;
326 }
327
328 char*
329 avahi_client_get_version_string (AvahiClient *client)
330 {
331     return avahi_client_get_string_reply_and_block (client, "GetVersionString", NULL);
332 }
333
334 char*
335 avahi_client_get_domain_name (AvahiClient *client)
336 {
337     return avahi_client_get_string_reply_and_block (client, "GetDomainName", NULL);
338 }
339
340 char*
341 avahi_client_get_host_name (AvahiClient *client)
342 {
343     return avahi_client_get_string_reply_and_block (client, "GetHostName", NULL);
344 }
345
346 char*
347 avahi_client_get_host_name_fqdn (AvahiClient *client)
348 {
349     return avahi_client_get_string_reply_and_block (client, "GetHostNameFqdn", NULL);
350 }