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_rfcomm.h"
17 #include "log.h"
18 #include "log_util.h"
19 #include "securec.h"
20 #include "transport_def.h"
21 
22 namespace OHOS {
23 namespace bluetooth {
24 const int SOCK_RFCOMM_EVENTS = RFCOMM_CHANNEL_EV_CONNECT_INCOMING | RFCOMM_CHANNEL_EV_CONNECT_SUCCESS |
25                                RFCOMM_CHANNEL_EV_CONNECT_FAIL | RFCOMM_CHANNEL_EV_DISCONNECTED |
26                                RFCOMM_CHANNEL_EV_DISCONNECT_SUCCESS | RFCOMM_CHANNEL_EV_DISCONNECT_FAIL |
27                                RFCOMM_CHANNEL_EV_REV_DATA | RFCOMM_CHANNEL_EV_FC_ON;
28 
RfcommTransport(const RawAddress * addr,uint8_t scn,uint16_t mtu,DataTransportObserver & observer,utility::Dispatcher & dispatcher)29 RfcommTransport::RfcommTransport(
30     const RawAddress *addr, uint8_t scn, uint16_t mtu, DataTransportObserver &observer, utility::Dispatcher &dispatcher)
31     : scn_(scn), mtu_(mtu), observer_(observer), dispatcher_(dispatcher)
32 {
33     if (addr != nullptr) {
34         remoteAddr_ = *addr;
35     }
36 }
37 
~RfcommTransport()38 RfcommTransport::~RfcommTransport()
39 {}
40 
Connect()41 int RfcommTransport::Connect()
42 {
43     HILOGI("[RfcommTransport]enter");
44     BtAddr btAddr;
45     remoteAddr_.ConvertToUint8(btAddr.addr);
46     btAddr.type = BT_PUBLIC_DEVICE_ADDRESS;
47 
48     RfcommConnectReqInfo reqInfo;
49     reqInfo.mtu = mtu_;
50     reqInfo.scn = scn_;
51     reqInfo.eventMask = SOCK_RFCOMM_EVENTS;
52     reqInfo.context = this;
53     reqInfo.callback = &TransportRfcEventCallback;
54     (void)memcpy_s(&reqInfo.addr, sizeof(BtAddr), &btAddr, sizeof(BtAddr));
55     return RFCOMM_ConnectChannel(&reqInfo, &rfcHandle_);
56 }
57 
Disconnect()58 int RfcommTransport::Disconnect()
59 {
60     HILOGI("[RfcommTransport]enter");
61 
62     return RFCOMM_DisconnectChannel(rfcHandle_);
63 }
64 
RegisterServer()65 int RfcommTransport::RegisterServer()
66 {
67     HILOGI("[RfcommTransport]enter");
68 
69     isServer_ = true;
70 
71     return RFCOMM_RegisterServer(scn_, mtu_, SOCK_RFCOMM_EVENTS, TransportRfcEventCallback, this);
72 }
73 
RemoveServer(bool isDisable)74 int RfcommTransport::RemoveServer(bool isDisable)
75 {
76     HILOGI("[RfcommTransport]enter");
77 
78     RFCOMM_FreeServerNum(this->scn_);
79     if (isDisable) {
80         return RFCOMM_DeregisterServer(this->scn_, true);
81     } else {
82         return RFCOMM_DeregisterServer(this->scn_, false);
83     }
84 }
85 
AcceptConnection(const RawAddress & addr,uint16_t scn)86 int RfcommTransport::AcceptConnection(const RawAddress &addr, uint16_t scn)
87 {
88     HILOGI("[RfcommTransport] RawAddress:%{public}s", GetEncryptAddr(addr.GetAddress()).c_str());
89     if (this->handleMap_.find(addr) != this->handleMap_.end()) {
90         this->rfcHandle_ = this->handleMap_.at(addr);
91     } else {
92         HILOGE("[RfcommTransport] handle:%{public}hu: handle does not exist", this->rfcHandle_);
93     }
94 
95     return RFCOMM_AcceptConnection(this->rfcHandle_);
96 }
97 
RejectConnection(const RawAddress & addr,uint16_t scn)98 int RfcommTransport::RejectConnection(const RawAddress &addr, uint16_t scn)
99 {
100     HILOGI("[RfcommTransport]enter");
101 
102     if (this->handleMap_.find(addr) != this->handleMap_.end()) {
103         this->rfcHandle_ = this->handleMap_.at(addr);
104     } else {
105         HILOGE("[RfcommTransport] handle:%{public}hu: handle does not exist", this->rfcHandle_);
106     }
107 
108     return RFCOMM_RejectConnection(this->rfcHandle_);
109 }
110 
GetRemoteAddress()111 RawAddress RfcommTransport::GetRemoteAddress()
112 {
113     HILOGI("[RfcommTransport]enter");
114 
115     if (IsServer()) {
116         return remoteAddrMap_.at(this);
117     } else {
118         return remoteAddr_;
119     }
120 }
121 
Read(Packet ** pkt)122 int RfcommTransport::Read(Packet **pkt)
123 {
124     HILOGI("[RfcommTransport]enter");
125 
126     return RFCOMM_Read(this->rfcHandle_, pkt);
127 }
128 
Write(Packet * pkt)129 int RfcommTransport::Write(Packet *pkt)
130 {
131     HILOGI("[RfcommTransport]enter");
132 
133     return RFCOMM_Write(this->rfcHandle_, pkt);
134 }
135 
AddTransportInternal(RawAddress addr,uint16_t handle)136 RfcommTransport *RfcommTransport::AddTransportInternal(RawAddress addr, uint16_t handle)
137 {
138     HILOGI("[RfcommTransport] RawAddress:%{public}s, handle: %{public}d",
139         GetEncryptAddr(addr.GetAddress()).c_str(), handle);
140 
141     RfcommTransport *newTransport = new (std::nothrow) RfcommTransport(&addr, scn_, mtu_, observer_, dispatcher_);
142     if (newTransport != nullptr) {
143         newTransport->rfcHandle_ = handle;
144         {
145             std::lock_guard<std::mutex> lock(transportMutex_);
146             transportMap_.insert(std::pair<uint16_t, RfcommTransport *>(handle, newTransport));
147         }
148         return newTransport;
149     } else {
150         return nullptr;
151     }
152 }
153 
TransportRfcEventCallback(uint16_t handle,uint32_t event,const void * eventData,void * context)154 void RfcommTransport::TransportRfcEventCallback(uint16_t handle, uint32_t event,
155                                                 const void *eventData, void *context)
156 {
157     HILOGI("[RfcommTransport] handle:%{public}hu event:%{public}u", handle, event);
158 
159     auto transport = static_cast<RfcommTransport *>(context);
160 
161     switch (event) {
162         case RFCOMM_CHANNEL_EV_CONNECT_INCOMING: {
163             RfcommIncomingInfo incomingEvent;
164             (void)memcpy_s(&incomingEvent, sizeof(RfcommIncomingInfo), eventData, sizeof(RfcommIncomingInfo));
165             transport->addressMap_.insert(
166                 std::pair<uint16_t, RawAddress>(handle, RawAddress::ConvertToString(incomingEvent.addr.addr)));
167             HILOGI("[RfcommTransport] handle:%{public}hu RawAddress:%{public}s",
168                 handle, GetEncryptAddr(RawAddress::ConvertToString(incomingEvent.addr.addr).GetAddress()).c_str());
169             transport->handleMap_.insert(
170                 std::pair<RawAddress, uint16_t>(RawAddress::ConvertToString(incomingEvent.addr.addr), handle));
171             transport->observer_.OnConnectIncoming(
172                 RawAddress::ConvertToString(incomingEvent.addr.addr), incomingEvent.scn);
173             break;
174         }
175         case RFCOMM_CHANNEL_EV_CONNECT_SUCCESS:
176             TransportRfcConnectSuccess(handle, eventData, transport);
177             break;
178         case RFCOMM_CHANNEL_EV_CONNECT_FAIL:
179             TransportRfcConnectFail(handle, transport);
180             break;
181         case RFCOMM_CHANNEL_EV_DISCONNECTED:
182             TransportRfcDisconnected(handle, transport);
183             break;
184         case RFCOMM_CHANNEL_EV_DISCONNECT_SUCCESS:
185             TransportRfcDisconnectSuccess(handle, transport);
186             break;
187         case RFCOMM_CHANNEL_EV_DISCONNECT_FAIL:
188             TransportRfcDisconnectFail(handle, transport);
189             break;
190         case RFCOMM_CHANNEL_EV_FC_ON:
191             TransportRfcFcOn(handle, transport);
192             break;
193         case RFCOMM_CHANNEL_EV_REV_DATA:
194             TransportRfcRecvData(handle, transport);
195             break;
196         default:
197             break;
198     }
199 }
200 
TransportRfcConnectSuccess(uint16_t handle,const void * eventData,RfcommTransport * transport)201 void RfcommTransport::TransportRfcConnectSuccess(uint16_t handle, const void *eventData, RfcommTransport *transport)
202 {
203     LOG_INFO("[RfcommTransport]%{public}s handle:%hu ", __func__, handle);
204 
205     RfcommConnectedInfo connectedEvent;
206     (void)memcpy_s(&connectedEvent, sizeof(RfcommConnectedInfo), eventData, sizeof(RfcommConnectedInfo));
207 
208     if (transport->IsServer()) {
209         if (transport->addressMap_.find(handle) != transport->addressMap_.end()) {
210             transport->remoteAddr_ = transport->addressMap_.at(handle);
211         } else {
212             LOG_ERROR("[RfcommTransport]%{public}s handle:%hu: address does not exist", __FUNCTION__, handle);
213         }
214         RfcommTransport *newTransport = transport->AddTransportInternal(transport->remoteAddr_, handle);
215         transport->remoteAddrMap_.insert(
216             std::pair<RfcommTransport *, RawAddress>(newTransport, transport->remoteAddr_));
217         transport->observer_.OnConnected(newTransport, connectedEvent.sendMTU, connectedEvent.recvMTU);
218     } else {
219         transport->observer_.OnConnected(transport, connectedEvent.sendMTU, connectedEvent.recvMTU);
220     }
221 }
222 
TransportRfcConnectFail(uint16_t handle,RfcommTransport * transport)223 void RfcommTransport::TransportRfcConnectFail(uint16_t handle, RfcommTransport *transport)
224 {
225     LOG_INFO("[RfcommTransport]%{public}s handle:%hu ", __func__, handle);
226 
227     if (transport->IsServer()) {
228         if (transport->transportMap_.find(handle) != transport->transportMap_.end()) {
229             transport->observer_.OnTransportError(transport->transportMap_.at(handle), CONNECT_FAIL);
230         } else {
231             LOG_ERROR("[RfcommTransport]%{public}s handle:%hu: RFCOMM_CHANNEL_EV_CONNECT_FAIL transport does not exist",
232                 __FUNCTION__,
233                 handle);
234             std::map<RawAddress, uint16_t>::iterator it;
235             for (it = transport->handleMap_.begin(); it != transport->handleMap_.end(); ++it) {
236                 if (it->second == handle) {
237                     LOG_INFO("[RfcommTransport]%{public}s erase handle map", __func__);
238                     transport->handleMap_.erase(it);
239                     break;
240                 }
241             }
242             transport->addressMap_.erase(handle);
243         }
244     } else {
245         transport->observer_.OnTransportError(transport, CONNECT_FAIL);
246     }
247 }
248 
TransportRfcDisconnected(uint16_t handle,RfcommTransport * transport)249 void RfcommTransport::TransportRfcDisconnected(uint16_t handle, RfcommTransport *transport)
250 {
251     LOG_INFO("[RfcommTransport]%{public}s handle:%hu ", __func__, handle);
252 
253     if (!transport->IsServer()) {
254         transport->observer_.OnDisconnected(transport);
255         return;
256     }
257     std::lock_guard<std::mutex> lock(transport->transportMutex_);
258     if (transport->transportMap_.find(handle) != transport->transportMap_.end()) {
259         std::map<RawAddress, uint16_t>::iterator it;
260         for (it = transport->handleMap_.begin(); it != transport->handleMap_.end(); ++it) {
261             if (it->second == handle) {
262                 LOG_INFO("[RfcommTransport]%{public}s erase handle map", __func__);
263                 transport->handleMap_.erase(it);
264                 break;
265             }
266         }
267         auto transportTmp = transport->transportMap_.at(handle);
268         transport->transportMap_.erase(handle);
269         transport->addressMap_.erase(handle);
270         transport->observer_.OnDisconnected(transportTmp);
271     } else {
272         LOG_ERROR(
273             "[RfcommTransport]%{public}s handle:%hu transport does not exist", __FUNCTION__, handle);
274         if (transport->addressMap_.find(handle) != transport->addressMap_.end()) {
275             transport->observer_.OnIncomingDisconnected(transport->addressMap_.at(handle));
276         } else {
277             LOG_ERROR("[RfcommTransport]%{public}s handle:%hu: transport and address does not exist",
278                 __FUNCTION__, handle);
279         }
280     }
281 }
282 
TransportRfcDisconnectSuccess(uint16_t handle,RfcommTransport * transport)283 void RfcommTransport::TransportRfcDisconnectSuccess(uint16_t handle, RfcommTransport *transport)
284 {
285     LOG_INFO("[RfcommTransport]%{public}s handle:%hu ", __func__, handle);
286 
287     if (!transport->IsServer()) {
288         transport->observer_.OnDisconnectSuccess(transport);
289         return;
290     }
291     std::lock_guard<std::mutex> lock(transport->transportMutex_);
292     if (transport->transportMap_.find(handle) != transport->transportMap_.end()) {
293         std::map<RawAddress, uint16_t>::iterator it;
294         for (it = transport->handleMap_.begin(); it != transport->handleMap_.end(); ++it) {
295             if (it->second == handle) {
296                 LOG_INFO("[RfcommTransport]%{public}s erase handle map", __func__);
297                 transport->handleMap_.erase(it);
298                 break;
299             }
300         }
301         auto transportTmp = transport->transportMap_.at(handle);
302         transport->transportMap_.erase(handle);
303         transport->addressMap_.erase(handle);
304         transport->observer_.OnDisconnectSuccess(transportTmp);
305     } else {
306         LOG_ERROR("[RfcommTransport]%{public}s handle:%hu transport does not exist",
307             __FUNCTION__,
308             handle);
309     }
310 }
311 
TransportRfcDisconnectFail(uint16_t handle,RfcommTransport * transport)312 void RfcommTransport::TransportRfcDisconnectFail(uint16_t handle, RfcommTransport *transport)
313 {
314     LOG_INFO("[RfcommTransport]%{public}s handle:%hu ", __func__, handle);
315 
316     if (transport->IsServer()) {
317         std::lock_guard<std::mutex> lock(transport->transportMutex_);
318         if (transport->transportMap_.find(handle) != transport->transportMap_.end()) {
319             transport->observer_.OnTransportError(transport->transportMap_.at(handle), DISCONNECT_FAIL);
320         } else {
321             LOG_ERROR("[RfcommTransport]%{public}s handle:%hu: RFCOMM_CHANNEL_EV_DISCONNECT_FAIL transport no exist",
322                 __FUNCTION__,
323                 handle);
324         }
325     } else {
326         transport->observer_.OnTransportError(transport, DISCONNECT_FAIL);
327     }
328 }
329 
TransportRfcFcOn(uint16_t handle,RfcommTransport * transport)330 void RfcommTransport::TransportRfcFcOn(uint16_t handle, RfcommTransport *transport)
331 {
332     LOG_INFO("[RfcommTransport]%{public}s handle:%hu ", __func__, handle);
333 
334     if (transport->IsServer()) {
335         std::lock_guard<std::mutex> lock(transport->transportMutex_);
336         if (transport->transportMap_.find(handle) != transport->transportMap_.end()) {
337             transport->observer_.OnTransportError(transport->transportMap_.at(handle), EV_FC_ON);
338         } else {
339             LOG_ERROR("[RfcommTransport]%{public}s handle:%hu transport does not exist", __FUNCTION__, handle);
340         }
341     } else {
342         transport->observer_.OnTransportError(transport, EV_FC_ON);
343     }
344 }
345 
TransportRfcRecvData(uint16_t handle,RfcommTransport * transport)346 void RfcommTransport::TransportRfcRecvData(uint16_t handle, RfcommTransport *transport)
347 {
348     LOG_INFO("[RfcommTransport]%{public}s handle:%hu ", __func__, handle);
349 
350     if (transport->IsServer()) {
351         std::lock_guard<std::mutex> lock(transport->transportMutex_);
352         if (transport->transportMap_.find(handle) != transport->transportMap_.end()) {
353             transport->observer_.OnDataAvailable(transport->transportMap_.at(handle));
354         } else {
355             LOG_ERROR(
356                 "[RfcommTransport]%{public}s handle:%hu transport does not exist", __FUNCTION__, handle);
357         }
358     } else {
359         transport->observer_.OnDataAvailable(transport);
360     }
361 }
362 }  // namespace bluetooth
363 }  // namespace OHOS
364