~ubuntuone-control-tower/ubuntuone-client/trunk
» Revision
1404
(compared to revision 1378)
: libsyncdaemon/syncdaemon-daemon.c
« back to all changes in this revision
Viewing changes to libsyncdaemon/syncdaemon-daemon.c
- browse files at revision 1404
- compare with another revision
- download diff
- download tarball
- view history from revision 1404
- Committer: Tarmac
- Author(s): Diego Sarmentero, Rodney Dawes
- Date: 2014-04-11 14:23:37 UTC
- mfrom: (1403.1.8 ubuntuone-client)
- Revision ID: tarmac-20140411142337-vg6lk4a6a5au0jag
- Show a message when the client is started indicating that the service will be suspended on June 1st.
- After June 1st, don't contact the server.
- After June 1st, don't contact the server.
- files added:
- setup.cfg
- files removed:
- COPYING.icons
- docs/reference
- libsyncdaemon
- tests/platform/event_logging
- tests/platform/linux/eventlog
- ubuntuone/eventlog
- ubuntuone/platform/event_logging
- windows
- files renamed:
- tests/platform/check_reactor_import.py => contrib/check-reactor-import *
- ubuntuone/syncdaemon/fsm/fsm_draw.py => contrib/draw-fsm *
- run-mac-tests => run-tests
- files modified:
- .bzrignore
added
removed
libsyncdaemon/syncdaemon-daemon.c
1
/*
2
* Syncdaemon API
3
*
4
* Authors: Rodrigo Moya <rodrigo.moya@canonical.com>
5
*
6
* Copyright 2010-2012 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
* In addition, as a special exception, the copyright holders give
21
* permission to link the code of portions of this program with the
22
* OpenSSL library under certain conditions as described in each
23
* individual source file, and distribute linked combinations
24
* including the two.
25
* You must obey the GNU General Public License in all respects
26
* for all of the code used other than OpenSSL. If you modify
27
* file(s) with this exception, you may extend this exception to your
28
* version of the file(s), but you are not obligated to do so. If you
29
* do not wish to do so, delete this exception statement from your
30
* version. If you delete this exception statement from all source
31
* files in the program, then also delete it here.
32
*
33
*/
34
35
#include "config.h"
36
#include <string.h>
37
#ifdef HAVE_GDBUS
38
#include <gio/gio.h>
39
#else
40
#include <dbus/dbus-glib.h>
41
#include <dbus/dbus-glib-bindings.h>
42
#endif
43
#include "syncdaemon-daemon.h"
44
#include "syncdaemon-config-interface.h"
45
#include "syncdaemon-events-interface.h"
46
#include "syncdaemon-filesystem-interface.h"
47
#include "syncdaemon-folders-interface.h"
48
#include "syncdaemon-publicfiles-interface.h"
49
#include "syncdaemon-shares-interface.h"
50
#include "syncdaemon-status-interface.h"
51
#include "syncdaemon-marshal.h"
52
53
#define SYNCDAEMON_DBUS_NAME "com.ubuntuone.SyncDaemon"
54
55
G_DEFINE_TYPE(SyncdaemonDaemon, syncdaemon_daemon, G_TYPE_OBJECT)
56
57
struct _SyncdaemonDaemonPrivate {
58
#ifdef HAVE_GDBUS
59
GDBusConnection *bus;
60
GDbusProxy *dbus_proxy;
61
#else
62
DBusGConnection *bus;
63
DBusGProxy *dbus_proxy;
64
#endif
65
66
/* Interfaces */
67
GObject *daemon_interface;
68
GHashTable *subinterfaces;
69
70
/* Status */
71
gboolean ready;
72
gboolean connected;
73
gchar *root_dir;
74
SyncdaemonAuthentication *auth;
75
};
76
77
/* Signals */
78
enum {
79
READY_SIGNAL,
80
CONNECTED_SIGNAL,
81
DISCONNECTED_SIGNAL,
82
STATUS_CHANGED_SIGNAL,
83
ERROR_SIGNAL,
84
EVENT_SIGNAL,
85
FOLDER_CREATED_SIGNAL,
86
FOLDER_DELETED_SIGNAL,
87
FOLDER_SUBSCRIBED_SIGNAL,
88
FOLDER_UNSUBSCRIBED_SIGNAL,
89
FILE_PUBLISHED_SIGNAL,
90
FILE_UNPUBLISHED_SIGNAL,
91
SHARE_CREATED_SIGNAL,
92
SHARE_DELETED_SIGNAL,
93
DOWNLOAD_STARTED_SIGNAL,
94
DOWNLOAD_FILE_PROGRESS_SIGNAL,
95
DOWNLOAD_FINISHED_SIGNAL,
96
UPLOAD_STARTED_SIGNAL,
97
UPLOAD_FILE_PROGRESS_SIGNAL,
98
UPLOAD_FINISHED_SIGNAL,
99
QUOTA_EXCEEDED_SIGNAL,
100
LAST_SIGNAL
101
};
102
103
static guint daemon_signals[LAST_SIGNAL] = { 0, };
104
105
static void
106
syncdaemon_daemon_finalize (GObject *object)
107
{
108
SyncdaemonDaemon *daemon = SYNCDAEMON_DAEMON (object);
109
110
if (daemon->priv != NULL) {
111
g_hash_table_destroy (daemon->priv->subinterfaces);
112
113
if (daemon->priv->dbus_proxy != NULL)
114
g_object_unref (daemon->priv->dbus_proxy);
115
116
if (daemon->priv->bus != NULL) {
117
#ifdef HAVE_GDBUS
118
g_object_unref (G_OBJECT (daemon->priv->bus));
119
#else
120
dbus_g_connection_unref (daemon->priv->bus);
121
#endif
122
}
123
124
if (daemon->priv->root_dir != NULL)
125
g_free (daemon->priv->root_dir);
126
127
if (daemon->priv->auth != NULL)
128
g_object_unref (G_OBJECT (daemon->priv->auth));
129
130
g_free (daemon->priv);
131
}
132
133
G_OBJECT_CLASS (syncdaemon_daemon_parent_class)->finalize (object);
134
}
135
136
static void
137
syncdaemon_daemon_class_init (SyncdaemonDaemonClass *klass)
138
{
139
GObjectClass *object_class = G_OBJECT_CLASS (klass);
140
141
object_class->finalize = syncdaemon_daemon_finalize;
142
143
/* Register signals */
144
daemon_signals[READY_SIGNAL] = g_signal_new ("ready",
145
G_TYPE_FROM_CLASS (klass),
146
(GSignalFlags) G_SIGNAL_RUN_LAST,
147
G_STRUCT_OFFSET (SyncdaemonDaemonClass, ready),
148
NULL, NULL,
149
g_cclosure_marshal_VOID__VOID,
150
G_TYPE_NONE, 0);
151
daemon_signals[CONNECTED_SIGNAL] = g_signal_new ("connected",
152
G_TYPE_FROM_CLASS (klass),
153
(GSignalFlags) G_SIGNAL_RUN_LAST,
154
G_STRUCT_OFFSET (SyncdaemonDaemonClass, connected),
155
NULL, NULL,
156
g_cclosure_marshal_VOID__VOID,
157
G_TYPE_NONE, 0);
158
daemon_signals[DISCONNECTED_SIGNAL] = g_signal_new ("disconnected",
159
G_TYPE_FROM_CLASS (klass),
160
(GSignalFlags) G_SIGNAL_RUN_LAST,
161
G_STRUCT_OFFSET (SyncdaemonDaemonClass, disconnected),
162
NULL, NULL,
163
g_cclosure_marshal_VOID__VOID,
164
G_TYPE_NONE, 0);
165
daemon_signals[STATUS_CHANGED_SIGNAL] = g_signal_new ("status_changed",
166
G_TYPE_FROM_CLASS (klass),
167
(GSignalFlags) G_SIGNAL_RUN_LAST,
168
G_STRUCT_OFFSET (SyncdaemonDaemonClass, status_changed),
169
NULL, NULL,
170
g_cclosure_marshal_VOID__OBJECT,
171
G_TYPE_NONE, 1,
172
G_TYPE_OBJECT);
173
daemon_signals[EVENT_SIGNAL] = g_signal_new ("event",
174
G_TYPE_FROM_CLASS (klass),
175
(GSignalFlags) G_SIGNAL_RUN_LAST,
176
G_STRUCT_OFFSET (SyncdaemonDaemonClass, event),
177
NULL, NULL,
178
g_cclosure_marshal_VOID__POINTER,
179
G_TYPE_NONE, 1,
180
G_TYPE_POINTER);
181
daemon_signals[ERROR_SIGNAL] = g_signal_new ("error",
182
G_TYPE_FROM_CLASS (klass),
183
(GSignalFlags) G_SIGNAL_RUN_LAST,
184
G_STRUCT_OFFSET (SyncdaemonDaemonClass, error),
185
NULL, NULL,
186
_syncdaemon_marshal_VOID__STRING_POINTER,
187
G_TYPE_NONE, 2,
188
G_TYPE_STRING, G_TYPE_POINTER);
189
daemon_signals[FOLDER_CREATED_SIGNAL] = g_signal_new ("folder_created",
190
G_TYPE_FROM_CLASS (klass),
191
(GSignalFlags) G_SIGNAL_RUN_LAST,
192
G_STRUCT_OFFSET (SyncdaemonDaemonClass, folder_created),
193
NULL, NULL,
194
_syncdaemon_marshal_VOID__BOOLEAN_OBJECT,
195
G_TYPE_NONE, 2,
196
G_TYPE_BOOLEAN,
197
G_TYPE_OBJECT);
198
daemon_signals[FOLDER_DELETED_SIGNAL] = g_signal_new ("folder_deleted",
199
G_TYPE_FROM_CLASS (klass),
200
(GSignalFlags) G_SIGNAL_RUN_LAST,
201
G_STRUCT_OFFSET (SyncdaemonDaemonClass, folder_deleted),
202
NULL, NULL,
203
_syncdaemon_marshal_VOID__BOOLEAN_OBJECT,
204
G_TYPE_NONE, 2,
205
G_TYPE_BOOLEAN,
206
G_TYPE_OBJECT);
207
daemon_signals[FOLDER_SUBSCRIBED_SIGNAL] = g_signal_new ("folder_subscribed",
208
G_TYPE_FROM_CLASS (klass),
209
(GSignalFlags) G_SIGNAL_RUN_LAST,
210
G_STRUCT_OFFSET (SyncdaemonDaemonClass, folder_subscribed),
211
NULL, NULL,
212
_syncdaemon_marshal_VOID__BOOLEAN_OBJECT,
213
G_TYPE_NONE, 2,
214
G_TYPE_BOOLEAN,
215
G_TYPE_OBJECT);
216
daemon_signals[FOLDER_UNSUBSCRIBED_SIGNAL] = g_signal_new ("folder_unsubscribed",
217
G_TYPE_FROM_CLASS (klass),
218
(GSignalFlags) G_SIGNAL_RUN_LAST,
219
G_STRUCT_OFFSET (SyncdaemonDaemonClass, folder_unsubscribed),
220
NULL, NULL,
221
_syncdaemon_marshal_VOID__BOOLEAN_OBJECT,
222
G_TYPE_NONE, 2,
223
G_TYPE_BOOLEAN,
224
G_TYPE_OBJECT);
225
daemon_signals[FILE_PUBLISHED_SIGNAL] = g_signal_new ("file_published",
226
G_TYPE_FROM_CLASS (klass),
227
(GSignalFlags) G_SIGNAL_RUN_LAST,
228
G_STRUCT_OFFSET (SyncdaemonDaemonClass, file_published),
229
NULL, NULL,
230
_syncdaemon_marshal_VOID__BOOLEAN_OBJECT,
231
G_TYPE_NONE, 2,
232
G_TYPE_BOOLEAN,
233
G_TYPE_OBJECT);
234
daemon_signals[FILE_UNPUBLISHED_SIGNAL] = g_signal_new ("file_unpublished",
235
G_TYPE_FROM_CLASS (klass),
236
(GSignalFlags) G_SIGNAL_RUN_LAST,
237
G_STRUCT_OFFSET (SyncdaemonDaemonClass, file_unpublished),
238
NULL, NULL,
239
_syncdaemon_marshal_VOID__BOOLEAN_OBJECT,
240
G_TYPE_NONE, 2,
241
G_TYPE_BOOLEAN,
242
G_TYPE_OBJECT);
243
daemon_signals[SHARE_CREATED_SIGNAL] = g_signal_new ("share_created",
244
G_TYPE_FROM_CLASS (klass),
245
(GSignalFlags) G_SIGNAL_RUN_LAST,
246
G_STRUCT_OFFSET (SyncdaemonDaemonClass, share_created),
247
NULL, NULL,
248
_syncdaemon_marshal_VOID__BOOLEAN_OBJECT,
249
G_TYPE_NONE, 2,
250
G_TYPE_BOOLEAN,
251
G_TYPE_OBJECT);
252
daemon_signals[SHARE_DELETED_SIGNAL] = g_signal_new ("share_deleted",
253
G_TYPE_FROM_CLASS (klass),
254
(GSignalFlags) G_SIGNAL_RUN_LAST,
255
G_STRUCT_OFFSET (SyncdaemonDaemonClass, share_deleted),
256
NULL, NULL,
257
_syncdaemon_marshal_VOID__BOOLEAN_OBJECT,
258
G_TYPE_NONE, 2,
259
G_TYPE_BOOLEAN,
260
G_TYPE_OBJECT);
261
daemon_signals[DOWNLOAD_STARTED_SIGNAL] = g_signal_new ("download_started",
262
G_TYPE_FROM_CLASS (klass),
263
(GSignalFlags) G_SIGNAL_RUN_LAST,
264
G_STRUCT_OFFSET (SyncdaemonDaemonClass, download_started),
265
NULL, NULL,
266
g_cclosure_marshal_VOID__STRING,
267
G_TYPE_NONE, 1,
268
G_TYPE_STRING);
269
daemon_signals[DOWNLOAD_FILE_PROGRESS_SIGNAL] = g_signal_new ("download_file_progress",
270
G_TYPE_FROM_CLASS (klass),
271
(GSignalFlags) G_SIGNAL_RUN_LAST,
272
G_STRUCT_OFFSET (SyncdaemonDaemonClass, download_file_progress),
273
NULL, NULL,
274
_syncdaemon_marshal_VOID__STRING_OBJECT,
275
G_TYPE_NONE, 2,
276
G_TYPE_STRING, G_TYPE_OBJECT);
277
daemon_signals[DOWNLOAD_FINISHED_SIGNAL] = g_signal_new ("download_finished",
278
G_TYPE_FROM_CLASS (klass),
279
(GSignalFlags) G_SIGNAL_RUN_LAST,
280
G_STRUCT_OFFSET (SyncdaemonDaemonClass, download_finished),
281
NULL, NULL,
282
_syncdaemon_marshal_VOID__STRING_OBJECT,
283
G_TYPE_NONE, 2,
284
G_TYPE_STRING, G_TYPE_OBJECT);
285
daemon_signals[UPLOAD_STARTED_SIGNAL] = g_signal_new ("upload_started",
286
G_TYPE_FROM_CLASS (klass),
287
(GSignalFlags) G_SIGNAL_RUN_LAST,
288
G_STRUCT_OFFSET (SyncdaemonDaemonClass, upload_started),
289
NULL, NULL,
290
g_cclosure_marshal_VOID__STRING,
291
G_TYPE_NONE, 1,
292
G_TYPE_STRING);
293
daemon_signals[UPLOAD_FILE_PROGRESS_SIGNAL] = g_signal_new ("upload_file_progress",
294
G_TYPE_FROM_CLASS (klass),
295
(GSignalFlags) G_SIGNAL_RUN_LAST,
296
G_STRUCT_OFFSET (SyncdaemonDaemonClass, upload_file_progress),
297
NULL, NULL,
298
_syncdaemon_marshal_VOID__STRING_OBJECT,
299
G_TYPE_NONE, 2,
300
G_TYPE_STRING, G_TYPE_OBJECT);
301
daemon_signals[UPLOAD_FINISHED_SIGNAL] = g_signal_new ("upload_finished",
302
G_TYPE_FROM_CLASS (klass),
303
(GSignalFlags) G_SIGNAL_RUN_LAST,
304
G_STRUCT_OFFSET (SyncdaemonDaemonClass, upload_finished),
305
NULL, NULL,
306
_syncdaemon_marshal_VOID__STRING_OBJECT,
307
G_TYPE_NONE, 2,
308
G_TYPE_STRING, G_TYPE_OBJECT);
309
daemon_signals[QUOTA_EXCEEDED_SIGNAL] = g_signal_new ("quota_exceeded",
310
G_TYPE_FROM_CLASS (klass),
311
(GSignalFlags) G_SIGNAL_RUN_LAST,
312
G_STRUCT_OFFSET (SyncdaemonDaemonClass, quota_exceeded),
313
NULL, NULL,
314
g_cclosure_marshal_VOID__POINTER,
315
G_TYPE_NONE, 1,
316
G_TYPE_POINTER);
317
}
318
319
static void
320
quota_exceeded_cb (DBusGProxy *proxy, GHashTable *volume_info, gpointer user_data)
321
{
322
SyncdaemonDaemon *daemon = SYNCDAEMON_DAEMON (user_data);
323
324
if (daemon != NULL)
325
g_signal_emit_by_name (daemon, "quota_exceeded", volume_info);
326
}
327
328
static gboolean
329
ready_signal_idle_cb (gpointer user_data)
330
{
331
SyncdaemonDaemon *daemon = SYNCDAEMON_DAEMON (user_data);
332
333
g_signal_emit (daemon, daemon_signals[READY_SIGNAL], 0);
334
335
return FALSE;
336
}
337
338
static void
339
setup_daemon_interface (SyncdaemonDaemon *daemon)
340
{
341
GObject *proxy = NULL;
342
343
if (daemon->priv->daemon_interface != NULL)
344
g_object_unref (daemon->priv->daemon_interface);
345
daemon->priv->daemon_interface = g_object_new (SYNCDAEMON_TYPE_INTERFACE,
346
"daemon", daemon,
347
NULL);
348
proxy = syncdaemon_interface_setup_proxy (SYNCDAEMON_INTERFACE (daemon->priv->daemon_interface),
349
SYNCDAEMON_DBUS_NAME, "/",
350
"com.ubuntuone.SyncDaemon.SyncDaemon");
351
if (proxy != NULL) {
352
daemon->priv->ready = TRUE;
353
354
dbus_g_proxy_add_signal (DBUS_G_PROXY (proxy), "QuotaExceeded",
355
dbus_g_type_get_map ("GHashTable",
356
G_TYPE_STRING,
357
G_TYPE_STRING),
358
G_TYPE_INVALID);
359
dbus_g_proxy_connect_signal (DBUS_G_PROXY (proxy), "QuotaExceeded",
360
G_CALLBACK (quota_exceeded_cb),
361
daemon, NULL);
362
363
/* Now get all the interfaces so that we get the signals from them */
364
syncdaemon_daemon_get_config_interface (daemon);
365
syncdaemon_daemon_get_events_interface (daemon);
366
syncdaemon_daemon_get_filesystem_interface (daemon);
367
syncdaemon_daemon_get_folders_interface (daemon);
368
syncdaemon_daemon_get_publicfiles_interface (daemon);
369
syncdaemon_daemon_get_shares_interface (daemon);
370
syncdaemon_daemon_get_status_interface (daemon);
371
372
/* Emit the signal in an idle callback so that callers get it when syncdaemon is running
373
and hence signal is emitted in the _init method */
374
g_idle_add ((GSourceFunc) ready_signal_idle_cb, daemon);
375
}
376
377
}
378
379
static void
380
name_owner_changed_cb (DBusGProxy *proxy,
381
const char *name,
382
const char *old_owner,
383
const char *new_owner,
384
gpointer user_data)
385
{
386
SyncdaemonDaemon *daemon = SYNCDAEMON_DAEMON (user_data);
387
388
if (g_strcmp0 (name, SYNCDAEMON_DBUS_NAME) == 0) {
389
if (new_owner != NULL && strlen (new_owner) > 0) {
390
g_debug ("Got notification of SyncDaemon startup in NameOwnerChanged");
391
setup_daemon_interface (daemon);
392
} else {
393
daemon->priv->ready = FALSE;
394
395
g_debug ("Syncdaemon service died");
396
if (daemon->priv->daemon_interface != NULL) {
397
g_object_unref (daemon->priv->daemon_interface);
398
daemon->priv->daemon_interface = NULL;
399
}
400
401
g_hash_table_remove_all (daemon->priv->subinterfaces);
402
daemon->priv->connected = FALSE;
403
}
404
}
405
}
406
407
static void
408
syncdaemon_daemon_init (SyncdaemonDaemon *daemon)
409
{
410
gboolean has_owner;
411
GError *error = NULL;
412
413
daemon->priv = g_new0 (SyncdaemonDaemonPrivate, 1);
414
415
daemon->priv->ready = FALSE;
416
daemon->priv->connected = FALSE;
417
daemon->priv->subinterfaces = g_hash_table_new_full (g_str_hash, g_str_equal,
418
g_free, g_object_unref);
419
daemon->priv->auth = g_object_new (SYNCDAEMON_TYPE_AUTHENTICATION, NULL);
420
421
/* Initialize DBus */
422
#ifdef HAVE_GDBUS
423
daemon->priv->bus = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error);
424
#else
425
daemon->priv->bus = dbus_g_bus_get (DBUS_BUS_SESSION, &error);
426
#endif
427
if (error != NULL) {
428
g_warning ("Couldn't get session bus: %s", error->message);
429
g_error_free (error);
430
return;
431
}
432
433
daemon->priv->dbus_proxy = dbus_g_proxy_new_for_name (daemon->priv->bus,
434
"org.freedesktop.DBus",
435
"/org/freedesktop/DBus",
436
"org.freedesktop.DBus");
437
438
/* Check if syncdaemon is running */
439
error = NULL;
440
if (org_freedesktop_DBus_name_has_owner (daemon->priv->dbus_proxy, SYNCDAEMON_DBUS_NAME, &has_owner, &error)) {
441
if (has_owner) {
442
/* Already running, so initialize ourselves */
443
g_debug ("SyncDaemon already running, initializing SyncdaemonDaemon object");
444
setup_daemon_interface (daemon);
445
} else
446
g_debug ("Syncdaemon not running, waiting for it to start in NameOwnerChanged");
447
} else {
448
/* The DBus call failed, so just wait for SyncDaemon to start in name_owner_changed_cb */
449
g_warning ("Error calling NameHasOwner: %s", error->message);
450
g_error_free (error);
451
}
452
453
/* Listen to DBus for syncdaemon restarts */
454
dbus_g_proxy_add_signal (DBUS_G_PROXY (daemon->priv->dbus_proxy), "NameOwnerChanged",
455
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
456
G_TYPE_INVALID);
457
dbus_g_proxy_connect_signal (DBUS_G_PROXY (daemon->priv->dbus_proxy),
458
"NameOwnerChanged",
459
G_CALLBACK (name_owner_changed_cb),
460
daemon, NULL);
461
}
462
463
/**
464
* syncdaemon_daemon_new:
465
*
466
* Create a new #SyncdaemonDaemon object, which provides access to the
467
* Syncdaemon daemon.
468
*
469
* Return value: A new #SyncdaemonDaemon object.
470
*/
471
SyncdaemonDaemon *
472
syncdaemon_daemon_new (void)
473
{
474
return g_object_new (SYNCDAEMON_TYPE_DAEMON, NULL);
475
}
476
477
/**
478
* syncdaemon_daemon_is_ready:
479
*/
480
gboolean
481
syncdaemon_daemon_is_ready (SyncdaemonDaemon *daemon)
482
{
483
g_return_val_if_fail (SYNCDAEMON_IS_DAEMON (daemon), FALSE);
484
485
return daemon->priv->ready;
486
}
487
488
static void
489
connect_response_cb (DBusGProxy *proxy, DBusGProxyCall *call_id, gpointer user_data)
490
{
491
GError *error = NULL;
492
SyncdaemonDaemon *daemon = (SyncdaemonDaemon *) user_data;
493
494
if (dbus_g_proxy_end_call (proxy, call_id, &error, G_TYPE_INVALID)) {
495
daemon->priv->connected = TRUE;
496
g_signal_emit (daemon, daemon_signals[CONNECTED_SIGNAL], 0);
497
} else {
498
g_warning ("Syncdaemon cannot connect: %s", error->message);
499
g_error_free (error);
500
}
501
}
502
503
/**
504
* syncdaemon_daemon_connect:
505
*/
506
gboolean
507
syncdaemon_daemon_connect (SyncdaemonDaemon *daemon)
508
{
509
GObject *proxy;
510
511
g_return_val_if_fail (SYNCDAEMON_IS_DAEMON (daemon), FALSE);
512
513
proxy = syncdaemon_interface_get_proxy_object (SYNCDAEMON_INTERFACE (daemon->priv->daemon_interface));
514
if (proxy != NULL) {
515
#ifdef HAVE_GDBUS
516
#else
517
if (!dbus_g_proxy_begin_call (DBUS_G_PROXY (proxy), "connect",
518
connect_response_cb, daemon, NULL,
519
G_TYPE_INVALID)) {
520
g_warning ("Call to 'connect' method failed");
521
522
return FALSE;
523
}
524
#endif
525
}
526
527
return TRUE;
528
}
529
530
static void
531
disconnect_response_cb (DBusGProxy *proxy, DBusGProxyCall *call_id, gpointer user_data)
532
{
533
GError *error = NULL;
534
SyncdaemonDaemon *daemon = (SyncdaemonDaemon *) user_data;
535
536
if (dbus_g_proxy_end_call (proxy, call_id, &error, G_TYPE_INVALID)) {
537
daemon->priv->connected = FALSE;
538
g_signal_emit (daemon, daemon_signals[DISCONNECTED_SIGNAL], 0);
539
} else {
540
g_warning ("Syncdaemon cannot disconnect: %s", error->message);
541
g_error_free (error);
542
}
543
}
544
545
/**
546
* syncdaemon_daemon_interface_disconnect:
547
*/
548
gboolean
549
syncdaemon_daemon_disconnect (SyncdaemonDaemon *daemon)
550
{
551
GObject *proxy;
552
553
g_return_val_if_fail (SYNCDAEMON_IS_DAEMON (daemon), FALSE);
554
555
proxy = syncdaemon_interface_get_proxy_object (SYNCDAEMON_INTERFACE (daemon->priv->daemon_interface));
556
if (proxy != NULL) {
557
#ifdef HAVE_GDBUS
558
#else
559
if (!dbus_g_proxy_begin_call (DBUS_G_PROXY (proxy), "disconnect",
560
disconnect_response_cb, daemon, NULL,
561
G_TYPE_INVALID)) {
562
g_warning ("Call to 'disconnect' method failed");
563
564
return FALSE;
565
}
566
#endif
567
}
568
569
return TRUE;
570
}
571
572
/**
573
* syncdaemon_daemon_interface_quit:
574
*/
575
gboolean
576
syncdaemon_daemon_quit (SyncdaemonDaemon *daemon)
577
{
578
GObject *proxy;
579
580
g_return_val_if_fail (SYNCDAEMON_IS_DAEMON (daemon), FALSE);
581
582
proxy = syncdaemon_interface_get_proxy_object (SYNCDAEMON_INTERFACE (daemon->priv->daemon_interface));
583
if (proxy != NULL) {
584
GError *error = NULL;
585
586
#ifdef HAVE_GDBUS
587
#else
588
if (!dbus_g_proxy_call (DBUS_G_PROXY (proxy), "quit", &error,
589
G_TYPE_INVALID,
590
G_TYPE_INVALID)) {
591
g_warning ("Could not quit syncdaemon: %s", error->message);
592
g_error_free (error);
593
594
return FALSE;
595
}
596
#endif
597
}
598
599
return TRUE;
600
}
601
602
/**
603
* syncdaemon_daemon_get_root_dir:
604
*/
605
const gchar *
606
syncdaemon_daemon_get_root_dir (SyncdaemonDaemon *daemon)
607
{
608
GObject *proxy;
609
610
g_return_val_if_fail (SYNCDAEMON_IS_DAEMON (daemon), NULL);
611
612
if (daemon->priv->root_dir != NULL)
613
return (const gchar *) daemon->priv->root_dir;
614
615
proxy = syncdaemon_interface_get_proxy_object (SYNCDAEMON_INTERFACE (daemon->priv->daemon_interface));
616
if (proxy != NULL) {
617
gchar *new_root_dir;
618
GError *error = NULL;
619
620
#ifdef HAVE_GDBUS
621
#else
622
if (!dbus_g_proxy_call (DBUS_G_PROXY (proxy), "get_rootdir", &error,
623
G_TYPE_INVALID,
624
G_TYPE_STRING, &new_root_dir,
625
G_TYPE_INVALID)) {
626
g_warning ("Could not get syncdaemon's root dir: %s", error->message);
627
g_error_free (error);
628
629
return NULL;
630
}
631
#endif
632
633
daemon->priv->root_dir = new_root_dir;
634
635
return (const gchar *) daemon->priv->root_dir;
636
}
637
638
return NULL;
639
}
640
641
/**
642
* syncdaemon_daemon_has_network:
643
*/
644
gboolean
645
syncdaemon_daemon_has_network (SyncdaemonDaemon *daemon)
646
{
647
SyncdaemonInterface *interface;
648
gboolean result = FALSE;
649
650
g_return_val_if_fail (SYNCDAEMON_IS_DAEMON (daemon), FALSE);
651
652
interface = syncdaemon_daemon_get_status_interface (daemon);
653
if (SYNCDAEMON_IS_STATUS_INTERFACE (interface)) {
654
SyncdaemonStatusInfo *status_info;
655
656
status_info = syncdaemon_status_interface_get_current_status (SYNCDAEMON_STATUS_INTERFACE (interface));
657
if (g_strrstr (syncdaemon_status_info_get_connection (status_info), "With Network") != NULL)
658
result = TRUE;
659
660
g_object_unref (G_OBJECT (status_info));
661
}
662
663
return result;
664
}
665
666
/**
667
* syncdaemon_daemon_get_authentication:
668
*/
669
SyncdaemonAuthentication *
670
syncdaemon_daemon_get_authentication (SyncdaemonDaemon *daemon)
671
{
672
g_return_val_if_fail (SYNCDAEMON_IS_DAEMON (daemon), NULL);
673
674
return daemon->priv->auth;
675
}
676
677
/**
678
* syncdaemon_daemon_get_bandwidth_throttling:
679
* @daemon: A #SyncdaemonDaemon object
680
*
681
* Get whether bandwidth throttling is enabled or not.
682
*
683
* Return value: TRUE if enabled, FALSE if disabled.
684
*/
685
gboolean
686
syncdaemon_daemon_get_bandwidth_throttling (SyncdaemonDaemon *daemon)
687
{
688
SyncdaemonInterface *interface;
689
690
g_return_val_if_fail (SYNCDAEMON_IS_DAEMON (daemon), FALSE);
691
692
interface = syncdaemon_daemon_get_config_interface (daemon);
693
if (SYNCDAEMON_IS_CONFIG_INTERFACE (interface))
694
return syncdaemon_config_interface_get_bandwidth_throttling (SYNCDAEMON_CONFIG_INTERFACE (interface));
695
696
return FALSE;
697
}
698
699
/**
700
* syncdaemon_daemon_set_bandwidth_throttling:
701
* @daemon: A #SyncdaemonDaemon object
702
* @enabled: Whether to enable bandwidth throttling or not.
703
*
704
* Enable or disable bandwidth throttling.
705
*/
706
void
707
syncdaemon_daemon_set_bandwidth_throttling (SyncdaemonDaemon *daemon, gboolean enabled)
708
{
709
SyncdaemonInterface *interface;
710
711
g_return_if_fail (SYNCDAEMON_IS_DAEMON (daemon));
712
713
interface = syncdaemon_daemon_get_config_interface (daemon);
714
if (SYNCDAEMON_IS_CONFIG_INTERFACE (interface))
715
syncdaemon_config_interface_set_bandwidth_throttling (SYNCDAEMON_CONFIG_INTERFACE (interface), enabled);
716
}
717
718
/**
719
* syncdaemon_daemon_get_files_sync:
720
* @daemon: A #SyncdaemonDaemon object
721
*
722
* Get whether file syncing is enabled or not.
723
*
724
* Return value: TRUE if enabled, FALSE if disabled.
725
*/
726
gboolean
727
syncdaemon_daemon_get_files_sync (SyncdaemonDaemon *daemon)
728
{
729
SyncdaemonInterface *interface;
730
731
g_return_val_if_fail (SYNCDAEMON_IS_DAEMON (daemon), FALSE);
732
733
interface = syncdaemon_daemon_get_config_interface (daemon);
734
if (SYNCDAEMON_IS_CONFIG_INTERFACE (interface))
735
return syncdaemon_config_interface_get_files_sync (SYNCDAEMON_CONFIG_INTERFACE (interface));
736
737
return FALSE;
738
}
739
740
/**
741
* syncdaemon_daemon_set_files_sync:
742
* @daemon: A #SyncdaemonDaemon object
743
* @enabled: Whether to enable file syncing or not.
744
*
745
* Enable or disable file syncing.
746
*/
747
void
748
syncdaemon_daemon_set_files_sync (SyncdaemonDaemon *daemon, gboolean enabled)
749
{
750
SyncdaemonInterface *interface;
751
752
g_return_if_fail (SYNCDAEMON_IS_DAEMON (daemon));
753
754
interface = syncdaemon_daemon_get_config_interface (daemon);
755
if (SYNCDAEMON_IS_CONFIG_INTERFACE (interface))
756
syncdaemon_config_interface_set_files_sync (SYNCDAEMON_CONFIG_INTERFACE (interface), enabled);
757
}
758
759
/**
760
* syncdaemon_daemon_get_throttling_limits:
761
* @daemon: A #SyncdaemonDaemon object
762
* @download: Placeholder for download limits
763
* @upload: Placeholder for upload limits
764
*
765
* Retrieve download and upload throttling limits.
766
*/
767
void
768
syncdaemon_daemon_get_throttling_limits (SyncdaemonDaemon *daemon, gint *download, gint *upload)
769
{
770
SyncdaemonInterface *interface;
771
772
g_return_if_fail (SYNCDAEMON_IS_DAEMON (daemon));
773
774
interface = syncdaemon_daemon_get_config_interface (daemon);
775
if (interface != NULL) {
776
syncdaemon_config_interface_get_throttling_limits (SYNCDAEMON_CONFIG_INTERFACE (interface),
777
download,
778
upload);
779
}
780
}
781
782
/**
783
* syncdaemon_daemon_set_throttling_limits:
784
* @daemon: A #SyncdaemonDaemon object
785
* @download: Download limit
786
* @upload: Upload limit
787
*
788
* Set download and upload throttling limits.
789
*/
790
void
791
syncdaemon_daemon_set_throttling_limits (SyncdaemonDaemon *daemon, gint download, gint upload)
792
{
793
SyncdaemonInterface *interface;
794
795
g_return_if_fail (SYNCDAEMON_IS_DAEMON (daemon));
796
797
interface = syncdaemon_daemon_get_config_interface (daemon);
798
if (interface != NULL) {
799
syncdaemon_config_interface_set_throttling_limits (SYNCDAEMON_CONFIG_INTERFACE (interface),
800
download,
801
upload);
802
}
803
}
804
805
/**
806
* syncdaemon_daemon_get_udf_autosubscribe:
807
* @daemon: A #SyncdaemonDaemon object
808
*
809
* Get whether autosubscription for UDFs is enabled or not.
810
*
811
* Return value: TRUE if enabled, FALSE if disabled.
812
*/
813
gboolean
814
syncdaemon_daemon_get_udf_autosubscribe (SyncdaemonDaemon *daemon)
815
{
816
SyncdaemonInterface *interface;
817
818
g_return_val_if_fail (SYNCDAEMON_IS_DAEMON (daemon), FALSE);
819
820
interface = syncdaemon_daemon_get_config_interface (daemon);
821
if (SYNCDAEMON_IS_CONFIG_INTERFACE (interface))
822
return syncdaemon_config_interface_get_udf_autosubscribe (SYNCDAEMON_CONFIG_INTERFACE (interface));
823
824
return FALSE;
825
}
826
827
/**
828
* syncdaemon_daemon_set_udf_autosubscribe:
829
* @daemon: A #SyncdaemonDaemon object
830
* @enabled: Whether to enable UDF autosubscription or not.
831
*
832
* Enable or disable UDF autosubscription.
833
*/
834
void
835
syncdaemon_daemon_set_udf_autosubscribe (SyncdaemonDaemon *daemon, gboolean enabled)
836
{
837
SyncdaemonInterface *interface;
838
839
g_return_if_fail (SYNCDAEMON_IS_DAEMON (daemon));
840
841
interface = syncdaemon_daemon_get_config_interface (daemon);
842
if (SYNCDAEMON_IS_CONFIG_INTERFACE (interface))
843
syncdaemon_config_interface_set_udf_autosubscribe (SYNCDAEMON_CONFIG_INTERFACE (interface), enabled);
844
}
845
846
/**
847
* syncdaemon_daemon_get_metadata:
848
* @daemon: A #SyncdaemonDaemon object
849
* @path: Path to check metadata for
850
* @with_subtree_sync_check: For folders, whether to check the status of all its children
851
*
852
* Retrieve metadata for a file or folder inside a Ubuntu One directory.
853
*
854
* Return value: Metadata for the specified path.
855
*/
856
SyncdaemonMetadata *
857
syncdaemon_daemon_get_metadata (SyncdaemonDaemon *daemon, const gchar *path, gboolean with_subtree_sync_check)
858
{
859
SyncdaemonInterface *interface;
860
861
g_return_val_if_fail (SYNCDAEMON_IS_DAEMON (daemon), NULL);
862
863
interface = syncdaemon_daemon_get_filesystem_interface (daemon);
864
if (interface != NULL) {
865
return syncdaemon_filesystem_interface_get_metadata (SYNCDAEMON_FILESYSTEM_INTERFACE (interface),
866
path,
867
with_subtree_sync_check);
868
}
869
870
return NULL;
871
}
872
873
/**
874
* syncdaemon_daemon_get_folders:
875
* @daemon: A #SyncdaemonDaemon object
876
*
877
* Retrieve the list of folders setup for synchronization with Ubuntu One.
878
*
879
* Return value: A list of #SyncdaemonFolderInfo containing all the folders being
880
* synchronized by the user. When no longer needed, the list should be freed
881
* by calling g_slist_free.
882
*/
883
GSList *
884
syncdaemon_daemon_get_folders (SyncdaemonDaemon *daemon)
885
{
886
SyncdaemonInterface *interface;
887
888
g_return_val_if_fail (SYNCDAEMON_IS_DAEMON (daemon), NULL);
889
890
interface = syncdaemon_daemon_get_folders_interface (daemon);
891
if (interface != NULL)
892
return syncdaemon_folders_interface_get_folders (SYNCDAEMON_FOLDERS_INTERFACE (interface));
893
894
return NULL;
895
}
896
897
/**
898
* syncdaemon_daemon_get_folder_info:
899
* @daemon: A #SyncdaemonDaemon object
900
* @path: Full path of the folder for which to retrieve information.
901
*
902
* Get information about a folder under Ubuntu One.
903
*
904
* Return value: A #SyncdaemonFolderInfo object containing all the information
905
* for the node. When no longer needed, it should be freed by calling
906
* g_object_unref.
907
*/
908
SyncdaemonFolderInfo *
909
syncdaemon_daemon_get_folder_info (SyncdaemonDaemon *daemon, const gchar *path)
910
{
911
SyncdaemonInterface *interface;
912
913
g_return_val_if_fail (SYNCDAEMON_IS_DAEMON (daemon), NULL);
914
915
interface = syncdaemon_daemon_get_folders_interface (daemon);
916
if (interface != NULL)
917
return syncdaemon_folders_interface_get_info (SYNCDAEMON_FOLDERS_INTERFACE (interface), path);
918
919
return NULL;
920
}
921
922
/**
923
* syncdaemon_daemon_is_folder_enabled:
924
* @daemon: A #SyncdaemonDaemon object
925
* @path: The folder path to check
926
* @is_root: Placeholder for returning whether the given path is a U1 root folder
927
*
928
* Check whether a given path is a folder enabled for synchronization to U1.
929
*
930
* Return value: TRUE if the folder is enabled, FALSE otherwise.
931
*/
932
gboolean
933
syncdaemon_daemon_is_folder_enabled (SyncdaemonDaemon *daemon, const gchar *path, gboolean *is_root)
934
{
935
const gchar *root;
936
gchar *root_with_slash;
937
gboolean managed = FALSE, is_subscribed = FALSE;
938
gchar *dirpath;
939
SyncdaemonInterface *interface;
940
941
g_return_val_if_fail (SYNCDAEMON_IS_DAEMON (daemon), FALSE);
942
g_return_val_if_fail (path != NULL, FALSE);
943
944
*is_root = FALSE;
945
946
/* First check the root folder */
947
root = syncdaemon_daemon_get_root_dir (daemon);
948
if (g_strcmp0 (path, root) == 0) {
949
*is_root = TRUE;
950
return TRUE;
951
} else {
952
root_with_slash = g_build_filename (root, G_DIR_SEPARATOR_S, NULL);
953
954
if (g_str_has_prefix (path, root_with_slash)) {
955
g_free(root_with_slash);
956
return TRUE;
957
}
958
g_free(root_with_slash);
959
}
960
/* Now check the 'Shared With Me' directory */
961
dirpath = g_build_filename (root, "Shared With Me", NULL);
962
if (g_strcmp0 (path, dirpath) == 0) {
963
g_free (dirpath);
964
return FALSE;
965
}
966
g_free (dirpath);
967
968
/* And finally check UDFs */
969
interface = syncdaemon_daemon_get_folders_interface (daemon);
970
if (SYNCDAEMON_IS_FOLDERS_INTERFACE (interface)) {
971
GSList *udfs, *l;
972
973
udfs = syncdaemon_folders_interface_get_folders (SYNCDAEMON_FOLDERS_INTERFACE (interface));
974
for (l = udfs; l != NULL; l = l->next) {
975
const gchar *tmp_path;
976
gchar *tmp_path_with_slash;
977
SyncdaemonFolderInfo *finfo = SYNCDAEMON_FOLDER_INFO (l->data);
978
979
tmp_path = syncdaemon_folder_info_get_path (finfo);
980
is_subscribed = syncdaemon_folder_info_get_subscribed (finfo);
981
982
tmp_path_with_slash = g_strconcat (tmp_path, G_DIR_SEPARATOR_S, NULL);
983
if (g_strcmp0 (path, tmp_path) == 0) {
984
managed = is_subscribed;
985
*is_root = TRUE;
986
break;
987
} else if (g_str_has_prefix (path, tmp_path_with_slash)) {
988
managed = is_subscribed;
989
break;
990
}
991
g_free (tmp_path_with_slash);
992
}
993
994
g_slist_free (udfs);
995
}
996
997
return managed;
998
}
999
1000
/**
1001
* syncdaemon_daemon_create_folder:
1002
* @daemon: A #SyncdaemonDaemon object
1003
* @path: The full path of the folder to create
1004
*
1005
* Enable a folder for Ubuntu One synchronization.
1006
*
1007
* The result of the operation can be retrieved by connecting to the "folder_created"
1008
* signal of the #SyncdaemonDaemon object.
1009
*/
1010
void
1011
syncdaemon_daemon_create_folder (SyncdaemonDaemon *daemon, const gchar *path)
1012
{
1013
SyncdaemonInterface *interface;
1014
1015
g_return_if_fail (SYNCDAEMON_IS_DAEMON (daemon));
1016
1017
interface = syncdaemon_daemon_get_folders_interface (daemon);
1018
if (interface != NULL)
1019
syncdaemon_folders_interface_create (SYNCDAEMON_FOLDERS_INTERFACE (interface), path);
1020
else
1021
g_signal_emit (daemon, daemon_signals[FOLDER_CREATED_SIGNAL], 0, FALSE, NULL);
1022
}
1023
1024
/**
1025
* syncdaemon_daemon_delete_folder:
1026
* @daemon: A #SyncdaemonDaemon object
1027
* @path: The full path of the folder to delete
1028
*
1029
* Disable a folder for Ubuntu One synchronization.
1030
*
1031
* The result of the operation can be retrieved by connecting to the "folder_deleted"
1032
* signal of the #SyncdaemonDaemon object.
1033
*/
1034
void
1035
syncdaemon_daemon_delete_folder (SyncdaemonDaemon *daemon, const gchar *path)
1036
{
1037
SyncdaemonInterface *interface;
1038
1039
g_return_if_fail (SYNCDAEMON_IS_DAEMON (daemon));
1040
1041
interface = syncdaemon_daemon_get_folders_interface (daemon);
1042
if (interface != NULL)
1043
syncdaemon_folders_interface_delete (SYNCDAEMON_FOLDERS_INTERFACE (interface), path);
1044
else
1045
g_signal_emit (daemon, daemon_signals[FOLDER_DELETED_SIGNAL], 0, FALSE, NULL);
1046
}
1047
1048
/**
1049
* syncdaemon_daemon_subscribe_folder:
1050
* @daemon: A #SyncdaemonDaemon object
1051
* @path: The full path of the folder to subscribe
1052
*
1053
* Subscribe a folder for Ubuntu One synchronization.
1054
*
1055
* The result of the operation can be retrieved by connecting to the "folder_subscribed"
1056
* signal of the #SyncdaemonDaemon object.
1057
*/
1058
void
1059
syncdaemon_daemon_subscribe_folder (SyncdaemonDaemon *daemon, const gchar *path)
1060
{
1061
SyncdaemonInterface *interface;
1062
1063
g_return_if_fail (SYNCDAEMON_IS_DAEMON (daemon));
1064
1065
interface = syncdaemon_daemon_get_folders_interface (daemon);
1066
if (interface != NULL)
1067
syncdaemon_folders_interface_subscribe (SYNCDAEMON_FOLDERS_INTERFACE (interface), path);
1068
else
1069
g_signal_emit (daemon, daemon_signals[FOLDER_SUBSCRIBED_SIGNAL], 0, FALSE, NULL);
1070
}
1071
1072
/**
1073
* syncdaemon_daemon_unsubscribe_folder:
1074
* @daemon: A #SyncdaemonDaemon object
1075
* @path: The full path of the folder to unsubscribe
1076
*
1077
* Unsubscribe a folder from Ubuntu One synchronization.
1078
*
1079
* The result of the operation can be retrieved by connecting to the "folder_unsubscribed"
1080
* signal of the #SyncdaemonDaemon object.
1081
*/
1082
void
1083
syncdaemon_daemon_unsubscribe_folder (SyncdaemonDaemon *daemon, const gchar *path)
1084
{
1085
SyncdaemonInterface *interface;
1086
1087
g_return_if_fail (SYNCDAEMON_IS_DAEMON (daemon));
1088
1089
interface = syncdaemon_daemon_get_folders_interface (daemon);
1090
if (interface != NULL)
1091
syncdaemon_folders_interface_unsubscribe (SYNCDAEMON_FOLDERS_INTERFACE (interface), path);
1092
else
1093
g_signal_emit (daemon, daemon_signals[FOLDER_UNSUBSCRIBED_SIGNAL], 0, FALSE, NULL);
1094
}
1095
1096
/**
1097
* syncdaemon_daemon_publish_file:
1098
* @daemon: A #SyncdaemonDaemon object
1099
* @path: Full path of the file to be published
1100
*
1101
* Publish a file on Ubuntu One. When the file is successfully published, the "file_published"
1102
* signal will be emitted.
1103
*
1104
* Return value: TRUE if successful, FALSE otherwise.
1105
*/
1106
gboolean
1107
syncdaemon_daemon_publish_file (SyncdaemonDaemon *daemon, const gchar *path)
1108
{
1109
SyncdaemonMetadata *metadata;
1110
gboolean result = FALSE;
1111
1112
g_return_val_if_fail (SYNCDAEMON_IS_DAEMON (daemon), FALSE);
1113
1114
/* First, retrieve the metadata */
1115
metadata = syncdaemon_daemon_get_metadata (daemon, path, FALSE);
1116
if (metadata != NULL) {
1117
SyncdaemonInterface *interface;
1118
1119
interface = syncdaemon_daemon_get_publicfiles_interface (daemon);
1120
syncdaemon_publicfiles_interface_change_public_access (
1121
SYNCDAEMON_PUBLICFILES_INTERFACE (interface),
1122
syncdaemon_metadata_get_share_id (metadata),
1123
syncdaemon_metadata_get_node_id (metadata),
1124
TRUE);
1125
1126
result = TRUE;
1127
1128
g_object_unref (metadata);
1129
}
1130
1131
return result;
1132
}
1133
1134
/**
1135
* syncdaemon_daemon_unpublish_file:
1136
* @daemon: A #SyncdaemonDaemon object
1137
* @path: Full path of the file to be unpublished
1138
*
1139
* Unpublish a file from Ubuntu One. When the file is successfully unpublished, the "file_unpublished"
1140
* signal will be emitted.
1141
*
1142
* Return value: TRUE if successful, FALSE otherwise.
1143
*/
1144
gboolean
1145
syncdaemon_daemon_unpublish_file (SyncdaemonDaemon *daemon, const gchar *path)
1146
{
1147
SyncdaemonMetadata *metadata;
1148
gboolean result = FALSE;
1149
1150
g_return_val_if_fail (SYNCDAEMON_IS_DAEMON (daemon), FALSE);
1151
1152
/* First, retrieve the metadata */
1153
metadata = syncdaemon_daemon_get_metadata (daemon, path, FALSE);
1154
if (metadata != NULL) {
1155
SyncdaemonInterface *interface;
1156
1157
interface = syncdaemon_daemon_get_publicfiles_interface (daemon);
1158
syncdaemon_publicfiles_interface_change_public_access (
1159
SYNCDAEMON_PUBLICFILES_INTERFACE (interface),
1160
syncdaemon_metadata_get_share_id (metadata),
1161
syncdaemon_metadata_get_node_id (metadata),
1162
FALSE);
1163
1164
result = TRUE;
1165
1166
g_object_unref (metadata);
1167
}
1168
1169
return result;
1170
}
1171
1172
/**
1173
* syncdaemon_daemon_get_public_files:
1174
* @daemon: A #SyncdaemonDaemon object
1175
*
1176
* Retrieve the list of public files.
1177
*
1178
* Return value: A #GSList of #SyncdaemonFileInfo objects, each of which describes
1179
* a published file for the user. When no longer needed, this list should be
1180
* freed by calling g_slist_free, but the data within the list should never
1181
* be freed, as it belongs to the library.
1182
*/
1183
GSList *
1184
syncdaemon_daemon_get_public_files (SyncdaemonDaemon *daemon)
1185
{
1186
SyncdaemonInterface *interface;
1187
1188
g_return_val_if_fail (SYNCDAEMON_IS_DAEMON (daemon), NULL);
1189
1190
interface = syncdaemon_daemon_get_publicfiles_interface (daemon);
1191
if (interface != NULL) {
1192
return syncdaemon_publicfiles_interface_get_public_files (
1193
SYNCDAEMON_PUBLICFILES_INTERFACE (interface));
1194
}
1195
1196
return NULL;
1197
}
1198
1199
/**
1200
* syncdaemon_daemon_create_share:
1201
* @daemon: A #SyncdaemonDaemon object
1202
* @path: Full path of the folder to be shared
1203
* @usernames: List of users with whom to share the folder
1204
* @name: Name to be used for the share
1205
* @allow_modifications: Whether to allow modifications to the list of users
1206
*
1207
* Share a Ubuntu One folder with a list of users.
1208
*
1209
* The result of the operation can be retrieved by connecting to the "share_created"
1210
* signal of the #SyncdaemonDaemon object.
1211
*/
1212
void
1213
syncdaemon_daemon_create_share (SyncdaemonDaemon *daemon,
1214
const gchar *path,
1215
GSList *usernames,
1216
const gchar *name,
1217
gboolean allow_modifications)
1218
{
1219
SyncdaemonInterface *interface;
1220
1221
g_return_if_fail (SYNCDAEMON_IS_DAEMON (daemon));
1222
1223
interface = syncdaemon_daemon_get_shares_interface (daemon);
1224
if (interface != NULL) {
1225
syncdaemon_shares_interface_create (SYNCDAEMON_SHARES_INTERFACE (interface),
1226
path,
1227
usernames,
1228
name,
1229
allow_modifications);
1230
} else
1231
g_signal_emit (daemon, daemon_signals[SHARE_CREATED_SIGNAL], 0, FALSE, NULL);
1232
}
1233
1234
/**
1235
* syncdaemon_daemon_delete_share:
1236
* @daemon: A #SyncdaemonDaemon object
1237
* @path: Full path of the folder to be shared
1238
*
1239
* Stop sharing a Ubuntu One folder.
1240
*
1241
* The result of the operation can be retrieved by connecting to the "share_deleted"
1242
* signal of the #SyncdaemonDaemon object.
1243
*/
1244
void
1245
syncdaemon_daemon_delete_share (SyncdaemonDaemon *daemon, const gchar *path)
1246
{
1247
SyncdaemonInterface *interface;
1248
1249
g_return_if_fail (SYNCDAEMON_IS_DAEMON (daemon));
1250
1251
interface = syncdaemon_daemon_get_shares_interface (daemon);
1252
if (interface != NULL)
1253
syncdaemon_shares_interface_delete (SYNCDAEMON_SHARES_INTERFACE (interface), path);
1254
else
1255
g_signal_emit (daemon, daemon_signals[SHARE_DELETED_SIGNAL], 0, FALSE, NULL);
1256
}
1257
1258
/**
1259
* syncdaemon_daemon_get_shared_folders:
1260
* @daemon: A #SyncdaemonDaemon object
1261
*
1262
* Get the list of folders shared by the user with other users.
1263
*
1264
* Return value: A GSList of #SyncdaemonShareInfo objects. When no longer needed,
1265
* the list should be freed by calling #g_slist_free.
1266
*/
1267
GSList *
1268
syncdaemon_daemon_get_shared_folders (SyncdaemonDaemon *daemon)
1269
{
1270
SyncdaemonInterface *interface;
1271
1272
g_return_val_if_fail (SYNCDAEMON_IS_DAEMON (daemon), NULL);
1273
1274
interface = syncdaemon_daemon_get_shares_interface (daemon);
1275
if (interface != NULL)
1276
return syncdaemon_shares_interface_get_shared (SYNCDAEMON_SHARES_INTERFACE (interface));
1277
1278
return NULL;
1279
}
1280
1281
/**
1282
* syncdaemon_daemon_get_shares:
1283
* @daemon: A #SyncdaemonDaemon object
1284
*
1285
* Get the list of folders shared by other users with the current user.
1286
*
1287
* Return value: A GSList of #SyncdaemonShareInfo objects. When no longer needed,
1288
* the list should be freed by calling #g_slist_free.
1289
*/
1290
GSList *
1291
syncdaemon_daemon_get_shares (SyncdaemonDaemon *daemon)
1292
{
1293
SyncdaemonInterface *interface;
1294
1295
g_return_val_if_fail (SYNCDAEMON_IS_DAEMON (daemon), NULL);
1296
1297
interface = syncdaemon_daemon_get_shares_interface (daemon);
1298
if (interface != NULL)
1299
return syncdaemon_shares_interface_get_shares (SYNCDAEMON_SHARES_INTERFACE (interface));
1300
1301
return NULL;
1302
}
1303
1304
/**
1305
* syncdaemon_daemon_get_current_status:
1306
* @daemon: A #SyncdaemonDaemon object
1307
*
1308
* Retrieve the current status of SyncDaemon.
1309
*
1310
* Return value: A #SyncdaemonStatusInfo object containing information about
1311
* Syncdaemon's current status. When no longer needed, it should be freed by
1312
* calling g_object_unref.
1313
*/
1314
SyncdaemonStatusInfo *
1315
syncdaemon_daemon_get_current_status (SyncdaemonDaemon *daemon)
1316
{
1317
SyncdaemonInterface *interface;
1318
1319
g_return_val_if_fail (SYNCDAEMON_IS_DAEMON (daemon), NULL);
1320
1321
interface = syncdaemon_daemon_get_status_interface (daemon);
1322
if (interface != NULL)
1323
return syncdaemon_status_interface_get_current_status (SYNCDAEMON_STATUS_INTERFACE (interface));
1324
1325
return NULL;
1326
}
1327
1328
/**
1329
* syncdaemon_daemon_get_current_downloads:
1330
* @daemon: A #SyncdaemonDaemon object
1331
*
1332
* Retrieve the list of downloads in progress.
1333
*
1334
* Return value: A GSList of #SyncdaemonTransferInfo objects, each of which contains
1335
* information about a file download in progress. The data in the list belongs to
1336
* the library, so when no longer needed, the list should be freed by just calling
1337
* g_slist_free.
1338
*/
1339
GSList *
1340
syncdaemon_daemon_get_current_downloads (SyncdaemonDaemon *daemon)
1341
{
1342
SyncdaemonInterface *interface;
1343
1344
g_return_val_if_fail (SYNCDAEMON_IS_DAEMON (daemon), NULL);
1345
1346
interface = syncdaemon_daemon_get_status_interface (daemon);
1347
if (interface != NULL)
1348
return syncdaemon_status_interface_get_current_downloads (SYNCDAEMON_STATUS_INTERFACE (interface));
1349
1350
return NULL;
1351
}
1352
1353
/**
1354
* syncdaemon_daemon_get_current_uploads:
1355
* @daemon: A #SyncdaemonDaemon object
1356
*
1357
* Retrieve the list of uploads in progress.
1358
*
1359
* Return value: A GSList of #SyncdaemonTransferInfo objects, each of which contains
1360
* information about a file upload in progress. The data in the list belongs to
1361
* the library, so when no longer needed, the list should be freed by just calling
1362
* g_slist_free.
1363
*/
1364
GSList *
1365
syncdaemon_daemon_get_current_uploads (SyncdaemonDaemon *daemon)
1366
{
1367
SyncdaemonInterface *interface;
1368
1369
g_return_val_if_fail (SYNCDAEMON_IS_DAEMON (daemon), NULL);
1370
1371
interface = syncdaemon_daemon_get_status_interface (daemon);
1372
if (interface != NULL)
1373
return syncdaemon_status_interface_get_current_uploads (SYNCDAEMON_STATUS_INTERFACE (interface));
1374
1375
return NULL;
1376
}
1377
1378
typedef SyncdaemonInterface * (* SDINewFunc) (SyncdaemonDaemon * daemon);
1379
1380
static SyncdaemonInterface *
1381
get_interface (SyncdaemonDaemon *daemon, const gchar *path, SDINewFunc new_func)
1382
{
1383
SyncdaemonInterface *interface;
1384
1385
interface = g_hash_table_lookup (daemon->priv->subinterfaces, path);
1386
if (interface == NULL) {
1387
interface = new_func (daemon);
1388
if (SYNCDAEMON_IS_INTERFACE (interface))
1389
g_hash_table_insert (daemon->priv->subinterfaces, g_strdup (path), interface);
1390
}
1391
1392
return interface;
1393
}
1394
1395
/**
1396
* syncdaemon_daemon_get_config_interface:
1397
*/
1398
SyncdaemonInterface *
1399
syncdaemon_daemon_get_config_interface (SyncdaemonDaemon *daemon)
1400
{
1401
g_return_val_if_fail (SYNCDAEMON_IS_DAEMON (daemon), NULL);
1402
1403
return get_interface (daemon, "/config",
1404
(SDINewFunc) syncdaemon_config_interface_new);
1405
}
1406
1407
/**
1408
* syncdaemon_daemon_get_events_interface:
1409
*/
1410
SyncdaemonInterface *
1411
syncdaemon_daemon_get_events_interface (SyncdaemonDaemon *daemon)
1412
{
1413
g_return_val_if_fail (SYNCDAEMON_IS_DAEMON (daemon), NULL);
1414
1415
return get_interface (daemon, "/events",
1416
(SDINewFunc) syncdaemon_events_interface_new);
1417
}
1418
1419
/**
1420
* syncdaemon_daemon_get_filesystem_interface:
1421
*/
1422
SyncdaemonInterface *
1423
syncdaemon_daemon_get_filesystem_interface (SyncdaemonDaemon *daemon)
1424
{
1425
g_return_val_if_fail (SYNCDAEMON_IS_DAEMON (daemon), NULL);
1426
1427
return get_interface (daemon, "/filesystem",
1428
(SDINewFunc) syncdaemon_filesystem_interface_new);
1429
}
1430
1431
/**
1432
* syncdaemon_daemon_get_folders_interface:
1433
*/
1434
SyncdaemonInterface *
1435
syncdaemon_daemon_get_folders_interface (SyncdaemonDaemon *daemon)
1436
{
1437
g_return_val_if_fail (SYNCDAEMON_IS_DAEMON (daemon), NULL);
1438
1439
return get_interface (daemon, "/folders",
1440
(SDINewFunc) syncdaemon_folders_interface_new);
1441
}
1442
1443
/**
1444
* syncdaemon_daemon_get_publicfiles_interface:
1445
*/
1446
SyncdaemonInterface *
1447
syncdaemon_daemon_get_publicfiles_interface (SyncdaemonDaemon *daemon)
1448
{
1449
g_return_val_if_fail (SYNCDAEMON_IS_DAEMON (daemon), NULL);
1450
1451
return get_interface (daemon, "/publicfiles",
1452
(SDINewFunc) syncdaemon_publicfiles_interface_new);
1453
}
1454
1455
/**
1456
* syncdaemon_daemon_get_shares_interface:
1457
*/
1458
SyncdaemonInterface *
1459
syncdaemon_daemon_get_shares_interface (SyncdaemonDaemon *daemon)
1460
{
1461
g_return_val_if_fail (SYNCDAEMON_IS_DAEMON (daemon), NULL);
1462
1463
return get_interface (daemon, "/shares",
1464
(SDINewFunc) syncdaemon_shares_interface_new);
1465
}
1466
1467
/**
1468
* syncdaemon_daemon_get_status_interface:
1469
*/
1470
SyncdaemonInterface *
1471
syncdaemon_daemon_get_status_interface (SyncdaemonDaemon *daemon)
1472
{
1473
g_return_val_if_fail (SYNCDAEMON_IS_DAEMON (daemon), NULL);
1474
1475
return get_interface (daemon, "/status",
1476
(SDINewFunc) syncdaemon_status_interface_new);
1477
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.1