1 /******************************************************************************
2  *
3  *  Copyright 1999-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 #pragma once
20 
21 #include <bluetooth/log.h>
22 
23 #include <cstdint>
24 #include <string>
25 
26 #include "internal_include/bt_target.h"  // L2CAP_EXTFEA_SUPPORTED_MASK
27 #include "macros.h"
28 
29 /* L2CAP command codes
30  */
31 #define L2CAP_CMD_REJECT 0x01
32 #define L2CAP_CMD_CONN_REQ 0x02
33 #define L2CAP_CMD_CONN_RSP 0x03
34 #define L2CAP_CMD_CONFIG_REQ 0x04
35 #define L2CAP_CMD_CONFIG_RSP 0x05
36 #define L2CAP_CMD_DISC_REQ 0x06
37 #define L2CAP_CMD_DISC_RSP 0x07
38 #define L2CAP_CMD_ECHO_REQ 0x08
39 #define L2CAP_CMD_ECHO_RSP 0x09
40 #define L2CAP_CMD_INFO_REQ 0x0A
41 #define L2CAP_CMD_INFO_RSP 0x0B
42 #define L2CAP_CMD_AMP_CONN_REQ 0x0C
43 #define L2CAP_CMD_AMP_MOVE_REQ 0x0E
44 #define L2CAP_CMD_BLE_UPDATE_REQ 0x12
45 #define L2CAP_CMD_BLE_UPDATE_RSP 0x13
46 #define L2CAP_CMD_BLE_CREDIT_BASED_CONN_REQ 0x14
47 #define L2CAP_CMD_BLE_CREDIT_BASED_CONN_RES 0x15
48 #define L2CAP_CMD_BLE_FLOW_CTRL_CREDIT 0x16
49 /* Enhanced CoC */
50 #define L2CAP_CMD_CREDIT_BASED_CONN_REQ 0x17
51 #define L2CAP_CMD_CREDIT_BASED_CONN_RES 0x18
52 #define L2CAP_CMD_CREDIT_BASED_RECONFIG_REQ 0x19
53 #define L2CAP_CMD_CREDIT_BASED_RECONFIG_RES 0x1A
54 
55 /* Define some packet and header lengths
56  */
57 /* Length and CID                       */
58 #define L2CAP_PKT_OVERHEAD 4
59 /* Cmd code, Id and length              */
60 #define L2CAP_CMD_OVERHEAD 4
61 /* Reason (data is optional)            */
62 #define L2CAP_CMD_REJECT_LEN 2
63 /* PSM and source CID                   */
64 #define L2CAP_CONN_REQ_LEN 4
65 /* Dest CID, source CID, reason, status */
66 #define L2CAP_CONN_RSP_LEN 8
67 /* Dest CID, flags (data is optional)   */
68 #define L2CAP_CONFIG_REQ_LEN 4
69 /* Dest CID, flags, result,data optional*/
70 #define L2CAP_CONFIG_RSP_LEN 6
71 /* Dest CID, source CID                 */
72 #define L2CAP_DISC_REQ_LEN 4
73 /* Dest CID, source CID                 */
74 #define L2CAP_DISC_RSP_LEN 4
75 /* Data is optional                     */
76 #define L2CAP_ECHO_REQ_LEN 0
77 /* Data is optional                     */
78 #define L2CAP_ECHO_RSP_LEN 0
79 /* Info type, result (data is optional) */
80 #define L2CAP_INFO_RSP_LEN 4
81 
82 /* Min and max interval, latency, tout  */
83 #define L2CAP_CMD_BLE_UPD_REQ_LEN 8
84 /* Result                               */
85 #define L2CAP_CMD_BLE_UPD_RSP_LEN 2
86 
87 /* LE_PSM, SCID, MTU, MPS, Init Credit */
88 #define L2CAP_CMD_BLE_CREDIT_BASED_CONN_REQ_LEN 10
89 /* DCID, MTU, MPS, Init credit, Result */
90 #define L2CAP_CMD_BLE_CREDIT_BASED_CONN_RES_LEN 10
91 /* CID, Credit */
92 #define L2CAP_CMD_BLE_FLOW_CTRL_CREDIT_LEN 4
93 
94 /* LE PSM, MTU, MPS, Initial Credits, SCIDS[] */
95 #define L2CAP_CMD_CREDIT_BASED_CONN_REQ_MIN_LEN 8
96 /* MTU, MPS, Initial Credits, Result, DCIDS[] */
97 #define L2CAP_CMD_CREDIT_BASED_CONN_RES_MIN_LEN 8
98 
99 /* MTU, MPS, DCIDS[] */
100 #define L2CAP_CMD_CREDIT_BASED_RECONFIG_REQ_MIN_LEN 4
101 /* Result */
102 #define L2CAP_CMD_CREDIT_BASED_RECONFIG_RES_LEN 2
103 
104 /* Define the packet boundary flags
105  */
106 #define L2CAP_PKT_START_NON_FLUSHABLE 0
107 #define L2CAP_PKT_START 2
108 #define L2CAP_PKT_CONTINUE 1
109 #define L2CAP_PKT_TYPE_SHIFT 12
110 
111 #define L2CAP_CONN_INTERNAL_MASK 0xF000
112 #define L2CAP_CONN_LE_MASK 0xFF00
113 
114 /* Define the LE L2CAP Connection Response Result codes
115  */
116 enum class tL2CAP_LE_RESULT_CODE : uint16_t {
117   L2CAP_LE_RESULT_CONN_OK = 0x0000,
118   L2CAP_LE_RESULT_NO_PSM = 0x0002,
119   L2CAP_LE_RESULT_NO_RESOURCES = 0x0004,
120   L2CAP_LE_RESULT_INSUFFICIENT_AUTHENTICATION = 0x0005,
121   L2CAP_LE_RESULT_INSUFFICIENT_AUTHORIZATION = 0x0006,
122   L2CAP_LE_RESULT_INSUFFICIENT_ENCRYP_KEY_SIZE = 0x0007,
123   L2CAP_LE_RESULT_INSUFFICIENT_ENCRYP = 0x0008,
124   L2CAP_LE_RESULT_INVALID_SOURCE_CID = 0x0009,
125   L2CAP_LE_RESULT_SOURCE_CID_ALREADY_ALLOCATED = 0x000A,
126   L2CAP_LE_RESULT_UNACCEPTABLE_PARAMETERS = 0x000B,
127   L2CAP_LE_RESULT_INVALID_PARAMETERS = 0x000C,
128   L2CAP_LE_RESULT_CONN_PENDING = 0x000D,
129   L2CAP_LE_RESULT_CONN_PENDING_AUTHENTICATION = 0x000E,
130   L2CAP_LE_RESULT_CONN_PENDING_AUTHORIZATION = 0x000F,
131 };
132 
l2cap_le_result_code_text(const tL2CAP_LE_RESULT_CODE & code)133 inline std::string l2cap_le_result_code_text(const tL2CAP_LE_RESULT_CODE& code) {
134   switch (code) {
135     CASE_RETURN_STRING_HEX04(tL2CAP_LE_RESULT_CODE::L2CAP_LE_RESULT_CONN_OK);
136     CASE_RETURN_STRING_HEX04(tL2CAP_LE_RESULT_CODE::L2CAP_LE_RESULT_NO_PSM);
137     CASE_RETURN_STRING_HEX04(tL2CAP_LE_RESULT_CODE::L2CAP_LE_RESULT_NO_RESOURCES);
138     CASE_RETURN_STRING_HEX04(tL2CAP_LE_RESULT_CODE::L2CAP_LE_RESULT_INSUFFICIENT_AUTHENTICATION);
139     CASE_RETURN_STRING_HEX04(tL2CAP_LE_RESULT_CODE::L2CAP_LE_RESULT_INSUFFICIENT_AUTHORIZATION);
140     CASE_RETURN_STRING_HEX04(tL2CAP_LE_RESULT_CODE::L2CAP_LE_RESULT_INSUFFICIENT_ENCRYP_KEY_SIZE);
141     CASE_RETURN_STRING_HEX04(tL2CAP_LE_RESULT_CODE::L2CAP_LE_RESULT_INSUFFICIENT_ENCRYP);
142     CASE_RETURN_STRING_HEX04(tL2CAP_LE_RESULT_CODE::L2CAP_LE_RESULT_INVALID_SOURCE_CID);
143     CASE_RETURN_STRING_HEX04(tL2CAP_LE_RESULT_CODE::L2CAP_LE_RESULT_SOURCE_CID_ALREADY_ALLOCATED);
144     CASE_RETURN_STRING_HEX04(tL2CAP_LE_RESULT_CODE::L2CAP_LE_RESULT_UNACCEPTABLE_PARAMETERS);
145     CASE_RETURN_STRING_HEX04(tL2CAP_LE_RESULT_CODE::L2CAP_LE_RESULT_INVALID_PARAMETERS);
146     CASE_RETURN_STRING_HEX04(tL2CAP_LE_RESULT_CODE::L2CAP_LE_RESULT_CONN_PENDING);
147     CASE_RETURN_STRING_HEX04(tL2CAP_LE_RESULT_CODE::L2CAP_LE_RESULT_CONN_PENDING_AUTHENTICATION);
148     CASE_RETURN_STRING_HEX04(tL2CAP_LE_RESULT_CODE::L2CAP_LE_RESULT_CONN_PENDING_AUTHORIZATION);
149     break;
150   }
151   RETURN_UNKNOWN_TYPE_STRING(tL2CAP_LE_RESULT_CODE, code);
152 }
153 
154 /* Define the L2CAP connection result codes */
155 enum class tL2CAP_CONN : uint16_t {
156   L2CAP_CONN_OK = 0x0000,
157   L2CAP_CONN_PENDING = 0x0001,
158   L2CAP_CONN_NO_PSM = 0x0002,
159   L2CAP_CONN_SECURITY_BLOCK = 0x0003,
160   L2CAP_CONN_NO_RESOURCES = 0x0004,
161   L2CAP_CONN_TIMEOUT = 0xEEEE,
162   /* Generic L2CAP conn failure reasons */
163   L2CAP_CONN_OTHER_ERROR = 0xF000,
164   L2CAP_CONN_ACL_CONNECTION_FAILED = 0xF001,
165   L2CAP_CONN_CLIENT_SECURITY_CLEARANCE_FAILED = 0xF002,
166   L2CAP_CONN_NO_LINK = 0xF003,
167   L2CAP_CONN_CANCEL = 0xF004, /* L2CAP connection cancelled */
168   /* For LE result codes converted to L2CAP conn failure code */
169   L2CAP_CONN_INSUFFICIENT_AUTHENTICATION = 0xFF05,
170   L2CAP_CONN_INSUFFICIENT_AUTHORIZATION = 0xFF06,
171   L2CAP_CONN_INSUFFICIENT_ENCRYP_KEY_SIZE = 0xFF07,
172   L2CAP_CONN_INSUFFICIENT_ENCRYP = 0xFF08,
173   L2CAP_CONN_INVALID_SOURCE_CID = 0xFF09,
174   L2CAP_CONN_SOURCE_CID_ALREADY_ALLOCATED = 0xFF0A,
175   L2CAP_CONN_UNACCEPTABLE_PARAMETERS = 0xFF0B,
176   L2CAP_CONN_INVALID_PARAMETERS = 0xFF0C,
177 };
178 
l2cap_result_code_text(const tL2CAP_CONN & result)179 inline std::string l2cap_result_code_text(const tL2CAP_CONN& result) {
180   switch (result) {
181     CASE_RETURN_STRING_HEX04(tL2CAP_CONN::L2CAP_CONN_OK);
182     CASE_RETURN_STRING_HEX04(tL2CAP_CONN::L2CAP_CONN_PENDING);
183     CASE_RETURN_STRING_HEX04(tL2CAP_CONN::L2CAP_CONN_NO_PSM);
184     CASE_RETURN_STRING_HEX04(tL2CAP_CONN::L2CAP_CONN_SECURITY_BLOCK);
185     CASE_RETURN_STRING_HEX04(tL2CAP_CONN::L2CAP_CONN_NO_RESOURCES);
186     CASE_RETURN_STRING_HEX04(tL2CAP_CONN::L2CAP_CONN_TIMEOUT);
187     CASE_RETURN_STRING_HEX04(tL2CAP_CONN::L2CAP_CONN_OTHER_ERROR);
188     CASE_RETURN_STRING_HEX04(tL2CAP_CONN::L2CAP_CONN_ACL_CONNECTION_FAILED);
189     CASE_RETURN_STRING_HEX04(tL2CAP_CONN::L2CAP_CONN_CLIENT_SECURITY_CLEARANCE_FAILED);
190     CASE_RETURN_STRING_HEX04(tL2CAP_CONN::L2CAP_CONN_NO_LINK);
191     CASE_RETURN_STRING_HEX04(tL2CAP_CONN::L2CAP_CONN_CANCEL);
192     CASE_RETURN_STRING_HEX04(tL2CAP_CONN::L2CAP_CONN_INSUFFICIENT_AUTHENTICATION);
193     CASE_RETURN_STRING_HEX04(tL2CAP_CONN::L2CAP_CONN_INSUFFICIENT_AUTHORIZATION);
194     CASE_RETURN_STRING_HEX04(tL2CAP_CONN::L2CAP_CONN_INSUFFICIENT_ENCRYP_KEY_SIZE);
195     CASE_RETURN_STRING_HEX04(tL2CAP_CONN::L2CAP_CONN_INSUFFICIENT_ENCRYP);
196     CASE_RETURN_STRING_HEX04(tL2CAP_CONN::L2CAP_CONN_INVALID_SOURCE_CID);
197     CASE_RETURN_STRING_HEX04(tL2CAP_CONN::L2CAP_CONN_SOURCE_CID_ALREADY_ALLOCATED);
198     CASE_RETURN_STRING_HEX04(tL2CAP_CONN::L2CAP_CONN_UNACCEPTABLE_PARAMETERS);
199     CASE_RETURN_STRING_HEX04(tL2CAP_CONN::L2CAP_CONN_INVALID_PARAMETERS);
200   };
201   RETURN_UNKNOWN_TYPE_STRING(tL2CAP_CONN, result);
202 }
203 
l2cap_command_code_text(uint8_t cmd)204 static inline std::string l2cap_command_code_text(uint8_t cmd) {
205   switch (cmd) {
206     CASE_RETURN_TEXT(L2CAP_CMD_REJECT);
207     CASE_RETURN_TEXT(L2CAP_CMD_CONN_REQ);
208     CASE_RETURN_TEXT(L2CAP_CMD_CONN_RSP);
209     CASE_RETURN_TEXT(L2CAP_CMD_CONFIG_REQ);
210     CASE_RETURN_TEXT(L2CAP_CMD_CONFIG_RSP);
211     CASE_RETURN_TEXT(L2CAP_CMD_DISC_REQ);
212     CASE_RETURN_TEXT(L2CAP_CMD_DISC_RSP);
213     CASE_RETURN_TEXT(L2CAP_CMD_ECHO_REQ);
214     CASE_RETURN_TEXT(L2CAP_CMD_ECHO_RSP);
215     CASE_RETURN_TEXT(L2CAP_CMD_INFO_REQ);
216     CASE_RETURN_TEXT(L2CAP_CMD_INFO_RSP);
217     CASE_RETURN_TEXT(L2CAP_CMD_AMP_CONN_REQ);
218     CASE_RETURN_TEXT(L2CAP_CMD_AMP_MOVE_REQ);
219     CASE_RETURN_TEXT(L2CAP_CMD_BLE_UPDATE_REQ);
220     CASE_RETURN_TEXT(L2CAP_CMD_BLE_UPDATE_RSP);
221     CASE_RETURN_TEXT(L2CAP_CMD_BLE_CREDIT_BASED_CONN_REQ);
222     CASE_RETURN_TEXT(L2CAP_CMD_BLE_CREDIT_BASED_CONN_RES);
223     CASE_RETURN_TEXT(L2CAP_CMD_BLE_FLOW_CTRL_CREDIT);
224     CASE_RETURN_TEXT(L2CAP_CMD_CREDIT_BASED_CONN_REQ);
225     CASE_RETURN_TEXT(L2CAP_CMD_CREDIT_BASED_CONN_RES);
226     CASE_RETURN_TEXT(L2CAP_CMD_CREDIT_BASED_RECONFIG_REQ);
227     CASE_RETURN_TEXT(L2CAP_CMD_CREDIT_BASED_RECONFIG_RES);
228     default:
229       return std::string("UNKNOWN L2CAP CMD[") + std::to_string(cmd) + std::string("]");
230   }
231 }
232 
to_l2cap_result_code(uint16_t result)233 inline tL2CAP_CONN to_l2cap_result_code(uint16_t result) {
234   switch (result) {
235     case 0x0000:
236       return tL2CAP_CONN::L2CAP_CONN_OK;
237     case 0x0001:
238       return tL2CAP_CONN::L2CAP_CONN_PENDING;
239     case 0x0002:
240       return tL2CAP_CONN::L2CAP_CONN_NO_PSM;
241     case 0x0003:
242       return tL2CAP_CONN::L2CAP_CONN_SECURITY_BLOCK;
243     case 0x0004:
244       return tL2CAP_CONN::L2CAP_CONN_NO_RESOURCES;
245     case 0xEEEE:
246       return tL2CAP_CONN::L2CAP_CONN_TIMEOUT;
247     case 0xF000:
248       return tL2CAP_CONN::L2CAP_CONN_OTHER_ERROR;
249     case 0xF001:
250       return tL2CAP_CONN::L2CAP_CONN_ACL_CONNECTION_FAILED;
251     case 0xF002:
252       return tL2CAP_CONN::L2CAP_CONN_CLIENT_SECURITY_CLEARANCE_FAILED;
253     case 0xF003:
254       return tL2CAP_CONN::L2CAP_CONN_NO_LINK;
255     case 0xF004:
256       return tL2CAP_CONN::L2CAP_CONN_CANCEL;
257     case 0xF005:
258       return tL2CAP_CONN::L2CAP_CONN_INSUFFICIENT_AUTHENTICATION;
259     case 0xF006:
260       return tL2CAP_CONN::L2CAP_CONN_INSUFFICIENT_AUTHORIZATION;
261     case 0xF007:
262       return tL2CAP_CONN::L2CAP_CONN_INSUFFICIENT_ENCRYP_KEY_SIZE;
263     case 0xF008:
264       return tL2CAP_CONN::L2CAP_CONN_INSUFFICIENT_ENCRYP;
265     case 0xF009:
266       return tL2CAP_CONN::L2CAP_CONN_INVALID_SOURCE_CID;
267     case 0xF00A:
268       return tL2CAP_CONN::L2CAP_CONN_SOURCE_CID_ALREADY_ALLOCATED;
269     case 0xF00B:
270       return tL2CAP_CONN::L2CAP_CONN_UNACCEPTABLE_PARAMETERS;
271     case 0xF00C:
272       return tL2CAP_CONN::L2CAP_CONN_INVALID_PARAMETERS;
273   }
274   bluetooth::log::warn("Received unsupported l2cap result:0x{:04x}", result);
275   return static_cast<tL2CAP_CONN>(result);
276 }
277 
l2cap_result_code_text(uint16_t result)278 inline std::string l2cap_result_code_text(uint16_t result) {
279   return l2cap_result_code_text(to_l2cap_result_code(result));
280 }
281 
282 /* Credit based reconfig results code */
283 enum class tL2CAP_RECONFIG_RESULT : uint16_t {
284   L2CAP_RECONFIG_SUCCEED = 0,
285   L2CAP_RECONFIG_REDUCTION_MTU_NO_ALLOWED = 1,
286   L2CAP_RECONFIG_REDUCTION_MPS_NO_ALLOWED = 2,
287   L2CAP_RECONFIG_INVALID_DCID = 3,
288   L2CAP_RECONFIG_UNACCAPTED_PARAM = 4,
289 };
290 
l2cap_reconfig_result_text(const tL2CAP_RECONFIG_RESULT & result)291 inline std::string l2cap_reconfig_result_text(const tL2CAP_RECONFIG_RESULT& result) {
292   switch (result) {
293     CASE_RETURN_TEXT(tL2CAP_RECONFIG_RESULT::L2CAP_RECONFIG_SUCCEED);
294     CASE_RETURN_TEXT(tL2CAP_RECONFIG_RESULT::L2CAP_RECONFIG_REDUCTION_MTU_NO_ALLOWED);
295     CASE_RETURN_TEXT(tL2CAP_RECONFIG_RESULT::L2CAP_RECONFIG_REDUCTION_MPS_NO_ALLOWED);
296     CASE_RETURN_TEXT(tL2CAP_RECONFIG_RESULT::L2CAP_RECONFIG_INVALID_DCID);
297     CASE_RETURN_TEXT(tL2CAP_RECONFIG_RESULT::L2CAP_RECONFIG_UNACCAPTED_PARAM);
298   }
299   RETURN_UNKNOWN_TYPE_STRING(tL2CAP_RECONFIG_RESULT, result);
300 }
301 
302 /* Define the L2CAP command reject reason codes
303  */
304 #define L2CAP_CMD_REJ_NOT_UNDERSTOOD 0
305 #define L2CAP_CMD_REJ_MTU_EXCEEDED 1
306 #define L2CAP_CMD_REJ_INVALID_CID 2
307 
308 /* L2CAP Predefined CIDs
309  */
310 enum tL2CAP_CID_FIXED : uint16_t {
311   L2CAP_SIGNALLING_CID = 1,
312   L2CAP_CONNECTIONLESS_CID = 2,
313   L2CAP_AMP_CID = 3,
314   L2CAP_ATT_CID = 4,
315   L2CAP_BLE_SIGNALLING_CID = 5,
316   L2CAP_SMP_CID = 6,
317   L2CAP_SMP_BR_CID = 7,
318   L2CAP_BASE_APPL_CID = 0x0040,
319 };
320 
l2cap_cid_fixed_text(const tL2CAP_CID_FIXED & cid)321 inline std::string l2cap_cid_fixed_text(const tL2CAP_CID_FIXED& cid) {
322   switch (cid) {
323     CASE_RETURN_STRING_HEX04(L2CAP_SIGNALLING_CID);
324     CASE_RETURN_STRING_HEX04(L2CAP_CONNECTIONLESS_CID);
325     CASE_RETURN_STRING_HEX04(L2CAP_AMP_CID);
326     CASE_RETURN_STRING_HEX04(L2CAP_ATT_CID);
327     CASE_RETURN_STRING_HEX04(L2CAP_BLE_SIGNALLING_CID);
328     CASE_RETURN_STRING_HEX04(L2CAP_SMP_CID);
329     CASE_RETURN_STRING_HEX04(L2CAP_SMP_BR_CID);
330     CASE_RETURN_STRING_HEX04(L2CAP_BASE_APPL_CID);
331   }
332   RETURN_UNKNOWN_TYPE_STRING(type, cid);
333 }
334 
335 /* Fixed Channels mask bits */
336 
337 /* Signal channel supported (Mandatory) */
338 #define L2CAP_FIXED_CHNL_SIG_BIT (1 << L2CAP_SIGNALLING_CID)
339 
340 /* Connectionless reception */
341 #define L2CAP_FIXED_CHNL_CNCTLESS_BIT (1 << L2CAP_CONNECTIONLESS_CID)
342 
343 /* Attribute protocol supported */
344 #define L2CAP_FIXED_CHNL_ATT_BIT (1 << L2CAP_ATT_CID)
345 
346 /* BLE Signalling supported */
347 #define L2CAP_FIXED_CHNL_BLE_SIG_BIT (1 << L2CAP_BLE_SIGNALLING_CID)
348 
349 /* BLE Security Mgr supported */
350 #define L2CAP_FIXED_CHNL_SMP_BIT (1 << L2CAP_SMP_CID)
351 
352 /* Security Mgr over BR supported */
353 #define L2CAP_FIXED_CHNL_SMP_BR_BIT (1 << L2CAP_SMP_BR_CID)
354 
355 /* Define the L2CAP configuration result codes
356  */
357 enum class tL2CAP_CFG_RESULT : uint16_t {
358   L2CAP_CFG_OK = 0,
359   L2CAP_CFG_UNACCEPTABLE_PARAMS = 1,
360   L2CAP_CFG_FAILED_NO_REASON = 2,
361   L2CAP_CFG_UNKNOWN_OPTIONS = 3,
362   L2CAP_CFG_PENDING = 4,
363 };
364 
l2cap_cfg_result_text(const tL2CAP_CFG_RESULT & result)365 inline std::string l2cap_cfg_result_text(const tL2CAP_CFG_RESULT& result) {
366   switch (result) {
367     CASE_RETURN_STRING_HEX04(tL2CAP_CFG_RESULT::L2CAP_CFG_OK);
368     CASE_RETURN_STRING_HEX04(tL2CAP_CFG_RESULT::L2CAP_CFG_UNACCEPTABLE_PARAMS);
369     CASE_RETURN_STRING_HEX04(tL2CAP_CFG_RESULT::L2CAP_CFG_FAILED_NO_REASON);
370     CASE_RETURN_STRING_HEX04(tL2CAP_CFG_RESULT::L2CAP_CFG_UNKNOWN_OPTIONS);
371     CASE_RETURN_STRING_HEX04(tL2CAP_CFG_RESULT::L2CAP_CFG_PENDING);
372   }
373   RETURN_UNKNOWN_TYPE_STRING(type, result);
374 }
375 
376 /* Define the L2CAP configuration option types
377  */
378 #define L2CAP_CFG_TYPE_MTU 0x01
379 #define L2CAP_CFG_TYPE_FLUSH_TOUT 0x02
380 #define L2CAP_CFG_TYPE_QOS 0x03
381 #define L2CAP_CFG_TYPE_FCR 0x04
382 #define L2CAP_CFG_TYPE_FCS 0x05
383 #define L2CAP_CFG_TYPE_EXT_FLOW 0x06
384 
385 #define L2CAP_CFG_MTU_OPTION_LEN 2       /* MTU option length    */
386 #define L2CAP_CFG_FLUSH_OPTION_LEN 2     /* Flush option len     */
387 #define L2CAP_CFG_QOS_OPTION_LEN 22      /* QOS option length    */
388 #define L2CAP_CFG_FCR_OPTION_LEN 9       /* FCR option length    */
389 #define L2CAP_CFG_FCS_OPTION_LEN 1       /* FCR option length    */
390 #define L2CAP_CFG_EXT_FLOW_OPTION_LEN 16 /* Extended Flow Spec   */
391 #define L2CAP_CFG_OPTION_OVERHEAD 2      /* Type and length      */
392 
393 /* Configuration Cmd/Rsp Flags mask
394  */
395 #define L2CAP_CFG_FLAGS_MASK_CONT 0x0001 /* Flags mask: Continuation */
396 
397 /* FCS Check Option values
398  */
399 #define L2CAP_CFG_FCS_BYPASS 0 /* Bypass the FCS in streaming or ERTM modes */
400 #define L2CAP_CFG_FCS_USE 1    /* Use the FCS in streaming or ERTM modes [default] */
401 
402 /* Default values for configuration
403  */
404 #define L2CAP_NO_AUTOMATIC_FLUSH 0xFFFF
405 
406 #define L2CAP_DEFAULT_MTU (672)
407 #define L2CAP_DEFAULT_SERV_TYPE 1
408 #define L2CAP_DEFAULT_TOKEN_RATE 0
409 #define L2CAP_DEFAULT_BUCKET_SIZE 0
410 #define L2CAP_DEFAULT_PEAK_BANDWIDTH 0
411 #define L2CAP_DEFAULT_LATENCY 0xFFFFFFFF
412 #define L2CAP_DEFAULT_DELAY 0xFFFFFFFF
413 
414 /* Define the L2CAP disconnect result codes
415  */
416 #define L2CAP_DISC_OK 0
417 #define L2CAP_DISC_TIMEOUT 0xEEEE
418 
419 /* Define the L2CAP info resp result codes
420  */
421 #define L2CAP_INFO_RESP_RESULT_SUCCESS 0
422 #define L2CAP_INFO_RESP_RESULT_NOT_SUPPORTED 1
423 
424 /* Define the info-type fields of information request & response
425  */
426 #define L2CAP_CONNLESS_MTU_INFO_TYPE 0x0001
427 /* Used in Information Req/Response */
428 #define L2CAP_EXTENDED_FEATURES_INFO_TYPE 0x0002
429 /* Used in AMP                      */
430 #define L2CAP_FIXED_CHANNELS_INFO_TYPE 0x0003
431 
432 /* Connectionless MTU size          */
433 #define L2CAP_CONNLESS_MTU_INFO_SIZE 2
434 /* Extended features array size     */
435 #define L2CAP_EXTENDED_FEATURES_ARRAY_SIZE 4
436 /* Fixed channel array size         */
437 #define L2CAP_FIXED_CHNL_ARRAY_SIZE 8
438 
439 /* Extended features mask bits
440  */
441 /* Enhanced retransmission mode           */
442 #define L2CAP_EXTFEA_ENH_RETRANS 0x00000008
443 /* Streaming Mode                         */
444 #define L2CAP_EXTFEA_STREAM_MODE 0x00000010
445 /* Optional FCS (if set No FCS desired)   */
446 #define L2CAP_EXTFEA_NO_CRC 0x00000020
447 /* Extended flow spec                     */
448 #define L2CAP_EXTFEA_EXT_FLOW_SPEC 0x00000040
449 /* Fixed channels                         */
450 #define L2CAP_EXTFEA_FIXED_CHNLS 0x00000080
451 /* Extended Window Size                   */
452 #define L2CAP_EXTFEA_EXT_WINDOW 0x00000100
453 /* Unicast Connectionless Data Reception  */
454 #define L2CAP_EXTFEA_UCD_RECEPTION 0x00000200
455 
456 /* Mask for locally supported features used in Information Response
457  * (default to none) */
458 #ifndef L2CAP_EXTFEA_SUPPORTED_MASK
459 #define L2CAP_EXTFEA_SUPPORTED_MASK 0
460 #endif
461 
462 /* Mask for LE supported features used in Information Response
463  * (default to none) */
464 #ifndef L2CAP_BLE_EXTFEA_MASK
465 #define L2CAP_BLE_EXTFEA_MASK 0
466 #endif
467 
468 /* Define a value that tells L2CAP to use the default HCI ACL buffer size */
469 #define L2CAP_INVALID_ERM_BUF_SIZE 0
470 /* Define a value that tells L2CAP to use the default MPS */
471 #define L2CAP_DEFAULT_ERM_MPS 0x0000
472 
473 #define L2CAP_FCR_OVERHEAD 2         /* Control word                 */
474 #define L2CAP_FCS_LEN 2              /* FCS takes 2 bytes */
475 #define L2CAP_SDU_LEN_OVERHEAD 2     /* SDU length field is 2 bytes */
476 #define L2CAP_SDU_LEN_OFFSET 2       /* SDU length offset is 2 bytes */
477 #define L2CAP_EXT_CONTROL_OVERHEAD 4 /* Extended Control Field       */
478 /* length(2), channel(2), control(4), SDU length(2) FCS(2) */
479 #define L2CAP_MAX_HEADER_FCS \
480   (L2CAP_PKT_OVERHEAD + L2CAP_EXT_CONTROL_OVERHEAD + L2CAP_SDU_LEN_OVERHEAD + L2CAP_FCS_LEN)
481 
482 /* TODO: This value can probably be optimized per transport, and per L2CAP
483  * socket type, but this should not bring any big performance improvements. For
484  * LE CoC, it should be biggest multiple of "PDU length" smaller than 0xffff (so
485  * depend on controller buffer size), for Classic, making it multiple of PDU
486  * length and also of the 3DH5 air including the l2cap headers in each packet.
487  */
488 #define L2CAP_SDU_LENGTH_MAX (8080 + 26 - (L2CAP_MIN_OFFSET + 6))
489 constexpr uint16_t L2CAP_SDU_LENGTH_LE_MAX = 0xffff;
490 constexpr uint16_t L2CAP_SDU_LENGTH_LE_MIN = 23;
491 
492 /* SAR bits in the control word
493  */
494 /* Control word to begin with for unsegmented PDU*/
495 #define L2CAP_FCR_UNSEG_SDU 0x0000
496 /* ...for Starting PDU of a semented SDU */
497 #define L2CAP_FCR_START_SDU 0x4000
498 /* ...for ending PDU of a segmented SDU */
499 #define L2CAP_FCR_END_SDU 0x8000
500 /* ...for continuation PDU of a segmented SDU */
501 #define L2CAP_FCR_CONT_SDU 0xc000
502 
503 /* Supervisory frame types */
504 /* Supervisory frame - RR                          */
505 #define L2CAP_FCR_SUP_RR 0x0000
506 /* Supervisory frame - REJ                         */
507 #define L2CAP_FCR_SUP_REJ 0x0001
508 /* Supervisory frame - RNR                         */
509 #define L2CAP_FCR_SUP_RNR 0x0002
510 /* Supervisory frame - SREJ                        */
511 #define L2CAP_FCR_SUP_SREJ 0x0003
512 
513 /* Mask to get the SAR bits from control word */
514 #define L2CAP_FCR_SAR_BITS 0xC000
515 /* Bits to shift right to get the SAR bits from ctrl-word */
516 #define L2CAP_FCR_SAR_BITS_SHIFT 14
517 
518 /* Mask to check if a PDU is S-frame */
519 #define L2CAP_FCR_S_FRAME_BIT 0x0001
520 /* Mask to get the req-seq from control word */
521 #define L2CAP_FCR_REQ_SEQ_BITS 0x3F00
522 /* Bits to shift right to get the req-seq from ctrl-word */
523 #define L2CAP_FCR_REQ_SEQ_BITS_SHIFT 8
524 /* Mask on get the tx-seq from control word */
525 #define L2CAP_FCR_TX_SEQ_BITS 0x007E
526 /* Bits to shift right to get the tx-seq from ctrl-word */
527 #define L2CAP_FCR_TX_SEQ_BITS_SHIFT 1
528 
529 /* F-bit in the control word (Sup and I frames)  */
530 #define L2CAP_FCR_F_BIT 0x0080
531 /* P-bit in the control word (Sup frames only)   */
532 #define L2CAP_FCR_P_BIT 0x0010
533 
534 #define L2CAP_FCR_F_BIT_SHIFT 7
535 #define L2CAP_FCR_P_BIT_SHIFT 4
536 
537 /* Mask to get the segmentation bits from ctrl-word */
538 #define L2CAP_FCR_SEG_BITS 0xC000
539 /* Bits to shift right to get the S-bits from ctrl-word */
540 #define L2CAP_FCR_SUP_SHIFT 2
541 /* Mask to get the supervisory bits from ctrl-word */
542 #define L2CAP_FCR_SUP_BITS 0x000C
543 
544 /* Initial state of the CRC register */
545 #define L2CAP_FCR_INIT_CRC 0
546 /* Mask for sequence numbers (range 0 - 63) */
547 #define L2CAP_FCR_SEQ_MODULO 0x3F
548 
549 namespace std {
550 template <>
551 struct formatter<tL2CAP_CONN> : enum_formatter<tL2CAP_CONN> {};
552 template <>
553 struct formatter<tL2CAP_CID_FIXED> : enum_formatter<tL2CAP_CID_FIXED> {};
554 template <>
555 struct formatter<tL2CAP_LE_RESULT_CODE> : enum_formatter<tL2CAP_LE_RESULT_CODE> {};
556 }  // namespace std
557