| /****************************************************************************** |
| * |
| * Copyright (C) 2009-2012 Broadcom Corporation |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at: |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| ******************************************************************************/ |
| |
| #define LOG_TAG "bt_btif_sock_rfcomm" |
| |
| #include <base/logging.h> |
| #include <errno.h> |
| #include <features.h> |
| #include <pthread.h> |
| #include <string.h> |
| #include <sys/ioctl.h> |
| #include <sys/socket.h> |
| #include <sys/types.h> |
| #include <unistd.h> |
| |
| #include <mutex> |
| |
| #include <hardware/bluetooth.h> |
| #include <hardware/bt_sock.h> |
| |
| #include "bt_common.h" |
| #include "bt_target.h" |
| #include "bta_api.h" |
| #include "bta_jv_api.h" |
| #include "bta_jv_co.h" |
| #include "btif_common.h" |
| #include "btif_sock_sdp.h" |
| #include "btif_sock_thread.h" |
| #include "btif_sock_util.h" |
| #include "btif_uid.h" |
| #include "btif_util.h" |
| #include "btm_api.h" |
| #include "btm_int.h" |
| #include "btu.h" |
| #include "hcimsgs.h" |
| #include "osi/include/compat.h" |
| #include "osi/include/list.h" |
| #include "osi/include/log.h" |
| #include "osi/include/osi.h" |
| #include "port_api.h" |
| #include "sdp_api.h" |
| |
| /* The JV interface can have only one user, hence we need to call a few |
| * L2CAP functions from this file. */ |
| #include "btif_sock_l2cap.h" |
| |
| // Maximum number of RFCOMM channels (1-30 inclusive). |
| #define MAX_RFC_CHANNEL 30 |
| |
| // Maximum number of devices we can have an RFCOMM connection with. |
| #define MAX_RFC_SESSION 7 |
| |
| typedef struct { |
| int outgoing_congest : 1; |
| int pending_sdp_request : 1; |
| int doing_sdp_request : 1; |
| int server : 1; |
| int connected : 1; |
| int closing : 1; |
| } flags_t; |
| |
| typedef struct { |
| flags_t f; |
| uint32_t id; // Non-zero indicates a valid (in-use) slot. |
| int security; |
| int scn; // Server channel number |
| int scn_notified; |
| bt_bdaddr_t addr; |
| int is_service_uuid_valid; |
| uint8_t service_uuid[16]; |
| char service_name[256]; |
| int fd; |
| int app_fd; // Temporary storage for the half of the socketpair that's sent |
| // back to upper layers. |
| int app_uid; // UID of the app for which this socket was created. |
| int mtu; |
| uint8_t* packet; |
| int sdp_handle; |
| int rfc_handle; |
| int rfc_port_handle; |
| int role; |
| list_t* incoming_queue; |
| } rfc_slot_t; |
| |
| static rfc_slot_t rfc_slots[MAX_RFC_CHANNEL]; |
| static uint32_t rfc_slot_id; |
| static volatile int pth = -1; // poll thread handle |
| static std::recursive_mutex slot_lock; |
| static uid_set_t* uid_set = NULL; |
| |
| static rfc_slot_t* find_free_slot(void); |
| static void cleanup_rfc_slot(rfc_slot_t* rs); |
| static void jv_dm_cback(tBTA_JV_EVT event, tBTA_JV* p_data, uint32_t id); |
| static uint32_t rfcomm_cback(tBTA_JV_EVT event, tBTA_JV* p_data, |
| uint32_t rfcomm_slot_id); |
| static bool send_app_scn(rfc_slot_t* rs); |
| |
| static bool is_init_done(void) { return pth != -1; } |
| |
| bt_status_t btsock_rfc_init(int poll_thread_handle, uid_set_t* set) { |
| pth = poll_thread_handle; |
| uid_set = set; |
| |
| memset(rfc_slots, 0, sizeof(rfc_slots)); |
| for (size_t i = 0; i < ARRAY_SIZE(rfc_slots); ++i) { |
| rfc_slots[i].scn = -1; |
| rfc_slots[i].sdp_handle = 0; |
| rfc_slots[i].fd = INVALID_FD; |
| rfc_slots[i].app_fd = INVALID_FD; |
| rfc_slots[i].incoming_queue = list_new(osi_free); |
| CHECK(rfc_slots[i].incoming_queue != NULL); |
| } |
| |
| BTA_JvEnable(jv_dm_cback); |
| |
| return BT_STATUS_SUCCESS; |
| } |
| |
| void btsock_rfc_cleanup(void) { |
| pth = -1; |
| uid_set = NULL; |
| |
| BTA_JvDisable(); |
| |
| std::unique_lock<std::recursive_mutex> lock(slot_lock); |
| for (size_t i = 0; i < ARRAY_SIZE(rfc_slots); ++i) { |
| if (rfc_slots[i].id) cleanup_rfc_slot(&rfc_slots[i]); |
| list_free(rfc_slots[i].incoming_queue); |
| rfc_slots[i].incoming_queue = NULL; |
| } |
| } |
| |
| static rfc_slot_t* find_free_slot(void) { |
| for (size_t i = 0; i < ARRAY_SIZE(rfc_slots); ++i) |
| if (rfc_slots[i].fd == INVALID_FD) return &rfc_slots[i]; |
| return NULL; |
| } |
| |
| static rfc_slot_t* find_rfc_slot_by_id(uint32_t id) { |
| CHECK(id != 0); |
| |
| for (size_t i = 0; i < ARRAY_SIZE(rfc_slots); ++i) |
| if (rfc_slots[i].id == id) return &rfc_slots[i]; |
| |
| LOG_ERROR(LOG_TAG, "%s unable to find RFCOMM slot id: %d", __func__, id); |
| return NULL; |
| } |
| |
| static rfc_slot_t* find_rfc_slot_by_pending_sdp(void) { |
| uint32_t min_id = UINT32_MAX; |
| int slot = -1; |
| for (size_t i = 0; i < ARRAY_SIZE(rfc_slots); ++i) |
| if (rfc_slots[i].id && rfc_slots[i].f.pending_sdp_request && |
| rfc_slots[i].id < min_id) { |
| min_id = rfc_slots[i].id; |
| slot = i; |
| } |
| |
| return (slot == -1) ? NULL : &rfc_slots[slot]; |
| } |
| |
| static bool is_requesting_sdp(void) { |
| for (size_t i = 0; i < ARRAY_SIZE(rfc_slots); ++i) |
| if (rfc_slots[i].id && rfc_slots[i].f.doing_sdp_request) return true; |
| return false; |
| } |
| |
| static rfc_slot_t* alloc_rfc_slot(const bt_bdaddr_t* addr, const char* name, |
| const uint8_t* uuid, int channel, int flags, |
| bool server) { |
| int security = 0; |
| if (flags & BTSOCK_FLAG_ENCRYPT) |
| security |= server ? BTM_SEC_IN_ENCRYPT : BTM_SEC_OUT_ENCRYPT; |
| if (flags & BTSOCK_FLAG_AUTH) |
| security |= server ? BTM_SEC_IN_AUTHENTICATE : BTM_SEC_OUT_AUTHENTICATE; |
| if (flags & BTSOCK_FLAG_AUTH_MITM) |
| security |= server ? BTM_SEC_IN_MITM : BTM_SEC_OUT_MITM; |
| if (flags & BTSOCK_FLAG_AUTH_16_DIGIT) |
| security |= BTM_SEC_IN_MIN_16_DIGIT_PIN; |
| |
| rfc_slot_t* slot = find_free_slot(); |
| if (!slot) { |
| LOG_ERROR(LOG_TAG, "%s unable to find free RFCOMM slot.", __func__); |
| return NULL; |
| } |
| |
| int fds[2] = {INVALID_FD, INVALID_FD}; |
| if (socketpair(AF_LOCAL, SOCK_STREAM, 0, fds) == -1) { |
| LOG_ERROR(LOG_TAG, "%s error creating socketpair: %s", __func__, |
| strerror(errno)); |
| return NULL; |
| } |
| |
| // Increment slot id and make sure we don't use id=0. |
| if (++rfc_slot_id == 0) rfc_slot_id = 1; |
| |
| slot->fd = fds[0]; |
| slot->app_fd = fds[1]; |
| slot->security = security; |
| slot->scn = channel; |
| slot->app_uid = -1; |
| |
| if (!is_uuid_empty(uuid)) { |
| memcpy(slot->service_uuid, uuid, sizeof(slot->service_uuid)); |
| slot->is_service_uuid_valid = true; |
| } else { |
| memset(slot->service_uuid, 0, sizeof(slot->service_uuid)); |
| slot->is_service_uuid_valid = false; |
| } |
| if (name && *name) { |
| strlcpy(slot->service_name, name, sizeof(slot->service_name)); |
| } else { |
| memset(slot->service_name, 0, sizeof(slot->service_name)); |
| } |
| if (addr) slot->addr = *addr; |
| |
| slot->id = rfc_slot_id; |
| slot->f.server = server; |
| |
| return slot; |
| } |
| |
| static rfc_slot_t* create_srv_accept_rfc_slot(rfc_slot_t* srv_rs, |
| const bt_bdaddr_t* addr, |
| int open_handle, |
| int new_listen_handle) { |
| rfc_slot_t* accept_rs = alloc_rfc_slot( |
| addr, srv_rs->service_name, srv_rs->service_uuid, srv_rs->scn, 0, false); |
| if (!accept_rs) { |
| LOG_ERROR(LOG_TAG, "%s unable to allocate RFCOMM slot.", __func__); |
| return NULL; |
| } |
| |
| accept_rs->f.server = false; |
| accept_rs->f.connected = true; |
| accept_rs->security = srv_rs->security; |
| accept_rs->mtu = srv_rs->mtu; |
| accept_rs->role = srv_rs->role; |
| accept_rs->rfc_handle = open_handle; |
| accept_rs->rfc_port_handle = BTA_JvRfcommGetPortHdl(open_handle); |
| accept_rs->app_uid = srv_rs->app_uid; |
| |
| srv_rs->rfc_handle = new_listen_handle; |
| srv_rs->rfc_port_handle = BTA_JvRfcommGetPortHdl(new_listen_handle); |
| |
| CHECK(accept_rs->rfc_port_handle != srv_rs->rfc_port_handle); |
| |
| // now swap the slot id |
| uint32_t new_listen_id = accept_rs->id; |
| accept_rs->id = srv_rs->id; |
| srv_rs->id = new_listen_id; |
| |
| return accept_rs; |
| } |
| |
| bt_status_t btsock_rfc_listen(const char* service_name, |
| const uint8_t* service_uuid, int channel, |
| int* sock_fd, int flags, int app_uid) { |
| CHECK(sock_fd != NULL); |
| CHECK((service_uuid != NULL) || |
| (channel >= 1 && channel <= MAX_RFC_CHANNEL) || |
| ((flags & BTSOCK_FLAG_NO_SDP) != 0)); |
| |
| *sock_fd = INVALID_FD; |
| |
| // TODO(sharvil): not sure that this check makes sense; seems like a logic |
| // error to call |
| // functions on RFCOMM sockets before initializing the module. Probably should |
| // be an assert. |
| if (!is_init_done()) return BT_STATUS_NOT_READY; |
| |
| if ((flags & BTSOCK_FLAG_NO_SDP) == 0) { |
| if (is_uuid_empty(service_uuid)) { |
| APPL_TRACE_DEBUG( |
| "BTA_JvGetChannelId: service_uuid not set AND " |
| "BTSOCK_FLAG_NO_SDP is not set - changing to SPP"); |
| service_uuid = |
| UUID_SPP; // Use serial port profile to listen to specified channel |
| } else { |
| // Check the service_uuid. overwrite the channel # if reserved |
| int reserved_channel = get_reserved_rfc_channel(service_uuid); |
| if (reserved_channel > 0) { |
| channel = reserved_channel; |
| } |
| } |
| } |
| |
| std::unique_lock<std::recursive_mutex> lock(slot_lock); |
| |
| rfc_slot_t* slot = |
| alloc_rfc_slot(NULL, service_name, service_uuid, channel, flags, true); |
| if (!slot) { |
| LOG_ERROR(LOG_TAG, "%s unable to allocate RFCOMM slot.", __func__); |
| return BT_STATUS_FAIL; |
| } |
| APPL_TRACE_DEBUG("BTA_JvGetChannelId: service_name: %s - channel: %d", |
| service_name, channel); |
| BTA_JvGetChannelId(BTA_JV_CONN_TYPE_RFCOMM, slot->id, channel); |
| *sock_fd = slot->app_fd; // Transfer ownership of fd to caller. |
| /*TODO: |
| * We are leaking one of the app_fd's - either the listen socket, or the |
| connection socket. |
| * WE need to close this in native, as the FD might belong to another process |
| - This is the server socket FD |
| - For accepted connections, we close the FD after passing it to JAVA. |
| - Try to simply remove the = -1 to free the FD at rs cleanup.*/ |
| // close(rs->app_fd); |
| slot->app_fd = INVALID_FD; // Drop our reference to the fd. |
| slot->app_uid = app_uid; |
| btsock_thread_add_fd(pth, slot->fd, BTSOCK_RFCOMM, SOCK_THREAD_FD_EXCEPTION, |
| slot->id); |
| |
| return BT_STATUS_SUCCESS; |
| } |
| |
| bt_status_t btsock_rfc_connect(const bt_bdaddr_t* bd_addr, |
| const uint8_t* service_uuid, int channel, |
| int* sock_fd, int flags, int app_uid) { |
| CHECK(sock_fd != NULL); |
| CHECK(service_uuid != NULL || (channel >= 1 && channel <= MAX_RFC_CHANNEL)); |
| |
| *sock_fd = INVALID_FD; |
| |
| // TODO(sharvil): not sure that this check makes sense; seems like a logic |
| // error to call |
| // functions on RFCOMM sockets before initializing the module. Probably should |
| // be an assert. |
| if (!is_init_done()) return BT_STATUS_NOT_READY; |
| |
| std::unique_lock<std::recursive_mutex> lock(slot_lock); |
| |
| rfc_slot_t* slot = |
| alloc_rfc_slot(bd_addr, NULL, service_uuid, channel, flags, false); |
| if (!slot) { |
| LOG_ERROR(LOG_TAG, "%s unable to allocate RFCOMM slot.", __func__); |
| return BT_STATUS_FAIL; |
| } |
| |
| if (is_uuid_empty(service_uuid)) { |
| tBTA_JV_STATUS ret = |
| BTA_JvRfcommConnect(slot->security, slot->role, slot->scn, |
| slot->addr.address, rfcomm_cback, slot->id); |
| if (ret != BTA_JV_SUCCESS) { |
| LOG_ERROR(LOG_TAG, "%s unable to initiate RFCOMM connection: %d", |
| __func__, ret); |
| cleanup_rfc_slot(slot); |
| return BT_STATUS_FAIL; |
| } |
| |
| if (!send_app_scn(slot)) { |
| LOG_ERROR(LOG_TAG, "%s unable to send channel number.", __func__); |
| cleanup_rfc_slot(slot); |
| return BT_STATUS_FAIL; |
| } |
| } else { |
| tSDP_UUID sdp_uuid; |
| sdp_uuid.len = 16; |
| memcpy(sdp_uuid.uu.uuid128, service_uuid, sizeof(sdp_uuid.uu.uuid128)); |
| |
| if (!is_requesting_sdp()) { |
| BTA_JvStartDiscovery((uint8_t*)bd_addr->address, 1, &sdp_uuid, slot->id); |
| slot->f.pending_sdp_request = false; |
| slot->f.doing_sdp_request = true; |
| } else { |
| slot->f.pending_sdp_request = true; |
| slot->f.doing_sdp_request = false; |
| } |
| } |
| |
| *sock_fd = slot->app_fd; // Transfer ownership of fd to caller. |
| slot->app_fd = INVALID_FD; // Drop our reference to the fd. |
| slot->app_uid = app_uid; |
| btsock_thread_add_fd(pth, slot->fd, BTSOCK_RFCOMM, SOCK_THREAD_FD_RD, |
| slot->id); |
| |
| return BT_STATUS_SUCCESS; |
| } |
| |
| static int create_server_sdp_record(rfc_slot_t* slot) { |
| if (slot->scn == 0) { |
| return false; |
| } |
| slot->sdp_handle = |
| add_rfc_sdp_rec(slot->service_name, slot->service_uuid, slot->scn); |
| return (slot->sdp_handle > 0); |
| } |
| |
| static void free_rfc_slot_scn(rfc_slot_t* slot) { |
| if (slot->scn <= 0) return; |
| |
| if (slot->f.server && !slot->f.closing && slot->rfc_handle) { |
| BTA_JvRfcommStopServer(slot->rfc_handle, slot->id); |
| slot->rfc_handle = 0; |
| } |
| |
| if (slot->f.server) BTM_FreeSCN(slot->scn); |
| slot->scn = 0; |
| } |
| |
| static void cleanup_rfc_slot(rfc_slot_t* slot) { |
| if (slot->fd != INVALID_FD) { |
| shutdown(slot->fd, SHUT_RDWR); |
| close(slot->fd); |
| slot->fd = INVALID_FD; |
| } |
| |
| if (slot->app_fd != INVALID_FD) { |
| close(slot->app_fd); |
| slot->app_fd = INVALID_FD; |
| } |
| |
| if (slot->sdp_handle > 0) { |
| del_rfc_sdp_rec(slot->sdp_handle); |
| slot->sdp_handle = 0; |
| } |
| |
| if (slot->rfc_handle && !slot->f.closing && !slot->f.server) { |
| BTA_JvRfcommClose(slot->rfc_handle, slot->id); |
| slot->rfc_handle = 0; |
| } |
| |
| free_rfc_slot_scn(slot); |
| list_clear(slot->incoming_queue); |
| |
| slot->rfc_port_handle = 0; |
| memset(&slot->f, 0, sizeof(slot->f)); |
| slot->id = 0; |
| slot->scn_notified = false; |
| } |
| |
| static bool send_app_scn(rfc_slot_t* slot) { |
| if (slot->scn_notified == true) { |
| // already send, just return success. |
| return true; |
| } |
| slot->scn_notified = true; |
| return sock_send_all(slot->fd, (const uint8_t*)&slot->scn, |
| sizeof(slot->scn)) == sizeof(slot->scn); |
| } |
| |
| static bool send_app_connect_signal(int fd, const bt_bdaddr_t* addr, |
| int channel, int status, int send_fd) { |
| sock_connect_signal_t cs; |
| cs.size = sizeof(cs); |
| cs.bd_addr = *addr; |
| cs.channel = channel; |
| cs.status = status; |
| cs.max_rx_packet_size = 0; // not used for RFCOMM |
| cs.max_tx_packet_size = 0; // not used for RFCOMM |
| if (send_fd == INVALID_FD) |
| return sock_send_all(fd, (const uint8_t*)&cs, sizeof(cs)) == sizeof(cs); |
| |
| return sock_send_fd(fd, (const uint8_t*)&cs, sizeof(cs), send_fd) == |
| sizeof(cs); |
| } |
| |
| static void on_cl_rfc_init(tBTA_JV_RFCOMM_CL_INIT* p_init, uint32_t id) { |
| std::unique_lock<std::recursive_mutex> lock(slot_lock); |
| rfc_slot_t* slot = find_rfc_slot_by_id(id); |
| if (!slot) return; |
| |
| if (p_init->status == BTA_JV_SUCCESS) { |
| slot->rfc_handle = p_init->handle; |
| } else { |
| cleanup_rfc_slot(slot); |
| } |
| } |
| |
| static void on_srv_rfc_listen_started(tBTA_JV_RFCOMM_START* p_start, |
| uint32_t id) { |
| std::unique_lock<std::recursive_mutex> lock(slot_lock); |
| rfc_slot_t* slot = find_rfc_slot_by_id(id); |
| if (!slot) return; |
| |
| if (p_start->status == BTA_JV_SUCCESS) { |
| slot->rfc_handle = p_start->handle; |
| } else { |
| cleanup_rfc_slot(slot); |
| } |
| } |
| |
| static uint32_t on_srv_rfc_connect(tBTA_JV_RFCOMM_SRV_OPEN* p_open, |
| uint32_t id) { |
| std::unique_lock<std::recursive_mutex> lock(slot_lock); |
| rfc_slot_t* accept_rs; |
| rfc_slot_t* srv_rs = find_rfc_slot_by_id(id); |
| if (!srv_rs) return 0; |
| |
| accept_rs = |
| create_srv_accept_rfc_slot(srv_rs, (const bt_bdaddr_t*)p_open->rem_bda, |
| p_open->handle, p_open->new_listen_handle); |
| if (!accept_rs) return 0; |
| |
| // Start monitoring the socket. |
| btsock_thread_add_fd(pth, srv_rs->fd, BTSOCK_RFCOMM, SOCK_THREAD_FD_EXCEPTION, |
| srv_rs->id); |
| btsock_thread_add_fd(pth, accept_rs->fd, BTSOCK_RFCOMM, SOCK_THREAD_FD_RD, |
| accept_rs->id); |
| send_app_connect_signal(srv_rs->fd, &accept_rs->addr, srv_rs->scn, 0, |
| accept_rs->app_fd); |
| accept_rs->app_fd = |
| INVALID_FD; // Ownership of the application fd has been transferred. |
| return srv_rs->id; |
| } |
| |
| static void on_cli_rfc_connect(tBTA_JV_RFCOMM_OPEN* p_open, uint32_t id) { |
| std::unique_lock<std::recursive_mutex> lock(slot_lock); |
| rfc_slot_t* slot = find_rfc_slot_by_id(id); |
| if (!slot) return; |
| |
| if (p_open->status != BTA_JV_SUCCESS) { |
| cleanup_rfc_slot(slot); |
| return; |
| } |
| |
| slot->rfc_port_handle = BTA_JvRfcommGetPortHdl(p_open->handle); |
| memcpy(slot->addr.address, p_open->rem_bda, 6); |
| |
| if (send_app_connect_signal(slot->fd, &slot->addr, slot->scn, 0, -1)) { |
| slot->f.connected = true; |
| } else { |
| LOG_ERROR(LOG_TAG, "%s unable to send connect completion signal to caller.", |
| __func__); |
| } |
| } |
| |
| static void on_rfc_close(UNUSED_ATTR tBTA_JV_RFCOMM_CLOSE* p_close, |
| uint32_t id) { |
| std::unique_lock<std::recursive_mutex> lock(slot_lock); |
| |
| // rfc_handle already closed when receiving rfcomm close event from stack. |
| rfc_slot_t* slot = find_rfc_slot_by_id(id); |
| if (slot) cleanup_rfc_slot(slot); |
| } |
| |
| static void on_rfc_write_done(tBTA_JV_RFCOMM_WRITE* p, uint32_t id) { |
| if (p->status != BTA_JV_SUCCESS) { |
| LOG_ERROR(LOG_TAG, "%s error writing to RFCOMM socket with slot %u.", |
| __func__, p->req_id); |
| return; |
| } |
| |
| int app_uid = -1; |
| std::unique_lock<std::recursive_mutex> lock(slot_lock); |
| |
| rfc_slot_t* slot = find_rfc_slot_by_id(id); |
| if (slot) { |
| app_uid = slot->app_uid; |
| if (!slot->f.outgoing_congest) { |
| btsock_thread_add_fd(pth, slot->fd, BTSOCK_RFCOMM, SOCK_THREAD_FD_RD, |
| slot->id); |
| } |
| } |
| |
| uid_set_add_tx(uid_set, app_uid, p->len); |
| } |
| |
| static void on_rfc_outgoing_congest(tBTA_JV_RFCOMM_CONG* p, uint32_t id) { |
| std::unique_lock<std::recursive_mutex> lock(slot_lock); |
| |
| rfc_slot_t* slot = find_rfc_slot_by_id(id); |
| if (slot) { |
| slot->f.outgoing_congest = p->cong ? 1 : 0; |
| if (!slot->f.outgoing_congest) |
| btsock_thread_add_fd(pth, slot->fd, BTSOCK_RFCOMM, SOCK_THREAD_FD_RD, |
| slot->id); |
| } |
| } |
| |
| static uint32_t rfcomm_cback(tBTA_JV_EVT event, tBTA_JV* p_data, |
| uint32_t rfcomm_slot_id) { |
| uint32_t id = 0; |
| |
| switch (event) { |
| case BTA_JV_RFCOMM_START_EVT: |
| on_srv_rfc_listen_started(&p_data->rfc_start, rfcomm_slot_id); |
| break; |
| |
| case BTA_JV_RFCOMM_CL_INIT_EVT: |
| on_cl_rfc_init(&p_data->rfc_cl_init, rfcomm_slot_id); |
| break; |
| |
| case BTA_JV_RFCOMM_OPEN_EVT: |
| BTA_JvSetPmProfile(p_data->rfc_open.handle, BTA_JV_PM_ID_1, |
| BTA_JV_CONN_OPEN); |
| on_cli_rfc_connect(&p_data->rfc_open, rfcomm_slot_id); |
| break; |
| |
| case BTA_JV_RFCOMM_SRV_OPEN_EVT: |
| BTA_JvSetPmProfile(p_data->rfc_srv_open.handle, BTA_JV_PM_ALL, |
| BTA_JV_CONN_OPEN); |
| id = on_srv_rfc_connect(&p_data->rfc_srv_open, rfcomm_slot_id); |
| break; |
| |
| case BTA_JV_RFCOMM_CLOSE_EVT: |
| APPL_TRACE_DEBUG("BTA_JV_RFCOMM_CLOSE_EVT: rfcomm_slot_id:%d", |
| rfcomm_slot_id); |
| on_rfc_close(&p_data->rfc_close, rfcomm_slot_id); |
| break; |
| |
| case BTA_JV_RFCOMM_WRITE_EVT: |
| on_rfc_write_done(&p_data->rfc_write, rfcomm_slot_id); |
| break; |
| |
| case BTA_JV_RFCOMM_CONG_EVT: |
| on_rfc_outgoing_congest(&p_data->rfc_cong, rfcomm_slot_id); |
| break; |
| |
| case BTA_JV_RFCOMM_DATA_IND_EVT: |
| // Unused. |
| break; |
| |
| default: |
| LOG_ERROR(LOG_TAG, "%s unhandled event %d, slot id: %zi", __func__, event, |
| rfcomm_slot_id); |
| break; |
| } |
| return id; |
| } |
| |
| static void jv_dm_cback(tBTA_JV_EVT event, tBTA_JV* p_data, uint32_t id) { |
| switch (event) { |
| case BTA_JV_GET_SCN_EVT: { |
| std::unique_lock<std::recursive_mutex> lock(slot_lock); |
| rfc_slot_t* rs = find_rfc_slot_by_id(id); |
| int new_scn = p_data->scn; |
| |
| if (rs && (new_scn != 0)) { |
| rs->scn = new_scn; |
| /* BTA_JvCreateRecordByUser will only create a record if a UUID is |
| * specified, |
| * else it just allocate a RFC channel and start the RFCOMM thread - |
| * needed |
| * for the java |
| * layer to get a RFCOMM channel. |
| * If uuid is null the create_sdp_record() will be called from Java when |
| * it |
| * has received the RFCOMM and L2CAP channel numbers through the |
| * sockets.*/ |
| |
| // Send channel ID to java layer |
| if (!send_app_scn(rs)) { |
| // closed |
| APPL_TRACE_DEBUG("send_app_scn() failed, close rs->id:%d", rs->id); |
| cleanup_rfc_slot(rs); |
| } else { |
| if (rs->is_service_uuid_valid == true) { |
| // We already have data for SDP record, create it (RFC-only |
| // profiles) |
| BTA_JvCreateRecordByUser(rs->id); |
| } else { |
| APPL_TRACE_DEBUG( |
| "is_service_uuid_valid==false - don't set SDP-record, " |
| "just start the RFCOMM server", |
| rs->id); |
| // now start the rfcomm server after sdp & channel # assigned |
| BTA_JvRfcommStartServer(rs->security, rs->role, rs->scn, |
| MAX_RFC_SESSION, rfcomm_cback, rs->id); |
| } |
| } |
| } else if (rs) { |
| APPL_TRACE_ERROR( |
| "jv_dm_cback: Error: allocate channel %d, slot found:%p", rs->scn, |
| rs); |
| cleanup_rfc_slot(rs); |
| } |
| break; |
| } |
| case BTA_JV_GET_PSM_EVT: { |
| APPL_TRACE_DEBUG("Received PSM: 0x%04x", p_data->psm); |
| on_l2cap_psm_assigned(id, p_data->psm); |
| break; |
| } |
| case BTA_JV_CREATE_RECORD_EVT: { |
| std::unique_lock<std::recursive_mutex> lock(slot_lock); |
| rfc_slot_t* slot = find_rfc_slot_by_id(id); |
| |
| if (slot && create_server_sdp_record(slot)) { |
| // Start the rfcomm server after sdp & channel # assigned. |
| BTA_JvRfcommStartServer(slot->security, slot->role, slot->scn, |
| MAX_RFC_SESSION, rfcomm_cback, slot->id); |
| } else if (slot) { |
| APPL_TRACE_ERROR("jv_dm_cback: cannot start server, slot found:%p", |
| slot); |
| cleanup_rfc_slot(slot); |
| } |
| break; |
| } |
| |
| case BTA_JV_DISCOVERY_COMP_EVT: { |
| std::unique_lock<std::recursive_mutex> lock(slot_lock); |
| rfc_slot_t* slot = find_rfc_slot_by_id(id); |
| if (p_data->disc_comp.status == BTA_JV_SUCCESS && p_data->disc_comp.scn) { |
| if (slot && slot->f.doing_sdp_request) { |
| // Establish the connection if we successfully looked up a channel |
| // number to connect to. |
| if (BTA_JvRfcommConnect(slot->security, slot->role, |
| p_data->disc_comp.scn, slot->addr.address, |
| rfcomm_cback, slot->id) == BTA_JV_SUCCESS) { |
| slot->scn = p_data->disc_comp.scn; |
| slot->f.doing_sdp_request = false; |
| if (!send_app_scn(slot)) cleanup_rfc_slot(slot); |
| } else { |
| cleanup_rfc_slot(slot); |
| } |
| } else if (slot) { |
| // TODO(sharvil): this is really a logic error and we should probably |
| // assert. |
| LOG_ERROR(LOG_TAG, |
| "%s SDP response returned but RFCOMM slot %d did not " |
| "request SDP record.", |
| __func__, id); |
| } |
| } else if (slot) { |
| cleanup_rfc_slot(slot); |
| } |
| |
| // Find the next slot that needs to perform an SDP request and service it. |
| slot = find_rfc_slot_by_pending_sdp(); |
| if (slot) { |
| tSDP_UUID sdp_uuid; |
| sdp_uuid.len = 16; |
| memcpy(sdp_uuid.uu.uuid128, slot->service_uuid, |
| sizeof(sdp_uuid.uu.uuid128)); |
| BTA_JvStartDiscovery((uint8_t*)slot->addr.address, 1, &sdp_uuid, |
| slot->id); |
| slot->f.pending_sdp_request = false; |
| slot->f.doing_sdp_request = true; |
| } |
| break; |
| } |
| |
| default: |
| APPL_TRACE_DEBUG("unhandled event:%d, slot id:%d", event, id); |
| break; |
| } |
| } |
| |
| typedef enum { |
| SENT_FAILED, |
| SENT_NONE, |
| SENT_PARTIAL, |
| SENT_ALL, |
| } sent_status_t; |
| |
| static sent_status_t send_data_to_app(int fd, BT_HDR* p_buf) { |
| if (p_buf->len == 0) return SENT_ALL; |
| |
| ssize_t sent; |
| OSI_NO_INTR( |
| sent = send(fd, p_buf->data + p_buf->offset, p_buf->len, MSG_DONTWAIT)); |
| |
| if (sent == -1) { |
| if (errno == EAGAIN || errno == EWOULDBLOCK) return SENT_NONE; |
| LOG_ERROR(LOG_TAG, "%s error writing RFCOMM data back to app: %s", __func__, |
| strerror(errno)); |
| return SENT_FAILED; |
| } |
| |
| if (sent == 0) return SENT_FAILED; |
| |
| if (sent == p_buf->len) return SENT_ALL; |
| |
| p_buf->offset += sent; |
| p_buf->len -= sent; |
| return SENT_PARTIAL; |
| } |
| |
| static bool flush_incoming_que_on_wr_signal(rfc_slot_t* slot) { |
| while (!list_is_empty(slot->incoming_queue)) { |
| BT_HDR* p_buf = (BT_HDR*)list_front(slot->incoming_queue); |
| switch (send_data_to_app(slot->fd, p_buf)) { |
| case SENT_NONE: |
| case SENT_PARTIAL: |
| // monitor the fd to get callback when app is ready to receive data |
| btsock_thread_add_fd(pth, slot->fd, BTSOCK_RFCOMM, SOCK_THREAD_FD_WR, |
| slot->id); |
| return true; |
| |
| case SENT_ALL: |
| list_remove(slot->incoming_queue, p_buf); |
| break; |
| |
| case SENT_FAILED: |
| list_remove(slot->incoming_queue, p_buf); |
| return false; |
| } |
| } |
| |
| // app is ready to receive data, tell stack to start the data flow |
| // fix me: need a jv flow control api to serialize the call in stack |
| APPL_TRACE_DEBUG( |
| "enable data flow, rfc_handle:0x%x, rfc_port_handle:0x%x, user_id:%d", |
| slot->rfc_handle, slot->rfc_port_handle, slot->id); |
| PORT_FlowControl_MaxCredit(slot->rfc_port_handle, true); |
| return true; |
| } |
| |
| void btsock_rfc_signaled(UNUSED_ATTR int fd, int flags, uint32_t user_id) { |
| bool need_close = false; |
| std::unique_lock<std::recursive_mutex> lock(slot_lock); |
| rfc_slot_t* slot = find_rfc_slot_by_id(user_id); |
| if (!slot) return; |
| |
| // Data available from app, tell stack we have outgoing data. |
| if (flags & SOCK_THREAD_FD_RD && !slot->f.server) { |
| if (slot->f.connected) { |
| // Make sure there's data pending in case the peer closed the socket. |
| int size = 0; |
| if (!(flags & SOCK_THREAD_FD_EXCEPTION) || |
| (ioctl(slot->fd, FIONREAD, &size) == 0 && size)) { |
| BTA_JvRfcommWrite(slot->rfc_handle, slot->id); |
| } |
| } else { |
| LOG_ERROR(LOG_TAG, |
| "%s socket signaled for read while disconnected, slot: %d, " |
| "channel: %d", |
| __func__, slot->id, slot->scn); |
| need_close = true; |
| } |
| } |
| |
| if (flags & SOCK_THREAD_FD_WR) { |
| // App is ready to receive more data, tell stack to enable data flow. |
| if (!slot->f.connected || !flush_incoming_que_on_wr_signal(slot)) { |
| LOG_ERROR(LOG_TAG, |
| "%s socket signaled for write while disconnected (or write " |
| "failure), slot: %d, channel: %d", |
| __func__, slot->id, slot->scn); |
| need_close = true; |
| } |
| } |
| |
| if (need_close || (flags & SOCK_THREAD_FD_EXCEPTION)) { |
| // Clean up if there's no data pending. |
| int size = 0; |
| if (need_close || ioctl(slot->fd, FIONREAD, &size) != 0 || !size) |
| cleanup_rfc_slot(slot); |
| } |
| } |
| |
| int bta_co_rfc_data_incoming(uint32_t id, BT_HDR* p_buf) { |
| int app_uid = -1; |
| uint64_t bytes_rx = 0; |
| int ret = 0; |
| std::unique_lock<std::recursive_mutex> lock(slot_lock); |
| rfc_slot_t* slot = find_rfc_slot_by_id(id); |
| if (!slot) return 0; |
| |
| app_uid = slot->app_uid; |
| bytes_rx = p_buf->len; |
| |
| if (list_is_empty(slot->incoming_queue)) { |
| switch (send_data_to_app(slot->fd, p_buf)) { |
| case SENT_NONE: |
| case SENT_PARTIAL: |
| list_append(slot->incoming_queue, p_buf); |
| btsock_thread_add_fd(pth, slot->fd, BTSOCK_RFCOMM, SOCK_THREAD_FD_WR, |
| slot->id); |
| break; |
| |
| case SENT_ALL: |
| osi_free(p_buf); |
| ret = 1; // Enable data flow. |
| break; |
| |
| case SENT_FAILED: |
| osi_free(p_buf); |
| cleanup_rfc_slot(slot); |
| break; |
| } |
| } else { |
| list_append(slot->incoming_queue, p_buf); |
| } |
| |
| uid_set_add_rx(uid_set, app_uid, bytes_rx); |
| |
| return ret; // Return 0 to disable data flow. |
| } |
| |
| int bta_co_rfc_data_outgoing_size(uint32_t id, int* size) { |
| *size = 0; |
| std::unique_lock<std::recursive_mutex> lock(slot_lock); |
| rfc_slot_t* slot = find_rfc_slot_by_id(id); |
| if (!slot) return false; |
| |
| if (ioctl(slot->fd, FIONREAD, size) != 0) { |
| LOG_ERROR(LOG_TAG, |
| "%s unable to determine bytes remaining to be read on fd %d: %s", |
| __func__, slot->fd, strerror(errno)); |
| cleanup_rfc_slot(slot); |
| return false; |
| } |
| |
| return true; |
| } |
| |
| int bta_co_rfc_data_outgoing(uint32_t id, uint8_t* buf, uint16_t size) { |
| std::unique_lock<std::recursive_mutex> lock(slot_lock); |
| rfc_slot_t* slot = find_rfc_slot_by_id(id); |
| if (!slot) return false; |
| |
| ssize_t received; |
| OSI_NO_INTR(received = recv(slot->fd, buf, size, 0)); |
| |
| if (received != size) { |
| LOG_ERROR(LOG_TAG, "%s error receiving RFCOMM data from app: %s", __func__, |
| strerror(errno)); |
| cleanup_rfc_slot(slot); |
| return false; |
| } |
| |
| return true; |
| } |