← Back to branch summary

~timchen119/+junk/bluez5-trusty

« back to all changes in this revision

Viewing changes to tools/obexctl.c

  • Committer: tim
  • Date: 2015-09-04 08:03:03 UTC
  • Revision ID: tim@tim-inspiron-5442-20150904080303-75u7z8bdsl17xz8q
* init

Show diffs side-by-side

added added

removed removed

Lines of Context:
tools/obexctl.c
 
1
/*
 
2
 *
 
3
 *  BlueZ - Bluetooth protocol stack for Linux
 
4
 *
 
5
 *  Copyright (C) 2013  Intel Corporation. All rights reserved.
 
6
 *
 
7
 *
 
8
 *  This program is free software; you can redistribute it and/or modify
 
9
 *  it under the terms of the GNU General Public License as published by
 
10
 *  the Free Software Foundation; either version 2 of the License, or
 
11
 *  (at your option) any later version.
 
12
 *
 
13
 *  This program is distributed in the hope that it will be useful,
 
14
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 
15
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
16
 *  GNU General Public License for more details.
 
17
 *
 
18
 *  You should have received a copy of the GNU General Public License
 
19
 *  along with this program; if not, write to the Free Software
 
20
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
21
 *
 
22
 */
 
23
 
 
24
#ifdef HAVE_CONFIG_H
 
25
#include <config.h>
 
26
#endif
 
27
 
 
28
#include <stdio.h>
 
29
#include <stdbool.h>
 
30
#include <errno.h>
 
31
#include <unistd.h>
 
32
#include <stdlib.h>
 
33
#include <signal.h>
 
34
#include <sys/signalfd.h>
 
35
#include <inttypes.h>
 
36
#include <wordexp.h>
 
37
 
 
38
#include <readline/readline.h>
 
39
#include <readline/history.h>
 
40
#include <glib.h>
 
41
 
 
42
#include "gdbus/gdbus.h"
 
43
#include "client/display.h"
 
44
 
 
45
/* String display constants */
 
46
#define COLORED_NEW     COLOR_GREEN "NEW" COLOR_OFF
 
47
#define COLORED_CHG     COLOR_YELLOW "CHG" COLOR_OFF
 
48
#define COLORED_DEL     COLOR_RED "DEL" COLOR_OFF
 
49
 
 
50
#define PROMPT_ON       COLOR_BLUE "[obex]" COLOR_OFF "# "
 
51
#define PROMPT_OFF      "[obex]# "
 
52
 
 
53
#define OBEX_SESSION_INTERFACE "org.bluez.obex.Session1"
 
54
#define OBEX_TRANSFER_INTERFACE "org.bluez.obex.Transfer1"
 
55
#define OBEX_CLIENT_INTERFACE "org.bluez.obex.Client1"
 
56
#define OBEX_OPP_INTERFACE "org.bluez.obex.ObjectPush1"
 
57
#define OBEX_FTP_INTERFACE "org.bluez.obex.FileTransfer1"
 
58
#define OBEX_PBAP_INTERFACE "org.bluez.obex.PhonebookAccess1"
 
59
#define OBEX_MAP_INTERFACE "org.bluez.obex.MessageAccess1"
 
60
#define OBEX_MSG_INTERFACE "org.bluez.obex.Message1"
 
61
 
 
62
static GMainLoop *main_loop;
 
63
static DBusConnection *dbus_conn;
 
64
static GDBusProxy *default_session;
 
65
static GSList *sessions = NULL;
 
66
static GSList *opps = NULL;
 
67
static GSList *ftps = NULL;
 
68
static GSList *pbaps = NULL;
 
69
static GSList *maps = NULL;
 
70
static GSList *msgs = NULL;
 
71
static GSList *transfers = NULL;
 
72
static GDBusProxy *client = NULL;
 
73
 
 
74
struct transfer_data {
 
75
        uint64_t transferred;
 
76
        uint64_t size;
 
77
};
 
78
 
 
79
static void connect_handler(DBusConnection *connection, void *user_data)
 
80
{
 
81
        rl_set_prompt(PROMPT_ON);
 
82
        printf("\r");
 
83
        rl_on_new_line();
 
84
        rl_redisplay();
 
85
}
 
86
 
 
87
static void disconnect_handler(DBusConnection *connection, void *user_data)
 
88
{
 
89
        rl_set_prompt(PROMPT_OFF);
 
90
        printf("\r");
 
91
        rl_on_new_line();
 
92
        rl_redisplay();
 
93
}
 
94
 
 
95
static void cmd_quit(int argc, char *argv[])
 
96
{
 
97
        g_main_loop_quit(main_loop);
 
98
}
 
99
 
 
100
static void connect_reply(DBusMessage *message, void *user_data)
 
101
{
 
102
        DBusError error;
 
103
 
 
104
        dbus_error_init(&error);
 
105
 
 
106
        if (dbus_set_error_from_message(&error, message) == TRUE) {
 
107
                rl_printf("Failed to connect: %s\n", error.name);
 
108
                dbus_error_free(&error);
 
109
                return;
 
110
        }
 
111
 
 
112
        rl_printf("Connection successful\n");
 
113
}
 
114
 
 
115
static void append_variant(DBusMessageIter *iter, int type, void *val)
 
116
{
 
117
        DBusMessageIter value;
 
118
        char sig[2] = { type, '\0' };
 
119
 
 
120
        dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT, sig, &value);
 
121
 
 
122
        dbus_message_iter_append_basic(&value, type, val);
 
123
 
 
124
        dbus_message_iter_close_container(iter, &value);
 
125
}
 
126
 
 
127
static void dict_append_entry(DBusMessageIter *dict, const char *key,
 
128
                                                        int type, void *val)
 
129
{
 
130
        DBusMessageIter entry;
 
131
 
 
132
        if (type == DBUS_TYPE_STRING) {
 
133
                const char *str = *((const char **) val);
 
134
                if (str == NULL)
 
135
                        return;
 
136
        }
 
137
 
 
138
        dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY,
 
139
                                                        NULL, &entry);
 
140
 
 
141
        dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
 
142
 
 
143
        append_variant(&entry, type, val);
 
144
 
 
145
        dbus_message_iter_close_container(dict, &entry);
 
146
}
 
147
 
 
148
struct connect_args {
 
149
        char *dev;
 
150
        char *target;
 
151
};
 
152
 
 
153
static void connect_args_free(void *data)
 
154
{
 
155
        struct connect_args *args = data;
 
156
 
 
157
        g_free(args->dev);
 
158
        g_free(args->target);
 
159
        g_free(args);
 
160
}
 
161
 
 
162
static void connect_setup(DBusMessageIter *iter, void *user_data)
 
163
{
 
164
        struct connect_args *args = user_data;
 
165
        DBusMessageIter dict;
 
166
 
 
167
        dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &args->dev);
 
168
 
 
169
        dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
 
170
                                        DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
 
171
                                        DBUS_TYPE_STRING_AS_STRING
 
172
                                        DBUS_TYPE_VARIANT_AS_STRING
 
173
                                        DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
 
174
                                        &dict);
 
175
 
 
176
        if (args->target == NULL)
 
177
                goto done;
 
178
 
 
179
        dict_append_entry(&dict, "Target", DBUS_TYPE_STRING, &args->target);
 
180
 
 
181
done:
 
182
        dbus_message_iter_close_container(iter, &dict);
 
183
}
 
184
 
 
185
static void cmd_connect(int argc, char *argv[])
 
186
{
 
187
        struct connect_args *args;
 
188
        const char *target = "opp";
 
189
 
 
190
        if (argc < 2) {
 
191
                rl_printf("Missing device address argument\n");
 
192
                return;
 
193
        }
 
194
 
 
195
        if (!client) {
 
196
                rl_printf("Client proxy not available\n");
 
197
                return;
 
198
        }
 
199
 
 
200
        if (argc > 2)
 
201
                target = argv[2];
 
202
 
 
203
        args = g_new0(struct connect_args, 1);
 
204
        args->dev = g_strdup(argv[1]);
 
205
        args->target = g_strdup(target);
 
206
 
 
207
        if (g_dbus_proxy_method_call(client, "CreateSession", connect_setup,
 
208
                        connect_reply, args, connect_args_free) == FALSE) {
 
209
                rl_printf("Failed to connect\n");
 
210
                return;
 
211
        }
 
212
 
 
213
        rl_printf("Attempting to connect to %s\n", argv[1]);
 
214
}
 
215
 
 
216
static void disconnect_reply(DBusMessage *message, void *user_data)
 
217
{
 
218
        DBusError error;
 
219
 
 
220
        dbus_error_init(&error);
 
221
 
 
222
        if (dbus_set_error_from_message(&error, message) == TRUE) {
 
223
                rl_printf("Failed to disconnect: %s\n", error.name);
 
224
                dbus_error_free(&error);
 
225
                return;
 
226
        }
 
227
 
 
228
        rl_printf("Disconnection successful\n");
 
229
}
 
230
 
 
231
static void disconnect_setup(DBusMessageIter *iter, void *user_data)
 
232
{
 
233
        GDBusProxy *proxy = user_data;
 
234
        const char *path;
 
235
 
 
236
        path = g_dbus_proxy_get_path(proxy);
 
237
 
 
238
        dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH, &path);
 
239
}
 
240
 
 
241
static GDBusProxy *find_session(const char *path)
 
242
{
 
243
        GSList *l;
 
244
 
 
245
        for (l = sessions; l; l = g_slist_next(l)) {
 
246
                GDBusProxy *proxy = l->data;
 
247
 
 
248
                if (strcmp(path, g_dbus_proxy_get_path(proxy)) == 0)
 
249
                        return proxy;
 
250
        }
 
251
 
 
252
        return NULL;
 
253
}
 
254
 
 
255
static void cmd_disconnect(int argc, char *argv[])
 
256
{
 
257
        GDBusProxy *proxy;
 
258
 
 
259
        if (argc > 1)
 
260
                proxy = find_session(argv[1]);
 
261
        else
 
262
                proxy = default_session;
 
263
 
 
264
        if (proxy == NULL) {
 
265
                rl_printf("Session not available\n");
 
266
                return;
 
267
        }
 
268
 
 
269
        if (g_dbus_proxy_method_call(client, "RemoveSession", disconnect_setup,
 
270
                                disconnect_reply, proxy, NULL) == FALSE) {
 
271
                rl_printf("Failed to disconnect\n");
 
272
                return;
 
273
        }
 
274
 
 
275
        rl_printf("Attempting to disconnect to %s\n",
 
276
                                                g_dbus_proxy_get_path(proxy));
 
277
}
 
278
 
 
279
static char *proxy_description(GDBusProxy *proxy, const char *title,
 
280
                                                const char *description)
 
281
{
 
282
        const char *path;
 
283
 
 
284
        path = g_dbus_proxy_get_path(proxy);
 
285
 
 
286
        return g_strdup_printf("%s%s%s%s %s ",
 
287
                                        description ? "[" : "",
 
288
                                        description ? : "",
 
289
                                        description ? "] " : "",
 
290
                                        title, path);
 
291
}
 
292
 
 
293
static void print_proxy(GDBusProxy *proxy, const char *title,
 
294
                                                        const char *description)
 
295
{
 
296
        char *str;
 
297
 
 
298
        str = proxy_description(proxy, title, description);
 
299
 
 
300
        rl_printf("%s%s\n", str, default_session == proxy ? "[default]" : "");
 
301
 
 
302
        g_free(str);
 
303
}
 
304
 
 
305
static void cmd_list(int argc, char *arg[])
 
306
{
 
307
        GSList *l;
 
308
 
 
309
        for (l = sessions; l; l = g_slist_next(l)) {
 
310
                GDBusProxy *proxy = l->data;
 
311
                print_proxy(proxy, "Session", NULL);
 
312
        }
 
313
}
 
314
 
 
315
static bool check_default_session(void)
 
316
{
 
317
        if (!default_session) {
 
318
                rl_printf("No default session available\n");
 
319
                return FALSE;
 
320
        }
 
321
 
 
322
        return TRUE;
 
323
}
 
324
 
 
325
static void print_iter(const char *label, const char *name,
 
326
                                                DBusMessageIter *iter)
 
