1 /******************************************************************************
2 *
3 * Copyright 2014 The Android Open Source Project
4 * Copyright 2009-2012 Broadcom Corporation
5 *
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at:
9 *
10 * http://www.apache.org/licenses/LICENSE-2.0
11 *
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
17 *
18 ******************************************************************************/
19
20 /*******************************************************************************
21 *
22 * Filename: btif_core.c
23 *
24 * Description: Contains core functionality related to interfacing between
25 * Bluetooth HAL and BTE core stack.
26 *
27 ******************************************************************************/
28
29 #define LOG_TAG "bt_btif_core"
30
31 #include <base/at_exit.h>
32 #include <base/bind.h>
33 #include <base/run_loop.h>
34 #include <base/threading/platform_thread.h>
35 #include <base/threading/thread.h>
36 #include <ctype.h>
37 #include <dirent.h>
38 #include <fcntl.h>
39 #include <hardware/bluetooth.h>
40 #include <stdlib.h>
41 #include <string.h>
42 #include <sys/stat.h>
43 #include <sys/types.h>
44 #include <unistd.h>
45
46 #include "bt_common.h"
47 #include "bt_utils.h"
48 #include "bta_api.h"
49 #include "bta_closure_api.h"
50 #include "bte.h"
51 #include "btif_api.h"
52 #include "btif_av.h"
53 #include "btif_config.h"
54 #include "btif_pan.h"
55 #include "btif_profile_queue.h"
56 #include "btif_sock.h"
57 #include "btif_storage.h"
58 #include "btif_uid.h"
59 #include "btif_util.h"
60 #include "btu.h"
61 #include "device/include/controller.h"
62 #include "osi/include/fixed_queue.h"
63 #include "osi/include/future.h"
64 #include "osi/include/log.h"
65 #include "osi/include/osi.h"
66 #include "osi/include/properties.h"
67 #include "osi/include/thread.h"
68 #include "stack_manager.h"
69
70 using base::PlatformThread;
71 using bluetooth::Uuid;
72
73 /*******************************************************************************
74 * Constants & Macros
75 ******************************************************************************/
76
77 #ifndef BTE_DID_CONF_FILE
78 // TODO(armansito): Find a better way than searching by a hardcoded path.
79 #if defined(OS_GENERIC)
80 #define BTE_DID_CONF_FILE "bt_did.conf"
81 #else // !defined(OS_GENERIC)
82 #define BTE_DID_CONF_FILE "/etc/bluetooth/bt_did.conf"
83 #endif // defined(OS_GENERIC)
84 #endif // BTE_DID_CONF_FILE
85
86 /*******************************************************************************
87 * Local type definitions
88 ******************************************************************************/
89
90 /* These type definitions are used when passing data from the HAL to BTIF
91 * context in the downstream path for the adapter and remote_device property
92 * APIs
93 */
94
95 typedef struct {
96 RawAddress bd_addr;
97 bt_property_type_t type;
98 } btif_storage_read_t;
99
100 typedef struct {
101 RawAddress bd_addr;
102 bt_property_t prop;
103 } btif_storage_write_t;
104
105 typedef union {
106 btif_storage_read_t read_req;
107 btif_storage_write_t write_req;
108 } btif_storage_req_t;
109
110 typedef enum {
111 BTIF_CORE_STATE_DISABLED = 0,
112 BTIF_CORE_STATE_ENABLING,
113 BTIF_CORE_STATE_ENABLED,
114 BTIF_CORE_STATE_DISABLING
115 } btif_core_state_t;
116
117 /*******************************************************************************
118 * Static variables
119 ******************************************************************************/
120
121 static tBTA_SERVICE_MASK btif_enabled_services = 0;
122
123 /*
124 * This variable should be set to 1, if the Bluedroid+BTIF libraries are to
125 * function in DUT mode.
126 *
127 * To set this, the btif_init_bluetooth needs to be called with argument as 1
128 */
129 static uint8_t btif_dut_mode = 0;
130
131 static thread_t* bt_jni_workqueue_thread;
132 static const char* BT_JNI_WORKQUEUE_NAME = "bt_jni_workqueue";
133 static uid_set_t* uid_set = NULL;
134 base::MessageLoop* message_loop_ = NULL;
135 base::RunLoop* jni_run_loop = NULL;
136 static base::PlatformThreadId btif_thread_id_ = -1;
137
138 /*******************************************************************************
139 * Static functions
140 ******************************************************************************/
141 static void btif_jni_associate();
142 static void btif_jni_disassociate();
143
144 /* sends message to btif task */
145 static void btif_sendmsg(void* p_msg);
146
147 /*******************************************************************************
148 * Externs
149 ******************************************************************************/
150 extern fixed_queue_t* btu_hci_msg_queue;
151
152 void btif_dm_execute_service_request(uint16_t event, char* p_param);
153 #ifdef BTIF_DM_OOB_TEST
154 void btif_dm_load_local_oob(void);
155 #endif
156
157 /*******************************************************************************
158 *
159 * Function btif_context_switched
160 *
161 * Description Callback used to execute transferred context callback
162 *
163 * p_msg : message to be executed in btif context
164 *
165 * Returns void
166 *
167 ******************************************************************************/
168
btif_context_switched(void * p_msg)169 static void btif_context_switched(void* p_msg) {
170 BTIF_TRACE_VERBOSE("btif_context_switched");
171
172 tBTIF_CONTEXT_SWITCH_CBACK* p = (tBTIF_CONTEXT_SWITCH_CBACK*)p_msg;
173
174 /* each callback knows how to parse the data */
175 if (p->p_cb) p->p_cb(p->event, p->p_param);
176 }
177
178 /*******************************************************************************
179 *
180 * Function btif_transfer_context
181 *
182 * Description This function switches context to btif task
183 *
184 * p_cback : callback used to process message in btif context
185 * event : event id of message
186 * p_params : parameter area passed to callback (copied)
187 * param_len : length of parameter area
188 * p_copy_cback : If set this function will be invoked for deep
189 * copy
190 *
191 * Returns void
192 *
193 ******************************************************************************/
194
btif_transfer_context(tBTIF_CBACK * p_cback,uint16_t event,char * p_params,int param_len,tBTIF_COPY_CBACK * p_copy_cback)195 bt_status_t btif_transfer_context(tBTIF_CBACK* p_cback, uint16_t event,
196 char* p_params, int param_len,
197 tBTIF_COPY_CBACK* p_copy_cback) {
198 tBTIF_CONTEXT_SWITCH_CBACK* p_msg = (tBTIF_CONTEXT_SWITCH_CBACK*)osi_malloc(
199 sizeof(tBTIF_CONTEXT_SWITCH_CBACK) + param_len);
200
201 BTIF_TRACE_VERBOSE("btif_transfer_context event %d, len %d", event,
202 param_len);
203
204 /* allocate and send message that will be executed in btif context */
205 p_msg->hdr.event = BT_EVT_CONTEXT_SWITCH_EVT; /* internal event */
206 p_msg->p_cb = p_cback;
207
208 p_msg->event = event; /* callback event */
209
210 /* check if caller has provided a copy callback to do the deep copy */
211 if (p_copy_cback) {
212 p_copy_cback(event, p_msg->p_param, p_params);
213 } else if (p_params) {
214 memcpy(p_msg->p_param, p_params, param_len); /* callback parameter data */
215 }
216
217 btif_sendmsg(p_msg);
218
219 return BT_STATUS_SUCCESS;
220 }
221
222 /**
223 * This function posts a task into the btif message loop, that executes it in
224 * the JNI message loop.
225 **/
do_in_jni_thread(const tracked_objects::Location & from_here,const base::Closure & task)226 bt_status_t do_in_jni_thread(const tracked_objects::Location& from_here,
227 const base::Closure& task) {
228 if (!message_loop_) {
229 BTIF_TRACE_WARNING("%s: Dropped message, message_loop not initialized yet!",
230 __func__);
231 return BT_STATUS_FAIL;
232 }
233
234 scoped_refptr<base::SingleThreadTaskRunner> task_runner =
235 message_loop_->task_runner();
236 if (!task_runner.get()) {
237 BTIF_TRACE_WARNING("%s: task runner is dead", __func__);
238 return BT_STATUS_FAIL;
239 }
240
241 if (task_runner->PostTask(from_here, task)) return BT_STATUS_SUCCESS;
242
243 BTIF_TRACE_ERROR("%s: Post task to task runner failed!", __func__);
244 return BT_STATUS_FAIL;
245 }
246
do_in_jni_thread(const base::Closure & task)247 bt_status_t do_in_jni_thread(const base::Closure& task) {
248 return do_in_jni_thread(FROM_HERE, task);
249 }
250
is_on_jni_thread()251 bool is_on_jni_thread() {
252 return btif_thread_id_ == PlatformThread::CurrentId();
253 }
254
get_jni_message_loop()255 base::MessageLoop* get_jni_message_loop() { return message_loop_; }
256
257 /*******************************************************************************
258 *
259 * Function btif_is_dut_mode
260 *
261 * Description checks if BTIF is currently in DUT mode
262 *
263 * Returns 1 if test mode, otherwize 0
264 *
265 ******************************************************************************/
266
btif_is_dut_mode(void)267 uint8_t btif_is_dut_mode(void) { return (btif_dut_mode == 1); }
268
269 /*******************************************************************************
270 *
271 * Function btif_is_enabled
272 *
273 * Description checks if main adapter is fully enabled
274 *
275 * Returns 1 if fully enabled, otherwize 0
276 *
277 ******************************************************************************/
278
btif_is_enabled(void)279 int btif_is_enabled(void) {
280 return ((!btif_is_dut_mode()) &&
281 (stack_manager_get_interface()->get_stack_is_running()));
282 }
283
btif_init_ok(UNUSED_ATTR uint16_t event,UNUSED_ATTR char * p_param)284 void btif_init_ok(UNUSED_ATTR uint16_t event, UNUSED_ATTR char* p_param) {
285 BTIF_TRACE_DEBUG("btif_task: received trigger stack init event");
286 btif_dm_load_ble_local_keys();
287 BTA_EnableBluetooth(bte_dm_evt);
288 }
289
290 /*******************************************************************************
291 *
292 * Function btif_task
293 *
294 * Description BTIF task handler managing all messages being passed
295 * Bluetooth HAL and BTA.
296 *
297 * Returns void
298 *
299 ******************************************************************************/
bt_jni_msg_ready(void * context)300 static void bt_jni_msg_ready(void* context) {
301 BT_HDR* p_msg = (BT_HDR*)context;
302
303 BTIF_TRACE_VERBOSE("btif task fetched event %x", p_msg->event);
304
305 switch (p_msg->event) {
306 case BT_EVT_CONTEXT_SWITCH_EVT:
307 btif_context_switched(p_msg);
308 break;
309 default:
310 BTIF_TRACE_ERROR("unhandled btif event (%d)", p_msg->event & BT_EVT_MASK);
311 break;
312 }
313 osi_free(p_msg);
314 }
315
316 /*******************************************************************************
317 *
318 * Function btif_sendmsg
319 *
320 * Description Sends msg to BTIF task
321 *
322 * Returns void
323 *
324 ******************************************************************************/
325
btif_sendmsg(void * p_msg)326 void btif_sendmsg(void* p_msg) {
327 do_in_jni_thread(base::Bind(&bt_jni_msg_ready, p_msg));
328 }
329
btif_thread_post(thread_fn func,void * context)330 void btif_thread_post(thread_fn func, void* context) {
331 do_in_jni_thread(base::Bind(func, context));
332 }
333
run_message_loop(UNUSED_ATTR void * context)334 void run_message_loop(UNUSED_ATTR void* context) {
335 LOG_INFO(LOG_TAG, "%s entered", __func__);
336 btif_thread_id_ = PlatformThread::CurrentId();
337
338 // TODO(jpawlowski): exit_manager should be defined in main(), but there is no
339 // main method.
340 // It is therefore defined in bt_jni_workqueue_thread, and will be deleted
341 // when we free it.
342 base::AtExitManager exit_manager;
343
344 message_loop_ = new base::MessageLoop(base::MessageLoop::Type::TYPE_DEFAULT);
345
346 // Associate this workqueue thread with JNI.
347 message_loop_->task_runner()->PostTask(FROM_HERE,
348 base::Bind(&btif_jni_associate));
349
350 jni_run_loop = new base::RunLoop();
351 jni_run_loop->Run();
352
353 delete message_loop_;
354 message_loop_ = NULL;
355
356 delete jni_run_loop;
357 jni_run_loop = NULL;
358
359 btif_thread_id_ = -1;
360 LOG_INFO(LOG_TAG, "%s finished", __func__);
361 }
362 /*******************************************************************************
363 *
364 * Function btif_init_bluetooth
365 *
366 * Description Creates BTIF task and prepares BT scheduler for startup
367 *
368 * Returns bt_status_t
369 *
370 ******************************************************************************/
btif_init_bluetooth()371 bt_status_t btif_init_bluetooth() {
372 LOG_INFO(LOG_TAG, "%s entered", __func__);
373
374 bte_main_boot_entry();
375
376 bt_jni_workqueue_thread = thread_new(BT_JNI_WORKQUEUE_NAME);
377 if (bt_jni_workqueue_thread == NULL) {
378 LOG_ERROR(LOG_TAG, "%s Unable to create thread %s", __func__,
379 BT_JNI_WORKQUEUE_NAME);
380 goto error_exit;
381 }
382
383 thread_post(bt_jni_workqueue_thread, run_message_loop, nullptr);
384
385 LOG_INFO(LOG_TAG, "%s finished", __func__);
386 return BT_STATUS_SUCCESS;
387
388 error_exit:;
389 thread_free(bt_jni_workqueue_thread);
390
391 bt_jni_workqueue_thread = NULL;
392
393 return BT_STATUS_FAIL;
394 }
395
396 /*******************************************************************************
397 *
398 * Function btif_enable_bluetooth_evt
399 *
400 * Description Event indicating bluetooth enable is completed
401 * Notifies HAL user with updated adapter state
402 *
403 * Returns void
404 *
405 ******************************************************************************/
406
btif_enable_bluetooth_evt(tBTA_STATUS status)407 void btif_enable_bluetooth_evt(tBTA_STATUS status) {
408 LOG_INFO(LOG_TAG, "%s entered: status %d", __func__, status);
409
410 /* Fetch the local BD ADDR */
411 RawAddress local_bd_addr = *controller_get_interface()->get_address();
412
413 std::string bdstr = local_bd_addr.ToString();
414
415 char val[PROPERTY_VALUE_MAX] = "";
416 int val_size = 0;
417 if ((btif_config_get_str("Adapter", "Address", val, &val_size) == 0) ||
418 strcmp(bdstr.c_str(), val) == 0) {
419 // This address is not present in the config file, save it there.
420 BTIF_TRACE_WARNING("%s: Saving the Adapter Address", __func__);
421 btif_config_set_str("Adapter", "Address", bdstr.c_str());
422 btif_config_save();
423
424 // fire HAL callback for property change
425 bt_property_t prop;
426 prop.type = BT_PROPERTY_BDADDR;
427 prop.val = (void*)&local_bd_addr;
428 prop.len = sizeof(RawAddress);
429 HAL_CBACK(bt_hal_cbacks, adapter_properties_cb, BT_STATUS_SUCCESS, 1,
430 &prop);
431 }
432
433 bte_main_postload_cfg();
434
435 /* callback to HAL */
436 if (status == BTA_SUCCESS) {
437 uid_set = uid_set_create();
438
439 btif_dm_init(uid_set);
440
441 /* init rfcomm & l2cap api */
442 btif_sock_init(uid_set);
443
444 /* init pan */
445 btif_pan_init();
446
447 /* load did configuration */
448 bte_load_did_conf(BTE_DID_CONF_FILE);
449
450 #ifdef BTIF_DM_OOB_TEST
451 btif_dm_load_local_oob();
452 #endif
453
454 future_ready(stack_manager_get_hack_future(), FUTURE_SUCCESS);
455 } else {
456 /* cleanup rfcomm & l2cap api */
457 btif_sock_cleanup();
458
459 btif_pan_cleanup();
460
461 future_ready(stack_manager_get_hack_future(), FUTURE_FAIL);
462 }
463
464 LOG_INFO(LOG_TAG, "%s finished", __func__);
465 }
466
467 /*******************************************************************************
468 *
469 * Function btif_disable_bluetooth
470 *
471 * Description Inititates shutdown of Bluetooth system.
472 * Any active links will be dropped and device entering
473 * non connectable/discoverable mode
474 *
475 * Returns void
476 *
477 ******************************************************************************/
btif_disable_bluetooth(void)478 bt_status_t btif_disable_bluetooth(void) {
479 LOG_INFO(LOG_TAG, "%s entered", __func__);
480
481 do_in_bta_thread(FROM_HERE, base::Bind(&btm_ble_multi_adv_cleanup));
482 // TODO(jpawlowski): this should do whole BTA_VendorCleanup(), but it would
483 // kill the stack now.
484
485 btif_dm_on_disable();
486 /* cleanup rfcomm & l2cap api */
487 btif_sock_cleanup();
488 btif_pan_cleanup();
489 BTA_DisableBluetooth();
490
491 LOG_INFO(LOG_TAG, "%s finished", __func__);
492
493 return BT_STATUS_SUCCESS;
494 }
495
496 /*******************************************************************************
497 *
498 * Function btif_disable_bluetooth_evt
499 *
500 * Description Event notifying BT disable is now complete.
501 * Terminates main stack tasks and notifies HAL
502 * user with updated BT state.
503 *
504 * Returns void
505 *
506 ******************************************************************************/
507
btif_disable_bluetooth_evt(void)508 void btif_disable_bluetooth_evt(void) {
509 LOG_INFO(LOG_TAG, "%s entered", __func__);
510
511 bte_main_disable();
512
513 /* callback to HAL */
514 future_ready(stack_manager_get_hack_future(), FUTURE_SUCCESS);
515
516 LOG_INFO(LOG_TAG, "%s finished", __func__);
517 }
518
519 /*******************************************************************************
520 *
521 * Function btif_cleanup_bluetooth
522 *
523 * Description Cleanup BTIF state.
524 *
525 * Returns void
526 *
527 ******************************************************************************/
528
btif_cleanup_bluetooth(void)529 bt_status_t btif_cleanup_bluetooth(void) {
530 LOG_INFO(LOG_TAG, "%s entered", __func__);
531
532 do_in_bta_thread(FROM_HERE, base::Bind(&BTA_VendorCleanup));
533
534 btif_dm_cleanup();
535 btif_jni_disassociate();
536 btif_queue_release();
537
538 if (jni_run_loop && message_loop_) {
539 message_loop_->task_runner()->PostTask(FROM_HERE,
540 jni_run_loop->QuitClosure());
541 }
542
543 thread_free(bt_jni_workqueue_thread);
544 bt_jni_workqueue_thread = NULL;
545
546 bte_main_cleanup();
547
548 btif_dut_mode = 0;
549
550 LOG_INFO(LOG_TAG, "%s finished", __func__);
551
552 return BT_STATUS_SUCCESS;
553 }
554
555 /*******************************************************************************
556 *
557 * Function btif_dut_mode_cback
558 *
559 * Description Callback invoked on completion of vendor specific test mode
560 * command
561 *
562 * Returns None
563 *
564 ******************************************************************************/
btif_dut_mode_cback(UNUSED_ATTR tBTM_VSC_CMPL * p)565 static void btif_dut_mode_cback(UNUSED_ATTR tBTM_VSC_CMPL* p) {
566 /* For now nothing to be done. */
567 }
568
569 /*******************************************************************************
570 *
571 * Function btif_dut_mode_configure
572 *
573 * Description Configure Test Mode - 'enable' to 1 puts the device in test
574 * mode and 0 exits test mode
575 *
576 * Returns BT_STATUS_SUCCESS on success
577 *
578 ******************************************************************************/
btif_dut_mode_configure(uint8_t enable)579 bt_status_t btif_dut_mode_configure(uint8_t enable) {
580 BTIF_TRACE_DEBUG("%s", __func__);
581
582 if (!stack_manager_get_interface()->get_stack_is_running()) {
583 BTIF_TRACE_ERROR("btif_dut_mode_configure : Bluetooth not enabled");
584 return BT_STATUS_NOT_READY;
585 }
586
587 btif_dut_mode = enable;
588 if (enable == 1) {
589 BTA_EnableTestMode();
590 } else {
591 BTA_DisableTestMode();
592 }
593 return BT_STATUS_SUCCESS;
594 }
595
596 /*******************************************************************************
597 *
598 * Function btif_dut_mode_send
599 *
600 * Description Sends a HCI Vendor specific command to the controller
601 *
602 * Returns BT_STATUS_SUCCESS on success
603 *
604 ******************************************************************************/
btif_dut_mode_send(uint16_t opcode,uint8_t * buf,uint8_t len)605 bt_status_t btif_dut_mode_send(uint16_t opcode, uint8_t* buf, uint8_t len) {
606 /* TODO: Check that opcode is a vendor command group */
607 BTIF_TRACE_DEBUG("%s", __func__);
608 if (!btif_is_dut_mode()) {
609 BTIF_TRACE_ERROR("Bluedroid HAL needs to be init with test_mode set to 1.");
610 return BT_STATUS_FAIL;
611 }
612 BTM_VendorSpecificCommand(opcode, len, buf, btif_dut_mode_cback);
613 return BT_STATUS_SUCCESS;
614 }
615
616 /*****************************************************************************
617 *
618 * btif api adapter property functions
619 *
620 ****************************************************************************/
621
btif_in_get_adapter_properties(void)622 static bt_status_t btif_in_get_adapter_properties(void) {
623 bt_property_t properties[6];
624 uint32_t num_props = 0;
625
626 RawAddress addr;
627 bt_bdname_t name;
628 bt_scan_mode_t mode;
629 uint32_t disc_timeout;
630 RawAddress bonded_devices[BTM_SEC_MAX_DEVICE_RECORDS];
631 Uuid local_uuids[BT_MAX_NUM_UUIDS];
632 bt_status_t status;
633
634 /* RawAddress */
635 BTIF_STORAGE_FILL_PROPERTY(&properties[num_props], BT_PROPERTY_BDADDR,
636 sizeof(addr), &addr);
637 status = btif_storage_get_adapter_property(&properties[num_props]);
638 // Add BT_PROPERTY_BDADDR property into list only when successful.
639 // Otherwise, skip this property entry.
640 if (status == BT_STATUS_SUCCESS) {
641 num_props++;
642 }
643
644 /* BD_NAME */
645 BTIF_STORAGE_FILL_PROPERTY(&properties[num_props], BT_PROPERTY_BDNAME,
646 sizeof(name), &name);
647 btif_storage_get_adapter_property(&properties[num_props]);
648 num_props++;
649
650 /* SCAN_MODE */
651 BTIF_STORAGE_FILL_PROPERTY(&properties[num_props],
652 BT_PROPERTY_ADAPTER_SCAN_MODE, sizeof(mode),
653 &mode);
654 btif_storage_get_adapter_property(&properties[num_props]);
655 num_props++;
656
657 /* DISC_TIMEOUT */
658 BTIF_STORAGE_FILL_PROPERTY(&properties[num_props],
659 BT_PROPERTY_ADAPTER_DISCOVERY_TIMEOUT,
660 sizeof(disc_timeout), &disc_timeout);
661 btif_storage_get_adapter_property(&properties[num_props]);
662 num_props++;
663
664 /* BONDED_DEVICES */
665 BTIF_STORAGE_FILL_PROPERTY(&properties[num_props],
666 BT_PROPERTY_ADAPTER_BONDED_DEVICES,
667 sizeof(bonded_devices), bonded_devices);
668 btif_storage_get_adapter_property(&properties[num_props]);
669 num_props++;
670
671 /* LOCAL UUIDs */
672 BTIF_STORAGE_FILL_PROPERTY(&properties[num_props], BT_PROPERTY_UUIDS,
673 sizeof(local_uuids), local_uuids);
674 btif_storage_get_adapter_property(&properties[num_props]);
675 num_props++;
676
677 HAL_CBACK(bt_hal_cbacks, adapter_properties_cb, BT_STATUS_SUCCESS, num_props,
678 properties);
679
680 return BT_STATUS_SUCCESS;
681 }
682
btif_in_get_remote_device_properties(RawAddress * bd_addr)683 static bt_status_t btif_in_get_remote_device_properties(RawAddress* bd_addr) {
684 bt_property_t remote_properties[8];
685 uint32_t num_props = 0;
686
687 bt_bdname_t name, alias;
688 uint32_t cod, devtype;
689 Uuid remote_uuids[BT_MAX_NUM_UUIDS];
690
691 memset(remote_properties, 0, sizeof(remote_properties));
692 BTIF_STORAGE_FILL_PROPERTY(&remote_properties[num_props], BT_PROPERTY_BDNAME,
693 sizeof(name), &name);
694 btif_storage_get_remote_device_property(bd_addr,
695 &remote_properties[num_props]);
696 num_props++;
697
698 BTIF_STORAGE_FILL_PROPERTY(&remote_properties[num_props],
699 BT_PROPERTY_REMOTE_FRIENDLY_NAME, sizeof(alias),
700 &alias);
701 btif_storage_get_remote_device_property(bd_addr,
702 &remote_properties[num_props]);
703 num_props++;
704
705 BTIF_STORAGE_FILL_PROPERTY(&remote_properties[num_props],
706 BT_PROPERTY_CLASS_OF_DEVICE, sizeof(cod), &cod);
707 btif_storage_get_remote_device_property(bd_addr,
708 &remote_properties[num_props]);
709 num_props++;
710
711 BTIF_STORAGE_FILL_PROPERTY(&remote_properties[num_props],
712 BT_PROPERTY_TYPE_OF_DEVICE, sizeof(devtype),
713 &devtype);
714 btif_storage_get_remote_device_property(bd_addr,
715 &remote_properties[num_props]);
716 num_props++;
717
718 BTIF_STORAGE_FILL_PROPERTY(&remote_properties[num_props], BT_PROPERTY_UUIDS,
719 sizeof(remote_uuids), remote_uuids);
720 btif_storage_get_remote_device_property(bd_addr,
721 &remote_properties[num_props]);
722 num_props++;
723
724 HAL_CBACK(bt_hal_cbacks, remote_device_properties_cb, BT_STATUS_SUCCESS,
725 bd_addr, num_props, remote_properties);
726
727 return BT_STATUS_SUCCESS;
728 }
729
730 /*******************************************************************************
731 *
732 * Function execute_storage_request
733 *
734 * Description Executes adapter storage request in BTIF context
735 *
736 * Returns bt_status_t
737 *
738 ******************************************************************************/
739
execute_storage_request(uint16_t event,char * p_param)740 static void execute_storage_request(uint16_t event, char* p_param) {
741 bt_status_t status = BT_STATUS_SUCCESS;
742
743 BTIF_TRACE_EVENT("execute storage request event : %d", event);
744
745 switch (event) {
746 case BTIF_CORE_STORAGE_ADAPTER_WRITE: {
747 btif_storage_req_t* p_req = (btif_storage_req_t*)p_param;
748 bt_property_t* p_prop = &(p_req->write_req.prop);
749 BTIF_TRACE_EVENT("type: %d, len %d, 0x%x", p_prop->type, p_prop->len,
750 p_prop->val);
751
752 status = btif_storage_set_adapter_property(p_prop);
753 HAL_CBACK(bt_hal_cbacks, adapter_properties_cb, status, 1, p_prop);
754 } break;
755
756 case BTIF_CORE_STORAGE_ADAPTER_READ: {
757 btif_storage_req_t* p_req = (btif_storage_req_t*)p_param;
758 char buf[512];
759 bt_property_t prop;
760 prop.type = p_req->read_req.type;
761 prop.val = (void*)buf;
762 prop.len = sizeof(buf);
763 if (prop.type == BT_PROPERTY_LOCAL_LE_FEATURES) {
764 tBTM_BLE_VSC_CB cmn_vsc_cb;
765 bt_local_le_features_t local_le_features;
766
767 /* LE features are not stored in storage. Should be retrived from stack
768 */
769 BTM_BleGetVendorCapabilities(&cmn_vsc_cb);
770 local_le_features.local_privacy_enabled = BTM_BleLocalPrivacyEnabled();
771
772 prop.len = sizeof(bt_local_le_features_t);
773 if (cmn_vsc_cb.filter_support == 1)
774 local_le_features.max_adv_filter_supported = cmn_vsc_cb.max_filter;
775 else
776 local_le_features.max_adv_filter_supported = 0;
777 local_le_features.max_adv_instance = cmn_vsc_cb.adv_inst_max;
778 local_le_features.max_irk_list_size = cmn_vsc_cb.max_irk_list_sz;
779 local_le_features.rpa_offload_supported = cmn_vsc_cb.rpa_offloading;
780 local_le_features.scan_result_storage_size =
781 cmn_vsc_cb.tot_scan_results_strg;
782 local_le_features.activity_energy_info_supported =
783 cmn_vsc_cb.energy_support;
784 local_le_features.version_supported = cmn_vsc_cb.version_supported;
785 local_le_features.total_trackable_advertisers =
786 cmn_vsc_cb.total_trackable_advertisers;
787
788 local_le_features.extended_scan_support =
789 cmn_vsc_cb.extended_scan_support > 0;
790 local_le_features.debug_logging_supported =
791 cmn_vsc_cb.debug_logging_supported > 0;
792 memcpy(prop.val, &local_le_features, prop.len);
793 } else {
794 status = btif_storage_get_adapter_property(&prop);
795 }
796 HAL_CBACK(bt_hal_cbacks, adapter_properties_cb, status, 1, &prop);
797 } break;
798
799 case BTIF_CORE_STORAGE_ADAPTER_READ_ALL: {
800 status = btif_in_get_adapter_properties();
801 } break;
802
803 case BTIF_CORE_STORAGE_NOTIFY_STATUS: {
804 HAL_CBACK(bt_hal_cbacks, adapter_properties_cb, status, 0, NULL);
805 } break;
806
807 default:
808 BTIF_TRACE_ERROR("%s invalid event id (%d)", __func__, event);
809 break;
810 }
811 }
812
execute_storage_remote_request(uint16_t event,char * p_param)813 static void execute_storage_remote_request(uint16_t event, char* p_param) {
814 bt_status_t status = BT_STATUS_FAIL;
815 bt_property_t prop;
816
817 BTIF_TRACE_EVENT("execute storage remote request event : %d", event);
818
819 switch (event) {
820 case BTIF_CORE_STORAGE_REMOTE_READ: {
821 char buf[1024];
822 btif_storage_req_t* p_req = (btif_storage_req_t*)p_param;
823 prop.type = p_req->read_req.type;
824 prop.val = (void*)buf;
825 prop.len = sizeof(buf);
826
827 status = btif_storage_get_remote_device_property(
828 &(p_req->read_req.bd_addr), &prop);
829 HAL_CBACK(bt_hal_cbacks, remote_device_properties_cb, status,
830 &(p_req->read_req.bd_addr), 1, &prop);
831 } break;
832 case BTIF_CORE_STORAGE_REMOTE_WRITE: {
833 btif_storage_req_t* p_req = (btif_storage_req_t*)p_param;
834 status = btif_storage_set_remote_device_property(
835 &(p_req->write_req.bd_addr), &(p_req->write_req.prop));
836 } break;
837 case BTIF_CORE_STORAGE_REMOTE_READ_ALL: {
838 btif_storage_req_t* p_req = (btif_storage_req_t*)p_param;
839 btif_in_get_remote_device_properties(&p_req->read_req.bd_addr);
840 } break;
841 }
842 }
843
btif_adapter_properties_evt(bt_status_t status,uint32_t num_props,bt_property_t * p_props)844 void btif_adapter_properties_evt(bt_status_t status, uint32_t num_props,
845 bt_property_t* p_props) {
846 HAL_CBACK(bt_hal_cbacks, adapter_properties_cb, status, num_props, p_props);
847 }
btif_remote_properties_evt(bt_status_t status,RawAddress * remote_addr,uint32_t num_props,bt_property_t * p_props)848 void btif_remote_properties_evt(bt_status_t status, RawAddress* remote_addr,
849 uint32_t num_props, bt_property_t* p_props) {
850 HAL_CBACK(bt_hal_cbacks, remote_device_properties_cb, status, remote_addr,
851 num_props, p_props);
852 }
853
854 /*******************************************************************************
855 *
856 * Function btif_in_storage_request_copy_cb
857 *
858 * Description Switch context callback function to perform the deep copy for
859 * both the adapter and remote_device property API
860 *
861 * Returns None
862 *
863 ******************************************************************************/
btif_in_storage_request_copy_cb(uint16_t event,char * p_new_buf,char * p_old_buf)864 static void btif_in_storage_request_copy_cb(uint16_t event, char* p_new_buf,
865 char* p_old_buf) {
866 btif_storage_req_t* new_req = (btif_storage_req_t*)p_new_buf;
867 btif_storage_req_t* old_req = (btif_storage_req_t*)p_old_buf;
868
869 BTIF_TRACE_EVENT("%s", __func__);
870 switch (event) {
871 case BTIF_CORE_STORAGE_REMOTE_WRITE:
872 case BTIF_CORE_STORAGE_ADAPTER_WRITE: {
873 new_req->write_req.bd_addr = old_req->write_req.bd_addr;
874 /* Copy the member variables one at a time */
875 new_req->write_req.prop.type = old_req->write_req.prop.type;
876 new_req->write_req.prop.len = old_req->write_req.prop.len;
877
878 new_req->write_req.prop.val =
879 (uint8_t*)(p_new_buf + sizeof(btif_storage_req_t));
880 memcpy(new_req->write_req.prop.val, old_req->write_req.prop.val,
881 old_req->write_req.prop.len);
882 } break;
883 }
884 }
885
886 /*******************************************************************************
887 *
888 * Function btif_get_adapter_properties
889 *
890 * Description Fetch all available properties (local & remote)
891 *
892 * Returns bt_status_t
893 *
894 ******************************************************************************/
895
btif_get_adapter_properties(void)896 bt_status_t btif_get_adapter_properties(void) {
897 BTIF_TRACE_EVENT("%s", __func__);
898
899 if (!btif_is_enabled()) return BT_STATUS_NOT_READY;
900
901 return btif_transfer_context(execute_storage_request,
902 BTIF_CORE_STORAGE_ADAPTER_READ_ALL, NULL, 0,
903 NULL);
904 }
905
906 /*******************************************************************************
907 *
908 * Function btif_get_adapter_property
909 *
910 * Description Fetches property value from local cache
911 *
912 * Returns bt_status_t
913 *
914 ******************************************************************************/
915
btif_get_adapter_property(bt_property_type_t type)916 bt_status_t btif_get_adapter_property(bt_property_type_t type) {
917 btif_storage_req_t req;
918
919 BTIF_TRACE_EVENT("%s %d", __func__, type);
920
921 /* Allow get_adapter_property only for BDADDR and BDNAME if BT is disabled */
922 if (!btif_is_enabled() && (type != BT_PROPERTY_BDADDR) &&
923 (type != BT_PROPERTY_BDNAME) && (type != BT_PROPERTY_CLASS_OF_DEVICE))
924 return BT_STATUS_NOT_READY;
925
926 req.read_req.bd_addr = RawAddress::kEmpty;
927 req.read_req.type = type;
928
929 return btif_transfer_context(execute_storage_request,
930 BTIF_CORE_STORAGE_ADAPTER_READ, (char*)&req,
931 sizeof(btif_storage_req_t), NULL);
932 }
933
934 /*******************************************************************************
935 *
936 * Function btif_set_adapter_property
937 *
938 * Description Updates core stack with property value and stores it in
939 * local cache
940 *
941 * Returns bt_status_t
942 *
943 ******************************************************************************/
944
btif_set_adapter_property(const bt_property_t * property)945 bt_status_t btif_set_adapter_property(const bt_property_t* property) {
946 btif_storage_req_t req;
947 bt_status_t status = BT_STATUS_SUCCESS;
948 int storage_req_id = BTIF_CORE_STORAGE_NOTIFY_STATUS; /* default */
949 char bd_name[BTM_MAX_LOC_BD_NAME_LEN + 1];
950 uint16_t name_len = 0;
951
952 BTIF_TRACE_EVENT("btif_set_adapter_property type: %d, len %d, 0x%x",
953 property->type, property->len, property->val);
954
955 if (!btif_is_enabled()) return BT_STATUS_NOT_READY;
956
957 switch (property->type) {
958 case BT_PROPERTY_BDNAME: {
959 name_len = property->len > BTM_MAX_LOC_BD_NAME_LEN
960 ? BTM_MAX_LOC_BD_NAME_LEN
961 : property->len;
962 memcpy(bd_name, property->val, name_len);
963 bd_name[name_len] = '\0';
964
965 BTIF_TRACE_EVENT("set property name : %s", (char*)bd_name);
966
967 BTA_DmSetDeviceName((char*)bd_name);
968
969 storage_req_id = BTIF_CORE_STORAGE_ADAPTER_WRITE;
970 } break;
971
972 case BT_PROPERTY_ADAPTER_SCAN_MODE: {
973 bt_scan_mode_t mode = *(bt_scan_mode_t*)property->val;
974 tBTA_DM_DISC disc_mode;
975 tBTA_DM_CONN conn_mode;
976
977 switch (mode) {
978 case BT_SCAN_MODE_NONE:
979 disc_mode = BTA_DM_NON_DISC;
980 conn_mode = BTA_DM_NON_CONN;
981 break;
982
983 case BT_SCAN_MODE_CONNECTABLE:
984 disc_mode = BTA_DM_NON_DISC;
985 conn_mode = BTA_DM_CONN;
986 break;
987
988 case BT_SCAN_MODE_CONNECTABLE_DISCOVERABLE:
989 disc_mode = BTA_DM_GENERAL_DISC;
990 conn_mode = BTA_DM_CONN;
991 break;
992
993 default:
994 BTIF_TRACE_ERROR("invalid scan mode (0x%x)", mode);
995 return BT_STATUS_PARM_INVALID;
996 }
997
998 BTIF_TRACE_EVENT("set property scan mode : %x", mode);
999
1000 BTA_DmSetVisibility(disc_mode, conn_mode, BTA_DM_IGNORE, BTA_DM_IGNORE);
1001
1002 storage_req_id = BTIF_CORE_STORAGE_ADAPTER_WRITE;
1003 } break;
1004 case BT_PROPERTY_ADAPTER_DISCOVERY_TIMEOUT: {
1005 /* Nothing to do beside store the value in NV. Java
1006 will change the SCAN_MODE property after setting timeout,
1007 if required */
1008 storage_req_id = BTIF_CORE_STORAGE_ADAPTER_WRITE;
1009 } break;
1010 case BT_PROPERTY_CLASS_OF_DEVICE: {
1011 DEV_CLASS dev_class;
1012 memcpy(dev_class, property->val, DEV_CLASS_LEN);
1013
1014 BTIF_TRACE_EVENT("set property dev_class : 0x%02x%02x%02x", dev_class[0],
1015 dev_class[1], dev_class[2]);
1016
1017 BTM_SetDeviceClass(dev_class);
1018 } break;
1019 case BT_PROPERTY_BDADDR:
1020 case BT_PROPERTY_UUIDS:
1021 case BT_PROPERTY_ADAPTER_BONDED_DEVICES:
1022 case BT_PROPERTY_REMOTE_FRIENDLY_NAME:
1023 /* no write support through HAL, these properties are only populated from
1024 * BTA events */
1025 status = BT_STATUS_FAIL;
1026 break;
1027 default:
1028 BTIF_TRACE_ERROR("btif_get_adapter_property : invalid type %d",
1029 property->type);
1030 status = BT_STATUS_FAIL;
1031 break;
1032 }
1033
1034 if (storage_req_id != BTIF_CORE_STORAGE_NO_ACTION) {
1035 /* pass on to storage for updating local database */
1036
1037 req.write_req.bd_addr = RawAddress::kEmpty;
1038 memcpy(&(req.write_req.prop), property, sizeof(bt_property_t));
1039
1040 return btif_transfer_context(execute_storage_request, storage_req_id,
1041 (char*)&req,
1042 sizeof(btif_storage_req_t) + property->len,
1043 btif_in_storage_request_copy_cb);
1044 }
1045
1046 return status;
1047 }
1048
1049 /*******************************************************************************
1050 *
1051 * Function btif_get_remote_device_property
1052 *
1053 * Description Fetches the remote device property from the NVRAM
1054 *
1055 * Returns bt_status_t
1056 *
1057 ******************************************************************************/
btif_get_remote_device_property(RawAddress * remote_addr,bt_property_type_t type)1058 bt_status_t btif_get_remote_device_property(RawAddress* remote_addr,
1059 bt_property_type_t type) {
1060 btif_storage_req_t req;
1061
1062 if (!btif_is_enabled()) return BT_STATUS_NOT_READY;
1063
1064 req.read_req.bd_addr = *remote_addr;
1065 req.read_req.type = type;
1066 return btif_transfer_context(execute_storage_remote_request,
1067 BTIF_CORE_STORAGE_REMOTE_READ, (char*)&req,
1068 sizeof(btif_storage_req_t), NULL);
1069 }
1070
1071 /*******************************************************************************
1072 *
1073 * Function btif_get_remote_device_properties
1074 *
1075 * Description Fetches all the remote device properties from NVRAM
1076 *
1077 * Returns bt_status_t
1078 *
1079 ******************************************************************************/
btif_get_remote_device_properties(RawAddress * remote_addr)1080 bt_status_t btif_get_remote_device_properties(RawAddress* remote_addr) {
1081 btif_storage_req_t req;
1082
1083 if (!btif_is_enabled()) return BT_STATUS_NOT_READY;
1084
1085 req.read_req.bd_addr = *remote_addr;
1086 return btif_transfer_context(execute_storage_remote_request,
1087 BTIF_CORE_STORAGE_REMOTE_READ_ALL, (char*)&req,
1088 sizeof(btif_storage_req_t), NULL);
1089 }
1090
1091 /*******************************************************************************
1092 *
1093 * Function btif_set_remote_device_property
1094 *
1095 * Description Writes the remote device property to NVRAM.
1096 * Currently, BT_PROPERTY_REMOTE_FRIENDLY_NAME is the only
1097 * remote device property that can be set
1098 *
1099 * Returns bt_status_t
1100 *
1101 ******************************************************************************/
btif_set_remote_device_property(RawAddress * remote_addr,const bt_property_t * property)1102 bt_status_t btif_set_remote_device_property(RawAddress* remote_addr,
1103 const bt_property_t* property) {
1104 btif_storage_req_t req;
1105
1106 if (!btif_is_enabled()) return BT_STATUS_NOT_READY;
1107
1108 req.write_req.bd_addr = *remote_addr;
1109 memcpy(&(req.write_req.prop), property, sizeof(bt_property_t));
1110
1111 return btif_transfer_context(execute_storage_remote_request,
1112 BTIF_CORE_STORAGE_REMOTE_WRITE, (char*)&req,
1113 sizeof(btif_storage_req_t) + property->len,
1114 btif_in_storage_request_copy_cb);
1115 }
1116
1117 /*******************************************************************************
1118 *
1119 * Function btif_get_remote_service_record
1120 *
1121 * Description Looks up the service matching uuid on the remote device
1122 * and fetches the SCN and service_name if the UUID is found
1123 *
1124 * Returns bt_status_t
1125 *
1126 ******************************************************************************/
btif_get_remote_service_record(const RawAddress & remote_addr,const Uuid & uuid)1127 bt_status_t btif_get_remote_service_record(const RawAddress& remote_addr,
1128 const Uuid& uuid) {
1129 if (!btif_is_enabled()) return BT_STATUS_NOT_READY;
1130
1131 return btif_dm_get_remote_service_record(remote_addr, uuid);
1132 }
1133
1134 /*******************************************************************************
1135 *
1136 * Function btif_get_enabled_services_mask
1137 *
1138 * Description Fetches currently enabled services
1139 *
1140 * Returns tBTA_SERVICE_MASK
1141 *
1142 ******************************************************************************/
1143
btif_get_enabled_services_mask(void)1144 tBTA_SERVICE_MASK btif_get_enabled_services_mask(void) {
1145 return btif_enabled_services;
1146 }
1147
1148 /*******************************************************************************
1149 *
1150 * Function btif_enable_service
1151 *
1152 * Description Enables the service 'service_ID' to the service_mask.
1153 * Upon BT enable, BTIF core shall invoke the BTA APIs to
1154 * enable the profiles
1155 *
1156 * Returns bt_status_t
1157 *
1158 ******************************************************************************/
btif_enable_service(tBTA_SERVICE_ID service_id)1159 bt_status_t btif_enable_service(tBTA_SERVICE_ID service_id) {
1160 tBTA_SERVICE_ID* p_id = &service_id;
1161
1162 /* If BT is enabled, we need to switch to BTIF context and trigger the
1163 * enable for that profile
1164 *
1165 * Otherwise, we just set the flag. On BT_Enable, the DM will trigger
1166 * enable for the profiles that have been enabled */
1167
1168 btif_enabled_services |= (1 << service_id);
1169
1170 BTIF_TRACE_DEBUG("%s: current services:0x%x", __func__,
1171 btif_enabled_services);
1172
1173 if (btif_is_enabled()) {
1174 btif_transfer_context(btif_dm_execute_service_request,
1175 BTIF_DM_ENABLE_SERVICE, (char*)p_id,
1176 sizeof(tBTA_SERVICE_ID), NULL);
1177 }
1178
1179 return BT_STATUS_SUCCESS;
1180 }
1181 /*******************************************************************************
1182 *
1183 * Function btif_disable_service
1184 *
1185 * Description Disables the service 'service_ID' to the service_mask.
1186 * Upon BT disable, BTIF core shall invoke the BTA APIs to
1187 * disable the profiles
1188 *
1189 * Returns bt_status_t
1190 *
1191 ******************************************************************************/
btif_disable_service(tBTA_SERVICE_ID service_id)1192 bt_status_t btif_disable_service(tBTA_SERVICE_ID service_id) {
1193 tBTA_SERVICE_ID* p_id = &service_id;
1194
1195 /* If BT is enabled, we need to switch to BTIF context and trigger the
1196 * disable for that profile so that the appropriate uuid_property_changed will
1197 * be triggerred. Otherwise, we just need to clear the service_id in the mask
1198 */
1199
1200 btif_enabled_services &= (tBTA_SERVICE_MASK)(~(1 << service_id));
1201
1202 BTIF_TRACE_DEBUG("%s: Current Services:0x%x", __func__,
1203 btif_enabled_services);
1204
1205 if (btif_is_enabled()) {
1206 btif_transfer_context(btif_dm_execute_service_request,
1207 BTIF_DM_DISABLE_SERVICE, (char*)p_id,
1208 sizeof(tBTA_SERVICE_ID), NULL);
1209 }
1210
1211 return BT_STATUS_SUCCESS;
1212 }
1213
btif_jni_associate()1214 static void btif_jni_associate() {
1215 BTIF_TRACE_DEBUG("%s Associating thread to JVM", __func__);
1216 HAL_CBACK(bt_hal_cbacks, thread_evt_cb, ASSOCIATE_JVM);
1217 }
1218
btif_jni_disassociate()1219 static void btif_jni_disassociate() {
1220 BTIF_TRACE_DEBUG("%s Disassociating thread from JVM", __func__);
1221 HAL_CBACK(bt_hal_cbacks, thread_evt_cb, DISASSOCIATE_JVM);
1222 bt_hal_cbacks = NULL;
1223 }
1224