← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/ubuntuone-client/oneiric

« back to all changes in this revision

Viewing changes to libsyncdaemon/syncdaemon-daemon.c

  • Committer: Bazaar Package Importer
  • Author(s): Rodney Dawes
  • Date: 2010-06-08 17:31:18 UTC
  • mto: This revision was merged to the branch mainline in revision 31.
  • Revision ID: james.westby@ubuntu.com-20100608173118-o8s897ll11rtne99
Tags: upstream-1.3.0
Import upstream version 1.3.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
libsyncdaemon/syncdaemon-daemon.c
 
1
/*
 
2
 * Syncdaemon API
 
3
 *
 
4
 * Authors: Rodrigo Moya <rodrigo.moya@canonical.com>
 
5
 *
 
6
 * Copyright 2010 Canonical Ltd.
 
7
 *
 
8
 * This program is free software: you can redistribute it and/or modify it
 
9
 * under the terms of the GNU General Public License version 3, as published
 
10
 * by the Free Software Foundation.
 
11
 *
 
12
 * This program is distributed in the hope that it will be useful, but
 
13
 * WITHOUT ANY WARRANTY; without even the implied warranties of
 
14
 * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
 
15
 * PURPOSE.  See the GNU General Public License for more details.
 
16
 *
 
17
 * You should have received a copy of the GNU General Public License along
 
18
 * with this program.  If not, see <http://www.gnu.org/licenses/>.
 
19
 *
 
20
 */
 
21
 
 
22
#include "config.h"
 
23
#include <string.h>
 
24
#ifdef HAVE_GDBUS
 
25
#include <gio/gio.h>
 
26
#else
 
27
#include <dbus/dbus-glib.h>
 
28
#endif
 
29
#include "syncdaemon-daemon.h"
 
30
#include "syncdaemon-config-interface.h"
 
31
#include "syncdaemon-events-interface.h"
 
32
#include "syncdaemon-filesystem-interface.h"
 
33
#include "syncdaemon-folders-interface.h"
 
34
#include "syncdaemon-publicfiles-interface.h"
 
35
#include "syncdaemon-shares-interface.h"
 
36
#include "syncdaemon-status-interface.h"
 
37
#include "syncdaemon-marshal.h"
 
38
 
 
39
G_DEFINE_TYPE(SyncdaemonDaemon, syncdaemon_daemon, G_TYPE_OBJECT)
 
40
 
 
41
struct _SyncdaemonDaemonPrivate {
 
42
#ifdef HAVE_GDBUS
 
43
        GDBusConnection *bus;
 
44
#else
 
45
        DBusGConnection *bus;
 
46
#endif
 
47
        GObject *dbus_proxy;
 
48
 
 
49
        /* Interfaces */
 
50
        GObject *daemon_interface;
 
51
        GHashTable *subinterfaces;
 
52
 
 
53
        /* Status */
 
54
        gboolean connected;
 
55
        gchar *root_dir;
 
56
};
 
57
 
 
58
/* Signals */
 
59
enum {
 
60
        CONNECTED_SIGNAL,
 
61
        DISCONNECTED_SIGNAL,
 
62
        ERROR_SIGNAL,
 
63
        EVENT_SIGNAL,
 
64
        GOT_METADATA_SIGNAL,
 
65
        FOLDER_CREATED_SIGNAL,
 
66
        FOLDER_DELETED_SIGNAL,
 
67
        FOLDER_SUBSCRIBED_SIGNAL,
 
68
        FOLDER_UNSUBSCRIBED_SIGNAL,
 
69
        SHARE_CREATED_SIGNAL,
 
70
        SHARE_DELETED_SIGNAL,
 
71
        DOWNLOAD_STARTED_SIGNAL,
 
72
        DOWNLOAD_FINISHED_SIGNAL,
 
73
        UPLOAD_STARTED_SIGNAL,
 
74
        UPLOAD_FINISHED_SIGNAL,
 
75
        LAST_SIGNAL
 
76
};
 
77
 
 
78
static guint daemon_signals[LAST_SIGNAL] = { 0, };
 
79
 
 
80
static void
 
81
syncdaemon_daemon_finalize (GObject *object)
 
