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