1 /*
2  * Copyright (C) 2021-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 "transport_l2cap.h"
17 #include "log.h"
18 #include "log_util.h"
19 #include "securec.h"
20 
21 namespace OHOS {
22 namespace bluetooth {
23 std::map<uint16_t, L2capTransport *> L2capTransport::g_clientTransportMap {};
24 std::recursive_mutex L2capTransport::g_clientTransportMutex;
25 
L2capTransport(L2capTransportInfo & createInfo)26 L2capTransport::L2capTransport(L2capTransportInfo &createInfo)
27     : lpsm_(createInfo.lpsm),
28       rpsm_(createInfo.rpsm),
29       localMtu_(createInfo.mtu),
30       observer_(createInfo.observer),
31       dispatcher_(createInfo.dispatcher)
32 {
33     if (createInfo.addr != nullptr) {
34         HILOGI("remoteAddr: %{public}s, lpsm: %{public}hu, rpsm: %{public}hu, localMtu_: %{public}hu",
35             GetEncryptAddr(remoteAddr_.GetAddress()).c_str(), lpsm_, rpsm_, localMtu_);
36         remoteAddr_ = *createInfo.addr;
37     }
38 }
39 
~L2capTransport()40 L2capTransport::~L2capTransport()
41 {
42 }
43 
Connect()44 int L2capTransport::Connect()
45 {
46     LOG_INFO("[L2capTransport]%{public}s lpsm:0x%04X, rpsm:0x%04X", __func__, lpsm_, rpsm_);
47 
48     BtAddr btAddr;
49     remoteAddr_.ConvertToUint8(btAddr.addr);
50     btAddr.type = BT_PUBLIC_DEVICE_ADDRESS;
51     return L2CIF_ConnectReq(&btAddr, lpsm_, rpsm_, this, TransportL2cConnectReqCallback);
52 }
53 
Disconnect()54 int L2capTransport::Disconnect()
55 {
56     LOG_INFO("[L2capTransport]%{public}s lcid:%hu", __func__, l2capHandle_);
57 
58     L2CIF_DisconnectionReq(l2capHandle_, nullptr);
59     return 0;
60 }
61 
RegisterServer()62 int L2capTransport::RegisterServer()
63 {
64     LOG_INFO("[L2capTransport]%{public}s", __func__);
65     isServer_ = true;
66     L2CIF_RegisterService(lpsm_, &L2CAP_CALLBACK, this, nullptr);
67     return 0;
68 }
69 
RemoveServer(bool isDisable)70 int L2capTransport::RemoveServer(bool isDisable)
71 {
72     LOG_INFO("[L2capTransport]%{public}s", __func__);
73 
74     L2CIF_DeregisterService(lpsm_, nullptr);
75 
76     this->isRemoveServer_ = true;
77     std::lock_guard<std::mutex> lock(this->transportMutex_);
78     std::map<uint16_t, L2capTransport *>::iterator it;
79     for (it = this->transportMap_.begin(); it != this->transportMap_.end(); ++it) {
80         if (!it->second->isConnected_) {
81             LOG_INFO("[L2capTransport]%{public}s delete transport", __func__);
82             delete it->second;
83             it->second = nullptr;
84         }
85     }
86     return 0;
87 }
88 
AcceptConnection(const RawAddress & addr,uint16_t psm)89 int L2capTransport::AcceptConnection(const RawAddress &addr, uint16_t psm)
90 {
91     LOG_INFO("[L2capTransport]%{public}s ", __func__);
92 
93     uint16_t lcid = 0;
94     uint8_t id = 0;
95     {
96         std::lock_guard<std::mutex> lock(transportMutex_);
97         if (this->handleMap_.find(addr) != this->handleMap_.end()) {
98             lcid = this->handleMap_.at(addr).lcid;
99             id = this->handleMap_.at(addr).id;
100         } else {
101             LOG_DEBUG("[L2capTransport]%{public}s handle does not exist", __FUNCTION__);
102         }
103     }
104     LOG_INFO("[L2capTransport]%{public}s lcid:%hu id:%hhu", __func__, lcid, id);
105     AddTransportInternal(addr, lcid);
106 
107     L2CIF_ConnectRsp(lcid, id, 0, 0, nullptr);
108 
109     L2capConfigInfo l2capConfigInfo;
110     (void)memset_s(&l2capConfigInfo, sizeof(L2capConfigInfo), 0x00, sizeof(L2capConfigInfo));
111     l2capConfigInfo.mtu = localMtu_;
112     l2capConfigInfo.flushTimeout = L2CAP_CONFIG_FLUSHTTIMEOUT;
113     l2capConfigInfo.fcs = L2CAP_CONFIG_FCS;
114     l2capConfigInfo.rfc.mode = L2CAP_CONFIG_RFC_MODE;
115 
116     L2CIF_ConfigReq(lcid, &l2capConfigInfo, nullptr);
117 
118     return 0;
119 }
120 
RejectConnection(const RawAddress & addr,uint16_t psm)121 int L2capTransport::RejectConnection(const RawAddress &addr, uint16_t psm)
122 {
123     LOG_INFO("[L2capTransport]%{public}s", __func__);
124 
125     uint16_t lcid = 0;
126     uint8_t id = 0;
127     {
128         std::lock_guard<std::mutex> lock(transportMutex_);
129         if (this->handleMap_.find(addr) != this->handleMap_.end()) {
130             lcid = this->handleMap_.at(addr).lcid;
131             id = this->handleMap_.at(addr).id;
132         } else {
133             LOG_DEBUG("[L2capTransport]%{public}s handle does not exist", __FUNCTION__);
134         }
135     }
136     LOG_INFO("[L2capTransport]%{public}s lcid:%hu id:%hhu", __func__, lcid, id);
137     L2CIF_ConnectRsp(lcid, id, L2CAP_NO_RESOURCES_AVAILABLE, 0, nullptr);
138     return 0;
139 }
140 
Read(Packet ** pkt)141 int L2capTransport::Read(Packet **pkt)
142 {
143     LOG_INFO("[L2capTransport]%{public}s", __func__);
144     return 0;
145 }
146 
Write(Packet * pkt)147 int L2capTransport::Write(Packet *pkt)
148 {
149     LOG_INFO("[L2capTransport]%{public}s", __func__);
150 
151     return L2CIF_SendData(this->l2capHandle_, pkt, NULL);
152 }
153 
GetRemoteAddress()154 RawAddress L2capTransport::GetRemoteAddress()
155 {
156     LOG_INFO("[L2capTransport]%{public}s", __func__);
157 
158     if (IsServer()) {
159         return remoteAddrMap_.at(this);
160     } else {
161         return remoteAddr_;
162     }
163 }
164 
RegisterClientPsm(uint16_t lpsm)165 int L2capTransport::RegisterClientPsm(uint16_t lpsm)
166 {
167     LOG_INFO("[L2capTransport]%{public}s lpsm:0x%04X", __func__, lpsm);
168     return L2CIF_RegisterService(lpsm, &L2CAP_CALLBACK, nullptr, nullptr);
169 }
170 
DeregisterClientPsm(uint16_t lpsm)171 void L2capTransport::DeregisterClientPsm(uint16_t lpsm)
172 {
173     LOG_INFO("[L2capTransport]%{public}s lpsm:0x%04X", __func__, lpsm);
174     L2CIF_DeregisterService(lpsm, nullptr);
175 }
176 
AddTransportInternal(RawAddress addr,uint16_t lcid)177 L2capTransport *L2capTransport::AddTransportInternal(RawAddress addr, uint16_t lcid)
178 {
179     LOG_INFO("[L2capTransport]%{public}s lcid:%hu", __func__, lcid);
180     L2capTransportInfo createInfo = {&addr, lpsm_, rpsm_, localMtu_, observer_, dispatcher_};
181     auto newTransport = new (std::nothrow) L2capTransport(createInfo);
182     if (newTransport != nullptr) {
183         newTransport->l2capHandle_ = lcid;
184         newTransport->l2capConfigState_ |= L2CAP_SEND_CONFIG_REQ;
185         {
186             std::lock_guard<std::mutex> lock(transportMutex_);
187             transportMap_.insert(std::pair<uint16_t, L2capTransport *>(lcid, newTransport));
188             remoteAddrMap_.insert(std::pair<L2capTransport *, RawAddress>(newTransport, addr));
189         }
190         return newTransport;
191     } else {
192         return nullptr;
193     }
194 }
195 
FindClientTransport(uint16_t lcid)196 L2capTransport *L2capTransport::FindClientTransport(uint16_t lcid)
197 {
198     LOG_INFO("[L2capTransport]%{public}s lcid:%hu", __func__, lcid);
199 
200     L2capTransport *clientTransport = nullptr;
201     std::lock_guard<std::recursive_mutex> lk(L2capTransport::g_clientTransportMutex);
202     if (g_clientTransportMap.find(lcid) != g_clientTransportMap.end()) {
203         clientTransport = g_clientTransportMap.at(lcid);
204     } else {
205         LOG_DEBUG("[L2capTransport]%{public}s transport does not exist", __func__);
206     }
207 
208     return clientTransport;
209 }
210 
FindAcceptTransport(L2capTransport * transport,uint16_t lcid)211 L2capTransport *L2capTransport::FindAcceptTransport(L2capTransport *transport, uint16_t lcid)
212 {
213     LOG_INFO("[L2capTransport]%{public}s lcid:%hu", __func__, lcid);
214 
215     L2capTransport *l2capTransport = nullptr;
216     if (transport->IsServer()) {
217         std::lock_guard<std::mutex> lock(transport->transportMutex_);
218         if (transport->transportMap_.find(lcid) != transport->transportMap_.end()) {
219             l2capTransport = transport->transportMap_.at(lcid);
220         }
221     } else {
222         l2capTransport = transport;
223     }
224 
225     return l2capTransport;
226 }
227 
GetTransport(uint16_t lcid,void * ctx)228 L2capTransport *L2capTransport::GetTransport(uint16_t lcid, void *ctx)
229 {
230     LOG_INFO("[L2capTransport]%{public}s lcid:%hu", __func__, lcid);
231 
232     L2capTransport *transport = FindClientTransport(lcid);
233     if ((transport == nullptr) && (ctx != nullptr)) {
234         transport = static_cast<L2capTransport *>(ctx);
235     }
236     return transport;
237 }
238 
TransportL2cConnectReqCallback(const BtAddr * addr,uint16_t lcid,int result,void * context)239 void L2capTransport::TransportL2cConnectReqCallback(const BtAddr *addr, uint16_t lcid, int result, void *context)
240 {
241     LOG_INFO("[L2capTransport]%{public}s lcid:%hu", __func__, lcid);
242 
243     if (context == nullptr) {
244         LOG_ERROR("[L2capTransport]%{public}s context is null.", __func__);
245         return;
246     }
247 
248     auto transport = static_cast<L2capTransport *>(context);
249     BtAddr btAddr;
250     (void)memcpy_s(&btAddr, sizeof(BtAddr), addr, sizeof(BtAddr));
251 
252     if (result != BT_SUCCESS) {
253         LOG_ERROR("[L2capTransport]%{public}s", __func__);
254         return;
255     }
256     if (lcid != 0) {
257         transport->l2capHandle_ = lcid;
258         LOG_INFO("[L2capTransport]%{public}s l2capHandle_:%hu", __func__, transport->l2capHandle_);
259         std::lock_guard<std::recursive_mutex> lk(L2capTransport::g_clientTransportMutex);
260         LOG_INFO("[L2capTransport]%{public}s clientTransportMap size:%{public}zu",
261             __func__, g_clientTransportMap.size());
262         std::map<uint16_t, L2capTransport *>::iterator it;
263         for (it = g_clientTransportMap.begin(); it != g_clientTransportMap.end(); ++it) {
264             LOG_INFO("[L2capTransport]%{public}s lcid:%hu", __func__, it->first);
265         }
266         g_clientTransportMap[lcid] = transport;
267     }
268     transport->dispatcher_.PostTask(
269         std::bind(&L2capTransport::TransportL2cConnectReqCallbackNative, transport, transport, btAddr, lcid, result));
270 }
271 
TransportRecvConnectionReqCallback(uint16_t lcid,uint8_t id,const L2capConnectionInfo * info,uint16_t lpsm,void * ctx)272 void L2capTransport::TransportRecvConnectionReqCallback(
273     uint16_t lcid, uint8_t id, const L2capConnectionInfo *info, uint16_t lpsm, void *ctx)
274 {
275     LOG_INFO("[L2capTransport]%{public}s lcid:%hu", __func__, lcid);
276 
277     if (ctx == nullptr) {
278         LOG_ERROR("[L2capTransport]%{public}s context is null.", __func__);
279         return;
280     }
281 
282     auto transport = static_cast<L2capTransport *>(ctx);
283     L2capConnectionInfo l2capConnectionInfo;
284     (void)memcpy_s(&l2capConnectionInfo, sizeof(L2capConnectionInfo), info, sizeof(L2capConnectionInfo));
285     transport->dispatcher_.PostTask(std::bind(&L2capTransport::TransportRecvConnectionReqCallbackNative,
286         transport,
287         transport,
288         lcid,
289         id,
290         l2capConnectionInfo,
291         lpsm));
292 }
293 
TransportRecvConnectionRspCallback(uint16_t lcid,const L2capConnectionInfo * info,uint16_t result,uint16_t status,void * ctx)294 void L2capTransport::TransportRecvConnectionRspCallback(
295     uint16_t lcid, const L2capConnectionInfo *info, uint16_t result, uint16_t status, void *ctx)
296 {
297     LOG_INFO("[L2capTransport]%{public}s lcid:%hu", __func__, lcid);
298 
299     L2capTransport *transport = GetTransport(lcid, ctx);
300     if (transport == nullptr) {
301         LOG_DEBUG("[L2capTransport]%{public}s transport is null.", __func__);
302         return;
303     }
304 
305     L2capConnectionInfo l2capConnectionInfo;
306     (void)memcpy_s(&l2capConnectionInfo, sizeof(L2capConnectionInfo), info, sizeof(L2capConnectionInfo));
307     transport->dispatcher_.PostTask(std::bind(&L2capTransport::TransportRecvConnectionRspCallbackNative,
308         transport,
309         transport,
310         lcid,
311         l2capConnectionInfo,
312         result,
313         status));
314 }
315 
TransportRecvConfigReqCallback(uint16_t lcid,uint8_t id,const L2capConfigInfo * cfg,void * ctx)316 void L2capTransport::TransportRecvConfigReqCallback(uint16_t lcid, uint8_t id, const L2capConfigInfo *cfg, void *ctx)
317 {
318     LOG_INFO("[L2capTransport]%{public}s lcid:%hu", __func__, lcid);
319 
320     L2capTransport *transport = GetTransport(lcid, ctx);
321 
322     if (transport == nullptr) {
323         LOG_DEBUG("[L2capTransport]%{public}s transport does not exist", __func__);
324         return;
325     }
326 
327     L2capConfigInfo l2capConfigInfo;
328     (void)memcpy_s(&l2capConfigInfo, sizeof(L2capConfigInfo), cfg, sizeof(L2capConfigInfo));
329     transport->dispatcher_.PostTask(std::bind(
330         &L2capTransport::TransportRecvConfigReqCallbackNative, transport, transport, lcid, id, l2capConfigInfo));
331 }
332 
TransportRecvConfigRspCallback(uint16_t lcid,const L2capConfigInfo * cfg,uint16_t result,void * ctx)333 void L2capTransport::TransportRecvConfigRspCallback(
334     uint16_t lcid, const L2capConfigInfo *cfg, uint16_t result, void *ctx)
335 {
336     LOG_INFO("[L2capTransport]%{public}s lcid:%hu", __func__, lcid);
337 
338     L2capTransport *transport = GetTransport(lcid, ctx);
339 
340     if (transport == nullptr) {
341         LOG_DEBUG("[L2capTransport]%{public}s transport does not exist", __func__);
342         return;
343     }
344     L2capConfigInfo l2capConfigInfo;
345     memcpy_s(&l2capConfigInfo, sizeof(L2capConfigInfo), cfg, sizeof(L2capConfigInfo));
346     transport->dispatcher_.PostTask(std::bind(
347         &L2capTransport::TransportRecvConfigRspCallbackNative, transport, transport, lcid, l2capConfigInfo, result));
348 }
349 
TransportRecvDisconnectionReqCallback(uint16_t lcid,uint8_t id,void * ctx)350 void L2capTransport::TransportRecvDisconnectionReqCallback(uint16_t lcid, uint8_t id, void *ctx)
351 {
352     LOG_INFO("[L2capTransport]%{public}s lcid:%hu", __func__, lcid);
353 
354     L2capTransport *transport = GetTransport(lcid, ctx);
355 
356     if (transport == nullptr) {
357         LOG_DEBUG("[L2capTransport]%{public}s transport does not exist", __func__);
358         return;
359     }
360 
361     {
362         std::lock_guard<std::recursive_mutex> lk(L2capTransport::g_clientTransportMutex);
363         g_clientTransportMap.erase(lcid);
364     }
365     transport->dispatcher_.PostTask(
366         std::bind(&L2capTransport::TransportRecvDisconnectionReqCallbackNative, transport, transport, lcid, id));
367 }
368 
TransportRecvDisconnectionRspCallback(uint16_t lcid,void * ctx)369 void L2capTransport::TransportRecvDisconnectionRspCallback(uint16_t lcid, void *ctx)
370 {
371     LOG_INFO("[L2capTransport]%{public}s lcid:%hu", __func__, lcid);
372 
373     L2capTransport *transport = GetTransport(lcid, ctx);
374 
375     if (transport == nullptr) {
376         LOG_DEBUG("[L2capTransport]%{public}s transport does not exist", __func__);
377         return;
378     }
379 
380     {
381         std::lock_guard<std::recursive_mutex> lk(L2capTransport::g_clientTransportMutex);
382         g_clientTransportMap.erase(lcid);
383     }
384     transport->dispatcher_.PostTask(
385         std::bind(&L2capTransport::TransportRecvDisconnectionRspCallbackNative, transport, transport, lcid));
386 }
387 
TransportDisconnectAbnormalCallback(uint16_t lcid,uint8_t reason,void * ctx)388 void L2capTransport::TransportDisconnectAbnormalCallback(uint16_t lcid, uint8_t reason, void *ctx)
389 {
390     LOG_INFO("[L2capTransport]%{public}s lcid:%hu", __func__, lcid);
391 
392     L2capTransport *transport = GetTransport(lcid, ctx);
393 
394     if (transport == nullptr) {
395         LOG_DEBUG("[L2capTransport]%{public}s transport does not exist", __func__);
396         return;
397     }
398 
399     {
400         std::lock_guard<std::recursive_mutex> lk(L2capTransport::g_clientTransportMutex);
401         g_clientTransportMap.erase(lcid);
402     }
403     transport->dispatcher_.PostTask(
404         std::bind(&L2capTransport::TransportDisconnectAbnormalCallbackNative, transport, transport, lcid, reason));
405 }
406 
TransportRecvDataCallback(uint16_t lcid,Packet * pkt,void * ctx)407 void L2capTransport::TransportRecvDataCallback(uint16_t lcid, Packet *pkt, void *ctx)
408 {
409     LOG_INFO("[L2capTransport]%{public}s lcid:%hu", __func__, lcid);
410 
411     L2capTransport *transport = GetTransport(lcid, ctx);
412 
413     if (transport == nullptr) {
414         LOG_DEBUG("[L2capTransport]%{public}s transport does not exist", __func__);
415         return;
416     }
417     Packet *pktref = PacketRefMalloc(pkt);
418     transport->dispatcher_.PostTask(
419         std::bind(&L2capTransport::TransportRecvDataCallbackNative, transport, transport, lcid, pktref));
420 }
421 
TransportRemoteBusyCallback(uint16_t lcid,uint8_t isBusy,void * ctx)422 void L2capTransport::TransportRemoteBusyCallback(uint16_t lcid, uint8_t isBusy, void *ctx)
423 {
424     LOG_INFO("[L2capTransport]%{public}s lcid:%hu isBusy:%hhu", __func__, lcid, isBusy);
425 
426     L2capTransport *transport = GetTransport(lcid, ctx);
427 
428     if (transport == nullptr) {
429         LOG_DEBUG("[L2capTransport]%{public}s transport does not exist", __func__);
430         return;
431     }
432     transport->dispatcher_.PostTask(
433         std::bind(&L2capTransport::TransportRemoteBusyCallbackNative, transport, transport, lcid, isBusy));
434 }
435 
TransportL2cConnectReqCallbackNative(L2capTransport * transport,const BtAddr & addr,uint16_t lcid,int result)436 void L2capTransport::TransportL2cConnectReqCallbackNative(
437     L2capTransport *transport, const BtAddr &addr, uint16_t lcid, int result)
438 {
439     LOG_INFO("[L2capTransport]%{public}s lcid:%hu result:%{public}d", __func__, lcid, result);
440 
441     if (lcid == 0) {
442         transport->observer_.OnTransportError(transport, CONNECT_FAIL);
443         return;
444     }
445 }
446 
TransportRecvConnectionReqCallbackNative(L2capTransport * transport,uint16_t lcid,uint8_t id,const L2capConnectionInfo info,uint16_t lpsm)447 void L2capTransport::TransportRecvConnectionReqCallbackNative(
448     L2capTransport *transport, uint16_t lcid, uint8_t id, const L2capConnectionInfo info, uint16_t lpsm)
449 {
450     LOG_INFO("[L2capTransport]%{public}s lcid:%hu", __func__, lcid);
451 
452     if (transport->isRemoveServer_) {
453         LOG_INFO("[L2capTransport]%{public}s server is removed", __func__);
454         L2CIF_ConnectRsp(lcid, id, L2CAP_NO_RESOURCES_AVAILABLE, 0, nullptr);
455         return;
456     }
457 
458     L2capConnectionInfo l2capConnectionInfo;
459     memcpy_s(&l2capConnectionInfo, sizeof(L2capConnectionInfo), &info, sizeof(L2capConnectionInfo));
460     ConnectReqInfo connectReqInfo = {};
461     connectReqInfo.id = id;
462     connectReqInfo.lcid = lcid;
463     {
464         std::lock_guard<std::mutex> lock(transport->transportMutex_);
465         transport->handleMap_[RawAddress::ConvertToString(l2capConnectionInfo.addr.addr)] = connectReqInfo;
466     }
467     transport->observer_.OnConnectIncoming(RawAddress::ConvertToString(l2capConnectionInfo.addr.addr), lpsm);
468 }
469 
TransportRecvConnectionRspCallbackNative(L2capTransport * transport,uint16_t lcid,const L2capConnectionInfo info,uint16_t result,uint16_t status)470 void L2capTransport::TransportRecvConnectionRspCallbackNative(
471     L2capTransport *transport, uint16_t lcid, const L2capConnectionInfo info, uint16_t result, uint16_t status)
472 {
473     LOG_INFO("[L2capTransport]%{public}s lcid:%hu result:%hu", __func__, lcid, result);
474 
475     if (result == L2CAP_CONNECTION_PENDING) {
476         LOG_DEBUG("[L2capTransport]%{public}s L2CAP Pending.", __func__);
477         return;
478     }
479 
480     if (result != L2CAP_CONNECTION_SUCCESSFUL) {
481         LOG_DEBUG("[L2capTransport]%{public}s L2CAP Connect fail.", __func__);
482         transport->observer_.OnTransportError(transport, CONNECT_FAIL);
483         {
484             std::lock_guard<std::recursive_mutex> lk(L2capTransport::g_clientTransportMutex);
485             g_clientTransportMap.erase(lcid);
486         }
487         return;
488     }
489 
490     LOG_INFO("[L2capTransport]%{public}s lcid:%hu l2capHandle_:%hu", __func__, lcid, transport->l2capHandle_);
491     if (lcid != transport->l2capHandle_) {
492         LOG_ERROR("[L2capTransport]%{public}s L2CAP lcid error.", __func__);
493         return;
494     }
495 
496     L2capConfigInfo l2capConfigInfo;
497     (void)memset_s(&l2capConfigInfo, sizeof(L2capConfigInfo), 0x00, sizeof(L2capConfigInfo));
498     l2capConfigInfo.mtu = localMtu_;
499     l2capConfigInfo.flushTimeout = 0xFFFF;
500     l2capConfigInfo.fcs = 0x01;
501     l2capConfigInfo.rfc.mode = 0x03;
502     l2capConfigState_ |= L2CAP_SEND_CONFIG_REQ;
503     L2CIF_ConfigReq(lcid, &l2capConfigInfo, nullptr);
504 }
505 
TransportRecvConfigReqCallbackNative(L2capTransport * transport,uint16_t lcid,uint8_t id,const L2capConfigInfo cfg)506 void L2capTransport::TransportRecvConfigReqCallbackNative(
507     L2capTransport *transport, uint16_t lcid, uint8_t id, const L2capConfigInfo cfg)
508 {
509     LOG_INFO("[L2capTransport]%{public}s lcid:%hu", __func__, lcid);
510 
511     L2capConfigInfo l2capConfigInfo;
512     memcpy_s(&l2capConfigInfo, sizeof(L2capConfigInfo), &cfg, sizeof(L2capConfigInfo));
513     remoteMtu_ = l2capConfigInfo.mtu;
514     L2CIF_ConfigRsp(lcid, id, &l2capConfigInfo, 0, nullptr);
515 
516     L2capTransport *l2capTransport = FindAcceptTransport(transport, lcid);
517 
518     if (l2capTransport == nullptr) {
519         LOG_INFO("[L2capTransport]%{public}s l2capTransport does not exist.", __func__);
520         return;
521     }
522 
523     l2capTransport->l2capConfigState_ |= L2CAP_RECV_CONFIG_REQ;
524     if (l2capTransport->l2capConfigState_ == L2CAP_CONFIG_COMPLETE) {
525         l2capTransport->isConnected_ = true;
526         transport->observer_.OnConnected(l2capTransport, transport->remoteMtu_, transport->localMtu_);
527     }
528 }
529 
TransportRecvConfigRspCallbackNative(L2capTransport * transport,uint16_t lcid,const L2capConfigInfo cfg,uint16_t result)530 void L2capTransport::TransportRecvConfigRspCallbackNative(
531     L2capTransport *transport, uint16_t lcid, const L2capConfigInfo cfg, uint16_t result)
532 {
533     LOG_INFO("[L2capTransport]%{public}s lcid:%hu result:%hu", __func__, lcid, result);
534 
535     L2capTransport *l2capTransport = FindAcceptTransport(transport, lcid);
536 
537     if (l2capTransport == nullptr) {
538         LOG_INFO("[L2capTransport]%{public}s l2capTransport does not exist.", __func__);
539         return;
540     }
541 
542     if (result != L2CAP_SUCCESS) {
543         std::map<RawAddress, ConnectReqInfo>::iterator it;
544         if (!transport->IsServer()) {
545             transport->observer_.OnTransportError(transport, CONNECT_FAIL);
546             {
547                 std::lock_guard<std::recursive_mutex> lk(L2capTransport::g_clientTransportMutex);
548                 g_clientTransportMap.erase(lcid);
549             }
550 
551             L2CIF_DisconnectionReq(lcid, nullptr);
552             return;
553         }
554 
555         std::lock_guard<std::mutex> lock(transport->transportMutex_);
556         for (it = transport->handleMap_.begin(); it != transport->handleMap_.end(); ++it) {
557             if (it->second.lcid == lcid) {
558                 transport->remoteAddr_ = it->first;
559                 transport->observer_.OnIncomingDisconnected(transport->remoteAddr_);
560                 transport->handleMap_.erase(it);
561                 break;
562             }
563         }
564         transport->remoteAddrMap_.erase(l2capTransport);
565         transport->transportMap_.erase(lcid);
566         delete l2capTransport;
567         L2CIF_DisconnectionReq(lcid, nullptr);
568         return;
569     }
570 
571     l2capTransport->l2capConfigState_ |= L2CAP_RECV_CONFIG_RSP;
572     if (l2capTransport->l2capConfigState_ == L2CAP_CONFIG_COMPLETE) {
573         l2capTransport->isConnected_ = true;
574         transport->observer_.OnConnected(l2capTransport, transport->remoteMtu_, transport->localMtu_);
575     }
576 }
577 
TransportRecvDisconnectionReqCallbackNative(L2capTransport * transport,uint16_t lcid,uint8_t id)578 void L2capTransport::TransportRecvDisconnectionReqCallbackNative(L2capTransport *transport, uint16_t lcid, uint8_t id)
579 {
580     LOG_INFO("[L2capTransport]%{public}s lcid:%hu", __func__, lcid);
581 
582     L2CIF_DisconnectionRsp(lcid, id, nullptr);
583 
584     if (!transport->IsServer()) {
585         transport->observer_.OnDisconnected(transport);
586         return;
587     }
588 
589     std::lock_guard<std::mutex> lock(transport->transportMutex_);
590     if (transport->transportMap_.find(lcid) != transport->transportMap_.end()) {
591         std::map<RawAddress, ConnectReqInfo>::iterator it;
592         for (it = transport->handleMap_.begin(); it != transport->handleMap_.end(); ++it) {
593             if (it->second.lcid == lcid) {
594                 transport->handleMap_.erase(it);
595                 break;
596             }
597         }
598 
599         auto transportTmp = transport->transportMap_.at(lcid);
600         transport->transportMap_.erase(lcid);
601         transport->remoteAddrMap_.erase(transportTmp);
602         transport->observer_.OnDisconnected(transportTmp);
603     } else {
604         LOG_ERROR("[L2capTransport]%{public}s handle:%hu transport does not exist", __FUNCTION__, lcid);
605         std::map<RawAddress, ConnectReqInfo>::iterator it;
606         for (it = transport->handleMap_.begin(); it != transport->handleMap_.end(); ++it) {
607             if (it->second.lcid == lcid) {
608                 transport->remoteAddr_ = it->first;
609                 transport->observer_.OnIncomingDisconnected(transport->remoteAddr_);
610                 break;
611             }
612         }
613     }
614 }
615 
TransportRecvDisconnectionRspCallbackNative(L2capTransport * transport,uint16_t lcid)616 void L2capTransport::TransportRecvDisconnectionRspCallbackNative(L2capTransport *transport, uint16_t lcid)
617 {
618     LOG_INFO("[L2capTransport]%{public}s lcid:%hu", __func__, lcid);
619 
620     if (!transport->IsServer()) {
621         transport->observer_.OnDisconnectSuccess(transport);
622         return;
623     }
624 
625     std::lock_guard<std::mutex> lock(transport->transportMutex_);
626     if (transport->transportMap_.find(lcid) != transport->transportMap_.end()) {
627         std::map<RawAddress, ConnectReqInfo>::iterator it;
628         for (it = transport->handleMap_.begin(); it != transport->handleMap_.end(); ++it) {
629             if (it->second.lcid == lcid) {
630                 transport->handleMap_.erase(it);
631                 break;
632             }
633         }
634 
635         auto transportTmp = transport->transportMap_.at(lcid);
636         transport->transportMap_.erase(lcid);
637         transport->remoteAddrMap_.erase(transportTmp);
638         transport->observer_.OnDisconnectSuccess(transportTmp);
639     } else {
640         LOG_ERROR("[L2capTransport]%{public}s handle:%hu transport does not exist", __FUNCTION__, lcid);
641     }
642 }
643 
TransportDisconnectAbnormalCallbackNative(L2capTransport * transport,uint16_t lcid,uint8_t reason)644 void L2capTransport::TransportDisconnectAbnormalCallbackNative(L2capTransport *transport, uint16_t lcid, uint8_t reason)
645 {
646     LOG_INFO("[L2capTransport]%{public}s lcid:%hu", __func__, lcid);
647 
648     if (!transport->IsServer()) {
649         if (reason == L2CAP_STATE_COLLISION) {
650             transport->observer_.OnTransportError(transport, CONNECT_COLLISION);
651         } else {
652             transport->observer_.OnDisconnected(transport);
653         }
654         return;
655     }
656 
657     std::lock_guard<std::mutex> lock(transport->transportMutex_);
658     if (transport->transportMap_.find(lcid) != transport->transportMap_.end()) {
659         std::map<RawAddress, ConnectReqInfo>::iterator it;
660         for (it = transport->handleMap_.begin(); it != transport->handleMap_.end(); ++it) {
661             if (it->second.lcid == lcid) {
662                 transport->handleMap_.erase(it);
663                 break;
664             }
665         }
666 
667         auto transportTmp = transport->transportMap_.at(lcid);
668         transport->transportMap_.erase(lcid);
669         transport->remoteAddrMap_.erase(transportTmp);
670         transport->observer_.OnDisconnected(transportTmp);
671     } else {
672         LOG_ERROR("[L2capTransport]%{public}s handle:%hu transport does not exist", __FUNCTION__, lcid);
673         std::map<RawAddress, ConnectReqInfo>::iterator it;
674         for (it = transport->handleMap_.begin(); it != transport->handleMap_.end(); ++it) {
675             if (it->second.lcid == lcid) {
676                 transport->remoteAddr_ = it->first;
677                 transport->observer_.OnIncomingDisconnected(transport->remoteAddr_);
678                 break;
679             }
680         }
681     }
682 }
683 
TransportRecvDataCallbackNative(L2capTransport * transport,uint16_t lcid,Packet * pkt)684 void L2capTransport::TransportRecvDataCallbackNative(L2capTransport *transport, uint16_t lcid, Packet *pkt)
685 {
686     LOG_INFO("[L2capTransport]%{public}s lcid:%hu", __func__, lcid);
687 
688     if (!transport->IsServer()) {
689         transport->observer_.OnDataAvailable(transport, pkt);
690         return;
691     }
692 
693     std::lock_guard<std::mutex> lock(transport->transportMutex_);
694     if (transport->transportMap_.find(lcid) != transport->transportMap_.end()) {
695         transport->observer_.OnDataAvailable(transport->transportMap_.at(lcid), pkt);
696     } else {
697         LOG_ERROR("[L2capTransport]%{public}s handle:%hu transport does not exist", __FUNCTION__, lcid);
698     }
699 }
700 
TransportRemoteBusyCallbackNative(L2capTransport * transport,uint16_t lcid,uint8_t isBusy)701 void L2capTransport::TransportRemoteBusyCallbackNative(L2capTransport *transport, uint16_t lcid, uint8_t isBusy)
702 {
703     LOG_INFO("[L2capTransport]%{public}s lcid:%hu isBusy:%hhu", __func__, lcid, isBusy);
704 
705     if (!transport->IsServer()) {
706         transport->observer_.OnDataBusy(transport, isBusy);
707         return;
708     }
709 
710     std::lock_guard<std::mutex> lock(transport->transportMutex_);
711     if (transport->transportMap_.find(lcid) != transport->transportMap_.end()) {
712         transport->observer_.OnDataBusy(transport->transportMap_.at(lcid), isBusy);
713     } else {
714         LOG_ERROR("[L2capTransport]%{public}s handle:%hu transport does not exist", __FUNCTION__, lcid);
715     }
716 }
717 }  // namespace bluetooth
718 }  // namespace OHOS