82
{
 
83
        SyncdaemonDaemon *daemon = SYNCDAEMON_DAEMON (object);
 
84
 
 
85
        if (daemon->priv != NULL) {
 
86
                g_hash_table_destroy (daemon->priv->subinterfaces);
 
87
 
 
88
                if (daemon->priv->dbus_proxy != NULL)
 
89
                        g_object_unref (daemon->priv->dbus_proxy);
 
90
 
 
91
                if (daemon->priv->bus != NULL) {
 
92
#ifdef HAVE_GDBUS
 
93
                        g_object_unref (G_OBJECT (daemon->priv->bus));
 
94
#else
 
95
                        dbus_g_connection_unref (daemon->priv->bus);
 
96
#endif
 
97
                }
 
98
 
 
99
                if (daemon->priv->root_dir != NULL)
 
100
                        g_free (daemon->priv->root_dir);
 
101
                        
 
102
                g_free (daemon->priv);
 
103
        }
 
104
 
 
105
        G_OBJECT_CLASS (syncdaemon_daemon_parent_class)->finalize (object);
 
106
}
 
107
 
 
108
static void
 
109
syncdaemon_daemon_class_init (SyncdaemonDaemonClass *klass)
 
110
{
 
111
        GObjectClass *object_class = G_OBJECT_CLASS (klass);
 
112
 
 
113
        object_class->finalize = syncdaemon_daemon_finalize;
 
114
 
 
115
        /* Register signals */
 
116
        daemon_signals[CONNECTED_SIGNAL] = g_signal_new ("connected",
 
117
                                                         G_TYPE_FROM_CLASS (klass),
 
118
                                                         (GSignalFlags) G_SIGNAL_RUN_LAST,
 
119
                                                         G_STRUCT_OFFSET (SyncdaemonDaemonClass, connected),
 
120
                                                         NULL, NULL,
 
121
                                                         g_cclosure_marshal_VOID__VOID,
 
122
                                                         G_TYPE_NONE, 0);
 
123
        daemon_signals[DISCONNECTED_SIGNAL] = g_signal_new ("disconnected",
 
124
                                                            G_TYPE_FROM_CLASS (klass),
 
125
                                                            (GSignalFlags) G_SIGNAL_RUN_LAST,
 
126
                                                            G_STRUCT_OFFSET (SyncdaemonDaemonClass, disconnected),
 
127
                                                            NULL, NULL,
 
128
                                                            g_cclosure_marshal_VOID__VOID,
 
129
                                                            G_TYPE_NONE, 0);
 
130
        daemon_signals[EVENT_SIGNAL] = g_signal_new ("event",
 
131
                                                     G_TYPE_FROM_CLASS (klass),
 
132
                                                     (GSignalFlags) G_SIGNAL_RUN_LAST,
 
133
                                                     G_STRUCT_OFFSET (SyncdaemonDaemonClass, event),
 
134
                                                     NULL, NULL,
 
135
                                                     g_cclosure_marshal_VOID__POINTER,
 
136
                                                     G_TYPE_NONE, 1,
 
137
                                                     G_TYPE_POINTER);
 
138
        daemon_signals[ERROR_SIGNAL] = g_signal_new ("error",
 
139
                                                     G_TYPE_FROM_CLASS (klass),
 
140
                                                     (GSignalFlags) G_SIGNAL_RUN_LAST,
 
141
                                                     G_STRUCT_OFFSET (SyncdaemonDaemonClass, error),
 
142
                                                     NULL, NULL,
 
143
                                                     _syncdaemon_marshal_VOID__STRING_POINTER,
 
144
                                                     G_TYPE_NONE, 2,
 
145
                                                     G_TYPE_STRING, G_TYPE_POINTER);
 
146
        daemon_signals[GOT_METADATA_SIGNAL] = g_signal_new ("got_metadata",
 
147
                                                            G_TYPE_FROM_CLASS (klass),
 
148
                                                            (GSignalFlags) G_SIGNAL_RUN_LAST,
 
149
                                                            G_STRUCT_OFFSET (SyncdaemonDaemonClass, got_metadata),
 
150
                                                            NULL, NULL,
 
151
                                                            _syncdaemon_marshal_VOID__STRING_POINTER,
 
152
                                                            G_TYPE_NONE, 2,
 
153
                                                            G_TYPE_STRING, G_TYPE_POINTER);
 
154
        daemon_signals[FOLDER_CREATED_SIGNAL] = g_signal_new ("folder_created",
 
155
                                                              G_TYPE_FROM_CLASS (klass),
 
156
                                                              (GSignalFlags) G_SIGNAL_RUN_LAST,
 
157
                                                              G_STRUCT_OFFSET (SyncdaemonDaemonClass, folder_created),
 
158
                                                              NULL, NULL,
 
159
                                                              g_cclosure_marshal_VOID__POINTER,
 
160
                                                              G_TYPE_NONE, 1,
 
161
                                                              G_TYPE_POINTER);
 
162
        daemon_signals[FOLDER_DELETED_SIGNAL] = g_signal_new ("folder_deleted",
 
163
                                                              G_TYPE_FROM_CLASS (klass),
 
164
                                                              (GSignalFlags) G_SIGNAL_RUN_LAST,
 
165
                                                              G_STRUCT_OFFSET (SyncdaemonDaemonClass, folder_deleted),
 
166
                                                              NULL, NULL,
 
167
                                                              g_cclosure_marshal_VOID__POINTER,
 
168
                                                              G_TYPE_NONE, 1,
 
169
                                                              G_TYPE_POINTER);
 
170
        daemon_signals[FOLDER_SUBSCRIBED_SIGNAL] = g_signal_new ("folder_subscribed",
 
171
                                                                 G_TYPE_FROM_CLASS (klass),
 
172
                                                                 (GSignalFlags) G_SIGNAL_RUN_LAST,
 
173
                                                                 G_STRUCT_OFFSET (SyncdaemonDaemonClass, folder_subscribed),
 
174
                                                                 NULL, NULL,
 
175
                                                                 g_cclosure_marshal_VOID__POINTER,
 
176
                                                                 G_TYPE_NONE, 1,
 
177
                                                                 G_TYPE_POINTER);
 
178
        daemon_signals[FOLDER_UNSUBSCRIBED_SIGNAL] = g_signal_new ("folder_unsubscribed",
 
179
                                                                   G_TYPE_FROM_CLASS (klass),
 
180
                                                                   (GSignalFlags) G_SIGNAL_RUN_LAST,
 
181
                                                                   G_STRUCT_OFFSET (SyncdaemonDaemonClass, folder_unsubscribed),
 
182
                                                                   NULL, NULL,
 
183
                                                                   g_cclosure_marshal_VOID__POINTER,
 
184
                                                                   G_TYPE_NONE, 1,
 
185
                                                                   G_TYPE_POINTER);
 
186
        daemon_signals[SHARE_CREATED_SIGNAL] = g_signal_new ("share_created",
 
187
                                                             G_TYPE_FROM_CLASS (klass),
 
188
                                                             (GSignalFlags) G_SIGNAL_RUN_LAST,
 
189
                                                             G_STRUCT_OFFSET (SyncdaemonDaemonClass, share_created),
 
190
                                                             NULL, NULL,
 
191
                                                             g_cclosure_marshal_VOID__POINTER,
 
192
                                                             G_TYPE_NONE, 1,
 
193
                                                             G_TYPE_POINTER);
 
194
        daemon_signals[SHARE_DELETED_SIGNAL] = g_signal_new ("share_deleted",
 
195
                                                             G_TYPE_FROM_CLASS (klass),
 
196
                                                             (GSignalFlags) G_SIGNAL_RUN_LAST,
 
197
                                                             G_STRUCT_OFFSET (SyncdaemonDaemonClass, share_deleted),
 
198
                                                             NULL, NULL,
 
199
                                                             g_cclosure_marshal_VOID__POINTER,
 
200
                                                             G_TYPE_NONE, 1,
 
201
                                                             G_TYPE_POINTER);
 
202
        daemon_signals[DOWNLOAD_STARTED_SIGNAL] = g_signal_new ("download_started",
 
203
                                                                G_TYPE_FROM_CLASS (klass),
 
204
                                                                (GSignalFlags) G_SIGNAL_RUN_LAST,
 
205
                                                                G_STRUCT_OFFSET (SyncdaemonDaemonClass, download_started),
 
206
                                                                NULL, NULL,
 
207
                                                                g_cclosure_marshal_VOID__STRING,
 
208
                                                                G_TYPE_NONE, 1,
 
209
                                                                G_TYPE_STRING);
 
210
        daemon_signals[DOWNLOAD_FINISHED_SIGNAL] = g_signal_new ("download_finished",
 
211
                                                                 G_TYPE_FROM_CLASS (klass),
 
212
                                                                 (GSignalFlags) G_SIGNAL_RUN_LAST,
 
213
                                                                 G_STRUCT_OFFSET (SyncdaemonDaemonClass, download_finished),
 
214
                                                                 NULL, NULL,
 
215
                                                                 _syncdaemon_marshal_VOID__STRING_POINTER,
 
216
                                                                 G_TYPE_NONE, 2,
 
217
                                                                 G_TYPE_STRING, G_TYPE_POINTER);
 
218
        daemon_signals[UPLOAD_STARTED_SIGNAL] = g_signal_new ("upload_started",
 
219
                                                              G_TYPE_FROM_CLASS (klass),
 
220
                                                              (GSignalFlags) G_SIGNAL_RUN_LAST,
 
221
                                                              G_STRUCT_OFFSET (SyncdaemonDaemonClass, upload_started),
 
222
                                                              NULL, NULL,
 
223
                                                              g_cclosure_marshal_VOID__STRING,
 
224
                                                              G_TYPE_NONE, 1,
 
225
                                                              G_TYPE_STRING);
 
226
        daemon_signals[UPLOAD_FINISHED_SIGNAL] = g_signal_new ("upload_finished",
 
227
                                                               G_TYPE_FROM_CLASS (klass),
 
228
                                                               (GSignalFlags) G_SIGNAL_RUN_LAST,
 
229
                                                               G_STRUCT_OFFSET (SyncdaemonDaemonClass, upload_finished),
 
230
                                                               NULL, NULL,
 
231
                                                               _syncdaemon_marshal_VOID__STRING_POINTER,
 
232
                                                               G_TYPE_NONE, 2,
 
233
                                                               G_TYPE_STRING, G_TYPE_POINTER);
 
234
}
 