327
{
 
328
        dbus_bool_t valbool;
 
329
        dbus_uint64_t valu64;
 
330
        dbus_uint32_t valu32;
 
331
        dbus_uint16_t valu16;
 
332
        dbus_int16_t vals16;
 
333
        const char *valstr;
 
334
        DBusMessageIter subiter;
 
335
 
 
336
        if (iter == NULL) {
 
337
                rl_printf("%s%s is nil\n", label, name);
 
338
                return;
 
339
        }
 
340
 
 
341
        switch (dbus_message_iter_get_arg_type(iter)) {
 
342
        case DBUS_TYPE_INVALID:
 
343
                rl_printf("%s%s is invalid\n", label, name);
 
344
                break;
 
345
        case DBUS_TYPE_STRING:
 
346
        case DBUS_TYPE_OBJECT_PATH:
 
347
                dbus_message_iter_get_basic(iter, &valstr);
 
348
                rl_printf("%s%s: %s\n", label, name, valstr);
 
349
                break;
 
350
        case DBUS_TYPE_BOOLEAN:
 
351
                dbus_message_iter_get_basic(iter, &valbool);
 
352
                rl_printf("%s%s: %s\n", label, name,
 
353
                                        valbool == TRUE ? "yes" : "no");
 
354
                break;
 
355
        case DBUS_TYPE_UINT64:
 
356
                dbus_message_iter_get_basic(iter, &valu64);
 
357
                rl_printf("%s%s: %" PRIu64 "\n", label, name, valu64);
 
358
                break;
 
359
        case DBUS_TYPE_UINT32:
 
360
                dbus_message_iter_get_basic(iter, &valu32);
 
361
                rl_printf("%s%s: 0x%08x\n", label, name, valu32);
 
362
                break;
 
363
        case DBUS_TYPE_UINT16:
 
364
                dbus_message_iter_get_basic(iter, &valu16);
 
365
                rl_printf("%s%s: 0x%04x\n", label, name, valu16);
 
366
                break;
 
367
        case DBUS_TYPE_INT16:
 
368
                dbus_message_iter_get_basic(iter, &vals16);
 
369
                rl_printf("%s%s: %d\n", label, name, vals16);
 
370
                break;
 
371
        case DBUS_TYPE_VARIANT:
 
372
                dbus_message_iter_recurse(iter, &subiter);
 
373
                print_iter(label, name, &subiter);
 
374
                break;
 
375
        case DBUS_TYPE_ARRAY:
 
376
                dbus_message_iter_recurse(iter, &subiter);
 
377
                while (dbus_message_iter_get_arg_type(&subiter) !=
 
378
                                                        DBUS_TYPE_INVALID) {
 
379
                        print_iter(label, name, &subiter);
 
380
                        dbus_message_iter_next(&subiter);
 
381
                }
 
382
                break;
 
383
        case DBUS_TYPE_DICT_ENTRY:
 
384
                dbus_message_iter_recurse(iter, &subiter);
 
385
                dbus_message_iter_get_basic(&subiter, &valstr);
 
386
                dbus_message_iter_next(&subiter);
 
387
                print_iter(label, valstr, &subiter);
 
388
                break;
 
389
        default:
 
390
                rl_printf("%s%s has unsupported type\n", label, name);
 
391
                break;
 
392
        }
 
393
}
 
394
 
 
395
static void print_property(GDBusProxy *proxy, const char *name)
 
396
{
 
397
        DBusMessageIter iter;
 
398
 
 
399
        if (g_dbus_proxy_get_property(proxy, name, &iter) == FALSE)
 
400
                return;
 
401
 
 
402
        print_iter("\t", name, &iter);
 
403
}
 
404
 
 
405
static void cmd_show(int argc, char *argv[])
 
406
{
 
407
        GDBusProxy *proxy;
 
408
 
 
409
        if (argc < 2) {
 
410
                if (check_default_session() == FALSE)
 
411
                        return;
 
412
 
 
413
                proxy = default_session;
 
414
        } else {
 
415
                proxy = find_session(argv[1]);
 
416
                if (!proxy) {
 
417
                        rl_printf("Session %s not available\n", argv[1]);
 
418
                        return;
 
419
                }
 
420
        }
 
421
 
 
422
        rl_printf("Session %s\n", g_dbus_proxy_get_path(proxy));
 
423
 
 
424
        print_property(proxy, "Destination");
 
425
        print_property(proxy, "Target");
 
426
}
 
427
 
 
428
static void set_default_session(GDBusProxy *proxy)
 
429
{
 
430
        char *desc;
 
431
        DBusMessageIter iter;
 
432
 
 
433
        default_session = proxy;
 
434
 
 
435
        if (!g_dbus_proxy_get_property(proxy, "Destination", &iter)) {
 
436
                desc = g_strdup(PROMPT_ON);
 
437
                goto done;
 
438
        }
 
439
 
 
440
        dbus_message_iter_get_basic(&iter, &desc);
 
441
        desc = g_strdup_printf(COLOR_BLUE "[%s]" COLOR_OFF "# ", desc);
 
442
 
 
443
done:
 
444
        rl_set_prompt(desc);
 
445
        rl_redisplay();
 
446
        g_free(desc);
 
447
}
 
448
 
 
449
static void cmd_select(int argc, char *argv[])
 
450
{
 
451
        GDBusProxy *proxy;
 
452
 
 
453
        if (argc < 2) {
 
454
                rl_printf("Missing session address argument\n");
 
455
                return;
 
456
        }
 
457
 
 
458
        proxy = find_session(argv[1]);
 
459
        if (proxy == NULL) {
 
460
                rl_printf("Session %s not available\n", argv[1]);
 
461
                return;
 
462
        }
 
463
 
 
464
        if (default_session == proxy)
 
465
                return;
 
466
 
 
467
        set_default_session(proxy);
 
468
 
 
469
        print_proxy(proxy, "Session", NULL);
 
470
}
 
471
 
 
472
static GDBusProxy *find_transfer(const char *path)
 
473
{
 
474
        GSList *l;
 
475
 
 
476
        for (l = transfers; l; l = g_slist_next(l)) {
 
477
                GDBusProxy *proxy = l->data;
 
478
 
 
479
                if (strcmp(path, g_dbus_proxy_get_path(proxy)) == 0)
 
480
                        return proxy;
 
481
        }
 
482
 
 
483
        return NULL;
 
484
}
 
485
 
 
486
static GDBusProxy *find_message(const char *path)
 
487
{
 
488
        GSList *l;
 
489
 
 
490
        for (l = msgs; l; l = g_slist_next(l)) {
 
491
                GDBusProxy *proxy = l->data;
 
492
 
 
493
                if (strcmp(path, g_dbus_proxy_get_path(proxy)) == 0)
 
494
                        return proxy;
 
495
        }
 
496
 
 
497
        return NULL;
 
498
}
 
499
 
 
500
static void transfer_info(GDBusProxy *proxy, int argc, char *argv[])
 
501
{
 
502
        rl_printf("Transfer %s\n", g_dbus_proxy_get_path(proxy));
 
503
 
 
504
        print_property(proxy, "Session");
 
505
        print_property(proxy, "Name");
 
506
        print_property(proxy, "Type");
 
507
        print_property(proxy, "Status");
 
508
        print_property(proxy, "Time");
 
509
        print_property(proxy, "Size");
 
510
        print_property(proxy, "Transferred");
 
511
        print_property(proxy, "Filename");
 
512
}
 
513
 
 
514
static void message_info(GDBusProxy *proxy, int argc, char *argv[])
 
515
{
 
516
        rl_printf("Message %s\n", g_dbus_proxy_get_path(proxy));
 
517
 
 
518
        print_property(proxy, "Folder");
 
519
        print_property(proxy, "Subject");
 
520
        print_property(proxy, "Timestamp");
 
521
        print_property(proxy, "Sender");
 
522
        print_property(proxy, "SenderAddress");
 
523
        print_property(proxy, "ReplyTo");
 
524
        print_property(proxy, "Recipient");
 
525
        print_property(proxy, "RecipientAddress");
 
526
        print_property(proxy, "Type");
 
527
        print_property(proxy, "Size");
 
528
        print_property(proxy, "Status");
 
529
        print_property(proxy, "Priority");
 
530
        print_property(proxy, "Read");
 
531
        print_property(proxy, "Deleted");
 
532
        print_property(proxy, "Sent");
 
533
        print_property(proxy, "Protected");
 
534
}
 
535
 
 
536
static void cmd_info(int argc, char *argv[])
 
537
{
 
538
        GDBusProxy *proxy;
 
539
 
 
540
        if (argc < 2) {
 
541
                rl_printf("Missing object path argument\n");
 
542
                return;
 
543
        }
 
544
 
 
545
        proxy = find_transfer(argv[1]);
 
546
        if (proxy) {
 
547
                transfer_info(proxy, argc, argv);
 
548
                return;
 
549
        }
 
550
 
 
551
        proxy = find_message(argv[1]);
 
552
        if (proxy) {
 
553
                message_info(proxy, argc, argv);
 
554
                return;
 
555
        }
 
556
 
 
557
        rl_printf("Object %s not available\n", argv[1]);
 
558
}
 
559
 
 
560
static void cancel_reply(DBusMessage *message, void *user_data)
 
561
{
 
562
        DBusError error;
 
563
 
 
564
        dbus_error_init(&error);
 
565
 
 
566
        if (dbus_set_error_from_message(&error, message) == TRUE) {
 
567
                rl_printf("Failed to cancel: %s\n", error.name);
 
568
                dbus_error_free(&error);
 
569
                return;
 
570
        }
 
571
 
 
572
        rl_printf("Cancel successful\n");
 
573
}
 
574
 
 
575
static void cmd_cancel(int argc, char *argv[])
 
576
{
 
577
        GDBusProxy *proxy;
 
578
 
 
579
        if (argc < 2) {
 
580
                rl_printf("Missing transfer address argument\n");
 
581
                return;
 
582
        }
 
583
 
 
584
        proxy = find_transfer(argv[1]);
 
585
        if (!proxy) {
 
586
                rl_printf("Transfer %s not available\n", argv[1]);
 
587
                return;
 
588
        }
 
589
 
 
590
        if (g_dbus_proxy_method_call(proxy, "Cancel", NULL, cancel_reply, NULL,
 
591
                                                        NULL) == FALSE) {
 
592
                rl_printf("Failed to cancel transfer\n");
 
593
                return;
 
594
        }
 
595
 
 
596
        rl_printf("Attempting to cancel transfer %s\n",
 
597
                                                g_dbus_proxy_get_path(proxy));
 
598
}
 
599
 
 
600
static void suspend_reply(DBusMessage *message, void *user_data)
 
601
{
 
602
        DBusError error;
 
603
 
 
604
        dbus_error_init(&error);
 
605
 
 
606
        if (dbus_set_error_from_message(&error, message) == TRUE) {
 
607
                rl_printf("Failed to suspend: %s\n", error.name);
 
608
                dbus_error_free(&error);
 
609
                return;
 
610
        }
 
611
 
 
612
        rl_printf("Suspend successful\n");
 
613
}
 
614
 
 
615
static void cmd_suspend(int argc, char *argv[])
 
616
{
 
617
        GDBusProxy *proxy;
 
618
 
 
619
        if (argc < 2) {
 
620
                rl_printf("Missing transfer address argument\n");
 
621
                return;
 
622
        }
 
623
 
 
624
        proxy = find_transfer(argv[1]);
 
625
        if (!proxy) {
 
626
                rl_printf("Transfer %s not available\n", argv[1]);
 
627
                return;
 
628
        }
 
629
 
 
630
        if (g_dbus_proxy_method_call(proxy, "Suspend", NULL, suspend_reply,
 
631
                                                NULL, NULL) == FALSE) {
 
632
                rl_printf("Failed to suspend transfer\n");
 
633
                return;
 
634
        }
 
635
 
 
636
        rl_printf("Attempting to suspend transfer %s\n",
 
637
                                                g_dbus_proxy_get_path(proxy));
 
638
}
 
639
 
 
640
static void resume_reply(DBusMessage *message, void *user_data)
 
