1 /*
2  * Copyright (c) 2021-2024 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "softbus_proxychannel_transceiver.h"
17 
18 #include <securec.h>
19 
20 #include "auth_device_common_key.h"
21 #include "lnn_device_info_recovery.h"
22 #include "lnn_lane_link.h"
23 #include "lnn_network_manager.h"
24 #include "message_handler.h"
25 #include "softbus_adapter_hitrace.h"
26 #include "softbus_adapter_mem.h"
27 #include "softbus_adapter_thread.h"
28 #include "softbus_base_listener.h"
29 #include "softbus_conn_interface.h"
30 #include "softbus_def.h"
31 #include "softbus_errcode.h"
32 #include "softbus_proxychannel_control.h"
33 #include "softbus_proxychannel_listener.h"
34 #include "softbus_proxychannel_manager.h"
35 #include "softbus_proxychannel_message.h"
36 #include "softbus_proxychannel_pipeline.h"
37 #include "softbus_utils.h"
38 #include "trans_auth_negotiation.h"
39 #include "trans_channel_common.h"
40 #include "trans_channel_manager.h"
41 #include "trans_log.h"
42 #include "trans_event.h"
43 
44 #define ID_OFFSET (1)
45 
46 static SoftBusList *g_proxyConnectionList = NULL;
47 const char *g_transProxyLoopName = "transProxyLoopName";
48 SoftBusHandler g_transLoopHandler = { 0 };
49 
50 typedef enum {
51     LOOP_HANDSHAKE_MSG,
52     LOOP_DISCONNECT_MSG,
53     LOOP_OPENFAIL_MSG,
54     LOOP_OPENCLOSE_MSG,
55     LOOP_KEEPALIVE_MSG,
56     LOOP_RESETPEER_MSG,
57     LOOP_AUTHSTATECHECK_MSG,
58 } LoopMsg;
59 
TransDelConnByReqId(uint32_t requestId)60 int32_t TransDelConnByReqId(uint32_t requestId)
61 {
62     ProxyConnInfo *removeNode = NULL;
63     ProxyConnInfo *tmpNode = NULL;
64 
65     if (g_proxyConnectionList == NULL) {
66         TRANS_LOGE(TRANS_CTRL, "g_proxyConnectionList is null!");
67         return SOFTBUS_NO_INIT;
68     }
69 
70     if (SoftBusMutexLock(&g_proxyConnectionList->lock) != SOFTBUS_OK) {
71         TRANS_LOGE(TRANS_CTRL, "lock mutex fail!");
72         return SOFTBUS_LOCK_ERR;
73     }
74 
75     LIST_FOR_EACH_ENTRY_SAFE(removeNode, tmpNode, &g_proxyConnectionList->list, ProxyConnInfo, node) {
76         if (removeNode->requestId == requestId && removeNode->state == PROXY_CHANNEL_STATUS_PYH_CONNECTING) {
77             ListDelete(&(removeNode->node));
78             TRANS_LOGI(TRANS_CTRL, "delete requestId=%{public}u", removeNode->requestId);
79             SoftBusFree(removeNode);
80             g_proxyConnectionList->cnt--;
81             break;
82         }
83     }
84     (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
85     return SOFTBUS_OK;
86 }
87 
TransDelConnByConnId(uint32_t connId)88 void TransDelConnByConnId(uint32_t connId)
89 {
90     ProxyConnInfo *removeNode = NULL;
91     ProxyConnInfo *tmpNode = NULL;
92 
93     if ((g_proxyConnectionList == NULL) || (connId == 0)) {
94         TRANS_LOGE(TRANS_CTRL, "g_proxyConnectionList or connId is null");
95         return;
96     }
97 
98     if (SoftBusMutexLock(&g_proxyConnectionList->lock) != SOFTBUS_OK) {
99         TRANS_LOGE(TRANS_CTRL, "lock mutex fail!");
100         return;
101     }
102 
103     LIST_FOR_EACH_ENTRY_SAFE(removeNode, tmpNode, &g_proxyConnectionList->list, ProxyConnInfo, node) {
104         if (removeNode->connId == connId) {
105             ListDelete(&(removeNode->node));
106             SoftBusFree(removeNode);
107             TRANS_LOGI(TRANS_CTRL, "del conn item. connId=%{public}d", connId);
108             g_proxyConnectionList->cnt--;
109         }
110     }
111     (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
112     return;
113 }
114 
TransDecConnRefByConnId(uint32_t connId,bool isServer)115 int32_t TransDecConnRefByConnId(uint32_t connId, bool isServer)
116 {
117     ProxyConnInfo *removeNode = NULL;
118     ProxyConnInfo *tmpNode = NULL;
119 
120     if ((g_proxyConnectionList == NULL) || (connId == 0)) {
121         TRANS_LOGE(TRANS_MSG, "g_proxyConnectionList or connId is null");
122         return SOFTBUS_NO_INIT;
123     }
124 
125     if (SoftBusMutexLock(&g_proxyConnectionList->lock) != SOFTBUS_OK) {
126         TRANS_LOGE(TRANS_CTRL, "lock mutex fail!");
127         return SOFTBUS_LOCK_ERR;
128     }
129 
130     LIST_FOR_EACH_ENTRY_SAFE(removeNode, tmpNode, &g_proxyConnectionList->list, ProxyConnInfo, node) {
131         if (removeNode->connId == connId && removeNode->isServerSide == isServer) {
132             removeNode->ref--;
133             if (removeNode->ref <= 0) {
134                 ListDelete(&(removeNode->node));
135                 SoftBusFree(removeNode);
136                 g_proxyConnectionList->cnt--;
137                 (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
138                 TRANS_LOGI(TRANS_CTRL, "conn ref is 0. connId=%{public}u", connId);
139                 return SOFTBUS_OK;
140             } else {
141                 TRANS_LOGI(TRANS_CTRL, "connId=%{public}u, proxyConnRef=%{public}d", connId, removeNode->ref);
142                 (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
143                 return SOFTBUS_TRANS_NOT_MATCH;
144             }
145         }
146     }
147 
148     TRANS_LOGW(TRANS_CTRL, "not find item. connId=%{public}u", connId);
149     (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
150     return SOFTBUS_OK;
151 }
152 
TransAddConnRefByConnId(uint32_t connId,bool isServer)153 int32_t TransAddConnRefByConnId(uint32_t connId, bool isServer)
154 {
155     ProxyConnInfo *item = NULL;
156 
157     if (g_proxyConnectionList == NULL) {
158         TRANS_LOGE(TRANS_MSG, "g_proxyConnectionList is null");
159         return SOFTBUS_NO_INIT;
160     }
161 
162     if (SoftBusMutexLock(&g_proxyConnectionList->lock) != SOFTBUS_OK) {
163         TRANS_LOGE(TRANS_CTRL, "lock mutex fail!");
164         return SOFTBUS_LOCK_ERR;
165     }
166 
167     LIST_FOR_EACH_ENTRY(item, &g_proxyConnectionList->list, ProxyConnInfo, node) {
168         if (item->connId == connId && item->isServerSide == isServer) {
169             item->ref++;
170             TRANS_LOGI(TRANS_CTRL, "add connId=%{public}u, proxyConnRef=%{public}d.", connId, item->ref);
171             (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
172             return SOFTBUS_OK;
173         }
174     }
175     (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
176     return SOFTBUS_TRANS_PROXY_CONN_ADD_REF_FAILED;
177 }
178 
TransProxyLoopMsgHandler(SoftBusMessage * msg)179 static void TransProxyLoopMsgHandler(SoftBusMessage *msg)
180 {
181     TRANS_CHECK_AND_RETURN_LOGE(msg != NULL, TRANS_MSG, "param invalid");
182     TRANS_LOGD(TRANS_CTRL, "trans loop process msgType=%{public}d", msg->what);
183     int32_t channelId;
184     ProxyChannelInfo *chan = NULL;
185     switch (msg->what) {
186         case LOOP_HANDSHAKE_MSG:
187             channelId = *((int32_t *)msg->obj);
188             TransProxyOpenProxyChannelSuccess(channelId);
189             break;
190         case LOOP_DISCONNECT_MSG: {
191             bool isServer = (bool)msg->arg1;
192             uint32_t connectionId = (uint32_t)msg->arg2;
193             chan = (ProxyChannelInfo *)msg->obj;
194             TRANS_CHECK_AND_RETURN_LOGE(chan != NULL, TRANS_MSG, "LOOP_DISCONNECT_MSG, chan is null");
195             TransProxyCloseConnChannelReset(connectionId, (isServer == 0), isServer, chan->deviceTypeIsWinpc);
196             break;
197         }
198         case LOOP_OPENFAIL_MSG:
199             chan = (ProxyChannelInfo *)msg->obj;
200             TRANS_CHECK_AND_RETURN_LOGE(chan != NULL, TRANS_MSG, "LOOP_OPENFAIL_MSG, chan is null");
201             TransProxyOpenProxyChannelFail(chan->channelId, &(chan->appInfo), (int32_t)msg->arg1);
202             break;
203         case LOOP_OPENCLOSE_MSG:
204             chan = (ProxyChannelInfo *)msg->obj;
205             TRANS_CHECK_AND_RETURN_LOGE(chan != NULL, TRANS_MSG, "LOOP_OPENCLOSE_MSG, chan is null");
206             OnProxyChannelClosed(chan->channelId, &(chan->appInfo));
207             break;
208         case LOOP_KEEPALIVE_MSG:
209             chan = (ProxyChannelInfo *)msg->obj;
210             TRANS_CHECK_AND_RETURN_LOGE(chan != NULL, TRANS_MSG, "LOOP_KEEPALIVE_MSG, chan is null");
211             TransProxyKeepalive(chan->connId, chan);
212             break;
213         case LOOP_RESETPEER_MSG:
214             chan = (ProxyChannelInfo *)msg->obj;
215             TRANS_CHECK_AND_RETURN_LOGE(chan != NULL, TRANS_MSG, "LOOP_RESETPEER_MSG, chan is null");
216             TransProxyResetPeer(chan);
217             break;
218         case LOOP_AUTHSTATECHECK_MSG: {
219             uint32_t authRequestId = (uint32_t)msg->arg1;
220             channelId = (int32_t)msg->arg2;
221             TransAuthNegoTaskManager(authRequestId, channelId);
222             break;
223         }
224         default:
225             break;
226     }
227 }
228 
TransProxyFreeLoopMsg(SoftBusMessage * msg)229 void TransProxyFreeLoopMsg(SoftBusMessage *msg)
230 {
231     if (msg != NULL) {
232         if (msg->obj != NULL) {
233             SoftBusFree(msg->obj);
234         }
235         SoftBusFree((void *)msg);
236     }
237 }
238 
TransProxyCreateLoopMsg(int32_t what,uint64_t arg1,uint64_t arg2,char * data)239 static SoftBusMessage *TransProxyCreateLoopMsg(int32_t what, uint64_t arg1, uint64_t arg2, char *data)
240 {
241     SoftBusMessage *msg = (SoftBusMessage *)SoftBusCalloc(sizeof(SoftBusMessage));
242     if (msg == NULL) {
243         TRANS_LOGE(TRANS_MSG, "msg calloc failed");
244         return NULL;
245     }
246     msg->what = what;
247     msg->arg1 = arg1;
248     msg->arg2 = arg2;
249     msg->handler = &g_transLoopHandler;
250     msg->FreeMessage = TransProxyFreeLoopMsg;
251     msg->obj = (void *)data;
252     return msg;
253 }
254 
TransProxyPostAuthNegoMsgToLooperDelay(uint32_t authRequestId,int32_t channelId,uint32_t delayTime)255 void TransProxyPostAuthNegoMsgToLooperDelay(uint32_t authRequestId, int32_t channelId, uint32_t delayTime)
256 {
257     SoftBusMessage *msg  = TransProxyCreateLoopMsg(LOOP_AUTHSTATECHECK_MSG, authRequestId, channelId, NULL);
258     TRANS_CHECK_AND_RETURN_LOGE(msg != NULL, TRANS_MSG, "msg create failed");
259 
260     g_transLoopHandler.looper->PostMessageDelay(g_transLoopHandler.looper, msg, delayTime);
261 }
262 
TransProxyPostResetPeerMsgToLoop(const ProxyChannelInfo * chan)263 void TransProxyPostResetPeerMsgToLoop(const ProxyChannelInfo *chan)
264 {
265     SoftBusMessage *msg  = TransProxyCreateLoopMsg(LOOP_RESETPEER_MSG, 0, 0, (char *)chan);
266     if (msg == NULL) {
267         TRANS_LOGE(TRANS_MSG, "msg create failed");
268         if (chan != NULL) {
269             SoftBusFree((void *)chan);
270         }
271         return;
272     }
273     g_transLoopHandler.looper->PostMessage(g_transLoopHandler.looper, msg);
274 }
275 
TransProxyPostHandshakeMsgToLoop(int32_t channelId)276 void TransProxyPostHandshakeMsgToLoop(int32_t channelId)
277 {
278     int32_t *chanIdMsg = (int32_t *)SoftBusCalloc(sizeof(int32_t));
279     if (chanIdMsg == NULL) {
280         TRANS_LOGE(TRANS_MSG, "chanIdMsg calloc failed");
281         return;
282     }
283     *chanIdMsg = channelId;
284     SoftBusMessage *msg  = TransProxyCreateLoopMsg(LOOP_HANDSHAKE_MSG, 0, 0, (char *)chanIdMsg);
285     if (msg == NULL) {
286         SoftBusFree((void *)chanIdMsg);
287         return;
288     }
289     g_transLoopHandler.looper->PostMessage(g_transLoopHandler.looper, msg);
290 }
291 
TransProxyPostDisConnectMsgToLoop(uint32_t connId,bool isServer,const ProxyChannelInfo * chan)292 void TransProxyPostDisConnectMsgToLoop(uint32_t connId, bool isServer, const ProxyChannelInfo *chan)
293 {
294     SoftBusMessage *msg = TransProxyCreateLoopMsg(LOOP_DISCONNECT_MSG, isServer, connId, (char *)chan);
295     if (msg == NULL) {
296         TRANS_LOGE(TRANS_MSG, "msg create failed");
297         SoftBusFree((void *)chan);
298         return;
299     }
300     g_transLoopHandler.looper->PostMessage(g_transLoopHandler.looper, msg);
301 }
302 
TransProxyPostKeepAliveMsgToLoop(const ProxyChannelInfo * chan)303 void TransProxyPostKeepAliveMsgToLoop(const ProxyChannelInfo *chan)
304 {
305     if (chan == NULL) {
306         TRANS_LOGE(TRANS_MSG, "param invalid");
307         return;
308     }
309     SoftBusMessage *msg = TransProxyCreateLoopMsg(LOOP_KEEPALIVE_MSG, 0, 0, (char *)chan);
310     if (msg == NULL) {
311         TRANS_LOGE(TRANS_MSG, "msg create failed");
312         if (chan != NULL) {
313             SoftBusFree((void *)chan);
314         }
315         return;
316     }
317     g_transLoopHandler.looper->PostMessage(g_transLoopHandler.looper, msg);
318 }
319 
TransProxyPostOpenFailMsgToLoop(const ProxyChannelInfo * chan,int32_t errCode)320 void TransProxyPostOpenFailMsgToLoop(const ProxyChannelInfo *chan, int32_t errCode)
321 {
322     if (chan == NULL) {
323         TRANS_LOGE(TRANS_MSG, "param invalid");
324         return;
325     }
326     SoftBusMessage *msg = TransProxyCreateLoopMsg(LOOP_OPENFAIL_MSG, errCode, 0, (char *)chan);
327     if (msg == NULL) {
328         TRANS_LOGE(TRANS_MSG, "msg create failed");
329         if (chan != NULL) {
330             SoftBusFree((void *)chan);
331         }
332         return;
333     }
334     g_transLoopHandler.looper->PostMessage(g_transLoopHandler.looper, msg);
335 }
336 
TransProxyPostOpenClosedMsgToLoop(const ProxyChannelInfo * chan)337 void TransProxyPostOpenClosedMsgToLoop(const ProxyChannelInfo *chan)
338 {
339     if (chan == NULL) {
340         TRANS_LOGE(TRANS_MSG, "param invalid");
341         return;
342     }
343     SoftBusMessage *msg = TransProxyCreateLoopMsg(LOOP_OPENCLOSE_MSG, 0, 0, (char *)chan);
344     if (msg == NULL) {
345         TRANS_LOGE(TRANS_MSG, "msg create failed");
346         if (chan != NULL) {
347             SoftBusFree((void *)chan);
348         }
349         return;
350     }
351     g_transLoopHandler.looper->PostMessage(g_transLoopHandler.looper, msg);
352 }
353 
TransProxyLoopInit(void)354 static int32_t TransProxyLoopInit(void)
355 {
356     g_transLoopHandler.name = (char *)g_transProxyLoopName;
357     g_transLoopHandler.looper = GetLooper(LOOP_TYPE_DEFAULT);
358     if (g_transLoopHandler.looper == NULL) {
359         return SOFTBUS_TRANS_INIT_FAILED;
360     }
361     g_transLoopHandler.HandleMessage = TransProxyLoopMsgHandler;
362     return SOFTBUS_OK;
363 }
364 
TransProxyTransSendMsg(uint32_t connectionId,uint8_t * buf,uint32_t len,int32_t priority,int32_t pid)365 int32_t TransProxyTransSendMsg(uint32_t connectionId, uint8_t *buf, uint32_t len, int32_t priority, int32_t pid)
366 {
367     ConnPostData data = { 0 };
368     static uint64_t seq = 1;
369 
370     data.module = MODULE_PROXY_CHANNEL;
371     data.seq = seq++;
372     data.flag = priority;
373     data.pid = pid;
374     data.len = len;
375     data.buf = (char *)buf;
376     TRANS_LOGI(TRANS_MSG,
377         "send msg connId=%{public}u, len=%{public}u, seq=%{public}" PRIu64 ", priority=%{public}d, pid=%{public}d",
378         connectionId, len, data.seq, priority, pid);
379     int32_t ret = ConnPostBytes(connectionId, &data);
380     if (ret < 0) {
381         TRANS_LOGE(TRANS_MSG, "conn send buf fail ret=%{public}d", ret);
382         return ret;
383     }
384     return SOFTBUS_OK;
385 }
386 
TransProxyOnConnected(uint32_t connId,const ConnectionInfo * connInfo)387 static void TransProxyOnConnected(uint32_t connId, const ConnectionInfo *connInfo)
388 {
389     (void)connInfo;
390     TRANS_LOGI(TRANS_CTRL, "connect enabled, connId=%{public}u", connId);
391     return;
392 }
393 
TransProxyOnDisConnect(uint32_t connId,const ConnectionInfo * connInfo)394 static void TransProxyOnDisConnect(uint32_t connId, const ConnectionInfo *connInfo)
395 {
396     (void)connInfo;
397     TRANS_LOGI(TRANS_CTRL, "connect disabled, connId=%{public}u", connId);
398     TransProxyDelByConnId(connId);
399     TransDelConnByConnId(connId);
400     return;
401 }
402 
CompareConnectOption(const ConnectOption * itemConnInfo,const ConnectOption * connInfo)403 static bool CompareConnectOption(const ConnectOption *itemConnInfo, const ConnectOption *connInfo)
404 {
405     if (connInfo->type == CONNECT_TCP) {
406         TRANS_LOGI(TRANS_CTRL, "CONNECT_TCP");
407         if (connInfo->socketOption.protocol == itemConnInfo->socketOption.protocol &&
408             strcasecmp(connInfo->socketOption.addr, itemConnInfo->socketOption.addr) == 0 &&
409             connInfo->socketOption.port == itemConnInfo->socketOption.port) {
410             return true;
411         }
412         return false;
413     } else if (connInfo->type == CONNECT_BR) {
414         TRANS_LOGI(TRANS_CTRL, "CONNECT_BR");
415         if (strcasecmp(connInfo->brOption.brMac, itemConnInfo->brOption.brMac) == 0) {
416             return true;
417         }
418         return false;
419     } else if (connInfo->type == CONNECT_BLE) {
420         TRANS_LOGI(TRANS_CTRL, "CONNECT_BLE");
421         if (strcasecmp(connInfo->bleOption.bleMac, itemConnInfo->bleOption.bleMac) == 0 &&
422             (connInfo->bleOption.protocol == itemConnInfo->bleOption.protocol) &&
423             connInfo->bleOption.psm == itemConnInfo->bleOption.psm) {
424             return true;
425         }
426         return false;
427     } else if (connInfo->type == CONNECT_BLE_DIRECT) {
428         TRANS_LOGI(TRANS_CTRL, "CONNECT_BLE_DIRECT");
429         if ((strcmp(connInfo->bleDirectOption.networkId, itemConnInfo->bleDirectOption.networkId) == 0) &&
430             (connInfo->bleDirectOption.protoType == itemConnInfo->bleDirectOption.protoType)) {
431             return true;
432         }
433         return false;
434     }
435     return false;
436 }
437 
TransAddConnItem(ProxyConnInfo * chan)438 int32_t TransAddConnItem(ProxyConnInfo *chan)
439 {
440     if (chan == NULL) {
441         TRANS_LOGE(TRANS_CTRL, "param invalid");
442         return SOFTBUS_INVALID_PARAM;
443     }
444     ProxyConnInfo *item = NULL;
445     ProxyConnInfo *tmpItem = NULL;
446 
447     if (g_proxyConnectionList == NULL) {
448         TRANS_LOGE(TRANS_CTRL, "g_proxyConnectionList is null");
449         return SOFTBUS_NO_INIT;
450     }
451 
452     if (SoftBusMutexLock(&g_proxyConnectionList->lock) != SOFTBUS_OK) {
453         TRANS_LOGE(TRANS_CTRL, "lock mutex fail!");
454         return SOFTBUS_LOCK_ERR;
455     }
456 
457     LIST_FOR_EACH_ENTRY_SAFE(item, tmpItem, &g_proxyConnectionList->list, ProxyConnInfo, node) {
458         if (item->isServerSide == chan->isServerSide &&
459             CompareConnectOption(&item->connInfo, &chan->connInfo) == true) {
460             (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
461             return SOFTBUS_TRANS_NOT_MATCH;
462         }
463     }
464     ListAdd(&(g_proxyConnectionList->list), &(chan->node));
465     TRANS_LOGI(TRANS_CTRL, "add requestId=%{public}u", chan->requestId);
466     g_proxyConnectionList->cnt++;
467     (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
468     return SOFTBUS_OK;
469 }
470 
TransConnInfoToConnOpt(ConnectionInfo * connInfo,ConnectOption * connOption)471 static void TransConnInfoToConnOpt(ConnectionInfo *connInfo, ConnectOption *connOption)
472 {
473     connOption->type = connInfo->type;
474     if (connOption->type == CONNECT_BR) {
475         TRANS_LOGI(TRANS_CTRL, "CONNECT_BR");
476         (void)memcpy_s(connOption->brOption.brMac, sizeof(char) * BT_MAC_LEN,
477             connInfo->brInfo.brMac, sizeof(char) * BT_MAC_LEN);
478     } else if (connOption->type == CONNECT_BLE) {
479         TRANS_LOGI(TRANS_CTRL, "CONNECT_BLE");
480         (void)memcpy_s(connOption->bleOption.bleMac, sizeof(char) * BT_MAC_LEN,
481             connInfo->bleInfo.bleMac, sizeof(char) * BT_MAC_LEN);
482         (void)memcpy_s(connOption->bleOption.deviceIdHash, sizeof(char) * UDID_HASH_LEN,
483             connInfo->bleInfo.deviceIdHash, sizeof(char) * UDID_HASH_LEN);
484     } else {
485         (void)memcpy_s(connOption->socketOption.addr, sizeof(char) * IP_LEN,
486             connInfo->socketInfo.addr, sizeof(char) * IP_LEN);
487         connOption->socketOption.protocol = connInfo->socketInfo.protocol;
488         connOption->socketOption.port = connInfo->socketInfo.port;
489         connOption->socketOption.moduleId = connInfo->socketInfo.moduleId;
490     }
491 }
492 
TransCreateConnByConnId(uint32_t connId,bool isServer)493 void TransCreateConnByConnId(uint32_t connId, bool isServer)
494 {
495     ProxyConnInfo *item = NULL;
496     ProxyConnInfo *tmpNode = NULL;
497     ConnectionInfo info = {0};
498 
499     if (g_proxyConnectionList == NULL) {
500         TRANS_LOGE(TRANS_CTRL, "g_proxyConnectionList is null");
501         return;
502     }
503 
504     if (ConnGetConnectionInfo(connId, &info) != SOFTBUS_OK) {
505         TRANS_LOGE(TRANS_CTRL, "CreateConn get conn info fail connId=%{public}u", connId);
506         return;
507     }
508 
509     if (SoftBusMutexLock(&g_proxyConnectionList->lock) != SOFTBUS_OK) {
510         TRANS_LOGE(TRANS_CTRL, "lock mutex fail!");
511         return;
512     }
513     LIST_FOR_EACH_ENTRY_SAFE(item, tmpNode, &g_proxyConnectionList->list, ProxyConnInfo, node) {
514         if (item->connId == connId && item->isServerSide == isServer) {
515             item->ref++;
516             TRANS_LOGI(TRANS_CTRL, "repeat conn proxyConnRef=%{public}d", item->ref);
517             (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
518             return;
519         }
520     }
521 
522     item = (ProxyConnInfo *)SoftBusCalloc(sizeof(ProxyConnInfo));
523     if (item == NULL) {
524         TRANS_LOGE(TRANS_CTRL, "item calloc failed");
525         (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
526         return;
527     }
528     item->ref++;
529     item->state = PROXY_CHANNEL_STATUS_PYH_CONNECTED;
530     TRANS_LOGI(TRANS_CTRL, "create conn proxyConnRef=%{public}d", item->ref);
531     item->connId = connId;
532     item->isServerSide = isServer;
533     TransConnInfoToConnOpt(&info, &item->connInfo);
534     ListAdd(&(g_proxyConnectionList->list), &(item->node));
535     TRANS_LOGI(TRANS_CTRL, "add connId=%{public}u", item->connId);
536     g_proxyConnectionList->cnt++;
537     (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
538     return;
539 }
540 
TransGetConn(const ConnectOption * connInfo,ProxyConnInfo * proxyConn,bool isServer)541 static int32_t TransGetConn(const ConnectOption *connInfo, ProxyConnInfo *proxyConn, bool isServer)
542 {
543     ProxyConnInfo *item = NULL;
544 
545     if (g_proxyConnectionList == NULL) {
546         TRANS_LOGE(TRANS_CTRL, "proxy connection list not inited!");
547         return SOFTBUS_NO_INIT;
548     }
549 
550     if (connInfo == NULL || proxyConn == NULL) {
551         TRANS_LOGE(TRANS_CTRL, "invalid para in trans get conn.");
552         return SOFTBUS_INVALID_PARAM;
553     }
554 
555     if (SoftBusMutexLock(&g_proxyConnectionList->lock) != SOFTBUS_OK) {
556         TRANS_LOGE(TRANS_CTRL, "lock mutex fail!");
557         return SOFTBUS_LOCK_ERR;
558     }
559 
560     LIST_FOR_EACH_ENTRY(item, &g_proxyConnectionList->list, ProxyConnInfo, node) {
561         if (item->connInfo.type != connInfo->type || item->isServerSide != isServer) {
562             continue;
563         }
564         if (CompareConnectOption(&item->connInfo, connInfo)) {
565             (void)memcpy_s(proxyConn, sizeof(ProxyConnInfo), item, sizeof(ProxyConnInfo));
566             (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
567             return SOFTBUS_OK;
568         }
569     }
570     (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
571     TRANS_LOGE(TRANS_CTRL, "can not find proxy conn in list.");
572     return SOFTBUS_TRANS_NOT_MATCH;
573 }
574 
TransSetConnStateByReqId(uint32_t requestId,uint32_t connId,uint32_t state)575 static void TransSetConnStateByReqId(uint32_t requestId, uint32_t connId, uint32_t state)
576 {
577     ProxyConnInfo *getNode = NULL;
578 
579     if (g_proxyConnectionList == NULL) {
580         return;
581     }
582 
583     if (SoftBusMutexLock(&g_proxyConnectionList->lock) != SOFTBUS_OK) {
584         TRANS_LOGE(TRANS_CTRL, "lock mutex fail!");
585         return;
586     }
587 
588     LIST_FOR_EACH_ENTRY(getNode, &g_proxyConnectionList->list, ProxyConnInfo, node) {
589         if (getNode->requestId == requestId && getNode->state == PROXY_CHANNEL_STATUS_PYH_CONNECTING) {
590             getNode->state = state;
591             getNode->connId = connId;
592             getNode->requestId = 0;
593             (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
594             return;
595         }
596     }
597     (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
598     TRANS_LOGE(TRANS_CTRL,
599         "can not find proxy conn when set conn state. requestId=%{public}u, connId=%{public}u", requestId, connId);
600     (void)ConnDisconnectDevice(connId);
601 }
602 
TransOnConnectSucceed(uint32_t requestId,uint32_t connectionId,const ConnectionInfo * connInfo)603 static void TransOnConnectSucceed(uint32_t requestId, uint32_t connectionId, const ConnectionInfo *connInfo)
604 {
605     TransEventExtra extra = {
606         .socketName = NULL,
607         .peerNetworkId = NULL,
608         .calleePkg = NULL,
609         .callerPkg = NULL,
610         .requestId = (int32_t)requestId,
611         .connectionId = (int32_t)connectionId,
612         .result = EVENT_STAGE_RESULT_OK
613     };
614     TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL, EVENT_STAGE_START_CONNECT, extra);
615     TRANS_LOGI(TRANS_CTRL,
616         "Connect Success requestId=%{public}u, connId=%{public}u", requestId, connectionId);
617     TransSetConnStateByReqId(requestId, connectionId, PROXY_CHANNEL_STATUS_PYH_CONNECTED);
618     TransProxyChanProcessByReqId((int32_t)requestId, connectionId);
619 }
620 
TransOnConnectFailed(uint32_t requestId,int32_t reason)621 static void TransOnConnectFailed(uint32_t requestId, int32_t reason)
622 {
623     TransEventExtra extra = {
624         .socketName = NULL,
625         .peerNetworkId = NULL,
626         .calleePkg = NULL,
627         .callerPkg = NULL,
628         .requestId = requestId,
629         .errcode = reason,
630         .result = EVENT_STAGE_RESULT_FAILED
631     };
632     TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL, EVENT_STAGE_START_CONNECT, extra);
633     TRANS_LOGE(TRANS_CTRL, "Connect fail requestId=%{public}u, reason=%{public}d", requestId, reason);
634     if (TransDelConnByReqId(requestId) != SOFTBUS_OK) {
635         TRANS_LOGE(TRANS_CTRL, "Connect fail del fail. requestId=%{public}u", requestId);
636     }
637     TransProxyDelChanByReqId((int32_t)requestId, reason);
638 }
639 
TransProxyCloseConnChannel(uint32_t connectionId,bool isServer)640 int32_t TransProxyCloseConnChannel(uint32_t connectionId, bool isServer)
641 {
642     if (TransDecConnRefByConnId(connectionId, isServer) == SOFTBUS_OK) {
643         TRANS_LOGI(TRANS_CTRL, "disconnect device connId=%{public}d", connectionId);
644         // BR don't disconnect
645         (void)ConnDisconnectDevice(connectionId);
646     }
647     return SOFTBUS_OK;
648 }
649 
TransProxyCloseConnChannelReset(uint32_t connectionId,bool isDisconnect,bool isServer,bool deviceType)650 int32_t TransProxyCloseConnChannelReset(uint32_t connectionId, bool isDisconnect, bool isServer, bool deviceType)
651 {
652     if (TransDecConnRefByConnId(connectionId, isServer) == SOFTBUS_OK) {
653         TRANS_LOGI(TRANS_CTRL, "reset dis device. isDisconnect=%{public}d, connId=%{public}u, deviceType=%{public}d",
654             isDisconnect, connectionId, deviceType);
655         // only client side can disconnect connection
656         if (isDisconnect && deviceType != true) {
657             (void)ConnDisconnectDevice(connectionId);
658         }
659     }
660     return SOFTBUS_OK;
661 }
662 
TransProxyConnExistProc(ProxyChannelInfo * chan,int32_t chanNewId,const ConnectOption * connInfo)663 static int32_t TransProxyConnExistProc(ProxyChannelInfo *chan, int32_t chanNewId, const ConnectOption *connInfo)
664 {
665     if (chan == NULL) {
666         TRANS_LOGE(TRANS_CTRL, "invalid param");
667         return SOFTBUS_INVALID_PARAM;
668     }
669     SoftbusHitraceStart(SOFTBUS_HITRACE_ID_VALID, (uint64_t)(chanNewId + ID_OFFSET));
670     TRANS_LOGI(TRANS_CTRL,
671         "SoftBusHiTraceChainBegin: set hiTraceId=%{public}" PRIu64, (uint64_t)(chanNewId + ID_OFFSET));
672     int32_t ret = GetProxyChannelLock();
673     TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_CTRL, "lock mutex fail!");
674     ProxyConnInfo conn;
675     if (TransGetConn(connInfo, &conn, false) != SOFTBUS_OK) {
676         ReleaseProxyChannelLock();
677         TRANS_LOGE(TRANS_CTRL, "get connectInfo failed, channelId=%{public}d", chanNewId);
678         return SOFTBUS_TRANS_PROXY_CONN_ADD_REF_FAILED;
679     }
680     ConnectType type = conn.connInfo.type;
681     if (conn.state == PROXY_CHANNEL_STATUS_PYH_CONNECTING) {
682         ProxyChannelInfo channelInfo = {
683             .channelId = chanNewId,
684             .reqId = (int32_t)conn.requestId,
685             .isServer = -1,
686             .type = type,
687             .status = PROXY_CHANNEL_STATUS_PYH_CONNECTING,
688             .connId = 0
689         };
690 
691         TransProxySpecialUpdateChanInfo(&channelInfo);
692         ReleaseProxyChannelLock();
693         TRANS_LOGI(TRANS_CTRL, "reuse connection requestId=%{public}d", chan->reqId);
694     } else {
695         ReleaseProxyChannelLock();
696         ProxyChannelInfo channelInfo = {
697             .channelId = chanNewId,
698             .reqId = -1,
699             .isServer = -1,
700             .type = type,
701             .status = PROXY_CHANNEL_STATUS_HANDSHAKEING,
702             .connId = conn.connId
703         };
704         if (TransAddConnRefByConnId(conn.connId, (bool)chan->isServer) != SOFTBUS_OK) {
705             TRANS_LOGE(TRANS_CTRL, "TransAddConnRefByConnId: connId=%{public}u err", conn.connId);
706             return SOFTBUS_TRANS_PROXY_CONN_ADD_REF_FAILED;
707         }
708         TransProxySpecialUpdateChanInfo(&channelInfo);
709         TransProxyPostHandshakeMsgToLoop(chanNewId);
710     }
711     return SOFTBUS_OK;
712 }
713 
TransProxyConnectDevice(const ConnectOption * connInfo,uint32_t requestId)714 static int32_t TransProxyConnectDevice(const ConnectOption *connInfo, uint32_t requestId)
715 {
716     ConnectResult result;
717     result.OnConnectFailed = TransOnConnectFailed;
718     result.OnConnectSuccessed = TransOnConnectSucceed;
719     if (connInfo->type == CONNECT_BLE_DIRECT) {
720         return ConnBleDirectConnectDevice(connInfo, requestId, &result);
721     } else {
722         return ConnConnectDevice(connInfo, requestId, &result);
723     }
724 }
725 
TransProxyOpenNewConnChannel(ListenerModule moduleId,const ConnectOption * connInfo,int32_t channelId)726 static int32_t TransProxyOpenNewConnChannel(ListenerModule moduleId, const ConnectOption *connInfo, int32_t channelId)
727 {
728     SoftbusHitraceStart(SOFTBUS_HITRACE_ID_VALID, (uint64_t)(channelId + ID_OFFSET));
729     TRANS_LOGI(TRANS_CTRL,
730         "SoftBusHiTraceChainBegin: set hiTraceId=%{public}" PRIu64, (uint64_t)(channelId + ID_OFFSET));
731     uint32_t requestId = ConnGetNewRequestId(MODULE_PROXY_CHANNEL);
732     ProxyChannelInfo channelInfo = {
733         .channelId = channelId,
734         .reqId = (int32_t)requestId,
735         .isServer = 0,
736         .type = CONNECT_TYPE_MAX,
737         .status = PROXY_CHANNEL_STATUS_PYH_CONNECTING,
738         .connId = 0
739     };
740     TransProxySpecialUpdateChanInfo(&channelInfo);
741 
742     ProxyConnInfo *connChan = (ProxyConnInfo *)SoftBusCalloc(sizeof(ProxyConnInfo));
743     if (connChan == NULL) {
744         TRANS_LOGE(TRANS_CTRL, "connChan calloc failed");
745         TransProxyDelChanByChanId(channelId);
746         return SOFTBUS_MALLOC_ERR;
747     }
748     connChan->requestId = requestId;
749     connChan->state = PROXY_CHANNEL_STATUS_PYH_CONNECTING;
750     connChan->ref = 0;
751     connChan->isServerSide = false;
752 
753     TRANS_LOGI(TRANS_CTRL, "Connect dev, channelId=%{public}d, requestId=%{public}u", channelId, requestId);
754     connChan->connInfo = (*connInfo);
755     if (connInfo->type == CONNECT_TCP) {
756         connChan->connInfo.socketOption.moduleId = moduleId;
757     }
758     if (TransAddConnItem(connChan) != SOFTBUS_OK) {
759         TRANS_LOGE(TRANS_CTRL, "conn add repeat");
760         SoftBusFree(connChan);
761         return SOFTBUS_TRANS_PROXY_CONN_REPEAT;
762     }
763     int32_t ret = TransProxyConnectDevice(&connChan->connInfo, requestId);
764     if (ret != SOFTBUS_OK) {
765         TRANS_LOGE(TRANS_CTRL, "connect device err");
766         TransDelConnByReqId(requestId);
767         TransProxyDelChanByChanId(channelId);
768     }
769     return ret;
770 }
771 
TransReportStartConnectEvent(const AppInfo * appInfo,const ProxyChannelInfo * chan,int32_t channelId)772 static void TransReportStartConnectEvent(const AppInfo *appInfo, const ProxyChannelInfo *chan, int32_t channelId)
773 {
774     TransEventExtra extra = {
775         .peerNetworkId = NULL,
776         .calleePkg = NULL,
777         .callerPkg = NULL,
778         .socketName = appInfo->myData.sessionName,
779         .channelType = appInfo->appType == APP_TYPE_AUTH ? CHANNEL_TYPE_AUTH : CHANNEL_TYPE_PROXY,
780         .channelId = channelId,
781         .requestId = chan->reqId,
782         .linkType = chan->type
783     };
784     TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL, EVENT_STAGE_START_CONNECT, extra);
785 }
786 
TransProxyOpenConnChannel(const AppInfo * appInfo,const ConnectOption * connInfo,int32_t * channelId)787 int32_t TransProxyOpenConnChannel(const AppInfo *appInfo, const ConnectOption *connInfo, int32_t *channelId)
788 {
789     if (appInfo == NULL || connInfo == NULL) {
790         TRANS_LOGE(TRANS_CTRL, "invalid param");
791         return SOFTBUS_INVALID_PARAM;
792     }
793     int32_t ret = SOFTBUS_ERR;
794     ProxyConnInfo conn;
795     int32_t chanNewId = GenerateChannelId(false);
796     if (chanNewId <= INVALID_CHANNEL_ID) {
797         TRANS_LOGE(TRANS_CTRL, "proxy channelId is invalid");
798         return SOFTBUS_TRANS_INVALID_CHANNEL_ID;
799     }
800     ProxyChannelInfo *chan = (ProxyChannelInfo *)SoftBusCalloc(sizeof(ProxyChannelInfo));
801     if (chan == NULL) {
802         ReleaseProxyChannelId(chanNewId);
803         TRANS_LOGE(TRANS_CTRL, "SoftBusCalloc fail");
804         return SOFTBUS_MALLOC_ERR;
805     }
806     chan->type = connInfo->type;
807     if (TransProxyCreateChanInfo(chan, chanNewId, appInfo) != SOFTBUS_OK) {
808         TRANS_LOGE(TRANS_CTRL, "TransProxyCreateChanInfo err");
809         ReleaseProxyChannelId(chanNewId);
810         (void)memset_s(chan->appInfo.sessionKey, sizeof(chan->appInfo.sessionKey), 0, sizeof(chan->appInfo.sessionKey));
811         SoftBusFree(chan);
812         return SOFTBUS_TRANS_PROXY_CREATE_CHANNEL_FAILED;
813     }
814     if (TransGetConn(connInfo, &conn, false) == SOFTBUS_OK) {
815         ret = TransProxyConnExistProc(chan, chanNewId, connInfo);
816         if (ret == SOFTBUS_TRANS_PROXY_CONN_ADD_REF_FAILED) {
817             ret = TransProxyOpenNewConnChannel(PROXY, connInfo, chanNewId);
818         }
819     } else {
820         ret = TransProxyOpenNewConnChannel(PROXY, connInfo, chanNewId);
821         if ((ret == SOFTBUS_TRANS_PROXY_CONN_REPEAT) && (TransGetConn(connInfo, &conn, false) == SOFTBUS_OK)) {
822             ret = TransProxyConnExistProc(chan, chanNewId, connInfo);
823         }
824     }
825     if (ret == SOFTBUS_OK) {
826         *channelId = chanNewId;
827     } else if (ret == SOFTBUS_TRANS_PROXY_CONN_ADD_REF_FAILED || ret == SOFTBUS_TRANS_PROXY_CONN_REPEAT) {
828         TransProxyDelChanByChanId(chanNewId);
829     }
830     TransReportStartConnectEvent(appInfo, chan, chanNewId);
831     return ret;
832 }
833 
TransProxySendBadKeyMessage(ProxyMessage * msg,const AuthHandle * authHandle)834 static int32_t TransProxySendBadKeyMessage(ProxyMessage *msg, const AuthHandle *authHandle)
835 {
836     ProxyDataInfo dataInfo;
837     dataInfo.inData = (uint8_t *)msg->data;
838     dataInfo.inLen = (uint32_t)msg->dateLen;
839     dataInfo.outData = NULL;
840     dataInfo.outLen = 0;
841 
842     msg->msgHead.type = (PROXYCHANNEL_MSG_TYPE_RESET & FOUR_BIT_MASK) | (VERSION << VERSION_SHIFT);
843     if (AuthCheckSessionKeyValidByAuthHandle(authHandle) == SOFTBUS_AUTH_SESSION_KEY_INVALID) {
844         TRANS_LOGE(TRANS_MSG, "ble single online, send renegotiate msg");
845         msg->msgHead.cipher |= AUTH_SINGLE_CIPHER;
846     } else {
847         msg->msgHead.cipher |= BAD_CIPHER;
848     }
849     TRANS_LOGW(TRANS_MSG, "send msg is bad key myChannelId=%{public}d, peerChannelId=%{public}d",
850         msg->msgHead.myId, msg->msgHead.peerId);
851 
852     int32_t ret = PackPlaintextMessage(&msg->msgHead, &dataInfo);
853     TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_MSG, "PackPlaintextMessage fail");
854 
855     ret = TransProxyTransSendMsg(msg->connId, dataInfo.outData, dataInfo.outLen, CONN_HIGH, 0);
856     TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_MSG, "send bad key buf fail");
857     return SOFTBUS_OK;
858 }
859 
TransProxyOnDataReceived(uint32_t connectionId,ConnModule moduleId,int64_t seq,char * data,int32_t len)860 static void TransProxyOnDataReceived(uint32_t connectionId, ConnModule moduleId, int64_t seq, char *data, int32_t len)
861 {
862     ProxyMessage msg;
863 
864     TRANS_LOGI(TRANS_CTRL, "recv data connId=%{public}u, moduleId=%{public}d, seq=%{public}" PRId64 ", len=%{public}d",
865         connectionId, moduleId, seq, len);
866     TRANS_CHECK_AND_RETURN_LOGE(data != NULL && moduleId == MODULE_PROXY_CHANNEL, TRANS_CTRL, "invalid param");
867     (void)memset_s(&msg, sizeof(ProxyMessage), 0, sizeof(ProxyMessage));
868     msg.connId = connectionId;
869 
870     AuthHandle authHandle = { .authId = AUTH_INVALID_ID };
871     int32_t ret = TransProxyParseMessage((char *)data, len, &msg, &authHandle);
872     if (((ret == SOFTBUS_AUTH_NOT_FOUND) || (ret == SOFTBUS_DECRYPT_ERR)) &&
873         (msg.msgHead.type == PROXYCHANNEL_MSG_TYPE_HANDSHAKE)) {
874         TransReportBadKeyEvent(ret, connectionId, seq, len);
875         if (TransProxySendBadKeyMessage(&msg, &authHandle) != SOFTBUS_OK) {
876             TRANS_LOGE(TRANS_CTRL, "send bad key msg ret=%{public}d", ret);
877             return;
878         }
879         char peerBrMac[BT_MAC_LEN] = {0};
880         char udid[UDID_BUF_LEN] = {0};
881         if (GetBrMacFromConnInfo(connectionId, peerBrMac, BT_MAC_LEN) == SOFTBUS_OK) {
882             if (LnnGetUdidByBrMac(peerBrMac, udid, UDID_BUF_LEN) == SOFTBUS_OK) {
883                 AuthRemoveDeviceKeyByUdid(udid);
884             }
885         }
886     }
887     if (ret != SOFTBUS_OK) {
888         TRANS_LOGE(TRANS_CTRL, "parse proxy msg ret=%{public}d", ret);
889         return;
890     }
891     TransProxyOnMessageReceived(&msg);
892     SoftBusFree(msg.data);
893 }
894 
TransProxyTransInit(void)895 int32_t TransProxyTransInit(void)
896 {
897     ConnectCallback proxyCallback = { 0 };
898 
899     proxyCallback.OnConnected = TransProxyOnConnected;
900     proxyCallback.OnDisconnected = TransProxyOnDisConnect;
901     proxyCallback.OnDataReceived = TransProxyOnDataReceived;
902     int32_t ret = ConnSetConnectCallback(MODULE_PROXY_CHANNEL, &proxyCallback);
903     TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_INIT, "ConnSetConnectCallback fail");
904 
905     g_proxyConnectionList = CreateSoftBusList();
906     if (g_proxyConnectionList == NULL) {
907         TRANS_LOGE(TRANS_INIT, "create observer list failed");
908         return SOFTBUS_MALLOC_ERR;
909     }
910 
911     ret = TransProxyLoopInit();
912     TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_INIT, "create loopInit fail");
913 
914     ret = TransProxyPipelineInit();
915     TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_INIT, "init proxy pipeline failed");
916 
917     return SOFTBUS_OK;
918 }
919 
TransProxyGetConnInfoByConnId(uint32_t connId,ConnectOption * connInfo)920 int32_t TransProxyGetConnInfoByConnId(uint32_t connId, ConnectOption *connInfo)
921 {
922     if (connInfo == NULL) {
923         TRANS_LOGW(TRANS_CTRL, "invalid param.");
924         return SOFTBUS_INVALID_PARAM;
925     }
926 
927     if (g_proxyConnectionList == NULL) {
928         TRANS_LOGE(TRANS_CTRL, "proxy connect list empty.");
929         return SOFTBUS_NO_INIT;
930     }
931 
932     if (SoftBusMutexLock(&g_proxyConnectionList->lock) != SOFTBUS_OK) {
933         TRANS_LOGE(TRANS_CTRL, "lock mutex fail.");
934         return SOFTBUS_LOCK_ERR;
935     }
936 
937     ProxyConnInfo *item = NULL;
938     LIST_FOR_EACH_ENTRY(item, &g_proxyConnectionList->list, ProxyConnInfo, node) {
939         if (item->connId == connId) {
940             if (memcpy_s(connInfo, sizeof(ConnectOption), &(item->connInfo), sizeof(ConnectOption)) != EOK) {
941                 TRANS_LOGE(TRANS_CTRL, "memcpy_s connInfo failed. connId=%{public}u", connId);
942                 (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
943                 return SOFTBUS_MEM_ERR;
944             }
945             (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
946             return SOFTBUS_OK;
947         }
948     }
949     (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
950     TRANS_LOGE(TRANS_INIT, "proxy conn node not found. connId=%{public}u", connId);
951     return SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND;
952 }
953 
CheckIsProxyAuthChannel(ConnectOption * connInfo)954 int32_t CheckIsProxyAuthChannel(ConnectOption *connInfo)
955 {
956     if (connInfo == NULL) {
957         TRANS_LOGW(TRANS_CTRL, "invalid param.");
958         return SOFTBUS_INVALID_PARAM;
959     }
960 
961     if (g_proxyConnectionList == NULL) {
962         TRANS_LOGE(TRANS_CTRL, "proxy connect list empty.");
963         return SOFTBUS_NO_INIT;
964     }
965 
966     if (SoftBusMutexLock(&g_proxyConnectionList->lock) != SOFTBUS_OK) {
967         TRANS_LOGE(TRANS_CTRL, "lock mutex fail.");
968         return SOFTBUS_LOCK_ERR;
969     }
970 
971     ProxyConnInfo *item = NULL;
972     LIST_FOR_EACH_ENTRY(item, &g_proxyConnectionList->list, ProxyConnInfo, node) {
973         if (memcmp(item->connInfo.bleOption.bleMac, connInfo->bleOption.bleMac,
974             sizeof(connInfo->bleOption.bleMac)) == 0 ||
975             memcmp(item->connInfo.bleOption.deviceIdHash, connInfo->bleOption.deviceIdHash,
976             SHORT_UDID_HASH_LEN) == 0) {
977             TRANS_LOGI(TRANS_CTRL, "auth channel type is ble");
978             (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
979             return SOFTBUS_OK;
980         } else if (memcmp(item->connInfo.brOption.brMac, connInfo->brOption.brMac,
981             sizeof(connInfo->brOption.brMac)) == 0) {
982             TRANS_LOGI(TRANS_CTRL, "auth channel type is br");
983             (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
984             return SOFTBUS_OK;
985         }
986     }
987     (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
988     TRANS_LOGE(TRANS_INIT, "proxy conn node not found.");
989     return SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND;
990 }