235
 
 
236
static void
 
237
setup_daemon_interface (SyncdaemonDaemon *daemon)
 
238
{
 
239
        daemon->priv->daemon_interface = g_object_new (SYNCDAEMON_TYPE_INTERFACE,
 
240
                                                       "daemon", daemon,
 
241
                                                       NULL);
 
242
        syncdaemon_interface_setup_proxy (SYNCDAEMON_INTERFACE (daemon->priv->daemon_interface),
 
243
                                          "com.ubuntuone.Syncdaemon", "/",
 
244
                                          "com.ubuntuone.Syncdaemon.SyncDaemon");
 
245
}
 
246
 
 
247
static void
 
248
name_owner_changed_cb (DBusGProxy *proxy,
 
249
                       const char *name,
 
250
                       const char *old_owner,
 
251
                       const char *new_owner,
 
252
                       gpointer user_data)
 
253
{
 
254
        SyncdaemonDaemon *daemon = SYNCDAEMON_DAEMON (user_data);
 
255
 
 
256
        if (g_strcmp0 (name, "com.ubuntuone.Syncdaemon") == 0) {
 
257
                if (new_owner != NULL && strlen (new_owner) > 0) {
 
258
                        setup_daemon_interface (daemon);
 
259
                } else {
 
260
                        g_debug ("Syncdaemon service died");
 
261
                        if (daemon->priv->daemon_interface != NULL) {
 
262
                                g_object_unref (daemon->priv->daemon_interface);
 
263
                                daemon->priv->daemon_interface = NULL;
 
264
                        }
 
265
 
 
266
                        g_hash_table_remove_all (daemon->priv->subinterfaces);
 
267
                        daemon->priv->connected = FALSE;
 
268
                }
 
269
        }
 
270
}
 
