client/manager.c

   1 /*
   2  *
   3  *  OBEX Client
   4  *
   5  *  Copyright (C) 2007-2010  Marcel Holtmann <marcel@holtmann.org>
   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 <stdlib.h>
  30 #include <string.h>
  31 #include <signal.h>
  32 #include <syslog.h>
  33
  34 #include <glib.h>
  35 #include <gdbus.h>
  36
  37 #include "log.h"
  38 #include "transfer.h"
  39 #include "session.h"
  40 #include "manager.h"
  41 #include "opp.h"
  42 #include "ftp.h"
  43 #include "pbap.h"
  44 #include "sync.h"
  45 #include "map.h"
  46
  47 #define CLIENT_SERVICE  "org.openobex.client"
  48
  49 #define CLIENT_INTERFACE  "org.openobex.Client"
  50 #define CLIENT_PATH       "/"
  51
  52 struct send_data {
  53         DBusConnection *connection;
  54         DBusMessage *message;
  55         gchar *sender;
  56         gchar *agent;
  57         char *filename;
  58         GPtrArray *files;
  59 };
  60
  61 static GSList *sessions = NULL;
  62
  63 static void shutdown_session(struct obc_session *session)
  64 {
  65         sessions = g_slist_remove(sessions, session);
  66         obc_session_shutdown(session);
  67         obc_session_unref(session);
  68 }
  69
  70 static void unregister_session(void *data)
  71 {
  72         struct obc_session *session = data;
  73
  74         if (g_slist_find(sessions, session) == NULL)
  75                 return;
  76
  77         sessions = g_slist_remove(sessions, session);
  78         obc_session_unref(session);
  79 }
  80
  81 static void create_callback(struct obc_session *session, GError *err,
  82                                                         void *user_data)
  83 {
  84         struct send_data *data = user_data;
  85         unsigned int i;
  86
  87         if (err != NULL) {
  88                 DBusMessage *error = g_dbus_create_error(data->message,
  89                                         "org.openobex.Error.Failed",
  90                                         "%s", err->message);
  91                 g_dbus_send_message(data->connection, error);
  92                 shutdown_session(session);
  93                 goto done;
  94         }
  95
  96         if (obc_session_get_target(session) != NULL) {
  97                 const char *path;
  98
  99                 path = obc_session_register(session, unregister_session);
 100
 101                 g_dbus_send_reply(data->connection, data->message,
 102                                 DBUS_TYPE_OBJECT_PATH, &path,
 103                                 DBUS_TYPE_INVALID);
 104                 goto done;
 105         }
 106
 107         g_dbus_send_reply(data->connection, data->message, DBUS_TYPE_INVALID);
 108
 109         obc_session_set_agent(session, data->sender, data->agent);
 110
 111         for (i = 0; i < data->files->len; i++) {
 112                 const gchar *filename = g_ptr_array_index(data->files, i);
 113                 gchar *basename = g_path_get_basename(filename);
 114
 115                 if (obc_session_send(session, filename, basename) < 0) {
 116                         g_free(basename);
 117                         break;
 118                 }
 119
 120                 g_free(basename);
 121         }
 122
 123         /* No need to keep a reference for SendFiles */
 124         sessions = g_slist_remove(sessions, session);
 125         obc_session_unref(session);
 126
 127 done:
 128         if (data->files)
 129                 g_ptr_array_free(data->files, TRUE);
 130         dbus_message_unref(data->message);
 131         dbus_connection_unref(data->connection);
 132         g_free(data->sender);
 133         g_free(data->agent);
 134         g_free(data);
 135 }
 136
 137 static int parse_device_dict(DBusMessageIter *iter,
 138                 const char **source, const char **dest, const char **target,
 139                 uint8_t *channel)
 140 {
 141         while (dbus_message_iter_get_arg_type(iter) == DBUS_TYPE_DICT_ENTRY) {
 142                 DBusMessageIter entry, value;
 143                 const char *key;
 144
 145                 dbus_message_iter_recurse(iter, &entry);
 146                 dbus_message_iter_get_basic(&entry, &key);
 147
 148                 dbus_message_iter_next(&entry);
 149                 dbus_message_iter_recurse(&entry, &value);
 150
 151                 switch (dbus_message_iter_get_arg_type(&value)) {
 152                 case DBUS_TYPE_STRING:
 153                         if (g_str_equal(key, "Source") == TRUE)
 154                                 dbus_message_iter_get_basic(&value, source);
 155                         else if (g_str_equal(key, "Destination") == TRUE)
 156                                 dbus_message_iter_get_basic(&value, dest);
 157                         else if (g_str_equal(key, "Target") == TRUE)
 158                                 dbus_message_iter_get_basic(&value, target);
 159                         break;
 160                 case DBUS_TYPE_BYTE:
 161                         if (g_str_equal(key, "Channel") == TRUE)
 162                                 dbus_message_iter_get_basic(&value, channel);
 163                         break;
 164                 }
 165
 166                 dbus_message_iter_next(iter);
 167         }
 168
 169         return 0;
 170 }
 171
 172 static DBusMessage *send_files(DBusConnection *connection,
 173                                         DBusMessage *message, void *user_data)
 174 {
 175         DBusMessageIter iter, array;
 176         struct obc_session *session;
 177         GPtrArray *files;
 178         struct send_data *data;
 179         const char *agent, *source = NULL, *dest = NULL, *target = NULL;
 180         const char *sender;
 181         uint8_t channel = 0;
 182
 183         dbus_message_iter_init(message, &iter);
 184         dbus_message_iter_recurse(&iter, &array);
 185
 186         parse_device_dict(&array, &source, &dest, &target, &channel);
 187         if (dest == NULL)
 188                 return g_dbus_create_error(message,
 189                                 "org.openobex.Error.InvalidArguments", NULL);
 190
 191         dbus_message_iter_next(&iter);
 192         dbus_message_iter_recurse(&iter, &array);
 193
 194         files = g_ptr_array_new();
 195         if (files == NULL)
 196                 return g_dbus_create_error(message,
 197                                         "org.openobex.Error.NoMemory", NULL);
 198
 199         while (dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_STRING) {
 200                 char *value;
 201
 202                 dbus_message_iter_get_basic(&array, &value);
 203                 g_ptr_array_add(files, value);
 204
 205                 dbus_message_iter_next(&array);
 206         }
 207
 208         dbus_message_iter_next(&iter);
 209         dbus_message_iter_get_basic(&iter, &agent);
 210
 211         if (files->len == 0) {
 212                 g_ptr_array_free(files, TRUE);
 213                 return g_dbus_create_error(message,
 214                                 "org.openobex.Error.InvalidArguments", NULL);
 215         }
 216
 217         sender = dbus_message_get_sender(message);
 218
 219         data = g_try_malloc0(sizeof(*data));
 220         if (data == NULL) {
 221                 g_ptr_array_free(files, TRUE);
 222                 return g_dbus_create_error(message,
 223                                         "org.openobex.Error.NoMemory", NULL);
 224         }
 225
 226         data->connection = dbus_connection_ref(connection);
 227         data->message = dbus_message_ref(message);
 228         data->sender = g_strdup(sender);
 229         data->agent = g_strdup(agent);
 230         data->files = files;
 231
 232         session = obc_session_create(source, dest, "OPP", channel, sender,
 233                                                         create_callback, data);
 234         if (session != NULL) {
 235                 sessions = g_slist_append(sessions, session);
 236                 return NULL;
 237         }
 238
 239         g_ptr_array_free(data->files, TRUE);
 240         dbus_message_unref(data->message);
 241         dbus_connection_unref(data->connection);
 242         g_free(data->sender);
 243         g_free(data->agent);
 244         g_free(data);
 245
 246         return g_dbus_create_error(message, "org.openobex.Error.Failed", NULL);
 247 }
 248
 249 static void pull_complete_callback(struct obc_session *session,
 250                                         GError *err, void *user_data)
 251 {
 252         struct send_data *data = user_data;
 253
 254         if (err != NULL) {
 255                 DBusMessage *error = g_dbus_create_error(data->message,
 256                                         "org.openobex.Error.Failed",
 257                                         "%s", err->message);
 258                 g_dbus_send_message(data->connection, error);
 259                 goto done;
 260         }
 261
 262         g_dbus_send_reply(data->connection, data->message, DBUS_TYPE_INVALID);
 263
 264 done:
 265         shutdown_session(session);
 266         dbus_message_unref(data->message);
 267         dbus_connection_unref(data->connection);
 268         g_free(data->filename);
 269         g_free(data->sender);
 270         g_free(data);
 271 }
 272
 273 static void pull_obc_session_callback(struct obc_session *session,
 274                                         GError *err, void *user_data)
 275 {
 276         struct send_data *data = user_data;
 277
 278         if (err != NULL) {
 279                 DBusMessage *error = g_dbus_create_error(data->message,
 280                                         "org.openobex.Error.Failed",
 281                                         "%s", err->message);
 282                 g_dbus_send_message(data->connection, error);
 283                 shutdown_session(session);
 284                 goto done;
 285         }
 286
 287         obc_session_pull(session, "text/x-vcard", data->filename,
 288                                                 pull_complete_callback, data);
 289
 290         return;
 291
 292 done:
 293         dbus_message_unref(data->message);
 294         dbus_connection_unref(data->connection);
 295         g_free(data->filename);
 296         g_free(data->sender);
 297         g_free(data);
 298 }
 299
 300 static DBusMessage *pull_business_card(DBusConnection *connection,
 301                                         DBusMessage *message, void *user_data)
 302 {
 303         DBusMessageIter iter, dict;
 304         struct obc_session *session;
 305         struct send_data *data;
 306         const char *source = NULL, *dest = NULL, *target = NULL;
 307         const char *name = NULL;
 308         uint8_t channel = 0;
 309
 310         dbus_message_iter_init(message, &iter);
 311         dbus_message_iter_recurse(&iter, &dict);
 312
 313         parse_device_dict(&dict, &source, &dest, &target, &channel);
 314         if (dest == NULL)
 315                 return g_dbus_create_error(message,
 316                                 "org.openobex.Error.InvalidArguments", NULL);
 317
 318         dbus_message_iter_next(&iter);
 319
 320         if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
 321                 return g_dbus_create_error(message,
 322                                 "org.openobex.Error.InvalidArguments", NULL);
 323
 324         dbus_message_iter_get_basic(&iter, &name);
 325
 326         data = g_try_malloc0(sizeof(*data));
 327         if (data == NULL)
 328                 return g_dbus_create_error(message,
 329                                         "org.openobex.Error.NoMemory", NULL);
 330
 331         data->connection = dbus_connection_ref(connection);
 332         data->message = dbus_message_ref(message);
 333         data->sender = g_strdup(dbus_message_get_sender(message));
 334         data->filename = g_strdup(name);
 335
 336         session = obc_session_create(source, dest, "OPP", channel, data->sender,
 337                                         pull_obc_session_callback, data);
 338         if (session != NULL) {
 339                 sessions = g_slist_append(sessions, session);
 340                 return NULL;
 341         }
 342
 343         dbus_message_unref(data->message);
 344         dbus_connection_unref(data->connection);
 345         g_free(data->sender);
 346         g_free(data->filename);
 347         g_free(data);
 348
 349         return g_dbus_create_error(message, "org.openobex.Error.Failed", NULL);
 350 }
 351
 352 static DBusMessage *exchange_business_cards(DBusConnection *connection,
 353                                         DBusMessage *message, void *user_data)
 354 {
 355         return g_dbus_create_error(message, "org.openobex.Error.Failed", NULL);
 356 }
 357
 358 static struct obc_session *find_session(const char *path)
 359 {
 360         GSList *l;
 361
 362         for (l = sessions; l; l = l->next) {
 363                 struct obc_session *session = l->data;
 364
 365                 if (g_str_equal(obc_session_get_path(session), path) == TRUE)
 366                         return session;
 367         }
 368
 369         return NULL;
 370 }
 371
 372 static DBusMessage *create_session(DBusConnection *connection,
 373                                         DBusMessage *message, void *user_data)
 374 {
 375         DBusMessageIter iter, dict;
 376         struct obc_session *session;
 377         struct send_data *data;
 378         const char *source = NULL, *dest = NULL, *target = NULL;
 379         uint8_t channel = 0;
 380
 381         dbus_message_iter_init(message, &iter);
 382         dbus_message_iter_recurse(&iter, &dict);
 383
 384         parse_device_dict(&dict, &source, &dest, &target, &channel);
 385         if (dest == NULL || target == NULL)
 386                 return g_dbus_create_error(message,
 387                                 "org.openobex.Error.InvalidArguments", NULL);
 388
 389         data = g_try_malloc0(sizeof(*data));
 390         if (data == NULL)
 391                 return g_dbus_create_error(message,
 392                                         "org.openobex.Error.NoMemory", NULL);
 393
 394         data->connection = dbus_connection_ref(connection);
 395         data->message = dbus_message_ref(message);
 396         data->sender = g_strdup(dbus_message_get_sender(message));
 397
 398         session = obc_session_create(source, dest, target, channel, data->sender,
 399                                                         create_callback, data);
 400         if (session != NULL) {
 401                 sessions = g_slist_append(sessions, session);
 402                 return NULL;
 403         }
 404
 405         dbus_message_unref(data->message);
 406         dbus_connection_unref(data->connection);
 407         g_free(data->sender);
 408         g_free(data);
 409
 410         return g_dbus_create_error(message, "org.openobex.Error.Failed", NULL);
 411 }
 412
 413 static DBusMessage *remove_session(DBusConnection *connection,
 414                                 DBusMessage *message, void *user_data)
 415 {
 416         struct obc_session *session;
 417         const gchar *sender, *path;
 418
 419         if (dbus_message_get_args(message, NULL,
 420                         DBUS_TYPE_OBJECT_PATH, &path,
 421                         DBUS_TYPE_INVALID) == FALSE)
 422                 return g_dbus_create_error(message,
 423                                 "org.openobex.Error.InvalidArguments", NULL);
 424
 425         session = find_session(path);
 426         if (session == NULL)
 427                 return g_dbus_create_error(message,
 428                                 "org.openobex.Error.InvalidArguments", NULL);
 429
 430         sender = dbus_message_get_sender(message);
 431         if (g_str_equal(sender, obc_session_get_owner(session)) == FALSE)
 432                 return g_dbus_create_error(message,
 433                                 "org.openobex.Error.NotAuthorized",
 434                                 "Not Authorized");
 435
 436         shutdown_session(session);
 437
 438         return dbus_message_new_method_return(message);
 439 }
 440
 441 static void capabilities_complete_callback(struct obc_session *session,
 442                                                 GError *err, void *user_data)
 443 {
 444         struct obc_transfer *transfer = obc_session_get_transfer(session);
 445         struct send_data *data = user_data;
 446         const char *capabilities;
 447         int size;
 448
 449         if (err != NULL) {
 450                 DBusMessage *error = g_dbus_create_error(data->message,
 451                                         "org.openobex.Error.Failed",
 452                                         "%s", err->message);
 453                 g_dbus_send_message(data->connection, error);
 454                 goto done;
 455         }
 456
 457         capabilities = obc_transfer_get_buffer(transfer, &size);
 458         if (size == 0)
 459                 capabilities = "";
 460
 461         g_dbus_send_reply(data->connection, data->message,
 462                         DBUS_TYPE_STRING, &capabilities,
 463                         DBUS_TYPE_INVALID);
 464
 465 done:
 466
 467         shutdown_session(session);
 468         dbus_message_unref(data->message);
 469         dbus_connection_unref(data->connection);
 470         g_free(data->sender);
 471         g_free(data);
 472 }
 473
 474 static void capability_obc_session_callback(struct obc_session *session,
 475                                                 GError *err, void *user_data)
 476 {
 477         struct send_data *data = user_data;
 478
 479         if (err != NULL) {
 480                 DBusMessage *error = g_dbus_create_error(data->message,
 481                                         "org.openobex.Error.Failed",
 482                                         "%s", err->message);
 483                 g_dbus_send_message(data->connection, error);
 484                 shutdown_session(session);
 485                 goto done;
 486         }
 487
 488         obc_session_pull(session, "x-obex/capability", NULL,
 489                                 capabilities_complete_callback, data);
 490
 491         return;
 492
 493 done:
 494         dbus_message_unref(data->message);
 495         dbus_connection_unref(data->connection);
 496         g_free(data->sender);
 497         g_free(data);
 498 }
 499
 500 static DBusMessage *get_capabilities(DBusConnection *connection,
 501                                         DBusMessage *message, void *user_data)
 502 {
 503         DBusMessageIter iter, dict;
 504         struct obc_session *session;
 505         struct send_data *data;
 506         const char *source = NULL, *dest = NULL, *target = NULL;
 507         uint8_t channel = 0;
 508
 509         dbus_message_iter_init(message, &iter);
 510         dbus_message_iter_recurse(&iter, &dict);
 511
 512         parse_device_dict(&dict, &source, &dest, &target, &channel);
 513         if (dest == NULL)
 514                 return g_dbus_create_error(message,
 515                                 "org.openobex.Error.InvalidArguments", NULL);
 516
 517         data = g_try_malloc0(sizeof(*data));
 518         if (data == NULL)
 519                 return g_dbus_create_error(message,
 520                                         "org.openobex.Error.NoMemory", NULL);
 521
 522         data->connection = dbus_connection_ref(connection);
 523         data->message = dbus_message_ref(message);
 524         data->sender = g_strdup(dbus_message_get_sender(message));
 525
 526         if (!target)
 527                 target = "OPP";
 528
 529         session = obc_session_create(source, dest, target, channel, data->sender,
 530                                         capability_obc_session_callback, data);
 531         if (session != NULL) {
 532                 sessions = g_slist_append(sessions, session);
 533                 return NULL;
 534         }
 535
 536         dbus_message_unref(data->message);
 537         dbus_connection_unref(data->connection);
 538         g_free(data->sender);
 539         g_free(data);
 540
 541         return g_dbus_create_error(message, "org.openobex.Error.Failed", NULL);
 542 }
 543
 544 #ifdef TIZEN_PATCH
 545 static DBusMessage *get_transfers(DBusConnection *connection,
 546                                         DBusMessage *message, void *user_data)
 547 {
 548         DBusMessage *reply;
 549         GSList *l;
 550         DBusMessageIter iter;
 551         DBusMessageIter array_iter;
 552
 553         reply = dbus_message_new_method_return(message);
 554         if (!reply)
 555                 return NULL;
 556
 557         dbus_message_iter_init_append(reply, &iter);
 558         dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
 559                                 DBUS_TYPE_OBJECT_PATH_AS_STRING, &array_iter);
 560
 561         for (l = opc_get_sessions(); l; l = l->next) {
 562                 struct obc_session *session = l->data;
 563                 GSList *k;
 564
 565                 if (session == NULL)
 566                         continue;
 567
 568                 for (k = opc_get_session_pending(session); k; k = k->next) {
 569                         struct obc_transfer *transfer = k->data;
 570                         const char *path = NULL;
 571
 572                         if (transfer == NULL)
 573                                 continue;
 574
 575                         path = obc_transfer_get_path(transfer);
 576
 577                         if (path == NULL)
 578                                 continue;
 579
 580                         DBG("transfer path: %s", path);
 581
 582                         dbus_message_iter_append_basic(&array_iter,
 583                                                 DBUS_TYPE_OBJECT_PATH,
 584                                                 &path);
 585                 }
 586         }
 587
 588         dbus_message_iter_close_container(&iter, &array_iter);
 589
 590         return reply;
 591 }
 592 #endif
 593 static GDBusMethodTable client_methods[] = {
 594         { "SendFiles", "a{sv}aso", "", send_files,
 595                                                 G_DBUS_METHOD_FLAG_ASYNC },
 596         { "PullBusinessCard", "a{sv}s", "", pull_business_card,
 597                                                 G_DBUS_METHOD_FLAG_ASYNC },
 598         { "ExchangeBusinessCards", "a{sv}ss", "", exchange_business_cards,
 599                                                 G_DBUS_METHOD_FLAG_ASYNC },
 600         { "CreateSession", "a{sv}", "o", create_session,
 601                                                 G_DBUS_METHOD_FLAG_ASYNC },
 602         { "RemoveSession", "o", "", remove_session,
 603                                                 G_DBUS_METHOD_FLAG_ASYNC },
 604         { "GetCapabilities", "a{sv}", "s", get_capabilities,
 605                                                 G_DBUS_METHOD_FLAG_ASYNC },
 606 #ifdef TIZEN_PATCH
 607         { "GetTransfers", "", "ao", get_transfers,
 608                                                 G_DBUS_METHOD_FLAG_ASYNC },
 609 #endif
 610         { }
 611 };
 612
 613 static DBusConnection *conn = NULL;
 614
 615 static struct target_module {
 616         const char *name;
 617         int (*init) (void);
 618         void (*exit) (void);
 619 } targets[] = {
 620         { "opp", opp_init, opp_exit },
 621         { "ftp", ftp_init, ftp_exit },
 622         { "pbap", pbap_init, pbap_exit },
 623         { "sync", sync_init, sync_exit },
 624         { "map", map_init, map_exit },
 625         { }
 626 };
 627
 628 int manager_init(void)
 629 {
 630         DBusError derr;
 631         struct target_module *target;
 632
 633         dbus_error_init(&derr);
 634
 635         conn = g_dbus_setup_bus(DBUS_BUS_SESSION, CLIENT_SERVICE, &derr);
 636         if (dbus_error_is_set(&derr) == TRUE) {
 637                 error("%s: %s", derr.name, derr.message);
 638                 dbus_error_free(&derr);
 639                 return -1;
 640         }
 641
 642         if (g_dbus_register_interface(conn, CLIENT_PATH, CLIENT_INTERFACE,
 643                                                 client_methods, NULL, NULL,
 644                                                         NULL, NULL) == FALSE) {
 645                 error("Can't register client interface");
 646                 dbus_connection_unref(conn);
 647                 conn = NULL;
 648                 return -1;
 649         }
 650
 651         for (target = targets; target && target->init; target++) {
 652                 if (target->init() < 0)
 653                         continue;
 654
 655                 DBG("Target %s loaded", target->name);
 656         }
 657
 658         return 0;
 659 }
 660
 661 void manager_exit(void)
 662 {
 663         struct target_module *target;
 664
 665         if (conn == NULL)
 666                 return;
 667
 668         for (target = targets; target && target->exit; target++)
 669                 target->exit();
 670
 671         g_dbus_unregister_interface(conn, CLIENT_PATH, CLIENT_INTERFACE);
 672         dbus_connection_unref(conn);
 673 }