1 /*
2 * Copyright 2020 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #pragma once
18
19 #include <cstdint>
20 #include <string>
21 #include <vector>
22
23 #include "internal_include/bt_target.h"
24 #include "internal_include/bt_trace.h"
25 #include "stack/acl/peer_packet_types.h"
26 #include "stack/btm/power_mode.h"
27 #include "stack/include/btm_status.h"
28 #include "stack/include/hcimsgs.h"
29 #include "types/bt_transport.h"
30 #include "types/hci_role.h"
31 #include "types/raw_address.h"
32 #include "types/remote_version_type.h"
33
34 enum btm_acl_encrypt_state_t {
35 BTM_ACL_ENCRYPT_STATE_IDLE = 0,
36 BTM_ACL_ENCRYPT_STATE_ENCRYPT_OFF = 1,
37 BTM_ACL_ENCRYPT_STATE_TEMP_FUNC = 2,
38 BTM_ACL_ENCRYPT_STATE_ENCRYPT_ON = 3,
39 };
40
41 enum btm_acl_swkey_state_t {
42 BTM_ACL_SWKEY_STATE_IDLE = 0,
43 BTM_ACL_SWKEY_STATE_MODE_CHANGE = 1,
44 BTM_ACL_SWKEY_STATE_ENCRYPTION_OFF = 2,
45 BTM_ACL_SWKEY_STATE_SWITCHING = 3,
46 BTM_ACL_SWKEY_STATE_ENCRYPTION_ON = 4,
47 BTM_ACL_SWKEY_STATE_IN_PROGRESS = 5,
48 };
49
50 /* Policy settings status */
51 typedef enum : uint16_t {
52 HCI_DISABLE_ALL_LM_MODES = 0,
53 HCI_ENABLE_CENTRAL_PERIPHERAL_SWITCH = (1u << 0),
54 HCI_ENABLE_HOLD_MODE = (1u << 1),
55 HCI_ENABLE_SNIFF_MODE = (1u << 2),
56 HCI_ENABLE_PARK_MODE = (1u << 3),
57 } tLINK_POLICY_BITMASK;
58 typedef uint16_t tLINK_POLICY;
59
60 constexpr tLINK_POLICY kAllLinkPoliciesEnabled =
61 (HCI_ENABLE_CENTRAL_PERIPHERAL_SWITCH | HCI_ENABLE_HOLD_MODE | HCI_ENABLE_SNIFF_MODE);
62
63 static const char* link_policy_string[] = {
64 " role_switch ",
65 " hold_mode ",
66 " sniff_mode ",
67 " park_mode ",
68 };
69
link_policy_text(tLINK_POLICY policy)70 inline std::string link_policy_text(tLINK_POLICY policy) {
71 std::ostringstream os;
72 os << "0x" << loghex(static_cast<uint16_t>(policy)) << " :";
73 std::string s = os.str();
74 for (uint16_t i = 0; i < 4; i++) {
75 if (policy & (0x1 << i)) {
76 s += link_policy_string[i];
77 }
78 }
79 return s;
80 }
81
82 // Power mode states.
83 // Used as both value and bitmask
84 enum : uint8_t {
85 BTM_PM_ST_ACTIVE = HCI_MODE_ACTIVE, // 0x00
86 BTM_PM_ST_HOLD = HCI_MODE_HOLD, // 0x01
87 BTM_PM_ST_SNIFF = HCI_MODE_SNIFF, // 0x02
88 BTM_PM_ST_PARK = HCI_MODE_PARK, // 0x03
89 BTM_PM_ST_UNUSED, // 0x04
90 BTM_PM_ST_PENDING = BTM_PM_STS_PENDING, // 0x05
91 BTM_PM_ST_INVALID = 0x7F,
92 BTM_PM_STORED_MASK = 0x80, /* set this mask if the command is stored */
93 };
94 typedef uint8_t tBTM_PM_STATE;
95
power_mode_state_text(tBTM_PM_STATE state)96 inline std::string power_mode_state_text(tBTM_PM_STATE state) {
97 std::string s = std::string((state & BTM_PM_STORED_MASK) ? "stored:" : "immediate:");
98 switch (state & ~BTM_PM_STORED_MASK) {
99 case BTM_PM_ST_ACTIVE:
100 return s + std::string("active");
101 case BTM_PM_ST_HOLD:
102 return s + std::string("hold");
103 case BTM_PM_ST_SNIFF:
104 return s + std::string("sniff");
105 case BTM_PM_ST_PARK:
106 return s + std::string("park");
107 case BTM_PM_ST_UNUSED:
108 return s + std::string("WARN:UNUSED");
109 case BTM_PM_ST_PENDING:
110 return s + std::string("pending");
111 case BTM_PM_ST_INVALID:
112 return s + std::string("invalid");
113 default:
114 return s + std::string("UNKNOWN");
115 }
116 }
117
118 namespace bluetooth {
119 namespace shim {
120 tBTM_STATUS BTM_SetPowerMode(uint16_t handle, const tBTM_PM_PWR_MD& new_mode);
121 tBTM_STATUS BTM_SetSsrParams(uint16_t handle, uint16_t max_lat, uint16_t min_rmt_to,
122 uint16_t min_loc_to);
123 void btm_pm_on_mode_change(tHCI_STATUS status, uint16_t handle, tHCI_MODE hci_mode,
124 uint16_t interval);
125 void btm_pm_on_sniff_subrating(tHCI_STATUS status, uint16_t handle,
126 uint16_t maximum_transmit_latency, uint16_t maximum_receive_latency,
127 uint16_t minimum_remote_timeout, uint16_t minimum_local_timeout);
128 } // namespace shim
129 } // namespace bluetooth
130
131 typedef struct {
132 uint16_t max_xmit_latency;
133 uint16_t max_recv_latency;
134 uint16_t min_remote_timeout;
135 uint16_t min_local_timeout;
136 } tSSR_PARAMS;
137
138 #define BTM_PM_REC_NOT_USED 0
139 typedef struct tBTM_PM_RCB {
140 tBTM_PM_STATUS_CBACK* cback = nullptr; /* to notify the registered party of mode change event */
141 uint8_t mask = 0; /* registered request mask. 0, if this entry is not used */
142 } tBTM_PM_RCB;
143
144 /* Structure returned with Role Switch information (in tBTM_CMPL_CB callback
145 * function) in response to BTM_SwitchRoleToCentral call.
146 */
147 typedef struct {
148 RawAddress remote_bd_addr; /* Remote BD addr involved with the switch */
149 tHCI_STATUS hci_status; /* HCI status returned with the event */
150 tHCI_ROLE role; /* HCI_ROLE_CENTRAL or HCI_ROLE_PERIPHERAL */
151 } tBTM_ROLE_SWITCH_CMPL;
152
153 struct tBTM_PM_MCB {
154 bool chg_ind = false;
155 tBTM_PM_PWR_MD req_mode;
156 tBTM_PM_PWR_MD set_mode;
157 tBTM_PM_STATE state = BTM_PM_ST_ACTIVE; // 0
158 uint16_t interval = 0;
159 uint16_t max_lat = 0;
160 uint16_t min_loc_to = 0;
161 uint16_t min_rmt_to = 0;
InittBTM_PM_MCB162 void Init(RawAddress bda, uint16_t handle) {
163 bda_ = bda;
164 handle_ = handle;
165 }
166 RawAddress bda_;
167 uint16_t handle_;
168 };
169
170 struct tACL_CONN {
171 BD_FEATURES peer_le_features;
172 bool peer_le_features_valid;
173 BD_FEATURES peer_lmp_feature_pages[HCI_EXT_FEATURES_PAGE_MAX + 1];
174 bool peer_lmp_feature_valid[HCI_EXT_FEATURES_PAGE_MAX + 1];
175
176 /* Whether "Read Remote Version Information Complete" was received */
177 bool remote_version_received{false};
178
179 RawAddress active_remote_addr;
180 tBLE_ADDR_TYPE active_remote_addr_type;
181
182 RawAddress remote_addr;
183 bool in_use{false};
184
185 public:
InUsetACL_CONN186 bool InUse() const { return in_use; }
RemoteAddresstACL_CONN187 const RawAddress RemoteAddress() const { return remote_addr; }
188
189 bool link_up_issued;
190 tBT_TRANSPORT transport;
is_transport_br_edrtACL_CONN191 bool is_transport_br_edr() const { return transport == BT_TRANSPORT_BR_EDR; }
is_transport_bletACL_CONN192 bool is_transport_ble() const { return transport == BT_TRANSPORT_LE; }
is_transport_validtACL_CONN193 bool is_transport_valid() const { return is_transport_ble() || is_transport_br_edr(); }
194
195 uint16_t flush_timeout_in_ticks;
196 uint16_t hci_handle;
197 tLINK_POLICY link_policy;
198
199 public:
HandletACL_CONN200 uint16_t Handle() const { return hci_handle; }
201 uint16_t link_super_tout;
202 uint16_t pkt_types_mask;
203 uint8_t disconnect_reason;
204
205 private:
206 btm_acl_encrypt_state_t encrypt_state_;
207
208 public:
set_encryption_offtACL_CONN209 void set_encryption_off() {
210 if (encrypt_state_ != BTM_ACL_ENCRYPT_STATE_ENCRYPT_OFF) {
211 btsnd_hcic_set_conn_encrypt(hci_handle, false);
212 encrypt_state_ = BTM_ACL_ENCRYPT_STATE_ENCRYPT_OFF;
213 }
214 }
set_encryption_ontACL_CONN215 void set_encryption_on() {
216 if (encrypt_state_ != BTM_ACL_ENCRYPT_STATE_ENCRYPT_ON) {
217 btsnd_hcic_set_conn_encrypt(hci_handle, true);
218 encrypt_state_ = BTM_ACL_ENCRYPT_STATE_ENCRYPT_ON;
219 }
220 }
set_encryption_idletACL_CONN221 void set_encryption_idle() { encrypt_state_ = BTM_ACL_ENCRYPT_STATE_IDLE; }
222
set_encryption_switchingtACL_CONN223 void set_encryption_switching() { encrypt_state_ = BTM_ACL_ENCRYPT_STATE_TEMP_FUNC; }
224
225 public:
226 bool is_encrypted = false;
227 tHCI_ROLE link_role;
228 uint8_t switch_role_failed_attempts;
229
230 tREMOTE_VERSION_INFO remote_version_info;
231
232 #define BTM_SEC_RS_NOT_PENDING 0 /* Role Switch not in progress */
233 #define BTM_SEC_RS_PENDING 1 /* Role Switch in progress */
234 #define BTM_SEC_DISC_PENDING 2 /* Disconnect is pending */
235 private:
236 uint8_t rs_disc_pending = BTM_SEC_RS_NOT_PENDING;
237 friend struct StackAclBtmAcl;
238 friend tBTM_STATUS btm_remove_acl(const RawAddress& bd_addr, tBT_TRANSPORT transport);
239 friend void acl_disconnect_after_role_switch(uint16_t conn_handle, tHCI_STATUS reason,
240 std::string);
241 friend void bluetooth::shim::btm_pm_on_mode_change(tHCI_STATUS status, uint16_t handle,
242 tHCI_MODE hci_mode, uint16_t interval);
243 friend void btm_acl_encrypt_change(uint16_t handle, uint8_t status, uint8_t encr_enable);
244
245 public:
is_disconnect_pendingtACL_CONN246 bool is_disconnect_pending() const { return rs_disc_pending == BTM_SEC_DISC_PENDING; }
is_role_switch_pendingtACL_CONN247 bool is_role_switch_pending() const { return rs_disc_pending == BTM_SEC_RS_PENDING; }
248
249 private:
250 uint8_t switch_role_state_;
251
252 public:
reset_switch_roletACL_CONN253 void reset_switch_role() { switch_role_state_ = BTM_ACL_SWKEY_STATE_IDLE; }
set_switch_role_changingtACL_CONN254 void set_switch_role_changing() { switch_role_state_ = BTM_ACL_SWKEY_STATE_MODE_CHANGE; }
set_switch_role_encryption_offtACL_CONN255 void set_switch_role_encryption_off() { switch_role_state_ = BTM_ACL_SWKEY_STATE_ENCRYPTION_OFF; }
set_switch_role_encryption_ontACL_CONN256 void set_switch_role_encryption_on() { switch_role_state_ = BTM_ACL_SWKEY_STATE_ENCRYPTION_ON; }
set_switch_role_in_progresstACL_CONN257 void set_switch_role_in_progress() { switch_role_state_ = BTM_ACL_SWKEY_STATE_IN_PROGRESS; }
set_switch_role_switchingtACL_CONN258 void set_switch_role_switching() { switch_role_state_ = BTM_ACL_SWKEY_STATE_SWITCHING; }
259
is_switch_role_idletACL_CONN260 bool is_switch_role_idle() const { return switch_role_state_ == BTM_ACL_SWKEY_STATE_IDLE; }
is_switch_role_encryption_offtACL_CONN261 bool is_switch_role_encryption_off() const {
262 return switch_role_state_ == BTM_ACL_SWKEY_STATE_ENCRYPTION_OFF;
263 }
is_switch_role_encryption_ontACL_CONN264 bool is_switch_role_encryption_on() const {
265 return switch_role_state_ == BTM_ACL_SWKEY_STATE_ENCRYPTION_ON;
266 }
is_switch_role_switchingtACL_CONN267 bool is_switch_role_switching() const {
268 return switch_role_state_ == BTM_ACL_SWKEY_STATE_SWITCHING;
269 }
is_switch_role_in_progresstACL_CONN270 bool is_switch_role_in_progress() const {
271 return switch_role_state_ == BTM_ACL_SWKEY_STATE_IN_PROGRESS;
272 }
is_switch_role_mode_changetACL_CONN273 bool is_switch_role_mode_change() const {
274 return switch_role_state_ == BTM_ACL_SWKEY_STATE_MODE_CHANGE;
275 }
is_switch_role_switching_or_in_progresstACL_CONN276 bool is_switch_role_switching_or_in_progress() const {
277 return is_switch_role_switching() || is_switch_role_in_progress();
278 }
279
280 public:
281 uint8_t sca; /* Sleep clock accuracy */
282
283 void Reset();
284 };
285
286 /****************************************************
287 ** ACL Management API
288 ****************************************************/
289 constexpr uint16_t kDefaultPacketTypeMask = HCI_PKT_TYPES_MASK_DH1 | HCI_PKT_TYPES_MASK_DM1 |
290 HCI_PKT_TYPES_MASK_DH3 | HCI_PKT_TYPES_MASK_DM3 |
291 HCI_PKT_TYPES_MASK_DH5 | HCI_PKT_TYPES_MASK_DM5;
292
293 struct tACL_CB {
294 private:
295 friend uint8_t btm_handle_to_acl_index(uint16_t hci_handle);
296 friend void btm_acl_device_down(void);
297 friend void btm_acl_encrypt_change(uint16_t handle, uint8_t status, uint8_t encr_enable);
298
299 friend void DumpsysAcl(int fd);
300 friend struct StackAclBtmAcl;
301
302 tACL_CONN acl_db[MAX_L2CAP_LINKS];
303 tBTM_ROLE_SWITCH_CMPL switch_role_ref_data;
304 uint16_t btm_acl_pkt_types_supported = kDefaultPacketTypeMask;
305 uint16_t btm_def_link_policy;
306 tHCI_STATUS acl_disc_reason = HCI_ERR_UNDEFINED;
307 bool locally_initiated;
308
309 public:
SetDefaultPacketTypeMasktACL_CB310 void SetDefaultPacketTypeMask(uint16_t packet_type_mask) {
311 btm_acl_pkt_types_supported = packet_type_mask;
312 }
313
get_disconnect_reasontACL_CB314 tHCI_STATUS get_disconnect_reason() const { return acl_disc_reason; }
set_disconnect_reasontACL_CB315 void set_disconnect_reason(tHCI_STATUS reason) { acl_disc_reason = reason; }
is_locally_initiatedtACL_CB316 bool is_locally_initiated() const { return locally_initiated; }
set_locally_initiatedtACL_CB317 void set_locally_initiated(bool value) { locally_initiated = value; }
DefaultPacketTypestACL_CB318 uint16_t DefaultPacketTypes() const { return btm_acl_pkt_types_supported; }
DefaultLinkPolicytACL_CB319 uint16_t DefaultLinkPolicy() const { return btm_def_link_policy; }
320
321 struct {
322 std::vector<tBTM_PM_STATUS_CBACK*> clients;
323 } link_policy;
324
NumberOfActiveLinkstACL_CB325 unsigned NumberOfActiveLinks() const {
326 unsigned cnt = 0;
327 for (int i = 0; i < MAX_L2CAP_LINKS; i++) {
328 if (acl_db[i].InUse()) {
329 ++cnt;
330 }
331 }
332 return cnt;
333 }
334 };
335
336 tACL_CONN* btm_acl_for_bda(const RawAddress& bd_addr, tBT_TRANSPORT transport);
337
338 void btm_acl_encrypt_change(uint16_t handle, uint8_t status, uint8_t encr_enable);
339