client/session.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 <errno.h>
  29 #include <fcntl.h>
  30 #include <unistd.h>
  31 #include <string.h>
  32 #include <sys/stat.h>
  33
  34 #include <glib.h>
  35 #include <gdbus.h>
  36 #include <gobex.h>
  37
  38 #include <bluetooth/bluetooth.h>
  39 #include <bluetooth/rfcomm.h>
  40 #include <bluetooth/sdp.h>
  41 #include <bluetooth/sdp_lib.h>
  42
  43 #include "log.h"
  44 #include "transfer.h"
  45 #include "session.h"
  46 #include "btio.h"
  47 #include "agent.h"
  48 #include "driver.h"
  49
  50 #define SESSION_INTERFACE  "org.openobex.Session"
  51 #define SESSION_BASEPATH   "/org/openobex"
  52
  53 #define OBEX_IO_ERROR obex_io_error_quark()
  54
  55 #define BT_BUS_NAME             "org.bluez"
  56 #define BT_PATH                 "/"
  57 #define BT_ADAPTER_IFACE        "org.bluez.Adapter"
  58 #define BT_MANAGER_IFACE        "org.bluez.Manager"
  59
  60 static guint64 counter = 0;
  61
  62 struct callback_data {
  63         struct obc_session *session;
  64         sdp_session_t *sdp;
  65         session_callback_t func;
  66         void *data;
  67 };
  68
  69 struct session_callback {
  70         session_callback_t func;
  71         void *data;
  72 };
  73
  74 struct pending_data {
  75         session_callback_t cb;
  76         struct obc_session *session;
  77         struct obc_transfer *transfer;
  78 };
  79
  80 struct pending_req {
  81         DBusPendingCall *call;
  82         void *user_data;
  83 };
  84
  85 struct obc_session {
  86         gint refcount;
  87         bdaddr_t src;
  88         bdaddr_t dst;
  89         uint8_t channel;
  90         struct obc_driver *driver;
  91         gchar *path;            /* Session path */
  92         DBusConnection *conn;
  93         DBusConnection *conn_system; /* system bus connection */
  94         DBusMessage *msg;
  95         GObex *obex;
  96         GIOChannel *io;
  97         struct obc_agent *agent;
  98         struct session_callback *callback;
  99         gchar *owner;           /* Session owner */
 100         guint watch;
 101         GSList *pending;
 102         GSList *pending_calls;
 103         void *priv;
 104         char *adapter;
 105 };
 106
 107 static GSList *sessions = NULL;
 108
 109 static void session_prepare_put(struct obc_session *session, GError *err,
 110                                                                 void *data);
 111 static void session_terminate_transfer(struct obc_session *session,
 112                                         struct obc_transfer *transfer,
 113                                         GError *gerr);
 114
 115 GQuark obex_io_error_quark(void)
 116 {
 117         return g_quark_from_static_string("obex-io-error-quark");
 118 }
 119
 120 struct obc_session *obc_session_ref(struct obc_session *session)
 121 {
 122         g_atomic_int_inc(&session->refcount);
 123
 124         DBG("%p: ref=%d", session, session->refcount);
 125
 126         return session;
 127 }
 128
 129 static void session_unregistered(struct obc_session *session)
 130 {
 131         char *path;
 132
 133         if (session->driver && session->driver->remove)
 134                 session->driver->remove(session);
 135
 136         path = session->path;
 137         session->path = NULL;
 138
 139         g_dbus_unregister_interface(session->conn, path, SESSION_INTERFACE);
 140
 141         DBG("Session(%p) unregistered %s", session, path);
 142
 143         g_free(path);
 144 }
 145
 146 static struct pending_req *find_session_request(
 147                                 const struct obc_session *session,
 148                                 const DBusPendingCall *call)
 149 {
 150         GSList *l;
 151
 152         for (l = session->pending_calls; l; l = l->next) {
 153                 struct pending_req *req = l->data;
 154
 155                 if (req->call == call)
 156                         return req;
 157         }
 158
 159         return NULL;
 160 }
 161
 162 static void pending_req_finalize(struct pending_req *req)
 163 {
 164         if (!dbus_pending_call_get_completed(req->call))
 165                 dbus_pending_call_cancel(req->call);
 166
 167         dbus_pending_call_unref(req->call);
 168         g_free(req);
 169 }
 170
 171 static void session_free(struct obc_session *session)
 172 {
 173         GSList *l = session->pending_calls;
 174
 175         DBG("%p", session);
 176
 177         while (l) {
 178                 struct pending_req *req = l->data;
 179                 l = l->next;
 180
 181                 session->pending_calls = g_slist_remove(session->pending_calls, req);
 182                 pending_req_finalize(req);
 183         }
 184
 185         if (session->agent) {
 186                 obc_agent_release(session->agent);
 187                 obc_agent_free(session->agent);
 188         }
 189
 190         if (session->watch)
 191                 g_dbus_remove_watch(session->conn, session->watch);
 192
 193         if (session->obex != NULL)
 194                 g_obex_unref(session->obex);
 195
 196         if (session->io != NULL) {
 197                 g_io_channel_shutdown(session->io, TRUE, NULL);
 198                 g_io_channel_unref(session->io);
 199         }
 200
 201         if (session->path)
 202                 session_unregistered(session);
 203
 204         if (session->conn)
 205                 dbus_connection_unref(session->conn);
 206
 207         if (session->conn_system)
 208                 dbus_connection_unref(session->conn_system);
 209
 210         sessions = g_slist_remove(sessions, session);
 211
 212         g_free(session->adapter);
 213         g_free(session->callback);
 214         g_free(session->path);
 215         g_free(session->owner);
 216         g_free(session);
 217 }
 218
 219 static struct pending_req *send_method_call(DBusConnection *connection,
 220                                 const char *dest, const char *path,
 221                                 const char *interface, const char *method,
 222                                 DBusPendingCallNotifyFunction cb,
 223                                 void *user_data, int type, ...)
 224 {
 225         DBusMessage *msg;
 226         DBusPendingCall *call;
 227         va_list args;
 228         struct pending_req *req;
 229
 230         msg = dbus_message_new_method_call(dest, path, interface, method);
 231         if (!msg) {
 232                 error("Unable to allocate new D-Bus %s message", method);
 233                 return NULL;
 234         }
 235
 236         va_start(args, type);
 237
 238         if (!dbus_message_append_args_valist(msg, type, args)) {
 239                 dbus_message_unref(msg);
 240                 va_end(args);
 241                 return NULL;
 242         }
 243
 244         va_end(args);
 245
 246         if (!cb) {
 247                 g_dbus_send_message(connection, msg);
 248                 return 0;
 249         }
 250
 251         if (!dbus_connection_send_with_reply(connection, msg, &call, -1)) {
 252                 error("Sending %s failed", method);
 253                 dbus_message_unref(msg);
 254                 return NULL;
 255         }
 256
 257         dbus_pending_call_set_notify(call, cb, user_data, NULL);
 258
 259         req = g_new0(struct pending_req, 1);
 260         req->call = call;
 261         req->user_data = user_data;
 262
 263         dbus_message_unref(msg);
 264
 265         return req;
 266 }
 267
 268 void obc_session_unref(struct obc_session *session)
 269 {
 270         gboolean ret;
 271
 272         ret = g_atomic_int_dec_and_test(&session->refcount);
 273
 274         DBG("%p: ref=%d", session, session->refcount);
 275
 276         if (ret == FALSE)
 277                 return;
 278
 279         send_method_call(session->conn_system,
 280                                 BT_BUS_NAME, session->adapter,
 281                                 BT_ADAPTER_IFACE, "ReleaseSession",
 282                                 NULL, NULL,
 283                                 DBUS_TYPE_INVALID);
 284         session_free(session);
 285 }
 286
 287 static void connect_cb(GObex *obex, GError *err, GObexPacket *rsp,
 288                                                         gpointer user_data)
 289 {
 290         struct callback_data *callback = user_data;
 291         GError *gerr = NULL;
 292         uint8_t rsp_code;
 293
 294         if (err != NULL) {
 295                 error("connect_cb: %s", err->message);
 296                 gerr = g_error_copy(err);
 297                 goto done;
 298         }
 299
 300         rsp_code = g_obex_packet_get_operation(rsp, NULL);
 301         if (rsp_code != G_OBEX_RSP_SUCCESS)
 302                 gerr = g_error_new(OBEX_IO_ERROR, -EIO,
 303                                 "OBEX Connect failed with 0x%02x", rsp_code);
 304
 305 done:
 306         callback->func(callback->session, gerr, callback->data);
 307         if (gerr != NULL)
 308                 g_error_free(gerr);
 309         obc_session_unref(callback->session);
 310         g_free(callback);
 311 }
 312
 313 static void rfcomm_callback(GIOChannel *io, GError *err, gpointer user_data)
 314 {
 315         struct callback_data *callback = user_data;
 316         struct obc_session *session = callback->session;
 317         struct obc_driver *driver = session->driver;
 318         GObex *obex;
 319
 320         DBG("");
 321
 322         if (err != NULL) {
 323                 error("%s", err->message);
 324                 goto done;
 325         }
 326
 327         g_io_channel_set_close_on_unref(session->io, FALSE);
 328
 329         obex = g_obex_new(session->io, G_OBEX_TRANSPORT_STREAM, -1, -1);
 330         if (obex == NULL)
 331                 goto done;
 332
 333         g_io_channel_set_close_on_unref(session->io, TRUE);
 334         g_io_channel_unref(session->io);
 335         session->io = NULL;
 336
 337         if (driver->target != NULL)
 338                 g_obex_connect(obex, connect_cb, callback, &err,
 339                         G_OBEX_HDR_TARGET, driver->target, driver->target_len,
 340                         G_OBEX_HDR_INVALID);
 341         else
 342                 g_obex_connect(obex, connect_cb, callback, &err,
 343                                                         G_OBEX_HDR_INVALID);
 344
 345         if (err != NULL) {
 346                 error("%s", err->message);
 347                 g_obex_unref(obex);
 348                 goto done;
 349         }
 350
 351         session->obex = obex;
 352         sessions = g_slist_prepend(sessions, session);
 353
 354         return;
 355 done:
 356         callback->func(callback->session, err, callback->data);
 357         obc_session_unref(callback->session);
 358         g_free(callback);
 359 }
 360
 361 static GIOChannel *rfcomm_connect(const bdaddr_t *src, const bdaddr_t *dst,
 362                                         uint8_t channel, BtIOConnect function,
 363                                         gpointer user_data)
 364 {
 365         GIOChannel *io;
 366         GError *err = NULL;
 367
 368         DBG("");
 369
 370         io = bt_io_connect(BT_IO_RFCOMM, function, user_data, NULL, &err,
 371                                 BT_IO_OPT_SOURCE_BDADDR, src,
 372                                 BT_IO_OPT_DEST_BDADDR, dst,
 373                                 BT_IO_OPT_CHANNEL, channel,
 374                                 BT_IO_OPT_SEC_LEVEL, BT_IO_SEC_LOW,
 375                                 BT_IO_OPT_INVALID);
 376         if (io != NULL)
 377                 return io;
 378
 379         error("%s", err->message);
 380         g_error_free(err);
 381         return NULL;
 382 }
 383
 384 static void search_callback(uint8_t type, uint16_t status,
 385                         uint8_t *rsp, size_t size, void *user_data)
 386 {
 387         struct callback_data *callback = user_data;
 388         struct obc_session *session = callback->session;
 389         unsigned int scanned, bytesleft = size;
 390         int seqlen = 0;
 391         uint8_t dataType, channel = 0;
 392         GError *gerr = NULL;
 393
 394         if (status || type != SDP_SVC_SEARCH_ATTR_RSP)
 395                 goto failed;
 396
 397         scanned = sdp_extract_seqtype(rsp, bytesleft, &dataType, &seqlen);
 398         if (!scanned || !seqlen)
 399                 goto failed;
 400
 401         rsp += scanned;
 402         bytesleft -= scanned;
 403         do {
 404                 sdp_record_t *rec;
 405                 sdp_list_t *protos;
 406                 int recsize, ch = -1;
 407
 408                 recsize = 0;
 409                 rec = sdp_extract_pdu(rsp, bytesleft, &recsize);
 410                 if (!rec)
 411                         break;
 412
 413                 if (!recsize) {
 414                         sdp_record_free(rec);
 415                         break;
 416                 }
 417
 418                 if (!sdp_get_access_protos(rec, &protos)) {
 419                         ch = sdp_get_proto_port(protos, RFCOMM_UUID);
 420                         sdp_list_foreach(protos,
 421                                         (sdp_list_func_t) sdp_list_free, NULL);
 422                         sdp_list_free(protos, NULL);
 423                         protos = NULL;
 424                 }
 425
 426                 sdp_record_free(rec);
 427
 428                 if (ch > 0) {
 429                         channel = ch;
 430                         break;
 431                 }
 432
 433                 scanned += recsize;
 434                 rsp += recsize;
 435                 bytesleft -= recsize;
 436         } while (scanned < size && bytesleft > 0);
 437
 438         if (channel == 0)
 439                 goto failed;
 440
 441         session->channel = channel;
 442
 443         g_io_channel_set_close_on_unref(session->io, FALSE);
 444         g_io_channel_unref(session->io);
 445
 446         session->io = rfcomm_connect(&session->src, &session->dst, channel,
 447                                         rfcomm_callback, callback);
 448         if (session->io != NULL) {
 449                 sdp_close(callback->sdp);
 450                 return;
 451         }
 452
 453 failed:
 454         g_io_channel_shutdown(session->io, TRUE, NULL);
 455         g_io_channel_unref(session->io);
 456         session->io = NULL;
 457
 458         g_set_error(&gerr, OBEX_IO_ERROR, -EIO,
 459                                         "Unable to find service record");
 460         callback->func(session, gerr, callback->data);
 461         g_clear_error(&gerr);
 462
 463         obc_session_unref(callback->session);
 464         g_free(callback);
 465 }
 466
 467 static gboolean process_callback(GIOChannel *io, GIOCondition cond,
 468                                                         gpointer user_data)
 469 {
 470         struct callback_data *callback = user_data;
 471
 472         if (cond & (G_IO_ERR | G_IO_HUP | G_IO_NVAL))
 473                 return FALSE;
 474
 475         if (sdp_process(callback->sdp) < 0)
 476                 return FALSE;
 477
 478         return TRUE;
 479 }
 480
 481 static int bt_string2uuid(uuid_t *uuid, const char *string)
 482 {
 483         uint32_t data0, data4;
 484         uint16_t data1, data2, data3, data5;
 485
 486         if (sscanf(string, "%08x-%04hx-%04hx-%04hx-%08x%04hx",
 487                                 &data0, &data1, &data2, &data3, &data4, &data5) == 6) {
 488                 uint8_t val[16];
 489
 490                 data0 = g_htonl(data0);
 491                 data1 = g_htons(data1);
 492                 data2 = g_htons(data2);
 493                 data3 = g_htons(data3);
 494                 data4 = g_htonl(data4);
 495                 data5 = g_htons(data5);
 496
 497                 memcpy(&val[0], &data0, 4);
 498                 memcpy(&val[4], &data1, 2);
 499                 memcpy(&val[6], &data2, 2);
 500                 memcpy(&val[8], &data3, 2);
 501                 memcpy(&val[10], &data4, 4);
 502                 memcpy(&val[14], &data5, 2);
 503
 504                 sdp_uuid128_create(uuid, val);
 505
 506                 return 0;
 507         }
 508
 509         return -EINVAL;
 510 }
 511
 512 static gboolean service_callback(GIOChannel *io, GIOCondition cond,
 513                                                         gpointer user_data)
 514 {
 515         struct callback_data *callback = user_data;
 516         struct obc_session *session = callback->session;
 517         sdp_list_t *search, *attrid;
 518         uint32_t range = 0x0000ffff;
 519         GError *gerr = NULL;
 520         uuid_t uuid;
 521
 522         if (cond & (G_IO_NVAL | G_IO_ERR))
 523                 goto failed;
 524
 525         if (sdp_set_notify(callback->sdp, search_callback, callback) < 0)
 526                 goto failed;
 527
 528         if (bt_string2uuid(&uuid, session->driver->uuid) < 0)
 529                 goto failed;
 530
 531         search = sdp_list_append(NULL, &uuid);
 532         attrid = sdp_list_append(NULL, &range);
 533
 534         if (sdp_service_search_attr_async(callback->sdp,
 535                                 search, SDP_ATTR_REQ_RANGE, attrid) < 0) {
 536                 sdp_list_free(attrid, NULL);
 537                 sdp_list_free(search, NULL);
 538                 goto failed;
 539         }
 540
 541         sdp_list_free(attrid, NULL);
 542         sdp_list_free(search, NULL);
 543
 544         g_io_add_watch(io, G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
 545                                                 process_callback, callback);
 546
 547         return FALSE;
 548
 549 failed:
 550         g_io_channel_shutdown(session->io, TRUE, NULL);
 551         g_io_channel_unref(session->io);
 552         session->io = NULL;
 553
 554         g_set_error(&gerr, OBEX_IO_ERROR, -EIO,
 555                                         "Unable to find service record");
 556         callback->func(callback->session, gerr, callback->data);
 557         g_clear_error(&gerr);
 558
 559         obc_session_unref(callback->session);
 560         g_free(callback);
 561         return FALSE;
 562 }
 563
 564 static sdp_session_t *service_connect(const bdaddr_t *src, const bdaddr_t *dst,
 565                                         GIOFunc function, gpointer user_data)
 566 {
 567         struct callback_data *cb = user_data;
 568         sdp_session_t *sdp;
 569         GIOChannel *io;
 570
 571         sdp = sdp_connect(src, dst, SDP_NON_BLOCKING);
 572         if (sdp == NULL)
 573                 return NULL;
 574
 575         io = g_io_channel_unix_new(sdp_get_socket(sdp));
 576         if (io == NULL) {
 577                 sdp_close(sdp);
 578                 return NULL;
 579         }
 580
 581         g_io_add_watch(io, G_IO_OUT | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
 582                                                         function, user_data);
 583
 584         cb->session->io = io;
 585
 586         return sdp;
 587 }
 588
 589 static gboolean connection_complete(gpointer data)
 590 {
 591         struct callback_data *cb = data;
 592
 593         cb->func(cb->session, 0, cb->data);
 594
 595         obc_session_unref(cb->session);
 596
 597         g_free(cb);
 598
 599         return FALSE;
 600 }
 601
 602 static void owner_disconnected(DBusConnection *connection, void *user_data)
 603 {
 604         struct obc_session *session = user_data;
 605
 606         DBG("");
 607
 608         obc_session_shutdown(session);
 609 }
 610
 611 int obc_session_set_owner(struct obc_session *session, const char *name,
 612                         GDBusWatchFunction func)
 613 {
 614         if (session == NULL)
 615                 return -EINVAL;
 616
 617         if (session->watch)
 618                 g_dbus_remove_watch(session->conn, session->watch);
 619
 620         session->watch = g_dbus_add_disconnect_watch(session->conn, name, func,
 621                                                         session, NULL);
 622         if (session->watch == 0)
 623                 return -EINVAL;
 624
 625         session->owner = g_strdup(name);
 626
 627         return 0;
 628 }
 629
 630 static struct obc_session *session_find(const char *source,
 631                                                 const char *destination,
 632                                                 const char *service,
 633                                                 uint8_t channel,
 634                                                 const char *owner)
 635 {
 636         GSList *l;
 637
 638         for (l = sessions; l; l = l->next) {
 639                 struct obc_session *session = l->data;
 640                 bdaddr_t adr;
 641
 642                 if (source) {
 643                         str2ba(source, &adr);
 644                         if (bacmp(&session->src, &adr))
 645                                 continue;
 646                 }
 647
 648                 str2ba(destination, &adr);
 649                 if (bacmp(&session->dst, &adr))
 650                         continue;
 651
 652                 if (g_strcmp0(service, session->driver->service))
 653                         continue;
 654
 655                 if (channel && session->channel != channel)
 656                         continue;
 657
 658                 if (g_strcmp0(owner, session->owner))
 659                         continue;
 660
 661                 return session;
 662         }
 663
 664         return NULL;
 665 }
 666
 667 static int session_connect(struct obc_session *session,
 668                                                 struct callback_data *callback)
 669 {
 670         int err;
 671
 672         if (session->obex) {
 673                 g_idle_add(connection_complete, callback);
 674                 err = 0;
 675         } else if (session->channel > 0) {
 676                 session->io = rfcomm_connect(&session->src, &session->dst,
 677                                                         session->channel,
 678                                                         rfcomm_callback,
 679                                                         callback);
 680                 err = (session->io == NULL) ? -EINVAL : 0;
 681         } else {
 682                 callback->sdp = service_connect(&session->src, &session->dst,
 683                                                 service_callback, callback);
 684                 err = (callback->sdp == NULL) ? -ENOMEM : 0;
 685         }
 686
 687         return err;
 688 }
 689
 690 static void adapter_reply(DBusPendingCall *call, void *user_data)
 691 {
 692         DBusError err;
 693         DBusMessage *reply;
 694         struct callback_data *callback = user_data;
 695         struct obc_session *session = callback->session;
 696         struct pending_req *req = find_session_request(session, call);
 697
 698         reply = dbus_pending_call_steal_reply(call);
 699
 700         session->pending_calls = g_slist_remove(session->pending_calls, req);
 701         pending_req_finalize(req);
 702
 703         dbus_error_init(&err);
 704         if (dbus_set_error_from_message(&err, reply)) {
 705                 error("manager replied with an error: %s, %s",
 706                                 err.name, err.message);
 707                 dbus_error_free(&err);
 708
 709                 goto failed;
 710         }
 711
 712         if (session_connect(session, callback) < 0)
 713                 goto failed;
 714
 715         goto proceed;
 716
 717 failed:
 718         obc_session_unref(session);
 719         g_free(callback);
 720
 721 proceed:
 722         dbus_message_unref(reply);
 723 }
 724
 725 static void manager_reply(DBusPendingCall *call, void *user_data)
 726 {
 727         DBusError err;
 728         DBusMessage *reply;
 729         char *adapter;
 730         struct callback_data *callback = user_data;
 731         struct obc_session *session = callback->session;
 732         struct pending_req *req = find_session_request(session, call);
 733
 734         reply = dbus_pending_call_steal_reply(call);
 735
 736         session->pending_calls = g_slist_remove(session->pending_calls, req);
 737         pending_req_finalize(req);
 738
 739         dbus_error_init(&err);
 740         if (dbus_set_error_from_message(&err, reply)) {
 741                 error("manager replied with an error: %s, %s",
 742                                 err.name, err.message);
 743                 dbus_error_free(&err);
 744
 745                 goto failed;
 746         }
 747
 748         if (dbus_message_get_args(reply, NULL,
 749                                 DBUS_TYPE_OBJECT_PATH, &adapter,
 750                                 DBUS_TYPE_INVALID)) {
 751                 DBG("adapter path %s", adapter);
 752
 753                 session->adapter = g_strdup(adapter);
 754                 req = send_method_call(session->conn_system,
 755                                         BT_BUS_NAME, adapter,
 756                                         BT_ADAPTER_IFACE, "RequestSession",
 757                                         adapter_reply, callback,
 758                                         DBUS_TYPE_INVALID);
 759                 if (!req)
 760                         goto failed;
 761
 762                 session->pending_calls = g_slist_prepend(session->pending_calls,
 763                                                                         req);
 764         } else
 765                 goto failed;
 766
 767         goto proceed;
 768
 769 failed:
 770         obc_session_unref(session);
 771         g_free(callback);
 772
 773 proceed:
 774         dbus_message_unref(reply);
 775 }
 776
 777 struct obc_session *obc_session_create(const char *source,
 778                                                 const char *destination,
 779                                                 const char *service,
 780                                                 uint8_t channel,
 781                                                 const char *owner,
 782                                                 session_callback_t function,
 783                                                 void *user_data)
 784 {
 785         struct obc_session *session;
 786         struct callback_data *callback;
 787         struct pending_req *req;
 788         struct obc_driver *driver;
 789
 790         if (destination == NULL)
 791                 return NULL;
 792
 793         session = session_find(source, destination, service, channel, owner);
 794         if (session) {
 795                 obc_session_ref(session);
 796                 goto proceed;
 797         }
 798
 799         driver = obc_driver_find(service);
 800         if (!driver)
 801                 return NULL;
 802
 803         session = g_try_malloc0(sizeof(*session));
 804         if (session == NULL)
 805                 return NULL;
 806
 807         session->refcount = 1;
 808         session->channel = channel;
 809         session->conn = dbus_bus_get(DBUS_BUS_SESSION, NULL);
 810         if (session->conn == NULL) {
 811                 session_free(session);
 812                 return NULL;
 813         }
 814
 815         session->conn_system = g_dbus_setup_bus(DBUS_BUS_SYSTEM, NULL, NULL);
 816         if (session->conn_system == NULL) {
 817                 session_free(session);
 818                 return NULL;
 819         }
 820
 821         if (source == NULL)
 822                 bacpy(&session->src, BDADDR_ANY);
 823         else
 824                 str2ba(source, &session->src);
 825
 826         str2ba(destination, &session->dst);
 827         session->driver = driver;
 828
 829         DBG("driver %s", driver->service);
 830
 831 proceed:
 832         callback = g_try_malloc0(sizeof(*callback));
 833         if (callback == NULL) {
 834                 obc_session_unref(session);
 835                 return NULL;
 836         }
 837
 838         callback->session = obc_session_ref(session);
 839         callback->func = function;
 840         callback->data = user_data;
 841
 842         if (source) {
 843                 req = send_method_call(session->conn_system,
 844                                 BT_BUS_NAME, BT_PATH,
 845                                 BT_MANAGER_IFACE, "FindAdapter",
 846                                 manager_reply, callback,
 847                                 DBUS_TYPE_STRING, &source,
 848                                 DBUS_TYPE_INVALID);
 849         } else {
 850                 req = send_method_call(session->conn_system,
 851                                 BT_BUS_NAME, BT_PATH,
 852                                 BT_MANAGER_IFACE, "DefaultAdapter",
 853                                 manager_reply, callback,
 854                                 DBUS_TYPE_INVALID);
 855         }
 856
 857         if (!req) {
 858                 obc_session_unref(session);
 859                 g_free(callback);
 860                 return NULL;
 861         }
 862
 863         session->pending_calls = g_slist_prepend(session->pending_calls, req);
 864
 865         if (owner)
 866                 obc_session_set_owner(session, owner, owner_disconnected);
 867
 868         return session;
 869 }
 870
 871 void obc_session_shutdown(struct obc_session *session)
 872 {
 873         DBG("%p", session);
 874
 875         obc_session_ref(session);
 876
 877         /* Unregister any pending transfer */
 878         g_slist_foreach(session->pending, (GFunc) obc_transfer_unregister,
 879                                                                         NULL);
 880
 881         /* Unregister interfaces */
 882         if (session->path)
 883                 session_unregistered(session);
 884
 885         /* Shutdown io */
 886         if (session->io) {
 887                 int fd = g_io_channel_unix_get_fd(session->io);
 888                 shutdown(fd, SHUT_RDWR);
 889         }
 890
 891         obc_session_unref(session);
 892 }
 893
 894 static DBusMessage *assign_agent(DBusConnection *connection,
 895                                 DBusMessage *message, void *user_data)
 896 {
 897         struct obc_session *session = user_data;
 898         const gchar *sender, *path;
 899
 900         if (dbus_message_get_args(message, NULL,
 901                                         DBUS_TYPE_OBJECT_PATH, &path,
 902                                         DBUS_TYPE_INVALID) == FALSE)
 903                 return g_dbus_create_error(message,
 904                                 "org.openobex.Error.InvalidArguments",
 905                                 "Invalid arguments in method call");
 906
 907         sender = dbus_message_get_sender(message);
 908
 909         if (obc_session_set_agent(session, sender, path) < 0)
 910                 return g_dbus_create_error(message,
 911                                 "org.openobex.Error.AlreadyExists",
 912                                 "Already exists");
 913
 914         return dbus_message_new_method_return(message);
 915 }
 916
 917 static DBusMessage *release_agent(DBusConnection *connection,
 918                                 DBusMessage *message, void *user_data)
 919 {
 920         struct obc_session *session = user_data;
 921         struct obc_agent *agent = session->agent;
 922         const gchar *sender;
 923         gchar *path;
 924
 925         if (dbus_message_get_args(message, NULL,
 926                                         DBUS_TYPE_OBJECT_PATH, &path,
 927                                         DBUS_TYPE_INVALID) == FALSE)
 928                 return g_dbus_create_error(message,
 929                                 "org.openobex.Error.InvalidArguments",
 930                                 "Invalid arguments in method call");
 931
 932         sender = dbus_message_get_sender(message);
 933
 934         if (agent == NULL)
 935                 return dbus_message_new_method_return(message);
 936
 937         if (g_str_equal(sender, obc_agent_get_name(agent)) == FALSE ||
 938                         g_str_equal(path, obc_agent_get_path(agent)) == FALSE)
 939                 return g_dbus_create_error(message,
 940                                 "org.openobex.Error.NotAuthorized",
 941                                 "Not Authorized");
 942
 943         obc_agent_free(agent);
 944
 945         return dbus_message_new_method_return(message);
 946 }
 947
 948 static void append_entry(DBusMessageIter *dict,
 949                                 const char *key, int type, void *val)
 950 {
 951         DBusMessageIter entry, value;
 952         const char *signature;
 953
 954         dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY,
 955                                                                 NULL, &entry);
 956
 957         dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
 958
 959         switch (type) {
 960         case DBUS_TYPE_STRING:
 961                 signature = DBUS_TYPE_STRING_AS_STRING;
 962                 break;
 963         case DBUS_TYPE_BYTE:
 964                 signature = DBUS_TYPE_BYTE_AS_STRING;
 965                 break;
 966         case DBUS_TYPE_UINT64:
 967                 signature = DBUS_TYPE_UINT64_AS_STRING;
 968                 break;
 969         default:
 970                 signature = DBUS_TYPE_VARIANT_AS_STRING;
 971                 break;
 972         }
 973
 974         dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
 975                                                         signature, &value);
 976         dbus_message_iter_append_basic(&value, type, val);
 977         dbus_message_iter_close_container(&entry, &value);
 978
 979         dbus_message_iter_close_container(dict, &entry);
 980 }
 981
 982 static DBusMessage *session_get_properties(DBusConnection *connection,
 983                                 DBusMessage *message, void *user_data)
 984 {
 985         struct obc_session *session = user_data;
 986         DBusMessage *reply;
 987         DBusMessageIter iter, dict;
 988         char addr[18];
 989         char *paddr = addr;
 990
 991         reply = dbus_message_new_method_return(message);
 992         if (!reply)
 993                 return NULL;
 994
 995         dbus_message_iter_init_append(reply, &iter);
 996
 997         dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
 998                         DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
 999                         DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
1000                         DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
1001
1002         ba2str(&session->src, addr);
1003         append_entry(&dict, "Source", DBUS_TYPE_STRING, &paddr);
1004
1005         ba2str(&session->dst, addr);
1006         append_entry(&dict, "Destination", DBUS_TYPE_STRING, &paddr);
1007
1008         append_entry(&dict, "Channel", DBUS_TYPE_BYTE, &session->channel);
1009
1010         dbus_message_iter_close_container(&iter, &dict);
1011
1012         return reply;
1013 }
1014
1015 static GDBusMethodTable session_methods[] = {
1016         { "GetProperties",      "", "a{sv}",    session_get_properties  },
1017         { "AssignAgent",        "o", "",        assign_agent    },
1018         { "ReleaseAgent",       "o", "",        release_agent   },
1019         { }
1020 };
1021
1022 static void session_request_reply(DBusPendingCall *call, gpointer user_data)
1023 {
1024         struct pending_data *pending = user_data;
1025         struct obc_session *session = pending->session;
1026         DBusMessage *reply = dbus_pending_call_steal_reply(call);
1027         const char *name;
1028         DBusError derr;
1029
1030         dbus_error_init(&derr);
1031         if (dbus_set_error_from_message(&derr, reply)) {
1032                 GError *gerr = NULL;
1033
1034                 error("Replied with an error: %s, %s",
1035                                 derr.name, derr.message);
1036                 dbus_error_free(&derr);
1037                 dbus_message_unref(reply);
1038
1039                 g_set_error(&gerr, OBEX_IO_ERROR, -ECANCELED, "%s",
1040                                                                 derr.message);
1041                 session_terminate_transfer(session, pending->transfer, gerr);
1042                 g_clear_error(&gerr);
1043
1044                 return;
1045         }
1046
1047         dbus_message_get_args(reply, NULL,
1048                         DBUS_TYPE_STRING, &name,
1049                         DBUS_TYPE_INVALID);
1050
1051         DBG("Agent.Request() reply: %s", name);
1052
1053         if (strlen(name))
1054                 obc_transfer_set_name(pending->transfer, name);
1055
1056         pending->cb(session, NULL, pending->transfer);
1057         dbus_message_unref(reply);
1058
1059         return;
1060 }
1061
1062 static gboolean session_request_proceed(gpointer data)
1063 {
1064         struct pending_data *pending = data;
1065         struct obc_transfer *transfer = pending->transfer;
1066
1067         pending->cb(pending->session, NULL, transfer);
1068         g_free(pending);
1069
1070         return FALSE;
1071 }
1072
1073 static int session_request(struct obc_session *session, session_callback_t cb,
1074                                 struct obc_transfer *transfer)
1075 {
1076         struct obc_agent *agent = session->agent;
1077         struct pending_data *pending;
1078         const char *path;
1079         int err;
1080
1081         pending = g_new0(struct pending_data, 1);
1082         pending->cb = cb;
1083         pending->session = session;
1084         pending->transfer = transfer;
1085
1086         path = obc_transfer_get_path(transfer);
1087
1088         if (agent == NULL || path == NULL) {
1089                 g_idle_add(session_request_proceed, pending);
1090                 return 0;
1091         }
1092
1093         err = obc_agent_request(agent, path, session_request_reply, pending,
1094                                                                 g_free);
1095         if (err < 0) {
1096                 g_free(pending);
1097                 return err;
1098         }
1099
1100         return 0;
1101 }
1102
1103 static void session_terminate_transfer(struct obc_session *session,
1104                                         struct obc_transfer *transfer,
1105                                         GError *gerr)
1106 {
1107         struct session_callback *callback = session->callback;
1108
1109         if (callback) {
1110                 callback->func(session, gerr, callback->data);
1111                 return;
1112         }
1113
1114         obc_session_ref(session);
1115
1116         obc_transfer_unregister(transfer);
1117
1118 #ifdef TIZEN_PATCH
1119         if (session->pending) {
1120                 if (gerr)
1121                         obc_session_shutdown(session);
1122                 else
1123                         session_request(session, session_prepare_put,
1124                                         session->pending->data);
1125         }
1126 #else
1127         if (session->pending)
1128                 session_request(session, session_prepare_put,
1129                                 session->pending->data);
1130 #endif
1131
1132         obc_session_unref(session);
1133 }
1134
1135 static void session_notify_complete(struct obc_session *session,
1136                                 struct obc_transfer *transfer)
1137 {
1138         struct obc_agent *agent = session->agent;
1139         const char *path;
1140
1141         path = obc_transfer_get_path(transfer);
1142
1143         if (agent == NULL || path == NULL)
1144                 goto done;
1145
1146         obc_agent_notify_complete(agent, path);
1147
1148 done:
1149
1150         DBG("Transfer(%p) complete", transfer);
1151
1152         session_terminate_transfer(session, transfer, NULL);
1153 }
1154
1155 static void session_notify_error(struct obc_session *session,
1156                                 struct obc_transfer *transfer,
1157                                 GError *err)
1158 {
1159         struct obc_agent *agent = session->agent;
1160         const char *path;
1161
1162         path = obc_transfer_get_path(transfer);
1163         if (agent == NULL || path == NULL)
1164                 goto done;
1165
1166         obc_agent_notify_error(agent, path, err->message);
1167
1168 done:
1169         error("Transfer(%p) Error: %s", transfer, err->message);
1170
1171         session_terminate_transfer(session, transfer, err);
1172 }
1173
1174 static void session_notify_progress(struct obc_session *session,
1175                                         struct obc_transfer *transfer,
1176                                         gint64 transferred)
1177 {
1178         struct obc_agent *agent = session->agent;
1179         const char *path;
1180
1181         path = obc_transfer_get_path(transfer);
1182         if (agent == NULL || path == NULL)
1183                 goto done;
1184
1185         obc_agent_notify_progress(agent, path, transferred);
1186
1187 done:
1188         DBG("Transfer(%p) progress: %ld bytes", transfer,
1189                         (long int ) transferred);
1190
1191         if (transferred == obc_transfer_get_size(transfer))
1192                 session_notify_complete(session, transfer);
1193 }
1194
1195 static void transfer_progress(struct obc_transfer *transfer,
1196                                         gint64 transferred, GError *err,
1197                                         void *user_data)
1198 {
1199         struct obc_session *session = user_data;
1200
1201         if (err != 0)
1202                 goto fail;
1203
1204         session_notify_progress(session, transfer, transferred);
1205
1206         return;
1207
1208 fail:
1209         session_notify_error(session, transfer, err);
1210 }
1211
1212 static void session_prepare_get(struct obc_session *session,
1213                                 GError *err, void *data)
1214 {
1215         struct obc_transfer *transfer = data;
1216         int ret;
1217
1218         ret = obc_transfer_get(transfer, transfer_progress, session);
1219         if (ret < 0) {
1220                 GError *gerr = NULL;
1221
1222                 g_set_error(&gerr, OBEX_IO_ERROR, ret, "%s", strerror(-ret));
1223                 session_notify_error(session, transfer, gerr);
1224                 g_clear_error(&gerr);
1225                 return;
1226         }
1227
1228         DBG("Transfer(%p) started", transfer);
1229 }
1230
1231 int obc_session_get(struct obc_session *session, const char *type,
1232                 const char *filename, const char *targetname,
1233                 const guint8 *apparam, gint apparam_size,
1234                 session_callback_t func, void *user_data)
1235 {
1236         struct obc_transfer *transfer;
1237         struct obc_transfer_params *params = NULL;
1238         int err;
1239
1240         if (session->obex == NULL)
1241                 return -ENOTCONN;
1242
1243         if (apparam != NULL) {
1244                 params = g_new0(struct obc_transfer_params, 1);
1245                 params->data = g_new(guint8, apparam_size);
1246                 memcpy(params->data, apparam, apparam_size);
1247                 params->size = apparam_size;
1248         }
1249
1250         transfer = obc_transfer_register(session->conn, filename, targetname,
1251                                                         type, params, session);
1252         if (transfer == NULL) {
1253                 if (params != NULL) {
1254                         g_free(params->data);
1255                         g_free(params);
1256                 }
1257                 return -EIO;
1258         }
1259
1260         if (func != NULL) {
1261                 struct session_callback *callback;
1262                 callback = g_new0(struct session_callback, 1);
1263                 callback->func = func;
1264                 callback->data = user_data;
1265                 session->callback = callback;
1266         }
1267
1268         err = session_request(session, session_prepare_get, transfer);
1269         if (err < 0)
1270                 return err;
1271
1272         return 0;
1273 }
1274
1275 int obc_session_send(struct obc_session *session, const char *filename,
1276                                 const char *targetname)
1277 {
1278         struct obc_transfer *transfer;
1279         int err;
1280
1281         if (session->obex == NULL)
1282                 return -ENOTCONN;
1283
1284         transfer = obc_transfer_register(session->conn, filename, targetname,
1285                                                         NULL, NULL, session);
1286         if (transfer == NULL)
1287                 return -EINVAL;
1288
1289         err = obc_transfer_set_file(transfer);
1290         if (err < 0)
1291                 goto fail;
1292
1293         /* Transfer should start if it is the first in the pending list */
1294         if (transfer != session->pending->data)
1295                 return 0;
1296
1297         err = session_request(session, session_prepare_put, transfer);
1298         if (err < 0)
1299                 goto fail;
1300
1301         return 0;
1302
1303 fail:
1304         obc_transfer_unregister(transfer);
1305
1306         return err;
1307 }
1308
1309 int obc_session_pull(struct obc_session *session,
1310                                 const char *type, const char *filename,
1311                                 session_callback_t function, void *user_data)
1312 {
1313         struct obc_transfer *transfer;
1314         int err;
1315
1316         if (session->obex == NULL)
1317                 return -ENOTCONN;
1318
1319         transfer = obc_transfer_register(session->conn, NULL, filename, type,
1320                                                                 NULL, session);
1321         if (transfer == NULL) {
1322                 return -EIO;
1323         }
1324
1325         if (function != NULL) {
1326                 struct session_callback *callback;
1327                 callback = g_new0(struct session_callback, 1);
1328                 callback->func = function;
1329                 callback->data = user_data;
1330                 session->callback = callback;
1331         }
1332
1333         err = session_request(session, session_prepare_get, transfer);
1334         if (err == 0)
1335                 return 0;
1336
1337         obc_transfer_unregister(transfer);
1338         return err;
1339 }
1340
1341 const char *obc_session_register(struct obc_session *session,
1342                                                 GDBusDestroyFunction destroy)
1343 {
1344         if (session->path)
1345                 return session->path;
1346
1347         session->path = g_strdup_printf("%s/session%ju",
1348                                                 SESSION_BASEPATH, counter++);
1349
1350         if (g_dbus_register_interface(session->conn, session->path,
1351                                         SESSION_INTERFACE, session_methods,
1352                                         NULL, NULL, session, destroy) == FALSE)
1353                 goto fail;
1354
1355         if (session->driver->probe && session->driver->probe(session) < 0) {
1356                 g_dbus_unregister_interface(session->conn, session->path,
1357                                                         SESSION_INTERFACE);
1358                 goto fail;
1359         }
1360
1361         DBG("Session(%p) registered %s", session, session->path);
1362
1363         return session->path;
1364
1365 fail:
1366         g_free(session->path);
1367         session->path = NULL;
1368         return NULL;
1369 }
1370
1371 static void session_prepare_put(struct obc_session *session,
1372                                 GError *err, void *data)
1373 {
1374         struct obc_transfer *transfer = data;
1375         int ret;
1376
1377         ret = obc_transfer_put(transfer, transfer_progress, session);
1378         if (ret < 0) {
1379                 GError *gerr = NULL;
1380
1381                 g_set_error(&gerr, OBEX_IO_ERROR, ret, "%s (%d)",
1382                                                         strerror(-ret), -ret);
1383                 session_notify_error(session, transfer, gerr);
1384                 g_clear_error(&gerr);
1385                 return;
1386         }
1387
1388         DBG("Transfer(%p) started", transfer);
1389 }
1390
1391 int obc_session_put(struct obc_session *session, char *buf, const char *targetname)
1392 {
1393         struct obc_transfer *transfer;
1394         int err;
1395
1396         if (session->obex == NULL)
1397                 return -ENOTCONN;
1398
1399         if (session->pending != NULL)
1400                 return -EISCONN;
1401
1402         transfer = obc_transfer_register(session->conn, NULL, targetname, NULL,
1403                                                                 NULL, session);
1404         if (transfer == NULL)
1405                 return -EIO;
1406
1407         obc_transfer_set_buffer(transfer, buf);
1408
1409         err = session_request(session, session_prepare_put, transfer);
1410         if (err < 0)
1411                 return err;
1412
1413         return 0;
1414 }
1415
1416 static void agent_destroy(gpointer data, gpointer user_data)
1417 {
1418         struct obc_session *session = user_data;
1419
1420         session->agent = NULL;
1421 }
1422
1423 #ifdef TIZEN_PATCH
1424 GSList *opc_get_sessions(void)
1425 {
1426         return sessions;
1427 }
1428
1429 GSList *opc_get_session_pending(struct obc_session *session)
1430 {
1431         return session ? session->pending : NULL;
1432 }
1433 #endif
1434
1435 int obc_session_set_agent(struct obc_session *session, const char *name,
1436                                                         const char *path)
1437 {
1438         struct obc_agent *agent;
1439
1440         if (session == NULL)
1441                 return -EINVAL;
1442
1443         if (session->agent)
1444                 return -EALREADY;
1445
1446         agent = obc_agent_create(session->conn, name, path, agent_destroy,
1447                                                                 session);
1448
1449         if (session->watch == 0)
1450                 obc_session_set_owner(session, name, owner_disconnected);
1451
1452         session->agent = agent;
1453
1454         return 0;
1455 }
1456
1457 const char *obc_session_get_agent(struct obc_session *session)
1458 {
1459         struct obc_agent *agent;
1460
1461         if (session == NULL)
1462                 return NULL;
1463
1464         agent = session->agent;
1465         if (agent == NULL)
1466                 return NULL;
1467
1468         return obc_agent_get_name(session->agent);
1469 }
1470
1471 const char *obc_session_get_owner(struct obc_session *session)
1472 {
1473         if (session == NULL)
1474                 return NULL;
1475
1476         return session->owner;
1477 }
1478
1479 const char *obc_session_get_path(struct obc_session *session)
1480 {
1481         return session->path;
1482 }
1483
1484 const char *obc_session_get_target(struct obc_session *session)
1485 {
1486         return session->driver->target;
1487 }
1488
1489 GObex *obc_session_get_obex(struct obc_session *session)
1490 {
1491         return session->obex;
1492 }
1493
1494 struct obc_transfer *obc_session_get_transfer(struct obc_session *session)
1495 {
1496         return session->pending ? session->pending->data : NULL;
1497 }
1498
1499 void obc_session_add_transfer(struct obc_session *session,
1500                                         struct obc_transfer *transfer)
1501 {
1502         session->pending = g_slist_append(session->pending, transfer);
1503 }
1504
1505 void obc_session_remove_transfer(struct obc_session *session,
1506                                         struct obc_transfer *transfer)
1507 {
1508         session->pending = g_slist_remove(session->pending, transfer);
1509 }