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 #include "softbus_proxychannel_manager.h"
16
17 #include <securec.h>
18 #include <string.h>
19
20 #include "auth_interface.h"
21 #include "auth_manager.h"
22 #include "auth_session_fsm.h"
23 #include "bus_center_event.h"
24 #include "bus_center_info_key.h"
25 #include "bus_center_manager.h"
26 #include "common_list.h"
27 #include "data_bus_native.h"
28 #include "lnn_lane_link.h"
29 #include "softbus_adapter_crypto.h"
30 #include "softbus_adapter_hitrace.h"
31 #include "softbus_adapter_mem.h"
32 #include "softbus_adapter_thread.h"
33 #include "softbus_conn_interface.h"
34 #include "softbus_def.h"
35 #include "softbus_errcode.h"
36 #include "softbus_feature_config.h"
37 #include "softbus_log.h"
38 #include "softbus_proxychannel_callback.h"
39 #include "softbus_proxychannel_control.h"
40 #include "softbus_proxychannel_listener.h"
41 #include "softbus_proxychannel_message.h"
42 #include "softbus_proxychannel_session.h"
43 #include "softbus_proxychannel_transceiver.h"
44 #include "softbus_utils.h"
45 #include "trans_channel_limit.h"
46 #include "trans_channel_manager.h"
47 #include "trans_pending_pkt.h"
48 #include "trans_session_manager.h"
49
50 #define ID_OFFSET (1)
51
52 #define PROXY_CHANNEL_CONTROL_TIMEOUT 19
53 #define PROXY_CHANNEL_BT_IDLE_TIMEOUT 240 // 4min
54 #define PROXY_CHANNEL_IDLE_TIMEOUT 15 // 10800 = 3 hour
55 #define PROXY_CHANNEL_TCP_IDLE_TIMEOUT 43200 // tcp 24 hour
56 #define PROXY_CHANNEL_CLIENT 0
57 #define PROXY_CHANNEL_SERVER 1
58 static SoftBusList *g_proxyChannelList = NULL;
59
60 typedef struct {
61 int32_t channelType;
62 int32_t businessType;
63 ConfigType configType;
64 } ConfigTypeMap;
65
ChanIsEqual(ProxyChannelInfo * a,ProxyChannelInfo * b)66 static int32_t ChanIsEqual(ProxyChannelInfo *a, ProxyChannelInfo *b)
67 {
68 if ((a->myId == b->myId) &&
69 (a->peerId == b->peerId) &&
70 (strncmp(a->identity, b->identity, sizeof(a->identity)) == 0)) {
71 return SOFTBUS_OK;
72 }
73 return SOFTBUS_ERR;
74 }
75
ResetChanIsEqual(int status,ProxyChannelInfo * a,ProxyChannelInfo * b)76 static int32_t ResetChanIsEqual(int status, ProxyChannelInfo *a, ProxyChannelInfo *b)
77 {
78 if (status == PROXY_CHANNEL_STATUS_HANDSHAKEING) {
79 if ((a->myId == b->myId) &&
80 (strncmp(a->identity, b->identity, sizeof(a->identity)) == 0)) {
81 return SOFTBUS_OK;
82 }
83 }
84
85 if ((a->myId == b->myId) &&
86 (a->peerId == b->peerId) &&
87 (strncmp(a->identity, b->identity, sizeof(a->identity)) == 0)) {
88 return SOFTBUS_OK;
89 }
90 return SOFTBUS_ERR;
91 }
92
TransProxyGetAppInfoType(int16_t myId,const char * identity)93 NO_SANITIZE("cfi") int32_t TransProxyGetAppInfoType(int16_t myId, const char *identity)
94 {
95 if (SoftBusMutexLock(&g_proxyChannelList->lock) != 0) {
96 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
97 return SOFTBUS_ERR;
98 }
99
100 AppType appType;
101 ProxyChannelInfo *item = NULL;
102 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
103 if ((item->myId == myId) && (strcmp(item->identity, identity) == 0)) {
104 appType = item->appInfo.appType;
105 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
106 return appType;
107 }
108 }
109 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
110 return SOFTBUS_ERR;
111 }
112
TransProxyUpdateAckInfo(ProxyChannelInfo * info)113 static int32_t TransProxyUpdateAckInfo(ProxyChannelInfo *info)
114 {
115 if (g_proxyChannelList == NULL || info == NULL) {
116 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "g_proxyChannelList or item is null");
117 return SOFTBUS_ERR;
118 }
119
120 if (SoftBusMutexLock(&g_proxyChannelList->lock) != 0) {
121 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
122 return SOFTBUS_ERR;
123 }
124
125 ProxyChannelInfo *item = NULL;
126 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
127 if ((item->myId == info->myId) && (strncmp(item->identity, info->identity, sizeof(item->identity)) == 0)) {
128 item->peerId = info->peerId;
129 item->status = PROXY_CHANNEL_STATUS_COMPLETED;
130 item->timeout = 0;
131 item->appInfo.encrypt = info->appInfo.encrypt;
132 item->appInfo.algorithm = info->appInfo.algorithm;
133 item->appInfo.crc = info->appInfo.crc;
134 item->appInfo.myData.dataConfig = info->appInfo.myData.dataConfig;
135 item->appInfo.peerHandleId = info->appInfo.peerHandleId;
136 (void)memcpy_s(&(item->appInfo.peerData), sizeof(item->appInfo.peerData),
137 &(info->appInfo.peerData), sizeof(info->appInfo.peerData));
138 (void)memcpy_s(info, sizeof(ProxyChannelInfo), item, sizeof(ProxyChannelInfo));
139 SoftbusHitraceStart(SOFTBUS_HITRACE_ID_VALID, (uint64_t)(item->channelId + ID_OFFSET));
140 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
141 return SOFTBUS_OK;
142 }
143 }
144 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
145 return SOFTBUS_ERR;
146 }
147
TransRefreshProxyTimesNative(int channelId)148 int32_t TransRefreshProxyTimesNative(int channelId)
149 {
150 if (g_proxyChannelList == NULL) {
151 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "g_proxyChannelList or item is null");
152 return SOFTBUS_ERR;
153 }
154
155 if (SoftBusMutexLock(&g_proxyChannelList->lock) != 0) {
156 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
157 return SOFTBUS_ERR;
158 }
159
160 ProxyChannelInfo *item = NULL;
161 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
162 if (item->myId == channelId) {
163 item->timeout = 0;
164 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
165 return SOFTBUS_OK;
166 }
167 }
168 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
169 return SOFTBUS_ERR;
170 }
171
TransProxyAddChanItem(ProxyChannelInfo * chan)172 static int32_t TransProxyAddChanItem(ProxyChannelInfo *chan)
173 {
174 if ((chan == NULL) || (g_proxyChannelList == NULL)) {
175 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "trans proxy add channel param nullptr!");
176 return SOFTBUS_ERR;
177 }
178
179 if (SoftBusMutexLock(&g_proxyChannelList->lock) != 0) {
180 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
181 return SOFTBUS_ERR;
182 }
183 ListAdd(&(g_proxyChannelList->list), &(chan->node));
184 g_proxyChannelList->cnt++;
185 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
186 return SOFTBUS_OK;
187 }
188
TransProxyGetChanByChanId(int32_t chanId,ProxyChannelInfo * chan)189 NO_SANITIZE("cfi") int32_t TransProxyGetChanByChanId(int32_t chanId, ProxyChannelInfo *chan)
190 {
191 ProxyChannelInfo *item = NULL;
192 ProxyChannelInfo *nextNode = NULL;
193
194 if (g_proxyChannelList == NULL || chan == NULL) {
195 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "trans proxy get channel param nullptr!");
196 return SOFTBUS_INVALID_PARAM;
197 }
198
199 if (SoftBusMutexLock(&g_proxyChannelList->lock) != 0) {
200 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
201 return SOFTBUS_ERR;
202 }
203
204 LIST_FOR_EACH_ENTRY_SAFE(item, nextNode, &g_proxyChannelList->list, ProxyChannelInfo, node) {
205 if (item->channelId == chanId) {
206 (void)memcpy_s(chan, sizeof(ProxyChannelInfo), item, sizeof(ProxyChannelInfo));
207 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
208 return SOFTBUS_OK;
209 }
210 }
211 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
212 return SOFTBUS_ERR;
213 }
214
TransProxyGetChanByReqId(int32_t reqId,ProxyChannelInfo * chan)215 int32_t TransProxyGetChanByReqId(int32_t reqId, ProxyChannelInfo *chan)
216 {
217 ProxyChannelInfo *item = NULL;
218 if (g_proxyChannelList == NULL) {
219 return SOFTBUS_ERR;
220 }
221
222 if (SoftBusMutexLock(&g_proxyChannelList->lock) != 0) {
223 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
224 return SOFTBUS_ERR;
225 }
226
227 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
228 if (item->reqId == reqId && item->status == PROXY_CHANNEL_STATUS_PYH_CONNECTING) {
229 *chan = *item;
230 break;
231 }
232 }
233 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
234 return SOFTBUS_OK;
235 }
236
TransProxyDelChanByReqId(int32_t reqId)237 NO_SANITIZE("cfi") void TransProxyDelChanByReqId(int32_t reqId)
238 {
239 ProxyChannelInfo *item = NULL;
240 ProxyChannelInfo *nextNode = NULL;
241
242 if (g_proxyChannelList == NULL) {
243 return;
244 }
245
246 if (SoftBusMutexLock(&g_proxyChannelList->lock) != 0) {
247 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
248 return;
249 }
250
251 LIST_FOR_EACH_ENTRY_SAFE(item, nextNode, &g_proxyChannelList->list, ProxyChannelInfo, node) {
252 if ((item->reqId == reqId) &&
253 (item->status == PROXY_CHANNEL_STATUS_PYH_CONNECTING)) {
254 ListDelete(&(item->node));
255 g_proxyChannelList->cnt--;
256 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "del channel(%d) by reqId.", item->channelId);
257 TransProxyPostOpenFailMsgToLoop(item, SOFTBUS_TRANS_PROXY_DISCONNECTED);
258 }
259 }
260 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
261 return;
262 }
263
TransProxyDelChanByChanId(int32_t chanlId)264 NO_SANITIZE("cfi") void TransProxyDelChanByChanId(int32_t chanlId)
265 {
266 ProxyChannelInfo *item = NULL;
267 ProxyChannelInfo *nextNode = NULL;
268
269 if (g_proxyChannelList == NULL) {
270 return;
271 }
272
273 if (SoftBusMutexLock(&g_proxyChannelList->lock) != 0) {
274 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
275 return;
276 }
277
278 LIST_FOR_EACH_ENTRY_SAFE(item, nextNode, &g_proxyChannelList->list, ProxyChannelInfo, node) {
279 if (item->channelId == chanlId) {
280 ListDelete(&(item->node));
281 SoftBusFree(item);
282 g_proxyChannelList->cnt--;
283 break;
284 }
285 }
286 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
287 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "del channel(%d) by chanId!", chanlId);
288 return;
289 }
290
TransProxyChanProcessByReqId(int32_t reqId,uint32_t connId)291 NO_SANITIZE("cfi") void TransProxyChanProcessByReqId(int32_t reqId, uint32_t connId)
292 {
293 ProxyChannelInfo *item = NULL;
294 if (g_proxyChannelList == NULL) {
295 return;
296 }
297
298 if (SoftBusMutexLock(&g_proxyChannelList->lock) != 0) {
299 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
300 return;
301 }
302
303 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
304 if (item->reqId == reqId && item->status == PROXY_CHANNEL_STATUS_PYH_CONNECTING) {
305 item->status = PROXY_CHANNEL_STATUS_HANDSHAKEING;
306 item->connId = connId;
307 TransAddConnRefByConnId(connId);
308 TransProxyPostHandshakeMsgToLoop(item->channelId);
309 }
310 }
311 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
312 return;
313 }
314
TransProxyCloseProxyOtherRes(int32_t channelId,const ProxyChannelInfo * info)315 static void TransProxyCloseProxyOtherRes(int32_t channelId, const ProxyChannelInfo *info)
316 {
317 uint32_t connId = info->connId;
318 bool isServer = (info->isServer != 1);
319 TransProxyPostResetPeerMsgToLoop(info);
320
321 if (isServer) {
322 TransProxyPostDisConnectMsgToLoop(connId);
323 }
324 }
325
TransProxyReleaseChannelList(ListNode * proxyChannelList,int32_t errCode)326 static void TransProxyReleaseChannelList(ListNode *proxyChannelList, int32_t errCode)
327 {
328 if (proxyChannelList == NULL || IsListEmpty(proxyChannelList)) {
329 return;
330 }
331 ProxyChannelInfo *removeNode = NULL;
332 ProxyChannelInfo *nextNode = NULL;
333 LIST_FOR_EACH_ENTRY_SAFE(removeNode, nextNode, proxyChannelList, ProxyChannelInfo, node) {
334 ListDelete(&(removeNode->node));
335 if (removeNode->status == PROXY_CHANNEL_STATUS_HANDSHAKEING ||
336 removeNode->status == PROXY_CHANNEL_STATUS_PYH_CONNECTING) {
337 TransProxyOpenProxyChannelFail(removeNode->channelId, &(removeNode->appInfo), errCode);
338 } else {
339 OnProxyChannelClosed(removeNode->channelId, &(removeNode->appInfo));
340 }
341 TransProxyCloseProxyOtherRes(removeNode->channelId, removeNode);
342 }
343 }
344
TransProxyDelByConnId(uint32_t connId)345 NO_SANITIZE("cfi") void TransProxyDelByConnId(uint32_t connId)
346 {
347 ProxyChannelInfo *removeNode = NULL;
348 ProxyChannelInfo *nextNode = NULL;
349 ListNode proxyChannelList;
350
351 if (g_proxyChannelList == NULL) {
352 return;
353 }
354
355 if (SoftBusMutexLock(&g_proxyChannelList->lock) != 0) {
356 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
357 return;
358 }
359
360 ListInit(&proxyChannelList);
361 LIST_FOR_EACH_ENTRY_SAFE(removeNode, nextNode, &g_proxyChannelList->list, ProxyChannelInfo, node) {
362 if (removeNode->connId == connId) {
363 ListDelete(&(removeNode->node));
364 g_proxyChannelList->cnt--;
365 ListAdd(&proxyChannelList, &removeNode->node);
366 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "trans proxy del channel by connId(%d).", connId);
367 }
368 }
369 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
370 TransProxyReleaseChannelList(&proxyChannelList, SOFTBUS_TRANS_PROXY_DISCONNECTED);
371 }
372
TransProxyDelByChannelId(int32_t channelId,ProxyChannelInfo * channelInfo)373 static int32_t TransProxyDelByChannelId(int32_t channelId, ProxyChannelInfo *channelInfo)
374 {
375 ProxyChannelInfo *removeNode = NULL;
376 ProxyChannelInfo *nextNode = NULL;
377
378 if (g_proxyChannelList == NULL) {
379 return SOFTBUS_ERR;
380 }
381
382 if (SoftBusMutexLock(&g_proxyChannelList->lock) != 0) {
383 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
384 return SOFTBUS_ERR;
385 }
386
387 LIST_FOR_EACH_ENTRY_SAFE(removeNode, nextNode, &g_proxyChannelList->list, ProxyChannelInfo, node) {
388 if (removeNode->channelId == channelId) {
389 if (channelInfo != NULL) {
390 (void)memcpy_s(channelInfo, sizeof(ProxyChannelInfo), removeNode, sizeof(ProxyChannelInfo));
391 }
392 ListDelete(&(removeNode->node));
393 SoftBusFree(removeNode);
394 g_proxyChannelList->cnt--;
395 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
396 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "trans proxy del channel by cId(%d).", channelId);
397 return SOFTBUS_OK;
398 }
399 }
400 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
401 return SOFTBUS_ERR;
402 }
403
TransProxyResetChan(ProxyChannelInfo * chanInfo)404 static int32_t TransProxyResetChan(ProxyChannelInfo *chanInfo)
405 {
406 ProxyChannelInfo *removeNode = NULL;
407 ProxyChannelInfo *nextNode = NULL;
408
409 if (g_proxyChannelList == NULL) {
410 return SOFTBUS_ERR;
411 }
412
413 if (SoftBusMutexLock(&g_proxyChannelList->lock) != 0) {
414 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
415 return SOFTBUS_ERR;
416 }
417
418 LIST_FOR_EACH_ENTRY_SAFE(removeNode, nextNode, &g_proxyChannelList->list, ProxyChannelInfo, node) {
419 if (ResetChanIsEqual(removeNode->status, removeNode, chanInfo) == SOFTBUS_OK) {
420 (void)memcpy_s(chanInfo, sizeof(ProxyChannelInfo), removeNode, sizeof(ProxyChannelInfo));
421 ListDelete(&(removeNode->node));
422 SoftBusFree(removeNode);
423 g_proxyChannelList->cnt--;
424 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
425 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "trans proxy reset channel(%d).", chanInfo->channelId);
426 return SOFTBUS_OK;
427 }
428 }
429 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
430
431 return SOFTBUS_ERR;
432 }
433
TransProxyGetRecvMsgChanInfo(int16_t myId,int16_t peerId,ProxyChannelInfo * chanInfo)434 static int32_t TransProxyGetRecvMsgChanInfo(int16_t myId, int16_t peerId, ProxyChannelInfo *chanInfo)
435 {
436 ProxyChannelInfo *item = NULL;
437
438 if (g_proxyChannelList == NULL) {
439 return SOFTBUS_ERR;
440 }
441
442 if (SoftBusMutexLock(&g_proxyChannelList->lock) != 0) {
443 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
444 return SOFTBUS_ERR;
445 }
446
447 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
448 if ((item->myId == myId) && (item->peerId == peerId)) {
449 if (item->status == PROXY_CHANNEL_STATUS_COMPLETED) {
450 item->timeout = 0;
451 }
452 (void)memcpy_s(chanInfo, sizeof(ProxyChannelInfo), item, sizeof(ProxyChannelInfo));
453 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
454 return SOFTBUS_OK;
455 }
456 }
457 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
458 return SOFTBUS_ERR;
459 }
460
TransProxyKeepAlvieChan(ProxyChannelInfo * chanInfo)461 static int32_t TransProxyKeepAlvieChan(ProxyChannelInfo *chanInfo)
462 {
463 ProxyChannelInfo *item = NULL;
464
465 if (g_proxyChannelList == NULL) {
466 return SOFTBUS_ERR;
467 }
468
469 if (SoftBusMutexLock(&g_proxyChannelList->lock) != 0) {
470 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
471 return SOFTBUS_ERR;
472 }
473
474 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
475 if (ChanIsEqual(item, chanInfo) == SOFTBUS_OK) {
476 if (item->status == PROXY_CHANNEL_STATUS_KEEPLIVEING || item->status == PROXY_CHANNEL_STATUS_COMPLETED) {
477 item->timeout = 0;
478 item->status = PROXY_CHANNEL_STATUS_COMPLETED;
479 }
480 (void)memcpy_s(chanInfo, sizeof(ProxyChannelInfo), item, sizeof(ProxyChannelInfo));
481 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
482 return SOFTBUS_OK;
483 }
484 }
485 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
486 return SOFTBUS_ERR;
487 }
488
TransProxyGetSendMsgChanInfo(int32_t channelId,ProxyChannelInfo * chanInfo)489 NO_SANITIZE("cfi") int32_t TransProxyGetSendMsgChanInfo(int32_t channelId, ProxyChannelInfo *chanInfo)
490 {
491 ProxyChannelInfo *item = NULL;
492
493 if (g_proxyChannelList == NULL) {
494 return SOFTBUS_ERR;
495 }
496
497 if (SoftBusMutexLock(&g_proxyChannelList->lock) != 0) {
498 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
499 return SOFTBUS_ERR;
500 }
501
502 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
503 if (item->channelId == channelId) {
504 if (item->status == PROXY_CHANNEL_STATUS_COMPLETED) {
505 item->timeout = 0;
506 }
507 (void)memcpy_s(chanInfo, sizeof(ProxyChannelInfo), item, sizeof(ProxyChannelInfo));
508 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
509 return SOFTBUS_OK;
510 }
511 }
512 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
513 return SOFTBUS_ERR;
514 }
515
TransProxyGetNewChanSeq(int32_t channelId)516 NO_SANITIZE("cfi") int32_t TransProxyGetNewChanSeq(int32_t channelId)
517 {
518 ProxyChannelInfo *item = NULL;
519 int32_t seq = 0;
520
521 if (g_proxyChannelList == NULL) {
522 return seq;
523 }
524
525 if (SoftBusMutexLock(&g_proxyChannelList->lock) != 0) {
526 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
527 return seq;
528 }
529
530 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
531 if (item->channelId == channelId) {
532 seq = item->seq;
533 item->seq++;
534 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
535 return seq;
536 }
537 }
538 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
539 return seq;
540 }
541
TransProxyGetAuthId(int32_t channelId)542 NO_SANITIZE("cfi") int64_t TransProxyGetAuthId(int32_t channelId)
543 {
544 int64_t authId;
545 ProxyChannelInfo *item = NULL;
546
547 if (g_proxyChannelList == NULL) {
548 return AUTH_INVALID_ID;
549 }
550
551 if (SoftBusMutexLock(&g_proxyChannelList->lock) != 0) {
552 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
553 return AUTH_INVALID_ID;
554 }
555
556 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
557 if (item->channelId == channelId) {
558 authId = item->authId;
559 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
560 return authId;
561 }
562 }
563 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
564 return AUTH_INVALID_ID;
565 }
566
TransProxyGetSessionKeyByChanId(int32_t channelId,char * sessionKey,uint32_t sessionKeySize)567 NO_SANITIZE("cfi") int32_t TransProxyGetSessionKeyByChanId(int32_t channelId, char *sessionKey, uint32_t sessionKeySize)
568 {
569 ProxyChannelInfo *item = NULL;
570
571 if (g_proxyChannelList == NULL) {
572 return SOFTBUS_ERR;
573 }
574
575 if (SoftBusMutexLock(&g_proxyChannelList->lock) != 0) {
576 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
577 return SOFTBUS_ERR;
578 }
579
580 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
581 if (item->channelId == channelId) {
582 if (item->status == PROXY_CHANNEL_STATUS_COMPLETED) {
583 item->timeout = 0;
584 }
585 if (memcpy_s(sessionKey, sessionKeySize, item->appInfo.sessionKey,
586 sizeof(item->appInfo.sessionKey)) != EOK) {
587 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "memcpy_s fail!");
588 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
589 return SOFTBUS_ERR;
590 }
591 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
592 return SOFTBUS_OK;
593 }
594 }
595 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
596 return SOFTBUS_ERR;
597 }
598
TransProxyProcessErrMsg(ProxyChannelInfo * info,int32_t errCode)599 static inline void TransProxyProcessErrMsg(ProxyChannelInfo *info, int32_t errCode)
600 {
601 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "TransProxyProcessErrMsg err: %d", errCode);
602
603 if (TransProxyGetChanByChanId(info->myId, info) != SOFTBUS_OK) {
604 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "TransProxyGetChanByChanId fail");
605 return;
606 }
607
608 if ((info->appInfo.appType == APP_TYPE_NORMAL) || (info->appInfo.appType == APP_TYPE_AUTH)) {
609 (void)TransProxyOpenProxyChannelFail(info->channelId, &(info->appInfo), errCode);
610 }
611 }
612
TransProxyGetAppInfo(int16_t myId,AppInfo * appInfo)613 static int32_t TransProxyGetAppInfo(int16_t myId, AppInfo *appInfo)
614 {
615 ProxyChannelInfo *item = NULL;
616
617 if (g_proxyChannelList == NULL) {
618 return SOFTBUS_ERR;
619 }
620
621 if (SoftBusMutexLock(&g_proxyChannelList->lock) != 0) {
622 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
623 return SOFTBUS_ERR;
624 }
625
626 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
627 if (item->myId == myId) {
628 (void)memcpy_s(appInfo, sizeof(AppInfo), &(item->appInfo), sizeof(item->appInfo));
629 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
630 return SOFTBUS_OK;
631 }
632 }
633 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
634 return SOFTBUS_ERR;
635 }
636
637 static const ConfigTypeMap g_configTypeMap[] = {
638 {CHANNEL_TYPE_AUTH, BUSINESS_TYPE_BYTE, SOFTBUS_INT_AUTH_MAX_BYTES_LENGTH},
639 {CHANNEL_TYPE_AUTH, BUSINESS_TYPE_MESSAGE, SOFTBUS_INT_AUTH_MAX_MESSAGE_LENGTH},
640 {CHANNEL_TYPE_PROXY, BUSINESS_TYPE_BYTE, SOFTBUS_INT_MAX_BYTES_NEW_LENGTH},
641 {CHANNEL_TYPE_PROXY, BUSINESS_TYPE_MESSAGE, SOFTBUS_INT_MAX_MESSAGE_NEW_LENGTH},
642 };
643
FindConfigType(int32_t channelType,int32_t businessType)644 static int32_t FindConfigType(int32_t channelType, int32_t businessType)
645 {
646 for (uint32_t i = 0; i < sizeof(g_configTypeMap) / sizeof(ConfigTypeMap); i++) {
647 if ((g_configTypeMap[i].channelType == channelType) && (g_configTypeMap[i].businessType == businessType)) {
648 return g_configTypeMap[i].configType;
649 }
650 }
651 return SOFTBUS_CONFIG_TYPE_MAX;
652 }
653
TransGetLocalConfig(int32_t channelType,int32_t businessType,uint32_t * len)654 static int TransGetLocalConfig(int32_t channelType, int32_t businessType, uint32_t *len)
655 {
656 ConfigType configType = (ConfigType)FindConfigType(channelType, businessType);
657 if (configType == SOFTBUS_CONFIG_TYPE_MAX) {
658 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "Invalid channelType[%d] businessType[%d]",
659 channelType, businessType);
660 return SOFTBUS_INVALID_PARAM;
661 }
662 uint32_t maxLen;
663 if (SoftbusGetConfig(configType, (unsigned char *)&maxLen, sizeof(maxLen)) != SOFTBUS_OK) {
664 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "get fail configType[%d]", configType);
665 return SOFTBUS_GET_CONFIG_VAL_ERR;
666 }
667 *len = maxLen;
668 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "get local config[%u]", *len);
669 return SOFTBUS_OK;
670 }
671
TransProxyProcessDataConfig(AppInfo * appInfo)672 static int32_t TransProxyProcessDataConfig(AppInfo *appInfo)
673 {
674 if (appInfo == NULL) {
675 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "appInfo is null");
676 return SOFTBUS_ERR;
677 }
678 if (appInfo->businessType != BUSINESS_TYPE_MESSAGE && appInfo->businessType != BUSINESS_TYPE_BYTE) {
679 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "invalid businessType[%d]", appInfo->businessType);
680 return SOFTBUS_OK;
681 }
682 if (appInfo->peerData.dataConfig != 0) {
683 appInfo->myData.dataConfig = MIN(appInfo->myData.dataConfig, appInfo->peerData.dataConfig);
684 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "process dataConfig[%u] succ", appInfo->myData.dataConfig);
685 return SOFTBUS_OK;
686 }
687 ConfigType configType = appInfo->businessType == BUSINESS_TYPE_BYTE ?
688 SOFTBUS_INT_PROXY_MAX_BYTES_LENGTH : SOFTBUS_INT_PROXY_MAX_MESSAGE_LENGTH;
689 if (SoftbusGetConfig(configType, (unsigned char *)&appInfo->myData.dataConfig,
690 sizeof(appInfo->myData.dataConfig)) != SOFTBUS_OK) {
691 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "get config failed, configType[%d]", configType);
692 return SOFTBUS_GET_CONFIG_VAL_ERR;
693 }
694 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "process data config value[%d]", appInfo->myData.dataConfig);
695 return SOFTBUS_OK;
696 }
697
TransProxyProcessHandshakeAckMsg(const ProxyMessage * msg)698 NO_SANITIZE("cfi") void TransProxyProcessHandshakeAckMsg(const ProxyMessage *msg)
699 {
700 ProxyChannelInfo *info = (ProxyChannelInfo *)SoftBusCalloc(sizeof(ProxyChannelInfo));
701 if (info == NULL) {
702 return;
703 }
704 info->myId = msg->msgHead.myId;
705 info->peerId = msg->msgHead.peerId;
706
707 if (TransProxyGetAppInfo(info->myId, &(info->appInfo)) != SOFTBUS_OK) {
708 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "fail to get peer data info");
709 SoftBusFree(info);
710 return;
711 }
712 int32_t errCode = SOFTBUS_OK;
713 if (TransProxyUnPackHandshakeErrMsg(msg->data, &errCode, msg->dateLen) == SOFTBUS_OK) {
714 TransProxyProcessErrMsg(info, errCode);
715 SoftBusFree(info);
716 return;
717 }
718 uint16_t fastDataSize = 0;
719 if (TransProxyUnpackHandshakeAckMsg(msg->data, info, msg->dateLen, &fastDataSize) != SOFTBUS_OK) {
720 SoftBusFree(info);
721 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "UnpackHandshakeAckMsg fail");
722 return;
723 }
724
725 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO,
726 "recv Handshake ack myid %d peerid %d identity %s crc %d",
727 info->myId, info->peerId, info->identity, info->appInfo.crc);
728
729 if (TransProxyProcessDataConfig(&info->appInfo) != SOFTBUS_OK) {
730 SoftBusFree(info);
731 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "ProcessDataConfig fail");
732 return;
733 }
734
735 if (TransProxyUpdateAckInfo(info) != SOFTBUS_OK) {
736 SoftBusFree(info);
737 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "UpdateAckInfo fail");
738 return;
739 }
740
741 info->appInfo.peerData.channelId = msg->msgHead.peerId;
742 if (info->appInfo.fastTransDataSize <= 0 || (fastDataSize > 0 && fastDataSize == info->appInfo.fastTransDataSize)) {
743 (void)OnProxyChannelOpened(info->channelId, &(info->appInfo), PROXY_CHANNEL_CLIENT);
744 } else {
745 uint32_t outLen;
746 char *buf = TransProxyPackFastData(&info->appInfo, &outLen);
747 if (buf == NULL) {
748 SoftBusFree(info);
749 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "failed to pack bytes.");
750 return;
751 }
752 (void)TransSendMsg(info->channelId, CHANNEL_TYPE_PROXY, buf, outLen, info->appInfo.businessType);
753 (void)OnProxyChannelOpened(info->channelId, &(info->appInfo), PROXY_CHANNEL_CLIENT);
754 SoftBusFree(buf);
755 }
756 SoftBusFree(info);
757 }
758
TransProxyGetLocalInfo(ProxyChannelInfo * chan)759 static int TransProxyGetLocalInfo(ProxyChannelInfo *chan)
760 {
761 bool noNeedGetPkg = (chan->appInfo.appType == APP_TYPE_INNER) ||
762 ((chan->appInfo.appType == APP_TYPE_AUTH) && (IsNoPkgNameSession(chan->appInfo.myData.sessionName)));
763 if (!noNeedGetPkg) {
764 if (TransProxyGetPkgName(chan->appInfo.myData.sessionName,
765 chan->appInfo.myData.pkgName, sizeof(chan->appInfo.myData.pkgName)) != SOFTBUS_OK) {
766 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "proc handshake get pkg name fail");
767 return SOFTBUS_TRANS_PEER_SESSION_NOT_CREATED;
768 }
769
770 if (TransProxyGetUidAndPidBySessionName(chan->appInfo.myData.sessionName,
771 &chan->appInfo.myData.uid, &chan->appInfo.myData.pid) != SOFTBUS_OK) {
772 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "proc handshake get uid pid fail");
773 return SOFTBUS_TRANS_PEER_SESSION_NOT_CREATED;
774 }
775 }
776
777 InfoKey key = STRING_KEY_UUID;
778 if (chan->appInfo.appType == APP_TYPE_AUTH) {
779 key = STRING_KEY_DEV_UDID;
780 }
781 if (LnnGetLocalStrInfo(key, chan->appInfo.myData.deviceId,
782 sizeof(chan->appInfo.myData.deviceId)) != 0) {
783 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "Handshake get local info fail");
784 return SOFTBUS_ERR;
785 }
786 return SOFTBUS_OK;
787 }
788
CheckAppTypeAndMsgHead(const ProxyMessageHead * msgHead,const AppInfo * appInfo)789 static inline int32_t CheckAppTypeAndMsgHead(const ProxyMessageHead *msgHead, const AppInfo *appInfo)
790 {
791 if (((msgHead->cipher & ENCRYPTED) == 0) && (appInfo->appType != APP_TYPE_AUTH)) {
792 return SOFTBUS_TRANS_PROXY_ERROR_APP_TYPE;
793 }
794 return SOFTBUS_OK;
795 }
796
ConstructProxyChannelInfo(ProxyChannelInfo * chan,const ProxyMessage * msg,int16_t newChanId,const ConnectionInfo * info)797 static void ConstructProxyChannelInfo(
798 ProxyChannelInfo *chan, const ProxyMessage *msg, int16_t newChanId, const ConnectionInfo *info)
799 {
800 chan->isServer = 1;
801 chan->status = PROXY_CHANNEL_STATUS_COMPLETED;
802 chan->connId = msg->connId;
803 chan->myId = newChanId;
804 chan->channelId = newChanId;
805 chan->peerId = msg->msgHead.peerId;
806 chan->authId = msg->authId;
807 chan->type = info->type;
808 if (chan->type == CONNECT_BLE || chan->type == CONNECT_BLE_DIRECT) {
809 chan->blePrototolType = info->bleInfo.protocol;
810 }
811
812 if (info->type == CONNECT_TCP) {
813 chan->appInfo.routeType = WIFI_STA;
814 } else if (info->type == CONNECT_BR) {
815 chan->appInfo.routeType = BT_BR;
816 } else if (info->type == CONNECT_BLE) {
817 chan->appInfo.routeType = BT_BLE;
818 } else if (info->type == CONNECT_BLE_DIRECT) {
819 chan->appInfo.routeType = BT_BLE;
820 }
821 }
822
TransProxyFillDataConfig(AppInfo * appInfo)823 static int32_t TransProxyFillDataConfig(AppInfo *appInfo)
824 {
825 if (appInfo == NULL) {
826 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "appInfo is null");
827 return SOFTBUS_ERR;
828 }
829 if (appInfo->appType == APP_TYPE_AUTH) {
830 appInfo->businessType = BUSINESS_TYPE_BYTE;
831 }
832 if (appInfo->businessType != BUSINESS_TYPE_MESSAGE && appInfo->businessType != BUSINESS_TYPE_BYTE) {
833 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "invalid businessType[%d]", appInfo->businessType);
834 return SOFTBUS_OK;
835 }
836 if (appInfo->peerData.dataConfig != 0) {
837 uint32_t localDataConfig = 0;
838 if (TransGetLocalConfig(CHANNEL_TYPE_PROXY, appInfo->businessType, &localDataConfig) != SOFTBUS_OK) {
839 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "get local config failed, businessType[%d]",
840 appInfo->businessType);
841 return SOFTBUS_ERR;
842 }
843 appInfo->myData.dataConfig = MIN(localDataConfig, appInfo->peerData.dataConfig);
844 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "fill dataConfig[%u] succ", appInfo->myData.dataConfig);
845 return SOFTBUS_OK;
846 }
847 ConfigType configType = appInfo->businessType == BUSINESS_TYPE_BYTE ?
848 SOFTBUS_INT_PROXY_MAX_BYTES_LENGTH : SOFTBUS_INT_PROXY_MAX_MESSAGE_LENGTH;
849 if (SoftbusGetConfig(configType, (unsigned char *)&appInfo->myData.dataConfig,
850 sizeof(appInfo->myData.dataConfig)) != SOFTBUS_OK) {
851 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "get config failed, configType[%d]", configType);
852 return SOFTBUS_GET_CONFIG_VAL_ERR;
853 }
854 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "fill data config value[%d]", appInfo->myData.dataConfig);
855 return SOFTBUS_OK;
856 }
857
TransProxyFillChannelInfo(const ProxyMessage * msg,ProxyChannelInfo * chan)858 static int32_t TransProxyFillChannelInfo(const ProxyMessage *msg, ProxyChannelInfo *chan)
859 {
860 int32_t ret = TransProxyUnpackHandshakeMsg(msg->data, chan, msg->dateLen);
861 if (ret != SOFTBUS_OK) {
862 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "UnpackHandshakeMsg fail.");
863 return ret;
864 }
865 if ((chan->appInfo.appType == APP_TYPE_AUTH) &&
866 (!CheckSessionNameValidOnAuthChannel(chan->appInfo.myData.sessionName))) {
867 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "proxy auth check sessionname valid.");
868 return SOFTBUS_TRANS_AUTH_NOTALLOW_OPENED;
869 }
870
871 if (CheckAppTypeAndMsgHead(&msg->msgHead, &chan->appInfo) != SOFTBUS_OK) {
872 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "only auth channel surpport plain text data");
873 return SOFTBUS_TRANS_PROXY_ERROR_APP_TYPE;
874 }
875
876 ConnectionInfo info;
877 (void)memset_s(&info, sizeof(ConnectionInfo), 0, sizeof(ConnectionInfo));
878 ret = ConnGetConnectionInfo(msg->connId, &info);
879 if (ret != SOFTBUS_OK) {
880 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "GetConnectionInfo fail connectionId %u", msg->connId);
881 return ret;
882 }
883
884 int16_t newChanId = GenerateChannelId(false);
885 ConstructProxyChannelInfo(chan, msg, newChanId, &info);
886
887 ret = TransProxyGetLocalInfo(chan);
888 if (ret != SOFTBUS_OK) {
889 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "TransProxyGetLocalInfo fail ret=%d.", ret);
890 return ret;
891 }
892
893 ret = TransProxyFillDataConfig(&chan->appInfo);
894 if (ret != SOFTBUS_OK) {
895 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "fill dataConfig fail.");
896 return ret;
897 }
898 return SOFTBUS_OK;
899 }
900
TransProxyProcessHandshakeAuthMsg(const ProxyMessage * msg)901 void TransProxyProcessHandshakeAuthMsg(const ProxyMessage *msg)
902 {
903 AppInfo appInfo;
904 if (TransProxyGetAppInfoByChanId(msg->msgHead.myId, &appInfo) != SOFTBUS_OK) {
905 return;
906 }
907 if ((appInfo.transFlag & TRANS_FLAG_HAS_CHANNEL_AUTH) == 0) {
908 return;
909 }
910 int64_t authSeq = appInfo.authSeq;
911 AuthSessionProcessAuthData(authSeq, (uint8_t*)msg->data, msg->dateLen);
912 }
913
ProcessHandshakeMsgNotifyNearBy(ProxyChannelInfo * chan)914 NO_SANITIZE("cfi") static void ProcessHandshakeMsgNotifyNearBy(ProxyChannelInfo *chan)
915 {
916 if (chan->appInfo.appType == APP_TYPE_NORMAL) {
917 int myHandleId = NotifyNearByUpdateHandleId(chan->channelId);
918 if (myHandleId != SOFTBUS_ERR) {
919 chan->appInfo.myHandleId = myHandleId;
920 }
921 }
922 }
923
TransProxyFastDataRecv(ProxyChannelInfo * chan)924 static void TransProxyFastDataRecv(ProxyChannelInfo *chan)
925 {
926 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO,
927 "TransProxyFastDataRecv begin, fastdatasize = %d", chan->appInfo.fastTransDataSize);
928 TransReceiveData receiveData;
929 receiveData.data = (void*)chan->appInfo.fastTransData;
930 if (chan->appInfo.businessType == BUSINESS_TYPE_MESSAGE && chan->appInfo.routeType == WIFI_STA) {
931 receiveData.dataLen = chan->appInfo.fastTransDataSize + FAST_EXT_MSG_SIZE;
932 } else {
933 receiveData.dataLen = chan->appInfo.fastTransDataSize + FAST_EXT_BYTE_SIZE;
934 }
935 if (chan->appInfo.businessType == BUSINESS_TYPE_MESSAGE) {
936 receiveData.dataType = TRANS_SESSION_MESSAGE;
937 } else {
938 receiveData.dataType = TRANS_SESSION_BYTES;
939 }
940 if (NotifyClientMsgReceived(chan->appInfo.myData.pkgName, chan->appInfo.myData.pid,
941 chan->channelId, &receiveData) != SOFTBUS_OK) {
942 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "TransProxyFastDataRecv err");
943 chan->appInfo.fastTransDataSize = 0;
944 }
945 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "TransProxyFastDataRecv end");
946 return;
947 }
948
TransProxyProcessHandshakeMsg(const ProxyMessage * msg)949 NO_SANITIZE("cfi") void TransProxyProcessHandshakeMsg(const ProxyMessage *msg)
950 {
951 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO,
952 "recv Handshake myid %d peerid %d", msg->msgHead.myId, msg->msgHead.peerId);
953 ProxyChannelInfo *chan = (ProxyChannelInfo *)SoftBusCalloc(sizeof(ProxyChannelInfo));
954 TRAN_CHECK_AND_RETURN_LOG(!(chan == NULL), "proxy handshake calloc failed.");
955
956 int32_t ret = TransProxyFillChannelInfo(msg, chan);
957 if ((ret == SOFTBUS_TRANS_PEER_SESSION_NOT_CREATED) &&
958 (TransProxyAckHandshake(msg->connId, chan, ret) != SOFTBUS_OK)) {
959 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "ErrHandshake fail, connId=%u.", msg->connId);
960 }
961 if (ret != SOFTBUS_OK) {
962 SoftBusFree(chan);
963 return;
964 }
965
966 TransCreateConnByConnId(msg->connId);
967 if ((ret = TransProxyAddChanItem(chan)) != SOFTBUS_OK) {
968 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "AddChanItem fail");
969 SoftBusFree(chan);
970 return;
971 }
972
973 if ((ret = OnProxyChannelOpened(chan->channelId, &(chan->appInfo), PROXY_CHANNEL_SERVER)) != SOFTBUS_OK) {
974 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "OnProxyChannelOpened fail");
975 (void)TransProxyCloseConnChannelReset(msg->connId, false);
976 TransProxyDelChanByChanId(chan->channelId);
977 return;
978 }
979 if (chan->appInfo.fastTransData != NULL && chan->appInfo.fastTransDataSize > 0) {
980 TransProxyFastDataRecv(chan);
981 }
982 ProcessHandshakeMsgNotifyNearBy(chan);
983
984 if ((ret = TransProxyAckHandshake(msg->connId, chan, SOFTBUS_OK)) != SOFTBUS_OK) {
985 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "AckHandshake fail");
986 OnProxyChannelClosed(chan->channelId, &(chan->appInfo));
987 TransProxyDelChanByChanId(chan->channelId);
988 }
989 }
990
TransProxyProcessResetMsg(const ProxyMessage * msg)991 NO_SANITIZE("cfi") void TransProxyProcessResetMsg(const ProxyMessage *msg)
992 {
993 ProxyChannelInfo *info = (ProxyChannelInfo *)SoftBusCalloc(sizeof(ProxyChannelInfo));
994 if (info == NULL) {
995 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "ProxyProcessResetMsg calloc failed.");
996 return;
997 }
998
999 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO,
1000 "recv reset myid %d peerid %d", msg->msgHead.myId, msg->msgHead.peerId);
1001 if (TransProxyUnpackIdentity(msg->data, info->identity, sizeof(info->identity), msg->dateLen) != SOFTBUS_OK) {
1002 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "reset identity fail");
1003 SoftBusFree(info);
1004 return;
1005 }
1006
1007 info->peerId = msg->msgHead.peerId;
1008 info->myId = msg->msgHead.myId;
1009
1010 if (TransProxyResetChan(info) != SOFTBUS_OK) {
1011 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR,
1012 "reset chan fail myid %d peerid %d", msg->msgHead.myId, msg->msgHead.peerId);
1013 SoftBusFree(info);
1014 return;
1015 }
1016
1017 if (CheckAppTypeAndMsgHead(&msg->msgHead, &info->appInfo) != SOFTBUS_OK) {
1018 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "only auth channel surpport plain text data");
1019 SoftBusFree(info);
1020 return;
1021 }
1022 if (info->status == PROXY_CHANNEL_STATUS_HANDSHAKEING) {
1023 TransProxyOpenProxyChannelFail(info->channelId, &(info->appInfo), SOFTBUS_TRANS_HANDSHAKE_ERROR);
1024 } else if (info->status == PROXY_CHANNEL_STATUS_COMPLETED) {
1025 OnProxyChannelClosed(info->channelId, &(info->appInfo));
1026 (void)TransProxyCloseConnChannelReset(msg->connId, (info->isServer == 0));
1027 }
1028 if ((msg->msgHead.cipher & BAD_CIPHER) == BAD_CIPHER) {
1029 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "clear bad key authId:%d",
1030 msg->authId, msg->keyIndex);
1031 RemoveAuthSessionKeyByIndex(msg->authId, msg->keyIndex);
1032 }
1033 SoftBusFree(info);
1034 }
1035
TransProxyProcessKeepAlive(const ProxyMessage * msg)1036 NO_SANITIZE("cfi") void TransProxyProcessKeepAlive(const ProxyMessage *msg)
1037 {
1038 ProxyChannelInfo *info = (ProxyChannelInfo *)SoftBusCalloc(sizeof(ProxyChannelInfo));
1039 if (info == NULL) {
1040 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "ProxyProcessKeepAlive calloc failed.");
1041 return;
1042 }
1043
1044 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO,
1045 "recv keepalive myid %d peerid %d", msg->msgHead.myId, msg->msgHead.peerId);
1046 if (TransProxyUnpackIdentity(msg->data, info->identity, sizeof(info->identity), msg->dateLen) != SOFTBUS_OK) {
1047 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "keep alive unpack identity fail");
1048 SoftBusFree(info);
1049 return;
1050 }
1051 info->peerId = msg->msgHead.peerId;
1052 info->myId = msg->msgHead.myId;
1053
1054 if (TransProxyKeepAlvieChan(info) != SOFTBUS_OK) {
1055 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR,
1056 "reset keep alive proc fail myid %d peerid %d", msg->msgHead.myId, msg->msgHead.peerId);
1057 SoftBusFree(info);
1058 return;
1059 }
1060
1061 TransProxyAckKeepalive(info);
1062 SoftBusFree(info);
1063 }
1064
TransProxyProcessKeepAliveAck(const ProxyMessage * msg)1065 NO_SANITIZE("cfi") void TransProxyProcessKeepAliveAck(const ProxyMessage *msg)
1066 {
1067 ProxyChannelInfo *info = (ProxyChannelInfo *)SoftBusCalloc(sizeof(ProxyChannelInfo));
1068 if (info == NULL) {
1069 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "ProxyProcessKeepAliveAck calloc failed.");
1070 return;
1071 }
1072
1073 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO,
1074 "recv keepalive ack myid %d peerid %d", msg->msgHead.myId, msg->msgHead.peerId);
1075 if (TransProxyUnpackIdentity(msg->data, info->identity, sizeof(info->identity), msg->dateLen) != SOFTBUS_OK) {
1076 SoftBusFree(info);
1077 return;
1078 }
1079 info->peerId = msg->msgHead.peerId;
1080 info->myId = msg->msgHead.myId;
1081
1082 if (TransProxyKeepAlvieChan(info) != SOFTBUS_OK) {
1083 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR,
1084 "reset keep alive ack proc fail myid %d peerid %d", msg->msgHead.myId, msg->msgHead.peerId);
1085 SoftBusFree(info);
1086 return;
1087 }
1088 SoftBusFree(info);
1089 }
1090
TransProxyProcessDataRecv(const ProxyMessage * msg)1091 NO_SANITIZE("cfi") void TransProxyProcessDataRecv(const ProxyMessage *msg)
1092 {
1093 ProxyChannelInfo *info = (ProxyChannelInfo *)SoftBusCalloc(sizeof(ProxyChannelInfo));
1094 if (info == NULL) {
1095 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "ProxyProcessDataRecv calloc failed.");
1096 return;
1097 }
1098
1099 if (TransProxyGetRecvMsgChanInfo(msg->msgHead.myId, msg->msgHead.peerId, info) != SOFTBUS_OK) {
1100 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR,
1101 "data recv get info fail mid %d pid %d", msg->msgHead.myId, msg->msgHead.peerId);
1102 SoftBusFree(info);
1103 return;
1104 }
1105
1106 OnProxyChannelMsgReceived(info->channelId, &(info->appInfo), msg->data, msg->dateLen);
1107 SoftBusFree(info);
1108 }
1109
TransProxyonMessageReceived(const ProxyMessage * msg)1110 NO_SANITIZE("cfi") void TransProxyonMessageReceived(const ProxyMessage *msg)
1111 {
1112 switch (msg->msgHead.type) {
1113 case PROXYCHANNEL_MSG_TYPE_HANDSHAKE: {
1114 TransProxyProcessHandshakeMsg(msg);
1115 break;
1116 }
1117 case PROXYCHANNEL_MSG_TYPE_HANDSHAKE_ACK: {
1118 TransProxyProcessHandshakeAckMsg(msg);
1119 break;
1120 }
1121 case PROXYCHANNEL_MSG_TYPE_RESET: {
1122 TransProxyProcessResetMsg(msg);
1123 break;
1124 }
1125 case PROXYCHANNEL_MSG_TYPE_KEEPALIVE: {
1126 TransProxyProcessKeepAlive(msg);
1127 break;
1128 }
1129 case PROXYCHANNEL_MSG_TYPE_KEEPALIVE_ACK: {
1130 TransProxyProcessKeepAliveAck(msg);
1131 break;
1132 }
1133 case PROXYCHANNEL_MSG_TYPE_NORMAL: {
1134 TransProxyProcessDataRecv(msg);
1135 break;
1136 }
1137 case PROXYCHANNEL_MSG_TYPE_HANDSHAKE_AUTH: {
1138 TransProxyProcessHandshakeAuthMsg(msg);
1139 break;
1140 }
1141 default: {
1142 break;
1143 }
1144 }
1145 }
1146
ConvertConnectType2AuthLinkType(ConnectType type)1147 static inline AuthLinkType ConvertConnectType2AuthLinkType(ConnectType type)
1148 {
1149 if (type == CONNECT_TCP) {
1150 return AUTH_LINK_TYPE_WIFI;
1151 } else if ((type == CONNECT_BLE) || (type == CONNECT_BLE_DIRECT)) {
1152 return AUTH_LINK_TYPE_BLE;
1153 } else if (type == CONNECT_BR) {
1154 return AUTH_LINK_TYPE_BR;
1155 } else {
1156 return AUTH_LINK_TYPE_P2P;
1157 }
1158 }
1159
TransProxyCreateChanInfo(ProxyChannelInfo * chan,int32_t channelId,const AppInfo * appInfo)1160 NO_SANITIZE("cfi") int32_t TransProxyCreateChanInfo(ProxyChannelInfo *chan, int32_t channelId, const AppInfo *appInfo)
1161 {
1162 chan->myId = channelId;
1163 chan->channelId = channelId;
1164
1165 if (GenerateRandomStr(chan->identity, sizeof(chan->identity)) != SOFTBUS_OK) {
1166 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "GenerateRandomStr err");
1167 return SOFTBUS_ERR;
1168 }
1169
1170 if (appInfo->appType != APP_TYPE_AUTH) {
1171 chan->authId = AuthGetLatestIdByUuid(appInfo->peerData.deviceId,
1172 ConvertConnectType2AuthLinkType(chan->type), false);
1173 if (chan->authId == AUTH_INVALID_ID) {
1174 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "get authId for cipher err");
1175 return SOFTBUS_ERR;
1176 }
1177 if (SoftBusGenerateRandomArray((unsigned char *)appInfo->sessionKey, sizeof(appInfo->sessionKey))
1178 != SOFTBUS_OK) {
1179 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "GenerateRandomArray err");
1180 return SOFTBUS_ERR;
1181 }
1182 }
1183
1184 (void)memcpy_s(&(chan->appInfo), sizeof(chan->appInfo), appInfo, sizeof(AppInfo));
1185 if (TransProxyAddChanItem(chan) != SOFTBUS_OK) {
1186 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "trans proxy add channel[%d] fail.", channelId);
1187 return SOFTBUS_ERR;
1188 }
1189 return SOFTBUS_OK;
1190 }
1191
TransProxyOpenProxyChannelSuccess(int32_t chanId)1192 void TransProxyOpenProxyChannelSuccess(int32_t chanId)
1193 {
1194 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "chanId[%d] send handshake msg.", chanId);
1195 ProxyChannelInfo *chan = (ProxyChannelInfo *)SoftBusCalloc(sizeof(ProxyChannelInfo));
1196 if (chan == NULL) {
1197 return;
1198 }
1199
1200 if (TransProxyGetChanByChanId(chanId, chan) != SOFTBUS_OK) {
1201 (void)TransProxyCloseConnChannel(chan->connId);
1202 SoftBusFree(chan);
1203 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "disconnect device chanId %d", chanId);
1204 return;
1205 }
1206
1207 if (TransProxyHandshake(chan) == SOFTBUS_ERR) {
1208 (void)TransProxyCloseConnChannel(chan->connId);
1209 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "chanId[%d] shake hand err.", chanId);
1210 TransProxyOpenProxyChannelFail(chan->channelId, &(chan->appInfo), SOFTBUS_TRANS_HANDSHAKE_ERROR);
1211 TransProxyDelChanByChanId(chanId);
1212 }
1213 SoftBusFree(chan);
1214 return;
1215 }
1216
TransProxyOpenProxyChannelFail(int32_t channelId,const AppInfo * appInfo,int32_t errCode)1217 NO_SANITIZE("cfi") void TransProxyOpenProxyChannelFail(int32_t channelId, const AppInfo *appInfo, int32_t errCode)
1218 {
1219 (void)OnProxyChannelOpenFailed(channelId, appInfo, errCode);
1220 }
1221
TransProxyOpenProxyChannel(AppInfo * appInfo,const ConnectOption * connInfo,int32_t * channelId)1222 NO_SANITIZE("cfi") int32_t TransProxyOpenProxyChannel(AppInfo *appInfo, const ConnectOption *connInfo,
1223 int32_t *channelId)
1224 {
1225 if (appInfo == NULL || connInfo == NULL || channelId == NULL) {
1226 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "open normal channel: invalid para");
1227 return SOFTBUS_ERR;
1228 }
1229
1230 if (connInfo->type == CONNECT_TCP) {
1231 appInfo->routeType = WIFI_STA;
1232 } else if (connInfo->type == CONNECT_BR) {
1233 appInfo->routeType = BT_BR;
1234 } else if (connInfo->type == CONNECT_BLE) {
1235 appInfo->routeType = BT_BLE;
1236 } else if (connInfo->type == CONNECT_BLE_DIRECT) {
1237 appInfo->routeType = BT_BLE;
1238 }
1239 return TransProxyOpenConnChannel(appInfo, connInfo, channelId);
1240 }
1241
TransProxyCloseProxyChannel(int32_t channelId)1242 int32_t TransProxyCloseProxyChannel(int32_t channelId)
1243 {
1244 ProxyChannelInfo *info = (ProxyChannelInfo *)SoftBusCalloc(sizeof(ProxyChannelInfo));
1245 if (info == NULL) {
1246 return SOFTBUS_MALLOC_ERR;
1247 }
1248
1249 if (TransProxyDelByChannelId(channelId, info) != SOFTBUS_OK) {
1250 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "proxy del channel:%d failed.", channelId);
1251 SoftBusFree(info);
1252 return SOFTBUS_TRANS_PROXY_DEL_CHANNELID_INVALID;
1253 }
1254
1255 TransProxyCloseProxyOtherRes(channelId, info);
1256 return SOFTBUS_OK;
1257 }
1258
TransProxyTimerItemProc(const ListNode * proxyProcList)1259 static void TransProxyTimerItemProc(const ListNode *proxyProcList)
1260 {
1261 ProxyChannelInfo *removeNode = NULL;
1262 ProxyChannelInfo *nextNode = NULL;
1263 uint32_t connId;
1264 int8_t status;
1265
1266 LIST_FOR_EACH_ENTRY_SAFE(removeNode, nextNode, proxyProcList, ProxyChannelInfo, node) {
1267 ListDelete(&(removeNode->node));
1268 status = removeNode->status;
1269 if (status == PROXY_CHANNEL_STATUS_TIMEOUT) {
1270 connId = removeNode->connId;
1271 ProxyChannelInfo *resetMsg = (ProxyChannelInfo *)SoftBusMalloc(sizeof(ProxyChannelInfo));
1272 if (resetMsg != NULL) {
1273 (void)memcpy_s(resetMsg, sizeof(ProxyChannelInfo), removeNode, sizeof(ProxyChannelInfo));
1274 TransProxyPostResetPeerMsgToLoop(resetMsg);
1275 }
1276 TransProxyPostOpenClosedMsgToLoop(removeNode);
1277 TransProxyPostDisConnectMsgToLoop(connId);
1278 }
1279 if (status == PROXY_CHANNEL_STATUS_HANDSHAKE_TIMEOUT) {
1280 connId = removeNode->connId;
1281 TransProxyPostOpenFailMsgToLoop(removeNode, SOFTBUS_TRANS_HANDSHAKE_TIMEOUT);
1282 TransProxyPostDisConnectMsgToLoop(connId);
1283 }
1284 if (status == PROXY_CHANNEL_STATUS_KEEPLIVEING) {
1285 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "send keepalive channel %d.", removeNode->myId);
1286 TransProxyPostKeepAliveMsgToLoop(removeNode);
1287 }
1288 }
1289 }
1290
GetBrAgingTimeout(const char * busname)1291 int GetBrAgingTimeout(const char *busname)
1292 {
1293 if (busname == NULL) {
1294 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "GetBrAgingTimeout bus name is null");
1295 return PROXY_CHANNEL_BT_IDLE_TIMEOUT;
1296 }
1297 int thresh = NotifyNearByGetBrAgingTimeoutByBusName(busname);
1298 if (thresh == 0) {
1299 thresh = PROXY_CHANNEL_BT_IDLE_TIMEOUT;
1300 }
1301 return thresh;
1302 }
1303
TransProxyTimerProc(void)1304 void TransProxyTimerProc(void)
1305 {
1306 ProxyChannelInfo *removeNode = NULL;
1307 ProxyChannelInfo *nextNode = NULL;
1308 ListNode proxyProcList;
1309
1310 if (g_proxyChannelList == 0 || g_proxyChannelList->cnt <= 0) {
1311 return;
1312 }
1313 if (SoftBusMutexLock(&g_proxyChannelList->lock) != 0) {
1314 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
1315 return;
1316 }
1317
1318 ListInit(&proxyProcList);
1319 LIST_FOR_EACH_ENTRY_SAFE(removeNode, nextNode, &g_proxyChannelList->list, ProxyChannelInfo, node) {
1320 removeNode->timeout++;
1321 if (removeNode->status == PROXY_CHANNEL_STATUS_HANDSHAKEING ||
1322 removeNode->status == PROXY_CHANNEL_STATUS_PYH_CONNECTING) {
1323 if (removeNode->timeout >= PROXY_CHANNEL_CONTROL_TIMEOUT) {
1324 removeNode->status = PROXY_CHANNEL_STATUS_HANDSHAKE_TIMEOUT;
1325 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "channel (%d) handshake is timeout", removeNode->myId);
1326 ListDelete(&(removeNode->node));
1327 ListAdd(&proxyProcList, &(removeNode->node));
1328 g_proxyChannelList->cnt--;
1329 }
1330 }
1331 if (removeNode->status == PROXY_CHANNEL_STATUS_KEEPLIVEING) {
1332 if (removeNode->timeout >= PROXY_CHANNEL_CONTROL_TIMEOUT) {
1333 removeNode->status = PROXY_CHANNEL_STATUS_TIMEOUT;
1334 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "channel (%d) keepalvie is timeout", removeNode->myId);
1335 ListDelete(&(removeNode->node));
1336 ListAdd(&proxyProcList, &(removeNode->node));
1337 g_proxyChannelList->cnt--;
1338 }
1339 }
1340 if (removeNode->status == PROXY_CHANNEL_STATUS_COMPLETED) {
1341 int thresh = GetBrAgingTimeout(removeNode->appInfo.myData.sessionName);
1342 if (thresh < 0) {
1343 continue;
1344 }
1345 if (removeNode->timeout >= thresh) {
1346 removeNode->status = PROXY_CHANNEL_STATUS_TIMEOUT;
1347 ListDelete(&(removeNode->node));
1348 ListAdd(&proxyProcList, &(removeNode->node));
1349 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "channel (%d) is idle", removeNode->myId);
1350 g_proxyChannelList->cnt--;
1351 }
1352 }
1353 }
1354 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
1355 TransProxyTimerItemProc(&proxyProcList);
1356 }
1357
TransWifiOnLineProc(const char * peerNetworkId)1358 static void TransWifiOnLineProc(const char *peerNetworkId)
1359 {
1360 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "trans wifi online");
1361 if (peerNetworkId == NULL) {
1362 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "TransWifiOnLineProc invalid networkId");
1363 }
1364 int ret = NotifyNearByOnMigrateEvents(peerNetworkId, WIFI_STA, true);
1365 if (ret == SOFTBUS_OK) {
1366 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "notify upgrade migrate success");
1367 return;
1368 }
1369 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "notify upgrade migrate fail");
1370 }
1371
TransWifiOffLineProc(const char * peerNetworkId)1372 static void TransWifiOffLineProc(const char *peerNetworkId)
1373 {
1374 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "trans wifi offline");
1375 if (peerNetworkId == NULL) {
1376 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "TransWifiOffLineProc invalid networkId");
1377 }
1378 int ret = NotifyNearByOnMigrateEvents(peerNetworkId, WIFI_STA, false);
1379 if (ret == SOFTBUS_OK) {
1380 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "notify degrade migrate success");
1381 return;
1382 }
1383 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "notify degrade migrate fail");
1384 }
1385
TransWifiStateChange(const LnnEventBasicInfo * info)1386 void TransWifiStateChange(const LnnEventBasicInfo *info)
1387 {
1388 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "TransWifiStateChange Start");
1389 if ((info == NULL) || (info->event != LNN_EVENT_NODE_MIGRATE)) {
1390 return;
1391 }
1392
1393 LnnOnlineStateEventInfo *onlineStateInfo = (LnnOnlineStateEventInfo*)info;
1394 if (onlineStateInfo->isOnline == true) {
1395 TransWifiOnLineProc(onlineStateInfo->networkId);
1396 } else {
1397 TransWifiOffLineProc(onlineStateInfo->networkId);
1398 }
1399 }
1400
TransNotifyOffLine(const LnnEventBasicInfo * info)1401 static void TransNotifyOffLine(const LnnEventBasicInfo *info)
1402 {
1403 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "Trans Notify OffLine Start");
1404 if ((info == NULL) || (info->event != LNN_EVENT_NODE_ONLINE_STATE_CHANGED)) {
1405 return;
1406 }
1407 LnnOnlineStateEventInfo *onlineStateInfo = (LnnOnlineStateEventInfo*)info;
1408 if (onlineStateInfo->isOnline == true) {
1409 return;
1410 }
1411
1412 TransOnLinkDown(onlineStateInfo->networkId, onlineStateInfo->uuid, onlineStateInfo->udid, "", WIFI_P2P);
1413 TransOnLinkDown(onlineStateInfo->networkId, onlineStateInfo->uuid, onlineStateInfo->udid, "", WIFI_STA);
1414 TransOnLinkDown(onlineStateInfo->networkId, onlineStateInfo->uuid, onlineStateInfo->udid, "", BT_BR);
1415 TransOnLinkDown(onlineStateInfo->networkId, onlineStateInfo->uuid, onlineStateInfo->udid, "", BT_BLE);
1416 }
1417
TransProxyManagerInitInner(const IServerChannelCallBack * cb)1418 NO_SANITIZE("cfi") static int32_t TransProxyManagerInitInner(const IServerChannelCallBack *cb)
1419 {
1420 if (TransProxySetCallBack(cb) != SOFTBUS_OK) {
1421 return SOFTBUS_ERR;
1422 }
1423
1424 g_proxyChannelList = CreateSoftBusList();
1425 if (g_proxyChannelList == NULL) {
1426 return SOFTBUS_ERR;
1427 }
1428 return SOFTBUS_OK;
1429 }
1430
TransProxyManagerInit(const IServerChannelCallBack * cb)1431 NO_SANITIZE("cfi") int32_t TransProxyManagerInit(const IServerChannelCallBack *cb)
1432 {
1433 if (TransProxyManagerInitInner(cb) != SOFTBUS_OK) {
1434 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "init proxy manager failed");
1435 return SOFTBUS_ERR;
1436 }
1437
1438 if (TransProxyTransInit() != SOFTBUS_OK) {
1439 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "TransProxyTransInit fail");
1440 return SOFTBUS_ERR;
1441 }
1442
1443 if (RegisterTimeoutCallback(SOFTBUS_PROXYCHANNEL_TIMER_FUN, TransProxyTimerProc) != SOFTBUS_OK) {
1444 DestroySoftBusList(g_proxyChannelList);
1445 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "trans proxy register timeout callback failed.");
1446 return SOFTBUS_ERR;
1447 }
1448
1449 if (LnnRegisterEventHandler(LNN_EVENT_NODE_ONLINE_STATE_CHANGED, TransNotifyOffLine) != SOFTBUS_OK) {
1450 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "register TransNotifyOffLine failed.");
1451 return SOFTBUS_ERR;
1452 }
1453
1454 if (LnnRegisterEventHandler(LNN_EVENT_NODE_MIGRATE, TransWifiStateChange) != SOFTBUS_OK) {
1455 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "TransWifiStateChange register fail");
1456 return SOFTBUS_ERR;
1457 }
1458
1459 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "proxy channel init ok");
1460 return SOFTBUS_OK;
1461 }
1462
TransProxyGetNameByChanId(int32_t chanId,char * pkgName,char * sessionName,uint16_t pkgLen,uint16_t sessionLen)1463 NO_SANITIZE("cfi") int32_t TransProxyGetNameByChanId(int32_t chanId, char *pkgName, char *sessionName,
1464 uint16_t pkgLen, uint16_t sessionLen)
1465 {
1466 if (pkgName == NULL || sessionName == NULL) {
1467 return SOFTBUS_INVALID_PARAM;
1468 }
1469 ProxyChannelInfo *chan = (ProxyChannelInfo *)SoftBusCalloc(sizeof(ProxyChannelInfo));
1470 if (chan == NULL) {
1471 return SOFTBUS_MALLOC_ERR;
1472 }
1473 if (TransProxyGetChanByChanId(chanId, chan) != SOFTBUS_OK) {
1474 SoftBusFree(chan);
1475 return SOFTBUS_ERR;
1476 }
1477 if (TransProxyGetPkgName(chan->appInfo.myData.sessionName, pkgName, pkgLen) != SOFTBUS_OK) {
1478 SoftBusFree(chan);
1479 return SOFTBUS_ERR;
1480 }
1481 if (strcpy_s(sessionName, sessionLen, chan->appInfo.myData.sessionName) != EOK) {
1482 SoftBusFree(chan);
1483 return SOFTBUS_MEM_ERR;
1484 }
1485 SoftBusFree(chan);
1486 return SOFTBUS_OK;
1487 }
1488
1489
TransProxyManagerDeinitInner(void)1490 static void TransProxyManagerDeinitInner(void)
1491 {
1492 ProxyChannelInfo *item = NULL;
1493 ProxyChannelInfo *nextNode = NULL;
1494 if (SoftBusMutexLock(&g_proxyChannelList->lock) != 0) {
1495 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
1496 return;
1497 }
1498 LIST_FOR_EACH_ENTRY_SAFE(item, nextNode, &g_proxyChannelList->list, ProxyChannelInfo, node) {
1499 ListDelete(&(item->node));
1500 SoftBusFree(item);
1501 }
1502 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
1503
1504 DestroySoftBusList(g_proxyChannelList);
1505 }
1506
TransProxyManagerDeinit(void)1507 NO_SANITIZE("cfi") void TransProxyManagerDeinit(void)
1508 {
1509 TransProxyManagerDeinitInner();
1510
1511 (void)RegisterTimeoutCallback(SOFTBUS_PROXYCHANNEL_TIMER_FUN, NULL);
1512 }
1513
TransProxyDestroyChannelList(const ListNode * destroyList)1514 static void TransProxyDestroyChannelList(const ListNode *destroyList)
1515 {
1516 if ((destroyList == NULL) || IsListEmpty(destroyList)) {
1517 return;
1518 }
1519
1520 ProxyChannelInfo *destroyNode = NULL;
1521 ProxyChannelInfo *nextDestroyNode = NULL;
1522 LIST_FOR_EACH_ENTRY_SAFE(destroyNode, nextDestroyNode, destroyList, ProxyChannelInfo, node) {
1523 ListDelete(&(destroyNode->node));
1524 TransProxyResetPeer(destroyNode);
1525 TransProxyCloseConnChannel(destroyNode->connId);
1526 SoftBusFree(destroyNode);
1527 }
1528 return;
1529 }
1530
TransProxyDeathCallback(const char * pkgName,int32_t pid)1531 NO_SANITIZE("cfi") void TransProxyDeathCallback(const char *pkgName, int32_t pid)
1532 {
1533 if ((pkgName == NULL) || (g_proxyChannelList == NULL)) {
1534 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "pkgName or proxy channel list is null.");
1535 return;
1536 }
1537
1538 ListNode destroyList;
1539 ListInit(&destroyList);
1540 ProxyChannelInfo *item = NULL;
1541 ProxyChannelInfo *nextNode = NULL;
1542 if (SoftBusMutexLock(&g_proxyChannelList->lock) != 0) {
1543 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
1544 return;
1545 }
1546 LIST_FOR_EACH_ENTRY_SAFE(item, nextNode, &g_proxyChannelList->list, ProxyChannelInfo, node) {
1547 if ((strcmp(item->appInfo.myData.pkgName, pkgName) == 0) && (item->appInfo.myData.pid == pid)) {
1548 ListDelete(&(item->node));
1549 g_proxyChannelList->cnt--;
1550 ListAdd(&destroyList, &(item->node));
1551 }
1552 }
1553 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
1554 TransProxyDestroyChannelList(&destroyList);
1555 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "TransProxyDeathCallback end.");
1556 }
1557
TransProxyGetAppInfoByChanId(int32_t chanId,AppInfo * appInfo)1558 NO_SANITIZE("cfi") int32_t TransProxyGetAppInfoByChanId(int32_t chanId, AppInfo* appInfo)
1559 {
1560 ProxyChannelInfo *item = NULL;
1561 ProxyChannelInfo *nextNode = NULL;
1562
1563 if (g_proxyChannelList == NULL) {
1564 return SOFTBUS_ERR;
1565 }
1566
1567 if (SoftBusMutexLock(&g_proxyChannelList->lock) != 0) {
1568 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
1569 return SOFTBUS_ERR;
1570 }
1571
1572 LIST_FOR_EACH_ENTRY_SAFE(item, nextNode, &g_proxyChannelList->list, ProxyChannelInfo, node) {
1573 if (item->channelId == chanId) {
1574 (void)memcpy_s(appInfo, sizeof(AppInfo), &item->appInfo, sizeof(AppInfo));
1575 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
1576 return SOFTBUS_OK;
1577 }
1578 }
1579 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
1580 return SOFTBUS_ERR;
1581 }
1582
TransProxyGetConnIdByChanId(int32_t channelId,int32_t * connId)1583 NO_SANITIZE("cfi") int32_t TransProxyGetConnIdByChanId(int32_t channelId, int32_t *connId)
1584 {
1585 if (g_proxyChannelList == NULL) {
1586 return SOFTBUS_ERR;
1587 }
1588 ProxyChannelInfo *item = NULL;
1589 if (SoftBusMutexLock(&g_proxyChannelList->lock) != 0) {
1590 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
1591 return SOFTBUS_ERR;
1592 }
1593 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
1594 if (item->channelId == channelId) {
1595 if (item->status == PROXY_CHANNEL_STATUS_COMPLETED || item->status ==
1596 PROXY_CHANNEL_STATUS_KEEPLIVEING) {
1597 *connId = item->connId;
1598 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
1599 return SOFTBUS_OK;
1600 } else {
1601 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "g_proxyChannel status error");
1602 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
1603 return SOFTBUS_ERR;
1604 }
1605 }
1606 }
1607 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
1608 return SOFTBUS_ERR;
1609 }
1610
TransProxyGetConnOptionByChanId(int32_t channelId,ConnectOption * connOpt)1611 NO_SANITIZE("cfi") int32_t TransProxyGetConnOptionByChanId(int32_t channelId, ConnectOption *connOpt)
1612 {
1613 if (connOpt == NULL) {
1614 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "[%s] invalid param.", __func__);
1615 return SOFTBUS_ERR;
1616 }
1617
1618 int32_t connId = -1;
1619 int32_t ret = TransProxyGetConnIdByChanId(channelId, &connId);
1620 if (ret != SOFTBUS_OK) {
1621 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "channel=%d get proxy connid fail, %d.", channelId, ret);
1622 return ret;
1623 }
1624
1625 ret = TransProxyGetConnInfoByConnId(connId, connOpt);
1626 if (ret != SOFTBUS_OK) {
1627 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "channel=%d get conn optinfo fail, %d.", channelId, ret);
1628 return ret;
1629 }
1630 return SOFTBUS_OK;
1631 }
1632