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_network_manager.h"
21 #include "message_handler.h"
22 #include "softbus_adapter_mem.h"
23 #include "softbus_adapter_thread.h"
24 #include "softbus_base_listener.h"
25 #include "softbus_conn_interface.h"
26 #include "softbus_errcode.h"
27 #include "softbus_log.h"
28 #include "softbus_proxychannel_control.h"
29 #include "softbus_proxychannel_listener.h"
30 #include "softbus_proxychannel_manager.h"
31 #include "softbus_proxychannel_message.h"
32 #include "softbus_utils.h"
33
34 static SoftBusList *g_proxyConnectionList = NULL;
35 const char *g_transProxyLoopName = "transProxyLoopName";
36 SoftBusHandler g_transLoophandler = {0};
37 typedef enum {
38 LOOP_HANDSHAKE_MSG,
39 LOOP_DISCONNECT_MSG,
40 LOOP_OPENFAIL_MSG,
41 LOOP_OPENCLOSE_MSG,
42 LOOP_KEEPALIVE_MSG,
43 LOOP_RESETPEER_MSG,
44 } LoopMsg;
45
TransDelConnByReqId(uint32_t reqId)46 static int32_t TransDelConnByReqId(uint32_t reqId)
47 {
48 ProxyConnInfo *removeNode = NULL;
49 ProxyConnInfo *tmpNode = NULL;
50
51 if (g_proxyConnectionList == NULL) {
52 return SOFTBUS_ERR;
53 }
54
55 if (SoftBusMutexLock(&g_proxyConnectionList->lock) != 0) {
56 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
57 return SOFTBUS_ERR;
58 }
59
60 LIST_FOR_EACH_ENTRY_SAFE(removeNode, tmpNode, &g_proxyConnectionList->list, ProxyConnInfo, node) {
61 if (removeNode->requestId == reqId && removeNode->state == PROXY_CHANNEL_STATUS_PYH_CONNECTING) {
62 ListDelete(&(removeNode->node));
63 SoftBusFree(removeNode);
64 g_proxyConnectionList->cnt--;
65 break;
66 }
67 }
68 (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
69 return SOFTBUS_OK;
70 }
71
TransDelConnByConnId(uint32_t connId)72 void TransDelConnByConnId(uint32_t connId)
73 {
74 ProxyConnInfo *removeNode = NULL;
75 ProxyConnInfo *tmpNode = NULL;
76
77 if (g_proxyConnectionList == NULL) {
78 return;
79 }
80
81 if (SoftBusMutexLock(&g_proxyConnectionList->lock) != 0) {
82 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
83 return;
84 }
85
86 LIST_FOR_EACH_ENTRY_SAFE(removeNode, tmpNode, &g_proxyConnectionList->list, ProxyConnInfo, node) {
87 if (removeNode->connId == connId) {
88 ListDelete(&(removeNode->node));
89 SoftBusFree(removeNode);
90 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "del conn=%d item.", connId);
91 g_proxyConnectionList->cnt--;
92 break;
93 }
94 }
95 (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
96 return;
97 }
98
TransDecConnRefByConnId(uint32_t connId)99 int32_t TransDecConnRefByConnId(uint32_t connId)
100 {
101 ProxyConnInfo *removeNode = NULL;
102 ProxyConnInfo *tmpNode = NULL;
103
104 if (g_proxyConnectionList == NULL) {
105 return SOFTBUS_ERR;
106 }
107
108 if (SoftBusMutexLock(&g_proxyConnectionList->lock) != 0) {
109 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
110 return SOFTBUS_ERR;
111 }
112
113 LIST_FOR_EACH_ENTRY_SAFE(removeNode, tmpNode, &g_proxyConnectionList->list, ProxyConnInfo, node) {
114 if (removeNode->connId == connId) {
115 removeNode->ref--;
116 if (removeNode->ref <= 0) {
117 ListDelete(&(removeNode->node));
118 SoftBusFree(removeNode);
119 g_proxyConnectionList->cnt--;
120 (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
121 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "conn=%d ref is 0.", connId);
122 return SOFTBUS_OK;
123 } else {
124 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "conn=%d removeNode->ref %d", connId, removeNode->ref);
125 (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
126 return SOFTBUS_ERR;
127 }
128 }
129 }
130
131 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "not find conn=%d item", connId);
132 (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
133 return SOFTBUS_OK;
134 }
135
TransAddConnRefByConnId(uint32_t connId)136 int32_t TransAddConnRefByConnId(uint32_t connId)
137 {
138 ProxyConnInfo *item = NULL;
139
140 if (g_proxyConnectionList == NULL) {
141 return SOFTBUS_ERR;
142 }
143
144 if (SoftBusMutexLock(&g_proxyConnectionList->lock) != 0) {
145 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
146 return SOFTBUS_ERR;
147 }
148
149 LIST_FOR_EACH_ENTRY(item, &g_proxyConnectionList->list, ProxyConnInfo, node) {
150 if (item->connId == connId) {
151 item->ref++;
152 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "add conn=%d ref %d.", connId, item->ref);
153 break;
154 }
155 }
156 (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
157 return SOFTBUS_OK;
158 }
159
TransProxyLoopMsgHandler(SoftBusMessage * msg)160 static void TransProxyLoopMsgHandler(SoftBusMessage *msg)
161 {
162 int32_t chanId;
163 uint32_t connectionId;
164 ProxyChannelInfo *chan = NULL;
165
166 if (msg == NULL) {
167 return;
168 }
169 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "trans loop process msg type %d", msg->what);
170 switch (msg->what) {
171 case LOOP_HANDSHAKE_MSG:
172 chanId = *((int32_t *)msg->obj);
173 TransProxyOpenProxyChannelSuccess(chanId);
174 break;
175 case LOOP_DISCONNECT_MSG:
176 connectionId = (uint32_t)msg->arg2;
177 TransProxyCloseConnChannel(connectionId);
178 break;
179 case LOOP_OPENFAIL_MSG:
180 chan = (ProxyChannelInfo *)msg->obj;
181 if (chan == NULL) {
182 return;
183 }
184 TransProxyOpenProxyChannelFail(chan->channelId, &(chan->appInfo), (int32_t)msg->arg1);
185 break;
186 case LOOP_OPENCLOSE_MSG:
187 chan = (ProxyChannelInfo *)msg->obj;
188 if (chan == NULL) {
189 return;
190 }
191 OnProxyChannelClosed(chan->channelId, &(chan->appInfo));
192 break;
193 case LOOP_KEEPALIVE_MSG:
194 chan = (ProxyChannelInfo *)msg->obj;
195 if (chan == NULL) {
196 return;
197 }
198 TransProxyKeepalive(chan->connId, chan);
199 break;
200 case LOOP_RESETPEER_MSG:
201 chan = (ProxyChannelInfo *)msg->obj;
202 if (chan == NULL) {
203 return;
204 }
205 TransProxyResetPeer(chan);
206 break;
207 default:
208 break;
209 }
210 }
211
TransProxyFreeLoopMsg(SoftBusMessage * msg)212 void TransProxyFreeLoopMsg(SoftBusMessage *msg)
213 {
214 if (msg != NULL) {
215 if (msg->obj != NULL) {
216 SoftBusFree(msg->obj);
217 }
218 SoftBusFree((void *)msg);
219 }
220 }
TransProxyCreateLoopMsg(int32_t what,uint64_t arg1,uint64_t arg2,char * data)221 static SoftBusMessage *TransProxyCreateLoopMsg(int32_t what, uint64_t arg1, uint64_t arg2, char *data)
222 {
223 SoftBusMessage *msg = (SoftBusMessage *)SoftBusCalloc(sizeof(SoftBusMessage));
224 if (msg == NULL) {
225 return NULL;
226 }
227 msg->what = what;
228 msg->arg1 = arg1;
229 msg->arg2 = arg2;
230 msg->handler = &g_transLoophandler;
231 msg->FreeMessage = TransProxyFreeLoopMsg;
232 msg->obj = (void *)data;
233 return msg;
234 }
235
TransProxyPostResetPeerMsgToLoop(const ProxyChannelInfo * chan)236 void TransProxyPostResetPeerMsgToLoop(const ProxyChannelInfo *chan)
237 {
238 SoftBusMessage *msg = TransProxyCreateLoopMsg(LOOP_RESETPEER_MSG, 0, 0, (char *)chan);
239 if (msg == NULL) {
240 if (chan != NULL) {
241 SoftBusFree((void *)chan);
242 }
243 return;
244 }
245 g_transLoophandler.looper->PostMessage(g_transLoophandler.looper, msg);
246 return;
247 }
248
TransProxyPostHandshakeMsgToLoop(int32_t chanId)249 void TransProxyPostHandshakeMsgToLoop(int32_t chanId)
250 {
251 int32_t *chanIdMsg = (int32_t *)SoftBusCalloc(sizeof(int32_t));
252 if (chanIdMsg == NULL) {
253 return;
254 }
255 *chanIdMsg = chanId;
256 SoftBusMessage *msg = TransProxyCreateLoopMsg(LOOP_HANDSHAKE_MSG, 0, 0, (char *)chanIdMsg);
257 if (msg == NULL) {
258 SoftBusFree((void *)chanIdMsg);
259 return;
260 }
261 g_transLoophandler.looper->PostMessage(g_transLoophandler.looper, msg);
262 return;
263 }
264
TransProxyPostDisConnectMsgToLoop(uint32_t connId)265 void TransProxyPostDisConnectMsgToLoop(uint32_t connId)
266 {
267 SoftBusMessage *msg = TransProxyCreateLoopMsg(LOOP_DISCONNECT_MSG, 0, connId, NULL);
268 if (msg == NULL) {
269 return;
270 }
271 g_transLoophandler.looper->PostMessage(g_transLoophandler.looper, msg);
272 return;
273 }
274
TransProxyPostKeepAliveMsgToLoop(const ProxyChannelInfo * chan)275 void TransProxyPostKeepAliveMsgToLoop(const ProxyChannelInfo *chan)
276 {
277 SoftBusMessage *msg = TransProxyCreateLoopMsg(LOOP_KEEPALIVE_MSG, 0, 0, (char *)chan);
278 if (msg == NULL) {
279 if (chan != NULL) {
280 SoftBusFree((void *)chan);
281 }
282 return;
283 }
284 g_transLoophandler.looper->PostMessage(g_transLoophandler.looper, msg);
285 return;
286 }
287
TransProxyPostOpenFailMsgToLoop(const ProxyChannelInfo * chan,int32_t errCode)288 void TransProxyPostOpenFailMsgToLoop(const ProxyChannelInfo *chan, int32_t errCode)
289 {
290 SoftBusMessage *msg = TransProxyCreateLoopMsg(LOOP_OPENFAIL_MSG, errCode, 0, (char *)chan);
291 if (msg == NULL) {
292 if (chan != NULL) {
293 SoftBusFree((void *)chan);
294 }
295 return;
296 }
297 g_transLoophandler.looper->PostMessage(g_transLoophandler.looper, msg);
298 return;
299 }
300
TransProxyPostOpenClosedMsgToLoop(const ProxyChannelInfo * chan)301 void TransProxyPostOpenClosedMsgToLoop(const ProxyChannelInfo *chan)
302 {
303 SoftBusMessage *msg = TransProxyCreateLoopMsg(LOOP_OPENCLOSE_MSG, 0, 0, (char *)chan);
304 if (msg == NULL) {
305 if (chan != NULL) {
306 SoftBusFree((void *)chan);
307 }
308 return;
309 }
310 g_transLoophandler.looper->PostMessage(g_transLoophandler.looper, msg);
311 return;
312 }
313
TransProxyLoopInit(void)314 static int32_t TransProxyLoopInit(void)
315 {
316 g_transLoophandler.name = (char *)g_transProxyLoopName;
317 g_transLoophandler.looper = GetLooper(LOOP_TYPE_DEFAULT);
318 if (g_transLoophandler.looper == NULL) {
319 return SOFTBUS_ERR;
320 }
321 g_transLoophandler.HandleMessage = TransProxyLoopMsgHandler;
322 return SOFTBUS_OK;
323 }
324
TransProxyTransSendMsg(uint32_t connectionId,uint8_t * buf,uint32_t len,int32_t priority,int32_t pid)325 int32_t TransProxyTransSendMsg(uint32_t connectionId, uint8_t *buf, uint32_t len, int32_t priority, int32_t pid)
326 {
327 ConnPostData data = {0};
328 static uint64_t seq = 1;
329 int32_t ret;
330
331 data.module = MODULE_PROXY_CHANNEL;
332 data.seq = seq++;
333 data.flag = priority;
334 data.pid = pid;
335 data.len = len;
336 data.buf = (char *)buf;
337 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO,
338 "send buf connid %d len %u seq %" PRIu64 " pri %d pid %d", connectionId, len, data.seq, priority, pid);
339 ret = ConnPostBytes(connectionId, &data);
340 if (ret < 0) {
341 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "conn send buf fail %d", ret);
342 return ret;
343 }
344 return SOFTBUS_OK;
345 }
346
TransProxyOnConnected(uint32_t connId,const ConnectionInfo * connInfo)347 static void TransProxyOnConnected(uint32_t connId, const ConnectionInfo *connInfo)
348 {
349 (void)connInfo;
350 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "connect enabled, connId = %u", connId);
351 return;
352 }
353
TransProxyOnDisConnect(uint32_t connId,const ConnectionInfo * connInfo)354 static void TransProxyOnDisConnect(uint32_t connId, const ConnectionInfo *connInfo)
355 {
356 (void)connInfo;
357 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "connect disabled, id = %u", connId);
358 TransProxyDelByConnId(connId);
359 TransDelConnByConnId(connId);
360 return;
361 }
362
TransAddConnItem(ProxyConnInfo * chan)363 int32_t TransAddConnItem(ProxyConnInfo *chan)
364 {
365 ProxyConnInfo *item = NULL;
366 ProxyConnInfo *tmpItem = NULL;
367
368 if (g_proxyConnectionList == NULL) {
369 return SOFTBUS_ERR;
370 }
371
372 if (SoftBusMutexLock(&g_proxyConnectionList->lock) != 0) {
373 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
374 return SOFTBUS_ERR;
375 }
376
377 LIST_FOR_EACH_ENTRY_SAFE(item, tmpItem, &g_proxyConnectionList->list, ProxyConnInfo, node) {
378 if (strcmp(item->connInfo.brOption.brMac, chan->connInfo.brOption.brMac) == 0) {
379 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "conn ref = %d", item->ref);
380 (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
381 if (item->state == PROXY_CHANNEL_STATUS_PYH_CONNECTED) {
382 TransProxyChanProcessByReqId((int32_t)chan->requestId, item->connId);
383 }
384 return SOFTBUS_ERR;
385 }
386 }
387 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "conn ref = %d", item->ref);
388 ListAdd(&(g_proxyConnectionList->list), &(chan->node));
389 g_proxyConnectionList->cnt++;
390 (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
391 return SOFTBUS_OK;
392 }
393
TransCreateConnByConnId(uint32_t connId)394 void TransCreateConnByConnId(uint32_t connId)
395 {
396 ProxyConnInfo *item = NULL;
397 ProxyConnInfo *tmpNode = NULL;
398 ConnectionInfo info = {0};
399
400 if (g_proxyConnectionList == NULL) {
401 return;
402 }
403
404 if (ConnGetConnectionInfo(connId, &info) != SOFTBUS_OK) {
405 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "CreateConn get conn info fail %d", connId);
406 return;
407 }
408
409 if (SoftBusMutexLock(&g_proxyConnectionList->lock) != 0) {
410 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
411 return;
412 }
413 LIST_FOR_EACH_ENTRY_SAFE(item, tmpNode, &g_proxyConnectionList->list, ProxyConnInfo, node) {
414 if (item->connId == connId) {
415 item->ref++;
416 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "repeat conn ref = %d", item->ref);
417 (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
418 return;
419 }
420 }
421
422 item = (ProxyConnInfo *)SoftBusCalloc(sizeof(ProxyConnInfo));
423 if (item == NULL) {
424 (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
425 return;
426 }
427 item->ref++;
428 item->state = PROXY_CHANNEL_STATUS_PYH_CONNECTED;
429 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "create conn ref = %d", item->ref);
430 item->connId = connId;
431 if (memcpy_s(&(item->connInfo), sizeof(ConnectOption), &info, sizeof(ConnectOption)) != EOK) {
432 SoftBusFree(item);
433 SoftBusMutexUnlock(&g_proxyConnectionList->lock);
434 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "memcpy_s failed.");
435 return;
436 }
437 ListAdd(&(g_proxyConnectionList->list), &(item->node));
438 g_proxyConnectionList->cnt++;
439 (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
440 return;
441 }
442
TransGetConn(const ConnectOption * connInfo,ProxyConnInfo * proxyConn)443 static int32_t TransGetConn(const ConnectOption *connInfo, ProxyConnInfo *proxyConn)
444 {
445 ProxyConnInfo *item = NULL;
446
447 if (g_proxyConnectionList == NULL) {
448 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "proxy connection list not inited!");
449 return SOFTBUS_ERR;
450 }
451
452 if (connInfo == NULL || proxyConn == NULL) {
453 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "invalid para in trans get conn.");
454 return SOFTBUS_INVALID_PARAM;
455 }
456
457 if (SoftBusMutexLock(&g_proxyConnectionList->lock) != 0) {
458 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
459 return SOFTBUS_ERR;
460 }
461
462 bool find = false;
463 LIST_FOR_EACH_ENTRY(item, &g_proxyConnectionList->list, ProxyConnInfo, node) {
464 if (item->connInfo.type != connInfo->type) {
465 continue;
466 }
467 switch (connInfo->type) {
468 case CONNECT_TCP: {
469 if (connInfo->socketOption.protocol == item->connInfo.socketOption.protocol &&
470 strcmp(connInfo->socketOption.addr, item->connInfo.socketOption.addr) == 0 &&
471 connInfo->socketOption.port == item->connInfo.socketOption.port) {
472 find = true;
473 }
474 break;
475 }
476 case CONNECT_BR: {
477 if (strcmp(connInfo->brOption.brMac, item->connInfo.brOption.brMac) == 0) {
478 find = true;
479 }
480 break;
481 }
482 case CONNECT_BLE:
483 if (strcmp(connInfo->bleOption.bleMac, item->connInfo.bleOption.bleMac) == 0) {
484 find = true;
485 }
486 break;
487 default:
488 break;
489 }
490 if (find == true) {
491 (void)memcpy_s(proxyConn, sizeof(ProxyConnInfo), item, sizeof(ProxyConnInfo));
492 (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
493 return SOFTBUS_OK;
494 }
495 }
496 (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
497 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "can not find proxy conn in list.");
498 return SOFTBUS_ERR;
499 }
500
TransSetConnStateByReqId(uint32_t reqId,uint32_t connId,uint32_t state)501 void TransSetConnStateByReqId(uint32_t reqId, uint32_t connId, uint32_t state)
502 {
503 ProxyConnInfo *getNode = NULL;
504
505 if (g_proxyConnectionList == NULL) {
506 return;
507 }
508
509 if (SoftBusMutexLock(&g_proxyConnectionList->lock) != 0) {
510 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
511 return;
512 }
513
514 LIST_FOR_EACH_ENTRY(getNode, &g_proxyConnectionList->list, ProxyConnInfo, node) {
515 if (getNode->requestId == reqId && getNode->state == PROXY_CHANNEL_STATUS_PYH_CONNECTING) {
516 getNode->state = state;
517 getNode->connId = connId;
518 getNode->requestId = 0;
519 (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
520 return;
521 }
522 }
523 (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
524 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR,
525 "can not find proxy conn when set conn state. reqid[%d] connid[%d]", reqId, connId);
526 (void)ConnDisconnectDevice(connId);
527 }
528
TransOnConnectSuccessed(uint32_t requestId,uint32_t connectionId,const ConnectionInfo * connInfo)529 static void TransOnConnectSuccessed(uint32_t requestId, uint32_t connectionId, const ConnectionInfo *connInfo)
530 {
531 (void)connInfo;
532 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO,
533 "Connect Successe reqid %d, connectionId %d", requestId, connectionId);
534 TransSetConnStateByReqId(requestId, connectionId, PROXY_CHANNEL_STATUS_PYH_CONNECTED);
535 TransProxyChanProcessByReqId((int32_t)requestId, connectionId);
536 }
537
TransOnConnectFailed(uint32_t requestId,int32_t reason)538 static void TransOnConnectFailed(uint32_t requestId, int32_t reason)
539 {
540 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "Connect fail id %u, reason %d", requestId, reason);
541 if (TransDelConnByReqId(requestId) != SOFTBUS_OK) {
542 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "Connect fail del reqid %u fail", requestId);
543 }
544
545 TransProxyDelChanByReqId((int32_t)requestId);
546 }
547
TransProxyCloseConnChannel(uint32_t connectionId)548 int32_t TransProxyCloseConnChannel(uint32_t connectionId)
549 {
550 if (TransDecConnRefByConnId(connectionId) == SOFTBUS_OK) {
551 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "disconnect device connid %d", connectionId);
552 // BR don't disconnect
553 (void)ConnDisconnectDevice(connectionId);
554 }
555 return SOFTBUS_OK;
556 }
557
TransProxyCloseConnChannelReset(uint32_t connectionId,bool isDisconnect)558 int32_t TransProxyCloseConnChannelReset(uint32_t connectionId, bool isDisconnect)
559 {
560 if (TransDecConnRefByConnId(connectionId) == SOFTBUS_OK) {
561 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "reset(%d) disconnect device connid %d",
562 isDisconnect, connectionId);
563 if (isDisconnect) {
564 (void)ConnDisconnectDevice(connectionId);
565 }
566 }
567 return SOFTBUS_OK;
568 }
569
TransProxyConnExistProc(ProxyConnInfo * conn,const AppInfo * appInfo,int32_t chanNewId)570 int32_t TransProxyConnExistProc(ProxyConnInfo *conn, const AppInfo *appInfo, int32_t chanNewId)
571 {
572 ProxyChannelInfo *chan = (ProxyChannelInfo *)SoftBusCalloc(sizeof(ProxyChannelInfo));
573 if (chan == NULL) {
574 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "SoftBusCalloc fail");
575 return SOFTBUS_ERR;
576 }
577 chan->type = conn->connInfo.type;
578 if (conn->state == PROXY_CHANNEL_STATUS_PYH_CONNECTING) {
579 chan->reqId = (int32_t)conn->requestId;
580 chan->status = PROXY_CHANNEL_STATUS_PYH_CONNECTING;
581 if (TransProxyCreateChanInfo(chan, chanNewId, appInfo) != SOFTBUS_OK) {
582 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "TransProxyCreateChanInfo err");
583 SoftBusFree(chan);
584 return SOFTBUS_ERR;
585 }
586 } else {
587 chan->connId = conn->connId;
588 chan->status = PROXY_CHANNEL_STATUS_HANDSHAKEING;
589 if (TransProxyCreateChanInfo(chan, chanNewId, appInfo) != SOFTBUS_OK) {
590 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "TransProxyCreateChanInfo err");
591 SoftBusFree(chan);
592 return SOFTBUS_ERR;
593 }
594 TransAddConnRefByConnId(conn->connId);
595 TransProxyPostHandshakeMsgToLoop(chanNewId);
596 }
597 return SOFTBUS_OK;
598 }
599
TransProxyOpenNewConnChannel(ListenerModule moduleId,const AppInfo * appInfo,const ConnectOption * connInfo,int32_t channelId)600 static int32_t TransProxyOpenNewConnChannel(
601 ListenerModule moduleId, const AppInfo *appInfo, const ConnectOption *connInfo, int32_t channelId)
602 {
603 ProxyChannelInfo *chan = (ProxyChannelInfo *)SoftBusCalloc(sizeof(ProxyChannelInfo));
604 if (chan == NULL) {
605 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "SoftBusCalloc fail");
606 return SOFTBUS_ERR;
607 }
608 uint32_t reqId = ConnGetNewRequestId(MODULE_PROXY_CHANNEL);
609 chan->reqId = (int32_t)reqId;
610 chan->isServer = 0;
611 chan->status = PROXY_CHANNEL_STATUS_PYH_CONNECTING;
612 chan->type = connInfo->type;
613 if (TransProxyCreateChanInfo(chan, channelId, appInfo) != SOFTBUS_OK) {
614 SoftBusFree(chan);
615 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "TransProxyCreateChanInfo err");
616 return SOFTBUS_ERR;
617 }
618
619 ProxyConnInfo *connChan = (ProxyConnInfo *)SoftBusCalloc(sizeof(ProxyConnInfo));
620 if (connChan == NULL) {
621 TransProxyDelChanByChanId(channelId);
622 return SOFTBUS_ERR;
623 }
624 connChan->requestId = reqId;
625 connChan->state = PROXY_CHANNEL_STATUS_PYH_CONNECTING;
626
627 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "Connect dev reqid %d", reqId);
628 (void)memcpy_s(&(connChan->connInfo), sizeof(ConnectOption), connInfo, sizeof(ConnectOption));
629 connChan->connInfo.socketOption.moduleId = moduleId;
630 if (TransAddConnItem(connChan) != SOFTBUS_OK) {
631 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "conn add repeat");
632 SoftBusFree(connChan);
633 return SOFTBUS_OK;
634 }
635 ConnectResult result;
636 result.OnConnectFailed = TransOnConnectFailed;
637 result.OnConnectSuccessed = TransOnConnectSuccessed;
638 int32_t ret = ConnConnectDevice(&(connChan->connInfo), reqId, &result);
639 if (ret != SOFTBUS_OK) {
640 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "connect device err");
641 TransDelConnByReqId(reqId);
642 TransProxyDelChanByChanId(channelId);
643 }
644 return ret;
645 }
646
TransProxyOpenConnChannel(const AppInfo * appInfo,const ConnectOption * connInfo,int32_t * channelId)647 int32_t TransProxyOpenConnChannel(const AppInfo *appInfo, const ConnectOption *connInfo, int32_t *channelId)
648 {
649 ProxyConnInfo conn;
650 int32_t chanNewId = TransProxyGetNewMyId();
651 *channelId = chanNewId;
652 if (TransGetConn(connInfo, &conn) == SOFTBUS_OK) {
653 return TransProxyConnExistProc(&conn, appInfo, chanNewId);
654 } else {
655 ListenerModule module = PROXY;
656 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "%s:get listener module %d!", __func__, module);
657 return TransProxyOpenNewConnChannel(module, appInfo, connInfo, chanNewId);
658 }
659 }
660
TransProxyOnDataReceived(uint32_t connectionId,ConnModule moduleId,int64_t seq,char * data,int32_t len)661 static void TransProxyOnDataReceived(uint32_t connectionId, ConnModule moduleId,
662 int64_t seq, char *data, int32_t len)
663 {
664 ProxyMessage msg;
665
666 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO,
667 "data recv connid :%u, moduleId %d, seq : %" PRId64 " len %d", connectionId, moduleId, seq, len);
668 if (data == NULL) {
669 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "invalid param");
670 return;
671 }
672 if (moduleId != MODULE_PROXY_CHANNEL) {
673 return;
674 }
675 (void)memset_s(&msg, sizeof(ProxyMessage), 0, sizeof(ProxyMessage));
676 msg.connId = connectionId;
677 if (TransProxyParseMessage(data, len, &msg) != SOFTBUS_OK) {
678 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "parse proxy msg err");
679 return;
680 }
681 if (msg.msgHead.type != PROXYCHANNEL_MSG_TYPE_NORMAL) {
682 AnonyPacketPrintout(SOFTBUS_LOG_TRAN, "TransProxyonMessageReceived, msg->data: ", msg.data, msg.dateLen);
683 }
684 TransProxyonMessageReceived(&msg);
685 if (msg.msgHead.cipher & ENCRYPTED) {
686 SoftBusFree(msg.data);
687 }
688 }
689
TransProxyTransInit(void)690 int32_t TransProxyTransInit(void)
691 {
692 ConnectCallback proxyCallback = {0};
693
694 proxyCallback.OnConnected = TransProxyOnConnected;
695 proxyCallback.OnDisconnected = TransProxyOnDisConnect;
696 proxyCallback.OnDataReceived = TransProxyOnDataReceived;
697 if (ConnSetConnectCallback(MODULE_PROXY_CHANNEL, &proxyCallback) != SOFTBUS_OK) {
698 return SOFTBUS_ERR;
699 }
700
701 g_proxyConnectionList = CreateSoftBusList();
702 if (g_proxyConnectionList == NULL) {
703 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "create observer list failed");
704 return SOFTBUS_ERR;
705 }
706 if (TransProxyLoopInit() != SOFTBUS_OK) {
707 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "create loopInit fail");
708 return SOFTBUS_ERR;
709 }
710 return SOFTBUS_OK;
711 }
712
TransProxyGetConnInfoByConnId(uint32_t connId,ConnectOption * connInfo)713 int32_t TransProxyGetConnInfoByConnId(uint32_t connId, ConnectOption *connInfo)
714 {
715 if (connInfo == NULL) {
716 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "%s invalid param.", __func__);
717 return SOFTBUS_ERR;
718 }
719
720 if (g_proxyConnectionList == NULL) {
721 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "proxy connect list empty.");
722 return SOFTBUS_ERR;
723 }
724
725 if (SoftBusMutexLock(&g_proxyConnectionList->lock) != SOFTBUS_OK) {
726 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock mutex fail.");
727 return SOFTBUS_ERR;
728 }
729
730 ProxyConnInfo *item = NULL;
731 LIST_FOR_EACH_ENTRY(item, &g_proxyConnectionList->list, ProxyConnInfo, node) {
732 if (item->connId == connId) {
733 if (memcpy_s(connInfo, sizeof(ConnectOption), &(item->connInfo), sizeof(ConnectOption)) != EOK) {
734 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "id=%u proxy connoption memcpy failed.", connId);
735 (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
736 return SOFTBUS_ERR;
737 }
738 (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
739 return SOFTBUS_OK;
740 }
741 }
742 (void)SoftBusMutexUnlock(&g_proxyConnectionList->lock);
743 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "id=%u proxy conn node not found.", connId);
744 return SOFTBUS_ERR;
745 }
746
747