271
 
 
272
static void
 
273
syncdaemon_daemon_init (SyncdaemonDaemon *daemon)
 
274
{
 
275
        GError *error = NULL;
 
276
 
 
277
        daemon->priv = g_new0 (SyncdaemonDaemonPrivate, 1);
 
278
 
 
279
        daemon->priv->connected = FALSE;
 
280
        daemon->priv->subinterfaces = g_hash_table_new_full (g_str_hash, g_str_equal,
 
281
                                                             g_free, g_object_unref);
 
282
 
 
283
        /* Initialize DBus */
 
284
#ifdef HAVE_GDBUS
 
285
        daemon->priv->bus = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error);
 
286
#else
 
287
        daemon->priv->bus = dbus_g_bus_get (DBUS_BUS_SESSION, &error);
 
288
#endif
 
289
        if (error != NULL) {
 
290
                g_warning ("Couldn't get session bus: %s", error->message);
 
291
                g_error_free (error);
 
292
                return;
 
293
        }
 
294
 
 
295
        /* Listen to DBus for syncdaemon restarts */
 
296
        daemon->priv->dbus_proxy = (GObject *) dbus_g_proxy_new_for_name (daemon->priv->bus,
 
297
                                                                          "org.freedesktop.DBus",
 
298
                                                                          "/org/freedesktop/DBus",
 
299
                                                                          "org.freedesktop.DBus");
 
