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