641
{
 
642
        DBusError error;
 
643
 
 
644
        dbus_error_init(&error);
 
645
 
 
646
        if (dbus_set_error_from_message(&error, message) == TRUE) {
 
647
                rl_printf("Failed to resume: %s\n", error.name);
 
648
                dbus_error_free(&error);
 
649
                return;
 
650
        }
 
651
 
 
652
        rl_printf("Resume successful\n");
 
653
}
 
654
 
 
655
static void cmd_resume(int argc, char *argv[])
 
656
{
 
657
        GDBusProxy *proxy;
 
658
 
 
659
        if (argc < 2) {
 
660
                rl_printf("Missing transfer address argument\n");
 
661
                return;
 
662
        }
 
663
 
 
664
        proxy = find_transfer(argv[1]);
 
665
        if (!proxy) {
 
666
                rl_printf("Transfer %s not available\n", argv[1]);
 
667
                return;
 
668
        }
 
669
 
 
670
        if (g_dbus_proxy_method_call(proxy, "Resume", NULL, resume_reply,
 
671
                                                NULL, NULL) == FALSE) {
 
672
                rl_printf("Failed to resume transfer\n");
 
673
                return;
 
674
        }
 
675
 
 
676
        rl_printf("Attempting to resume transfer %s\n",
 
677
                                                g_dbus_proxy_get_path(proxy));
 
678
}
 
679
 
 
680
static GDBusProxy *find_opp(const char *path)
 
681
{
 
682
        GSList *l;
 
683
 
 
684
        for (l = opps; l; l = g_slist_next(l)) {
 
685
                GDBusProxy *proxy = l->data;
 
686
 
 
687
                if (strcmp(path, g_dbus_proxy_get_path(proxy)) == 0)
 
688
                        return proxy;
 
689
        }
 
690
 
 
691
        return NULL;
 
692
}
 
693
 
 
694
static GDBusProxy *find_map(const char *path)
 
695
{
 
696
        GSList *l;
 
697
 
 
698
        for (l = maps; l; l = g_slist_next(l)) {
 
699
                GDBusProxy *proxy = l->data;
 
700
 
 
701
                if (strcmp(path, g_dbus_proxy_get_path(proxy)) == 0)
 
702
                        return proxy;
 
703
        }
 
704
 
 
705
        return NULL;
 
706
}
 
707
 
 
708
static void print_dict_iter(DBusMessageIter *iter)
 
709
{
 
710
        DBusMessageIter dict;
 
711
        int ctype;
 
712
 
 
713
        ctype = dbus_message_iter_get_arg_type(iter);
 
714
        if (ctype != DBUS_TYPE_ARRAY)
 
715
                return;
 
716
 
 
717
        dbus_message_iter_recurse(iter, &dict);
 
718
 
 
719
        while ((ctype = dbus_message_iter_get_arg_type(&dict)) !=
 
720
                                                        DBUS_TYPE_INVALID) {
 
721
                DBusMessageIter entry;
 
722
                const char *key;
 
723
 
 
724
                if (ctype != DBUS_TYPE_DICT_ENTRY)
 
725
                        return;
 
726
 
 
727
                dbus_message_iter_recurse(&dict, &entry);
 
728
                if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING)
 
729
                        return;
 
730
 
 
731
                dbus_message_iter_get_basic(&entry, &key);
 
732
                dbus_message_iter_next(&entry);
 
733
 
 
734
                print_iter("\t", key, &entry);
 
735
 
 
736
                dbus_message_iter_next(&dict);
 
737
        }
 
738
}
 
739
 
 
740
static void print_transfer_iter(DBusMessageIter *iter)
 
741
{
 
742
        const char *path;
 
743
 
 
744
        dbus_message_iter_get_basic(iter, &path);
 
745
 
 
746
        rl_printf("Transfer %s\n", path);
 
747
 
 
748
        dbus_message_iter_next(iter);
 
749
 
 
750
        print_dict_iter(iter);
 
751
}
 
752
 
 
753
static void send_reply(DBusMessage *message, void *user_data)
 
754
{
 
755
        DBusMessageIter iter;
 
756
        DBusError error;
 
757
 
 
758
        dbus_error_init(&error);
 
759
 
 
760
        if (dbus_set_error_from_message(&error, message) == TRUE) {
 
761
                rl_printf("Failed to send/pull: %s\n", error.name);
 
762
                dbus_error_free(&error);
 
763
                return;
 
764
        }
 
765
 
 
766
        dbus_message_iter_init(message, &iter);
 
767
 
 
768
        print_transfer_iter(&iter);
 
769
}
 
770
 
 
771
static void send_setup(DBusMessageIter *iter, void *user_data)
 
772
{
 
773
        const char *file = user_data;
 
774
 
 
775
        dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &file);
 
776
}
 
777
 
 
778
static void opp_send(GDBusProxy *proxy, int argc, char *argv[])
 
779
{
 
780
        if (argc < 2) {
 
781
                rl_printf("Missing file argument\n");
 
782
                return;
 
783
        }
 
784
 
 
785
        if (g_dbus_proxy_method_call(proxy, "SendFile", send_setup, send_reply,
 
786
                                        g_strdup(argv[1]), g_free) == FALSE) {
 
787
                rl_printf("Failed to send\n");
 
788
                return;
 
789
        }
 
790
 
 
791
        rl_printf("Attempting to send %s to %s\n", argv[1],
 
792
                                                g_dbus_proxy_get_path(proxy));
 
793
}
 
794
 
 
795
static void opp_pull(GDBusProxy *proxy, int argc, char *argv[])
 
796
{
 
797
        if (argc < 2) {
 
798
                rl_printf("Missing file argument\n");
 
799
                return;
 
800
        }
 
801
 
 
802
        if (g_dbus_proxy_method_call(proxy, "PullBusinessCard", send_setup,
 
803
                        send_reply, g_strdup(argv[1]), g_free) == FALSE) {
 
804
                rl_printf("Failed to pull\n");
 
805
                return;
 
806
        }
 
807
 
 
808
        rl_printf("Attempting to pull %s from %s\n", argv[1],
 
809
                                                g_dbus_proxy_get_path(proxy));
 
810
}
 
811
 
 
812
static void push_reply(DBusMessage *message, void *user_data)
 
813
{
 
814
        DBusMessageIter iter;
 
815
        DBusError error;
 
816
 
 
817
        dbus_error_init(&error);
 
818
 
 
819
        if (dbus_set_error_from_message(&error, message) == TRUE) {
 
820
                rl_printf("Failed to PushMessage: %s\n", error.name);
 
821
                dbus_error_free(&error);
 
822
                return;
 
823
        }
 
824
 
 
825
        dbus_message_iter_init(message, &iter);
 
826
 
 
827
        print_transfer_iter(&iter);
 
828
}
 
829
 
 
830
static void push_setup(DBusMessageIter *iter, void *user_data)
 
831
{
 
832
        const char *file = user_data;
 
833
        const char *folder = "";
 
834
        DBusMessageIter dict;
 
835
 
 
836
        dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &file);
 
837
        dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &folder);
 
838
 
 
839
        dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
 
840
                                        DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
 
841
                                        DBUS_TYPE_STRING_AS_STRING
 
842
                                        DBUS_TYPE_VARIANT_AS_STRING
 
843
                                        DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
 
844
                                        &dict);
 
845
 
 
846
        dbus_message_iter_close_container(iter, &dict);
 
847
}
 
848
 
 
849
static void map_send(GDBusProxy *proxy, int argc, char *argv[])
 
850
{
 
851
        if (argc < 2) {
 
852
                rl_printf("Missing file argument\n");
 
853
                return;
 
854
        }
 
855
 
 
856
        if (g_dbus_proxy_method_call(proxy, "PushMessage", push_setup,
 
857
                                        push_reply, g_strdup(argv[1]),
 
858
                                        g_free) == FALSE) {
 
859
                rl_printf("Failed to send\n");
 
860
                return;
 
861
        }
 
862
 
 
863
        rl_printf("Attempting to send %s to %s\n", argv[1],
 
864
                                                g_dbus_proxy_get_path(proxy));
 
865
}
 
866
 
 
867
static void cmd_send(int argc, char *argv[])
 
868
{
 
869
        GDBusProxy *proxy;
 
870
 
 
871
        if (!check_default_session())
 
872
                return;
 
873
 
 
874
        proxy = find_opp(g_dbus_proxy_get_path(default_session));
 
875
        if (proxy) {
 
876
                opp_send(proxy, argc, argv);
 
877
                return;
 
878
        }
 
879
 
 
880
        proxy = find_map(g_dbus_proxy_get_path(default_session));
 
881
        if (proxy) {
 
882
                map_send(proxy, argc, argv);
 
883
                return;
 
884
        }
 
885
 
 
886
        rl_printf("Command not supported\n");
 
887
}
 
888
 
 
889
static void cmd_pull(int argc, char *argv[])
 
890
{
 
891
        GDBusProxy *proxy;
 
892
 
 
893
        if (!check_default_session())
 
894
                return;
 
895
 
 
896
        proxy = find_opp(g_dbus_proxy_get_path(default_session));
 
897
        if (proxy) {
 
898
                opp_pull(proxy, argc, argv);
 
899
                return;
 
900
        }
 
901
 
 
902
        rl_printf("Command not supported\n");
 
903
}
 
904
 
 
905
static void change_folder_reply(DBusMessage *message, void *user_data)
 
906
{
 
907
        DBusError error;
 
908
 
 
909
        dbus_error_init(&error);
 
910
 
 
911
        if (dbus_set_error_from_message(&error, message) == TRUE) {
 
912
                rl_printf("Failed to ChangeFolder: %s\n", error.name);
 
913
                dbus_error_free(&error);
 
914
                return;
 
915
        }
 
916
 
 
917
        rl_printf("ChangeFolder successful\n");
 
918
}
 
919
 
 
920
static void change_folder_setup(DBusMessageIter *iter, void *user_data)
 
921
{
 
922
        const char *folder = user_data;
 
923
 
 
924
        dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &folder);
 
925
}
 
926
 
 
927
static void select_reply(DBusMessage *message, void *user_data)
 
928
{
 
929
        DBusMessageIter iter;
 
930
        DBusError error;
 
931
 
 
932
        dbus_error_init(&error);
 
933
 
 
934
        if (dbus_set_error_from_message(&error, message) == TRUE) {
 
935
                rl_printf("Failed to Select: %s\n", error.name);
 
936
                dbus_error_free(&error);
 
937
                return;
 
938
        }
 
939
 
 
940
        dbus_message_iter_init(message, &iter);
 
941
 
 
942
        rl_printf("Select successful\n");
 
943
}
 
944
 
 
945
static void select_setup(DBusMessageIter *iter, void *user_data)
 
946
{
 
947
        const char *folder = user_data;
 
948
        const char *location = "int";
 
949
 
 
950
        dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &location);
 
951
        dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &folder);
 
952
}
 
953
 
 
954
static void setfolder_reply(DBusMessage *message, void *user_data)
 
955
{
 
956
        DBusError error;
 
957
 
 
958
        dbus_error_init(&error);
 
959
 
 
960
        if (dbus_set_error_from_message(&error, message) == TRUE) {
 
961
                rl_printf("Failed to SetFolder: %s\n", error.name);
 
962
                dbus_error_free(&error);
 
963
                return;
 
964
        }
 
965
 
 
966
        rl_printf("SetFolder successful\n");
 
967
}
 
968
 
 
969
static void setfolder_setup(DBusMessageIter *iter, void *user_data)
 
970
{
 
971
        const char *folder = user_data;
 
972
 
 
973
        dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &folder);
 
974
}
 
975
 
 
976
static GDBusProxy *find_ftp(const char *path)
 
977
{
 
978
        GSList *l;
 
979
 
 
980
        for (l = ftps; l; l = g_slist_next(l)) {
 
981
                GDBusProxy *proxy = l->data;
 
982
 
 
983
                if (strcmp(path, g_dbus_proxy_get_path(proxy)) == 0)
 
984
                        return proxy;
 
985
        }
 
986
 
 
987
        return NULL;
 
988
}
 
989
 
 
990
static GDBusProxy *find_pbap(const char *path)
 
991
{
 
992
        GSList *l;
 
993
 
 
994
        for (l = pbaps; l; l = g_slist_next(l)) {
 
995
                GDBusProxy *proxy = l->data;
 
996
 
 
997
                if (strcmp(path, g_dbus_proxy_get_path(proxy)) == 0)
 
998
                        return proxy;
 
999
        }
 
1000
 
 
1001
        return NULL;
 
1002
}
 
