1 /*
2  * Copyright (c) 2021 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 "trans_udp_channel_manager.h"
17 
18 #include "common_list.h"
19 #include "securec.h"
20 #include "softbus_adapter_mem.h"
21 #include "softbus_adapter_thread.h"
22 #include "softbus_conn_interface.h"
23 #include "softbus_def.h"
24 #include "softbus_errcode.h"
25 #include "softbus_utils.h"
26 #include "trans_client_proxy.h"
27 #include "trans_log.h"
28 #include "trans_udp_negotiation.h"
29 
30 #define MAX_WAIT_CONNECT_TIME 15
31 
32 static SoftBusList *g_udpChannelMgr = NULL;
33 
GetUdpChannelMgrHead(void)34 SoftBusList *GetUdpChannelMgrHead(void)
35 {
36     return g_udpChannelMgr;
37 }
38 
GetUdpChannelLock(void)39 int32_t GetUdpChannelLock(void)
40 {
41     if (g_udpChannelMgr == NULL) {
42         return SOFTBUS_NO_INIT;
43     }
44     if (SoftBusMutexLock(&g_udpChannelMgr->lock) != SOFTBUS_OK) {
45         TRANS_LOGE(TRANS_CTRL, "lock failed");
46         return SOFTBUS_LOCK_ERR;
47     }
48     return SOFTBUS_OK;
49 }
50 
ReleaseUdpChannelLock(void)51 void ReleaseUdpChannelLock(void)
52 {
53     (void)SoftBusMutexUnlock(&g_udpChannelMgr->lock);
54 }
55 
NotifyTimeOutUdpChannel(ListNode * udpChannelList)56 static void NotifyTimeOutUdpChannel(ListNode *udpChannelList)
57 {
58     UdpChannelInfo *udpChannel = NULL;
59     UdpChannelInfo *nextUdpChannel = NULL;
60     LIST_FOR_EACH_ENTRY_SAFE(udpChannel, nextUdpChannel, udpChannelList, UdpChannelInfo, node) {
61         if (udpChannel->info.udpChannelOptType == TYPE_UDP_CHANNEL_OPEN) {
62             TRANS_LOGW(TRANS_CTRL, "open udp channel time out, notify open failed.");
63             (void)NotifyUdpChannelOpenFailed(&(udpChannel->info), SOFTBUS_TRANS_HANDSHAKE_TIMEOUT);
64         } else if (udpChannel->info.udpChannelOptType == TYPE_UDP_CHANNEL_CLOSE) {
65             TRANS_LOGW(TRANS_CTRL, "close udp channel time out, notify close.");
66             (void)NotifyUdpChannelClosed(&(udpChannel->info), MESSAGE_TYPE_NOMAL);
67         }
68         ListDelete(&(udpChannel->node));
69         if (udpChannel->info.fastTransData != NULL) {
70             SoftBusFree((void *)udpChannel->info.fastTransData);
71         }
72         (void)memset_s(udpChannel->info.sessionKey, sizeof(udpChannel->info.sessionKey), 0,
73             sizeof(udpChannel->info.sessionKey));
74         SoftBusFree(udpChannel);
75     }
76 }
77 
TransUdpTimerProc(void)78 static void TransUdpTimerProc(void)
79 {
80     if (g_udpChannelMgr == NULL) {
81         return;
82     }
83     if (SoftBusMutexLock(&g_udpChannelMgr->lock) != SOFTBUS_OK) {
84         TRANS_LOGE(TRANS_CTRL, "lock failed");
85         return;
86     }
87 
88     ListNode udpTmpChannelList;
89     ListInit(&udpTmpChannelList);
90 
91     UdpChannelInfo *udpChannel = NULL;
92     UdpChannelInfo *nextUdpChannel = NULL;
93     LIST_FOR_EACH_ENTRY_SAFE(udpChannel, nextUdpChannel, &g_udpChannelMgr->list, UdpChannelInfo, node) {
94         if (udpChannel->status == UDP_CHANNEL_STATUS_NEGING) {
95             udpChannel->timeOut++;
96             if (udpChannel->timeOut < MAX_WAIT_CONNECT_TIME) {
97                 continue;
98             }
99             ReleaseUdpChannelId((int32_t)(udpChannel->info.myData.channelId));
100             ListDelete(&(udpChannel->node));
101             g_udpChannelMgr->cnt--;
102 
103             ListAdd(&udpTmpChannelList, &(udpChannel->node));
104         }
105     }
106     (void)SoftBusMutexUnlock(&g_udpChannelMgr->lock);
107 
108     NotifyTimeOutUdpChannel(&udpTmpChannelList);
109 }
110 
TransUdpChannelMgrInit(void)111 int32_t TransUdpChannelMgrInit(void)
112 {
113     if (g_udpChannelMgr != NULL) {
114         TRANS_LOGI(TRANS_INIT, "udp channel info manager has init.");
115         return SOFTBUS_OK;
116     }
117     g_udpChannelMgr = CreateSoftBusList();
118     if (g_udpChannelMgr == NULL) {
119         TRANS_LOGE(TRANS_INIT, "create udp channel manager list failed.");
120         return SOFTBUS_MALLOC_ERR;
121     }
122 
123     int32_t ret = RegisterTimeoutCallback(SOFTBUS_UDP_CHANNEL_TIMER_FUN, TransUdpTimerProc);
124     TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret,
125         TRANS_INIT, "register udp channel time out callback failed.");
126 
127     return SOFTBUS_OK;
128 }
129 
TransUdpChannelMgrDeinit(void)130 void TransUdpChannelMgrDeinit(void)
131 {
132     if (g_udpChannelMgr == NULL) {
133         return;
134     }
135     if (SoftBusMutexLock(&g_udpChannelMgr->lock) != SOFTBUS_OK) {
136         TRANS_LOGE(TRANS_INIT, "lock failed");
137         return;
138     }
139     UdpChannelInfo *udpChannel = NULL;
140     UdpChannelInfo *nextUdpChannel = NULL;
141     LIST_FOR_EACH_ENTRY_SAFE(udpChannel, nextUdpChannel, &g_udpChannelMgr->list, UdpChannelInfo, node) {
142         ReleaseUdpChannelId((int32_t)(udpChannel->info.myData.channelId));
143         ListDelete(&(udpChannel->node));
144         if (udpChannel->info.fastTransData != NULL) {
145             SoftBusFree((void *)udpChannel->info.fastTransData);
146         }
147         (void)memset_s(udpChannel->info.sessionKey, sizeof(udpChannel->info.sessionKey), 0,
148             sizeof(udpChannel->info.sessionKey));
149         SoftBusFree(udpChannel);
150     }
151     (void)SoftBusMutexUnlock(&g_udpChannelMgr->lock);
152     DestroySoftBusList(g_udpChannelMgr);
153     g_udpChannelMgr = NULL;
154     return;
155 }
156 
TransAddUdpChannel(UdpChannelInfo * channel)157 int32_t TransAddUdpChannel(UdpChannelInfo *channel)
158 {
159     if (g_udpChannelMgr == NULL) {
160         TRANS_LOGE(TRANS_INIT, "udp channel manager hasn't init.");
161         return SOFTBUS_NO_INIT;
162     }
163 
164     if (channel == NULL) {
165         TRANS_LOGW(TRANS_CTRL, "invalid param.");
166         return SOFTBUS_INVALID_PARAM;
167     }
168 
169     if (SoftBusMutexLock(&(g_udpChannelMgr->lock)) != SOFTBUS_OK) {
170         TRANS_LOGE(TRANS_CTRL, "lock failed");
171         return SOFTBUS_LOCK_ERR;
172     }
173 
174     UdpChannelInfo *udpChannelNode = NULL;
175     LIST_FOR_EACH_ENTRY(udpChannelNode, &(g_udpChannelMgr->list), UdpChannelInfo, node) {
176         if (udpChannelNode->info.myData.channelId == channel->info.myData.channelId) {
177             TRANS_LOGE(TRANS_CTRL, "udp channel has exited. channelId=%{public}" PRId64,
178                 channel->info.myData.channelId);
179             (void)SoftBusMutexUnlock(&(g_udpChannelMgr->lock));
180             return SOFTBUS_TRANS_UDP_CHANNEL_ALREADY_EXIST;
181         }
182     }
183     int64_t channelId = channel->info.myData.channelId;
184     ListInit(&(channel->node));
185     ListAdd(&(g_udpChannelMgr->list), &(channel->node));
186     TRANS_LOGI(TRANS_CTRL, "add channelId=%{public}" PRId64, channelId);
187     g_udpChannelMgr->cnt++;
188 
189     (void)SoftBusMutexUnlock(&(g_udpChannelMgr->lock));
190     TRANS_LOGI(TRANS_CTRL, "add udp channel success. channelId=%{public}" PRId64, channelId);
191     return SOFTBUS_OK;
192 }
193 
TransDelUdpChannel(int32_t channelId)194 int32_t TransDelUdpChannel(int32_t channelId)
195 {
196     if (g_udpChannelMgr == NULL) {
197         TRANS_LOGE(TRANS_INIT, "udp channel manager hasn't init.");
198         return SOFTBUS_NO_INIT;
199     }
200     if (SoftBusMutexLock(&(g_udpChannelMgr->lock)) != SOFTBUS_OK) {
201         TRANS_LOGE(TRANS_CTRL, "lock failed");
202         return SOFTBUS_LOCK_ERR;
203     }
204 
205     UdpChannelInfo *udpChannelNode = NULL;
206     UdpChannelInfo *udpChannelNext = NULL;
207     LIST_FOR_EACH_ENTRY_SAFE(udpChannelNode, udpChannelNext, &(g_udpChannelMgr->list), UdpChannelInfo, node) {
208         if (udpChannelNode->info.myData.channelId == channelId) {
209             ReleaseUdpChannelId((int32_t)(udpChannelNode->info.myData.channelId));
210             ListDelete(&(udpChannelNode->node));
211             TRANS_LOGI(TRANS_CTRL, "delete channelId=%{public}d", channelId);
212             if (udpChannelNode->info.fastTransData != NULL) {
213                 SoftBusFree((void *)(udpChannelNode->info.fastTransData));
214             }
215             (void)memset_s(udpChannelNode->info.sessionKey, sizeof(udpChannelNode->info.sessionKey), 0,
216                 sizeof(udpChannelNode->info.sessionKey));
217             SoftBusFree(udpChannelNode);
218             g_udpChannelMgr->cnt--;
219             (void)SoftBusMutexUnlock(&(g_udpChannelMgr->lock));
220             return SOFTBUS_OK;
221         }
222     }
223     (void)SoftBusMutexUnlock(&(g_udpChannelMgr->lock));
224     TRANS_LOGE(TRANS_CTRL, "udp channel not found. channelId=%{public}d", channelId);
225     return SOFTBUS_TRANS_UDP_CHANNEL_NOT_FOUND;
226 }
227 
NotifyUdpChannelCloseInList(ListNode * udpChannelList)228 static void NotifyUdpChannelCloseInList(ListNode *udpChannelList)
229 {
230     UdpChannelInfo *udpChannel = NULL;
231     UdpChannelInfo *udpChannelNext = NULL;
232     LIST_FOR_EACH_ENTRY_SAFE(udpChannel, udpChannelNext, udpChannelList, UdpChannelInfo, node) {
233         (void)NotifyUdpChannelClosed(&udpChannel->info, MESSAGE_TYPE_NOMAL);
234 
235         ListDelete(&(udpChannel->node));
236         TRANS_LOGI(TRANS_CTRL, "channelId=%{public}" PRId64, udpChannel->info.myData.channelId);
237         if (udpChannel->info.fastTransData != NULL) {
238             SoftBusFree((void *)(udpChannel->info.fastTransData));
239         }
240         (void)memset_s(udpChannel->info.sessionKey, sizeof(udpChannel->info.sessionKey), 0,
241             sizeof(udpChannel->info.sessionKey));
242         SoftBusFree(udpChannel);
243     }
244 }
245 
TransCloseUdpChannelByNetWorkId(const char * netWorkId)246 void TransCloseUdpChannelByNetWorkId(const char* netWorkId)
247 {
248     TRANS_LOGI(TRANS_CTRL, "enter.");
249     if ((g_udpChannelMgr == NULL) || (netWorkId == NULL)) {
250         return;
251     }
252     if (SoftBusMutexLock(&g_udpChannelMgr->lock) != SOFTBUS_OK) {
253         TRANS_LOGE(TRANS_CTRL, "TransCloseUdpChannelByAuId lock failed");
254         return;
255     }
256 
257     ListNode udpDeleteChannelList;
258     ListInit(&udpDeleteChannelList);
259 
260     UdpChannelInfo *udpChannel = NULL;
261     UdpChannelInfo *udpChannelNext = NULL;
262     LIST_FOR_EACH_ENTRY_SAFE(udpChannel, udpChannelNext, &g_udpChannelMgr->list, UdpChannelInfo, node) {
263         if (strcmp(udpChannel->info.peerNetWorkId, netWorkId) == 0) {
264             ReleaseUdpChannelId((int32_t)(udpChannel->info.myData.channelId));
265             ListDelete(&(udpChannel->node));
266             g_udpChannelMgr->cnt--;
267 
268             ListAdd(&udpDeleteChannelList, &(udpChannel->node));
269         }
270     }
271     (void)SoftBusMutexUnlock(&g_udpChannelMgr->lock);
272 
273     NotifyUdpChannelCloseInList(&udpDeleteChannelList);
274 }
275 
TransGetUdpChannelBySeq(int64_t seq,UdpChannelInfo * channel)276 int32_t TransGetUdpChannelBySeq(int64_t seq, UdpChannelInfo *channel)
277 {
278     if (g_udpChannelMgr == NULL) {
279         TRANS_LOGE(TRANS_INIT, "udp channel manager hasn't init.");
280         return SOFTBUS_NO_INIT;
281     }
282 
283     if (channel == NULL) {
284         TRANS_LOGW(TRANS_CTRL, "invalid param.");
285         return SOFTBUS_INVALID_PARAM;
286     }
287 
288     if (SoftBusMutexLock(&(g_udpChannelMgr->lock)) != SOFTBUS_OK) {
289         TRANS_LOGE(TRANS_CTRL, "lock failed");
290         return SOFTBUS_LOCK_ERR;
291     }
292 
293     UdpChannelInfo *udpChannelNode = NULL;
294     LIST_FOR_EACH_ENTRY(udpChannelNode, &(g_udpChannelMgr->list), UdpChannelInfo, node) {
295         if (udpChannelNode->seq == seq) {
296             if (memcpy_s(channel, sizeof(UdpChannelInfo), udpChannelNode, sizeof(UdpChannelInfo)) != EOK) {
297                 TRANS_LOGE(TRANS_CTRL, "memcpy_s UdpChannelInfo failed.");
298                 (void)SoftBusMutexUnlock(&(g_udpChannelMgr->lock));
299                 return SOFTBUS_MEM_ERR;
300             }
301             (void)SoftBusMutexUnlock(&(g_udpChannelMgr->lock));
302             return SOFTBUS_OK;
303         }
304     }
305     (void)SoftBusMutexUnlock(&(g_udpChannelMgr->lock));
306     TRANS_LOGE(TRANS_CTRL, "udp channel not found. seq=%{public}" PRId64 "", seq);
307     return SOFTBUS_TRANS_UDP_CHANNEL_NOT_FOUND;
308 }
309 
TransGetUdpChannelById(int32_t channelId,UdpChannelInfo * channel)310 int32_t TransGetUdpChannelById(int32_t channelId, UdpChannelInfo *channel)
311 {
312     if (g_udpChannelMgr == NULL) {
313         TRANS_LOGE(TRANS_CTRL, "udp channel manager hasn't init.");
314         return SOFTBUS_NO_INIT;
315     }
316 
317     if (channel == NULL) {
318         TRANS_LOGW(TRANS_CTRL, "invalid param.");
319         return SOFTBUS_INVALID_PARAM;
320     }
321 
322     if (SoftBusMutexLock(&(g_udpChannelMgr->lock)) != SOFTBUS_OK) {
323         TRANS_LOGE(TRANS_CTRL, "lock failed");
324         return SOFTBUS_LOCK_ERR;
325     }
326 
327     UdpChannelInfo *udpChannelNode = NULL;
328     LIST_FOR_EACH_ENTRY(udpChannelNode, &(g_udpChannelMgr->list), UdpChannelInfo, node) {
329         if (udpChannelNode->info.myData.channelId == channelId) {
330             if (memcpy_s(channel, sizeof(UdpChannelInfo), udpChannelNode, sizeof(UdpChannelInfo)) != EOK) {
331                 TRANS_LOGE(TRANS_CTRL, "memcpy_s UdpChannelInfo failed.");
332                 (void)SoftBusMutexUnlock(&(g_udpChannelMgr->lock));
333                 return SOFTBUS_MEM_ERR;
334             }
335             (void)SoftBusMutexUnlock(&(g_udpChannelMgr->lock));
336             return SOFTBUS_OK;
337         }
338     }
339     (void)SoftBusMutexUnlock(&(g_udpChannelMgr->lock));
340     TRANS_LOGE(TRANS_CTRL, "udp channel not found. channelId=%{public}d", channelId);
341     return SOFTBUS_TRANS_UDP_CHANNEL_NOT_FOUND;
342 }
343 
TransUdpGetNameByChanId(int32_t channelId,char * pkgName,char * sessionName,uint16_t pkgNameLen,uint16_t sessionNameLen)344 int32_t TransUdpGetNameByChanId(int32_t channelId, char *pkgName, char *sessionName,
345     uint16_t pkgNameLen, uint16_t sessionNameLen)
346 {
347     if (g_udpChannelMgr == NULL) {
348         TRANS_LOGE(TRANS_INIT, "udp channel manager hasn't init.");
349         return SOFTBUS_NO_INIT;
350     }
351     if (pkgName == NULL || sessionName == NULL) {
352         TRANS_LOGW(TRANS_CTRL, "invalid param.");
353         return SOFTBUS_INVALID_PARAM;
354     }
355     if (SoftBusMutexLock(&(g_udpChannelMgr->lock)) != SOFTBUS_OK) {
356         TRANS_LOGE(TRANS_CTRL, "lock failed");
357         return SOFTBUS_LOCK_ERR;
358     }
359 
360     UdpChannelInfo *udpChannelNode = NULL;
361     LIST_FOR_EACH_ENTRY(udpChannelNode, &(g_udpChannelMgr->list), UdpChannelInfo, node) {
362         if (udpChannelNode->info.myData.channelId == channelId) {
363             if (strcpy_s(pkgName, pkgNameLen, udpChannelNode->info.myData.pkgName) != EOK ||
364                 strcpy_s(sessionName, sessionNameLen, udpChannelNode->info.myData.sessionName) != EOK) {
365                 TRANS_LOGE(TRANS_CTRL, "strcpy_s failed.");
366                 (void)SoftBusMutexUnlock(&(g_udpChannelMgr->lock));
367                 return SOFTBUS_STRCPY_ERR;
368             }
369             (void)SoftBusMutexUnlock(&(g_udpChannelMgr->lock));
370             return SOFTBUS_OK;
371         }
372     }
373     (void)SoftBusMutexUnlock(&(g_udpChannelMgr->lock));
374     TRANS_LOGE(TRANS_CTRL, "udp channel not found. channelId=%{public}d", channelId);
375     return SOFTBUS_TRANS_UDP_CHANNEL_NOT_FOUND;
376 }
377 
TransSetUdpChannelStatus(int64_t seq,UdpChannelStatus status)378 int32_t TransSetUdpChannelStatus(int64_t seq, UdpChannelStatus status)
379 {
380     if (g_udpChannelMgr == NULL) {
381         TRANS_LOGE(TRANS_INIT, "udp channel manager hasn't init.");
382         return SOFTBUS_NO_INIT;
383     }
384 
385     if (SoftBusMutexLock(&(g_udpChannelMgr->lock)) != SOFTBUS_OK) {
386         TRANS_LOGE(TRANS_CTRL, "lock failed");
387         return SOFTBUS_LOCK_ERR;
388     }
389 
390     UdpChannelInfo *udpChannelNode = NULL;
391     LIST_FOR_EACH_ENTRY(udpChannelNode, &(g_udpChannelMgr->list), UdpChannelInfo, node) {
392         if (udpChannelNode->seq == seq) {
393             udpChannelNode->status = status;
394             (void)SoftBusMutexUnlock(&(g_udpChannelMgr->lock));
395             return SOFTBUS_OK;
396         }
397     }
398     (void)SoftBusMutexUnlock(&(g_udpChannelMgr->lock));
399     TRANS_LOGE(TRANS_CTRL, "udp channel not found. seq=%{public}" PRId64, seq);
400     return SOFTBUS_TRANS_UDP_CHANNEL_NOT_FOUND;
401 }
402 
TransSetUdpChannelOptType(int32_t channelId,UdpChannelOptType type)403 int32_t TransSetUdpChannelOptType(int32_t channelId, UdpChannelOptType type)
404 {
405     if (g_udpChannelMgr == NULL) {
406         TRANS_LOGE(TRANS_INIT, "udp channel manager hasn't init.");
407         return SOFTBUS_NO_INIT;
408     }
409 
410     if (SoftBusMutexLock(&(g_udpChannelMgr->lock)) != SOFTBUS_OK) {
411         TRANS_LOGE(TRANS_CTRL, "lock failed");
412         return SOFTBUS_LOCK_ERR;
413     }
414 
415     UdpChannelInfo *udpChannelNode = NULL;
416     LIST_FOR_EACH_ENTRY(udpChannelNode, &(g_udpChannelMgr->list), UdpChannelInfo, node) {
417         if (udpChannelNode->info.myData.channelId == channelId) {
418             udpChannelNode->info.udpChannelOptType = type;
419             (void)SoftBusMutexUnlock(&(g_udpChannelMgr->lock));
420             return SOFTBUS_OK;
421         }
422     }
423     (void)SoftBusMutexUnlock(&(g_udpChannelMgr->lock));
424     TRANS_LOGE(TRANS_CTRL, "udp channel not found. channelId=%{public}d", channelId);
425     return SOFTBUS_TRANS_UDP_CHANNEL_NOT_FOUND;
426 }
427 
TransUpdateUdpChannelInfo(int64_t seq,const AppInfo * appInfo)428 void TransUpdateUdpChannelInfo(int64_t seq, const AppInfo *appInfo)
429 {
430     if (g_udpChannelMgr == NULL) {
431         TRANS_LOGE(TRANS_INIT, "udp channel manager hasn't init.");
432         return;
433     }
434 
435     if (appInfo == NULL) {
436         TRANS_LOGW(TRANS_CTRL, "invalid param.");
437         return;
438     }
439 
440     if (SoftBusMutexLock(&(g_udpChannelMgr->lock)) != SOFTBUS_OK) {
441         TRANS_LOGE(TRANS_CTRL, "lock failed");
442         return;
443     }
444 
445     UdpChannelInfo *udpChannelNode = NULL;
446     LIST_FOR_EACH_ENTRY(udpChannelNode, &(g_udpChannelMgr->list), UdpChannelInfo, node) {
447         if (udpChannelNode->seq == seq) {
448             if (memcpy_s(&(udpChannelNode->info), sizeof(AppInfo), appInfo, sizeof(AppInfo)) != EOK) {
449                 TRANS_LOGE(TRANS_CTRL, "memcpy_s UdpChannelInfo failed.");
450             }
451             (void)SoftBusMutexUnlock(&(g_udpChannelMgr->lock));
452             return;
453         }
454     }
455     (void)SoftBusMutexUnlock(&(g_udpChannelMgr->lock));
456     TRANS_LOGE(TRANS_CTRL, "udp channel not found. seq=%{public}" PRId64, seq);
457 }
458 
TransGetUdpChannelByRequestId(uint32_t requestId,UdpChannelInfo * channel)459 int32_t TransGetUdpChannelByRequestId(uint32_t requestId, UdpChannelInfo *channel)
460 {
461     if (g_udpChannelMgr == NULL) {
462         TRANS_LOGE(TRANS_INIT, "udp channel manager hasn't init.");
463         return SOFTBUS_NO_INIT;
464     }
465 
466     if (channel == NULL) {
467         TRANS_LOGW(TRANS_CTRL, "invalid param.");
468         return SOFTBUS_INVALID_PARAM;
469     }
470 
471     if (SoftBusMutexLock(&(g_udpChannelMgr->lock)) != SOFTBUS_OK) {
472         TRANS_LOGE(TRANS_CTRL, "lock failed");
473         return SOFTBUS_LOCK_ERR;
474     }
475 
476     UdpChannelInfo *udpChannelNode = NULL;
477     LIST_FOR_EACH_ENTRY(udpChannelNode, &(g_udpChannelMgr->list), UdpChannelInfo, node) {
478         if (udpChannelNode->requestId == requestId) {
479             if (memcpy_s(channel, sizeof(UdpChannelInfo), udpChannelNode, sizeof(UdpChannelInfo)) != EOK) {
480                 (void)SoftBusMutexUnlock(&(g_udpChannelMgr->lock));
481                 return SOFTBUS_MEM_ERR;
482             }
483             (void)SoftBusMutexUnlock(&(g_udpChannelMgr->lock));
484             return SOFTBUS_OK;
485         }
486     }
487     (void)SoftBusMutexUnlock(&(g_udpChannelMgr->lock));
488     TRANS_LOGE(TRANS_CTRL, "udp channel not found. reqId=%{public}u", requestId);
489     return SOFTBUS_TRANS_UDP_CHANNEL_NOT_FOUND;
490 }
491 
TransGetChannelObj(int32_t channelId)492 UdpChannelInfo *TransGetChannelObj(int32_t channelId)
493 {
494     if (g_udpChannelMgr == NULL) {
495         return NULL;
496     }
497     UdpChannelInfo *item = NULL;
498     LIST_FOR_EACH_ENTRY(item, &(g_udpChannelMgr->list), UdpChannelInfo, node) {
499         if (item->info.myData.channelId == channelId) {
500             return item;
501         }
502     }
503     TRANS_LOGE(TRANS_CTRL, "not found: channelId=%{public}d", channelId);
504     return NULL;
505 }
506 
TransGetUdpAppInfoByChannelId(int32_t channelId,AppInfo * appInfo)507 int32_t TransGetUdpAppInfoByChannelId(int32_t channelId, AppInfo *appInfo)
508 {
509     if (appInfo == NULL) {
510         TRANS_LOGE(TRANS_INIT, "Invalid param");
511         return SOFTBUS_INVALID_PARAM;
512     }
513 
514     if (g_udpChannelMgr == NULL) {
515         TRANS_LOGE(TRANS_INIT, "udp channel manager hasn't init.");
516         return SOFTBUS_NO_INIT;
517     }
518 
519     if (SoftBusMutexLock(&(g_udpChannelMgr->lock)) != SOFTBUS_OK) {
520         return SOFTBUS_LOCK_ERR;
521     }
522 
523     UdpChannelInfo *udpChannelNode = NULL;
524     LIST_FOR_EACH_ENTRY(udpChannelNode, &(g_udpChannelMgr->list), UdpChannelInfo, node) {
525         if (udpChannelNode->info.myData.channelId == channelId) {
526             memcpy_s(appInfo, sizeof(AppInfo), &udpChannelNode->info, sizeof(AppInfo));
527             (void)SoftBusMutexUnlock(&(g_udpChannelMgr->lock));
528             return SOFTBUS_OK;
529         }
530     }
531     (void)SoftBusMutexUnlock(&(g_udpChannelMgr->lock));
532     TRANS_LOGE(TRANS_CTRL, "udp channel not found. channelId=%{public}d", channelId);
533     return SOFTBUS_NOT_FIND;
534 }
535 
TransUdpGetChannelIdByAddr(AppInfo * appInfo)536 int32_t TransUdpGetChannelIdByAddr(AppInfo *appInfo)
537 {
538     if (appInfo == NULL) {
539         TRANS_LOGE(TRANS_INIT, "Invalid param");
540         return SOFTBUS_INVALID_PARAM;
541     }
542 
543     if (g_udpChannelMgr == NULL) {
544         TRANS_LOGE(TRANS_INIT, "udp channel manager hasn't init.");
545         return SOFTBUS_NO_INIT;
546     }
547 
548     if (SoftBusMutexLock(&(g_udpChannelMgr->lock)) != SOFTBUS_OK) {
549         return SOFTBUS_LOCK_ERR;
550     }
551 
552     UdpChannelInfo *udpChannelNode = NULL;
553     LIST_FOR_EACH_ENTRY(udpChannelNode, &(g_udpChannelMgr->list), UdpChannelInfo, node) {
554         if (udpChannelNode->info.peerData.channelId == appInfo->peerData.channelId) {
555             if (strcmp(udpChannelNode->info.peerData.addr, appInfo->peerData.addr) == EOK) {
556                 appInfo->myData.channelId = udpChannelNode->info.myData.channelId;
557                 (void)SoftBusMutexUnlock(&(g_udpChannelMgr->lock));
558                 return SOFTBUS_OK;
559             }
560         }
561     }
562     (void)SoftBusMutexUnlock(&(g_udpChannelMgr->lock));
563     TRANS_LOGE(TRANS_CTRL, "not found peerChannelId and addr");
564     return SOFTBUS_NOT_FIND;
565 }
566 
CreateUdpChannelNotifyInfo(UdpChannelInfo * udpChannelNode)567 static UdpChannelNotifyInfo *CreateUdpChannelNotifyInfo(UdpChannelInfo *udpChannelNode)
568 {
569     UdpChannelNotifyInfo *notifyInfo = (UdpChannelNotifyInfo *)SoftBusCalloc(sizeof(UdpChannelNotifyInfo));
570     if (notifyInfo == NULL) {
571         TRANS_LOGE(TRANS_CTRL, "malloc failed.");
572         return NULL;
573     }
574     notifyInfo->channelId = udpChannelNode->info.myData.channelId;
575     notifyInfo->pid = udpChannelNode->info.myData.pid;
576     if (strcpy_s(notifyInfo->pkgName, PKG_NAME_SIZE_MAX, udpChannelNode->info.myData.pkgName) != EOK) {
577         SoftBusFree(notifyInfo);
578         return NULL;
579     }
580     return notifyInfo;
581 }
582 
FillNotifyList(ListNode * notifyList,uint8_t tos)583 static void FillNotifyList(ListNode *notifyList, uint8_t tos)
584 {
585     if (SoftBusMutexLock(&(g_udpChannelMgr->lock)) != SOFTBUS_OK) {
586         TRANS_LOGE(TRANS_CTRL, "lock failed");
587         return;
588     }
589     UdpChannelInfo *udpChannelNode = NULL;
590     LIST_FOR_EACH_ENTRY(udpChannelNode, &(g_udpChannelMgr->list), UdpChannelInfo, node) {
591         if (udpChannelNode->info.businessType == BUSINESS_TYPE_FILE && udpChannelNode->info.isClient &&
592             udpChannelNode->tos != tos) {
593             UdpChannelNotifyInfo *notifyInfo = CreateUdpChannelNotifyInfo(udpChannelNode);
594             if (notifyInfo == NULL) {
595                 continue;
596             }
597             ListAdd(notifyList, &(notifyInfo->node));
598         }
599     }
600     (void)SoftBusMutexUnlock(&(g_udpChannelMgr->lock));
601 }
602 
ModifyUdpChannelTos(uint8_t tos)603 static int32_t ModifyUdpChannelTos(uint8_t tos)
604 {
605     if (g_udpChannelMgr == NULL) {
606         TRANS_LOGE(TRANS_CTRL, "udp channel manager not initialized.");
607         return SOFTBUS_NO_INIT;
608     }
609     ListNode notifyList;
610     ListInit(&notifyList);
611     FillNotifyList(&notifyList, tos);
612     if (IsListEmpty(&notifyList)) {
613         TRANS_LOGI(TRANS_CTRL, "no need to modify tos.");
614         return SOFTBUS_OK;
615     }
616     int32_t ret = SOFTBUS_OK;
617     UdpChannelNotifyInfo *notifyNode = NULL;
618     UdpChannelNotifyInfo *notifyNodeNext = NULL;
619     LIST_FOR_EACH_ENTRY_SAFE(notifyNode, notifyNodeNext, &notifyList, UdpChannelNotifyInfo, node) {
620         ret = ClientIpcOnTransLimitChange(notifyNode->pkgName, notifyNode->pid, notifyNode->channelId, tos);
621         if (ret != SOFTBUS_OK) {
622             TRANS_LOGE(TRANS_CTRL, "ClientIpcOnTransLimitChange end, channelId=%{public}" PRId64 ", ret=%{public}d",
623                 notifyNode->channelId, ret);
624             ListDelete(&(notifyNode->node));
625             SoftBusFree(notifyNode);
626             continue;
627         }
628         if (SoftBusMutexLock(&(g_udpChannelMgr->lock)) != SOFTBUS_OK) {
629             TRANS_LOGE(TRANS_CTRL, "lock failed");
630             ListDelete(&(notifyNode->node));
631             SoftBusFree(notifyNode);
632             continue;
633         }
634         UdpChannelInfo *udpChannelNodeTemp = NULL;
635         LIST_FOR_EACH_ENTRY(udpChannelNodeTemp, &(g_udpChannelMgr->list), UdpChannelInfo, node) {
636             if (udpChannelNodeTemp->info.myData.channelId == notifyNode->channelId) {
637                 udpChannelNodeTemp->tos = tos;
638                 break;
639             }
640         }
641         (void)SoftBusMutexUnlock(&(g_udpChannelMgr->lock));
642         ListDelete(&(notifyNode->node));
643         SoftBusFree(notifyNode);
644     }
645     return ret;
646 }
647 
UdpChannelFileTransLimit(const ChannelInfo * channel,uint8_t tos)648 int32_t UdpChannelFileTransLimit(const ChannelInfo *channel, uint8_t tos)
649 {
650     if (channel == NULL) {
651         TRANS_LOGE(TRANS_CTRL, "invalid param.");
652         return SOFTBUS_INVALID_PARAM;
653     }
654     TRANS_LOGD(TRANS_CTRL, "new session opened, channelId=%{public}d, channelType=%{public}d, businessType=%{public}d",
655         channel->channelId, channel->channelType, channel->businessType);
656     if (channel->channelType == CHANNEL_TYPE_PROXY) {
657         TRANS_LOGI(TRANS_CTRL, "channel type is proxy, no need to limit file trans.");
658         return SOFTBUS_OK;
659     }
660     if (channel->businessType == BUSINESS_TYPE_MESSAGE) {
661         TRANS_LOGI(TRANS_CTRL, "business type is message, no need to limit file trans.");
662         return SOFTBUS_OK;
663     }
664     int32_t ret = ModifyUdpChannelTos(tos);
665     if (ret != SOFTBUS_OK) {
666         TRANS_LOGE(TRANS_CTRL, "ModifyUdpChannelTos failed, ret=%{public}d", ret);
667     }
668     return SOFTBUS_OK;
669 }
670 
UdpChannelFileTransRecoveryLimit(uint8_t tos)671 int32_t UdpChannelFileTransRecoveryLimit(uint8_t tos)
672 {
673     int32_t ret = ModifyUdpChannelTos(tos);
674     if (ret != SOFTBUS_OK) {
675         TRANS_LOGE(TRANS_CTRL, "ModifyUdpChannelTos failed, ret=%{public}d", ret);
676     }
677     return SOFTBUS_OK;
678 }
679 
IsUdpRecoveryTransLimit(void)680 bool IsUdpRecoveryTransLimit(void)
681 {
682     if (g_udpChannelMgr == NULL) {
683         TRANS_LOGE(TRANS_CTRL, "invalid param.");
684         return false;
685     }
686     if (SoftBusMutexLock(&(g_udpChannelMgr->lock)) != SOFTBUS_OK) {
687         TRANS_LOGE(TRANS_CTRL, "lock failed");
688         return false;
689     }
690     UdpChannelInfo *udpChannelNode = NULL;
691     LIST_FOR_EACH_ENTRY(udpChannelNode, &(g_udpChannelMgr->list), UdpChannelInfo, node) {
692         if (udpChannelNode->info.businessType == BUSINESS_TYPE_STREAM) {
693             TRANS_LOGD(TRANS_CTRL, "udp channel exists stream business, no need to recovery limit.");
694             (void)SoftBusMutexUnlock(&(g_udpChannelMgr->lock));
695             return false;
696         }
697     }
698     (void)SoftBusMutexUnlock(&(g_udpChannelMgr->lock));
699     return true;
700 }
701 
TransUdpGetIpAndConnectTypeById(int32_t channelId,char * localIp,char * remoteIp,uint32_t maxIpLen,int32_t * connectType)702 int32_t TransUdpGetIpAndConnectTypeById(int32_t channelId, char *localIp, char *remoteIp, uint32_t maxIpLen,
703     int32_t *connectType)
704 {
705     if (localIp == NULL || remoteIp == NULL || maxIpLen < IP_LEN || connectType == NULL) {
706         TRANS_LOGE(TRANS_CTRL, "invalid param");
707         return SOFTBUS_INVALID_PARAM;
708     }
709 
710     if (g_udpChannelMgr == NULL) {
711         TRANS_LOGE(TRANS_CTRL, "udp channel manager not initialized.");
712         return SOFTBUS_NO_INIT;
713     }
714 
715     if (SoftBusMutexLock(&(g_udpChannelMgr->lock)) != SOFTBUS_OK) {
716         TRANS_LOGE(TRANS_CTRL, "lock failed");
717         return SOFTBUS_LOCK_ERR;
718     }
719 
720     UdpChannelInfo *udpChannelNode = NULL;
721     LIST_FOR_EACH_ENTRY(udpChannelNode, &(g_udpChannelMgr->list), UdpChannelInfo, node) {
722         if (udpChannelNode->info.myData.channelId == channelId) {
723             if (strcpy_s(localIp, maxIpLen, udpChannelNode->info.myData.addr) != EOK) {
724                 TRANS_LOGE(TRANS_CTRL, "failed to strcpy localIp, channelId=%{public}d", channelId);
725                 (void)SoftBusMutexUnlock(&(g_udpChannelMgr->lock));
726                 return SOFTBUS_STRCPY_ERR;
727             }
728             if (strcpy_s(remoteIp, maxIpLen, udpChannelNode->info.peerData.addr) != EOK) {
729                 TRANS_LOGE(TRANS_CTRL, "failed to strcpy remoteIp, channelId=%{public}d", channelId);
730                 (void)SoftBusMutexUnlock(&(g_udpChannelMgr->lock));
731                 return SOFTBUS_STRCPY_ERR;
732             }
733             *connectType = udpChannelNode->info.connectType;
734             (void)SoftBusMutexUnlock(&(g_udpChannelMgr->lock));
735             return SOFTBUS_OK;
736         }
737     }
738     (void)SoftBusMutexUnlock(&(g_udpChannelMgr->lock));
739     TRANS_LOGE(TRANS_CTRL, "not found locapIp and connectType by channelId=%{public}d", channelId);
740     return SOFTBUS_NOT_FIND;
741 }
742