1 /*
2 * Copyright (c) 2021-2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "softbus_proxychannel_transceiver.h"
17
18 #include <securec.h>
19
20 #include "message_handler.h"
21 #include "g_enhance_lnn_func.h"
22 #include "g_enhance_lnn_func_pack.h"
23 #include "g_enhance_conn_func.h"
24 #include "g_enhance_conn_func_pack.h"
25 #include "legacy/softbus_adapter_hitrace.h"
26 #include "legacy/softbus_hisysevt_transreporter.h"
27 #include "lnn_async_callback_utils.h"
28 #include "softbus_adapter_mem.h"
29 #include "softbus_adapter_thread.h"
30 #include "softbus_conn_interface.h"
31 #include "softbus_def.h"
32 #include "softbus_error_code.h"
33 #include "softbus_proxychannel_control.h"
34 #include "softbus_proxychannel_listener.h"
35 #include "softbus_proxychannel_manager.h"
36 #include "softbus_proxychannel_message.h"
37 #include "softbus_proxychannel_pipeline.h"
38 #include "softbus_utils.h"
39 #include "softbus_init_common.h"
40 #include "trans_auth_negotiation.h"
41 #include "trans_channel_common.h"
42 #include "trans_channel_manager.h"
43 #include "trans_event.h"
44 #include "trans_log.h"
45
46 #define ID_OFFSET (1)
47 #define WAIT_LISTEN_CHECK_DELAY (200)
48 #define WAIT_LISTEN_CHECK_NUM (50)
49
50 static SoftBusList *g_proxyConnectionList = NULL;
51 static SoftBusList *g_proxyPagingWaitList = NULL;
52 const char *g_transProxyLoopName = "transProxyLoopName";
53 SoftBusHandler g_transLoopHandler = { 0 };
54
55 typedef enum {
56 LOOP_HANDSHAKE_MSG,
57 LOOP_DISCONNECT_MSG,
58 LOOP_OPENFAIL_MSG,
59 LOOP_OPENCLOSE_MSG,
60 LOOP_KEEPALIVE_MSG,
61 LOOP_RESETPEER_MSG,
62 LOOP_AUTHSTATECHECK_MSG,
63 LOOP_PAGINGHANDSHAKE_MSG,
64 } LoopMsg;
65
66 typedef enum {
67 WAIT_LISTEN_CHECK_INVALID = -1,
68 WAIT_LISTEN_CHECK_SUCCESS = 0,
69 WAIT_LISTEN_CHECK_LOAD_FAIL,
70 WAIT_LISTEN_CHECK_RETRY,
71 WAIT_LISTEN_CHECK_TIMEOUT,
72 } CheckResultType;
73
TransDelConnByReqId(uint32_t requestId)74 int32_t TransDelConnByReqId(uint32_t requestId)
75 {
76 ProxyConnInfo *removeNode = NULL;
77 ProxyConnInfo *tmpNode = NULL;
78
79 if (g_proxyConnectionList == NULL) {
80 TRANS_LOGE(TRANS_CTRL, "g_proxyConnectionList is null!");
81 return SOFTBUS_NO_INIT;
82 }
83
84 if (SoftBusMutexLock(&g_proxyConnectionList->lock) != SOFTBUS_OK) {
85 TRANS_LOGE(TRANS_CTRL, "lock mutex fail!");
86 return SOFTBUS_LOCK_ERR;
87 }
88
89 LIST_FOR_EACH_ENTRY_SAFE(removeNode, tmpNode, &g_proxyConnectionList->list, ProxyConnInfo, node) {
90 if (removeNode->requestId == requestId && removeNode->state == PROXY_CHANNEL_STATUS_PYH_CONNECTING) {
91 ListDelete(&(removeNode->node));
92 TRANS_LOGI(TRANS_CTRL, "delete requestId=%{public}u", removeNode->requestId);
93 SoftBusFree(removeNode);
94 g_proxyConnectionList->cnt--;
95 break;
96 }
97 }
98 (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
99 return SOFTBUS_OK;
100 }
101
TransDelConnByConnId(uint32_t connId)102 void TransDelConnByConnId(uint32_t connId)
103 {
104 ProxyConnInfo *removeNode = NULL;
105 ProxyConnInfo *tmpNode = NULL;
106
107 if ((g_proxyConnectionList == NULL) || (connId == 0)) {
108 TRANS_LOGE(TRANS_CTRL, "g_proxyConnectionList or connId is null");
109 return;
110 }
111
112 if (SoftBusMutexLock(&g_proxyConnectionList->lock) != SOFTBUS_OK) {
113 TRANS_LOGE(TRANS_CTRL, "lock mutex fail!");
114 return;
115 }
116
117 LIST_FOR_EACH_ENTRY_SAFE(removeNode, tmpNode, &g_proxyConnectionList->list, ProxyConnInfo, node) {
118 if (removeNode->connId == connId) {
119 ListDelete(&(removeNode->node));
120 SoftBusFree(removeNode);
121 TRANS_LOGI(TRANS_CTRL, "del conn item. connId=%{public}d", connId);
122 g_proxyConnectionList->cnt--;
123 }
124 }
125 (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
126 return;
127 }
128
TransDecConnRefByConnId(uint32_t connId,bool isServer)129 int32_t TransDecConnRefByConnId(uint32_t connId, bool isServer)
130 {
131 ProxyConnInfo *removeNode = NULL;
132 ProxyConnInfo *tmpNode = NULL;
133
134 if ((g_proxyConnectionList == NULL) || (connId == 0)) {
135 TRANS_LOGE(TRANS_MSG, "g_proxyConnectionList or connId is null");
136 return SOFTBUS_NO_INIT;
137 }
138
139 if (SoftBusMutexLock(&g_proxyConnectionList->lock) != SOFTBUS_OK) {
140 TRANS_LOGE(TRANS_CTRL, "lock mutex fail!");
141 return SOFTBUS_LOCK_ERR;
142 }
143
144 LIST_FOR_EACH_ENTRY_SAFE(removeNode, tmpNode, &g_proxyConnectionList->list, ProxyConnInfo, node) {
145 if (removeNode->connId == connId && removeNode->isServerSide == isServer) {
146 removeNode->ref--;
147 if (removeNode->ref <= 0) {
148 ListDelete(&(removeNode->node));
149 SoftBusFree(removeNode);
150 g_proxyConnectionList->cnt--;
151 (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
152 TRANS_LOGI(TRANS_CTRL, "conn ref is 0. connId=%{public}u", connId);
153 return SOFTBUS_OK;
154 } else {
155 TRANS_LOGI(TRANS_CTRL, "connId=%{public}u, proxyConnRef=%{public}d", connId, removeNode->ref);
156 (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
157 return SOFTBUS_TRANS_NOT_MATCH;
158 }
159 }
160 }
161
162 TRANS_LOGW(TRANS_CTRL, "not find item. connId=%{public}u", connId);
163 (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
164 return SOFTBUS_OK;
165 }
166
TransAddConnRefByConnId(uint32_t connId,bool isServer)167 int32_t TransAddConnRefByConnId(uint32_t connId, bool isServer)
168 {
169 ProxyConnInfo *item = NULL;
170
171 if (g_proxyConnectionList == NULL) {
172 TRANS_LOGE(TRANS_MSG, "g_proxyConnectionList is null");
173 return SOFTBUS_NO_INIT;
174 }
175
176 if (SoftBusMutexLock(&g_proxyConnectionList->lock) != SOFTBUS_OK) {
177 TRANS_LOGE(TRANS_CTRL, "lock mutex fail!");
178 return SOFTBUS_LOCK_ERR;
179 }
180
181 LIST_FOR_EACH_ENTRY(item, &g_proxyConnectionList->list, ProxyConnInfo, node) {
182 if (item->connId == connId && item->isServerSide == isServer) {
183 item->ref++;
184 TRANS_LOGI(TRANS_CTRL, "add connId=%{public}u, proxyConnRef=%{public}d.", connId, item->ref);
185 (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
186 return SOFTBUS_OK;
187 }
188 }
189 (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
190 return SOFTBUS_TRANS_PROXY_CONN_ADD_REF_FAILED;
191 }
192
TransProxyResetAndCloseConn(ProxyChannelInfo * chan)193 static int32_t TransProxyResetAndCloseConn(ProxyChannelInfo *chan)
194 {
195 int32_t ret = TransProxyResetPeer(chan);
196 if (ret != SOFTBUS_OK) {
197 TRANS_LOGW(TRANS_CTRL, "reset to peer msg send failed.");
198 }
199 if (TransDecConnRefByConnId(chan->connId, chan->isServer) == SOFTBUS_OK) {
200 TRANS_LOGI(TRANS_CTRL, "reset dis device. isDisconnect=%{public}d, connId=%{public}u, deviceType=%{public}d",
201 !chan->isServer, chan->connId, chan->deviceTypeIsWinpc);
202 // only client side can disconnect connection
203 if (((!chan->isServer) || ret != SOFTBUS_OK) && (!chan->deviceTypeIsWinpc)) {
204 (void)ConnDisconnectDevice(chan->connId);
205 }
206 }
207 return SOFTBUS_OK;
208 }
209
TransProxyLoopMsgHandler(SoftBusMessage * msg)210 static void TransProxyLoopMsgHandler(SoftBusMessage *msg)
211 {
212 TRANS_CHECK_AND_RETURN_LOGE(msg != NULL, TRANS_MSG, "param invalid");
213 TRANS_LOGD(TRANS_CTRL, "trans loop process msgType=%{public}d", msg->what);
214 int32_t channelId;
215 ProxyChannelInfo *chan = NULL;
216 switch (msg->what) {
217 case LOOP_HANDSHAKE_MSG:
218 channelId = *((int32_t *)msg->obj);
219 TransProxyOpenProxyChannelSuccess(channelId);
220 break;
221 case LOOP_DISCONNECT_MSG: {
222 bool isServer = (bool)msg->arg1;
223 uint32_t connectionId = (uint32_t)msg->arg2;
224 chan = (ProxyChannelInfo *)msg->obj;
225 TRANS_CHECK_AND_RETURN_LOGE(chan != NULL, TRANS_MSG, "LOOP_DISCONNECT_MSG, chan is null");
226 TransProxyCloseConnChannelReset(connectionId, (isServer == 0), isServer, chan->deviceTypeIsWinpc);
227 break;
228 }
229 case LOOP_OPENFAIL_MSG:
230 chan = (ProxyChannelInfo *)msg->obj;
231 TRANS_CHECK_AND_RETURN_LOGE(chan != NULL, TRANS_MSG, "LOOP_OPENFAIL_MSG, chan is null");
232 TransProxyOpenProxyChannelFail(chan->channelId, &(chan->appInfo), (int32_t)msg->arg1);
233 break;
234 case LOOP_OPENCLOSE_MSG:
235 chan = (ProxyChannelInfo *)msg->obj;
236 TRANS_CHECK_AND_RETURN_LOGE(chan != NULL, TRANS_MSG, "LOOP_OPENCLOSE_MSG, chan is null");
237 OnProxyChannelClosed(chan->channelId, &(chan->appInfo));
238 break;
239 case LOOP_KEEPALIVE_MSG:
240 chan = (ProxyChannelInfo *)msg->obj;
241 TRANS_CHECK_AND_RETURN_LOGE(chan != NULL, TRANS_MSG, "LOOP_KEEPALIVE_MSG, chan is null");
242 TransProxyKeepalive(chan->connId, chan);
243 break;
244 case LOOP_RESETPEER_MSG:
245 chan = (ProxyChannelInfo *)msg->obj;
246 TRANS_CHECK_AND_RETURN_LOGE(chan != NULL, TRANS_MSG, "LOOP_RESETPEER_MSG, chan is null");
247 TransProxyResetAndCloseConn(chan);
248 break;
249 case LOOP_AUTHSTATECHECK_MSG: {
250 uint32_t authRequestId = (uint32_t)msg->arg1;
251 channelId = (int32_t)msg->arg2;
252 TransAuthNegoTaskManager(authRequestId, channelId);
253 break;
254 }
255 case LOOP_PAGINGHANDSHAKE_MSG: {
256 channelId = (int32_t)msg->arg1;
257 uint32_t keyLen = (uint32_t)msg->arg2;
258 uint8_t *authKey = (uint8_t *)msg->obj;
259 TRANS_CHECK_AND_RETURN_LOGE(authKey != NULL, TRANS_MSG, "LOOP_PAGINGHANDSHAKE_MSG, authKey is null");
260 TransPagingHandshake(channelId, authKey, keyLen);
261 break;
262 }
263 default:
264 break;
265 }
266 }
267
TransProxyFreeLoopMsg(SoftBusMessage * msg)268 void TransProxyFreeLoopMsg(SoftBusMessage *msg)
269 {
270 if (msg != NULL) {
271 if (msg->obj != NULL) {
272 SoftBusFree(msg->obj);
273 }
274 SoftBusFree((void *)msg);
275 }
276 }
277
TransProxyCreateLoopMsg(int32_t what,uint64_t arg1,uint64_t arg2,char * data)278 static SoftBusMessage *TransProxyCreateLoopMsg(int32_t what, uint64_t arg1, uint64_t arg2, char *data)
279 {
280 if (data == NULL) {
281 TRANS_LOGE(TRANS_MSG, "invalid param.");
282 return NULL;
283 }
284
285 SoftBusMessage *msg = (SoftBusMessage *)SoftBusCalloc(sizeof(SoftBusMessage));
286 if (msg == NULL) {
287 TRANS_LOGE(TRANS_MSG, "msg calloc failed");
288 return NULL;
289 }
290 msg->what = what;
291 msg->arg1 = arg1;
292 msg->arg2 = arg2;
293 msg->handler = &g_transLoopHandler;
294 msg->FreeMessage = TransProxyFreeLoopMsg;
295 msg->obj = (void *)data;
296 return msg;
297 }
298
TransProxyPostAuthNegoMsgToLooperDelay(uint32_t authRequestId,int32_t channelId,uint32_t delayTime)299 void TransProxyPostAuthNegoMsgToLooperDelay(uint32_t authRequestId, int32_t channelId, uint32_t delayTime)
300 {
301 SoftBusMessage *msg = TransProxyCreateLoopMsg(LOOP_AUTHSTATECHECK_MSG, authRequestId, channelId, NULL);
302 TRANS_CHECK_AND_RETURN_LOGE(msg != NULL, TRANS_MSG, "msg create failed");
303
304 g_transLoopHandler.looper->PostMessageDelay(g_transLoopHandler.looper, msg, delayTime);
305 }
306
TransProxyPostResetPeerMsgToLoop(const ProxyChannelInfo * chan)307 void TransProxyPostResetPeerMsgToLoop(const ProxyChannelInfo *chan)
308 {
309 SoftBusMessage *msg = TransProxyCreateLoopMsg(LOOP_RESETPEER_MSG, 0, 0, (char *)chan);
310 if (msg == NULL) {
311 TRANS_LOGE(TRANS_MSG, "msg create failed");
312 if (chan != NULL) {
313 (void)memset_s(
314 (void *)chan->appInfo.sessionKey,
315 sizeof(chan->appInfo.sessionKey), 0, sizeof(chan->appInfo.sessionKey));
316 SoftBusFree((void *)chan);
317 }
318 return;
319 }
320 g_transLoopHandler.looper->PostMessage(g_transLoopHandler.looper, msg);
321 }
322
TransProxyPostHandshakeMsgToLoop(int32_t channelId)323 void TransProxyPostHandshakeMsgToLoop(int32_t channelId)
324 {
325 int32_t *chanIdMsg = (int32_t *)SoftBusCalloc(sizeof(int32_t));
326 if (chanIdMsg == NULL) {
327 TRANS_LOGE(TRANS_MSG, "chanIdMsg calloc failed");
328 return;
329 }
330 *chanIdMsg = channelId;
331 SoftBusMessage *msg = TransProxyCreateLoopMsg(LOOP_HANDSHAKE_MSG, 0, 0, (char *)chanIdMsg);
332 if (msg == NULL) {
333 SoftBusFree((void *)chanIdMsg);
334 return;
335 }
336 g_transLoopHandler.looper->PostMessage(g_transLoopHandler.looper, msg);
337 }
338
TransProxyPostDisConnectMsgToLoop(uint32_t connId,bool isServer,const ProxyChannelInfo * chan)339 void TransProxyPostDisConnectMsgToLoop(uint32_t connId, bool isServer, const ProxyChannelInfo *chan)
340 {
341 SoftBusMessage *msg = TransProxyCreateLoopMsg(LOOP_DISCONNECT_MSG, isServer, connId, (char *)chan);
342 if (msg == NULL) {
343 TRANS_LOGE(TRANS_MSG, "msg create failed");
344 SoftBusFree((void *)chan);
345 return;
346 }
347 g_transLoopHandler.looper->PostMessage(g_transLoopHandler.looper, msg);
348 }
349
TransProxyPostKeepAliveMsgToLoop(const ProxyChannelInfo * chan)350 void TransProxyPostKeepAliveMsgToLoop(const ProxyChannelInfo *chan)
351 {
352 if (chan == NULL) {
353 TRANS_LOGE(TRANS_MSG, "param invalid");
354 return;
355 }
356 SoftBusMessage *msg = TransProxyCreateLoopMsg(LOOP_KEEPALIVE_MSG, 0, 0, (char *)chan);
357 if (msg == NULL) {
358 TRANS_LOGE(TRANS_MSG, "msg create failed");
359 if (chan != NULL) {
360 SoftBusFree((void *)chan);
361 }
362 return;
363 }
364 g_transLoopHandler.looper->PostMessage(g_transLoopHandler.looper, msg);
365 }
366
TransProxyPostOpenFailMsgToLoop(const ProxyChannelInfo * chan,int32_t errCode)367 void TransProxyPostOpenFailMsgToLoop(const ProxyChannelInfo *chan, int32_t errCode)
368 {
369 if (chan == NULL) {
370 TRANS_LOGE(TRANS_MSG, "param invalid");
371 return;
372 }
373 SoftBusMessage *msg = TransProxyCreateLoopMsg(LOOP_OPENFAIL_MSG, errCode, 0, (char *)chan);
374 if (msg == NULL) {
375 TRANS_LOGE(TRANS_MSG, "msg create failed");
376 if (chan != NULL) {
377 SoftBusFree((void *)chan);
378 }
379 return;
380 }
381 g_transLoopHandler.looper->PostMessage(g_transLoopHandler.looper, msg);
382 }
383
TransProxyPostOpenClosedMsgToLoop(const ProxyChannelInfo * chan)384 void TransProxyPostOpenClosedMsgToLoop(const ProxyChannelInfo *chan)
385 {
386 if (chan == NULL) {
387 TRANS_LOGE(TRANS_MSG, "param invalid");
388 return;
389 }
390 SoftBusMessage *msg = TransProxyCreateLoopMsg(LOOP_OPENCLOSE_MSG, 0, 0, (char *)chan);
391 if (msg == NULL) {
392 TRANS_LOGE(TRANS_MSG, "msg create failed");
393 if (chan != NULL) {
394 SoftBusFree((void *)chan);
395 }
396 return;
397 }
398 g_transLoopHandler.looper->PostMessage(g_transLoopHandler.looper, msg);
399 }
400
TransProxyPagingHandshakeMsgToLoop(int32_t channelId,uint8_t * authKey,uint32_t keyLen)401 void TransProxyPagingHandshakeMsgToLoop(int32_t channelId, uint8_t *authKey, uint32_t keyLen)
402 {
403 if (authKey == NULL) {
404 TRANS_LOGE(TRANS_MSG, "param invalid");
405 return;
406 }
407 SoftBusMessage *msg = TransProxyCreateLoopMsg(LOOP_PAGINGHANDSHAKE_MSG, channelId, keyLen, (char *)authKey);
408 if (msg == NULL) {
409 TRANS_LOGE(TRANS_MSG, "msg create failed");
410 if (authKey != NULL) {
411 SoftBusFree((void *)authKey);
412 }
413 return;
414 }
415 g_transLoopHandler.looper->PostMessage(g_transLoopHandler.looper, msg);
416 }
417
TransProxyLoopInit(void)418 static int32_t TransProxyLoopInit(void)
419 {
420 g_transLoopHandler.name = (char *)g_transProxyLoopName;
421 g_transLoopHandler.looper = GetLooper(LOOP_TYPE_DEFAULT);
422 if (g_transLoopHandler.looper == NULL) {
423 return SOFTBUS_TRANS_INIT_FAILED;
424 }
425 g_transLoopHandler.HandleMessage = TransProxyLoopMsgHandler;
426 return SOFTBUS_OK;
427 }
428
TransProxyTransSendMsg(uint32_t connectionId,uint8_t * buf,uint32_t len,int32_t priority,int32_t pid)429 int32_t TransProxyTransSendMsg(uint32_t connectionId, uint8_t *buf, uint32_t len, int32_t priority, int32_t pid)
430 {
431 ConnPostData data = { 0 };
432 static uint64_t seq = 1;
433
434 data.module = MODULE_PROXY_CHANNEL;
435 data.seq = seq++;
436 data.flag = priority;
437 data.pid = pid;
438 data.len = len;
439 data.buf = (char *)buf;
440 TRANS_LOGI(TRANS_MSG,
441 "send msg connId=%{public}u, len=%{public}u, seq=%{public}" PRIu64 ", priority=%{public}d, pid=%{public}d",
442 connectionId, len, data.seq, priority, pid);
443 int32_t ret = ConnPostBytes(connectionId, &data);
444 if (ret < 0) {
445 TRANS_LOGE(TRANS_MSG, "conn send buf fail ret=%{public}d", ret);
446 return ret;
447 }
448 return SOFTBUS_OK;
449 }
450
TransProxyOnConnected(uint32_t connId,const ConnectionInfo * connInfo)451 static void TransProxyOnConnected(uint32_t connId, const ConnectionInfo *connInfo)
452 {
453 (void)connInfo;
454 TRANS_LOGI(TRANS_CTRL, "connect enabled, connId=%{public}u", connId);
455 }
456
TransProxyOnDisConnect(uint32_t connId,const ConnectionInfo * connInfo)457 static void TransProxyOnDisConnect(uint32_t connId, const ConnectionInfo *connInfo)
458 {
459 SoftBusHitraceChainBegin("TransProxyOnDisConnect");
460 (void)connInfo;
461 TRANS_LOGI(TRANS_CTRL, "connect disabled, connId=%{public}u", connId);
462 TransProxyDelByConnId(connId);
463 TransDelConnByConnId(connId);
464 SoftBusHitraceChainEnd();
465 }
466
CompareConnectOption(const ConnectOption * itemConnInfo,const ConnectOption * connInfo)467 static bool CompareConnectOption(const ConnectOption *itemConnInfo, const ConnectOption *connInfo)
468 {
469 if (connInfo->type == CONNECT_TCP) {
470 TRANS_LOGI(TRANS_CTRL, "CONNECT_TCP");
471 if (connInfo->socketOption.protocol == itemConnInfo->socketOption.protocol &&
472 strcasecmp(connInfo->socketOption.addr, itemConnInfo->socketOption.addr) == 0 &&
473 connInfo->socketOption.port == itemConnInfo->socketOption.port) {
474 return true;
475 }
476 return false;
477 } else if (connInfo->type == CONNECT_BR) {
478 TRANS_LOGI(TRANS_CTRL, "CONNECT_BR");
479 if (strcasecmp(connInfo->brOption.brMac, itemConnInfo->brOption.brMac) == 0) {
480 return true;
481 }
482 return false;
483 } else if (connInfo->type == CONNECT_BLE) {
484 TRANS_LOGI(TRANS_CTRL, "CONNECT_BLE");
485 if (strcasecmp(connInfo->bleOption.bleMac, itemConnInfo->bleOption.bleMac) == 0 &&
486 (connInfo->bleOption.protocol == itemConnInfo->bleOption.protocol) &&
487 connInfo->bleOption.psm == itemConnInfo->bleOption.psm) {
488 return true;
489 }
490 return false;
491 } else if (connInfo->type == CONNECT_BLE_DIRECT) {
492 TRANS_LOGI(TRANS_CTRL, "CONNECT_BLE_DIRECT");
493 if ((strcmp(connInfo->bleDirectOption.networkId, itemConnInfo->bleDirectOption.networkId) == 0) &&
494 (connInfo->bleDirectOption.protoType == itemConnInfo->bleDirectOption.protoType)) {
495 return true;
496 }
497 return false;
498 } else if (connInfo->type == CONNECT_SLE_DIRECT) {
499 TRANS_LOGI(TRANS_CTRL, "CONNECT_SLE_DIRECT");
500 if ((strcmp(connInfo->sleDirectOption.networkId, itemConnInfo->sleDirectOption.networkId) == 0) &&
501 (connInfo->sleDirectOption.protoType == itemConnInfo->sleDirectOption.protoType)) {
502 return true;
503 }
504 return false;
505 }
506 return false;
507 }
508
TransAddConnItem(ProxyConnInfo * conn)509 int32_t TransAddConnItem(ProxyConnInfo *conn)
510 {
511 if (conn == NULL) {
512 TRANS_LOGE(TRANS_CTRL, "param invalid");
513 return SOFTBUS_INVALID_PARAM;
514 }
515 ProxyConnInfo *item = NULL;
516 ProxyConnInfo *tmpItem = NULL;
517
518 if (g_proxyConnectionList == NULL) {
519 TRANS_LOGE(TRANS_CTRL, "g_proxyConnectionList is null");
520 return SOFTBUS_NO_INIT;
521 }
522
523 if (SoftBusMutexLock(&g_proxyConnectionList->lock) != SOFTBUS_OK) {
524 TRANS_LOGE(TRANS_CTRL, "lock mutex fail!");
525 return SOFTBUS_LOCK_ERR;
526 }
527
528 LIST_FOR_EACH_ENTRY_SAFE(item, tmpItem, &g_proxyConnectionList->list, ProxyConnInfo, node) {
529 if (item->isServerSide == conn->isServerSide &&
530 item->connInfo.type == conn->connInfo.type &&
531 CompareConnectOption(&item->connInfo, &conn->connInfo) == true) {
532 (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
533 return SOFTBUS_TRANS_NOT_MATCH;
534 }
535 }
536 ListAdd(&(g_proxyConnectionList->list), &(conn->node));
537 TRANS_LOGI(TRANS_CTRL, "add requestId=%{public}u", conn->requestId);
538 g_proxyConnectionList->cnt++;
539 (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
540 return SOFTBUS_OK;
541 }
542
TransConnInfoToConnOpt(ConnectionInfo * connInfo,ConnectOption * connOption)543 static void TransConnInfoToConnOpt(ConnectionInfo *connInfo, ConnectOption *connOption)
544 {
545 connOption->type = connInfo->type;
546 if (connOption->type == CONNECT_BR) {
547 TRANS_LOGI(TRANS_CTRL, "CONNECT_BR");
548 (void)memcpy_s(connOption->brOption.brMac, sizeof(char) * BT_MAC_LEN,
549 connInfo->brInfo.brMac, sizeof(char) * BT_MAC_LEN);
550 } else if (connOption->type == CONNECT_BLE) {
551 TRANS_LOGI(TRANS_CTRL, "CONNECT_BLE");
552 (void)memcpy_s(connOption->bleOption.bleMac, sizeof(char) * BT_MAC_LEN,
553 connInfo->bleInfo.bleMac, sizeof(char) * BT_MAC_LEN);
554 (void)memcpy_s(connOption->bleOption.deviceIdHash, sizeof(char) * UDID_HASH_LEN,
555 connInfo->bleInfo.deviceIdHash, sizeof(char) * UDID_HASH_LEN);
556 } else if (connOption->type == CONNECT_SLE) {
557 TRANS_LOGI(TRANS_CTRL, "CONNECT_SLE");
558 (void)memcpy_s(connOption->sleOption.address, sizeof(char) * BT_MAC_LEN,
559 connInfo->sleInfo.address, sizeof(char) * BT_MAC_LEN);
560 (void)memcpy_s(connOption->sleOption.networkId, sizeof(char) * NETWORK_ID_BUF_LEN,
561 connInfo->sleInfo.networkId, sizeof(char) * NETWORK_ID_BUF_LEN);
562 } else {
563 (void)memcpy_s(connOption->socketOption.addr, sizeof(char) * IP_LEN,
564 connInfo->socketInfo.addr, sizeof(char) * IP_LEN);
565 connOption->socketOption.protocol = connInfo->socketInfo.protocol;
566 connOption->socketOption.port = connInfo->socketInfo.port;
567 connOption->socketOption.moduleId = connInfo->socketInfo.moduleId;
568 }
569 }
570
TransCreateConnByConnId(uint32_t connId,bool isServer)571 void TransCreateConnByConnId(uint32_t connId, bool isServer)
572 {
573 ProxyConnInfo *item = NULL;
574 ProxyConnInfo *tmpNode = NULL;
575 ConnectionInfo info = {0};
576
577 if (g_proxyConnectionList == NULL) {
578 TRANS_LOGE(TRANS_CTRL, "g_proxyConnectionList is null");
579 return;
580 }
581
582 if (ConnGetConnectionInfo(connId, &info) != SOFTBUS_OK) {
583 TRANS_LOGE(TRANS_CTRL, "CreateConn get conn info fail connId=%{public}u", connId);
584 return;
585 }
586
587 if (SoftBusMutexLock(&g_proxyConnectionList->lock) != SOFTBUS_OK) {
588 TRANS_LOGE(TRANS_CTRL, "lock mutex fail!");
589 return;
590 }
591 LIST_FOR_EACH_ENTRY_SAFE(item, tmpNode, &g_proxyConnectionList->list, ProxyConnInfo, node) {
592 if (item->connId == connId && item->isServerSide == isServer) {
593 item->ref++;
594 TRANS_LOGI(TRANS_CTRL, "repeat conn proxyConnRef=%{public}d", item->ref);
595 (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
596 return;
597 }
598 }
599
600 item = (ProxyConnInfo *)SoftBusCalloc(sizeof(ProxyConnInfo));
601 if (item == NULL) {
602 TRANS_LOGE(TRANS_CTRL, "item calloc failed");
603 (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
604 return;
605 }
606 item->ref++;
607 item->state = PROXY_CHANNEL_STATUS_PYH_CONNECTED;
608 TRANS_LOGI(TRANS_CTRL, "create conn proxyConnRef=%{public}d", item->ref);
609 item->connId = connId;
610 item->isServerSide = isServer;
611 TransConnInfoToConnOpt(&info, &item->connInfo);
612 ListAdd(&(g_proxyConnectionList->list), &(item->node));
613 TRANS_LOGI(TRANS_CTRL, "add connId=%{public}u", item->connId);
614 g_proxyConnectionList->cnt++;
615 (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
616 return;
617 }
618
TransGetConn(const ConnectOption * connInfo,ProxyConnInfo * proxyConn,bool isServer)619 static int32_t TransGetConn(const ConnectOption *connInfo, ProxyConnInfo *proxyConn, bool isServer)
620 {
621 ProxyConnInfo *item = NULL;
622
623 if (g_proxyConnectionList == NULL) {
624 TRANS_LOGE(TRANS_CTRL, "proxy connection list not inited!");
625 return SOFTBUS_NO_INIT;
626 }
627
628 if (connInfo == NULL || proxyConn == NULL) {
629 TRANS_LOGE(TRANS_CTRL, "invalid para in trans get conn.");
630 return SOFTBUS_INVALID_PARAM;
631 }
632
633 if (SoftBusMutexLock(&g_proxyConnectionList->lock) != SOFTBUS_OK) {
634 TRANS_LOGE(TRANS_CTRL, "lock mutex fail!");
635 return SOFTBUS_LOCK_ERR;
636 }
637
638 LIST_FOR_EACH_ENTRY(item, &g_proxyConnectionList->list, ProxyConnInfo, node) {
639 if (item->connInfo.type != connInfo->type || item->isServerSide != isServer) {
640 continue;
641 }
642 if (CompareConnectOption(&item->connInfo, connInfo)) {
643 (void)memcpy_s(proxyConn, sizeof(ProxyConnInfo), item, sizeof(ProxyConnInfo));
644 (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
645 return SOFTBUS_OK;
646 }
647 }
648 (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
649 TRANS_LOGE(TRANS_CTRL, "can not find proxy conn in list.");
650 return SOFTBUS_TRANS_NOT_MATCH;
651 }
652
TransSetConnStateByReqId(uint32_t requestId,uint32_t connId,uint32_t state)653 static int32_t TransSetConnStateByReqId(uint32_t requestId, uint32_t connId, uint32_t state)
654 {
655 ProxyConnInfo *getNode = NULL;
656
657 if (g_proxyConnectionList == NULL) {
658 return SOFTBUS_NO_INIT;
659 }
660
661 if (SoftBusMutexLock(&g_proxyConnectionList->lock) != SOFTBUS_OK) {
662 TRANS_LOGE(TRANS_CTRL, "lock mutex fail!");
663 return SOFTBUS_LOCK_ERR;
664 }
665
666 LIST_FOR_EACH_ENTRY(getNode, &g_proxyConnectionList->list, ProxyConnInfo, node) {
667 if (getNode->requestId == requestId && getNode->state == PROXY_CHANNEL_STATUS_PYH_CONNECTING) {
668 getNode->state = state;
669 getNode->connId = connId;
670 getNode->requestId = 0;
671 (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
672 return SOFTBUS_OK;
673 }
674 }
675 (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
676 TRANS_LOGE(TRANS_CTRL,
677 "can not find proxy conn when set conn state. requestId=%{public}u, connId=%{public}u", requestId, connId);
678 (void)ConnDisconnectDevice(connId);
679 return SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND;
680 }
681
TransOnConnectSucceed(uint32_t requestId,uint32_t connectionId,const ConnectionInfo * connInfo)682 static void TransOnConnectSucceed(uint32_t requestId, uint32_t connectionId, const ConnectionInfo *connInfo)
683 {
684 SoftBusHitraceChainBegin("TransOnConnectSucceed");
685 TransEventExtra extra = {
686 .socketName = NULL,
687 .peerNetworkId = NULL,
688 .calleePkg = NULL,
689 .callerPkg = NULL,
690 .requestId = (int32_t)requestId,
691 .connectionId = (int32_t)connectionId,
692 .result = EVENT_STAGE_RESULT_OK
693 };
694 TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL, EVENT_STAGE_START_CONNECT, extra);
695 TRANS_LOGI(TRANS_CTRL,
696 "Connect Success requestId=%{public}u, connId=%{public}u", requestId, connectionId);
697 int32_t ret = TransSetConnStateByReqId(requestId, connectionId, PROXY_CHANNEL_STATUS_PYH_CONNECTED);
698 TransProxyChanProcessByReqId((int32_t)requestId, connectionId, ret);
699 SoftBusHitraceChainEnd();
700 }
701
TransOnConnectFailed(uint32_t requestId,int32_t reason)702 static void TransOnConnectFailed(uint32_t requestId, int32_t reason)
703 {
704 SoftBusHitraceChainBegin("TransOnConnectFailed");
705 TransEventExtra extra = {
706 .socketName = NULL,
707 .peerNetworkId = NULL,
708 .calleePkg = NULL,
709 .callerPkg = NULL,
710 .requestId = requestId,
711 .errcode = reason,
712 .result = EVENT_STAGE_RESULT_FAILED
713 };
714 TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL, EVENT_STAGE_START_CONNECT, extra);
715 TRANS_LOGE(TRANS_CTRL, "Connect fail requestId=%{public}u, reason=%{public}d", requestId, reason);
716 if (TransDelConnByReqId(requestId) != SOFTBUS_OK) {
717 TRANS_LOGE(TRANS_CTRL, "Connect fail del fail. requestId=%{public}u", requestId);
718 }
719 TransProxyDelChanByReqId((int32_t)requestId, reason);
720 SoftBusHitraceChainEnd();
721 }
722
TransProxyCloseConnChannel(uint32_t connectionId,bool isServer)723 int32_t TransProxyCloseConnChannel(uint32_t connectionId, bool isServer)
724 {
725 if (TransDecConnRefByConnId(connectionId, isServer) == SOFTBUS_OK) {
726 TRANS_LOGI(TRANS_CTRL, "disconnect device connId=%{public}d", connectionId);
727 // BR don't disconnect
728 (void)ConnDisconnectDevice(connectionId);
729 }
730 return SOFTBUS_OK;
731 }
732
TransProxyCloseConnChannelReset(uint32_t connectionId,bool isDisconnect,bool isServer,bool deviceType)733 int32_t TransProxyCloseConnChannelReset(uint32_t connectionId, bool isDisconnect, bool isServer, bool deviceType)
734 {
735 if (TransDecConnRefByConnId(connectionId, isServer) == SOFTBUS_OK) {
736 TRANS_LOGI(TRANS_CTRL, "reset dis device. isDisconnect=%{public}d, connId=%{public}u, deviceType=%{public}d",
737 isDisconnect, connectionId, deviceType);
738 // only client side can disconnect connection
739 if (isDisconnect && deviceType != true) {
740 (void)ConnDisconnectDevice(connectionId);
741 }
742 }
743 return SOFTBUS_OK;
744 }
745
TransProxyConnExistProc(bool isServer,int32_t chanNewId,const ConnectOption * connInfo)746 static int32_t TransProxyConnExistProc(bool isServer, int32_t chanNewId, const ConnectOption *connInfo)
747 {
748 SoftbusHitraceStart(SOFTBUS_HITRACE_ID_VALID, (uint64_t)(chanNewId + ID_OFFSET));
749 TRANS_LOGI(TRANS_CTRL,
750 "SoftBusHiTraceChainBegin: set hiTraceId=%{public}" PRIu64, (uint64_t)(chanNewId + ID_OFFSET));
751 int32_t ret = GetProxyChannelLock();
752 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_CTRL, "lock mutex fail!");
753 ProxyConnInfo conn;
754 if (TransGetConn(connInfo, &conn, false) != SOFTBUS_OK) {
755 ReleaseProxyChannelLock();
756 TRANS_LOGE(TRANS_CTRL, "get connectInfo failed, channelId=%{public}d", chanNewId);
757 return SOFTBUS_TRANS_PROXY_CONN_ADD_REF_FAILED;
758 }
759 ConnectType type = conn.connInfo.type;
760 if (conn.state == PROXY_CHANNEL_STATUS_PYH_CONNECTING) {
761 ProxyChannelInfo channelInfo = {
762 .channelId = chanNewId,
763 .reqId = (int32_t)conn.requestId,
764 .isServer = -1,
765 .type = type,
766 .status = PROXY_CHANNEL_STATUS_PYH_CONNECTING,
767 .connId = 0
768 };
769
770 TransProxySpecialUpdateChanInfo(&channelInfo);
771 ReleaseProxyChannelLock();
772 TRANS_LOGI(TRANS_CTRL, "reuse connection requestId=%{public}d", channelInfo.reqId);
773 } else {
774 ReleaseProxyChannelLock();
775 ProxyChannelInfo channelInfo = {
776 .channelId = chanNewId,
777 .reqId = -1,
778 .isServer = -1,
779 .type = type,
780 .status = PROXY_CHANNEL_STATUS_HANDSHAKEING,
781 .connId = conn.connId
782 };
783 if (TransAddConnRefByConnId(conn.connId, isServer) != SOFTBUS_OK) {
784 TRANS_LOGE(TRANS_CTRL, "TransAddConnRefByConnId: connId=%{public}u err", conn.connId);
785 return SOFTBUS_TRANS_PROXY_CONN_ADD_REF_FAILED;
786 }
787 TransProxySpecialUpdateChanInfo(&channelInfo);
788 TransProxyPostHandshakeMsgToLoop(chanNewId);
789 }
790 return SOFTBUS_OK;
791 }
792
TransProxyConnectDevice(const ConnectOption * connInfo,uint32_t requestId)793 static int32_t TransProxyConnectDevice(const ConnectOption *connInfo, uint32_t requestId)
794 {
795 ConnectResult result;
796 result.OnConnectFailed = TransOnConnectFailed;
797 result.OnConnectSuccessed = TransOnConnectSucceed;
798 if (connInfo->type == CONNECT_BLE_DIRECT || connInfo->type == CONNECT_SLE_DIRECT) {
799 return ConnDirectConnectDevicePacked(connInfo, requestId, &result);
800 } else {
801 return ConnConnectDevice(connInfo, requestId, &result);
802 }
803 }
804
TransProxyOpenNewConnChannel(ListenerModule moduleId,const ConnectOption * connInfo,int32_t channelId)805 static int32_t TransProxyOpenNewConnChannel(ListenerModule moduleId, const ConnectOption *connInfo, int32_t channelId)
806 {
807 SoftbusHitraceStart(SOFTBUS_HITRACE_ID_VALID, (uint64_t)(channelId + ID_OFFSET));
808 TRANS_LOGI(TRANS_CTRL,
809 "SoftBusHiTraceChainBegin: set hiTraceId=%{public}" PRIu64, (uint64_t)(channelId + ID_OFFSET));
810 uint32_t requestId = ConnGetNewRequestId(MODULE_PROXY_CHANNEL);
811 ProxyChannelInfo channelInfo = {
812 .channelId = channelId,
813 .reqId = (int32_t)requestId,
814 .isServer = 0,
815 .type = CONNECT_TYPE_MAX,
816 .status = PROXY_CHANNEL_STATUS_PYH_CONNECTING,
817 .connId = 0
818 };
819 TransProxySpecialUpdateChanInfo(&channelInfo);
820
821 ProxyConnInfo *connChan = (ProxyConnInfo *)SoftBusCalloc(sizeof(ProxyConnInfo));
822 if (connChan == NULL) {
823 TRANS_LOGE(TRANS_CTRL, "connChan calloc failed");
824 TransProxyDelChanByChanId(channelId);
825 return SOFTBUS_MALLOC_ERR;
826 }
827 connChan->requestId = requestId;
828 connChan->state = PROXY_CHANNEL_STATUS_PYH_CONNECTING;
829 connChan->ref = 0;
830 connChan->isServerSide = false;
831
832 TRANS_LOGI(TRANS_CTRL, "Connect dev, channelId=%{public}d, requestId=%{public}u", channelId, requestId);
833 connChan->connInfo = (*connInfo);
834 if (connInfo->type == CONNECT_TCP) {
835 connChan->connInfo.socketOption.moduleId = moduleId;
836 }
837 if (TransAddConnItem(connChan) != SOFTBUS_OK) {
838 TRANS_LOGE(TRANS_CTRL, "conn add repeat");
839 SoftBusFree(connChan);
840 return SOFTBUS_TRANS_PROXY_CONN_REPEAT;
841 }
842 int32_t ret = TransProxyConnectDevice(&connChan->connInfo, requestId);
843 if (ret != SOFTBUS_OK) {
844 TRANS_LOGE(TRANS_CTRL, "connect device err");
845 TransDelConnByReqId(requestId);
846 TransProxyDelChanByChanId(channelId);
847 }
848 return ret;
849 }
850
TransReportStartConnectEvent(const AppInfo * appInfo,const ConnectOption * connInfo,int32_t channelId)851 static void TransReportStartConnectEvent(const AppInfo *appInfo, const ConnectOption *connInfo, int32_t channelId)
852 {
853 ProxyChannelInfo *channelInfo = (ProxyChannelInfo *)SoftBusCalloc(sizeof(ProxyChannelInfo));
854 TRANS_CHECK_AND_RETURN_LOGE(channelInfo != NULL, TRANS_CTRL, "malloc proxyChannelInfo failed");
855 if (TransProxyGetChanByChanId(channelId, channelInfo) != SOFTBUS_OK) {
856 SoftBusFree(channelInfo);
857 TRANS_LOGE(TRANS_CTRL, "TransProxyGetChanByChanId failed, channelId=%{public}d", channelId);
858 return;
859 }
860 TransEventExtra extra = {
861 .peerNetworkId = NULL,
862 .calleePkg = NULL,
863 .callerPkg = NULL,
864 .socketName = appInfo->myData.sessionName,
865 .channelType = appInfo->appType == APP_TYPE_AUTH ? CHANNEL_TYPE_AUTH : CHANNEL_TYPE_PROXY,
866 .channelId = channelId,
867 .requestId = channelInfo->reqId,
868 .linkType = connInfo->type
869 };
870 TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL, EVENT_STAGE_START_CONNECT, extra);
871 SoftBusFree(channelInfo);
872 }
873
TransProxyOpenConnChannel(const AppInfo * appInfo,const ConnectOption * connInfo,int32_t * channelId)874 int32_t TransProxyOpenConnChannel(const AppInfo *appInfo, const ConnectOption *connInfo, int32_t *channelId)
875 {
876 if (appInfo == NULL || connInfo == NULL) {
877 TRANS_LOGE(TRANS_CTRL, "invalid param");
878 return SOFTBUS_INVALID_PARAM;
879 }
880 int32_t ret;
881 ProxyConnInfo conn;
882 int32_t chanNewId = INVALID_CHANNEL_ID;
883 if (*channelId != INVALID_CHANNEL_ID) {
884 chanNewId = *channelId;
885 } else {
886 chanNewId = GenerateChannelId(false);
887 }
888 if (chanNewId <= INVALID_CHANNEL_ID) {
889 TRANS_LOGE(TRANS_CTRL, "proxy channelId is invalid");
890 return SOFTBUS_TRANS_INVALID_CHANNEL_ID;
891 }
892 ProxyChannelInfo *chan = (ProxyChannelInfo *)SoftBusCalloc(sizeof(ProxyChannelInfo));
893 if (chan == NULL) {
894 ReleaseProxyChannelId(chanNewId);
895 TRANS_LOGE(TRANS_CTRL, "SoftBusCalloc fail");
896 return SOFTBUS_MALLOC_ERR;
897 }
898 chan->type = connInfo->type;
899 if (TransProxyCreateChanInfo(chan, chanNewId, appInfo) != SOFTBUS_OK) {
900 TRANS_LOGE(TRANS_CTRL, "TransProxyCreateChanInfo err");
901 ReleaseProxyChannelId(chanNewId);
902 (void)memset_s(chan->appInfo.sessionKey, sizeof(chan->appInfo.sessionKey), 0, sizeof(chan->appInfo.sessionKey));
903 SoftBusFree(chan);
904 return SOFTBUS_TRANS_PROXY_CREATE_CHANNEL_FAILED;
905 }
906 if (TransGetConn(connInfo, &conn, false) == SOFTBUS_OK) {
907 ret = TransProxyConnExistProc(false, chanNewId, connInfo);
908 if (ret == SOFTBUS_TRANS_PROXY_CONN_ADD_REF_FAILED) {
909 ret = TransProxyOpenNewConnChannel(PROXY, connInfo, chanNewId);
910 }
911 } else {
912 ret = TransProxyOpenNewConnChannel(PROXY, connInfo, chanNewId);
913 if ((ret == SOFTBUS_TRANS_PROXY_CONN_REPEAT) && (TransGetConn(connInfo, &conn, false) == SOFTBUS_OK)) {
914 ret = TransProxyConnExistProc(false, chanNewId, connInfo);
915 }
916 }
917 if (ret == SOFTBUS_OK) {
918 *channelId = chanNewId;
919 } else if (ret == SOFTBUS_TRANS_PROXY_CONN_ADD_REF_FAILED || ret == SOFTBUS_TRANS_PROXY_CONN_REPEAT) {
920 TransProxyDelChanByChanId(chanNewId);
921 }
922 TransReportStartConnectEvent(appInfo, connInfo, chanNewId);
923 return ret;
924 }
925
TransProxySendBadKeyMessage(ProxyMessage * msg,const AuthHandle * authHandle)926 static int32_t TransProxySendBadKeyMessage(ProxyMessage *msg, const AuthHandle *authHandle)
927 {
928 ProxyDataInfo dataInfo;
929 dataInfo.inData = (uint8_t *)msg->data;
930 dataInfo.inLen = (uint32_t)msg->dataLen;
931 dataInfo.outData = NULL;
932 dataInfo.outLen = 0;
933
934 msg->msgHead.type = (PROXYCHANNEL_MSG_TYPE_RESET & FOUR_BIT_MASK) | (VERSION << VERSION_SHIFT);
935 if (AuthCheckSessionKeyValidByAuthHandle(authHandle) == SOFTBUS_AUTH_SESSION_KEY_INVALID) {
936 TRANS_LOGE(TRANS_MSG, "ble single online, send renegotiate msg");
937 msg->msgHead.cipher |= AUTH_SINGLE_CIPHER;
938 } else {
939 msg->msgHead.cipher |= BAD_CIPHER;
940 }
941 TRANS_LOGW(TRANS_MSG, "send msg is bad key myChannelId=%{public}d, peerChannelId=%{public}d",
942 msg->msgHead.myId, msg->msgHead.peerId);
943
944 int32_t ret = PackPlaintextMessage(&msg->msgHead, &dataInfo);
945 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_MSG, "PackPlaintextMessage fail");
946
947 ret = TransProxyTransSendMsg(msg->connId, dataInfo.outData, dataInfo.outLen, CONN_HIGH, 0);
948 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_MSG, "send bad key buf fail");
949
950 return SOFTBUS_OK;
951 }
952
TransProxyOnDataReceived(uint32_t connectionId,ConnModule moduleId,int64_t seq,char * data,int32_t len)953 static void TransProxyOnDataReceived(uint32_t connectionId, ConnModule moduleId, int64_t seq, char *data, int32_t len)
954 {
955 TRANS_LOGI(TRANS_CTRL, "recv data connId=%{public}u, moduleId=%{public}d, seq=%{public}" PRId64 ", len=%{public}d",
956 connectionId, moduleId, seq, len);
957 TRANS_CHECK_AND_RETURN_LOGE(data != NULL && moduleId == MODULE_PROXY_CHANNEL, TRANS_CTRL, "invalid param");
958
959 int32_t ret = SOFTBUS_TRANS_INVALID_MESSAGE_TYPE;
960 ProxyMessage msg;
961 (void)memset_s(&msg, sizeof(ProxyMessage), 0, sizeof(ProxyMessage));
962 msg.connId = connectionId;
963 ret = TransParseMessageHeadType(data, len, &msg);
964 if (ret != SOFTBUS_OK) {
965 TRANS_LOGE(TRANS_CTRL, "invalid msg head");
966 return;
967 }
968 TRANS_LOGI(TRANS_CTRL, "recv data msgType=%{public}d", msg.msgHead.type);
969 if (msg.msgHead.type == PROXYCHANNEL_MSG_TYPE_D2D) {
970 TransProxyParseD2DData(data, len);
971 return;
972 }
973 if (msg.msgHead.type >= PROXYCHANNEL_MSG_TYPE_PAGING_HANDSHAKE) {
974 ret = TransPagingParseMessage(data, len, &msg);
975 if (ret != SOFTBUS_OK) {
976 TRANS_LOGE(TRANS_CTRL, "parse paging data failed.");
977 }
978 return;
979 }
980 AuthHandle authHandle = { .authId = AUTH_INVALID_ID };
981 ret = TransProxyParseMessage((char *)data, len, &msg, &authHandle);
982 if (((ret == SOFTBUS_AUTH_NOT_FOUND) || (ret == SOFTBUS_DECRYPT_ERR)) &&
983 (msg.msgHead.type == PROXYCHANNEL_MSG_TYPE_HANDSHAKE)) {
984 TransReportBadKeyEvent(ret, connectionId, seq, len);
985 if (TransProxySendBadKeyMessage(&msg, &authHandle) != SOFTBUS_OK) {
986 TRANS_LOGE(TRANS_CTRL, "send bad key msg ret=%{public}d", ret);
987 return;
988 }
989 char peerBrMac[BT_MAC_LEN] = { 0 };
990 char udid[UDID_BUF_LEN] = { 0 };
991 if (GetBrMacFromConnInfo(connectionId, peerBrMac, BT_MAC_LEN) == SOFTBUS_OK) {
992 if (LnnGetUdidByBrMacPacked(peerBrMac, udid, UDID_BUF_LEN) == SOFTBUS_OK) {
993 AuthRemoveDeviceKeyByUdidPacked(udid);
994 }
995 }
996 }
997 if (ret != SOFTBUS_OK) {
998 TRANS_LOGE(TRANS_CTRL, "parse proxy msg ret=%{public}d", ret);
999 return;
1000 }
1001 TransProxyOnMessageReceived(&msg);
1002 SoftBusFree(msg.data);
1003 }
1004
TransProxyTransInit(void)1005 int32_t TransProxyTransInit(void)
1006 {
1007 ConnectCallback proxyCallback = { 0 };
1008
1009 proxyCallback.OnConnected = TransProxyOnConnected;
1010 proxyCallback.OnDisconnected = TransProxyOnDisConnect;
1011 proxyCallback.OnDataReceived = TransProxyOnDataReceived;
1012 int32_t ret = ConnSetConnectCallback(MODULE_PROXY_CHANNEL, &proxyCallback);
1013 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_INIT, "ConnSetConnectCallback fail");
1014
1015 g_proxyConnectionList = CreateSoftBusList();
1016 if (g_proxyConnectionList == NULL) {
1017 TRANS_LOGE(TRANS_INIT, "create observer list failed");
1018 return SOFTBUS_MALLOC_ERR;
1019 }
1020 g_proxyPagingWaitList = CreateSoftBusList();
1021 if (g_proxyPagingWaitList == NULL) {
1022 TRANS_LOGE(TRANS_INIT, "create paging handshake list failed");
1023 return SOFTBUS_MALLOC_ERR;
1024 }
1025
1026 ret = TransProxyLoopInit();
1027 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_INIT, "create loopInit fail");
1028
1029 ret = TransProxyPipelineInit();
1030 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_INIT, "init proxy pipeline failed");
1031
1032 return SOFTBUS_OK;
1033 }
1034
TransProxyGetConnInfoByConnId(uint32_t connId,ConnectOption * connInfo)1035 int32_t TransProxyGetConnInfoByConnId(uint32_t connId, ConnectOption *connInfo)
1036 {
1037 if (connInfo == NULL) {
1038 TRANS_LOGW(TRANS_CTRL, "invalid param.");
1039 return SOFTBUS_INVALID_PARAM;
1040 }
1041
1042 if (g_proxyConnectionList == NULL) {
1043 TRANS_LOGE(TRANS_CTRL, "proxy connect list empty.");
1044 return SOFTBUS_NO_INIT;
1045 }
1046
1047 if (SoftBusMutexLock(&g_proxyConnectionList->lock) != SOFTBUS_OK) {
1048 TRANS_LOGE(TRANS_CTRL, "lock mutex fail.");
1049 return SOFTBUS_LOCK_ERR;
1050 }
1051
1052 ProxyConnInfo *item = NULL;
1053 LIST_FOR_EACH_ENTRY(item, &g_proxyConnectionList->list, ProxyConnInfo, node) {
1054 if (item->connId == connId) {
1055 if (memcpy_s(connInfo, sizeof(ConnectOption), &(item->connInfo), sizeof(ConnectOption)) != EOK) {
1056 TRANS_LOGE(TRANS_CTRL, "memcpy_s connInfo failed. connId=%{public}u", connId);
1057 (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
1058 return SOFTBUS_MEM_ERR;
1059 }
1060 (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
1061 return SOFTBUS_OK;
1062 }
1063 }
1064 (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
1065 TRANS_LOGE(TRANS_INIT, "proxy conn node not found. connId=%{public}u", connId);
1066 return SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND;
1067 }
1068
CheckIsProxyAuthChannel(ConnectOption * connInfo)1069 int32_t CheckIsProxyAuthChannel(ConnectOption *connInfo)
1070 {
1071 if (connInfo == NULL) {
1072 TRANS_LOGW(TRANS_CTRL, "invalid param.");
1073 return SOFTBUS_INVALID_PARAM;
1074 }
1075
1076 if (g_proxyConnectionList == NULL) {
1077 TRANS_LOGE(TRANS_CTRL, "proxy connect list empty.");
1078 return SOFTBUS_NO_INIT;
1079 }
1080
1081 if (SoftBusMutexLock(&g_proxyConnectionList->lock) != SOFTBUS_OK) {
1082 TRANS_LOGE(TRANS_CTRL, "lock mutex fail.");
1083 return SOFTBUS_LOCK_ERR;
1084 }
1085
1086 ProxyConnInfo *item = NULL;
1087 LIST_FOR_EACH_ENTRY(item, &g_proxyConnectionList->list, ProxyConnInfo, node) {
1088 if (memcmp(item->connInfo.bleOption.bleMac, connInfo->bleOption.bleMac,
1089 sizeof(connInfo->bleOption.bleMac)) == 0 ||
1090 memcmp(item->connInfo.bleOption.deviceIdHash, connInfo->bleOption.deviceIdHash,
1091 SHORT_UDID_HASH_LEN) == 0) {
1092 TRANS_LOGI(TRANS_CTRL, "auth channel type is ble");
1093 (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
1094 return SOFTBUS_OK;
1095 } else if (memcmp(item->connInfo.brOption.brMac, connInfo->brOption.brMac,
1096 sizeof(connInfo->brOption.brMac)) == 0) {
1097 TRANS_LOGI(TRANS_CTRL, "auth channel type is br");
1098 (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
1099 return SOFTBUS_OK;
1100 } else if (memcmp(item->connInfo.sleOption.address, connInfo->sleOption.address,
1101 sizeof(connInfo->sleOption.address)) == 0) {
1102 TRANS_LOGI(TRANS_CTRL, "auth channel type is sle");
1103 (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
1104 return SOFTBUS_OK;
1105 }
1106 }
1107 (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
1108 TRANS_LOGE(TRANS_INIT, "proxy conn node not found.");
1109 return SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND;
1110 }
1111
TransProxyUdpateNewPeerUdidHash(const char * deviceId,ConnectOption * connOpt)1112 static int32_t TransProxyUdpateNewPeerUdidHash(const char *deviceId, ConnectOption *connOpt)
1113 {
1114 uint8_t udidHash[UDID_HASH_LEN] = { 0 };
1115 int32_t ret = SoftBusGenerateStrHash((const unsigned char *)deviceId, strlen(deviceId), udidHash);
1116 if (ret != SOFTBUS_OK) {
1117 TRANS_LOGE(TRANS_CTRL, "Generate UDID HexStringHash fail, ret=%{public}d", ret);
1118 return ret;
1119 }
1120 if (memcpy_s(connOpt->bleOption.deviceIdHash, UDID_HASH_LEN, udidHash, UDID_HASH_LEN) != EOK) {
1121 TRANS_LOGE(TRANS_CTRL, "memcpy_s udid hash err");
1122 return SOFTBUS_MEM_ERR;
1123 }
1124 return SOFTBUS_OK;
1125 }
1126
TransProxyGetConnOptionByChanId(int32_t channelId,ConnectOption * connOpt)1127 int32_t TransProxyGetConnOptionByChanId(int32_t channelId, ConnectOption *connOpt)
1128 {
1129 TRANS_CHECK_AND_RETURN_RET_LOGE(connOpt != NULL, SOFTBUS_INVALID_PARAM, TRANS_CTRL, "invalid param");
1130 ProxyChannelInfo chan;
1131 (void)memset_s(&chan, sizeof(ProxyChannelInfo), 0, sizeof(ProxyChannelInfo));
1132 int32_t ret = TransProxyGetProxyChannelInfoByChannelId(channelId, &chan);
1133 if (ret != SOFTBUS_OK) {
1134 TRANS_LOGE(TRANS_CTRL, "get proxy channel info fail, channelId=%{public}d, ret=%{public}d", channelId, ret);
1135 return ret;
1136 }
1137
1138 ret = TransProxyGetConnInfoByConnId(chan.connId, connOpt);
1139 if (ret != SOFTBUS_OK) {
1140 TRANS_LOGE(TRANS_CTRL, "get conn optinfo fail, channelId=%{public}d, connId=%{public}d, ret=%{public}d",
1141 chan.channelId, chan.connId, ret);
1142 return ret;
1143 }
1144
1145 ret = TransProxyUdpateNewPeerUdidHash(chan.appInfo.peerData.deviceId, connOpt);
1146 if (ret != SOFTBUS_OK) {
1147 TRANS_LOGE(TRANS_CTRL, "get new peer udid hash fail, channelId=%{public}d, connId=%{public}d, ret=%{public}d",
1148 chan.channelId, chan.connId, ret);
1149 return ret;
1150 }
1151
1152 char udidHashStr[HEXIFY_LEN(SHORT_UDID_HASH_LEN)] = { 0 };
1153 ret = ConvertBytesToHexString(udidHashStr, HEXIFY_LEN(SHORT_UDID_HASH_LEN),
1154 (unsigned char *)connOpt->bleOption.deviceIdHash, SHORT_UDID_HASH_LEN);
1155 if (ret != SOFTBUS_OK) {
1156 TRANS_LOGE(
1157 TRANS_CTRL, "convert udid hash to string fail, channelId=%{public}d, connId=%{public}d, ret=%{public}d",
1158 chan.channelId, chan.connId, ret);
1159 return ret;
1160 }
1161
1162 char *udidHash = NULL;
1163 Anonymize(udidHashStr, &udidHash);
1164 TRANS_LOGI(TRANS_CTRL, "channelId=%{public}d, connId=%{public}d, udidHash=%{public}s",
1165 chan.channelId, chan.connId, AnonymizeWrapper(udidHash));
1166 AnonymizeFree(udidHash);
1167 return SOFTBUS_OK;
1168 }
1169
TransProxyNegoSessionKeyFail(int32_t channelId,int32_t errCode)1170 void TransProxyNegoSessionKeyFail(int32_t channelId, int32_t errCode)
1171 {
1172 ProxyChannelInfo *channelInfo = (ProxyChannelInfo *)SoftBusCalloc(sizeof(ProxyChannelInfo));
1173 TRANS_CHECK_AND_RETURN_LOGE(channelInfo != NULL, TRANS_CTRL, "malloc proxyChannelInfo failed");
1174
1175 if (TransProxyGetChanByChanId(channelId, channelInfo) != SOFTBUS_OK) {
1176 SoftBusFree(channelInfo);
1177 TRANS_LOGE(TRANS_CTRL, "disconnect device channelId=%{public}d", channelId);
1178 return;
1179 }
1180
1181 (void)TransProxyCloseConnChannel(channelInfo->connId, channelInfo->isServer);
1182 (void)OnProxyChannelOpenFailed(channelId, &(channelInfo->appInfo), errCode);
1183 (void)memset_s(channelInfo->appInfo.sessionKey, sizeof(channelInfo->appInfo.sessionKey), 0,
1184 sizeof(channelInfo->appInfo.sessionKey));
1185 SoftBusFree(channelInfo);
1186 TransProxyDelChanByChanId(channelId);
1187 }
1188
TransProxyNegoSessionKeySucc(int32_t channelId)1189 void TransProxyNegoSessionKeySucc(int32_t channelId)
1190 {
1191 ProxyChannelInfo *channelInfo = (ProxyChannelInfo *)SoftBusCalloc(sizeof(ProxyChannelInfo));
1192 TRANS_CHECK_AND_RETURN_LOGE(channelInfo != NULL, TRANS_CTRL, "malloc proxyChannelInfo failed");
1193
1194 if (TransProxyGetChanByChanId(channelId, channelInfo) != SOFTBUS_OK) {
1195 SoftBusFree(channelInfo);
1196 TRANS_LOGE(TRANS_CTRL, "disconnect device channelId=%{public}d", channelId);
1197 return;
1198 }
1199 channelInfo->appInfo.connectedStart = GetSoftbusRecordTimeMillis();
1200 int32_t ret = TransProxyHandshake(channelInfo);
1201 if (ret != SOFTBUS_OK) {
1202 TransEventExtra extra = {
1203 .socketName = NULL,
1204 .peerNetworkId = NULL,
1205 .calleePkg = NULL,
1206 .callerPkg = NULL,
1207 .channelId = channelId,
1208 .connectionId = channelInfo->connId,
1209 .errcode = ret,
1210 .result = EVENT_STAGE_RESULT_FAILED
1211 };
1212 TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL, EVENT_STAGE_HANDSHAKE_START, extra);
1213 (void)TransProxyCloseConnChannel(channelInfo->connId, channelInfo->isServer);
1214 TRANS_LOGE(TRANS_CTRL, "channelId=%{public}d handshake err, ret=%{public}d", channelId, ret);
1215 TransProxyOpenProxyChannelFail(channelInfo->channelId, &(channelInfo->appInfo), ret);
1216 TransProxyDelChanByChanId(channelId);
1217 }
1218 (void)memset_s(channelInfo->appInfo.sessionKey, sizeof(channelInfo->appInfo.sessionKey), 0,
1219 sizeof(channelInfo->appInfo.sessionKey));
1220 SoftBusFree(channelInfo);
1221 }
1222
TransPagingLoadSaFail(const uint32_t businessFlag)1223 int32_t TransPagingLoadSaFail(const uint32_t businessFlag)
1224 {
1225 if (SoftBusMutexLock(&g_proxyPagingWaitList->lock) != SOFTBUS_OK) {
1226 TRANS_LOGE(TRANS_CTRL, "lock mutex fail!");
1227 return SOFTBUS_LOCK_ERR;
1228 }
1229 ProxyPagingWaitInfo *item = NULL;
1230 LIST_FOR_EACH_ENTRY(item, &g_proxyPagingWaitList->list, ProxyPagingWaitInfo, node) {
1231 if (item->businessFlag == businessFlag) {
1232 item->isLoadFailed = true;
1233 (void)SoftBusMutexUnlock(&g_proxyPagingWaitList->lock);
1234 return SOFTBUS_OK;
1235 }
1236 }
1237 TRANS_LOGE(TRANS_CTRL, "not found wait listen, businessFlag=%{public}u", businessFlag);
1238 (void)SoftBusMutexUnlock(&g_proxyPagingWaitList->lock);
1239 return SOFTBUS_TRANS_PAGING_WAIT_LISTEN_NOT_FOUND;
1240 }
1241
TransPagingWaitListenStatus(const uint32_t businessFlag,PagingWaitListenStatus status)1242 int32_t TransPagingWaitListenStatus(const uint32_t businessFlag, PagingWaitListenStatus status)
1243 {
1244 if (status < PAGING_WAIT_LISTEN_DONE || status > PAGING_WAIT_LISTEN_LOAD_SA_FAIL) {
1245 TRANS_LOGE(TRANS_CTRL, "invalid param! status=%{public}d", status);
1246 return SOFTBUS_INVALID_PARAM;
1247 }
1248 if (SoftBusMutexLock(&g_proxyPagingWaitList->lock) != SOFTBUS_OK) {
1249 TRANS_LOGE(TRANS_CTRL, "lock mutex fail!");
1250 return SOFTBUS_LOCK_ERR;
1251 }
1252 ProxyPagingWaitInfo *item = NULL;
1253 LIST_FOR_EACH_ENTRY(item, &g_proxyPagingWaitList->list, ProxyPagingWaitInfo, node) {
1254 if (item->businessFlag == businessFlag) {
1255 switch (status) {
1256 case PAGING_WAIT_LISTEN_DONE:
1257 item->isListened = true;
1258 break;
1259 case PAGING_WAIT_LISTEN_LOAD_SA_FAIL:
1260 item->isLoadFailed = true;
1261 break;
1262 default:
1263 TRANS_LOGE(TRANS_CTRL, "unknown status=%{public}d", status);
1264 break;
1265 }
1266 (void)SoftBusMutexUnlock(&g_proxyPagingWaitList->lock);
1267 return SOFTBUS_OK;
1268 }
1269 }
1270 TRANS_LOGE(TRANS_CTRL, "not found wait listen, businessFlag=%{public}u", businessFlag);
1271 (void)SoftBusMutexUnlock(&g_proxyPagingWaitList->lock);
1272 return SOFTBUS_TRANS_PAGING_WAIT_LISTEN_NOT_FOUND;
1273 }
1274
AddWaitListInfo(const uint32_t businessFlag)1275 static int32_t AddWaitListInfo(const uint32_t businessFlag)
1276 {
1277 ProxyPagingWaitInfo *info = (ProxyPagingWaitInfo *)SoftBusCalloc(sizeof(ProxyPagingWaitInfo));
1278 if (info == NULL) {
1279 TRANS_LOGE(TRANS_CTRL, "calloc ProxyPagingWaitInfo fail");
1280 return SOFTBUS_MALLOC_ERR;
1281 }
1282 info->businessFlag = businessFlag;
1283 info->isListened = false;
1284 info->isLoadFailed = false;
1285 info->retryTime = WAIT_LISTEN_CHECK_NUM;
1286 if (SoftBusMutexLock(&g_proxyPagingWaitList->lock) != SOFTBUS_OK) {
1287 TRANS_LOGE(TRANS_CTRL, "lock mutex fail!");
1288 SoftBusFree(info);
1289 return SOFTBUS_LOCK_ERR;
1290 }
1291 ListAdd(&(g_proxyPagingWaitList->list), &(info->node));
1292 TRANS_LOGE(TRANS_CTRL, "add wait listen success, businessFlag=%{public}u", businessFlag);
1293 (void)SoftBusMutexUnlock(&g_proxyPagingWaitList->lock);
1294 return SOFTBUS_OK;
1295 }
1296
DelWaitListenByFlag(uint32_t businessFlag)1297 static int32_t DelWaitListenByFlag(uint32_t businessFlag)
1298 {
1299 if (SoftBusMutexLock(&g_proxyPagingWaitList->lock) != SOFTBUS_OK) {
1300 TRANS_LOGE(TRANS_CTRL, "lock mutex fail!");
1301 return SOFTBUS_LOCK_ERR;
1302 }
1303 ProxyPagingWaitInfo *item = NULL;
1304 LIST_FOR_EACH_ENTRY(item, &g_proxyPagingWaitList->list, ProxyPagingWaitInfo, node) {
1305 if (item->businessFlag == businessFlag) {
1306 ListDelete(&item->node);
1307 SoftBusFree(item);
1308 (void)SoftBusMutexUnlock(&g_proxyPagingWaitList->lock);
1309 return SOFTBUS_OK;
1310 }
1311 }
1312 TRANS_LOGE(TRANS_CTRL, "not found wait listen, businessFlag=%{public}u", businessFlag);
1313 (void)SoftBusMutexUnlock(&g_proxyPagingWaitList->lock);
1314 return SOFTBUS_TRANS_PAGING_WAIT_LISTEN_NOT_FOUND;
1315 }
1316
CheckListenResult(uint32_t businessFlag)1317 static CheckResultType CheckListenResult(uint32_t businessFlag)
1318 {
1319 if (SoftBusMutexLock(&g_proxyPagingWaitList->lock) != SOFTBUS_OK) {
1320 TRANS_LOGE(TRANS_CTRL, "lock mutex fail!");
1321 return WAIT_LISTEN_CHECK_INVALID;
1322 }
1323 ProxyPagingWaitInfo *item = NULL;
1324 LIST_FOR_EACH_ENTRY(item, &g_proxyPagingWaitList->list, ProxyPagingWaitInfo, node) {
1325 if (item->businessFlag == businessFlag) {
1326 if (item->isListened) {
1327 (void)SoftBusMutexUnlock(&g_proxyPagingWaitList->lock);
1328 return WAIT_LISTEN_CHECK_SUCCESS;
1329 }
1330 if (item->isLoadFailed) {
1331 (void)SoftBusMutexUnlock(&g_proxyPagingWaitList->lock);
1332 return WAIT_LISTEN_CHECK_LOAD_FAIL;
1333 }
1334 if (item->retryTime > 0) {
1335 item->retryTime--;
1336 (void)SoftBusMutexUnlock(&g_proxyPagingWaitList->lock);
1337 return WAIT_LISTEN_CHECK_RETRY;
1338 }
1339 if (item->retryTime <= 0) {
1340 (void)SoftBusMutexUnlock(&g_proxyPagingWaitList->lock);
1341 return WAIT_LISTEN_CHECK_TIMEOUT;
1342 }
1343 }
1344 }
1345 (void)SoftBusMutexUnlock(&g_proxyPagingWaitList->lock);
1346 return WAIT_LISTEN_CHECK_INVALID;
1347 }
1348
CheckPagingListen(void * para)1349 static void CheckPagingListen(void *para)
1350 {
1351 uint32_t *businessFlag = (uint32_t *)para;
1352 if (businessFlag == NULL) {
1353 TRANS_LOGE(TRANS_CTRL, "para invalid");
1354 return;
1355 }
1356 CheckResultType ret = CheckListenResult(*businessFlag);
1357 if (ret == WAIT_LISTEN_CHECK_RETRY) {
1358 if (LnnAsyncCallbackDelayHelper(GetLooper(LOOP_TYPE_DEFAULT), CheckPagingListen, (void *)businessFlag,
1359 WAIT_LISTEN_CHECK_DELAY) != SOFTBUS_OK) {
1360 TRANS_LOGE(TRANS_CTRL, "lnn async fail.");
1361 TransWaitListenResult(*businessFlag, SOFTBUS_TRANS_PAGING_ASYNC_FAIL);
1362 goto EXIT_ERR;
1363 }
1364 return;
1365 }
1366 if (ret == WAIT_LISTEN_CHECK_SUCCESS) {
1367 TransWaitListenResult(*businessFlag, SOFTBUS_OK);
1368 goto EXIT_ERR;
1369 }
1370 if (ret == WAIT_LISTEN_CHECK_LOAD_FAIL) {
1371 TransWaitListenResult(*businessFlag, SOFTBUS_TRANS_PAGING_WAIT_LISTEN_LOAD_FAIL);
1372 goto EXIT_ERR;
1373 }
1374 if (ret == WAIT_LISTEN_CHECK_TIMEOUT) {
1375 TRANS_LOGE(TRANS_CTRL, "check wait listen time out");
1376 TransWaitListenResult(*businessFlag, SOFTBUS_TRANS_PAGING_WAIT_LISTEN_TIMEOUT);
1377 goto EXIT_ERR;
1378 }
1379 TRANS_LOGE(TRANS_CTRL, "wait listen check fail, requestId=%{public}u", *businessFlag);
1380 TransWaitListenResult(*businessFlag, ret);
1381 goto EXIT_ERR;
1382 EXIT_ERR:
1383 (void)DelWaitListenByFlag(*businessFlag);
1384 SoftBusFree(businessFlag);
1385 }
1386
TransCheckPagingListenState(uint32_t businessFlag)1387 int32_t TransCheckPagingListenState(uint32_t businessFlag)
1388 {
1389 if (AddWaitListInfo(businessFlag) != SOFTBUS_OK) {
1390 TRANS_LOGE(TRANS_CTRL, "linkInfo memcpy fail");
1391 return SOFTBUS_MEM_ERR;
1392 }
1393 uint32_t *flag = (uint32_t *)SoftBusCalloc(sizeof(uint32_t));
1394 if (flag == NULL) {
1395 TRANS_LOGE(TRANS_CTRL, "calloc flag fail");
1396 (void)DelWaitListenByFlag(businessFlag);
1397 TransWaitListenResult(businessFlag, SOFTBUS_MALLOC_ERR);
1398 return SOFTBUS_MALLOC_ERR;
1399 }
1400 *flag = businessFlag;
1401 if (LnnAsyncCallbackDelayHelper(GetLooper(LOOP_TYPE_DEFAULT), CheckPagingListen, (void *)flag,
1402 WAIT_LISTEN_CHECK_DELAY) != SOFTBUS_OK) {
1403 TRANS_LOGE(TRANS_CTRL, "lnn async fail.");
1404 (void)DelWaitListenByFlag(businessFlag);
1405 SoftBusFree(flag);
1406 return SOFTBUS_TRANS_PAGING_ASYNC_FAIL;
1407 }
1408 return SOFTBUS_OK;
1409 }
1410