1003
 
 
1004
static void ftp_cd(GDBusProxy *proxy, int argc, char *argv[])
 
1005
{
 
1006
        if (argc < 2) {
 
1007
                rl_printf("Missing path argument\n");
 
1008
                return;
 
1009
        }
 
1010
 
 
1011
        if (g_dbus_proxy_method_call(proxy, "ChangeFolder", change_folder_setup,
 
1012
                                        change_folder_reply, g_strdup(argv[1]),
 
1013
                                        g_free) == FALSE) {
 
1014
                rl_printf("Failed to ChangeFolder\n");
 
1015
                return;
 
1016
        }
 
1017
 
 
1018
        rl_printf("Attempting to ChangeFolder to %s\n", argv[1]);
 
1019
}
 
1020
 
 
1021
static void pbap_cd(GDBusProxy *proxy, int argc, char *argv[])
 
1022
{
 
1023
        if (argc < 2) {
 
1024
                rl_printf("Missing path argument\n");
 
1025
                return;
 
1026
        }
 
1027
 
 
1028
        if (g_dbus_proxy_method_call(proxy, "Select", select_setup,
 
1029
                                        select_reply, g_strdup(argv[1]),
 
1030
                                        g_free) == FALSE) {
 
1031
                rl_printf("Failed to Select\n");
 
1032
                return;
 
1033
        }
 
1034
 
 
1035
        rl_printf("Attempting to Select to %s\n", argv[1]);
 
1036
}
 
1037
 
 
1038
static void map_cd(GDBusProxy *proxy, int argc, char *argv[])
 
1039
{
 
1040
        if (argc < 2) {
 
1041
                rl_printf("Missing path argument\n");
 
1042
                return;
 
1043
        }
 
1044
 
 
1045
        if (g_dbus_proxy_method_call(proxy, "SetFolder", setfolder_setup,
 
1046
                                        setfolder_reply, g_strdup(argv[1]),
 
1047
                                        g_free) == FALSE) {
 
1048
                rl_printf("Failed to SetFolder\n");
 
1049
                return;
 
1050
        }
 
1051
 
 
1052
        rl_printf("Attempting to SetFolder to %s\n", argv[1]);
 
1053
}
 
1054
 
 
1055
static void cmd_cd(int argc, char *argv[])
 
1056
{
 
1057
        GDBusProxy *proxy;
 
1058
 
 
1059
        if (!check_default_session())
 
1060
                return;
 
1061
 
 
1062
        proxy = find_ftp(g_dbus_proxy_get_path(default_session));
 
1063
        if (proxy) {
 
1064
                ftp_cd(proxy, argc, argv);
 
1065
                return;
 
1066
        }
 
1067
 
 
1068
        proxy = find_pbap(g_dbus_proxy_get_path(default_session));
 
1069
        if (proxy) {
 
1070
                pbap_cd(proxy, argc, argv);
 
1071
                return;
 
1072
        }
 
1073
 
 
1074
        proxy = find_map(g_dbus_proxy_get_path(default_session));
 
1075
        if (proxy) {
 
1076
                map_cd(proxy, argc, argv);
 
1077
                return;
 
1078
        }
 
1079
 
 
1080
        rl_printf("Command not supported\n");
 
1081
}
 
1082
 
 
1083
static void list_folder_reply(DBusMessage *message, void *user_data)
 
1084
{
 
1085
        DBusMessageIter iter, array;
 
1086
        DBusError error;
 
1087
 
 
1088
        dbus_error_init(&error);
 
1089
 
 
1090
        if (dbus_set_error_from_message(&error, message) == TRUE) {
 
1091
                rl_printf("Failed to ListFolder: %s\n", error.name);
 
1092
                dbus_error_free(&error);
 
1093
                return;
 
1094
        }
 
1095
 
 
1096
        dbus_message_iter_init(message, &iter);
 
1097
 
 
1098
        if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY)
 
1099
                return;
 
1100
 
 
1101
        dbus_message_iter_recurse(&iter, &array);
 
1102
 
 
1103
        while (dbus_message_iter_get_arg_type(&array) != DBUS_TYPE_INVALID) {
 
1104
                print_dict_iter(&array);
 
1105
                dbus_message_iter_next(&array);
 
1106
        }
 
1107
}
 
1108
 
 
1109
static void ftp_ls(GDBusProxy *proxy, int argc, char *argv[])
 
1110
{
 
1111
        if (g_dbus_proxy_method_call(proxy, "ListFolder", NULL,
 
1112
                                                list_folder_reply, NULL,
 
1113
                                                NULL) == FALSE) {
 
1114
                rl_printf("Failed to ls\n");
 
1115
                return;
 
1116
        }
 
1117
 
 
1118
        rl_printf("Attempting to ListFolder\n");
 
1119
}
 
1120
 
 
1121
static void parse_list_reply(DBusMessage *message)
 
1122
{
 
1123
        DBusMessageIter iter, array;
 
1124
 
 
1125
        dbus_message_iter_init(message, &iter);
 
1126
 
 
1127
        if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY)
 
1128
                return;
 
1129
 
 
1130
        dbus_message_iter_recurse(&iter, &array);
 
1131
 
 
1132
        while (dbus_message_iter_get_arg_type(&array) != DBUS_TYPE_INVALID) {
 
1133
                DBusMessageIter entry;
 
1134
                const char *vcard;
 
1135
 
 
1136
                if (dbus_message_iter_get_arg_type(&array) != DBUS_TYPE_STRUCT)
 
1137
                        return;
 
1138
 
 
1139
                dbus_message_iter_recurse(&array, &entry);
 
1140
 
 
1141
                dbus_message_iter_get_basic(&entry, &vcard);
 
1142
                dbus_message_iter_next(&entry);
 
1143
                print_iter("\t", vcard, &entry);
 
1144
                dbus_message_iter_next(&array);
 
1145
        }
 
1146
}
 
1147
 
 
1148
static void list_reply(DBusMessage *message, void *user_data)
 
1149
{
 
1150
        DBusError error;
 
1151
 
 
1152
        dbus_error_init(&error);
 
1153
 
 
1154
        if (dbus_set_error_from_message(&error, message) == TRUE) {
 
1155
                rl_printf("Failed to List: %s\n", error.name);
 
1156
                dbus_error_free(&error);
 
1157
                return;
 
1158
        }
 
1159
 
 
1160
        parse_list_reply(message);
 
1161
}
 
1162
 
 
1163
static void list_setup(DBusMessageIter *iter, void *user_data)
 
1164
{
 
1165
        DBusMessageIter dict;
 
1166
 
 
1167
        dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
 
1168
                                        DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
 
1169
                                        DBUS_TYPE_STRING_AS_STRING
 
1170
                                        DBUS_TYPE_VARIANT_AS_STRING
 
1171
                                        DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
 
1172
                                        &dict);
 
1173
 
 
1174
        dbus_message_iter_close_container(iter, &dict);
 
1175
}
 
1176
 
 
1177
static void search_reply(DBusMessage *message, void *user_data)
 
1178
{
 
1179
        DBusError error;
 
1180
 
 
1181
        dbus_error_init(&error);
 
1182
 
 
1183
        if (dbus_set_error_from_message(&error, message) == TRUE) {
 
1184
                rl_printf("Failed to Search: %s\n", error.name);
 
1185
                dbus_error_free(&error);
 
1186
                return;
 
1187
        }
 
1188
 
 
1189
        parse_list_reply(message);
 
1190
}
 
1191
 
 
1192
static void search_setup(DBusMessageIter *iter, void *user_data)
 
1193
{
 
1194
        const char *value = user_data;
 
1195
        const char *field;
 
1196
        DBusMessageIter dict;
 
1197
 
 
1198
        field = isalpha(value[0]) ? "name" : "number";
 
1199
 
 
1200
        dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &field);
 
1201
        dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &value);
 
1202
 
 
1203
        dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
 
1204
                                        DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
 
1205
                                        DBUS_TYPE_STRING_AS_STRING
 
1206
                                        DBUS_TYPE_VARIANT_AS_STRING
 
1207
                                        DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
 
1208
                                        &dict);
 
1209
 
 
1210
        dbus_message_iter_close_container(iter, &dict);
 
1211
}
 
1212
 
 
1213
static void pbap_search(GDBusProxy *proxy, int argc, char *argv[])
 
1214
{
 
1215
        if (g_dbus_proxy_method_call(proxy, "Search", search_setup,
 
1216
                                        search_reply, g_strdup(argv[1]),
 
1217
                                        g_free) == FALSE) {
 
1218
                rl_printf("Failed to Search\n");
 
1219
                return;
 
1220
        }
 
1221
 
 
1222
        rl_printf("Attempting to Search\n");
 
1223
}
 
1224
 
 
1225
static void list_folders_reply(DBusMessage *message, void *user_data)
 
1226
{
 
1227
        DBusError error;
 
1228
        DBusMessageIter iter, array;
 
1229
 
 
1230
        dbus_error_init(&error);
 
1231
 
 
1232
        if (dbus_set_error_from_message(&error, message) == TRUE) {
 
1233
                rl_printf("Failed to ListFolders: %s\n", error.name);
 
1234
                dbus_error_free(&error);
 
1235
                return;
 
1236
        }
 
1237
 
 
1238
        dbus_message_iter_init(message, &iter);
 
1239
 
 
1240
        if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY)
 
1241
                return;
 
1242
 
 
1243
        dbus_message_iter_recurse(&iter, &array);
 
1244
 
 
1245
        while (dbus_message_iter_get_arg_type(&array) != DBUS_TYPE_INVALID) {
 
1246
                print_dict_iter(&array);
 
1247
                dbus_message_iter_next(&array);
 
1248
        }
 
1249
}
 
1250
 
 
1251
static void list_folders_setup(DBusMessageIter *iter, void *user_data)
 
1252
{
 
1253
        DBusMessageIter dict;
 
1254
 
 
1255
        dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
 
1256
                                        DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
 
1257
                                        DBUS_TYPE_STRING_AS_STRING
 
1258
                                        DBUS_TYPE_VARIANT_AS_STRING
 
1259
                                        DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
 
1260
                                        &dict);
 
1261
 
 
1262
        dbus_message_iter_close_container(iter, &dict);
 
1263
}
 
1264
 
 
1265
static void list_messages_reply(DBusMessage *message, void *user_data)
 
1266
{
 
1267
        DBusError error;
 
1268
        DBusMessageIter iter, array;
 
1269
 
 
1270
        dbus_error_init(&error);
 
1271
 
 
1272
        if (dbus_set_error_from_message(&error, message) == TRUE) {
 
1273
                rl_printf("Failed to ListFolders: %s\n", error.name);
 
1274
                dbus_error_free(&error);
 
1275
                return;
 
1276
        }
 
1277
 
 
1278
        dbus_message_iter_init(message, &iter);
 
1279
 
 
1280
        if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY)
 
1281
                return;
 
1282
 
 
1283
        dbus_message_iter_recurse(&iter, &array);
 
1284
 
 
1285
        while ((dbus_message_iter_get_arg_type(&array)) ==
 
1286
                                                DBUS_TYPE_DICT_ENTRY) {
 
1287
                DBusMessageIter entry;
 
1288
                const char *obj;
 
1289
 
 
1290
                dbus_message_iter_recurse(&array, &entry);
 
1291
                dbus_message_iter_get_basic(&entry, &obj);
 
1292
                rl_printf("\t%s\n", obj);
 
1293
                dbus_message_iter_next(&array);
 
1294
        }
 
1295
}
 
1296
 
 
1297
static void list_messages_setup(DBusMessageIter *iter, void *user_data)
 
1298
{
 
1299
        const char *folder = user_data;
 
1300
        DBusMessageIter dict;
 
1301
 
 
1302
        if (strcmp(folder, "*") == 0)
 
1303
                folder = "";
 
1304
 
 
1305
        dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &folder);
 
1306
 
 
1307
        dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
 
1308
                                        DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
 
1309
                                        DBUS_TYPE_STRING_AS_STRING
 
1310
                                        DBUS_TYPE_VARIANT_AS_STRING
 
