1 /*
2  * Copyright (C) 2021 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #ifndef RFCOMM_DEFS_H
17 #define RFCOMM_DEFS_H
18 
19 #include <stdbool.h>
20 #include <stddef.h>
21 #include <stdint.h>
22 #include <stdlib.h>
23 #include <string.h>
24 
25 #include "btm/btm_thread.h"
26 #include "btstack.h"
27 #include "gap_if.h"
28 #include "l2cap_if.h"
29 #include "log.h"
30 #include "packet.h"
31 #include "platform/include/alarm.h"
32 #include "platform/include/event.h"
33 #include "platform/include/list.h"
34 #include "platform/include/mutex.h"
35 #include "platform/include/random.h"
36 #include "rfcomm.h"
37 #include "securec.h"
38 
39 #define BT_PSM_RFCOMM 3
40 #define RFCOMM_L2CAP_MTU 1500
41 #define RFCOMM_L2CAP_DEFAUT_MTU L2CAP_DEFAULT_MTU
42 #define RFCOMM_HEAD_MAX_LEN 6  // Address(1),control(1),length(2),credit(1),tail(1)
43 #define RFCOMM_LOCAL_DEFAULT_MTU (RFCOMM_L2CAP_MTU - RFCOMM_HEAD_MAX_LEN)
44 #define RFCOMM_PEER_DEFAULT_MTU 127
45 #define MAX_SESSION_COUNT BT_CONNECT_NUM_MAX
46 #define MAX_SERVER_COUNT 30
47 #define MAX_DLC_COUNT 36
48 #define MAX_CREDIT_COUNT 10
49 #define MAX_QUEUE_COUNT MAX_CREDIT_COUNT
50 #define MAX_ONCE_NEWCREDIT 255
51 
52 #define FRAME_TYPE_SABM 0b00101111
53 #define FRAME_TYPE_UA 0b01100011
54 #define FRAME_TYPE_DM 0b00001111
55 #define FRAME_TYPE_DISC 0b01000011
56 #define FRAME_TYPE_UIH 0b11101111
57 
58 #define UIH_TYPE_PN 0b00100000
59 #define UIH_TYPE_MSC 0b00111000
60 #define UIH_TYPE_RPN 0b00100100
61 #define UIH_TYPE_RLS 0b00010100
62 #define UIH_TYPE_TEST 0b00001000
63 #define UIH_TYPE_FCON 0b00101000
64 #define UIH_TYPE_FCOFF 0b00011000
65 #define UIH_TYPE_NSC 0b00000100
66 
67 #define EA 0b00000001
68 #define PF 0b00010000
69 #define CONTROL_DLCI 0x00
70 
71 // Common command header information
72 #define RFCOMM_ADDRESS 0x00
73 #define RFCOMM_CONTROL 0x01
74 #define RFCOMM_LENGTH_1 0x02
75 #define RFCOMM_LENGTH_2 0x03
76 #define RFCOMM_INFO_TYPE 0x03
77 #define RFCOMM_INFO_LEN 0x04
78 // PN command
79 #define RFCOMM_PN_DLCI 0x05
80 #define RFCOMM_PN_CL 0x06
81 #define RFCOMM_PN_PRIORITY 0x07
82 #define RFCOMM_PN_TIME 0x08
83 #define RFCOMM_PN_MTU1 0x09
84 #define RFCOMM_PN_MTU2 0x0A
85 #define RFCOMM_PN_NA 0x0B
86 #define RFCOMM_PN_CREDIT 0x0C
87 // MSC command
88 #define RFCOMM_MSC_DLCI 0x05
89 #define RFCOMM_MSC_SIGNAL 0x06
90 #define RFCOMM_MSC_BREAK 0x07
91 // RLS command
92 #define RFCOMM_RLS_DLCI 0x05
93 #define RFCOMM_RLS_STATUS 0x06
94 // RPN command
95 #define RFCOMM_RPN_DLCI 0x05
96 #define RFCOMM_RPN_BAUDRATE 0x06
97 #define RFCOMM_RPN_BITINFO 0x07
98 #define RFCOMM_RPN_FLC 0x08
99 #define RFCOMM_RPN_XON 0x09
100 #define RFCOMM_RPN_XOFF 0x0A
101 #define RFCOMM_RPN_MASK1 0x0B
102 #define RFCOMM_RPN_MASK2 0x0C
103 // NSC command
104 #define RFCOMM_NSC_TYPE 0x05
105 
106 #define RFCOMM_OFFSET_0 0x00
107 #define RFCOMM_OFFSET_1 0x01
108 #define RFCOMM_OFFSET_2 0x02
109 #define RFCOMM_OFFSET_3 0x03
110 #define RFCOMM_OFFSET_4 0x04
111 #define RFCOMM_OFFSET_5 0x05
112 #define RFCOMM_OFFSET_6 0x06
113 #define RFCOMM_OFFSET_7 0x07
114 
115 // FCS calculation length
116 #define RFCOMM_IS_UIH_FSC_LEN 0x02
117 #define RFCOMM_NOT_UIH_FSC_LEN 0x03
118 
119 #define RFCOMM_SHIFT_CR 0x01
120 #define RFCOMM_SHIFT_DLCI 0x02
121 #define RFCOMM_SHIFT_PF 0x04
122 #define RFCOMM_SHIFT_TYPE 0x02
123 #define RFCOMM_SHIFT_LENGTH2 0x07
124 #define RFCOMM_DLCI_SHIFT_SCN 0x01
125 #define RFCOMM_RLS_SHIFT_OVERRUN 0x01
126 #define RFCOMM_RLS_SHIFT_PARITY 0x02
127 #define RFCOMM_RLS_SHIFT_FRAMING 0x03
128 #define RFCOMM_MSC_SHIFT_BREAKLEN 0x03
129 #define RFCOMM_PN_SHIFT_CL 0x04
130 #define RFCOMM_PN_SHIFT_MTU 0x08
131 #define RFCOMM_RPN_SHIFT_STOP_BIT 0x02
132 #define RFCOMM_RPN_SHIFT_PARITY 0x03
133 #define RFCOMM_RPN_SHIFT_PARITY_TYPE 0x04
134 
135 #define IS_DLCI_VALID(dlci) ((dlci) >= 2 && (dlci) <= 61)
136 #define IS_MTU_VALID(mtu) ((mtu) >= 23 && (mtu) <= 32767)
137 #define IS_CMD(isInitiator, cr) (((isInitiator) && !(cr)) || (!(isInitiator) && (cr)))
138 #define IS_RSP(isInitiator, cr) (((isInitiator) && (cr)) || (!(isInitiator) && !(cr)))
139 #define IS_FIRST_CMD(event)                                                                                        \
140     ((event) == EV_CHANNEL_RECV_SABM || (event) == EV_CHANNEL_RECV_PN_REQ || (event) == EV_CHANNEL_RECV_RPN_CMD || \
141         (event) == EV_CHANNEL_RECV_RPN_REQ)
142 #define IS_DISCONNECTED(event)                                                                 \
143     ((event) == RFCOMM_CHANNEL_EV_CONNECT_FAIL || (event) == RFCOMM_CHANNEL_EV_DISCONNECTED || \
144         (event) == RFCOMM_CHANNEL_EV_DISCONNECT_SUCCESS)
145 
146 #define CL_REQ_SUPPORT_CREDIT 0x0F
147 #define CL_RSP_SUPPORT_CREDIT 0x0E
148 #define CL_REQ_UNSUPPORTED_CREDIT 0x00
149 #define CL_RSP_UNSUPPORTED_CREDIT 0x00
150 #define DEFAULT_CREDITS_VALUE 7
151 
152 // Timer value(s)
153 #define RFCOMM_PER_SEC 1000
154 #define T1_SABM_DISC 20      // The timeout for SABM and DISC frames in RFCOMM).
155 #define T1_SABM_OPEN_DLC 60  // The timeout for SABM frame to start a new DLC (with DLCI > 0).
156 #define T2_UIH_DLCI0 20      // The timeout for commands sent in UIH frames on DLCI 0.
157 
158 #define RFCOMM_NUM_TEN 10
159 
160 // Transfer status
161 #define MSC_CMD_SEND 0b001
162 #define MSC_CMD_RECV 0b010
163 #define MSC_RSP_RECV 0b100
164 #define TRANSFER_READY 0b111
165 
166 // Information length
167 #define RFCOMM_PN_INFO_LEN 0x08
168 #define RFCOMM_RLS_INFO_LEN 0x02
169 #define RFCOMM_RPN_REQINFO_LEN 0x01
170 #define RFCOMM_RPN_CMDINFO_LEN 0x08
171 #define RFCOMM_MSC_INFO_HAVEBREAK_LEN 0x03
172 #define RFCOMM_MSC_INFO_NO_BREAK_LEN 0x02
173 #define RFCOMM_NSC_INFO_LEN 0x01
174 // Frame length(info:type 1byte + len 1byte + info length)
175 #define RFCOMM_PN_FRAME_LEN (RFCOMM_PN_INFO_LEN + 2)
176 #define RFCOMM_RLS_FRAME_LEN (RFCOMM_RLS_INFO_LEN + 2)
177 #define RFCOMM_RPN_REQFRAME_LEN (RFCOMM_RPN_REQINFO_LEN + 2)
178 #define RFCOMM_RPN_CMDFRAME_LEN (RFCOMM_RPN_CMDINFO_LEN + 2)
179 #define RFCOMM_MSC_FRAME_HAVEBREAK_LEN (RFCOMM_MSC_INFO_HAVEBREAK_LEN + 2)
180 #define RFCOMM_MSC_FRAME_NO_BREAK_LEN (RFCOMM_MSC_INFO_NO_BREAK_LEN + 2)
181 #define RFCOMM_FCON_FRAME_LEN 0x02
182 #define RFCOMM_FCOFF_FRAME_LEN 0x02
183 #define RFCOMM_NSC_FRAME_LEN (RFCOMM_NSC_INFO_LEN + 2)
184 #define RFCOMM_TEST_FRAME_LEN_MIN 0x02
185 // Total header length
186 #define RFCOMM_SABM_HEADER_LEN 0x03
187 #define RFCOMM_DISC_HEADER_LEN 0x03
188 #define RFCOMM_UA_HEADER_LEN 0x03
189 #define RFCOMM_DM_HEADER_LEN 0x03
190 #define RFCOMM_PN_HEADER_LEN (RFCOMM_PN_FRAME_LEN + 3)
191 #define RFCOMM_RLS_HEADER_LEN (RFCOMM_RLS_FRAME_LEN + 3)
192 #define RFCOMM_RPN_REQHEADER_LEN (RFCOMM_RPN_REQFRAME_LEN + 3)
193 #define RFCOMM_RPN_CMDHEADER_LEN (RFCOMM_RPN_CMDFRAME_LEN + 3)
194 #define RFCOMM_MSC_HAVEBREAK_HEADER_LEN (RFCOMM_MSC_FRAME_HAVEBREAK_LEN + 3)
195 #define RFCOMM_MSC_NO_BREAK_HEADER_LEN (RFCOMM_MSC_FRAME_NO_BREAK_LEN + 3)
196 #define RFCOMM_FCON_HEADER_LEN (RFCOMM_FCON_FRAME_LEN + 3)
197 #define RFCOMM_FCOFF_HEADER_LEN (RFCOMM_FCOFF_FRAME_LEN + 3)
198 #define RFCOMM_NSC_HEADER_LEN (RFCOMM_NSC_FRAME_LEN + 3)
199 #define RFCOMM_TEST_HEADER_LEN_MAX 0x07
200 #define RFCOMM_DATA_HEADER_LEN_MAX 0x05
201 
202 // Default rpn value
203 #define BAUDRATE_9600 0x03
204 #define DATA_BIT_8 0x08
205 #define STOP_BIT_1 0x00
206 #define NO_PARITY 0x00
207 #define ODD_PARITY 0x00
208 #define NO_FLC 0x00
209 #define XON_DC1 0x11
210 #define XOFF_DC3 0x13
211 
212 // Remote port line status
213 #define OVERRUN_ERROR 0b001  // Received character overwrote an unread character
214 #define PARITY_ERROR 0b010   // Received character’s parity was incorrect
215 #define FRAMING_ERROR 0b100  // a character did not terminate with a stop bit
216 
217 typedef enum {
218     EVENT_UNKNOWN = 0,
219     EVENT_SESSION,
220     EVENT_CHANNEL,
221     EVENT_FRAME_ERR,
222     EVENT_UNSUPPORTED_CMD
223 } RfcommEventType;
224 
225 typedef enum {
226     EV_SESSION_SEND_OPEN_REQ = 0,
227     EV_SESSION_SEND_CLOSE_REQ,
228     EV_SESSION_RECV_REQ_CONNECT_RESULT,
229     EV_SESSION_RECV_SECURITY_RESULT,
230     EV_SESSION_RECV_CONNECT_REQ,
231     EV_SESSION_RECV_CONNECT_RSP,
232     EV_SESSION_RECV_CONFIG_REQ,
233     EV_SESSION_RECV_CONFIG_RSP,
234     EV_SESSION_RECV_DISCONNECT_REQ,
235     EV_SESSION_RECV_SABM0,
236     EV_SESSION_RECV_DISC0,
237     EV_SESSION_RECV_UA0,
238     EV_SESSION_RECV_DM0,
239     EV_SESSION_RECV_FCON_REQ,
240     EV_SESSION_RECV_FCON_RSP,
241     EV_SESSION_RECV_FCOFF_REQ,
242     EV_SESSION_RECV_FCOFF_RSP,
243     EV_SESSION_RECV_TEST_REQ,
244     EV_SESSION_RECV_TEST_RSP,
245     EV_SESSION_RECV_NSC,
246     EV_SESSION_RECV_LINK_LOSS,
247     EV_SESSION_TIMEOUT,
248     EV_SESSION_EV_MAX
249 } RfcommSessionEvent;
250 
251 typedef enum {
252     EV_CHANNEL_SEND_OPEN_REQ = 0,
253     EV_CHANNEL_SEND_CLOSE_REQ,
254     EV_CHANNEL_RECV_SECURITY_RESULT,
255     EV_CHANNEL_RECV_SABM,
256     EV_CHANNEL_RECV_DISC,
257     EV_CHANNEL_RECV_UA,
258     EV_CHANNEL_RECV_DM,
259     EV_CHANNEL_RECV_PN_REQ,
260     EV_CHANNEL_RECV_PN_RSP,
261     EV_CHANNEL_RECV_MSC_REQ,
262     EV_CHANNEL_RECV_MSC_RSP,
263     EV_CHANNEL_RECV_RPN_CMD,
264     EV_CHANNEL_RECV_RPN_REQ,
265     EV_CHANNEL_RECV_RPN_RSP,
266     EV_CHANNEL_RECV_RLS_REQ,
267     EV_CHANNEL_RECV_RLS_RSP,
268     EV_CHANNEL_ACCEPT,
269     EV_CHANNEL_REJECT,
270     EV_CHANNEL_RECV_DATA,
271     EV_CHANNEL_WRITE_DATA,
272     EV_CHANNEL_SEND_RPN_CMD,
273     EV_CHANNEL_SEND_RPN_REQ,
274     EV_CHANNEL_SEND_RLS_REQ,
275     EV_CHANNEL_SEND_MSC_REQ,
276     EV_CHANNEL_TIMEOUT,
277     EV_CHANNEL_EV_MAX
278 } RfcommChannelEvent;
279 
280 typedef enum { FC_TYPE_UNKNOWN = 0, FC_TYPE_NORMAL, FC_TYPE_CREDIT } RfcommFlowControlType;
281 
282 typedef enum { PN_REQ = 0, PN_RSP_BEFORE_CREATE, PN_RSP_AFTER_CREATE } RfcommPnCmdKind;
283 
284 typedef enum {
285     ST_SESSION_CLOSED = 0,
286     ST_SESSION_INITIATOR_WAIT_SECURITY_RESULT,
287     ST_SESSION_WAIT_CONNECT_REQ_RESULT,
288     ST_SESSION_WAIT_CONNECT_RSP,
289     ST_SESSION_INITIATOR_WAIT_CONFIG_REQ_AND_RSP,
290     ST_SESSION_INITIATOR_WAIT_CONFIG_REQ,
291     ST_SESSION_INITIATOR_WAIT_CONFIG_RSP,
292     ST_SESSION_SABM0_REQ_WAIT_UA0,
293     ST_SESSION_RESPONDER_WAIT_SECURITY_RESULT,
294     ST_SESSION_RESPONDER_WAIT_CONFIG_REQ_AND_RSP,
295     ST_SESSION_RESPONDER_WAIT_CONFIG_REQ,
296     ST_SESSION_RESPONDER_WAIT_CONFIG_RSP,
297     ST_SESSION_WAIT_SABM0,
298     ST_SESSION_DISC0_REQ_WAIT_UA0,
299     ST_SESSION_WAIT_RESTART,
300     ST_SESSION_CLOSING,
301     ST_SESSION_CONNECTED
302 } RfcommSessionState;
303 
304 typedef enum {
305     ST_CHANNEL_CLOSED = 0,
306     ST_CHANNEL_WAIT_PN_RSP,
307     ST_CHANNEL_CLIENT_WAIT_SECURITY_RESULT,
308     ST_CHANNEL_SABM_REQ_WAIT_UA,
309     ST_CHANNEL_WAIT_UPPER_RESPONSE,
310     ST_CHANNEL_WAIT_SABM,
311     ST_CHANNEL_SERVER_WAIT_SECURITY_RESULT,
312     ST_CHANNEL_DISC_REQ_WAIT_UA,
313     ST_CHANNEL_WAIT_RESTART,
314     ST_CHANNEL_CONNECTED
315 } RfcommChannelState;
316 
317 typedef struct {
318 #define MSC_FC 0b00000001
319 #define MSC_RTC 0b00000010
320 #define MSC_RTR 0b00000100
321 #define MSC_IC 0b00100000
322 #define MSC_DV 0b01000000
323     uint8_t signals;
324 #define MSC_BREAK 0b00000001
325 #define MSC_BREAK_LEN 0b01111000
326     uint8_t breakSignal;
327 } RfcommModemStatusInfo;
328 
329 typedef struct {
330     uint8_t scn;
331     uint16_t maxRevSize;
332     uint32_t eventMask;
333     RFCOMM_EventCallback callBack;
334     void *context;
335 } RfcommServerInfo;
336 
337 typedef struct {
338     uint16_t l2capId;
339     uint8_t id; // Only use in recvConnectionReq callback
340     uint16_t pendingL2capId;
341     uint8_t pendingId;
342     BtAddr btAddr;
343     bool isInitiator;
344     bool peerSessionFc;
345     RfcommFlowControlType fcType;
346     RfcommSessionState sessionState;
347     Alarm *timer;
348     uint16_t l2capPeerMtu;
349     uint16_t l2capLocalMtu;
350 } RfcommSessionInfo;
351 
352 typedef struct {
353     RfcommSessionInfo *session;
354     bool isServer;
355     uint8_t dlci;
356     uint16_t mtu;
357     uint32_t eventMask;
358     RFCOMM_EventCallback callback;
359     void *context;
360 } RfcommCreateChannelInfo;
361 
362 typedef struct {
363     uint8_t cl;
364     uint8_t credits;
365     uint16_t mtu;
366     uint8_t priority;
367 } RfcommSendPnInfo;
368 
369 typedef struct {
370     uint16_t handle;
371     uint8_t dlci;
372     uint8_t scn;
373     bool isServer;
374     RfcommSessionInfo *session;
375     uint16_t peerMtu;
376     uint16_t localMtu;
377     RfcommChannelState channelState;
378     uint8_t transferReady;
379     bool peerChannelFc;
380     bool localFcToPeer;
381     bool localFcToUpper;
382     uint8_t peerCredit;
383     uint8_t localCredit;
384     uint8_t localCreditMax;
385     List *sendQueue;
386     List *recvQueue;
387     uint8_t lineStatus;
388     RfcommRemotePortConfig portConfig;
389     RfcommModemStatusInfo peerModemSt;
390     uint32_t eventMask;
391     uint32_t receivedBytes;
392     uint32_t transmittedBytes;
393     Alarm *timer;
394     RFCOMM_EventCallback callBack;
395     void *context;
396 } RfcommChannelInfo;
397 
398 typedef struct {
399     L2capConfigInfo cfg;
400     uint16_t result;
401 } RfcommConfigRspInfo;
402 
403 typedef struct {
404     L2capConfigInfo cfg;
405     uint8_t id;
406 } RfcommConfigReqInfo;
407 
408 typedef struct {
409     uint16_t lcid;
410     int result;
411 } RfcommReqConnectRslt;
412 
413 typedef union {
414     struct {
415         uint8_t dlci;
416         uint8_t cl;
417         uint8_t priority;
418         uint16_t mtu;
419         uint8_t k;
420     } pn;
421     struct {
422         uint8_t dlci;
423         uint8_t signal;
424         uint8_t breakSignal;
425     } msc;
426     struct {
427         uint8_t dlci;
428         bool isCmd;
429         RfcommRemotePortConfig rpnInfo;
430     } rpn;
431     struct {
432         uint8_t dlci;
433         uint8_t lineStatus;
434     } rls;
435     struct {
436         uint8_t ea;
437         uint8_t cr;
438         uint8_t type;
439     } nsc;
440     struct {
441         Packet *pkt;
442         uint16_t length;
443     } test;
444     struct {
445         uint8_t credits;
446         Packet *payload;
447         size_t size;
448     } data;
449     struct {
450         uint8_t ea;
451         uint8_t cr;
452         uint8_t type;
453     } invalidCmd;
454 } RfcommUihInfo;
455 
456 typedef struct {
457     bool isInitiator;
458     uint8_t cr;
459     uint8_t dlci;
460     uint8_t pf;
461     uint8_t fcs;
462     uint8_t calcInfo[3];
463     uint16_t length;
464 } RfcommCheckFrameValidInfo;
465 
466 typedef struct {
467     uint8_t cr;
468     uint8_t dlci;
469     uint8_t pf;
470     uint8_t type;
471     uint8_t fcs;
472     uint8_t calcInfo[3];
473     uint16_t length;
474 } RfcommFrameHeaderTailInfo;
475 
476 typedef struct {
477     uint8_t *dlci;
478     int *event;
479     RfcommUihInfo *info;
480 } RfcommParseFrameResult;
481 
482 typedef struct {
483     uint16_t lcid;
484     uint8_t id;
485 } RfcommRecvConnectedInfo;
486 
487 typedef struct {
488     uint16_t result;
489     GAP_ServiceConnectDirection direction;
490 } RfcommSessionSecurityRslt;
491 
492 void RfcommInitialize();
493 void RfcommFinalize();
494 uint8_t RfcommAssignServerNum();
495 int RfcommFreeServerNum(uint8_t scn);
496 int RfcommConnectChannel(const RfcommConnectReqInfo *reqInfo, uint16_t *handle);
497 int RfcommRegisterServer(uint8_t scn, uint16_t mtu, uint32_t eventMask, RFCOMM_EventCallback callback, void *context);
498 int RfcommDeregisterServer(uint8_t scn, bool isRemoveCallback);
499 int RfcommAcceptConnection(uint16_t handle);
500 int RfcommRejectConnection(uint16_t handle);
501 int RfcommDisconnectChannel(uint16_t handle);
502 int RfcommSetPortConfig(uint16_t handle, const RfcommRemotePortConfig *config);
503 int RfcommReqPortConfig(uint16_t handle);
504 int RfcommSendRemoteLineStatus(uint16_t handle, const RfcommRemoteLineStatus *lineStatus);
505 int RfcommSetModemStatus(uint16_t handle, const RfcommModemStatus *modemStatus);
506 int RfcommGetPortState(uint16_t handle, RfcommPortState *state);
507 int RfcommRead(uint16_t handle, Packet **pkt);
508 int RfcommWrite(uint16_t handle, Packet *pkt);
509 int RfcommSendTestCmd(uint16_t handle, Packet *pkt);
510 
511 // Call L2CAP interface.
512 // Register and deregister with L2CAP.
513 void RfcommRegisterL2cap();
514 void RfcommDeregisterL2cap();
515 // Send command to L2CAP.
516 int RfcommSendConnectReq(const BtAddr *addr);
517 int RfcommSendConnectRsp(uint16_t lcid, uint8_t id, uint16_t result, uint16_t status);
518 int RfcommSendConfigReq(uint16_t lcid, const L2capConfigInfo *cfg);
519 int RfcommSendConfigRsp(uint16_t lcid, uint8_t id, const L2capConfigInfo *cfg, uint16_t result);
520 int RfcommSendDisconnectReq(uint16_t lcid);
521 int RfcommSendDisconnectRsp(uint16_t lcid, uint8_t id);
522 int RfcommSendData(uint16_t lcid, const uint8_t *header, uint8_t headSize, uint8_t tail, Packet *pkt);
523 // Process callback
524 void RfcommRecvConnectReqCback(uint16_t lcid, uint8_t id, const L2capConnectionInfo *info, uint16_t lpsm);
525 void RfcommRecvConnectRspCback(uint16_t lcid, const L2capConnectionInfo *info, uint16_t result, uint16_t status);
526 void RfcommRecvConfigReqCback(uint16_t lcid, uint8_t id, const L2capConfigInfo *cfg);
527 void RfcommRecvConfigRspCback(uint16_t lcid, const L2capConfigInfo *cfg, uint16_t result);
528 void RfcommRecvDisconnectReqCback(uint16_t lcid, uint8_t id);
529 void RfcommDisconnectAbnormalCback(uint16_t lcid, uint8_t reason);
530 void RfcommRecvDataCback(uint16_t lcid, Packet *pkt);
531 void RfcommSendConnectReqCback(const BtAddr *addr, uint16_t lcid, int result);
532 
533 // Call GAP interface.
534 // Check security.
535 void RfcommRegisterSecurity();
536 void RfcommDeregisterSecurity();
537 int RfcommCheckChannelSecurity(RfcommChannelInfo *channel, bool isServer);
538 int RfcommCheckSessionSecurity(RfcommSessionInfo *session, uint8_t scn, bool isServer);
539 void RfcommRecvChannelSecurityResult(uint16_t result, GapServiceSecurityInfo serviceInfo, void *context);
540 void RfcommRecvSessionSecurityResult(uint16_t result, GapServiceSecurityInfo serviceInfo, void *context);
541 
542 // Create and destroy session list.
543 void RfcommCreateSessionList();
544 void RfcommDestroySessionList();
545 uint8_t RfcommGetSessionLstCnt();
546 // About the method of operating session.
547 RfcommSessionInfo *RfcommCreateSession(const BtAddr *addr, uint16_t lcid, uint8_t id, bool isInitiator);
548 RfcommSessionInfo *RfcommGetSessionByLcid(uint16_t lcid);
549 RfcommSessionInfo *RfcommGetSessionByAddr(const BtAddr *addr);
550 void RfcommResetSessionInfo(RfcommSessionInfo *session);
551 void RfcommRemoveSession(RfcommSessionInfo *session);
552 void RfcommStartSessionTimer(RfcommSessionInfo *session, uint8_t timeout);
553 void RfcommStopSessionTimer(RfcommSessionInfo *session);
554 void RfcommSessionTimeout(void *parameter);
555 bool RfcommIsSessionValid(RfcommSessionInfo *session);
556 void RfcommSetFlowControlType(RfcommSessionInfo *session, bool isPnReq, uint8_t cl);
557 
558 // Session state machine.
559 int RfcommSessionEvtFsm(RfcommSessionInfo *session, RfcommSessionEvent event, const void *data);
560 
561 // Create and destroy channel list.
562 void RfcommCreateChannelList();
563 void RfcommDestroyChannelList();
564 // About the method of operating channel.
565 RfcommChannelInfo *RfcommCreateChannel(const RfcommCreateChannelInfo *createChannelInfo);
566 RfcommChannelInfo *RfcommCreateChannelOfServer(RfcommSessionInfo *session, uint8_t dlci, int event);
567 RfcommChannelInfo *RfcommGetChannelByDlci(const RfcommSessionInfo *session, uint8_t dlci);
568 RfcommChannelInfo *RfcommGetFirstChannelOnSession(const RfcommSessionInfo *session);
569 RfcommChannelInfo *RfcommGetChannelByHandle(uint16_t handle);
570 int RfcommOpenAllChannelOnSession(const RfcommSessionInfo *session);
571 void RfcommResetAllChannelOnSession(const RfcommSessionInfo *session);
572 void RfcommSetFlcToUpper(RfcommChannelInfo *channel);
573 void RfcommSetFlcToPeer(RfcommChannelInfo *channel, bool enable);
574 void RfcommNotifyEvtToUpper(const RfcommChannelInfo *channel, uint32_t eventId, const void *eventData);
575 void RfcommNotifyAllChannelEvtOnSession(const RfcommSessionInfo *session, uint32_t eventId);
576 void RfcommReleaseCachePkt(RfcommChannelInfo *channel);
577 void RfcommRemoveChannel(RfcommChannelInfo *channel);
578 void RfcommRemoveAllChannelOnSession(const RfcommSessionInfo *session);
579 void RfcommRemoveInvalidChannelOnSession(const RfcommSessionInfo *session);
580 void RfcommRemoveChannelCallback(uint8_t scn);
581 void RfcommSendCachePkt(RfcommChannelInfo *channel);
582 void RfcommSendAllCachePktOnSession(const RfcommSessionInfo *session);
583 bool RfcommCheckSessionValid(const RfcommSessionInfo *session);
584 void RfcommCloseInvalidSession(RfcommSessionInfo *session);
585 void RfcommResetChannelInfo(RfcommChannelInfo *channel);
586 void RfcommSetPeerModemStatus(RfcommChannelInfo *channel, const RfcommModemStatusInfo *modemSts);
587 void RfcommStartChannelTimer(RfcommChannelInfo *channel, uint8_t timeout);
588 void RfcommStopChannelTimer(RfcommChannelInfo *channel);
589 void RfcommChannelTimeout(void *parameter);
590 bool RfcommIsChannelValid(const RfcommChannelInfo *channel);
591 void RfcommDeterminePeerMtu(RfcommChannelInfo *channel);
592 void RfcommUpdateChannelDirectionBit(const RfcommSessionInfo *session, bool isInitiator);
593 
594 void RfcommReadLock();
595 void RfcommReadUnlock();
596 
597 // Channel state machine.
598 int RfcommChannelEvtFsm(RfcommChannelInfo *channel, RfcommChannelEvent event, const void *data);
599 
600 // Create and destroy server list.
601 void RfcommCreateServerList();
602 void RfcommDestroyServerList();
603 // About the method of operating server.
604 RfcommServerInfo *RfcommGetServerByScn(uint8_t scn);
605 RfcommServerInfo *RfcommCreateServer(
606     uint8_t scn, uint16_t mtu, uint32_t eventMask, RFCOMM_EventCallback callback, void *context);
607 void RfcommRemoveServer(RfcommServerInfo *server);
608 
609 // Compose or parse Frame.
610 int RfcommSendSabm(const RfcommSessionInfo *session, uint8_t dlci);
611 int RfcommSendDisc(const RfcommSessionInfo *session, uint8_t dlci);
612 int RfcommSendUa(const RfcommSessionInfo *session, uint8_t dlci);
613 int RfcommSendDm(const RfcommSessionInfo *session, uint8_t dlci, bool pf);
614 int RfcommSendUihPn(const RfcommSessionInfo *session, uint8_t dlci, bool isCmd, const RfcommSendPnInfo *pnInfo);
615 int RfcommSendUihMsc(const RfcommSessionInfo *session, uint8_t dlci, bool isCmd,
616                      const RfcommModemStatusInfo *modemSts);
617 int RfcommSendUihRls(const RfcommSessionInfo *session, uint8_t dlci, bool isCmd, uint8_t lineStatus);
618 int RfcommSendUihRpn(const RfcommSessionInfo *session, uint8_t dlci, bool isCmd,
619                      const RfcommRemotePortConfig *portConfig);
620 int RfcommSendUihFcon(const RfcommSessionInfo *session, bool isCmd);
621 int RfcommSendUihFcoff(const RfcommSessionInfo *session, bool isCmd);
622 int RfcommSendUihTest(const RfcommSessionInfo *session, bool isCmd, Packet *pkt);
623 int RfcommSendUihNsc(const RfcommSessionInfo *session, uint8_t ea, uint8_t cr, uint8_t type);
624 int RfcommSendUihData(const RfcommSessionInfo *session, uint8_t dlci, uint8_t newCredits, Packet *pkt);
625 RfcommEventType RfcommParseFrames(const RfcommSessionInfo *session, Packet *pkt, RfcommParseFrameResult output);
626 
627 #endif