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 "pan_bnep.h"
17 #include <endian.h>
18 #include "pan_service.h"
19 
20 namespace OHOS {
21 namespace bluetooth {
Startup()22 int PanBnep::Startup()
23 {
24     GapServiceSecurityInfo securityInfo = {INCOMING, PAN_BNEP, SEC_PROTOCOL_L2CAP,
25         { .l2capPsm = BT_BNEP_PSM }};
26     if (GAPIF_RegisterServiceSecurity(nullptr, &securityInfo,
27         GAP_SEC_IN_ENCRYPTION | GAP_SEC_IN_AUTHENTICATION |
28         GAP_SEC_OUT_ENCRYPTION | GAP_SEC_OUT_AUTHENTICATION)) {
29         LOG_ERROR("[PAN BNEP] %{public}s:GAPIF_RegisterServiceSecurity INCOMING failed.", __func__);
30         return RET_BAD_STATUS;
31     }
32 
33     securityInfo = {OUTGOING, PAN_BNEP, SEC_PROTOCOL_L2CAP,
34         { .l2capPsm = BT_BNEP_PSM }};
35     if (GAPIF_RegisterServiceSecurity(nullptr, &securityInfo,
36         GAP_SEC_IN_ENCRYPTION | GAP_SEC_IN_AUTHENTICATION |
37         GAP_SEC_OUT_ENCRYPTION | GAP_SEC_OUT_AUTHENTICATION)) {
38             LOG_ERROR("[PAN BNEP] %{public}s:GAPIF_RegisterServiceSecurity OUTGOING failed.", __func__);
39         return RET_BAD_STATUS;
40     }
41 
42     /* regist pan bnep psm */
43     if (L2CIF_RegisterService(BT_BNEP_PSM, (L2capService *)&BNEP_CALLBACK, nullptr, nullptr)) {
44         LOG_ERROR("[PAN BNEP] %{public}s:L2CIF_RegisterService PAN_PSM failed.", __func__);
45         return RET_BAD_STATUS;
46     }
47     return BT_SUCCESS;
48 }
49 
Shutdown()50 void PanBnep::Shutdown()
51 {
52     L2CIF_DeregisterService(BT_BNEP_PSM, nullptr);
53     GapServiceSecurityInfo securityInfo = {INCOMING, PAN_BNEP, SEC_PROTOCOL_L2CAP,
54         { .l2capPsm = BT_BNEP_PSM }};
55     GAPIF_DeregisterServiceSecurity(nullptr, &securityInfo);
56     securityInfo = {OUTGOING, PAN_BNEP, SEC_PROTOCOL_L2CAP,
57         { .l2capPsm = BT_BNEP_PSM }};
58     GAPIF_DeregisterServiceSecurity(nullptr, &securityInfo);
59 }
60 
PanBnep(std::string address)61 PanBnep::PanBnep(std::string address)
62 {
63     address_ = address;
64     state_ = BNEP_CONN_STATE_UNUSED;
65     lcid_ = 0;
66     connFlags_ = 0;
67     id_ = 0;
68     isBusy_ = false;
69 }
70 
~PanBnep()71 PanBnep::~PanBnep()
72 {
73     while (!waitingSendDataList_.empty()) {
74         Packet *packet = waitingSendDataList_.front();
75         waitingSendDataList_.pop();
76         PacketFree(packet);
77     }
78 }
79 
Connect()80 int PanBnep::Connect()
81 {
82     LOG_INFO("[PAN BNEP]%{public}s", __func__);
83     BtAddr btAddr;
84     RawAddress(address_).ConvertToUint8(btAddr.addr);
85     btAddr.type = BT_PUBLIC_DEVICE_ADDRESS;
86 
87     if (state_ == BNEP_CONN_STATE_CONNECTED) {
88         PanMessage event(PAN_INT_OPEN_EVT);
89         event.dev_ = address_;
90         PanService::GetService()->PostEvent(event);
91         return BT_SUCCESS;
92     }
93 
94     if (state_ != BNEP_CONN_STATE_UNUSED) {
95         LOG_ERROR("[PAN BNEP] %{public}s:state error state = %{public}d", __func__, state_);
96         return RET_BAD_STATUS;
97     }
98 
99     return SendGapRequestSecurity(false, 0, 0);
100 }
101 
102 /**
103  *
104  * @brief         PanSecurityCheckCallback
105  *
106  * @details       Host receive the security check result
107  *
108  * @return        uint16_t
109  *
110  */
BnepSecurityCheckCallback(uint16_t result,GapServiceSecurityInfo security,void * context)111 void PanBnep::BnepSecurityCheckCallback(
112     uint16_t result, GapServiceSecurityInfo security, void *context)
113 {
114     LOG_INFO("[PAN BNEP]%{public}s:result(%{public}hu), l2capPsm(0x%{public}x)",
115         __func__, result, security.channelId.l2capPsm);
116     std::string *address = (std::string *)context;
117     if (address != nullptr) {
118         PanMessage event(BNEP_L2CAP_SECURITY_RESULT_EVT, result);
119         event.dev_ = *address;
120         PanService::GetService()->PostEvent(event);
121     } else {
122         LOG_ERROR("[PAN BNEP]%{public}s PanL2capConnection is null.", __func__);
123     }
124 }
125 
BnepSecurityCheckTask(uint16_t result)126 void PanBnep::BnepSecurityCheckTask(uint16_t result)
127 {
128     BtAddr btAddr;
129     RawAddress(address_).ConvertToUint8(btAddr.addr);
130     btAddr.type = BT_PUBLIC_DEVICE_ADDRESS;
131 
132     connFlags_ = BNEP_CONN_FLAGS_IS_ORIG;
133 
134     if (result == BT_SUCCESS) {
135         LOG_INFO("[PAN BNEP]%{public}s start connect", __func__);
136         int ret = L2CIF_ConnectReq(&btAddr, BT_BNEP_PSM, BT_BNEP_PSM,
137             this, BnepL2cConnectReqCallback);
138         if (ret != BT_SUCCESS) {
139             LOG_ERROR("[PAN BNEP]%{public}s L2CIF_ConnectReq return value is error.", __func__);
140             state_ = BNEP_CONN_STATE_UNUSED;
141 
142             PanMessage event(PAN_INT_CLOSE_EVT);
143             event.dev_ = address_;
144             PanService::GetService()->PostEvent(event);
145             return;
146         }
147         state_ = BNEP_CONN_STATE_CONNECTING;
148     } else {
149         LOG_ERROR("[PAN BNEP]%{public}s Request Security faild!", __func__);
150         state_ = BNEP_CONN_STATE_UNUSED;
151 
152         PanMessage event(PAN_INT_CLOSE_EVT);
153         event.dev_ = address_;
154         PanService::GetService()->PostEvent(event);
155     }
156 }
157 
158 /**
159  *
160  * @brief         PanIndSecurityCheckCallback
161  *
162  * @details       Host receive the security check result，when receive device's connect request.
163  *
164  * @return        uint16_t
165  *
166  */
BnepIndSecurityCheckDeviceConnectCallback(uint16_t result,GapServiceSecurityInfo security,void * context)167 void PanBnep::BnepIndSecurityCheckDeviceConnectCallback(uint16_t result,
168     GapServiceSecurityInfo security, void *context)
169 {
170     LOG_INFO("[PAN BNEP]%{public}s:result(%{public}hu), l2capPsm(0x%{public}x)",
171         __func__, result, security.channelId.l2capPsm);
172     std::string *address = (std::string *)context;
173     if (address != nullptr) {
174         PanMessage event(BNEP_L2CAP_IND_SECURITY_RESULT_EVT, result);
175         event.dev_ = *address;
176         PanService::GetService()->PostEvent(event);
177     } else {
178         LOG_ERROR("[PAN BNEP]%{public}s PanL2capConnection is null.", __func__);
179     }
180 }
181 
BnepSecurityCheckDeviceConnectTask(uint16_t result)182 void PanBnep::BnepSecurityCheckDeviceConnectTask(uint16_t result)
183 {
184     BtAddr btAddr;
185     RawAddress(address_).ConvertToUint8(btAddr.addr);
186     btAddr.type = BT_PUBLIC_DEVICE_ADDRESS;
187 
188     if ((result == BT_SUCCESS) && (state_ == BNEP_CONN_STATE_SECURITY)) {
189         LOG_INFO("[PAN BNEP]%{public}s start send connect response", __func__);
190         state_ = BNEP_CONN_STATE_CONNECTING;
191         L2CIF_ConnectRsp(lcid_, id_, L2CAP_CONNECTION_SUCCESSFUL, L2CAP_NO_FURTHER_INFORMATION_AVAILABLE, nullptr);
192 
193         L2capConfigInfo l2capConfigInfo;
194         (void)memset_s(&l2capConfigInfo, sizeof(L2capConfigInfo), 0x00, sizeof(L2capConfigInfo));
195         l2capConfigInfo.mtu = BNEP_MTU_SIZE;
196         l2capConfigInfo.flushTimeout = 0xFFFF;
197         if (L2CIF_ConfigReq(lcid_, &l2capConfigInfo, nullptr)) {
198             LOG_ERROR("[PAN BNEP] %{public}s:L2CIF_ConfigReq failed.", __func__);
199         }
200     } else if (result != BT_SUCCESS) {
201         LOG_ERROR("[PAN BNEP]%{public}s Request Security faild!", __func__);
202         state_ = BNEP_CONN_STATE_UNUSED;
203 
204         PanMessage event(PAN_INT_CLOSE_EVT);
205         event.dev_ = address_;
206         PanService::GetService()->PostEvent(event);
207     }
208 }
209 
Disconnect()210 int PanBnep::Disconnect()
211 {
212     LOG_INFO("[PAN BNEP]%{public}s", __func__);
213 
214     if (state_ == BNEP_CONN_STATE_UNUSED) {
215         PanMessage event(PAN_INT_CLOSE_EVT);
216         event.dev_ = address_;
217         PanService::GetService()->PostEvent(event);
218         return BT_SUCCESS;
219     }
220 
221     if (lcid_ != 0) {
222         state_ = BNEP_CONN_STATE_DISCONNECTING;
223         L2CIF_DisconnectionReq(lcid_, nullptr);
224     } else {
225         state_ = BNEP_CONN_STATE_UNUSED;
226         PanMessage event(PAN_INT_CLOSE_EVT);
227         event.dev_ = address_;
228         PanService::GetService()->PostEvent(event);
229         return BT_SUCCESS;
230     }
231 
232     return BT_SUCCESS;
233 }
234 
SendData(EthernetHeader ethernetHeader,uint8_t * pkt,int length)235 int PanBnep::SendData(EthernetHeader ethernetHeader, uint8_t* pkt, int length)
236 {
237     if (!CheckBnepEthernetDataFilter(ethernetHeader, pkt, length)) {
238         return BT_SUCCESS;
239     }
240     uint8_t bluetoothDestAddr[BT_ADDRESS_LENGTH];
241     uint8_t bluetoothSrcAddr[BT_ADDRESS_LENGTH];
242     PanService::ReverseAddress(ethernetHeader.destAddr, bluetoothDestAddr);
243     PanService::ReverseAddress(ethernetHeader.srcAddr, bluetoothSrcAddr);
244     std::string destAddr = RawAddress::ConvertToString(bluetoothDestAddr).GetAddress();
245     BtAddr localAddr;
246     RawAddress(PanService::GetLocalAddress()).ConvertToUint8(localAddr.addr);
247     Packet *packet = nullptr;
248     uint8_t *buf = nullptr;
249     int offset = 0;
250     int ret;
251     uint8_t type = BNEP_COMPRESSED_ETHERNET;
252     int packetLength = length;
253     if (localAddr.addr[BT_ADDRESS_LENGTH - 1] & 0x01) {
254         LOG_DEBUG("[PAN BNEP]%{public}s():use unicast MAC address", __FUNCTION__);
255         localAddr.addr[BT_ADDRESS_LENGTH - 1] &= ~0x01;
256     }
257     if (memcmp(bluetoothSrcAddr, localAddr.addr, BT_ADDRESS_LENGTH) == 0) {
258         if (destAddr == address_) {
259             type = BNEP_COMPRESSED_ETHERNET;
260             packetLength += BNEP_COMPRESSED_ETHERNET_HEAD_LENGTH;
261         } else {
262             type = BNEP_COMPRESSED_ETHERNET_DEST_ONLY;
263             packetLength += BNEP_COMPRESSED_ETHERNET_DEST_ONLY_HEAD_LENGTH;
264         }
265     } else {
266         if (destAddr == address_) {
267             type = BNEP_COMPRESSED_ETHERNET_SRC_ONLY;
268             packetLength += BNEP_COMPRESSED_ETHERNET_SRC_ONLY_HEAD_LENGTH;
269         } else {
270             type = BNEP_GENERAL_ETHERNET;
271             packetLength += BNEP_GENERAL_ETHERNET_HEAD_LENGTH;
272         }
273     }
274     packet = PacketMalloc(packetLength, 0, 0);
275     buf = (uint8_t *)BufferPtr(PacketHead(packet));
276     ret = BnepBuildEthernetPacketHeader(type, ethernetHeader, buf);
277     if (ret <= 0) {
278         return PAN_FAILURE;
279     }
280     offset += ret;
281     if ((length > 0) && (pkt != nullptr)) {
282         if (memcpy_s(buf + offset, length, pkt, length) != EOK) {
283             LOG_ERROR("[PAN BNEP]%{public}s(): memcpy source Address error", __FUNCTION__);
284             return PAN_FAILURE;
285         }
286     }
287     AddPacketToWaitingSendDataList(packet);
288     return BT_SUCCESS;
289 }
290 
AddPacketToWaitingSendDataList(Packet * addPacket)291 void PanBnep::AddPacketToWaitingSendDataList(Packet *addPacket)
292 {
293     if (waitingSendDataList_.size() < BNEP_MAX_WAITING_SEND_DATA_LIST_NUMBER) {
294         waitingSendDataList_.push(addPacket);
295     } else {
296         LOG_ERROR("[PAN BNEP]%{public}s(): waiting send data list is full!", __FUNCTION__);
297         PacketFree(addPacket);
298     }
299     while (!isBusy_ && !waitingSendDataList_.empty()) {
300         Packet *packet = waitingSendDataList_.front();
301         waitingSendDataList_.pop();
302         L2CIF_SendData(lcid_, packet, nullptr);
303         PacketFree(packet);
304     }
305 }
306 
CheckBnepEthernetDataFilter(EthernetHeader ethernetHeader,uint8_t * pkt,int length)307 bool PanBnep::CheckBnepEthernetDataFilter(EthernetHeader ethernetHeader, uint8_t* pkt, int length)
308 {
309     if (!protocolFilterList_.empty()) {
310         std::vector<BnepProtocolFilterRange>::iterator it;
311         for (it = protocolFilterList_.begin(); it != protocolFilterList_.end(); it++) {
312             if ((ethernetHeader.protocol >= it->start) && (ethernetHeader.protocol <= it->end)) {
313                 break;
314             }
315         }
316         if (it == protocolFilterList_.end()) {
317             return false;
318         }
319     }
320     // Just check broadcast
321     if ((ethernetHeader.destAddr[0] & 0x01) && !multycastFilterList_.empty()) {
322         std::vector<BnepMultycastFilterRange>::iterator it;
323         for (it = multycastFilterList_.begin(); it != multycastFilterList_.end(); it++) {
324             if ((memcmp(ethernetHeader.destAddr, it->start, BT_ADDRESS_LENGTH) >= 0) &&
325                 (memcmp(ethernetHeader.destAddr, it->end, BT_ADDRESS_LENGTH) <= 0)) {
326                 break;
327             }
328         }
329         if (it == multycastFilterList_.end()) {
330             return false;
331         }
332     }
333     return true;
334 }
335 
BnepBuildEthernetPacketHeader(uint8_t type,EthernetHeader ethernetHeader,uint8_t * buf)336 int PanBnep::BnepBuildEthernetPacketHeader(uint8_t type, EthernetHeader ethernetHeader, uint8_t *buf)
337 {
338     if (buf == nullptr) {
339         LOG_ERROR("[PAN BNEP]%{public}s(): buf is null", __FUNCTION__);
340         return 0;
341     }
342     int offset = 0;
343     buf[offset] = type;
344     offset++;
345     if ((type == BNEP_COMPRESSED_ETHERNET_DEST_ONLY) || (type == BNEP_GENERAL_ETHERNET)) {
346         if (memcpy_s(buf + offset, BT_ADDRESS_LENGTH, ethernetHeader.destAddr,
347             BT_ADDRESS_LENGTH) != EOK) {
348             LOG_ERROR("[PAN BNEP]%{public}s(): memcpy destination Address error", __FUNCTION__);
349             return 0;
350         }
351         offset += BT_ADDRESS_LENGTH;
352     }
353     if ((type == BNEP_COMPRESSED_ETHERNET_SRC_ONLY) || (type == BNEP_GENERAL_ETHERNET)) {
354         if (memcpy_s(buf + offset, BT_ADDRESS_LENGTH, ethernetHeader.srcAddr,
355             BT_ADDRESS_LENGTH) != EOK) {
356             LOG_ERROR("[PAN BNEP]%{public}s(): memcpy source Address error", __FUNCTION__);
357             return 0;
358         }
359         offset += BT_ADDRESS_LENGTH;
360     }
361 
362     *(reinterpret_cast<uint16_t *>(buf + offset)) = htobe16(ethernetHeader.protocol);
363     offset += BNEP_UINT16_SIZE;
364     return offset;
365 }
366 
GetLcid()367 uint16_t PanBnep::GetLcid()
368 {
369     return lcid_;
370 }
371 
BnepL2cConnectReqCallback(const BtAddr * addr,uint16_t lcid,int result,void * context)372 void PanBnep::BnepL2cConnectReqCallback(
373     const BtAddr *addr, uint16_t lcid, int result, void *context)
374 {
375     LOG_INFO("[PAN BNEP]%{public}s lcid:%{public}hu", __func__, lcid);
376     PanBnep* l2capConnect = (PanBnep *)context;
377     if ((l2capConnect != nullptr) && (result == BT_SUCCESS)) {
378         l2capConnect->lcid_ = lcid;
379     } else {
380         LOG_ERROR("[PAN BNEP]%{public}s PanService is null!", __func__);
381     }
382 }
383 
BnepRecvConnectionReqCallback(uint16_t lcid,uint8_t id,const L2capConnectionInfo * info,uint16_t lpsm,void * ctx)384 void PanBnep::BnepRecvConnectionReqCallback(
385     uint16_t lcid, uint8_t id, const L2capConnectionInfo *info, uint16_t lpsm, void *ctx)
386 {
387     LOG_INFO("[PAN BNEP]%{public}s lcid:%{public}hu", __func__, lcid);
388 
389     if (info == nullptr) {
390         LOG_ERROR("[PAN BNEP]%{public}s L2capConnectionInfo is null!", __func__);
391         return;
392     }
393     std::string address = RawAddress::ConvertToString(info->addr.addr).GetAddress();
394     PanMessage event(BNEP_L2CAP_CONNECT_REQ_EVT);
395     PanL2capConnectionInfo l2capInfo;
396     l2capInfo.lcid = lcid;
397     l2capInfo.id = id;
398     l2capInfo.lpsm = lpsm;
399     event.dev_ = address;
400     event.l2capInfo_ = l2capInfo;
401     PanService::GetService()->PostEvent(event);
402 }
403 
BnepRecvConnectionRspCallback(uint16_t lcid,const L2capConnectionInfo * info,uint16_t result,uint16_t status,void * ctx)404 void PanBnep::BnepRecvConnectionRspCallback(
405     uint16_t lcid, const L2capConnectionInfo *info, uint16_t result, uint16_t status, void *ctx)
406 {
407     LOG_INFO("[PAN BNEP]%{public}s lcid:%{public}hu", __func__, lcid);
408 
409     if (info == nullptr) {
410         LOG_ERROR("[PAN BNEP]%{public}s L2capConnectionInfo is null!", __func__);
411         return;
412     }
413     std::string address = RawAddress::ConvertToString(info->addr.addr).GetAddress();
414     PanMessage event(BNEP_L2CAP_CONNECT_RSP_EVT);
415     PanL2capConnectionInfo l2capInfo;
416     l2capInfo.lcid = lcid;
417     l2capInfo.result = result;
418     event.dev_ = address;
419     event.l2capInfo_ = l2capInfo;
420     PanService::GetService()->PostEvent(event);
421 }
422 
BnepRecvConfigReqCallback(uint16_t lcid,uint8_t id,const L2capConfigInfo * cfg,void * ctx)423 void PanBnep::BnepRecvConfigReqCallback(
424     uint16_t lcid, uint8_t id, const L2capConfigInfo *cfg, void *ctx)
425 {
426     LOG_INFO("[PAN BNEP]%{public}s lcid:%{public}hu", __func__, lcid);
427 
428     PanService *service = PanService::GetService();
429     if (service == nullptr) {
430         LOG_ERROR("[PAN BNEP]%{public}s PanService is null!", __func__);
431         return;
432     }
433     std::string address = service->PanFindDeviceByLcid(lcid);
434     if (address.empty()) {
435         LOG_ERROR("[PAN BNEP]%{public}s can not find device!", __func__);
436         L2CIF_ConfigRsp(lcid, id, cfg, L2CAP_REJECTED, nullptr);
437         return;
438     }
439 
440     if (cfg->rfc.mode == L2CAP_ENHANCED_RETRANSMISSION_MODE) {
441         HILOGI("[PAN BNEP] for PTS BROADCAST-0/BV-01-C");
442         L2capConfigInfo l2capConfigInfo;
443         (void)memset_s(&l2capConfigInfo, sizeof(L2capConfigInfo), 0x00, sizeof(L2capConfigInfo));
444         l2capConfigInfo.mtu = BNEP_MTU_SIZE;
445         l2capConfigInfo.flushTimeout = 0xFFFF;
446         L2CIF_ConfigRsp(lcid, id, &l2capConfigInfo, L2CAP_UNACCEPTABLE_PARAMETERS, nullptr);
447         return;
448     }
449 
450     PanMessage event(BNEP_L2CAP_CONFIG_REQ_EVT);
451     PanL2capConnectionInfo l2capInfo;
452     L2capConfigInfo l2capConfigInfo;
453     if (memcpy_s(&l2capConfigInfo, sizeof(L2capConfigInfo), cfg, sizeof(L2capConfigInfo)) != EOK) {
454         LOG_ERROR("[PAN BNEP]%{public}s(): memcpy error", __FUNCTION__);
455         return;
456     }
457 
458     l2capInfo.lcid = lcid;
459     l2capInfo.id = id;
460     l2capInfo.cfg = l2capConfigInfo;
461     event.dev_ = address;
462     event.l2capInfo_ = l2capInfo;
463     service->PostEvent(event);
464 }
465 
BnepRecvConfigRspCallback(uint16_t lcid,const L2capConfigInfo * cfg,uint16_t result,void * ctx)466 void PanBnep::BnepRecvConfigRspCallback(
467     uint16_t lcid, const L2capConfigInfo *cfg, uint16_t result, void *ctx)
468 {
469     LOG_INFO("[PAN BNEP]%{public}s lcid:%{public}hu", __func__, lcid);
470 
471     PanService *service = PanService::GetService();
472     if (service == nullptr) {
473         LOG_ERROR("[PAN BNEP]%{public}s PanService is null!", __func__);
474         return;
475     }
476     std::string address = service->PanFindDeviceByLcid(lcid);
477     if (address.empty()) {
478         LOG_ERROR("[PAN BNEP]%{public}s can not find device!", __func__);
479         return;
480     }
481 
482     PanMessage event(BNEP_L2CAP_CONFIG_RSP_EVT);
483     PanL2capConnectionInfo l2capInfo;
484     L2capConfigInfo l2capConfigInfo;
485     if (memcpy_s(&l2capConfigInfo, sizeof(L2capConfigInfo), cfg, sizeof(L2capConfigInfo)) != EOK) {
486         LOG_ERROR("[PAN BNEP]%{public}s(): memcpy error", __FUNCTION__);
487         return;
488     }
489 
490     l2capInfo.lcid = lcid;
491     l2capInfo.result = result;
492     l2capInfo.cfg = l2capConfigInfo;
493     event.dev_ = address;
494     event.l2capInfo_ = l2capInfo;
495     service->PostEvent(event);
496 }
497 
BnepRecvDisconnectionReqCallback(uint16_t lcid,uint8_t id,void * ctx)498 void PanBnep::BnepRecvDisconnectionReqCallback(
499     uint16_t lcid, uint8_t id, void *ctx)
500 {
501     LOG_INFO("[PAN BNEP]%{public}s lcid:%{public}hu", __func__, lcid);
502 
503     PanService *service = PanService::GetService();
504     if (service == nullptr) {
505         LOG_ERROR("[PAN BNEP]%{public}s PanService is null!", __func__);
506         return;
507     }
508     std::string address = service->PanFindDeviceByLcid(lcid);
509     if (address.empty()) {
510         LOG_ERROR("[PAN BNEP]%{public}s can not find device!", __func__);
511         return;
512     }
513 
514     PanMessage event(BNEP_L2CAP_DISCONNECT_REQ_EVT);
515     PanL2capConnectionInfo l2capInfo;
516 
517     l2capInfo.lcid = lcid;
518     l2capInfo.id = id;
519     event.dev_ = address;
520     event.l2capInfo_ = l2capInfo;
521     service->PostEvent(event);
522 }
523 
BnepRecvDisconnectionRspCallback(uint16_t lcid,void * ctx)524 void PanBnep::BnepRecvDisconnectionRspCallback(
525     uint16_t lcid, void *ctx)
526 {
527     LOG_INFO("[PAN BNEP]%{public}s lcid:%{public}hu", __func__, lcid);
528 
529     PanService *service = PanService::GetService();
530     if (service == nullptr) {
531         LOG_ERROR("[PAN BNEP]%{public}s PanService is null!", __func__);
532         return;
533     }
534     std::string address = service->PanFindDeviceByLcid(lcid);
535     if (address.empty()) {
536         LOG_ERROR("[PAN BNEP]%{public}s can not find device!", __func__);
537         return;
538     }
539 
540     PanMessage event(BNEP_L2CAP_DISCONNECT_RSP_EVT);
541     PanL2capConnectionInfo l2capInfo;
542 
543     l2capInfo.lcid = lcid;
544     event.dev_ = address;
545     event.l2capInfo_ = l2capInfo;
546     service->PostEvent(event);
547 }
548 
BnepDisconnectAbnormalCallback(uint16_t lcid,uint8_t reason,void * ctx)549 void PanBnep::BnepDisconnectAbnormalCallback(
550     uint16_t lcid, uint8_t reason, void *ctx)
551 {
552     LOG_INFO("[PAN BNEP]%{public}s lcid:%{public}hu", __func__, lcid);
553 
554     PanService *service = PanService::GetService();
555     if (service == nullptr) {
556         LOG_ERROR("[PAN BNEP]%{public}s PanService is null!", __func__);
557         return;
558     }
559     std::string address = service->PanFindDeviceByLcid(lcid);
560     if (address.empty()) {
561         LOG_ERROR("[PAN BNEP]%{public}s can not find device!", __func__);
562         return;
563     }
564 
565     PanMessage event(BNEP_L2CAP_DISCONNECT_ABNORMAL_EVT);
566     PanL2capConnectionInfo l2capInfo;
567 
568     l2capInfo.lcid = lcid;
569     l2capInfo.reason = reason;
570     event.dev_ = address;
571     event.l2capInfo_ = l2capInfo;
572     service->PostEvent(event);
573 }
574 
BnepRecvDataCallback(uint16_t lcid,Packet * pkt,void * ctx)575 void PanBnep::BnepRecvDataCallback(
576     uint16_t lcid, Packet *pkt, void *ctx)
577 {
578     PanService *service = PanService::GetService();
579     if (service == nullptr) {
580         LOG_ERROR("[PAN BNEP]%{public}s PanService is null!", __func__);
581         return;
582     }
583 
584     std::string address = PanService::GetService()->PanFindDeviceByLcid(lcid);
585     if (address.empty()) {
586         LOG_ERROR("[PAN BNEP]%{public}s can not find device!", __func__);
587         return;
588     }
589 
590     PanMessage event(BNEP_L2CAP_DATA_EVT);
591     PanL2capConnectionInfo l2capInfo;
592 
593     l2capInfo.lcid = lcid;
594     event.dev_ = address;
595     event.l2capInfo_ = l2capInfo;
596     int dataLength = static_cast<int>(PacketSize(pkt));
597     if (dataLength > 0) {
598         std::unique_ptr<uint8_t[]> buff = std::make_unique<uint8_t[]>(dataLength);
599         PacketRead(pkt, buff.get(), 0, dataLength);
600         event.data_ = std::make_shared<std::unique_ptr<uint8_t[]>>(std::move(buff));
601     }
602     event.dataLength_ = dataLength;
603     service->PostEvent(event);
604 }
605 
BnepRemoteBusyCallback(uint16_t lcid,uint8_t isBusy,void * ctx)606 void PanBnep::BnepRemoteBusyCallback(
607     uint16_t lcid, uint8_t isBusy, void *ctx)
608 {
609     LOG_INFO("[PAN BNEP]%{public}s lcid:%{public}hu", __func__, lcid);
610 
611     PanService *service = PanService::GetService();
612     if (service == nullptr) {
613         LOG_ERROR("[PAN BNEP]%{public}s PanService is null!", __func__);
614         return;
615     }
616     std::string address = service->PanFindDeviceByLcid(lcid);
617     if (address.empty()) {
618         LOG_ERROR("[PAN BNEP]%{public}s can not find device!", __func__);
619         return;
620     }
621 
622     PanMessage event(BNEP_L2CAP_REMOTE_BUSY_EVT);
623     PanL2capConnectionInfo l2capInfo;
624 
625     l2capInfo.lcid = lcid;
626     l2capInfo.isBusy = isBusy;
627     event.dev_ = address;
628     event.l2capInfo_ = l2capInfo;
629     service->PostEvent(event);
630 }
631 
BnepRecvConnectionReqCallbackTask(uint16_t lcid,uint8_t id,uint16_t lpsm)632 void PanBnep::BnepRecvConnectionReqCallbackTask(
633     uint16_t lcid, uint8_t id, uint16_t lpsm)
634 {
635     LOG_INFO("[PAN BNEP]%{public}s lcid:%{public}hu", __func__, lcid);
636 
637     bool isAccept = true;
638     if (state_ != BNEP_CONN_STATE_UNUSED) {
639         LOG_ERROR("[PAN BNEP]%{public}s receive control connect,but not in idle state[%{public}d]",
640             __func__, state_);
641         isAccept = false;
642     }
643     if (!isAccept) {
644         L2CIF_ConnectRsp(lcid, id, L2CAP_NO_RESOURCES_AVAILABLE, L2CAP_NO_FURTHER_INFORMATION_AVAILABLE, nullptr);
645         return;
646     }
647 
648     connFlags_ = 0;
649     SendGapRequestSecurity(true, lcid, id);
650 }
651 
SendGapRequestSecurity(bool isIncoming,uint16_t lcid,uint8_t id)652 int PanBnep::SendGapRequestSecurity(bool isIncoming, uint16_t lcid, uint8_t id)
653 {
654     BtAddr btAddr;
655     RawAddress(address_).ConvertToUint8(btAddr.addr);
656     btAddr.type = BT_PUBLIC_DEVICE_ADDRESS;
657 
658     GapRequestSecurityParam param;
659     GapServiceSecurityInfo securityInfo;
660     param.context = &address_;
661     if (isIncoming) {
662         securityInfo = {INCOMING, PAN_BNEP, SEC_PROTOCOL_L2CAP,
663                 { .l2capPsm = BT_BNEP_PSM }};
664         param.callback = BnepIndSecurityCheckDeviceConnectCallback;
665         param.info = securityInfo;
666         if (GAPIF_RequestSecurityAsync((const BtAddr *)&btAddr, &param)) {
667             LOG_ERROR("[PAN BNEP] %{public}s:GAPIF_RequestSecurityAsync INCOMING failed.", __func__);
668             return RET_BAD_STATUS;
669         }
670         lcid_ = lcid;
671         id_ = id;
672         state_ = BNEP_CONN_STATE_SECURITY;
673     } else {
674         securityInfo = {OUTGOING, PAN_BNEP, SEC_PROTOCOL_L2CAP,
675             { .l2capPsm = BT_BNEP_PSM }};
676         param.callback = BnepSecurityCheckCallback;
677         param.info = securityInfo;
678         if (GAPIF_RequestSecurityAsync((const BtAddr *)&btAddr, &param)) {
679             LOG_ERROR("[PAN BNEP] %{public}s:GAPIF_RequestSecurityAsync OUTGOING failed.", __func__);
680             PanMessage event(PAN_INT_CLOSE_EVT);
681             event.dev_ = address_;
682             PanService::GetService()->PostEvent(event);
683             return RET_BAD_STATUS;
684         }
685     }
686     return BT_SUCCESS;
687 }
688 
BnepRecvConnectionRspCallbackTask(uint16_t lcid,int result)689 void PanBnep::BnepRecvConnectionRspCallbackTask(
690     uint16_t lcid, int result)
691 {
692     LOG_INFO("[PAN BNEP]%{public}s lcid:%{public}hu", __func__, lcid);
693 
694     if (result == L2CAP_CONNECTION_PENDING) {
695         LOG_INFO("[PAN BNEP]%{public}s: Connect RSP result is pending, do nothing!", __func__);
696         return;
697     }
698     if (result != BT_SUCCESS) {
699         LOG_ERROR("[PAN BNEP]%{public}s result[%{public}d]", __func__, result);
700         if (lcid == lcid_) {
701             lcid_ = 0;
702         }
703 
704         Disconnect();
705         return;
706     }
707 
708     state_ = BNEP_CONN_STATE_CONFIG;
709 
710     L2capConfigInfo l2capConfigInfo;
711     (void)memset_s(&l2capConfigInfo, sizeof(L2capConfigInfo), 0x00, sizeof(L2capConfigInfo));
712     l2capConfigInfo.mtu = BNEP_MTU_SIZE;
713     l2capConfigInfo.flushTimeout = 0xFFFF;
714     if (L2CIF_ConfigReq(lcid, &l2capConfigInfo, nullptr)) {
715         LOG_ERROR("[PAN BNEP] %{public}s:L2CIF_ConfigReq failed.", __func__);
716     }
717 }
718 
BnepRecvConfigReqCallbackTask(uint16_t lcid,uint8_t id,L2capConfigInfo cfg)719 void PanBnep::BnepRecvConfigReqCallbackTask(
720     uint16_t lcid, uint8_t id, L2capConfigInfo cfg)
721 {
722     LOG_INFO("[PAN BNEP]%{public}s lcid:%{public}hu", __func__, lcid);
723 
724     BtAddr btAddr;
725     RawAddress(address_).ConvertToUint8(btAddr.addr);
726     btAddr.type = BT_PUBLIC_DEVICE_ADDRESS;
727 
728     if (L2CIF_ConfigRsp(lcid, id, &cfg, L2CAP_SUCCESS, nullptr)) {
729         LOG_ERROR("[PAN BNEP] %{public}s:L2CIF_ConfigRsp failed.", __func__);
730     }
731     connFlags_ |= BNEP_CONN_FLAGS_HIS_CFG_DONE;
732     if ((connFlags_ & BNEP_CONN_FLAGS_ALL_CONFIGURED) == BNEP_CONN_FLAGS_ALL_CONFIGURED) {
733         state_ = BNEP_CONN_STATE_SETUP_CONNECTION;
734     }
735 }
736 
BnepRecvConfigRspCallbackTask(uint16_t lcid,const L2capConfigInfo cfg,uint16_t result)737 void PanBnep::BnepRecvConfigRspCallbackTask(
738     uint16_t lcid, const L2capConfigInfo cfg, uint16_t result)
739 {
740     LOG_INFO("[PAN BNEP]%{public}s lcid:%{public}hu", __func__, lcid);
741 
742     BtAddr btAddr;
743     RawAddress(address_).ConvertToUint8(btAddr.addr);
744     btAddr.type = BT_PUBLIC_DEVICE_ADDRESS;
745 
746     if (result != L2CAP_SUCCESS) {
747         LOG_ERROR("[PAN BNEP]%{public}s result[%{public}d]", __func__, result);
748         Disconnect();
749         return;
750     }
751     connFlags_ |= BNEP_CONN_FLAGS_MY_CFG_DONE;
752     if ((connFlags_ & BNEP_CONN_FLAGS_ALL_CONFIGURED) == BNEP_CONN_FLAGS_ALL_CONFIGURED) {
753         state_ = BNEP_CONN_STATE_SETUP_CONNECTION;
754     }
755 }
756 
BnepRecvDisconnectionReqCallbackTask(uint16_t lcid,uint8_t id)757 void PanBnep::BnepRecvDisconnectionReqCallbackTask(
758     uint16_t lcid, uint8_t id)
759 {
760     LOG_INFO("[PAN BNEP]%{public}s lcid:%{public}hu", __func__, lcid);
761 
762     L2CIF_DisconnectionRsp(lcid, id, nullptr);
763     state_ = BNEP_CONN_STATE_DISCONNECTING;
764 
765     if (lcid == lcid_) {
766         lcid_ = 0;
767     }
768 
769     if (lcid_ == 0) {
770         state_ = BNEP_CONN_STATE_UNUSED;
771         PanMessage event(PAN_INT_CLOSE_EVT);
772         event.dev_ = address_;
773         PanService::GetService()->PostEvent(event);
774     }
775 }
776 
BnepRecvDisconnectionRspCallbackTask(uint16_t lcid)777 void PanBnep::BnepRecvDisconnectionRspCallbackTask(uint16_t lcid)
778 {
779     LOG_INFO("[PAN BNEP]%{public}s lcid:%{public}hu", __func__, lcid);
780 
781     if (lcid == lcid_) {
782         lcid_ = 0;
783     }
784 
785     if (lcid_ == 0) {
786         state_ = BNEP_CONN_STATE_UNUSED;
787         PanMessage event(PAN_INT_CLOSE_EVT);
788         event.dev_ = address_;
789         PanService::GetService()->PostEvent(event);
790     }
791 }
792 
BnepDisconnectAbnormalCallbackTask(uint16_t lcid,uint8_t reason)793 void PanBnep::BnepDisconnectAbnormalCallbackTask(
794     uint16_t lcid, uint8_t reason)
795 {
796     LOG_INFO("[PAN BNEP]%{public}s lcid:%{public}hu, reason=%{public}d", __func__, lcid, reason);
797 
798     if (lcid == lcid_) {
799         lcid_ = 0;
800     }
801 
802     if (lcid_ == 0) {
803         state_ = BNEP_CONN_STATE_UNUSED;
804         PanMessage event(PAN_INT_CLOSE_EVT);
805         event.dev_ = address_;
806         PanService::GetService()->PostEvent(event);
807     } else {
808         Disconnect();
809     }
810 }
811 
BnepRecvDataCallbackTask(uint16_t lcid,uint8_t * data,int dataLength)812 void PanBnep::BnepRecvDataCallbackTask(uint16_t lcid, uint8_t *data, int dataLength)
813 {
814     if ((data == nullptr) || (dataLength < 1)) {
815         LOG_ERROR("[PAN BNEP]%{public}s data is null!", __func__);
816         return;
817     }
818     int offset = 0, ret = 0;
819 
820     bool hasExtension = ((data[offset] & 0x80) != 0);
821     uint8_t type = data[offset++] & 0x7f;
822     EthernetHeader ethernetHeader;
823     bool isEthernetData = false;
824 
825     switch (type) {
826         case BNEP_CONTROL:
827             ret = ProcessBnepControlData(data + offset, dataLength - offset, false);
828             break;
829         case BNEP_GENERAL_ETHERNET:
830         case BNEP_COMPRESSED_ETHERNET:
831         case BNEP_COMPRESSED_ETHERNET_SRC_ONLY:
832         case BNEP_COMPRESSED_ETHERNET_DEST_ONLY:
833             ret = ProcessBnepEthernetPacketHeader(type, ethernetHeader, data + offset, dataLength - offset);
834             isEthernetData = true;
835             break;
836         default:
837             LOG_ERROR("[PAN BNEP]%{public}s unknow bnep data type:%{public}d", __func__, type);
838             break;
839     }
840     if (ret == 0) {
841         return;
842     }
843     offset += ret;
844 
845     if (hasExtension) {
846         ret = ProcessBnepExtensionData(data + offset, dataLength - offset);
847         if (ret == 0) {
848             return;
849         }
850         offset += ret;
851     }
852 
853     if (isEthernetData) {
854         SendBnepDataEvent(ethernetHeader, dataLength, offset, data);
855     }
856 }
857 
SendBnepDataEvent(EthernetHeader ethernetHeader,int dataLength,int offset,uint8_t * data)858 void PanBnep::SendBnepDataEvent(EthernetHeader ethernetHeader, int dataLength, int offset, uint8_t *data)
859 {
860     PanMessage event(PAN_INT_DATA_EVT);
861     event.dev_ = address_;
862     event.ethernetHeader_ = ethernetHeader;
863     if ((dataLength - offset) > 0) {
864         event.dataLength_ = dataLength - offset;
865         std::unique_ptr<uint8_t[]> buff = std::make_unique<uint8_t[]>(event.dataLength_);
866         if (memcpy_s(buff.get(), event.dataLength_, data + offset, event.dataLength_) != EOK) {
867             LOG_ERROR("[PAN BNEP]%{public}s(): memcpy error", __FUNCTION__);
868             return;
869         }
870         event.data_ = std::make_shared<std::unique_ptr<uint8_t[]>>(std::move(buff));
871     }
872     PanService::GetService()->PostEvent(event);
873 }
874 
BnepRemoteBusyCallbackTask(uint16_t lcid,uint8_t isBusy)875 void PanBnep::BnepRemoteBusyCallbackTask(
876     uint16_t lcid, uint8_t isBusy)
877 {
878     LOG_INFO("[PAN BNEP]%{public}s lcid:%{public}hu", __func__, lcid);
879     isBusy_ = ((isBusy != 0) ? true : false);
880     while (!isBusy && !waitingSendDataList_.empty()) {
881         Packet *packet = waitingSendDataList_.front();
882         waitingSendDataList_.pop();
883         L2CIF_SendData(lcid_, packet, nullptr);
884         PacketFree(packet);
885     }
886     PanService::GetService()->ReceiveRemoteBusy(isBusy_);
887 }
888 
ProcessBnepExtensionData(uint8_t * data,int dataLength)889 int PanBnep::ProcessBnepExtensionData(uint8_t *data, int dataLength)
890 {
891     int offset = 0;
892     int ret = 0;
893     if ((data == nullptr) || (dataLength < 1)) {
894         LOG_ERROR("[PAN BNEP]%{public}s data is null!", __func__);
895         return 0;
896     }
897     bool hasNextExtension = ((data[offset] & 0x80) != 0);
898     uint8_t extensionType = data[offset++] & 0x7f;
899     if (extensionType != BNEP_EXTENTION_CONTROL) {
900         LOG_ERROR("[PAN BNEP]%{public}s unknow extension control type! extensionType=%{public}d",
901             __func__, extensionType);
902         return 0;
903     }
904     ret = ProcessBnepControlData(data + offset, dataLength - offset, true);
905     if (ret == 0) {
906         return 0;
907     }
908     offset += ret;
909     if (hasNextExtension) {
910         ret = ProcessBnepExtensionData(data + offset, dataLength - offset);
911         if (ret == 0) {
912             return 0;
913         }
914         offset += ret;
915     }
916     return offset;
917 }
918 
ProcessBnepControlData(uint8_t * data,int dataLength,bool isExtension)919 int PanBnep::ProcessBnepControlData(uint8_t *data, int dataLength, bool isExtension)
920 {
921     int offset = 0;
922     int ret = 0;
923     uint8_t extensionLength = 0;
924     if ((data == nullptr) || (dataLength < 1)) {
925         LOG_ERROR("[PAN BNEP]%{public}s data is null!", __func__);
926         return 0;
927     }
928     if (isExtension) {
929         extensionLength = data[offset++];
930         if (dataLength - offset < 1) {
931             LOG_ERROR("[PAN BNEP]%{public}s extension data length is error!", __func__);
932             return 0;
933         }
934     }
935     uint8_t controlType = data[offset++];
936     switch (controlType) {
937         case BNEP_CONTROL_COMMAND_NOT_UNDERSTOOD:
938             ret = ProcessBnepControlCommandNotUnderstood(data + offset, dataLength - offset);
939             break;
940         case BNEP_SETUP_CONNECTION_REQUEST_MSG:
941             ret = ProcessBnepSetupConnectionRequest(data + offset, dataLength - offset);
942             break;
943         case BNEP_SETUP_CONNECTION_RESPONSE_MSG:
944             ret = ProcessBnepSetupConnectionResponse(data + offset, dataLength - offset);
945             break;
946         case BNEP_FILTER_NET_TYPE_SET_MSG:
947             ret = ProcessBnepFilterNetTypeSet(data + offset, dataLength - offset);
948             break;
949         case BNEP_FILTER_NET_TYPE_RESPONSE_MSG:
950             ret = ProcessBnepFilterNetTypeResponse(data + offset, dataLength - offset);
951             break;
952         case BNEP_FILTER_MULTI_ADDR_SET_MSG:
953             ret = ProcessBnepFilterMultiAddrSet(data + offset, dataLength - offset);
954             break;
955         case BNEP_FILTER_MULTI_ADDR_RESPONSE_MSG:
956             ret = ProcessBnepFilterMultiAddrResponse(data + offset, dataLength - offset);
957             break;
958         default:
959             LOG_ERROR("[PAN BNEP]%{public}s unknow control type ", __func__);
960             BnepSendControlCommandNotUnderstood(controlType);
961             if ((dataLength - offset) >= extensionLength) {
962                 ret = extensionLength;
963             }
964             break;
965     }
966     if (ret == 0) {
967         return 0;
968     }
969     return (offset + ret);
970 }
971 
ProcessBnepControlCommandNotUnderstood(uint8_t * data,int dataLength)972 int PanBnep::ProcessBnepControlCommandNotUnderstood(uint8_t *data, int dataLength)
973 {
974     int offset = 0;
975     if ((data == nullptr) || (dataLength < 1)) {
976         LOG_ERROR("[PAN BNEP]%{public}s data is null!", __func__);
977         return 0;
978     }
979     uint8_t controlCode = data[offset++];
980     LOG_ERROR("[PAN BNEP]%{public}s receive BNEP_CONTROL_COMMAND_NOT_UNDERSTOOD code=%{public}d",
981         __func__, controlCode);
982     return offset;
983 }
984 
ProcessBnepSetupConnectionRequest(uint8_t * data,int dataLength)985 int PanBnep::ProcessBnepSetupConnectionRequest(uint8_t *data, int dataLength)
986 {
987     int offset = 0;
988     Uuid localUuid;
989     Uuid remoteUuid;
990     if ((data == nullptr) || (dataLength < 1)) {
991         LOG_ERROR("[PAN BNEP]%{public}s data is null!", __func__);
992         return 0;
993     }
994     uint8_t uuidType = data[offset++];
995     if ((dataLength - offset) < (uuidType + uuidType)) {
996         LOG_ERROR("[PAN BNEP]%{public}s data length is error!", __func__);
997         return 0;
998     }
999     if (uuidType == Uuid::UUID16_BYTES_TYPE) {
1000         uint16_t uuid = be16toh(*reinterpret_cast<uint16_t *>(data + offset));
1001         offset += uuidType;
1002         localUuid = Uuid::ConvertFrom16Bits(uuid);
1003         uuid = be16toh(*reinterpret_cast<uint16_t *>(data + offset));
1004         offset += uuidType;
1005         remoteUuid = Uuid::ConvertFrom16Bits(uuid);
1006     } else if (uuidType == Uuid::UUID32_BYTES_TYPE) {
1007         uint32_t uuid = be32toh(*reinterpret_cast<uint32_t *>(data + offset));
1008         offset += uuidType;
1009         localUuid = Uuid::ConvertFrom32Bits(uuid);
1010         uuid = be32toh(*reinterpret_cast<uint32_t *>(data + offset));
1011         offset += uuidType;
1012         remoteUuid = Uuid::ConvertFrom32Bits(uuid);
1013     } else if (uuidType == Uuid::UUID128_BYTES_TYPE) {
1014         localUuid = Uuid::ConvertFromBytesLE(data + offset);
1015         offset += uuidType;
1016         remoteUuid = Uuid::ConvertFromBytesLE(data + offset);
1017         offset += uuidType;
1018     } else {
1019         LOG_ERROR("[PAN BNEP]%{public}s error uuid type(%{public}d).", __func__, uuidType);
1020         BnepSendSetupConnectionResponse(BNEP_SETUP_FAILED_INVALID_UUID_SIZE);
1021         return offset;
1022     }
1023     CheckRoleUuid(localUuid, remoteUuid);
1024 
1025     return offset;
1026 }
1027 
ProcessBnepSetupConnectionResponse(uint8_t * data,int dataLength)1028 int PanBnep::ProcessBnepSetupConnectionResponse(uint8_t *data, int dataLength)
1029 {
1030     int offset = 0;
1031     if ((data == nullptr) || (dataLength < BNEP_UINT16_SIZE)) {
1032         LOG_ERROR("[PAN BNEP]%{public}s data is null!", __func__);
1033         return 0;
1034     }
1035     uint16_t responseMessage = be16toh(*reinterpret_cast<uint16_t *>(data + offset));
1036     offset += BNEP_UINT16_SIZE;
1037     LOG_ERROR("[PAN BNEP]%{public}s we are not origination! responseMessage=%{public}d",
1038         __func__, responseMessage);
1039     return offset;
1040 }
1041 
ProcessBnepFilterNetTypeSet(uint8_t * data,int dataLength)1042 int PanBnep::ProcessBnepFilterNetTypeSet(uint8_t *data, int dataLength)
1043 {
1044     int offset = 0;
1045     int ret = 0;
1046     uint16_t filterNum = 0;
1047     uint16_t responseMessage = BNEP_FILTER_SUCCESSFULL;
1048     if ((data == nullptr) || (dataLength < BNEP_UINT16_SIZE)) {
1049         LOG_ERROR("[PAN BNEP]%{public}s data is null!", __func__);
1050         return 0;
1051     }
1052     uint16_t listLength = be16toh(*reinterpret_cast<uint16_t *>(data + offset));
1053     offset += BNEP_UINT16_SIZE;
1054     ret = offset + listLength;
1055     if ((dataLength - offset) < listLength) {
1056         LOG_ERROR("[PAN BNEP]%{public}s data length is error!", __func__);
1057         return 0;
1058     }
1059     if ((listLength % BNEP_PROTOCOL_FILTER_RANGE_LENGTH) != 0) {
1060         LOG_ERROR("[PAN BNEP]%{public}s filter length is error!", __func__);
1061         responseMessage = BNEP_FILTER_FAILED_INVALID_NET_TYPE_RANGE;
1062     } else {
1063         filterNum = listLength / BNEP_PROTOCOL_FILTER_RANGE_LENGTH;
1064         if (filterNum > BNEP_MAX_PROTOCOL_FILTER) {
1065             responseMessage = BNEP_FILTER_FAILED_TOO_MANY_FILTER;
1066         }
1067     }
1068     if (responseMessage != BNEP_FILTER_SUCCESSFULL) {
1069         BnepSendFilterNetTypeResponse(responseMessage);
1070         return ret;
1071     }
1072     std::vector<BnepProtocolFilterRange> tempFilters_;
1073     for (uint16_t i = 0; i < filterNum; i++) {
1074         BnepProtocolFilterRange range;
1075         range.start = be16toh(*reinterpret_cast<uint16_t *>(data + offset));
1076         range.end = be16toh(*reinterpret_cast<uint16_t *>(data + offset + BNEP_UINT16_SIZE));
1077         if (range.start > range.end) {
1078             LOG_ERROR("[PAN BNEP]%{public}s range.start > range.end!", __func__);
1079             BnepSendFilterNetTypeResponse(BNEP_FILTER_FAILED_INVALID_NET_TYPE_RANGE);
1080             return ret;
1081         }
1082         tempFilters_.push_back(range);
1083         offset += BNEP_PROTOCOL_FILTER_RANGE_LENGTH;
1084     }
1085     protocolFilterList_ = tempFilters_;
1086     BnepSendFilterNetTypeResponse(responseMessage);
1087     return ret;
1088 }
1089 
ProcessBnepFilterNetTypeResponse(uint8_t * data,int dataLength)1090 int PanBnep::ProcessBnepFilterNetTypeResponse(uint8_t *data, int dataLength)
1091 {
1092     int offset = 0;
1093     if ((data == nullptr) || (dataLength < BNEP_UINT16_SIZE)) {
1094         LOG_ERROR("[PAN BNEP]%{public}s data is null!", __func__);
1095         return 0;
1096     }
1097     uint16_t responseMessage = be16toh(*reinterpret_cast<uint16_t *>(data + offset));
1098     offset += BNEP_UINT16_SIZE;
1099     LOG_ERROR("[PAN BNEP]%{public}s we are not set filter! responseMessage=%{public}d",
1100         __func__, responseMessage);
1101     return offset;
1102 }
1103 
ProcessBnepFilterMultiAddrSet(uint8_t * data,int dataLength)1104 int PanBnep::ProcessBnepFilterMultiAddrSet(uint8_t *data, int dataLength)
1105 {
1106     int offset = 0;
1107     int ret = 0;
1108     int filterNum = 0;
1109     uint16_t responseMessage = BNEP_FILTER_SUCCESSFULL;
1110     if ((data == nullptr) || (dataLength < BNEP_UINT16_SIZE)) {
1111         LOG_ERROR("[PAN BNEP]%{public}s data is null!", __func__);
1112         return 0;
1113     }
1114     uint16_t listLength = be16toh(*reinterpret_cast<uint16_t *>(data + offset));
1115     offset += BNEP_UINT16_SIZE;
1116     ret = offset + listLength;
1117     if ((dataLength - offset) < listLength) {
1118         LOG_ERROR("[PAN BNEP]%{public}s data length is error!", __func__);
1119         return 0;
1120     }
1121     filterNum = listLength / BNEP_MULTYCAST_FILTER_RANGE_LENGTH;
1122     if ((listLength % BNEP_MULTYCAST_FILTER_RANGE_LENGTH) != 0) {
1123         LOG_ERROR("[PAN BNEP]%{public}s filter length is error!", __func__);
1124         responseMessage = BNEP_FILTER_FAILED_INVALID_NET_TYPE_RANGE;
1125     } else if (filterNum > BNEP_MAX_MULTYCAST_FILTER) {
1126         responseMessage = BNEP_FILTER_FAILED_TOO_MANY_FILTER;
1127     } else {
1128         std::vector<BnepMultycastFilterRange> tempFilters_;
1129         for (int i = 0; i < filterNum; i++) {
1130             BnepMultycastFilterRange range;
1131             if (memcpy_s(range.start, BT_ADDRESS_LENGTH, data + offset, BT_ADDRESS_LENGTH) != EOK) {
1132                 LOG_ERROR("[PAN BNEP]%{public}s(): memcpy range start error", __FUNCTION__);
1133                 BnepSendFilterMultiAddrResponse(BNEP_FILTER_FAILED_INVALID_NET_TYPE_RANGE);
1134                 return ret;
1135             }
1136             offset += BT_ADDRESS_LENGTH;
1137             if (memcpy_s(range.end, BT_ADDRESS_LENGTH, data + offset, BT_ADDRESS_LENGTH) != EOK) {
1138                 LOG_ERROR("[PAN BNEP]%{public}s(): memcpy range end error", __FUNCTION__);
1139                 BnepSendFilterMultiAddrResponse(BNEP_FILTER_FAILED_INVALID_NET_TYPE_RANGE);
1140                 return ret;
1141             }
1142             offset += BT_ADDRESS_LENGTH;
1143             if (memcmp(range.start, range.end, BT_ADDRESS_LENGTH) > 0) {
1144                 LOG_ERROR("[PAN BNEP]%{public}s range.start > range.end!", __func__);
1145                 BnepSendFilterMultiAddrResponse(BNEP_FILTER_FAILED_INVALID_NET_TYPE_RANGE);
1146                 return ret;
1147             }
1148             tempFilters_.push_back(range);
1149         }
1150         multycastFilterList_ = tempFilters_;
1151     }
1152     BnepSendFilterMultiAddrResponse(responseMessage);
1153     return ret;
1154 }
1155 
ProcessBnepFilterMultiAddrResponse(uint8_t * data,int dataLength)1156 int PanBnep::ProcessBnepFilterMultiAddrResponse(uint8_t *data, int dataLength)
1157 {
1158     int offset = 0;
1159     if ((data == nullptr) || (dataLength < BNEP_UINT16_SIZE)) {
1160         LOG_ERROR("[PAN BNEP]%{public}s data is null!", __func__);
1161         return 0;
1162     }
1163     uint16_t responseMessage = be16toh(*reinterpret_cast<uint16_t *>(data + offset));
1164     offset += BNEP_UINT16_SIZE;
1165     LOG_ERROR("[PAN BNEP]%{public}s we are not set filter! responseMessage=%{public}d",
1166         __func__, responseMessage);
1167     return offset;
1168 }
1169 
CheckRoleUuid(Uuid localUuid,Uuid remoteUuid)1170 void PanBnep::CheckRoleUuid(Uuid localUuid, Uuid remoteUuid)
1171 {
1172     if (remoteUuid.GetUuidType() != Uuid::UUID16_BYTES_TYPE) {
1173         BnepSendSetupConnectionResponse(BNEP_SETUP_FAILED_INVALID_SRC_UUID);
1174     } else if (localUuid.GetUuidType() != Uuid::UUID16_BYTES_TYPE) {
1175         BnepSendSetupConnectionResponse(BNEP_SETUP_FAILED_INVALID_DEST_UUID);
1176     } else if ((remoteUuid.ConvertTo16Bits() != BNEP_UUID_PANU) ||
1177         (localUuid.ConvertTo16Bits() != BNEP_UUID_NAP)) {
1178         BnepSendSetupConnectionResponse(BNEP_SETUP_FAILED_CONN_NOT_ALLOWED);
1179         LOG_ERROR("[PAN BNEP]%{public}s error role uuid remote(%{public}x), local(%{public}x).", __func__,
1180             remoteUuid.ConvertTo16Bits(), localUuid.ConvertTo16Bits());
1181     } else {
1182         BnepSendSetupConnectionResponse(BNEP_SETUP_SUCCESSFULL);
1183         if (state_ == BNEP_CONN_STATE_SETUP_CONNECTION) {
1184             state_ = BNEP_CONN_STATE_CONNECTED;
1185             PanMessage event(PAN_INT_OPEN_EVT);
1186             event.dev_ = address_;
1187             PanService::GetService()->PostEvent(event);
1188         }
1189     }
1190 }
1191 
BnepSendControlCommandNotUnderstood(uint8_t controlCommand)1192 void PanBnep::BnepSendControlCommandNotUnderstood(uint8_t controlCommand)
1193 {
1194     Packet *packet = nullptr;
1195     uint8_t *buf = nullptr;
1196     uint8_t offset = 0;
1197     uint8_t packetLength = BNEP_CONTROL_COMMAND_NOT_UNDERSTOOD_LENGTH;
1198 
1199     packet = PacketMalloc(packetLength, 0, 0);
1200     buf = (uint8_t *)BufferPtr(PacketHead(packet));
1201     buf[offset] = BNEP_CONTROL;
1202     offset++;
1203     buf[offset] = BNEP_CONTROL_COMMAND_NOT_UNDERSTOOD;
1204     offset++;
1205     buf[offset] = controlCommand;
1206 
1207     L2CIF_SendData(lcid_, packet, nullptr);
1208     LOG_DEBUG("[PAN BNEP] %{public}s send control command not understood ", __FUNCTION__);
1209     PacketFree(packet);
1210     packet = nullptr;
1211 }
1212 
BnepSendSetupConnectionResponse(uint16_t responseMessage)1213 void PanBnep::BnepSendSetupConnectionResponse(uint16_t responseMessage)
1214 {
1215     Packet *packet = nullptr;
1216     uint8_t *buf = nullptr;
1217     uint8_t offset = 0;
1218     uint8_t packetLength = BNEP_CONTROL_RESPONSE_LENGTH;
1219 
1220     packet = PacketMalloc(packetLength, 0, 0);
1221     buf = (uint8_t *)BufferPtr(PacketHead(packet));
1222     buf[offset] = BNEP_CONTROL;
1223     offset++;
1224     buf[offset] = BNEP_SETUP_CONNECTION_RESPONSE_MSG;
1225     offset++;
1226     *(reinterpret_cast<uint16_t *>(buf + offset)) = htobe16(responseMessage);
1227 
1228     L2CIF_SendData(lcid_, packet, nullptr);
1229     LOG_DEBUG("[PAN BNEP] %{public}s send bnep setup connection response ", __FUNCTION__);
1230     PacketFree(packet);
1231     packet = nullptr;
1232 }
1233 
BnepSendFilterNetTypeResponse(uint16_t responseMessage)1234 void PanBnep::BnepSendFilterNetTypeResponse(uint16_t responseMessage)
1235 {
1236     Packet *packet = nullptr;
1237     uint8_t *buf = nullptr;
1238     uint8_t offset = 0;
1239     uint8_t packetLength = BNEP_CONTROL_RESPONSE_LENGTH;
1240 
1241     packet = PacketMalloc(packetLength, 0, 0);
1242     buf = (uint8_t *)BufferPtr(PacketHead(packet));
1243     buf[offset] = BNEP_CONTROL;
1244     offset++;
1245     buf[offset] = BNEP_FILTER_NET_TYPE_RESPONSE_MSG;
1246     offset++;
1247     *(reinterpret_cast<uint16_t *>(buf + offset)) = htobe16(responseMessage);
1248 
1249     L2CIF_SendData(lcid_, packet, nullptr);
1250     LOG_DEBUG("[PAN BNEP] %{public}s send BNEP_FILTER_NET_TYPE_RESPONSE_MSG ", __FUNCTION__);
1251     PacketFree(packet);
1252     packet = nullptr;
1253 }
1254 
BnepSendFilterMultiAddrResponse(uint16_t responseMessage)1255 void PanBnep::BnepSendFilterMultiAddrResponse(uint16_t responseMessage)
1256 {
1257     Packet *packet = nullptr;
1258     uint8_t *buf = nullptr;
1259     uint8_t offset = 0;
1260     uint8_t packetLength = BNEP_CONTROL_RESPONSE_LENGTH;
1261 
1262     packet = PacketMalloc(packetLength, 0, 0);
1263     buf = (uint8_t *)BufferPtr(PacketHead(packet));
1264     buf[offset] = BNEP_CONTROL;
1265     offset++;
1266     buf[offset] = BNEP_FILTER_MULTI_ADDR_RESPONSE_MSG;
1267     offset++;
1268     *(reinterpret_cast<uint16_t *>(buf + offset)) = htobe16(responseMessage);
1269 
1270     L2CIF_SendData(lcid_, packet, nullptr);
1271     LOG_DEBUG("[PAN BNEP] %{public}s send BNEP_FILTER_MULTI_ADDR_RESPONSE_MSG ", __FUNCTION__);
1272     PacketFree(packet);
1273     packet = nullptr;
1274 }
1275 
ProcessBnepEthernetPacketHeader(uint8_t type,EthernetHeader & ethernetHeader,uint8_t * data,int dataLength)1276 int PanBnep::ProcessBnepEthernetPacketHeader(uint8_t type, EthernetHeader &ethernetHeader,
1277     uint8_t *data, int dataLength)
1278 {
1279     if ((data == nullptr) || (dataLength < 1)) {
1280         LOG_ERROR("[PAN BNEP]%{public}s data is null!", __func__);
1281         return 0;
1282     }
1283     int offset = 0;
1284     if ((type == BNEP_COMPRESSED_ETHERNET_DEST_ONLY) || (type == BNEP_GENERAL_ETHERNET)) {
1285         if (dataLength < (BT_ADDRESS_LENGTH + offset)) {
1286             LOG_ERROR("[PAN BNEP]%{public}s copy destination Address,data length is error!", __func__);
1287             return 0;
1288         }
1289         if (memcpy_s(ethernetHeader.destAddr, BT_ADDRESS_LENGTH, data + offset,
1290             BT_ADDRESS_LENGTH) != EOK) {
1291             LOG_ERROR("[PAN BNEP]%{public}s(): memcpy destination Address error", __FUNCTION__);
1292             return 0;
1293         }
1294         offset += BT_ADDRESS_LENGTH;
1295     } else {
1296         uint8_t bluetoothDestAddr[BT_ADDRESS_LENGTH];
1297         RawAddress(PanService::GetLocalAddress()).ConvertToUint8(bluetoothDestAddr);
1298         PanService::ReverseAddress(bluetoothDestAddr, ethernetHeader.destAddr);
1299         if (ethernetHeader.destAddr[0] & 0x01) {
1300             LOG_DEBUG("[PAN BNEP]%{public}s():ethernetHeader.destAddr use unicast MAC address", __FUNCTION__);
1301             ethernetHeader.destAddr[0] &= ~0x01;
1302         }
1303     }
1304 
1305     if ((type == BNEP_COMPRESSED_ETHERNET_SRC_ONLY) || (type == BNEP_GENERAL_ETHERNET)) {
1306         if (dataLength < (BT_ADDRESS_LENGTH + offset)) {
1307             LOG_ERROR("[PAN BNEP]%{public}s copy source Address,data length is error!", __func__);
1308             return 0;
1309         }
1310         if (memcpy_s(ethernetHeader.srcAddr, BT_ADDRESS_LENGTH, data + offset,
1311             BT_ADDRESS_LENGTH) != EOK) {
1312             LOG_ERROR("[PAN BNEP]%{public}s(): memcpy source Address error", __FUNCTION__);
1313             return 0;
1314         }
1315         offset += BT_ADDRESS_LENGTH;
1316     } else {
1317         uint8_t bluetoothSrcAddr[BT_ADDRESS_LENGTH];
1318         RawAddress(address_).ConvertToUint8(bluetoothSrcAddr);
1319         PanService::ReverseAddress(bluetoothSrcAddr, ethernetHeader.srcAddr);
1320     }
1321 
1322     if (dataLength < (BNEP_UINT16_SIZE + offset)) {
1323         LOG_ERROR("[PAN BNEP]%{public}s get protocol,data length is error!", __func__);
1324         return 0;
1325     }
1326     ethernetHeader.protocol = be16toh(*reinterpret_cast<uint16_t *>(data + offset));
1327     offset += BNEP_UINT16_SIZE;
1328     return offset;
1329 }
1330 
ProcessEvent(const PanMessage & event)1331 void PanBnep::ProcessEvent(const PanMessage &event)
1332 {
1333     LOG_DEBUG("[PAN BNEP]%{public}s(): event %{public}s[%{public}d]",
1334         __FUNCTION__, PanBnep::GetEventName(event.what_).c_str(), event.what_);
1335 
1336     switch (event.what_) {
1337         case BNEP_L2CAP_CONNECT_REQ_EVT:
1338             BnepRecvConnectionReqCallbackTask(event.l2capInfo_.lcid, event.l2capInfo_.id, event.l2capInfo_.lpsm);
1339             break;
1340         case BNEP_L2CAP_CONNECT_RSP_EVT:
1341             BnepRecvConnectionRspCallbackTask(
1342                 event.l2capInfo_.lcid, event.l2capInfo_.result);
1343             break;
1344         case BNEP_L2CAP_CONFIG_REQ_EVT:
1345             BnepRecvConfigReqCallbackTask(event.l2capInfo_.lcid, event.l2capInfo_.id, event.l2capInfo_.cfg);
1346             break;
1347         case BNEP_L2CAP_CONFIG_RSP_EVT:
1348             BnepRecvConfigRspCallbackTask(event.l2capInfo_.lcid, event.l2capInfo_.cfg, event.l2capInfo_.result);
1349             break;
1350         case BNEP_L2CAP_DISCONNECT_REQ_EVT:
1351             BnepRecvDisconnectionReqCallbackTask(event.l2capInfo_.lcid, event.l2capInfo_.id);
1352             break;
1353         case BNEP_L2CAP_DISCONNECT_RSP_EVT:
1354             BnepRecvDisconnectionRspCallbackTask(event.l2capInfo_.lcid);
1355             break;
1356         case BNEP_L2CAP_DISCONNECT_ABNORMAL_EVT:
1357             BnepDisconnectAbnormalCallbackTask(event.l2capInfo_.lcid, event.l2capInfo_.reason);
1358             break;
1359         case BNEP_L2CAP_DATA_EVT:
1360             if (event.data_ != nullptr) {
1361                 BnepRecvDataCallbackTask(event.l2capInfo_.lcid, event.data_->get(), event.dataLength_);
1362             } else {
1363                 BnepRecvDataCallbackTask(event.l2capInfo_.lcid, nullptr, 0);
1364             }
1365             break;
1366         case BNEP_L2CAP_REMOTE_BUSY_EVT:
1367             BnepRemoteBusyCallbackTask(event.l2capInfo_.lcid, event.l2capInfo_.isBusy);
1368             break;
1369         case BNEP_L2CAP_SECURITY_RESULT_EVT:
1370             BnepSecurityCheckTask(event.arg1_);
1371             break;
1372         case BNEP_L2CAP_IND_SECURITY_RESULT_EVT:
1373             BnepSecurityCheckDeviceConnectTask(event.arg1_);
1374             break;
1375         default:
1376             break;
1377     }
1378 }
1379 
GetEventName(int what)1380 std::string PanBnep::GetEventName(int what)
1381 {
1382     switch (what) {
1383         case BNEP_L2CAP_CONNECT_REQ_EVT:
1384             return "BNEP_L2CAP_CONNECT_REQ_EVT";
1385         case BNEP_L2CAP_CONNECT_RSP_EVT:
1386             return "BNEP_L2CAP_CONNECT_RSP_EVT";
1387         case BNEP_L2CAP_CONFIG_REQ_EVT:
1388             return "BNEP_L2CAP_CONFIG_REQ_EVT";
1389         case BNEP_L2CAP_CONFIG_RSP_EVT:
1390             return "BNEP_L2CAP_CONFIG_RSP_EVT";
1391         case BNEP_L2CAP_DISCONNECT_REQ_EVT:
1392             return "BNEP_L2CAP_DISCONNECT_REQ_EVT";
1393         case BNEP_L2CAP_DISCONNECT_RSP_EVT:
1394             return "BNEP_L2CAP_DISCONNECT_RSP_EVT";
1395         case BNEP_L2CAP_DISCONNECT_ABNORMAL_EVT:
1396             return "BNEP_L2CAP_DISCONNECT_ABNORMAL_EVT";
1397         case BNEP_L2CAP_DATA_EVT:
1398             return "BNEP_L2CAP_DATA_EVT";
1399         case BNEP_L2CAP_REMOTE_BUSY_EVT:
1400             return "BNEP_L2CAP_REMOTE_BUSY_EVT";
1401         case BNEP_L2CAP_SECURITY_RESULT_EVT:
1402             return "BNEP_L2CAP_SECURITY_RESULT_EVT";
1403         case BNEP_L2CAP_IND_SECURITY_RESULT_EVT:
1404             return "BNEP_L2CAP_IND_SECURITY_RESULT_EVT";
1405         default:
1406             return "Unknown";
1407     }
1408 }
1409 }  // namespace bluetooth
1410 }  // namespace OHOS
1411