300
        dbus_g_proxy_add_signal (DBUS_G_PROXY (daemon->priv->dbus_proxy), "NameOwnerChanged",
 
301
                                 G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
 
302
                                 G_TYPE_INVALID);
 
303
        dbus_g_proxy_connect_signal (DBUS_G_PROXY (daemon->priv->dbus_proxy),
 
304
                                     "NameOwnerChanged",
 
305
                                     G_CALLBACK (name_owner_changed_cb),
 
306
                                     daemon, NULL);
 
307
 
 
308
        /* Get the main interface */
 
309
        setup_daemon_interface (daemon);
 
310
}
 
311
 
 
312
/**
 
313
 * syncdaemon_daemon_new:
 
314
 *
 
315
 * Create a new #SyncdaemonDaemon object, which provides access to the
 
316
 * Syncdaemon daemon.
 
317
 *
 
318
 * Return value: A new #SyncdaemonDaemon object.
 
319
 */
 
320
SyncdaemonDaemon *
 
321
syncdaemon_daemon_new (void)
 
322
{
 
323
        return g_object_new (SYNCDAEMON_TYPE_DAEMON, NULL);
 
324
}
 
325
 
 
326
static void
 
327
connect_response_cb (DBusGProxy *proxy, DBusGProxyCall *call_id, gpointer user_data)
 
328
{
 
329
        GError *error = NULL;
 
330
        SyncdaemonDaemon *daemon = (SyncdaemonDaemon *) user_data;
 
331
 
 
332
        if (dbus_g_proxy_end_call (proxy, call_id, &error, G_TYPE_INVALID)) {
 
333
                daemon->priv->connected = TRUE;
 
334
                g_signal_emit (daemon, daemon_signals[CONNECTED_SIGNAL], 0);
 
335
        } else {
 
336
                g_warning ("Syncdaemon cannot connect: %s", error->message);
 
337
                g_error_free (error);
 
338
        }
 
339
}
 
340
 
 
341
/**
 
342
 * syncdaemon_daemon_connect:
 
343
 */
 
344
gboolean
 
345
syncdaemon_daemon_connect (SyncdaemonDaemon *daemon)
 
346
{
 
347
        GObject *proxy;
 
348
 
 
349
        g_return_val_if_fail (SYNCDAEMON_IS_DAEMON (daemon), FALSE);
 
350
 
 
351
        proxy = syncdaemon_interface_get_proxy_object (SYNCDAEMON_INTERFACE (daemon->priv->daemon_interface));
 
352
        if (proxy != NULL) {
 
353
#ifdef HAVE_GDBUS
 
354
#else
 
355
                if (!dbus_g_proxy_begin_call (DBUS_G_PROXY (proxy), "connect",
 
356
                                              connect_response_cb, daemon, NULL,
 
357
                                              G_TYPE_INVALID)) {
 
358
                        g_warning ("Call to 'connect' method failed");
 
359
 
 
360
                        return FALSE;
 
361
                }
 
362
#endif
 
363
        }
 
364
 
 
365
        return TRUE;
 
366
}
 
367
 
 
368
static void
 
369
disconnect_response_cb (DBusGProxy *proxy, DBusGProxyCall *call_id, gpointer user_data)
 
