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 <unordered_set>
22 #include <vector>
23
24 #include "stack/acl/peer_packet_types.h"
25 #include "stack/include/acl_api_types.h"
26 #include "stack/include/bt_types.h"
27 #include "stack/include/btm_api_types.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
33 enum btm_acl_encrypt_state_t {
34 BTM_ACL_ENCRYPT_STATE_IDLE = 0,
35 BTM_ACL_ENCRYPT_STATE_ENCRYPT_OFF = 1,
36 BTM_ACL_ENCRYPT_STATE_TEMP_FUNC = 2,
37 BTM_ACL_ENCRYPT_STATE_ENCRYPT_ON = 3,
38 };
39
40 enum btm_acl_swkey_state_t {
41 BTM_ACL_SWKEY_STATE_IDLE = 0,
42 BTM_ACL_SWKEY_STATE_MODE_CHANGE = 1,
43 BTM_ACL_SWKEY_STATE_ENCRYPTION_OFF = 2,
44 BTM_ACL_SWKEY_STATE_SWITCHING = 3,
45 BTM_ACL_SWKEY_STATE_ENCRYPTION_ON = 4,
46 BTM_ACL_SWKEY_STATE_IN_PROGRESS = 5,
47 };
48
49 enum btm_data_direction {
50 HOST_TO_CONTROLLER = 0,
51 CONTROLLER_TO_HOST = 1,
52 };
53
54 /* Policy settings status */
55 typedef enum : uint16_t {
56 HCI_DISABLE_ALL_LM_MODES = 0,
57 HCI_ENABLE_CENTRAL_PERIPHERAL_SWITCH = (1u << 0),
58 HCI_ENABLE_HOLD_MODE = (1u << 1),
59 HCI_ENABLE_SNIFF_MODE = (1u << 2),
60 HCI_ENABLE_PARK_MODE = (1u << 3),
61 } tLINK_POLICY_BITMASK;
62 typedef uint16_t tLINK_POLICY;
63
64 constexpr tLINK_POLICY kAllLinkPoliciesEnabled =
65 (HCI_ENABLE_CENTRAL_PERIPHERAL_SWITCH | HCI_ENABLE_HOLD_MODE |
66 HCI_ENABLE_SNIFF_MODE);
67
68 static const char* link_policy_string[] = {
69 " role_switch ",
70 " hold_mode ",
71 " sniff_mode ",
72 " park_mode ",
73 };
74
link_policy_text(tLINK_POLICY policy)75 inline std::string link_policy_text(tLINK_POLICY policy) {
76 std::ostringstream os;
77 os << "0x" << loghex(static_cast<uint16_t>(policy)) << " :";
78 std::string s = os.str();
79 for (uint16_t i = 0; i < 4; i++) {
80 if (policy & (0x1 << i)) s += link_policy_string[i];
81 }
82 return s;
83 }
84
85 // Power mode states.
86 // Used as both value and bitmask
87 enum : uint8_t {
88 BTM_PM_ST_ACTIVE = HCI_MODE_ACTIVE, // 0x00
89 BTM_PM_ST_HOLD = HCI_MODE_HOLD, // 0x01
90 BTM_PM_ST_SNIFF = HCI_MODE_SNIFF, // 0x02
91 BTM_PM_ST_PARK = HCI_MODE_PARK, // 0x03
92 BTM_PM_ST_UNUSED, // 0x04
93 BTM_PM_ST_PENDING = BTM_PM_STS_PENDING, // 0x05
94 BTM_PM_ST_INVALID = 0x7F,
95 BTM_PM_STORED_MASK = 0x80, /* set this mask if the command is stored */
96 };
97 typedef uint8_t tBTM_PM_STATE;
98
power_mode_state_text(tBTM_PM_STATE state)99 inline std::string power_mode_state_text(tBTM_PM_STATE state) {
100 std::string s =
101 std::string((state & BTM_PM_STORED_MASK) ? "stored:" : "immediate:");
102 switch (state & ~BTM_PM_STORED_MASK) {
103 case BTM_PM_ST_ACTIVE:
104 return s + std::string("active");
105 case BTM_PM_ST_HOLD:
106 return s + std::string("hold");
107 case BTM_PM_ST_SNIFF:
108 return s + std::string("sniff");
109 case BTM_PM_ST_PARK:
110 return s + std::string("park");
111 case BTM_PM_ST_UNUSED:
112 return s + std::string("WARN:UNUSED");
113 case BTM_PM_ST_PENDING:
114 return s + std::string("pending");
115 case BTM_PM_ST_INVALID:
116 return s + std::string("invalid");
117 default:
118 return s + std::string("UNKNOWN");
119 }
120 }
121
122 namespace bluetooth {
123 namespace shim {
124 tBTM_STATUS BTM_SetPowerMode(uint16_t handle, const tBTM_PM_PWR_MD& new_mode);
125 tBTM_STATUS BTM_SetSsrParams(uint16_t handle, uint16_t max_lat,
126 uint16_t min_rmt_to, uint16_t min_loc_to);
127 void btm_pm_on_mode_change(tHCI_STATUS status, uint16_t handle,
128 tHCI_MODE hci_mode, uint16_t interval);
129 void btm_pm_on_sniff_subrating(tHCI_STATUS status, uint16_t handle,
130 uint16_t maximum_transmit_latency,
131 uint16_t maximum_receive_latency,
132 uint16_t minimum_remote_timeout,
133 uint16_t minimum_local_timeout);
134 } // namespace shim
135 } // namespace bluetooth
136
137 typedef struct {
138 uint16_t max_xmit_latency;
139 uint16_t max_recv_latency;
140 uint16_t min_remote_timeout;
141 uint16_t min_local_timeout;
142 } tSSR_PARAMS;
143
144 #define BTM_PM_REC_NOT_USED 0
145 typedef struct {
146 tBTM_PM_STATUS_CBACK* cback =
147 nullptr; /* to notify the registered party of mode change event */
148 uint8_t mask = 0; /* registered request mask. 0, if this entry is not used */
149 } tBTM_PM_RCB;
150
151 /* Structure returned with Role Switch information (in tBTM_CMPL_CB callback
152 * function) in response to BTM_SwitchRoleToCentral call.
153 */
154 typedef struct {
155 RawAddress remote_bd_addr; /* Remote BD addr involved with the switch */
156 tHCI_STATUS hci_status; /* HCI status returned with the event */
157 tHCI_ROLE role; /* HCI_ROLE_CENTRAL or HCI_ROLE_PERIPHERAL */
158 } tBTM_ROLE_SWITCH_CMPL;
159
160 struct tBTM_PM_MCB {
161 bool chg_ind = false;
162 tBTM_PM_PWR_MD req_mode;
163 tBTM_PM_PWR_MD set_mode;
164 tBTM_PM_STATE state = BTM_PM_ST_ACTIVE; // 0
165 uint16_t interval = 0;
166 uint16_t max_lat = 0;
167 uint16_t min_loc_to = 0;
168 uint16_t min_rmt_to = 0;
InittBTM_PM_MCB169 void Init(RawAddress bda, uint16_t handle) {
170 bda_ = bda;
171 handle_ = handle;
172 }
173 RawAddress bda_;
174 uint16_t handle_;
175 };
176
177 struct tACL_CONN {
178 BD_FEATURES peer_le_features;
179 bool peer_le_features_valid;
180 BD_FEATURES peer_lmp_feature_pages[HCI_EXT_FEATURES_PAGE_MAX + 1];
181 bool peer_lmp_feature_valid[HCI_EXT_FEATURES_PAGE_MAX + 1];
182
183 RawAddress active_remote_addr;
184 tBLE_ADDR_TYPE active_remote_addr_type;
185
186 RawAddress remote_addr;
187 bool in_use{false};
188
189 public:
InUsetACL_CONN190 bool InUse() const { return in_use; }
RemoteAddresstACL_CONN191 const RawAddress RemoteAddress() const { return remote_addr; }
192
193 bool link_up_issued;
194 tBT_TRANSPORT transport;
is_transport_br_edrtACL_CONN195 bool is_transport_br_edr() const { return transport == BT_TRANSPORT_BR_EDR; }
is_transport_bletACL_CONN196 bool is_transport_ble() const { return transport == BT_TRANSPORT_LE; }
is_transport_validtACL_CONN197 bool is_transport_valid() const {
198 return is_transport_ble() || is_transport_br_edr();
199 }
200
201 uint16_t flush_timeout_in_ticks;
202 uint16_t hci_handle;
203 tLINK_POLICY link_policy;
204
205 public:
HandletACL_CONN206 uint16_t Handle() const { return hci_handle; }
207 uint16_t link_super_tout;
208 uint16_t pkt_types_mask;
209 uint8_t disconnect_reason;
210
211 private:
212 btm_acl_encrypt_state_t encrypt_state_;
213
214 public:
set_encryption_offtACL_CONN215 void set_encryption_off() {
216 if (encrypt_state_ != BTM_ACL_ENCRYPT_STATE_ENCRYPT_OFF) {
217 btsnd_hcic_set_conn_encrypt(hci_handle, false);
218 encrypt_state_ = BTM_ACL_ENCRYPT_STATE_ENCRYPT_OFF;
219 }
220 }
set_encryption_ontACL_CONN221 void set_encryption_on() {
222 if (encrypt_state_ != BTM_ACL_ENCRYPT_STATE_ENCRYPT_ON) {
223 btsnd_hcic_set_conn_encrypt(hci_handle, true);
224 encrypt_state_ = BTM_ACL_ENCRYPT_STATE_ENCRYPT_ON;
225 }
226 }
set_encryption_idletACL_CONN227 void set_encryption_idle() { encrypt_state_ = BTM_ACL_ENCRYPT_STATE_IDLE; }
228
set_encryption_switchingtACL_CONN229 void set_encryption_switching() {
230 encrypt_state_ = BTM_ACL_ENCRYPT_STATE_TEMP_FUNC;
231 }
232
233 public:
234 bool is_encrypted = false;
235 tHCI_ROLE link_role;
236 uint8_t switch_role_failed_attempts;
237
238 tREMOTE_VERSION_INFO remote_version_info;
239
240 #define BTM_SEC_RS_NOT_PENDING 0 /* Role Switch not in progress */
241 #define BTM_SEC_RS_PENDING 1 /* Role Switch in progress */
242 #define BTM_SEC_DISC_PENDING 2 /* Disconnect is pending */
243 private:
244 uint8_t rs_disc_pending = BTM_SEC_RS_NOT_PENDING;
245 friend struct StackAclBtmAcl;
246 friend tBTM_STATUS btm_remove_acl(const RawAddress& bd_addr,
247 tBT_TRANSPORT transport);
248 friend void acl_disconnect_after_role_switch(uint16_t conn_handle,
249 tHCI_STATUS reason, std::string);
250 friend void bluetooth::shim::btm_pm_on_mode_change(tHCI_STATUS status,
251 uint16_t handle,
252 tHCI_MODE hci_mode,
253 uint16_t interval);
254 friend void btm_acl_encrypt_change(uint16_t handle, uint8_t status,
255 uint8_t encr_enable);
256
257 public:
is_disconnect_pendingtACL_CONN258 bool is_disconnect_pending() const {
259 return rs_disc_pending == BTM_SEC_DISC_PENDING;
260 }
is_role_switch_pendingtACL_CONN261 bool is_role_switch_pending() const {
262 return rs_disc_pending == BTM_SEC_RS_PENDING;
263 }
264
265 private:
266 uint8_t switch_role_state_;
267
268 public:
reset_switch_roletACL_CONN269 void reset_switch_role() { switch_role_state_ = BTM_ACL_SWKEY_STATE_IDLE; }
set_switch_role_changingtACL_CONN270 void set_switch_role_changing() {
271 switch_role_state_ = BTM_ACL_SWKEY_STATE_MODE_CHANGE;
272 }
set_switch_role_encryption_offtACL_CONN273 void set_switch_role_encryption_off() {
274 switch_role_state_ = BTM_ACL_SWKEY_STATE_ENCRYPTION_OFF;
275 }
set_switch_role_encryption_ontACL_CONN276 void set_switch_role_encryption_on() {
277 switch_role_state_ = BTM_ACL_SWKEY_STATE_ENCRYPTION_ON;
278 }
set_switch_role_in_progresstACL_CONN279 void set_switch_role_in_progress() {
280 switch_role_state_ = BTM_ACL_SWKEY_STATE_IN_PROGRESS;
281 }
set_switch_role_switchingtACL_CONN282 void set_switch_role_switching() {
283 switch_role_state_ = BTM_ACL_SWKEY_STATE_SWITCHING;
284 }
285
is_switch_role_idletACL_CONN286 bool is_switch_role_idle() const {
287 return switch_role_state_ == BTM_ACL_SWKEY_STATE_IDLE;
288 }
is_switch_role_encryption_offtACL_CONN289 bool is_switch_role_encryption_off() const {
290 return switch_role_state_ == BTM_ACL_SWKEY_STATE_ENCRYPTION_OFF;
291 }
is_switch_role_encryption_ontACL_CONN292 bool is_switch_role_encryption_on() const {
293 return switch_role_state_ == BTM_ACL_SWKEY_STATE_ENCRYPTION_ON;
294 }
is_switch_role_switchingtACL_CONN295 bool is_switch_role_switching() const {
296 return switch_role_state_ == BTM_ACL_SWKEY_STATE_SWITCHING;
297 }
is_switch_role_in_progresstACL_CONN298 bool is_switch_role_in_progress() const {
299 return switch_role_state_ == BTM_ACL_SWKEY_STATE_IN_PROGRESS;
300 }
is_switch_role_mode_changetACL_CONN301 bool is_switch_role_mode_change() const {
302 return switch_role_state_ == BTM_ACL_SWKEY_STATE_MODE_CHANGE;
303 }
is_switch_role_switching_or_in_progresstACL_CONN304 bool is_switch_role_switching_or_in_progress() const {
305 return is_switch_role_switching() || is_switch_role_in_progress();
306 }
307
308 friend void DumpsysL2cap(int fd);
309
310 public:
311 uint8_t sca; /* Sleep clock accuracy */
312
313 void Reset();
314
315 struct tPolicy {
ModetACL_CONN::tPolicy316 tBTM_PM_MODE Mode() const { return this->mode.mode_; }
317 struct {
IsPendingtACL_CONN::tPolicy::__anon607aa1dd0608318 bool IsPending() const { return pending_ != BTM_PM_MD_UNKNOWN; }
PendingtACL_CONN::tPolicy::__anon607aa1dd0608319 tBTM_PM_MODE Pending() const { return pending_; }
IntervaltACL_CONN::tPolicy::__anon607aa1dd0608320 uint16_t Interval() const { return interval_; }
321
322 private:
323 tBTM_PM_MODE mode_{BTM_PM_MD_ACTIVE};
324 tBTM_PM_MODE pending_{BTM_PM_MD_UNKNOWN};
325 uint16_t interval_{0};
326 friend tBTM_STATUS bluetooth::shim::BTM_SetPowerMode(
327 uint16_t, const tBTM_PM_PWR_MD& new_mode);
328 friend void bluetooth::shim::btm_pm_on_mode_change(tHCI_STATUS status,
329 uint16_t handle,
330 tHCI_MODE hci_mode,
331 uint16_t interval);
332 friend void tACL_CONN::Reset();
333 friend tBTM_PM_MODE tACL_CONN::tPolicy::Mode() const;
334 } mode;
335
RoletACL_CONN::tPolicy336 hci_role_t Role() const { return this->role.role_; }
337 struct {
RoleSwitchFailedCounttACL_CONN::tPolicy::__anon607aa1dd0708338 unsigned RoleSwitchFailedCount() const { return role_switch_failed_cnt_; }
339
340 private:
341 hci_role_t role_{HCI_ROLE_CENTRAL};
342 unsigned role_switch_failed_cnt_{0};
343 friend void tACL_CONN::Reset();
344 friend hci_role_t tACL_CONN::tPolicy::Role() const;
345 } role;
346
347 struct {
IsPendingtACL_CONN::tPolicy::__anon607aa1dd0808348 bool IsPending() const { return pending_; }
349
350 private:
351 bool pending_{false};
352 friend tBTM_STATUS bluetooth::shim::BTM_SetSsrParams(uint16_t handle,
353 uint16_t max_lat,
354 uint16_t min_rmt_to,
355 uint16_t min_loc_to);
356 friend void bluetooth::shim::btm_pm_on_sniff_subrating(
357 tHCI_STATUS status, uint16_t handle,
358 uint16_t maximum_transmit_latency, uint16_t maximum_receive_latency,
359 uint16_t minimum_remote_timeout, uint16_t minimum_local_timeout);
360 friend void tACL_CONN::Reset();
361 } sniff_subrating;
362
SettingstACL_CONN::tPolicy363 tLINK_POLICY Settings() const { return settings_; }
364
365 private:
366 tLINK_POLICY settings_{kAllLinkPoliciesEnabled};
367 friend void btm_set_link_policy(tACL_CONN* conn, tLINK_POLICY policy);
368 friend void tACL_CONN::Reset();
369 } policy;
370 };
371
372 struct controller_t;
373
374 /****************************************************
375 ** ACL Management API
376 ****************************************************/
377 constexpr uint16_t kDefaultPacketTypeMask =
378 HCI_PKT_TYPES_MASK_DH1 | HCI_PKT_TYPES_MASK_DM1 | HCI_PKT_TYPES_MASK_DH3 |
379 HCI_PKT_TYPES_MASK_DM3 | HCI_PKT_TYPES_MASK_DH5 | HCI_PKT_TYPES_MASK_DM5;
380
381 struct tACL_CB {
382 private:
383 friend uint8_t btm_handle_to_acl_index(uint16_t hci_handle);
384 friend void btm_acl_device_down(void);
385 friend void btm_acl_encrypt_change(uint16_t handle, uint8_t status,
386 uint8_t encr_enable);
387
388 friend void DumpsysL2cap(int fd);
389 friend void DumpsysAcl(int fd);
390 friend struct StackAclBtmAcl;
391
392 tACL_CONN acl_db[MAX_L2CAP_LINKS];
393 tBTM_ROLE_SWITCH_CMPL switch_role_ref_data;
394 uint16_t btm_acl_pkt_types_supported = kDefaultPacketTypeMask;
395 uint16_t btm_def_link_policy;
396 tHCI_STATUS acl_disc_reason = HCI_ERR_UNDEFINED;
397 bool locally_initiated;
398
399 public:
SetDefaultPacketTypeMasktACL_CB400 void SetDefaultPacketTypeMask(uint16_t packet_type_mask) {
401 btm_acl_pkt_types_supported = packet_type_mask;
402 }
403
get_disconnect_reasontACL_CB404 tHCI_STATUS get_disconnect_reason() const { return acl_disc_reason; }
set_disconnect_reasontACL_CB405 void set_disconnect_reason(tHCI_STATUS reason) { acl_disc_reason = reason; }
is_locally_initiatedtACL_CB406 bool is_locally_initiated() const { return locally_initiated; }
set_locally_initiatedtACL_CB407 void set_locally_initiated(bool value) { locally_initiated = value; }
DefaultPacketTypestACL_CB408 uint16_t DefaultPacketTypes() const { return btm_acl_pkt_types_supported; }
DefaultLinkPolicytACL_CB409 uint16_t DefaultLinkPolicy() const { return btm_def_link_policy; }
410
411 struct {
412 std::vector<tBTM_PM_STATUS_CBACK*> clients;
413 } link_policy;
414
NumberOfActiveLinkstACL_CB415 unsigned NumberOfActiveLinks() const {
416 unsigned cnt = 0;
417 for (int i = 0; i < MAX_L2CAP_LINKS; i++) {
418 if (acl_db[i].InUse()) ++cnt;
419 }
420 return cnt;
421 }
422 };
423
424 tACL_CONN* btm_acl_for_bda(const RawAddress& bd_addr, tBT_TRANSPORT transport);
425