bt-api/bt-l2cap-le-client.c

   1 /*
   2  * Copyright (c) 2022 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 #include <gio/gunixfdlist.h>
  20 #include <sys/socket.h>
  21
  22 #include "bluetooth-api.h"
  23 #include "bt-internal-types.h"
  24
  25 #include "bt-common.h"
  26 #include "bt-request-sender.h"
  27 #include "bt-event-handler.h"
  28
  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
  34 */
  35 static int privilege_token;
  36
  37 GSList *l2cap_le_clients;
  38
  39 typedef struct {
  40         int psm;
  41         char *remote_addr;
  42         int sock_fd;
  43         int watch_id;
  44 } l2cap_le_client_conn_info_t;
  45
  46 static gboolean __is_error_by_disconnect(GError *err)
  47 {
  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");
  51 }
  52
  53 static l2cap_le_client_conn_info_t *__find_l2cap_le_conn_info_with_fd(int fd)
  54 {
  55         GSList *l;
  56
  57         BT_DBG("+");
  58
  59         for (l = l2cap_le_clients; l != NULL; l = l->next) {
  60                 l2cap_le_client_conn_info_t *info = l->data;
  61
  62                 if (info && info->sock_fd == fd) {
  63                         BT_INFO("Match found");
  64                         return info;
  65                 }
  66         }
  67
  68         BT_DBG("-");
  69         return NULL;
  70 }
  71
  72 static void __l2cap_le_remove_client_conn_info_t(
  73                                                 l2cap_le_client_conn_info_t *info)
  74 {
  75         ret_if(info == NULL);
  76
  77         l2cap_le_clients = g_slist_remove(l2cap_le_clients, info);
  78         g_free(info->remote_addr);
  79
  80         if (info->sock_fd > 0) {
  81             shutdown(info->sock_fd, SHUT_RDWR);
  82             close(info->sock_fd);
  83         }
  84
  85         if (info->watch_id > 0)
  86                 g_source_remove(info->watch_id);
  87         g_free(info);
  88 }
  89
  90 static void __bt_l2cap_le_client_disconnected(
  91                                                 l2cap_le_client_conn_info_t *conn_info)
  92 {
  93         bluetooth_l2cap_le_disconnection_t disconn_info;
  94         bt_event_info_t *event_info = NULL;
  95
  96         BT_DBG("+");
  97
  98         ret_if(conn_info == NULL);
  99
 100         event_info = _bt_event_get_cb_data(BT_L2CAP_LE_CLIENT_EVENT);
 101         ret_if(event_info == NULL);
 102
 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);
 109
 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);
 116
 117         BT_DBG("-");
 118 }
 119
 120 static gboolean __client_data_received_cb(GIOChannel *chan, GIOCondition cond,
 121                                                 gpointer data)
 122 {
 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;
 126         int fd;
 127         gsize len = 0;
 128         char *buffer;
 129         GError *err = NULL;
 130         GIOStatus status = G_IO_STATUS_NORMAL;
 131         static int resource_unavailable_cnt = 0;
 132
 133         BT_DBG("+");
 134
 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);
 138                 goto fail;
 139         }
 140
 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,
 144                         &len, &err);
 145         if (status != G_IO_STATUS_NORMAL) {
 146                 BT_ERR("IO Channel read is failed with %d", status);
 147                 g_free(buffer);
 148                 if (err) {
 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);
 153                                 g_error_free(err);
 154                                 goto fail;
 155                         }
 156                         g_error_free(err);
 157                 }
 158
 159                 if (status == G_IO_STATUS_ERROR ||
 160                         status == G_IO_STATUS_EOF) {
 161                         goto fail;
 162                 } else if (status == G_IO_STATUS_AGAIN) {
 163                         resource_unavailable_cnt++;
 164                         if (resource_unavailable_cnt > 10)
 165                                 goto fail;
 166                 }
 167
 168                 return TRUE;
 169         }
 170         resource_unavailable_cnt = 0;
 171
 172         if (len == 0) {
 173                 BT_ERR("Length is zero, remote end hang up");
 174                 g_free(buffer);
 175                 goto fail;
 176         }
 177
 178         BT_DBG("fd: %d, len: %zd, buffer: %s", fd, len, buffer);
 179
 180         event_info = _bt_event_get_cb_data(BT_L2CAP_LE_CLIENT_EVENT);
 181         if (event_info == NULL) {
 182                 BT_INFO("event_info == NULL");
 183                 g_free(buffer);
 184                 return TRUE;
 185         }
 186
 187         data_r.socket_fd = fd;
 188         data_r.buffer_size = len;
 189         data_r.buffer = buffer;
 190
 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);
 194
 195         g_free(buffer);
 196         return TRUE;
 197
 198 fail:
 199         conn_info = __find_l2cap_le_conn_info_with_fd(fd);
 200         if (conn_info) {
 201                 BT_INFO("Disconnecting client, fd %d", fd);
 202                 __bt_l2cap_le_client_disconnected(conn_info);
 203                 __l2cap_le_remove_client_conn_info_t(conn_info);
 204         } else {
 205                 BT_ERR("l2cap_le client conn_info not found");
 206         }
 207
 208         BT_DBG("-");
 209         return FALSE;
 210 }
 211
 212 static void __l2cap_le_client_connection_create_watch(
 213                                                 l2cap_le_client_conn_info_t *conn_info)
 214 {
 215         GIOChannel *data_io;
 216
 217         BT_DBG("+");
 218
 219         ret_if(NULL == conn_info);
 220
 221         data_io = g_io_channel_unix_new(conn_info->sock_fd);
 222         g_io_channel_set_encoding(data_io, NULL, NULL);
 223         g_io_channel_set_flags(data_io, G_IO_FLAG_NONBLOCK, NULL);
 224         conn_info->watch_id = g_io_add_watch(data_io,
 225                         G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
 226                         __client_data_received_cb, NULL);
 227         g_io_channel_unref(data_io);
 228
 229         BT_DBG("-");
 230 }
 231
 232 static void __bt_l2cap_le_handle_new_client_connection(
 233                                                 bluetooth_l2cap_le_connection_t *info)
 234 {
 235         l2cap_le_client_conn_info_t *conn_info;
 236
 237         BT_DBG("+");
 238
 239         ret_if(NULL == info);
 240
 241         conn_info = g_malloc0(sizeof(l2cap_le_client_conn_info_t));
 242         conn_info->remote_addr = g_malloc0(BT_ADDRESS_STRING_SIZE);
 243         _bt_convert_addr_type_to_string(
 244                         conn_info->remote_addr, info->device_addr.addr);
 245         conn_info->sock_fd = info->socket_fd;
 246         conn_info->psm = info->psm;
 247
 248         BT_INFO("Address:%s, Socket: %d, psm: %d",
 249                         conn_info->remote_addr, conn_info->sock_fd, conn_info->psm);
 250
 251         l2cap_le_clients = g_slist_append(l2cap_le_clients, conn_info);
 252         __l2cap_le_client_connection_create_watch(conn_info);
 253
 254         BT_DBG("-");
 255 }
 256
 257 static void __async_req_cb_with_unix_fd_list(GDBusProxy *proxy,
 258                                                 GAsyncResult *res, gpointer user_data)
 259 {
 260         int result = BLUETOOTH_ERROR_NONE;
 261         int event_type = BT_LE_ADAPTER_EVENT;
 262         gboolean fail = false;
 263
 264         bt_req_info_t *cb_data = user_data;
 265         bluetooth_event_param_t bt_event;
 266         GArray *out_param1 = NULL;
 267         GUnixFDList *out_fd_list = NULL;
 268         bt_l2cap_user_info_t *l2cap_user_info = NULL;
 269
 270         BT_DBG("+");
 271
 272         if (cb_data)
 273                 l2cap_user_info = (bt_l2cap_user_info_t *)cb_data->user_data;
 274
 275         if (l2cap_user_info)
 276                 cb_data->user_data = (void *)l2cap_user_info->user_data;
 277
 278         _bt_get_fd_list_info(proxy, res, user_data, &bt_event, &out_param1,
 279                 &event_type, &out_fd_list, &result, &fail);
 280
 281         if (fail) {
 282                 BT_INFO("Connection failed due to error: %d", result);
 283                 bluetooth_l2cap_le_connection_t *conn_info;
 284
 285                 conn_info = g_malloc0(sizeof(bluetooth_l2cap_le_connection_t));
 286                 memset(conn_info, 0x00, sizeof(bluetooth_l2cap_le_connection_t));
 287
 288                 conn_info->psm = l2cap_user_info->psm;
 289                 memcpy(&conn_info->device_addr, &l2cap_user_info->device_addr,
 290                         sizeof(bluetooth_device_address_t));
 291
 292                 bt_event.param_data = (void *)conn_info;
 293                 goto failed;
 294         }
 295
 296         if (!cb_data)
 297                 goto done;
 298
 299         if (result == BLUETOOTH_ERROR_NONE && out_param1) {
 300                 if (BT_L2CAP_LE_CLIENT_CONNECT == cb_data->service_function) {
 301                         int *fd_list_array;
 302                         int len = 0;
 303                         bluetooth_l2cap_le_connection_t *conn_info;
 304
 305                         conn_info = (bluetooth_l2cap_le_connection_t *)bt_event.param_data;
 306                         if (!out_fd_list) {
 307                                 BT_ERR("out_fd_list is NULL");
 308                                 goto failed;
 309                         }
 310
 311                         fd_list_array = g_unix_fd_list_steal_fds(out_fd_list, &len);
 312                         BT_INFO("Num fds in fd_list is : %d, fd_list[0]: %d", len, fd_list_array[0]);
 313                         conn_info->socket_fd = fd_list_array[0];
 314
 315                         BT_INFO("conn_info->socket_fd: %d", conn_info->socket_fd);
 316                         __bt_l2cap_le_handle_new_client_connection(conn_info);
 317
 318                         if (cb_data->cb != NULL) {
 319                                 /* Send client connected event */
 320                                 bt_event.result = result;
 321                                 BT_INFO("send client connected event event_type[%d], result=[%d]", event_type, result);
 322                                 ((bluetooth_cb_func_ptr)cb_data->cb)(
 323                                         bt_event.event, &bt_event, cb_data->user_data);
 324                         }
 325
 326                         g_free(fd_list_array);
 327                         g_object_unref(out_fd_list);
 328                 }
 329                 goto done;
 330         }
 331
 332 failed:
 333         if (cb_data->cb == NULL)
 334                 goto done;
 335
 336         /* Only if fail case, call the callback function*/
 337         bt_event.result = result;
 338
 339         BT_INFO("send fail event event_type[%d], result=[%d]", event_type, result);
 340         if (event_type == BT_L2CAP_LE_CLIENT_EVENT) {
 341                 BT_INFO("l2cap_le client event");
 342                 ((bluetooth_cb_func_ptr)cb_data->cb)(bt_event.event,
 343                         &bt_event, cb_data->user_data);
 344         } else {
 345                 BT_INFO("Not handled event type : %d", event_type);
 346         }
 347 done:
 348         if (out_param1)
 349                 g_array_free(out_param1, TRUE);
 350
 351         g_free(l2cap_user_info);
 352         g_free(cb_data);
 353         BT_DBG("-");
 354 }
 355
 356 BT_EXPORT_API int bluetooth_l2cap_le_connect(
 357                 const bluetooth_device_address_t *remote_bt_address, int psm)
 358 {
 359         int result;
 360         bt_user_info_t *user_info;
 361         int t_psm;
 362         bt_l2cap_user_info_t *l2cap_user_info;
 363
 364         BT_CHECK_PARAMETER(remote_bt_address, return);
 365         BT_CHECK_ENABLED_LE(return);
 366
 367         BT_INFO_C("connect l2cap_le psm %d", psm);
 368         user_info = _bt_get_user_data(BT_COMMON);
 369         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
 370
 371
 372         if (_bt_check_privilege_le(BT_CHECK_PRIVILEGE, BT_L2CAP_LE_CLIENT_CONNECT)
 373              == BLUETOOTH_ERROR_PERMISSION_DEINED) {
 374                 BT_ERR("Don't have a privilege to use this API");
 375         }
 376
 377         l2cap_user_info = g_malloc0(sizeof(bt_l2cap_user_info_t));
 378         l2cap_user_info->psm = psm;
 379         l2cap_user_info->user_data = user_info->user_data;
 380         memcpy(&l2cap_user_info->device_addr, remote_bt_address,
 381                         sizeof(bluetooth_device_address_t));
 382
 383         BT_INIT_PARAMS();
 384         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 385
 386         g_array_append_vals(in_param1, remote_bt_address,
 387                                 sizeof(bluetooth_device_address_t));
 388
 389         t_psm = psm;
 390         g_array_append_vals(in_param2, &t_psm, sizeof(int));
 391
 392         result = _bt_send_request_async_with_unix_fd_list(BT_BLUEZ_SERVICE,
 393                                 BT_L2CAP_LE_CLIENT_CONNECT,
 394                                 in_param1, in_param2,
 395                                 in_param3, in_param4,
 396                                 user_info->cb, (void *)l2cap_user_info,
 397                                 NULL, (GAsyncReadyCallback)__async_req_cb_with_unix_fd_list);
 398
 399         BT_INFO("result: %x", result);
 400
 401         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 402
 403         return result;
 404 }
 405
 406 BT_EXPORT_API int bluetooth_l2cap_le_client_is_connected(
 407                 const bluetooth_device_address_t *device_address, gboolean *connected)
 408 {
 409         GSList *l;
 410         char address[BT_ADDRESS_STRING_SIZE] = { 0 };
 411
 412         BT_CHECK_PARAMETER(device_address, return);
 413         BT_CHECK_PARAMETER(connected, return);
 414
 415         BT_DBG("+");
 416
 417         *connected = FALSE;
 418         _bt_convert_addr_type_to_string(address, (unsigned char *)device_address->addr);
 419         BT_INFO("Client address: [%s]", address);
 420
 421         for (l = l2cap_le_clients; l != NULL; l = l->next) {
 422                 l2cap_le_client_conn_info_t *info = l->data;
 423
 424                 if (info && !strncasecmp(info->remote_addr, address, BT_ADDRESS_STRING_SIZE)) {
 425                         BT_INFO("Match found");
 426                         *connected = TRUE;
 427                         return BLUETOOTH_ERROR_NONE;
 428                 }
 429         }
 430
 431         BT_DBG("-");
 432         return BLUETOOTH_ERROR_NONE;
 433 }
 434
 435 BT_EXPORT_API int bluetooth_l2cap_le_disconnect(int socket_fd)
 436 {
 437         l2cap_le_client_conn_info_t *conn_info;
 438
 439         BT_INFO_C("<<<<<<<<< L2CAP_LE Disconnect request from app >>>>>>>>");
 440
 441         BT_CHECK_ENABLED_ANY(return);
 442         retv_if(socket_fd < 0, BLUETOOTH_ERROR_INVALID_PARAM);
 443
 444         if (_bt_check_privilege_le(BT_CHECK_PRIVILEGE, BT_L2CAP_LE_SOCKET_DISCONNECT)
 445                         == BLUETOOTH_ERROR_PERMISSION_DEINED) {
 446                 BT_ERR("Don't have a privilege to use this API");
 447         }
 448
 449         BT_INFO("FD %d", socket_fd);
 450
 451         conn_info = __find_l2cap_le_conn_info_with_fd(socket_fd);
 452         if (conn_info == NULL) {
 453                 BT_INFO("Could not find in client, so check in server");
 454                 /* Check for fd in server list and perform the disconnection if present */
 455                 return bluetooth_l2cap_le_server_disconnect(socket_fd);
 456         }
 457
 458         if (conn_info->watch_id <= 0) {
 459                 BT_ERR("Invalid state");
 460                 return BLUETOOTH_ERROR_NOT_CONNECTED;
 461         }
 462
 463         __bt_l2cap_le_client_disconnected(conn_info);
 464         __l2cap_le_remove_client_conn_info_t(conn_info);
 465
 466         return BLUETOOTH_ERROR_NONE;
 467 }
 468
 469 static int __write_all(int fd, const char *buf, int len)
 470 {
 471         int sent = 0, try = 0;
 472
 473         BT_DBG("+");
 474         while (len > 0) {
 475                 int written;
 476
 477                 written = write(fd, buf, len);
 478                 BT_DBG("written: %d, len %d", written, len);
 479                 if (written < 0) {
 480                         if (errno == EINTR || errno == EAGAIN) {
 481                                 try++;
 482                                 if (try <= 49)
 483                                         continue;
 484                         }
 485                         return -1;
 486                 }
 487
 488                 if (!written)
 489                         return 0;
 490
 491                 len -= written;
 492                 buf += written;
 493                 sent += written;
 494                 try = 0;
 495         }
 496
 497         BT_DBG("-");
 498         return sent;
 499 }
 500
 501 BT_EXPORT_API int bluetooth_l2cap_le_write(int fd, const char *buf, int length)
 502 {
 503         int result;
 504
 505         BT_CHECK_ENABLED_LE(return);
 506         BT_CHECK_PARAMETER(buf, return);
 507
 508         if (fd < 0) {
 509                 BT_ERR("Invalid FD");
 510                 return BLUETOOTH_ERROR_INVALID_PARAM;
 511         }
 512
 513         retv_if(length <= 0, BLUETOOTH_ERROR_INVALID_PARAM);
 514
 515         switch (privilege_token) {
 516         case 0:
 517                 result = _bt_check_privilege_le(BT_CHECK_PRIVILEGE, BT_L2CAP_LE_SOCKET_WRITE);
 518
 519                 if (result == BLUETOOTH_ERROR_NONE) {
 520                         privilege_token = 1; /* Have a permission */
 521                 } else if (result == BLUETOOTH_ERROR_PERMISSION_DEINED) {
 522                         BT_ERR("Don't have a privilege to use this API");
 523                         privilege_token = -1; /* Don't have a permission */
 524                         return BLUETOOTH_ERROR_PERMISSION_DEINED;
 525                 } else {
 526                         BT_ERR("Some error occurred");
 527                         /* Just break - It is not related with permission error */
 528                 }
 529                 break;
 530         case 1:
 531                 /* Already have a privilege */
 532                 break;
 533         case -1:
 534                 return BLUETOOTH_ERROR_PERMISSION_DEINED;
 535         default:
 536                 /* Invalid privilge token value */
 537                 return BLUETOOTH_ERROR_INTERNAL;
 538         }
 539
 540         result = __write_all(fd, buf, length);
 541
 542         return result;
 543 }
 544
 545 BT_EXPORT_API int bluetooth_l2cap_le_get_max_buffer_size(int *size)
 546 {
 547         BT_CHECK_ENABLED_LE(return);
 548         BT_CHECK_PARAMETER(size, return);
 549
 550         *size = BT_L2CAP_LE_BUFFER_LEN;
 551
 552         return BLUETOOTH_ERROR_NONE;
 553 }