1311
                                        DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
 
1312
                                        &dict);
 
1313
 
 
1314
        dbus_message_iter_close_container(iter, &dict);
 
1315
}
 
1316
 
 
1317
static void pbap_list(GDBusProxy *proxy, int argc, char *argv[])
 
1318
{
 
1319
        if (g_dbus_proxy_method_call(proxy, "List", list_setup, list_reply,
 
1320
                                                NULL, NULL) == FALSE) {
 
1321
                rl_printf("Failed to List\n");
 
1322
                return;
 
1323
        }
 
1324
 
 
1325
        rl_printf("Attempting to List\n");
 
1326
}
 
1327
 
 
1328
static void get_size_reply(DBusMessage *message, void *user_data)
 
1329
{
 
1330
        GDBusProxy *proxy = user_data;
 
1331
        DBusError error;
 
1332
        DBusMessageIter iter;
 
1333
 
 
1334
        dbus_error_init(&error);
 
1335
 
 
1336
        if (dbus_set_error_from_message(&error, message) == TRUE) {
 
1337
                rl_printf("Failed to GetSize: %s\n", error.name);
 
1338
                dbus_error_free(&error);
 
1339
                return;
 
1340
        }
 
1341
 
 
1342
        dbus_message_iter_init(message, &iter);
 
1343
 
 
1344
        print_iter("\t", "Size", &iter);
 
1345
 
 
1346
        pbap_list(proxy, 0, NULL);
 
1347
}
 
1348
 
 
1349
static void pbap_get_size(GDBusProxy *proxy, int argc, char *argv[])
 
1350
{
 
1351
        if (g_dbus_proxy_method_call(proxy, "GetSize", NULL, get_size_reply,
 
1352
                                                proxy, NULL) == FALSE) {
 
1353
                rl_printf("Failed to GetSize\n");
 
1354
                return;
 
1355
        }
 
1356
 
 
1357
        rl_printf("Attempting to GetSize\n");
 
1358
}
 
1359
 
 
1360
static void pbap_ls(GDBusProxy *proxy, int argc, char *argv[])
 
1361
{
 
1362
        if (argc > 1) {
 
1363
                if (strcmp("-l", argv[1]))
 
1364
                        pbap_search(proxy, argc, argv);
 
1365
                else
 
1366
                        pbap_get_size(proxy, argc, argv);
 
1367
                return;
 
1368
        }
 
1369
 
 
1370
        pbap_list(proxy, argc, argv);
 
1371
}
 
1372
 
 
1373
static void map_ls_messages(GDBusProxy *proxy, int argc, char *argv[])
 
1374
{
 
1375
        if (g_dbus_proxy_method_call(proxy, "ListMessages", list_messages_setup,
 
1376
                                        list_messages_reply, g_strdup(argv[1]),
 
1377
                                        g_free) == FALSE) {
 
1378
                rl_printf("Failed to ListMessages\n");
 
1379
                return;
 
1380
        }
 
1381
 
 
1382
        rl_printf("Attempting to ListMessages\n");
 
1383
}
 
1384
 
 
1385
static void map_ls(GDBusProxy *proxy, int argc, char *argv[])
 
1386
{
 
1387
        if (argc > 1) {
 
1388
                map_ls_messages(proxy, argc, argv);
 
1389
                return;
 
1390
        }
 
1391
 
 
1392
        if (g_dbus_proxy_method_call(proxy, "ListFolders", list_folders_setup,
 
1393
                                                list_folders_reply, NULL,
 
1394
                                                NULL) == FALSE) {
 
1395
                rl_printf("Failed to ListFolders\n");
 
1396
                return;
 
1397
        }
 
1398
 
 
1399
        rl_printf("Attempting to ListFolders\n");
 
1400
}
 
1401
 
 
1402
static void cmd_ls(int argc, char *argv[])
 
1403
{
 
1404
        GDBusProxy *proxy;
 
1405
 
 
1406
        if (!check_default_session())
 
1407
                return;
 
1408
 
 
1409
        proxy = find_ftp(g_dbus_proxy_get_path(default_session));
 
1410
        if (proxy) {
 
1411
                ftp_ls(proxy, argc, argv);
 
1412
                return;
 
1413
        }
 
1414
 
 
1415
        proxy = find_pbap(g_dbus_proxy_get_path(default_session));
 
1416
        if (proxy) {
 
1417
                pbap_ls(proxy, argc, argv);
 
1418
                return;
 
1419
        }
 
1420
 
 
1421
        proxy = find_map(g_dbus_proxy_get_path(default_session));
 
1422
        if (proxy) {
 
1423
                map_ls(proxy, argc, argv);
 
1424
                return;
 
1425
        }
 
1426
 
 
1427
        rl_printf("Command not supported\n");
 
1428
}
 
1429
 
 
1430
struct cp_args {
 
1431
        char *source;
 
1432
        char *target;
 
1433
};
 
1434
 
 
1435
static void cp_free(void *data)
 
1436
{
 
1437
        struct cp_args *args = data;
 
1438
 
 
1439
        g_free(args->source);
 
1440
        g_free(args->target);
 
1441
        g_free(args);
 
1442
}
 
1443
 
 
1444
static struct cp_args *cp_new(char *argv[])
 
1445
{
 
1446
        struct cp_args *args;
 
1447
        const char *source;
 
1448
        const char *target;
 
1449
 
 
1450
        source = rindex(argv[1], ':');
 
1451
        if (source == NULL)
 
1452
                source = argv[1];
 
1453
        else
 
1454
                source++;
 
1455
 
 
1456
        target = rindex(argv[2], ':');
 
1457
        if (target == NULL)
 
1458
                target = argv[2];
 
1459
        else
 
1460
                target++;
 
1461
 
 
1462
        args = g_new0(struct cp_args, 1);
 
1463
        args->source = g_strdup(source);
 
1464
        args->target = g_strdup(target);
 
1465
 
 
1466
        return args;
 
1467
}
 
1468
 
 
1469
static void cp_setup(DBusMessageIter *iter, void *user_data)
 
1470
{
 
1471
        struct cp_args *args = user_data;
 
1472
 
 
1473
        dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &args->source);
 
1474
        dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &args->target);
 
1475
}
 
1476
 
 
1477
static void copy_file_reply(DBusMessage *message, void *user_data)
 
1478
{
 
1479
        DBusError error;
 
1480
 
 
1481
        dbus_error_init(&error);
 
1482
 
 
1483
        if (dbus_set_error_from_message(&error, message) == TRUE) {
 
1484
                rl_printf("Failed to CopyFile: %s\n", error.name);
 
1485
                dbus_error_free(&error);
 
1486
                return;
 
1487
        }
 
1488
 
 
1489
        rl_printf("CopyFile successful\n");
 
1490
}
 
1491
 
 
1492
static void ftp_copy(GDBusProxy *proxy, int argc, char *argv[])
 
1493
{
 
1494
        struct cp_args *args;
 
1495
 
 
1496
        args = cp_new(argv);
 
1497
 
 
1498
        if (g_dbus_proxy_method_call(proxy, "CopyFile", cp_setup,
 
1499
                                copy_file_reply, args, cp_free) == FALSE) {
 
1500
                rl_printf("Failed to CopyFile\n");
 
1501
                return;
 
1502
        }
 
1503
 
 
1504
        rl_printf("Attempting to CopyFile\n");
 
1505
}
 
1506
 
 
1507
static void get_file_reply(DBusMessage *message, void *user_data)
 
1508
{
 
1509
        DBusError error;
 
1510
        DBusMessageIter iter;
 
1511
 
 
1512
        dbus_error_init(&error);
 
1513
 
 
1514
        if (dbus_set_error_from_message(&error, message) == TRUE) {
 
1515
                rl_printf("Failed to GetFile: %s\n", error.name);
 
1516
                dbus_error_free(&error);
 
1517
                return;
 
1518
        }
 
1519
 
 
1520
        dbus_message_iter_init(message, &iter);
 
1521
 
 
1522
        print_transfer_iter(&iter);
 
1523
}
 
1524
 
 
1525
static void get_file_setup(DBusMessageIter *iter, void *user_data)
 
1526
{
 
1527
        struct cp_args *args = user_data;
 
1528
 
 
1529
        dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &args->target);
 
1530
        dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &args->source);
 
1531
}
 
1532
 
 
1533
static void ftp_get(GDBusProxy *proxy, int argc, char *argv[])
 
1534
{
 
1535
        struct cp_args *args;
 
1536
 
 
1537
        if (rindex(argv[2], ':') == NULL)
 
1538
                return ftp_copy(proxy, argc, argv);
 
1539
 
 
1540
        args = cp_new(argv);
 
1541
 
 
1542
        if (g_dbus_proxy_method_call(proxy, "GetFile", get_file_setup,
 
1543
                                get_file_reply, args, cp_free) == FALSE) {
 
1544
                rl_printf("Failed to GetFile\n");
 
1545
                return;
 
1546
        }
 
1547
 
 
1548
        rl_printf("Attempting to GetFile\n");
 
1549
}
 
1550
 
 
1551
static void put_file_reply(DBusMessage *message, void *user_data)
 
1552
{
 
1553
        DBusError error;
 
1554
        DBusMessageIter iter;
 
1555
 
 
1556
        dbus_error_init(&error);
 
1557
 
 
1558
        if (dbus_set_error_from_message(&error, message) == TRUE) {
 
1559
                rl_printf("Failed to PutFile: %s\n", error.name);
 
1560
                dbus_error_free(&error);
 
1561
                return;
 
1562
        }
 
1563
 
 
1564
        dbus_message_iter_init(message, &iter);
 
1565
 
 
1566
        print_transfer_iter(&iter);
 
1567
}
 
1568
 
 
1569
static void ftp_put(GDBusProxy *proxy, int argc, char *argv[])
 
1570
{
 
1571
        struct cp_args *args;
 
1572
 
 
1573
        if (rindex(argv[2], ':') != NULL) {
 
1574
                rl_printf("Invalid target file argument\n");
 
1575
                return;
 
1576
        }
 
1577
 
 
1578
        args = cp_new(argv);
 
1579
 
 
1580
        if (g_dbus_proxy_method_call(proxy, "PutFile", cp_setup, put_file_reply,
 
1581
                                                args, cp_free) == FALSE) {
 
1582
                rl_printf("Failed to PutFile\n");
 
1583
                return;
 
1584
        }
 
1585
 
 
1586
        rl_printf("Attempting to PutFile\n");
 
1587
}
 
1588
 
 
1589
static void ftp_cp(GDBusProxy *proxy, int argc, char *argv[])
 
1590
{
 
1591
        if (argc < 2) {
 
1592
                rl_printf("Missing source file argument\n");
 
1593
                return;
 
1594
        }
 
1595
 
 
1596
        if (argc < 3) {
 
1597
                rl_printf("Missing target file argument\n");
 
1598
                return;
 
1599
        }
 
1600
 
 
1601
        if (rindex(argv[1], ':') == NULL)
 
1602
                return ftp_get(proxy, argc, argv);
 
1603
 
 
1604
        return ftp_put(proxy, argc, argv);
 
1605
}
 
1606
 
 
1607
static void pull_all_reply(DBusMessage *message, void *user_data)
 
1608
{
 
1609
        DBusError error;
 
1610
 
 
1611
        dbus_error_init(&error);
 
1612
 
 
1613
        if (dbus_set_error_from_message(&error, message) == TRUE) {
 
1614
                rl_printf("Failed to PullAll: %s\n", error.name);
 
1615
                dbus_error_free(&error);
 
1616
                return;
 
1617
        }
 
1618
 
 
1619
 
 
1620
        rl_printf("PullAll successful\n");
 
1621
}
 
1622
 
 
1623
static void pull_all_setup(DBusMessageIter *iter, void *user_data)
 
1624
{
 
1625
        const char *file = user_data;
 
1626
        DBusMessageIter dict;
 
1627
 
 
1628
        dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &file);
 
1629
 
 
1630
        dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
 
1631
                                        DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
 
1632
                                        DBUS_TYPE_STRING_AS_STRING
 
1633
                                        DBUS_TYPE_VARIANT_AS_STRING
 
1634
                                        DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
 
1635
                                        &dict);
 
