1 /*
2 * Copyright (c) 2022-2025 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_file_listener.h"
17
18 #include <securec.h>
19
20 #include "anonymizer.h"
21 #include "softbus_adapter_mem.h"
22 #include "softbus_adapter_thread.h"
23 #include "softbus_def.h"
24 #include "softbus_error_code.h"
25 #include "softbus_utils.h"
26 #include "trans_log.h"
27
28 static SoftBusList *g_fileListener = NULL;
29
TransFileInit(void)30 int TransFileInit(void)
31 {
32 if (g_fileListener != NULL) {
33 TRANS_LOGI(TRANS_INIT, "file listener has init.");
34 return SOFTBUS_OK;
35 }
36 g_fileListener = CreateSoftBusList();
37 if (g_fileListener == NULL) {
38 TRANS_LOGE(TRANS_INIT, "create file listener list failed.");
39 return SOFTBUS_MALLOC_ERR;
40 }
41 return SOFTBUS_OK;
42 }
43
TransFileDeinit(void)44 void TransFileDeinit(void)
45 {
46 if (g_fileListener == NULL) {
47 return;
48 }
49 if (SoftBusMutexLock(&(g_fileListener->lock)) != SOFTBUS_OK) {
50 TRANS_LOGE(TRANS_INIT, "file listener deinit lock failed");
51 return;
52 }
53 FileListener *fileNode = NULL;
54 FileListener *nextNode = NULL;
55 LIST_FOR_EACH_ENTRY_SAFE(fileNode, nextNode, &(g_fileListener->list), FileListener, node) {
56 ListDelete(&(fileNode->node));
57 SoftBusFree(fileNode);
58 }
59 (void)SoftBusMutexUnlock(&(g_fileListener->lock));
60 DestroySoftBusList(g_fileListener);
61 g_fileListener = NULL;
62 }
63
TransSetFileReceiveListener(const char * sessionName,const IFileReceiveListener * recvListener,const char * rootDir)64 int32_t TransSetFileReceiveListener(const char *sessionName,
65 const IFileReceiveListener *recvListener, const char *rootDir)
66 {
67 TRANS_CHECK_AND_RETURN_RET_LOGE(
68 g_fileListener != NULL, SOFTBUS_TRANS_FILE_LISTENER_NOT_INIT, TRANS_CTRL, "file listener hasn't init.");
69 if (SoftBusMutexLock(&(g_fileListener->lock)) != SOFTBUS_OK) {
70 TRANS_LOGE(TRANS_FILE, "file receive listener lock failed");
71 return SOFTBUS_LOCK_ERR;
72 }
73 FileListener *fileNode = NULL;
74 bool exist = false;
75 LIST_FOR_EACH_ENTRY(fileNode, &(g_fileListener->list), FileListener, node) {
76 if (strcmp(fileNode->mySessionName, sessionName) == 0) {
77 exist = true;
78 break;
79 }
80 }
81 if (exist) {
82 if (strcpy_s(fileNode->rootDir, FILE_RECV_ROOT_DIR_SIZE_MAX, rootDir) != EOK ||
83 memcpy_s(&(fileNode->recvListener), sizeof(IFileReceiveListener),
84 recvListener, sizeof(IFileReceiveListener)) != EOK) {
85 (void)SoftBusMutexUnlock(&(g_fileListener->lock));
86 TRANS_LOGE(TRANS_FILE, "update file receive listener failed");
87 return SOFTBUS_MEM_ERR;
88 }
89 (void)SoftBusMutexUnlock(&(g_fileListener->lock));
90 TRANS_LOGI(TRANS_FILE, "update file receive listener success");
91 return SOFTBUS_OK;
92 }
93 fileNode = (FileListener *)SoftBusCalloc(sizeof(FileListener));
94 if (fileNode == NULL) {
95 (void)SoftBusMutexUnlock(&(g_fileListener->lock));
96 TRANS_LOGE(TRANS_FILE, "file receive listener calloc failed");
97 return SOFTBUS_MALLOC_ERR;
98 }
99 if (strcpy_s(fileNode->mySessionName, SESSION_NAME_SIZE_MAX, sessionName) != EOK ||
100 strcpy_s(fileNode->rootDir, FILE_RECV_ROOT_DIR_SIZE_MAX, rootDir) != EOK ||
101 memcpy_s(&(fileNode->recvListener), sizeof(IFileReceiveListener),
102 recvListener, sizeof(IFileReceiveListener)) != EOK) {
103 TRANS_LOGE(TRANS_FILE, "file node copy failed.");
104 SoftBusFree(fileNode);
105 (void)SoftBusMutexUnlock(&(g_fileListener->lock));
106 return SOFTBUS_MEM_ERR;
107 }
108 ListAdd(&(g_fileListener->list), &(fileNode->node));
109 char *tmpName = NULL;
110 Anonymize(sessionName, &tmpName);
111 TRANS_LOGI(TRANS_FILE, "add sessionName=%{public}s", AnonymizeWrapper(tmpName));
112 AnonymizeFree(tmpName);
113 (void)SoftBusMutexUnlock(&(g_fileListener->lock));
114 return SOFTBUS_OK;
115 }
116
TransSetFileSendListener(const char * sessionName,const IFileSendListener * sendListener)117 int32_t TransSetFileSendListener(const char *sessionName, const IFileSendListener *sendListener)
118 {
119 if (g_fileListener == NULL) {
120 TRANS_LOGE(TRANS_FILE, "file listener hasn't init.");
121 return SOFTBUS_TRANS_FILE_LISTENER_NOT_INIT;
122 }
123 if (SoftBusMutexLock(&(g_fileListener->lock)) != SOFTBUS_OK) {
124 TRANS_LOGE(TRANS_FILE, "file send listener lock failed");
125 return SOFTBUS_LOCK_ERR;
126 }
127 FileListener *fileNode = NULL;
128 bool exist = false;
129 LIST_FOR_EACH_ENTRY(fileNode, &(g_fileListener->list), FileListener, node) {
130 if (strcmp(fileNode->mySessionName, sessionName) == 0) {
131 exist = true;
132 break;
133 }
134 }
135 if (exist) {
136 if (memcpy_s(&(fileNode->sendListener), sizeof(IFileSendListener),
137 sendListener, sizeof(IFileSendListener)) != EOK) {
138 (void)SoftBusMutexUnlock(&(g_fileListener->lock));
139 TRANS_LOGE(TRANS_FILE, "memcpy_s file send listener failed");
140 return SOFTBUS_MEM_ERR;
141 }
142 (void)SoftBusMutexUnlock(&(g_fileListener->lock));
143 TRANS_LOGE(TRANS_FILE, "update file send listener success");
144 return SOFTBUS_OK;
145 }
146 fileNode = (FileListener *)SoftBusCalloc(sizeof(FileListener));
147 if (fileNode == NULL) {
148 (void)SoftBusMutexUnlock(&(g_fileListener->lock));
149 TRANS_LOGE(TRANS_FILE, "file send listener calloc failed");
150 return SOFTBUS_MALLOC_ERR;
151 }
152 if (strcpy_s(fileNode->mySessionName, SESSION_NAME_SIZE_MAX, sessionName) != EOK ||
153 memcpy_s(&(fileNode->sendListener), sizeof(IFileSendListener),
154 sendListener, sizeof(IFileSendListener)) != EOK) {
155 TRANS_LOGE(TRANS_FILE, "file node copy failed.");
156 SoftBusFree(fileNode);
157 (void)SoftBusMutexUnlock(&(g_fileListener->lock));
158 return SOFTBUS_MEM_ERR;
159 }
160 ListAdd(&(g_fileListener->list), &(fileNode->node));
161 char *tmpName = NULL;
162 Anonymize(sessionName, &tmpName);
163 TRANS_LOGI(TRANS_FILE, "add sessionName=%{public}s", AnonymizeWrapper(tmpName));
164 AnonymizeFree(tmpName);
165 (void)SoftBusMutexUnlock(&(g_fileListener->lock));
166 return SOFTBUS_OK;
167 }
168
TransAddNewSocketFileListener(const char * sessionName,SocketFileCallbackFunc fileCallback,bool isReceiver)169 static int32_t TransAddNewSocketFileListener(const char *sessionName, SocketFileCallbackFunc fileCallback,
170 bool isReceiver)
171 {
172 if (sessionName == NULL || fileCallback == NULL) {
173 TRANS_LOGE(TRANS_SDK, "invalid param.");
174 return SOFTBUS_INVALID_PARAM;
175 }
176 FileListener *listener = (FileListener *)SoftBusCalloc(sizeof(FileListener));
177 if (listener == NULL) {
178 TRANS_LOGE(TRANS_SDK, "file send listener calloc failed");
179 return SOFTBUS_MALLOC_ERR;
180 }
181 if (strcpy_s(listener->mySessionName, SESSION_NAME_SIZE_MAX, sessionName) != EOK) {
182 TRANS_LOGE(TRANS_SDK, "file node copy failed.");
183 SoftBusFree(listener);
184 return SOFTBUS_STRCPY_ERR;
185 }
186 if (isReceiver) {
187 listener->socketRecvCallback = fileCallback;
188 } else {
189 listener->socketSendCallback = fileCallback;
190 }
191 ListAdd(&(g_fileListener->list), &(listener->node));
192 return SOFTBUS_OK;
193 }
194
TransSetSocketFileListener(const char * sessionName,SocketFileCallbackFunc fileCallback,bool isReceiver)195 int32_t TransSetSocketFileListener(const char *sessionName, SocketFileCallbackFunc fileCallback, bool isReceiver)
196 {
197 if (sessionName == NULL || fileCallback == NULL) {
198 TRANS_LOGE(TRANS_SDK, "[client] invalid param.");
199 return SOFTBUS_INVALID_PARAM;
200 }
201 if (g_fileListener == NULL) {
202 TRANS_LOGE(TRANS_FILE, "file listener hasn't init.");
203 return SOFTBUS_TRANS_FILE_LISTENER_NOT_INIT;
204 }
205 if (SoftBusMutexLock(&(g_fileListener->lock)) != SOFTBUS_OK) {
206 TRANS_LOGE(TRANS_SDK, "file delete lock failed");
207 return SOFTBUS_LOCK_ERR;
208 }
209
210 FileListener *fileNode = NULL;
211 bool exist = false;
212 LIST_FOR_EACH_ENTRY(fileNode, &(g_fileListener->list), FileListener, node) {
213 if (strcmp(fileNode->mySessionName, sessionName) == 0) {
214 exist = true;
215 break;
216 }
217 }
218 if (exist) {
219 if (isReceiver) {
220 fileNode->socketRecvCallback = fileCallback;
221 } else {
222 fileNode->socketSendCallback = fileCallback;
223 }
224 (void)SoftBusMutexUnlock(&(g_fileListener->lock));
225 TRANS_LOGI(TRANS_SDK, "update file callback of socket");
226 return SOFTBUS_OK;
227 }
228 int32_t ret = TransAddNewSocketFileListener(sessionName, fileCallback, isReceiver);
229 if (ret != SOFTBUS_OK) {
230 (void)SoftBusMutexUnlock(&(g_fileListener->lock));
231 TRANS_LOGE(TRANS_SDK, "failed to add new socket file listener");
232 return ret;
233 }
234 (void)SoftBusMutexUnlock(&(g_fileListener->lock));
235
236 char *tmpName = NULL;
237 Anonymize(sessionName, &tmpName);
238 TRANS_LOGI(TRANS_SDK, "set socket file listener ok, sessionName=%{public}s, isReceiver=%{public}d",
239 AnonymizeWrapper(tmpName), isReceiver);
240 AnonymizeFree(tmpName);
241 return SOFTBUS_OK;
242 }
243
TransGetFileListener(const char * sessionName,FileListener * fileListener)244 int32_t TransGetFileListener(const char *sessionName, FileListener *fileListener)
245 {
246 if (sessionName == NULL || fileListener == NULL) {
247 TRANS_LOGE(TRANS_FILE, "invalid param.");
248 return SOFTBUS_INVALID_PARAM;
249 }
250 if (g_fileListener == NULL) {
251 TRANS_LOGE(TRANS_FILE, "file listener hasn't init.");
252 return SOFTBUS_TRANS_FILE_LISTENER_NOT_INIT;
253 }
254 if (SoftBusMutexLock(&(g_fileListener->lock)) != SOFTBUS_OK) {
255 TRANS_LOGE(TRANS_FILE, "file get listener lock failed");
256 return SOFTBUS_LOCK_ERR;
257 }
258
259 FileListener *fileNode = NULL;
260 LIST_FOR_EACH_ENTRY(fileNode, &(g_fileListener->list), FileListener, node) {
261 if (strcmp(fileNode->mySessionName, sessionName) == 0) {
262 if (memcpy_s(fileListener, sizeof(FileListener), fileNode, sizeof(FileListener)) != EOK) {
263 TRANS_LOGE(TRANS_FILE, "memcpy_s file listener failed.");
264 (void)SoftBusMutexUnlock(&(g_fileListener->lock));
265 return SOFTBUS_MEM_ERR;
266 }
267 (void)SoftBusMutexUnlock(&(g_fileListener->lock));
268 return SOFTBUS_OK;
269 }
270 }
271 (void)SoftBusMutexUnlock(&(g_fileListener->lock));
272 return SOFTBUS_TRANS_NODE_NOT_FOUND;
273 }
274
TransDeleteFileListener(const char * sessionName)275 void TransDeleteFileListener(const char *sessionName)
276 {
277 if (sessionName == NULL) {
278 TRANS_LOGW(TRANS_FILE, "invalid param.");
279 return;
280 }
281 if (g_fileListener == NULL) {
282 TRANS_LOGE(TRANS_FILE, "file listener hasn't init.");
283 return;
284 }
285 if (SoftBusMutexLock(&(g_fileListener->lock)) != SOFTBUS_OK) {
286 TRANS_LOGE(TRANS_FILE, "file delete lock failed");
287 return;
288 }
289
290 FileListener *fileNode = NULL;
291 LIST_FOR_EACH_ENTRY(fileNode, &(g_fileListener->list), FileListener, node) {
292 if (strcmp(fileNode->mySessionName, sessionName) == 0) {
293 ListDelete(&fileNode->node);
294 char *tmpName = NULL;
295 Anonymize(sessionName, &tmpName);
296 TRANS_LOGI(TRANS_FILE, "delete sessionName=%{public}s", AnonymizeWrapper(tmpName));
297 AnonymizeFree(tmpName);
298 SoftBusFree(fileNode);
299 break;
300 }
301 }
302 (void)SoftBusMutexUnlock(&(g_fileListener->lock));
303 }
304