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 "socket.h"
17 #include <sys/ioctl.h>
18 #include <sys/socket.h>
19 #include <unistd.h>
20
21 #include "adapter_config.h"
22 #include "log.h"
23 #include "packet.h"
24 #include "power_manager.h"
25 #include "profile_service_manager.h"
26 #include "securec.h"
27
28 #include "socket_def.h"
29 #include "socket_listener.h"
30 #include "socket_service.h"
31 #include "socket_util.h"
32
33 namespace OHOS {
34 namespace bluetooth {
35 static int g_arrayServiceId[SOCK_MAX_SERVICE_ID] = {0};
36 std::vector<Socket *> Socket::g_allServerSockets;
37 std::recursive_mutex Socket::g_socketMutex;
38
39 struct Socket::impl {
40 class DataTransportObserverImplement;
41 std::unique_ptr<DataTransportObserver> transportObserver_ {};
42 void OnConnectIncomingNative(Socket &socket, RawAddress addr, uint8_t port);
43 void OnConnectedNative(Socket &socket, DataTransport *transport, uint16_t sendMTU, uint16_t recvMTU);
44 void OnDisconnectedNative(Socket &socket, DataTransport *transport);
45 void OnDisconnectSuccessNative(Socket &socket, DataTransport *transport);
46 void OnDataAvailableNative(Socket &socket, DataTransport *transport);
47 void OnTransportErrorNative(Socket &socket, DataTransport *transport, int errType);
48 void SockRfcConnectFail(Socket &socket, DataTransport *transport);
49 void SockRfcDisconnectFail(Socket &socket, DataTransport *transport);
50 void SockRfcFcOn(Socket &socket, DataTransport *transport);
51 static int GetMaxConnectionDevicesNum();
52 };
53
54 class Socket::impl::DataTransportObserverImplement : public DataTransportObserver {
55 public:
OnConnectIncoming(const RawAddress & addr,uint16_t port)56 void OnConnectIncoming(const RawAddress &addr, uint16_t port) override
57 {
58 SocketService *socketService =
59 static_cast<SocketService *>(IProfileManager::GetInstance()->GetProfileService(PROFILE_NAME_SPP));
60 if (socketService != nullptr) {
61 socketService->GetDispatcher()->PostTask(
62 std::bind(&impl::OnConnectIncomingNative, socket_.pimpl.get(), std::ref(socket_), addr, port));
63 }
64 }
65
OnIncomingDisconnected(const RawAddress & addr)66 void OnIncomingDisconnected(const RawAddress &addr) override
67 {
68 LOG_INFO("[sock]%{public}s", __func__);
69 }
70
OnConnected(DataTransport * transport,uint16_t sendMTU,uint16_t recvMTU)71 void OnConnected(DataTransport *transport, uint16_t sendMTU, uint16_t recvMTU) override
72 {
73 LOG_INFO("[sock]%{public}s", __func__);
74
75 SocketService *socketService =
76 static_cast<SocketService *>(IProfileManager::GetInstance()->GetProfileService(PROFILE_NAME_SPP));
77 if (socketService != nullptr) {
78 socketService->GetDispatcher()->PostTask(std::bind(&impl::OnConnectedNative, socket_.pimpl.get(),
79 std::ref(socket_), transport, sendMTU, recvMTU));
80 }
81 }
82
OnDisconnected(DataTransport * transport)83 void OnDisconnected(DataTransport *transport) override
84 {
85 LOG_INFO("[sock]%{public}s", __func__);
86
87 SocketService *socketService =
88 static_cast<SocketService *>(IProfileManager::GetInstance()->GetProfileService(PROFILE_NAME_SPP));
89 if (socketService != nullptr) {
90 socketService->GetDispatcher()->PostTask(
91 std::bind(&impl::OnDisconnectedNative, socket_.pimpl.get(), std::ref(socket_), transport));
92 }
93 }
94
OnDisconnectSuccess(DataTransport * transport)95 void OnDisconnectSuccess(DataTransport *transport) override
96 {
97 LOG_INFO("[sock]%{public}s", __func__);
98
99 SocketService *socketService =
100 static_cast<SocketService *>(IProfileManager::GetInstance()->GetProfileService(PROFILE_NAME_SPP));
101 if (socketService != nullptr) {
102 socketService->GetDispatcher()->PostTask(
103 std::bind(&impl::OnDisconnectSuccessNative, socket_.pimpl.get(), std::ref(socket_), transport));
104 }
105 }
106
OnDataAvailable(DataTransport * transport)107 void OnDataAvailable(DataTransport *transport) override
108 {
109 LOG_INFO("[sock]%{public}s", __func__);
110
111 SocketService *socketService =
112 static_cast<SocketService *>(IProfileManager::GetInstance()->GetProfileService(PROFILE_NAME_SPP));
113 if (socketService != nullptr) {
114 socketService->GetDispatcher()->PostTask(
115 std::bind(&impl::OnDataAvailableNative, socket_.pimpl.get(), std::ref(socket_), transport));
116 }
117 }
118
OnDataAvailable(DataTransport * transport,Packet * pkt)119 void OnDataAvailable(DataTransport *transport, Packet *pkt) override
120 {
121 LOG_INFO("[sock]%{public}s", __func__);
122 }
123
OnTransportError(DataTransport * transport,int errType)124 void OnTransportError(DataTransport *transport, int errType) override
125 {
126 LOG_INFO("[sock]%{public}s", __func__);
127
128 SocketService *socketService =
129 static_cast<SocketService *>(IProfileManager::GetInstance()->GetProfileService(PROFILE_NAME_SPP));
130 if (socketService != nullptr) {
131 socketService->GetDispatcher()->PostTask(
132 std::bind(&impl::OnTransportErrorNative, socket_.pimpl.get(), std::ref(socket_), transport, errType));
133 }
134 }
135
DataTransportObserverImplement(Socket & socket)136 DataTransportObserverImplement(Socket &socket) : socket_(socket)
137 {}
138
139 ~DataTransportObserverImplement() = default;
140
141 private:
142 Socket &socket_;
143 };
144
OnConnectIncomingNative(Socket & socket,RawAddress addr,uint8_t port)145 void Socket::impl::OnConnectIncomingNative(Socket &socket, RawAddress addr, uint8_t port)
146 {
147 LOG_INFO("[sock]%{public}s", __func__);
148
149 socket.maxConnectedNum_ = GetMaxConnectionDevicesNum();
150 addr.ConvertToUint8(socket.remoteAddr_.addr);
151 socket.remoteAddr_.type = BT_PUBLIC_DEVICE_ADDRESS;
152 if (socket.clientNumber_ < socket.maxConnectedNum_) {
153 socket.sockTransport_->AcceptConnection(addr, port);
154 } else {
155 socket.sockTransport_->RejectConnection(addr, port);
156 }
157 }
158
OnConnectedNative(Socket & socket,DataTransport * transport,uint16_t sendMTU,uint16_t recvMTU)159 void Socket::impl::OnConnectedNative(Socket &socket, DataTransport *transport, uint16_t sendMTU, uint16_t recvMTU)
160 {
161 LOG_INFO("[sock]%{public}s", __func__);
162 IPowerManager::GetInstance().StatusUpdate(
163 RequestStatus::CONNECT_ON, PROFILE_NAME_SPP, RawAddress::ConvertToString(socket.remoteAddr_.addr));
164 if (socket.IsServer()) {
165 socket.clientNumber_++;
166 int newFd = socket.AddSocketInternal(socket.remoteAddr_, transport, sendMTU, recvMTU);
167 Socket::SendAppConnectInfo(socket.transportFd_, socket.remoteAddr_, true, newFd);
168 } else {
169 socket.state_ = CONNECTED;
170 socket.sendMTU_ = sendMTU;
171 socket.recvMTU_ = recvMTU;
172 Socket::SendAppConnectInfo(socket.transportFd_, socket.remoteAddr_, true, -1);
173 LOG_INFO("[sock]%{public}s app fd:%{public}d client connect successfully", __func__, socket.upperlayerFd_);
174 std::lock_guard<std::recursive_mutex> lck(Socket::g_socketMutex);
175 g_allServerSockets.push_back(&socket);
176 }
177 }
178
OnDisconnectedNative(Socket & socket,DataTransport * transport)179 void Socket::impl::OnDisconnectedNative(Socket &socket, DataTransport *transport)
180 {
181 LOG_INFO("[sock]%{public}s", __func__);
182
183 socket.ProcessDisconnection(socket, transport);
184 }
185
OnDisconnectSuccessNative(Socket & socket,DataTransport * transport)186 void Socket::impl::OnDisconnectSuccessNative(Socket &socket, DataTransport *transport)
187 {
188 LOG_INFO("[sock]%{public}s", __func__);
189
190 socket.ProcessDisconnection(socket, transport);
191 }
192
OnDataAvailableNative(Socket & socket,DataTransport * transport)193 void Socket::impl::OnDataAvailableNative(Socket &socket, DataTransport *transport)
194 {
195 LOG_INFO("[sock]%{public}s", __func__);
196
197 Packet *pkt = nullptr;
198 uint8_t *pData = nullptr;
199 Buffer *buf = nullptr;
200
201 Socket *socketTmp = nullptr;
202 if (socket.IsServer()) {
203 if (socket.socketMap_.find(transport) != socket.socketMap_.end()) {
204 socketTmp = socket.socketMap_.at(transport).get();
205 } else {
206 LOG_ERROR("[sock]%{public}s socket does not exist", __func__);
207 return;
208 }
209 } else {
210 socketTmp = &socket;
211 }
212
213 if (!socketTmp->isCanRead_) {
214 LOG_DEBUG("[sock]%{public}s app can not receive data", __func__);
215 return;
216 }
217
218 if (socketTmp->isNewSocket_) {
219 if (socketTmp->newSockTransport_ != nullptr) {
220 socketTmp->newSockTransport_->Read(&pkt);
221 } else {
222 LOG_DEBUG("[sock]%{public}s newSockTransport is null", __func__);
223 return;
224 }
225 } else {
226 socketTmp->sockTransport_->Read(&pkt);
227 }
228
229 if (pkt == nullptr) {
230 LOG_ERROR("[sock]%{public}s pkt is null", __func__);
231 return;
232 }
233
234 size_t len = PacketPayloadSize(pkt);
235 buf = PacketContinuousPayload(pkt);
236 if (buf == nullptr) {
237 LOG_ERROR("[sock]%{public}s pkt buf is null", __func__);
238 return;
239 }
240 pData = (uint8_t *)BufferPtr(buf);
241
242 socketTmp->WriteDataToAPP(pData, len);
243
244 if (pkt != nullptr) {
245 PacketFree(pkt);
246 }
247 }
248
OnTransportErrorNative(Socket & socket,DataTransport * transport,int errType)249 void Socket::impl::OnTransportErrorNative(Socket &socket, DataTransport *transport, int errType)
250 {
251 LOG_INFO("[sock]%{public}s errType:%{public}d", __func__, errType);
252
253 switch (errType) {
254 case RFCOMM_CONNECT_FAIL:
255 SockRfcConnectFail(socket, transport);
256 break;
257 case RFCOMM_DISCONNECT_FAIL:
258 SockRfcDisconnectFail(socket, transport);
259 break;
260 case RFCOMM_EV_FC_ON:
261 SockRfcFcOn(socket, transport);
262 break;
263 default:
264 break;
265 }
266 }
267
SockRfcConnectFail(Socket & socket,DataTransport * transport)268 void Socket::impl::SockRfcConnectFail(Socket &socket, DataTransport *transport)
269 {
270 LOG_INFO("[sock]%{public}s", __func__);
271
272 if (socket.IsServer()) {
273 if (socket.socketMap_.find(transport) != socket.socketMap_.end()) {
274 Socket *serverSocket = nullptr;
275 serverSocket = socket.socketMap_.at(transport).get();
276 Socket::SendAppConnectInfo(serverSocket->transportFd_, socket.remoteAddr_, false, -1);
277 }
278 } else {
279 Socket::SendAppConnectInfo(socket.transportFd_, socket.remoteAddr_, false, -1);
280 }
281 socket.ProcessDisconnection(socket, transport);
282 }
283
SockRfcDisconnectFail(Socket & socket,DataTransport * transport)284 void Socket::impl::SockRfcDisconnectFail(Socket &socket, DataTransport *transport)
285 {
286 LOG_INFO("[sock]%{public}s", __func__);
287
288 if (socket.IsServer()) {
289 if (socket.socketMap_.find(transport) != socket.socketMap_.end()) {
290 LOG_DEBUG("SockRfcDisconnectFail closefd : fd:%{public}d", socket.socketMap_.at(transport).get()->transportFd_);
291 close(socket.socketMap_.at(transport).get()->transportFd_);
292 } else {
293 LOG_ERROR("[sock]socket does not exist");
294 }
295 } else {
296 LOG_DEBUG("SockRfcDisconnectFail closefd : fd:%{public}d", socket.transportFd_);
297 close(socket.transportFd_);
298 }
299 }
300
SockRfcFcOn(Socket & socket,DataTransport * transport)301 void Socket::impl::SockRfcFcOn(Socket &socket, DataTransport *transport)
302 {
303 LOG_INFO("[sock]%{public}s", __func__);
304
305 Socket *socketTmp = nullptr;
306 if (socket.IsServer()) {
307 if (socket.socketMap_.find(transport) != socket.socketMap_.end()) {
308 socketTmp = socket.socketMap_.at(transport).get();
309 } else {
310 LOG_ERROR("socket does not exist");
311 }
312 } else {
313 socketTmp = &socket;
314 }
315 if (socketTmp == nullptr) {
316 return;
317 }
318 std::lock_guard<std::recursive_mutex> lk(socketTmp->writeMutex_);
319 if (socketTmp->sendBufLen_ > 0) {
320 Packet *wPkt = PacketMalloc(0, 0, socketTmp->sendBufLen_);
321 Buffer *wPayloadBuf = PacketContinuousPayload(wPkt);
322 void *buffer = BufferPtr(wPayloadBuf);
323 (void)memcpy_s(buffer, socketTmp->sendBufLen_, socketTmp->sendDataBuf_, socketTmp->sendBufLen_);
324 if (wPayloadBuf == nullptr) {
325 if (wPkt != nullptr) {
326 PacketFree(wPkt);
327 }
328 return;
329 }
330 int ret = socketTmp->TransportWrite(wPkt);
331 if (ret < 0) {
332 LOG_ERROR("%{public}s stack write failed", __func__);
333 } else {
334 (void)memset_s(socketTmp->sendDataBuf_, socketTmp->sendBufLen_, 0x00, socketTmp->sendBufLen_);
335 socketTmp->sendBufLen_ = 0;
336 socketTmp->isCanWrite_ = true;
337 socketTmp->WriteData();
338 }
339 if (wPkt != nullptr) {
340 PacketFree(wPkt);
341 }
342 } else {
343 socketTmp->isCanWrite_ = true;
344 socketTmp->WriteData();
345 }
346 }
347
GetMaxConnectionDevicesNum()348 int Socket::impl::GetMaxConnectionDevicesNum()
349 {
350 int number = SOCK_MAX_CLIENT;
351 if (!AdapterConfig::GetInstance()->GetValue(SECTION_SOCKET_SERVICE, PROPERTY_MAX_CONNECTED_DEVICES, number)) {
352 LOG_DEBUG("[sock]%{public}s: It's failed to get the max connection number", __FUNCTION__);
353 }
354 return number;
355 }
356
Socket()357 Socket::Socket() : pimpl(nullptr)
358 {
359 state_ = SocketState::INIT;
360 pimpl = std::make_unique<Socket::impl>();
361 this->pimpl->transportObserver_ = std::make_unique<Socket::impl::DataTransportObserverImplement>(*this);
362 }
363
~Socket()364 Socket::~Socket()
365 {}
366
Connect(const std::string & addr,const Uuid & uuid,int securityFlag,int & sockfd)367 int Socket::Connect(const std::string &addr, const Uuid &uuid, int securityFlag, int &sockfd)
368 {
369 LOG_INFO("[sock]%{public}s", __func__);
370
371 sockfd = SOCK_INVALID_FD;
372 int socketPair[2] = {SOCK_INVALID_FD, SOCK_INVALID_FD};
373
374 if (socketpair(AF_UNIX, SOCK_STREAM, 0, socketPair) == -1) {
375 LOG_ERROR("[sock]%{public}s: create rfcomm socket pair failed", __FUNCTION__);
376 return -1;
377 }
378
379 SetRemoteAddr(addr);
380
381 sdpClient_ = std::make_unique<SocketSdpClient>();
382 int ret = sdpClient_->StartDiscovery(addr, uuid, this);
383 if (ret != BT_NO_ERROR) {
384 LOG_ERROR("[sock]%{public}s: Discovery SPP Service Fail!", __FUNCTION__);
385 }
386
387 upperlayerFd_ = socketPair[0];
388 transportFd_ = socketPair[1];
389
390 LOG_INFO("[sock]%{public}s appFd:%{public}d fd:%{public}d", __func__, upperlayerFd_, transportFd_);
391
392 sockfd = upperlayerFd_;
393 upperlayerFd_ = SOCK_INVALID_FD;
394 securityFlag_ = securityFlag;
395 SocketThread::GetInstance().AddSocket(transportFd_, 0, *this);
396 return ret;
397 }
398
Listen(const std::string & name,const Uuid & uuid,int securityFlag,int & sockfd)399 int Socket::Listen(const std::string &name, const Uuid &uuid, int securityFlag, int &sockfd)
400 {
401 LOG_INFO("[sock]%{public}s", __func__);
402
403 isServer_ = true;
404 sockfd = SOCK_INVALID_FD;
405 int socketPair[2] = {SOCK_INVALID_FD, SOCK_INVALID_FD};
406 if (socketpair(AF_UNIX, SOCK_STREAM, 0, socketPair) == -1) {
407 LOG_ERROR("[sock]%{public}s: create listen socket failed", __FUNCTION__);
408 return -1;
409 }
410 upperlayerFd_ = socketPair[0];
411 transportFd_ = socketPair[1];
412 LOG_INFO("[sock]%{public}s appFd:%{public}d fd:%{public}d", __func__, upperlayerFd_, transportFd_);
413 sockfd = upperlayerFd_;
414 upperlayerFd_ = SOCK_INVALID_FD;
415 securityFlag_ = securityFlag;
416 state_ = LISTEN;
417
418 SocketThread::GetInstance().AddSocket(transportFd_, 0, *this);
419
420 scn_ = RFCOMM_AssignServerNum();
421
422 sdpServer_ = std::make_unique<SocketSdpServer>();
423 int ret = sdpServer_->RegisterSdpService(name, uuid, scn_);
424 if (ret != BT_NO_ERROR) {
425 LOG_ERROR("[sock]%{public}s: Discovery SPP Service Fail!", __FUNCTION__);
426 }
427
428 serviceId_ = AssignServiceId();
429 LOG_INFO("[sock]%{public}s securityFlag:%{public}d serviceId_:%{public}d", __func__, securityFlag_, serviceId_);
430 socketGapServer_ = std::make_unique<SocketGapServer>();
431 socketGapServer_->RegisterServiceSecurity(scn_, securityFlag_, serviceId_);
432
433 sockTransport_ = std::move(transportFactory_->CreateRfcommTransport(
434 nullptr, scn_, SOCK_DEF_RFC_MTU, *this->pimpl->transportObserver_.get(), *GetDispatchter()));
435 sockTransport_->RegisterServer();
436
437 std::lock_guard<std::recursive_mutex> lk(Socket::g_socketMutex);
438 g_allServerSockets.push_back(this);
439 return ret;
440 }
441
ReceiveSdpResult(uint8_t scn)442 int Socket::ReceiveSdpResult(uint8_t scn)
443 {
444 LOG_INFO("[sock]%{public}s", __func__);
445
446 serviceId_ = AssignServiceId();
447 scn_ = scn;
448 LOG_INFO("[sock]%{public}s securityFlag:%{public}d serviceId_:%{public}d scn:%hhu", __func__, securityFlag_, serviceId_, scn_);
449 if (scn_ > SOCK_MAX_SERVER) {
450 LOG_INFO("[sock]%{public}s scn invalid", __func__);
451 return -1;
452 }
453
454 socketGapClient_ = std::make_unique<SocketGapClient>();
455 socketGapClient_->RegisterServiceSecurity(remoteAddr_, scn_, securityFlag_, serviceId_);
456 RawAddress rawAddr = RawAddress::ConvertToString(remoteAddr_.addr);
457 sockTransport_ = std::move(transportFactory_->CreateRfcommTransport(
458 &rawAddr, scn_, SOCK_DEF_RFC_MTU, *this->pimpl->transportObserver_.get(), *GetDispatchter()));
459
460 switch (state_) {
461 case INIT:
462 if (sockTransport_->Connect() < 0) {
463 LOG_ERROR("[sock]create rfcomm channel failed");
464 SocketThread::GetInstance().DeleteSocket(*this);
465 CloseSocketFd();
466 return -1;
467 }
468 state_ = CONNECTING;
469 break;
470 default:
471 LOG_ERROR("[sock]create rfcomm channel failed");
472 break;
473 }
474 return 0;
475 }
476
AddSocketInternal(BtAddr addr,DataTransport * transport,uint16_t sendMTU,uint16_t recvMTU)477 int Socket::AddSocketInternal(BtAddr addr, DataTransport *transport, uint16_t sendMTU, uint16_t recvMTU)
478 {
479 LOG_INFO("[sock]%{public}s", __func__);
480
481 std::unique_ptr<Socket> acceptSocket = std::make_unique<Socket>();
482 int socketPair[2] = {SOCK_INVALID_FD, SOCK_INVALID_FD};
483 if (socketpair(AF_UNIX, SOCK_STREAM, 0, socketPair) == -1) {
484 LOG_ERROR("[sock]create accept socket failed");
485 }
486 LOG_DEBUG("AddSocketInternal : fd:%{public}d, fd:%{public}d", socketPair[0], socketPair[1]);
487 acceptSocket->upperlayerFd_ = socketPair[0];
488 acceptSocket->transportFd_ = socketPair[1];
489 acceptSocket->remoteAddr_ = addr;
490 acceptSocket->isNewSocket_ = true;
491 acceptSocket->isServer_ = true;
492 acceptSocket->state_ = SocketState::CONNECTED;
493 acceptSocket->sendMTU_ = sendMTU;
494 acceptSocket->recvMTU_ = recvMTU;
495 acceptSocket->newSockTransport_ = transport;
496 mutex_.lock();
497 auto it = socketMap_.emplace(transport, std::move(acceptSocket));
498 mutex_.unlock();
499
500 SocketThread::GetInstance().AddSocket(
501 it.first->second.get()->transportFd_, 0, *(it.first->second.get()));
502
503 utility::Message msg(SOCKET_ACCEPT_NEW);
504 msg.arg1_ = socketPair[0];
505 msg.arg2_ = it.first->second.get();
506 SocketService *socketService =
507 static_cast<SocketService *>(IProfileManager::GetInstance()->GetProfileService(PROFILE_NAME_SPP));
508 if (socketService != nullptr) {
509 socketService->ProcessMessage(msg);
510 }
511
512 std::lock_guard<std::recursive_mutex> lck(Socket::g_socketMutex);
513 g_allServerSockets.push_back(it.first->second.get());
514
515 if (socketPair[0] < 0) {
516 LOG_ERROR("[sock]create accept socket failed");
517 }
518 return socketPair[0];
519 }
520
SendAppConnectInfo(int fd,BtAddr addr,bool status,int acceptFd)521 bool Socket::SendAppConnectInfo(int fd, BtAddr addr, bool status, int acceptFd)
522 {
523 LOG_INFO("[sock]%{public}s", __func__);
524
525 SocketConnectInfo connectInfo;
526 (void)memset_s(&connectInfo, sizeof(connectInfo), 0, sizeof(connectInfo));
527 (void)memcpy_s(connectInfo.addr, sizeof(addr.addr), addr.addr, sizeof(addr.addr));
528 connectInfo.status = status;
529 LOG_INFO("[sock]%{public}s size:%{public}zu", __func__, sizeof(connectInfo));
530 if (acceptFd == -1) {
531 return SocketUtil::SocketSendData(fd, reinterpret_cast<const uint8_t *>(&connectInfo), sizeof(connectInfo));
532 } else {
533 return SocketUtil::SocketSendFd(fd, reinterpret_cast<const uint8_t *>(&connectInfo),
534 sizeof(connectInfo), acceptFd);
535 }
536 }
537
ProcessDisconnection(Socket & socket,DataTransport * transport)538 void Socket::ProcessDisconnection(Socket &socket, DataTransport *transport)
539 {
540 LOG_INFO("[sock]%{public}s", __func__);
541
542 IPowerManager::GetInstance().StatusUpdate(
543 RequestStatus::CONNECT_OFF, PROFILE_NAME_SPP, RawAddress::ConvertToString(socket.remoteAddr_.addr));
544
545 if (socket.IsServer()) {
546 if (socket.socketMap_.find(transport) != socket.socketMap_.end()) {
547 socket.clientNumber_--;
548 Socket *serverSocket = nullptr;
549 serverSocket = socket.socketMap_.at(transport).get();
550 serverSocket->state_ = DISCONNECTED;
551 serverSocket->newSockTransport_ = nullptr;
552 SocketThread::GetInstance().DeleteSocket(*serverSocket);
553 serverSocket->CloseSocketFd();
554 std::lock_guard<std::recursive_mutex> lk(Socket::g_socketMutex);
555 Socket::EraseSocket(*serverSocket);
556 socket.socketMap_.erase(transport);
557 socket.NotifyServiceDeleteSocket(*serverSocket);
558 if (transport != nullptr) {
559 delete transport;
560 }
561 } else {
562 LOG_ERROR("[sock]socket does not exist");
563 }
564 } else {
565 socket.state_ = DISCONNECTED;
566 socketGapClient_->UnregisterSecurity(remoteAddr_, scn_, serviceId_);
567 FreeServiceId(serviceId_);
568 SocketThread::GetInstance().DeleteSocket(*this);
569 socket.CloseSocketFd();
570 std::lock_guard<std::recursive_mutex> lk(Socket::g_socketMutex);
571 Socket::EraseSocket(socket);
572 Socket::NotifyServiceDeleteSocket(socket);
573 }
574 }
575
SetRemoteAddr(std::string addr)576 void Socket::SetRemoteAddr(std::string addr)
577 {
578 LOG_INFO("[sock]%{public}s", __func__);
579
580 RawAddress rawAddr(addr);
581 rawAddr.ConvertToUint8(remoteAddr_.addr);
582 remoteAddr_.type = BT_PUBLIC_DEVICE_ADDRESS;
583 }
584
CloseSocket(bool isDisable)585 void Socket::CloseSocket(bool isDisable)
586 {
587 LOG_INFO("[sock]%{public}s", __func__);
588
589 CloseSocketFd();
590
591 if (isServer_ && (!isNewSocket_)) {
592 RFCOMM_FreeServerNum(scn_);
593 sdpServer_->UnregisterSdpService();
594 socketGapServer_->UnregisterSecurity(remoteAddr_, scn_, serviceId_);
595 FreeServiceId(serviceId_);
596 if (isDisable) {
597 sockTransport_->RemoveServer(true);
598 } else {
599 sockTransport_->RemoveServer(false);
600 }
601 state_ = CLOSED;
602 NotifyServiceDeleteSocket(*this);
603 std::lock_guard<std::recursive_mutex> lk(Socket::g_socketMutex);
604 EraseSocket(*this);
605 return;
606 }
607
608 if (state_ == CONNECTED || state_ == CONNECTING) {
609 LOG_INFO("[sock]%{public}s close connection", __func__);
610 if (isServer_) {
611 socketGapServer_->UnregisterSecurity(remoteAddr_, scn_, serviceId_);
612 } else {
613 socketGapClient_->UnregisterSecurity(remoteAddr_, scn_, serviceId_);
614 }
615 FreeServiceId(serviceId_);
616
617 if (isServer_) {
618 if (newSockTransport_ != nullptr) {
619 newSockTransport_->Disconnect();
620 } else {
621 LOG_ERROR("[sock]%{public}s newSockTransport is null", __func__);
622 }
623 } else {
624 if (sockTransport_ != nullptr) {
625 sockTransport_->Disconnect();
626 } else {
627 LOG_ERROR("[sock]%{public}s client sockTransport is null", __func__);
628 }
629 }
630 } else if (state_ == INIT || state_ == DISCONNECTED) {
631 LOG_INFO("[sock]%{public}s close no connection", __func__);
632 NotifyServiceDeleteSocket(*this);
633 }
634 }
635
OnSocketReadReady(Socket & sock)636 void Socket::OnSocketReadReady(Socket &sock)
637 {
638 std::lock_guard<std::recursive_mutex> lk(Socket::g_socketMutex);
639 std::vector<Socket *>::iterator it = find(g_allServerSockets.begin(), g_allServerSockets.end(), &sock);
640 if (it == g_allServerSockets.end()) {
641 LOG_DEBUG("[sock]%{public}s socket does not exist", __func__);
642 return;
643 }
644
645 std::lock_guard<std::recursive_mutex> lck(sock.writeMutex_);
646 if (sock.isCanWrite_) {
647 LOG_INFO("[sock]%{public}s socket write data", __func__);
648 sock.WriteData();
649 }
650 }
651
OnSocketWriteReady(Socket & sock)652 void Socket::OnSocketWriteReady(Socket &sock)
653 {
654 LOG_INFO("[sock]%{public}s", __func__);
655
656 std::lock_guard<std::recursive_mutex> lk(Socket::g_socketMutex);
657 std::vector<Socket *>::iterator it = find(g_allServerSockets.begin(), g_allServerSockets.end(), &sock);
658 if (it == g_allServerSockets.end()) {
659 LOG_DEBUG("[sock]%{public}s socket does not exist", __func__);
660 return;
661 }
662
663 SocketService *socketService =
664 static_cast<SocketService *>(IProfileManager::GetInstance()->GetProfileService(PROFILE_NAME_SPP));
665 if (socketService != nullptr) {
666 socketService->GetDispatcher()->PostTask(std::bind(&Socket::OnSocketWriteReadyNative, &sock, std::ref(sock)));
667 }
668 }
669
OnSocketWriteReadyNative(Socket & sock)670 void Socket::OnSocketWriteReadyNative(Socket &sock)
671 {
672 LOG_INFO("[sock]%{public}s", __func__);
673
674 sock.isCanRead_ = true;
675
676 if (sock.recvBufLen_ == 0) {
677 LOG_INFO("[sock]%{public}s recvbuf has been send", __func__);
678 sock.ReadData();
679 return;
680 }
681
682 SocketSendRet sendRet = SendDataToApp(sock.transportFd_, sock.recvDataBuf_, sock.recvBufLen_);
683 switch (sendRet) {
684 case SOCKET_SEND_NONE:
685 case SOCKET_SEND_PARTIAL:
686 sock.isCanRead_ = false;
687 SocketThread::GetInstance().AddSocket(
688 sock.transportFd_, 1, sock);
689 break;
690 case SOCKET_SEND_ERROR:
691 sock.isCanRead_ = false;
692 LOG_INFO("[sock]%{public}s close socket", __func__);
693 SocketThread::GetInstance().DeleteSocket(sock);
694 sock.CloseSocket(false);
695 break;
696 case SOCKET_SEND_ALL:
697 sock.isCanRead_ = true;
698 (void)memset_s(sock.recvDataBuf_, SOCK_DEF_RFC_MTU, 0, SOCK_DEF_RFC_MTU);
699 sock.ReadData();
700 LOG_INFO("[sock]%{public}s send data success", __func__);
701 break;
702 default:
703 break;
704 }
705 }
706
ReadData()707 void Socket::ReadData()
708 {
709 Packet *pkt = nullptr;
710 uint8_t *pData = nullptr;
711 Buffer *buf = nullptr;
712
713 while (true) {
714 if (!this->isCanRead_) {
715 LOG_DEBUG("[sock]%{public}s can not read.", __func__);
716 return;
717 }
718
719 if (this->isNewSocket_) {
720 if (this->newSockTransport_ == nullptr) {
721 LOG_DEBUG("[sock]%{public}s newSockTransport is null", __func__);
722 return;
723 }
724 if (this->newSockTransport_->Read(&pkt) != 0) {
725 break;
726 }
727 } else {
728 if (this->sockTransport_->Read(&pkt) != 0) {
729 break;
730 }
731 }
732
733 if (pkt == nullptr) {
734 LOG_ERROR("[sock]%{public}s pkt is null", __func__);
735 return;
736 }
737
738 size_t len = PacketPayloadSize(pkt);
739 if (len == 0) {
740 break;
741 }
742 buf = PacketContinuousPayload(pkt);
743 if (buf != nullptr) {
744 pData = (uint8_t *)BufferPtr(buf);
745 }
746 if (pData == nullptr) {
747 return;
748 }
749
750 this->WriteDataToAPP(pData, len);
751
752 if (pkt != nullptr) {
753 PacketFree(pkt);
754 pkt = nullptr;
755 }
756 }
757 }
758
WriteDataToAPP(const uint8_t * buffer,size_t len)759 void Socket::WriteDataToAPP(const uint8_t *buffer, size_t len)
760 {
761 LOG_INFO("[sock]%{public}s", __func__);
762
763 SocketSendRet sendRet = SendDataToApp(this->transportFd_, buffer, len);
764 switch (sendRet) {
765 case SOCKET_SEND_NONE:
766 case SOCKET_SEND_PARTIAL:
767 LOG_INFO("[sock]%{public}s SOCKET_SEND_PARTIAL", __func__);
768 this->isCanRead_ = false;
769 (void)memcpy_s(this->recvDataBuf_, SOCK_DEF_RFC_MTU, buffer, len);
770 this->recvBufLen_ = len;
771 SocketThread::GetInstance().AddSocket(this->transportFd_, 1, *this);
772 break;
773 case SOCKET_SEND_ERROR:
774 this->isCanRead_ = false;
775 LOG_INFO("[sock]%{public}s send data error", __func__);
776 SocketThread::GetInstance().DeleteSocket(*this);
777 this->CloseSocket(false);
778 break;
779 case SOCKET_SEND_ALL:
780 this->isCanRead_ = true;
781 LOG_INFO("[sock]%{public}s send data success", __func__);
782 break;
783 default:
784 break;
785 }
786 }
787
WriteData()788 void Socket::WriteData()
789 {
790 LOG_INFO("[sock]%{public}s", __func__);
791
792 int totalSize = 0;
793
794 {
795 std::lock_guard<std::mutex> lock(fdMutex_);
796 if (ioctl(this->transportFd_, FIONREAD, &totalSize) != 0) {
797 LOG_ERROR("[sock]%{public}s ioctl read fd error", __func__);
798 return;
799 }
800 }
801
802 if (totalSize == 0) {
803 LOG_DEBUG("[sock]%{public}s recv buffer has no data", __func__);
804 return;
805 }
806
807 LOG_INFO("[sock]%{public}s totalSize:%{public}d", __func__, totalSize);
808
809 while (totalSize > 0) {
810 if (this->isCanWrite_) {
811 int mallocSize = (totalSize > this->sendMTU_) ? this->sendMTU_ : totalSize;
812
813 Packet *wPkt = PacketMalloc(0, 0, mallocSize);
814 if (wPkt == nullptr) {
815 LOG_INFO("[sock]pkt is null");
816 return;
817 }
818 Buffer *wPayloadBuf = PacketContinuousPayload(wPkt);
819 void *buffer = BufferPtr(wPayloadBuf);
820
821 int wbytes = read(this->transportFd_, buffer, mallocSize);
822 LOG_INFO("[sock]%{public}s wbytes:%{public}d", __func__, wbytes);
823 if (wbytes <= 0) {
824 LOG_DEBUG("[sock]%{public}s socket fd exception", __func__);
825 PacketFree(wPkt);
826 return;
827 }
828 int ret = TransportWrite(wPkt);
829 if (ret < 0) {
830 LOG_DEBUG("[sock]%{public}s stack write failed", __func__);
831 (void)memcpy_s(this->sendDataBuf_, wbytes, buffer, wbytes);
832 this->sendBufLen_ = wbytes;
833 this->isCanWrite_ = false;
834 PacketFree(wPkt);
835 return;
836 }
837 totalSize -= wbytes;
838 PacketFree(wPkt);
839 } else {
840 return;
841 }
842 }
843 }
844
TransportWrite(Packet * subPkt)845 int Socket::TransportWrite(Packet *subPkt)
846 {
847 LOG_INFO("[sock]%{public}s", __func__);
848
849 RawAddress rawAddr = RawAddress::ConvertToString(this->remoteAddr_.addr);
850 IPowerManager::GetInstance().StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_SPP, rawAddr);
851
852 int ret = 0;
853 if (this->isNewSocket_) {
854 if (this->newSockTransport_ == nullptr) {
855 LOG_DEBUG("[sock]%{public}s newSockTransport is nullptr", __func__);
856 } else {
857 ret = this->newSockTransport_->Write(subPkt);
858 }
859 } else {
860 ret = this->sockTransport_->Write(subPkt);
861 }
862 IPowerManager::GetInstance().StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_SPP, rawAddr);
863 return ret;
864 }
865
OnSocketException(Socket & sock)866 void Socket::OnSocketException(Socket &sock)
867 {
868 LOG_INFO("[sock]%{public}s", __func__);
869
870 SocketService *socketService =
871 static_cast<SocketService *>(IProfileManager::GetInstance()->GetProfileService(PROFILE_NAME_SPP));
872 if (socketService != nullptr) {
873 socketService->GetDispatcher()->PostTask(std::bind(&Socket::OnSocketExceptionNative, &sock, std::ref(sock)));
874 }
875 }
876
OnSocketExceptionNative(Socket & sock)877 void Socket::OnSocketExceptionNative(Socket &sock)
878 {
879 LOG_INFO("[sock]%{public}s", __func__);
880
881 std::lock_guard<std::recursive_mutex> lk(Socket::g_socketMutex);
882 std::vector<Socket *>::iterator it;
883
884 LOG_INFO("[sock]%{public}s size:%{public}zu", __func__, g_allServerSockets.size());
885
886 for (it = g_allServerSockets.begin(); it != g_allServerSockets.end(); ++it) {
887 if (*it == &sock) {
888 sock.CloseSocket(false);
889 break;
890 }
891 }
892 }
893
AssignServiceId()894 GAP_Service Socket::AssignServiceId()
895 {
896 int serviceId = 0;
897 for (int i = 0; i < SOCK_MAX_SERVICE_ID; i++) {
898 if (g_arrayServiceId[i] == 0) {
899 g_arrayServiceId[i] = SPP_ID_START + i;
900 serviceId = g_arrayServiceId[i];
901 break;
902 }
903 }
904 return (GAP_Service)serviceId;
905 }
906
FreeServiceId(GAP_Service serviceId)907 void Socket::FreeServiceId(GAP_Service serviceId)
908 {
909 if (serviceId >= SPP_ID_START) {
910 g_arrayServiceId[serviceId - SPP_ID_START] = 0;
911 }
912 }
913
SendDataToApp(int fd,const uint8_t * buf,size_t len)914 SocketSendRet Socket::SendDataToApp(int fd, const uint8_t *buf, size_t len)
915 {
916 LOG_INFO("[sock]%{public}s", __func__);
917
918 #ifdef DARWIN_PLATFORM
919 auto sendRet = send(fd, buf, len, MSG_DONTWAIT);
920 #else
921 auto sendRet = send(fd, buf, len, MSG_NOSIGNAL);
922 #endif
923 if (sendRet < 0) {
924 if ((errno == EAGAIN || errno == EWOULDBLOCK)) {
925 return SOCKET_SEND_NONE;
926 }
927 return SOCKET_SEND_ERROR;
928 }
929
930 if (sendRet == 0) {
931 return SOCKET_SEND_ERROR;
932 }
933
934 if (sendRet == ssize_t(len)) {
935 return SOCKET_SEND_ALL;
936 }
937
938 return SOCKET_SEND_PARTIAL;
939 }
940
NotifyServiceDeleteSocket(Socket & sock)941 void Socket::NotifyServiceDeleteSocket(Socket &sock)
942 {
943 LOG_INFO("[sock]%{public}s", __func__);
944
945 utility::Message msg(SOCKET_CLOSE);
946 msg.arg2_ = &sock;
947 SocketService *socketService =
948 static_cast<SocketService *>(IProfileManager::GetInstance()->GetProfileService(PROFILE_NAME_SPP));
949 if (socketService != nullptr) {
950 socketService->ProcessMessage(msg);
951 }
952 }
953
EraseSocket(Socket & socket)954 void Socket::EraseSocket(Socket &socket)
955 {
956 LOG_INFO("[sock]%{public}s", __func__);
957
958 std::vector<Socket *>::iterator it;
959 LOG_INFO("[sock]%{public}s size:%{public}zu", __func__, g_allServerSockets.size());
960
961 for (it = g_allServerSockets.begin(); it != g_allServerSockets.end(); ++it) {
962 if (*it == &socket) {
963 g_allServerSockets.erase(it);
964 break;
965 }
966 }
967 }
968
RemoveServerSocket()969 void Socket::RemoveServerSocket()
970 {
971 LOG_INFO("[sock]%{public}s", __func__);
972
973 CloseSocketFd();
974 EraseSocket(*this);
975 sockTransport_->RemoveServer(true);
976 }
977
CloseSocketFd()978 void Socket::CloseSocketFd()
979 {
980 LOG_INFO("[sock]%{public}s", __func__);
981 if (this->transportFd_ != SOCK_INVALID_FD) {
982 LOG_DEBUG("closefd : transportFd_:%{public}d", this->transportFd_);
983 shutdown(this->transportFd_, SHUT_RDWR);
984 close(this->transportFd_);
985 std::lock_guard<std::mutex> lock(this->fdMutex_);
986 this->transportFd_ = SOCK_INVALID_FD;
987 }
988
989 if (this->upperlayerFd_ != SOCK_INVALID_FD) {
990 LOG_DEBUG("closefd : upperlayerFd_:%{public}d", this->upperlayerFd_);
991 shutdown(this->upperlayerFd_, SHUT_RDWR);
992 close(this->upperlayerFd_);
993 this->upperlayerFd_ = SOCK_INVALID_FD;
994 }
995 }
996
GetDispatchter()997 utility::Dispatcher *Socket::GetDispatchter()
998 {
999 LOG_INFO("[sock]%{public}s", __func__);
1000 SocketService *socketService =
1001 static_cast<SocketService *>(IProfileManager::GetInstance()->GetProfileService(PROFILE_NAME_SPP));
1002 if (socketService == nullptr) {
1003 return nullptr;
1004 }
1005 return socketService->GetDispatcher();
1006 }
1007
ClearUpAllSocket()1008 void Socket::ClearUpAllSocket()
1009 {
1010 LOG_INFO("[sock]%{public}s", __func__);
1011
1012 LOG_INFO("[sock]%{public}s size:%{public}zu", __func__, g_allServerSockets.size());
1013 if (g_allServerSockets.size() > 0) {
1014 g_allServerSockets.clear();
1015 }
1016 }
1017 } // namespace bluetooth
1018 } // namespace OHOS
1019