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",
291 socket.socketMap_.at(transport).get()->transportFd_);
292 close(socket.socketMap_.at(transport).get()->transportFd_);
293 } else {
294 LOG_ERROR("[sock]socket does not exist");
295 }
296 } else {
297 LOG_DEBUG("SockRfcDisconnectFail closefd : fd:%{public}d", socket.transportFd_);
298 close(socket.transportFd_);
299 }
300 }
301
SockRfcFcOn(Socket & socket,DataTransport * transport)302 void Socket::impl::SockRfcFcOn(Socket &socket, DataTransport *transport)
303 {
304 LOG_INFO("[sock]%{public}s", __func__);
305
306 Socket *socketTmp = nullptr;
307 if (socket.IsServer()) {
308 if (socket.socketMap_.find(transport) != socket.socketMap_.end()) {
309 socketTmp = socket.socketMap_.at(transport).get();
310 } else {
311 LOG_ERROR("socket does not exist");
312 }
313 } else {
314 socketTmp = &socket;
315 }
316 if (socketTmp == nullptr) {
317 return;
318 }
319 std::lock_guard<std::recursive_mutex> lk(socketTmp->writeMutex_);
320 if (socketTmp->sendBufLen_ > 0) {
321 Packet *wPkt = PacketMalloc(0, 0, socketTmp->sendBufLen_);
322 Buffer *wPayloadBuf = PacketContinuousPayload(wPkt);
323 void *buffer = BufferPtr(wPayloadBuf);
324 (void)memcpy_s(buffer, socketTmp->sendBufLen_, socketTmp->sendDataBuf_, socketTmp->sendBufLen_);
325 if (wPayloadBuf == nullptr) {
326 if (wPkt != nullptr) {
327 PacketFree(wPkt);
328 }
329 return;
330 }
331 int ret = socketTmp->TransportWrite(wPkt);
332 if (ret < 0) {
333 LOG_ERROR("%{public}s stack write failed", __func__);
334 } else {
335 (void)memset_s(socketTmp->sendDataBuf_, socketTmp->sendBufLen_, 0x00, socketTmp->sendBufLen_);
336 socketTmp->sendBufLen_ = 0;
337 socketTmp->isCanWrite_ = true;
338 socketTmp->WriteData();
339 }
340 if (wPkt != nullptr) {
341 PacketFree(wPkt);
342 }
343 } else {
344 socketTmp->isCanWrite_ = true;
345 socketTmp->WriteData();
346 }
347 }
348
GetMaxConnectionDevicesNum()349 int Socket::impl::GetMaxConnectionDevicesNum()
350 {
351 int number = SOCK_MAX_CLIENT;
352 if (!AdapterConfig::GetInstance()->GetValue(SECTION_SOCKET_SERVICE, PROPERTY_MAX_CONNECTED_DEVICES, number)) {
353 LOG_DEBUG("[sock]%{public}s: It's failed to get the max connection number", __FUNCTION__);
354 }
355 return number;
356 }
357
Socket()358 Socket::Socket() : pimpl(nullptr)
359 {
360 state_ = SocketState::INIT;
361 pimpl = std::make_unique<Socket::impl>();
362 this->pimpl->transportObserver_ = std::make_unique<Socket::impl::DataTransportObserverImplement>(*this);
363 }
364
~Socket()365 Socket::~Socket()
366 {}
367
Connect(const std::string & addr,const Uuid & uuid,int securityFlag,int & sockfd)368 int Socket::Connect(const std::string &addr, const Uuid &uuid, int securityFlag, int &sockfd)
369 {
370 LOG_INFO("[sock]%{public}s", __func__);
371
372 sockfd = SOCK_INVALID_FD;
373 int socketPair[2] = {SOCK_INVALID_FD, SOCK_INVALID_FD};
374
375 if (socketpair(AF_UNIX, SOCK_STREAM, 0, socketPair) == -1) {
376 LOG_ERROR("[sock]%{public}s: create rfcomm socket pair failed", __FUNCTION__);
377 return -1;
378 }
379
380 SetRemoteAddr(addr);
381
382 sdpClient_ = std::make_unique<SocketSdpClient>();
383 int ret = sdpClient_->StartDiscovery(addr, uuid, this);
384 if (ret != BT_SUCCESS) {
385 LOG_ERROR("[sock]%{public}s: Discovery SPP Service Fail!", __FUNCTION__);
386 }
387
388 upperlayerFd_ = socketPair[0];
389 transportFd_ = socketPair[1];
390
391 LOG_INFO("[sock]%{public}s appFd:%{public}d fd:%{public}d", __func__, upperlayerFd_, transportFd_);
392
393 sockfd = upperlayerFd_;
394 upperlayerFd_ = SOCK_INVALID_FD;
395 securityFlag_ = securityFlag;
396 SocketThread::GetInstance().AddSocket(transportFd_, 0, *this);
397 return ret;
398 }
399
Listen(const std::string & name,const Uuid & uuid,int securityFlag,int & sockfd)400 int Socket::Listen(const std::string &name, const Uuid &uuid, int securityFlag, int &sockfd)
401 {
402 LOG_INFO("[sock]%{public}s", __func__);
403
404 isServer_ = true;
405 sockfd = SOCK_INVALID_FD;
406 int socketPair[2] = {SOCK_INVALID_FD, SOCK_INVALID_FD};
407 if (socketpair(AF_UNIX, SOCK_STREAM, 0, socketPair) == -1) {
408 LOG_ERROR("[sock]%{public}s: create listen socket failed", __FUNCTION__);
409 return -1;
410 }
411 upperlayerFd_ = socketPair[0];
412 transportFd_ = socketPair[1];
413 LOG_INFO("[sock]%{public}s appFd:%{public}d fd:%{public}d", __func__, upperlayerFd_, transportFd_);
414 sockfd = upperlayerFd_;
415 upperlayerFd_ = SOCK_INVALID_FD;
416 securityFlag_ = securityFlag;
417 state_ = LISTEN;
418
419 SocketThread::GetInstance().AddSocket(transportFd_, 0, *this);
420
421 scn_ = RFCOMM_AssignServerNum();
422
423 sdpServer_ = std::make_unique<SocketSdpServer>();
424 int ret = sdpServer_->RegisterSdpService(name, uuid, scn_);
425 if (ret != BT_SUCCESS) {
426 LOG_ERROR("[sock]%{public}s: Discovery SPP Service Fail!", __FUNCTION__);
427 }
428
429 serviceId_ = AssignServiceId();
430 LOG_INFO("[sock]%{public}s securityFlag:%{public}d serviceId_:%{public}d", __func__, securityFlag_, serviceId_);
431 socketGapServer_ = std::make_unique<SocketGapServer>();
432 socketGapServer_->RegisterServiceSecurity(scn_, securityFlag_, serviceId_);
433
434 sockTransport_ = std::move(transportFactory_->CreateRfcommTransport(
435 nullptr, scn_, SOCK_DEF_RFC_MTU, *this->pimpl->transportObserver_.get(), *GetDispatchter()));
436 sockTransport_->RegisterServer();
437
438 std::lock_guard<std::recursive_mutex> lk(Socket::g_socketMutex);
439 g_allServerSockets.push_back(this);
440 return ret;
441 }
442
ReceiveSdpResult(uint8_t scn)443 int Socket::ReceiveSdpResult(uint8_t scn)
444 {
445 LOG_INFO("[sock]%{public}s", __func__);
446
447 serviceId_ = AssignServiceId();
448 scn_ = scn;
449 LOG_INFO("[sock]%{public}s securityFlag:%{public}d serviceId_:%{public}d scn:%hhu",
450 __func__, securityFlag_, serviceId_, scn_);
451 if (scn_ > SOCK_MAX_SERVER) {
452 LOG_INFO("[sock]%{public}s scn invalid", __func__);
453 return -1;
454 }
455
456 socketGapClient_ = std::make_unique<SocketGapClient>();
457 socketGapClient_->RegisterServiceSecurity(remoteAddr_, scn_, securityFlag_, serviceId_);
458 RawAddress rawAddr = RawAddress::ConvertToString(remoteAddr_.addr);
459 sockTransport_ = std::move(transportFactory_->CreateRfcommTransport(
460 &rawAddr, scn_, SOCK_DEF_RFC_MTU, *this->pimpl->transportObserver_.get(), *GetDispatchter()));
461
462 switch (state_) {
463 case INIT:
464 if (sockTransport_->Connect() < 0) {
465 LOG_ERROR("[sock]create rfcomm channel failed");
466 SocketThread::GetInstance().DeleteSocket(*this);
467 CloseSocketFd();
468 return -1;
469 }
470 state_ = CONNECTING;
471 break;
472 default:
473 LOG_ERROR("[sock]create rfcomm channel failed");
474 break;
475 }
476 return 0;
477 }
478
AddSocketInternal(BtAddr addr,DataTransport * transport,uint16_t sendMTU,uint16_t recvMTU)479 int Socket::AddSocketInternal(BtAddr addr, DataTransport *transport, uint16_t sendMTU, uint16_t recvMTU)
480 {
481 LOG_INFO("[sock]%{public}s", __func__);
482
483 std::unique_ptr<Socket> acceptSocket = std::make_unique<Socket>();
484 int socketPair[2] = {SOCK_INVALID_FD, SOCK_INVALID_FD};
485 if (socketpair(AF_UNIX, SOCK_STREAM, 0, socketPair) == -1) {
486 LOG_ERROR("[sock]create accept socket failed");
487 }
488 LOG_DEBUG("AddSocketInternal : fd:%{public}d, fd:%{public}d", socketPair[0], socketPair[1]);
489 acceptSocket->upperlayerFd_ = socketPair[0];
490 acceptSocket->transportFd_ = socketPair[1];
491 acceptSocket->remoteAddr_ = addr;
492 acceptSocket->isNewSocket_ = true;
493 acceptSocket->isServer_ = true;
494 acceptSocket->state_ = SocketState::CONNECTED;
495 acceptSocket->sendMTU_ = sendMTU;
496 acceptSocket->recvMTU_ = recvMTU;
497 acceptSocket->newSockTransport_ = transport;
498 mutex_.lock();
499 auto it = socketMap_.emplace(transport, std::move(acceptSocket));
500 mutex_.unlock();
501
502 SocketThread::GetInstance().AddSocket(
503 it.first->second.get()->transportFd_, 0, *(it.first->second.get()));
504
505 utility::Message msg(SOCKET_ACCEPT_NEW);
506 msg.arg1_ = socketPair[0];
507 msg.arg2_ = it.first->second.get();
508 SocketService *socketService =
509 static_cast<SocketService *>(IProfileManager::GetInstance()->GetProfileService(PROFILE_NAME_SPP));
510 if (socketService != nullptr) {
511 socketService->ProcessMessage(msg);
512 }
513
514 std::lock_guard<std::recursive_mutex> lck(Socket::g_socketMutex);
515 g_allServerSockets.push_back(it.first->second.get());
516
517 if (socketPair[0] < 0) {
518 LOG_ERROR("[sock]create accept socket failed");
519 }
520 return socketPair[0];
521 }
522
SendAppConnectInfo(int fd,BtAddr addr,bool status,int acceptFd)523 bool Socket::SendAppConnectInfo(int fd, BtAddr addr, bool status, int acceptFd)
524 {
525 LOG_INFO("[sock]%{public}s", __func__);
526
527 SocketConnectInfo connectInfo;
528 (void)memset_s(&connectInfo, sizeof(connectInfo), 0, sizeof(connectInfo));
529 (void)memcpy_s(connectInfo.addr, sizeof(addr.addr), addr.addr, sizeof(addr.addr));
530 connectInfo.status = status;
531 LOG_INFO("[sock]%{public}s size:%{public}zu", __func__, sizeof(connectInfo));
532 if (acceptFd == -1) {
533 return SocketUtil::SocketSendData(fd, reinterpret_cast<const uint8_t *>(&connectInfo), sizeof(connectInfo));
534 } else {
535 return SocketUtil::SocketSendFd(fd, reinterpret_cast<const uint8_t *>(&connectInfo),
536 sizeof(connectInfo), acceptFd);
537 }
538 }
539
ProcessDisconnection(Socket & socket,DataTransport * transport)540 void Socket::ProcessDisconnection(Socket &socket, DataTransport *transport)
541 {
542 LOG_INFO("[sock]%{public}s", __func__);
543
544 IPowerManager::GetInstance().StatusUpdate(
545 RequestStatus::CONNECT_OFF, PROFILE_NAME_SPP, RawAddress::ConvertToString(socket.remoteAddr_.addr));
546
547 if (socket.IsServer()) {
548 if (socket.socketMap_.find(transport) != socket.socketMap_.end()) {
549 socket.clientNumber_--;
550 Socket *serverSocket = nullptr;
551 serverSocket = socket.socketMap_.at(transport).get();
552 serverSocket->state_ = DISCONNECTED;
553 serverSocket->newSockTransport_ = nullptr;
554 SocketThread::GetInstance().DeleteSocket(*serverSocket);
555 serverSocket->CloseSocketFd();
556 std::lock_guard<std::recursive_mutex> lk(Socket::g_socketMutex);
557 Socket::EraseSocket(*serverSocket);
558 socket.socketMap_.erase(transport);
559 socket.NotifyServiceDeleteSocket(*serverSocket);
560 if (transport != nullptr) {
561 delete transport;
562 }
563 } else {
564 LOG_ERROR("[sock]socket does not exist");
565 }
566 } else {
567 socket.state_ = DISCONNECTED;
568 socketGapClient_->UnregisterSecurity(remoteAddr_, scn_, serviceId_);
569 FreeServiceId(serviceId_);
570 SocketThread::GetInstance().DeleteSocket(*this);
571 socket.CloseSocketFd();
572 std::lock_guard<std::recursive_mutex> lk(Socket::g_socketMutex);
573 Socket::EraseSocket(socket);
574 Socket::NotifyServiceDeleteSocket(socket);
575 }
576 }
577
SetRemoteAddr(std::string addr)578 void Socket::SetRemoteAddr(std::string addr)
579 {
580 LOG_INFO("[sock]%{public}s", __func__);
581
582 RawAddress rawAddr(addr);
583 rawAddr.ConvertToUint8(remoteAddr_.addr);
584 remoteAddr_.type = BT_PUBLIC_DEVICE_ADDRESS;
585 }
586
CloseSocket(bool isDisable)587 void Socket::CloseSocket(bool isDisable)
588 {
589 LOG_INFO("[sock]%{public}s", __func__);
590
591 CloseSocketFd();
592
593 if (isServer_ && (!isNewSocket_)) {
594 RFCOMM_FreeServerNum(scn_);
595 sdpServer_->UnregisterSdpService();
596 socketGapServer_->UnregisterSecurity(remoteAddr_, scn_, serviceId_);
597 FreeServiceId(serviceId_);
598 if (isDisable) {
599 sockTransport_->RemoveServer(true);
600 } else {
601 sockTransport_->RemoveServer(false);
602 }
603 state_ = CLOSED;
604 NotifyServiceDeleteSocket(*this);
605 std::lock_guard<std::recursive_mutex> lk(Socket::g_socketMutex);
606 EraseSocket(*this);
607 return;
608 }
609
610 if (state_ == CONNECTED || state_ == CONNECTING) {
611 LOG_INFO("[sock]%{public}s close connection", __func__);
612 if (isServer_) {
613 socketGapServer_->UnregisterSecurity(remoteAddr_, scn_, serviceId_);
614 } else {
615 socketGapClient_->UnregisterSecurity(remoteAddr_, scn_, serviceId_);
616 }
617 FreeServiceId(serviceId_);
618
619 if (isServer_) {
620 if (newSockTransport_ != nullptr) {
621 newSockTransport_->Disconnect();
622 } else {
623 LOG_ERROR("[sock]%{public}s newSockTransport is null", __func__);
624 }
625 } else {
626 if (sockTransport_ != nullptr) {
627 sockTransport_->Disconnect();
628 } else {
629 LOG_ERROR("[sock]%{public}s client sockTransport is null", __func__);
630 }
631 }
632 } else if (state_ == INIT || state_ == DISCONNECTED) {
633 LOG_INFO("[sock]%{public}s close no connection", __func__);
634 NotifyServiceDeleteSocket(*this);
635 }
636 }
637
OnSocketReadReady(Socket & sock)638 void Socket::OnSocketReadReady(Socket &sock)
639 {
640 std::lock_guard<std::recursive_mutex> lk(Socket::g_socketMutex);
641 std::vector<Socket *>::iterator it = find(g_allServerSockets.begin(), g_allServerSockets.end(), &sock);
642 if (it == g_allServerSockets.end()) {
643 LOG_DEBUG("[sock]%{public}s socket does not exist", __func__);
644 return;
645 }
646
647 std::lock_guard<std::recursive_mutex> lck(sock.writeMutex_);
648 if (sock.isCanWrite_) {
649 LOG_INFO("[sock]%{public}s socket write data", __func__);
650 sock.WriteData();
651 }
652 }
653
OnSocketWriteReady(Socket & sock)654 void Socket::OnSocketWriteReady(Socket &sock)
655 {
656 LOG_INFO("[sock]%{public}s", __func__);
657
658 std::lock_guard<std::recursive_mutex> lk(Socket::g_socketMutex);
659 std::vector<Socket *>::iterator it = find(g_allServerSockets.begin(), g_allServerSockets.end(), &sock);
660 if (it == g_allServerSockets.end()) {
661 LOG_DEBUG("[sock]%{public}s socket does not exist", __func__);
662 return;
663 }
664
665 SocketService *socketService =
666 static_cast<SocketService *>(IProfileManager::GetInstance()->GetProfileService(PROFILE_NAME_SPP));
667 if (socketService != nullptr) {
668 socketService->GetDispatcher()->PostTask(std::bind(&Socket::OnSocketWriteReadyNative, &sock, std::ref(sock)));
669 }
670 }
671
OnSocketWriteReadyNative(Socket & sock)672 void Socket::OnSocketWriteReadyNative(Socket &sock)
673 {
674 LOG_INFO("[sock]%{public}s", __func__);
675
676 sock.isCanRead_ = true;
677
678 if (sock.recvBufLen_ == 0) {
679 LOG_INFO("[sock]%{public}s recvbuf has been send", __func__);
680 sock.ReadData();
681 return;
682 }
683
684 SocketSendRet sendRet = SendDataToApp(sock.transportFd_, sock.recvDataBuf_, sock.recvBufLen_);
685 switch (sendRet) {
686 case SOCKET_SEND_NONE:
687 case SOCKET_SEND_PARTIAL:
688 sock.isCanRead_ = false;
689 SocketThread::GetInstance().AddSocket(
690 sock.transportFd_, 1, sock);
691 break;
692 case SOCKET_SEND_ERROR:
693 sock.isCanRead_ = false;
694 LOG_INFO("[sock]%{public}s close socket", __func__);
695 SocketThread::GetInstance().DeleteSocket(sock);
696 sock.CloseSocket(false);
697 break;
698 case SOCKET_SEND_ALL:
699 sock.isCanRead_ = true;
700 (void)memset_s(sock.recvDataBuf_, SOCK_DEF_RFC_MTU, 0, SOCK_DEF_RFC_MTU);
701 sock.ReadData();
702 LOG_INFO("[sock]%{public}s send data success", __func__);
703 break;
704 default:
705 break;
706 }
707 }
708
ReadData()709 void Socket::ReadData()
710 {
711 Packet *pkt = nullptr;
712 uint8_t *pData = nullptr;
713 Buffer *buf = nullptr;
714
715 while (true) {
716 if (!this->isCanRead_) {
717 LOG_DEBUG("[sock]%{public}s can not read.", __func__);
718 return;
719 }
720
721 if (this->isNewSocket_) {
722 if (this->newSockTransport_ == nullptr) {
723 LOG_DEBUG("[sock]%{public}s newSockTransport is null", __func__);
724 return;
725 }
726 if (this->newSockTransport_->Read(&pkt) != 0) {
727 break;
728 }
729 } else {
730 if (this->sockTransport_->Read(&pkt) != 0) {
731 break;
732 }
733 }
734
735 if (pkt == nullptr) {
736 LOG_ERROR("[sock]%{public}s pkt is null", __func__);
737 return;
738 }
739
740 size_t len = PacketPayloadSize(pkt);
741 if (len == 0) {
742 break;
743 }
744 buf = PacketContinuousPayload(pkt);
745 if (buf != nullptr) {
746 pData = (uint8_t *)BufferPtr(buf);
747 }
748 if (pData == nullptr) {
749 return;
750 }
751
752 this->WriteDataToAPP(pData, len);
753
754 if (pkt != nullptr) {
755 PacketFree(pkt);
756 pkt = nullptr;
757 }
758 }
759 }
760
WriteDataToAPP(const uint8_t * buffer,size_t len)761 void Socket::WriteDataToAPP(const uint8_t *buffer, size_t len)
762 {
763 LOG_INFO("[sock]%{public}s", __func__);
764
765 SocketSendRet sendRet = SendDataToApp(this->transportFd_, buffer, len);
766 switch (sendRet) {
767 case SOCKET_SEND_NONE:
768 case SOCKET_SEND_PARTIAL:
769 LOG_INFO("[sock]%{public}s SOCKET_SEND_PARTIAL", __func__);
770 this->isCanRead_ = false;
771 (void)memcpy_s(this->recvDataBuf_, SOCK_DEF_RFC_MTU, buffer, len);
772 this->recvBufLen_ = len;
773 SocketThread::GetInstance().AddSocket(this->transportFd_, 1, *this);
774 break;
775 case SOCKET_SEND_ERROR:
776 this->isCanRead_ = false;
777 LOG_INFO("[sock]%{public}s send data error", __func__);
778 SocketThread::GetInstance().DeleteSocket(*this);
779 this->CloseSocket(false);
780 break;
781 case SOCKET_SEND_ALL:
782 this->isCanRead_ = true;
783 LOG_INFO("[sock]%{public}s send data success", __func__);
784 break;
785 default:
786 break;
787 }
788 }
789
WriteData()790 void Socket::WriteData()
791 {
792 LOG_INFO("[sock]%{public}s", __func__);
793
794 int totalSize = 0;
795
796 {
797 std::lock_guard<std::mutex> lock(fdMutex_);
798 if (ioctl(this->transportFd_, FIONREAD, &totalSize) != 0) {
799 LOG_ERROR("[sock]%{public}s ioctl read fd error", __func__);
800 return;
801 }
802 }
803
804 if (totalSize == 0) {
805 LOG_DEBUG("[sock]%{public}s recv buffer has no data", __func__);
806 return;
807 }
808
809 LOG_INFO("[sock]%{public}s totalSize:%{public}d", __func__, totalSize);
810
811 while (totalSize > 0) {
812 if (this->isCanWrite_) {
813 int mallocSize = (totalSize > this->sendMTU_) ? this->sendMTU_ : totalSize;
814
815 Packet *wPkt = PacketMalloc(0, 0, mallocSize);
816 if (wPkt == nullptr) {
817 LOG_INFO("[sock]pkt is null");
818 return;
819 }
820 Buffer *wPayloadBuf = PacketContinuousPayload(wPkt);
821 void *buffer = BufferPtr(wPayloadBuf);
822
823 int wbytes = read(this->transportFd_, buffer, mallocSize);
824 LOG_INFO("[sock]%{public}s wbytes:%{public}d", __func__, wbytes);
825 if (wbytes <= 0) {
826 LOG_DEBUG("[sock]%{public}s socket fd exception", __func__);
827 PacketFree(wPkt);
828 return;
829 }
830 int ret = TransportWrite(wPkt);
831 if (ret < 0) {
832 LOG_DEBUG("[sock]%{public}s stack write failed", __func__);
833 (void)memcpy_s(this->sendDataBuf_, wbytes, buffer, wbytes);
834 this->sendBufLen_ = wbytes;
835 this->isCanWrite_ = false;
836 PacketFree(wPkt);
837 return;
838 }
839 totalSize -= wbytes;
840 PacketFree(wPkt);
841 } else {
842 return;
843 }
844 }
845 }
846
TransportWrite(Packet * subPkt)847 int Socket::TransportWrite(Packet *subPkt)
848 {
849 LOG_INFO("[sock]%{public}s", __func__);
850
851 RawAddress rawAddr = RawAddress::ConvertToString(this->remoteAddr_.addr);
852 IPowerManager::GetInstance().StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_SPP, rawAddr);
853
854 int ret = 0;
855 if (this->isNewSocket_) {
856 if (this->newSockTransport_ == nullptr) {
857 LOG_DEBUG("[sock]%{public}s newSockTransport is nullptr", __func__);
858 } else {
859 ret = this->newSockTransport_->Write(subPkt);
860 }
861 } else {
862 ret = this->sockTransport_->Write(subPkt);
863 }
864 IPowerManager::GetInstance().StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_SPP, rawAddr);
865 return ret;
866 }
867
OnSocketException(Socket & sock)868 void Socket::OnSocketException(Socket &sock)
869 {
870 LOG_INFO("[sock]%{public}s", __func__);
871
872 SocketService *socketService =
873 static_cast<SocketService *>(IProfileManager::GetInstance()->GetProfileService(PROFILE_NAME_SPP));
874 if (socketService != nullptr) {
875 socketService->GetDispatcher()->PostTask(std::bind(&Socket::OnSocketExceptionNative, &sock, std::ref(sock)));
876 }
877 }
878
OnSocketExceptionNative(Socket & sock)879 void Socket::OnSocketExceptionNative(Socket &sock)
880 {
881 LOG_INFO("[sock]%{public}s", __func__);
882
883 std::lock_guard<std::recursive_mutex> lk(Socket::g_socketMutex);
884 std::vector<Socket *>::iterator it;
885
886 LOG_INFO("[sock]%{public}s size:%{public}zu", __func__, g_allServerSockets.size());
887
888 for (it = g_allServerSockets.begin(); it != g_allServerSockets.end(); ++it) {
889 if (*it == &sock) {
890 sock.CloseSocket(false);
891 break;
892 }
893 }
894 }
895
AssignServiceId()896 GAP_Service Socket::AssignServiceId()
897 {
898 int serviceId = 0;
899 for (int i = 0; i < SOCK_MAX_SERVICE_ID; i++) {
900 if (g_arrayServiceId[i] == 0) {
901 g_arrayServiceId[i] = SPP_ID_START + i;
902 serviceId = g_arrayServiceId[i];
903 break;
904 }
905 }
906 return (GAP_Service)serviceId;
907 }
908
FreeServiceId(GAP_Service serviceId)909 void Socket::FreeServiceId(GAP_Service serviceId)
910 {
911 if (serviceId >= SPP_ID_START) {
912 g_arrayServiceId[serviceId - SPP_ID_START] = 0;
913 }
914 }
915
SendDataToApp(int fd,const uint8_t * buf,size_t len)916 SocketSendRet Socket::SendDataToApp(int fd, const uint8_t *buf, size_t len)
917 {
918 LOG_INFO("[sock]%{public}s", __func__);
919
920 #ifdef DARWIN_PLATFORM
921 auto sendRet = send(fd, buf, len, MSG_DONTWAIT);
922 #else
923 auto sendRet = send(fd, buf, len, MSG_NOSIGNAL);
924 #endif
925 if (sendRet < 0) {
926 if ((errno == EAGAIN || errno == EWOULDBLOCK)) {
927 return SOCKET_SEND_NONE;
928 }
929 return SOCKET_SEND_ERROR;
930 }
931
932 if (sendRet == 0) {
933 return SOCKET_SEND_ERROR;
934 }
935
936 if (sendRet == ssize_t(len)) {
937 return SOCKET_SEND_ALL;
938 }
939
940 return SOCKET_SEND_PARTIAL;
941 }
942
NotifyServiceDeleteSocket(Socket & sock)943 void Socket::NotifyServiceDeleteSocket(Socket &sock)
944 {
945 LOG_INFO("[sock]%{public}s", __func__);
946
947 utility::Message msg(SOCKET_CLOSE);
948 msg.arg2_ = &sock;
949 SocketService *socketService =
950 static_cast<SocketService *>(IProfileManager::GetInstance()->GetProfileService(PROFILE_NAME_SPP));
951 if (socketService != nullptr) {
952 socketService->ProcessMessage(msg);
953 }
954 }
955
EraseSocket(Socket & socket)956 void Socket::EraseSocket(Socket &socket)
957 {
958 LOG_INFO("[sock]%{public}s", __func__);
959
960 std::vector<Socket *>::iterator it;
961 LOG_INFO("[sock]%{public}s size:%{public}zu", __func__, g_allServerSockets.size());
962
963 for (it = g_allServerSockets.begin(); it != g_allServerSockets.end(); ++it) {
964 if (*it == &socket) {
965 g_allServerSockets.erase(it);
966 break;
967 }
968 }
969 }
970
RemoveServerSocket()971 void Socket::RemoveServerSocket()
972 {
973 LOG_INFO("[sock]%{public}s", __func__);
974
975 CloseSocketFd();
976 EraseSocket(*this);
977 sockTransport_->RemoveServer(true);
978 }
979
CloseSocketFd()980 void Socket::CloseSocketFd()
981 {
982 LOG_INFO("[sock]%{public}s", __func__);
983 if (this->transportFd_ != SOCK_INVALID_FD) {
984 LOG_DEBUG("closefd : transportFd_:%{public}d", this->transportFd_);
985 shutdown(this->transportFd_, SHUT_RDWR);
986 close(this->transportFd_);
987 std::lock_guard<std::mutex> lock(this->fdMutex_);
988 this->transportFd_ = SOCK_INVALID_FD;
989 }
990
991 if (this->upperlayerFd_ != SOCK_INVALID_FD) {
992 LOG_DEBUG("closefd : upperlayerFd_:%{public}d", this->upperlayerFd_);
993 shutdown(this->upperlayerFd_, SHUT_RDWR);
994 close(this->upperlayerFd_);
995 this->upperlayerFd_ = SOCK_INVALID_FD;
996 }
997 }
998
GetDispatchter()999 utility::Dispatcher *Socket::GetDispatchter()
1000 {
1001 LOG_INFO("[sock]%{public}s", __func__);
1002 SocketService *socketService =
1003 static_cast<SocketService *>(IProfileManager::GetInstance()->GetProfileService(PROFILE_NAME_SPP));
1004 if (socketService == nullptr) {
1005 return nullptr;
1006 }
1007 return socketService->GetDispatcher();
1008 }
1009
ClearUpAllSocket()1010 void Socket::ClearUpAllSocket()
1011 {
1012 LOG_INFO("[sock]%{public}s", __func__);
1013
1014 LOG_INFO("[sock]%{public}s size:%{public}zu", __func__, g_allServerSockets.size());
1015 if (g_allServerSockets.size() > 0) {
1016 g_allServerSockets.clear();
1017 }
1018 }
1019 } // namespace bluetooth
1020 } // namespace OHOS
1021