1 /*
2  * Copyright (C) 2022 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 #include "hid_host_l2cap_connection.h"
17 #include "hid_host_service.h"
18 
19 namespace OHOS {
20 namespace bluetooth {
Startup()21 int HidHostL2capConnection::Startup()
22 {
23     GapServiceSecurityInfo securityInfo = {INCOMING, HID_HOST, SEC_PROTOCOL_L2CAP,
24         { .l2capPsm = HID_CONTROL_PSM }};
25     if (GAPIF_RegisterServiceSecurity(nullptr, &securityInfo,
26         GAP_SEC_IN_ENCRYPTION | GAP_SEC_IN_AUTHENTICATION |
27         GAP_SEC_OUT_ENCRYPTION | GAP_SEC_OUT_AUTHENTICATION)) {
28         LOG_ERROR("[HIDH L2CAP] %{public}s:GAPIF_RegisterServiceSecurity INCOMING failed.", __func__);
29         return RET_BAD_STATUS;
30     }
31 
32     securityInfo = {OUTGOING, HID_HOST, SEC_PROTOCOL_L2CAP,
33         { .l2capPsm = HID_CONTROL_PSM }};
34     if (GAPIF_RegisterServiceSecurity(nullptr, &securityInfo,
35         GAP_SEC_IN_ENCRYPTION | GAP_SEC_IN_AUTHENTICATION |
36         GAP_SEC_OUT_ENCRYPTION | GAP_SEC_OUT_AUTHENTICATION)) {
37             LOG_ERROR("[HIDH L2CAP] %{public}s:GAPIF_RegisterServiceSecurity OUTGOING failed.", __func__);
38         return RET_BAD_STATUS;
39     }
40 
41     /* regist hid control psm */
42     if (L2CIF_RegisterService(HID_CONTROL_PSM, (L2capService *)&L2CAP_HID_Host_CALLBACK, nullptr, nullptr)) {
43         LOG_ERROR("[HIDH L2CAP] %{public}s:L2CIF_RegisterService HID_CONTROL_PSM failed.", __func__);
44         return RET_BAD_STATUS;
45     }
46     /* regist hid interrupt psm */
47     if (L2CIF_RegisterService(HID_INTERRUPT_PSM, (L2capService *)&L2CAP_HID_Host_CALLBACK, nullptr, nullptr)) {
48         L2CIF_DeregisterService(HID_CONTROL_PSM, nullptr);
49         LOG_ERROR("[HIDH L2CAP] %{public}s:L2CIF_RegisterService HID_INTERRUPT_PSM failed.", __func__);
50         return RET_BAD_STATUS;
51     }
52     return BT_SUCCESS;
53 }
54 
Shutdown()55 void HidHostL2capConnection::Shutdown()
56 {
57     L2CIF_DeregisterService(HID_CONTROL_PSM, nullptr);
58     L2CIF_DeregisterService(HID_INTERRUPT_PSM, nullptr);
59     GapServiceSecurityInfo securityInfo = {INCOMING, HID_HOST, SEC_PROTOCOL_L2CAP,
60         { .l2capPsm = HID_CONTROL_PSM }};
61     GAPIF_DeregisterServiceSecurity(nullptr, &securityInfo);
62     securityInfo = {OUTGOING, HID_HOST, SEC_PROTOCOL_L2CAP,
63         { .l2capPsm = HID_CONTROL_PSM }};
64     GAPIF_DeregisterServiceSecurity(nullptr, &securityInfo);
65 }
66 
HidHostL2capConnection(std::string address)67 HidHostL2capConnection::HidHostL2capConnection(std::string address)
68 {
69     address_ = address;
70     state_ = HID_HOST_CONN_STATE_UNUSED;
71     ctrlLcid_ = 0;
72     intrLcid_ = 0;
73     connFlags_ = 0;
74     ctrlId_ = 0;
75 }
76 
Connect()77 int HidHostL2capConnection::Connect()
78 {
79     LOG_INFO("[HIDH L2CAP]%{public}s", __func__);
80     BtAddr btAddr;
81     RawAddress(address_).ConvertToUint8(btAddr.addr);
82     btAddr.type = BT_PUBLIC_DEVICE_ADDRESS;
83 
84     if (state_ == HID_HOST_CONN_STATE_CONNECTED) {
85         HidHostMessage event(HID_HOST_INT_OPEN_EVT);
86         event.dev_ = address_;
87         HidHostService::GetService()->PostEvent(event);
88         return BT_SUCCESS;
89     }
90 
91     if (state_ != HID_HOST_CONN_STATE_UNUSED) {
92         LOG_ERROR("[HIDH L2CAP] %{public}s:state error state = %{public}d", __func__, state_);
93         return RET_BAD_STATUS;
94     }
95 
96     return SendGapRequestSecurity(false, 0, 0);
97 }
98 
99 /**
100  *
101  * @brief         HidHostSecurityCheckCallback
102  *
103  * @details       Host receive the security check result
104  *
105  * @return        uint16_t
106  *
107  */
HidHostSecurityCheckCallback(uint16_t result,GapServiceSecurityInfo security,void * context)108 void HidHostL2capConnection::HidHostSecurityCheckCallback(
109     uint16_t result, GapServiceSecurityInfo security, void *context)
110 {
111     LOG_INFO("[HIDH L2CAP]%{public}s:result(%{public}hu), l2capPsm(0x%{public}x)",
112         __func__, result, security.channelId.l2capPsm);
113     std::string *address = (std::string *)context;
114     if (address != nullptr) {
115         HidHostMessage event(HID_HOST_L2CAP_SECURITY_RESULT_EVT, result);
116         event.dev_ = *address;
117         HidHostService::GetService()->PostEvent(event);
118     } else {
119         LOG_ERROR("[HIDH L2CAP]%{public}s HidHostL2capConnection is null.", __func__);
120     }
121 }
122 
HidHostSecurityCheckTask(uint16_t result)123 void HidHostL2capConnection::HidHostSecurityCheckTask(uint16_t result)
124 {
125     BtAddr btAddr;
126     RawAddress(address_).ConvertToUint8(btAddr.addr);
127     btAddr.type = BT_PUBLIC_DEVICE_ADDRESS;
128 
129     connFlags_ = HID_HOST_CONN_FLAGS_IS_ORIG;
130 
131     if (result == BT_SUCCESS) {
132         LOG_INFO("[HIDH L2CAP]%{public}s start connect HID control", __func__);
133         int ret = L2CIF_ConnectReq(&btAddr, HID_CONTROL_PSM, HID_CONTROL_PSM,
134             this, HidHostL2cConnectControlReqCallback);
135         if (ret != BT_SUCCESS) {
136             LOG_ERROR("[HIDH L2CAP]%{public}s L2CIF_ConnectReq return value is error.", __func__);
137             state_ = HID_HOST_CONN_STATE_UNUSED;
138 
139             HidHostMessage event(HID_HOST_INT_CLOSE_EVT);
140             event.dev_ = address_;
141             HidHostService::GetService()->PostEvent(event);
142             return;
143         }
144         state_ = HID_HOST_CONN_STATE_CONNECTING_CTRL;
145     } else {
146         LOG_ERROR("[HIDH L2CAP]%{public}s Request Security faild!", __func__);
147         state_ = HID_HOST_CONN_STATE_UNUSED;
148 
149         HidHostMessage event(HID_HOST_INT_CLOSE_EVT);
150         event.dev_ = address_;
151         HidHostService::GetService()->PostEvent(event);
152     }
153 }
154 
155 /**
156  *
157  * @brief         HidHostIndSecurityCheckCallback
158  *
159  * @details       Host receive the security check result，when receive device's connect request.
160  *
161  * @return        uint16_t
162  *
163  */
HidHostIndSecurityCheckDeviceConnectCallback(uint16_t result,GapServiceSecurityInfo security,void * context)164 void HidHostL2capConnection::HidHostIndSecurityCheckDeviceConnectCallback(uint16_t result,
165     GapServiceSecurityInfo security, void *context)
166 {
167     LOG_INFO("[HIDH L2CAP]%{public}s:result(%{public}hu), l2capPsm(0x%{public}x)",
168         __func__, result, security.channelId.l2capPsm);
169     std::string *address = (std::string *)context;
170     if (address != nullptr) {
171         HidHostMessage event(HID_HOST_L2CAP_IND_SECURITY_RESULT_EVT, result);
172         event.dev_ = *address;
173         HidHostService::GetService()->PostEvent(event);
174     } else {
175         LOG_ERROR("[HIDH L2CAP]%{public}s HidHostL2capConnection is null.", __func__);
176     }
177 }
178 
HidHostSecurityCheckDeviceConnectTask(uint16_t result)179 void HidHostL2capConnection::HidHostSecurityCheckDeviceConnectTask(uint16_t result)
180 {
181     BtAddr btAddr;
182     RawAddress(address_).ConvertToUint8(btAddr.addr);
183     btAddr.type = BT_PUBLIC_DEVICE_ADDRESS;
184 
185     if ((result == BT_SUCCESS) && (state_ == HID_HOST_CONN_STATE_SECURITY)) {
186         LOG_INFO("[HIDH L2CAP]%{public}s start send connect response", __func__);
187         state_ = HID_HOST_CONN_STATE_CONNECTING_INTR;
188         L2CIF_ConnectRsp(ctrlLcid_, ctrlId_, L2CAP_CONNECTION_SUCCESSFUL, 0, nullptr);
189 
190         L2capConfigInfo l2capConfigInfo;
191         (void)memset_s(&l2capConfigInfo, sizeof(L2capConfigInfo), 0x00, sizeof(L2capConfigInfo));
192         l2capConfigInfo.mtu = HID_HOST_MTU;
193         l2capConfigInfo.flushTimeout = 0xFFFF;
194         if (L2CIF_ConfigReq(ctrlLcid_, &l2capConfigInfo, nullptr)) {
195             LOG_ERROR("[HIDH L2CAP] %{public}s:L2CIF_ConfigReq failed.", __func__);
196         }
197     } else if (result != BT_SUCCESS) {
198         LOG_ERROR("[HIDH L2CAP]%{public}s Request Security faild!", __func__);
199         state_ = HID_HOST_CONN_STATE_UNUSED;
200 
201         HidHostMessage event(HID_HOST_INT_CLOSE_EVT);
202         event.dev_ = address_;
203         HidHostService::GetService()->PostEvent(event);
204     }
205 }
206 
Disconnect()207 int HidHostL2capConnection::Disconnect()
208 {
209     LOG_INFO("[HID L2CAP]%{public}s", __func__);
210 
211     if (state_ == HID_HOST_CONN_STATE_UNUSED) {
212         HidHostMessage event(HID_HOST_INT_CLOSE_EVT);
213         event.dev_ = address_;
214         HidHostService::GetService()->PostEvent(event);
215         return BT_SUCCESS;
216     }
217 
218     if ((ctrlLcid_ != 0) || (intrLcid_ != 0)) {
219         state_ = HID_HOST_CONN_STATE_DISCONNECTING;
220         if (intrLcid_) {
221             L2CIF_DisconnectionReq(intrLcid_, nullptr);
222         } else if (ctrlLcid_) {
223             L2CIF_DisconnectionReq(ctrlLcid_, nullptr);
224         }
225     } else {
226         state_ = HID_HOST_CONN_STATE_UNUSED;
227         HidHostMessage event(HID_HOST_INT_CLOSE_EVT);
228         event.dev_ = address_;
229         HidHostService::GetService()->PostEvent(event);
230         return BT_SUCCESS;
231     }
232 
233     return BT_SUCCESS;
234 }
235 
SendData(SendHidData sendData,int length,uint8_t * pkt)236 int HidHostL2capConnection::SendData(SendHidData sendData, int length, uint8_t* pkt)
237 {
238     switch (sendData.type) {
239         case HID_HOST_DATA_TYPE_GET_REPORT:
240         case HID_HOST_DATA_TYPE_CONTROL:
241         case HID_HOST_DATA_TYPE_DATA:
242             SendGetReport(sendData);
243             break;
244         case HID_HOST_DATA_TYPE_SET_REPORT:
245             SendSetReport(sendData, length, pkt);
246             break;
247         default:
248             return RET_BAD_PARAM;
249     }
250 
251     return BT_SUCCESS;
252 }
253 
SendGetReport(SendHidData sendData)254 void HidHostL2capConnection::SendGetReport(SendHidData sendData)
255 {
256     Packet *packet = nullptr;
257     uint8_t *buf = nullptr;
258     uint16_t lcid = 0;
259     uint8_t offset = 0;
260     uint8_t packetLength = sizeof(uint8_t);
261     if (sendData.reportId != 0) {
262         packetLength += sizeof(uint8_t);
263     }
264     // If have max buff size,add the buff size to last
265     if (sendData.data > 0) {
266         packetLength += sizeof(uint16_t);
267     }
268     packet = PacketMalloc(packetLength, 0, 0);
269     buf = (uint8_t *)BufferPtr(PacketHead(packet));
270     if (sendData.data > 0) {
271         buf[offset] = static_cast<uint8_t>(sendData.type << HID_HOST_SHIFT_OPRATURN_4) |
272             ((sendData.param | 0x08) & 0x0f);
273         offset++;
274         if (sendData.reportId != 0) {
275             buf[offset] = sendData.reportId;
276             offset++;
277         }
278         buf[offset] = sendData.data & 0xff;
279         offset++;
280         buf[offset] = (sendData.data >> HID_HOST_SHIFT_OPRATURN_8) & 0xff;
281     } else {
282         buf[offset] = (sendData.type << HID_HOST_SHIFT_OPRATURN_4) | (sendData.param & 0x0f);
283         offset++;
284         if (sendData.reportId != 0) {
285             buf[offset] = sendData.reportId;
286         }
287     }
288     if (sendData.type == HID_HOST_DATA_TYPE_DATA) {
289         lcid = intrLcid_;
290     } else {
291         lcid = ctrlLcid_;
292     }
293     L2CIF_SendData(lcid, packet, nullptr);
294     PacketFree(packet);
295     packet = nullptr;
296 }
297 
SendSetReport(SendHidData sendData,int length,uint8_t * pkt)298 void HidHostL2capConnection::SendSetReport(SendHidData sendData, int length, uint8_t* pkt)
299 {
300     if ((pkt == nullptr) || (length <= 0)) {
301         LOG_ERROR("[HIDH L2CAP] %{public}s:data is null.", __func__);
302         HidHostMessage event(HID_HOST_INT_HANDSK_EVT, HID_HOST_HANDSHAKE_ERROR);
303         event.dev_ = address_;
304         HidHostService::GetService()->PostEvent(event);
305         return;
306     }
307 
308     Packet *packet = nullptr;
309     uint8_t *buf = nullptr;
310     uint16_t lcid = 0;
311 
312     packet = PacketMalloc(length + HID_HOST_PDU_HEADER_LENGTH, 0, 0);
313     buf = (uint8_t *)BufferPtr(PacketHead(packet));
314     buf[0] = static_cast<uint8_t>(sendData.type << HID_HOST_SHIFT_OPRATURN_4) | (sendData.param & 0x0f);
315     if (memcpy_s(buf + 1, length, pkt, length) != EOK) {
316         LOG_ERROR("[HIDH L2CAP] %{public}s:memcpy error.", __func__);
317         return;
318     }
319     lcid = ctrlLcid_;
320 
321     L2CIF_SendData(lcid, packet, nullptr);
322     PacketFree(packet);
323     packet = nullptr;
324 }
325 
GetControlLcid()326 uint16_t HidHostL2capConnection::GetControlLcid()
327 {
328     return ctrlLcid_;
329 }
330 
GetInterruptLcid()331 uint16_t HidHostL2capConnection::GetInterruptLcid()
332 {
333     return intrLcid_;
334 }
335 
HidHostL2cConnectControlReqCallback(const BtAddr * addr,uint16_t lcid,int result,void * context)336 void HidHostL2capConnection::HidHostL2cConnectControlReqCallback(
337     const BtAddr *addr, uint16_t lcid, int result, void *context)
338 {
339     LOG_INFO("[HIDH L2CAP]%{public}s lcid:%{public}hu", __func__, lcid);
340     std::string address = RawAddress::ConvertToString(addr->addr).GetAddress();
341     HidHostL2capConnection* l2capConnect = (HidHostL2capConnection *)context;
342     if ((l2capConnect != nullptr) && (result == BT_SUCCESS)) {
343         l2capConnect->ctrlLcid_ = lcid;
344     } else {
345         LOG_ERROR("[HIDH L2CAP]%{public}s HidHostService is null!", __func__);
346     }
347 }
348 
HidHostL2cConnectInterruptReqCallback(const BtAddr * addr,uint16_t lcid,int result,void * context)349 void HidHostL2capConnection::HidHostL2cConnectInterruptReqCallback
350     (const BtAddr *addr, uint16_t lcid, int result, void *context)
351 {
352     LOG_INFO("[HIDH L2CAP]%{public}s lcid:%{public}hu", __func__, lcid);
353 
354     std::string address = RawAddress::ConvertToString(addr->addr).GetAddress();
355     HidHostL2capConnection* l2capConnect = (HidHostL2capConnection *)context;
356     if ((l2capConnect != nullptr) && (result == BT_SUCCESS)) {
357         l2capConnect->intrLcid_ = lcid;
358     } else {
359         LOG_ERROR("[HIDH L2CAP]%{public}s HidHostService is null!", __func__);
360     }
361 }
362 
HidHostRecvConnectionReqCallback(uint16_t lcid,uint8_t id,const L2capConnectionInfo * info,uint16_t lpsm,void * ctx)363 void HidHostL2capConnection::HidHostRecvConnectionReqCallback(
364     uint16_t lcid, uint8_t id, const L2capConnectionInfo *info, uint16_t lpsm, void *ctx)
365 {
366     LOG_INFO("[HIDH L2CAP]%{public}s lcid:%{public}hu", __func__, lcid);
367 
368     if (info == nullptr) {
369         LOG_ERROR("[HIDH L2CAP]%{public}s L2capConnectionInfo is null!", __func__);
370         return;
371     }
372     std::string address = RawAddress::ConvertToString(info->addr.addr).GetAddress();
373     HidHostMessage event(HID_HOST_L2CAP_CONNECT_REQ_EVT);
374     HidHostL2capConnectionInfo l2capInfo;
375     (void)memset_s(&l2capInfo, sizeof(HidHostL2capConnectionInfo),
376         0x00, sizeof(HidHostL2capConnectionInfo));
377     l2capInfo.lcid = lcid;
378     l2capInfo.id = id;
379     l2capInfo.lpsm = lpsm;
380     event.dev_ = address;
381     event.l2capInfo_ = l2capInfo;
382     HidHostService::GetService()->PostEvent(event);
383 }
384 
HidHostRecvConnectionRspCallback(uint16_t lcid,const L2capConnectionInfo * info,uint16_t result,uint16_t status,void * ctx)385 void HidHostL2capConnection::HidHostRecvConnectionRspCallback(
386     uint16_t lcid, const L2capConnectionInfo *info, uint16_t result, uint16_t status, void *ctx)
387 {
388     LOG_INFO("[HIDH L2CAP]%{public}s lcid:%{public}hu", __func__, lcid);
389 
390     if (info == nullptr) {
391         LOG_ERROR("[HIDH L2CAP]%{public}s L2capConnectionInfo is null!", __func__);
392         return;
393     }
394     std::string address = RawAddress::ConvertToString(info->addr.addr).GetAddress();
395     HidHostMessage event(HID_HOST_L2CAP_CONNECT_RSP_EVT);
396     HidHostL2capConnectionInfo l2capInfo;
397     (void)memset_s(&l2capInfo, sizeof(HidHostL2capConnectionInfo),
398         0x00, sizeof(HidHostL2capConnectionInfo));
399     l2capInfo.lcid = lcid;
400     l2capInfo.result = result;
401     event.dev_ = address;
402     event.l2capInfo_ = l2capInfo;
403     HidHostService::GetService()->PostEvent(event);
404 }
405 
HidHostRecvConfigReqCallback(uint16_t lcid,uint8_t id,const L2capConfigInfo * cfg,void * ctx)406 void HidHostL2capConnection::HidHostRecvConfigReqCallback(
407     uint16_t lcid, uint8_t id, const L2capConfigInfo *cfg, void *ctx)
408 {
409     LOG_INFO("[HIDH L2CAP]%{public}s lcid:%{public}hu", __func__, lcid);
410 
411     HidHostService *service = HidHostService::GetService();
412     if (service == nullptr) {
413         LOG_ERROR("[HIDH L2CAP]%{public}s HidHostService is null!", __func__);
414         return;
415     }
416     bool isControlLcid = false;
417     std::string address = service->HidHostFindDeviceByLcid(lcid, &isControlLcid);
418     if (address.empty()) {
419         LOG_ERROR("[HIDH L2CAP]%{public}s can not find device!", __func__);
420         L2CIF_ConfigRsp(lcid, id, cfg, L2CAP_REJECTED, nullptr);
421         return;
422     }
423 
424     HidHostMessage event(HID_HOST_L2CAP_CONFIG_REQ_EVT);
425     HidHostL2capConnectionInfo l2capInfo;
426     (void)memset_s(&l2capInfo, sizeof(HidHostL2capConnectionInfo),
427         0x00, sizeof(HidHostL2capConnectionInfo));
428     L2capConfigInfo l2capConfigInfo;
429     memcpy_s(&l2capConfigInfo, sizeof(L2capConfigInfo), cfg, sizeof(L2capConfigInfo));
430 
431     l2capInfo.lcid = lcid;
432     l2capInfo.id = id;
433     l2capInfo.cfg = l2capConfigInfo;
434     event.dev_ = address;
435     event.l2capInfo_ = l2capInfo;
436     service->PostEvent(event);
437 }
438 
HidHostRecvConfigRspCallback(uint16_t lcid,const L2capConfigInfo * cfg,uint16_t result,void * ctx)439 void HidHostL2capConnection::HidHostRecvConfigRspCallback(
440     uint16_t lcid, const L2capConfigInfo *cfg, uint16_t result, void *ctx)
441 {
442     LOG_INFO("[HIDH L2CAP]%{public}s lcid:%{public}hu", __func__, lcid);
443 
444     HidHostService *service = HidHostService::GetService();
445     if (service == nullptr) {
446         LOG_ERROR("[HIDH L2CAP]%{public}s HidHostService is null!", __func__);
447         return;
448     }
449     bool isControlLcid = false;
450     std::string address = service->HidHostFindDeviceByLcid(lcid, &isControlLcid);
451     if (address.empty()) {
452         LOG_ERROR("[HIDH L2CAP]%{public}s can not find device!", __func__);
453         return;
454     }
455 
456     HidHostMessage event(HID_HOST_L2CAP_CONFIG_RSP_EVT);
457     HidHostL2capConnectionInfo l2capInfo;
458     (void)memset_s(&l2capInfo, sizeof(HidHostL2capConnectionInfo),
459         0x00, sizeof(HidHostL2capConnectionInfo));
460     L2capConfigInfo l2capConfigInfo;
461     memcpy_s(&l2capConfigInfo, sizeof(L2capConfigInfo), cfg, sizeof(L2capConfigInfo));
462 
463     l2capInfo.lcid = lcid;
464     l2capInfo.result = result;
465     l2capInfo.cfg = l2capConfigInfo;
466     event.dev_ = address;
467     event.l2capInfo_ = l2capInfo;
468     service->PostEvent(event);
469 }
470 
HidHostRecvDisconnectionReqCallback(uint16_t lcid,uint8_t id,void * ctx)471 void HidHostL2capConnection::HidHostRecvDisconnectionReqCallback(
472     uint16_t lcid, uint8_t id, void *ctx)
473 {
474     LOG_INFO("[HIDH L2CAP]%{public}s lcid:%{public}hu", __func__, lcid);
475 
476     HidHostService *service = HidHostService::GetService();
477     if (service == nullptr) {
478         LOG_ERROR("[HIDH L2CAP]%{public}s HidHostService is null!", __func__);
479         return;
480     }
481     bool isControlLcid = false;
482     std::string address = service->HidHostFindDeviceByLcid(lcid, &isControlLcid);
483     if (address.empty()) {
484         LOG_ERROR("[HIDH L2CAP]%{public}s can not find device!", __func__);
485         return;
486     }
487 
488     HidHostMessage event(HID_HOST_L2CAP_DISCONNECT_REQ_EVT);
489     HidHostL2capConnectionInfo l2capInfo;
490     (void)memset_s(&l2capInfo, sizeof(HidHostL2capConnectionInfo),
491         0x00, sizeof(HidHostL2capConnectionInfo));
492 
493     l2capInfo.lcid = lcid;
494     l2capInfo.id = id;
495     event.dev_ = address;
496     event.l2capInfo_ = l2capInfo;
497     service->PostEvent(event);
498 }
499 
HidHostRecvDisconnectionRspCallback(uint16_t lcid,void * ctx)500 void HidHostL2capConnection::HidHostRecvDisconnectionRspCallback(
501     uint16_t lcid, void *ctx)
502 {
503     LOG_INFO("[HIDH L2CAP]%{public}s lcid:%{public}hu", __func__, lcid);
504 
505     HidHostService *service = HidHostService::GetService();
506     if (service == nullptr) {
507         LOG_ERROR("[HIDH L2CAP]%{public}s HidHostService is null!", __func__);
508         return;
509     }
510     bool isControlLcid = false;
511     std::string address = service->HidHostFindDeviceByLcid(lcid, &isControlLcid);
512     if (address.empty()) {
513         LOG_ERROR("[HIDH L2CAP]%{public}s can not find device!", __func__);
514         return;
515     }
516 
517     HidHostMessage event(HID_HOST_L2CAP_DISCONNECT_RSP_EVT);
518     HidHostL2capConnectionInfo l2capInfo;
519     (void)memset_s(&l2capInfo, sizeof(HidHostL2capConnectionInfo),
520         0x00, sizeof(HidHostL2capConnectionInfo));
521 
522     l2capInfo.lcid = lcid;
523     event.dev_ = address;
524     event.l2capInfo_ = l2capInfo;
525     service->PostEvent(event);
526 }
527 
HidHostDisconnectAbnormalCallback(uint16_t lcid,uint8_t reason,void * ctx)528 void HidHostL2capConnection::HidHostDisconnectAbnormalCallback(
529     uint16_t lcid, uint8_t reason, void *ctx)
530 {
531     LOG_INFO("[HIDH L2CAP]%{public}s lcid:%{public}hu", __func__, lcid);
532 
533     HidHostService *service = HidHostService::GetService();
534     if (service == nullptr) {
535         LOG_ERROR("[HIDH L2CAP]%{public}s HidHostService is null!", __func__);
536         return;
537     }
538     bool isControlLcid = false;
539     std::string address = service->HidHostFindDeviceByLcid(lcid, &isControlLcid);
540     if (address.empty()) {
541         LOG_ERROR("[HIDH L2CAP]%{public}s can not find device!", __func__);
542         return;
543     }
544 
545     HidHostMessage event(HID_HOST_L2CAP_DISCONNECT_ABNORMAL_EVT);
546     HidHostL2capConnectionInfo l2capInfo;
547     (void)memset_s(&l2capInfo, sizeof(HidHostL2capConnectionInfo),
548         0x00, sizeof(HidHostL2capConnectionInfo));
549 
550     l2capInfo.lcid = lcid;
551     l2capInfo.reason = reason;
552     event.dev_ = address;
553     event.l2capInfo_ = l2capInfo;
554     service->PostEvent(event);
555 }
556 
HidHostRecvDataCallback(uint16_t lcid,Packet * pkt,void * ctx)557 void HidHostL2capConnection::HidHostRecvDataCallback(
558     uint16_t lcid, Packet *pkt, void *ctx)
559 {
560     bool isControlLcid = false;
561     std::string address = HidHostService::GetService()->HidHostFindDeviceByLcid(lcid, &isControlLcid);
562     if (address.empty()) {
563         LOG_ERROR("[HIDH L2CAP]%{public}s can not find device!", __func__);
564         return;
565     }
566 
567     uint8_t header[HID_HOST_PDU_HEADER_LENGTH] = {0};
568     int dataLength;
569     uint16_t offset = 0;
570     HidHostMessage event;
571 
572     PacketExtractHead(pkt, header, sizeof(header));
573     uint8_t type = HidHostGetType(header[offset]);
574     uint8_t param = HidHostGetParam(header[offset]);
575 
576     switch (type) {
577         case HID_HOST_DATA_TYPE_HANDSHAKE:
578             LOG_INFO("[HIDH L2CAP]%{public}s HANDSHAKE lcid:%{public}hu", __func__, lcid);
579             event.what_ = HID_HOST_INT_HANDSK_EVT;
580             event.arg1_ = param;
581             event.dev_ = address;
582             HidHostService::GetService()->PostEvent(event);
583             break;
584 
585         case HID_HOST_DATA_TYPE_CONTROL:
586             LOG_INFO("[HIDH L2CAP]%{public}s CONTROL lcid:%{public}hu", __func__, lcid);
587             break;
588 
589         case HID_HOST_DATA_TYPE_DATA:
590         case HID_HOST_DATA_TYPE_DATAC:
591             if (!isControlLcid) {
592                 event.what_ = HID_HOST_INT_DATA_EVT;
593             } else {
594                 LOG_INFO("[HIDH L2CAP]%{public}s CTRL_DATA lcid:%{public}hu", __func__, lcid);
595                 event.what_ = HID_HOST_INT_CTRL_DATA;
596             }
597             event.dev_ = address;
598             dataLength = static_cast<int>(PacketSize(pkt));
599             if (dataLength > 0) {
600                 event.data_ = std::make_unique<uint8_t[]>(dataLength);
601                 PacketRead(pkt, event.data_.get(), 0, dataLength);
602             }
603             event.dataLength_ = dataLength;
604             HidHostService::GetService()->PostEvent(event);
605             break;
606         default:
607             LOG_INFO("[HIDH L2CAP]%{public}s other data lcid:%{public}hu", __func__, lcid);
608             break;
609     }
610 }
611 
HidHostRemoteBusyCallback(uint16_t lcid,uint8_t isBusy,void * ctx)612 void HidHostL2capConnection::HidHostRemoteBusyCallback(
613     uint16_t lcid, uint8_t isBusy, void *ctx)
614 {
615     LOG_INFO("[HIDH L2CAP]%{public}s lcid:%{public}hu", __func__, lcid);
616 
617     HidHostService *service = HidHostService::GetService();
618     if (service == nullptr) {
619         LOG_ERROR("[HIDH L2CAP]%{public}s HidHostService is null!", __func__);
620         return;
621     }
622     bool isControlLcid = false;
623     std::string address = service->HidHostFindDeviceByLcid(lcid, &isControlLcid);
624     if (address.empty()) {
625         LOG_ERROR("[HIDH L2CAP]%{public}s can not find device!", __func__);
626         return;
627     }
628 
629     HidHostMessage event(HID_HOST_L2CAP_REMOTE_BUSY_EVT);
630     HidHostL2capConnectionInfo l2capInfo;
631     (void)memset_s(&l2capInfo, sizeof(HidHostL2capConnectionInfo),
632         0x00, sizeof(HidHostL2capConnectionInfo));
633 
634     l2capInfo.lcid = lcid;
635     l2capInfo.isBusy = isBusy;
636     event.dev_ = address;
637     event.l2capInfo_ = l2capInfo;
638     service->PostEvent(event);
639 }
640 
HidHostRecvConnectionReqCallbackTask(uint16_t lcid,uint8_t id,uint16_t lpsm)641 void HidHostL2capConnection::HidHostRecvConnectionReqCallbackTask(
642     uint16_t lcid, uint8_t id, uint16_t lpsm)
643 {
644     LOG_INFO("[HIDH L2CAP]%{public}s lcid:%{public}hu", __func__, lcid);
645 
646     bool isAccept = true;
647     if (lpsm == HID_INTERRUPT_PSM) {
648         if (ctrlLcid_ == 0) {
649             LOG_ERROR("[HIDH L2CAP]%{public}s receive interrupt connect,but control is not connected", __func__);
650             isAccept = false;
651         }
652         if (state_ != HID_HOST_CONN_STATE_CONNECTING_INTR) {
653             LOG_ERROR("[HIDH L2CAP]%{public}s receive interrupt connect,but not in connecting state[%{public}d",
654                 __func__, state_);
655             isAccept = false;
656         }
657     } else {
658         // Control channel connect
659         if (state_ != HID_HOST_CONN_STATE_UNUSED) {
660             LOG_ERROR("[HIDH L2CAP]%{public}s receive control connect,but not in idle state[%{public}d]",
661                 __func__, state_);
662             isAccept = false;
663         }
664     }
665     if (!isAccept) {
666         L2CIF_ConnectRsp(lcid, id, L2CAP_NO_RESOURCES_AVAILABLE, 0, nullptr);
667         return;
668     }
669 
670     if (lpsm == HID_INTERRUPT_PSM) {
671         state_ = HID_HOST_CONN_STATE_CONFIG;
672         intrLcid_ = lcid;
673         L2CIF_ConnectRsp(lcid, id, L2CAP_CONNECTION_SUCCESSFUL, 0, nullptr);
674 
675         L2capConfigInfo l2capConfigInfo;
676         (void)memset_s(&l2capConfigInfo, sizeof(L2capConfigInfo), 0x00, sizeof(L2capConfigInfo));
677         l2capConfigInfo.mtu = HID_HOST_MTU;
678         l2capConfigInfo.flushTimeout = 0xFFFF;
679         if (L2CIF_ConfigReq(lcid, &l2capConfigInfo, nullptr)) {
680             LOG_ERROR("[HIDH L2CAP] %{public}s:L2CIF_ConfigReq failed.", __func__);
681         }
682     } else {
683         // Control channel connect
684         connFlags_ = 0;
685 
686         SendGapRequestSecurity(true, lcid, id);
687     }
688 }
689 
SendGapRequestSecurity(bool isIncoming,uint16_t lcid,uint8_t id)690 int HidHostL2capConnection::SendGapRequestSecurity(bool isIncoming, uint16_t lcid, uint8_t id)
691 {
692     BtAddr btAddr;
693     RawAddress(address_).ConvertToUint8(btAddr.addr);
694     btAddr.type = BT_PUBLIC_DEVICE_ADDRESS;
695 
696     GapRequestSecurityParam param;
697     GapServiceSecurityInfo securityInfo;
698     param.context = &address_;
699     if (isIncoming) {
700         securityInfo = {INCOMING, HID_HOST, SEC_PROTOCOL_L2CAP,
701                 { .l2capPsm = HID_CONTROL_PSM }};
702         param.callback = HidHostIndSecurityCheckDeviceConnectCallback;
703         param.info = securityInfo;
704         if (GAPIF_RequestSecurityAsync((const BtAddr *)&btAddr, &param)) {
705             LOG_ERROR("[HIDH L2CAP] %{public}s:GAPIF_RequestSecurityAsync INCOMING failed.", __func__);
706             return RET_BAD_STATUS;
707         }
708         ctrlLcid_ = lcid;
709         ctrlId_ = id;
710         state_ = HID_HOST_CONN_STATE_SECURITY;
711     } else {
712         securityInfo = {OUTGOING, HID_HOST, SEC_PROTOCOL_L2CAP,
713             { .l2capPsm = HID_CONTROL_PSM }};
714         param.callback = HidHostSecurityCheckCallback;
715         param.info = securityInfo;
716         if (GAPIF_RequestSecurityAsync((const BtAddr *)&btAddr, &param)) {
717             LOG_ERROR("[HIDH L2CAP] %{public}s:GAPIF_RequestSecurityAsync OUTGOING failed.", __func__);
718             HidHostMessage event(HID_HOST_INT_CLOSE_EVT);
719             event.dev_ = address_;
720             HidHostService::GetService()->PostEvent(event);
721             return RET_BAD_STATUS;
722         }
723     }
724     return BT_SUCCESS;
725 }
726 
HidHostRecvConnectionRspCallbackTask(uint16_t lcid,int result)727 void HidHostL2capConnection::HidHostRecvConnectionRspCallbackTask(
728     uint16_t lcid, int result)
729 {
730     LOG_INFO("[HIDH L2CAP]%{public}s lcid:%{public}hu", __func__, lcid);
731 
732     if (result == L2CAP_CONNECTION_PENDING) {
733         LOG_INFO("[HIDH L2CAP]%{public}s: Connect RSP result is pending, do nothing!", __func__);
734         return;
735     }
736     if (result != BT_SUCCESS) {
737         LOG_ERROR("[HIDH L2CAP]%{public}s result[%{public}d]", __func__, result);
738         if (lcid == ctrlLcid_) {
739             ctrlLcid_ = 0;
740         } else {
741             intrLcid_ = 0;
742         }
743 
744         Disconnect();
745         return;
746     }
747 
748     state_ = HID_HOST_CONN_STATE_CONFIG;
749 
750     L2capConfigInfo l2capConfigInfo;
751     (void)memset_s(&l2capConfigInfo, sizeof(L2capConfigInfo), 0x00, sizeof(L2capConfigInfo));
752     l2capConfigInfo.mtu = HID_HOST_MTU;
753     l2capConfigInfo.flushTimeout = 0xFFFF;
754     if (L2CIF_ConfigReq(lcid, &l2capConfigInfo, nullptr)) {
755         LOG_ERROR("[HIDH L2CAP] %{public}s:L2CIF_ConfigReq failed.", __func__);
756     }
757 }
758 
HidHostRecvConfigReqCallbackTask(uint16_t lcid,uint8_t id,L2capConfigInfo cfg)759 void HidHostL2capConnection::HidHostRecvConfigReqCallbackTask(
760     uint16_t lcid, uint8_t id, L2capConfigInfo cfg)
761 {
762     LOG_INFO("[HIDH L2CAP]%{public}s lcid:%{public}hu", __func__, lcid);
763 
764     BtAddr btAddr;
765     RawAddress(address_).ConvertToUint8(btAddr.addr);
766     btAddr.type = BT_PUBLIC_DEVICE_ADDRESS;
767 
768     if (cfg.rfc.mode == L2CAP_ENHANCED_RETRANSMISSION_MODE) {
769         LOG_INFO("[HIDH L2CAP]%{public}s for PTS HCT/BI-01-C", __func__);
770         L2capConfigInfo l2capConfigInfo;
771         (void)memset_s(&l2capConfigInfo, sizeof(L2capConfigInfo), 0x00, sizeof(L2capConfigInfo));
772         l2capConfigInfo.mtu = HID_HOST_MTU;
773         l2capConfigInfo.flushTimeout = 0xFFFF;
774         L2CIF_ConfigRsp(lcid, id, &l2capConfigInfo, L2CAP_UNACCEPTABLE_PARAMETERS, nullptr);
775         return;
776     }
777 
778     if (L2CIF_ConfigRsp(lcid, id, &cfg, 0, nullptr)) {
779         LOG_ERROR("[HIDH L2CAP] %{public}s:L2CIF_ConfigRsp failed.", __func__);
780     }
781     if (lcid == ctrlLcid_) {
782         connFlags_ |= HID_HOST_CONN_FLAGS_HIS_CTRL_CFG_DONE;
783         if ((connFlags_ & HID_HOST_CONN_FLAGS_MY_CTRL_CFG_DONE) &&
784             (connFlags_ & HID_HOST_CONN_FLAGS_IS_ORIG)) {
785             int ret = L2CIF_ConnectReq(&btAddr, HID_INTERRUPT_PSM, HID_INTERRUPT_PSM,
786                 this, HidHostL2cConnectInterruptReqCallback);
787             if (ret != BT_SUCCESS) {
788                 LOG_ERROR("%{public}s L2CIF_ConnectReq return value is error.", __func__);
789                 return;
790             }
791             state_ = HID_HOST_CONN_STATE_CONNECTING_INTR;
792         }
793     } else {
794         connFlags_ |= HID_HOST_CONN_FLAGS_HIS_INTR_CFG_DONE;
795         if ((connFlags_ & HID_HOST_CONN_FLAGS_ALL_CONFIGURED) ==
796                 HID_HOST_CONN_FLAGS_ALL_CONFIGURED) {
797             state_ = HID_HOST_CONN_STATE_CONNECTED;
798             HidHostMessage event(HID_HOST_INT_OPEN_EVT);
799             event.dev_ = address_;
800             HidHostService::GetService()->PostEvent(event);
801         }
802     }
803 }
804 
HidHostRecvConfigRspCallbackTask(uint16_t lcid,const L2capConfigInfo cfg,uint16_t result)805 void HidHostL2capConnection::HidHostRecvConfigRspCallbackTask(
806     uint16_t lcid, const L2capConfigInfo cfg, uint16_t result)
807 {
808     LOG_INFO("[HIDH L2CAP]%{public}s lcid:%{public}hu", __func__, lcid);
809 
810     BtAddr btAddr;
811     RawAddress(address_).ConvertToUint8(btAddr.addr);
812     btAddr.type = BT_PUBLIC_DEVICE_ADDRESS;
813 
814     if (result != L2CAP_SUCCESS) {
815         LOG_ERROR("[HIDH L2CAP]%{public}s result[%{public}d]", __func__, result);
816         Disconnect();
817         return;
818     }
819     if (lcid == ctrlLcid_) {
820         connFlags_ |= HID_HOST_CONN_FLAGS_MY_CTRL_CFG_DONE;
821         if ((connFlags_ & HID_HOST_CONN_FLAGS_HIS_CTRL_CFG_DONE) &&
822             (connFlags_ & HID_HOST_CONN_FLAGS_IS_ORIG)) {
823             int ret = L2CIF_ConnectReq(&btAddr, HID_INTERRUPT_PSM, HID_INTERRUPT_PSM,
824                 this, HidHostL2cConnectInterruptReqCallback);
825             if (ret != BT_SUCCESS) {
826                 LOG_ERROR("[HIDH L2CAP]%{public}s L2CIF_ConnectReq return value is error.", __func__);
827                 return;
828             }
829             state_ = HID_HOST_CONN_STATE_CONNECTING_INTR;
830         }
831     } else {
832         connFlags_ |= HID_HOST_CONN_FLAGS_MY_INTR_CFG_DONE;
833         if ((connFlags_ & HID_HOST_CONN_FLAGS_ALL_CONFIGURED) ==
834                 HID_HOST_CONN_FLAGS_ALL_CONFIGURED) {
835             state_ = HID_HOST_CONN_STATE_CONNECTED;
836             HidHostMessage event(HID_HOST_INT_OPEN_EVT);
837             event.dev_ = address_;
838             HidHostService::GetService()->PostEvent(event);
839         }
840     }
841 }
842 
HidHostRecvDisconnectionReqCallbackTask(uint16_t lcid,uint8_t id)843 void HidHostL2capConnection::HidHostRecvDisconnectionReqCallbackTask(
844     uint16_t lcid, uint8_t id)
845 {
846     LOG_INFO("[HIDH L2CAP]%{public}s lcid:%{public}hu", __func__, lcid);
847 
848     L2CIF_DisconnectionRsp(lcid, id, nullptr);
849     state_ = HID_HOST_CONN_STATE_DISCONNECTING;
850 
851     if (lcid == ctrlLcid_) {
852         ctrlLcid_ = 0;
853     } else {
854         intrLcid_ = 0;
855     }
856 
857     if ((ctrlLcid_ == 0) && (intrLcid_ == 0)) {
858         state_ = HID_HOST_CONN_STATE_UNUSED;
859         HidHostMessage event(HID_HOST_INT_CLOSE_EVT);
860         event.dev_ = address_;
861         HidHostService::GetService()->PostEvent(event);
862     }
863 }
864 
HidHostRecvDisconnectionRspCallbackTask(uint16_t lcid)865 void HidHostL2capConnection::HidHostRecvDisconnectionRspCallbackTask(uint16_t lcid)
866 {
867     LOG_INFO("[HIDH L2CAP]%{public}s lcid:%{public}hu", __func__, lcid);
868 
869     if (lcid == ctrlLcid_) {
870         ctrlLcid_ = 0;
871     } else {
872         intrLcid_ = 0;
873         if (ctrlLcid_) {
874             L2CIF_DisconnectionReq(ctrlLcid_, nullptr);
875         }
876     }
877 
878     if ((ctrlLcid_ == 0) && (intrLcid_ == 0)) {
879         state_ = HID_HOST_CONN_STATE_UNUSED;
880         HidHostMessage event(HID_HOST_INT_CLOSE_EVT);
881         event.dev_ = address_;
882         HidHostService::GetService()->PostEvent(event);
883     }
884 }
885 
HidHostDisconnectAbnormalCallbackTask(uint16_t lcid,uint8_t reason)886 void HidHostL2capConnection::HidHostDisconnectAbnormalCallbackTask(
887     uint16_t lcid, uint8_t reason)
888 {
889     LOG_INFO("[HIDH L2CAP]%{public}s lcid:%{public}hu, reason=%{public}d", __func__, lcid, reason);
890 
891     if (lcid == ctrlLcid_) {
892         ctrlLcid_ = 0;
893     } else {
894         intrLcid_ = 0;
895     }
896 
897     if ((ctrlLcid_ == 0) && (intrLcid_ == 0)) {
898         state_ = HID_HOST_CONN_STATE_UNUSED;
899         HidHostMessage event(HID_HOST_INT_CLOSE_EVT);
900         event.dev_ = address_;
901         HidHostService::GetService()->PostEvent(event);
902     } else {
903         Disconnect();
904     }
905 }
906 
HidHostRemoteBusyCallbackTask(uint16_t lcid,uint8_t isBusy)907 void HidHostL2capConnection::HidHostRemoteBusyCallbackTask(
908     uint16_t lcid, uint8_t isBusy)
909 {
910     LOG_INFO("[HIDH L2CAP]%{public}s lcid:%{public}hu", __func__, lcid);
911 }
912 
HidHostGetType(uint8_t type)913 uint8_t HidHostL2capConnection::HidHostGetType(uint8_t type)
914 {
915     uint8_t result = 0;
916     result = ((type) >> HID_HOST_SHIFT_OPRATURN_4) & 0x0f;
917     return result;
918 }
919 
HidHostGetParam(uint8_t type)920 uint8_t HidHostL2capConnection::HidHostGetParam(uint8_t type)
921 {
922     uint8_t result = 0;
923     result = (type)&0x0f;
924     return result;
925 }
926 
927 
ProcessEvent(const HidHostMessage & event)928 void HidHostL2capConnection::ProcessEvent(
929     const HidHostMessage &event)
930 {
931     LOG_DEBUG("[HIDH L2CAP]%{public}s(): event %{public}s[%{public}d]",
932         __FUNCTION__, HidHostL2capConnection::GetEventName(event.what_).c_str(), event.what_);
933 
934     switch (event.what_) {
935         case HID_HOST_L2CAP_CONNECT_REQ_EVT:
936             HidHostRecvConnectionReqCallbackTask(event.l2capInfo_.lcid, event.l2capInfo_.id, event.l2capInfo_.lpsm);
937             break;
938         case HID_HOST_L2CAP_CONNECT_RSP_EVT:
939             HidHostRecvConnectionRspCallbackTask(
940                 event.l2capInfo_.lcid, event.l2capInfo_.result);
941             break;
942         case HID_HOST_L2CAP_CONFIG_REQ_EVT:
943             HidHostRecvConfigReqCallbackTask(event.l2capInfo_.lcid, event.l2capInfo_.id, event.l2capInfo_.cfg);
944             break;
945         case HID_HOST_L2CAP_CONFIG_RSP_EVT:
946             HidHostRecvConfigRspCallbackTask(event.l2capInfo_.lcid, event.l2capInfo_.cfg, event.l2capInfo_.result);
947             break;
948         case HID_HOST_L2CAP_DISCONNECT_REQ_EVT:
949             HidHostRecvDisconnectionReqCallbackTask(event.l2capInfo_.lcid, event.l2capInfo_.id);
950             break;
951         case HID_HOST_L2CAP_DISCONNECT_RSP_EVT:
952             HidHostRecvDisconnectionRspCallbackTask(event.l2capInfo_.lcid);
953             break;
954         case HID_HOST_L2CAP_DISCONNECT_ABNORMAL_EVT:
955             HidHostDisconnectAbnormalCallbackTask(event.l2capInfo_.lcid, event.l2capInfo_.reason);
956             break;
957         case HID_HOST_L2CAP_REMOTE_BUSY_EVT:
958             HidHostRemoteBusyCallbackTask(event.l2capInfo_.lcid, event.l2capInfo_.isBusy);
959             break;
960         case HID_HOST_L2CAP_SECURITY_RESULT_EVT:
961             HidHostSecurityCheckTask(event.arg1_);
962             break;
963         case HID_HOST_L2CAP_IND_SECURITY_RESULT_EVT:
964             HidHostSecurityCheckDeviceConnectTask(event.arg1_);
965             break;
966         default:
967             break;
968     }
969 }
970 
GetEventName(int what)971 std::string HidHostL2capConnection::GetEventName(int what)
972 {
973     switch (what) {
974         case HID_HOST_L2CAP_CONNECT_REQ_EVT:
975             return "HID_HOST_L2CAP_CONNECT_REQ_EVT";
976         case HID_HOST_L2CAP_CONNECT_RSP_EVT:
977             return "HID_HOST_L2CAP_CONNECT_RSP_EVT";
978         case HID_HOST_L2CAP_CONFIG_REQ_EVT:
979             return "HID_HOST_L2CAP_CONFIG_REQ_EVT";
980         case HID_HOST_L2CAP_CONFIG_RSP_EVT:
981             return "HID_HOST_L2CAP_CONFIG_RSP_EVT";
982         case HID_HOST_L2CAP_DISCONNECT_REQ_EVT:
983             return "HID_HOST_L2CAP_DISCONNECT_REQ_EVT";
984         case HID_HOST_L2CAP_DISCONNECT_RSP_EVT:
985             return "HID_HOST_L2CAP_DISCONNECT_RSP_EVT";
986         case HID_HOST_L2CAP_DISCONNECT_ABNORMAL_EVT:
987             return "HID_HOST_L2CAP_DISCONNECT_ABNORMAL_EVT";
988         case HID_HOST_L2CAP_REMOTE_BUSY_EVT:
989             return "HID_HOST_L2CAP_REMOTE_BUSY_EVT";
990         case HID_HOST_L2CAP_SECURITY_RESULT_EVT:
991             return "HID_HOST_L2CAP_SECURITY_RESULT_EVT";
992         case HID_HOST_L2CAP_IND_SECURITY_RESULT_EVT:
993             return "HID_HOST_L2CAP_IND_SECURITY_RESULT_EVT";
994         default:
995             return "Unknown";
996     }
997 }
998 }  // namespace bluetooth
999 }  // namespace OHOS