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 #include "softbus_proxychannel_manager.h"
16
17 #include <securec.h>
18 #include <string.h>
19
20 #include "auth_interface.h"
21 #include "bus_center_info_key.h"
22 #include "bus_center_manager.h"
23 #include "common_list.h"
24 #include "softbus_adapter_crypto.h"
25 #include "softbus_adapter_mem.h"
26 #include "softbus_adapter_thread.h"
27 #include "softbus_conn_interface.h"
28 #include "softbus_errcode.h"
29 #include "softbus_feature_config.h"
30 #include "softbus_log.h"
31 #include "softbus_proxychannel_callback.h"
32 #include "softbus_proxychannel_control.h"
33 #include "softbus_proxychannel_listener.h"
34 #include "softbus_proxychannel_message.h"
35 #include "softbus_proxychannel_session.h"
36 #include "softbus_proxychannel_transceiver.h"
37 #include "softbus_utils.h"
38 #include "trans_channel_limit.h"
39 #include "trans_pending_pkt.h"
40
41 #define PROXY_CHANNEL_CONTROL_TIMEOUT 19
42 #define PROXY_CHANNEL_BT_IDLE_TIMEOUT 240 // 4min
43 #define PROXY_CHANNEL_IDLE_TIMEOUT 15 // 10800 = 3 hour
44 #define PROXY_CHANNEL_TCP_IDLE_TIMEOUT 43200 // tcp 24 hour
45 #define PROXY_CHANNEL_CLIENT 0
46 #define PROXY_CHANNEL_SERVER 1
47 static SoftBusList *g_proxyChannelList = NULL;
48 static SoftBusMutex g_myIdLock;
49 static uint32_t g_authMaxByteBufSize;
50 static uint32_t g_authMaxMessageBufSize;
51
MyIdIsValid(int16_t myId)52 static int32_t MyIdIsValid(int16_t myId)
53 {
54 ProxyChannelInfo *item = NULL;
55
56 if (g_proxyChannelList == NULL) {
57 return SOFTBUS_ERR;
58 }
59
60 if (SoftBusMutexLock(&g_proxyChannelList->lock) != 0) {
61 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
62 return SOFTBUS_ERR;
63 }
64
65 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
66 if (item->myId == myId) {
67 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
68 return SOFTBUS_ERR;
69 }
70 }
71 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
72 return SOFTBUS_OK;
73 }
74
IsLittleEndianCPU(void)75 static bool IsLittleEndianCPU(void)
76 {
77 #define CHECK_NUM 0x0100
78 #define CHECK_NUM_HIGH 0x01
79
80 uint16_t num = CHECK_NUM;
81
82 if (*((char *)&num) == CHECK_NUM_HIGH) {
83 return false;
84 }
85 return true;
86 }
87
EndianSwap16(uint16_t num)88 static uint16_t EndianSwap16(uint16_t num)
89 {
90 #define HIGH_MASK 0xFF00
91 #define LOW_MASK 0x00FF
92 #define ENDIAN_SHIFT 8
93
94 if (!IsLittleEndianCPU()) {
95 return num;
96 }
97 return (((num & HIGH_MASK) >> ENDIAN_SHIFT) | ((num & LOW_MASK) << ENDIAN_SHIFT));
98 }
99
TransProxyGetNewMyId(void)100 int16_t TransProxyGetNewMyId(void)
101 {
102 #define MYID_MAX_NUM 100
103 static uint16_t myId = 0;
104 int32_t cnt = MYID_MAX_NUM;
105 if (SoftBusMutexLock(&g_myIdLock) != 0) {
106 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
107 return SOFTBUS_ERR;
108 }
109
110 while (cnt) {
111 cnt--;
112 myId++;
113 uint16_t ret = myId % MYID_MAX_NUM + 1;
114 ret = EndianSwap16(ret);
115 if (MyIdIsValid((int16_t)ret) == SOFTBUS_OK) {
116 SoftBusMutexUnlock(&g_myIdLock);
117 return (int16_t)ret;
118 }
119 }
120 SoftBusMutexUnlock(&g_myIdLock);
121 return INVALID_CHANNEL_ID;
122 }
123
ChanIsEqual(ProxyChannelInfo * a,ProxyChannelInfo * b)124 static int32_t ChanIsEqual(ProxyChannelInfo *a, ProxyChannelInfo *b)
125 {
126 if ((a->myId == b->myId) &&
127 (a->peerId == b->peerId) &&
128 (strncmp(a->identity, b->identity, sizeof(a->identity)) == 0)) {
129 return SOFTBUS_OK;
130 }
131 return SOFTBUS_ERR;
132 }
133
ResetChanIsEqual(int status,ProxyChannelInfo * a,ProxyChannelInfo * b)134 static int32_t ResetChanIsEqual(int status, ProxyChannelInfo *a, ProxyChannelInfo *b)
135 {
136 if (status == PROXY_CHANNEL_STATUS_HANDSHAKEING) {
137 if ((a->myId == b->myId) &&
138 (strncmp(a->identity, b->identity, sizeof(a->identity)) == 0)) {
139 return SOFTBUS_OK;
140 }
141 }
142
143 if ((a->myId == b->myId) &&
144 (a->peerId == b->peerId) &&
145 (strncmp(a->identity, b->identity, sizeof(a->identity)) == 0)) {
146 return SOFTBUS_OK;
147 }
148 return SOFTBUS_ERR;
149 }
150
TransProxyGetAppInfoType(int16_t myId,const char * identity)151 int32_t TransProxyGetAppInfoType(int16_t myId, const char *identity)
152 {
153 if (SoftBusMutexLock(&g_proxyChannelList->lock) != 0) {
154 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
155 return SOFTBUS_ERR;
156 }
157
158 AppType appType;
159 ProxyChannelInfo *item = NULL;
160 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
161 if ((item->myId == myId) && (strcmp(item->identity, identity) == 0)) {
162 appType = item->appInfo.appType;
163 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
164 return appType;
165 }
166 }
167 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
168 return SOFTBUS_ERR;
169 }
170
TransProxyUpdateAckInfo(ProxyChannelInfo * info)171 static int32_t TransProxyUpdateAckInfo(ProxyChannelInfo *info)
172 {
173 if (g_proxyChannelList == NULL || info == NULL) {
174 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "g_proxyChannelList or item is null");
175 return SOFTBUS_ERR;
176 }
177
178 if (SoftBusMutexLock(&g_proxyChannelList->lock) != 0) {
179 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
180 return SOFTBUS_ERR;
181 }
182
183 ProxyChannelInfo *item = NULL;
184 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
185 if ((item->myId == info->myId) && (strncmp(item->identity, info->identity, sizeof(item->identity)) == 0)) {
186 item->peerId = info->peerId;
187 item->status = PROXY_CHANNEL_STATUS_COMPLETED;
188 item->timeout = 0;
189 item->appInfo.encrypt = info->appInfo.encrypt;
190 item->appInfo.algorithm = info->appInfo.algorithm;
191 item->appInfo.crc = info->appInfo.crc;
192 (void)memcpy_s(&(item->appInfo.peerData), sizeof(item->appInfo.peerData),
193 &(info->appInfo.peerData), sizeof(info->appInfo.peerData));
194 (void)memcpy_s(info, sizeof(ProxyChannelInfo), item, sizeof(ProxyChannelInfo));
195 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
196 return SOFTBUS_OK;
197 }
198 }
199 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
200 return SOFTBUS_ERR;
201 }
202
TransProxyAddChanItem(ProxyChannelInfo * chan)203 static int32_t TransProxyAddChanItem(ProxyChannelInfo *chan)
204 {
205 if ((chan == NULL) || (g_proxyChannelList == NULL)) {
206 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "trans proxy add channel param nullptr!");
207 return SOFTBUS_ERR;
208 }
209
210 if (SoftBusMutexLock(&g_proxyChannelList->lock) != 0) {
211 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
212 return SOFTBUS_ERR;
213 }
214 ListAdd(&(g_proxyChannelList->list), &(chan->node));
215 g_proxyChannelList->cnt++;
216 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
217 return SOFTBUS_OK;
218 }
219
TransProxyGetChanByChanId(int32_t chanId,ProxyChannelInfo * chan)220 int32_t TransProxyGetChanByChanId(int32_t chanId, ProxyChannelInfo *chan)
221 {
222 ProxyChannelInfo *item = NULL;
223 ProxyChannelInfo *nextNode = NULL;
224
225 if (g_proxyChannelList == NULL || chan == NULL) {
226 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "trans proxy get channel param nullptr!");
227 return SOFTBUS_INVALID_PARAM;
228 }
229
230 if (SoftBusMutexLock(&g_proxyChannelList->lock) != 0) {
231 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
232 return SOFTBUS_ERR;
233 }
234
235 LIST_FOR_EACH_ENTRY_SAFE(item, nextNode, &g_proxyChannelList->list, ProxyChannelInfo, node) {
236 if (item->channelId == chanId) {
237 (void)memcpy_s(chan, sizeof(ProxyChannelInfo), item, sizeof(ProxyChannelInfo));
238 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
239 return SOFTBUS_OK;
240 }
241 }
242 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
243 return SOFTBUS_ERR;
244 }
245
TransProxyDelChanByReqId(int32_t reqId)246 void TransProxyDelChanByReqId(int32_t reqId)
247 {
248 ProxyChannelInfo *item = NULL;
249 ProxyChannelInfo *nextNode = NULL;
250
251 if (g_proxyChannelList == NULL) {
252 return;
253 }
254
255 if (SoftBusMutexLock(&g_proxyChannelList->lock) != 0) {
256 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
257 return;
258 }
259
260 LIST_FOR_EACH_ENTRY_SAFE(item, nextNode, &g_proxyChannelList->list, ProxyChannelInfo, node) {
261 if ((item->reqId == reqId) &&
262 (item->status == PROXY_CHANNEL_STATUS_PYH_CONNECTING)) {
263 ListDelete(&(item->node));
264 g_proxyChannelList->cnt--;
265 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "del channel(%d) by reqId.", item->channelId);
266 TransProxyPostOpenFailMsgToLoop(item, SOFTBUS_TRANS_PROXY_DISCONNECTED);
267 }
268 }
269 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
270 return;
271 }
272
TransProxyDelChanByChanId(int32_t chanlId)273 void TransProxyDelChanByChanId(int32_t chanlId)
274 {
275 ProxyChannelInfo *item = NULL;
276 ProxyChannelInfo *nextNode = NULL;
277
278 if (g_proxyChannelList == NULL) {
279 return;
280 }
281
282 if (SoftBusMutexLock(&g_proxyChannelList->lock) != 0) {
283 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
284 return;
285 }
286
287 LIST_FOR_EACH_ENTRY_SAFE(item, nextNode, &g_proxyChannelList->list, ProxyChannelInfo, node) {
288 if (item->channelId == chanlId) {
289 ListDelete(&(item->node));
290 SoftBusFree(item);
291 g_proxyChannelList->cnt--;
292 break;
293 }
294 }
295 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
296 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "del channel(%d) by chanId!", chanlId);
297 return;
298 }
299
TransProxyChanProcessByReqId(int32_t reqId,uint32_t connId)300 void TransProxyChanProcessByReqId(int32_t reqId, uint32_t connId)
301 {
302 ProxyChannelInfo *item = NULL;
303 if (g_proxyChannelList == NULL) {
304 return;
305 }
306
307 if (SoftBusMutexLock(&g_proxyChannelList->lock) != 0) {
308 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
309 return;
310 }
311
312 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
313 if (item->reqId == reqId && item->status == PROXY_CHANNEL_STATUS_PYH_CONNECTING) {
314 item->status = PROXY_CHANNEL_STATUS_HANDSHAKEING;
315 item->connId = connId;
316 TransAddConnRefByConnId(connId);
317 TransProxyPostHandshakeMsgToLoop(item->channelId);
318 }
319 }
320 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
321 return;
322 }
323
TransProxyCloseProxyOtherRes(int32_t channelId,const ProxyChannelInfo * info)324 static void TransProxyCloseProxyOtherRes(int32_t channelId, const ProxyChannelInfo *info)
325 {
326 if (TransProxyDelSliceProcessorByChannelId(channelId) != SOFTBUS_OK) {
327 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "del channel err, cId(%d).", channelId);
328 }
329
330 if (DelPendingPacket(channelId, PENDING_TYPE_PROXY) != SOFTBUS_OK) {
331 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "del pending pkt err, cId(%d).", channelId);
332 }
333
334 uint32_t connId = info->connId;
335 TransProxyPostResetPeerMsgToLoop(info);
336
337 if (info->isServer != 1) {
338 TransProxyPostDisConnectMsgToLoop(connId);
339 }
340 }
341
TransProxyReleaseChannelList(ListNode * proxyChannelList,int32_t errCode)342 static void TransProxyReleaseChannelList(ListNode *proxyChannelList, int32_t errCode)
343 {
344 if (proxyChannelList == NULL || IsListEmpty(proxyChannelList)) {
345 return;
346 }
347 ProxyChannelInfo *removeNode = NULL;
348 ProxyChannelInfo *nextNode = NULL;
349 LIST_FOR_EACH_ENTRY_SAFE(removeNode, nextNode, proxyChannelList, ProxyChannelInfo, node) {
350 ListDelete(&(removeNode->node));
351 if (removeNode->status == PROXY_CHANNEL_STATUS_HANDSHAKEING ||
352 removeNode->status == PROXY_CHANNEL_STATUS_PYH_CONNECTING) {
353 TransProxyOpenProxyChannelFail(removeNode->channelId, &(removeNode->appInfo), errCode);
354 } else {
355 OnProxyChannelClosed(removeNode->channelId, &(removeNode->appInfo));
356 }
357 TransProxyCloseProxyOtherRes(removeNode->channelId, removeNode);
358 }
359 }
360
TransProxyDelByConnId(uint32_t connId)361 void TransProxyDelByConnId(uint32_t connId)
362 {
363 ProxyChannelInfo *removeNode = NULL;
364 ProxyChannelInfo *nextNode = NULL;
365 ListNode proxyChannelList;
366
367 if (g_proxyChannelList == NULL) {
368 return;
369 }
370
371 if (SoftBusMutexLock(&g_proxyChannelList->lock) != 0) {
372 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
373 return;
374 }
375
376 ListInit(&proxyChannelList);
377 LIST_FOR_EACH_ENTRY_SAFE(removeNode, nextNode, &g_proxyChannelList->list, ProxyChannelInfo, node) {
378 if (removeNode->connId == connId) {
379 ListDelete(&(removeNode->node));
380 g_proxyChannelList->cnt--;
381 ListAdd(&proxyChannelList, &removeNode->node);
382 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "trans proxy del channel by connId(%d).", connId);
383 }
384 }
385 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
386 TransProxyReleaseChannelList(&proxyChannelList, SOFTBUS_TRANS_PROXY_DISCONNECTED);
387 }
388
TransProxyDelByChannelId(int32_t channelId,ProxyChannelInfo * channelInfo)389 static int32_t TransProxyDelByChannelId(int32_t channelId, ProxyChannelInfo *channelInfo)
390 {
391 ProxyChannelInfo *removeNode = NULL;
392 ProxyChannelInfo *nextNode = NULL;
393
394 if (g_proxyChannelList == NULL) {
395 return SOFTBUS_ERR;
396 }
397
398 if (SoftBusMutexLock(&g_proxyChannelList->lock) != 0) {
399 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
400 return SOFTBUS_ERR;
401 }
402
403 LIST_FOR_EACH_ENTRY_SAFE(removeNode, nextNode, &g_proxyChannelList->list, ProxyChannelInfo, node) {
404 if (removeNode->channelId == channelId) {
405 if (channelInfo != NULL) {
406 (void)memcpy_s(channelInfo, sizeof(ProxyChannelInfo), removeNode, sizeof(ProxyChannelInfo));
407 }
408 ListDelete(&(removeNode->node));
409 SoftBusFree(removeNode);
410 g_proxyChannelList->cnt--;
411 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
412 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "trans proxy del channel by cId(%d).", channelId);
413 return SOFTBUS_OK;
414 }
415 }
416 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
417 return SOFTBUS_ERR;
418 }
419
TransProxyResetChan(ProxyChannelInfo * chanInfo)420 static int32_t TransProxyResetChan(ProxyChannelInfo *chanInfo)
421 {
422 ProxyChannelInfo *removeNode = NULL;
423 ProxyChannelInfo *nextNode = NULL;
424
425 if (g_proxyChannelList == NULL) {
426 return SOFTBUS_ERR;
427 }
428
429 if (SoftBusMutexLock(&g_proxyChannelList->lock) != 0) {
430 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
431 return SOFTBUS_ERR;
432 }
433
434 LIST_FOR_EACH_ENTRY_SAFE(removeNode, nextNode, &g_proxyChannelList->list, ProxyChannelInfo, node) {
435 if (ResetChanIsEqual(removeNode->status, removeNode, chanInfo) == SOFTBUS_OK) {
436 (void)memcpy_s(chanInfo, sizeof(ProxyChannelInfo), removeNode, sizeof(ProxyChannelInfo));
437 ListDelete(&(removeNode->node));
438 SoftBusFree(removeNode);
439 g_proxyChannelList->cnt--;
440 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
441 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "trans proxy reset channel(%d).", chanInfo->channelId);
442 return SOFTBUS_OK;
443 }
444 }
445 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
446
447 return SOFTBUS_ERR;
448 }
449
TransProxyGetRecvMsgChanInfo(int16_t myId,int16_t peerId,ProxyChannelInfo * chanInfo)450 static int32_t TransProxyGetRecvMsgChanInfo(int16_t myId, int16_t peerId, ProxyChannelInfo *chanInfo)
451 {
452 ProxyChannelInfo *item = NULL;
453
454 if (g_proxyChannelList == NULL) {
455 return SOFTBUS_ERR;
456 }
457
458 if (SoftBusMutexLock(&g_proxyChannelList->lock) != 0) {
459 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
460 return SOFTBUS_ERR;
461 }
462
463 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
464 if ((item->myId == myId) && (item->peerId == peerId)) {
465 if (item->status == PROXY_CHANNEL_STATUS_COMPLETED) {
466 item->timeout = 0;
467 }
468 (void)memcpy_s(chanInfo, sizeof(ProxyChannelInfo), item, sizeof(ProxyChannelInfo));
469 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
470 return SOFTBUS_OK;
471 }
472 }
473 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
474 return SOFTBUS_ERR;
475 }
476
TransProxyKeepAlvieChan(ProxyChannelInfo * chanInfo)477 static int32_t TransProxyKeepAlvieChan(ProxyChannelInfo *chanInfo)
478 {
479 ProxyChannelInfo *item = NULL;
480
481 if (g_proxyChannelList == NULL) {
482 return SOFTBUS_ERR;
483 }
484
485 if (SoftBusMutexLock(&g_proxyChannelList->lock) != 0) {
486 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
487 return SOFTBUS_ERR;
488 }
489
490 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
491 if (ChanIsEqual(item, chanInfo) == SOFTBUS_OK) {
492 if (item->status == PROXY_CHANNEL_STATUS_KEEPLIVEING || item->status == PROXY_CHANNEL_STATUS_COMPLETED) {
493 item->timeout = 0;
494 item->status = PROXY_CHANNEL_STATUS_COMPLETED;
495 }
496 (void)memcpy_s(chanInfo, sizeof(ProxyChannelInfo), item, sizeof(ProxyChannelInfo));
497 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
498 return SOFTBUS_OK;
499 }
500 }
501 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
502 return SOFTBUS_ERR;
503 }
504
TransProxyGetSendMsgChanInfo(int32_t channelId,ProxyChannelInfo * chanInfo)505 int32_t TransProxyGetSendMsgChanInfo(int32_t channelId, ProxyChannelInfo *chanInfo)
506 {
507 ProxyChannelInfo *item = NULL;
508
509 if (g_proxyChannelList == NULL) {
510 return SOFTBUS_ERR;
511 }
512
513 if (SoftBusMutexLock(&g_proxyChannelList->lock) != 0) {
514 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
515 return SOFTBUS_ERR;
516 }
517
518 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
519 if (item->channelId == channelId) {
520 if (item->status == PROXY_CHANNEL_STATUS_COMPLETED) {
521 item->timeout = 0;
522 }
523 (void)memcpy_s(chanInfo, sizeof(ProxyChannelInfo), item, sizeof(ProxyChannelInfo));
524 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
525 return SOFTBUS_OK;
526 }
527 }
528 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
529 return SOFTBUS_ERR;
530 }
531
TransProxyGetNewChanSeq(int32_t channelId)532 int32_t TransProxyGetNewChanSeq(int32_t channelId)
533 {
534 ProxyChannelInfo *item = NULL;
535 int32_t seq = 0;
536
537 if (g_proxyChannelList == NULL) {
538 return seq;
539 }
540
541 if (SoftBusMutexLock(&g_proxyChannelList->lock) != 0) {
542 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
543 return seq;
544 }
545
546 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
547 if (item->channelId == channelId) {
548 seq = item->seq;
549 item->seq++;
550 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
551 return seq;
552 }
553 }
554 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
555 return seq;
556 }
557
TransProxyGetAuthId(int32_t channelId)558 int64_t TransProxyGetAuthId(int32_t channelId)
559 {
560 int64_t authId;
561 ProxyChannelInfo *item = NULL;
562
563 if (g_proxyChannelList == NULL) {
564 return AUTH_INVALID_ID;
565 }
566
567 if (SoftBusMutexLock(&g_proxyChannelList->lock) != 0) {
568 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
569 return AUTH_INVALID_ID;
570 }
571
572 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
573 if (item->channelId == channelId) {
574 authId = item->authId;
575 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
576 return authId;
577 }
578 }
579 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
580 return AUTH_INVALID_ID;
581 }
582
TransProxyGetSessionKeyByChanId(int32_t channelId,char * sessionKey,uint32_t sessionKeySize)583 int32_t TransProxyGetSessionKeyByChanId(int32_t channelId, char *sessionKey, uint32_t sessionKeySize)
584 {
585 ProxyChannelInfo *item = NULL;
586
587 if (g_proxyChannelList == NULL) {
588 return SOFTBUS_ERR;
589 }
590
591 if (SoftBusMutexLock(&g_proxyChannelList->lock) != 0) {
592 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
593 return SOFTBUS_ERR;
594 }
595
596 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
597 if (item->channelId == channelId) {
598 if (item->status == PROXY_CHANNEL_STATUS_COMPLETED) {
599 item->timeout = 0;
600 }
601 if (memcpy_s(sessionKey, sessionKeySize, item->appInfo.sessionKey,
602 sizeof(item->appInfo.sessionKey)) != EOK) {
603 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "memcpy_s fail!");
604 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
605 return SOFTBUS_ERR;
606 }
607 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
608 return SOFTBUS_OK;
609 }
610 }
611 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
612 return SOFTBUS_ERR;
613 }
614
TransProxyProcessErrMsg(ProxyChannelInfo * info,int32_t errCode)615 static inline void TransProxyProcessErrMsg(ProxyChannelInfo *info, int32_t errCode)
616 {
617 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "TransProxyProcessErrMsg err: %d", errCode);
618
619 if (TransProxyGetChanByChanId(info->myId, info) != SOFTBUS_OK) {
620 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "TransProxyGetChanByChanId fail");
621 return;
622 }
623
624 if ((info->appInfo.appType == APP_TYPE_NORMAL) || (info->appInfo.appType == APP_TYPE_AUTH)) {
625 (void)TransProxyOpenProxyChannelFail(info->channelId, &(info->appInfo), errCode);
626 }
627 }
628
TransProxyProcessHandshakeAckMsg(const ProxyMessage * msg)629 void TransProxyProcessHandshakeAckMsg(const ProxyMessage *msg)
630 {
631 ProxyChannelInfo *info = (ProxyChannelInfo *)SoftBusCalloc(sizeof(ProxyChannelInfo));
632 if (info == NULL) {
633 return;
634 }
635 info->myId = msg->msgHead.myId;
636 info->peerId = msg->msgHead.peerId;
637
638 int32_t errCode = SOFTBUS_OK;
639 if (TransProxyUnPackHandshakeErrMsg(msg->data, &errCode, msg->dateLen) == SOFTBUS_OK) {
640 TransProxyProcessErrMsg(info, errCode);
641 SoftBusFree(info);
642 return;
643 }
644
645 if (TransProxyUnpackHandshakeAckMsg(msg->data, info, msg->dateLen) != SOFTBUS_OK) {
646 SoftBusFree(info);
647 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "UnpackHandshakeAckMsg fail");
648 return;
649 }
650
651 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO,
652 "recv Handshake ack myid %d peerid %d identity %s crc %d",
653 info->myId, info->peerId, info->identity, info->appInfo.crc);
654
655 if (TransProxyUpdateAckInfo(info) != SOFTBUS_OK) {
656 SoftBusFree(info);
657 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "UpdateAckInfo fail");
658 return;
659 }
660
661 (void)OnProxyChannelOpened(info->channelId, &(info->appInfo), PROXY_CHANNEL_CLIENT);
662 SoftBusFree(info);
663 }
664
TransProxyGetLocalInfo(ProxyChannelInfo * chan)665 static int TransProxyGetLocalInfo(ProxyChannelInfo *chan)
666 {
667 if (chan->appInfo.appType != APP_TYPE_INNER) {
668 if (TransProxyGetPkgName(chan->appInfo.myData.sessionName,
669 chan->appInfo.myData.pkgName, sizeof(chan->appInfo.myData.pkgName)) != SOFTBUS_OK) {
670 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "proc handshake get pkg name fail");
671 return SOFTBUS_TRANS_PEER_SESSION_NOT_CREATED;
672 }
673
674 if (TransProxyGetUidAndPidBySessionName(chan->appInfo.myData.sessionName,
675 &chan->appInfo.myData.uid, &chan->appInfo.myData.pid) != SOFTBUS_OK) {
676 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "proc handshake get uid pid fail");
677 return SOFTBUS_TRANS_PEER_SESSION_NOT_CREATED;
678 }
679 }
680
681 if (LnnGetLocalStrInfo(STRING_KEY_UUID, chan->appInfo.myData.deviceId,
682 sizeof(chan->appInfo.myData.deviceId)) != 0) {
683 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "Handshake get local info fail");
684 return SOFTBUS_ERR;
685 }
686 return SOFTBUS_OK;
687 }
688
CheckAppTypeAndMsgHead(const ProxyMessageHead * msgHead,const AppInfo * appInfo)689 static inline int32_t CheckAppTypeAndMsgHead(const ProxyMessageHead *msgHead, const AppInfo *appInfo)
690 {
691 if (((msgHead->cipher & ENCRYPTED) == 0) && (appInfo->appType != APP_TYPE_AUTH)) {
692 return SOFTBUS_TRANS_PROXY_ERROR_APP_TYPE;
693 }
694 return SOFTBUS_OK;
695 }
696
ConstructProxyChannelInfo(ProxyChannelInfo * chan,const ProxyMessage * msg,int16_t newChanId,ConnectType type)697 static inline void ConstructProxyChannelInfo(ProxyChannelInfo *chan, const ProxyMessage *msg, int16_t newChanId,
698 ConnectType type)
699 {
700 chan->isServer = 1;
701 chan->status = PROXY_CHANNEL_STATUS_COMPLETED;
702 chan->connId = msg->connId;
703 chan->myId = newChanId;
704 chan->channelId = newChanId;
705 chan->peerId = msg->msgHead.peerId;
706 chan->authId = msg->authId;
707 chan->type = type;
708 }
709
TransProxyFillChannelInfo(const ProxyMessage * msg,ProxyChannelInfo * chan)710 static int32_t TransProxyFillChannelInfo(const ProxyMessage *msg, ProxyChannelInfo *chan)
711 {
712 int32_t ret = TransProxyUnpackHandshakeMsg(msg->data, chan, msg->dateLen);
713 if (ret != SOFTBUS_OK) {
714 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "UnpackHandshakeMsg fail.");
715 return ret;
716 }
717 if ((chan->appInfo.appType == APP_TYPE_AUTH) &&
718 (!CheckSessionNameValidOnAuthChannel(chan->appInfo.myData.sessionName))) {
719 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "proxy auth check sessionname valid.");
720 return SOFTBUS_TRANS_AUTH_NOTALLOW_OPENED;
721 }
722
723 if (CheckAppTypeAndMsgHead(&msg->msgHead, &chan->appInfo) != SOFTBUS_OK) {
724 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "only auth channel surpport plain text data");
725 return SOFTBUS_TRANS_PROXY_ERROR_APP_TYPE;
726 }
727
728 ConnectionInfo info;
729 (void)memset_s(&info, sizeof(ConnectionInfo), 0, sizeof(ConnectionInfo));
730 ret = ConnGetConnectionInfo(msg->connId, &info);
731 if (ret != SOFTBUS_OK) {
732 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "GetConnectionInfo fail connectionId %u", msg->connId);
733 return ret;
734 }
735
736 int16_t newChanId = TransProxyGetNewMyId();
737 ConstructProxyChannelInfo(chan, msg, newChanId, info.type);
738
739 ret = TransProxyGetLocalInfo(chan);
740 if (ret!= SOFTBUS_OK) {
741 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "TransProxyGetLocalInfo fail ret=%d.", ret);
742 return ret;
743 }
744
745 return SOFTBUS_OK;
746 }
747
TransProxyProcessHandshakeMsg(const ProxyMessage * msg)748 void TransProxyProcessHandshakeMsg(const ProxyMessage *msg)
749 {
750 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO,
751 "recv Handshake myid %d peerid %d", msg->msgHead.myId, msg->msgHead.peerId);
752 ProxyChannelInfo *chan = (ProxyChannelInfo *)SoftBusCalloc(sizeof(ProxyChannelInfo));
753 if (chan == NULL) {
754 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "proxy handshake calloc failed.");
755 return;
756 }
757
758 int32_t ret = TransProxyFillChannelInfo(msg, chan);
759 if ((ret == SOFTBUS_TRANS_PEER_SESSION_NOT_CREATED) &&
760 (TransProxyAckHandshake(msg->connId, chan, ret) != SOFTBUS_OK)) {
761 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "ErrHandshake fail, connId=%u.", msg->connId);
762 }
763 if (ret != SOFTBUS_OK) {
764 SoftBusFree(chan);
765 return;
766 }
767
768 TransCreateConnByConnId(msg->connId);
769 if (TransProxyAddChanItem(chan) != SOFTBUS_OK) {
770 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "AddChanItem fail");
771 SoftBusFree(chan);
772 return;
773 }
774
775 if (OnProxyChannelOpened(chan->channelId, &(chan->appInfo), PROXY_CHANNEL_SERVER) != SOFTBUS_OK) {
776 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "OnProxyChannelOpened fail");
777 (void)TransProxyCloseConnChannel(msg->connId);
778 TransProxyDelChanByChanId(chan->channelId);
779 return;
780 }
781
782 if (TransProxyAckHandshake(msg->connId, chan, SOFTBUS_OK) != SOFTBUS_OK) {
783 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "AckHandshake fail");
784 OnProxyChannelClosed(chan->channelId, &(chan->appInfo));
785 TransProxyDelChanByChanId(chan->channelId);
786 }
787 }
788
TransProxyProcessResetMsg(const ProxyMessage * msg)789 void TransProxyProcessResetMsg(const ProxyMessage *msg)
790 {
791 ProxyChannelInfo *info = (ProxyChannelInfo *)SoftBusCalloc(sizeof(ProxyChannelInfo));
792 if (info == NULL) {
793 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "ProxyProcessResetMsg calloc failed.");
794 return;
795 }
796
797 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO,
798 "recv reset myid %d peerid %d", msg->msgHead.myId, msg->msgHead.peerId);
799 if (TransProxyUnpackIdentity(msg->data, info->identity, sizeof(info->identity), msg->dateLen) != SOFTBUS_OK) {
800 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "reset identity fail");
801 SoftBusFree(info);
802 return;
803 }
804
805 info->peerId = msg->msgHead.peerId;
806 info->myId = msg->msgHead.myId;
807
808 if (TransProxyResetChan(info) != SOFTBUS_OK) {
809 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR,
810 "reset chan fail myid %d peerid %d", msg->msgHead.myId, msg->msgHead.peerId);
811 SoftBusFree(info);
812 return;
813 }
814
815 if (CheckAppTypeAndMsgHead(&msg->msgHead, &info->appInfo) != SOFTBUS_OK) {
816 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "only auth channel surpport plain text data");
817 return;
818 }
819
820 if (info->status == PROXY_CHANNEL_STATUS_HANDSHAKEING) {
821 TransProxyOpenProxyChannelFail(info->channelId, &(info->appInfo), SOFTBUS_TRANS_HANDSHAKE_ERROR);
822 } else {
823 OnProxyChannelClosed(info->channelId, &(info->appInfo));
824 }
825 if ((info->type == CONNECT_BR || info->type == CONNECT_BLE) &&
826 info->status == PROXY_CHANNEL_STATUS_COMPLETED) {
827 (void)TransProxyCloseConnChannelReset(msg->connId, false);
828 } else {
829 (void)TransProxyCloseConnChannel(msg->connId);
830 }
831 SoftBusFree(info);
832 }
833
TransProxyProcessKeepAlive(const ProxyMessage * msg)834 void TransProxyProcessKeepAlive(const ProxyMessage *msg)
835 {
836 ProxyChannelInfo *info = (ProxyChannelInfo *)SoftBusCalloc(sizeof(ProxyChannelInfo));
837 if (info == NULL) {
838 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "ProxyProcessKeepAlive calloc failed.");
839 return;
840 }
841
842 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO,
843 "recv keepalive myid %d peerid %d", msg->msgHead.myId, msg->msgHead.peerId);
844 if (TransProxyUnpackIdentity(msg->data, info->identity, sizeof(info->identity), msg->dateLen) != SOFTBUS_OK) {
845 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "keep alive unpack identity fail");
846 SoftBusFree(info);
847 return;
848 }
849 info->peerId = msg->msgHead.peerId;
850 info->myId = msg->msgHead.myId;
851
852 if (TransProxyKeepAlvieChan(info) != SOFTBUS_OK) {
853 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR,
854 "reset keep alive proc fail myid %d peerid %d", msg->msgHead.myId, msg->msgHead.peerId);
855 SoftBusFree(info);
856 return;
857 }
858
859 TransProxyAckKeepalive(info);
860 SoftBusFree(info);
861 }
862
TransProxyProcessKeepAliveAck(const ProxyMessage * msg)863 void TransProxyProcessKeepAliveAck(const ProxyMessage *msg)
864 {
865 ProxyChannelInfo *info = (ProxyChannelInfo *)SoftBusCalloc(sizeof(ProxyChannelInfo));
866 if (info == NULL) {
867 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "ProxyProcessKeepAliveAck calloc failed.");
868 return;
869 }
870
871 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO,
872 "recv keepalive ack myid %d peerid %d", msg->msgHead.myId, msg->msgHead.peerId);
873 if (TransProxyUnpackIdentity(msg->data, info->identity, sizeof(info->identity), msg->dateLen) != SOFTBUS_OK) {
874 SoftBusFree(info);
875 return;
876 }
877 info->peerId = msg->msgHead.peerId;
878 info->myId = msg->msgHead.myId;
879
880 if (TransProxyKeepAlvieChan(info) != SOFTBUS_OK) {
881 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR,
882 "reset keep alive ack proc fail myid %d peerid %d", msg->msgHead.myId, msg->msgHead.peerId);
883 SoftBusFree(info);
884 return;
885 }
886 SoftBusFree(info);
887 }
888
TransProxyProcessDataRecv(const ProxyMessage * msg)889 void TransProxyProcessDataRecv(const ProxyMessage *msg)
890 {
891 ProxyChannelInfo *info = (ProxyChannelInfo *)SoftBusCalloc(sizeof(ProxyChannelInfo));
892 if (info == NULL) {
893 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "ProxyProcessDataRecv calloc failed.");
894 return;
895 }
896
897 if (TransProxyGetRecvMsgChanInfo(msg->msgHead.myId, msg->msgHead.peerId, info) != SOFTBUS_OK) {
898 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR,
899 "data recv get info fail mid %d pid %d", msg->msgHead.myId, msg->msgHead.peerId);
900 SoftBusFree(info);
901 return;
902 }
903
904 OnProxyChannelMsgReceived(info->channelId, &(info->appInfo), msg->data, msg->dateLen);
905 SoftBusFree(info);
906 }
907
TransProxyonMessageReceived(const ProxyMessage * msg)908 void TransProxyonMessageReceived(const ProxyMessage *msg)
909 {
910 switch (msg->msgHead.type) {
911 case PROXYCHANNEL_MSG_TYPE_HANDSHAKE: {
912 TransProxyProcessHandshakeMsg(msg);
913 break;
914 }
915 case PROXYCHANNEL_MSG_TYPE_HANDSHAKE_ACK: {
916 TransProxyProcessHandshakeAckMsg(msg);
917 break;
918 }
919 case PROXYCHANNEL_MSG_TYPE_RESET: {
920 TransProxyProcessResetMsg(msg);
921 break;
922 }
923 case PROXYCHANNEL_MSG_TYPE_KEEPALIVE: {
924 TransProxyProcessKeepAlive(msg);
925 break;
926 }
927 case PROXYCHANNEL_MSG_TYPE_KEEPALIVE_ACK: {
928 TransProxyProcessKeepAliveAck(msg);
929 break;
930 }
931 case PROXYCHANNEL_MSG_TYPE_NORMAL: {
932 TransProxyProcessDataRecv(msg);
933 break;
934 }
935 default: {
936 break;
937 }
938 }
939 }
940
TransProxyCreateChanInfo(ProxyChannelInfo * chan,int32_t channelId,const AppInfo * appInfo)941 int32_t TransProxyCreateChanInfo(ProxyChannelInfo *chan, int32_t channelId, const AppInfo *appInfo)
942 {
943 chan->myId = channelId;
944 chan->channelId = channelId;
945
946 if (GenerateRandomStr(chan->identity, sizeof(chan->identity)) != SOFTBUS_OK) {
947 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "GenerateRandomStr err");
948 return SOFTBUS_ERR;
949 }
950
951 if (appInfo->appType != APP_TYPE_AUTH) {
952 chan->authId = AuthGetLatestIdByUuid(appInfo->peerData.deviceId, chan->type == CONNECT_TCP, false);
953 if (chan->authId == AUTH_INVALID_ID) {
954 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "get authId for cipher err");
955 return SOFTBUS_ERR;
956 }
957 if (SoftBusGenerateRandomArray((unsigned char *)appInfo->sessionKey, sizeof(appInfo->sessionKey))
958 != SOFTBUS_OK) {
959 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "GenerateRandomArray err");
960 return SOFTBUS_ERR;
961 }
962 }
963
964 (void)memcpy_s(&(chan->appInfo), sizeof(chan->appInfo), appInfo, sizeof(AppInfo));
965 if (TransProxyAddChanItem(chan) != SOFTBUS_OK) {
966 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "trans proxy add channel[%d] fail.", channelId);
967 return SOFTBUS_ERR;
968 }
969 return SOFTBUS_OK;
970 }
971
TransProxyOpenProxyChannelSuccess(int32_t chanId)972 void TransProxyOpenProxyChannelSuccess(int32_t chanId)
973 {
974 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "chanId[%d] send handshake msg.", chanId);
975 ProxyChannelInfo *chan = (ProxyChannelInfo *)SoftBusCalloc(sizeof(ProxyChannelInfo));
976 if (chan == NULL) {
977 return;
978 }
979
980 if (TransProxyGetChanByChanId(chanId, chan) != SOFTBUS_OK) {
981 (void)TransProxyCloseConnChannel(chan->connId);
982 SoftBusFree(chan);
983 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "disconnect device chanId %d", chanId);
984 return;
985 }
986
987 if (TransProxyHandshake(chan) == SOFTBUS_ERR) {
988 (void)TransProxyCloseConnChannel(chan->connId);
989 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "chanId[%d] shake hand err.", chanId);
990 TransProxyOpenProxyChannelFail(chan->channelId, &(chan->appInfo), SOFTBUS_TRANS_HANDSHAKE_ERROR);
991 TransProxyDelChanByChanId(chanId);
992 }
993 SoftBusFree(chan);
994 return;
995 }
996
TransProxyOpenProxyChannelFail(int32_t channelId,const AppInfo * appInfo,int32_t errCode)997 void TransProxyOpenProxyChannelFail(int32_t channelId, const AppInfo *appInfo, int32_t errCode)
998 {
999 (void)OnProxyChannelOpenFailed(channelId, appInfo, errCode);
1000 }
1001
TransProxyOpenProxyChannel(const AppInfo * appInfo,const ConnectOption * connInfo,int32_t * channelId)1002 int32_t TransProxyOpenProxyChannel(const AppInfo *appInfo, const ConnectOption *connInfo, int32_t *channelId)
1003 {
1004 if (appInfo == NULL || connInfo == NULL || channelId == NULL) {
1005 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "open normal channel: invalid para");
1006 return SOFTBUS_ERR;
1007 }
1008
1009 return TransProxyOpenConnChannel(appInfo, connInfo, channelId);
1010 }
1011
TransProxyCloseProxyChannel(int32_t channelId)1012 int32_t TransProxyCloseProxyChannel(int32_t channelId)
1013 {
1014 ProxyChannelInfo *info = (ProxyChannelInfo *)SoftBusCalloc(sizeof(ProxyChannelInfo));
1015 if (info == NULL) {
1016 return SOFTBUS_MALLOC_ERR;
1017 }
1018
1019 if (TransProxyDelByChannelId(channelId, info) != SOFTBUS_OK) {
1020 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "proxy del channel:%d failed.", channelId);
1021 SoftBusFree(info);
1022 return SOFTBUS_TRANS_PROXY_DEL_CHANNELID_INVALID;
1023 }
1024
1025 TransProxyCloseProxyOtherRes(channelId, info);
1026 return SOFTBUS_OK;
1027 }
1028
TransProxySendMsg(int32_t channelId,const char * data,uint32_t dataLen,int32_t priority)1029 int32_t TransProxySendMsg(int32_t channelId, const char *data, uint32_t dataLen, int32_t priority)
1030 {
1031 int32_t ret = SOFTBUS_ERR;
1032 ProxyChannelInfo *info = (ProxyChannelInfo *)SoftBusCalloc(sizeof(ProxyChannelInfo));
1033 if (info == NULL) {
1034 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "malloc in trans proxy send message.id[%d]", channelId);
1035 return SOFTBUS_MALLOC_ERR;
1036 }
1037
1038 if (TransProxyGetSendMsgChanInfo(channelId, info) != SOFTBUS_OK) {
1039 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "get proxy channel:%d failed.", channelId);
1040 SoftBusFree(info);
1041 return SOFTBUS_TRANS_PROXY_SEND_CHANNELID_INVALID;
1042 }
1043
1044 if (info->status != PROXY_CHANNEL_STATUS_COMPLETED && info->status != PROXY_CHANNEL_STATUS_KEEPLIVEING) {
1045 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "proxy channel status:%d is err.", info->status);
1046 SoftBusFree(info);
1047 return SOFTBUS_TRANS_PROXY_CHANNLE_STATUS_INVALID;
1048 }
1049
1050 ret = TransProxySendMessage(info, (char *)data, dataLen, priority);
1051 SoftBusFree(info);
1052 return ret;
1053 }
1054
TransProxyTimerItemProc(const ListNode * proxyProcList)1055 static void TransProxyTimerItemProc(const ListNode *proxyProcList)
1056 {
1057 ProxyChannelInfo *removeNode = NULL;
1058 ProxyChannelInfo *nextNode = NULL;
1059 uint32_t connId;
1060
1061 LIST_FOR_EACH_ENTRY_SAFE(removeNode, nextNode, proxyProcList, ProxyChannelInfo, node) {
1062 ListDelete(&(removeNode->node));
1063 if (removeNode->status == PROXY_CHANNEL_STATUS_TIMEOUT) {
1064 connId = removeNode->connId;
1065 ProxyChannelInfo *resetMsg = (ProxyChannelInfo *)SoftBusMalloc(sizeof(ProxyChannelInfo));
1066 if (resetMsg != NULL) {
1067 (void)memcpy_s(resetMsg, sizeof(ProxyChannelInfo), removeNode, sizeof(ProxyChannelInfo));
1068 TransProxyPostResetPeerMsgToLoop(resetMsg);
1069 }
1070 TransProxyPostOpenClosedMsgToLoop(removeNode);
1071 TransProxyPostDisConnectMsgToLoop(connId);
1072 }
1073 if (removeNode->status == PROXY_CHANNEL_STATUS_HANDSHAKE_TIMEOUT) {
1074 connId = removeNode->connId;
1075 TransProxyPostOpenFailMsgToLoop(removeNode, SOFTBUS_TRANS_HANDSHAKE_TIMEOUT);
1076 TransProxyPostDisConnectMsgToLoop(connId);
1077 }
1078 if (removeNode->status == PROXY_CHANNEL_STATUS_KEEPLIVEING) {
1079 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "send keepalive channel %d.", removeNode->myId);
1080 TransProxyPostKeepAliveMsgToLoop(removeNode);
1081 }
1082 }
1083 }
1084
TransProxyTimerProc(void)1085 void TransProxyTimerProc(void)
1086 {
1087 ProxyChannelInfo *removeNode = NULL;
1088 ProxyChannelInfo *nextNode = NULL;
1089 ListNode proxyProcList;
1090
1091 if (g_proxyChannelList == 0 || g_proxyChannelList->cnt <= 0) {
1092 return;
1093 }
1094 if (SoftBusMutexLock(&g_proxyChannelList->lock) != 0) {
1095 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
1096 return;
1097 }
1098
1099 ListInit(&proxyProcList);
1100 LIST_FOR_EACH_ENTRY_SAFE(removeNode, nextNode, &g_proxyChannelList->list, ProxyChannelInfo, node) {
1101 removeNode->timeout++;
1102 if (removeNode->status == PROXY_CHANNEL_STATUS_HANDSHAKEING ||
1103 removeNode->status == PROXY_CHANNEL_STATUS_PYH_CONNECTING) {
1104 if (removeNode->timeout >= PROXY_CHANNEL_CONTROL_TIMEOUT) {
1105 removeNode->status = PROXY_CHANNEL_STATUS_HANDSHAKE_TIMEOUT;
1106 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "channel (%d) handshake is timeout", removeNode->myId);
1107 ListDelete(&(removeNode->node));
1108 ListAdd(&proxyProcList, &(removeNode->node));
1109 g_proxyChannelList->cnt--;
1110 }
1111 }
1112 if (removeNode->status == PROXY_CHANNEL_STATUS_KEEPLIVEING) {
1113 if (removeNode->timeout >= PROXY_CHANNEL_CONTROL_TIMEOUT) {
1114 removeNode->status = PROXY_CHANNEL_STATUS_TIMEOUT;
1115 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "channel (%d) keepalvie is timeout", removeNode->myId);
1116 ListDelete(&(removeNode->node));
1117 ListAdd(&proxyProcList, &(removeNode->node));
1118 g_proxyChannelList->cnt--;
1119 }
1120 }
1121 if (removeNode->status == PROXY_CHANNEL_STATUS_COMPLETED) {
1122 if (removeNode->timeout >= PROXY_CHANNEL_BT_IDLE_TIMEOUT) {
1123 removeNode->status = PROXY_CHANNEL_STATUS_TIMEOUT;
1124 ListDelete(&(removeNode->node));
1125 ListAdd(&proxyProcList, &(removeNode->node));
1126 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "channel (%d) is idle", removeNode->myId);
1127 g_proxyChannelList->cnt--;
1128 }
1129 }
1130 }
1131 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
1132 TransProxyTimerItemProc(&proxyProcList);
1133 }
1134
TransProxyAuthSessionDataLenCheck(uint32_t dataLen,int32_t type)1135 int32_t TransProxyAuthSessionDataLenCheck(uint32_t dataLen, int32_t type)
1136 {
1137 switch (type) {
1138 case PROXY_FLAG_MESSAGE:
1139 case PROXY_FLAG_ASYNC_MESSAGE: {
1140 if (dataLen > g_authMaxMessageBufSize) {
1141 return SOFTBUS_ERR;
1142 }
1143 break;
1144 }
1145 case PROXY_FLAG_BYTES: {
1146 if (dataLen > g_authMaxByteBufSize) {
1147 return SOFTBUS_ERR;
1148 }
1149 break;
1150 }
1151 default: {
1152 return SOFTBUS_OK;
1153 }
1154 }
1155 return SOFTBUS_OK;
1156 }
1157
TransProxyManagerInitInner(const IServerChannelCallBack * cb)1158 static int32_t TransProxyManagerInitInner(const IServerChannelCallBack *cb)
1159 {
1160 if (SoftBusMutexInit(&g_myIdLock, NULL) != SOFTBUS_OK) {
1161 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "init lock failed");
1162 return SOFTBUS_ERR;
1163 }
1164
1165 if (TransProxySetCallBack(cb) != SOFTBUS_OK) {
1166 return SOFTBUS_ERR;
1167 }
1168
1169 g_proxyChannelList = CreateSoftBusList();
1170 if (g_proxyChannelList == NULL) {
1171 return SOFTBUS_ERR;
1172 }
1173 return SOFTBUS_OK;
1174 }
1175
TransProxyManagerInit(const IServerChannelCallBack * cb)1176 int32_t TransProxyManagerInit(const IServerChannelCallBack *cb)
1177 {
1178 if (TransProxyManagerInitInner(cb) != SOFTBUS_OK) {
1179 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "init proxy manager failed");
1180 return SOFTBUS_ERR;
1181 }
1182
1183 if (TransProxyTransInit() != SOFTBUS_OK) {
1184 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "TransProxyTransInit fail");
1185 return SOFTBUS_ERR;
1186 }
1187
1188 if (PendingInit(PENDING_TYPE_PROXY) == SOFTBUS_ERR) {
1189 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "trans proxy pending init failed.");
1190 return SOFTBUS_ERR;
1191 }
1192
1193 if (RegisterTimeoutCallback(SOFTBUS_PROXYCHANNEL_TIMER_FUN, TransProxyTimerProc) != SOFTBUS_OK) {
1194 DestroySoftBusList(g_proxyChannelList);
1195 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "trans proxy register timeout callback failed.");
1196 return SOFTBUS_ERR;
1197 }
1198
1199 if (TransSliceManagerInit() != SOFTBUS_OK) {
1200 SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "Trans slice manager init failed");
1201 }
1202
1203 if (SoftbusGetConfig(SOFTBUS_INT_AUTH_MAX_BYTES_LENGTH,
1204 (unsigned char*)&g_authMaxByteBufSize, sizeof(g_authMaxByteBufSize)) != SOFTBUS_OK) {
1205 SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "get auth proxy channel max bytes length fail");
1206 }
1207
1208 if (SoftbusGetConfig(SOFTBUS_INT_AUTH_MAX_MESSAGE_LENGTH,
1209 (unsigned char*)&g_authMaxMessageBufSize, sizeof(g_authMaxMessageBufSize)) != SOFTBUS_OK) {
1210 SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "get auth proxy channel max message length fail");
1211 }
1212
1213 SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_INFO, "proxy auth byteSize[%u], messageSize[%u]",
1214 g_authMaxByteBufSize, g_authMaxMessageBufSize);
1215 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "proxy channel init ok");
1216 return SOFTBUS_OK;
1217 }
1218
TransProxyGetNameByChanId(int32_t chanId,char * pkgName,char * sessionName,uint16_t pkgLen,uint16_t sessionLen)1219 int32_t TransProxyGetNameByChanId(int32_t chanId, char *pkgName, char *sessionName,
1220 uint16_t pkgLen, uint16_t sessionLen)
1221 {
1222 if (pkgName == NULL || sessionName == NULL) {
1223 return SOFTBUS_INVALID_PARAM;
1224 }
1225 ProxyChannelInfo *chan = (ProxyChannelInfo *)SoftBusCalloc(sizeof(ProxyChannelInfo));
1226 if (chan == NULL) {
1227 return SOFTBUS_MALLOC_ERR;
1228 }
1229 if (TransProxyGetChanByChanId(chanId, chan) != SOFTBUS_OK) {
1230 SoftBusFree(chan);
1231 return SOFTBUS_ERR;
1232 }
1233 if (TransProxyGetPkgName(chan->appInfo.myData.sessionName, pkgName, pkgLen) != SOFTBUS_OK) {
1234 SoftBusFree(chan);
1235 return SOFTBUS_ERR;
1236 }
1237 if (strcpy_s(sessionName, sessionLen, chan->appInfo.myData.sessionName) != EOK) {
1238 SoftBusFree(chan);
1239 return SOFTBUS_MEM_ERR;
1240 }
1241 SoftBusFree(chan);
1242 return SOFTBUS_OK;
1243 }
1244
1245
TransProxyManagerDeinitInner(void)1246 static void TransProxyManagerDeinitInner(void)
1247 {
1248 ProxyChannelInfo *item = NULL;
1249 ProxyChannelInfo *nextNode = NULL;
1250 if (SoftBusMutexLock(&g_proxyChannelList->lock) != 0) {
1251 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
1252 return;
1253 }
1254 LIST_FOR_EACH_ENTRY_SAFE(item, nextNode, &g_proxyChannelList->list, ProxyChannelInfo, node) {
1255 ListDelete(&(item->node));
1256 SoftBusFree(item);
1257 }
1258 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
1259
1260 DestroySoftBusList(g_proxyChannelList);
1261 SoftBusMutexDestroy(&g_myIdLock);
1262 }
1263
TransProxyManagerDeinit(void)1264 void TransProxyManagerDeinit(void)
1265 {
1266 TransProxyManagerDeinitInner();
1267
1268 TransSliceManagerDeInit();
1269 (void)RegisterTimeoutCallback(SOFTBUS_PROXYCHANNEL_TIMER_FUN, NULL);
1270 PendingDeinit(PENDING_TYPE_PROXY);
1271 }
1272
TransProxyDestroyChannelList(const ListNode * destroyList)1273 static void TransProxyDestroyChannelList(const ListNode *destroyList)
1274 {
1275 if ((destroyList == NULL) || IsListEmpty(destroyList)) {
1276 return;
1277 }
1278
1279 ProxyChannelInfo *destroyNode = NULL;
1280 ProxyChannelInfo *nextDestroyNode = NULL;
1281 LIST_FOR_EACH_ENTRY_SAFE(destroyNode, nextDestroyNode, destroyList, ProxyChannelInfo, node) {
1282 ListDelete(&(destroyNode->node));
1283 TransProxyResetPeer(destroyNode);
1284 (void)TransProxyCloseConnChannel(destroyNode->connId);
1285 SoftBusFree(destroyNode);
1286 }
1287 return;
1288 }
1289
TransProxyDeathCallback(const char * pkgName)1290 void TransProxyDeathCallback(const char *pkgName)
1291 {
1292 if ((pkgName == NULL) || (g_proxyChannelList == NULL)) {
1293 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "pkgName or proxy channel list is null.");
1294 return;
1295 }
1296
1297 ListNode destroyList;
1298 ListInit(&destroyList);
1299 ProxyChannelInfo *item = NULL;
1300 ProxyChannelInfo *nextNode = NULL;
1301 if (SoftBusMutexLock(&g_proxyChannelList->lock) != 0) {
1302 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
1303 return;
1304 }
1305 LIST_FOR_EACH_ENTRY_SAFE(item, nextNode, &g_proxyChannelList->list, ProxyChannelInfo, node) {
1306 if (strcmp(item->appInfo.myData.pkgName, pkgName) == 0) {
1307 ListDelete(&(item->node));
1308 g_proxyChannelList->cnt--;
1309 ListAdd(&destroyList, &(item->node));
1310 }
1311 }
1312 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
1313 TransProxyDestroyChannelList(&destroyList);
1314 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "TransProxyDeathCallback end.");
1315 }
1316
TransProxyGetAppInfoByChanId(int32_t chanId,AppInfo * appInfo)1317 int32_t TransProxyGetAppInfoByChanId(int32_t chanId, AppInfo* appInfo)
1318 {
1319 ProxyChannelInfo *item = NULL;
1320 ProxyChannelInfo *nextNode = NULL;
1321
1322 if (g_proxyChannelList == NULL) {
1323 return SOFTBUS_ERR;
1324 }
1325
1326 if (SoftBusMutexLock(&g_proxyChannelList->lock) != 0) {
1327 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
1328 return SOFTBUS_ERR;
1329 }
1330
1331 LIST_FOR_EACH_ENTRY_SAFE(item, nextNode, &g_proxyChannelList->list, ProxyChannelInfo, node) {
1332 if (item->channelId == chanId) {
1333 (void)memcpy_s(appInfo, sizeof(AppInfo), &item->appInfo, sizeof(AppInfo));
1334 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
1335 return SOFTBUS_OK;
1336 }
1337 }
1338 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
1339 return SOFTBUS_ERR;
1340 }
1341
TransProxyGetConnIdByChanId(int32_t channelId,int32_t * connId)1342 int32_t TransProxyGetConnIdByChanId(int32_t channelId, int32_t *connId)
1343 {
1344 if (g_proxyChannelList == NULL) {
1345 return SOFTBUS_ERR;
1346 }
1347 ProxyChannelInfo *item = NULL;
1348 if (SoftBusMutexLock(&g_proxyChannelList->lock) != 0) {
1349 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
1350 return SOFTBUS_ERR;
1351 }
1352 LIST_FOR_EACH_ENTRY(item, &g_proxyChannelList->list, ProxyChannelInfo, node) {
1353 if (item->channelId == channelId) {
1354 if (item->status == PROXY_CHANNEL_STATUS_COMPLETED || item->status ==
1355 PROXY_CHANNEL_STATUS_KEEPLIVEING) {
1356 *connId = item->connId;
1357 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
1358 return SOFTBUS_OK;
1359 } else {
1360 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "g_proxyChannel status error");
1361 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
1362 return SOFTBUS_ERR;
1363 }
1364 }
1365 }
1366 (void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
1367 return SOFTBUS_ERR;
1368 }
1369
TransProxyGetConnOptionByChanId(int32_t channelId,ConnectOption * connOpt)1370 int32_t TransProxyGetConnOptionByChanId(int32_t channelId, ConnectOption *connOpt)
1371 {
1372 if (connOpt == NULL) {
1373 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "[%s] invalid param.", __func__);
1374 return SOFTBUS_ERR;
1375 }
1376
1377 int32_t connId = -1;
1378 int32_t ret = TransProxyGetConnIdByChanId(channelId, &connId);
1379 if (ret != SOFTBUS_OK) {
1380 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "channel=%d get proxy connid fail, %d.", channelId, ret);
1381 return ret;
1382 }
1383
1384 ret = TransProxyGetConnInfoByConnId(connId, connOpt);
1385 if (ret != SOFTBUS_OK) {
1386 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "channel=%d get conn optinfo fail, %d.", channelId, ret);
1387 return ret;
1388 }
1389 return SOFTBUS_OK;
1390 }
1391