1636
 
 
1637
        dbus_message_iter_close_container(iter, &dict);
 
1638
}
 
1639
 
 
1640
static void pbap_pull_all(GDBusProxy *proxy, int argc, char *argv[])
 
1641
{
 
1642
        if (g_dbus_proxy_method_call(proxy, "PullAll", pull_all_setup,
 
1643
                                        pull_all_reply, g_strdup(argv[2]),
 
1644
                                        g_free) == FALSE) {
 
1645
                rl_printf("Failed to PullAll\n");
 
1646
                return;
 
1647
        }
 
1648
 
 
1649
        rl_printf("Attempting to PullAll\n");
 
1650
}
 
1651
 
 
1652
static void pull_reply(DBusMessage *message, void *user_data)
 
1653
{
 
1654
        DBusError error;
 
1655
 
 
1656
        dbus_error_init(&error);
 
1657
 
 
1658
        if (dbus_set_error_from_message(&error, message) == TRUE) {
 
1659
                rl_printf("Failed to Pull: %s\n", error.name);
 
1660
                dbus_error_free(&error);
 
1661
                return;
 
1662
        }
 
1663
 
 
1664
 
 
1665
        rl_printf("Pull successful\n");
 
1666
}
 
1667
 
 
1668
static void pull_setup(DBusMessageIter *iter, void *user_data)
 
1669
{
 
1670
        struct cp_args *args = user_data;
 
1671
        DBusMessageIter dict;
 
1672
 
 
1673
        dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &args->source);
 
1674
        dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &args->target);
 
1675
 
 
1676
        dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
 
1677
                                        DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
 
1678
                                        DBUS_TYPE_STRING_AS_STRING
 
1679
                                        DBUS_TYPE_VARIANT_AS_STRING
 
1680
                                        DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
 
1681
                                        &dict);
 
1682
 
 
1683
        dbus_message_iter_close_container(iter, &dict);
 
1684
}
 
1685
 
 
1686
static void pbap_pull(GDBusProxy *proxy, int argc, char *argv[])
 
1687
{
 
1688
        struct cp_args *args;
 
1689
 
 
1690
        args = cp_new(argv);
 
1691
 
 
1692
        if (g_dbus_proxy_method_call(proxy, "Pull", pull_setup, pull_reply,
 
1693
                                                args, cp_free) == FALSE) {
 
1694
                rl_printf("Failed to Pull\n");
 
1695
                return;
 
1696
        }
 
1697
 
 
1698
        rl_printf("Attempting to Pull\n");
 
1699
}
 
1700
 
 
1701
static void pbap_cp(GDBusProxy *proxy, int argc, char *argv[])
 
1702
{
 
1703
        if (argc < 2) {
 
1704
                rl_printf("Missing source file argument\n");
 
1705
                return;
 
1706
        }
 
1707
 
 
1708
        if (argc < 3) {
 
1709
                rl_printf("Missing target file argument\n");
 
1710
                return;
 
1711
        }
 
1712
 
 
1713
        if (strcmp(argv[1], "*") == 0)
 
1714
                return pbap_pull_all(proxy, argc, argv);
 
1715
 
 
1716
        return pbap_pull(proxy, argc, argv);
 
1717
}
 
1718
 
 
1719
static void get_reply(DBusMessage *message, void *user_data)
 
1720
{
 
1721
        DBusMessageIter iter;
 
1722
        DBusError error;
 
1723
 
 
1724
        dbus_error_init(&error);
 
1725
 
 
1726
        if (dbus_set_error_from_message(&error, message) == TRUE) {
 
1727
                rl_printf("Failed to Get: %s\n", error.name);
 
1728
                dbus_error_free(&error);
 
1729
                return;
 
1730
        }
 
1731
 
 
1732
        dbus_message_iter_init(message, &iter);
 
1733
 
 
1734
        print_transfer_iter(&iter);
 
1735
}
 
1736
 
 
1737
static void get_setup(DBusMessageIter *iter, void *user_data)
 
1738
{
 
1739
        const char *file = user_data;
 
1740
        dbus_bool_t attachment = TRUE;
 
1741
 
 
1742
        dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &file);
 
1743
        dbus_message_iter_append_basic(iter, DBUS_TYPE_BOOLEAN, &attachment);
 
1744
}
 
1745
 
 
1746
static void map_cp(GDBusProxy *proxy, int argc, char *argv[])
 
1747
{
 
1748
        GDBusProxy *obj;
 
1749
 
 
1750
        if (argc < 2) {
 
1751
                rl_printf("Missing message argument\n");
 
1752
                return;
 
1753
        }
 
1754
 
 
1755
        obj = find_message(argv[1]);
 
1756
        if (obj == NULL) {
 
1757
                rl_printf("Invalid message argument\n");
 
1758
                return;
 
1759
        }
 
1760
 
 
1761
        if (argc < 3) {
 
1762
                rl_printf("Missing target file argument\n");
 
1763
                return;
 
1764
        }
 
1765
 
 
1766
        if (g_dbus_proxy_method_call(obj, "Get", get_setup, get_reply,
 
1767
                                        g_strdup(argv[2]), g_free) == FALSE) {
 
1768
                rl_printf("Failed to Get\n");
 
1769
                return;
 
1770
        }
 
1771
 
 
1772
        rl_printf("Attempting to Get\n");
 
1773
}
 
1774
 
 
1775
static void cmd_cp(int argc, char *argv[])
 
1776
{
 
1777
 
 
1778
        GDBusProxy *proxy;
 
1779
 
 
1780
        if (!check_default_session())
 
1781
                return;
 
1782
 
 
1783
        proxy = find_ftp(g_dbus_proxy_get_path(default_session));
 
1784
        if (proxy) {
 
1785
                ftp_cp(proxy, argc, argv);
 
1786
                return;
 
1787
        }
 
1788
 
 
1789
        proxy = find_pbap(g_dbus_proxy_get_path(default_session));
 
1790
        if (proxy) {
 
1791
                pbap_cp(proxy, argc, argv);
 
1792
                return;
 
1793
        }
 
1794
 
 
1795
        proxy = find_map(g_dbus_proxy_get_path(default_session));
 
1796
        if (proxy) {
 
1797
                map_cp(proxy, argc, argv);
 
1798
                return;
 
1799
        }
 
1800
 
 
1801
        rl_printf("Command not supported\n");
 
1802
}
 
1803
 
 
1804
static void move_file_reply(DBusMessage *message, void *user_data)
 
1805
{
 
1806
        DBusError error;
 
1807
 
 
1808
        dbus_error_init(&error);
 
1809
 
 
1810
        if (dbus_set_error_from_message(&error, message) == TRUE) {
 
1811
                rl_printf("Failed to MoveFile: %s\n", error.name);
 
1812
                dbus_error_free(&error);
 
1813
                return;
 
1814
        }
 
1815
 
 
1816
        rl_printf("MoveFile successful\n");
 
1817
}
 
1818
 
 
1819
static void cmd_mv(int argc, char *argv[])
 
1820
{
 
1821
        GDBusProxy *proxy;
 
1822
        struct cp_args *args;
 
1823
 
 
1824
        if (!check_default_session())
 
1825
                return;
 
1826
 
 
1827
        if (argc < 2) {
 
1828
                rl_printf("Missing source file argument\n");
 
1829
                return;
 
1830
        }
 
1831
 
 
1832
        if (argc < 3) {
 
1833
                rl_printf("Missing target file argument\n");
 
1834
                return;
 
1835
        }
 
1836
 
 
1837
        proxy = find_ftp(g_dbus_proxy_get_path(default_session));
 
1838
        if (proxy == NULL) {
 
1839
                rl_printf("Command not supported\n");
 
1840
                return;
 
1841
        }
 
1842
 
 
1843
        args = cp_new(argv);
 
1844
 
 
1845
        if (g_dbus_proxy_method_call(proxy, "MoveFile", cp_setup,
 
1846
                                move_file_reply, args, cp_free) == FALSE) {
 
1847
                rl_printf("Failed to MoveFile\n");
 
1848
                return;
 
1849
        }
 
1850
 
 
1851
        rl_printf("Attempting to MoveFile\n");
 
1852
}
 
1853
 
 
1854
static void delete_reply(DBusMessage *message, void *user_data)
 
1855
{
 
1856
        DBusError error;
 
1857
 
 
1858
        dbus_error_init(&error);
 
1859
 
 
1860
        if (dbus_set_error_from_message(&error, message) == TRUE) {
 
1861
                rl_printf("Failed to Delete: %s\n", error.name);
 
1862
                dbus_error_free(&error);
 
1863
                return;
 
1864
        }
 
1865
 
 
1866
        rl_printf("Delete successful\n");
 
1867
}
 
1868
 
 
1869
static void delete_setup(DBusMessageIter *iter, void *user_data)
 
1870
{
 
1871
        const char *file = user_data;
 
1872
 
 
1873
        dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &file);
 
1874
}
 
1875
 
 
1876
static void ftp_rm(GDBusProxy *proxy, int argc, char *argv[])
 
1877
{
 
1878
        if (argc < 2) {
 
1879
                rl_printf("Missing file argument\n");
 
1880
                return;
 
1881
        }
 
1882
 
 
1883
        if (g_dbus_proxy_method_call(proxy, "Delete", delete_setup,
 
1884
                                        delete_reply, g_strdup(argv[1]),
 
1885
                                        g_free) == FALSE) {
 
1886
                rl_printf("Failed to Delete\n");
 
1887
                return;
 
1888
        }
 
1889
 
 
1890
        rl_printf("Attempting to Delete\n");
 
1891
}
 
1892
 
 
1893
static void set_delete_reply(const DBusError *error, void *user_data)
 
1894
{
 
1895
        if (dbus_error_is_set(error))
 
1896
                rl_printf("Failed to set Deleted: %s\n", error->name);
 
1897
        else
 
1898
                rl_printf("Set Deleted successful\n");
 
1899
}
 
1900
 
 
1901
static void map_rm(GDBusProxy *proxy, int argc, char *argv[])
 
1902
{
 
1903
        GDBusProxy *msg;
 
1904
        dbus_bool_t value = TRUE;
 
1905
 
 
1906
        if (argc < 2) {
 
1907
                rl_printf("Missing message argument\n");
 
1908
                return;
 
1909
        }
 
1910
 
 
1911
        msg = find_message(argv[1]);
 
1912
        if (msg == NULL) {
 
1913
                rl_printf("Invalid message argument\n");
 
1914
                return;
 
1915
        }
 
1916
 
 
1917
        if (g_dbus_proxy_set_property_basic(msg, "Deleted", DBUS_TYPE_BOOLEAN,
 
1918
                                                &value, set_delete_reply,
 
1919
                                                NULL, NULL) == FALSE) {
 
1920
                rl_printf("Failed to set Deleted\n");
 
1921
                return;
 
1922
        }
 
1923
 
 
1924
        rl_printf("Attempting to set Deleted\n");
 
1925
}
 
1926
 
 
1927
static void cmd_rm(int argc, char *argv[])
 
1928
{
 
1929
        GDBusProxy *proxy;
 
1930
 
 
1931
        if (!check_default_session())
 
1932
                return;
 
1933
 
 
1934
        proxy = find_ftp(g_dbus_proxy_get_path(default_session));
 
1935
        if (proxy) {
 
1936
                ftp_rm(proxy, argc, argv);
 
1937
                return;
 
1938
        }
 
1939
 
 
1940
        proxy = find_map(g_dbus_proxy_get_path(default_session));
 
1941
        if (proxy) {
 
1942
                map_rm(proxy, argc, argv);
 
1943
                return;
 
1944
        }
 
1945
 
 
1946
        rl_printf("Command not supported\n");
 
1947
}
 
1948
 
 
1949
static void create_folder_reply(DBusMessage *message, void *user_data)
 
1950
{
 
1951
        DBusError error;
 
1952
 
 
1953
        dbus_error_init(&error);
 
1954
 
 
1955
        if (dbus_set_error_from_message(&error, message) == TRUE) {
 
1956
                rl_printf("Failed to CreateFolder: %s\n", error.name);
 
1957
                dbus_error_free(&error);
 
1958
                return;
 
1959
        }
 
1960
 
 
1961
        rl_printf("CreateFolder successful\n");
 
1962
}
 
