]> git.meshlink.io Git - catta/blob - avahi-client/entrygroup.c
* Add a free function for AvahiEntryGroup in C api
[catta] / avahi-client / entrygroup.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 void avahi_entry_group_state_change (AvahiEntryGroup *group, int state)
44 {
45     if (group == NULL || group->callback == NULL)
46         return;
47
48     group->callback (group, state, group->user_data);
49 }
50
51 AvahiEntryGroup*
52 avahi_entry_group_new (AvahiClient *client, AvahiEntryGroupCallback callback, void *user_data)
53 {
54     AvahiEntryGroup *tmp = NULL;
55     DBusMessage *message = NULL, *reply;
56     DBusError error;
57     char *path;
58
59     if (client == NULL)
60         return NULL;
61     
62     dbus_error_init (&error);
63
64     message = dbus_message_new_method_call (AVAHI_DBUS_NAME, AVAHI_DBUS_PATH_SERVER,
65             AVAHI_DBUS_INTERFACE_SERVER, "EntryGroupNew");
66
67     reply = dbus_connection_send_with_reply_and_block (client->bus, message, -1, &error);
68
69     if (dbus_error_is_set (&error))
70     {
71         fprintf (stderr, "Error sending EntryGroupNew message: %s\n", error.message);
72         dbus_error_free (&error);
73
74         avahi_client_set_errno (client, AVAHI_ERR_DBUS_ERROR);
75         goto fail;
76     }
77
78     if (reply == NULL)
79     {
80         fprintf (stderr, "Got NULL reply from EntryGroupNew\n");
81
82         avahi_client_set_errno (client, AVAHI_ERR_DBUS_ERROR);
83         goto fail;
84     }
85
86     dbus_message_get_args (reply, &error, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID);
87
88     if (dbus_error_is_set (&error))
89     {
90         fprintf (stderr, "Failure parsing EntryGroupNew reply: %s\n", error.message);
91         avahi_client_set_errno (client, AVAHI_ERR_DBUS_ERROR);
92         goto fail;
93     }
94
95     tmp = malloc (sizeof (AvahiEntryGroup));
96
97     tmp->client = client;
98
99     tmp->path = strdup (path);
100     tmp->callback = callback;
101     tmp->user_data = user_data;
102
103     AVAHI_LLIST_PREPEND(AvahiEntryGroup, groups, client->groups, tmp);
104
105     dbus_message_unref (message);
106
107     avahi_client_set_errno (client, AVAHI_OK);
108     return tmp;
109
110 fail:
111     if (tmp) free (tmp);
112     if (message) dbus_message_unref (message);
113     return NULL;
114 }
115
116 int
117 avahi_entry_group_free (AvahiEntryGroup *group)
118 {
119     AvahiClient *client = group->client;
120     DBusMessage *message;
121
122     if (group == NULL || group->path == NULL)
123         return avahi_client_set_errno (client, AVAHI_ERR_INVALID_OBJECT);
124
125     message = dbus_message_new_method_call (AVAHI_DBUS_NAME,
126             group->path, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "Free");
127
128     if (message == NULL)
129         return avahi_client_set_errno (client, AVAHI_ERR_DBUS_ERROR);
130
131     dbus_connection_send (client->bus, message, NULL);
132
133     free (group);
134
135     return avahi_client_set_errno (client, AVAHI_OK);
136 }
137
138 int
139 avahi_entry_group_commit (AvahiEntryGroup *group)
140 {
141     DBusMessage *message;
142     DBusError error;
143
144     dbus_error_init (&error);
145
146     message = dbus_message_new_method_call (AVAHI_DBUS_NAME, group->path,
147             AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "Commit");
148
149     dbus_connection_send (group->client->bus, message, NULL);
150
151     return avahi_client_set_errno (group->client, AVAHI_OK);
152 }
153
154 int
155 avahi_entry_group_reset (AvahiEntryGroup *group)
156 {
157     DBusMessage *message;
158
159     message = dbus_message_new_method_call (AVAHI_DBUS_NAME, group->path,
160             AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "Reset");
161
162     dbus_connection_send (group->client->bus, message, NULL);
163
164     return avahi_client_set_errno (group->client, AVAHI_OK);
165 }
166
167 int
168 avahi_entry_group_get_state (AvahiEntryGroup *group)
169 {
170     DBusMessage *message, *reply;
171     DBusError error;
172     int state;
173
174     dbus_error_init (&error);
175
176     message = dbus_message_new_method_call (AVAHI_DBUS_NAME, group->path,
177             AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "GetState");
178
179     reply = dbus_connection_send_with_reply_and_block (group->client->bus, message, -1, &error);
180
181     if (dbus_error_is_set (&error))
182     {
183         fprintf (stderr, "Error sending GetState message for %s EntryGroup: %s\n", group->path, error.message);
184         dbus_error_free (&error);
185
186         return avahi_client_set_errno (group->client, AVAHI_ERR_DBUS_ERROR);
187     }
188
189     dbus_message_get_args(message, &error, DBUS_TYPE_BOOLEAN, &state, DBUS_TYPE_INVALID);
190
191     if (dbus_error_is_set (&error))
192     {
193         fprintf (stderr, "Error parsing GetState reply for %s EntryGroup: %s\n", group->path, error.message);
194         dbus_error_free (&error);
195
196         return avahi_client_set_errno (group->client, AVAHI_ERR_DBUS_ERROR);
197     }
198
199     avahi_client_set_errno (group->client, AVAHI_OK);
200     return state;
201 }
202
203 int
204 avahi_client_errno (AvahiClient *client)
205 {
206     return client->error;
207 }
208
209 AvahiClient*
210 avahi_entry_group_get_client (AvahiEntryGroup *group)
211 {
212     return group->client;
213 }
214
215 int
216 avahi_entry_group_is_empty (AvahiEntryGroup *group)
217 {
218     return AVAHI_OK;
219 }
220
221 int
222 avahi_entry_group_add_service (AvahiEntryGroup *group,
223                                AvahiIfIndex interface,
224                                AvahiProtocol protocol,
225                                const char *name,
226                                const char *type,
227                                const char *domain,
228                                const char *host,
229                                uint16_t port,
230                                AvahiStringList *txt)
231 {
232     DBusMessage *message;
233     DBusMessageIter iter, sub;
234     AvahiStringList *p;
235
236     message = dbus_message_new_method_call (AVAHI_DBUS_NAME, group->path,
237             AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "AddService");
238
239     if (!message)
240     {
241         dbus_message_unref (message);
242         return avahi_client_set_errno (group->client, AVAHI_ERR_DBUS_ERROR);
243     }
244
245     if (!dbus_message_append_args (message, DBUS_TYPE_INT32, &interface, DBUS_TYPE_INT32, &protocol,
246                 DBUS_TYPE_STRING, &name, DBUS_TYPE_STRING, &type, DBUS_TYPE_STRING, &domain,
247                 DBUS_TYPE_STRING, &host, DBUS_TYPE_UINT16, &port, DBUS_TYPE_INVALID))
248     {
249         dbus_message_unref (message);
250         return avahi_client_set_errno (group->client, AVAHI_ERR_DBUS_ERROR);
251     }
252     
253     dbus_message_iter_init_append(message, &iter);
254     dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_BYTE_AS_STRING, &sub);
255
256     /* Assemble the AvahiStringList into an Array of Array of Bytes to send over dbus */
257     for (p = txt; p != NULL; p = p->next) {
258         DBusMessageIter sub2;
259         const guint8 *data = p->text;
260
261         dbus_message_iter_open_container(&sub, DBUS_TYPE_ARRAY, "y", &sub2);
262         dbus_message_iter_append_fixed_array(&sub2, DBUS_TYPE_BYTE, &data, p->size);
263         dbus_message_iter_close_container(&sub, &sub2);
264     }
265
266     dbus_message_iter_close_container(&iter, &sub);
267
268     dbus_connection_send (group->client->bus, message, NULL);
269
270     return avahi_client_set_errno (group->client, AVAHI_OK);
271 }
272
273 /* XXX: debug function */
274 char* avahi_entry_group_path (AvahiEntryGroup *group)
275 {
276     if (group != NULL) return group->path;
277     else return NULL;
278 }