bt-api/bt-rfcomm-client.c

   1 /*
   2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *              http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 #include <string.h>
  19 #ifdef TIZEN_FEATURE_BT_RFCOMM_DIRECT
  20 #include <errno.h>
  21 #include <gio/gunixfdlist.h>
  22 #endif
  23
  24 #include "bluetooth-api.h"
  25 #include "bt-internal-types.h"
  26
  27 #include "bt-common.h"
  28 #include "bt-request-sender.h"
  29 #include "bt-event-handler.h"
  30
  31 #ifdef TIZEN_FEATURE_BT_DPM
  32 #include "bt-dpm.h"
  33 #endif
  34
  35 #ifdef TIZEN_FEATURE_BT_RFCOMM_DIRECT
  36
  37 #define BT_TIMEOUT_MESSAGE "Did not receive a reply. Possible causes include: " \
  38                         "the remote application did not send a reply, " \
  39                         "the message bus security policy blocked the reply, " \
  40                         "the reply timeout expired, or the network connection " \
  41                         "was broken."
  42
  43 static GSList *rfcomm_clients;
  44
  45 /* Variable for privilege, only for write API,
  46   before we should reduce time to bt-service dbus calling
  47   -1 : Don't have a permission to access API
  48   0 : Initial value, not yet check
  49   1 : Have a permission to access API
  50 */
  51 static int privilege_token;
  52
  53 typedef struct {
  54         char bt_addr[BT_ADDRESS_STRING_SIZE];
  55         int fd;
  56         guint watch_id;
  57         gboolean disconnected;
  58 } rfcomm_conn_info_t;
  59
  60 typedef struct {
  61         char uuid[BLUETOOTH_UUID_STRING_MAX];
  62         char *device_path;
  63         char *obj_path;
  64         int object_id;
  65         int id;
  66         GSList *rfcomm_conns;
  67         unsigned int idle_id;
  68 } rfcomm_cb_data_t;
  69
  70 static void __client_connected_cb(rfcomm_cb_data_t *cb_data,
  71         char *dev_address, int result);
  72
  73 static void __bt_free_cb_data(rfcomm_cb_data_t *cb_data)
  74 {
  75         BT_DBG("+");
  76
  77         if (cb_data->id >= 0)
  78                 __rfcomm_delete_id(cb_data->id);
  79
  80         if (cb_data->object_id > 0)
  81                 _bt_unregister_gdbus(cb_data->object_id);
  82
  83         if (cb_data->obj_path) {
  84                 BT_INFO("Unregister profile");
  85                 _bt_unregister_profile(cb_data->obj_path);
  86         }
  87
  88         if (cb_data->idle_id != 0) {
  89                 BT_INFO("Removing idle source");
  90                 g_source_remove(cb_data->idle_id);
  91         }
  92
  93         g_free(cb_data->obj_path);
  94
  95         g_free(cb_data->device_path);
  96         g_free(cb_data);
  97         BT_DBG("-");
  98 }
  99
 100 static void rfcomm_cb_data_remove(rfcomm_cb_data_t *info)
 101 {
 102         if (info) {
 103                 BT_INFO("No more device connected remove info");
 104                 rfcomm_clients = g_slist_remove(rfcomm_clients, info);
 105                 __bt_free_cb_data(info);
 106         }
 107 }
 108
 109 gint compare(gpointer *a, gpointer *b)
 110 {
 111         rfcomm_conn_info_t *node = (rfcomm_conn_info_t *)a;
 112         char *address = (char *)b;
 113         return g_strcmp0(node->bt_addr, address);
 114 }
 115
 116 gint compare_fd(gpointer *a, gpointer *b)
 117 {
 118         rfcomm_conn_info_t *node = (rfcomm_conn_info_t *)a;
 119         int *fd = (int *)b;
 120         if (node->fd == *fd)
 121                 return 0;
 122
 123         return 1;
 124 }
 125 static void __bt_free_conn(rfcomm_conn_info_t *conn)
 126 {
 127         BT_DBG("+");
 128
 129         if (conn == NULL)
 130                 return;
 131
 132         if (conn->watch_id > 0) {
 133                 g_source_remove(conn->watch_id);
 134                 conn->watch_id = 0;
 135         }
 136
 137         g_free(conn);
 138
 139         BT_DBG("-");
 140 }
 141
 142 static void __rfcomm_remove_conn_info_t(rfcomm_cb_data_t *info, char *address)
 143 {
 144         GSList *l = NULL;
 145         rfcomm_conn_info_t *conn_info = NULL;
 146         l = g_slist_find_custom(info->rfcomm_conns, address, (GCompareFunc)compare);
 147         if (l)
 148                 conn_info = l->data;
 149         if (conn_info) {
 150                 info->rfcomm_conns = g_slist_remove(info->rfcomm_conns, conn_info);
 151                 __bt_free_conn(conn_info);
 152         }
 153 }
 154
 155 static rfcomm_conn_info_t *__get_conn_info_from_fd(rfcomm_cb_data_t *info,
 156         int fd)
 157 {
 158         GSList *l;
 159         rfcomm_conn_info_t *device_node = NULL;
 160         for (l = info->rfcomm_conns; l != NULL; l = l->next) {
 161                 device_node = l->data;
 162                 if (device_node && device_node->fd == fd)
 163                         return device_node;
 164         }
 165         return NULL;
 166 }
 167
 168 static rfcomm_conn_info_t *__get_conn_info_from_address(rfcomm_cb_data_t *info,
 169                 char *dev_address)
 170 {
 171         GSList *l = NULL;
 172         rfcomm_conn_info_t *conn_info = NULL;
 173         l = g_slist_find_custom(info->rfcomm_conns, dev_address,
 174                 (GCompareFunc)compare);
 175         if (l)
 176                 conn_info = l->data;
 177         return conn_info;
 178 }
 179
 180 static void __rfcomm_client_connected_cb(rfcomm_cb_data_t *info,
 181         char *dev_address, int result)
 182 {
 183         if (g_slist_find(rfcomm_clients, info) == NULL) {
 184                 BT_INFO("rfcomm resource is already freed");
 185                 return;
 186         }
 187
 188         __client_connected_cb(info, dev_address, result);
 189         __rfcomm_remove_conn_info_t(info, dev_address);
 190
 191         if (info->rfcomm_conns == NULL)
 192                 rfcomm_cb_data_remove(info);
 193 }
 194
 195 static rfcomm_cb_data_t *__find_rfcomm_info_with_fd(int fd)
 196 {
 197         GSList *l;
 198         GSList *device_fd;
 199         for (l = rfcomm_clients; l != NULL; l = l->next) {
 200                 rfcomm_cb_data_t *info = l->data;
 201                 device_fd = g_slist_find_custom(info->rfcomm_conns, &fd,
 202                         (GCompareFunc)compare_fd);
 203                 if (device_fd)
 204                         return info;
 205         }
 206
 207         return NULL;
 208 }
 209
 210 static rfcomm_cb_data_t *__find_rfcomm_info_from_path(const char *path)
 211 {
 212         GSList *l;
 213
 214         for (l = rfcomm_clients; l != NULL; l = l->next) {
 215                 rfcomm_cb_data_t *info = l->data;
 216
 217                 if (info != NULL)
 218                         if (g_strcmp0(info->obj_path, path) == 0)
 219                                 return info;
 220         }
 221
 222         return NULL;
 223 }
 224
 225 static rfcomm_cb_data_t *__find_rfcomm_info_from_uuid(const char *uuid)
 226 {
 227         GSList *l;
 228
 229         for (l = rfcomm_clients; l != NULL; l = l->next) {
 230                 rfcomm_cb_data_t *info = l->data;
 231
 232                 if (g_strcmp0(info->uuid, uuid) == 0)
 233                         return info;
 234         }
 235
 236         return NULL;
 237 }
 238
 239 static void _bt_rfcomm_disconnect_conn_info(rfcomm_conn_info_t *conn_info,
 240         rfcomm_cb_data_t *info)
 241 {
 242         if (conn_info == NULL)
 243                 return;
 244
 245         bluetooth_rfcomm_disconnection_t disconn_info;
 246         bt_event_info_t *event_info = NULL;
 247
 248         if (conn_info->disconnected == FALSE)
 249                 return;
 250
 251         event_info = _bt_event_get_cb_data(BT_RFCOMM_CLIENT_EVENT);
 252         if (event_info == NULL) {
 253                 __rfcomm_remove_conn_info_t(info, conn_info->bt_addr);
 254
 255                 if (info->rfcomm_conns == NULL)
 256                         rfcomm_cb_data_remove(info);
 257                 return;
 258         }
 259
 260         memset(&disconn_info, 0x00, sizeof(bluetooth_rfcomm_disconnection_t));
 261         disconn_info.device_role = RFCOMM_ROLE_CLIENT;
 262         g_strlcpy(disconn_info.uuid, info->uuid, BLUETOOTH_UUID_STRING_MAX);
 263         _bt_convert_addr_string_to_type(disconn_info.device_addr.addr,
 264                                         conn_info->bt_addr);
 265
 266         BT_DBG("Disconnected FD [%d]", conn_info->fd);
 267         disconn_info.socket_fd = conn_info->fd;
 268
 269         BT_DBG("Disconnection Result[%d] BT_ADDRESS[%s] UUID[%s] FD[%d]",
 270                         BLUETOOTH_ERROR_NONE, conn_info->bt_addr,
 271                         info->uuid, conn_info->fd);
 272         _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_DISCONNECTED,
 273                         BLUETOOTH_ERROR_NONE, &disconn_info,
 274                         event_info->cb, event_info->user_data);
 275
 276         __rfcomm_remove_conn_info_t(info, conn_info->bt_addr);
 277
 278         if (info->rfcomm_conns == NULL)
 279                 rfcomm_cb_data_remove(info);
 280
 281         BT_DBG("-");
 282 }
 283
 284 static gboolean __rfcomm_client_disconnect(gpointer user_data)
 285 {
 286         rfcomm_cb_data_t *info = (rfcomm_cb_data_t *)user_data;
 287
 288         BT_INFO_C("### Disconnected [RFCOMM Client]");
 289
 290         retv_if(info == NULL, FALSE);
 291
 292         if (g_slist_find(rfcomm_clients, info) == NULL) {
 293                 BT_INFO("rfcomm resource is already freed");
 294                 return FALSE;
 295         }
 296         info->idle_id = 0;
 297
 298         g_slist_foreach(info->rfcomm_conns,
 299                 (GFunc)_bt_rfcomm_disconnect_conn_info, info);
 300
 301         BT_DBG("-");
 302         return FALSE;
 303 }
 304
 305 static gboolean __is_error_by_disconnect(GError *err)
 306 {
 307         return !g_strcmp0(err->message, "Connection reset by peer") ||
 308                         !g_strcmp0(err->message, "Connection timed out") ||
 309                         !g_strcmp0(err->message, "Software caused connection abort");
 310 }
 311
 312 static gboolean __client_data_received_cb(GIOChannel *chan, GIOCondition cond,
 313                                                                 gpointer data)
 314 {
 315         char *buffer = NULL;
 316         gsize len = 0;
 317         int result = BLUETOOTH_ERROR_NONE;
 318         rfcomm_cb_data_t *info = data;
 319         rfcomm_conn_info_t *conn_info = NULL;
 320         bt_event_info_t *event_info;
 321         bluetooth_rfcomm_received_data_t data_r;
 322         GIOStatus status = G_IO_STATUS_NORMAL;
 323         GError *err = NULL;
 324         int fd;
 325         BT_DBG("");
 326
 327         retv_if(info == NULL, FALSE);
 328         fd = g_io_channel_unix_get_fd(chan);
 329         if (cond & (G_IO_NVAL | G_IO_HUP | G_IO_ERR)) {
 330                 BT_ERR_C("RFComm Client  disconnected: %d", fd);
 331
 332                 conn_info = __get_conn_info_from_fd(info, fd);
 333                 if (conn_info == NULL) {
 334                         BT_ERR("No Connection info found with FD [%d]", fd);
 335                         return FALSE;
 336                 }
 337
 338                 if (conn_info->disconnected == FALSE) {
 339                         close(conn_info->fd);
 340                         conn_info->disconnected = TRUE;
 341                 }
 342                 __rfcomm_client_disconnect(info);
 343                 return FALSE;
 344         }
 345
 346         buffer = g_malloc0(BT_RFCOMM_BUFFER_LEN + 1);
 347
 348         status = g_io_channel_read_chars(chan, buffer, BT_RFCOMM_BUFFER_LEN,
 349                         &len, &err);
 350         if (status != G_IO_STATUS_NORMAL) {
 351                 BT_ERR("IO Channel read is failed with %d", status);
 352
 353                 g_free(buffer);
 354                 if (err) {
 355                         BT_ERR("IO Channel read error [%s]", err->message);
 356                         if (status == G_IO_STATUS_ERROR &&
 357                                         __is_error_by_disconnect(err)) {
 358                                 BT_ERR("cond : %d", cond);
 359                                 g_error_free(err);
 360
 361                                 conn_info = __get_conn_info_from_fd(info, fd);
 362                                 if (conn_info == NULL) {
 363                                         BT_ERR("No Connection info found with FD [%d]", fd);
 364                                         return FALSE;
 365                                 }
 366
 367                                 if (conn_info->disconnected == FALSE) {
 368                                         close(conn_info->fd);
 369                                         conn_info->disconnected = TRUE;
 370                                 }
 371                                 __rfcomm_client_disconnect(info);
 372                                 return FALSE;
 373                         }
 374                         g_error_free(err);
 375                 }
 376                 return TRUE;
 377         }
 378
 379         event_info = _bt_event_get_cb_data(BT_RFCOMM_CLIENT_EVENT);
 380         if (event_info == NULL) {
 381                 g_free(buffer);
 382                 return TRUE;
 383         }
 384
 385         data_r.socket_fd = fd;
 386         data_r.buffer_size = len;
 387         data_r.buffer = buffer;
 388
 389         _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_DATA_RECEIVED,
 390                         result, &data_r,
 391                         event_info->cb, event_info->user_data);
 392
 393         g_free(buffer);
 394         return TRUE;
 395 }
 396
 397 static void __client_connected_cb(rfcomm_cb_data_t *cb_data, char *dev_address,
 398         int result)
 399 {
 400         bluetooth_rfcomm_connection_t conn_info;
 401         bt_event_info_t *event_info;
 402         rfcomm_conn_info_t *conn_list_info = NULL;
 403
 404         if (result == BLUETOOTH_ERROR_NONE)
 405                 BT_INFO_C("### Connected [RFCOMM Client]");
 406
 407         event_info = _bt_event_get_cb_data(BT_RFCOMM_CLIENT_EVENT);
 408         if (event_info == NULL)
 409                 return;
 410
 411         memset(&conn_info, 0x00, sizeof(bluetooth_rfcomm_connection_t));
 412         conn_info.device_role = RFCOMM_ROLE_CLIENT;
 413         g_strlcpy(conn_info.uuid, cb_data->uuid, BLUETOOTH_UUID_STRING_MAX);
 414         _bt_convert_addr_string_to_type(conn_info.device_addr.addr,
 415                         dev_address);
 416         conn_list_info = __get_conn_info_from_address(cb_data, dev_address);
 417         if (conn_list_info == NULL) {
 418                 BT_ERR("Device addres %s not found in connection list", dev_address);
 419                 return;
 420         }
 421         conn_info.socket_fd = conn_list_info->fd;
 422         conn_info.server_id = -1;
 423
 424         BT_DBG("Connection Result[%d] BT_ADDRESS[%s] UUID[%s] FD[%d]",
 425                         result, conn_list_info->bt_addr, cb_data->uuid, conn_list_info->fd);
 426         _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_CONNECTED,
 427                         result, &conn_info,
 428                         event_info->cb, event_info->user_data);
 429         BT_DBG("-");
 430 }
 431
 432 void _bt_rfcomm_client_disconnect_all(void)
 433 {
 434         GSList *client;
 435         GSList *conn;
 436
 437         BT_INFO_C("### Disconnect all RFCOMM client connections");
 438
 439         for (client = rfcomm_clients; client; ) {
 440                 rfcomm_cb_data_t *info = client->data;
 441
 442                 for (conn = info->rfcomm_conns; conn; conn = conn->next) {
 443                         rfcomm_conn_info_t *conn_info = conn->data;
 444
 445                         if (conn_info == NULL)
 446                                 continue;
 447
 448                         if (conn_info->watch_id == 0 || conn_info->disconnected)
 449                                 continue;
 450
 451                         close(conn_info->fd);
 452                         conn_info->disconnected = TRUE;
 453
 454                         _bt_disconnect_ext_profile(conn_info->bt_addr,
 455                                                    info->obj_path);
 456                 }
 457
 458                 client = client->next;
 459                 __rfcomm_client_disconnect(info);
 460         }
 461
 462         return;
 463 }
 464 #endif
 465
 466 int new_connection(const char *path, int fd, bluetooth_device_address_t *addr)
 467 {
 468         rfcomm_cb_data_t *info;
 469         GIOChannel *data_io;
 470         rfcomm_conn_info_t *conn_info = NULL;
 471         char address[BT_ADDRESS_STRING_SIZE];
 472
 473         BT_INFO("%s %d", path, fd);
 474
 475         _bt_convert_addr_type_to_string(address,
 476                                 (unsigned char *)addr);
 477
 478         info = __find_rfcomm_info_from_path(path);
 479         if (info == NULL) {
 480                 BT_ERR("rfcomm info is NULL");
 481                 return -1;
 482         }
 483
 484         conn_info = __get_conn_info_from_address(info, address);
 485         if (conn_info == NULL) {
 486                 BT_ERR("connection info is NULL");
 487                 return -1;
 488         }
 489
 490         conn_info->fd = fd;
 491
 492         data_io = g_io_channel_unix_new(fd);
 493
 494         g_io_channel_set_encoding(data_io, NULL, NULL);
 495         g_io_channel_set_flags(data_io, G_IO_FLAG_NONBLOCK, NULL);
 496
 497         conn_info->watch_id = g_io_add_watch(data_io,
 498                                 G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
 499                                 __client_data_received_cb, info);
 500
 501         g_io_channel_unref(data_io);
 502
 503         __client_connected_cb(info, address, BLUETOOTH_ERROR_NONE);
 504
 505         return 0;
 506 }
 507
 508 static void __bt_connect_response_cb(GDBusProxy *proxy, GAsyncResult *res,
 509                                                         gpointer user_data)
 510
 511 {
 512         GError *error = NULL;
 513         GVariant *value;
 514         rfcomm_cb_data_t *cb_data;
 515         char dev_address[BT_ADDRESS_STRING_SIZE];
 516         const char *path;
 517         BT_DBG("+");
 518
 519         ret_if(user_data == NULL);
 520
 521         cb_data = user_data;
 522
 523         value = g_dbus_proxy_call_finish(proxy, res, &error);
 524         if (value == NULL) {
 525                 int result;
 526                 g_dbus_error_strip_remote_error(error);
 527                 BT_ERR("Error : %s \n", error->message);
 528
 529                 if (g_strcmp0(error->message, "In Progress") == 0)
 530                         result = BLUETOOTH_ERROR_DEVICE_BUSY;
 531                 else
 532                         result = BLUETOOTH_ERROR_INTERNAL;
 533                 path = g_dbus_proxy_get_object_path(proxy);
 534                 _bt_convert_device_path_to_address(path, dev_address);
 535                 __rfcomm_client_connected_cb(cb_data, dev_address, result);
 536
 537                 g_error_free(error);
 538         } else {
 539                 g_variant_unref(value);
 540         }
 541
 542         if (proxy)
 543                 g_object_unref(proxy);
 544
 545         BT_DBG("-");
 546 }
 547
 548 static void __bt_discover_service_response_cb(GDBusProxy *proxy,
 549                                 GAsyncResult *res, gpointer user_data)
 550 {
 551         rfcomm_cb_data_t *cb_data;
 552         int ret = 0;
 553         GError *err = NULL;
 554         GVariant *value;
 555         bt_register_profile_info_t info = {0};
 556         int result = BLUETOOTH_ERROR_NONE;
 557         char dev_address[BT_ADDRESS_STRING_SIZE];
 558         const char *path;
 559
 560         BT_DBG("+");
 561
 562         ret_if(user_data == NULL);
 563
 564         cb_data = user_data;
 565
 566         path = g_dbus_proxy_get_object_path(proxy);
 567
 568         _bt_convert_device_path_to_address(path, dev_address);
 569         BT_DBG("Device Adress [%s]", dev_address);
 570         value = g_dbus_proxy_call_finish(proxy, res, &err);
 571         if (proxy)
 572                 g_object_unref(proxy);
 573         if (value)
 574                 g_variant_unref(value);
 575
 576         if (err != NULL) {
 577                 g_dbus_error_strip_remote_error(err);
 578                 BT_ERR("Error occured in Proxy call [%s]\n", err->message);
 579                 if (!strcmp("Operation canceled", err->message)) {
 580                         result = BLUETOOTH_ERROR_CANCEL_BY_USER;
 581                 } else if (!strcmp("In Progress", err->message)) {
 582                         result = BLUETOOTH_ERROR_IN_PROGRESS;
 583                 } else if (!strcmp("Host is down", err->message)) {
 584                         result = BLUETOOTH_ERROR_HOST_DOWN;
 585                 } else if (!strcmp(BT_TIMEOUT_MESSAGE, err->message)) {
 586                         result = BLUETOOTH_ERROR_SERVICE_SEARCH_ERROR;
 587                         ret = _bt_cancel_discovers(dev_address);
 588                         if (ret != BLUETOOTH_ERROR_NONE)
 589                                 BT_ERR("Error: While CancelDiscovery");
 590                 } else {
 591                         result = BLUETOOTH_ERROR_CONNECTION_ERROR;
 592                 }
 593                 __rfcomm_client_connected_cb(cb_data, dev_address, result);
 594                 goto done;
 595         } else {
 596                 BT_INFO("Services are Updated checking required uuid is there");
 597                 /* Check here for uuid present */
 598                 ret = _bt_discover_service_uuids(dev_address, (char *)cb_data->uuid);
 599                 if (ret == BLUETOOTH_ERROR_NONE) {
 600                         info.uuid = (char *)cb_data->uuid;
 601                         info.obj_path = cb_data->obj_path;
 602                         info.role = "client";
 603
 604                         ret = _bt_register_profile(&info, FALSE);
 605                         if (ret < 0)
 606                                 BT_DBG("Error: register profile");
 607                         ret = _bt_connect_profile(dev_address, cb_data->uuid,
 608                                                 __bt_connect_response_cb, cb_data);
 609
 610                         if (ret != BLUETOOTH_ERROR_NONE) {
 611                                 BT_ERR("ConnectProfile failed");
 612                                 result = BLUETOOTH_ERROR_CONNECTION_ERROR;
 613                                 __rfcomm_client_connected_cb(cb_data, dev_address, result);
 614                                 goto done;
 615                         }
 616                 } else {
 617                         BT_ERR("remote uuid not found");
 618                         result = BLUETOOTH_ERROR_SERVICE_NOT_FOUND;
 619                         __rfcomm_client_connected_cb(cb_data, dev_address, result);
 620                 }
 621         }
 622 done:
 623         if (err)
 624                 g_clear_error(&err);
 625 }
 626
 627 BT_EXPORT_API int bluetooth_rfcomm_connect(
 628                 const bluetooth_device_address_t *remote_bt_address,
 629                 const char *remote_uuid)
 630 {
 631
 632 #ifdef TIZEN_FEATURE_BT_RFCOMM_DIRECT
 633         rfcomm_cb_data_t *cb_data = NULL;
 634         rfcomm_conn_info_t *conn = NULL;
 635 #else
 636         int result;
 637         int connect_type;
 638         bt_user_info_t *user_info;
 639         char uuid[BLUETOOTH_UUID_STRING_MAX];
 640 #endif
 641         BT_CHECK_PARAMETER(remote_bt_address, return);
 642         BT_CHECK_PARAMETER(remote_uuid, return);
 643         BT_CHECK_ENABLED(return);
 644
 645 #ifdef TIZEN_FEATURE_BT_DPM
 646         if (_bt_check_dpm(BT_DPM_ADDRESS, (void *)remote_bt_address) == BT_DPM_RESTRICTED) {
 647                 BT_ERR("Blacklist device");
 648                 return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
 649         }
 650
 651         if (_bt_check_dpm(BT_DPM_SPP, NULL) == BT_DPM_RESTRICTED ||
 652                 _bt_check_dpm(BT_DPM_HF_ONLY, NULL) == BT_DPM_RESTRICTED) {
 653                 BT_ERR("Not allow to connect the RFCOMM service");
 654                 return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
 655         }
 656
 657         if (_bt_check_dpm(BT_DPM_DESKTOP, NULL) == BT_DPM_RESTRICTED) {
 658                 char address[BT_ADDRESS_STRING_SIZE] = { 0 };
 659                 bluetooth_device_class_t dev_class;
 660
 661                 _bt_convert_addr_type_to_string(address, (unsigned char *)remote_bt_address->addr);
 662                 _bt_get_cod_by_address(address, &dev_class);
 663
 664                 if (dev_class.major_class == BLUETOOTH_DEVICE_MAJOR_CLASS_COMPUTER) {
 665                         BT_ERR("Reject a authorization due to MDM Policy");
 666                         return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
 667                 }
 668         }
 669 #endif
 670
 671 #ifdef TIZEN_FEATURE_BT_RFCOMM_DIRECT
 672         BT_INFO_C("### Connect RFCOMM");
 673         int ret;
 674         int id, object_id;
 675         char *path;
 676
 677         if (_bt_check_privilege(BT_BLUEZ_SERVICE, BT_RFCOMM_CLIENT_CONNECT)
 678              == BLUETOOTH_ERROR_PERMISSION_DEINED) {
 679                 BT_ERR("Don't have a privilege to use this API");
 680                 return BLUETOOTH_ERROR_PERMISSION_DEINED;
 681         }
 682
 683         id = __rfcomm_assign_id();
 684         if (id < 0)
 685                 return BLUETOOTH_ERROR_INTERNAL;
 686
 687         cb_data = __find_rfcomm_info_from_uuid(remote_uuid);
 688         if (!cb_data) {
 689                 path = g_strdup_printf("/org/socket/client/%d/%d", getpid(), id);
 690
 691                 object_id = _bt_register_new_conn(path, new_connection);
 692                 if (object_id < 0) {
 693                         __rfcomm_delete_id(id);
 694                         g_free(path);
 695                         return BLUETOOTH_ERROR_INTERNAL;
 696                 }
 697
 698                 cb_data = g_new0(rfcomm_cb_data_t, 1);
 699                 g_strlcpy(cb_data->uuid, remote_uuid, BLUETOOTH_UUID_STRING_MAX);
 700                 cb_data->obj_path = path;
 701                 cb_data->object_id = object_id;
 702                 cb_data->id = id;
 703         }
 704
 705         conn = g_new0(rfcomm_conn_info_t, 1);
 706         conn->fd = -1;
 707         _bt_convert_addr_type_to_string(conn->bt_addr,
 708                                 (unsigned char *)remote_bt_address->addr);
 709
 710         BT_DBG("Connecting to %s uuid %s", conn->bt_addr, remote_uuid);
 711         cb_data->rfcomm_conns = g_slist_append(cb_data->rfcomm_conns, conn);
 712
 713         ret = _bt_discover_services(conn->bt_addr, (char *)remote_uuid,
 714                                 __bt_discover_service_response_cb, cb_data);
 715         if (ret != BLUETOOTH_ERROR_NONE) {
 716                 BT_ERR("Error returned while service discovery");
 717                 __rfcomm_remove_conn_info_t(cb_data, conn->bt_addr);
 718                 if (cb_data->rfcomm_conns == NULL)
 719                         rfcomm_cb_data_remove(cb_data);
 720                 return BLUETOOTH_ERROR_INTERNAL;
 721         }
 722
 723         if (g_slist_find(rfcomm_clients, cb_data) == NULL) {
 724                 BT_INFO("Adding callback information to rfcomm_clients");
 725                 rfcomm_clients = g_slist_append(rfcomm_clients, cb_data);
 726         } else
 727                 BT_INFO("Callback information is already added");
 728
 729         return BLUETOOTH_ERROR_NONE;
 730 #else
 731         user_info = _bt_get_user_data(BT_COMMON);
 732         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
 733
 734         /* connect_type:  BT_RFCOMM_UUID / BT_RFCOMM_CHANNEL*/
 735         /* In now, we only support to connecty using UUID */
 736         connect_type = BT_RFCOMM_UUID;
 737
 738         if (_bt_check_privilege(BT_BLUEZ_SERVICE, BT_RFCOMM_CLIENT_CONNECT)
 739              == BLUETOOTH_ERROR_PERMISSION_DEINED) {
 740                 BT_ERR("Don't have a privilege to use this API");
 741                 return BLUETOOTH_ERROR_PERMISSION_DEINED;
 742         }
 743
 744         BT_INIT_PARAMS();
 745         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 746
 747         g_array_append_vals(in_param1, remote_bt_address,
 748                                 sizeof(bluetooth_device_address_t));
 749
 750         g_strlcpy(uuid, remote_uuid, sizeof(uuid));
 751         g_array_append_vals(in_param2, uuid, BLUETOOTH_UUID_STRING_MAX);
 752
 753         g_array_append_vals(in_param3, &connect_type, sizeof(int));
 754
 755         result = _bt_send_request_async(BT_BLUEZ_SERVICE,
 756                                 BT_RFCOMM_CLIENT_CONNECT,
 757                                 in_param1, in_param2,
 758                                 in_param3, in_param4,
 759                                 user_info->cb, user_info->user_data);
 760
 761         BT_DBG("result: %x", result);
 762
 763         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 764
 765         return result;
 766 #endif
 767 }
 768
 769 BT_EXPORT_API int bluetooth_rfcomm_client_is_connected(const bluetooth_device_address_t *device_address, gboolean *connected)
 770 {
 771         GSList *l;
 772         GSList *conn_list = NULL;
 773         rfcomm_cb_data_t *client_info;
 774         rfcomm_conn_info_t *conn_info;
 775         char address[BT_ADDRESS_STRING_SIZE] = { 0 };
 776
 777         BT_CHECK_PARAMETER(device_address, return);
 778         BT_CHECK_PARAMETER(connected, return);
 779
 780         _bt_convert_addr_type_to_string(address, (unsigned char *)device_address->addr);
 781         *connected = FALSE;
 782
 783         for (l = rfcomm_clients; l != NULL; l = l->next) {
 784                 client_info = l->data;
 785                 if (client_info == NULL)
 786                         continue;
 787                 for (conn_list = client_info->rfcomm_conns;
 788                         conn_list != NULL; conn_list = conn_list->next) {
 789                         conn_info = conn_list->data;
 790                         if (conn_info == NULL)
 791                                 continue;
 792
 793                         if (g_strcmp0(address, conn_info->bt_addr) == 0) {
 794                                 *connected = TRUE;
 795                                 return BLUETOOTH_ERROR_NONE;
 796                         }
 797                 }
 798         }
 799
 800         return BLUETOOTH_ERROR_NONE;
 801 }
 802
 803 BT_EXPORT_API gboolean bluetooth_rfcomm_is_client_connected(void)
 804 {
 805         int result;
 806         int connected = FALSE;
 807
 808         BT_CHECK_ENABLED(return);
 809
 810         BT_INIT_PARAMS();
 811         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 812
 813         result = _bt_send_request(BT_BLUEZ_SERVICE,
 814                         BT_RFCOMM_CLIENT_IS_CONNECTED,
 815                         in_param1, in_param2, in_param3,
 816                         in_param4, &out_param);
 817
 818         BT_DBG("result: %x", result);
 819
 820         if (result == BLUETOOTH_ERROR_NONE) {
 821                 connected = g_array_index(out_param,
 822                                 int, 0);
 823         } else {
 824                 BT_ERR("Fail to send request");
 825         }
 826
 827         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 828
 829         return connected;
 830 }
 831
 832 BT_EXPORT_API int bluetooth_rfcomm_disconnect(int socket_fd)
 833 {
 834 #ifdef TIZEN_FEATURE_BT_RFCOMM_DIRECT
 835         rfcomm_cb_data_t *info;
 836         rfcomm_conn_info_t *conn_info;
 837
 838         BT_INFO_C("### Disconnect RFCOMM");
 839
 840         BT_CHECK_ENABLED(return);
 841
 842         if (_bt_check_privilege(BT_BLUEZ_SERVICE, BT_RFCOMM_SOCKET_DISCONNECT)
 843              == BLUETOOTH_ERROR_PERMISSION_DEINED) {
 844                 BT_ERR("Don't have a privilege to use this API");
 845                 return BLUETOOTH_ERROR_PERMISSION_DEINED;
 846         }
 847
 848         BT_DBG("Requested FD %d", socket_fd);
 849         if (socket_fd < 0) {
 850                 BT_ERR("Invalid FD");
 851                 return BLUETOOTH_ERROR_INVALID_PARAM;
 852         }
 853         BT_DBG("FDD %d", socket_fd);
 854
 855         info = __find_rfcomm_info_with_fd(socket_fd);
 856         if (info == NULL) {
 857                 BT_DBG("Could not find in client, so check in server");
 858                 return bluetooth_rfcomm_server_disconnect(socket_fd);
 859         }
 860
 861         conn_info = __get_conn_info_from_fd(info, socket_fd);
 862         if (conn_info == NULL) {
 863                 BT_ERR("Could not find connection info");
 864                 return BLUETOOTH_ERROR_INTERNAL;
 865         }
 866
 867         if (conn_info->watch_id == 0 || conn_info->disconnected) {
 868                 BT_ERR("Invalid state");
 869                 return BLUETOOTH_ERROR_NOT_CONNECTED;
 870         }
 871
 872         close(conn_info->fd);
 873         conn_info->disconnected = TRUE;
 874
 875         BT_INFO("conn_info %s", conn_info->bt_addr);
 876         _bt_disconnect_ext_profile(conn_info->bt_addr, info->obj_path);
 877
 878         if (info->idle_id == 0)
 879                 info->idle_id = g_idle_add(__rfcomm_client_disconnect, info);
 880
 881         return BLUETOOTH_ERROR_NONE;
 882 #else
 883         int result;
 884
 885         BT_CHECK_ENABLED(return);
 886
 887         BT_INIT_PARAMS();
 888         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 889
 890         /* Support the OSP */
 891         if (socket_fd == -1) {
 892                 /* Cancel connect */
 893                 result = _bt_send_request(BT_BLUEZ_SERVICE, BT_RFCOMM_CLIENT_CANCEL_CONNECT,
 894                         in_param1, in_param2, in_param3, in_param4, &out_param);
 895         } else {
 896                 g_array_append_vals(in_param1, &socket_fd, sizeof(int));
 897                 result = _bt_send_request(BT_BLUEZ_SERVICE, BT_RFCOMM_SOCKET_DISCONNECT,
 898                         in_param1, in_param2, in_param3, in_param4, &out_param);
 899         }
 900
 901         BT_DBG("result: %x", result);
 902
 903         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 904
 905         return result;
 906 #endif
 907 }
 908
 909 BT_EXPORT_API int bluetooth_rfcomm_write(int fd, const char *buf, int length)
 910 {
 911 #ifdef TIZEN_FEATURE_BT_RFCOMM_DIRECT
 912         int written;
 913 #else
 914         char *buffer;
 915 #endif
 916         int result;
 917
 918         BT_CHECK_PARAMETER(buf, return);
 919         if (fd < 0) {
 920                 BT_ERR("Invalid FD");
 921                 return BLUETOOTH_ERROR_INVALID_PARAM;
 922         }
 923
 924 #ifndef TIZEN_FEATURE_BT_RFCOMM_DIRECT
 925         BT_CHECK_ENABLED(return);
 926 #endif
 927         retv_if(length <= 0, BLUETOOTH_ERROR_INVALID_PARAM);
 928
 929 #ifdef TIZEN_FEATURE_BT_DPM
 930         if (_bt_check_dpm(BT_DPM_SPP, NULL) == BT_DPM_RESTRICTED ||
 931                 _bt_check_dpm(BT_DPM_HF_ONLY, NULL) == BT_DPM_RESTRICTED) {
 932                 BT_ERR("Not allow to write RFCOMM data");
 933                 return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
 934         }
 935 #endif
 936
 937 #ifdef TIZEN_FEATURE_BT_RFCOMM_DIRECT
 938         switch (privilege_token) {
 939         case 0:
 940                 result = _bt_check_privilege(BT_BLUEZ_SERVICE, BT_RFCOMM_SOCKET_WRITE);
 941
 942                 if (result == BLUETOOTH_ERROR_NONE) {
 943                         privilege_token = 1; /* Have a permission */
 944                 } else if (result == BLUETOOTH_ERROR_PERMISSION_DEINED) {
 945                         BT_ERR("Don't have a privilege to use this API");
 946                         privilege_token = -1; /* Don't have a permission */
 947                         return BLUETOOTH_ERROR_PERMISSION_DEINED;
 948                 } else {
 949                         /* Just break - It is not related with permission error */
 950                 }
 951                 break;
 952         case 1:
 953                 /* Already have a privilege */
 954                 break;
 955         case -1:
 956                 return BLUETOOTH_ERROR_PERMISSION_DEINED;
 957         default:
 958                 /* Invalid privilge token value */
 959                 return BLUETOOTH_ERROR_INTERNAL;
 960         }
 961
 962         written = write(fd, buf, length);
 963         /*BT_DBG("Length %d, written = %d, balance(%d)",
 964                          length, written, length - written); */
 965         return written;
 966 #else
 967         BT_INIT_PARAMS();
 968         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 969
 970         buffer = g_malloc0(length + 1);
 971
 972         memcpy(buffer, buf, length);
 973
 974         g_array_append_vals(in_param1, &fd, sizeof(int));
 975         g_array_append_vals(in_param2, &length, sizeof(int));
 976         g_array_append_vals(in_param3, buffer, length);
 977
 978         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_RFCOMM_SOCKET_WRITE,
 979                 in_param1, in_param2, in_param3, in_param4, &out_param);
 980
 981         BT_DBG("result: %x", result);
 982
 983         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 984
 985         g_free(buffer);
 986
 987         return result;
 988 #endif
 989 }
 990