~ubuntu-branches/ubuntu/saucy/ubuntuone-client/saucy-proposed

« back to all changes in this revision

Viewing changes to libsyncdaemon/syncdaemon-shares-interface.c

  • Committer: Package Import Robot
  • Author(s): Rodney Dawes
  • Date: 2013-07-11 15:11:07 UTC
  • mfrom: (1.1.83)
  • Revision ID: package-import@ubuntu.com-20130711151107-6tbv4n9er446e2yy
Tags: 13.07-0ubuntu1
* New upstream release.
  - Remove libsyncdaemon and convert to pure python project.
* debian/control:
  - Update dependencies for changes.
  - Drop libsyncdaemon packages. (LP: #1196684)
* debian/rules:
  - Convert to pure dh and update for build system changes.
* debian/tests:
  - Add autopkgtest configuration.

Show diffs side-by-side

added added

removed removed

Lines of Context:
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 "syncdaemon-shares-interface.h"
37
 
#include "utils.h"
38
 
 
39
 
G_DEFINE_TYPE(SyncdaemonSharesInterface, syncdaemon_shares_interface, SYNCDAEMON_TYPE_INTERFACE)
40
 
 
41
 
struct _SyncdaemonSharesInterfacePrivate {
42
 
        GObject *proxy;
43
 
        GHashTable *shared;
44
 
        GHashTable *shares;
45
 
};
46
 
 
47
 
typedef struct _AddEmblemData {
48
 
        SyncdaemonSharesInterface *interface;
49
 
        gchar *path;
50
 
} AddEmblemData;
51
 
 
52
 
static void
53
 
syncdaemon_shares_interface_finalize (GObject *object)
54
 
{
55
 
        SyncdaemonSharesInterface *interface = SYNCDAEMON_SHARES_INTERFACE (object);
56
 
 
57
 
        if (interface->priv != NULL) {
58
 
                g_free (interface->priv);
59
 
        }
60
 
 
61
 
        G_OBJECT_CLASS (syncdaemon_shares_interface_parent_class)->finalize (object);
62
 
}
63
 
 
64
 
static void
65
 
syncdaemon_shares_interface_class_init (SyncdaemonSharesInterfaceClass *klass)
66
 
{
67
 
        GObjectClass *object_class = G_OBJECT_CLASS (klass);
68
 
 
69
 
        object_class->finalize = syncdaemon_shares_interface_finalize;
70
 
}
71
 
 
72
 
static void
73
 
share_created_cb (DBusGProxy *proxy, GHashTable *hash, gpointer user_data)
74
 
{
75
 
        SyncdaemonDaemon *daemon = NULL;
76
 
        SyncdaemonShareInfo *share_info;
77
 
        SyncdaemonSharesInterface *interface = SYNCDAEMON_SHARES_INTERFACE (user_data);
78
 
 
79
 
        share_info = syncdaemon_share_info_new_from_hash_table (hash);
80
 
        switch (syncdaemon_share_info_get_share_type (share_info)) {
81
 
        case SYNCDAEMON_SHARE_INFO_TYPE_SHARED:
82
 
                if (interface->priv->shared == NULL) {
83
 
                        GSList *shared;
84
 
 
85
 
                        shared = syncdaemon_shares_interface_get_shared (interface);
86
 
                        g_slist_free (shared);
87
 
                }
88
 
 
89
 
                g_hash_table_insert (interface->priv->shared,
90
 
                                     g_strdup (syncdaemon_share_info_get_path (share_info)),
91
 
                                     share_info);
92
 
                break;
93
 
        case SYNCDAEMON_SHARE_INFO_TYPE_SHARE:
94
 
                if (interface->priv->shares == NULL) {
95
 
                        GSList *shares;
96
 
 
97
 
                        shares = syncdaemon_shares_interface_get_shares (interface);
98
 
                        g_slist_free (shares);
99
 
                }
100
 
 
101
 
                g_hash_table_insert (interface->priv->shares,
102
 
                                     g_strdup (syncdaemon_share_info_get_path (share_info)),
103
 
                                     share_info);
104
 
                break;
105
 
        default:
106
 
                return;
107
 
        }
108
 
 
109
 
        g_object_get (G_OBJECT (interface), "daemon", &daemon, NULL);
110
 
        if (daemon != NULL)
111
 
                g_signal_emit_by_name (daemon, "share_created", TRUE, share_info);
112
 
}
113
 
 
114
 
static void
115
 
share_create_error_cb (DBusGProxy *proxy, GHashTable *hash, const gchar *error, gpointer user_data)
116
 
{
117
 
        SyncdaemonDaemon *daemon = NULL;
118
 
        SyncdaemonSharesInterface *interface = SYNCDAEMON_SHARES_INTERFACE (user_data);
119
 
 
120
 
        g_object_get (G_OBJECT (interface), "daemon", &daemon, NULL);
121
 
        if (daemon != NULL) {
122
 
                SyncdaemonShareInfo *share_info;
123
 
 
124
 
                share_info = syncdaemon_share_info_new_from_hash_table (hash);
125
 
                g_signal_emit_by_name (daemon, "share_created", FALSE, share_info);
126
 
                g_object_unref (G_OBJECT (share_info));
127
 
        }
128
 
}
129
 
 
130
 
static void
131
 
share_deleted_cb (DBusGProxy *proxy, GHashTable *hash, gpointer user_data)
132
 
{
133
 
        SyncdaemonDaemon *daemon = NULL;
134
 
        SyncdaemonShareInfo *share_info;
135
 
        SyncdaemonSharesInterface *interface = SYNCDAEMON_SHARES_INTERFACE (user_data);
136
 
 
137
 
        share_info = syncdaemon_share_info_new_from_hash_table (hash);
138
 
        switch (syncdaemon_share_info_get_share_type (share_info)) {
139
 
        case SYNCDAEMON_SHARE_INFO_TYPE_SHARED:
140
 
                if (interface->priv->shared != NULL)
141
 
                        g_hash_table_remove (interface->priv->shared, syncdaemon_share_info_get_path (share_info));
142
 
                break;
143
 
        case SYNCDAEMON_SHARE_INFO_TYPE_SHARE:
144
 
                if (interface->priv->shares != NULL)
145
 
                        g_hash_table_remove (interface->priv->shares, syncdaemon_share_info_get_path (share_info));
146
 
                break;
147
 
        default:
148
 
                return;
149
 
        }
150
 
 
151
 
        g_object_get (G_OBJECT (interface), "daemon", &daemon, NULL);
152
 
        if (daemon != NULL)
153
 
                g_signal_emit_by_name (daemon, "share_deleted", TRUE, share_info);
154
 
 
155
 
        g_object_unref (G_OBJECT (share_info));
156
 
}
157
 
 
158
 
static void
159
 
share_delete_error_cb (DBusGProxy *proxy, GHashTable *hash, const gchar *error, gpointer user_data)
160
 
{
161
 
        SyncdaemonDaemon *daemon = NULL;
162
 
        SyncdaemonSharesInterface *interface = SYNCDAEMON_SHARES_INTERFACE (user_data);
163
 
 
164
 
        g_object_get (G_OBJECT (interface), "daemon", &daemon, NULL);
165
 
        if (daemon != NULL) {
166
 
                SyncdaemonShareInfo *share_info;
167
 
 
168
 
                share_info = syncdaemon_share_info_new_from_hash_table (hash);
169
 
                g_signal_emit_by_name (daemon, "share_deleted", FALSE, share_info);
170
 
                g_object_unref (G_OBJECT (share_info));
171
 
        }
172
 
}
173
 
 
174
 
static void
175
 
syncdaemon_shares_interface_init (SyncdaemonSharesInterface *interface)
176
 
{
177
 
        interface->priv = g_new0 (SyncdaemonSharesInterfacePrivate, 1);
178
 
 
179
 
        /* Setup DBus proxy */
180
 
        interface->priv->proxy = syncdaemon_interface_setup_proxy (SYNCDAEMON_INTERFACE (interface),
181
 
                                                                   "com.ubuntuone.SyncDaemon",
182
 
                                                                   "/shares", "com.ubuntuone.SyncDaemon.Shares");
183
 
        if (interface->priv->proxy != NULL) {
184
 
                /* Connect to DBus signals */
185
 
                dbus_g_proxy_add_signal (DBUS_G_PROXY (interface->priv->proxy), "ShareCreated",
186
 
                                         dbus_g_type_get_map ("GHashTable",
187
 
                                                              G_TYPE_STRING,
188
 
                                                              G_TYPE_STRING),
189
 
                                         G_TYPE_INVALID);
190
 
                dbus_g_proxy_connect_signal (DBUS_G_PROXY (interface->priv->proxy), "ShareCreated",
191
 
                                             G_CALLBACK (share_created_cb), interface, NULL);
192
 
 
193
 
                dbus_g_proxy_add_signal (DBUS_G_PROXY (interface->priv->proxy), "ShareCreateError",
194
 
                                         dbus_g_type_get_map ("GHashTable",
195
 
                                                              G_TYPE_STRING,
196
 
                                                              G_TYPE_STRING),
197
 
                                         G_TYPE_STRING,
198
 
                                         G_TYPE_INVALID);
199
 
                dbus_g_proxy_connect_signal (DBUS_G_PROXY (interface->priv->proxy), "ShareCreateError",
200
 
                                             G_CALLBACK (share_create_error_cb), interface, NULL);
201
 
 
202
 
                dbus_g_proxy_add_signal (DBUS_G_PROXY (interface->priv->proxy), "ShareDeleted",
203
 
                                         dbus_g_type_get_map ("GHashTable",
204
 
                                                              G_TYPE_STRING,
205
 
                                                              G_TYPE_STRING),
206
 
                                         G_TYPE_INVALID);
207
 
                dbus_g_proxy_connect_signal (DBUS_G_PROXY (interface->priv->proxy), "ShareDeleted",
208
 
                                             G_CALLBACK (share_deleted_cb), interface, NULL);
209
 
 
210
 
                dbus_g_proxy_add_signal (DBUS_G_PROXY (interface->priv->proxy), "ShareDeleteError",
211
 
                                         dbus_g_type_get_map ("GHashTable",
212
 
                                                              G_TYPE_STRING,
213
 
                                                              G_TYPE_STRING),
214
 
                                         G_TYPE_STRING,
215
 
                                         G_TYPE_INVALID);
216
 
                dbus_g_proxy_connect_signal (DBUS_G_PROXY (interface->priv->proxy), "ShareDeleteError",
217
 
                                             G_CALLBACK (share_delete_error_cb), interface, NULL);
218
 
        }
219
 
}
220
 
 
221
 
/**
222
 
 * syncdaemon_shares_interface_new:
223
 
 */
224
 
SyncdaemonSharesInterface *
225
 
syncdaemon_shares_interface_new (SyncdaemonDaemon *daemon)
226
 
{
227
 
        g_return_val_if_fail (SYNCDAEMON_IS_DAEMON (daemon), NULL);
228
 
 
229
 
        return g_object_new (SYNCDAEMON_TYPE_SHARES_INTERFACE, "daemon", daemon, NULL);
230
 
}
231
 
 
232
 
/**
233
 
 * syncdaemon_shares_interface_accept:
234
 
 */
235
 
void
236
 
syncdaemon_shares_interface_accept (SyncdaemonSharesInterface *interface, const gchar *share_id)
237
 
{
238
 
        g_return_if_fail (SYNCDAEMON_IS_SHARES_INTERFACE (interface));
239
 
        g_return_if_fail (share_id != NULL);
240
 
 
241
 
        dbus_g_proxy_begin_call (DBUS_G_PROXY (interface->priv->proxy), "accept_share",
242
 
                                 no_output_dbus_call_ended_cb, interface, NULL,
243
 
                                 G_TYPE_STRING, share_id,
244
 
                                 G_TYPE_INVALID);
245
 
}
246
 
 
247
 
void
248
 
add_emblem_cb (DBusGProxy *proxy, DBusGProxyCall *call_id, gpointer user_data) {
249
 
        SyncdaemonShareInfo *share_info;
250
 
        SyncdaemonDaemon *daemon;
251
 
        GHashTable *hash;
252
 
        AddEmblemData *emblem_data = user_data;
253
 
 
254
 
        hash = g_hash_table_new (g_str_hash, g_str_equal);
255
 
        g_hash_table_insert (hash, "path", emblem_data->path);
256
 
        share_info = syncdaemon_share_info_new_from_hash_table (hash);
257
 
        g_hash_table_unref (hash);
258
 
 
259
 
        g_hash_table_insert (emblem_data->interface->priv->shared,
260
 
                             g_strdup (syncdaemon_share_info_get_path (share_info)),
261
 
                             share_info);
262
 
 
263
 
 
264
 
        g_object_get (G_OBJECT (emblem_data->interface), "daemon", &daemon, NULL);
265
 
        if (daemon != NULL)
266
 
                g_signal_emit_by_name (daemon, "share_created", TRUE, share_info);
267
 
 
268
 
        no_output_dbus_call_ended_cb (proxy, call_id, user_data);
269
 
 
270
 
        g_object_unref (emblem_data->interface);
271
 
        g_free (emblem_data->path);
272
 
        g_free (emblem_data);
273
 
}
274
 
 
275
 
/**
276
 
 * syncdaemon_shares_interface_create:
277
 
 */
278
 
void
279
 
syncdaemon_shares_interface_create (SyncdaemonSharesInterface *interface,
280
 
                                    const gchar *path,
281
 
                                    GSList *usernames,
282
 
                                    const gchar *name,
283
 
                                    gboolean allow_modifications)
284
 
{
285
 
        AddEmblemData *emblem_data;
286
 
        g_return_if_fail (SYNCDAEMON_IS_SHARES_INTERFACE (interface));
287
 
        g_return_if_fail (path != NULL);
288
 
        g_return_if_fail (usernames != NULL);
289
 
        g_return_if_fail (name != NULL);
290
 
 
291
 
        emblem_data = g_new0 (AddEmblemData, 1);
292
 
        emblem_data->interface = g_object_ref (interface);
293
 
        emblem_data->path = g_strdup (path);
294
 
 
295
 
        if (g_slist_length (usernames) == 1) {
296
 
                dbus_g_proxy_begin_call (DBUS_G_PROXY (interface->priv->proxy), "create_share",
297
 
                                         add_emblem_cb, emblem_data, NULL,
298
 
                                         G_TYPE_STRING, path,
299
 
                                         G_TYPE_STRING, (const gchar *) usernames->data,
300
 
                                         G_TYPE_STRING, name,
301
 
                                         G_TYPE_STRING, allow_modifications ? "Modify" : "View",
302
 
                                         G_TYPE_INVALID);
303
 
        } else {
304
 
                GSList *l;
305
 
                gint i;
306
 
                gchar **users_array = g_new0 (gchar *, g_slist_length (usernames) + 1);
307
 
 
308
 
                for (l = usernames, i = 0; l != NULL; l = l->next, i++)
309
 
                        users_array[i] = g_strdup (l->data);
310
 
 
311
 
                dbus_g_proxy_begin_call (DBUS_G_PROXY (interface->priv->proxy), "create_shares",
312
 
                                         add_emblem_cb, emblem_data, NULL,
313
 
                                         G_TYPE_STRING, path,
314
 
                                         G_TYPE_STRV, users_array,
315
 
                                         G_TYPE_STRING, name,
316
 
                                         G_TYPE_STRING, allow_modifications ? "Modify" : "View",
317
 
                                         G_TYPE_INVALID);
318
 
 
319
 
                g_strfreev (users_array);
320
 
        }
321
 
}
322
 
 
323
 
/**
324
 
 * syncdaemon_shares_interface_delete:
325
 
 */
326
 
void
327
 
syncdaemon_shares_interface_delete (SyncdaemonSharesInterface *interface, const gchar *path)
328
 
{
329
 
        GSList *shares, *l;
330
 
        const gchar *share_id = NULL;
331
 
 
332
 
        g_return_if_fail (SYNCDAEMON_IS_SHARES_INTERFACE (interface));
333
 
        g_return_if_fail (path != NULL);
334
 
 
335
 
        shares = syncdaemon_shares_interface_get_shared (interface);
336
 
        for (l = shares; l != NULL; l = l->next) {
337
 
                SyncdaemonShareInfo *sinfo = SYNCDAEMON_SHARE_INFO (l->data);
338
 
 
339
 
                if (g_str_equal (path, syncdaemon_share_info_get_path (sinfo)))
340
 
                        share_id = syncdaemon_share_info_get_node_id (sinfo);
341
 
        }
342
 
 
343
 
        if (share_id != NULL) {
344
 
                dbus_g_proxy_begin_call (DBUS_G_PROXY (interface->priv->proxy), "delete_share",
345
 
                                         no_output_dbus_call_ended_cb, interface, NULL,
346
 
                                         G_TYPE_STRING, share_id,
347
 
                                         G_TYPE_INVALID);
348
 
        }
349
 
 
350
 
        g_slist_free (shares);
351
 
}
352
 
 
353
 
/**
354
 
 * syncdaemon_shares_interface_get_shared:
355
 
 */
356
 
GSList *
357
 
syncdaemon_shares_interface_get_shared (SyncdaemonSharesInterface *interface)
358
 
{
359
 
        GHashTableIter iter;
360
 
        gchar *path;
361
 
        SyncdaemonShareInfo *share_info;
362
 
        GSList *shared_list, *returned_list = NULL;;
363
 
        GError *error = NULL;
364
 
 
365
 
        g_return_val_if_fail (SYNCDAEMON_IS_SHARES_INTERFACE (interface), NULL);
366
 
 
367
 
        if (interface->priv->shared == NULL) {
368
 
                interface->priv->shared = g_hash_table_new_full (g_str_hash, g_str_equal,
369
 
                                                                 g_free, g_object_unref);
370
 
 
371
 
                if (dbus_g_proxy_call (DBUS_G_PROXY (interface->priv->proxy), "get_shared", &error,
372
 
                                       G_TYPE_INVALID,
373
 
                                       dbus_g_type_get_collection ("GSList",
374
 
                                                                   dbus_g_type_get_map (
375
 
                                                                           "GHashTable",
376
 
                                                                           G_TYPE_STRING,
377
 
                                                                           G_TYPE_STRING)), &shared_list,
378
 
                                       G_TYPE_INVALID)) {
379
 
                        while (shared_list != NULL) {
380
 
                                GHashTable *hash = (GHashTable *) shared_list->data;
381
 
 
382
 
                                share_info = syncdaemon_share_info_new_from_hash_table (hash);
383
 
 
384
 
                                shared_list = g_slist_remove (shared_list, hash);
385
 
                                g_hash_table_unref (hash);
386
 
 
387
 
                                g_hash_table_insert (interface->priv->shared,
388
 
                                                     g_strdup (syncdaemon_share_info_get_path (share_info)),
389
 
                                                     share_info);
390
 
                        }
391
 
                } else {
392
 
                        SyncdaemonDaemon *daemon = NULL;
393
 
 
394
 
                        g_object_get (G_OBJECT (interface), "daemon", &daemon, NULL);
395
 
                        if (daemon != NULL)
396
 
                                g_signal_emit_by_name (daemon, "error", error->message, NULL);
397
 
 
398
 
                        g_error_free (error);
399
 
 
400
 
                        return NULL;
401
 
                }
402
 
        }
403
 
 
404
 
        /* Create the list to be returned */
405
 
        g_hash_table_iter_init (&iter, interface->priv->shared);
406
 
        while (g_hash_table_iter_next (&iter, (gpointer *) &path, (gpointer *) &share_info))
407
 
                returned_list = g_slist_append (returned_list, share_info);
408
 
 
409
 
        return returned_list;
410
 
}
411
 
 
412
 
/**
413
 
 * syncdaemon_shares_interface_get_shares:
414
 
 */
415
 
GSList *
416
 
syncdaemon_shares_interface_get_shares (SyncdaemonSharesInterface *interface)
417
 
{
418
 
        GHashTableIter iter;
419
 
        gchar *path;
420
 
        SyncdaemonShareInfo *share_info;
421
 
        GSList *shares_list, *returned_list = NULL;;
422
 
        GError *error = NULL;
423
 
 
424
 
        g_return_val_if_fail (SYNCDAEMON_IS_SHARES_INTERFACE (interface), NULL);
425
 
 
426
 
        if (interface->priv->shares == NULL) {
427
 
                interface->priv->shares = g_hash_table_new_full (g_str_hash, g_str_equal,
428
 
                                                                 g_free, g_object_unref);
429
 
 
430
 
                if (dbus_g_proxy_call (DBUS_G_PROXY (interface->priv->proxy), "get_shares", &error,
431
 
                                       G_TYPE_INVALID,
432
 
                                       dbus_g_type_get_collection ("GSList",
433
 
                                                                   dbus_g_type_get_map (
434
 
                                                                           "GHashTable",
435
 
                                                                           G_TYPE_STRING,
436
 
                                                                           G_TYPE_STRING)), &shares_list,
437
 
                                       G_TYPE_INVALID)) {
438
 
                        while (shares_list != NULL) {
439
 
                                GHashTable *hash = (GHashTable *) shares_list->data;
440
 
 
441
 
                                share_info = syncdaemon_share_info_new_from_hash_table (hash);
442
 
 
443
 
                                shares_list = g_slist_remove (shares_list, hash);
444
 
                                g_hash_table_unref (hash);
445
 
 
446
 
                                g_hash_table_insert (interface->priv->shares,
447
 
                                                     g_strdup (syncdaemon_share_info_get_path (share_info)),
448
 
                                                     share_info);
449
 
                        }
450
 
                } else {
451
 
                        SyncdaemonDaemon *daemon = NULL;
452
 
 
453
 
                        g_object_get (G_OBJECT (interface), "daemon", &daemon, NULL);
454
 
                        if (daemon != NULL)
455
 
                                g_signal_emit_by_name (daemon, "error", error->message, NULL);
456
 
 
457
 
                        g_error_free (error);
458
 
 
459
 
                        return NULL;
460
 
                }
461
 
        }
462
 
 
463
 
        /* Create the list to be returned */
464
 
        g_hash_table_iter_init (&iter, interface->priv->shares);
465
 
        while (g_hash_table_iter_next (&iter, (gpointer) &path, (gpointer) &share_info))
466
 
                returned_list = g_slist_append (returned_list, share_info);
467
 
 
468
 
        return returned_list;
469
 
}
470
 
 
471
 
/**
472
 
 * syncdaemon_shares_interface_refresh:
473
 
 */
474
 
void
475
 
syncdaemon_shares_interface_refresh (SyncdaemonSharesInterface *interface)
476
 
{
477
 
        g_return_if_fail (SYNCDAEMON_IS_SHARES_INTERFACE (interface));
478
 
 
479
 
        dbus_g_proxy_begin_call (DBUS_G_PROXY (interface->priv->proxy), "refresh_shares",
480
 
                                 no_output_dbus_call_ended_cb, interface, NULL,
481
 
                                 G_TYPE_INVALID);
482
 
}
483
 
 
484
 
/**
485
 
 * syncdaemon_shares_interface_reject:
486
 
 */
487
 
void
488
 
syncdaemon_shares_interface_reject (SyncdaemonSharesInterface *interface, const gchar *share_id)
489
 
{
490
 
        g_return_if_fail (SYNCDAEMON_IS_SHARES_INTERFACE (interface));
491
 
        g_return_if_fail (share_id != NULL);
492
 
 
493
 
        dbus_g_proxy_begin_call (DBUS_G_PROXY (interface->priv->proxy), "reject_share",
494
 
                                 no_output_dbus_call_ended_cb, interface, NULL,
495
 
                                 G_TYPE_STRING, share_id,
496
 
                                 G_TYPE_INVALID);
497
 
}