1963
 
 
1964
static void create_folder_setup(DBusMessageIter *iter, void *user_data)
 
1965
{
 
1966
        const char *folder = user_data;
 
1967
 
 
1968
        dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &folder);
 
1969
}
 
1970
 
 
1971
static void cmd_mkdir(int argc, char *argv[])
 
1972
{
 
1973
        GDBusProxy *proxy;
 
1974
 
 
1975
        if (!check_default_session())
 
1976
                return;
 
1977
 
 
1978
        if (argc < 2) {
 
1979
                rl_printf("Missing folder argument\n");
 
1980
                return;
 
1981
        }
 
1982
 
 
1983
        proxy = find_ftp(g_dbus_proxy_get_path(default_session));
 
1984
        if (proxy == NULL) {
 
1985
                rl_printf("Command not supported\n");
 
1986
                return;
 
1987
        }
 
1988
 
 
1989
        if (g_dbus_proxy_method_call(proxy, "CreateFolder", create_folder_setup,
 
1990
                                        create_folder_reply, g_strdup(argv[1]),
 
1991
                                        g_free) == FALSE) {
 
1992
                rl_printf("Failed to CreateFolder\n");
 
1993
                return;
 
1994
        }
 
1995
 
 
1996
        rl_printf("Attempting to CreateFolder\n");
 
1997
}
 
1998
 
 
1999
static const struct {
 
2000
        const char *cmd;
 
2001
        const char *arg;
 
2002
        void (*func) (int argc, char *argv[]);
 
2003
        const char *desc;
 
2004
} cmd_table[] = {
 
2005
        { "connect",      "<dev> [uuid]", cmd_connect, "Connect session" },
 
2006
        { "disconnect",   "[session]", cmd_disconnect, "Disconnect session" },
 
2007
        { "list",         NULL,       cmd_list, "List available sessions" },
 
2008
        { "show",         "[session]", cmd_show, "Session information" },
 
2009
        { "select",       "<session>", cmd_select, "Select default session" },
 
2010
        { "info",         "<object>", cmd_info, "Object information" },
 
2011
        { "cancel",       "<transfer>", cmd_cancel, "Cancel transfer" },
 
2012
        { "suspend",      "<transfer>", cmd_suspend, "Suspend transfer" },
 
2013
        { "resume",       "<transfer>", cmd_resume, "Resume transfer" },
 
2014
        { "send",         "<file>",   cmd_send, "Send file" },
 
2015
        { "pull",         "<file>",   cmd_pull,
 
2016
                                        "Pull Vobject & stores in file" },
 
2017
        { "cd",           "<path>",   cmd_cd, "Change current folder" },
 
2018
        { "ls",           "<options>", cmd_ls, "List current folder" },
 
2019
        { "cp",          "<source file> <destination file>",   cmd_cp,
 
2020
                                "Copy source file to destination file" },
 
2021
        { "mv",          "<source file> <destination file>",   cmd_mv,
 
2022
                                "Move source file to destination file" },
 
2023
        { "rm",          "<file>",    cmd_rm, "Delete file" },
 
2024
        { "mkdir",       "<folder>",    cmd_mkdir, "Create folder" },
 
2025
        { "quit",         NULL,       cmd_quit, "Quit program" },
 
2026
        { "exit",         NULL,       cmd_quit },
 
2027
        { "help" },
 
2028
        {}
 
2029
};
 
2030
 
 
2031
static char *cmd_generator(const char *text, int state)
 
2032
{
 
2033
        static int index, len;
 
2034
        const char *cmd;
 
2035
 
 
2036
        if (!state) {
 
2037
                index = 0;
 
2038
                len = strlen(text);
 
2039
        }
 
2040
 
 
2041
        while ((cmd = cmd_table[index].cmd)) {
 
2042
                index++;
 
2043
 
 
2044
                if (!strncmp(cmd, text, len))
 
2045
                        return strdup(cmd);
 
2046
        }
 
2047
 
 
2048
        return NULL;
 
2049
}
 
2050
 
 
2051
static char **cmd_completion(const char *text, int start, int end)
 
2052
{
 
2053
        char **matches = NULL;
 
2054
 
 
2055
        if (start == 0) {
 
2056
                rl_completion_display_matches_hook = NULL;
 
2057
                matches = rl_completion_matches(text, cmd_generator);
 
2058
        }
 
2059
 
 
2060
        if (!matches)
 
2061
                rl_attempted_completion_over = 1;
 
2062
 
 
2063
        return matches;
 
2064
}
 
2065
 
 
2066
static void rl_handler(char *input)
 
2067
{
 
2068
        wordexp_t w;
 
2069
        int argc;
 
2070
        char **argv;
 
2071
        int i;
 
2072
 
 
2073
        if (!input) {
 
2074
                rl_insert_text("quit");
 
2075
                rl_redisplay();
 
2076
                rl_crlf();
 
2077
                g_main_loop_quit(main_loop);
 
2078
                return;
 
2079
        }
 
2080
 
 
2081
        if (!strlen(input))
 
2082
                goto done;
 
2083
 
 
2084
        add_history(input);
 
2085
 
 
2086
        if (wordexp(input, &w, WRDE_NOCMD))
 
2087
                goto done;
 
2088
 
 
2089
        if (w.we_wordc == 0)
 
2090
                goto free_we;
 
2091
 
 
2092
        argv = w.we_wordv;
 
2093
        argc = w.we_wordc;
 
2094
 
 
2095
        for (i = 0; cmd_table[i].cmd; i++) {
 
2096
                if (strcmp(argv[0], cmd_table[i].cmd))
 
2097
                        continue;
 
2098
 
 
2099
                if (cmd_table[i].func) {
 
2100
                        cmd_table[i].func(argc, argv);
 
2101
                        goto free_we;
 
2102
                }
 
2103
        }
 
2104
 
 
2105
        if (strcmp(argv[0], "help")) {
 
2106
                printf("Invalid command\n");
 
2107
                goto free_we;
 
2108
        }
 
2109
 
 
2110
        printf("Available commands:\n");
 
2111
 
 
2112
        for (i = 0; cmd_table[i].cmd; i++) {
 
2113
                if (cmd_table[i].desc)
 
2114
                        printf("  %s %-*s %s\n", cmd_table[i].cmd,
 
2115
                                        (int)(25 - strlen(cmd_table[i].cmd)),
 
2116
                                        cmd_table[i].arg ? : "",
 
2117
                                        cmd_table[i].desc ? : "");
 
2118
        }
 
2119
 
 
2120
free_we:
 
2121
        wordfree(&w);
 
2122
done:
 
2123
        free(input);
 
2124
}
 
2125
 
 
2126
static gboolean option_version = FALSE;
 
2127
 
 
2128
static GOptionEntry options[] = {
 
2129
        { "version", 'v', 0, G_OPTION_ARG_NONE, &option_version,
 
2130
                                "Show version information and exit" },
 
2131
        { NULL },
 
2132
};
 
2133
 
 
2134
static gboolean signal_handler(GIOChannel *channel, GIOCondition condition,
 
2135
                                                        gpointer user_data)
 
2136
{
 
2137
        static unsigned int __terminated = 0;
 
2138
        struct signalfd_siginfo si;
 
2139
        ssize_t result;
 
2140
        int fd;
 
2141
 
 
2142
        if (condition & (G_IO_NVAL | G_IO_ERR | G_IO_HUP)) {
 
2143
                g_main_loop_quit(main_loop);
 
2144
                return FALSE;
 
2145
        }
 
2146
 
 
2147
        fd = g_io_channel_unix_get_fd(channel);
 
2148
 
 
2149
        result = read(fd, &si, sizeof(si));
 
2150
        if (result != sizeof(si))
 
2151
                return FALSE;
 
2152
 
 
2153
        switch (si.ssi_signo) {
 
2154
        case SIGINT:
 
2155
                rl_replace_line("", 0);
 
2156
                rl_crlf();
 
2157
                rl_on_new_line();
 
2158
                rl_redisplay();
 
2159
                break;
 
2160
        case SIGTERM:
 
2161
                if (__terminated == 0) {
 
2162
                        rl_replace_line("", 0);
 
2163
                        rl_crlf();
 
2164
                        g_main_loop_quit(main_loop);
 
2165
                }
 
2166
 
 
2167
                __terminated = 1;
 
2168
                break;
 
2169
        }
 
2170
 
 
2171
        return TRUE;
 
2172
}
 
2173
 
 
2174
static guint setup_signalfd(void)
 
2175
{
 
2176
        GIOChannel *channel;
 
2177
        guint source;
 
2178
        sigset_t mask;
 
2179
        int fd;
 
2180
 
 
2181
        sigemptyset(&mask);
 
2182
        sigaddset(&mask, SIGINT);
 
2183
        sigaddset(&mask, SIGTERM);
 
2184
 
 
2185
        if (sigprocmask(SIG_BLOCK, &mask, NULL) < 0) {
 
2186
                perror("Failed to set signal mask");
 
2187
                return 0;
 
2188
        }
 
2189
 
 
2190
        fd = signalfd(-1, &mask, 0);
 
2191
        if (fd < 0) {
 
2192
                perror("Failed to create signal descriptor");
 
2193
                return 0;
 
2194
        }
 
2195
 
 
2196
        channel = g_io_channel_unix_new(fd);
 
2197
 
 
2198
        g_io_channel_set_close_on_unref(channel, TRUE);
 
2199
        g_io_channel_set_encoding(channel, NULL, NULL);
 
2200
        g_io_channel_set_buffered(channel, FALSE);
 
2201
 
 
2202
        source = g_io_add_watch(channel,
 
2203
                                G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
 
2204
                                signal_handler, NULL);
 
2205
 
 
2206
        g_io_channel_unref(channel);
 
2207
 
 
2208
        return source;
 
2209
}
 
2210
 
 
2211
static gboolean input_handler(GIOChannel *channel, GIOCondition condition,
 
2212
                                                        gpointer user_data)
 
2213
{
 
2214
        if (condition & (G_IO_HUP | G_IO_ERR | G_IO_NVAL)) {
 
2215
                g_main_loop_quit(main_loop);
 
2216
                return FALSE;
 
2217
        }
 
2218
 
 
2219
        rl_callback_read_char();
 
2220
        return TRUE;
 
2221
}
 
2222
 
 
2223
static guint setup_standard_input(void)
 
2224
{
 
2225
        GIOChannel *channel;
 
2226
        guint source;
 
2227
 
 
2228
        channel = g_io_channel_unix_new(fileno(stdin));
 
2229
 
 
2230
        source = g_io_add_watch(channel,
 
2231
                                G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
 
2232
                                input_handler, NULL);
 
2233
 
 
2234
        g_io_channel_unref(channel);
 
2235
 
 
2236
        return source;
 
2237
}
 
2238
 
 
2239
static void client_added(GDBusProxy *proxy)
 
2240
{
 
2241
        if (client == NULL)
 
2242
                client = proxy;
 
2243
 
 
2244
        print_proxy(proxy, "Client", COLORED_NEW);
 
2245
}
 
2246
 
 
2247
static void session_added(GDBusProxy *proxy)
 
2248
{
 
2249
        sessions = g_slist_append(sessions, proxy);
 
2250
 
 
2251
        if (default_session == NULL)
 
2252
                set_default_session(proxy);
 
2253
 
 
2254
        print_proxy(proxy, "Session", COLORED_NEW);
 
2255
}
 
2256
 
 
2257
static void print_transferred(struct transfer_data *data, const char *str,
 
2258
                                                        DBusMessageIter *iter)
 
2259
{
 
2260
        dbus_uint64_t valu64;
 
2261
        uint64_t speed;
 
2262
        int seconds, minutes;
 
2263
 
 
2264
        dbus_message_iter_get_basic(iter, &valu64);
 
2265
        speed = valu64 - data->transferred;
 
2266
        data->transferred = valu64;
 
2267
 
 
2268
        if (data->size == 0) {
 
2269
                rl_printf("%sTransferred: %" PRIu64 " (@%" PRIu64 "KB/s)\n",
 
2270
                                                str, valu64, speed / 1000);
 
2271
                return;
 
2272
        }
 
2273
 
 
2274
        seconds = (data->size - data->transferred) / speed;
 
2275
        minutes = seconds / 60;
 
2276
        seconds %= 60;
 
2277
        rl_printf("%sTransferred: %" PRIu64 " (@%" PRIu64 "KB/s %02u:%02u)\n",
 
2278
                                str, valu64, speed / 1000, minutes, seconds);
 
2279
}
 
