1 /******************************************************************************
2 *
3 * Copyright 2006-2012 Broadcom Corporation
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at:
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *
17 ******************************************************************************/
18
19 /******************************************************************************
20 *
21 * This file contains action functions for BTA JV APIs.
22 *
23 ******************************************************************************/
24
25 #define LOG_TAG "bluetooth"
26
27 #include <bluetooth/log.h>
28 #include <com_android_bluetooth_flags.h>
29
30 #include <cstdint>
31 #include <unordered_set>
32
33 #include "bta/include/bta_jv_co.h"
34 #include "bta/include/bta_rfcomm_scn.h"
35 #include "bta/jv/bta_jv_int.h"
36 #include "bta/sys/bta_sys.h"
37 #include "internal_include/bt_target.h"
38 #include "osi/include/allocator.h"
39 #include "osi/include/properties.h"
40 #include "stack/btm/btm_sec.h"
41 #include "stack/include/bt_hdr.h"
42 #include "stack/include/bt_psm_types.h"
43 #include "stack/include/bt_types.h"
44 #include "stack/include/bt_uuid16.h"
45 #include "stack/include/btm_client_interface.h"
46 #include "stack/include/gap_api.h"
47 #include "stack/include/l2cap_interface.h"
48 #include "stack/include/l2cdefs.h"
49 #include "stack/include/port_api.h"
50 #include "stack/include/rfcdefs.h"
51 #include "stack/include/sdp_api.h"
52 #include "types/bluetooth/uuid.h"
53 #include "types/raw_address.h"
54
55 // TODO(b/369381361) Enfore -Wmissing-prototypes
56 #pragma GCC diagnostic ignored "-Wmissing-prototypes"
57
58 using namespace bluetooth::legacy::stack::sdp;
59 using namespace bluetooth;
60
61 tBTA_JV_CB bta_jv_cb;
62 std::unordered_set<uint16_t> used_l2cap_classic_dynamic_psm;
63
64 static tBTA_JV_PCB* bta_jv_add_rfc_port(tBTA_JV_RFC_CB* p_cb, tBTA_JV_PCB* p_pcb_open);
65 static tBTA_JV_STATUS bta_jv_free_set_pm_profile_cb(uint32_t jv_handle);
66 static void bta_jv_pm_conn_busy(tBTA_JV_PM_CB* p_cb);
67 static void bta_jv_pm_conn_idle(tBTA_JV_PM_CB* p_cb);
68 static void bta_jv_pm_state_change(tBTA_JV_PM_CB* p_cb, const tBTA_JV_CONN_STATE state);
69 static void bta_jv_reset_sniff_timer(tBTA_JV_PM_CB* p_cb);
70
71 #ifndef BTA_JV_SDP_DB_SIZE
72 #define BTA_JV_SDP_DB_SIZE 4500
73 #endif
74
75 #ifndef BTA_JV_SDP_RAW_DATA_SIZE
76 #define BTA_JV_SDP_RAW_DATA_SIZE 1800
77 #endif
78
79 static uint8_t bta_jv_sdp_raw_data[BTA_JV_SDP_RAW_DATA_SIZE];
80 static tSDP_DISCOVERY_DB bta_jv_sdp_db_data[BTA_JV_SDP_DB_SIZE / sizeof(tSDP_DISCOVERY_DB)];
81
82 /* JV configuration structure */
83 struct tBTA_JV_CFG {
84 uint16_t sdp_raw_size; /* The size of p_sdp_raw_data */
85 uint16_t sdp_db_size; /* The size of p_sdp_db */
86 uint8_t* p_sdp_raw_data; /* The data buffer to keep raw data */
87 tSDP_DISCOVERY_DB* p_sdp_db; /* The data buffer to keep SDP database */
88 } bta_jv_cfg = {
89 BTA_JV_SDP_RAW_DATA_SIZE, /* The size of p_sdp_raw_data */
90 (BTA_JV_SDP_DB_SIZE / sizeof(tSDP_DISCOVERY_DB)) *
91 sizeof(tSDP_DISCOVERY_DB), /* The size of p_sdp_db_data */
92 bta_jv_sdp_raw_data, /* The data buffer to keep raw data */
93 bta_jv_sdp_db_data /* The data buffer to keep SDP database */
94 };
95
96 tBTA_JV_CFG* p_bta_jv_cfg = &bta_jv_cfg;
97
98 /*******************************************************************************
99 *
100 * Function bta_jv_alloc_sec_id
101 *
102 * Description allocate a security id
103 *
104 * Returns
105 *
106 ******************************************************************************/
bta_jv_alloc_sec_id(void)107 uint8_t bta_jv_alloc_sec_id(void) {
108 uint8_t ret = 0;
109 int i;
110 for (i = 0; i < BTA_JV_NUM_SERVICE_ID; i++) {
111 if (0 == bta_jv_cb.sec_id[i]) {
112 bta_jv_cb.sec_id[i] = BTA_JV_FIRST_SERVICE_ID + i;
113 ret = bta_jv_cb.sec_id[i];
114 break;
115 }
116 }
117 return ret;
118 }
get_sec_id_used(void)119 static int get_sec_id_used(void) {
120 int i;
121 int used = 0;
122 for (i = 0; i < BTA_JV_NUM_SERVICE_ID; i++) {
123 if (bta_jv_cb.sec_id[i]) {
124 used++;
125 }
126 }
127 if (used == BTA_JV_NUM_SERVICE_ID) {
128 log::error("sec id exceeds the limit={}", BTA_JV_NUM_SERVICE_ID);
129 }
130 return used;
131 }
get_rfc_cb_used(void)132 static int get_rfc_cb_used(void) {
133 int i;
134 int used = 0;
135 for (i = 0; i < BTA_JV_MAX_RFC_CONN; i++) {
136 if (bta_jv_cb.rfc_cb[i].handle) {
137 used++;
138 }
139 }
140 if (used == BTA_JV_MAX_RFC_CONN) {
141 log::error("rfc ctrl block exceeds the limit={}", BTA_JV_MAX_RFC_CONN);
142 }
143 return used;
144 }
145
146 /*******************************************************************************
147 *
148 * Function bta_jv_free_sec_id
149 *
150 * Description free the given security id
151 *
152 * Returns
153 *
154 ******************************************************************************/
bta_jv_free_sec_id(uint8_t * p_sec_id)155 static void bta_jv_free_sec_id(uint8_t* p_sec_id) {
156 uint8_t sec_id = *p_sec_id;
157 *p_sec_id = 0;
158 if (sec_id >= BTA_JV_FIRST_SERVICE_ID && sec_id <= BTA_JV_LAST_SERVICE_ID) {
159 BTM_SecClrService(sec_id);
160 bta_jv_cb.sec_id[sec_id - BTA_JV_FIRST_SERVICE_ID] = 0;
161 }
162 }
163
164 /*******************************************************************************
165 *
166 * Function bta_jv_from_gap_l2cap_err
167 *
168 * Description Convert the L2CAP error result propagated from GAP to BTA JV
169 * L2CAP close reason code.
170 *
171 * Params l2cap_result: The L2CAP result propagated from GAP error.
172 *
173 * Returns Appropriate l2cap error reason value
174 * or BTA_JV_L2CAP_REASON_UNKNOWN if reason isn't defined yet.
175 *
176 ******************************************************************************/
bta_jv_from_gap_l2cap_err(const tL2CAP_CONN & l2cap_result)177 static tBTA_JV_L2CAP_REASON bta_jv_from_gap_l2cap_err(const tL2CAP_CONN& l2cap_result) {
178 switch (l2cap_result) {
179 case tL2CAP_CONN::L2CAP_CONN_ACL_CONNECTION_FAILED:
180 return BTA_JV_L2CAP_REASON_ACL_FAILURE;
181 case tL2CAP_CONN::L2CAP_CONN_CLIENT_SECURITY_CLEARANCE_FAILED:
182 return BTA_JV_L2CAP_REASON_CL_SEC_FAILURE;
183 case tL2CAP_CONN::L2CAP_CONN_INSUFFICIENT_AUTHENTICATION:
184 return BTA_JV_L2CAP_REASON_INSUFFICIENT_AUTHENTICATION;
185 case tL2CAP_CONN::L2CAP_CONN_INSUFFICIENT_AUTHORIZATION:
186 return BTA_JV_L2CAP_REASON_INSUFFICIENT_AUTHORIZATION;
187 case tL2CAP_CONN::L2CAP_CONN_INSUFFICIENT_ENCRYP_KEY_SIZE:
188 return BTA_JV_L2CAP_REASON_INSUFFICIENT_ENCRYP_KEY_SIZE;
189 case tL2CAP_CONN::L2CAP_CONN_INSUFFICIENT_ENCRYP:
190 return BTA_JV_L2CAP_REASON_INSUFFICIENT_ENCRYP;
191 case tL2CAP_CONN::L2CAP_CONN_INVALID_SOURCE_CID:
192 return BTA_JV_L2CAP_REASON_INVALID_SOURCE_CID;
193 case tL2CAP_CONN::L2CAP_CONN_SOURCE_CID_ALREADY_ALLOCATED:
194 return BTA_JV_L2CAP_REASON_SOURCE_CID_ALREADY_ALLOCATED;
195 case tL2CAP_CONN::L2CAP_CONN_UNACCEPTABLE_PARAMETERS:
196 return BTA_JV_L2CAP_REASON_UNACCEPTABLE_PARAMETERS;
197 case tL2CAP_CONN::L2CAP_CONN_INVALID_PARAMETERS:
198 return BTA_JV_L2CAP_REASON_INVALID_PARAMETERS;
199 case tL2CAP_CONN::L2CAP_CONN_NO_RESOURCES:
200 return BTA_JV_L2CAP_REASON_NO_RESOURCES;
201 case tL2CAP_CONN::L2CAP_CONN_NO_PSM:
202 return BTA_JV_L2CAP_REASON_NO_PSM;
203 case tL2CAP_CONN::L2CAP_CONN_TIMEOUT:
204 return BTA_JV_L2CAP_REASON_TIMEOUT;
205 default:
206 return BTA_JV_L2CAP_REASON_UNKNOWN;
207 }
208 }
209 /******************************************************************************/
210
211 /*******************************************************************************
212 *
213 * Function bta_jv_alloc_rfc_cb
214 *
215 * Description allocate a control block for the given port handle
216 *
217 * Returns
218 *
219 ******************************************************************************/
bta_jv_alloc_rfc_cb(uint16_t port_handle,tBTA_JV_PCB ** pp_pcb)220 tBTA_JV_RFC_CB* bta_jv_alloc_rfc_cb(uint16_t port_handle, tBTA_JV_PCB** pp_pcb) {
221 tBTA_JV_RFC_CB* p_cb = NULL;
222 tBTA_JV_PCB* p_pcb;
223 int i, j;
224 for (i = 0; i < BTA_JV_MAX_RFC_CONN; i++) {
225 if (0 == bta_jv_cb.rfc_cb[i].handle) {
226 p_cb = &bta_jv_cb.rfc_cb[i];
227 /* mask handle to distinguish it with L2CAP handle */
228 p_cb->handle = (i + 1) | BTA_JV_RFCOMM_MASK;
229
230 p_cb->max_sess = 1;
231 p_cb->curr_sess = 1;
232 for (j = 0; j < BTA_JV_MAX_RFC_SR_SESSION; j++) {
233 p_cb->rfc_hdl[j] = 0;
234 }
235 p_cb->rfc_hdl[0] = port_handle;
236 log::verbose("port_handle={}, handle=0x{:x}", port_handle, p_cb->handle);
237
238 p_pcb = &bta_jv_cb.port_cb[port_handle - 1];
239 p_pcb->handle = p_cb->handle;
240 p_pcb->port_handle = port_handle;
241 p_pcb->p_pm_cb = NULL;
242 *pp_pcb = p_pcb;
243 break;
244 }
245 }
246 if (p_cb == NULL) {
247 log::error("port_handle={} ctrl block exceeds limit:{}", port_handle, BTA_JV_MAX_RFC_CONN);
248 }
249 return p_cb;
250 }
251
252 /*******************************************************************************
253 *
254 * Function bta_jv_rfc_port_to_pcb
255 *
256 * Description find the port control block associated with the given port
257 * handle
258 *
259 * Returns
260 *
261 ******************************************************************************/
bta_jv_rfc_port_to_pcb(uint16_t port_handle)262 tBTA_JV_PCB* bta_jv_rfc_port_to_pcb(uint16_t port_handle) {
263 tBTA_JV_PCB* p_pcb = NULL;
264
265 if ((port_handle > 0) && (port_handle <= MAX_RFC_PORTS) &&
266 bta_jv_cb.port_cb[port_handle - 1].handle) {
267 p_pcb = &bta_jv_cb.port_cb[port_handle - 1];
268 }
269
270 return p_pcb;
271 }
272
273 /*******************************************************************************
274 *
275 * Function bta_jv_rfc_port_to_cb
276 *
277 * Description find the RFCOMM control block associated with the given port
278 * handle
279 *
280 * Returns
281 *
282 ******************************************************************************/
bta_jv_rfc_port_to_cb(uint16_t port_handle)283 tBTA_JV_RFC_CB* bta_jv_rfc_port_to_cb(uint16_t port_handle) {
284 tBTA_JV_RFC_CB* p_cb = NULL;
285 uint32_t handle;
286
287 if ((port_handle > 0) && (port_handle <= MAX_RFC_PORTS) &&
288 bta_jv_cb.port_cb[port_handle - 1].handle) {
289 handle = bta_jv_cb.port_cb[port_handle - 1].handle;
290 handle &= BTA_JV_RFC_HDL_MASK;
291 handle &= ~BTA_JV_RFCOMM_MASK;
292 if (handle) {
293 p_cb = &bta_jv_cb.rfc_cb[handle - 1];
294 }
295 } else {
296 log::warn("jv handle not found port_handle:{}", port_handle);
297 }
298 return p_cb;
299 }
300
bta_jv_free_rfc_cb(tBTA_JV_RFC_CB * p_cb,tBTA_JV_PCB * p_pcb)301 static tBTA_JV_STATUS bta_jv_free_rfc_cb(tBTA_JV_RFC_CB* p_cb, tBTA_JV_PCB* p_pcb) {
302 tBTA_JV_STATUS status = tBTA_JV_STATUS::SUCCESS;
303 bool remove_server = false;
304 int close_pending = 0;
305
306 if (!p_cb || !p_pcb) {
307 log::error("p_cb or p_pcb cannot be null");
308 return tBTA_JV_STATUS::FAILURE;
309 }
310 log::verbose("max_sess={}, curr_sess={}, p_pcb={}, user={}, state={}, jv handle=0x{:x}",
311 p_cb->max_sess, p_cb->curr_sess, std::format_ptr(p_pcb), p_pcb->rfcomm_slot_id,
312 p_pcb->state, p_pcb->handle);
313
314 if (p_cb->curr_sess <= 0) {
315 return tBTA_JV_STATUS::SUCCESS;
316 }
317
318 switch (p_pcb->state) {
319 case BTA_JV_ST_CL_CLOSING:
320 case BTA_JV_ST_SR_CLOSING:
321 log::warn("return on closing, port state={}, scn={}, p_pcb={}, user_data={}", p_pcb->state,
322 p_cb->scn, std::format_ptr(p_pcb), p_pcb->rfcomm_slot_id);
323 status = tBTA_JV_STATUS::FAILURE;
324 return status;
325 case BTA_JV_ST_CL_OPEN:
326 case BTA_JV_ST_CL_OPENING:
327 log::verbose("state={}, scn={}, user_data={}", p_pcb->state, p_cb->scn,
328 p_pcb->rfcomm_slot_id);
329 p_pcb->state = BTA_JV_ST_CL_CLOSING;
330 break;
331 case BTA_JV_ST_SR_LISTEN:
332 p_pcb->state = BTA_JV_ST_SR_CLOSING;
333 remove_server = true;
334 log::verbose("state: BTA_JV_ST_SR_LISTEN, scn={}, user_data={}", p_cb->scn,
335 p_pcb->rfcomm_slot_id);
336 break;
337 case BTA_JV_ST_SR_OPEN:
338 p_pcb->state = BTA_JV_ST_SR_CLOSING;
339 log::verbose(": state: BTA_JV_ST_SR_OPEN, scn={} user_data={}", p_cb->scn,
340 p_pcb->rfcomm_slot_id);
341 break;
342 default:
343 log::warn(
344 "failed, ignore port state= {}, scn={}, p_pcb= {}, jv handle=0x{:x}, "
345 "port_handle={}, user_data={}",
346 p_pcb->state, p_cb->scn, std::format_ptr(p_pcb), p_pcb->handle, p_pcb->port_handle,
347 p_pcb->rfcomm_slot_id);
348 status = tBTA_JV_STATUS::FAILURE;
349 break;
350 }
351 if (tBTA_JV_STATUS::SUCCESS == status) {
352 int port_status;
353
354 if (!remove_server) {
355 port_status = RFCOMM_RemoveConnection(p_pcb->port_handle);
356 } else {
357 port_status = RFCOMM_RemoveServer(p_pcb->port_handle);
358 }
359 if (port_status != PORT_SUCCESS) {
360 status = tBTA_JV_STATUS::FAILURE;
361 log::warn(
362 "Remove jv handle=0x{:x}, state={}, port_status={}, port_handle={}, close_pending={}",
363 p_pcb->handle, p_pcb->state, port_status, p_pcb->port_handle, close_pending);
364 }
365 }
366 if (!close_pending) {
367 p_pcb->port_handle = 0;
368 p_pcb->state = BTA_JV_ST_NONE;
369 bta_jv_free_set_pm_profile_cb(p_pcb->handle);
370
371 // Initialize congestion flags
372 p_pcb->cong = false;
373 p_pcb->rfcomm_slot_id = 0;
374 int si = BTA_JV_RFC_HDL_TO_SIDX(p_pcb->handle);
375 if (0 <= si && si < BTA_JV_MAX_RFC_SR_SESSION) {
376 p_cb->rfc_hdl[si] = 0;
377 }
378 p_pcb->handle = 0;
379 p_cb->curr_sess--;
380 if (p_cb->curr_sess == 0) {
381 p_cb->scn = 0;
382 p_cb->p_cback = NULL;
383 p_cb->handle = 0;
384 p_cb->curr_sess = -1;
385 }
386 }
387 return status;
388 }
389
390 /*******************************************************************************
391 *
392 * Function bta_jv_free_l2c_cb
393 *
394 * Description free the given L2CAP control block
395 *
396 * Returns
397 *
398 ******************************************************************************/
bta_jv_free_l2c_cb(tBTA_JV_L2C_CB * p_cb)399 tBTA_JV_STATUS bta_jv_free_l2c_cb(tBTA_JV_L2C_CB* p_cb) {
400 tBTA_JV_STATUS status = tBTA_JV_STATUS::SUCCESS;
401
402 if (BTA_JV_ST_NONE != p_cb->state) {
403 bta_jv_free_set_pm_profile_cb((uint32_t)p_cb->handle);
404 if (GAP_ConnClose(p_cb->handle) != BT_PASS) {
405 status = tBTA_JV_STATUS::FAILURE;
406 }
407 }
408 p_cb->psm = 0;
409 p_cb->state = BTA_JV_ST_NONE;
410 p_cb->cong = false;
411 bta_jv_free_sec_id(&p_cb->sec_id);
412 p_cb->p_cback = NULL;
413 p_cb->handle = 0;
414 p_cb->l2cap_socket_id = 0;
415 return status;
416 }
417
418 /*******************************************************************************
419 *
420 *
421 * Function bta_jv_clear_pm_cb
422 *
423 * Description clears jv pm control block and optionally calls
424 * bta_sys_conn_close()
425 * In general close_conn should be set to true to remove registering
426 * with dm pm!
427 *
428 * WARNING: Make sure to clear pointer form port or l2c to this control block
429 * too!
430 *
431 ******************************************************************************/
bta_jv_clear_pm_cb(tBTA_JV_PM_CB * p_pm_cb,bool close_conn)432 static void bta_jv_clear_pm_cb(tBTA_JV_PM_CB* p_pm_cb, bool close_conn) {
433 /* needs to be called if registered with bta pm, otherwise we may run out of
434 * dm pm slots! */
435 if (close_conn) {
436 bta_sys_conn_close(BTA_ID_JV, p_pm_cb->app_id, p_pm_cb->peer_bd_addr);
437 }
438 p_pm_cb->state = BTA_JV_PM_FREE_ST;
439 p_pm_cb->app_id = BTA_JV_PM_ALL;
440 p_pm_cb->handle = BTA_JV_PM_HANDLE_CLEAR;
441 p_pm_cb->peer_bd_addr = RawAddress::kEmpty;
442 }
443
444 /*******************************************************************************
445 *
446 * Function bta_jv_free_set_pm_profile_cb
447 *
448 * Description free pm profile control block
449 *
450 * Returns tBTA_JV_STATUS::SUCCESS if cb has been freed correctly,
451 * tBTA_JV_STATUS::FAILURE in case of no profile has been registered
452 * or already freed
453 *
454 ******************************************************************************/
bta_jv_free_set_pm_profile_cb(uint32_t jv_handle)455 static tBTA_JV_STATUS bta_jv_free_set_pm_profile_cb(uint32_t jv_handle) {
456 tBTA_JV_STATUS status = tBTA_JV_STATUS::FAILURE;
457 tBTA_JV_PM_CB** p_cb;
458 int i, j, bd_counter = 0, appid_counter = 0;
459
460 for (i = 0; i < BTA_JV_PM_MAX_NUM; i++) {
461 p_cb = NULL;
462 if ((bta_jv_cb.pm_cb[i].state != BTA_JV_PM_FREE_ST) &&
463 (jv_handle == bta_jv_cb.pm_cb[i].handle)) {
464 for (j = 0; j < BTA_JV_PM_MAX_NUM; j++) {
465 if (bta_jv_cb.pm_cb[j].peer_bd_addr == bta_jv_cb.pm_cb[i].peer_bd_addr) {
466 bd_counter++;
467 }
468 if (bta_jv_cb.pm_cb[j].app_id == bta_jv_cb.pm_cb[i].app_id) {
469 appid_counter++;
470 }
471 }
472
473 log::verbose("jv_handle=0x{:x}, idx={}app_id={}, bd_counter={}, appid_counter={}", jv_handle,
474 i, bta_jv_cb.pm_cb[i].app_id, bd_counter, appid_counter);
475 if (bd_counter > 1) {
476 bta_jv_pm_conn_idle(&bta_jv_cb.pm_cb[i]);
477 }
478
479 if (bd_counter <= 1 || (appid_counter <= 1)) {
480 bta_jv_clear_pm_cb(&bta_jv_cb.pm_cb[i], true);
481 } else {
482 bta_jv_clear_pm_cb(&bta_jv_cb.pm_cb[i], false);
483 }
484
485 if (BTA_JV_RFCOMM_MASK & jv_handle) {
486 uint32_t hi = ((jv_handle & BTA_JV_RFC_HDL_MASK) & ~BTA_JV_RFCOMM_MASK) - 1;
487 uint32_t si = BTA_JV_RFC_HDL_TO_SIDX(jv_handle);
488 if (hi < BTA_JV_MAX_RFC_CONN && bta_jv_cb.rfc_cb[hi].p_cback &&
489 si < BTA_JV_MAX_RFC_SR_SESSION && bta_jv_cb.rfc_cb[hi].rfc_hdl[si]) {
490 tBTA_JV_PCB* p_pcb = bta_jv_rfc_port_to_pcb(bta_jv_cb.rfc_cb[hi].rfc_hdl[si]);
491 if (p_pcb) {
492 if (NULL == p_pcb->p_pm_cb) {
493 log::warn("jv_handle=0x{:x}, port_handle={}, i={}, no link to pm_cb?", jv_handle,
494 p_pcb->port_handle, i);
495 }
496 p_cb = &p_pcb->p_pm_cb;
497 }
498 }
499 } else {
500 if (jv_handle < BTA_JV_MAX_L2C_CONN) {
501 tBTA_JV_L2C_CB* p_l2c_cb = &bta_jv_cb.l2c_cb[jv_handle];
502 if (NULL == p_l2c_cb->p_pm_cb) {
503 log::warn("jv_handle=0x{:x}, i={} no link to pm_cb?", jv_handle, i);
504 }
505 p_cb = &p_l2c_cb->p_pm_cb;
506 }
507 }
508 if (p_cb) {
509 *p_cb = NULL;
510 status = tBTA_JV_STATUS::SUCCESS;
511 }
512 }
513 }
514 return status;
515 }
516
517 /*******************************************************************************
518 *
519 * Function bta_jv_alloc_set_pm_profile_cb
520 *
521 * Description set PM profile control block
522 *
523 * Returns pointer to allocated cb or NULL in case of failure
524 *
525 ******************************************************************************/
bta_jv_alloc_set_pm_profile_cb(uint32_t jv_handle,tBTA_JV_PM_ID app_id)526 static tBTA_JV_PM_CB* bta_jv_alloc_set_pm_profile_cb(uint32_t jv_handle, tBTA_JV_PM_ID app_id) {
527 bool bRfcHandle = (jv_handle & BTA_JV_RFCOMM_MASK) != 0;
528 RawAddress peer_bd_addr = RawAddress::kEmpty;
529 int i, j;
530 tBTA_JV_PM_CB** pp_cb;
531
532 for (i = 0; i < BTA_JV_PM_MAX_NUM; i++) {
533 pp_cb = NULL;
534 if (bta_jv_cb.pm_cb[i].state == BTA_JV_PM_FREE_ST) {
535 /* rfc handle bd addr retrieval requires core stack handle */
536 if (bRfcHandle) {
537 for (j = 0; j < BTA_JV_MAX_RFC_CONN; j++) {
538 if (jv_handle == bta_jv_cb.port_cb[j].handle) {
539 pp_cb = &bta_jv_cb.port_cb[j].p_pm_cb;
540 if (PORT_SUCCESS !=
541 PORT_CheckConnection(bta_jv_cb.port_cb[j].port_handle, &peer_bd_addr, NULL)) {
542 i = BTA_JV_PM_MAX_NUM;
543 }
544 break;
545 }
546 }
547 } else {
548 /* use jv handle for l2cap bd address retrieval */
549 for (j = 0; j < BTA_JV_MAX_L2C_CONN; j++) {
550 if (jv_handle == bta_jv_cb.l2c_cb[j].handle) {
551 pp_cb = &bta_jv_cb.l2c_cb[j].p_pm_cb;
552 const RawAddress* p_bd_addr = GAP_ConnGetRemoteAddr((uint16_t)jv_handle);
553 if (p_bd_addr) {
554 peer_bd_addr = *p_bd_addr;
555 } else {
556 i = BTA_JV_PM_MAX_NUM;
557 }
558 break;
559 }
560 }
561 }
562 log::verbose("handle=0x{:x}, app_id={}, idx={}, BTA_JV_PM_MAX_NUM={}, pp_cb={}", jv_handle,
563 app_id, i, BTA_JV_PM_MAX_NUM, std::format_ptr(pp_cb));
564 break;
565 }
566 }
567
568 if ((i != BTA_JV_PM_MAX_NUM) && (NULL != pp_cb)) {
569 *pp_cb = &bta_jv_cb.pm_cb[i];
570 bta_jv_cb.pm_cb[i].handle = jv_handle;
571 bta_jv_cb.pm_cb[i].app_id = app_id;
572 bta_jv_cb.pm_cb[i].peer_bd_addr = peer_bd_addr;
573 bta_jv_cb.pm_cb[i].state = BTA_JV_PM_IDLE_ST;
574 return &bta_jv_cb.pm_cb[i];
575 }
576 log::warn("handle=0x{:x}, app_id={}, return NULL", jv_handle, app_id);
577 return NULL;
578 }
579
580 /*******************************************************************************
581 *
582 * Function bta_jv_check_psm
583 *
584 * Description for now use only the legal PSM per JSR82 spec
585 *
586 * Returns true, if allowed
587 *
588 ******************************************************************************/
bta_jv_check_psm(uint16_t psm)589 bool bta_jv_check_psm(uint16_t psm) {
590 bool ret = false;
591
592 if (L2C_IS_VALID_PSM(psm)) {
593 if (psm < 0x1001) {
594 /* see if this is defined by spec */
595 switch (psm) {
596 case BT_PSM_SDP:
597 case BT_PSM_RFCOMM: /* 3 */
598 /* do not allow java app to use these 2 PSMs */
599 break;
600
601 case BT_PSM_TCS:
602 case BT_PSM_CTP:
603 if (!bta_sys_is_register(BTA_ID_CT) && !bta_sys_is_register(BTA_ID_CG)) {
604 ret = true;
605 }
606 break;
607
608 case BT_PSM_BNEP: /* F */
609 if (!bta_sys_is_register(BTA_ID_PAN)) {
610 ret = true;
611 }
612 break;
613
614 case BT_PSM_HIDC:
615 case BT_PSM_HIDI:
616 // FIX: allow HID Device and HID Host to coexist
617 if (!bta_sys_is_register(BTA_ID_HD) || !bta_sys_is_register(BTA_ID_HH)) {
618 ret = true;
619 }
620 break;
621
622 case BT_PSM_AVCTP: /* 0x17 */
623 case BT_PSM_AVDTP: /* 0x19 */
624 if (!bta_sys_is_register(BTA_ID_AV)) {
625 ret = true;
626 }
627 break;
628
629 default:
630 ret = true;
631 break;
632 }
633 } else {
634 ret = true;
635 }
636 }
637 return ret;
638 }
639
640 /* Initialises the JAVA I/F */
bta_jv_enable(tBTA_JV_DM_CBACK * p_cback)641 void bta_jv_enable(tBTA_JV_DM_CBACK* p_cback) {
642 bta_jv_cb.p_dm_cback = p_cback;
643 if (bta_jv_cb.p_dm_cback) {
644 tBTA_JV bta_jv = {
645 .status = tBTA_JV_STATUS::SUCCESS,
646 };
647 bta_jv_cb.p_dm_cback(BTA_JV_ENABLE_EVT, &bta_jv, 0);
648 }
649 memset(bta_jv_cb.free_psm_list, 0, sizeof(bta_jv_cb.free_psm_list));
650 memset(bta_jv_cb.scn_in_use, 0, sizeof(bta_jv_cb.scn_in_use));
651 bta_jv_cb.scn_search_index = 1;
652 }
653
654 /** Disables the BT device manager free the resources used by java */
bta_jv_disable()655 void bta_jv_disable() { log::info(""); }
656
657 /**
658 * We keep a list of PSM's that have been freed from JAVA, for reuse.
659 * This function will return a free PSM, and delete it from the free
660 * list.
661 * If no free PSMs exist, 0 will be returned.
662 */
bta_jv_get_free_psm()663 static uint16_t bta_jv_get_free_psm() {
664 const int cnt = sizeof(bta_jv_cb.free_psm_list) / sizeof(bta_jv_cb.free_psm_list[0]);
665 for (int i = 0; i < cnt; i++) {
666 uint16_t psm = bta_jv_cb.free_psm_list[i];
667 if (psm != 0) {
668 log::verbose("Reusing PSM=0x{:x}", psm);
669 bta_jv_cb.free_psm_list[i] = 0;
670 return psm;
671 }
672 }
673 return 0;
674 }
675
bta_jv_set_free_psm(uint16_t psm)676 static void bta_jv_set_free_psm(uint16_t psm) {
677 int free_index = -1;
678 const int cnt = sizeof(bta_jv_cb.free_psm_list) / sizeof(bta_jv_cb.free_psm_list[0]);
679 for (int i = 0; i < cnt; i++) {
680 if (bta_jv_cb.free_psm_list[i] == 0) {
681 free_index = i;
682 } else if (psm == bta_jv_cb.free_psm_list[i]) {
683 return; // PSM already freed?
684 }
685 }
686 if (free_index != -1) {
687 bta_jv_cb.free_psm_list[free_index] = psm;
688 log::verbose("Recycling PSM=0x{:x}", psm);
689 } else {
690 log::error("unable to free psm=0x{:x} no more free slots", psm);
691 }
692 }
693
bta_jv_allocate_l2cap_classic_psm()694 static uint16_t bta_jv_allocate_l2cap_classic_psm() {
695 bool done = false;
696 uint16_t psm = bta_jv_cb.dyn_psm;
697
698 while (!done) {
699 psm += 2;
700 if (psm > 0xfeff) {
701 psm = 0x1001;
702 } else if (psm & 0x0100) {
703 /* the upper byte must be even */
704 psm += 0x0100;
705 }
706
707 /* if psm is in range of reserved BRCM Aware features */
708 if ((BRCM_RESERVED_PSM_START <= psm) && (psm <= BRCM_RESERVED_PSM_END)) {
709 continue;
710 }
711
712 /* make sure the newlly allocated psm is not used right now */
713 if (used_l2cap_classic_dynamic_psm.count(psm) == 0) {
714 done = true;
715 }
716 }
717 bta_jv_cb.dyn_psm = psm;
718
719 return psm;
720 }
721
722 /** Obtain a free SCN (Server Channel Number) (RFCOMM channel or L2CAP PSM) */
bta_jv_get_channel_id(tBTA_JV_CONN_TYPE type,int32_t channel,uint32_t l2cap_socket_id,uint32_t rfcomm_slot_id)723 void bta_jv_get_channel_id(tBTA_JV_CONN_TYPE type /* One of BTA_JV_CONN_TYPE_ */,
724 int32_t channel /* optionally request a specific channel */,
725 uint32_t l2cap_socket_id, uint32_t rfcomm_slot_id) {
726 uint16_t psm = 0;
727
728 switch (type) {
729 case tBTA_JV_CONN_TYPE::RFCOMM: {
730 uint8_t scn = 0;
731 if (channel > 0) {
732 if (BTA_TryAllocateSCN(channel)) {
733 scn = static_cast<uint8_t>(channel);
734 } else {
735 log::error("rfc channel {} already in use or invalid", channel);
736 }
737 } else {
738 scn = BTA_AllocateSCN();
739 if (scn == 0) {
740 log::error("out of rfc channels");
741 }
742 }
743 if (bta_jv_cb.p_dm_cback) {
744 tBTA_JV bta_jv;
745 bta_jv.scn = scn;
746 bta_jv_cb.p_dm_cback(BTA_JV_GET_SCN_EVT, &bta_jv, rfcomm_slot_id);
747 }
748 return;
749 }
750 case tBTA_JV_CONN_TYPE::L2CAP:
751 psm = bta_jv_get_free_psm();
752 if (psm == 0) {
753 psm = bta_jv_allocate_l2cap_classic_psm();
754 log::verbose("returned PSM=0x{:x}", psm);
755 }
756 break;
757 case tBTA_JV_CONN_TYPE::L2CAP_LE:
758 psm = stack::l2cap::get_interface().L2CA_AllocateLePSM();
759 if (psm == 0) {
760 log::error("Error: No free LE PSM available");
761 }
762 break;
763 default:
764 break;
765 }
766
767 if (bta_jv_cb.p_dm_cback) {
768 tBTA_JV bta_jv;
769 bta_jv.psm = psm;
770 bta_jv_cb.p_dm_cback(BTA_JV_GET_PSM_EVT, &bta_jv, l2cap_socket_id);
771 }
772 }
773
774 /** free a SCN */
bta_jv_free_scn(tBTA_JV_CONN_TYPE type,uint16_t scn)775 void bta_jv_free_scn(tBTA_JV_CONN_TYPE type /* One of BTA_JV_CONN_TYPE_ */, uint16_t scn) {
776 switch (type) {
777 case tBTA_JV_CONN_TYPE::RFCOMM:
778 BTA_FreeSCN(scn);
779 break;
780 case tBTA_JV_CONN_TYPE::L2CAP:
781 bta_jv_set_free_psm(scn);
782 break;
783 case tBTA_JV_CONN_TYPE::L2CAP_LE:
784 log::verbose("type=BTA_JV_CONN_TYPE::L2CAP_LE. psm={}", scn);
785 stack::l2cap::get_interface().L2CA_FreeLePSM(scn);
786 break;
787 default:
788 break;
789 }
790 }
791
792 /*******************************************************************************
793 *
794 * Function bta_jv_start_discovery_cback
795 *
796 * Description Callback for Start Discovery
797 *
798 * Returns void
799 *
800 ******************************************************************************/
bta_jv_start_discovery_cback(uint32_t rfcomm_slot_id,const RawAddress & bd_addr,tSDP_RESULT result)801 static void bta_jv_start_discovery_cback(uint32_t rfcomm_slot_id, const RawAddress& bd_addr,
802 tSDP_RESULT result) {
803 if (!bta_jv_cb.sdp_cb.sdp_active) {
804 log::warn("Received unexpected service discovery callback bd_addr:{} result:{}", bd_addr,
805 sdp_result_text(result), bta_jv_cb.sdp_cb.sdp_active);
806 }
807 if (bta_jv_cb.sdp_cb.bd_addr != bta_jv_cb.sdp_cb.bd_addr) {
808 log::warn(
809 "Received incorrect service discovery callback expected_bd_addr:{} "
810 "actual_bd_addr:{} result:{}",
811 bta_jv_cb.sdp_cb.bd_addr, bd_addr, sdp_result_text(result),
812 bta_jv_cb.sdp_cb.sdp_active);
813 }
814
815 if (bta_jv_cb.p_dm_cback) {
816 tBTA_JV bta_jv = {
817 .disc_comp =
818 {
819 .status = tBTA_JV_STATUS::FAILURE,
820 .scn = 0,
821 },
822 };
823 if (result == tSDP_STATUS::SDP_SUCCESS || result == tSDP_STATUS::SDP_DB_FULL) {
824 log::info("Received service discovery callback success bd_addr:{} result:{}", bd_addr,
825 sdp_result_text(result));
826 tSDP_PROTOCOL_ELEM pe;
827 tSDP_DISC_REC* p_sdp_rec = NULL;
828 p_sdp_rec = get_legacy_stack_sdp_api()->db.SDP_FindServiceUUIDInDb(
829 p_bta_jv_cfg->p_sdp_db, bta_jv_cb.sdp_cb.uuid, p_sdp_rec);
830 log::verbose("bta_jv_cb.uuid={} p_sdp_rec={}", bta_jv_cb.sdp_cb.uuid,
831 std::format_ptr(p_sdp_rec));
832 if (p_sdp_rec && get_legacy_stack_sdp_api()->record.SDP_FindProtocolListElemInRec(
833 p_sdp_rec, UUID_PROTOCOL_RFCOMM, &pe)) {
834 bta_jv = {
835 .disc_comp =
836 {
837 .status = tBTA_JV_STATUS::SUCCESS,
838 .scn = (uint8_t)pe.params[0],
839 },
840 };
841 }
842 } else {
843 log::warn("Received service discovery callback failed bd_addr:{} result:{}", bd_addr,
844 sdp_result_text(result));
845 }
846 log::info("Issuing service discovery complete callback bd_addr:{} result:{} status:{} scn:{}",
847 bd_addr, sdp_result_text(result), bta_jv_status_text(bta_jv.disc_comp.status),
848 bta_jv.disc_comp.scn);
849 bta_jv_cb.p_dm_cback(BTA_JV_DISCOVERY_COMP_EVT, &bta_jv, rfcomm_slot_id);
850 } else {
851 log::warn("Received service discovery callback when disabled bd_addr:{} result:{}", bd_addr,
852 sdp_result_text(result));
853 }
854 bta_jv_cb.sdp_cb = {};
855 }
856
857 /* Discovers services on a remote device */
bta_jv_start_discovery(const RawAddress & bd_addr,uint16_t num_uuid,bluetooth::Uuid * uuid_list,uint32_t rfcomm_slot_id)858 void bta_jv_start_discovery(const RawAddress& bd_addr, uint16_t num_uuid,
859 bluetooth::Uuid* uuid_list, uint32_t rfcomm_slot_id) {
860 log::assert_that(uuid_list != nullptr, "assert failed: uuid_list != nullptr");
861 if (bta_jv_cb.sdp_cb.sdp_active) {
862 log::warn(
863 "Unable to start discovery as already in progress active_bd_addr{} "
864 "request_bd_addr:{} num:uuid:{} rfcomm_slot_id:{}",
865 bta_jv_cb.sdp_cb.bd_addr, bd_addr, num_uuid, rfcomm_slot_id);
866 if (bta_jv_cb.p_dm_cback) {
867 tBTA_JV bta_jv = {
868 .status = tBTA_JV_STATUS::BUSY,
869 };
870 bta_jv_cb.p_dm_cback(BTA_JV_DISCOVERY_COMP_EVT, &bta_jv, rfcomm_slot_id);
871 } else {
872 log::warn(
873 "bta::jv module DISABLED so unable to inform caller service discovery is "
874 "unavailable");
875 }
876 return;
877 }
878
879 /* init the database/set up the filter */
880 if (!get_legacy_stack_sdp_api()->service.SDP_InitDiscoveryDb(
881 p_bta_jv_cfg->p_sdp_db, p_bta_jv_cfg->sdp_db_size, num_uuid, uuid_list, 0, NULL)) {
882 log::warn("Unable to initialize service discovery db bd_addr:{} num:uuid:{} rfcomm_slot_id:{}",
883 bd_addr, num_uuid, rfcomm_slot_id);
884 }
885
886 /* tell SDP to keep the raw data */
887 p_bta_jv_cfg->p_sdp_db->raw_data = p_bta_jv_cfg->p_sdp_raw_data;
888 p_bta_jv_cfg->p_sdp_db->raw_size = p_bta_jv_cfg->sdp_raw_size;
889
890 // Optimistically set this as active
891 bta_jv_cb.sdp_cb = {
892 .sdp_active = true,
893 .bd_addr = bd_addr,
894 .uuid = uuid_list[0],
895 };
896
897 if (!get_legacy_stack_sdp_api()->service.SDP_ServiceSearchAttributeRequest2(
898 bd_addr, p_bta_jv_cfg->p_sdp_db,
899 base::BindRepeating(&bta_jv_start_discovery_cback, rfcomm_slot_id))) {
900 bta_jv_cb.sdp_cb = {};
901 log::warn("Unable to original service discovery bd_addr:{} num:uuid:{} rfcomm_slot_id:{}",
902 bd_addr, num_uuid, rfcomm_slot_id);
903 /* failed to start SDP. report the failure right away */
904 if (bta_jv_cb.p_dm_cback) {
905 tBTA_JV bta_jv = {
906 .status = tBTA_JV_STATUS::FAILURE,
907 };
908 bta_jv_cb.p_dm_cback(BTA_JV_DISCOVERY_COMP_EVT, &bta_jv, rfcomm_slot_id);
909 } else {
910 log::warn("No callback set for discovery complete event");
911 }
912 } else {
913 log::info("Started service discovery bd_addr:{} num_uuid:{} rfcomm_slot_id:{}", bd_addr,
914 num_uuid, rfcomm_slot_id);
915 }
916 }
917
bta_jv_cancel_discovery(uint32_t rfcomm_slot_id)918 void bta_jv_cancel_discovery(uint32_t rfcomm_slot_id) {
919 if (!bta_jv_cb.sdp_cb.sdp_active) {
920 log::error("Canceling discovery but discovery is not active");
921 return;
922 }
923 if (!get_legacy_stack_sdp_api()->service.SDP_CancelServiceSearch(p_bta_jv_cfg->p_sdp_db)) {
924 log::error("Failed to cancel discovery, clean up the control block anyway");
925 bta_jv_cb.sdp_cb = {};
926 /* Send complete event right away as we might not receive callback from stack */
927 if (bta_jv_cb.p_dm_cback) {
928 tBTA_JV bta_jv = {
929 .status = tBTA_JV_STATUS::FAILURE,
930 };
931 bta_jv_cb.p_dm_cback(BTA_JV_DISCOVERY_COMP_EVT, &bta_jv, rfcomm_slot_id);
932 } else {
933 log::warn("No callback set for discovery complete event");
934 }
935 } else {
936 log::info("Canceled discovery");
937 }
938 }
939
940 /* Create an SDP record with the given attributes */
bta_jv_create_record(uint32_t rfcomm_slot_id)941 void bta_jv_create_record(uint32_t rfcomm_slot_id) {
942 tBTA_JV_CREATE_RECORD evt_data;
943 evt_data.status = tBTA_JV_STATUS::SUCCESS;
944 if (bta_jv_cb.p_dm_cback) {
945 // callback immediately to create the sdp record in stack thread context
946 tBTA_JV bta_jv;
947 bta_jv.create_rec = evt_data;
948 bta_jv_cb.p_dm_cback(BTA_JV_CREATE_RECORD_EVT, &bta_jv, rfcomm_slot_id);
949 }
950 }
951
952 /* Delete an SDP record */
bta_jv_delete_record(uint32_t handle)953 void bta_jv_delete_record(uint32_t handle) {
954 if (handle) {
955 /* this is a record created by btif layer*/
956 if (!get_legacy_stack_sdp_api()->handle.SDP_DeleteRecord(handle)) {
957 log::warn("Unable to delete SDP record handle:{}", handle);
958 }
959 }
960 }
961
962 /*******************************************************************************
963 *
964 * Function bta_jv_l2cap_client_cback
965 *
966 * Description handles the l2cap client events
967 *
968 * Returns void
969 *
970 ******************************************************************************/
bta_jv_l2cap_client_cback(uint16_t gap_handle,uint16_t event,tGAP_CB_DATA * data)971 static void bta_jv_l2cap_client_cback(uint16_t gap_handle, uint16_t event, tGAP_CB_DATA* data) {
972 tBTA_JV_L2C_CB* p_cb = &bta_jv_cb.l2c_cb[gap_handle];
973 tBTA_JV evt_data;
974
975 if (gap_handle >= BTA_JV_MAX_L2C_CONN && !p_cb->p_cback) {
976 return;
977 }
978
979 log::verbose("gap_handle={}, evt=0x{:x}", gap_handle, event);
980 evt_data.l2c_open.status = tBTA_JV_STATUS::SUCCESS;
981 evt_data.l2c_open.handle = gap_handle;
982
983 switch (event) {
984 case GAP_EVT_CONN_OPENED:
985 if (!com::android::bluetooth::flags::socket_settings_api() ||
986 !GAP_IsTransportLe(gap_handle)) {
987 evt_data.l2c_open.rem_bda = *GAP_ConnGetRemoteAddr(gap_handle);
988 evt_data.l2c_open.tx_mtu = GAP_ConnGetRemMtuSize(gap_handle);
989 if (data != nullptr) {
990 evt_data.l2c_open.local_cid = data->l2cap_cids.local_cid;
991 evt_data.l2c_open.remote_cid = data->l2cap_cids.remote_cid;
992 }
993 } else {
994 uint16_t remote_mtu, local_mps, remote_mps, local_credit, remote_credit;
995 uint16_t local_cid, remote_cid, acl_handle;
996 evt_data.l2c_open.rem_bda = *GAP_ConnGetRemoteAddr(gap_handle);
997 if (GAP_GetLeChannelInfo(gap_handle, &remote_mtu, &local_mps, &remote_mps, &local_credit,
998 &remote_credit, &local_cid, &remote_cid,
999 &acl_handle) != PORT_SUCCESS) {
1000 log::warn("Unable to get GAP channel info handle:{}", gap_handle);
1001 }
1002 evt_data.l2c_open.tx_mtu = remote_mtu;
1003 evt_data.l2c_open.local_coc_mps = local_mps;
1004 evt_data.l2c_open.remote_coc_mps = remote_mps;
1005 evt_data.l2c_open.local_coc_credit = local_credit;
1006 evt_data.l2c_open.remote_coc_credit = remote_credit;
1007 evt_data.l2c_open.local_cid = local_cid;
1008 evt_data.l2c_open.remote_cid = remote_cid;
1009 evt_data.l2c_open.acl_handle = acl_handle;
1010 }
1011 p_cb->state = BTA_JV_ST_CL_OPEN;
1012 p_cb->p_cback(BTA_JV_L2CAP_OPEN_EVT, &evt_data, p_cb->l2cap_socket_id);
1013 break;
1014
1015 case GAP_EVT_CONN_CLOSED:
1016 p_cb->state = BTA_JV_ST_NONE;
1017 bta_jv_free_sec_id(&p_cb->sec_id);
1018 evt_data.l2c_close.async = true;
1019 evt_data.l2c_close.reason = data != nullptr ? bta_jv_from_gap_l2cap_err(data->l2cap_result)
1020 : BTA_JV_L2CAP_REASON_EMPTY;
1021 p_cb->p_cback(BTA_JV_L2CAP_CLOSE_EVT, &evt_data, p_cb->l2cap_socket_id);
1022 p_cb->p_cback = NULL;
1023 break;
1024
1025 case GAP_EVT_CONN_DATA_AVAIL:
1026 evt_data.data_ind.handle = gap_handle;
1027 /* Reset idle timer to avoid requesting sniff mode while receiving data */
1028 bta_jv_pm_conn_busy(p_cb->p_pm_cb);
1029 p_cb->p_cback(BTA_JV_L2CAP_DATA_IND_EVT, &evt_data, p_cb->l2cap_socket_id);
1030 bta_jv_pm_conn_idle(p_cb->p_pm_cb);
1031 break;
1032
1033 case GAP_EVT_TX_EMPTY:
1034 bta_jv_pm_conn_idle(p_cb->p_pm_cb);
1035 break;
1036
1037 case GAP_EVT_CONN_CONGESTED:
1038 case GAP_EVT_CONN_UNCONGESTED:
1039 p_cb->cong = (event == GAP_EVT_CONN_CONGESTED) ? true : false;
1040 evt_data.l2c_cong.cong = p_cb->cong;
1041 p_cb->p_cback(BTA_JV_L2CAP_CONG_EVT, &evt_data, p_cb->l2cap_socket_id);
1042 break;
1043
1044 default:
1045 break;
1046 }
1047 }
1048
1049 /* makes an l2cap client connection */
bta_jv_l2cap_connect(tBTA_JV_CONN_TYPE type,tBTA_SEC sec_mask,uint16_t remote_psm,uint16_t rx_mtu,const RawAddress & peer_bd_addr,std::unique_ptr<tL2CAP_CFG_INFO> cfg_param,std::unique_ptr<tL2CAP_ERTM_INFO> ertm_info,tBTA_JV_L2CAP_CBACK * p_cback,uint32_t l2cap_socket_id)1050 void bta_jv_l2cap_connect(tBTA_JV_CONN_TYPE type, tBTA_SEC sec_mask, uint16_t remote_psm,
1051 uint16_t rx_mtu, const RawAddress& peer_bd_addr,
1052 std::unique_ptr<tL2CAP_CFG_INFO> cfg_param,
1053 std::unique_ptr<tL2CAP_ERTM_INFO> ertm_info, tBTA_JV_L2CAP_CBACK* p_cback,
1054 uint32_t l2cap_socket_id) {
1055 uint16_t handle = GAP_INVALID_HANDLE;
1056
1057 tL2CAP_CFG_INFO cfg;
1058 memset(&cfg, 0, sizeof(tL2CAP_CFG_INFO));
1059 if (cfg_param) {
1060 cfg = *cfg_param;
1061 }
1062
1063 /* We need to use this value for MTU to be able to handle cases where cfg is
1064 * not set in req. */
1065 cfg.mtu_present = true;
1066 cfg.mtu = rx_mtu;
1067
1068 uint8_t sec_id = bta_jv_alloc_sec_id();
1069 tBTA_JV_L2CAP_CL_INIT evt_data;
1070 evt_data.sec_id = sec_id;
1071 evt_data.status = tBTA_JV_STATUS::FAILURE;
1072
1073 if (sec_id) {
1074 /* PSM checking is not required for LE COC */
1075 if ((type != tBTA_JV_CONN_TYPE::L2CAP) || (bta_jv_check_psm(remote_psm))) /* allowed */
1076 {
1077 // Given a client socket type
1078 // return the associated transport
1079 const tBT_TRANSPORT transport = [](tBTA_JV_CONN_TYPE type) -> tBT_TRANSPORT {
1080 switch (type) {
1081 case tBTA_JV_CONN_TYPE::L2CAP:
1082 return BT_TRANSPORT_BR_EDR;
1083 case tBTA_JV_CONN_TYPE::L2CAP_LE:
1084 return BT_TRANSPORT_LE;
1085 case tBTA_JV_CONN_TYPE::RFCOMM:
1086 default:
1087 break;
1088 }
1089 log::warn("Unexpected socket type:{}", bta_jv_conn_type_text(type));
1090 return BT_TRANSPORT_AUTO;
1091 }(type);
1092
1093 uint16_t max_mps = 0xffff; // Let GAP_ConnOpen set the max_mps.
1094 handle = GAP_ConnOpen("", sec_id, 0, &peer_bd_addr, remote_psm, max_mps, &cfg,
1095 ertm_info.get(), sec_mask, bta_jv_l2cap_client_cback, transport);
1096 if (handle != GAP_INVALID_HANDLE) {
1097 evt_data.status = tBTA_JV_STATUS::SUCCESS;
1098 }
1099 }
1100 }
1101
1102 if (evt_data.status == tBTA_JV_STATUS::SUCCESS) {
1103 tBTA_JV_L2C_CB* p_cb;
1104 p_cb = &bta_jv_cb.l2c_cb[handle];
1105 p_cb->handle = handle;
1106 p_cb->p_cback = p_cback;
1107 p_cb->l2cap_socket_id = l2cap_socket_id;
1108 p_cb->psm = 0; /* not a server */
1109 p_cb->sec_id = sec_id;
1110 p_cb->state = BTA_JV_ST_CL_OPENING;
1111 } else {
1112 bta_jv_free_sec_id(&sec_id);
1113 }
1114
1115 evt_data.handle = handle;
1116 if (p_cback) {
1117 tBTA_JV bta_jv;
1118 bta_jv.l2c_cl_init = evt_data;
1119 p_cback(BTA_JV_L2CAP_CL_INIT_EVT, &bta_jv, l2cap_socket_id);
1120 }
1121 }
1122
1123 /** Close an L2CAP client connection */
bta_jv_l2cap_close(uint32_t handle,tBTA_JV_L2C_CB * p_cb)1124 void bta_jv_l2cap_close(uint32_t handle, tBTA_JV_L2C_CB* p_cb) {
1125 tBTA_JV_L2CAP_CLOSE evt_data;
1126 tBTA_JV_L2CAP_CBACK* p_cback = p_cb->p_cback;
1127 uint32_t l2cap_socket_id = p_cb->l2cap_socket_id;
1128
1129 evt_data.handle = handle;
1130 evt_data.status = bta_jv_free_l2c_cb(p_cb);
1131 evt_data.async = false;
1132
1133 if (p_cback) {
1134 tBTA_JV bta_jv;
1135 bta_jv.l2c_close = evt_data;
1136 p_cback(BTA_JV_L2CAP_CLOSE_EVT, &bta_jv, l2cap_socket_id);
1137 }
1138 }
1139
1140 /*******************************************************************************
1141 *
1142 * Function bta_jv_l2cap_server_cback
1143 *
1144 * Description handles the l2cap server callback
1145 *
1146 * Returns void
1147 *
1148 ******************************************************************************/
bta_jv_l2cap_server_cback(uint16_t gap_handle,uint16_t event,tGAP_CB_DATA * data)1149 static void bta_jv_l2cap_server_cback(uint16_t gap_handle, uint16_t event, tGAP_CB_DATA* data) {
1150 tBTA_JV_L2C_CB* p_cb = &bta_jv_cb.l2c_cb[gap_handle];
1151 tBTA_JV evt_data;
1152 tBTA_JV_L2CAP_CBACK* p_cback;
1153 uint32_t socket_id;
1154
1155 if (gap_handle >= BTA_JV_MAX_L2C_CONN && !p_cb->p_cback) {
1156 return;
1157 }
1158
1159 log::verbose("gap_handle={}, evt=0x{:x}", gap_handle, event);
1160 evt_data.l2c_open.status = tBTA_JV_STATUS::SUCCESS;
1161 evt_data.l2c_open.handle = gap_handle;
1162
1163 switch (event) {
1164 case GAP_EVT_CONN_OPENED:
1165 if (!com::android::bluetooth::flags::socket_settings_api() ||
1166 !GAP_IsTransportLe(gap_handle)) {
1167 evt_data.l2c_open.rem_bda = *GAP_ConnGetRemoteAddr(gap_handle);
1168 evt_data.l2c_open.tx_mtu = GAP_ConnGetRemMtuSize(gap_handle);
1169 if (data != nullptr) {
1170 evt_data.l2c_open.local_cid = data->l2cap_cids.local_cid;
1171 evt_data.l2c_open.remote_cid = data->l2cap_cids.remote_cid;
1172 }
1173 } else {
1174 uint16_t remote_mtu, local_mps, remote_mps, local_credit, remote_credit;
1175 uint16_t local_cid, remote_cid, acl_handle;
1176 evt_data.l2c_open.rem_bda = *GAP_ConnGetRemoteAddr(gap_handle);
1177 if (GAP_GetLeChannelInfo(gap_handle, &remote_mtu, &local_mps, &remote_mps, &local_credit,
1178 &remote_credit, &local_cid, &remote_cid,
1179 &acl_handle) != PORT_SUCCESS) {
1180 log::warn("Unable to get GAP channel info handle:{}", gap_handle);
1181 }
1182 evt_data.l2c_open.tx_mtu = remote_mtu;
1183 evt_data.l2c_open.local_coc_mps = local_mps;
1184 evt_data.l2c_open.remote_coc_mps = remote_mps;
1185 evt_data.l2c_open.local_coc_credit = local_credit;
1186 evt_data.l2c_open.remote_coc_credit = remote_credit;
1187 evt_data.l2c_open.local_cid = local_cid;
1188 evt_data.l2c_open.remote_cid = remote_cid;
1189 evt_data.l2c_open.acl_handle = acl_handle;
1190 }
1191 p_cb->state = BTA_JV_ST_SR_OPEN;
1192 p_cb->p_cback(BTA_JV_L2CAP_OPEN_EVT, &evt_data, p_cb->l2cap_socket_id);
1193 break;
1194
1195 case GAP_EVT_CONN_CLOSED:
1196 evt_data.l2c_close.async = true;
1197 evt_data.l2c_close.handle = p_cb->handle;
1198 p_cback = p_cb->p_cback;
1199 socket_id = p_cb->l2cap_socket_id;
1200 evt_data.l2c_close.status = bta_jv_free_l2c_cb(p_cb);
1201 p_cback(BTA_JV_L2CAP_CLOSE_EVT, &evt_data, socket_id);
1202 break;
1203
1204 case GAP_EVT_CONN_DATA_AVAIL:
1205 evt_data.data_ind.handle = gap_handle;
1206 /* Reset idle timer to avoid requesting sniff mode while receiving data */
1207 bta_jv_pm_conn_busy(p_cb->p_pm_cb);
1208 p_cb->p_cback(BTA_JV_L2CAP_DATA_IND_EVT, &evt_data, p_cb->l2cap_socket_id);
1209 bta_jv_pm_conn_idle(p_cb->p_pm_cb);
1210 break;
1211
1212 case GAP_EVT_TX_EMPTY:
1213 bta_jv_pm_conn_idle(p_cb->p_pm_cb);
1214 break;
1215
1216 case GAP_EVT_CONN_CONGESTED:
1217 case GAP_EVT_CONN_UNCONGESTED:
1218 p_cb->cong = (event == GAP_EVT_CONN_CONGESTED) ? true : false;
1219 evt_data.l2c_cong.cong = p_cb->cong;
1220 p_cb->p_cback(BTA_JV_L2CAP_CONG_EVT, &evt_data, p_cb->l2cap_socket_id);
1221 break;
1222
1223 default:
1224 break;
1225 }
1226 }
1227
1228 /** starts an L2CAP server */
bta_jv_l2cap_start_server(tBTA_JV_CONN_TYPE type,tBTA_SEC sec_mask,uint16_t local_psm,uint16_t rx_mtu,std::unique_ptr<tL2CAP_CFG_INFO> cfg_param,std::unique_ptr<tL2CAP_ERTM_INFO> ertm_info,tBTA_JV_L2CAP_CBACK * p_cback,uint32_t l2cap_socket_id)1229 void bta_jv_l2cap_start_server(tBTA_JV_CONN_TYPE type, tBTA_SEC sec_mask, uint16_t local_psm,
1230 uint16_t rx_mtu, std::unique_ptr<tL2CAP_CFG_INFO> cfg_param,
1231 std::unique_ptr<tL2CAP_ERTM_INFO> ertm_info,
1232 tBTA_JV_L2CAP_CBACK* p_cback, uint32_t l2cap_socket_id) {
1233 uint16_t handle;
1234 tBTA_JV_L2CAP_START evt_data;
1235
1236 tL2CAP_CFG_INFO cfg;
1237 memset(&cfg, 0, sizeof(tL2CAP_CFG_INFO));
1238 if (cfg_param) {
1239 cfg = *cfg_param;
1240 }
1241
1242 // FIX: MTU=0 means not present
1243 if (rx_mtu > 0) {
1244 cfg.mtu_present = true;
1245 cfg.mtu = rx_mtu;
1246 } else {
1247 cfg.mtu_present = false;
1248 cfg.mtu = 0;
1249 }
1250
1251 uint8_t sec_id = bta_jv_alloc_sec_id();
1252 uint16_t max_mps = 0xffff; // Let GAP_ConnOpen set the max_mps.
1253 /* PSM checking is not required for LE COC */
1254
1255 // Given a server socket type
1256 // return the associated transport
1257 const tBT_TRANSPORT transport = [](tBTA_JV_CONN_TYPE type) -> tBT_TRANSPORT {
1258 switch (type) {
1259 case tBTA_JV_CONN_TYPE::L2CAP:
1260 return BT_TRANSPORT_BR_EDR;
1261 case tBTA_JV_CONN_TYPE::L2CAP_LE:
1262 return BT_TRANSPORT_LE;
1263 case tBTA_JV_CONN_TYPE::RFCOMM:
1264 default:
1265 break;
1266 }
1267 log::warn("Unexpected socket type:{}", bta_jv_conn_type_text(type));
1268 return BT_TRANSPORT_AUTO;
1269 }(type);
1270
1271 if (0 == sec_id || ((type == tBTA_JV_CONN_TYPE::L2CAP) && (!bta_jv_check_psm(local_psm))) ||
1272 (handle = GAP_ConnOpen("JV L2CAP", sec_id, 1, nullptr, local_psm, max_mps, &cfg,
1273 ertm_info.get(), sec_mask, bta_jv_l2cap_server_cback, transport)) ==
1274 GAP_INVALID_HANDLE) {
1275 bta_jv_free_sec_id(&sec_id);
1276 evt_data.status = tBTA_JV_STATUS::FAILURE;
1277 } else {
1278 tBTA_JV_L2C_CB* p_cb = &bta_jv_cb.l2c_cb[handle];
1279 evt_data.status = tBTA_JV_STATUS::SUCCESS;
1280 evt_data.handle = handle;
1281 evt_data.sec_id = sec_id;
1282 p_cb->p_cback = p_cback;
1283 p_cb->l2cap_socket_id = l2cap_socket_id;
1284 p_cb->handle = handle;
1285 p_cb->sec_id = sec_id;
1286 p_cb->state = BTA_JV_ST_SR_LISTEN;
1287 p_cb->psm = local_psm;
1288 }
1289
1290 if (p_cback) {
1291 tBTA_JV bta_jv;
1292 bta_jv.l2c_start = evt_data;
1293 p_cback(BTA_JV_L2CAP_START_EVT, &bta_jv, l2cap_socket_id);
1294 }
1295 }
1296
1297 /* stops an L2CAP server */
bta_jv_l2cap_stop_server(uint16_t,uint32_t l2cap_socket_id)1298 void bta_jv_l2cap_stop_server(uint16_t /* local_psm */, uint32_t l2cap_socket_id) {
1299 for (int i = 0; i < BTA_JV_MAX_L2C_CONN; i++) {
1300 if (bta_jv_cb.l2c_cb[i].l2cap_socket_id == l2cap_socket_id) {
1301 tBTA_JV_L2C_CB* p_cb = &bta_jv_cb.l2c_cb[i];
1302 tBTA_JV_L2CAP_CBACK* p_cback = p_cb->p_cback;
1303 tBTA_JV_L2CAP_CLOSE evt_data;
1304 evt_data.handle = p_cb->handle;
1305 evt_data.status = bta_jv_free_l2c_cb(p_cb);
1306 evt_data.async = false;
1307 if (p_cback) {
1308 tBTA_JV bta_jv;
1309 bta_jv.l2c_close = evt_data;
1310 p_cback(BTA_JV_L2CAP_CLOSE_EVT, &bta_jv, l2cap_socket_id);
1311 }
1312 break;
1313 }
1314 }
1315 }
1316
1317 /* Write data to an L2CAP connection */
bta_jv_l2cap_write(uint32_t handle,uint32_t req_id,BT_HDR * msg,uint32_t user_id,tBTA_JV_L2C_CB * p_cb)1318 void bta_jv_l2cap_write(uint32_t handle, uint32_t req_id, BT_HDR* msg, uint32_t user_id,
1319 tBTA_JV_L2C_CB* p_cb) {
1320 /* As we check this callback exists before the tBTA_JV_API_L2CAP_WRITE can be
1321 * send through the API this check should not be needed. But the API is not
1322 * designed to be used (safely at least) in a multi-threaded scheduler, hence
1323 * if the peer device disconnects the l2cap link after the API is called, but
1324 * before this message is handled, the ->p_cback will be cleared at this
1325 * point. At first glanch this seems highly unlikely, but for all
1326 * obex-profiles with two channels connected - e.g. MAP, this happens around 1
1327 * of 4 disconnects, as a disconnect on the server channel causes a disconnect
1328 * to be send on the client (notification) channel, but at the peer typically
1329 * disconnects both the OBEX disconnect request crosses the incoming l2cap
1330 * disconnect. If p_cback is cleared, we simply discard the data. RISK: The
1331 * caller must handle any cleanup based on another signal than
1332 * BTA_JV_L2CAP_WRITE_EVT, which is typically not possible, as the pointer to
1333 * the allocated buffer is stored in this message, and can therefore not be
1334 * freed, hence we have a mem-leak-by-design.*/
1335 if (!p_cb->p_cback) {
1336 /* As this pointer is checked in the API function, this occurs only when the
1337 * channel is disconnected after the API function is called, but before the
1338 * message is handled. */
1339 log::error("p_cb->p_cback == NULL");
1340 osi_free(msg);
1341 return;
1342 }
1343
1344 tBTA_JV_L2CAP_WRITE evt_data;
1345 evt_data.status = tBTA_JV_STATUS::FAILURE;
1346 evt_data.handle = handle;
1347 evt_data.req_id = req_id;
1348 evt_data.cong = p_cb->cong;
1349 evt_data.len = msg->len;
1350
1351 bta_jv_pm_conn_busy(p_cb->p_pm_cb);
1352
1353 // TODO: this was set only for non-fixed channel packets. Is that needed ?
1354 msg->event = BT_EVT_TO_BTU_SP_DATA;
1355
1356 if (evt_data.cong) {
1357 osi_free(msg);
1358 } else {
1359 if (GAP_ConnWriteData(handle, msg) == BT_PASS) {
1360 evt_data.status = tBTA_JV_STATUS::SUCCESS;
1361 }
1362 }
1363
1364 tBTA_JV bta_jv;
1365 bta_jv.l2c_write = evt_data;
1366 p_cb->p_cback(BTA_JV_L2CAP_WRITE_EVT, &bta_jv, user_id);
1367 }
1368
1369 /*******************************************************************************
1370 *
1371 * Function bta_jv_port_data_co_cback
1372 *
1373 * Description port data callback function of rfcomm
1374 * connections
1375 *
1376 * Returns void
1377 *
1378 ******************************************************************************/
bta_jv_port_data_co_cback(uint16_t port_handle,uint8_t * buf,uint16_t len,int type)1379 static int bta_jv_port_data_co_cback(uint16_t port_handle, uint8_t* buf, uint16_t len, int type) {
1380 tBTA_JV_RFC_CB* p_cb = bta_jv_rfc_port_to_cb(port_handle);
1381 tBTA_JV_PCB* p_pcb = bta_jv_rfc_port_to_pcb(port_handle);
1382 log::verbose("p_cb={}, p_pcb={}, len={}, type={}", std::format_ptr(p_cb), std::format_ptr(p_pcb),
1383 len, type);
1384 if (p_pcb != NULL) {
1385 switch (type) {
1386 case DATA_CO_CALLBACK_TYPE_INCOMING:
1387 // Reset sniff timer when receiving data by sysproxy
1388 if (osi_property_get_bool("bluetooth.rfcomm.sysproxy.rx.exit_sniff", false)) {
1389 bta_jv_reset_sniff_timer(p_pcb->p_pm_cb);
1390 }
1391 return bta_co_rfc_data_incoming(p_pcb->rfcomm_slot_id, (BT_HDR*)buf);
1392 case DATA_CO_CALLBACK_TYPE_OUTGOING_SIZE:
1393 return bta_co_rfc_data_outgoing_size(p_pcb->rfcomm_slot_id, (int*)buf);
1394 case DATA_CO_CALLBACK_TYPE_OUTGOING:
1395 return bta_co_rfc_data_outgoing(p_pcb->rfcomm_slot_id, buf, len);
1396 default:
1397 log::error("unknown callout type={}", type);
1398 break;
1399 }
1400 }
1401 return 0;
1402 }
1403
1404 /*******************************************************************************
1405 *
1406 * Function bta_jv_port_mgmt_cl_cback
1407 *
1408 * Description callback for port mamangement function of rfcomm
1409 * client connections
1410 *
1411 * Returns void
1412 *
1413 ******************************************************************************/
bta_jv_port_mgmt_cl_cback(const tPORT_RESULT code,uint16_t port_handle)1414 static void bta_jv_port_mgmt_cl_cback(const tPORT_RESULT code, uint16_t port_handle) {
1415 tBTA_JV_RFC_CB* p_cb = bta_jv_rfc_port_to_cb(port_handle);
1416 tBTA_JV_PCB* p_pcb = bta_jv_rfc_port_to_pcb(port_handle);
1417 RawAddress rem_bda = RawAddress::kEmpty;
1418 uint16_t lcid;
1419 tBTA_JV_RFCOMM_CBACK* p_cback; /* the callback function */
1420
1421 if (p_cb == NULL) {
1422 log::warn("p_cb is NULL, code={}, port_handle={}", code, port_handle);
1423 return;
1424 } else if (p_cb->p_cback == NULL) {
1425 log::warn("p_cb->p_cback is null, code={}, port_handle={}", code, port_handle);
1426 return;
1427 }
1428
1429 log::verbose("code={}, port_handle={}, handle={}", code, port_handle, p_cb->handle);
1430
1431 if (PORT_CheckConnection(port_handle, &rem_bda, &lcid) != PORT_SUCCESS) {
1432 log::warn("Unable to check RFCOMM connection peer:{} handle:{}", rem_bda, port_handle);
1433 }
1434
1435 if (code == PORT_SUCCESS) {
1436 tBTA_JV evt_data = {
1437 .rfc_open =
1438 {
1439 .status = tBTA_JV_STATUS::SUCCESS,
1440 .handle = p_cb->handle,
1441 .rem_bda = rem_bda,
1442 },
1443 };
1444 p_pcb->state = BTA_JV_ST_CL_OPEN;
1445 p_cb->p_cback(BTA_JV_RFCOMM_OPEN_EVT, &evt_data, p_pcb->rfcomm_slot_id);
1446 } else {
1447 tBTA_JV evt_data = {
1448 .rfc_close =
1449 {
1450 .status = tBTA_JV_STATUS::FAILURE,
1451 .port_status = code,
1452 .handle = p_cb->handle,
1453 .async = (p_pcb->state == BTA_JV_ST_CL_CLOSING) ? false : true,
1454 },
1455 };
1456 // p_pcb->state = BTA_JV_ST_NONE;
1457 // p_pcb->cong = false;
1458 p_cback = p_cb->p_cback;
1459 p_cback(BTA_JV_RFCOMM_CLOSE_EVT, &evt_data, p_pcb->rfcomm_slot_id);
1460 // bta_jv_free_rfc_cb(p_cb, p_pcb);
1461 }
1462 }
1463
1464 /*******************************************************************************
1465 *
1466 * Function bta_jv_port_event_cl_cback
1467 *
1468 * Description Callback for RFCOMM client port events
1469 *
1470 * Returns void
1471 *
1472 ******************************************************************************/
bta_jv_port_event_cl_cback(uint32_t code,uint16_t port_handle)1473 static void bta_jv_port_event_cl_cback(uint32_t code, uint16_t port_handle) {
1474 tBTA_JV_RFC_CB* p_cb = bta_jv_rfc_port_to_cb(port_handle);
1475 tBTA_JV_PCB* p_pcb = bta_jv_rfc_port_to_pcb(port_handle);
1476 tBTA_JV evt_data;
1477
1478 log::verbose("port_handle={}", port_handle);
1479 if (NULL == p_cb || NULL == p_cb->p_cback) {
1480 return;
1481 }
1482
1483 log::verbose("code=0x{:x}, port_handle={}, handle={}", code, port_handle, p_cb->handle);
1484 if (code & PORT_EV_RXCHAR) {
1485 evt_data.data_ind.handle = p_cb->handle;
1486 p_cb->p_cback(BTA_JV_RFCOMM_DATA_IND_EVT, &evt_data, p_pcb->rfcomm_slot_id);
1487 }
1488
1489 if (code & PORT_EV_FC) {
1490 p_pcb->cong = (code & PORT_EV_FCS) ? false : true;
1491 evt_data.rfc_cong.cong = p_pcb->cong;
1492 evt_data.rfc_cong.handle = p_cb->handle;
1493 evt_data.rfc_cong.status = tBTA_JV_STATUS::SUCCESS;
1494 p_cb->p_cback(BTA_JV_RFCOMM_CONG_EVT, &evt_data, p_pcb->rfcomm_slot_id);
1495 }
1496
1497 if (code & PORT_EV_TXEMPTY) {
1498 bta_jv_pm_conn_idle(p_pcb->p_pm_cb);
1499 }
1500 }
1501
1502 /* Client initiates an RFCOMM connection */
bta_jv_rfcomm_connect(tBTA_SEC sec_mask,uint8_t remote_scn,const RawAddress & peer_bd_addr,tBTA_JV_RFCOMM_CBACK * p_cback,uint32_t rfcomm_slot_id)1503 void bta_jv_rfcomm_connect(tBTA_SEC sec_mask, uint8_t remote_scn, const RawAddress& peer_bd_addr,
1504 tBTA_JV_RFCOMM_CBACK* p_cback, uint32_t rfcomm_slot_id) {
1505 uint16_t handle = 0;
1506 uint32_t event_mask = BTA_JV_RFC_EV_MASK;
1507 PortSettings port_settings;
1508
1509 tBTA_JV bta_jv = {
1510 .rfc_cl_init =
1511 {
1512 .status = tBTA_JV_STATUS::SUCCESS,
1513 .handle = 0,
1514 .sec_id = 0,
1515 .use_co = false,
1516 },
1517 };
1518
1519 if (com::android::bluetooth::flags::rfcomm_always_use_mitm()) {
1520 // Update security service record for RFCOMM client so that
1521 // secure RFCOMM connection will be authenticated with MTIM protection
1522 // while creating the L2CAP connection.
1523 get_btm_client_interface().security.BTM_SetSecurityLevel(
1524 true, "RFC_MUX", BTM_SEC_SERVICE_RFC_MUX, sec_mask, BT_PSM_RFCOMM, BTM_SEC_PROTO_RFCOMM,
1525 0);
1526 }
1527
1528 if (RFCOMM_CreateConnectionWithSecurity(UUID_SERVCLASS_SERIAL_PORT, remote_scn, false,
1529 BTA_JV_DEF_RFC_MTU, peer_bd_addr, &handle,
1530 bta_jv_port_mgmt_cl_cback, sec_mask) != PORT_SUCCESS) {
1531 log::error("RFCOMM_CreateConnection failed");
1532 bta_jv.rfc_cl_init.status = tBTA_JV_STATUS::FAILURE;
1533 } else {
1534 tBTA_JV_PCB* p_pcb;
1535 tBTA_JV_RFC_CB* p_cb = bta_jv_alloc_rfc_cb(handle, &p_pcb);
1536 if (p_cb) {
1537 p_cb->p_cback = p_cback;
1538 p_cb->scn = 0;
1539 p_pcb->state = BTA_JV_ST_CL_OPENING;
1540 p_pcb->rfcomm_slot_id = rfcomm_slot_id;
1541 bta_jv.rfc_cl_init.use_co = true;
1542
1543 if (PORT_SetEventMaskAndCallback(handle, event_mask, bta_jv_port_event_cl_cback) !=
1544 PORT_SUCCESS) {
1545 log::warn("Unable to set RFCOMM client event mask and callback handle:{}", handle);
1546 }
1547 if (PORT_SetDataCOCallback(handle, bta_jv_port_data_co_cback) != PORT_SUCCESS) {
1548 log::warn("Unable to set RFCOMM client data callback handle:{}", handle);
1549 }
1550 if (PORT_GetSettings(handle, &port_settings) != PORT_SUCCESS) {
1551 log::warn("Unable to get RFCOMM client state handle:{}", handle);
1552 }
1553
1554 port_settings.fc_type = (PORT_FC_CTS_ON_INPUT | PORT_FC_CTS_ON_OUTPUT);
1555
1556 if (PORT_SetSettings(handle, &port_settings) != PORT_SUCCESS) {
1557 log::warn("Unable to set RFCOMM client state handle:{}", handle);
1558 }
1559
1560 bta_jv.rfc_cl_init.handle = p_cb->handle;
1561 } else {
1562 bta_jv.rfc_cl_init.status = tBTA_JV_STATUS::FAILURE;
1563 log::error("run out of rfc control block");
1564 }
1565 }
1566
1567 p_cback(BTA_JV_RFCOMM_CL_INIT_EVT, &bta_jv, rfcomm_slot_id);
1568 if (bta_jv.rfc_cl_init.status == tBTA_JV_STATUS::FAILURE) {
1569 if (handle) {
1570 if (RFCOMM_RemoveConnection(handle) != PORT_SUCCESS) {
1571 log::warn("Unable to remove RFCOMM connection handle:{}", handle);
1572 }
1573 }
1574 }
1575 }
1576
find_rfc_pcb(uint32_t rfcomm_slot_id,tBTA_JV_RFC_CB ** cb,tBTA_JV_PCB ** pcb)1577 static int find_rfc_pcb(uint32_t rfcomm_slot_id, tBTA_JV_RFC_CB** cb, tBTA_JV_PCB** pcb) {
1578 *cb = NULL;
1579 *pcb = NULL;
1580 int i;
1581 for (i = 0; i < MAX_RFC_PORTS; i++) {
1582 uint32_t rfc_handle = bta_jv_cb.port_cb[i].handle & BTA_JV_RFC_HDL_MASK;
1583 rfc_handle &= ~BTA_JV_RFCOMM_MASK;
1584 if (rfc_handle && bta_jv_cb.port_cb[i].rfcomm_slot_id == rfcomm_slot_id) {
1585 *pcb = &bta_jv_cb.port_cb[i];
1586 *cb = &bta_jv_cb.rfc_cb[rfc_handle - 1];
1587 log::verbose(
1588 "FOUND rfc_cb_handle=0x{:x}, port.jv_handle=0x{:x}, state={}, rfc_cb->handle=0x{:x}",
1589 rfc_handle, (*pcb)->handle, (*pcb)->state, (*cb)->handle);
1590 return 1;
1591 }
1592 }
1593 log::verbose("cannot find rfc_cb from user data:{}", rfcomm_slot_id);
1594 return 0;
1595 }
1596
1597 /* Close an RFCOMM connection */
bta_jv_rfcomm_close(uint32_t handle,uint32_t rfcomm_slot_id)1598 void bta_jv_rfcomm_close(uint32_t handle, uint32_t rfcomm_slot_id) {
1599 if (!handle) {
1600 log::error("rfc handle is null");
1601 return;
1602 }
1603
1604 log::verbose("rfc handle={}", handle);
1605
1606 tBTA_JV_RFC_CB* p_cb = NULL;
1607 tBTA_JV_PCB* p_pcb = NULL;
1608
1609 if (!find_rfc_pcb(rfcomm_slot_id, &p_cb, &p_pcb)) {
1610 return;
1611 }
1612 bta_jv_free_rfc_cb(p_cb, p_pcb);
1613 }
1614
1615 /*******************************************************************************
1616 *
1617 * Function bta_jv_port_mgmt_sr_cback
1618 *
1619 * Description callback for port mamangement function of rfcomm
1620 * server connections
1621 *
1622 * Returns void
1623 *
1624 ******************************************************************************/
bta_jv_port_mgmt_sr_cback(const tPORT_RESULT code,uint16_t port_handle)1625 static void bta_jv_port_mgmt_sr_cback(const tPORT_RESULT code, uint16_t port_handle) {
1626 tBTA_JV_PCB* p_pcb = bta_jv_rfc_port_to_pcb(port_handle);
1627 tBTA_JV_RFC_CB* p_cb = bta_jv_rfc_port_to_cb(port_handle);
1628 tBTA_JV evt_data;
1629 RawAddress rem_bda = RawAddress::kEmpty;
1630 uint16_t lcid;
1631 log::verbose("code={}, port_handle={}", code, port_handle);
1632 if (NULL == p_cb || NULL == p_cb->p_cback) {
1633 log::error("p_cb={}, p_cb->p_cback={}", std::format_ptr(p_cb),
1634 std::format_ptr(p_cb ? p_cb->p_cback : nullptr));
1635 return;
1636 }
1637 uint32_t rfcomm_slot_id = p_pcb->rfcomm_slot_id;
1638 log::verbose("code={}, port_handle=0x{:x}, handle=0x{:x}, p_pcb{}, user={}", code, port_handle,
1639 p_cb->handle, std::format_ptr(p_pcb), p_pcb->rfcomm_slot_id);
1640
1641 int status = PORT_CheckConnection(port_handle, &rem_bda, &lcid);
1642 int failed = true;
1643 if (code == PORT_SUCCESS) {
1644 if (status != PORT_SUCCESS) {
1645 log::error("PORT_CheckConnection returned {}, although port is supposed to be connected",
1646 status);
1647 }
1648 evt_data.rfc_srv_open.handle = p_pcb->handle;
1649 evt_data.rfc_srv_open.status = tBTA_JV_STATUS::SUCCESS;
1650 evt_data.rfc_srv_open.rem_bda = rem_bda;
1651 tBTA_JV_PCB* p_pcb_new_listen = bta_jv_add_rfc_port(p_cb, p_pcb);
1652 if (p_pcb_new_listen) {
1653 evt_data.rfc_srv_open.new_listen_handle = p_pcb_new_listen->handle;
1654 p_pcb_new_listen->rfcomm_slot_id =
1655 p_cb->p_cback(BTA_JV_RFCOMM_SRV_OPEN_EVT, &evt_data, rfcomm_slot_id);
1656 if (p_pcb_new_listen->rfcomm_slot_id == 0) {
1657 log::error("rfcomm_slot_id == {}", p_pcb_new_listen->rfcomm_slot_id);
1658 } else {
1659 log::verbose("curr_sess={}, max_sess={}", p_cb->curr_sess, p_cb->max_sess);
1660 failed = false;
1661 }
1662 } else {
1663 log::error("failed to create new listen port");
1664 }
1665 }
1666 if (failed) {
1667 evt_data.rfc_close.handle = p_cb->handle;
1668 evt_data.rfc_close.status = tBTA_JV_STATUS::FAILURE;
1669 evt_data.rfc_close.async = true;
1670 evt_data.rfc_close.port_status = code;
1671 p_pcb->cong = false;
1672
1673 tBTA_JV_RFCOMM_CBACK* p_cback = p_cb->p_cback;
1674 log::verbose("PORT_CLOSED before BTA_JV_RFCOMM_CLOSE_EVT: curr_sess={}, max_sess={}",
1675 p_cb->curr_sess, p_cb->max_sess);
1676 if (BTA_JV_ST_SR_CLOSING == p_pcb->state) {
1677 evt_data.rfc_close.async = false;
1678 evt_data.rfc_close.status = tBTA_JV_STATUS::SUCCESS;
1679 }
1680 // p_pcb->state = BTA_JV_ST_NONE;
1681 p_cback(BTA_JV_RFCOMM_CLOSE_EVT, &evt_data, rfcomm_slot_id);
1682 // bta_jv_free_rfc_cb(p_cb, p_pcb);
1683
1684 log::verbose("PORT_CLOSED after BTA_JV_RFCOMM_CLOSE_EVT: curr_sess={}, max_sess={}",
1685 p_cb->curr_sess, p_cb->max_sess);
1686 }
1687 }
1688
1689 /*******************************************************************************
1690 *
1691 * Function bta_jv_port_event_sr_cback
1692 *
1693 * Description Callback for RFCOMM server port events
1694 *
1695 * Returns void
1696 *
1697 ******************************************************************************/
bta_jv_port_event_sr_cback(uint32_t code,uint16_t port_handle)1698 static void bta_jv_port_event_sr_cback(uint32_t code, uint16_t port_handle) {
1699 tBTA_JV_PCB* p_pcb = bta_jv_rfc_port_to_pcb(port_handle);
1700 tBTA_JV_RFC_CB* p_cb = bta_jv_rfc_port_to_cb(port_handle);
1701 tBTA_JV evt_data;
1702
1703 if (NULL == p_cb || NULL == p_cb->p_cback) {
1704 log::error("p_cb={}, p_cb->p_cback={}", std::format_ptr(p_cb),
1705 std::format_ptr(p_cb ? p_cb->p_cback : nullptr));
1706 return;
1707 }
1708
1709 log::verbose("code=0x{:x}, port_handle={}, handle={}", code, port_handle, p_cb->handle);
1710
1711 uint32_t user_data = p_pcb->rfcomm_slot_id;
1712 if (code & PORT_EV_RXCHAR) {
1713 evt_data.data_ind.handle = p_cb->handle;
1714 p_cb->p_cback(BTA_JV_RFCOMM_DATA_IND_EVT, &evt_data, user_data);
1715 }
1716
1717 if (code & PORT_EV_FC) {
1718 p_pcb->cong = (code & PORT_EV_FCS) ? false : true;
1719 evt_data.rfc_cong.cong = p_pcb->cong;
1720 evt_data.rfc_cong.handle = p_cb->handle;
1721 evt_data.rfc_cong.status = tBTA_JV_STATUS::SUCCESS;
1722 p_cb->p_cback(BTA_JV_RFCOMM_CONG_EVT, &evt_data, user_data);
1723 }
1724
1725 if (code & PORT_EV_TXEMPTY) {
1726 bta_jv_pm_conn_idle(p_pcb->p_pm_cb);
1727 }
1728 }
1729
1730 /*******************************************************************************
1731 *
1732 * Function bta_jv_add_rfc_port
1733 *
1734 * Description add a port for server when the existing posts is open
1735 *
1736 * Returns return a pointer to tBTA_JV_PCB just added
1737 *
1738 ******************************************************************************/
bta_jv_add_rfc_port(tBTA_JV_RFC_CB * p_cb,tBTA_JV_PCB * p_pcb_open)1739 static tBTA_JV_PCB* bta_jv_add_rfc_port(tBTA_JV_RFC_CB* p_cb, tBTA_JV_PCB* p_pcb_open) {
1740 uint8_t used = 0, i, listen = 0;
1741 uint32_t si = 0;
1742 PortSettings port_settings;
1743 uint32_t event_mask = BTA_JV_RFC_EV_MASK;
1744 tBTA_JV_PCB* p_pcb = NULL;
1745 tBTA_SEC sec_mask;
1746 if (p_cb->max_sess > 1) {
1747 for (i = 0; i < p_cb->max_sess; i++) {
1748 if (p_cb->rfc_hdl[i] != 0) {
1749 p_pcb = &bta_jv_cb.port_cb[p_cb->rfc_hdl[i] - 1];
1750 if (p_pcb->state == BTA_JV_ST_SR_LISTEN) {
1751 listen++;
1752 if (p_pcb_open == p_pcb) {
1753 log::verbose("port_handle={}, change the listen port to open state",
1754 p_pcb->port_handle);
1755 p_pcb->state = BTA_JV_ST_SR_OPEN;
1756
1757 } else {
1758 log::error(
1759 "open pcb not matching listen one, count={}, listen pcb handle={}, open pcb={}",
1760 listen, p_pcb->port_handle, p_pcb_open->handle);
1761 return NULL;
1762 }
1763 }
1764 used++;
1765 } else if (si == 0) {
1766 si = i + 1;
1767 }
1768 }
1769
1770 log::verbose("max_sess={}, used={}, curr_sess={}, listen={}, si={}", p_cb->max_sess, used,
1771 p_cb->curr_sess, listen, si);
1772 if (used < p_cb->max_sess && listen == 1 && si) {
1773 si--;
1774 if (PORT_GetSecurityMask(p_pcb_open->port_handle, &sec_mask) != PORT_SUCCESS) {
1775 log::error("RFCOMM_CreateConnection failed: invalid port_handle");
1776 }
1777
1778 if (RFCOMM_CreateConnectionWithSecurity(
1779 p_cb->sec_id, p_cb->scn, true, BTA_JV_DEF_RFC_MTU, RawAddress::kAny,
1780 &(p_cb->rfc_hdl[si]), bta_jv_port_mgmt_sr_cback, sec_mask) == PORT_SUCCESS) {
1781 p_cb->curr_sess++;
1782 p_pcb = &bta_jv_cb.port_cb[p_cb->rfc_hdl[si] - 1];
1783 p_pcb->state = BTA_JV_ST_SR_LISTEN;
1784 p_pcb->port_handle = p_cb->rfc_hdl[si];
1785 p_pcb->rfcomm_slot_id = p_pcb_open->rfcomm_slot_id;
1786
1787 if (PORT_ClearKeepHandleFlag(p_pcb->port_handle) != PORT_SUCCESS) {
1788 log::warn("Unable to clear RFCOMM server keep handle flag handle:{}", p_pcb->port_handle);
1789 }
1790 if (PORT_SetEventMaskAndCallback(p_pcb->port_handle, event_mask,
1791 bta_jv_port_event_sr_cback) != PORT_SUCCESS) {
1792 log::warn("Unable to set RFCOMM server event mask and callback handle:{}",
1793 p_pcb->port_handle);
1794 }
1795 if (PORT_SetDataCOCallback(p_pcb->port_handle, bta_jv_port_data_co_cback) != PORT_SUCCESS) {
1796 log::warn("Unable to set RFCOMM server data callback handle:{}", p_pcb->port_handle);
1797 }
1798 if (PORT_GetSettings(p_pcb->port_handle, &port_settings) != PORT_SUCCESS) {
1799 log::warn("Unable to get RFCOMM server state handle:{}", p_pcb->port_handle);
1800 }
1801
1802 port_settings.fc_type = (PORT_FC_CTS_ON_INPUT | PORT_FC_CTS_ON_OUTPUT);
1803
1804 if (PORT_SetSettings(p_pcb->port_handle, &port_settings) != PORT_SUCCESS) {
1805 log::warn("Unable to set RFCOMM server state handle:{}", p_pcb->port_handle);
1806 }
1807 p_pcb->handle = BTA_JV_RFC_H_S_TO_HDL(p_cb->handle, si);
1808 log::verbose("p_pcb->handle=0x{:x}, curr_sess={}", p_pcb->handle, p_cb->curr_sess);
1809 } else {
1810 log::error("RFCOMM_CreateConnection failed");
1811 return NULL;
1812 }
1813 } else {
1814 log::error("cannot create new rfc listen port");
1815 return NULL;
1816 }
1817 }
1818 log::verbose("sec id in use={}, rfc_cb in use={}", get_sec_id_used(), get_rfc_cb_used());
1819 return p_pcb;
1820 }
1821
1822 /* waits for an RFCOMM client to connect */
bta_jv_rfcomm_start_server(tBTA_SEC sec_mask,uint8_t local_scn,uint8_t max_session,tBTA_JV_RFCOMM_CBACK * p_cback,uint32_t rfcomm_slot_id)1823 void bta_jv_rfcomm_start_server(tBTA_SEC sec_mask, uint8_t local_scn, uint8_t max_session,
1824 tBTA_JV_RFCOMM_CBACK* p_cback, uint32_t rfcomm_slot_id) {
1825 uint16_t handle = 0;
1826 uint32_t event_mask = BTA_JV_RFC_EV_MASK;
1827 PortSettings port_settings;
1828 tBTA_JV_RFC_CB* p_cb = NULL;
1829 tBTA_JV_PCB* p_pcb;
1830 tBTA_JV_RFCOMM_START evt_data;
1831
1832 memset(&evt_data, 0, sizeof(evt_data));
1833 evt_data.status = tBTA_JV_STATUS::FAILURE;
1834
1835 do {
1836 if (RFCOMM_CreateConnectionWithSecurity(0, local_scn, true, BTA_JV_DEF_RFC_MTU,
1837 RawAddress::kAny, &handle, bta_jv_port_mgmt_sr_cback,
1838 sec_mask) != PORT_SUCCESS) {
1839 log::error("RFCOMM_CreateConnection failed");
1840 break;
1841 }
1842
1843 p_cb = bta_jv_alloc_rfc_cb(handle, &p_pcb);
1844 if (!p_cb) {
1845 log::error("run out of rfc control block");
1846 break;
1847 }
1848
1849 p_cb->max_sess = max_session;
1850 p_cb->p_cback = p_cback;
1851 p_cb->scn = local_scn;
1852 p_pcb->state = BTA_JV_ST_SR_LISTEN;
1853 p_pcb->rfcomm_slot_id = rfcomm_slot_id;
1854 evt_data.status = tBTA_JV_STATUS::SUCCESS;
1855 evt_data.handle = p_cb->handle;
1856 evt_data.use_co = true;
1857
1858 if (PORT_ClearKeepHandleFlag(handle) != PORT_SUCCESS) {
1859 log::warn("Unable to clear RFCOMM server keep handle flag handle:{}", handle);
1860 }
1861 if (PORT_SetEventMaskAndCallback(handle, event_mask, bta_jv_port_event_sr_cback) !=
1862 PORT_SUCCESS) {
1863 log::warn("Unable to set RFCOMM server event mask and callback handle:{}", handle);
1864 }
1865 if (PORT_GetSettings(handle, &port_settings) != PORT_SUCCESS) {
1866 log::warn("Unable to get RFCOMM server state handle:{}", handle);
1867 }
1868
1869 port_settings.fc_type = (PORT_FC_CTS_ON_INPUT | PORT_FC_CTS_ON_OUTPUT);
1870
1871 if (PORT_SetSettings(handle, &port_settings) != PORT_SUCCESS) {
1872 log::warn("Unable to set RFCOMM port state handle:{}", handle);
1873 }
1874 } while (0);
1875
1876 tBTA_JV bta_jv;
1877 bta_jv.rfc_start = evt_data;
1878 p_cback(BTA_JV_RFCOMM_START_EVT, &bta_jv, rfcomm_slot_id);
1879 if (bta_jv.rfc_start.status == tBTA_JV_STATUS::SUCCESS) {
1880 if (PORT_SetDataCOCallback(handle, bta_jv_port_data_co_cback) != PORT_SUCCESS) {
1881 log::error("Unable to set RFCOMM server data callback handle:{}", handle);
1882 }
1883 } else {
1884 if (handle) {
1885 if (RFCOMM_RemoveConnection(handle) != PORT_SUCCESS) {
1886 log::warn("Unable to remote RFCOMM server connection handle:{}", handle);
1887 }
1888 }
1889 }
1890 }
1891
1892 /* stops an RFCOMM server */
bta_jv_rfcomm_stop_server(uint32_t handle,uint32_t rfcomm_slot_id)1893 void bta_jv_rfcomm_stop_server(uint32_t handle, uint32_t rfcomm_slot_id) {
1894 if (!handle) {
1895 log::error("jv handle is null");
1896 return;
1897 }
1898
1899 log::verbose("");
1900 tBTA_JV_RFC_CB* p_cb = NULL;
1901 tBTA_JV_PCB* p_pcb = NULL;
1902
1903 if (!find_rfc_pcb(rfcomm_slot_id, &p_cb, &p_pcb)) {
1904 return;
1905 }
1906 log::verbose("p_pcb={}, p_pcb->port_handle={}", std::format_ptr(p_pcb), p_pcb->port_handle);
1907 bta_jv_free_rfc_cb(p_cb, p_pcb);
1908 }
1909
1910 /* write data to an RFCOMM connection */
bta_jv_rfcomm_write(uint32_t handle,uint32_t req_id,tBTA_JV_RFC_CB * p_cb,tBTA_JV_PCB * p_pcb)1911 void bta_jv_rfcomm_write(uint32_t handle, uint32_t req_id, tBTA_JV_RFC_CB* p_cb,
1912 tBTA_JV_PCB* p_pcb) {
1913 if (p_pcb->state == BTA_JV_ST_NONE) {
1914 log::error("in state BTA_JV_ST_NONE - cannot write");
1915 return;
1916 }
1917
1918 tBTA_JV_RFCOMM_WRITE evt_data;
1919 evt_data.status = tBTA_JV_STATUS::FAILURE;
1920 evt_data.handle = handle;
1921 evt_data.req_id = req_id;
1922 evt_data.cong = p_pcb->cong;
1923 evt_data.len = 0;
1924
1925 bta_jv_pm_conn_busy(p_pcb->p_pm_cb);
1926
1927 if (!evt_data.cong && PORT_WriteDataCO(p_pcb->port_handle, &evt_data.len) == PORT_SUCCESS) {
1928 evt_data.status = tBTA_JV_STATUS::SUCCESS;
1929 }
1930
1931 // Update congestion flag
1932 evt_data.cong = p_pcb->cong;
1933
1934 if (!p_cb->p_cback) {
1935 log::error("No JV callback set");
1936 return;
1937 }
1938
1939 tBTA_JV bta_jv;
1940 bta_jv.rfc_write = evt_data;
1941 p_cb->p_cback(BTA_JV_RFCOMM_WRITE_EVT, &bta_jv, p_pcb->rfcomm_slot_id);
1942 }
1943
1944 /* Set or free power mode profile for a JV application */
bta_jv_set_pm_profile(uint32_t handle,tBTA_JV_PM_ID app_id,tBTA_JV_CONN_STATE init_st)1945 void bta_jv_set_pm_profile(uint32_t handle, tBTA_JV_PM_ID app_id, tBTA_JV_CONN_STATE init_st) {
1946 log::verbose("handle=0x{:x}, app_id={}, init_st={}", handle, app_id,
1947 bta_jv_conn_state_text(init_st));
1948
1949 /* clear PM control block */
1950 if (app_id == BTA_JV_PM_ID_CLEAR) {
1951 tBTA_JV_STATUS status = bta_jv_free_set_pm_profile_cb(handle);
1952 if (status != tBTA_JV_STATUS::SUCCESS) {
1953 log::warn("Unable to free a power mode profile handle:0x:{:x} app_id:{} state:{} status:{}",
1954 handle, app_id, init_st, bta_jv_status_text(status));
1955 }
1956 } else { /* set PM control block */
1957 tBTA_JV_PM_CB* p_cb = bta_jv_alloc_set_pm_profile_cb(handle, app_id);
1958 if (p_cb) {
1959 bta_jv_pm_state_change(p_cb, init_st);
1960 } else {
1961 log::warn("Unable to allocate a power mode profile handle:0x:{:x} app_id:{} state:{}", handle,
1962 app_id, init_st);
1963 }
1964 }
1965 }
1966
1967 /*******************************************************************************
1968 *
1969 * Function bta_jv_pm_conn_busy
1970 *
1971 * Description set pm connection busy state (input param safe)
1972 *
1973 * Params p_cb: pm control block of jv connection
1974 *
1975 * Returns void
1976 *
1977 ******************************************************************************/
bta_jv_pm_conn_busy(tBTA_JV_PM_CB * p_cb)1978 static void bta_jv_pm_conn_busy(tBTA_JV_PM_CB* p_cb) {
1979 if ((NULL != p_cb) && (BTA_JV_PM_IDLE_ST == p_cb->state)) {
1980 bta_jv_pm_state_change(p_cb, BTA_JV_CONN_BUSY);
1981 }
1982 }
1983
1984 /*******************************************************************************
1985 *
1986 * Function bta_jv_pm_conn_idle
1987 *
1988 * Description set pm connection idle state (input param safe)
1989 *
1990 * Params p_cb: pm control block of jv connection
1991 *
1992 * Returns void
1993 *
1994 ******************************************************************************/
bta_jv_pm_conn_idle(tBTA_JV_PM_CB * p_cb)1995 static void bta_jv_pm_conn_idle(tBTA_JV_PM_CB* p_cb) {
1996 if ((NULL != p_cb) && (BTA_JV_PM_IDLE_ST != p_cb->state)) {
1997 bta_jv_pm_state_change(p_cb, BTA_JV_CONN_IDLE);
1998 }
1999 }
2000
2001 /*******************************************************************************
2002 *
2003 * Function bta_jv_pm_state_change
2004 *
2005 * Description Notify power manager there is state change
2006 *
2007 * Params p_cb: must be NONE NULL
2008 *
2009 * Returns void
2010 *
2011 ******************************************************************************/
bta_jv_pm_state_change(tBTA_JV_PM_CB * p_cb,const tBTA_JV_CONN_STATE state)2012 static void bta_jv_pm_state_change(tBTA_JV_PM_CB* p_cb, const tBTA_JV_CONN_STATE state) {
2013 log::verbose("p_cb={}, handle=0x{:x}, busy/idle_state={}, app_id={}, conn_state={}",
2014 std::format_ptr(p_cb), p_cb->handle, p_cb->state, p_cb->app_id,
2015 bta_jv_conn_state_text(state));
2016
2017 switch (state) {
2018 case BTA_JV_CONN_OPEN:
2019 bta_sys_conn_open(BTA_ID_JV, p_cb->app_id, p_cb->peer_bd_addr);
2020 break;
2021
2022 case BTA_JV_CONN_CLOSE:
2023 bta_sys_conn_close(BTA_ID_JV, p_cb->app_id, p_cb->peer_bd_addr);
2024 break;
2025
2026 case BTA_JV_APP_OPEN:
2027 bta_sys_app_open(BTA_ID_JV, p_cb->app_id, p_cb->peer_bd_addr);
2028 break;
2029
2030 case BTA_JV_APP_CLOSE:
2031 bta_sys_app_close(BTA_ID_JV, p_cb->app_id, p_cb->peer_bd_addr);
2032 break;
2033
2034 case BTA_JV_SCO_OPEN:
2035 bta_sys_sco_open(BTA_ID_JV, p_cb->app_id, p_cb->peer_bd_addr);
2036 break;
2037
2038 case BTA_JV_SCO_CLOSE:
2039 bta_sys_sco_close(BTA_ID_JV, p_cb->app_id, p_cb->peer_bd_addr);
2040 break;
2041
2042 case BTA_JV_CONN_IDLE:
2043 p_cb->state = BTA_JV_PM_IDLE_ST;
2044 bta_sys_idle(BTA_ID_JV, p_cb->app_id, p_cb->peer_bd_addr);
2045 break;
2046
2047 case BTA_JV_CONN_BUSY:
2048 p_cb->state = BTA_JV_PM_BUSY_ST;
2049 bta_sys_busy(BTA_ID_JV, p_cb->app_id, p_cb->peer_bd_addr);
2050 break;
2051
2052 default:
2053 log::warn("Invalid state={}", bta_jv_conn_state_text(state));
2054 break;
2055 }
2056 }
2057
2058 /*******************************************************************************
2059 *
2060 * Function bta_jv_reset_sniff_timer
2061 *
2062 * Description reset pm sniff timer state (input param safe)
2063 *
2064 * Params p_cb: pm control block of jv connection
2065 *
2066 * Returns void
2067 *
2068 ******************************************************************************/
bta_jv_reset_sniff_timer(tBTA_JV_PM_CB * p_cb)2069 static void bta_jv_reset_sniff_timer(tBTA_JV_PM_CB* p_cb) {
2070 if (NULL != p_cb) {
2071 p_cb->state = BTA_JV_PM_IDLE_ST;
2072 bta_sys_reset_sniff(BTA_ID_JV, p_cb->app_id, p_cb->peer_bd_addr);
2073 }
2074 }
2075 /******************************************************************************/
2076
2077 namespace bluetooth::legacy::testing {
2078
bta_jv_start_discovery_cback(uint32_t rfcomm_slot_id,const RawAddress & bd_addr,tSDP_RESULT result)2079 void bta_jv_start_discovery_cback(uint32_t rfcomm_slot_id, const RawAddress& bd_addr,
2080 tSDP_RESULT result) {
2081 ::bta_jv_start_discovery_cback(rfcomm_slot_id, bd_addr, result);
2082 }
2083
2084 } // namespace bluetooth::legacy::testing
2085