2 * Copyright (c) 2022 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>
20 #include <sys/socket.h>
22 #include "bluetooth-api.h"
23 #include "bt-internal-types.h"
25 #include "bt-common.h"
26 #include "bt-request-sender.h"
27 #include "bt-event-handler.h"
29 /* Variable for privilege, only for write API,
30 before we should reduce time to bt-service dbus calling
31 -1 : Don't have a permission to access API
32 0 : Initial value, not yet check
33 1 : Have a permission to access API
35 static int privilege_token;
37 GSList *l2cap_le_clients;
44 } l2cap_le_client_conn_info_t;
46 static gboolean __is_error_by_disconnect(GError *err)
48 return !g_strcmp0(err->message, "Connection reset by peer") ||
49 !g_strcmp0(err->message, "Connection timed out") ||
50 !g_strcmp0(err->message, "Software caused connection abort");
53 static l2cap_le_client_conn_info_t *__find_l2cap_le_conn_info_with_fd(int fd)
59 for (l = l2cap_le_clients; l != NULL; l = l->next) {
60 l2cap_le_client_conn_info_t *info = l->data;
62 if (info && info->sock_fd == fd) {
63 BT_INFO("Match found");
72 static void __l2cap_le_remove_client_conn_info_t(
73 l2cap_le_client_conn_info_t *info)
77 l2cap_le_clients = g_slist_remove(l2cap_le_clients, info);
78 g_free(info->remote_addr);
80 if (info->sock_fd > 0) {
81 shutdown(info->sock_fd, SHUT_RDWR);
85 if (info->watch_id > 0)
86 g_source_remove(info->watch_id);
90 static void __bt_l2cap_le_client_disconnected(
91 l2cap_le_client_conn_info_t *conn_info)
93 bluetooth_l2cap_le_disconnection_t disconn_info;
94 bt_event_info_t *event_info = NULL;
98 ret_if(conn_info == NULL);
100 event_info = _bt_event_get_cb_data(BT_L2CAP_LE_CLIENT_EVENT);
101 ret_if(event_info == NULL);
103 memset(&disconn_info, 0x00, sizeof(bluetooth_l2cap_le_disconnection_t));
104 disconn_info.device_role = L2CAP_LE_ROLE_CLIENT;
105 disconn_info.socket_fd = conn_info->sock_fd;
106 disconn_info.psm = conn_info->psm;
107 _bt_convert_addr_string_to_type(disconn_info.device_addr.addr,
108 conn_info->remote_addr);
110 BT_INFO("Disconnection Result[%d] BT_ADDRESS[%s] FD[%d] PSM[%d]",
111 BLUETOOTH_ERROR_NONE, conn_info->remote_addr,
112 conn_info->sock_fd, conn_info->psm);
113 _bt_common_event_cb(BLUETOOTH_EVENT_L2CAP_LE_DISCONNECTED,
114 BLUETOOTH_ERROR_NONE, &disconn_info,
115 event_info->cb, event_info->user_data);
120 static gboolean __client_data_received_cb(GIOChannel *chan, GIOCondition cond,
123 bt_event_info_t *event_info;
124 bluetooth_l2cap_le_received_data_t data_r;
125 l2cap_le_client_conn_info_t *conn_info;
130 GIOStatus status = G_IO_STATUS_NORMAL;
131 static int resource_unavailable_cnt = 0;
135 fd = g_io_channel_unix_get_fd(chan);
136 if (cond & (G_IO_NVAL | G_IO_HUP | G_IO_ERR)) {
137 BT_ERR_C("L2cap_le Client disconnected: %d", fd);
141 buffer = g_malloc0(BT_L2CAP_LE_BUFFER_LEN + 1);
142 g_io_channel_set_buffer_size(chan, BT_L2CAP_LE_BUFFER_LEN);
143 status = g_io_channel_read_chars(chan, buffer, BT_L2CAP_LE_BUFFER_LEN,
145 if (status != G_IO_STATUS_NORMAL) {
146 BT_ERR("IO Channel read is failed with %d", status);
149 BT_ERR("IO Channel read error [%s]", err->message);
150 if (status == G_IO_STATUS_ERROR &&
151 __is_error_by_disconnect(err)) {
152 BT_ERR("cond : %d", cond);
159 if (status == G_IO_STATUS_ERROR ||
160 status == G_IO_STATUS_EOF) {
162 } else if (status == G_IO_STATUS_AGAIN) {
163 resource_unavailable_cnt++;
164 if (resource_unavailable_cnt > 10)
170 resource_unavailable_cnt = 0;
173 BT_ERR("Length is zero, remote end hang up");
178 BT_DBG("fd: %d, len: %zd, buffer: %s", fd, len, buffer);
180 event_info = _bt_event_get_cb_data(BT_L2CAP_LE_CLIENT_EVENT);
181 if (event_info == NULL) {
182 BT_INFO("event_info == NULL");
187 data_r.socket_fd = fd;
188 data_r.buffer_size = len;
189 data_r.buffer = buffer;
191 _bt_common_event_cb(BLUETOOTH_EVENT_L2CAP_LE_DATA_RECEIVED,
192 BLUETOOTH_ERROR_NONE, &data_r,
193 event_info->cb, event_info->user_data);
199 conn_info = __find_l2cap_le_conn_info_with_fd(fd);
201 BT_INFO("Disconnecting client, fd %d", fd);
202 close(conn_info->sock_fd);
203 __bt_l2cap_le_client_disconnected(conn_info);
204 __l2cap_le_remove_client_conn_info_t(conn_info);
206 BT_ERR("l2cap_le client conn_info not found");
213 static void __l2cap_le_client_connection_create_watch(
214 l2cap_le_client_conn_info_t *conn_info)
220 ret_if(NULL == conn_info);
222 data_io = g_io_channel_unix_new(conn_info->sock_fd);
223 g_io_channel_set_encoding(data_io, NULL, NULL);
224 g_io_channel_set_flags(data_io, G_IO_FLAG_NONBLOCK, NULL);
225 conn_info->watch_id = g_io_add_watch(data_io,
226 G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
227 __client_data_received_cb, NULL);
228 g_io_channel_unref(data_io);
233 static void __bt_l2cap_le_handle_new_client_connection(
234 bluetooth_l2cap_le_connection_t *info)
236 l2cap_le_client_conn_info_t *conn_info;
240 ret_if(NULL == info);
242 conn_info = g_malloc0(sizeof(l2cap_le_client_conn_info_t));
243 conn_info->remote_addr = g_malloc0(BT_ADDRESS_STRING_SIZE);
244 _bt_convert_addr_type_to_string(
245 conn_info->remote_addr, info->device_addr.addr);
246 conn_info->sock_fd = info->socket_fd;
247 conn_info->psm = info->psm;
249 BT_INFO("Address:%s, Socket: %d, psm: %d",
250 conn_info->remote_addr, conn_info->sock_fd, conn_info->psm);
252 l2cap_le_clients = g_slist_append(l2cap_le_clients, conn_info);
253 __l2cap_le_client_connection_create_watch(conn_info);
258 static void __async_req_cb_with_unix_fd_list(GDBusProxy *proxy,
259 GAsyncResult *res, gpointer user_data)
261 int result = BLUETOOTH_ERROR_NONE;
262 int event_type = BT_LE_ADAPTER_EVENT;
263 gboolean fail = false;
265 bt_req_info_t *cb_data = user_data;
266 bluetooth_event_param_t bt_event;
267 GArray *out_param1 = NULL;
268 GUnixFDList *out_fd_list = NULL;
269 bt_l2cap_user_info_t *l2cap_user_info = NULL;
274 l2cap_user_info = (bt_l2cap_user_info_t *)cb_data->user_data;
277 cb_data->user_data = (void *)l2cap_user_info->user_data;
279 _bt_get_fd_list_info(proxy, res, user_data, &bt_event, &out_param1,
280 &event_type, &out_fd_list, &result, &fail);
283 BT_INFO("Connection failed due to error: %d", result);
284 bluetooth_l2cap_le_connection_t *conn_info;
286 conn_info = g_malloc0(sizeof(bluetooth_l2cap_le_connection_t));
287 memset(conn_info, 0x00, sizeof(bluetooth_l2cap_le_connection_t));
289 if (l2cap_user_info) {
290 conn_info->psm = l2cap_user_info->psm;
291 memcpy(&conn_info->device_addr, &l2cap_user_info->device_addr,
292 sizeof(bluetooth_device_address_t));
295 bt_event.param_data = (void *)conn_info;
302 if (result == BLUETOOTH_ERROR_NONE && out_param1) {
303 if (BT_L2CAP_LE_CLIENT_CONNECT == cb_data->service_function) {
306 bluetooth_l2cap_le_connection_t *conn_info;
308 conn_info = (bluetooth_l2cap_le_connection_t *)bt_event.param_data;
310 BT_ERR("out_fd_list is NULL");
314 fd_list_array = g_unix_fd_list_steal_fds(out_fd_list, &len);
315 BT_INFO("Num fds in fd_list is : %d, fd_list[0]: %d", len, fd_list_array[0]);
316 conn_info->socket_fd = fd_list_array[0];
318 BT_INFO("conn_info->socket_fd: %d", conn_info->socket_fd);
319 __bt_l2cap_le_handle_new_client_connection(conn_info);
321 if (cb_data->cb != NULL) {
322 /* Send client connected event */
323 bt_event.result = result;
324 BT_INFO("send client connected event event_type[%d], result=[%d]", event_type, result);
325 ((bluetooth_cb_func_ptr)cb_data->cb)(
326 bt_event.event, &bt_event, cb_data->user_data);
329 g_free(fd_list_array);
330 g_object_unref(out_fd_list);
336 if (cb_data->cb == NULL)
339 /* Only if fail case, call the callback function*/
340 bt_event.result = result;
342 BT_INFO("send fail event event_type[%d], result=[%d]", event_type, result);
343 if (event_type == BT_L2CAP_LE_CLIENT_EVENT) {
344 BT_INFO("l2cap_le client event");
345 ((bluetooth_cb_func_ptr)cb_data->cb)(bt_event.event,
346 &bt_event, cb_data->user_data);
348 BT_INFO("Not handled event type : %d", event_type);
352 g_array_free(out_param1, TRUE);
354 g_free(l2cap_user_info);
359 BT_EXPORT_API int bluetooth_l2cap_le_connect(
360 const bluetooth_device_address_t *remote_bt_address, int psm)
363 bt_user_info_t *user_info;
365 bt_l2cap_user_info_t *l2cap_user_info;
367 BT_CHECK_PARAMETER(remote_bt_address, return);
368 BT_CHECK_ENABLED_LE(return);
370 BT_INFO_C("connect l2cap_le psm %d", psm);
371 user_info = _bt_get_user_data(BT_COMMON);
372 retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
375 if (_bt_check_privilege_le(BT_CHECK_PRIVILEGE, BT_L2CAP_LE_CLIENT_CONNECT)
376 == BLUETOOTH_ERROR_PERMISSION_DEINED) {
377 BT_ERR("Don't have a privilege to use this API");
380 l2cap_user_info = g_malloc0(sizeof(bt_l2cap_user_info_t));
381 l2cap_user_info->psm = psm;
382 l2cap_user_info->user_data = user_info->user_data;
383 memcpy(&l2cap_user_info->device_addr, remote_bt_address,
384 sizeof(bluetooth_device_address_t));
387 BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
389 g_array_append_vals(in_param1, remote_bt_address,
390 sizeof(bluetooth_device_address_t));
393 g_array_append_vals(in_param2, &t_psm, sizeof(int));
395 result = _bt_send_request_async_with_unix_fd_list(BT_BLUEZ_SERVICE,
396 BT_L2CAP_LE_CLIENT_CONNECT,
397 in_param1, in_param2,
398 in_param3, in_param4,
399 user_info->cb, (void *)l2cap_user_info,
400 NULL, (GAsyncReadyCallback)__async_req_cb_with_unix_fd_list);
402 BT_INFO("result: %x", result);
404 BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
409 BT_EXPORT_API int bluetooth_l2cap_le_client_is_connected(
410 const bluetooth_device_address_t *device_address, gboolean *connected)
413 char address[BT_ADDRESS_STRING_SIZE] = { 0 };
415 BT_CHECK_PARAMETER(device_address, return);
416 BT_CHECK_PARAMETER(connected, return);
421 _bt_convert_addr_type_to_string(address, (unsigned char *)device_address->addr);
422 BT_INFO("Client address: [%s]", address);
424 for (l = l2cap_le_clients; l != NULL; l = l->next) {
425 l2cap_le_client_conn_info_t *info = l->data;
427 if (info && !strncasecmp(info->remote_addr, address, BT_ADDRESS_STRING_SIZE)) {
428 BT_INFO("Match found");
430 return BLUETOOTH_ERROR_NONE;
435 return BLUETOOTH_ERROR_NONE;
438 BT_EXPORT_API int bluetooth_l2cap_le_disconnect(int socket_fd)
440 l2cap_le_client_conn_info_t *conn_info;
442 BT_INFO_C("<<<<<<<<< L2CAP_LE Disconnect request from app >>>>>>>>");
444 BT_CHECK_ENABLED_ANY(return);
445 retv_if(socket_fd < 0, BLUETOOTH_ERROR_INVALID_PARAM);
447 if (_bt_check_privilege_le(BT_CHECK_PRIVILEGE, BT_L2CAP_LE_SOCKET_DISCONNECT)
448 == BLUETOOTH_ERROR_PERMISSION_DEINED) {
449 BT_ERR("Don't have a privilege to use this API");
452 BT_INFO("FD %d", socket_fd);
454 conn_info = __find_l2cap_le_conn_info_with_fd(socket_fd);
455 if (conn_info == NULL) {
456 BT_INFO("Could not find in client, so check in server");
457 /* Check for fd in server list and perform the disconnection if present */
458 return bluetooth_l2cap_le_server_disconnect(socket_fd);
461 if (conn_info->watch_id <= 0) {
462 BT_ERR("Invalid state");
463 return BLUETOOTH_ERROR_NOT_CONNECTED;
466 close(conn_info->sock_fd);
467 __bt_l2cap_le_client_disconnected(conn_info);
468 __l2cap_le_remove_client_conn_info_t(conn_info);
470 return BLUETOOTH_ERROR_NONE;
473 static int __write_all(int fd, const char *buf, int len)
475 int sent = 0, try = 0;
481 written = write(fd, buf, len);
482 BT_DBG("written: %d, len %d", written, len);
484 if (errno == EINTR || errno == EAGAIN) {
505 BT_EXPORT_API int bluetooth_l2cap_le_write(int fd, const char *buf, int length)
509 BT_CHECK_ENABLED_LE(return);
510 BT_CHECK_PARAMETER(buf, return);
513 BT_ERR("Invalid FD");
514 return BLUETOOTH_ERROR_INVALID_PARAM;
517 retv_if(length <= 0, BLUETOOTH_ERROR_INVALID_PARAM);
519 switch (privilege_token) {
521 result = _bt_check_privilege_le(BT_CHECK_PRIVILEGE, BT_L2CAP_LE_SOCKET_WRITE);
523 if (result == BLUETOOTH_ERROR_NONE) {
524 privilege_token = 1; /* Have a permission */
525 } else if (result == BLUETOOTH_ERROR_PERMISSION_DEINED) {
526 BT_ERR("Don't have a privilege to use this API");
527 privilege_token = -1; /* Don't have a permission */
528 return BLUETOOTH_ERROR_PERMISSION_DEINED;
530 BT_ERR("Some error occurred");
531 /* Just break - It is not related with permission error */
535 /* Already have a privilege */
538 return BLUETOOTH_ERROR_PERMISSION_DEINED;
540 /* Invalid privilge token value */
541 return BLUETOOTH_ERROR_INTERNAL;
544 result = __write_all(fd, buf, length);