2280
 
 
2281
static void transfer_property_changed(GDBusProxy *proxy, const char *name,
 
2282
                                        DBusMessageIter *iter, void *user_data)
 
2283
{
 
2284
        struct transfer_data *data = user_data;
 
2285
        char *str;
 
2286
 
 
2287
        str = proxy_description(proxy, "Transfer", COLORED_CHG);
 
2288
 
 
2289
        if (strcmp(name, "Transferred") == 0) {
 
2290
                print_transferred(data, str, iter);
 
2291
                goto done;
 
2292
        }
 
2293
 
 
2294
        if (strcmp(name, "Size") == 0)
 
2295
                dbus_message_iter_get_basic(iter, &data->size);
 
2296
 
 
2297
        print_iter(str, name, iter);
 
2298
 
 
2299
done:
 
2300
        g_free(str);
 
2301
}
 
2302
 
 
2303
static void transfer_destroy(GDBusProxy *proxy, void *user_data)
 
2304
{
 
2305
        struct transfer_data *data = user_data;
 
2306
 
 
2307
        g_free(data);
 
2308
}
 
2309
 
 
2310
static void transfer_added(GDBusProxy *proxy)
 
2311
{
 
2312
        struct transfer_data *data;
 
2313
        DBusMessageIter iter;
 
2314
 
 
2315
        transfers = g_slist_append(transfers, proxy);
 
2316
 
 
2317
        print_proxy(proxy, "Transfer", COLORED_NEW);
 
2318
 
 
2319
        data = g_new0(struct transfer_data, 1);
 
2320
 
 
2321
        if (g_dbus_proxy_get_property(proxy, "Transfered", &iter))
 
2322
                dbus_message_iter_get_basic(&iter, &data->transferred);
 
2323
 
 
2324
        if (g_dbus_proxy_get_property(proxy, "Size", &iter))
 
2325
                dbus_message_iter_get_basic(&iter, &data->size);
 
2326
 
 
2327
        g_dbus_proxy_set_property_watch(proxy, transfer_property_changed, data);
 
2328
        g_dbus_proxy_set_removed_watch(proxy, transfer_destroy, data);
 
2329
}
 
2330
 
 
2331
static void opp_added(GDBusProxy *proxy)
 
2332
{
 
2333
        opps = g_slist_append(opps, proxy);
 
2334
 
 
2335
        print_proxy(proxy, "ObjectPush", COLORED_NEW);
 
2336
}
 
2337
 
 
2338
static void ftp_added(GDBusProxy *proxy)
 
2339
{
 
2340
        ftps = g_slist_append(ftps, proxy);
 
2341
 
 
2342
        print_proxy(proxy, "FileTransfer", COLORED_NEW);
 
2343
}
 
2344
 
 
2345
static void pbap_added(GDBusProxy *proxy)
 
2346
{
 
2347
        pbaps = g_slist_append(pbaps, proxy);
 
2348
 
 
2349
        print_proxy(proxy, "PhonebookAccess", COLORED_NEW);
 
2350
}
 
2351
 
 
2352
static void map_added(GDBusProxy *proxy)
 
2353
{
 
2354
        maps = g_slist_append(maps, proxy);
 
2355
 
 
2356
        print_proxy(proxy, "MessageAccess", COLORED_NEW);
 
2357
}
 
2358
 
 
2359
static void msg_added(GDBusProxy *proxy)
 
2360
{
 
2361
        msgs = g_slist_append(msgs, proxy);
 
2362
 
 
2363
        print_proxy(proxy, "Message", COLORED_NEW);
 
2364
}
 
2365
 
 
2366
static void proxy_added(GDBusProxy *proxy, void *user_data)
 
2367
{
 
2368
        const char *interface;
 
2369
 
 
2370
        interface = g_dbus_proxy_get_interface(proxy);
 
2371
 
 
2372
        if (!strcmp(interface, OBEX_CLIENT_INTERFACE))
 
2373
                client_added(proxy);
 
2374
        else if (!strcmp(interface, OBEX_SESSION_INTERFACE))
 
2375
                session_added(proxy);
 
2376
        else if (!strcmp(interface, OBEX_TRANSFER_INTERFACE))
 
2377
                transfer_added(proxy);
 
2378
        else if (!strcmp(interface, OBEX_OPP_INTERFACE))
 
2379
                opp_added(proxy);
 
2380
        else if (!strcmp(interface, OBEX_FTP_INTERFACE))
 
2381
                ftp_added(proxy);
 
2382
        else if (!strcmp(interface, OBEX_PBAP_INTERFACE))
 
2383
                pbap_added(proxy);
 
2384
        else if (!strcmp(interface, OBEX_MAP_INTERFACE))
 
2385
                map_added(proxy);
 
2386
        else if (!strcmp(interface, OBEX_MSG_INTERFACE))
 
2387
                msg_added(proxy);
 
2388
}
 
2389
 
 
2390
static void client_removed(GDBusProxy *proxy)
 
2391
{
 
2392
        print_proxy(proxy, "Client", COLORED_DEL);
 
2393
 
 
2394
        if (client == proxy)
 
2395
                client = NULL;
 
2396
}
 
2397
 
 
2398
static void session_removed(GDBusProxy *proxy)
 
2399
{
 
2400
        print_proxy(proxy, "Session", COLORED_DEL);
 
2401
 
 
2402
        if (default_session == proxy)
 
2403
                set_default_session(NULL);
 
2404
 
 
2405
        sessions = g_slist_remove(sessions, proxy);
 
2406
}
 
2407
 
 
2408
static void transfer_removed(GDBusProxy *proxy)
 
2409
{
 
2410
        print_proxy(proxy, "Transfer", COLORED_DEL);
 
2411
 
 
2412
        transfers = g_slist_remove(transfers, proxy);
 
2413
}
 
2414
 
 
2415
static void opp_removed(GDBusProxy *proxy)
 
2416
{
 
2417
        print_proxy(proxy, "ObjectPush", COLORED_DEL);
 
2418
 
 
2419
        opps = g_slist_remove(opps, proxy);
 
2420
}
 
2421
 
 
2422
static void ftp_removed(GDBusProxy *proxy)
 
2423
{
 
2424
        print_proxy(proxy, "FileTransfer", COLORED_DEL);
 
2425
 
 
2426
        ftps = g_slist_remove(ftps, proxy);
 
2427
}
 
2428
 
 
2429
static void pbap_removed(GDBusProxy *proxy)
 
2430
{
 
2431
        print_proxy(proxy, "PhonebookAccess", COLORED_DEL);
 
2432
 
 
2433
        pbaps = g_slist_remove(pbaps, proxy);
 
2434
}
 
2435
 
 
2436
static void map_removed(GDBusProxy *proxy)
 
2437
{
 
2438
        print_proxy(proxy, "MessageAccess", COLORED_DEL);
 
2439
 
 
2440
        maps = g_slist_remove(maps, proxy);
 
2441
}
 
2442
 
 
2443
static void msg_removed(GDBusProxy *proxy)
 
2444
{
 
2445
        print_proxy(proxy, "Message", COLORED_DEL);
 
2446
 
 
2447
        msgs = g_slist_remove(msgs, proxy);
 
2448
}
 
2449
 
 
2450
static void proxy_removed(GDBusProxy *proxy, void *user_data)
 
2451
{
 
2452
        const char *interface;
 
2453
 
 
2454
        interface = g_dbus_proxy_get_interface(proxy);
 
2455
 
 
2456
        if (!strcmp(interface, OBEX_CLIENT_INTERFACE))
 
2457
                client_removed(proxy);
 
2458
        else if (!strcmp(interface, OBEX_SESSION_INTERFACE))
 
2459
                session_removed(proxy);
 
2460
        else if (!strcmp(interface, OBEX_TRANSFER_INTERFACE))
 
2461
                transfer_removed(proxy);
 
2462
        else if (!strcmp(interface, OBEX_OPP_INTERFACE))
 
2463
                opp_removed(proxy);
 
2464
        else if (!strcmp(interface, OBEX_FTP_INTERFACE))
 
2465
                ftp_removed(proxy);
 
2466
        else if (!strcmp(interface, OBEX_PBAP_INTERFACE))
 
2467
                pbap_removed(proxy);
 
2468
        else if (!strcmp(interface, OBEX_MAP_INTERFACE))
 
2469
                map_removed(proxy);
 
2470
        else if (!strcmp(interface, OBEX_MSG_INTERFACE))
 
2471
                msg_removed(proxy);
 
2472
}
 
2473
 
 
2474
static void session_property_changed(GDBusProxy *proxy, const char *name,
 
2475
                                                DBusMessageIter *iter)
 
2476
{
 
2477
        char *str;
 
2478
 
 
2479
        str = proxy_description(proxy, "Session", COLORED_CHG);
 
2480
        print_iter(str, name, iter);
 
2481
        g_free(str);
 
2482
}
 
2483
 
 
2484
static void property_changed(GDBusProxy *proxy, const char *name,
 
2485
                                        DBusMessageIter *iter, void *user_data)
 
2486
{
 
2487
        const char *interface;
 
2488
 
 
2489
        interface = g_dbus_proxy_get_interface(proxy);
 
2490
 
 
2491
        if (!strcmp(interface, OBEX_SESSION_INTERFACE))
 
2492
                session_property_changed(proxy, name, iter);
 
2493
}
 
2494
 
 
2495
int main(int argc, char *argv[])
 
2496
{
 
2497
        GOptionContext *context;
 
2498
        GError *error = NULL;
 
2499
        GDBusClient *client;
 
2500
        guint signal, input;
 
2501
 
 
2502
        context = g_option_context_new(NULL);
 
2503
        g_option_context_add_main_entries(context, options, NULL);
 
2504
 
 
2505
        if (g_option_context_parse(context, &argc, &argv, &error) == FALSE) {
 
2506
                if (error != NULL) {
 
2507
                        g_printerr("%s\n", error->message);
 
2508
                        g_error_free(error);
 
2509
                } else
 
2510
                        g_printerr("An unknown error occurred\n");
 
2511
                exit(1);
 
2512
        }
 
2513
 
 
2514
        g_option_context_free(context);
 
2515
 
 
2516
        if (option_version == TRUE) {
 
2517
                printf("%s\n", VERSION);
 
2518
                exit(0);
 
2519
        }
 
2520
 
 
2521
        main_loop = g_main_loop_new(NULL, FALSE);
 
2522
        dbus_conn = g_dbus_setup_bus(DBUS_BUS_SESSION, NULL, NULL);
 
2523
 
 
2524
        rl_attempted_completion_function = cmd_completion;
 
2525
 
 
2526
        rl_erase_empty_line = 1;
 
2527
        rl_callback_handler_install(NULL, rl_handler);
 
2528
 
 
2529
        rl_set_prompt(PROMPT_OFF);
 
2530
        rl_redisplay();
 
2531
 
 
2532
        input = setup_standard_input();
 
2533
        signal = setup_signalfd();
 
2534
        client = g_dbus_client_new(dbus_conn, "org.bluez.obex",
 
2535
                                                        "/org/bluez/obex");
 
2536
 
 
2537
        g_dbus_client_set_connect_watch(client, connect_handler, NULL);
 
2538
        g_dbus_client_set_disconnect_watch(client, disconnect_handler, NULL);
 
2539
 
 
2540
        g_dbus_client_set_proxy_handlers(client, proxy_added, proxy_removed,
 
2541
                                                        property_changed, NULL);
 
2542
 
 
2543
        g_main_loop_run(main_loop);
 
2544
 
 
2545
        g_dbus_client_unref(client);
 
2546
        g_source_remove(signal);
 
2547
        g_source_remove(input);
 
2548
 
 
2549
        rl_message("");
 
2550
        rl_callback_handler_remove();
 
2551
 
 
2552
        dbus_connection_unref(dbus_conn);
 
2553
        g_main_loop_unref(main_loop);
 
2554
 
 
2555
        return 0;
 
2556
}