370
{
 
371
        GError *error = NULL;
 
372
        SyncdaemonDaemon *daemon = (SyncdaemonDaemon *) user_data;
 
373
 
 
374
        if (dbus_g_proxy_end_call (proxy, call_id, &error, G_TYPE_INVALID)) {
 
375
                daemon->priv->connected = FALSE;
 
376
                g_signal_emit (daemon, daemon_signals[DISCONNECTED_SIGNAL], 0);
 
377
        } else {
 
378
                g_warning ("Syncdaemon cannot disconnect: %s", error->message);
 
379
                g_error_free (error);
 
380
        }
 
381
}
 
382
 
 
383
/**
 
384
 * syncdaemon_daemon_interface_disconnect:
 
385
 */
 
386
gboolean
 
387
syncdaemon_daemon_disconnect (SyncdaemonDaemon *daemon)
 
388
{
 
389
        GObject *proxy;
 
390
 
 
391
        g_return_val_if_fail (SYNCDAEMON_IS_DAEMON (daemon), FALSE);
 
392
 
 
393
        proxy = syncdaemon_interface_get_proxy_object (SYNCDAEMON_INTERFACE (daemon->priv->daemon_interface));
 
394
        if (proxy != NULL) {
 
395
#ifdef HAVE_GDBUS
 
396
#else
 
397
                if (!dbus_g_proxy_begin_call (DBUS_G_PROXY (proxy), "disconnect",
 
398
                                              disconnect_response_cb, daemon, NULL,
 
399
                                              G_TYPE_INVALID)) {
 
400
                        g_warning ("Call to 'disconnect' method failed");
 
401
 
 
402
                        return FALSE;
 
403
                }
 
404
#endif
 
405
        }
 
406
 
 
407
        return TRUE;
 
408
}
 
409
 
 
410
/**
 
411
 * syncdaemon_daemon_interface_quit:
 
412
 */
 
413
gboolean
 
414
syncdaemon_daemon_quit (SyncdaemonDaemon *daemon)
 
415
{
 
416
        GObject *proxy;
 
417
 
 
418
        g_return_val_if_fail (SYNCDAEMON_IS_DAEMON (daemon), FALSE);
 
419
 
 
420
        proxy = syncdaemon_interface_get_proxy_object (SYNCDAEMON_INTERFACE (daemon->priv->daemon_interface));
 
421
        if (proxy != NULL) {
 
422
                GError *error = NULL;
 
423
 
 
424
#ifdef HAVE_GDBUS
 
425
#else
 
426
                if (!dbus_g_proxy_call (DBUS_G_PROXY (proxy), "quit", &error,
 
427
                                        G_TYPE_INVALID,
 
428
                                        G_TYPE_INVALID)) {
 
429
                        g_warning ("Could not quit syncdaemon: %s", error->message);
 
430
                        g_error_free (error);
 
431
 
 
432
                        return FALSE;
 
433
                }
 
434
#endif
 
435
        }
 
436
 
 
437
        return TRUE;
 
438
}
 
439
 
 
440
/**
 
441
 * syncdaemon_daemon_get_root_dir:
 
442
 */
 
443
const gchar *
 
444
syncdaemon_daemon_get_root_dir (SyncdaemonDaemon *daemon)
 
445
{
 
446
        GObject *proxy;
 
447
 
 
448
        g_return_val_if_fail (SYNCDAEMON_IS_DAEMON (daemon), NULL);
 
449
 
 
450
        if (daemon->priv->root_dir != NULL)
 
451
                return (const gchar *) daemon->priv->root_dir;
 
452
 
 
453
        proxy = syncdaemon_interface_get_proxy_object (SYNCDAEMON_INTERFACE (daemon->priv->daemon_interface));
 
454
        if (proxy != NULL) {
 
455
                gchar *new_root_dir;
 
456
                GError *error = NULL;
 
457
 
 
458
#ifdef HAVE_GDBUS
 
459
#else
 
460
                if (!dbus_g_proxy_call (DBUS_G_PROXY (proxy), "get_root_dir", &error,
 
461
                                        G_TYPE_INVALID,
 
462
                                        G_TYPE_STRING, &new_root_dir,
 
463
                                        G_TYPE_INVALID)) {
 
464
                        g_warning ("Could not get syncdaemon's root dir: %s", error->message);
 
465
                        g_error_free (error);
 
466
 
 
467
                        return NULL;
 
468
                }
 
469
#endif
 
470
 
 
471
                daemon->priv->root_dir = new_root_dir;
 
472
        }
 
473
 
 
474
        return NULL;
 
475
}
 
