1 /*
2 * Copyright (c) 2021-2024 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 "client_trans_tcp_direct_listener.h"
17
18 #include <stdbool.h>
19 #include <unistd.h>
20 #include <securec.h>
21 #include <stdatomic.h>
22
23 #include "client_trans_tcp_direct_callback.h"
24 #include "client_trans_tcp_direct_manager.h"
25 #include "client_trans_tcp_direct_message.h"
26 #include "softbus_adapter_thread.h"
27 #include "softbus_base_listener.h"
28 #include "softbus_errcode.h"
29 #include "softbus_socket.h"
30 #include "trans_log.h"
31
32 typedef struct {
33 SoftBusMutex lock;
34 _Atomic bool lockInit;
35 } SoftBusTcpListenerLock;
36
37 static SoftBusTcpListenerLock g_lock = {
38 .lockInit = false,
39 };
40
41 static bool g_isInitedFlag = false;
42
43
TdcLockInit(void)44 static void TdcLockInit(void)
45 {
46 if (!atomic_load_explicit(&(g_lock.lockInit), memory_order_acquire)) {
47 if (SoftBusMutexInit(&g_lock.lock, NULL) != SOFTBUS_OK) {
48 TRANS_LOGE(TRANS_INIT, "TDC lock init failed");
49 return;
50 }
51 atomic_store_explicit(&(g_lock.lockInit), true, memory_order_release);
52 }
53 }
ClientTdcOnConnectEvent(ListenerModule module,int cfd,const ConnectOption * clientAddr)54 static int32_t ClientTdcOnConnectEvent(ListenerModule module, int cfd,
55 const ConnectOption *clientAddr)
56 {
57 (void)module;
58 (void)cfd;
59 (void)clientAddr;
60 return SOFTBUS_OK;
61 }
62
ClientTdcOnDataEvent(ListenerModule module,int events,int32_t fd)63 static int32_t ClientTdcOnDataEvent(ListenerModule module, int events, int32_t fd)
64 {
65 (void)module;
66 TcpDirectChannelInfo channel;
67 (void)memset_s(&channel, sizeof(TcpDirectChannelInfo), 0, sizeof(TcpDirectChannelInfo));
68 if (TransTdcGetInfoByFd(fd, &channel) == NULL) {
69 TransTdcReleaseFd(fd);
70 TRANS_LOGE(TRANS_SDK, "can not match fd. release fd=%{public}d", fd);
71 return SOFTBUS_MEM_ERR;
72 }
73
74 if (events == SOFTBUS_SOCKET_IN) {
75 int32_t channelId = channel.channelId;
76 int32_t ret = TransTdcRecvData(channelId);
77 if (ret == SOFTBUS_DATA_NOT_ENOUGH) {
78 TRANS_LOGE(TRANS_SDK, "client process data fail, SOFTBUS_DATA_NOT_ENOUGH. channelId=%{public}d", channelId);
79 return SOFTBUS_OK;
80 }
81 if (ret != SOFTBUS_OK) {
82 TRANS_LOGE(TRANS_SDK, "client process data fail, channelId=%{public}d, ret=%{public}d", channelId, ret);
83 TransDelDataBufNode(channelId);
84 TransTdcCloseChannel(channelId);
85 ClientTransTdcOnSessionClosed(channelId, SHUTDOWN_REASON_RECV_DATA_ERR);
86 return ret;
87 }
88 }
89 return SOFTBUS_OK;
90 }
91
TransTdcCreateListener(int32_t fd)92 int32_t TransTdcCreateListener(int32_t fd)
93 {
94 TdcLockInit();
95 if (SoftBusMutexLock(&g_lock.lock) != SOFTBUS_OK) {
96 TRANS_LOGE(TRANS_SDK, "lock failed.");
97 return SOFTBUS_LOCK_ERR;
98 }
99 if (g_isInitedFlag == false) {
100 g_isInitedFlag = true;
101
102 static SoftbusBaseListener listener = {
103 .onConnectEvent = ClientTdcOnConnectEvent,
104 .onDataEvent = ClientTdcOnDataEvent,
105 };
106 int32_t ret = StartBaseClient(DIRECT_CHANNEL_CLIENT, &listener);
107 if (ret != SOFTBUS_OK) {
108 TRANS_LOGE(TRANS_SDK, "start sdk base listener failed, ret=%{public}d", ret);
109 SoftBusMutexUnlock(&g_lock.lock);
110 return ret;
111 }
112 TRANS_LOGI(TRANS_SDK, "create sdk listener success. fd=%{public}d", fd);
113 }
114 SoftBusMutexUnlock(&g_lock.lock);
115
116 return AddTrigger(DIRECT_CHANNEL_CLIENT, fd, READ_TRIGGER);
117 }
118
TransTdcCreateListenerWithoutAddTrigger(int32_t fd)119 int32_t TransTdcCreateListenerWithoutAddTrigger(int32_t fd)
120 {
121 TdcLockInit();
122 if (SoftBusMutexLock(&g_lock.lock) != SOFTBUS_OK) {
123 TRANS_LOGE(TRANS_SDK, "lock failed.");
124 return SOFTBUS_LOCK_ERR;
125 }
126 if (!g_isInitedFlag) {
127 static SoftbusBaseListener listener = {
128 .onConnectEvent = ClientTdcOnConnectEvent,
129 .onDataEvent = ClientTdcOnDataEvent,
130 };
131 int32_t ret = StartBaseClient(DIRECT_CHANNEL_CLIENT, &listener);
132 if (ret != SOFTBUS_OK) {
133 TRANS_LOGE(TRANS_SDK, "start sdk base listener failed, ret=%{public}d", ret);
134 SoftBusMutexUnlock(&g_lock.lock);
135 return ret;
136 }
137 g_isInitedFlag = true;
138 TRANS_LOGI(TRANS_SDK, "create sdk listener success.fd=%{public}d", fd);
139 }
140 SoftBusMutexUnlock(&g_lock.lock);
141
142 return SOFTBUS_OK;
143 }
144
TransTdcCloseFd(int32_t fd)145 void TransTdcCloseFd(int32_t fd)
146 {
147 if (fd < 0) {
148 TRANS_LOGI(TRANS_SDK, "fd less than zero");
149 return;
150 }
151 DelTrigger(DIRECT_CHANNEL_CLIENT, fd, READ_TRIGGER);
152 ConnCloseSocket(fd);
153 }
154
TransTdcReleaseFd(int32_t fd)155 void TransTdcReleaseFd(int32_t fd)
156 {
157 if (fd < 0) {
158 TRANS_LOGI(TRANS_SDK, "fd less than zero");
159 return;
160 }
161 DelTrigger(DIRECT_CHANNEL_CLIENT, fd, READ_TRIGGER);
162 ConnShutdownSocket(fd);
163 }
164
TransTdcStopRead(int32_t fd)165 int32_t TransTdcStopRead(int32_t fd)
166 {
167 if (fd < 0) {
168 TRANS_LOGI(TRANS_SDK, "fd less than zero");
169 return SOFTBUS_OK;
170 }
171 return DelTrigger(DIRECT_CHANNEL_CLIENT, fd, READ_TRIGGER);
172 }
173