2 * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
19 #include <gio/gunixfdlist.h>
21 #ifdef TIZEN_FEATURE_BT_RFCOMM_DIRECT
25 #include "bluetooth-api.h"
26 #include "bt-internal-types.h"
28 #include "bt-common.h"
29 #include "bt-request-sender.h"
30 #include "bt-event-handler.h"
32 #ifdef TIZEN_FEATURE_BT_DPM
36 /* Variable for privilege, only for write API,
37 before we should reduce time to bt-service dbus calling
38 -1 : Don't have a permission to access API
39 0 : Initial value, not yet check
40 1 : Have a permission to access API
42 static int privilege_token;
45 #ifdef TIZEN_FEATURE_BT_RFCOMM_DIRECT
46 #define BT_TIMEOUT_MESSAGE "Did not receive a reply. Possible causes include: " \
47 "the remote application did not send a reply, " \
48 "the message bus security policy blocked the reply, " \
49 "the reply timeout expired, or the network connection " \
52 #define BATTERY_MONITOR_RFCOMM_INTERVAL 5
54 static GSList *rfcomm_clients;
57 char bt_addr[BT_ADDRESS_STRING_SIZE];
60 gboolean disconnected;
64 char uuid[BLUETOOTH_UUID_STRING_MAX];
73 static unsigned int rx_data = 0, tx_data = 0;
74 static guint tx_tag = 0, rx_tag = 0;
76 static void __client_connected_cb(rfcomm_cb_data_t *cb_data,
77 char *dev_address, int result);
79 static bool __rfcomm_record_tx_data(void)
82 int ret = _bt_common_send_rfcomm_tx_details(tx_data);
83 if (ret == BLUETOOTH_ERROR_NONE) {
87 BT_ERR("RFCOMM tx data could not be registered");
97 static bool __rfcomm_record_rx_data(void)
100 int ret = _bt_common_send_rfcomm_rx_details(rx_data);
101 if (ret == BLUETOOTH_ERROR_NONE) {
105 BT_ERR("RFCOMM rx data could not be registered");
115 static void __bt_free_cb_data(rfcomm_cb_data_t *cb_data)
119 if (cb_data->id >= 0)
120 __rfcomm_delete_id(cb_data->id);
122 if (cb_data->object_id > 0)
123 _bt_unregister_gdbus(cb_data->object_id);
125 if (cb_data->obj_path) {
126 BT_INFO("Unregister profile");
127 _bt_unregister_profile(cb_data->obj_path);
130 if (cb_data->idle_id != 0) {
131 BT_INFO("Removing idle source");
132 g_source_remove(cb_data->idle_id);
135 g_free(cb_data->obj_path);
137 g_free(cb_data->device_path);
142 static void rfcomm_cb_data_remove(rfcomm_cb_data_t *info)
145 BT_INFO("No more device connected remove info");
146 rfcomm_clients = g_slist_remove(rfcomm_clients, info);
147 __bt_free_cb_data(info);
151 gint compare(gpointer *a, gpointer *b)
153 rfcomm_conn_info_t *node = (rfcomm_conn_info_t *)a;
154 char *address = (char *)b;
155 return g_strcmp0(node->bt_addr, address);
158 gint compare_fd(gpointer *a, gpointer *b)
160 rfcomm_conn_info_t *node = (rfcomm_conn_info_t *)a;
167 static void __bt_free_conn(rfcomm_conn_info_t *conn)
174 if (conn->watch_id > 0) {
175 g_source_remove(conn->watch_id);
184 static void __rfcomm_remove_conn_info_t(rfcomm_cb_data_t *info, char *address)
187 rfcomm_conn_info_t *conn_info = NULL;
188 l = g_slist_find_custom(info->rfcomm_conns, address, (GCompareFunc)compare);
192 info->rfcomm_conns = g_slist_remove(info->rfcomm_conns, conn_info);
193 __bt_free_conn(conn_info);
197 static rfcomm_conn_info_t *__get_conn_info_from_fd(rfcomm_cb_data_t *info,
201 rfcomm_conn_info_t *device_node = NULL;
202 for (l = info->rfcomm_conns; l != NULL; l = l->next) {
203 device_node = l->data;
204 if (device_node && device_node->fd == fd)
210 static rfcomm_conn_info_t *__get_conn_info_from_address(rfcomm_cb_data_t *info,
214 rfcomm_conn_info_t *conn_info = NULL;
215 l = g_slist_find_custom(info->rfcomm_conns, dev_address,
216 (GCompareFunc)compare);
222 static void __rfcomm_client_connected_cb(rfcomm_cb_data_t *info,
223 char *dev_address, int result)
225 if (g_slist_find(rfcomm_clients, info) == NULL) {
226 BT_INFO("rfcomm resource is already freed");
230 __client_connected_cb(info, dev_address, result);
231 __rfcomm_remove_conn_info_t(info, dev_address);
233 if (info->rfcomm_conns == NULL)
234 rfcomm_cb_data_remove(info);
237 static rfcomm_cb_data_t *__find_rfcomm_info_with_fd(int fd)
241 for (l = rfcomm_clients; l != NULL; l = l->next) {
242 rfcomm_cb_data_t *info = l->data;
243 device_fd = g_slist_find_custom(info->rfcomm_conns, &fd,
244 (GCompareFunc)compare_fd);
252 static rfcomm_cb_data_t *__find_rfcomm_info_from_path(const char *path)
256 for (l = rfcomm_clients; l != NULL; l = l->next) {
257 rfcomm_cb_data_t *info = l->data;
260 if (g_strcmp0(info->obj_path, path) == 0)
267 static rfcomm_cb_data_t *__find_rfcomm_info_from_uuid(const char *uuid)
271 for (l = rfcomm_clients; l != NULL; l = l->next) {
272 rfcomm_cb_data_t *info = l->data;
274 if (g_strcmp0(info->uuid, uuid) == 0)
281 static void _bt_rfcomm_disconnect_conn_info(rfcomm_conn_info_t *conn_info,
282 rfcomm_cb_data_t *info)
284 if (conn_info == NULL)
287 bluetooth_rfcomm_disconnection_t disconn_info;
288 bt_event_info_t *event_info = NULL;
290 if (conn_info->disconnected == FALSE)
293 event_info = _bt_event_get_cb_data(BT_RFCOMM_CLIENT_EVENT);
294 if (event_info == NULL) {
295 __rfcomm_remove_conn_info_t(info, conn_info->bt_addr);
297 if (info->rfcomm_conns == NULL)
298 rfcomm_cb_data_remove(info);
302 memset(&disconn_info, 0x00, sizeof(bluetooth_rfcomm_disconnection_t));
303 disconn_info.device_role = RFCOMM_ROLE_CLIENT;
304 g_strlcpy(disconn_info.uuid, info->uuid, BLUETOOTH_UUID_STRING_MAX);
305 _bt_convert_addr_string_to_type(disconn_info.device_addr.addr,
308 BT_DBG("Disconnected FD [%d]", conn_info->fd);
309 disconn_info.socket_fd = conn_info->fd;
311 BT_DBG("Disconnection Result[%d] BT_ADDRESS[%s] UUID[%s] FD[%d]",
312 BLUETOOTH_ERROR_NONE, conn_info->bt_addr,
313 info->uuid, conn_info->fd);
314 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_DISCONNECTED,
315 BLUETOOTH_ERROR_NONE, &disconn_info,
316 event_info->cb, event_info->user_data);
318 __rfcomm_remove_conn_info_t(info, conn_info->bt_addr);
320 if (info->rfcomm_conns == NULL)
321 rfcomm_cb_data_remove(info);
323 if (_bt_common_send_rfcomm_conn_info(RFCOMM_ROLE_CLIENT,
324 FALSE, disconn_info.socket_fd) != BLUETOOTH_ERROR_NONE)
325 BT_ERR("Fail to send the connection info");
330 static gboolean __rfcomm_client_disconnect(gpointer user_data)
332 rfcomm_cb_data_t *info = (rfcomm_cb_data_t *)user_data;
334 BT_INFO_C("### Disconnected [RFCOMM Client]");
336 retv_if(info == NULL, FALSE);
338 if (g_slist_find(rfcomm_clients, info) == NULL) {
339 BT_INFO("rfcomm resource is already freed");
344 g_slist_foreach(info->rfcomm_conns,
345 (GFunc)_bt_rfcomm_disconnect_conn_info, info);
351 static gboolean __is_error_by_disconnect(GError *err)
353 return !g_strcmp0(err->message, "Connection reset by peer") ||
354 !g_strcmp0(err->message, "Connection timed out") ||
355 !g_strcmp0(err->message, "Software caused connection abort");
358 static gboolean __client_data_received_cb(GIOChannel *chan, GIOCondition cond,
363 int result = BLUETOOTH_ERROR_NONE;
364 rfcomm_cb_data_t *info = data;
365 rfcomm_conn_info_t *conn_info = NULL;
366 bt_event_info_t *event_info;
367 bluetooth_rfcomm_received_data_t data_r;
368 GIOStatus status = G_IO_STATUS_NORMAL;
371 static int resource_unavailable_cnt = 0;
373 retv_if(info == NULL, FALSE);
374 fd = g_io_channel_unix_get_fd(chan);
375 if (cond & (G_IO_NVAL | G_IO_HUP | G_IO_ERR)) {
376 BT_ERR_C("RFComm Client disconnected: %d", fd);
378 conn_info = __get_conn_info_from_fd(info, fd);
379 if (conn_info == NULL) {
380 BT_ERR("No Connection info found with FD [%d]", fd);
384 if (conn_info->disconnected == FALSE) {
385 close(conn_info->fd);
386 conn_info->disconnected = TRUE;
388 __rfcomm_client_disconnect(info);
392 buffer = g_malloc0(BT_RFCOMM_BUFFER_LEN + 1);
394 status = g_io_channel_read_chars(chan, buffer, BT_RFCOMM_BUFFER_LEN,
396 if (status != G_IO_STATUS_NORMAL) {
397 BT_ERR("IO Channel read is failed with %d", status);
402 BT_ERR("IO Channel read error [%s]", err->message);
403 if (status == G_IO_STATUS_ERROR &&
404 __is_error_by_disconnect(err)) {
406 BT_ERR("cond : %d", cond);
413 if (status == G_IO_STATUS_ERROR ||
414 status == G_IO_STATUS_EOF) {
416 } else if (status == G_IO_STATUS_AGAIN) {
417 resource_unavailable_cnt++;
418 if (resource_unavailable_cnt > 10)
424 resource_unavailable_cnt = 0;
426 event_info = _bt_event_get_cb_data(BT_RFCOMM_CLIENT_EVENT);
427 if (event_info == NULL) {
432 data_r.socket_fd = fd;
433 data_r.buffer_size = len;
434 data_r.buffer = buffer;
436 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_DATA_RECEIVED,
438 event_info->cb, event_info->user_data);
440 if (bluetooth_get_battery_monitor_state()) {
442 BT_DBG("Adding rfcomm rx timeout function for battery monitor");
443 rx_tag = g_timeout_add_seconds(BATTERY_MONITOR_RFCOMM_INTERVAL, (GSourceFunc)__rfcomm_record_rx_data, NULL);
452 conn_info = __get_conn_info_from_fd(info, fd);
453 if (conn_info == NULL) {
454 BT_ERR("No Connection info found with FD [%d]", fd);
458 if (conn_info->disconnected == FALSE) {
459 close(conn_info->fd);
460 conn_info->disconnected = TRUE;
462 __rfcomm_client_disconnect(info);
467 static void __client_connected_cb(rfcomm_cb_data_t *cb_data, char *dev_address,
470 bluetooth_rfcomm_connection_t conn_info;
471 bt_event_info_t *event_info;
472 rfcomm_conn_info_t *conn_list_info = NULL;
474 if (result == BLUETOOTH_ERROR_NONE)
475 BT_INFO_C("### Connected [RFCOMM Client]");
477 event_info = _bt_event_get_cb_data(BT_RFCOMM_CLIENT_EVENT);
478 if (event_info == NULL)
481 memset(&conn_info, 0x00, sizeof(bluetooth_rfcomm_connection_t));
482 conn_info.device_role = RFCOMM_ROLE_CLIENT;
483 g_strlcpy(conn_info.uuid, cb_data->uuid, BLUETOOTH_UUID_STRING_MAX);
484 _bt_convert_addr_string_to_type(conn_info.device_addr.addr,
486 conn_list_info = __get_conn_info_from_address(cb_data, dev_address);
487 if (conn_list_info == NULL) {
488 BT_ERR("Device addres %s not found in connection list", dev_address);
491 conn_info.socket_fd = conn_list_info->fd;
492 conn_info.server_id = -1;
494 if (_bt_common_send_rfcomm_conn_info(RFCOMM_ROLE_CLIENT,
495 TRUE, conn_info.socket_fd) != BLUETOOTH_ERROR_NONE)
496 BT_ERR("Fail to send the connection info");
498 BT_DBG("Connection Result[%d] BT_ADDRESS[%s] UUID[%s] FD[%d]",
499 result, conn_list_info->bt_addr, cb_data->uuid, conn_list_info->fd);
500 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_CONNECTED,
502 event_info->cb, event_info->user_data);
506 void _bt_rfcomm_client_disconnect_all(void)
511 BT_INFO_C("### Disconnect all RFCOMM client connections");
513 for (client = rfcomm_clients; client; ) {
514 rfcomm_cb_data_t *info = client->data;
516 for (conn = info->rfcomm_conns; conn; conn = conn->next) {
517 rfcomm_conn_info_t *conn_info = conn->data;
519 if (conn_info == NULL)
522 if (conn_info->watch_id == 0 || conn_info->disconnected)
525 close(conn_info->fd);
526 conn_info->disconnected = TRUE;
528 _bt_disconnect_ext_profile(conn_info->bt_addr,
532 client = client->next;
533 __rfcomm_client_disconnect(info);
539 void _bt_rfcomm_client_reset_timer(void)
543 g_source_remove(rx_tag);
547 g_source_remove(tx_tag);
555 int new_connection(const char *path, int fd, bluetooth_device_address_t *addr)
557 rfcomm_cb_data_t *info;
559 rfcomm_conn_info_t *conn_info = NULL;
560 char address[BT_ADDRESS_STRING_SIZE];
562 BT_INFO("%s %d", path, fd);
564 _bt_convert_addr_type_to_string(address,
565 (unsigned char *)addr);
567 info = __find_rfcomm_info_from_path(path);
569 BT_ERR("rfcomm info is NULL");
573 conn_info = __get_conn_info_from_address(info, address);
574 if (conn_info == NULL) {
575 BT_ERR("connection info is NULL");
581 data_io = g_io_channel_unix_new(fd);
583 g_io_channel_set_encoding(data_io, NULL, NULL);
584 g_io_channel_set_flags(data_io, G_IO_FLAG_NONBLOCK, NULL);
586 conn_info->watch_id = g_io_add_watch(data_io,
587 G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
588 __client_data_received_cb, info);
590 g_io_channel_unref(data_io);
592 __client_connected_cb(info, address, BLUETOOTH_ERROR_NONE);
597 static void __bt_connect_response_cb(GDBusProxy *proxy, GAsyncResult *res,
601 GError *error = NULL;
603 rfcomm_cb_data_t *cb_data;
604 char dev_address[BT_ADDRESS_STRING_SIZE];
608 ret_if(user_data == NULL);
612 value = g_dbus_proxy_call_finish(proxy, res, &error);
615 g_dbus_error_strip_remote_error(error);
616 BT_ERR("Error : %s \n", error->message);
618 if (g_strcmp0(error->message, "In Progress") == 0)
619 result = BLUETOOTH_ERROR_DEVICE_BUSY;
621 result = BLUETOOTH_ERROR_INTERNAL;
622 path = g_dbus_proxy_get_object_path(proxy);
623 _bt_convert_device_path_to_address(path, dev_address);
624 __rfcomm_client_connected_cb(cb_data, dev_address, result);
628 g_variant_unref(value);
632 g_object_unref(proxy);
637 static void __bt_discover_service_response_cb(GDBusProxy *proxy,
638 GAsyncResult *res, gpointer user_data)
640 rfcomm_cb_data_t *cb_data;
644 bt_register_profile_info_t info = {0};
645 int result = BLUETOOTH_ERROR_NONE;
646 char dev_address[BT_ADDRESS_STRING_SIZE];
651 ret_if(user_data == NULL);
655 path = g_dbus_proxy_get_object_path(proxy);
657 _bt_convert_device_path_to_address(path, dev_address);
658 BT_DBG("Device Adress [%s]", dev_address);
659 value = g_dbus_proxy_call_finish(proxy, res, &err);
661 g_object_unref(proxy);
663 g_variant_unref(value);
666 g_dbus_error_strip_remote_error(err);
667 BT_ERR("Error occured in Proxy call [%s]\n", err->message);
668 if (!strcmp("Operation canceled", err->message)) {
669 result = BLUETOOTH_ERROR_CANCEL_BY_USER;
670 } else if (!strcmp("In Progress", err->message)) {
671 result = BLUETOOTH_ERROR_IN_PROGRESS;
672 } else if (!strcmp("Host is down", err->message)) {
673 result = BLUETOOTH_ERROR_HOST_DOWN;
674 } else if (!strcmp(BT_TIMEOUT_MESSAGE, err->message)) {
675 result = BLUETOOTH_ERROR_SERVICE_SEARCH_ERROR;
676 ret = _bt_cancel_discovers(dev_address);
677 if (ret != BLUETOOTH_ERROR_NONE)
678 BT_ERR("Error: While CancelDiscovery");
680 result = BLUETOOTH_ERROR_CONNECTION_ERROR;
682 __rfcomm_client_connected_cb(cb_data, dev_address, result);
685 BT_INFO("Services are Updated checking required uuid is there");
686 /* Check here for uuid present */
687 ret = _bt_discover_service_uuids(dev_address, (char *)cb_data->uuid);
688 if (ret == BLUETOOTH_ERROR_NONE) {
689 info.uuid = (char *)cb_data->uuid;
690 info.obj_path = cb_data->obj_path;
691 info.role = "client";
693 ret = _bt_register_profile(&info, FALSE);
695 BT_DBG("Error: register profile");
696 ret = _bt_connect_profile(dev_address, cb_data->uuid,
697 __bt_connect_response_cb, cb_data);
699 if (ret != BLUETOOTH_ERROR_NONE) {
700 BT_ERR("ConnectProfile failed");
701 result = BLUETOOTH_ERROR_CONNECTION_ERROR;
702 __rfcomm_client_connected_cb(cb_data, dev_address, result);
706 BT_ERR("remote uuid not found");
707 result = BLUETOOTH_ERROR_SERVICE_NOT_FOUND;
708 __rfcomm_client_connected_cb(cb_data, dev_address, result);
716 GSList *rfcomm_clients;
723 } rfcomm_client_conn_info_t;
725 static gboolean __is_error_by_disconnect(GError *err)
727 return !g_strcmp0(err->message, "Connection reset by peer") ||
728 !g_strcmp0(err->message, "Connection timed out") ||
729 !g_strcmp0(err->message, "Software caused connection abort");
732 static rfcomm_client_conn_info_t *__find_rfcomm_conn_info_with_fd(int fd)
738 for (l = rfcomm_clients; l != NULL; l = l->next) {
739 rfcomm_client_conn_info_t *info = l->data;
741 if (info && info->sock_fd == fd) {
742 BT_INFO("Match found");
751 static void __rfcomm_remove_client_conn_info_t(rfcomm_client_conn_info_t *info)
753 ret_if(info == NULL);
755 rfcomm_clients = g_slist_remove(rfcomm_clients, info);
757 g_free(info->remote_addr);
760 static void __bt_rfcomm_client_disconnected(rfcomm_client_conn_info_t *conn_info)
763 bluetooth_rfcomm_disconnection_t disconn_info;
764 bt_event_info_t *event_info = NULL;
766 ret_if(conn_info == NULL);
768 event_info = _bt_event_get_cb_data(BT_RFCOMM_CLIENT_EVENT);
769 ret_if(event_info == NULL);
771 memset(&disconn_info, 0x00, sizeof(bluetooth_rfcomm_disconnection_t));
772 disconn_info.device_role = RFCOMM_ROLE_CLIENT;
773 disconn_info.socket_fd = conn_info->sock_fd;
774 g_strlcpy(disconn_info.uuid, conn_info->uuid, BLUETOOTH_UUID_STRING_MAX);
775 _bt_convert_addr_string_to_type(disconn_info.device_addr.addr,
776 conn_info->remote_addr);
778 BT_DBG("Disconnection Result[%d] BT_ADDRESS[%s] UUID[%s] FD[%d]",
779 BLUETOOTH_ERROR_NONE, conn_info->remote_addr,
780 conn_info->uuid, conn_info->sock_fd);
781 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_DISCONNECTED,
782 BLUETOOTH_ERROR_NONE, &disconn_info,
783 event_info->cb, event_info->user_data);
788 static gboolean __client_data_received_cb(GIOChannel *chan, GIOCondition cond, gpointer data)
790 bt_event_info_t *event_info;
791 bluetooth_rfcomm_received_data_t data_r;
792 rfcomm_client_conn_info_t *conn_info;
798 GIOStatus status = G_IO_STATUS_NORMAL;
802 fd = g_io_channel_unix_get_fd(chan);
803 if (cond & (G_IO_NVAL | G_IO_HUP | G_IO_ERR)) {
804 BT_ERR_C("RFComm Client disconnected: %d", fd);
808 buffer = g_malloc0(BT_RFCOMM_BUFFER_LEN + 1);
809 status = g_io_channel_read_chars(chan, buffer, BT_RFCOMM_BUFFER_LEN,
811 if (status != G_IO_STATUS_NORMAL) {
812 BT_ERR("IO Channel read is failed with %d", status);
815 BT_ERR("IO Channel read error [%s]", err->message);
816 if (status == G_IO_STATUS_ERROR &&
817 __is_error_by_disconnect(err)) {
818 BT_ERR("cond : %d", cond);
829 BT_ERR("Length is zero, remote end hang up");
833 BT_DBG("fd: %d, len: %d, buffer: %s", fd, len, buffer);
835 event_info = _bt_event_get_cb_data(BT_RFCOMM_CLIENT_EVENT);
836 if (event_info == NULL) {
837 BT_INFO("event_info == NULL");
842 data_r.socket_fd = fd;
843 data_r.buffer_size = len;
844 data_r.buffer = buffer;
846 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_DATA_RECEIVED,
847 BLUETOOTH_ERROR_NONE, &data_r,
848 event_info->cb, event_info->user_data);
854 conn_info = __find_rfcomm_conn_info_with_fd(fd);
856 __bt_rfcomm_client_disconnected(conn_info);
857 __rfcomm_remove_client_conn_info_t(conn_info);
859 BT_ERR("RFCOMM client conn_info not found");
864 static void __rfcomm_client_connection_create_watch(rfcomm_client_conn_info_t *conn_info)
868 ret_if(NULL == conn_info);
872 data_io = g_io_channel_unix_new(conn_info->sock_fd);
873 g_io_channel_set_encoding(data_io, NULL, NULL);
874 g_io_channel_set_flags(data_io, G_IO_FLAG_NONBLOCK, NULL);
875 conn_info->watch_id = g_io_add_watch(data_io,
876 G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
877 __client_data_received_cb, NULL);
878 g_io_channel_unref(data_io);
883 static void __bt_rfcomm_handle_new_client_connection(bluetooth_rfcomm_connection_t *info)
885 rfcomm_client_conn_info_t *conn_info;
887 ret_if(NULL == info);
891 conn_info = g_malloc0(sizeof(rfcomm_client_conn_info_t));
892 conn_info->remote_addr = g_malloc0(BT_ADDRESS_STRING_SIZE);
893 _bt_convert_addr_type_to_string(
894 conn_info->remote_addr, info->device_addr.addr);
895 conn_info->uuid = g_strdup(info->uuid);
896 conn_info->sock_fd = info->socket_fd;
898 BT_DBG("Address:%s, UUID:%s Socket: %d",
899 conn_info->remote_addr, conn_info->uuid, conn_info->sock_fd);
901 rfcomm_clients = g_slist_append(rfcomm_clients, conn_info);
902 __rfcomm_client_connection_create_watch(conn_info);
907 static void __bt_fill_garray_from_variant(GVariant *var, GArray *param)
912 size = g_variant_get_size(var);
914 data = (char *)g_variant_get_data(var);
916 param = g_array_append_vals(param, data, size);
922 /* TODO_40 : 4.0 merge */
923 /* Don't use this function directly. Instead of it, get the out parameter only */
924 static void __bt_get_event_info(int service_function, GArray *output,
925 int *event, int *event_type, void **param_data)
927 ret_if(event == NULL);
929 BT_DBG("service_function : %s (0x%x)",
930 _bt_convert_service_function_to_string(service_function),
932 switch (service_function) {
933 case BT_RFCOMM_CLIENT_CONNECT:
934 *event_type = BT_RFCOMM_CLIENT_EVENT;
935 *event = BLUETOOTH_EVENT_RFCOMM_CONNECTED;
936 ret_if(output == NULL);
937 *param_data = &g_array_index(output,
938 bluetooth_rfcomm_connection_t, 0);
941 BT_ERR("Unknown function");
947 static void __async_req_cb_with_unix_fd_list(GDBusProxy *proxy, GAsyncResult *res, gpointer user_data)
949 int result = BLUETOOTH_ERROR_NONE;
950 int event_type = BT_ADAPTER_EVENT;
951 bt_req_info_t *cb_data = user_data;
952 bluetooth_event_param_t bt_event;
954 GError *error = NULL;
957 GArray *out_param1 = NULL;
958 GUnixFDList *out_fd_list = NULL;
962 memset(&bt_event, 0x00, sizeof(bluetooth_event_param_t));
964 value = g_dbus_proxy_call_with_unix_fd_list_finish(proxy, &out_fd_list, res, &error);
967 /* dBUS gives error cause */
968 BT_ERR("D-Bus API failure: message[%s]",
970 g_clear_error(&error);
972 result = BLUETOOTH_ERROR_TIMEOUT;
974 ret_if(cb_data == NULL);
976 __bt_get_event_info(cb_data->service_function, NULL,
977 &bt_event.event, &event_type,
978 &bt_event.param_data);
982 g_variant_get(value, "(iv)", &result, ¶m1);
983 g_variant_unref(value);
986 out_param1 = g_array_new(TRUE, TRUE, sizeof(gchar));
987 __bt_fill_garray_from_variant(param1, out_param1);
988 g_variant_unref(param1);
994 __bt_get_event_info(cb_data->service_function, out_param1,
995 &bt_event.event, &event_type,
996 &bt_event.param_data);
998 if (result == BLUETOOTH_ERROR_NONE && out_param1) {
999 if (BT_RFCOMM_CLIENT_CONNECT == cb_data->service_function) {
1002 bluetooth_rfcomm_connection_t *conn_info;
1004 conn_info = (bluetooth_rfcomm_connection_t *)bt_event.param_data;
1006 BT_ERR("out_fd_list is NULL");
1010 fd_list_array = g_unix_fd_list_steal_fds(out_fd_list, &len);
1011 BT_INFO("Num fds in fd_list is : %d, fd_list[0]: %d", len, fd_list_array[0]);
1012 conn_info->socket_fd = fd_list_array[0];
1014 BT_DBG("conn_info->socket_fd: %d", conn_info->socket_fd);
1015 __bt_rfcomm_handle_new_client_connection(conn_info);
1017 if (cb_data->cb != NULL) {
1018 /* Send client connected event */
1019 bt_event.result = result;
1020 BT_INFO("event_type[%d], result=[%d]", event_type, result);
1021 ((bluetooth_cb_func_ptr)cb_data->cb)(
1022 bt_event.event, &bt_event, cb_data->user_data);
1025 g_free(fd_list_array);
1026 g_object_unref(out_fd_list);
1032 if (cb_data->cb == NULL)
1035 /* Only if fail case, call the callback function*/
1036 bt_event.result = result;
1038 BT_INFO("event_type[%d], result=[%d]", event_type, result);
1039 if (event_type == BT_RFCOMM_CLIENT_EVENT) {
1040 ((bluetooth_cb_func_ptr)cb_data->cb)(bt_event.event,
1041 &bt_event, cb_data->user_data);
1043 BT_INFO("Not handled event type : %d", event_type);
1047 g_array_free(out_param1, TRUE);
1054 BT_EXPORT_API int bluetooth_rfcomm_connect(
1055 const bluetooth_device_address_t *remote_bt_address,
1056 const char *remote_uuid)
1059 #ifdef TIZEN_FEATURE_BT_RFCOMM_DIRECT
1060 rfcomm_cb_data_t *cb_data = NULL;
1061 rfcomm_conn_info_t *conn = NULL;
1065 bt_user_info_t *user_info;
1066 char uuid[BLUETOOTH_UUID_STRING_MAX];
1068 BT_CHECK_PARAMETER(remote_bt_address, return);
1069 BT_CHECK_PARAMETER(remote_uuid, return);
1070 BT_CHECK_ENABLED(return);
1072 #ifdef TIZEN_FEATURE_BT_DPM
1073 if (_bt_check_dpm(BT_DPM_ADDRESS, (void *)remote_bt_address) == BT_DPM_RESTRICTED) {
1074 BT_ERR("Blacklist device");
1075 return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
1078 if (_bt_check_dpm(BT_DPM_SPP, NULL) == BT_DPM_RESTRICTED ||
1079 _bt_check_dpm(BT_DPM_HF_ONLY, NULL) == BT_DPM_RESTRICTED) {
1080 BT_ERR("Not allow to connect the RFCOMM service");
1081 return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
1084 if (_bt_check_dpm(BT_DPM_DESKTOP, NULL) == BT_DPM_RESTRICTED) {
1085 char address[BT_ADDRESS_STRING_SIZE] = { 0 };
1086 bluetooth_device_class_t dev_class;
1088 _bt_convert_addr_type_to_string(address, (unsigned char *)remote_bt_address->addr);
1089 _bt_get_cod_by_address(address, &dev_class);
1091 if (dev_class.major_class == BLUETOOTH_DEVICE_MAJOR_CLASS_COMPUTER) {
1092 BT_ERR("Reject a authorization due to MDM Policy");
1093 return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
1098 #ifdef TIZEN_FEATURE_BT_RFCOMM_DIRECT
1099 BT_INFO_C("### Connect RFCOMM");
1104 if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_RFCOMM_CLIENT_CONNECT)
1105 == BLUETOOTH_ERROR_PERMISSION_DEINED) {
1106 BT_ERR("Don't have a privilege to use this API");
1107 return BLUETOOTH_ERROR_PERMISSION_DEINED;
1110 id = __rfcomm_assign_id();
1112 return BLUETOOTH_ERROR_INTERNAL;
1114 cb_data = __find_rfcomm_info_from_uuid(remote_uuid);
1116 path = g_strdup_printf("/org/socket/client/%d/%d", getpid(), id);
1118 object_id = _bt_register_new_conn(path, new_connection);
1119 if (object_id < 0) {
1120 __rfcomm_delete_id(id);
1122 return BLUETOOTH_ERROR_INTERNAL;
1125 cb_data = g_new0(rfcomm_cb_data_t, 1);
1126 g_strlcpy(cb_data->uuid, remote_uuid, BLUETOOTH_UUID_STRING_MAX);
1127 cb_data->obj_path = path;
1128 cb_data->object_id = object_id;
1132 conn = g_new0(rfcomm_conn_info_t, 1);
1134 _bt_convert_addr_type_to_string(conn->bt_addr,
1135 (unsigned char *)remote_bt_address->addr);
1137 BT_DBG("Connecting to %s uuid %s", conn->bt_addr, remote_uuid);
1138 cb_data->rfcomm_conns = g_slist_append(cb_data->rfcomm_conns, conn);
1140 ret = _bt_discover_services(conn->bt_addr, (char *)remote_uuid,
1141 __bt_discover_service_response_cb, cb_data);
1142 if (ret != BLUETOOTH_ERROR_NONE) {
1143 BT_ERR("Error returned while service discovery");
1144 __rfcomm_remove_conn_info_t(cb_data, conn->bt_addr);
1145 if (cb_data->rfcomm_conns == NULL)
1146 rfcomm_cb_data_remove(cb_data);
1147 return BLUETOOTH_ERROR_INTERNAL;
1150 if (g_slist_find(rfcomm_clients, cb_data) == NULL) {
1151 BT_INFO("Adding callback information to rfcomm_clients");
1152 rfcomm_clients = g_slist_append(rfcomm_clients, cb_data);
1154 BT_INFO("Callback information is already added");
1156 return BLUETOOTH_ERROR_NONE;
1158 user_info = _bt_get_user_data(BT_COMMON);
1159 retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
1161 /* connect_type: BT_RFCOMM_UUID / BT_RFCOMM_CHANNEL*/
1162 /* In now, we only support to connecty using UUID */
1163 connect_type = BT_RFCOMM_UUID;
1165 if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_RFCOMM_CLIENT_CONNECT)
1166 == BLUETOOTH_ERROR_PERMISSION_DEINED) {
1167 BT_ERR("Don't have a privilege to use this API");
1168 return BLUETOOTH_ERROR_PERMISSION_DEINED;
1172 BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1174 g_array_append_vals(in_param1, remote_bt_address,
1175 sizeof(bluetooth_device_address_t));
1177 g_strlcpy(uuid, remote_uuid, sizeof(uuid));
1178 g_array_append_vals(in_param2, uuid, BLUETOOTH_UUID_STRING_MAX);
1180 g_array_append_vals(in_param3, &connect_type, sizeof(int));
1182 result = _bt_send_request_async_with_unix_fd_list(BT_BLUEZ_SERVICE,
1183 BT_RFCOMM_CLIENT_CONNECT,
1184 in_param1, in_param2,
1185 in_param3, in_param4,
1186 user_info->cb, user_info->user_data,
1187 NULL, (GAsyncReadyCallback)__async_req_cb_with_unix_fd_list);
1189 BT_DBG("result: %x", result);
1191 BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1197 BT_EXPORT_API int bluetooth_rfcomm_client_is_connected(const bluetooth_device_address_t *device_address, gboolean *connected)
1199 #ifdef TIZEN_FEATURE_BT_RFCOMM_DIRECT
1201 GSList *conn_list = NULL;
1202 rfcomm_cb_data_t *client_info;
1203 rfcomm_conn_info_t *conn_info;
1204 char address[BT_ADDRESS_STRING_SIZE] = { 0 };
1206 BT_CHECK_PARAMETER(device_address, return);
1207 BT_CHECK_PARAMETER(connected, return);
1209 _bt_convert_addr_type_to_string(address, (unsigned char *)device_address->addr);
1212 for (l = rfcomm_clients; l != NULL; l = l->next) {
1213 client_info = l->data;
1214 if (client_info == NULL)
1216 for (conn_list = client_info->rfcomm_conns;
1217 conn_list != NULL; conn_list = conn_list->next) {
1218 conn_info = conn_list->data;
1219 if (conn_info == NULL)
1222 if (g_strcmp0(address, conn_info->bt_addr) == 0) {
1224 return BLUETOOTH_ERROR_NONE;
1229 return BLUETOOTH_ERROR_NONE;
1232 char address[BT_ADDRESS_STRING_SIZE] = { 0 };
1234 BT_CHECK_PARAMETER(device_address, return);
1235 BT_CHECK_PARAMETER(connected, return);
1240 _bt_convert_addr_type_to_string(address, (unsigned char *)device_address->addr);
1241 BT_INFO("Client address: [%s]", address);
1243 for (l = rfcomm_clients; l != NULL; l = l->next) {
1244 rfcomm_client_conn_info_t *info = l->data;
1246 if (info && !strncasecmp(info->remote_addr, address, BT_ADDRESS_STRING_SIZE)) {
1247 BT_INFO("Match found");
1249 return BLUETOOTH_ERROR_NONE;
1254 return BLUETOOTH_ERROR_NONE;
1258 BT_EXPORT_API gboolean bluetooth_rfcomm_is_client_connected(void)
1261 int connected = FALSE;
1263 BT_CHECK_ENABLED(return);
1266 BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1268 result = _bt_send_request(BT_BLUEZ_SERVICE,
1269 BT_RFCOMM_CLIENT_IS_CONNECTED,
1270 in_param1, in_param2, in_param3,
1271 in_param4, &out_param);
1273 BT_DBG("result: %x", result);
1275 if (result == BLUETOOTH_ERROR_NONE) {
1276 connected = g_array_index(out_param,
1279 BT_ERR("Fail to send request");
1282 BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1287 BT_EXPORT_API int bluetooth_rfcomm_disconnect(int socket_fd)
1289 #ifdef TIZEN_FEATURE_BT_RFCOMM_DIRECT
1290 rfcomm_cb_data_t *info;
1291 rfcomm_conn_info_t *conn_info;
1293 BT_INFO_C("### Disconnect RFCOMM");
1295 BT_CHECK_ENABLED(return);
1297 if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_RFCOMM_SOCKET_DISCONNECT)
1298 == BLUETOOTH_ERROR_PERMISSION_DEINED) {
1299 BT_ERR("Don't have a privilege to use this API");
1300 return BLUETOOTH_ERROR_PERMISSION_DEINED;
1303 BT_DBG("Requested FD %d", socket_fd);
1304 if (socket_fd < 0) {
1305 BT_ERR("Invalid FD");
1306 return BLUETOOTH_ERROR_INVALID_PARAM;
1308 BT_DBG("FDD %d", socket_fd);
1310 info = __find_rfcomm_info_with_fd(socket_fd);
1312 BT_DBG("Could not find in client, so check in server");
1313 return bluetooth_rfcomm_server_disconnect(socket_fd);
1316 conn_info = __get_conn_info_from_fd(info, socket_fd);
1317 if (conn_info == NULL) {
1318 BT_ERR("Could not find connection info");
1319 return BLUETOOTH_ERROR_INTERNAL;
1322 if (conn_info->watch_id == 0 || conn_info->disconnected) {
1323 BT_ERR("Invalid state");
1324 return BLUETOOTH_ERROR_NOT_CONNECTED;
1327 close(conn_info->fd);
1328 conn_info->disconnected = TRUE;
1330 BT_INFO("conn_info %s", conn_info->bt_addr);
1331 _bt_disconnect_ext_profile(conn_info->bt_addr, info->obj_path);
1333 if (info->idle_id == 0)
1334 info->idle_id = g_idle_add(__rfcomm_client_disconnect, info);
1336 return BLUETOOTH_ERROR_NONE;
1338 rfcomm_client_conn_info_t *conn_info;
1340 BT_INFO_C("<<<<<<<<< RFCOMM Disconnect request from app >>>>>>>>");
1342 BT_CHECK_ENABLED(return);
1343 retv_if(socket_fd < 0, BLUETOOTH_ERROR_INVALID_PARAM);
1345 if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_RFCOMM_SOCKET_DISCONNECT)
1346 == BLUETOOTH_ERROR_PERMISSION_DEINED) {
1347 BT_ERR("Don't have a privilege to use this API");
1348 return BLUETOOTH_ERROR_PERMISSION_DEINED;
1351 BT_DBG("FD %d", socket_fd);
1353 conn_info = __find_rfcomm_conn_info_with_fd(socket_fd);
1354 if (conn_info == NULL) {
1355 BT_DBG("Could not find in client, so check in server");
1356 /* Check for fd in server list and perform the disconnection if present */
1357 return bluetooth_rfcomm_server_disconnect(socket_fd);
1360 if (conn_info->watch_id <= 0) {
1361 BT_ERR("Invalid state");
1362 return BLUETOOTH_ERROR_NOT_CONNECTED;
1366 * Just close socket here and return. Socket close will be detected via I/O watch
1367 * and disconnection event as well as info cleanup will be performed there.
1369 close(conn_info->sock_fd);
1371 return BLUETOOTH_ERROR_NONE;
1375 #ifdef TIZEN_FEATURE_BT_RFCOMM_DIRECT
1377 static int __write_all(int fd, const char *buf, int len)
1379 int sent = 0, try = 0;
1385 written = write(fd, buf, len);
1386 BT_DBG("written: %d", written);
1388 if (errno == EINTR || errno == EAGAIN) {
1410 BT_EXPORT_API int bluetooth_rfcomm_write(int fd, const char *buf, int length)
1412 #ifdef TIZEN_FEATURE_BT_RFCOMM_DIRECT
1417 #ifndef TIZEN_FEATURE_BT_RFCOMM_DIRECT
1418 BT_CHECK_ENABLED(return);
1420 BT_CHECK_PARAMETER(buf, return);
1422 BT_ERR("Invalid FD");
1423 return BLUETOOTH_ERROR_INVALID_PARAM;
1426 retv_if(length <= 0, BLUETOOTH_ERROR_INVALID_PARAM);
1428 switch (privilege_token) {
1430 result = _bt_check_privilege(BT_CHECK_PRIVILEGE, BT_RFCOMM_SOCKET_WRITE);
1432 if (result == BLUETOOTH_ERROR_NONE) {
1433 privilege_token = 1; /* Have a permission */
1434 } else if (result == BLUETOOTH_ERROR_PERMISSION_DEINED) {
1435 BT_ERR("Don't have a privilege to use this API");
1436 privilege_token = -1; /* Don't have a permission */
1437 return BLUETOOTH_ERROR_PERMISSION_DEINED;
1439 /* Just break - It is not related with permission error */
1443 /* Already have a privilege */
1446 return BLUETOOTH_ERROR_PERMISSION_DEINED;
1448 /* Invalid privilge token value */
1449 return BLUETOOTH_ERROR_INTERNAL;
1452 #ifdef TIZEN_FEATURE_BT_RFCOMM_DIRECT
1453 written = write(fd, buf, length);
1454 /*BT_DBG("Length %d, written = %d, balance(%d)",
1455 length, written, length - written); */
1456 if (written > 0 && bluetooth_get_battery_monitor_state()) {
1458 BT_DBG("Adding rfcomm tx timeout function for battery monitor");
1459 tx_tag = g_timeout_add_seconds(BATTERY_MONITOR_RFCOMM_INTERVAL, (GSourceFunc)__rfcomm_record_tx_data, NULL);
1465 result = __write_all(fd, buf, length);
1466 if (result > 0 && bluetooth_get_battery_monitor_state()) {
1468 BT_DBG("Adding rfcomm tx timeout function for battery monitor");
1469 tx_tag = g_timeout_add_seconds(BATTERY_MONITOR_RFCOMM_INTERVAL, (GSourceFunc)__rfcomm_record_tx_data, NULL);