476
 
 
477
static SyncdaemonInterface *
 
478
get_interface (SyncdaemonDaemon *daemon, const gchar *path, SyncdaemonInterface * (* new_func) (SyncdaemonDaemon *daemon))
 
479
{
 
480
        SyncdaemonInterface *interface;
 
481
 
 
482
        interface = g_hash_table_lookup (daemon->priv->subinterfaces, path);
 
483
        if (interface == NULL) {
 
484
                interface = new_func (daemon);
 
485
                if (SYNCDAEMON_IS_INTERFACE (interface))
 
486
                        g_hash_table_insert (daemon->priv->subinterfaces, g_strdup (path), interface);
 
487
        }
 
488
 
 
489
        return interface;
 
490
}
 
491
 
 
492
/**
 
493
 * syncdaemon_daemon_get_config_interface:
 
494
 */
 
495
SyncdaemonInterface *
 
496
syncdaemon_daemon_get_config_interface (SyncdaemonDaemon *daemon)
 
497
{
 
498
        g_return_val_if_fail (SYNCDAEMON_IS_DAEMON (daemon), NULL);
 
499
 
 
500
        return get_interface (daemon, "/config", syncdaemon_config_interface_new);
 
501
}
 
502
 
 
503
/**
 
504
 * syncdaemon_daemon_get_events_interface:
 
505
 */
 
506
SyncdaemonInterface *
 
507
syncdaemon_daemon_get_events_interface (SyncdaemonDaemon *daemon)
 
508
{
 
509
        g_return_val_if_fail (SYNCDAEMON_IS_DAEMON (daemon), NULL);
 
510
 
 
511
        return get_interface (daemon, "/events", syncdaemon_events_interface_new);
 
512
}
 
513
 
 
514
/**
 
515
 * syncdaemon_daemon_get_filesystem_interface:
 
516
 */
 
517
SyncdaemonInterface *
 
518
syncdaemon_daemon_get_filesystem_interface (SyncdaemonDaemon *daemon)
 
519
{
 
520
        g_return_val_if_fail (SYNCDAEMON_IS_DAEMON (daemon), NULL);
 
521
 
 
522
        return get_interface (daemon, "/filesystem", syncdaemon_filesystem_interface_new);
 
523
}
 
524
 
 
525
/**
 
526
 * syncdaemon_daemon_get_folders_interface:
 
527
 */
 
528
SyncdaemonInterface *
 
529
syncdaemon_daemon_get_folders_interface (SyncdaemonDaemon *daemon)
 
530
{
 
531
        g_return_val_if_fail (SYNCDAEMON_IS_DAEMON (daemon), NULL);
 
532
 
 
533
        return get_interface (daemon, "/folders", syncdaemon_folders_interface_new);
 
534
}
 
535
 
 
536
/**
 
537
 * syncdaemon_daemon_get_publicfiles_interface:
 
538
 */
 
539
SyncdaemonInterface *
 
540
syncdaemon_daemon_get_publicfiles_interface (SyncdaemonDaemon *daemon)
 
541
{
 
542
        g_return_val_if_fail (SYNCDAEMON_IS_DAEMON (daemon), NULL);
 
543
 
 
544
        return get_interface (daemon, "/publicfiles", syncdaemon_publicfiles_interface_new);
 
545
}
 
546
 
 
547
/**
 
548
 * syncdaemon_daemon_get_shares_interface:
 
549
 */
 
550
SyncdaemonInterface *
 
551
syncdaemon_daemon_get_shares_interface (SyncdaemonDaemon *daemon)
 
552
{
 
553
        g_return_val_if_fail (SYNCDAEMON_IS_DAEMON (daemon), NULL);
 
554
 
 
555
        return get_interface (daemon, "/shares", syncdaemon_shares_interface_new);
 
556
}
 
557
 
 
558
/**
 
559
 * syncdaemon_daemon_get_status_interface:
 
560
 */
 
561
SyncdaemonInterface *
 
562
syncdaemon_daemon_get_status_interface (SyncdaemonDaemon *daemon)
 
563
{
 
564
        g_return_val_if_fail (SYNCDAEMON_IS_DAEMON (daemon), NULL);
 
565
 
 
566
        return get_interface (daemon, "/status", syncdaemon_status_interface_new);
 
567
}