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_LOGI(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(ProxyConnInfo * conn,ProxyChannelInfo * chan,int32_t chanNewId)663 int32_t TransProxyConnExistProc(ProxyConnInfo *conn, ProxyChannelInfo *chan, int32_t chanNewId)
664 {
665 if (conn == NULL || 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 ConnectType type = conn->connInfo.type;
673 if (conn->state == PROXY_CHANNEL_STATUS_PYH_CONNECTING) {
674 ProxyChannelInfo channelInfo = {
675 .channelId = chanNewId,
676 .reqId = (int32_t)conn->requestId,
677 .isServer = -1,
678 .type = type,
679 .status = PROXY_CHANNEL_STATUS_PYH_CONNECTING,
680 .connId = 0
681 };
682
683 TransProxySpecialUpdateChanInfo(&channelInfo);
684 TRANS_LOGI(TRANS_CTRL, "reuse connection requestId=%{public}d", chan->reqId);
685 } else {
686 ProxyChannelInfo channelInfo = {
687 .channelId = chanNewId,
688 .reqId = -1,
689 .isServer = -1,
690 .type = type,
691 .status = PROXY_CHANNEL_STATUS_HANDSHAKEING,
692 .connId = conn->connId
693 };
694 TransProxySpecialUpdateChanInfo(&channelInfo);
695 if (TransAddConnRefByConnId(conn->connId, (bool)chan->isServer) != SOFTBUS_OK) {
696 TRANS_LOGE(TRANS_CTRL, "TransAddConnRefByConnId: connId=%{public}u err", conn->connId);
697 return SOFTBUS_TRANS_PROXY_CONN_ADD_REF_FAILED;
698 }
699 TransProxyPostHandshakeMsgToLoop(chanNewId);
700 }
701 return SOFTBUS_OK;
702 }
703
TransProxyConnectDevice(const ConnectOption * connInfo,uint32_t requestId)704 static int32_t TransProxyConnectDevice(const ConnectOption *connInfo, uint32_t requestId)
705 {
706 ConnectResult result;
707 result.OnConnectFailed = TransOnConnectFailed;
708 result.OnConnectSuccessed = TransOnConnectSucceed;
709 if (connInfo->type == CONNECT_BLE_DIRECT) {
710 return ConnBleDirectConnectDevice(connInfo, requestId, &result);
711 } else {
712 return ConnConnectDevice(connInfo, requestId, &result);
713 }
714 }
715
TransProxyOpenNewConnChannel(ListenerModule moduleId,const ConnectOption * connInfo,int32_t channelId)716 static int32_t TransProxyOpenNewConnChannel(ListenerModule moduleId, const ConnectOption *connInfo, int32_t channelId)
717 {
718 SoftbusHitraceStart(SOFTBUS_HITRACE_ID_VALID, (uint64_t)(channelId + ID_OFFSET));
719 TRANS_LOGI(TRANS_CTRL,
720 "SoftBusHiTraceChainBegin: set hiTraceId=%{public}" PRIu64, (uint64_t)(channelId + ID_OFFSET));
721 uint32_t requestId = ConnGetNewRequestId(MODULE_PROXY_CHANNEL);
722 ProxyChannelInfo channelInfo = {
723 .channelId = channelId,
724 .reqId = (int32_t)requestId,
725 .isServer = 0,
726 .type = CONNECT_TYPE_MAX,
727 .status = PROXY_CHANNEL_STATUS_PYH_CONNECTING,
728 .connId = 0
729 };
730 TransProxySpecialUpdateChanInfo(&channelInfo);
731
732 ProxyConnInfo *connChan = (ProxyConnInfo *)SoftBusCalloc(sizeof(ProxyConnInfo));
733 if (connChan == NULL) {
734 TRANS_LOGE(TRANS_CTRL, "connChan calloc failed");
735 TransProxyDelChanByChanId(channelId);
736 return SOFTBUS_MALLOC_ERR;
737 }
738 connChan->requestId = requestId;
739 connChan->state = PROXY_CHANNEL_STATUS_PYH_CONNECTING;
740 connChan->ref = 0;
741 connChan->isServerSide = false;
742
743 TRANS_LOGI(TRANS_CTRL, "Connect dev, channelId=%{public}d, requestId=%{public}u", channelId, requestId);
744 connChan->connInfo = (*connInfo);
745 if (connInfo->type == CONNECT_TCP) {
746 connChan->connInfo.socketOption.moduleId = moduleId;
747 }
748 if (TransAddConnItem(connChan) != SOFTBUS_OK) {
749 TRANS_LOGE(TRANS_CTRL, "conn add repeat");
750 SoftBusFree(connChan);
751 return SOFTBUS_TRANS_PROXY_CONN_REPEAT;
752 }
753 int32_t ret = TransProxyConnectDevice(&connChan->connInfo, requestId);
754 if (ret != SOFTBUS_OK) {
755 TRANS_LOGE(TRANS_CTRL, "connect device err");
756 TransDelConnByReqId(requestId);
757 TransProxyDelChanByChanId(channelId);
758 }
759 return ret;
760 }
761
TransReportStartConnectEvent(const AppInfo * appInfo,const ProxyChannelInfo * chan,int32_t channelId)762 static void TransReportStartConnectEvent(const AppInfo *appInfo, const ProxyChannelInfo *chan, int32_t channelId)
763 {
764 TransEventExtra extra = {
765 .peerNetworkId = NULL,
766 .calleePkg = NULL,
767 .callerPkg = NULL,
768 .socketName = appInfo->myData.sessionName,
769 .channelType = appInfo->appType == APP_TYPE_AUTH ? CHANNEL_TYPE_AUTH : CHANNEL_TYPE_PROXY,
770 .channelId = channelId,
771 .requestId = chan->reqId,
772 .linkType = chan->type
773 };
774 TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL, EVENT_STAGE_START_CONNECT, extra);
775 }
776
TransProxyOpenConnChannel(const AppInfo * appInfo,const ConnectOption * connInfo,int32_t * channelId)777 int32_t TransProxyOpenConnChannel(const AppInfo *appInfo, const ConnectOption *connInfo, int32_t *channelId)
778 {
779 if (appInfo == NULL || connInfo == NULL) {
780 TRANS_LOGE(TRANS_CTRL, "invalid param");
781 return SOFTBUS_INVALID_PARAM;
782 }
783 int32_t ret = SOFTBUS_ERR;
784 ProxyConnInfo conn;
785 int32_t chanNewId = GenerateChannelId(false);
786 if (chanNewId <= INVALID_CHANNEL_ID) {
787 TRANS_LOGE(TRANS_CTRL, "proxy channelId is invalid");
788 return SOFTBUS_TRANS_INVALID_CHANNEL_ID;
789 }
790 ProxyChannelInfo *chan = (ProxyChannelInfo *)SoftBusCalloc(sizeof(ProxyChannelInfo));
791 if (chan == NULL) {
792 ReleaseProxyChannelId(chanNewId);
793 TRANS_LOGE(TRANS_CTRL, "SoftBusCalloc fail");
794 return SOFTBUS_MALLOC_ERR;
795 }
796 chan->type = connInfo->type;
797 if (TransProxyCreateChanInfo(chan, chanNewId, appInfo) != SOFTBUS_OK) {
798 TRANS_LOGE(TRANS_CTRL, "TransProxyCreateChanInfo err");
799 ReleaseProxyChannelId(chanNewId);
800 (void)memset_s(chan->appInfo.sessionKey, sizeof(chan->appInfo.sessionKey), 0, sizeof(chan->appInfo.sessionKey));
801 SoftBusFree(chan);
802 return SOFTBUS_TRANS_PROXY_CREATE_CHANNEL_FAILED;
803 }
804 if (TransGetConn(connInfo, &conn, false) == SOFTBUS_OK) {
805 ret = TransProxyConnExistProc(&conn, chan, chanNewId);
806 if (ret == SOFTBUS_TRANS_PROXY_CONN_ADD_REF_FAILED) {
807 ret = TransProxyOpenNewConnChannel(PROXY, connInfo, chanNewId);
808 }
809 } else {
810 ret = TransProxyOpenNewConnChannel(PROXY, connInfo, chanNewId);
811 if ((ret == SOFTBUS_TRANS_PROXY_CONN_REPEAT) && (TransGetConn(connInfo, &conn, false) == SOFTBUS_OK)) {
812 ret = TransProxyConnExistProc(&conn, chan, chanNewId);
813 }
814 }
815 if (ret == SOFTBUS_OK) {
816 *channelId = chanNewId;
817 } else if (ret == SOFTBUS_TRANS_PROXY_CONN_ADD_REF_FAILED || ret == SOFTBUS_TRANS_PROXY_CONN_REPEAT) {
818 TransProxyDelChanByChanId(chanNewId);
819 }
820 TransReportStartConnectEvent(appInfo, chan, chanNewId);
821 return ret;
822 }
823
TransProxySendBadKeyMessage(ProxyMessage * msg,const AuthHandle * authHandle)824 static int32_t TransProxySendBadKeyMessage(ProxyMessage *msg, const AuthHandle *authHandle)
825 {
826 ProxyDataInfo dataInfo;
827 dataInfo.inData = (uint8_t *)msg->data;
828 dataInfo.inLen = (uint32_t)msg->dateLen;
829 dataInfo.outData = NULL;
830 dataInfo.outLen = 0;
831
832 msg->msgHead.type = (PROXYCHANNEL_MSG_TYPE_RESET & FOUR_BIT_MASK) | (VERSION << VERSION_SHIFT);
833 if (AuthCheckSessionKeyValidByAuthHandle(authHandle) == SOFTBUS_AUTH_SESSION_KEY_INVALID) {
834 TRANS_LOGE(TRANS_MSG, "ble single online, send renegotiate msg");
835 msg->msgHead.cipher |= AUTH_SINGLE_CIPHER;
836 } else {
837 msg->msgHead.cipher |= BAD_CIPHER;
838 }
839 TRANS_LOGW(TRANS_MSG, "send msg is bad key myChannelId=%{public}d, peerChannelId=%{public}d",
840 msg->msgHead.myId, msg->msgHead.peerId);
841
842 int32_t ret = PackPlaintextMessage(&msg->msgHead, &dataInfo);
843 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_MSG, "PackPlaintextMessage fail");
844
845 ret = TransProxyTransSendMsg(msg->connId, dataInfo.outData, dataInfo.outLen, CONN_HIGH, 0);
846 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_MSG, "send bad key buf fail");
847 return SOFTBUS_OK;
848 }
849
TransProxyOnDataReceived(uint32_t connectionId,ConnModule moduleId,int64_t seq,char * data,int32_t len)850 static void TransProxyOnDataReceived(uint32_t connectionId, ConnModule moduleId, int64_t seq, char *data, int32_t len)
851 {
852 ProxyMessage msg;
853
854 TRANS_LOGI(TRANS_CTRL, "recv data connId=%{public}u, moduleId=%{public}d, seq=%{public}" PRId64 ", len=%{public}d",
855 connectionId, moduleId, seq, len);
856 TRANS_CHECK_AND_RETURN_LOGE(data != NULL && moduleId == MODULE_PROXY_CHANNEL, TRANS_CTRL, "invalid param");
857 (void)memset_s(&msg, sizeof(ProxyMessage), 0, sizeof(ProxyMessage));
858 msg.connId = connectionId;
859
860 AuthHandle authHandle = { .authId = AUTH_INVALID_ID };
861 int32_t ret = TransProxyParseMessage((char *)data, len, &msg, &authHandle);
862 if (((ret == SOFTBUS_AUTH_NOT_FOUND) || (ret == SOFTBUS_DECRYPT_ERR)) &&
863 (msg.msgHead.type == PROXYCHANNEL_MSG_TYPE_HANDSHAKE)) {
864 TransReportBadKeyEvent(ret, connectionId, seq, len);
865 if (TransProxySendBadKeyMessage(&msg, &authHandle) != SOFTBUS_OK) {
866 TRANS_LOGE(TRANS_CTRL, "send bad key msg ret=%{public}d", ret);
867 return;
868 }
869 char peerBrMac[BT_MAC_LEN] = {0};
870 char udid[UDID_BUF_LEN] = {0};
871 if (GetBrMacFromConnInfo(connectionId, peerBrMac, BT_MAC_LEN) == SOFTBUS_OK) {
872 if (LnnGetUdidByBrMac(peerBrMac, udid, UDID_BUF_LEN) == SOFTBUS_OK) {
873 AuthRemoveDeviceKeyByUdid(udid);
874 }
875 }
876 }
877 if (ret != SOFTBUS_OK) {
878 TRANS_LOGE(TRANS_CTRL, "parse proxy msg ret=%{public}d", ret);
879 return;
880 }
881 TransProxyOnMessageReceived(&msg);
882 SoftBusFree(msg.data);
883 }
884
TransProxyTransInit(void)885 int32_t TransProxyTransInit(void)
886 {
887 ConnectCallback proxyCallback = { 0 };
888
889 proxyCallback.OnConnected = TransProxyOnConnected;
890 proxyCallback.OnDisconnected = TransProxyOnDisConnect;
891 proxyCallback.OnDataReceived = TransProxyOnDataReceived;
892 int32_t ret = ConnSetConnectCallback(MODULE_PROXY_CHANNEL, &proxyCallback);
893 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_INIT, "ConnSetConnectCallback fail");
894
895 g_proxyConnectionList = CreateSoftBusList();
896 if (g_proxyConnectionList == NULL) {
897 TRANS_LOGE(TRANS_INIT, "create observer list failed");
898 return SOFTBUS_MALLOC_ERR;
899 }
900
901 ret = TransProxyLoopInit();
902 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_INIT, "create loopInit fail");
903
904 ret = TransProxyPipelineInit();
905 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_INIT, "init proxy pipeline failed");
906
907 return SOFTBUS_OK;
908 }
909
TransProxyGetConnInfoByConnId(uint32_t connId,ConnectOption * connInfo)910 int32_t TransProxyGetConnInfoByConnId(uint32_t connId, ConnectOption *connInfo)
911 {
912 if (connInfo == NULL) {
913 TRANS_LOGW(TRANS_CTRL, "invalid param.");
914 return SOFTBUS_INVALID_PARAM;
915 }
916
917 if (g_proxyConnectionList == NULL) {
918 TRANS_LOGE(TRANS_CTRL, "proxy connect list empty.");
919 return SOFTBUS_NO_INIT;
920 }
921
922 if (SoftBusMutexLock(&g_proxyConnectionList->lock) != SOFTBUS_OK) {
923 TRANS_LOGE(TRANS_CTRL, "lock mutex fail.");
924 return SOFTBUS_LOCK_ERR;
925 }
926
927 ProxyConnInfo *item = NULL;
928 LIST_FOR_EACH_ENTRY(item, &g_proxyConnectionList->list, ProxyConnInfo, node) {
929 if (item->connId == connId) {
930 if (memcpy_s(connInfo, sizeof(ConnectOption), &(item->connInfo), sizeof(ConnectOption)) != EOK) {
931 TRANS_LOGE(TRANS_CTRL, "memcpy_s connInfo failed. connId=%{public}u", connId);
932 (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
933 return SOFTBUS_MEM_ERR;
934 }
935 (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
936 return SOFTBUS_OK;
937 }
938 }
939 (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
940 TRANS_LOGE(TRANS_INIT, "proxy conn node not found. connId=%{public}u", connId);
941 return SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND;
942 }
943
CheckIsProxyAuthChannel(ConnectOption * connInfo)944 int32_t CheckIsProxyAuthChannel(ConnectOption *connInfo)
945 {
946 if (connInfo == NULL) {
947 TRANS_LOGW(TRANS_CTRL, "invalid param.");
948 return SOFTBUS_INVALID_PARAM;
949 }
950
951 if (g_proxyConnectionList == NULL) {
952 TRANS_LOGE(TRANS_CTRL, "proxy connect list empty.");
953 return SOFTBUS_NO_INIT;
954 }
955
956 if (SoftBusMutexLock(&g_proxyConnectionList->lock) != SOFTBUS_OK) {
957 TRANS_LOGE(TRANS_CTRL, "lock mutex fail.");
958 return SOFTBUS_LOCK_ERR;
959 }
960
961 ProxyConnInfo *item = NULL;
962 LIST_FOR_EACH_ENTRY(item, &g_proxyConnectionList->list, ProxyConnInfo, node) {
963 if (memcmp(item->connInfo.bleOption.bleMac, connInfo->bleOption.bleMac,
964 sizeof(connInfo->bleOption.bleMac)) == 0 ||
965 memcmp(item->connInfo.bleOption.deviceIdHash, connInfo->bleOption.deviceIdHash,
966 SHORT_UDID_HASH_LEN) == 0) {
967 TRANS_LOGI(TRANS_CTRL, "auth channel type is ble");
968 (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
969 return SOFTBUS_OK;
970 } else if (memcmp(item->connInfo.brOption.brMac, connInfo->brOption.brMac,
971 sizeof(connInfo->brOption.brMac)) == 0) {
972 TRANS_LOGI(TRANS_CTRL, "auth channel typ is br");
973 (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
974 return SOFTBUS_OK;
975 }
976 }
977 (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
978 TRANS_LOGE(TRANS_INIT, "proxy conn node not found.");
979 return SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND;
980 }